xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

fix: adjust SValueV0 data order

This commit is contained in:
Shungang Li 2024-05-09 21:52:43 +08:00
parent 7ae4415890
commit 457b98fee8
2 changed files with 96 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
source/dnode/vnode/src/inc/tsdb.h
View File

@ -900,32 +900,8 @@ typedef struct {
SRowKey rowKey; SRowKey rowKey;
int8_t dirty; int8_t dirty;
SColVal colVal; SColVal colVal;
int8_t version;
} SLastCol; } SLastCol;
typedef struct {
union {
int64_t val;
struct {
uint8_t *pData;
uint32_t nData;
};
};
} SValueV0;
typedef struct {
int16_t cid;
int8_t type;
int8_t flag;
SValueV0 value;
} SColValV0;
typedef struct {
TSKEY ts;
int8_t dirty;
SColValV0 colVal;
} SLastColV0;
int32_t tsdbOpenCache(STsdb *pTsdb); int32_t tsdbOpenCache(STsdb *pTsdb);
void tsdbCloseCache(STsdb *pTsdb); void tsdbCloseCache(STsdb *pTsdb);
int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSDBROW *row); int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSDBROW *row);

222
source/dnode/vnode/src/tsdb/tsdbCache.c
View File

@ -330,32 +330,41 @@ static void rocksMayWrite(STsdb *pTsdb, bool force, bool read, bool lock) {
} }
} }
static SLastColV0 *tsdbCacheDeserializeV0(char const *value, size_t *inOutOffset) { typedef struct {
SLastColV0 *pLastColV0 = NULL; TSKEY ts;
size_t localOffset = 0; int8_t dirty;
struct {
int16_t cid;
int8_t type;
int8_t flag;
union {
int64_t val;
struct {
uint32_t nData;
uint8_t *pData;
};
} value;
} colVal;
} SLastColV0;
if (!value) { static int32_t tsdbCacheDeserializeV0(char const *value, SLastCol *pLastCol) {
goto _OUT; SLastColV0 *pLastColV0 = (SLastColV0 *)value;
pLastCol->rowKey.ts = pLastColV0->ts;
pLastCol->rowKey.numOfPKs = 0;
pLastCol->dirty = pLastColV0->dirty;
pLastCol->colVal.cid = pLastColV0->colVal.cid;
pLastCol->colVal.flag = pLastColV0->colVal.flag;
pLastCol->colVal.value.type = pLastColV0->colVal.type;
if (IS_VAR_DATA_TYPE(pLastCol->colVal.value.type)) {
pLastCol->colVal.value.nData = pLastColV0->colVal.value.nData;
pLastCol->colVal.value.pData = (uint8_t *)(&pLastColV0[1]);
return sizeof(SLastColV0) + pLastColV0->colVal.value.nData;
} else {
pLastCol->colVal.value.val = pLastColV0->colVal.value.val;
return sizeof(SLastColV0);
} }
pLastColV0 = taosMemoryMalloc(sizeof(SLastColV0));
*pLastColV0 = *(SLastColV0 *)(value);
localOffset = sizeof(*pLastColV0);
SColValV0 *pColValV0 = &pLastColV0->colVal;
if (IS_VAR_DATA_TYPE(pColValV0->type)) {
if (pColValV0->value.nData > 0) {
pColValV0->value.pData = (char *)value + localOffset;
localOffset += pColValV0->value.nData;
} else {
pColValV0->value.pData = NULL;
}
}
_OUT:
*inOutOffset += localOffset;
return pLastColV0;
} }
static SLastCol *tsdbCacheDeserialize(char const *value, size_t size) { static SLastCol *tsdbCacheDeserialize(char const *value, size_t size) {
@ -363,61 +372,41 @@ static SLastCol *tsdbCacheDeserialize(char const *value, size_t size) {
return NULL; return NULL;
} }
size_t offset = 0; SLastCol* pLastCol = taosMemoryCalloc(1, sizeof(SLastCol));
if (NULL == pLastCol) {
SLastColV0 *pLastColV0 = tsdbCacheDeserializeV0(value, &offset);
if (NULL == pLastColV0) {
return NULL; return NULL;
} }
SLastCol *pLastCol = taosMemoryMalloc(sizeof(SLastCol)); int32_t offset = tsdbCacheDeserializeV0(value, pLastCol);
pLastCol->rowKey.ts = pLastColV0->ts;
pLastCol->dirty = pLastColV0->dirty;
pLastCol->colVal.cid = pLastColV0->colVal.cid;
pLastCol->colVal.flag = pLastColV0->colVal.flag;
pLastCol->colVal.value.type = pLastColV0->colVal.type;
if (IS_VAR_DATA_TYPE(pLastCol->colVal.value.type)) {
pLastCol->colVal.value.nData = pLastColV0->colVal.value.nData;
pLastCol->colVal.value.pData = pLastColV0->colVal.value.pData;
} else {
pLastCol->colVal.value.val = pLastColV0->colVal.value.val;
}
taosMemoryFreeClear(pLastColV0);
if (offset == size) { if (offset == size) {
// version 0 // version 0
pLastCol->version = LAST_COL_VERSION;
pLastCol->rowKey.numOfPKs = 0;
memset(pLastCol->rowKey.pks, 0, sizeof(pLastCol->rowKey.pks));
return pLastCol; return pLastCol;
} else if (offset > size) {
terrno = TSDB_CODE_INVALID_DATA_FMT;
taosMemoryFreeClear(pLastCol);
return NULL;
} }
pLastCol->version = *(int8_t *)(value + offset); // version
int8_t version = *(int8_t *)(value + offset);
offset += sizeof(int8_t); offset += sizeof(int8_t);
// numOfPKs
pLastCol->rowKey.numOfPKs = *(uint8_t *)(value + offset); pLastCol->rowKey.numOfPKs = *(uint8_t *)(value + offset);
offset += sizeof(uint8_t); offset += sizeof(uint8_t);
for (int8_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) { // pks
SValue *pValue = &pLastCol->rowKey.pks[i]; for (int32_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) {
*pValue = *(SValue *)(value + offset); pLastCol->rowKey.pks[i] = *(SValue *)(value + offset);
offset += sizeof(SValue); offset += sizeof(SValue);
if (IS_VAR_DATA_TYPE(pValue->type)) { if (IS_VAR_DATA_TYPE(pLastCol->rowKey.pks[i].type)) {
if (pValue->nData > 0) { pLastCol->rowKey.pks[i].pData = (uint8_t *)value + offset;
pValue->pData = (char *)value + offset; offset += pLastCol->rowKey.pks[i].nData;
offset += pValue->nData;
} else {
pValue->pData = NULL;
}
} else {
pValue->val = *(int64_t *)(value + offset);
offset += sizeof(int64_t);
} }
} }
if (size < offset) { if (offset > size) {
terrno = TSDB_CODE_INVALID_DATA_FMT; terrno = TSDB_CODE_INVALID_DATA_FMT;
taosMemoryFreeClear(pLastCol); taosMemoryFreeClear(pLastCol);
return NULL; return NULL;
@ -426,25 +415,6 @@ static SLastCol *tsdbCacheDeserialize(char const *value, size_t size) {
return pLastCol; return pLastCol;
} }
static uint32_t tsdbCacheCopyVarData(SValue *from, SValue *to) {
ASSERT(from->nData >= 0);
if (from->nData > 0) {
memcpy(to->pData, from->pData, from->nData);
}
to->type = from->type;
to->nData = from->nData;
return from->nData;
}
static uint32_t tsdbCacheCopyVarDataToV0(SValue *from, SValueV0 *to) {
ASSERT(from->nData >= 0);
if (from->nData > 0) {
memcpy(to->pData, from->pData, from->nData);
}
to->nData = from->nData;
return from->nData;
}
/* /*
typedef struct { typedef struct {
SLastColV0 lastColV0; SLastColV0 lastColV0;
@ -458,61 +428,61 @@ typedef struct {
... ...
} SLastColDisk; } SLastColDisk;
*/ */
static void tsdbCacheSerialize(SLastCol *pLastCol, char **value, size_t *size) { static int32_t tsdbCacheSerializeV0(char const *value, SLastCol *pLastCol) {
SColVal *pColVal = &pLastCol->colVal; SLastColV0 *pLastColV0 = (SLastColV0 *)value;
size_t length = sizeof(SLastColV0);
if (IS_VAR_DATA_TYPE(pColVal->value.type)) {
length += pColVal->value.nData;
}
uint8_t numOfPKs = pLastCol->rowKey.numOfPKs; pLastColV0->ts = pLastCol->rowKey.ts;
pLastColV0->dirty = pLastCol->dirty;
length += sizeof(int8_t) + sizeof(uint8_t) + (sizeof(SValue) * numOfPKs); // version + numOfPKs + pks pLastColV0->colVal.cid = pLastCol->colVal.cid;
pLastColV0->colVal.flag = pLastCol->colVal.flag;
for (int8_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) { pLastColV0->colVal.type = pLastCol->colVal.value.type;
if (IS_VAR_DATA_TYPE(pLastCol->rowKey.pks[i].type)) { if (IS_VAR_DATA_TYPE(pLastCol->colVal.value.type)) {
length += pLastCol->rowKey.pks[i].nData; pLastColV0->colVal.value.nData = pLastCol->colVal.value.nData;
} memcpy(&pLastColV0[1], pLastCol->colVal.value.pData, pLastCol->colVal.value.nData);
} return sizeof(SLastColV0) + pLastCol->colVal.value.nData;
*value = taosMemoryMalloc(length);
// copy last col
SLastColV0 *pToLastColV0 = (SLastColV0 *)(*value);
pToLastColV0->ts = pLastCol->rowKey.ts;
pToLastColV0->dirty = pLastCol->dirty;
pToLastColV0->colVal.cid = pColVal->cid;
pToLastColV0->colVal.flag = pColVal->flag;
pToLastColV0->colVal.type = pColVal->value.type;
char *currentPos = *value + sizeof(*pToLastColV0);
// copy var data value
if (IS_VAR_DATA_TYPE(pColVal->value.type)) {
SValue *pFromValue = &pColVal->value;
SValueV0 *pToValue = &pToLastColV0->colVal.value;
pToValue->pData = (pFromValue->nData == 0) ? NULL : currentPos;
currentPos += tsdbCacheCopyVarDataToV0(pFromValue, pToValue);
} else { } else {
pToLastColV0->colVal.value.val = pColVal->value.val; pLastColV0->colVal.value.val = pLastCol->colVal.value.val;
return sizeof(SLastColV0);
} }
*(int8_t *)currentPos = LAST_COL_VERSION; return 0;
currentPos += sizeof(int8_t); }
static void tsdbCacheSerialize(SLastCol *pLastCol, char **value, size_t *size) {
*size = sizeof(SLastColV0);
if (IS_VAR_DATA_TYPE(pLastCol->colVal.value.type)) {
*size += pLastCol->colVal.value.nData;
}
*size += sizeof(uint8_t) + sizeof(uint8_t); // version + numOfPKs
// copy var data pks
for (int8_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) { for (int8_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) {
SValue *pFromValue = &pLastCol->rowKey.pks[i]; *size += sizeof(SValue);
SValue *pToValue = (SValue *)currentPos; if (IS_VAR_DATA_TYPE(pLastCol->rowKey.pks[i].type)) {
*pToValue = *pFromValue; *size += pLastCol->rowKey.pks[i].nData;
currentPos += sizeof(SValue);
if (IS_VAR_DATA_TYPE(pFromValue->type)) {
pToValue->pData = (pFromValue->nData == 0) ? NULL : currentPos;
currentPos += tsdbCacheCopyVarData(pFromValue, pToValue);
} }
} }
*size = length; *value = taosMemoryMalloc(*size);
int32_t offset = tsdbCacheSerializeV0(*value, pLastCol);
// version
((uint8_t *)(*value + offset))[0] = LAST_COL_VERSION;
offset++;
// numOfPKs
((uint8_t *)(*value + offset))[0] = pLastCol->rowKey.numOfPKs;
offset++;
// pks
for (int8_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) {
((SValue *)(*value + offset))[0] = pLastCol->rowKey.pks[i];
offset += sizeof(SValue);
if (IS_VAR_DATA_TYPE(pLastCol->rowKey.pks[i].type)) {
memcpy(*value + offset, pLastCol->rowKey.pks[i].pData, pLastCol->rowKey.pks[i].nData);
offset += pLastCol->rowKey.pks[i].nData;
}
}
} }
static void tsdbCachePutBatch(SLastCol *pLastCol, const void *key, size_t klen, SCacheFlushState *state) { static void tsdbCachePutBatch(SLastCol *pLastCol, const void *key, size_t klen, SCacheFlushState *state) {