From 7b942097c1df5315c69474d6e5e52e93dd67f03d Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Wed, 9 Feb 2022 18:28:11 +0800 Subject: [PATCH] create stb --- include/common/tmsg.h | 14 ++- include/libs/parser/parsenodes.h | 6 -- source/common/src/tmsg.c | 63 +++++++++++ source/dnode/mnode/impl/src/mndStb.c | 116 +++++++++++--------- source/dnode/mnode/impl/test/stb/stb.cpp | 131 ++++++++++++----------- source/libs/parser/src/astToMsg.c | 103 ++++-------------- source/util/src/tarray.c | 9 +- 7 files changed, 242 insertions(+), 200 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 808c7c8fa6..04742e547d 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -249,14 +249,24 @@ typedef struct SSchema { char name[TSDB_COL_NAME_LEN]; } SSchema; +typedef struct SField { + char name[TSDB_COL_NAME_LEN]; + uint8_t type; + int32_t bytes; +} SField; + typedef struct { char name[TSDB_TABLE_FNAME_LEN]; int8_t igExists; - int32_t numOfTags; int32_t numOfColumns; - SSchema pSchemas[]; + int32_t numOfTags; + SArray* pColumns; + SArray* pTags; } SMCreateStbReq; +int32_t tSerializeSMCreateStbReq(void** buf, SMCreateStbReq* pReq); +void* tDeserializeSMCreateStbReq(void* buf, SMCreateStbReq* pReq); + typedef struct { char name[TSDB_TABLE_FNAME_LEN]; int8_t igNotExists; diff --git a/include/libs/parser/parsenodes.h b/include/libs/parser/parsenodes.h index d245d04166..292b4ab2c9 100644 --- a/include/libs/parser/parsenodes.h +++ b/include/libs/parser/parsenodes.h @@ -37,12 +37,6 @@ typedef struct SQueryNode { #define queryNodeType(nodeptr) (((const SQueryNode*)(nodeptr))->type) -typedef struct SField { - char name[TSDB_COL_NAME_LEN]; - uint8_t type; - int32_t bytes; -} SField; - typedef struct SFieldInfo { int16_t numOfOutput; // number of column in result SField *final; diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 6f094b20f8..0711981436 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -336,3 +336,66 @@ void *tDeserializeSVDropTbReq(void *buf, SVDropTbReq *pReq) { buf = taosDecodeFixedU8(buf, &pReq->type); return buf; } + +int32_t tSerializeSMCreateStbReq(void **buf, SMCreateStbReq *pReq) { + int32_t tlen = 0; + + tlen += taosEncodeString(buf, pReq->name); + tlen += taosEncodeFixedI8(buf, pReq->igExists); + tlen += taosEncodeFixedI32(buf, pReq->numOfColumns); + tlen += taosEncodeFixedI32(buf, pReq->numOfTags); + + for (int32_t i = 0; i < pReq->numOfColumns; ++i) { + SField *pField = taosArrayGet(pReq->pColumns, i); + tlen += taosEncodeFixedI8(buf, pField->type); + tlen += taosEncodeFixedI32(buf, pField->bytes); + tlen += taosEncodeString(buf, pField->name); + } + + for (int32_t i = 0; i < pReq->numOfTags; ++i) { + SField *pField = taosArrayGet(pReq->pTags, i); + tlen += taosEncodeFixedI8(buf, pField->type); + tlen += taosEncodeFixedI32(buf, pField->bytes); + tlen += taosEncodeString(buf, pField->name); + } + + return tlen; +} + +void *tDeserializeSMCreateStbReq(void *buf, SMCreateStbReq *pReq) { + buf = taosDecodeStringTo(buf, pReq->name); + buf = taosDecodeFixedI8(buf, &pReq->igExists); + buf = taosDecodeFixedI32(buf, &pReq->numOfColumns); + buf = taosDecodeFixedI32(buf, &pReq->numOfTags); + + pReq->pColumns = taosArrayInit(pReq->numOfColumns, sizeof(SField)); + pReq->pTags = taosArrayInit(pReq->numOfTags, sizeof(SField)); + if (pReq->pColumns == NULL || pReq->pTags == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } + + for (int32_t i = 0; i < pReq->numOfColumns; ++i) { + SField field = {0}; + buf = taosDecodeFixedI8(buf, &field.type); + buf = taosDecodeFixedI32(buf, &field.bytes); + buf = taosDecodeStringTo(buf, field.name); + if (taosArrayPush(pReq->pColumns, &field) == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } + } + + for (int32_t i = 0; i < pReq->numOfTags; ++i) { + SField field = {0}; + buf = taosDecodeFixedI8(buf, &field.type); + buf = taosDecodeFixedI32(buf, &field.bytes); + buf = taosDecodeStringTo(buf, field.name); + if (taosArrayPush(pReq->pTags, &field) == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } + } + + return buf; +} diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index b5222ab3fc..845f911787 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -323,14 +323,6 @@ static void *mndBuildVDropStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, } static int32_t mndCheckCreateStbReq(SMCreateStbReq *pCreate) { - pCreate->numOfColumns = htonl(pCreate->numOfColumns); - pCreate->numOfTags = htonl(pCreate->numOfTags); - int32_t totalCols = pCreate->numOfColumns + pCreate->numOfTags; - for (int32_t i = 0; i < totalCols; ++i) { - SSchema *pSchema = &pCreate->pSchemas[i]; - pSchema->bytes = htonl(pSchema->bytes); - } - if (pCreate->igExists < 0 || pCreate->igExists > 1) { terrno = TSDB_CODE_MND_INVALID_STB_OPTION; return -1; @@ -346,23 +338,39 @@ static int32_t mndCheckCreateStbReq(SMCreateStbReq *pCreate) { return -1; } - SSchema *pSchema = &pCreate->pSchemas[0]; - if (pSchema->type != TSDB_DATA_TYPE_TIMESTAMP) { + SField *pField = taosArrayGet(pCreate->pColumns, 0) ; + if (pField->type != TSDB_DATA_TYPE_TIMESTAMP) { terrno = TSDB_CODE_MND_INVALID_STB_OPTION; return -1; } - for (int32_t i = 0; i < totalCols; ++i) { - SSchema *pSchema = &pCreate->pSchemas[i]; - if (pSchema->type < 0) { + for (int32_t i = 0; i < pCreate->numOfColumns; ++i) { + SField *pField = taosArrayGet(pCreate->pColumns, i); + if (pField->type < 0) { terrno = TSDB_CODE_MND_INVALID_STB_OPTION; return -1; } - if (pSchema->bytes <= 0) { + if (pField->bytes <= 0) { terrno = TSDB_CODE_MND_INVALID_STB_OPTION; return -1; } - if (pSchema->name[0] == 0) { + if (pField->name[0] == 0) { + terrno = TSDB_CODE_MND_INVALID_STB_OPTION; + return -1; + } + } + + for (int32_t i = 0; i < pCreate->numOfTags; ++i) { + SField *pField = taosArrayGet(pCreate->pTags, i); + if (pField->type < 0) { + terrno = TSDB_CODE_MND_INVALID_STB_OPTION; + return -1; + } + if (pField->bytes <= 0) { + terrno = TSDB_CODE_MND_INVALID_STB_OPTION; + return -1; + } + if (pField->name[0] == 0) { terrno = TSDB_CODE_MND_INVALID_STB_OPTION; return -1; } @@ -490,16 +498,23 @@ static int32_t mndCreateStb(SMnode *pMnode, SMnodeMsg *pReq, SMCreateStbReq *pCr return -1; } - memcpy(stbObj.pColumns, pCreate->pSchemas, stbObj.numOfColumns * sizeof(SSchema)); - memcpy(stbObj.pTags, pCreate->pSchemas + stbObj.numOfColumns, stbObj.numOfTags * sizeof(SSchema)); - for (int32_t i = 0; i < stbObj.numOfColumns; ++i) { - stbObj.pColumns[i].colId = stbObj.nextColId; + SField *pField = taosArrayGet(pCreate->pColumns, i); + SSchema *pSchema = &stbObj.pColumns[i]; + pSchema->type = pField->type; + pSchema->bytes = pField->bytes; + memcpy(pSchema->name, pField->name, TSDB_COL_NAME_LEN); + pSchema->colId = stbObj.nextColId; stbObj.nextColId++; } for (int32_t i = 0; i < stbObj.numOfTags; ++i) { - stbObj.pTags[i].colId = stbObj.nextColId; + SField *pField = taosArrayGet(pCreate->pTags, i); + SSchema *pSchema = &stbObj.pTags[i]; + pSchema->type = pField->type; + pSchema->bytes = pField->bytes; + memcpy(pSchema->name, pField->name, TSDB_COL_NAME_LEN); + pSchema->colId = stbObj.nextColId; stbObj.nextColId++; } @@ -524,57 +539,60 @@ CREATE_STB_OVER: } static int32_t mndProcessMCreateStbReq(SMnodeMsg *pReq) { - SMnode *pMnode = pReq->pMnode; - SMCreateStbReq *pCreate = pReq->rpcMsg.pCont; + SMnode *pMnode = pReq->pMnode; + int32_t code = -1; + SStbObj *pTopicStb = NULL; + SStbObj *pStb = NULL; + SDbObj *pDb = NULL; + SMCreateStbReq createReq = {0}; - mDebug("stb:%s, start to create", pCreate->name); + if (tDeserializeSMCreateStbReq(pReq->rpcMsg.pCont, &createReq) == NULL) goto CREATE_STB_OVER; - if (mndCheckCreateStbReq(pCreate) != 0) { - mError("stb:%s, failed to create since %s", pCreate->name, terrstr()); - return -1; - } + mDebug("stb:%s, start to create", createReq.name); + if (mndCheckCreateStbReq(&createReq) != 0) goto CREATE_STB_OVER; - SStbObj *pStb = mndAcquireStb(pMnode, pCreate->name); + pStb = mndAcquireStb(pMnode, createReq.name); if (pStb != NULL) { - mndReleaseStb(pMnode, pStb); - if (pCreate->igExists) { - mDebug("stb:%s, already exist, ignore exist is set", pCreate->name); - return 0; + if (createReq.igExists) { + mDebug("stb:%s, already exist, ignore exist is set", createReq.name); + code = 0; + goto CREATE_STB_OVER; } else { terrno = TSDB_CODE_MND_STB_ALREADY_EXIST; - mError("stb:%s, failed to create since %s", pCreate->name, terrstr()); - return -1; + goto CREATE_STB_OVER; } } else if (terrno != TSDB_CODE_MND_STB_NOT_EXIST) { - mError("stb:%s, failed to create since %s", pCreate->name, terrstr()); - return -1; + goto CREATE_STB_OVER; } - // topic should have different name with stb - SStbObj *pTopicStb = mndAcquireStb(pMnode, pCreate->name); + pTopicStb = mndAcquireStb(pMnode, createReq.name); if (pTopicStb != NULL) { - mndReleaseStb(pMnode, pTopicStb); terrno = TSDB_CODE_MND_NAME_CONFLICT_WITH_TOPIC; - mError("stb:%s, failed to create since %s", pCreate->name, terrstr()); - return -1; + goto CREATE_STB_OVER; } - SDbObj *pDb = mndAcquireDbByStb(pMnode, pCreate->name); + pDb = mndAcquireDbByStb(pMnode, createReq.name); if (pDb == NULL) { terrno = TSDB_CODE_MND_DB_NOT_SELECTED; - mError("stb:%s, failed to create since %s", pCreate->name, terrstr()); - return -1; + goto CREATE_STB_OVER; } - int32_t code = mndCreateStb(pMnode, pReq, pCreate, pDb); - mndReleaseDb(pMnode, pDb); + code = mndCreateStb(pMnode, pReq, &createReq, pDb); +CREATE_STB_OVER: if (code != 0) { - mError("stb:%s, failed to create since %s", pCreate->name, terrstr()); - return -1; + mError("stb:%s, failed to create since %s", createReq.name, terrstr()); + } else { + code = TSDB_CODE_MND_ACTION_IN_PROGRESS; } - return TSDB_CODE_MND_ACTION_IN_PROGRESS; + mndReleaseStb(pMnode, pStb); + mndReleaseStb(pMnode, pTopicStb); + mndReleaseDb(pMnode, pDb); + taosArrayClear(createReq.pColumns); + taosArrayClear(createReq.pTags); + + return code; } static int32_t mndProcessVCreateStbRsp(SMnodeMsg *pRsp) { diff --git a/source/dnode/mnode/impl/test/stb/stb.cpp b/source/dnode/mnode/impl/test/stb/stb.cpp index 402795eb03..b870bc8fe8 100644 --- a/source/dnode/mnode/impl/test/stb/stb.cpp +++ b/source/dnode/mnode/impl/test/stb/stb.cpp @@ -22,19 +22,19 @@ class MndTestStb : public ::testing::Test { void SetUp() override {} void TearDown() override {} - SCreateDbReq* BuildCreateDbReq(const char* dbname, int32_t* pContLen); - SDropDbReq* BuildDropDbReq(const char* dbname, int32_t* pContLen); - SMCreateStbReq* BuildCreateStbReq(const char* stbname, int32_t* pContLen); - SMAltertbReq* BuildAlterStbAddTagReq(const char* stbname, const char* tagname, int32_t* pContLen); - SMAltertbReq* BuildAlterStbDropTagReq(const char* stbname, const char* tagname, int32_t* pContLen); - SMAltertbReq* BuildAlterStbUpdateTagNameReq(const char* stbname, const char* tagname, const char* newtagname, - int32_t* pContLen); - SMAltertbReq* BuildAlterStbUpdateTagBytesReq(const char* stbname, const char* tagname, int32_t bytes, - int32_t* pContLen); - SMAltertbReq* BuildAlterStbAddColumnReq(const char* stbname, const char* colname, int32_t* pContLen); - SMAltertbReq* BuildAlterStbDropColumnReq(const char* stbname, const char* colname, int32_t* pContLen); - SMAltertbReq* BuildAlterStbUpdateColumnBytesReq(const char* stbname, const char* colname, int32_t bytes, - int32_t* pContLen); + SCreateDbReq* BuildCreateDbReq(const char* dbname, int32_t* pContLen); + SDropDbReq* BuildDropDbReq(const char* dbname, int32_t* pContLen); + void* BuildCreateStbReq(const char* stbname, int32_t* pContLen); + SMAltertbReq* BuildAlterStbAddTagReq(const char* stbname, const char* tagname, int32_t* pContLen); + SMAltertbReq* BuildAlterStbDropTagReq(const char* stbname, const char* tagname, int32_t* pContLen); + SMAltertbReq* BuildAlterStbUpdateTagNameReq(const char* stbname, const char* tagname, const char* newtagname, + int32_t* pContLen); + SMAltertbReq* BuildAlterStbUpdateTagBytesReq(const char* stbname, const char* tagname, int32_t bytes, + int32_t* pContLen); + SMAltertbReq* BuildAlterStbAddColumnReq(const char* stbname, const char* colname, int32_t* pContLen); + SMAltertbReq* BuildAlterStbDropColumnReq(const char* stbname, const char* colname, int32_t* pContLen); + SMAltertbReq* BuildAlterStbUpdateColumnBytesReq(const char* stbname, const char* colname, int32_t bytes, + int32_t* pContLen); }; Testbase MndTestStb::test; @@ -78,53 +78,62 @@ SDropDbReq* MndTestStb::BuildDropDbReq(const char* dbname, int32_t* pContLen) { return pReq; } -SMCreateStbReq* MndTestStb::BuildCreateStbReq(const char* stbname, int32_t* pContLen) { - int32_t cols = 2; - int32_t tags = 3; - int32_t contLen = (tags + cols) * sizeof(SSchema) + sizeof(SMCreateStbReq); - - SMCreateStbReq* pReq = (SMCreateStbReq*)rpcMallocCont(contLen); - strcpy(pReq->name, stbname); - pReq->numOfTags = htonl(tags); - pReq->numOfColumns = htonl(cols); +void* MndTestStb::BuildCreateStbReq(const char* stbname, int32_t* pContLen) { + SMCreateStbReq createReq = {0}; + createReq.numOfColumns = 2; + createReq.numOfTags = 3; + createReq.igExists = 0; + createReq.pColumns = taosArrayInit(createReq.numOfColumns, sizeof(SField)); + createReq.pTags = taosArrayInit(createReq.numOfTags, sizeof(SField)); + strcpy(createReq.name, stbname); { - SSchema* pSchema = &pReq->pSchemas[0]; - pSchema->bytes = htonl(8); - pSchema->type = TSDB_DATA_TYPE_TIMESTAMP; - strcpy(pSchema->name, "ts"); + SField field = {0}; + field.bytes = 8; + field.type = TSDB_DATA_TYPE_TIMESTAMP; + strcpy(field.name, "ts"); + taosArrayPush(createReq.pColumns, &field); } { - SSchema* pSchema = &pReq->pSchemas[1]; - pSchema->bytes = htonl(12); - pSchema->type = TSDB_DATA_TYPE_BINARY; - strcpy(pSchema->name, "col1"); + SField field = {0}; + field.bytes = 12; + field.type = TSDB_DATA_TYPE_BINARY; + strcpy(field.name, "col1"); + taosArrayPush(createReq.pColumns, &field); } { - SSchema* pSchema = &pReq->pSchemas[2]; - pSchema->bytes = htonl(2); - pSchema->type = TSDB_DATA_TYPE_TINYINT; - strcpy(pSchema->name, "tag1"); + SField field = {0}; + field.bytes = 2; + field.type = TSDB_DATA_TYPE_TINYINT; + strcpy(field.name, "tag1"); + taosArrayPush(createReq.pTags, &field); } { - SSchema* pSchema = &pReq->pSchemas[3]; - pSchema->bytes = htonl(8); - pSchema->type = TSDB_DATA_TYPE_BIGINT; - strcpy(pSchema->name, "tag2"); + SField field = {0}; + field.bytes = 8; + field.type = TSDB_DATA_TYPE_BIGINT; + strcpy(field.name, "tag2"); + taosArrayPush(createReq.pTags, &field); } { - SSchema* pSchema = &pReq->pSchemas[4]; - pSchema->bytes = htonl(16); - pSchema->type = TSDB_DATA_TYPE_BINARY; - strcpy(pSchema->name, "tag3"); + SField field = {0}; + field.bytes = 16; + field.type = TSDB_DATA_TYPE_BINARY; + strcpy(field.name, "tag3"); + taosArrayPush(createReq.pTags, &field); } - *pContLen = contLen; - return pReq; + int32_t tlen = tSerializeSMCreateStbReq(NULL, &createReq); + void* pHead = rpcMallocCont(tlen); + + void* pBuf = pHead; + tSerializeSMCreateStbReq(&pBuf, &createReq); + *pContLen = tlen; + return pHead; } SMAltertbReq* MndTestStb::BuildAlterStbAddTagReq(const char* stbname, const char* tagname, int32_t* pContLen) { @@ -260,9 +269,9 @@ TEST_F(MndTestStb, 01_Create_Show_Meta_Drop_Restart_Stb) { } { - int32_t contLen = 0; - SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen); - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); + int32_t contLen = 0; + void* pReq = BuildCreateStbReq(stbname, &contLen); + SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); ASSERT_NE(pRsp, nullptr); ASSERT_EQ(pRsp->code, 0); } @@ -418,8 +427,8 @@ TEST_F(MndTestStb, 02_Alter_Stb_AddTag) { } { - SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen); - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); + void* pReq = BuildCreateStbReq(stbname, &contLen); + SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); ASSERT_NE(pRsp, nullptr); ASSERT_EQ(pRsp->code, 0); } @@ -483,8 +492,8 @@ TEST_F(MndTestStb, 03_Alter_Stb_DropTag) { } { - SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen); - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); + void* pReq = BuildCreateStbReq(stbname, &contLen); + SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); ASSERT_EQ(pRsp->code, 0); } @@ -529,8 +538,8 @@ TEST_F(MndTestStb, 04_Alter_Stb_AlterTagName) { } { - SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen); - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); + void* pReq = BuildCreateStbReq(stbname, &contLen); + SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); ASSERT_EQ(pRsp->code, 0); } @@ -598,8 +607,8 @@ TEST_F(MndTestStb, 05_Alter_Stb_AlterTagBytes) { } { - SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen); - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); + void* pReq = BuildCreateStbReq(stbname, &contLen); + SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); ASSERT_EQ(pRsp->code, 0); } @@ -656,8 +665,8 @@ TEST_F(MndTestStb, 06_Alter_Stb_AddColumn) { } { - SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen); - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); + void* pReq = BuildCreateStbReq(stbname, &contLen); + SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); ASSERT_NE(pRsp, nullptr); ASSERT_EQ(pRsp->code, 0); } @@ -721,8 +730,8 @@ TEST_F(MndTestStb, 07_Alter_Stb_DropColumn) { } { - SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen); - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); + void* pReq = BuildCreateStbReq(stbname, &contLen); + SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); ASSERT_EQ(pRsp->code, 0); } @@ -786,8 +795,8 @@ TEST_F(MndTestStb, 08_Alter_Stb_AlterTagBytes) { } { - SMCreateStbReq* pReq = BuildCreateStbReq(stbname, &contLen); - SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); + void* pReq = BuildCreateStbReq(stbname, &contLen); + SRpcMsg* pRsp = test.SendReq(TDMT_MND_CREATE_STB, pReq, contLen); ASSERT_EQ(pRsp->code, 0); } diff --git a/source/libs/parser/src/astToMsg.c b/source/libs/parser/src/astToMsg.c index c7a1fd26a0..0402c5c60f 100644 --- a/source/libs/parser/src/astToMsg.c +++ b/source/libs/parser/src/astToMsg.c @@ -249,92 +249,35 @@ SCreateDbReq* buildCreateDbMsg(SCreateDbInfo* pCreateDbInfo, SParseContext *pCtx return pCreateMsg; } -SMCreateStbReq* buildCreateStbMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf) { - SSchema* pSchema; - - int32_t numOfTags = 0; - int32_t numOfCols = (int32_t) taosArrayGetSize(pCreateTableSql->colInfo.pColumns); - if (pCreateTableSql->colInfo.pTagColumns != NULL) { - numOfTags = (int32_t) taosArrayGetSize(pCreateTableSql->colInfo.pTagColumns); +SMCreateStbReq* buildCreateStbMsg(SCreateTableSql* pCreateTableSql, int32_t* len, SParseContext* pParseCtx, + SMsgBuf* pMsgBuf) { + SMCreateStbReq createReq = {0}; + createReq.igExists = pCreateTableSql->existCheck ? 1 : 0; + createReq.pColumns = pCreateTableSql->colInfo.pColumns; + createReq.pTags = pCreateTableSql->colInfo.pTagColumns; + createReq.numOfColumns = (int32_t)taosArrayGetSize(pCreateTableSql->colInfo.pColumns); + createReq.numOfTags = (int32_t)taosArrayGetSize(pCreateTableSql->colInfo.pTagColumns); + + SName n = {0}; + if (createSName(&n, &pCreateTableSql->name, pParseCtx, pMsgBuf) != 0) { + return NULL; } - SMCreateStbReq* pCreateStbMsg = (SMCreateStbReq*)calloc(1, sizeof(SMCreateStbReq) + (numOfCols + numOfTags) * sizeof(SSchema)); - if (pCreateStbMsg == NULL) { + if (tNameExtractFullName(&n, createReq.name) != 0) { + buildInvalidOperationMsg(pMsgBuf, "invalid table name or database not specified"); return NULL; } - char* pMsg = NULL; -#if 0 - int32_t tableType = pCreateTableSql->type; - if (tableType != TSQL_CREATE_TABLE && tableType != TSQL_CREATE_STABLE) { // create by using super table, tags value - SArray* list = pInfo->pCreateTableInfo->childTableInfo; - - int32_t numOfTables = (int32_t)taosArrayGetSize(list); - pCreateStbMsg->numOfTables = htonl(numOfTables); - - pMsg = (char*)pCreateMsg; - for (int32_t i = 0; i < numOfTables; ++i) { - SCreateTableMsg* pCreate = (SCreateTableMsg*)pMsg; - - pCreate->numOfColumns = htons(pCmd->numOfCols); - pCreate->numOfTags = htons(pCmd->count); - pMsg += sizeof(SCreateTableMsg); - - SCreatedTableInfo* p = taosArrayGet(list, i); - strcpy(pCreate->tableName, p->fullname); - pCreate->igExists = (p->igExist) ? 1 : 0; - - // use dbinfo from table id without modifying current db info - pMsg = serializeTagData(&p->tagdata, pMsg); - - int32_t len = (int32_t)(pMsg - (char*)pCreate); - pCreate->len = htonl(len); - } - - } else { -#endif - // create (super) table - SName n = {0}; - int32_t code = createSName(&n, &pCreateTableSql->name, pParseCtx, pMsgBuf); - if (code != 0) { - return NULL; - } - - code = tNameExtractFullName(&n, pCreateStbMsg->name); - if (code != 0) { - buildInvalidOperationMsg(pMsgBuf, "invalid table name or database not specified"); - return NULL; - } - - pCreateStbMsg->igExists = pCreateTableSql->existCheck ? 1 : 0; - pCreateStbMsg->numOfColumns = htonl(numOfCols); - pCreateStbMsg->numOfTags = htonl(numOfTags); - - pSchema = (SSchema*)pCreateStbMsg->pSchemas; - for (int i = 0; i < numOfCols; ++i) { - SField* pField = taosArrayGet(pCreateTableSql->colInfo.pColumns, i); - pSchema->type = pField->type; - pSchema->bytes = htonl(pField->bytes); - strcpy(pSchema->name, pField->name); - - pSchema++; - } - - for(int32_t i = 0; i < numOfTags; ++i) { - SField* pField = taosArrayGet(pCreateTableSql->colInfo.pTagColumns, i); - pSchema->type = pField->type; - pSchema->bytes = htonl(pField->bytes); - strcpy(pSchema->name, pField->name); - - pSchema++; - } - - pMsg = (char*)pSchema; - - int32_t msgLen = (int32_t)(pMsg - (char*)pCreateStbMsg); - *len = msgLen; + int32_t tlen = tSerializeSMCreateStbReq(NULL, &createReq); + void* req = malloc(tlen); + if (req == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } - return pCreateStbMsg; + void *buf = req; + tSerializeSMCreateStbReq(&buf, &createReq); + return req; } SMDropStbReq* buildDropStableMsg(SSqlInfo* pInfo, int32_t* len, SParseContext* pParseCtx, SMsgBuf* pMsgBuf) { diff --git a/source/util/src/tarray.c b/source/util/src/tarray.c index 09aeff5ff3..3e6f97c0c3 100644 --- a/source/util/src/tarray.c +++ b/source/util/src/tarray.c @@ -204,7 +204,12 @@ void* taosArrayGetLast(const SArray* pArray) { return TARRAY_GET_ELEM(pArray, pArray->size - 1); } -size_t taosArrayGetSize(const SArray* pArray) { return pArray->size; } +size_t taosArrayGetSize(const SArray* pArray) { + if (pArray == NULL) { + return 0; + } + return pArray->size; +} void taosArraySetSize(SArray* pArray, size_t size) { assert(size <= pArray->capacity); @@ -296,7 +301,7 @@ SArray* taosArrayDup(const SArray* pSrc) { } void taosArrayClear(SArray* pArray) { - assert( pArray != NULL ); + if (pArray == NULL) return; pArray->size = 0; } -- GitLab