diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 39f1bd172bb24cb287cd553571f5c56e999de66d..19897ecb24a3a30db5fa6c1bf730c568b295b21a 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -332,7 +332,7 @@ typedef struct { int64_t clusterId; int32_t connId; int8_t superUser; - int8_t reserved[5]; + int8_t align[3]; SEpSet epSet; } SConnectRsp; @@ -345,20 +345,17 @@ typedef struct { int32_t maxStreams; int32_t accessState; // Configured only by command int64_t maxStorage; // In unit of GB - int32_t reserve[8]; } SCreateAcctMsg, SAlterAcctMsg; typedef struct { - char user[TSDB_USER_LEN]; - int32_t reserve[8]; + char user[TSDB_USER_LEN]; } SDropUserMsg, SDropAcctMsg; typedef struct { - int8_t type; - char user[TSDB_USER_LEN]; - char pass[TSDB_PASSWORD_LEN]; - int8_t superUser; // denote if it is a super user or not - int32_t reserve[8]; + int8_t type; + char user[TSDB_USER_LEN]; + char pass[TSDB_PASSWORD_LEN]; + int8_t superUser; // denote if it is a super user or not } SCreateUserMsg, SAlterUserMsg; typedef struct { @@ -547,7 +544,6 @@ typedef struct { int8_t update; int8_t cacheLastRow; int8_t ignoreExist; - int32_t reserve[8]; } SCreateDbMsg; typedef struct { @@ -560,29 +556,24 @@ typedef struct { int8_t walLevel; int8_t quorum; int8_t cacheLastRow; - int32_t reserve[8]; } SAlterDbMsg; typedef struct { - char db[TSDB_TABLE_FNAME_LEN]; - int8_t ignoreNotExists; - int32_t reserve[8]; + char db[TSDB_TABLE_FNAME_LEN]; + int8_t ignoreNotExists; } SDropDbMsg; typedef struct { char db[TSDB_TABLE_FNAME_LEN]; int32_t vgVersion; - int32_t reserve[8]; } SUseDbMsg; typedef struct { - char db[TSDB_TABLE_FNAME_LEN]; - int32_t reserve[8]; + char db[TSDB_TABLE_FNAME_LEN]; } SSyncDbMsg; typedef struct { - char db[TSDB_TABLE_FNAME_LEN]; - int32_t reserve[8]; + char db[TSDB_TABLE_FNAME_LEN]; } SCompactDbMsg; typedef struct { @@ -638,7 +629,7 @@ typedef struct { typedef struct { int32_t vgId; int8_t role; - int8_t reserved[3]; + int8_t align[3]; int64_t totalStorage; int64_t compStorage; int64_t pointsWritten; @@ -675,7 +666,7 @@ typedef struct { typedef struct { int32_t id; int8_t isMnode; - int8_t reserved; + int8_t align; uint16_t port; char fqdn[TSDB_FQDN_LEN]; } SDnodeEp; @@ -911,7 +902,7 @@ typedef struct { int32_t totalDnodes; int32_t onlineDnodes; int8_t killConnection; - int8_t reserved[3]; + int8_t align[3]; SEpSet epSet; } SHeartBeatRsp; @@ -939,7 +930,7 @@ typedef struct { typedef struct { int8_t finished; - int8_t reserved1[7]; + int8_t align[7]; char name[TSDB_STEP_NAME_LEN]; char desc[TSDB_STEP_DESC_LEN]; } SStartupMsg; diff --git a/include/dnode/mnode/sdb/sdb.h b/include/dnode/mnode/sdb/sdb.h index 3ff86bea3ebfbcd4aea7a8c6fbdef833d26561e7..9373e258be81c3af089bab5443f3f35d94dfdb21 100644 --- a/include/dnode/mnode/sdb/sdb.h +++ b/include/dnode/mnode/sdb/sdb.h @@ -22,121 +22,70 @@ extern "C" { #endif -#define SDB_GET_INT64(pData, pRow, dataPos, val) \ - { \ - if (sdbGetRawInt64(pRaw, dataPos, val) != 0) { \ - tfree(pRow); \ - return NULL; \ - } \ - dataPos += sizeof(int64_t); \ +#define SDB_GET_VAL(pData, dataPos, val, pos, func, type) \ + { \ + if (func(pRaw, dataPos, val) != 0) { \ + goto pos; \ + } \ + dataPos += sizeof(type); \ } -#define SDB_GET_INT32(pData, pRow, dataPos, val) \ - { \ - if (sdbGetRawInt32(pRaw, dataPos, val) != 0) { \ - tfree(pRow); \ - return NULL; \ - } \ - dataPos += sizeof(int32_t); \ - } - -#define SDB_GET_INT16(pData, pRow, dataPos, val) \ - { \ - if (sdbGetRawInt16(pRaw, dataPos, val) != 0) { \ - tfree(pRow); \ - return NULL; \ - } \ - dataPos += sizeof(int16_t); \ - } - -#define SDB_GET_INT8(pData, pRow, dataPos, val) \ - { \ - if (sdbGetRawInt8(pRaw, dataPos, val) != 0) { \ - tfree(pRow); \ - return NULL; \ - } \ - dataPos += sizeof(int8_t); \ - } - -#define SDB_GET_BINARY(pRaw, pRow, dataPos, val, valLen) \ +#define SDB_GET_BINARY(pRaw, dataPos, val, valLen, pos) \ { \ if (sdbGetRawBinary(pRaw, dataPos, val, valLen) != 0) { \ - tfree(pRow); \ - return NULL; \ + goto pos; \ } \ dataPos += valLen; \ } -#define SDB_GET_RESERVE(pRaw, pRow, dataPos, valLen) \ - { \ - char val[valLen] = {0}; \ - if (sdbGetRawBinary(pRaw, dataPos, val, valLen) != 0) { \ - tfree(pRow); \ - return NULL; \ - } \ - dataPos += valLen; \ - } +#define SDB_GET_INT64(pData, dataPos, val, pos) SDB_GET_VAL(pData, dataPos, val, pos, sdbGetRawInt64, int64_t) -#define SDB_SET_INT64(pRaw, dataPos, val) \ - { \ - if (sdbSetRawInt64(pRaw, dataPos, val) != 0) { \ - sdbFreeRaw(pRaw); \ - return NULL; \ - } \ - dataPos += sizeof(int64_t); \ - } +#define SDB_GET_INT32(pData, dataPos, val, pos) SDB_GET_VAL(pData, dataPos, val, pos, sdbGetRawInt32, int32_t) -#define SDB_SET_INT32(pRaw, dataPos, val) \ - { \ - if (sdbSetRawInt32(pRaw, dataPos, val) != 0) { \ - sdbFreeRaw(pRaw); \ - return NULL; \ - } \ - dataPos += sizeof(int32_t); \ - } +#define SDB_GET_INT16(pData, dataPos, val, pos) SDB_GET_VAL(pData, dataPos, val, pos, sdbGetRawInt16, int16_t) + +#define SDB_GET_INT8(pData, dataPos, val, pos) SDB_GET_VAL(pData, dataPos, val, pos, sdbGetRawInt8, int8_t) -#define SDB_SET_INT16(pRaw, dataPos, val) \ - { \ - if (sdbSetRawInt16(pRaw, dataPos, val) != 0) { \ - sdbFreeRaw(pRaw); \ - return NULL; \ - } \ - dataPos += sizeof(int16_t); \ +#define SDB_GET_RESERVE(pRaw, dataPos, valLen, pos) \ + { \ + char val[valLen] = {0}; \ + SDB_GET_BINARY(pRaw, dataPos, val, valLen, pos) \ } -#define SDB_SET_INT8(pRaw, dataPos, val) \ - { \ - if (sdbSetRawInt8(pRaw, dataPos, val) != 0) { \ - sdbFreeRaw(pRaw); \ - return NULL; \ - } \ - dataPos += sizeof(int8_t); \ +#define SDB_SET_VAL(pRaw, dataPos, val, pos, func, type) \ + { \ + if (func(pRaw, dataPos, val) != 0) { \ + goto pos; \ + } \ + dataPos += sizeof(type); \ } -#define SDB_SET_BINARY(pRaw, dataPos, val, valLen) \ +#define SDB_SET_INT64(pRaw, dataPos, val, pos) SDB_SET_VAL(pRaw, dataPos, val, pos, sdbSetRawInt64, int64_t) + +#define SDB_SET_INT32(pRaw, dataPos, val, pos) SDB_SET_VAL(pRaw, dataPos, val, pos, sdbSetRawInt32, int32_t) + +#define SDB_SET_INT16(pRaw, dataPos, val, pos) SDB_SET_VAL(pRaw, dataPos, val, pos, sdbSetRawInt16, int16_t) + +#define SDB_SET_INT8(pRaw, dataPos, val, pos) SDB_SET_VAL(pRaw, dataPos, val, pos, sdbSetRawInt8, int8_t) + +#define SDB_SET_BINARY(pRaw, dataPos, val, valLen, pos) \ { \ if (sdbSetRawBinary(pRaw, dataPos, val, valLen) != 0) { \ - sdbFreeRaw(pRaw); \ - return NULL; \ + goto pos; \ } \ dataPos += valLen; \ } -#define SDB_SET_RESERVE(pRaw, dataPos, valLen) \ - { \ - char val[valLen] = {0}; \ - if (sdbSetRawBinary(pRaw, dataPos, val, valLen) != 0) { \ - sdbFreeRaw(pRaw); \ - return NULL; \ - } \ - dataPos += valLen; \ +#define SDB_SET_RESERVE(pRaw, dataPos, valLen, pos) \ + { \ + char val[valLen] = {0}; \ + SDB_SET_BINARY(pRaw, dataPos, val, valLen, pos) \ } -#define SDB_SET_DATALEN(pRaw, dataLen) \ +#define SDB_SET_DATALEN(pRaw, dataLen, pos) \ { \ if (sdbSetRawDataLen(pRaw, dataLen) != 0) { \ - sdbFreeRaw(pRaw); \ - return NULL; \ + goto pos; \ } \ } diff --git a/source/dnode/mgmt/impl/src/dndTransport.c b/source/dnode/mgmt/impl/src/dndTransport.c index dc5248c8e0ecd5cfddab311d2db5b8cb1ab12897..bb16ef0b77bc4021f7a060e19cd99e36a5ad46ae 100644 --- a/source/dnode/mgmt/impl/src/dndTransport.c +++ b/source/dnode/mgmt/impl/src/dndTransport.c @@ -160,8 +160,8 @@ static void dndProcessResponse(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) { DndMsgFp fp = pMgmt->msgFp[TMSG_INDEX(msgType)]; if (fp != NULL) { + dTrace("RPC %p, rsp:%s will be processed, code:0x%x", pMsg->handle, TMSG_INFO(msgType), pMsg->code & 0XFFFF); (*fp)(pDnode, pMsg, pEpSet); - dTrace("RPC %p, rsp:%s is processed, code:0x%x", pMsg->handle, TMSG_INFO(msgType), pMsg->code & 0XFFFF); } else { dError("RPC %p, rsp:%s not processed", pMsg->handle, TMSG_INFO(msgType)); rpcFreeCont(pMsg->pCont); diff --git a/source/dnode/mgmt/impl/test/db/db.cpp b/source/dnode/mgmt/impl/test/db/db.cpp index 5c67c10817547cb5d81666afa402238b6397c960..7ba19677fd38e2ca182495268a56be240d928bee 100644 --- a/source/dnode/mgmt/impl/test/db/db.cpp +++ b/source/dnode/mgmt/impl/test/db/db.cpp @@ -115,8 +115,8 @@ TEST_F(DndTestDb, 02_Create_Alter_Drop_Db) { test.SendShowRetrieveMsg(); EXPECT_EQ(test.GetShowRows(), 2); - CheckInt32(1); CheckInt32(2); + CheckInt32(3); CheckInt32(0); CheckInt32(0); CheckInt16(1); diff --git a/source/dnode/mgmt/impl/test/sut/inc/base.h b/source/dnode/mgmt/impl/test/sut/inc/base.h index fef7ad9d430fd20719fcd378a9e8eed99bf48a0f..41382fbab5cdfba3f14417e51ba7cef3ed0a8dad 100644 --- a/source/dnode/mgmt/impl/test/sut/inc/base.h +++ b/source/dnode/mgmt/impl/test/sut/inc/base.h @@ -71,7 +71,7 @@ class Testbase { const char* GetShowBinary(int32_t len); private: - int32_t showId; + int64_t showId; STableMetaMsg* pMeta; SRetrieveTableRsp* pRetrieveRsp; char* pData; diff --git a/source/dnode/mgmt/impl/test/sut/src/base.cpp b/source/dnode/mgmt/impl/test/sut/src/base.cpp index e14dc94d31bb126a286780c79d19cfb42c37e114..429d5a6976b02cc8c4344b149703f7cd3f44497f 100644 --- a/source/dnode/mgmt/impl/test/sut/src/base.cpp +++ b/source/dnode/mgmt/impl/test/sut/src/base.cpp @@ -79,7 +79,7 @@ void Testbase::SendShowMetaMsg(int8_t showType, const char* db) { SShowRsp* pShowRsp = (SShowRsp*)pMsg->pCont; ASSERT(pShowRsp != nullptr); - pShowRsp->showId = htonl(pShowRsp->showId); + pShowRsp->showId = htobe64(pShowRsp->showId); pMeta = &pShowRsp->tableMeta; pMeta->numOfTags = htonl(pMeta->numOfTags); pMeta->numOfColumns = htonl(pMeta->numOfColumns); @@ -121,7 +121,7 @@ void Testbase::SendShowRetrieveMsg() { int32_t contLen = sizeof(SRetrieveTableMsg); SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(contLen); - pRetrieve->showId = htonl(showId); + pRetrieve->showId = htobe64(showId); pRetrieve->free = 0; SRpcMsg* pMsg = SendMsg(TDMT_MND_SHOW_RETRIEVE, pRetrieve, contLen); diff --git a/source/dnode/mgmt/impl/test/user/user.cpp b/source/dnode/mgmt/impl/test/user/user.cpp index aa160304c844c00225cef8cc962070763e225143..aecce0bdc9e224aac9ad573593e818dddcf468d7 100644 --- a/source/dnode/mgmt/impl/test/user/user.cpp +++ b/source/dnode/mgmt/impl/test/user/user.cpp @@ -43,6 +43,153 @@ TEST_F(DndTestUser, 01_ShowUser) { CheckBinary("root", TSDB_USER_LEN); } +TEST_F(DndTestUser, 02_Create_User) { + { + int32_t contLen = sizeof(SCreateUserMsg); + + SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, ""); + strcpy(pReq->pass, "p1"); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_USER_FORMAT); + } + + { + int32_t contLen = sizeof(SCreateUserMsg); + + SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, "u1"); + strcpy(pReq->pass, ""); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_PASS_FORMAT); + } + + { + int32_t contLen = sizeof(SCreateUserMsg); + + SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, "root"); + strcpy(pReq->pass, "1"); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, TSDB_CODE_MND_USER_ALREADY_EXIST); + } + + { + int32_t contLen = sizeof(SCreateUserMsg); + + SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, "u1"); + strcpy(pReq->pass, "p1"); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_CREATE_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, 0); + } + + test.SendShowMetaMsg(TSDB_MGMT_TABLE_USER, ""); + CHECK_META("show users", 4); + + test.SendShowRetrieveMsg(); + EXPECT_EQ(test.GetShowRows(), 2); +} + +TEST_F(DndTestUser, 03_Alter_User) { + { + int32_t contLen = sizeof(SAlterUserMsg); + + SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, ""); + strcpy(pReq->pass, "p1"); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_ALTER_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_USER_FORMAT); + } + + { + int32_t contLen = sizeof(SAlterUserMsg); + + SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, "u1"); + strcpy(pReq->pass, ""); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_ALTER_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_PASS_FORMAT); + } + + { + int32_t contLen = sizeof(SAlterUserMsg); + + SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, "u4"); + strcpy(pReq->pass, "1"); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_ALTER_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, TSDB_CODE_MND_USER_NOT_EXIST); + } + + { + int32_t contLen = sizeof(SAlterUserMsg); + + SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, "u1"); + strcpy(pReq->pass, "1"); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_ALTER_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, 0); + } +} + +TEST_F(DndTestUser, 04_Drop_User) { + { + int32_t contLen = sizeof(SDropUserMsg); + + SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, ""); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, TSDB_CODE_MND_INVALID_USER_FORMAT); + } + + { + int32_t contLen = sizeof(SDropUserMsg); + + SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, "u4"); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, TSDB_CODE_MND_USER_NOT_EXIST); + } + + { + int32_t contLen = sizeof(SDropUserMsg); + + SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(contLen); + strcpy(pReq->user, "u1"); + + SRpcMsg* pMsg = test.SendMsg(TDMT_MND_DROP_USER, pReq, contLen); + ASSERT_NE(pMsg, nullptr); + ASSERT_EQ(pMsg->code, 0); + } + + test.SendShowMetaMsg(TSDB_MGMT_TABLE_USER, ""); + CHECK_META("show users", 4); + + test.SendShowRetrieveMsg(); + EXPECT_EQ(test.GetShowRows(), 1); +} + TEST_F(DndTestUser, 02_Create_Drop_Alter_User) { { int32_t contLen = sizeof(SCreateUserMsg); @@ -161,4 +308,4 @@ TEST_F(DndTestUser, 02_Create_Drop_Alter_User) { CheckTimestamp(); CheckBinary("root", TSDB_USER_LEN); CheckBinary("root", TSDB_USER_LEN); -} +} \ No newline at end of file diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index e26c0c5ae7d3704d64171c6fb36020518ad8723c..267a3f6cf5df040cd9ac4f0c6b6e61fee6dfe389 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -160,8 +160,14 @@ typedef struct { typedef struct { int32_t maxUsers; int32_t maxDbs; + int32_t maxStbs; + int32_t maxTbs; int32_t maxTimeSeries; int32_t maxStreams; + int32_t maxFuncs; + int32_t maxConsumers; + int32_t maxConns; + int32_t maxTopics; int64_t maxStorage; // In unit of GB int32_t accessState; // Configured only by command } SAcctCfg; diff --git a/source/dnode/mnode/impl/src/mndAcct.c b/source/dnode/mnode/impl/src/mndAcct.c index 767f628306ad2e563baccdd15972f762ffbbd21d..2847d19beaa3a4bb449fc04e760f6cbd71fb46d2 100644 --- a/source/dnode/mnode/impl/src/mndAcct.c +++ b/source/dnode/mnode/impl/src/mndAcct.c @@ -18,7 +18,7 @@ #include "mndShow.h" #define TSDB_ACCT_VER_NUMBER 1 -#define TSDB_ACCT_RESERVE_SIZE 64 +#define TSDB_ACCT_RESERVE_SIZE 128 static int32_t mndCreateDefaultAcct(SMnode *pMnode); static SSdbRaw *mndAcctActionEncode(SAcctObj *pAcct); @@ -55,10 +55,16 @@ static int32_t mndCreateDefaultAcct(SMnode *pMnode) { acctObj.createdTime = taosGetTimestampMs(); acctObj.updateTime = acctObj.createdTime; acctObj.acctId = 1; - acctObj.cfg = (SAcctCfg){.maxUsers = 1024, - .maxDbs = 1024, + acctObj.cfg = (SAcctCfg){.maxUsers = INT32_MAX, + .maxDbs = INT32_MAX, + .maxStbs = INT32_MAX, + .maxTbs = INT32_MAX, .maxTimeSeries = INT32_MAX, - .maxStreams = 8092, + .maxStreams = INT32_MAX, + .maxFuncs = INT32_MAX, + .maxConsumers = INT32_MAX, + .maxConns = INT32_MAX, + .maxTopics = INT32_MAX, .maxStorage = INT64_MAX, .accessState = TSDB_VN_ALL_ACCCESS}; @@ -66,79 +72,116 @@ static int32_t mndCreateDefaultAcct(SMnode *pMnode) { if (pRaw == NULL) return -1; sdbSetRawStatus(pRaw, SDB_STATUS_READY); - mDebug("acct:%s, will be created while deploy sdb", acctObj.acct); + mDebug("acct:%s, will be created while deploy sdb, raw:%p", acctObj.acct, pRaw); return sdbWrite(pMnode->pSdb, pRaw); } static SSdbRaw *mndAcctActionEncode(SAcctObj *pAcct) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + SSdbRaw *pRaw = sdbAllocRaw(SDB_ACCT, TSDB_ACCT_VER_NUMBER, sizeof(SAcctObj) + TSDB_ACCT_RESERVE_SIZE); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto ACCT_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_BINARY(pRaw, dataPos, pAcct->acct, TSDB_USER_LEN) - SDB_SET_INT64(pRaw, dataPos, pAcct->createdTime) - SDB_SET_INT64(pRaw, dataPos, pAcct->updateTime) - SDB_SET_INT32(pRaw, dataPos, pAcct->acctId) - SDB_SET_INT32(pRaw, dataPos, pAcct->status) - SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxUsers) - SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxDbs) - SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxTimeSeries) - SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxStreams) - SDB_SET_INT64(pRaw, dataPos, pAcct->cfg.maxStorage) - SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.accessState) - SDB_SET_RESERVE(pRaw, dataPos, TSDB_ACCT_RESERVE_SIZE) - SDB_SET_DATALEN(pRaw, dataPos); + SDB_SET_BINARY(pRaw, dataPos, pAcct->acct, TSDB_USER_LEN, ACCT_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pAcct->createdTime, ACCT_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pAcct->updateTime, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->acctId, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->status, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxUsers, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxDbs, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxStbs, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxTbs, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxTimeSeries, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxStreams, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxFuncs, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxConsumers, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxConns, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.maxTopics, ACCT_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pAcct->cfg.maxStorage, ACCT_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAcct->cfg.accessState, ACCT_ENCODE_OVER) + SDB_SET_RESERVE(pRaw, dataPos, TSDB_ACCT_RESERVE_SIZE, ACCT_ENCODE_OVER) + SDB_SET_DATALEN(pRaw, dataPos, ACCT_ENCODE_OVER) + + terrno = 0; + +ACCT_ENCODE_OVER: + if (terrno != 0) { + mError("acct:%s, failed to encode to raw:%p since %s", pAcct->acct, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + mTrace("acct:%s, encode to raw:%p, row:%p", pAcct->acct, pRaw, pAcct); return pRaw; } static SSdbRow *mndAcctActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto ACCT_DECODE_OVER; if (sver != TSDB_ACCT_VER_NUMBER) { - mError("failed to decode acct since %s", terrstr()); terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - return NULL; + goto ACCT_DECODE_OVER; } - SSdbRow *pRow = sdbAllocRow(sizeof(SAcctObj)); + SSdbRow *pRow = sdbAllocRow(sizeof(SAcctObj)); + if (pRow == NULL) goto ACCT_DECODE_OVER; + SAcctObj *pAcct = sdbGetRowObj(pRow); - if (pAcct == NULL) return NULL; + if (pAcct == NULL) goto ACCT_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_BINARY(pRaw, pRow, dataPos, pAcct->acct, TSDB_USER_LEN) - SDB_GET_INT64(pRaw, pRow, dataPos, &pAcct->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pAcct->updateTime) - SDB_GET_INT32(pRaw, pRow, dataPos, &pAcct->acctId) - SDB_GET_INT32(pRaw, pRow, dataPos, &pAcct->status) - SDB_GET_INT32(pRaw, pRow, dataPos, &pAcct->cfg.maxUsers) - SDB_GET_INT32(pRaw, pRow, dataPos, &pAcct->cfg.maxDbs) - SDB_GET_INT32(pRaw, pRow, dataPos, &pAcct->cfg.maxTimeSeries) - SDB_GET_INT32(pRaw, pRow, dataPos, &pAcct->cfg.maxStreams) - SDB_GET_INT64(pRaw, pRow, dataPos, &pAcct->cfg.maxStorage) - SDB_GET_INT32(pRaw, pRow, dataPos, &pAcct->cfg.accessState) - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_ACCT_RESERVE_SIZE) + SDB_GET_BINARY(pRaw, dataPos, pAcct->acct, TSDB_USER_LEN, ACCT_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pAcct->createdTime, ACCT_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pAcct->updateTime, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->acctId, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->status, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxUsers, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxDbs, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxStbs, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxTbs, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxTimeSeries, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxStreams, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxFuncs, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxConsumers, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxConns, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.maxTopics, ACCT_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pAcct->cfg.maxStorage, ACCT_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pAcct->cfg.accessState, ACCT_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_ACCT_RESERVE_SIZE, ACCT_DECODE_OVER) + + terrno = 0; + +ACCT_DECODE_OVER: + if (terrno != 0) { + mError("acct:%s, failed to decode from raw:%p since %s", pAcct->acct, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + mTrace("acct:%s, decode from raw:%p, row:%p", pAcct->acct, pRaw, pAcct); return pRow; } static int32_t mndAcctActionInsert(SSdb *pSdb, SAcctObj *pAcct) { - mTrace("acct:%s, perform insert action", pAcct->acct); + mTrace("acct:%s, perform insert action, row:%p", pAcct->acct, pAcct); return 0; } static int32_t mndAcctActionDelete(SSdb *pSdb, SAcctObj *pAcct) { - mTrace("acct:%s, perform delete action", pAcct->acct); + mTrace("acct:%s, perform delete action, row:%p", pAcct->acct, pAcct); return 0; } static int32_t mndAcctActionUpdate(SSdb *pSdb, SAcctObj *pOldAcct, SAcctObj *pNewAcct) { - mTrace("acct:%s, perform update action", pOldAcct->acct); + mTrace("acct:%s, perform update action, old_row:%p new_row:%p", pOldAcct->acct, pOldAcct, pNewAcct); pOldAcct->updateTime = pNewAcct->updateTime; pOldAcct->status = pNewAcct->status; - memcpy(&pOldAcct->cfg, &pNewAcct->cfg, sizeof(SAcctInfo)); + memcpy(&pOldAcct->cfg, &pNewAcct->cfg, sizeof(SAcctCfg)); return 0; } diff --git a/source/dnode/mnode/impl/src/mndBnode.c b/source/dnode/mnode/impl/src/mndBnode.c index 2d14e0f92e828b267fb768f26d8d76fb06625683..ceaebe3f6df67a716919946bf301a3139a223809 100644 --- a/source/dnode/mnode/impl/src/mndBnode.c +++ b/source/dnode/mnode/impl/src/mndBnode.c @@ -58,9 +58,9 @@ int32_t mndInitBnode(SMnode *pMnode) { void mndCleanupBnode(SMnode *pMnode) {} -static SBnodeObj *mndAcquireBnode(SMnode *pMnode, int32_t snodeId) { +static SBnodeObj *mndAcquireBnode(SMnode *pMnode, int32_t bnodeId) { SSdb *pSdb = pMnode->pSdb; - SBnodeObj *pObj = sdbAcquire(pSdb, SDB_BNODE, &snodeId); + SBnodeObj *pObj = sdbAcquire(pSdb, SDB_BNODE, &bnodeId); if (pObj == NULL) { terrno = TSDB_CODE_MND_BNODE_NOT_EXIST; } @@ -73,47 +73,72 @@ static void mndReleaseBnode(SMnode *pMnode, SBnodeObj *pObj) { } static SSdbRaw *mndBnodeActionEncode(SBnodeObj *pObj) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + SSdbRaw *pRaw = sdbAllocRaw(SDB_BNODE, TSDB_BNODE_VER_NUMBER, sizeof(SBnodeObj) + TSDB_BNODE_RESERVE_SIZE); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto BNODE_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_INT32(pRaw, dataPos, pObj->id); - SDB_SET_INT64(pRaw, dataPos, pObj->createdTime) - SDB_SET_INT64(pRaw, dataPos, pObj->updateTime) - SDB_SET_RESERVE(pRaw, dataPos, TSDB_BNODE_RESERVE_SIZE) + SDB_SET_INT32(pRaw, dataPos, pObj->id, BNODE_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pObj->createdTime, BNODE_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pObj->updateTime, BNODE_ENCODE_OVER) + SDB_SET_RESERVE(pRaw, dataPos, TSDB_BNODE_RESERVE_SIZE, BNODE_ENCODE_OVER) + + terrno = 0; +BNODE_ENCODE_OVER: + if (terrno != 0) { + mError("bnode:%d, failed to encode to raw:%p since %s", pObj->id, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + + mTrace("bnode:%d, encode to raw:%p, row:%p", pObj->id, pRaw, pObj); return pRaw; } static SSdbRow *mndBnodeActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto BNODE_DECODE_OVER; if (sver != TSDB_BNODE_VER_NUMBER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - mError("failed to decode snode since %s", terrstr()); - return NULL; + goto BNODE_DECODE_OVER; } - SSdbRow *pRow = sdbAllocRow(sizeof(SBnodeObj)); + SSdbRow *pRow = sdbAllocRow(sizeof(SBnodeObj)); + if (pRow == NULL) goto BNODE_DECODE_OVER; + SBnodeObj *pObj = sdbGetRowObj(pRow); - if (pObj == NULL) return NULL; + if (pObj == NULL) goto BNODE_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &pObj->id) - SDB_GET_INT64(pRaw, pRow, dataPos, &pObj->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pObj->updateTime) - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_BNODE_RESERVE_SIZE) + SDB_GET_INT32(pRaw, dataPos, &pObj->id, BNODE_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pObj->createdTime, BNODE_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pObj->updateTime, BNODE_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_BNODE_RESERVE_SIZE, BNODE_DECODE_OVER) + + terrno = 0; +BNODE_DECODE_OVER: + if (terrno != 0) { + mError("bnode:%d, failed to decode from raw:%p since %s", pObj->id, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + + mTrace("bnode:%d, decode from raw:%p, row:%p", pObj->id, pRaw, pObj); return pRow; } static int32_t mndBnodeActionInsert(SSdb *pSdb, SBnodeObj *pObj) { - mTrace("snode:%d, perform insert action", pObj->id); + mTrace("bnode:%d, perform insert action, row:%p", pObj->id, pObj); pObj->pDnode = sdbAcquire(pSdb, SDB_DNODE, &pObj->id); if (pObj->pDnode == NULL) { terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; - mError("snode:%d, failed to perform insert action since %s", pObj->id, terrstr()); + mError("bnode:%d, failed to perform insert action since %s", pObj->id, terrstr()); return -1; } @@ -121,7 +146,7 @@ static int32_t mndBnodeActionInsert(SSdb *pSdb, SBnodeObj *pObj) { } static int32_t mndBnodeActionDelete(SSdb *pSdb, SBnodeObj *pObj) { - mTrace("snode:%d, perform delete action", pObj->id); + mTrace("bnode:%d, perform delete action, row:%p", pObj->id, pObj); if (pObj->pDnode != NULL) { sdbRelease(pSdb, pObj->pDnode); pObj->pDnode = NULL; @@ -131,7 +156,7 @@ static int32_t mndBnodeActionDelete(SSdb *pSdb, SBnodeObj *pObj) { } static int32_t mndBnodeActionUpdate(SSdb *pSdb, SBnodeObj *pOldBnode, SBnodeObj *pNewBnode) { - mTrace("snode:%d, perform update action", pOldBnode->id); + mTrace("bnode:%d, perform update action, old_row:%p new_row:%p", pOldBnode->id, pOldBnode, pNewBnode); pOldBnode->updateTime = pNewBnode->updateTime; return 0; } @@ -175,30 +200,30 @@ static int32_t mndSetCreateBnodeRedoActions(STrans *pTrans, SDnodeObj *pDnode, S } static int32_t mndCreateBnode(SMnode *pMnode, SMnodeMsg *pMsg, SDnodeObj *pDnode, SMCreateBnodeMsg *pCreate) { - SBnodeObj snodeObj = {0}; - snodeObj.id = pDnode->id; - snodeObj.createdTime = taosGetTimestampMs(); - snodeObj.updateTime = snodeObj.createdTime; + SBnodeObj bnodeObj = {0}; + bnodeObj.id = pDnode->id; + bnodeObj.createdTime = taosGetTimestampMs(); + bnodeObj.updateTime = bnodeObj.createdTime; int32_t code = -1; STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, &pMsg->rpcMsg); if (pTrans == NULL) { - mError("snode:%d, failed to create since %s", pCreate->dnodeId, terrstr()); + mError("bnode:%d, failed to create since %s", pCreate->dnodeId, terrstr()); goto CREATE_BNODE_OVER; } - mDebug("trans:%d, used to create snode:%d", pTrans->id, pCreate->dnodeId); + mDebug("trans:%d, used to create bnode:%d", pTrans->id, pCreate->dnodeId); - if (mndSetCreateBnodeRedoLogs(pTrans, &snodeObj) != 0) { + if (mndSetCreateBnodeRedoLogs(pTrans, &bnodeObj) != 0) { mError("trans:%d, failed to set redo log since %s", pTrans->id, terrstr()); goto CREATE_BNODE_OVER; } - if (mndSetCreateBnodeCommitLogs(pTrans, &snodeObj) != 0) { + if (mndSetCreateBnodeCommitLogs(pTrans, &bnodeObj) != 0) { mError("trans:%d, failed to set commit log since %s", pTrans->id, terrstr()); goto CREATE_BNODE_OVER; } - if (mndSetCreateBnodeRedoActions(pTrans, pDnode, &snodeObj) != 0) { + if (mndSetCreateBnodeRedoActions(pTrans, pDnode, &bnodeObj) != 0) { mError("trans:%d, failed to set redo actions since %s", pTrans->id, terrstr()); goto CREATE_BNODE_OVER; } @@ -221,18 +246,18 @@ static int32_t mndProcessCreateBnodeReq(SMnodeMsg *pMsg) { pCreate->dnodeId = htonl(pCreate->dnodeId); - mDebug("snode:%d, start to create", pCreate->dnodeId); + mDebug("bnode:%d, start to create", pCreate->dnodeId); SBnodeObj *pObj = mndAcquireBnode(pMnode, pCreate->dnodeId); if (pObj != NULL) { - mError("snode:%d, snode already exist", pObj->id); + mError("bnode:%d, bnode already exist", pObj->id); mndReleaseBnode(pMnode, pObj); return -1; } SDnodeObj *pDnode = mndAcquireDnode(pMnode, pCreate->dnodeId); if (pDnode == NULL) { - mError("snode:%d, dnode not exist", pCreate->dnodeId); + mError("bnode:%d, dnode not exist", pCreate->dnodeId); terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; return -1; } @@ -241,7 +266,7 @@ static int32_t mndProcessCreateBnodeReq(SMnodeMsg *pMsg) { mndReleaseDnode(pMnode, pDnode); if (code != 0) { - mError("snode:%d, failed to create since %s", pCreate->dnodeId, terrstr()); + mError("bnode:%d, failed to create since %s", pCreate->dnodeId, terrstr()); return -1; } @@ -290,11 +315,11 @@ static int32_t mndDropBnode(SMnode *pMnode, SMnodeMsg *pMsg, SBnodeObj *pObj) { int32_t code = -1; STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, &pMsg->rpcMsg); if (pTrans == NULL) { - mError("snode:%d, failed to drop since %s", pObj->id, terrstr()); + mError("bnode:%d, failed to drop since %s", pObj->id, terrstr()); goto DROP_BNODE_OVER; } - mDebug("trans:%d, used to drop snode:%d", pTrans->id, pObj->id); + mDebug("trans:%d, used to drop bnode:%d", pTrans->id, pObj->id); if (mndSetDropBnodeRedoLogs(pTrans, pObj) != 0) { mError("trans:%d, failed to set redo log since %s", pTrans->id, terrstr()); @@ -328,24 +353,24 @@ static int32_t mndProcessDropBnodeReq(SMnodeMsg *pMsg) { SMDropBnodeMsg *pDrop = pMsg->rpcMsg.pCont; pDrop->dnodeId = htonl(pDrop->dnodeId); - mDebug("snode:%d, start to drop", pDrop->dnodeId); + mDebug("bnode:%d, start to drop", pDrop->dnodeId); if (pDrop->dnodeId <= 0) { terrno = TSDB_CODE_SDB_APP_ERROR; - mError("snode:%d, failed to drop since %s", pDrop->dnodeId, terrstr()); + mError("bnode:%d, failed to drop since %s", pDrop->dnodeId, terrstr()); return -1; } SBnodeObj *pObj = mndAcquireBnode(pMnode, pDrop->dnodeId); if (pObj == NULL) { - mError("snode:%d, not exist", pDrop->dnodeId); - terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; + mError("bnode:%d, not exist", pDrop->dnodeId); + terrno = TSDB_CODE_MND_BNODE_NOT_EXIST; return -1; } int32_t code = mndDropBnode(pMnode, pMsg, pObj); if (code != 0) { - mError("snode:%d, failed to drop since %s", pMnode->dnodeId, terrstr()); + mError("bnode:%d, failed to drop since %s", pMnode->dnodeId, terrstr()); return -1; } diff --git a/source/dnode/mnode/impl/src/mndCluster.c b/source/dnode/mnode/impl/src/mndCluster.c index f656c27dcd224db8cb6c80dee9e609c40668ef88..00cfa6b4132c7ffe771f3c511dbbbbe564af6ce1 100644 --- a/source/dnode/mnode/impl/src/mndCluster.c +++ b/source/dnode/mnode/impl/src/mndCluster.c @@ -33,7 +33,7 @@ static void mndCancelGetNextCluster(SMnode *pMnode, void *pIter); int32_t mndInitCluster(SMnode *pMnode) { SSdbTable table = {.sdbType = SDB_CLUSTER, - .keyType = SDB_KEY_INT32, + .keyType = SDB_KEY_INT64, .deployFp = (SdbDeployFp)mndCreateDefaultCluster, .encodeFp = (SdbEncodeFp)mndClusterActionEncode, .decodeFp = (SdbDecodeFp)mndClusterActionDecode, @@ -63,55 +63,80 @@ int32_t mndGetClusterName(SMnode *pMnode, char *clusterName, int32_t len) { } static SSdbRaw *mndClusterActionEncode(SClusterObj *pCluster) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + SSdbRaw *pRaw = sdbAllocRaw(SDB_CLUSTER, TSDB_CLUSTER_VER_NUMBE, sizeof(SClusterObj) + TSDB_CLUSTER_RESERVE_SIZE); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto CLUSTER_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_INT64(pRaw, dataPos, pCluster->id); - SDB_SET_INT64(pRaw, dataPos, pCluster->createdTime) - SDB_SET_INT64(pRaw, dataPos, pCluster->updateTime) - SDB_SET_BINARY(pRaw, dataPos, pCluster->name, TSDB_CLUSTER_ID_LEN) - SDB_SET_RESERVE(pRaw, dataPos, TSDB_CLUSTER_RESERVE_SIZE) + SDB_SET_INT64(pRaw, dataPos, pCluster->id, CLUSTER_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pCluster->createdTime, CLUSTER_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pCluster->updateTime, CLUSTER_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pCluster->name, TSDB_CLUSTER_ID_LEN, CLUSTER_ENCODE_OVER) + SDB_SET_RESERVE(pRaw, dataPos, TSDB_CLUSTER_RESERVE_SIZE, CLUSTER_ENCODE_OVER) + + terrno = 0; + +CLUSTER_ENCODE_OVER: + if (terrno != 0) { + mError("cluster:%" PRId64 ", failed to encode to raw:%p since %s", pCluster->id, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + mTrace("cluster:%" PRId64 ", encode to raw:%p, row:%p", pCluster->id, pRaw, pCluster); return pRaw; } static SSdbRow *mndClusterActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto CLUSTER_DECODE_OVER; if (sver != TSDB_CLUSTER_VER_NUMBE) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - mError("failed to decode cluster since %s", terrstr()); - return NULL; + goto CLUSTER_DECODE_OVER; } - SSdbRow *pRow = sdbAllocRow(sizeof(SClusterObj)); + SSdbRow *pRow = sdbAllocRow(sizeof(SClusterObj)); + if (pRow == NULL) goto CLUSTER_DECODE_OVER; + SClusterObj *pCluster = sdbGetRowObj(pRow); - if (pCluster == NULL) return NULL; + if (pCluster == NULL) goto CLUSTER_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_INT64(pRaw, pRow, dataPos, &pCluster->id) - SDB_GET_INT64(pRaw, pRow, dataPos, &pCluster->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pCluster->updateTime) - SDB_GET_BINARY(pRaw, pRow, dataPos, pCluster->name, TSDB_CLUSTER_ID_LEN) - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_CLUSTER_RESERVE_SIZE) + SDB_GET_INT64(pRaw, dataPos, &pCluster->id, CLUSTER_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pCluster->createdTime, CLUSTER_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pCluster->updateTime, CLUSTER_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pCluster->name, TSDB_CLUSTER_ID_LEN, CLUSTER_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_CLUSTER_RESERVE_SIZE, CLUSTER_DECODE_OVER) + + terrno = 0; + +CLUSTER_DECODE_OVER: + if (terrno != 0) { + mError("cluster:%" PRId64 ", failed to decode from raw:%p since %s", pCluster->id, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + mTrace("cluster:%" PRId64 ", decode from raw:%p, row:%p", pCluster->id, pRaw, pCluster); return pRow; } static int32_t mndClusterActionInsert(SSdb *pSdb, SClusterObj *pCluster) { - mTrace("cluster:%" PRId64 ", perform insert action", pCluster->id); + mTrace("cluster:%" PRId64 ", perform insert action, row:%p", pCluster->id, pCluster); return 0; } static int32_t mndClusterActionDelete(SSdb *pSdb, SClusterObj *pCluster) { - mTrace("cluster:%" PRId64 ", perform delete action", pCluster->id); + mTrace("cluster:%" PRId64 ", perform delete action, row:%p", pCluster->id, pCluster); return 0; } -static int32_t mndClusterActionUpdate(SSdb *pSdb, SClusterObj *pOldCluster, SClusterObj *pNewCluster) { - mTrace("cluster:%" PRId64 ", perform update action", pOldCluster->id); +static int32_t mndClusterActionUpdate(SSdb *pSdb, SClusterObj *pOld, SClusterObj *pNew) { + mTrace("cluster:%" PRId64 ", perform update action, old_row:%p new_row:%p", pOld->id, pOld, pNew); return 0; } @@ -124,18 +149,18 @@ static int32_t mndCreateDefaultCluster(SMnode *pMnode) { if (code != 0) { strcpy(clusterObj.name, "tdengine2.0"); mError("failed to get name from system, set to default val %s", clusterObj.name); - } else { - mDebug("cluster:%" PRId64 ", name is %s", clusterObj.id, clusterObj.name); } - clusterObj.id = MurmurHash3_32(clusterObj.name, TSDB_CLUSTER_ID_LEN); + + clusterObj.id = mndGenerateUid(clusterObj.name, TSDB_CLUSTER_ID_LEN); clusterObj.id = (clusterObj.id >= 0 ? clusterObj.id : -clusterObj.id); pMnode->clusterId = clusterObj.id; + mDebug("cluster:%" PRId64 ", name is %s", clusterObj.id, clusterObj.name); SSdbRaw *pRaw = mndClusterActionEncode(&clusterObj); if (pRaw == NULL) return -1; sdbSetRawStatus(pRaw, SDB_STATUS_READY); - mDebug("cluster:%" PRId64 ", will be created while deploy sdb", clusterObj.id); + mDebug("cluster:%" PRId64 ", will be created while deploy sdb, raw:%p", clusterObj.id, pRaw); return sdbWrite(pMnode->pSdb, pRaw); } diff --git a/source/dnode/mnode/impl/src/mndConsumer.c b/source/dnode/mnode/impl/src/mndConsumer.c index 9e7cdbf09e17a2836c948713c5f0222347ee0aeb..32a044fe09dad2674b352317aab0db7ff69c4b46 100644 --- a/source/dnode/mnode/impl/src/mndConsumer.c +++ b/source/dnode/mnode/impl/src/mndConsumer.c @@ -67,66 +67,87 @@ int32_t mndInitConsumer(SMnode *pMnode) { void mndCleanupConsumer(SMnode *pMnode) {} static SSdbRaw *mndConsumerActionEncode(SConsumerObj *pConsumer) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int32_t size = sizeof(SConsumerObj) + MND_CONSUMER_RESERVE_SIZE; SSdbRaw *pRaw = sdbAllocRaw(SDB_CONSUMER, MND_CONSUMER_VER_NUMBER, size); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto CM_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_BINARY(pRaw, dataPos, pConsumer->name, TSDB_TABLE_FNAME_LEN); - SDB_SET_BINARY(pRaw, dataPos, pConsumer->db, TSDB_DB_FNAME_LEN); - SDB_SET_INT64(pRaw, dataPos, pConsumer->createTime); - SDB_SET_INT64(pRaw, dataPos, pConsumer->updateTime); - SDB_SET_INT64(pRaw, dataPos, pConsumer->uid); + SDB_SET_BINARY(pRaw, dataPos, pConsumer->name, TSDB_TABLE_FNAME_LEN, CM_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pConsumer->db, TSDB_DB_FNAME_LEN, CM_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pConsumer->createTime, CM_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pConsumer->updateTime, CM_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pConsumer->uid, CM_ENCODE_OVER) /*SDB_SET_INT64(pRaw, dataPos, pConsumer->dbUid);*/ - SDB_SET_INT32(pRaw, dataPos, pConsumer->version); + SDB_SET_INT32(pRaw, dataPos, pConsumer->version, CM_ENCODE_OVER) - SDB_SET_RESERVE(pRaw, dataPos, MND_CONSUMER_RESERVE_SIZE); - SDB_SET_DATALEN(pRaw, dataPos); + SDB_SET_RESERVE(pRaw, dataPos, MND_CONSUMER_RESERVE_SIZE, CM_ENCODE_OVER) + SDB_SET_DATALEN(pRaw, dataPos, CM_ENCODE_OVER) +CM_ENCODE_OVER: + if (terrno != 0) { + mError("consumer:%s, failed to encode to raw:%p since %s", pConsumer->name, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + + mTrace("consumer:%s, encode to raw:%p, row:%p", pConsumer->name, pRaw, pConsumer); return pRaw; } static SSdbRow *mndConsumerActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto CONSUME_DECODE_OVER; if (sver != MND_CONSUMER_VER_NUMBER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - mError("failed to decode consumer since %s", terrstr()); - return NULL; + goto CONSUME_DECODE_OVER; } - int32_t size = sizeof(SConsumerObj) + TSDB_MAX_COLUMNS * sizeof(SSchema); - SSdbRow *pRow = sdbAllocRow(size); + int32_t size = sizeof(SConsumerObj) + TSDB_MAX_COLUMNS * sizeof(SSchema); + SSdbRow *pRow = sdbAllocRow(size); + if (pRow == NULL) goto CONSUME_DECODE_OVER; + SConsumerObj *pConsumer = sdbGetRowObj(pRow); - if (pConsumer == NULL) return NULL; + if (pConsumer == NULL) goto CONSUME_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_BINARY(pRaw, pRow, dataPos, pConsumer->name, TSDB_TABLE_FNAME_LEN); - SDB_GET_BINARY(pRaw, pRow, dataPos, pConsumer->db, TSDB_DB_FNAME_LEN); - SDB_GET_INT64(pRaw, pRow, dataPos, &pConsumer->createTime); - SDB_GET_INT64(pRaw, pRow, dataPos, &pConsumer->updateTime); - SDB_GET_INT64(pRaw, pRow, dataPos, &pConsumer->uid); + SDB_GET_BINARY(pRaw, dataPos, pConsumer->name, TSDB_TABLE_FNAME_LEN, CONSUME_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pConsumer->db, TSDB_DB_FNAME_LEN, CONSUME_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pConsumer->createTime, CONSUME_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pConsumer->updateTime, CONSUME_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pConsumer->uid, CONSUME_DECODE_OVER) /*SDB_GET_INT64(pRaw, pRow, dataPos, &pConsumer->dbUid);*/ - SDB_GET_INT32(pRaw, pRow, dataPos, &pConsumer->version); - - SDB_GET_RESERVE(pRaw, pRow, dataPos, MND_CONSUMER_RESERVE_SIZE); + SDB_GET_INT32(pRaw, dataPos, &pConsumer->version, CONSUME_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, MND_CONSUMER_RESERVE_SIZE, CONSUME_DECODE_OVER) + terrno = 0; + +CONSUME_DECODE_OVER: + if (terrno != 0) { + mError("consumer:%s, failed to decode from raw:%p since %s", pConsumer->name, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + mTrace("consumer:%s, decode from raw:%p, row:%p", pConsumer->name, pRaw, pConsumer); return pRow; } static int32_t mndConsumerActionInsert(SSdb *pSdb, SConsumerObj *pConsumer) { - mTrace("consumer:%s, perform insert action", pConsumer->name); + mTrace("consumer:%s, perform insert action, row:%p", pConsumer->name, pConsumer); return 0; } static int32_t mndConsumerActionDelete(SSdb *pSdb, SConsumerObj *pConsumer) { - mTrace("consumer:%s, perform delete action", pConsumer->name); + mTrace("consumer:%s, perform delete action, row:%p", pConsumer->name, pConsumer); return 0; } static int32_t mndConsumerActionUpdate(SSdb *pSdb, SConsumerObj *pOldConsumer, SConsumerObj *pNewConsumer) { - mTrace("consumer:%s, perform update action", pOldConsumer->name); + mTrace("consumer:%s, perform update action, old_row:%p new_row:%p", pOldConsumer->name, pOldConsumer, pNewConsumer); atomic_exchange_32(&pOldConsumer->updateTime, pNewConsumer->updateTime); atomic_exchange_32(&pOldConsumer->version, pNewConsumer->version); diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c index f9199f9eed0f65bbb2bbd9e10471bd288723be92..410368f13060609cc365e446860c989437addad1 100644 --- a/source/dnode/mnode/impl/src/mndDb.c +++ b/source/dnode/mnode/impl/src/mndDb.c @@ -65,100 +65,125 @@ int32_t mndInitDb(SMnode *pMnode) { void mndCleanupDb(SMnode *pMnode) {} static SSdbRaw *mndDbActionEncode(SDbObj *pDb) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, TSDB_DB_VER_NUMBER, sizeof(SDbObj) + TSDB_DB_RESERVE_SIZE); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto DB_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN) - SDB_SET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN) - SDB_SET_INT64(pRaw, dataPos, pDb->createdTime) - SDB_SET_INT64(pRaw, dataPos, pDb->updateTime) - SDB_SET_INT64(pRaw, dataPos, pDb->uid) - SDB_SET_INT32(pRaw, dataPos, pDb->cfgVersion) - SDB_SET_INT32(pRaw, dataPos, pDb->vgVersion) - SDB_SET_INT8(pRaw, dataPos, pDb->hashMethod) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfVgroups) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.cacheBlockSize) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.totalBlocks) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysPerFile) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep0) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep1) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep2) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.minRows) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.maxRows) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.commitTime) - SDB_SET_INT32(pRaw, dataPos, pDb->cfg.fsyncPeriod) - SDB_SET_INT8(pRaw, dataPos, pDb->cfg.walLevel) - SDB_SET_INT8(pRaw, dataPos, pDb->cfg.precision) - SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compression) - SDB_SET_INT8(pRaw, dataPos, pDb->cfg.replications) - SDB_SET_INT8(pRaw, dataPos, pDb->cfg.quorum) - SDB_SET_INT8(pRaw, dataPos, pDb->cfg.update) - SDB_SET_INT8(pRaw, dataPos, pDb->cfg.cacheLastRow) - SDB_SET_RESERVE(pRaw, dataPos, TSDB_DB_RESERVE_SIZE) - SDB_SET_DATALEN(pRaw, dataPos); + SDB_SET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, DB_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, DB_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pDb->createdTime, DB_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pDb->updateTime, DB_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pDb->uid, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfgVersion, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->vgVersion, DB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pDb->hashMethod, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfVgroups, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.cacheBlockSize, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.totalBlocks, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysPerFile, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep0, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep1, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep2, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.minRows, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.maxRows, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.commitTime, DB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pDb->cfg.fsyncPeriod, DB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pDb->cfg.walLevel, DB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pDb->cfg.precision, DB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compression, DB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pDb->cfg.replications, DB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pDb->cfg.quorum, DB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pDb->cfg.update, DB_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pDb->cfg.cacheLastRow, DB_ENCODE_OVER) + SDB_SET_RESERVE(pRaw, dataPos, TSDB_DB_RESERVE_SIZE, DB_ENCODE_OVER) + SDB_SET_DATALEN(pRaw, dataPos, DB_ENCODE_OVER) + + terrno = 0; + +DB_ENCODE_OVER: + if (terrno != 0) { + mError("db:%s, failed to encode to raw:%p since %s", pDb->name, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + mTrace("db:%s, encode to raw:%p, row:%p", pDb->name, pRaw, pDb); return pRaw; } static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto DB_DECODE_OVER; if (sver != TSDB_DB_VER_NUMBER) { - mError("failed to decode db since %s", terrstr()); terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - return NULL; + goto DB_DECODE_OVER; } SSdbRow *pRow = sdbAllocRow(sizeof(SDbObj)); - SDbObj *pDb = sdbGetRowObj(pRow); - if (pDb == NULL) return NULL; + if (pRow == NULL) goto DB_DECODE_OVER; + + SDbObj *pDb = sdbGetRowObj(pRow); + if (pDb == NULL) goto DB_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_BINARY(pRaw, pRow, dataPos, pDb->name, TSDB_DB_FNAME_LEN) - SDB_GET_BINARY(pRaw, pRow, dataPos, pDb->acct, TSDB_USER_LEN) - SDB_GET_INT64(pRaw, pRow, dataPos, &pDb->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pDb->updateTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pDb->uid) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfgVersion) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->vgVersion) - SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->hashMethod) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.numOfVgroups) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.cacheBlockSize) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.totalBlocks) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.daysPerFile) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.daysToKeep0) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.daysToKeep1) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.daysToKeep2) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.minRows) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.maxRows) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.commitTime) - SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.fsyncPeriod) - SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.walLevel) - SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.precision) - SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.compression) - SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.replications) - SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.quorum) - SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.update) - SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.cacheLastRow) - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_DB_RESERVE_SIZE) + SDB_GET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, DB_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, DB_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pDb->createdTime, DB_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pDb->updateTime, DB_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pDb->uid, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfgVersion, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->vgVersion, DB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pDb->hashMethod, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfVgroups, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.cacheBlockSize, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.totalBlocks, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysPerFile, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep0, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep1, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep2, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.minRows, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.maxRows, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.commitTime, DB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.fsyncPeriod, DB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.walLevel, DB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.precision, DB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.compression, DB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.replications, DB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.quorum, DB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.update, DB_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.cacheLastRow, DB_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_DB_RESERVE_SIZE, DB_DECODE_OVER) + + terrno = 0; + +DB_DECODE_OVER: + if (terrno != 0) { + mError("db:%s, failed to decode from raw:%p since %s", pDb->name, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + mTrace("db:%s, decode from raw:%p, row:%p", pDb->name, pRaw, pDb); return pRow; } static int32_t mndDbActionInsert(SSdb *pSdb, SDbObj *pDb) { - mTrace("db:%s, perform insert action", pDb->name); + mTrace("db:%s, perform insert action, row:%p", pDb->name, pDb); return 0; } static int32_t mndDbActionDelete(SSdb *pSdb, SDbObj *pDb) { - mTrace("db:%s, perform delete action", pDb->name); + mTrace("db:%s, perform delete action, row:%p", pDb->name, pDb); return 0; } static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOldDb, SDbObj *pNewDb) { - mTrace("db:%s, perform update action", pOldDb->name); + mTrace("db:%s, perform update action, old_row:%p new_row:%p", pOldDb->name, pOldDb, pNewDb); pOldDb->updateTime = pNewDb->updateTime; pOldDb->cfgVersion = pNewDb->cfgVersion; pOldDb->vgVersion = pNewDb->vgVersion; diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c index 1c7f8544e901f00acec1da0da00bb728e4da63ab..d11096902563357037fca69523d6b10de4289548 100644 --- a/source/dnode/mnode/impl/src/mndDnode.c +++ b/source/dnode/mnode/impl/src/mndDnode.c @@ -100,65 +100,90 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) { if (pRaw == NULL) return -1; if (sdbSetRawStatus(pRaw, SDB_STATUS_READY) != 0) return -1; - mDebug("dnode:%d, will be created while deploy sdb", dnodeObj.id); + mDebug("dnode:%d, will be created while deploy sdb, raw:%p", dnodeObj.id, pRaw); return sdbWrite(pMnode->pSdb, pRaw); } static SSdbRaw *mndDnodeActionEncode(SDnodeObj *pDnode) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + SSdbRaw *pRaw = sdbAllocRaw(SDB_DNODE, TSDB_DNODE_VER_NUMBER, sizeof(SDnodeObj) + TSDB_DNODE_RESERVE_SIZE); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto DNODE_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_INT32(pRaw, dataPos, pDnode->id); - SDB_SET_INT64(pRaw, dataPos, pDnode->createdTime) - SDB_SET_INT64(pRaw, dataPos, pDnode->updateTime) - SDB_SET_INT16(pRaw, dataPos, pDnode->port) - SDB_SET_BINARY(pRaw, dataPos, pDnode->fqdn, TSDB_FQDN_LEN) - SDB_SET_RESERVE(pRaw, dataPos, TSDB_DNODE_RESERVE_SIZE) - SDB_SET_DATALEN(pRaw, dataPos); + SDB_SET_INT32(pRaw, dataPos, pDnode->id, DNODE_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pDnode->createdTime, DNODE_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pDnode->updateTime, DNODE_ENCODE_OVER) + SDB_SET_INT16(pRaw, dataPos, pDnode->port, DNODE_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pDnode->fqdn, TSDB_FQDN_LEN, DNODE_ENCODE_OVER) + SDB_SET_RESERVE(pRaw, dataPos, TSDB_DNODE_RESERVE_SIZE, DNODE_ENCODE_OVER) + SDB_SET_DATALEN(pRaw, dataPos, DNODE_ENCODE_OVER); + + terrno = 0; + +DNODE_ENCODE_OVER: + if (terrno != 0) { + mError("dnode:%d, failed to encode to raw:%p since %s", pDnode->id, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + mTrace("dnode:%d, encode to raw:%p, row:%p", pDnode->id, pRaw, pDnode); return pRaw; } static SSdbRow *mndDnodeActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto DNODE_DECODE_OVER; if (sver != TSDB_DNODE_VER_NUMBER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - mError("failed to decode dnode since %s", terrstr()); - return NULL; + goto DNODE_DECODE_OVER; } - SSdbRow *pRow = sdbAllocRow(sizeof(SDnodeObj)); + SSdbRow *pRow = sdbAllocRow(sizeof(SDnodeObj)); + if (pRow == NULL) goto DNODE_DECODE_OVER; + SDnodeObj *pDnode = sdbGetRowObj(pRow); - if (pDnode == NULL) return NULL; + if (pDnode == NULL) goto DNODE_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &pDnode->id) - SDB_GET_INT64(pRaw, pRow, dataPos, &pDnode->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pDnode->updateTime) - SDB_GET_INT16(pRaw, pRow, dataPos, &pDnode->port) - SDB_GET_BINARY(pRaw, pRow, dataPos, pDnode->fqdn, TSDB_FQDN_LEN) - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_DNODE_RESERVE_SIZE) + SDB_GET_INT32(pRaw, dataPos, &pDnode->id, DNODE_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pDnode->createdTime, DNODE_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pDnode->updateTime, DNODE_DECODE_OVER) + SDB_GET_INT16(pRaw, dataPos, &pDnode->port, DNODE_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pDnode->fqdn, TSDB_FQDN_LEN, DNODE_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_DNODE_RESERVE_SIZE, DNODE_DECODE_OVER) + + terrno = 0; + +DNODE_DECODE_OVER: + if (terrno != 0) { + mError("dnode:%d, failed to decode from raw:%p since %s", pDnode->id, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + mTrace("dnode:%d, decode from raw:%p, row:%p", pDnode->id, pRaw, pDnode); return pRow; } static int32_t mndDnodeActionInsert(SSdb *pSdb, SDnodeObj *pDnode) { - mTrace("dnode:%d, perform insert action", pDnode->id); + mTrace("dnode:%d, perform insert action, row:%p", pDnode->id, pDnode); pDnode->offlineReason = DND_REASON_STATUS_NOT_RECEIVED; snprintf(pDnode->ep, TSDB_EP_LEN, "%s:%u", pDnode->fqdn, pDnode->port); return 0; } static int32_t mndDnodeActionDelete(SSdb *pSdb, SDnodeObj *pDnode) { - mTrace("dnode:%d, perform delete action", pDnode->id); + mTrace("dnode:%d, perform delete action, row:%p", pDnode->id, pDnode); return 0; } static int32_t mndDnodeActionUpdate(SSdb *pSdb, SDnodeObj *pOldDnode, SDnodeObj *pNewDnode) { - mTrace("dnode:%d, perform update action", pOldDnode->id); + mTrace("dnode:%d, perform update action, old_row:%p new_row:%p", pOldDnode->id, pOldDnode, pNewDnode); pOldDnode->updateTime = pNewDnode->updateTime; return 0; } diff --git a/source/dnode/mnode/impl/src/mndFunc.c b/source/dnode/mnode/impl/src/mndFunc.c index 638d984c694957611cd7a091cdd6dc915bdd4c02..f7a39ce9e5f82fb03f4a0a09b8c9eb7063e8b874 100644 --- a/source/dnode/mnode/impl/src/mndFunc.c +++ b/source/dnode/mnode/impl/src/mndFunc.c @@ -58,76 +58,101 @@ int32_t mndInitFunc(SMnode *pMnode) { void mndCleanupFunc(SMnode *pMnode) {} static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int32_t size = pFunc->commentSize + pFunc->codeSize + sizeof(SFuncObj); SSdbRaw *pRaw = sdbAllocRaw(SDB_FUNC, SDB_FUNC_VER, size); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto FUNC_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN) - SDB_SET_INT64(pRaw, dataPos, pFunc->createdTime) - SDB_SET_INT8(pRaw, dataPos, pFunc->funcType) - SDB_SET_INT8(pRaw, dataPos, pFunc->scriptType) - SDB_SET_INT8(pRaw, dataPos, pFunc->align) - SDB_SET_INT8(pRaw, dataPos, pFunc->outputType) - SDB_SET_INT32(pRaw, dataPos, pFunc->outputLen) - SDB_SET_INT32(pRaw, dataPos, pFunc->bufSize) - SDB_SET_INT64(pRaw, dataPos, pFunc->sigature) - SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize) - SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize) - SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize) - SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize) - SDB_SET_DATALEN(pRaw, dataPos); + SDB_SET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pFunc->createdTime, FUNC_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->funcType, FUNC_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->scriptType, FUNC_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->align, FUNC_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pFunc->outputType, FUNC_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->outputLen, FUNC_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->bufSize, FUNC_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pFunc->sigature, FUNC_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->commentSize, FUNC_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pFunc->codeSize, FUNC_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pFunc->pComment, pFunc->commentSize, FUNC_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pFunc->pCode, pFunc->codeSize, FUNC_ENCODE_OVER) + SDB_SET_DATALEN(pRaw, dataPos, FUNC_ENCODE_OVER); + + terrno = 0; + +FUNC_ENCODE_OVER: + if (terrno != 0) { + mError("func:%s, failed to encode to raw:%p since %s", pFunc->name, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + mTrace("func:%s, encode to raw:%p, row:%p", pFunc->name, pRaw, pFunc); return pRaw; } static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto FUNC_DECODE_OVER; if (sver != SDB_FUNC_VER) { - mError("failed to decode func since %s", terrstr()); terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - return NULL; + goto FUNC_DECODE_OVER; } - int32_t size = sizeof(SFuncObj) + TSDB_FUNC_COMMENT_LEN + TSDB_FUNC_CODE_LEN; - SSdbRow *pRow = sdbAllocRow(size); + int32_t size = sizeof(SFuncObj) + TSDB_FUNC_COMMENT_LEN + TSDB_FUNC_CODE_LEN; + SSdbRow *pRow = sdbAllocRow(size); + if (pRow == NULL) goto FUNC_DECODE_OVER; + SFuncObj *pFunc = sdbGetRowObj(pRow); - if (pFunc == NULL) return NULL; + if (pFunc == NULL) goto FUNC_DECODE_OVER; char *tmp = (char *)pFunc + sizeof(SFuncObj); int32_t dataPos = 0; - SDB_GET_BINARY(pRaw, pRow, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN) - SDB_GET_INT64(pRaw, pRow, dataPos, &pFunc->createdTime) - SDB_GET_INT8(pRaw, pRow, dataPos, &pFunc->funcType) - SDB_GET_INT8(pRaw, pRow, dataPos, &pFunc->scriptType) - SDB_GET_INT8(pRaw, pRow, dataPos, &pFunc->align) - SDB_GET_INT8(pRaw, pRow, dataPos, &pFunc->outputType) - SDB_GET_INT32(pRaw, pRow, dataPos, &pFunc->outputLen) - SDB_GET_INT32(pRaw, pRow, dataPos, &pFunc->bufSize) - SDB_GET_INT64(pRaw, pRow, dataPos, &pFunc->sigature) - SDB_GET_INT32(pRaw, pRow, dataPos, &pFunc->commentSize) - SDB_GET_INT32(pRaw, pRow, dataPos, &pFunc->codeSize) - SDB_GET_BINARY(pRaw, pRow, dataPos, pFunc->pData, pFunc->commentSize + pFunc->codeSize) + SDB_GET_BINARY(pRaw, dataPos, pFunc->name, TSDB_FUNC_NAME_LEN, FUNC_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pFunc->createdTime, FUNC_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->funcType, FUNC_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->scriptType, FUNC_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->align, FUNC_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pFunc->outputType, FUNC_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->outputLen, FUNC_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->bufSize, FUNC_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pFunc->sigature, FUNC_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->commentSize, FUNC_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pFunc->codeSize, FUNC_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pFunc->pData, pFunc->commentSize + pFunc->codeSize, FUNC_DECODE_OVER) pFunc->pComment = pFunc->pData; pFunc->pCode = (pFunc->pData + pFunc->commentSize); + terrno = 0; + +FUNC_DECODE_OVER: + if (terrno != 0) { + mError("func:%s, failed to decode from raw:%p since %s", pFunc->name, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + + mTrace("func:%s, decode from raw:%p, row:%p", pFunc->name, pRaw, pFunc); return pRow; } static int32_t mndFuncActionInsert(SSdb *pSdb, SFuncObj *pFunc) { - mTrace("func:%s, perform insert action", pFunc->name); + mTrace("func:%s, perform insert action, row:%p", pFunc->name, pFunc); return 0; } static int32_t mndFuncActionDelete(SSdb *pSdb, SFuncObj *pFunc) { - mTrace("func:%s, perform delete action", pFunc->name); + mTrace("func:%s, perform delete action, row:%p", pFunc->name, pFunc); return 0; } static int32_t mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOldFunc, SFuncObj *pNewFunc) { - mTrace("func:%s, perform update action", pOldFunc->name); + mTrace("func:%s, perform update action, old_row:%p new_row:%p", pOldFunc->name, pOldFunc, pNewFunc); return 0; } diff --git a/source/dnode/mnode/impl/src/mndMnode.c b/source/dnode/mnode/impl/src/mndMnode.c index ad3d5e1cf6811ee694bd70605e890efee9b1d223..df1848f2f1f236c4ce2e9e999d4f4d131211c727 100644 --- a/source/dnode/mnode/impl/src/mndMnode.c +++ b/source/dnode/mnode/impl/src/mndMnode.c @@ -117,50 +117,75 @@ static int32_t mndCreateDefaultMnode(SMnode *pMnode) { if (pRaw == NULL) return -1; sdbSetRawStatus(pRaw, SDB_STATUS_READY); - mDebug("mnode:%d, will be created while deploy sdb", mnodeObj.id); + mDebug("mnode:%d, will be created while deploy sdb, raw:%p", mnodeObj.id, pRaw); return sdbWrite(pMnode->pSdb, pRaw); } static SSdbRaw *mndMnodeActionEncode(SMnodeObj *pObj) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + SSdbRaw *pRaw = sdbAllocRaw(SDB_MNODE, TSDB_MNODE_VER_NUMBER, sizeof(SMnodeObj) + TSDB_MNODE_RESERVE_SIZE); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto MNODE_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_INT32(pRaw, dataPos, pObj->id); - SDB_SET_INT64(pRaw, dataPos, pObj->createdTime) - SDB_SET_INT64(pRaw, dataPos, pObj->updateTime) - SDB_SET_RESERVE(pRaw, dataPos, TSDB_MNODE_RESERVE_SIZE) + SDB_SET_INT32(pRaw, dataPos, pObj->id, MNODE_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pObj->createdTime, MNODE_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pObj->updateTime, MNODE_ENCODE_OVER) + SDB_SET_RESERVE(pRaw, dataPos, TSDB_MNODE_RESERVE_SIZE, MNODE_ENCODE_OVER) + + terrno = 0; + +MNODE_ENCODE_OVER: + if (terrno != 0) { + mError("mnode:%d, failed to encode to raw:%p since %s", pObj->id, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + mTrace("mnode:%d, encode to raw:%p, row:%p", pObj->id, pRaw, pObj); return pRaw; } static SSdbRow *mndMnodeActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; if (sver != TSDB_MNODE_VER_NUMBER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - mError("failed to decode mnode since %s", terrstr()); - return NULL; + goto MNODE_DECODE_OVER; } - SSdbRow *pRow = sdbAllocRow(sizeof(SMnodeObj)); + SSdbRow *pRow = sdbAllocRow(sizeof(SMnodeObj)); + if (pRow == NULL) goto MNODE_DECODE_OVER; + SMnodeObj *pObj = sdbGetRowObj(pRow); - if (pObj == NULL) return NULL; + if (pObj == NULL) goto MNODE_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &pObj->id) - SDB_GET_INT64(pRaw, pRow, dataPos, &pObj->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pObj->updateTime) - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_MNODE_RESERVE_SIZE) + SDB_GET_INT32(pRaw, dataPos, &pObj->id, MNODE_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pObj->createdTime, MNODE_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pObj->updateTime, MNODE_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_MNODE_RESERVE_SIZE, MNODE_DECODE_OVER) + + terrno = 0; + +MNODE_DECODE_OVER: + if (terrno != 0) { + mError("mnode:%d, failed to decode from raw:%p since %s", pObj->id, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + mTrace("mnode:%d, decode from raw:%p, row:%p", pObj->id, pRaw, pObj); return pRow; } static void mnodeResetMnode(SMnodeObj *pObj) { pObj->role = TAOS_SYNC_STATE_FOLLOWER; } static int32_t mndMnodeActionInsert(SSdb *pSdb, SMnodeObj *pObj) { - mTrace("mnode:%d, perform insert action", pObj->id); + mTrace("mnode:%d, perform insert action, row:%p", pObj->id, pObj); pObj->pDnode = sdbAcquire(pSdb, SDB_DNODE, &pObj->id); if (pObj->pDnode == NULL) { terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; @@ -173,7 +198,7 @@ static int32_t mndMnodeActionInsert(SSdb *pSdb, SMnodeObj *pObj) { } static int32_t mndMnodeActionDelete(SSdb *pSdb, SMnodeObj *pObj) { - mTrace("mnode:%d, perform delete action", pObj->id); + mTrace("mnode:%d, perform delete action, row:%p", pObj->id, pObj); if (pObj->pDnode != NULL) { sdbRelease(pSdb, pObj->pDnode); pObj->pDnode = NULL; @@ -183,7 +208,7 @@ static int32_t mndMnodeActionDelete(SSdb *pSdb, SMnodeObj *pObj) { } static int32_t mndMnodeActionUpdate(SSdb *pSdb, SMnodeObj *pOldMnode, SMnodeObj *pNewMnode) { - mTrace("mnode:%d, perform update action", pOldMnode->id); + mTrace("mnode:%d, perform update action, old_row:%p new_row:%p", pOldMnode->id, pOldMnode, pNewMnode); pOldMnode->updateTime = pNewMnode->updateTime; return 0; } @@ -370,7 +395,7 @@ CREATE_MNODE_OVER: } static int32_t mndProcessCreateMnodeReq(SMnodeMsg *pMsg) { - SMnode *pMnode = pMsg->pMnode; + SMnode *pMnode = pMsg->pMnode; SMCreateMnodeMsg *pCreate = pMsg->rpcMsg.pCont; pCreate->dnodeId = htonl(pCreate->dnodeId); @@ -537,7 +562,7 @@ DROP_MNODE_OVER: } static int32_t mndProcessDropMnodeReq(SMnodeMsg *pMsg) { - SMnode *pMnode = pMsg->pMnode; + SMnode *pMnode = pMsg->pMnode; SMDropMnodeMsg *pDrop = pMsg->rpcMsg.pCont; pDrop->dnodeId = htonl(pDrop->dnodeId); diff --git a/source/dnode/mnode/impl/src/mndQnode.c b/source/dnode/mnode/impl/src/mndQnode.c index 3b27764c7cae6a5bf70a5cc7aba1dba3d7a55064..a0c4ff8218df144b60a56b287245288c5d7c8993 100644 --- a/source/dnode/mnode/impl/src/mndQnode.c +++ b/source/dnode/mnode/impl/src/mndQnode.c @@ -73,43 +73,68 @@ static void mndReleaseQnode(SMnode *pMnode, SQnodeObj *pObj) { } static SSdbRaw *mndQnodeActionEncode(SQnodeObj *pObj) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + SSdbRaw *pRaw = sdbAllocRaw(SDB_QNODE, TSDB_QNODE_VER_NUMBER, sizeof(SQnodeObj) + TSDB_QNODE_RESERVE_SIZE); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto QNODE_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_INT32(pRaw, dataPos, pObj->id); - SDB_SET_INT64(pRaw, dataPos, pObj->createdTime) - SDB_SET_INT64(pRaw, dataPos, pObj->updateTime) - SDB_SET_RESERVE(pRaw, dataPos, TSDB_QNODE_RESERVE_SIZE) + SDB_SET_INT32(pRaw, dataPos, pObj->id, QNODE_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pObj->createdTime, QNODE_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pObj->updateTime, QNODE_ENCODE_OVER) + SDB_SET_RESERVE(pRaw, dataPos, TSDB_QNODE_RESERVE_SIZE, QNODE_ENCODE_OVER) + + terrno = 0; +QNODE_ENCODE_OVER: + if (terrno != 0) { + mError("qnode:%d, failed to encode to raw:%p since %s", pObj->id, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + + mTrace("qnode:%d, encode to raw:%p, row:%p", pObj->id, pRaw, pObj); return pRaw; } static SSdbRow *mndQnodeActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto QNODE_DECODE_OVER; if (sver != TSDB_QNODE_VER_NUMBER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - mError("failed to decode qnode since %s", terrstr()); - return NULL; + goto QNODE_DECODE_OVER; } - SSdbRow *pRow = sdbAllocRow(sizeof(SQnodeObj)); + SSdbRow *pRow = sdbAllocRow(sizeof(SQnodeObj)); + if (pRow == NULL) goto QNODE_DECODE_OVER; + SQnodeObj *pObj = sdbGetRowObj(pRow); - if (pObj == NULL) return NULL; + if (pObj == NULL) goto QNODE_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &pObj->id) - SDB_GET_INT64(pRaw, pRow, dataPos, &pObj->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pObj->updateTime) - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_QNODE_RESERVE_SIZE) + SDB_GET_INT32(pRaw, dataPos, &pObj->id, QNODE_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pObj->createdTime, QNODE_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pObj->updateTime, QNODE_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_QNODE_RESERVE_SIZE, QNODE_DECODE_OVER) + + terrno = 0; +QNODE_DECODE_OVER: + if (terrno != 0) { + mError("qnode:%d, failed to decode from raw:%p since %s", pObj->id, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + + mTrace("qnode:%d, decode from raw:%p, row:%p", pObj->id, pRaw, pObj); return pRow; } static int32_t mndQnodeActionInsert(SSdb *pSdb, SQnodeObj *pObj) { - mTrace("qnode:%d, perform insert action", pObj->id); + mTrace("qnode:%d, perform insert action, row:%p", pObj->id, pObj); pObj->pDnode = sdbAcquire(pSdb, SDB_DNODE, &pObj->id); if (pObj->pDnode == NULL) { terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; @@ -121,7 +146,7 @@ static int32_t mndQnodeActionInsert(SSdb *pSdb, SQnodeObj *pObj) { } static int32_t mndQnodeActionDelete(SSdb *pSdb, SQnodeObj *pObj) { - mTrace("qnode:%d, perform delete action", pObj->id); + mTrace("qnode:%d, perform delete action, row:%p", pObj->id, pObj); if (pObj->pDnode != NULL) { sdbRelease(pSdb, pObj->pDnode); pObj->pDnode = NULL; @@ -131,7 +156,7 @@ static int32_t mndQnodeActionDelete(SSdb *pSdb, SQnodeObj *pObj) { } static int32_t mndQnodeActionUpdate(SSdb *pSdb, SQnodeObj *pOldQnode, SQnodeObj *pNewQnode) { - mTrace("qnode:%d, perform update action", pOldQnode->id); + mTrace("qnode:%d, perform update action, old_row:%p new_row:%p", pOldQnode->id, pOldQnode, pNewQnode); pOldQnode->updateTime = pNewQnode->updateTime; return 0; } @@ -339,7 +364,7 @@ static int32_t mndProcessDropQnodeReq(SMnodeMsg *pMsg) { SQnodeObj *pObj = mndAcquireQnode(pMnode, pDrop->dnodeId); if (pObj == NULL) { mError("qnode:%d, not exist", pDrop->dnodeId); - terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; + terrno = TSDB_CODE_MND_QNODE_NOT_EXIST; return -1; } diff --git a/source/dnode/mnode/impl/src/mndShow.c b/source/dnode/mnode/impl/src/mndShow.c index d4b4459176330c1b8ff55ee98c89796e1f430f67..c156c87123799c840b568149e2e7322573f82b2a 100644 --- a/source/dnode/mnode/impl/src/mndShow.c +++ b/source/dnode/mnode/impl/src/mndShow.c @@ -68,11 +68,11 @@ static SShowObj *mndCreateShowObj(SMnode *pMnode, SShowMsg *pMsg) { SShowObj *pShow = taosCachePut(pMgmt->cache, &showId, sizeof(int64_t), &showObj, size, keepTime); if (pShow == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - mError("show:0x%"PRIx64", failed to put into cache since %s", showId, terrstr()); + mError("show:0x%" PRIx64 ", failed to put into cache since %s", showId, terrstr()); return NULL; } - mTrace("show:0x%"PRIx64", is created, data:%p", showId, pShow); + mTrace("show:0x%" PRIx64 ", is created, data:%p", showId, pShow); return pShow; } @@ -87,7 +87,7 @@ static void mndFreeShowObj(SShowObj *pShow) { } } - mTrace("show:0x%d, is destroyed, data:%p", pShow->id, pShow); + mTrace("show:0x%" PRIx64 ", is destroyed, data:%p", pShow->id, pShow); } static SShowObj *mndAcquireShowObj(SMnode *pMnode, int64_t showId) { @@ -95,17 +95,17 @@ static SShowObj *mndAcquireShowObj(SMnode *pMnode, int64_t showId) { SShowObj *pShow = taosCacheAcquireByKey(pMgmt->cache, &showId, sizeof(showId)); if (pShow == NULL) { - mError("show:0x%"PRIx64", already destroyed", showId); + mError("show:0x%" PRIx64 ", already destroyed", showId); return NULL; } - mTrace("show:0x%"PRIx64", acquired from cache, data:%p", pShow->id, pShow); + mTrace("show:0x%" PRIx64 ", acquired from cache, data:%p", pShow->id, pShow); return pShow; } static void mndReleaseShowObj(SShowObj *pShow, bool forceRemove) { if (pShow == NULL) return; - mTrace("show:0x%"PRIx64", released from cache, data:%p force:%d", pShow->id, pShow, forceRemove); + mTrace("show:0x%" PRIx64 ", released from cache, data:%p force:%d", pShow->id, pShow, forceRemove); // A bug in tcache.c forceRemove = 0; @@ -146,18 +146,19 @@ static int32_t mndProcessShowMsg(SMnodeMsg *pMnodeMsg) { if (pRsp == NULL) { mndReleaseShowObj(pShow, true); terrno = TSDB_CODE_OUT_OF_MEMORY; - mError("show:0x%"PRIx64", failed to process show-meta msg:%s since malloc rsp error", pShow->id, mndShowStr(type)); + mError("show:0x%" PRIx64 ", failed to process show-meta msg:%s since malloc rsp error", pShow->id, + mndShowStr(type)); return -1; } int32_t code = (*metaFp)(pMnodeMsg, pShow, &pRsp->tableMeta); - mDebug("show:0x%"PRIx64", get meta finished, numOfRows:%d cols:%d type:%s result:%s", pShow->id, pShow->numOfRows, + mDebug("show:0x%" PRIx64 ", get meta finished, numOfRows:%d cols:%d type:%s result:%s", pShow->id, pShow->numOfRows, pShow->numOfColumns, mndShowStr(type), tstrerror(code)); if (code == TSDB_CODE_SUCCESS) { pMnodeMsg->contLen = sizeof(SShowRsp) + sizeof(SSchema) * pShow->numOfColumns; - pMnodeMsg->pCont = pRsp; - pRsp->showId = htobe64(pShow->id); + pMnodeMsg->pCont = pRsp; + pRsp->showId = htobe64(pShow->id); mndReleaseShowObj(pShow, false); return TSDB_CODE_SUCCESS; } else { @@ -175,7 +176,7 @@ static int32_t mndProcessRetrieveMsg(SMnodeMsg *pMnodeMsg) { int32_t rowsRead = 0; SRetrieveTableMsg *pRetrieve = pMnodeMsg->rpcMsg.pCont; - int64_t showId = htobe64(pRetrieve->showId); + int64_t showId = htobe64(pRetrieve->showId); SShowObj *pShow = mndAcquireShowObj(pMnode, showId); if (pShow == NULL) { @@ -188,15 +189,16 @@ static int32_t mndProcessRetrieveMsg(SMnodeMsg *pMnodeMsg) { if (retrieveFp == NULL) { mndReleaseShowObj(pShow, false); terrno = TSDB_CODE_MSG_NOT_PROCESSED; - mError("show:0x%"PRIx64", failed to retrieve data since %s", pShow->id, terrstr()); + mError("show:0x%" PRIx64 ", failed to retrieve data since %s", pShow->id, terrstr()); return -1; } - mDebug("show:0x%"PRIx64", start retrieve data, numOfReads:%d numOfRows:%d type:%s", pShow->id, pShow->numOfReads, + mDebug("show:0x%" PRIx64 ", start retrieve data, numOfReads:%d numOfRows:%d type:%s", pShow->id, pShow->numOfReads, pShow->numOfRows, mndShowStr(pShow->type)); if (mndCheckRetrieveFinished(pShow)) { - mDebug("show:0x%"PRIx64", read finished, numOfReads:%d numOfRows:%d", pShow->id, pShow->numOfReads, pShow->numOfRows); + mDebug("show:0x%" PRIx64 ", read finished, numOfReads:%d numOfRows:%d", pShow->id, pShow->numOfReads, + pShow->numOfRows); pShow->numOfReads = pShow->numOfRows; } @@ -219,7 +221,7 @@ static int32_t mndProcessRetrieveMsg(SMnodeMsg *pMnodeMsg) { if (pRsp == NULL) { mndReleaseShowObj(pShow, false); terrno = TSDB_CODE_OUT_OF_MEMORY; - mError("show:0x%"PRIx64", failed to retrieve data since %s", pShow->id, terrstr()); + mError("show:0x%" PRIx64 ", failed to retrieve data since %s", pShow->id, terrstr()); return -1; } @@ -228,7 +230,7 @@ static int32_t mndProcessRetrieveMsg(SMnodeMsg *pMnodeMsg) { rowsRead = (*retrieveFp)(pMnodeMsg, pShow, pRsp->data, rowsToRead); } - mDebug("show:0x%"PRIx64", stop retrieve data, rowsRead:%d rowsToRead:%d", pShow->id, rowsRead, rowsToRead); + mDebug("show:0x%" PRIx64 ", stop retrieve data, rowsRead:%d rowsToRead:%d", pShow->id, rowsRead, rowsToRead); pRsp->numOfRows = htonl(rowsRead); pRsp->precision = TSDB_TIME_PRECISION_MILLI; // millisecond time precision @@ -238,10 +240,10 @@ static int32_t mndProcessRetrieveMsg(SMnodeMsg *pMnodeMsg) { if (rowsRead == 0 || rowsToRead == 0 || (rowsRead == rowsToRead && pShow->numOfRows == pShow->numOfReads)) { pRsp->completed = 1; - mDebug("show:0x%"PRIx64", retrieve completed", pShow->id); + mDebug("show:0x%" PRIx64 ", retrieve completed", pShow->id); mndReleaseShowObj(pShow, true); } else { - mDebug("show:0x%"PRIx64", retrieve not completed yet", pShow->id); + mDebug("show:0x%" PRIx64 ", retrieve not completed yet", pShow->id); mndReleaseShowObj(pShow, false); } diff --git a/source/dnode/mnode/impl/src/mndSnode.c b/source/dnode/mnode/impl/src/mndSnode.c index a4825c0e82d98cf47544f1795991f32294689b7b..ac03e1659cb041f3743af4813dd08f954cdeccd6 100644 --- a/source/dnode/mnode/impl/src/mndSnode.c +++ b/source/dnode/mnode/impl/src/mndSnode.c @@ -73,43 +73,68 @@ static void mndReleaseSnode(SMnode *pMnode, SSnodeObj *pObj) { } static SSdbRaw *mndSnodeActionEncode(SSnodeObj *pObj) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + SSdbRaw *pRaw = sdbAllocRaw(SDB_SNODE, TSDB_SNODE_VER_NUMBER, sizeof(SSnodeObj) + TSDB_SNODE_RESERVE_SIZE); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto SNODE_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_INT32(pRaw, dataPos, pObj->id); - SDB_SET_INT64(pRaw, dataPos, pObj->createdTime) - SDB_SET_INT64(pRaw, dataPos, pObj->updateTime) - SDB_SET_RESERVE(pRaw, dataPos, TSDB_SNODE_RESERVE_SIZE) + SDB_SET_INT32(pRaw, dataPos, pObj->id, SNODE_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pObj->createdTime, SNODE_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pObj->updateTime, SNODE_ENCODE_OVER) + SDB_SET_RESERVE(pRaw, dataPos, TSDB_SNODE_RESERVE_SIZE, SNODE_ENCODE_OVER) + + terrno = 0; +SNODE_ENCODE_OVER: + if (terrno != 0) { + mError("snode:%d, failed to encode to raw:%p since %s", pObj->id, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + + mTrace("snode:%d, encode to raw:%p, row:%p", pObj->id, pRaw, pObj); return pRaw; } static SSdbRow *mndSnodeActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto SNODE_DECODE_OVER; if (sver != TSDB_SNODE_VER_NUMBER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - mError("failed to decode snode since %s", terrstr()); - return NULL; + goto SNODE_DECODE_OVER; } - SSdbRow *pRow = sdbAllocRow(sizeof(SSnodeObj)); + SSdbRow *pRow = sdbAllocRow(sizeof(SSnodeObj)); + if (pRow == NULL) goto SNODE_DECODE_OVER; + SSnodeObj *pObj = sdbGetRowObj(pRow); - if (pObj == NULL) return NULL; + if (pObj == NULL) goto SNODE_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &pObj->id) - SDB_GET_INT64(pRaw, pRow, dataPos, &pObj->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pObj->updateTime) - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_SNODE_RESERVE_SIZE) + SDB_GET_INT32(pRaw, dataPos, &pObj->id, SNODE_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pObj->createdTime, SNODE_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pObj->updateTime, SNODE_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_SNODE_RESERVE_SIZE, SNODE_DECODE_OVER) + + terrno = 0; +SNODE_DECODE_OVER: + if (terrno != 0) { + mError("snode:%d, failed to decode from raw:%p since %s", pObj->id, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + + mTrace("snode:%d, decode from raw:%p, row:%p", pObj->id, pRaw, pObj); return pRow; } static int32_t mndSnodeActionInsert(SSdb *pSdb, SSnodeObj *pObj) { - mTrace("snode:%d, perform insert action", pObj->id); + mTrace("snode:%d, perform insert action, row:%p", pObj->id, pObj); pObj->pDnode = sdbAcquire(pSdb, SDB_DNODE, &pObj->id); if (pObj->pDnode == NULL) { terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; @@ -121,7 +146,7 @@ static int32_t mndSnodeActionInsert(SSdb *pSdb, SSnodeObj *pObj) { } static int32_t mndSnodeActionDelete(SSdb *pSdb, SSnodeObj *pObj) { - mTrace("snode:%d, perform delete action", pObj->id); + mTrace("snode:%d, perform delete action, row:%p", pObj->id, pObj); if (pObj->pDnode != NULL) { sdbRelease(pSdb, pObj->pDnode); pObj->pDnode = NULL; @@ -131,7 +156,7 @@ static int32_t mndSnodeActionDelete(SSdb *pSdb, SSnodeObj *pObj) { } static int32_t mndSnodeActionUpdate(SSdb *pSdb, SSnodeObj *pOldSnode, SSnodeObj *pNewSnode) { - mTrace("snode:%d, perform update action", pOldSnode->id); + mTrace("snode:%d, perform update action, old_row:%p new_row:%p", pOldSnode->id, pOldSnode, pNewSnode); pOldSnode->updateTime = pNewSnode->updateTime; return 0; } @@ -339,7 +364,7 @@ static int32_t mndProcessDropSnodeReq(SMnodeMsg *pMsg) { SSnodeObj *pObj = mndAcquireSnode(pMnode, pDrop->dnodeId); if (pObj == NULL) { mError("snode:%d, not exist", pDrop->dnodeId); - terrno = TSDB_CODE_MND_DNODE_NOT_EXIST; + terrno = TSDB_CODE_MND_SNODE_NOT_EXIST; return -1; } diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index f81a19a78070cbbce0b7e40dfb209f30f9d65e78..2609faa41a5999cc2114212b7ba9667e2e6db49c 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -70,90 +70,115 @@ int32_t mndInitStb(SMnode *pMnode) { void mndCleanupStb(SMnode *pMnode) {} static SSdbRaw *mndStbActionEncode(SStbObj *pStb) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int32_t size = sizeof(SStbObj) + (pStb->numOfColumns + pStb->numOfTags) * sizeof(SSchema) + TSDB_STB_RESERVE_SIZE; SSdbRaw *pRaw = sdbAllocRaw(SDB_STB, TSDB_STB_VER_NUMBER, size); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto STB_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN) - SDB_SET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN) - SDB_SET_INT64(pRaw, dataPos, pStb->createdTime) - SDB_SET_INT64(pRaw, dataPos, pStb->updateTime) - SDB_SET_INT64(pRaw, dataPos, pStb->uid) - SDB_SET_INT64(pRaw, dataPos, pStb->dbUid) - SDB_SET_INT32(pRaw, dataPos, pStb->version) - SDB_SET_INT32(pRaw, dataPos, pStb->numOfColumns) - SDB_SET_INT32(pRaw, dataPos, pStb->numOfTags) + SDB_SET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN, STB_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN, STB_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pStb->createdTime, STB_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pStb->updateTime, STB_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pStb->uid, STB_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pStb->dbUid, STB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->version, STB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->numOfColumns, STB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pStb->numOfTags, STB_ENCODE_OVER) int32_t totalCols = pStb->numOfColumns + pStb->numOfTags; for (int32_t i = 0; i < totalCols; ++i) { SSchema *pSchema = &pStb->pSchema[i]; - SDB_SET_INT8(pRaw, dataPos, pSchema->type); - SDB_SET_INT32(pRaw, dataPos, pSchema->colId); - SDB_SET_INT32(pRaw, dataPos, pSchema->bytes); - SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN); + SDB_SET_INT8(pRaw, dataPos, pSchema->type, STB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pSchema->colId, STB_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pSchema->bytes, STB_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_ENCODE_OVER) } - SDB_SET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE) - SDB_SET_DATALEN(pRaw, dataPos); + SDB_SET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, STB_ENCODE_OVER) + SDB_SET_DATALEN(pRaw, dataPos, STB_ENCODE_OVER) + + terrno = 0; +STB_ENCODE_OVER: + if (terrno != 0) { + mError("stb:%s, failed to encode to raw:%p since %s", pStb->name, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + + mTrace("stb:%s, encode to raw:%p, row:%p", pStb->name, pRaw, pStb); return pRaw; } static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto STB_DECODE_OVER; if (sver != TSDB_STB_VER_NUMBER) { - mError("failed to decode stable since %s", terrstr()); terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - return NULL; + goto STB_DECODE_OVER; } int32_t size = sizeof(SStbObj) + TSDB_MAX_COLUMNS * sizeof(SSchema); SSdbRow *pRow = sdbAllocRow(size); + if (pRow == NULL) goto STB_DECODE_OVER; + SStbObj *pStb = sdbGetRowObj(pRow); - if (pStb == NULL) return NULL; + if (pStb == NULL) goto STB_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_BINARY(pRaw, pRow, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN) - SDB_GET_BINARY(pRaw, pRow, dataPos, pStb->db, TSDB_DB_FNAME_LEN) - SDB_GET_INT64(pRaw, pRow, dataPos, &pStb->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pStb->updateTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pStb->uid) - SDB_GET_INT64(pRaw, pRow, dataPos, &pStb->dbUid) - SDB_GET_INT32(pRaw, pRow, dataPos, &pStb->version) - SDB_GET_INT32(pRaw, pRow, dataPos, &pStb->numOfColumns) - SDB_GET_INT32(pRaw, pRow, dataPos, &pStb->numOfTags) + SDB_GET_BINARY(pRaw, dataPos, pStb->name, TSDB_TABLE_FNAME_LEN, STB_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pStb->db, TSDB_DB_FNAME_LEN, STB_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pStb->createdTime, STB_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pStb->updateTime, STB_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pStb->uid, STB_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pStb->dbUid, STB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->version, STB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->numOfColumns, STB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pStb->numOfTags, STB_DECODE_OVER) int32_t totalCols = pStb->numOfColumns + pStb->numOfTags; pStb->pSchema = calloc(totalCols, sizeof(SSchema)); for (int32_t i = 0; i < totalCols; ++i) { SSchema *pSchema = &pStb->pSchema[i]; - SDB_GET_INT8(pRaw, pRow, dataPos, &pSchema->type); - SDB_GET_INT32(pRaw, pRow, dataPos, &pSchema->colId); - SDB_GET_INT32(pRaw, pRow, dataPos, &pSchema->bytes); - SDB_GET_BINARY(pRaw, pRow, dataPos, pSchema->name, TSDB_COL_NAME_LEN); + SDB_GET_INT8(pRaw, dataPos, &pSchema->type, STB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pSchema->colId, STB_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pSchema->bytes, STB_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pSchema->name, TSDB_COL_NAME_LEN, STB_DECODE_OVER) } - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_STB_RESERVE_SIZE) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_STB_RESERVE_SIZE, STB_DECODE_OVER) + + terrno = 0; + +STB_DECODE_OVER: + if (terrno != 0) { + mError("stb:%s, failed to decode from raw:%p since %s", pStb->name, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + mTrace("stb:%s, decode from raw:%p, row:%p", pStb->name, pRaw, pStb); return pRow; } static int32_t mndStbActionInsert(SSdb *pSdb, SStbObj *pStb) { - mTrace("stb:%s, perform insert action", pStb->name); + mTrace("stb:%s, perform insert action, row:%p", pStb->name, pStb); return 0; } static int32_t mndStbActionDelete(SSdb *pSdb, SStbObj *pStb) { - mTrace("stb:%s, perform delete action", pStb->name); + mTrace("stb:%s, perform delete action, row:%p", pStb->name, pStb); return 0; } static int32_t mndStbActionUpdate(SSdb *pSdb, SStbObj *pOldStb, SStbObj *pNewStb) { - mTrace("stb:%s, perform update action", pOldStb->name); + mTrace("stb:%s, perform update action, old_row:%p new_row:%p", pOldStb->name, pOldStb, pNewStb); atomic_exchange_32(&pOldStb->updateTime, pNewStb->updateTime); atomic_exchange_32(&pOldStb->version, pNewStb->version); @@ -177,7 +202,7 @@ static int32_t mndStbActionUpdate(SSdb *pSdb, SStbObj *pOldStb, SStbObj *pNewStb } SStbObj *mndAcquireStb(SMnode *pMnode, char *stbName) { - SSdb * pSdb = pMnode->pSdb; + SSdb *pSdb = pMnode->pSdb; SStbObj *pStb = sdbAcquire(pSdb, SDB_STB, stbName); if (pStb == NULL) { terrno = TSDB_CODE_MND_STB_NOT_EXIST; @@ -202,9 +227,9 @@ static SDbObj *mndAcquireDbByStb(SMnode *pMnode, char *stbName) { static void *mndBuildCreateStbMsg(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb, int *pContLen) { SVCreateTbReq req; - void * buf; + void *buf; int bsize; - SMsgHead * pMsgHead; + SMsgHead *pMsgHead; req.ver = 0; SName name = {0}; @@ -328,9 +353,9 @@ static int32_t mndSetCreateStbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj } static int32_t mndSetCreateStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) { - SSdb * pSdb = pMnode->pSdb; + SSdb *pSdb = pMnode->pSdb; SVgObj *pVgroup = NULL; - void * pIter = NULL; + void *pIter = NULL; int contLen; while (1) { @@ -364,9 +389,9 @@ static int32_t mndSetCreateStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj } static int32_t mndSetCreateStbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) { - SSdb * pSdb = pMnode->pSdb; + SSdb *pSdb = pMnode->pSdb; SVgObj *pVgroup = NULL; - void * pIter = NULL; + void *pIter = NULL; while (1) { pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup); @@ -470,7 +495,7 @@ CREATE_STB_OVER: } static int32_t mndProcessCreateStbMsg(SMnodeMsg *pMsg) { - SMnode * pMnode = pMsg->pMnode; + SMnode *pMnode = pMsg->pMnode; SCreateStbMsg *pCreate = pMsg->rpcMsg.pCont; mDebug("stb:%s, start to create", pCreate->name); @@ -554,7 +579,7 @@ static int32_t mndCheckAlterStbMsg(SAlterStbMsg *pAlter) { static int32_t mndUpdateStb(SMnode *pMnode, SMnodeMsg *pMsg, SStbObj *pOldStb, SStbObj *pNewStb) { return 0; } static int32_t mndProcessAlterStbMsg(SMnodeMsg *pMsg) { - SMnode * pMnode = pMsg->pMnode; + SMnode *pMnode = pMsg->pMnode; SAlterStbMsg *pAlter = pMsg->rpcMsg.pCont; mDebug("stb:%s, start to alter", pAlter->name); @@ -668,7 +693,7 @@ DROP_STB_OVER: } static int32_t mndProcessDropStbMsg(SMnodeMsg *pMsg) { - SMnode * pMnode = pMsg->pMnode; + SMnode *pMnode = pMsg->pMnode; SDropStbMsg *pDrop = pMsg->rpcMsg.pCont; mDebug("stb:%s, start to drop", pDrop->name); @@ -703,7 +728,7 @@ static int32_t mndProcessDropStbInRsp(SMnodeMsg *pMsg) { } static int32_t mndProcessStbMetaMsg(SMnodeMsg *pMsg) { - SMnode * pMnode = pMsg->pMnode; + SMnode *pMnode = pMsg->pMnode; STableInfoMsg *pInfo = pMsg->rpcMsg.pCont; mDebug("stb:%s, start to retrieve meta", pInfo->tableFname); @@ -775,7 +800,7 @@ static int32_t mndGetNumOfStbs(SMnode *pMnode, char *dbName, int32_t *pNumOfStbs } int32_t numOfStbs = 0; - void * pIter = NULL; + void *pIter = NULL; while (1) { SStbObj *pStb = NULL; pIter = sdbFetch(pSdb, SDB_STB, pIter, (void **)&pStb); @@ -794,7 +819,7 @@ static int32_t mndGetNumOfStbs(SMnode *pMnode, char *dbName, int32_t *pNumOfStbs static int32_t mndGetStbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) { SMnode *pMnode = pMsg->pMnode; - SSdb * pSdb = pMnode->pSdb; + SSdb *pSdb = pMnode->pSdb; if (mndGetNumOfStbs(pMnode, pShow->db, &pShow->numOfRows) != 0) { return -1; diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c index 24e32e07b47c7eb5e4f0f500a7a0b76ce3c0d578..9fb63f6f58f2a9f31f39126a72a2b7cae281dd71 100644 --- a/source/dnode/mnode/impl/src/mndTopic.c +++ b/source/dnode/mnode/impl/src/mndTopic.c @@ -59,80 +59,105 @@ int32_t mndInitTopic(SMnode *pMnode) { void mndCleanupTopic(SMnode *pMnode) {} static SSdbRaw *mndTopicActionEncode(STopicObj *pTopic) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int32_t size = sizeof(STopicObj) + MND_TOPIC_RESERVE_SIZE; SSdbRaw *pRaw = sdbAllocRaw(SDB_TOPIC, MND_TOPIC_VER_NUMBER, size); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto TOPIC_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_BINARY(pRaw, dataPos, pTopic->name, TSDB_TABLE_FNAME_LEN); - SDB_SET_BINARY(pRaw, dataPos, pTopic->db, TSDB_DB_FNAME_LEN); - SDB_SET_INT64(pRaw, dataPos, pTopic->createTime); - SDB_SET_INT64(pRaw, dataPos, pTopic->updateTime); - SDB_SET_INT64(pRaw, dataPos, pTopic->uid); - SDB_SET_INT64(pRaw, dataPos, pTopic->dbUid); - SDB_SET_INT32(pRaw, dataPos, pTopic->version); - SDB_SET_INT32(pRaw, dataPos, pTopic->execLen); - SDB_SET_BINARY(pRaw, dataPos, pTopic->executor, pTopic->execLen); - SDB_SET_INT32(pRaw, dataPos, pTopic->sqlLen); - SDB_SET_BINARY(pRaw, dataPos, pTopic->sql, pTopic->sqlLen); - - SDB_SET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE); - SDB_SET_DATALEN(pRaw, dataPos); + SDB_SET_BINARY(pRaw, dataPos, pTopic->name, TSDB_TABLE_FNAME_LEN, TOPIC_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pTopic->db, TSDB_DB_FNAME_LEN, TOPIC_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pTopic->createTime, TOPIC_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pTopic->updateTime, TOPIC_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pTopic->uid, TOPIC_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pTopic->dbUid, TOPIC_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pTopic->version, TOPIC_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pTopic->execLen, TOPIC_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pTopic->executor, pTopic->execLen, TOPIC_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pTopic->sqlLen, TOPIC_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pTopic->sql, pTopic->sqlLen, TOPIC_ENCODE_OVER) + + SDB_SET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE, TOPIC_ENCODE_OVER) + SDB_SET_DATALEN(pRaw, dataPos, TOPIC_ENCODE_OVER) + + terrno = 0; + +TOPIC_ENCODE_OVER: + if (terrno != 0) { + mError("topic:%s, failed to encode to raw:%p since %s", pTopic->name, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + mTrace("topic:%s, encode to raw:%p, row:%p", pTopic->name, pRaw, pTopic); return pRaw; } static SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto TOPIC_DECODE_OVER; if (sver != MND_TOPIC_VER_NUMBER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - mError("failed to decode topic since %s", terrstr()); - return NULL; + goto TOPIC_DECODE_OVER; } - int32_t size = sizeof(STopicObj) + TSDB_MAX_COLUMNS * sizeof(SSchema); - SSdbRow *pRow = sdbAllocRow(size); + int32_t size = sizeof(STopicObj) + TSDB_MAX_COLUMNS * sizeof(SSchema); + SSdbRow *pRow = sdbAllocRow(size); + if (pRow == NULL) goto TOPIC_DECODE_OVER; + STopicObj *pTopic = sdbGetRowObj(pRow); - if (pTopic == NULL) return NULL; + if (pTopic == NULL) goto TOPIC_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_BINARY(pRaw, pRow, dataPos, pTopic->name, TSDB_TABLE_FNAME_LEN); - SDB_GET_BINARY(pRaw, pRow, dataPos, pTopic->db, TSDB_DB_FNAME_LEN); - SDB_GET_INT64(pRaw, pRow, dataPos, &pTopic->createTime); - SDB_GET_INT64(pRaw, pRow, dataPos, &pTopic->updateTime); - SDB_GET_INT64(pRaw, pRow, dataPos, &pTopic->uid); - SDB_GET_INT64(pRaw, pRow, dataPos, &pTopic->dbUid); - SDB_GET_INT32(pRaw, pRow, dataPos, &pTopic->version); - SDB_GET_INT32(pRaw, pRow, dataPos, &pTopic->execLen); - SDB_GET_BINARY(pRaw, pRow, dataPos, pTopic->executor, pTopic->execLen); - SDB_GET_INT32(pRaw, pRow, dataPos, &pTopic->sqlLen); - SDB_GET_BINARY(pRaw, pRow, dataPos, pTopic->sql, pTopic->sqlLen); - - SDB_GET_RESERVE(pRaw, pRow, dataPos, MND_TOPIC_RESERVE_SIZE); + SDB_GET_BINARY(pRaw, dataPos, pTopic->name, TSDB_TABLE_FNAME_LEN, TOPIC_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pTopic->db, TSDB_DB_FNAME_LEN, TOPIC_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pTopic->createTime, TOPIC_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pTopic->updateTime, TOPIC_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pTopic->uid, TOPIC_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pTopic->dbUid, TOPIC_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pTopic->version, TOPIC_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pTopic->execLen, TOPIC_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pTopic->executor, pTopic->execLen, TOPIC_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pTopic->sqlLen, TOPIC_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pTopic->sql, pTopic->sqlLen, TOPIC_DECODE_OVER) + + SDB_GET_RESERVE(pRaw, dataPos, MND_TOPIC_RESERVE_SIZE, TOPIC_DECODE_OVER) + + terrno = 0; + +TOPIC_DECODE_OVER: + if (terrno != 0) { + mError("topic:%s, failed to decode from raw:%p since %s", pTopic->name, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + mTrace("topic:%s, decode from raw:%p, row:%p", pTopic->name, pRaw, pTopic); return pRow; } static int32_t mndTopicActionInsert(SSdb *pSdb, STopicObj *pTopic) { - mTrace("topic:%s, perform insert action", pTopic->name); + mTrace("topic:%s, perform insert action, row:%p", pTopic->name, pTopic); return 0; } static int32_t mndTopicActionDelete(SSdb *pSdb, STopicObj *pTopic) { - mTrace("topic:%s, perform delete action", pTopic->name); + mTrace("topic:%s, perform delete action, row:%p", pTopic->name, pTopic); return 0; } static int32_t mndTopicActionUpdate(SSdb *pSdb, STopicObj *pOldTopic, STopicObj *pNewTopic) { - mTrace("topic:%s, perform update action", pOldTopic->name); + mTrace("topic:%s, perform update action, old_row:%p new_row:%p", pOldTopic->name, pOldTopic, pNewTopic); atomic_exchange_32(&pOldTopic->updateTime, pNewTopic->updateTime); atomic_exchange_32(&pOldTopic->version, pNewTopic->version); taosWLockLatch(&pOldTopic->lock); - - //TODO handle update + + // TODO handle update taosWUnLockLatch(&pOldTopic->lock); return 0; @@ -201,9 +226,9 @@ static int32_t mndCreateTopic(SMnode *pMnode, SMnodeMsg *pMsg, SCMCreateTopicReq } static int32_t mndProcessCreateTopicMsg(SMnodeMsg *pMsg) { - SMnode *pMnode = pMsg->pMnode; - char *msgStr = pMsg->rpcMsg.pCont; - SCMCreateTopicReq* pCreate; + SMnode *pMnode = pMsg->pMnode; + char *msgStr = pMsg->rpcMsg.pCont; + SCMCreateTopicReq *pCreate; tDeserializeSCMCreateTopicReq(msgStr, pCreate); mDebug("topic:%s, start to create", pCreate->name); @@ -245,9 +270,7 @@ static int32_t mndProcessCreateTopicMsg(SMnodeMsg *pMsg) { return TSDB_CODE_MND_ACTION_IN_PROGRESS; } -static int32_t mndDropTopic(SMnode *pMnode, SMnodeMsg *pMsg, STopicObj *pTopic) { - return 0; -} +static int32_t mndDropTopic(SMnode *pMnode, SMnodeMsg *pMsg, STopicObj *pTopic) { return 0; } static int32_t mndProcessDropTopicMsg(SMnodeMsg *pMsg) { SMnode *pMnode = pMsg->pMnode; diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c index cf434dda39df13b59fa59654c2a5b33b76b01672..5062048d6dc8f078e61744c3f2b489e7f241a07e 100644 --- a/source/dnode/mnode/impl/src/mndTrans.c +++ b/source/dnode/mnode/impl/src/mndTrans.c @@ -31,6 +31,7 @@ static int32_t mndTransAppendLog(SArray *pArray, SSdbRaw *pRaw); static int32_t mndTransAppendAction(SArray *pArray, STransAction *pAction); static void mndTransDropLogs(SArray *pArray); static void mndTransDropActions(SArray *pArray); +static void mndTransDropData(STrans *pTrans); static int32_t mndTransExecuteLogs(SMnode *pMnode, SArray *pArray); static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pArray); static int32_t mndTransExecuteRedoLogs(SMnode *pMnode, STrans *pTrans); @@ -70,6 +71,8 @@ int32_t mndInitTrans(SMnode *pMnode) { void mndCleanupTrans(SMnode *pMnode) {} static SSdbRaw *mndTransActionEncode(STrans *pTrans) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int32_t rawDataLen = sizeof(STrans) + MND_TRANS_RESERVE_SIZE; int32_t redoLogNum = taosArrayGetSize(pTrans->redoLogs); int32_t undoLogNum = taosArrayGetSize(pTrans->undoLogs); @@ -109,75 +112,95 @@ static SSdbRaw *mndTransActionEncode(STrans *pTrans) { } int32_t dataPos = 0; - SDB_SET_INT32(pRaw, dataPos, pTrans->id) - SDB_SET_INT8(pRaw, dataPos, pTrans->policy) - SDB_SET_INT32(pRaw, dataPos, redoLogNum) - SDB_SET_INT32(pRaw, dataPos, undoLogNum) - SDB_SET_INT32(pRaw, dataPos, commitLogNum) - SDB_SET_INT32(pRaw, dataPos, redoActionNum) - SDB_SET_INT32(pRaw, dataPos, undoActionNum) + SDB_SET_INT32(pRaw, dataPos, pTrans->id, TRANS_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pTrans->policy, TRANS_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, redoLogNum, TRANS_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, undoLogNum, TRANS_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, commitLogNum, TRANS_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, redoActionNum, TRANS_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, undoActionNum, TRANS_ENCODE_OVER) for (int32_t i = 0; i < redoLogNum; ++i) { SSdbRaw *pTmp = taosArrayGetP(pTrans->redoLogs, i); int32_t len = sdbGetRawTotalSize(pTmp); - SDB_SET_INT32(pRaw, dataPos, len) - SDB_SET_BINARY(pRaw, dataPos, (void *)pTmp, len) + SDB_SET_INT32(pRaw, dataPos, len, TRANS_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, (void *)pTmp, len, TRANS_ENCODE_OVER) } for (int32_t i = 0; i < undoLogNum; ++i) { SSdbRaw *pTmp = taosArrayGetP(pTrans->undoLogs, i); int32_t len = sdbGetRawTotalSize(pTmp); - SDB_SET_INT32(pRaw, dataPos, len) - SDB_SET_BINARY(pRaw, dataPos, (void *)pTmp, len) + SDB_SET_INT32(pRaw, dataPos, len, TRANS_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, (void *)pTmp, len, TRANS_ENCODE_OVER) } for (int32_t i = 0; i < commitLogNum; ++i) { SSdbRaw *pTmp = taosArrayGetP(pTrans->commitLogs, i); int32_t len = sdbGetRawTotalSize(pTmp); - SDB_SET_INT32(pRaw, dataPos, len) - SDB_SET_BINARY(pRaw, dataPos, (void *)pTmp, len) + SDB_SET_INT32(pRaw, dataPos, len, TRANS_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, (void *)pTmp, len, TRANS_ENCODE_OVER) } for (int32_t i = 0; i < redoActionNum; ++i) { STransAction *pAction = taosArrayGet(pTrans->redoActions, i); - SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet)); - SDB_SET_INT16(pRaw, dataPos, pAction->msgType) - SDB_SET_INT32(pRaw, dataPos, pAction->contLen) - SDB_SET_BINARY(pRaw, dataPos, pAction->pCont, pAction->contLen); + SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet), TRANS_ENCODE_OVER) + SDB_SET_INT16(pRaw, dataPos, pAction->msgType, TRANS_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->contLen, TRANS_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pAction->pCont, pAction->contLen, TRANS_ENCODE_OVER) } for (int32_t i = 0; i < undoActionNum; ++i) { STransAction *pAction = taosArrayGet(pTrans->undoActions, i); - SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet)); - SDB_SET_INT16(pRaw, dataPos, pAction->msgType) - SDB_SET_INT32(pRaw, dataPos, pAction->contLen) - SDB_SET_BINARY(pRaw, dataPos, (void *)pAction->pCont, pAction->contLen); + SDB_SET_BINARY(pRaw, dataPos, (void *)&pAction->epSet, sizeof(SEpSet), TRANS_ENCODE_OVER) + SDB_SET_INT16(pRaw, dataPos, pAction->msgType, TRANS_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pAction->contLen, TRANS_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, (void *)pAction->pCont, pAction->contLen, TRANS_ENCODE_OVER) + } + + SDB_SET_RESERVE(pRaw, dataPos, MND_TRANS_RESERVE_SIZE, TRANS_ENCODE_OVER) + SDB_SET_DATALEN(pRaw, dataPos, TRANS_ENCODE_OVER) + + terrno = 0; + +TRANS_ENCODE_OVER: + if (terrno != 0) { + mError("trans:%d, failed to encode to raw:%p len:%d since %s", pTrans->id, pRaw, dataPos, terrstr()); + sdbFreeRaw(pRaw); + return NULL; } - SDB_SET_RESERVE(pRaw, dataPos, MND_TRANS_RESERVE_SIZE) - SDB_SET_DATALEN(pRaw, dataPos); mTrace("trans:%d, encode to raw:%p, len:%d", pTrans->id, pRaw, dataPos); return pRaw; } static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) { - int32_t code = 0; - - int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + terrno = TSDB_CODE_OUT_OF_MEMORY; + + SSdbRow *pRow = NULL; + STrans *pTrans = NULL; + char *pData = NULL; + int32_t dataLen = 0; + int8_t sver = 0; + int32_t redoLogNum = 0; + int32_t undoLogNum = 0; + int32_t commitLogNum = 0; + int32_t redoActionNum = 0; + int32_t undoActionNum = 0; + int32_t dataPos = 0; + STransAction action = {0}; + + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto TRANS_DECODE_OVER; if (sver != MND_TRANS_VER_NUMBER) { terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - mError("failed to get check soft ver from raw:%p since %s", pRaw, terrstr()); - return NULL; + goto TRANS_DECODE_OVER; } - SSdbRow *pRow = sdbAllocRow(sizeof(STrans)); - STrans *pTrans = sdbGetRowObj(pRow); - if (pTrans == NULL) { - mError("failed to alloc trans from raw:%p since %s", pRaw, terrstr()); - return NULL; - } + pRow = sdbAllocRow(sizeof(STrans)); + if (pRow == NULL) goto TRANS_DECODE_OVER; + + pTrans = sdbGetRowObj(pRow); + if (pTrans == NULL) goto TRANS_DECODE_OVER; pTrans->redoLogs = taosArrayInit(MND_TRANS_ARRAY_SIZE, sizeof(void *)); pTrans->undoLogs = taosArrayInit(MND_TRANS_ARRAY_SIZE, sizeof(void *)); @@ -185,112 +208,79 @@ static SSdbRow *mndTransActionDecode(SSdbRaw *pRaw) { pTrans->redoActions = taosArrayInit(MND_TRANS_ARRAY_SIZE, sizeof(STransAction)); pTrans->undoActions = taosArrayInit(MND_TRANS_ARRAY_SIZE, sizeof(STransAction)); - if (pTrans->redoLogs == NULL || pTrans->undoLogs == NULL || pTrans->commitLogs == NULL || - pTrans->redoActions == NULL || pTrans->undoActions == NULL) { - mDebug("trans:%d, failed to create array while parsed from raw:%p", pTrans->id, pRaw); - code = TSDB_CODE_OUT_OF_MEMORY; - goto TRANS_DECODE_OVER; - } - - int32_t redoLogNum = 0; - int32_t undoLogNum = 0; - int32_t commitLogNum = 0; - int32_t redoActionNum = 0; - int32_t undoActionNum = 0; + if (pTrans->redoLogs == NULL) goto TRANS_DECODE_OVER; + if (pTrans->undoLogs == NULL) goto TRANS_DECODE_OVER; + if (pTrans->commitLogs == NULL) goto TRANS_DECODE_OVER; + if (pTrans->redoActions == NULL) goto TRANS_DECODE_OVER; + if (pTrans->undoActions == NULL) goto TRANS_DECODE_OVER; - int32_t dataPos = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &pTrans->id) - SDB_GET_INT8(pRaw, pRow, dataPos, (int8_t *)&pTrans->policy) - SDB_GET_INT32(pRaw, pRow, dataPos, &redoLogNum) - SDB_GET_INT32(pRaw, pRow, dataPos, &undoLogNum) - SDB_GET_INT32(pRaw, pRow, dataPos, &commitLogNum) - SDB_GET_INT32(pRaw, pRow, dataPos, &redoActionNum) - SDB_GET_INT32(pRaw, pRow, dataPos, &undoActionNum) + SDB_GET_INT32(pRaw, dataPos, &pTrans->id, TRANS_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, (int8_t *)&pTrans->policy, TRANS_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &redoLogNum, TRANS_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &undoLogNum, TRANS_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &commitLogNum, TRANS_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &redoActionNum, TRANS_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &undoActionNum, TRANS_DECODE_OVER) for (int32_t i = 0; i < redoLogNum; ++i) { - int32_t dataLen = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &dataLen) - char *pData = malloc(dataLen); - SDB_GET_BINARY(pRaw, pRow, dataPos, pData, dataLen); - - void *ret = taosArrayPush(pTrans->redoLogs, &pData); - if (ret == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto TRANS_DECODE_OVER; - } + SDB_GET_INT32(pRaw, dataPos, &dataLen, TRANS_DECODE_OVER) + pData = malloc(dataLen); + if (pData == NULL) goto TRANS_DECODE_OVER; + SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, TRANS_DECODE_OVER); + if (taosArrayPush(pTrans->redoLogs, &pData) == NULL) goto TRANS_DECODE_OVER; + pData = NULL; } for (int32_t i = 0; i < undoLogNum; ++i) { - int32_t dataLen = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &dataLen) - char *pData = malloc(dataLen); - SDB_GET_BINARY(pRaw, pRow, dataPos, pData, dataLen); - - void *ret = taosArrayPush(pTrans->undoLogs, &pData); - if (ret == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto TRANS_DECODE_OVER; - } + SDB_GET_INT32(pRaw, dataPos, &dataLen, TRANS_DECODE_OVER) + pData = malloc(dataLen); + if (pData == NULL) goto TRANS_DECODE_OVER; + SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, TRANS_DECODE_OVER); + if (taosArrayPush(pTrans->undoLogs, &pData) == NULL) goto TRANS_DECODE_OVER; + pData = NULL; } for (int32_t i = 0; i < commitLogNum; ++i) { - int32_t dataLen = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &dataLen) - char *pData = malloc(dataLen); - SDB_GET_BINARY(pRaw, pRow, dataPos, pData, dataLen); - - void *ret = taosArrayPush(pTrans->commitLogs, &pData); - if (ret == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto TRANS_DECODE_OVER; - } + SDB_GET_INT32(pRaw, dataPos, &dataLen, TRANS_DECODE_OVER) + pData = malloc(dataLen); + SDB_GET_BINARY(pRaw, dataPos, pData, dataLen, TRANS_DECODE_OVER); + if (taosArrayPush(pTrans->commitLogs, &pData) == NULL) goto TRANS_DECODE_OVER; + pData = NULL; } for (int32_t i = 0; i < redoActionNum; ++i) { - STransAction action = {0}; - SDB_GET_BINARY(pRaw, pRow, dataPos, (void *)&action.epSet, sizeof(SEpSet)); - SDB_GET_INT16(pRaw, pRow, dataPos, &action.msgType) - SDB_GET_INT32(pRaw, pRow, dataPos, &action.contLen) + SDB_GET_BINARY(pRaw, dataPos, (void *)&action.epSet, sizeof(SEpSet), TRANS_DECODE_OVER); + SDB_GET_INT16(pRaw, dataPos, &action.msgType, TRANS_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &action.contLen, TRANS_DECODE_OVER) action.pCont = malloc(action.contLen); - if (action.pCont == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto TRANS_DECODE_OVER; - } - SDB_GET_BINARY(pRaw, pRow, dataPos, action.pCont, action.contLen); - - void *ret = taosArrayPush(pTrans->redoActions, &action); - if (ret == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto TRANS_DECODE_OVER; - } + if (action.pCont == NULL) goto TRANS_DECODE_OVER; + SDB_GET_BINARY(pRaw, dataPos, action.pCont, action.contLen, TRANS_DECODE_OVER); + if (taosArrayPush(pTrans->redoActions, &action) == NULL) goto TRANS_DECODE_OVER; + action.pCont = NULL; } for (int32_t i = 0; i < undoActionNum; ++i) { - STransAction action = {0}; - SDB_GET_BINARY(pRaw, pRow, dataPos, (void *)&action.epSet, sizeof(SEpSet)); - SDB_GET_INT16(pRaw, pRow, dataPos, &action.msgType) - SDB_GET_INT32(pRaw, pRow, dataPos, &action.contLen) + SDB_GET_BINARY(pRaw, dataPos, (void *)&action.epSet, sizeof(SEpSet), TRANS_DECODE_OVER); + SDB_GET_INT16(pRaw, dataPos, &action.msgType, TRANS_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &action.contLen, TRANS_DECODE_OVER) action.pCont = malloc(action.contLen); - if (action.pCont == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto TRANS_DECODE_OVER; - } - SDB_GET_BINARY(pRaw, pRow, dataPos, action.pCont, action.contLen); - - void *ret = taosArrayPush(pTrans->undoActions, &action); - if (ret == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto TRANS_DECODE_OVER; - } + if (action.pCont == NULL) goto TRANS_DECODE_OVER; + SDB_GET_BINARY(pRaw, dataPos, action.pCont, action.contLen, TRANS_DECODE_OVER); + if (taosArrayPush(pTrans->undoActions, &action) == NULL) goto TRANS_DECODE_OVER; + action.pCont = NULL; } - SDB_GET_RESERVE(pRaw, pRow, dataPos, MND_TRANS_RESERVE_SIZE) + SDB_GET_RESERVE(pRaw, dataPos, MND_TRANS_RESERVE_SIZE, TRANS_DECODE_OVER) + + terrno = 0; TRANS_DECODE_OVER: - if (code != 0) { - mError("trans:%d, failed to parse from raw:%p since %s", pTrans->id, pRaw, tstrerror(errno)); - mndTransDrop(pTrans); - terrno = code; + if (terrno != 0) { + mError("trans:%d, failed to parse from raw:%p since %s", pTrans->id, pRaw, terrstr()); + mndTransDropData(pTrans); + tfree(pRow); + tfree(pData); + tfree(action.pCont); return NULL; } @@ -304,15 +294,17 @@ static int32_t mndTransActionInsert(SSdb *pSdb, STrans *pTrans) { return 0; } -static int32_t mndTransActionDelete(SSdb *pSdb, STrans *pTrans) { - mTrace("trans:%d, perform delete action, data:%p", pTrans->id, pTrans); - +static void mndTransDropData(STrans *pTrans) { mndTransDropLogs(pTrans->redoLogs); mndTransDropLogs(pTrans->undoLogs); mndTransDropLogs(pTrans->commitLogs); mndTransDropActions(pTrans->redoActions); mndTransDropActions(pTrans->undoActions); +} +static int32_t mndTransActionDelete(SSdb *pSdb, STrans *pTrans) { + mTrace("trans:%d, perform delete action, data:%p", pTrans->id, pTrans); + mndTransDropData(pTrans); return 0; } @@ -367,6 +359,7 @@ STrans *mndTransCreate(SMnode *pMnode, ETrnPolicy policy, SRpcMsg *pMsg) { } static void mndTransDropLogs(SArray *pArray) { + if (pArray == NULL) return; for (int32_t i = 0; i < pArray->size; ++i) { SSdbRaw *pRaw = taosArrayGetP(pArray, i); sdbFreeRaw(pRaw); @@ -376,6 +369,7 @@ static void mndTransDropLogs(SArray *pArray) { } static void mndTransDropActions(SArray *pArray) { + if (pArray == NULL) return; for (int32_t i = 0; i < pArray->size; ++i) { STransAction *pAction = taosArrayGet(pArray, i); free(pAction->pCont); @@ -385,12 +379,7 @@ static void mndTransDropActions(SArray *pArray) { } void mndTransDrop(STrans *pTrans) { - mndTransDropLogs(pTrans->redoLogs); - mndTransDropLogs(pTrans->undoLogs); - mndTransDropLogs(pTrans->commitLogs); - mndTransDropActions(pTrans->redoActions); - mndTransDropActions(pTrans->undoActions); - + mndTransDropData(pTrans); mDebug("trans:%d, is dropped, data:%p", pTrans->id, pTrans); tfree(pTrans); } diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c index 0926cf0c48db62d80e3114f3dd55a98730f14795..6311d3e8da2c82576e4f226dc9d26a5f9b1e956d 100644 --- a/source/dnode/mnode/impl/src/mndUser.c +++ b/source/dnode/mnode/impl/src/mndUser.c @@ -75,7 +75,7 @@ static int32_t mndCreateDefaultUser(SMnode *pMnode, char *acct, char *user, char if (pRaw == NULL) return -1; sdbSetRawStatus(pRaw, SDB_STATUS_READY); - mDebug("user:%s, will be created while deploy sdb", userObj.user); + mDebug("user:%s, will be created while deploy sdb, raw:%p", userObj.user, pRaw); return sdbWrite(pMnode->pSdb, pRaw); } @@ -94,50 +94,75 @@ static int32_t mndCreateDefaultUsers(SMnode *pMnode) { } static SSdbRaw *mndUserActionEncode(SUserObj *pUser) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + SSdbRaw *pRaw = sdbAllocRaw(SDB_USER, TSDB_USER_VER_NUMBER, sizeof(SUserObj) + TSDB_USER_RESERVE_SIZE); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto USER_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_BINARY(pRaw, dataPos, pUser->user, TSDB_USER_LEN) - SDB_SET_BINARY(pRaw, dataPos, pUser->pass, TSDB_PASSWORD_LEN) - SDB_SET_BINARY(pRaw, dataPos, pUser->acct, TSDB_USER_LEN) - SDB_SET_INT64(pRaw, dataPos, pUser->createdTime) - SDB_SET_INT64(pRaw, dataPos, pUser->updateTime) - SDB_SET_INT8(pRaw, dataPos, pUser->superUser) - SDB_SET_RESERVE(pRaw, dataPos, TSDB_USER_RESERVE_SIZE) - SDB_SET_DATALEN(pRaw, dataPos); + SDB_SET_BINARY(pRaw, dataPos, pUser->user, TSDB_USER_LEN, USER_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pUser->pass, TSDB_PASSWORD_LEN, USER_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pUser->acct, TSDB_USER_LEN, USER_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pUser->createdTime, USER_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pUser->updateTime, USER_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pUser->superUser, USER_ENCODE_OVER) + SDB_SET_RESERVE(pRaw, dataPos, TSDB_USER_RESERVE_SIZE, USER_ENCODE_OVER) + SDB_SET_DATALEN(pRaw, dataPos, USER_ENCODE_OVER) + + terrno = 0; + +USER_ENCODE_OVER: + if (terrno != 0) { + mError("user:%s, failed to encode to raw:%p since %s", pUser->user, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; + } + mTrace("user:%s, encode to raw:%p, row:%p", pUser->user, pRaw, pUser); return pRaw; } static SSdbRow *mndUserActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto USER_DECODE_OVER; if (sver != TSDB_USER_VER_NUMBER) { - mError("failed to decode user since %s", terrstr()); terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - return NULL; + goto USER_DECODE_OVER; } - SSdbRow *pRow = sdbAllocRow(sizeof(SUserObj)); + SSdbRow *pRow = sdbAllocRow(sizeof(SUserObj)); + if (pRow == NULL) goto USER_DECODE_OVER; + SUserObj *pUser = sdbGetRowObj(pRow); - if (pUser == NULL) return NULL; + if (pUser == NULL) goto USER_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_BINARY(pRaw, pRow, dataPos, pUser->user, TSDB_USER_LEN) - SDB_GET_BINARY(pRaw, pRow, dataPos, pUser->pass, TSDB_PASSWORD_LEN) - SDB_GET_BINARY(pRaw, pRow, dataPos, pUser->acct, TSDB_USER_LEN) - SDB_GET_INT64(pRaw, pRow, dataPos, &pUser->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pUser->updateTime) - SDB_GET_INT8(pRaw, pRow, dataPos, &pUser->superUser) - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_USER_RESERVE_SIZE) + SDB_GET_BINARY(pRaw, dataPos, pUser->user, TSDB_USER_LEN, USER_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pUser->pass, TSDB_PASSWORD_LEN, USER_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pUser->acct, TSDB_USER_LEN, USER_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pUser->createdTime, USER_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pUser->updateTime, USER_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pUser->superUser, USER_DECODE_OVER) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_USER_RESERVE_SIZE, USER_DECODE_OVER) + + terrno = 0; + +USER_DECODE_OVER: + if (terrno != 0) { + mError("user:%s, failed to decode from raw:%p since %s", pUser->user, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + mTrace("user:%s, decode from raw:%p, row:%p", pUser->user, pRaw, pUser); return pRow; } static int32_t mndUserActionInsert(SSdb *pSdb, SUserObj *pUser) { - mTrace("user:%s, perform insert action", pUser->user); + mTrace("user:%s, perform insert action, row:%p", pUser->user, pUser); pUser->prohibitDbHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK); if (pUser->prohibitDbHash == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -158,7 +183,7 @@ static int32_t mndUserActionInsert(SSdb *pSdb, SUserObj *pUser) { } static int32_t mndUserActionDelete(SSdb *pSdb, SUserObj *pUser) { - mTrace("user:%s, perform delete action", pUser->user); + mTrace("user:%s, perform delete action, row:%p", pUser->user, pUser); if (pUser->prohibitDbHash) { taosHashCleanup(pUser->prohibitDbHash); pUser->prohibitDbHash = NULL; @@ -168,7 +193,7 @@ static int32_t mndUserActionDelete(SSdb *pSdb, SUserObj *pUser) { } static int32_t mndUserActionUpdate(SSdb *pSdb, SUserObj *pOldUser, SUserObj *pNewUser) { - mTrace("user:%s, perform update action", pOldUser->user); + mTrace("user:%s, perform update action, old_row:%p new_row:%p", pOldUser->user, pOldUser, pNewUser); memcpy(pOldUser->pass, pNewUser->pass, TSDB_PASSWORD_LEN); pOldUser->updateTime = pNewUser->updateTime; return 0; @@ -240,15 +265,15 @@ static int32_t mndProcessCreateUserMsg(SMnodeMsg *pMsg) { return -1; } - SUserObj *pUser = sdbAcquire(pMnode->pSdb, SDB_USER, pCreate->user); + SUserObj *pUser = mndAcquireUser(pMnode, pCreate->user); if (pUser != NULL) { - sdbRelease(pMnode->pSdb, pUser); + mndReleaseUser(pMnode, pUser); terrno = TSDB_CODE_MND_USER_ALREADY_EXIST; mError("user:%s, failed to create since %s", pCreate->user, terrstr()); return -1; } - SUserObj *pOperUser = sdbAcquire(pMnode->pSdb, SDB_USER, pMsg->user); + SUserObj *pOperUser = mndAcquireUser(pMnode, pMsg->user); if (pOperUser == NULL) { terrno = TSDB_CODE_MND_NO_USER_FROM_CONN; mError("user:%s, failed to create since %s", pCreate->user, terrstr()); @@ -256,7 +281,7 @@ static int32_t mndProcessCreateUserMsg(SMnodeMsg *pMsg) { } int32_t code = mndCreateUser(pMnode, pOperUser->acct, pCreate->user, pCreate->pass, pMsg); - sdbRelease(pMnode->pSdb, pOperUser); + mndReleaseUser(pMnode, pOperUser); if (code != 0) { mError("user:%s, failed to create since %s", pCreate->user, terrstr()); @@ -310,15 +335,16 @@ static int32_t mndProcessAlterUserMsg(SMnodeMsg *pMsg) { return -1; } - SUserObj *pUser = sdbAcquire(pMnode->pSdb, SDB_USER, pAlter->user); + SUserObj *pUser = mndAcquireUser(pMnode, pAlter->user); if (pUser == NULL) { terrno = TSDB_CODE_MND_USER_NOT_EXIST; mError("user:%s, failed to alter since %s", pAlter->user, terrstr()); return -1; } - SUserObj *pOperUser = sdbAcquire(pMnode->pSdb, SDB_USER, pMsg->user); + SUserObj *pOperUser = mndAcquireUser(pMnode, pMsg->user); if (pOperUser == NULL) { + mndReleaseUser(pMnode, pUser); terrno = TSDB_CODE_MND_NO_USER_FROM_CONN; mError("user:%s, failed to alter since %s", pAlter->user, terrstr()); return -1; @@ -331,7 +357,8 @@ static int32_t mndProcessAlterUserMsg(SMnodeMsg *pMsg) { newUser.updateTime = taosGetTimestampMs(); int32_t code = mndUpdateUser(pMnode, pUser, &newUser, pMsg); - sdbRelease(pMnode->pSdb, pOperUser); + mndReleaseUser(pMnode, pOperUser); + mndReleaseUser(pMnode, pUser); if (code != 0) { mError("user:%s, failed to alter since %s", pAlter->user, terrstr()); @@ -379,22 +406,24 @@ static int32_t mndProcessDropUserMsg(SMnodeMsg *pMsg) { return -1; } - SUserObj *pUser = sdbAcquire(pMnode->pSdb, SDB_USER, pDrop->user); + SUserObj *pUser = mndAcquireUser(pMnode, pDrop->user); if (pUser == NULL) { terrno = TSDB_CODE_MND_USER_NOT_EXIST; mError("user:%s, failed to drop since %s", pDrop->user, terrstr()); return -1; } - SUserObj *pOperUser = sdbAcquire(pMnode->pSdb, SDB_USER, pMsg->user); + SUserObj *pOperUser = mndAcquireUser(pMnode, pMsg->user); if (pOperUser == NULL) { + mndReleaseUser(pMnode, pUser); terrno = TSDB_CODE_MND_NO_USER_FROM_CONN; mError("user:%s, failed to drop since %s", pDrop->user, terrstr()); return -1; } int32_t code = mndDropUser(pMnode, pMsg, pUser); - sdbRelease(pMnode->pSdb, pOperUser); + mndReleaseUser(pMnode, pOperUser); + mndReleaseUser(pMnode, pUser); if (code != 0) { mError("user:%s, failed to drop since %s", pDrop->user, terrstr()); diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c index 41de70283f02d6bbf94c22021bd0b8b86fc5149e..bd17c6d15077ad0f303a1096e0bcf39b10eb021c 100644 --- a/source/dnode/mnode/impl/src/mndVgroup.c +++ b/source/dnode/mnode/impl/src/mndVgroup.c @@ -70,77 +70,102 @@ int32_t mndInitVgroup(SMnode *pMnode) { void mndCleanupVgroup(SMnode *pMnode) {} SSdbRaw *mndVgroupActionEncode(SVgObj *pVgroup) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + SSdbRaw *pRaw = sdbAllocRaw(SDB_VGROUP, TSDB_VGROUP_VER_NUMBER, sizeof(SVgObj) + TSDB_VGROUP_RESERVE_SIZE); - if (pRaw == NULL) return NULL; + if (pRaw == NULL) goto VG_ENCODE_OVER; int32_t dataPos = 0; - SDB_SET_INT32(pRaw, dataPos, pVgroup->vgId) - SDB_SET_INT64(pRaw, dataPos, pVgroup->createdTime) - SDB_SET_INT64(pRaw, dataPos, pVgroup->updateTime) - SDB_SET_INT32(pRaw, dataPos, pVgroup->version) - SDB_SET_INT32(pRaw, dataPos, pVgroup->hashBegin) - SDB_SET_INT32(pRaw, dataPos, pVgroup->hashEnd) - SDB_SET_BINARY(pRaw, dataPos, pVgroup->dbName, TSDB_DB_FNAME_LEN) - SDB_SET_INT64(pRaw, dataPos, pVgroup->dbUid) - SDB_SET_INT8(pRaw, dataPos, pVgroup->replica) + SDB_SET_INT32(pRaw, dataPos, pVgroup->vgId, VG_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pVgroup->createdTime, VG_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pVgroup->updateTime, VG_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pVgroup->version, VG_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pVgroup->hashBegin, VG_ENCODE_OVER) + SDB_SET_INT32(pRaw, dataPos, pVgroup->hashEnd, VG_ENCODE_OVER) + SDB_SET_BINARY(pRaw, dataPos, pVgroup->dbName, TSDB_DB_FNAME_LEN, VG_ENCODE_OVER) + SDB_SET_INT64(pRaw, dataPos, pVgroup->dbUid, VG_ENCODE_OVER) + SDB_SET_INT8(pRaw, dataPos, pVgroup->replica, VG_ENCODE_OVER) for (int8_t i = 0; i < pVgroup->replica; ++i) { SVnodeGid *pVgid = &pVgroup->vnodeGid[i]; - SDB_SET_INT32(pRaw, dataPos, pVgid->dnodeId) + SDB_SET_INT32(pRaw, dataPos, pVgid->dnodeId, VG_ENCODE_OVER) + } + SDB_SET_RESERVE(pRaw, dataPos, TSDB_VGROUP_RESERVE_SIZE, VG_ENCODE_OVER) + SDB_SET_DATALEN(pRaw, dataPos, VG_ENCODE_OVER) + + terrno = 0; + +VG_ENCODE_OVER: + if (terrno != 0) { + mError("vgId:%d, failed to encode to raw:%p since %s", pVgroup->vgId, pRaw, terrstr()); + sdbFreeRaw(pRaw); + return NULL; } - SDB_SET_RESERVE(pRaw, dataPos, TSDB_VGROUP_RESERVE_SIZE) - SDB_SET_DATALEN(pRaw, dataPos); + mTrace("vgId:%d, encode to raw:%p, row:%p", pVgroup->vgId, pRaw, pVgroup); return pRaw; } SSdbRow *mndVgroupActionDecode(SSdbRaw *pRaw) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + int8_t sver = 0; - if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL; + if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto VG_DECODE_OVER; if (sver != TSDB_VGROUP_VER_NUMBER) { - mError("failed to decode vgroup since %s", terrstr()); terrno = TSDB_CODE_SDB_INVALID_DATA_VER; - return NULL; + goto VG_DECODE_OVER; } SSdbRow *pRow = sdbAllocRow(sizeof(SVgObj)); - SVgObj *pVgroup = sdbGetRowObj(pRow); - if (pVgroup == NULL) return NULL; + if (pRow == NULL) goto VG_DECODE_OVER; + + SVgObj *pVgroup = sdbGetRowObj(pRow); + if (pVgroup == NULL) goto VG_DECODE_OVER; int32_t dataPos = 0; - SDB_GET_INT32(pRaw, pRow, dataPos, &pVgroup->vgId) - SDB_GET_INT64(pRaw, pRow, dataPos, &pVgroup->createdTime) - SDB_GET_INT64(pRaw, pRow, dataPos, &pVgroup->updateTime) - SDB_GET_INT32(pRaw, pRow, dataPos, &pVgroup->version) - SDB_GET_INT32(pRaw, pRow, dataPos, &pVgroup->hashBegin) - SDB_GET_INT32(pRaw, pRow, dataPos, &pVgroup->hashEnd) - SDB_GET_BINARY(pRaw, pRow, dataPos, pVgroup->dbName, TSDB_DB_FNAME_LEN) - SDB_GET_INT64(pRaw, pRow, dataPos, &pVgroup->dbUid) - SDB_GET_INT8(pRaw, pRow, dataPos, &pVgroup->replica) + SDB_GET_INT32(pRaw, dataPos, &pVgroup->vgId, VG_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pVgroup->createdTime, VG_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pVgroup->updateTime, VG_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pVgroup->version, VG_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pVgroup->hashBegin, VG_DECODE_OVER) + SDB_GET_INT32(pRaw, dataPos, &pVgroup->hashEnd, VG_DECODE_OVER) + SDB_GET_BINARY(pRaw, dataPos, pVgroup->dbName, TSDB_DB_FNAME_LEN, VG_DECODE_OVER) + SDB_GET_INT64(pRaw, dataPos, &pVgroup->dbUid, VG_DECODE_OVER) + SDB_GET_INT8(pRaw, dataPos, &pVgroup->replica, VG_DECODE_OVER) for (int8_t i = 0; i < pVgroup->replica; ++i) { SVnodeGid *pVgid = &pVgroup->vnodeGid[i]; - SDB_GET_INT32(pRaw, pRow, dataPos, &pVgid->dnodeId) + SDB_GET_INT32(pRaw, dataPos, &pVgid->dnodeId, VG_DECODE_OVER) if (pVgroup->replica == 1) { pVgid->role = TAOS_SYNC_STATE_LEADER; } } - SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_VGROUP_RESERVE_SIZE) + SDB_GET_RESERVE(pRaw, dataPos, TSDB_VGROUP_RESERVE_SIZE, VG_DECODE_OVER) + + terrno = 0; + +VG_DECODE_OVER: + if (terrno != 0) { + mError("vgId:%d, failed to decode from raw:%p since %s", pVgroup->vgId, pRaw, terrstr()); + tfree(pRow); + return NULL; + } + mTrace("vgId:%d, decode from raw:%p, row:%p", pVgroup->vgId, pRaw, pVgroup); return pRow; } static int32_t mndVgroupActionInsert(SSdb *pSdb, SVgObj *pVgroup) { - mTrace("vgId:%d, perform insert action", pVgroup->vgId); + mTrace("vgId:%d, perform insert action, row:%p", pVgroup->vgId, pVgroup); return 0; } static int32_t mndVgroupActionDelete(SSdb *pSdb, SVgObj *pVgroup) { - mTrace("vgId:%d, perform delete action", pVgroup->vgId); + mTrace("vgId:%d, perform delete action, row:%p", pVgroup->vgId, pVgroup); return 0; } static int32_t mndVgroupActionUpdate(SSdb *pSdb, SVgObj *pOldVgroup, SVgObj *pNewVgroup) { - mTrace("vgId:%d, perform update action", pOldVgroup->vgId); + mTrace("vgId:%d, perform update action, old_row:%p new_row:%p", pOldVgroup->vgId, pOldVgroup, pNewVgroup); pOldVgroup->updateTime = pNewVgroup->updateTime; pOldVgroup->version = pNewVgroup->version; pOldVgroup->hashBegin = pNewVgroup->hashBegin; diff --git a/source/dnode/mnode/impl/src/mnode.c b/source/dnode/mnode/impl/src/mnode.c index e902e13a36ffe57873dd32dfe60f49bad32d5695..3a55961d4ad93c5000686c01c8440eac03cf8610 100644 --- a/source/dnode/mnode/impl/src/mnode.c +++ b/source/dnode/mnode/impl/src/mnode.c @@ -202,8 +202,6 @@ static int32_t mndExecSteps(SMnode *pMnode) { SMnodeStep *pStep = taosArrayGet(pMnode->pSteps, pos); if (pStep->initFp == NULL) continue; - // (*pMnode->reportProgress)(pStep->name, "start initialize"); - if ((*pStep->initFp)(pMnode) != 0) { int32_t code = terrno; mError("step:%s exec failed since %s, start to cleanup", pStep->name, terrstr()); @@ -213,8 +211,6 @@ static int32_t mndExecSteps(SMnode *pMnode) { } else { mDebug("step:%s is initialized", pStep->name); } - - // (*pMnode->reportProgress)(pStep->name, "initialize completed"); } return 0; diff --git a/source/dnode/mnode/sdb/inc/sdbInt.h b/source/dnode/mnode/sdb/inc/sdbInt.h index da90451202ef07edfdff8e9ca3bf350ab1c2c61f..070aa569447bb0b9bc2ad5f9b55ee1c9ee40a439 100644 --- a/source/dnode/mnode/sdb/inc/sdbInt.h +++ b/source/dnode/mnode/sdb/inc/sdbInt.h @@ -72,7 +72,9 @@ typedef struct SSdb { } SSdb; int32_t sdbWriteFile(SSdb *pSdb); -void sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper); + +const char *sdbTableName(ESdbType type); +void sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper); #ifdef __cplusplus } diff --git a/source/dnode/mnode/sdb/src/sdbFile.c b/source/dnode/mnode/sdb/src/sdbFile.c index 78cf0a3492ffa279af42bbdda6a19ba0b2907715..5a03b3409e08c3baf180bdad5287070b549c61dc 100644 --- a/source/dnode/mnode/sdb/src/sdbFile.c +++ b/source/dnode/mnode/sdb/src/sdbFile.c @@ -121,6 +121,8 @@ int32_t sdbWriteFile(SSdb *pSdb) { char curfile[PATH_MAX] = {0}; snprintf(curfile, sizeof(curfile), "%s%ssdb.data", pSdb->currDir, TD_DIRSEP); + mDebug("start to write file:%s", curfile); + FileFd fd = taosOpenFileCreateWrite(tmpfile); if (fd <= 0) { terrno = TAOS_SYSTEM_ERROR(errno); @@ -132,6 +134,8 @@ int32_t sdbWriteFile(SSdb *pSdb) { SdbEncodeFp encodeFp = pSdb->encodeFps[i]; if (encodeFp == NULL) continue; + mTrace("sdb write %s, total %d rows", sdbTableName(i), sdbGetSize(pSdb, i)); + SHashObj *hash = pSdb->hashObjs[i]; SRWLatch *pLock = &pSdb->locks[i]; taosWLockLatch(pLock); @@ -144,6 +148,8 @@ int32_t sdbWriteFile(SSdb *pSdb) { continue; } + sdbPrintOper(pSdb, pRow, "writeFile"); + SSdbRaw *pRaw = (*encodeFp)(pRow->pObj); if (pRaw != NULL) { pRaw->status = pRow->status; diff --git a/source/dnode/mnode/sdb/src/sdbHash.c b/source/dnode/mnode/sdb/src/sdbHash.c index 0388fa99f5af66b534ae438f395039aae607d5c3..597484dad1faed1ae5509f3dda3535a6cf1b61bc 100644 --- a/source/dnode/mnode/sdb/src/sdbHash.c +++ b/source/dnode/mnode/sdb/src/sdbHash.c @@ -16,7 +16,7 @@ #define _DEFAULT_SOURCE #include "sdbInt.h" -static const char *sdbTableName(ESdbType type) { +const char *sdbTableName(ESdbType type) { switch (type) { case SDB_TRANS: return "trans"; @@ -57,12 +57,14 @@ void sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper) { EKeyType keyType = pSdb->keyTypes[pRow->type]; if (keyType == SDB_KEY_BINARY) { - mTrace("%s:%s, refCount:%d oper:%s", sdbTableName(pRow->type), (char *)pRow->pObj, pRow->refCount, oper); + mTrace("%s:%s, refCount:%d oper:%s row:%p", sdbTableName(pRow->type), (char *)pRow->pObj, pRow->refCount, oper, + pRow->pObj); } else if (keyType == SDB_KEY_INT32) { - mTrace("%s:%d, refCount:%d oper:%s", sdbTableName(pRow->type), *(int32_t *)pRow->pObj, pRow->refCount, oper); + mTrace("%s:%d, refCount:%d oper:%s row:%p", sdbTableName(pRow->type), *(int32_t *)pRow->pObj, pRow->refCount, oper, + pRow->pObj); } else if (keyType == SDB_KEY_INT64) { - mTrace("%s:%" PRId64 ", refCount:%d oper:%s", sdbTableName(pRow->type), *(int64_t *)pRow->pObj, pRow->refCount, - oper); + mTrace("%s:%" PRId64 ", refCount:%d oper:%s row:%p", sdbTableName(pRow->type), *(int64_t *)pRow->pObj, + pRow->refCount, oper, pRow->pObj); } else { } } diff --git a/source/dnode/mnode/sdb/src/sdbRow.c b/source/dnode/mnode/sdb/src/sdbRow.c index 4c889a6d04a303ec94ec4dfa61571259694166e3..e51dd48dcdd9fff0652e13d5b94cbe961e93bfad 100644 --- a/source/dnode/mnode/sdb/src/sdbRow.c +++ b/source/dnode/mnode/sdb/src/sdbRow.c @@ -23,6 +23,7 @@ SSdbRow *sdbAllocRow(int32_t objSize) { return NULL; } + mTrace("row:%p, is created, len:%d", pRow->pObj, objSize); return pRow; } @@ -43,5 +44,7 @@ void sdbFreeRow(SSdb *pSdb, SSdbRow *pRow) { } sdbPrintOper(pSdb, pRow, "freeRow"); + + mTrace("row:%p, is freed", pRow->pObj); tfree(pRow); } diff --git a/source/dnode/vnode/meta/src/metaBDBImpl.c b/source/dnode/vnode/meta/src/metaBDBImpl.c index 4254ad0acde0fcdda9027b2ab5aca76a5bf3ad71..b8ad7ab235549a92ee116201198def619aaea046 100644 --- a/source/dnode/vnode/meta/src/metaBDBImpl.c +++ b/source/dnode/vnode/meta/src/metaBDBImpl.c @@ -577,11 +577,16 @@ char *metaTbCursorNext(SMTbCursor *pTbCur) { STbCfg tbCfg; void * pBuf; - if (pTbCur->pCur->get(pTbCur->pCur, &key, &value, DB_NEXT) == 0) { - pBuf = value.data; - metaDecodeTbInfo(pBuf, &tbCfg); - return tbCfg.name; - } else { - return NULL; + for (;;) { + if (pTbCur->pCur->get(pTbCur->pCur, &key, &value, DB_NEXT) == 0) { + pBuf = value.data; + metaDecodeTbInfo(pBuf, &tbCfg); + if (tbCfg.type == META_SUPER_TABLE) { + continue; + } + return tbCfg.name; + } else { + return NULL; + } } } \ No newline at end of file diff --git a/source/util/src/encode.c b/source/util/src/encode.c index 40c03ea05196b2dcf4760b01467a0de85c0d617f..758d3f442db0007ea60317827d582d50f60f8d75 100644 --- a/source/util/src/encode.c +++ b/source/util/src/encode.c @@ -88,13 +88,9 @@ void tEndEncode(SCoder* pCoder) { pCoder->size = pNode->size; pCoder->pos = pNode->pos; - if (TD_RT_ENDIAN() == pCoder->endian) { - tPut(int32_t, pCoder->data + pCoder->pos, len); - } else { - tRPut32(pCoder->data + pCoder->pos, len); - } + tEncodeI32(pCoder, len); - TD_CODER_MOVE_POS(pCoder, len + sizeof(int32_t)); + TD_CODER_MOVE_POS(pCoder, len); free(pNode); } @@ -127,15 +123,14 @@ void tEndDecode(SCoder* pCoder) { struct SCoderNode* pNode; ASSERT(pCoder->type == TD_DECODER); - ASSERT(tDecodeIsEnd(pCoder)); pNode = TD_SLIST_HEAD(&(pCoder->stack)); ASSERT(pNode); TD_SLIST_POP(&(pCoder->stack)); pCoder->data = pNode->data; + pCoder->pos = pCoder->size + pNode->pos; pCoder->size = pNode->size; - pCoder->pos = pCoder->pos + pNode->pos; free(pNode); } diff --git a/source/util/test/encodeTest.cpp b/source/util/test/encodeTest.cpp index 1a861701d78791ea3c36a2808dd2f59a713ccc3f..b178ee0b10b6fedc7f28299e8973f530e8fa3231 100644 --- a/source/util/test/encodeTest.cpp +++ b/source/util/test/encodeTest.cpp @@ -360,8 +360,8 @@ TEST(td_encode_test, compound_struct_encode_test) { SStructA_v2 sa2 = {.A_a = 10, .A_b = 65478, .A_c = "Hello", .A_d = 67, .A_e = 13}; SFinalReq_v1 req1 = {.pA = &sa1, .v_a = 15, .v_b = 35}; SFinalReq_v2 req2 = {.pA = &sa2, .v_a = 15, .v_b = 32, .v_c = 37}; - SFinalReq_v1 dreq1; - SFinalReq_v2 dreq21, dreq22; + SFinalReq_v1 dreq11, dreq21; + SFinalReq_v2 dreq12, dreq22; // Get size tCoderInit(&encoder, TD_LITTLE_ENDIAN, nullptr, 0, TD_ENCODER); @@ -386,27 +386,30 @@ TEST(td_encode_test, compound_struct_encode_test) { tCoderClear(&encoder); // Decode + // buf1 -> req1 tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf1, buf1size, TD_DECODER); - GTEST_ASSERT_EQ(tSFinalReq_v1_decode(&decoder, &dreq1), 0); - GTEST_ASSERT_EQ(dreq1.pA->A_a, req1.pA->A_a); - GTEST_ASSERT_EQ(dreq1.pA->A_b, req1.pA->A_b); - GTEST_ASSERT_EQ(strcmp(dreq1.pA->A_c, req1.pA->A_c), 0); - GTEST_ASSERT_EQ(dreq1.v_a, req1.v_a); - GTEST_ASSERT_EQ(dreq1.v_b, req1.v_b); + GTEST_ASSERT_EQ(tSFinalReq_v1_decode(&decoder, &dreq11), 0); + GTEST_ASSERT_EQ(dreq11.pA->A_a, req1.pA->A_a); + GTEST_ASSERT_EQ(dreq11.pA->A_b, req1.pA->A_b); + GTEST_ASSERT_EQ(strcmp(dreq11.pA->A_c, req1.pA->A_c), 0); + GTEST_ASSERT_EQ(dreq11.v_a, req1.v_a); + GTEST_ASSERT_EQ(dreq11.v_b, req1.v_b); tCoderClear(&decoder); + // buf1 -> req2 (backward compatibility) tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf1, buf1size, TD_DECODER); - GTEST_ASSERT_EQ(tSFinalReq_v2_decode(&decoder, &dreq21), 0); - GTEST_ASSERT_EQ(dreq21.pA->A_a, req1.pA->A_a); - GTEST_ASSERT_EQ(dreq21.pA->A_b, req1.pA->A_b); - GTEST_ASSERT_EQ(strcmp(dreq21.pA->A_c, req1.pA->A_c), 0); - GTEST_ASSERT_EQ(dreq21.pA->A_d, 0); - GTEST_ASSERT_EQ(dreq21.pA->A_e, 0); - GTEST_ASSERT_EQ(dreq21.v_a, req1.v_a); - GTEST_ASSERT_EQ(dreq21.v_b, req1.v_b); - GTEST_ASSERT_EQ(dreq21.v_c, 0); + GTEST_ASSERT_EQ(tSFinalReq_v2_decode(&decoder, &dreq12), 0); + GTEST_ASSERT_EQ(dreq12.pA->A_a, req1.pA->A_a); + GTEST_ASSERT_EQ(dreq12.pA->A_b, req1.pA->A_b); + GTEST_ASSERT_EQ(strcmp(dreq12.pA->A_c, req1.pA->A_c), 0); + GTEST_ASSERT_EQ(dreq12.pA->A_d, 0); + GTEST_ASSERT_EQ(dreq12.pA->A_e, 0); + GTEST_ASSERT_EQ(dreq12.v_a, req1.v_a); + GTEST_ASSERT_EQ(dreq12.v_b, req1.v_b); + GTEST_ASSERT_EQ(dreq12.v_c, 0); tCoderClear(&decoder); + // buf2 -> req2 tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf2, buf2size, TD_DECODER); GTEST_ASSERT_EQ(tSFinalReq_v2_decode(&decoder, &dreq22), 0); GTEST_ASSERT_EQ(dreq22.pA->A_a, req2.pA->A_a); @@ -418,4 +421,13 @@ TEST(td_encode_test, compound_struct_encode_test) { GTEST_ASSERT_EQ(dreq22.v_b, req2.v_b); GTEST_ASSERT_EQ(dreq22.v_c, req2.v_c); tCoderClear(&decoder); + + tCoderInit(&decoder, TD_LITTLE_ENDIAN, buf2, buf2size, TD_DECODER); + GTEST_ASSERT_EQ(tSFinalReq_v1_decode(&decoder, &dreq21), 0); + GTEST_ASSERT_EQ(dreq21.pA->A_a, req2.pA->A_a); + GTEST_ASSERT_EQ(dreq21.pA->A_b, req2.pA->A_b); + GTEST_ASSERT_EQ(strcmp(dreq21.pA->A_c, req2.pA->A_c), 0); + GTEST_ASSERT_EQ(dreq21.v_a, req2.v_a); + GTEST_ASSERT_EQ(dreq21.v_b, req2.v_b); + tCoderClear(&decoder); } \ No newline at end of file diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 966eb943541fda493dd120c12e1ba6be1c93cf48..59cbbb31471acc377dd614610aa715ae72c9ec31 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,4 +1,4 @@ #ADD_SUBDIRECTORY(examples/c) ADD_SUBDIRECTORY(tsim) -#ADD_SUBDIRECTORY(test/c) +ADD_SUBDIRECTORY(test/c) #ADD_SUBDIRECTORY(comparisonTest/tdengine) diff --git a/tests/test/c/CMakeLists.txt b/tests/test/c/CMakeLists.txt index 2702d192d3f47022f05888f90ca89c4ef533fe44..ebe9f96989560bd3ffa4072f53e4a54f93a28b8f 100644 --- a/tests/test/c/CMakeLists.txt +++ b/tests/test/c/CMakeLists.txt @@ -1,52 +1,8 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 2.8...3.20) -PROJECT(TDengine) - -INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc) -INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc) -INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc) -INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc) -INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc) -INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/mnode/inc) -INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/tsdb/inc) -INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/plugins/http/inc) -INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc) -INCLUDE_DIRECTORIES(${TD_ENTERPRISE_DIR}/src/inc) - -IF (TD_LINUX) - #add_executable(insertPerTable insertPerTable.c) - #target_link_libraries(insertPerTable taos_static pthread) - - #add_executable(insertPerRow insertPerRow.c) - #target_link_libraries(insertPerRow taos_static pthread) - - #add_executable(importOneRow importOneRow.c) - #target_link_libraries(importOneRow taos_static pthread) - - #add_executable(importPerTable importPerTable.c) - #target_link_libraries(importPerTable taos_static pthread) - - #add_executable(hashPerformance hashPerformance.c) - #target_link_libraries(hashPerformance taos_static tutil common pthread) - - #add_executable(createTablePerformance createTablePerformance.c) - #target_link_libraries(createTablePerformance taos_static tutil common pthread) - - #add_executable(createNormalTable createNormalTable.c) - #target_link_libraries(createNormalTable taos_static tutil common pthread) - - #add_executable(queryPerformance queryPerformance.c) - #target_link_libraries(queryPerformance taos_static tutil common pthread) - - #add_executable(httpTest httpTest.c) - #target_link_libraries(httpTest taos_static tutil common pthread mnode monitor http tsdb twal vnode cJson lz4) - - #add_executable(cacheTest cacheTest.c) - #target_link_libraries(cacheTest taos_static tutil common pthread mnode monitor http tsdb twal vnode cJson lz4) - - #add_executable(invalidTableId invalidTableId.c) - #target_link_libraries(invalidTableId taos_static tutil common pthread) - - #add_executable(hashIterator hashIterator.c) - #target_link_libraries(hashIterator taos_static tutil common pthread) -ENDIF() - +add_executable(create_table create_table.c) +target_link_libraries( + create_table + PUBLIC taos + PUBLIC util + PUBLIC common + PUBLIC os +) diff --git a/tests/test/c/cacheTest.c b/tests/test/c/cacheTest.c deleted file mode 100644 index ce5d7d1421d9d55d6bfab4a690d87f94c17ded29..0000000000000000000000000000000000000000 --- a/tests/test/c/cacheTest.c +++ /dev/null @@ -1,146 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include -#include "../../../include/client/taos.h" -#include "os.h" -#include "tcache.h" -#include "tulog.h" -#include "tutil.h" - -#define MAX_REFRESH_TIME_SEC 2 -#define MAX_RANDOM_POINTS 20000 -#define GREEN "\033[1;32m" -#define NC "\033[0m" - -int32_t tsKeepTimeInSec = 3; -int32_t tsNumOfRows = 1000000; -int32_t tsSizeOfRow = 64 * 1024; -void * tsCacheObj = NULL; -int32_t destroyTimes = 0; - -typedef int64_t CacheTestKey; -typedef struct CacheTestRow { - int32_t index; - void ** ppRow; - void * data; -} CacheTestRow; - -CacheTestRow *initRow(int32_t index) { - CacheTestRow *row = calloc(sizeof(CacheTestRow), 1); - row->index = index; - row->data = malloc(tsSizeOfRow * sizeof(int8_t)); - return row; -} - -void detroyRow(void *data) { - CacheTestRow *row = *(CacheTestRow **)data; - free(row->data); - free(row); - destroyTimes++; - if (destroyTimes % 50000 == 0) { - pPrint("%s ===> destroyTimes:%d %s", GREEN, destroyTimes, NC); - } -} - -void initCache() { - tsCacheObj = taosCacheInit(TSDB_DATA_TYPE_BIGINT, MAX_REFRESH_TIME_SEC, true, detroyRow, "cachetest"); -} - -void putRowInCache() { - for (int index = 0; index < tsNumOfRows; ++index) { - CacheTestRow *row = initRow(index); - uint64_t key = (uint64_t)row; - void **ppRow = taosCachePut(tsCacheObj, &key, sizeof(int64_t), &row, sizeof(int64_t), tsKeepTimeInSec * 1000); - row->ppRow = ppRow; - taosCacheRelease(tsCacheObj, (void **)&ppRow, false); - } -} - -void cleanupCache() { - taosCacheCleanup(tsCacheObj); -} - -void initGetMemory() { - osInit(); - taos_init(); -} - -float getProcMemory() { - float procMemoryUsedMB = 0; - taosGetProcMemory(&procMemoryUsedMB); - return procMemoryUsedMB; -} - -void doTest() { - initCache(); - pPrint("%s initialize procMemory %f MB %s", GREEN, getProcMemory(), NC); - - putRowInCache(); - pPrint("%s insert %d rows, procMemory %f MB %s", GREEN, tsNumOfRows, getProcMemory(), NC); - - int32_t sleepMs = (MAX_REFRESH_TIME_SEC * 3) * 1000 + tsKeepTimeInSec * 1000; - taosMsleep(sleepMs); - pPrint("%s after sleep %d ms, procMemory %f MB %s", GREEN, sleepMs, getProcMemory(), NC); - - cleanupCache(); - taosMsleep(sleepMs); - pPrint("%s after cleanup cache, procMemory %f MB %s", GREEN, getProcMemory(), NC); - - malloc_trim(0); - taosMsleep(sleepMs); - pPrint("%s after malloc_trim, procMemory %f MB %s", GREEN, getProcMemory(), NC); -} - -void printHelp() { - char indent[10] = " "; - printf("Used to test the performance of cache\n"); - - printf("%s%s\n", indent, "-k"); - printf("%s%s%s%d\n", indent, indent, "KeepTimeInSec, default is ", tsKeepTimeInSec); - printf("%s%s\n", indent, "-n"); - printf("%s%s%s%d\n", indent, indent, "NumOfRows, default is ", tsNumOfRows); - printf("%s%s\n", indent, "-s"); - printf("%s%s%s%d\n", indent, indent, "SizeOfData, default is ", tsSizeOfRow); - - exit(EXIT_SUCCESS); -} - -void parseArgument(int argc, char *argv[]) { - for (int i = 1; i < argc; i++) { - if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { - printHelp(); - exit(0); - } else if (strcmp(argv[i], "-k") == 0) { - tsKeepTimeInSec = atoi(argv[++i]); - } else if (strcmp(argv[i], "-n") == 0) { - tsNumOfRows = atoi(argv[++i]); - } else if (strcmp(argv[i], "-s") == 0) { - tsSizeOfRow = atoi(argv[++i]); - } else { - } - } - - pPrint("%s KeepTimeInSec:%d %s", GREEN, tsKeepTimeInSec, NC); - pPrint("%s NumOfRows:%d %s", GREEN, tsNumOfRows, NC); - pPrint("%s SizeOfData:%d %s", GREEN, tsSizeOfRow, NC); -} - -int main(int argc, char *argv[]) { - initGetMemory(); - parseArgument(argc, argv); - doTest(); -} diff --git a/tests/test/c/createTablePerformance.c b/tests/test/c/createTablePerformance.c deleted file mode 100644 index 1a59657f1a48ef5ac58e788b2bc2bdf5f6327da1..0000000000000000000000000000000000000000 --- a/tests/test/c/createTablePerformance.c +++ /dev/null @@ -1,225 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "../../../include/client/taos.h" -#include "hash.h" -#include "os.h" -#include "taoserror.h" -#include "tglobal.h" -#include "tulog.h" -#include "tutil.h" - -#define MAX_RANDOM_POINTS 20000 -#define GREEN "\033[1;32m" -#define NC "\033[0m" - -char dbName[32] = "db"; -char stableName[64] = "st"; -int32_t numOfThreads = 30; -int32_t numOfTables = 100000; -int32_t replica = 1; -int32_t numOfColumns = 2; -TAOS * con = NULL; - -typedef struct { - int32_t tableBeginIndex; - int32_t tableEndIndex; - int32_t threadIndex; - char dbName[32]; - char stableName[64]; - float createTableSpeed; - pthread_t thread; -} SThreadInfo; - -void shellParseArgument(int argc, char *argv[]); -void *threadFunc(void *param); -void createDbAndSTable(); - -int main(int argc, char *argv[]) { - shellParseArgument(argc, argv); - taos_init(); - createDbAndSTable(); - - pPrint("%d threads are spawned to create table", numOfThreads); - - pthread_attr_t thattr; - pthread_attr_init(&thattr); - pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE); - SThreadInfo *pInfo = (SThreadInfo *)calloc(numOfThreads, sizeof(SThreadInfo)); - - int32_t numOfTablesPerThread = numOfTables / numOfThreads; - numOfTables = numOfTablesPerThread * numOfThreads; - for (int i = 0; i < numOfThreads; ++i) { - pInfo[i].tableBeginIndex = i * numOfTablesPerThread; - pInfo[i].tableEndIndex = (i + 1) * numOfTablesPerThread; - pInfo[i].threadIndex = i; - strcpy(pInfo[i].dbName, dbName); - strcpy(pInfo[i].stableName, stableName); - pthread_create(&(pInfo[i].thread), &thattr, threadFunc, (void *)(pInfo + i)); - } - - taosMsleep(300); - for (int i = 0; i < numOfThreads; i++) { - pthread_join(pInfo[i].thread, NULL); - } - - float createTableSpeed = 0; - for (int i = 0; i < numOfThreads; ++i) { - createTableSpeed += pInfo[i].createTableSpeed; - } - - pPrint("%s total speed:%.1f tables/second, threads:%d %s", GREEN, createTableSpeed, numOfThreads, NC); - - pthread_attr_destroy(&thattr); - free(pInfo); - taos_close(con); -} - -void createDbAndSTable() { - pPrint("start to create db and stable"); - char qstr[64000]; - - con = taos_connect(NULL, "root", "taosdata", NULL, 0); - if (con == NULL) { - pError("failed to connect to DB, reason:%s", taos_errstr(con)); - exit(1); - } - - sprintf(qstr, "create database if not exists %s replica %d", dbName, replica); - TAOS_RES *pSql = taos_query(con, qstr); - int32_t code = taos_errno(pSql); - if (code != 0) { - pError("failed to create database:%s, sql:%s, code:%d reason:%s", dbName, qstr, taos_errno(con), taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - - sprintf(qstr, "use %s", dbName); - pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to use db, code:%d reason:%s", taos_errno(con), taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - - int len = sprintf(qstr, "create table if not exists %s(ts timestamp", stableName); - for (int32_t f = 0; f < numOfColumns - 1; ++f) { - len += sprintf(qstr + len, ", f%d double", f); - } - sprintf(qstr + len, ") tags(t int)"); - - pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to create stable, code:%d reason:%s", taos_errno(con), taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); -} - -void *threadFunc(void *param) { - SThreadInfo *pInfo = (SThreadInfo *)param; - char qstr[65000]; - int code; - - sprintf(qstr, "use %s", pInfo->dbName); - TAOS_RES *pSql = taos_query(con, qstr); - taos_free_result(pSql); - - int64_t startMs = taosGetTimestampMs(); - - for (int32_t t = pInfo->tableBeginIndex; t < pInfo->tableEndIndex; ++t) { - sprintf(qstr, "create table if not exists %s%d using %s tags(%d)", stableName, t, stableName, t); - TAOS_RES *pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to create table %s%d, reason:%s", stableName, t, tstrerror(code)); - } - taos_free_result(pSql); - } - - float createTableSpeed = 0; - for (int i = 0; i < numOfThreads; ++i) { - createTableSpeed += pInfo[i].createTableSpeed; - } - - int64_t endMs = taosGetTimestampMs(); - int32_t totalTables = pInfo->tableEndIndex - pInfo->tableBeginIndex; - float seconds = (endMs - startMs) / 1000.0; - float speed = totalTables / seconds; - pInfo->createTableSpeed = speed; - - pPrint("thread:%d, time:%.2f sec, speed:%.1f tables/second, ", pInfo->threadIndex, seconds, speed); - - return 0; -} - -void printHelp() { - char indent[10] = " "; - printf("Used to test the performance while create table\n"); - - printf("%s%s\n", indent, "-c"); - printf("%s%s%s%s\n", indent, indent, "Configuration directory, default is ", configDir); - printf("%s%s\n", indent, "-d"); - printf("%s%s%s%s\n", indent, indent, "The name of the database to be created, default is ", dbName); - printf("%s%s\n", indent, "-s"); - printf("%s%s%s%s\n", indent, indent, "The name of the super table to be created, default is ", stableName); - printf("%s%s\n", indent, "-t"); - printf("%s%s%s%d\n", indent, indent, "numOfThreads, default is ", numOfThreads); - printf("%s%s\n", indent, "-n"); - printf("%s%s%s%d\n", indent, indent, "numOfTables, default is ", numOfTables); - printf("%s%s\n", indent, "-r"); - printf("%s%s%s%d\n", indent, indent, "replica, default is ", replica); - printf("%s%s\n", indent, "-columns"); - printf("%s%s%s%d\n", indent, indent, "numOfColumns, default is ", numOfColumns); - - exit(EXIT_SUCCESS); -} - -void shellParseArgument(int argc, char *argv[]) { - for (int i = 1; i < argc; i++) { - if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { - printHelp(); - exit(0); - } else if (strcmp(argv[i], "-d") == 0) { - strcpy(dbName, argv[++i]); - } else if (strcmp(argv[i], "-c") == 0) { - strcpy(configDir, argv[++i]); - } else if (strcmp(argv[i], "-s") == 0) { - strcpy(stableName, argv[++i]); - } else if (strcmp(argv[i], "-t") == 0) { - numOfThreads = atoi(argv[++i]); - } else if (strcmp(argv[i], "-n") == 0) { - numOfTables = atoi(argv[++i]); - } else if (strcmp(argv[i], "-r") == 0) { - replica = atoi(argv[++i]); - } else if (strcmp(argv[i], "-columns") == 0) { - numOfColumns = atoi(argv[++i]); - } else { - } - } - - pPrint("%s dbName:%s %s", GREEN, dbName, NC); - pPrint("%s stableName:%s %s", GREEN, stableName, NC); - pPrint("%s configDir:%s %s", GREEN, configDir, NC); - pPrint("%s numOfTables:%d %s", GREEN, numOfTables, NC); - pPrint("%s numOfThreads:%d %s", GREEN, numOfThreads, NC); - pPrint("%s numOfColumns:%d %s", GREEN, numOfColumns, NC); - pPrint("%s replica:%d %s", GREEN, replica, NC); - - pPrint("%s start create table performace test %s", GREEN, NC); -} diff --git a/tests/test/c/createNormalTable.c b/tests/test/c/create_table.c similarity index 59% rename from tests/test/c/createNormalTable.c rename to tests/test/c/create_table.c index f9e4aa5a3a8e1a60b77facd97e7e9bb4617294a5..96c7f873929aacddf29a2d13be399188f0f7a3ca 100644 --- a/tests/test/c/createNormalTable.c +++ b/tests/test/c/create_table.c @@ -14,48 +14,49 @@ */ #define _DEFAULT_SOURCE -#include "../../../include/client/taos.h" -#include "hash.h" #include "os.h" + +#include "taos.h" +#include "taosdef.h" #include "taoserror.h" -#include "tglobal.h" -#include "tulog.h" +#include "thash.h" #include "tutil.h" +#include "ulog.h" #define MAX_RANDOM_POINTS 20000 #define GREEN "\033[1;32m" #define NC "\033[0m" char dbName[32] = "db"; -char stableName[64] = "st"; -int32_t numOfThreads = 30; -int32_t numOfTables = 100000; -int32_t replica = 1; -int32_t numOfColumns = 2; +char stbName[64] = "st"; +int32_t numOfThreads = 2; +int32_t numOfTables = 10000; +int32_t createTable = 1; +int32_t insertData = 0; +int32_t batchNum = 1; +int32_t numOfVgroups = 2; typedef struct { int32_t tableBeginIndex; int32_t tableEndIndex; int32_t threadIndex; char dbName[32]; - char stableName[64]; + char stbName[64]; float createTableSpeed; + float insertDataSpeed; pthread_t thread; } SThreadInfo; -void shellParseArgument(int argc, char *argv[]); +void parseArgument(int argc, char *argv[]); void *threadFunc(void *param); -void createDbAndSTable(); +void createDbAndStb(); int main(int argc, char *argv[]) { - shellParseArgument(argc, argv); - taos_init(); - if (replica != 0) { - createDbAndSTable(); - } + parseArgument(argc, argv); + createDbAndStb(); + + pPrint("%d threads are spawned to create %d tables", numOfThreads, numOfThreads); - pPrint("%d threads are spawned to create table", numOfThreads); - pthread_attr_t thattr; pthread_attr_init(&thattr); pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE); @@ -68,7 +69,7 @@ int main(int argc, char *argv[]) { pInfo[i].tableEndIndex = (i + 1) * numOfTablesPerThread; pInfo[i].threadIndex = i; strcpy(pInfo[i].dbName, dbName); - strcpy(pInfo[i].stableName, stableName); + strcpy(pInfo[i].stbName, stbName); pthread_create(&(pInfo[i].thread), &thattr, threadFunc, (void *)(pInfo + i)); } @@ -82,25 +83,31 @@ int main(int argc, char *argv[]) { createTableSpeed += pInfo[i].createTableSpeed; } - pPrint("%s total speed:%.1f tables/second, threads:%d %s", GREEN, createTableSpeed, numOfThreads, NC); + float insertDataSpeed = 0; + for (int i = 0; i < numOfThreads; ++i) { + insertDataSpeed += pInfo[i].insertDataSpeed; + } + + pPrint("%s total %.1f tables/second, threads:%d %s", GREEN, createTableSpeed, numOfThreads, NC); + pPrint("%s total %.1f rows/second, threads:%d %s", GREEN, insertDataSpeed, numOfThreads, NC); pthread_attr_destroy(&thattr); free(pInfo); } -void createDbAndSTable() { +void createDbAndStb() { pPrint("start to create db and stable"); char qstr[64000]; - + TAOS *con = taos_connect(NULL, "root", "taosdata", NULL, 0); if (con == NULL) { pError("failed to connect to DB, reason:%s", taos_errstr(con)); exit(1); } - sprintf(qstr, "create database if not exists %s replica %d", dbName, replica); + sprintf(qstr, "create database if not exists %s vgroups %d", dbName, numOfVgroups); TAOS_RES *pSql = taos_query(con, qstr); - int32_t code = taos_errno(pSql); + int32_t code = taos_errno(pSql); if (code != 0) { pError("failed to create database:%s, sql:%s, code:%d reason:%s", dbName, qstr, taos_errno(con), taos_errstr(con)); exit(0); @@ -116,13 +123,22 @@ void createDbAndSTable() { } taos_free_result(pSql); + sprintf(qstr, "create table %s (ts timestamp, i int) tags (j int)", stbName); + pSql = taos_query(con, qstr); + code = taos_errno(pSql); + if (code != 0) { + pError("failed to use db, code:%d reason:%s", taos_errno(con), taos_errstr(con)); + exit(0); + } + taos_free_result(pSql); + taos_close(con); } void *threadFunc(void *param) { SThreadInfo *pInfo = (SThreadInfo *)param; - char qstr[65000]; - int code; + char qstr[65000]; + int code; TAOS *con = taos_connect(NULL, "root", "taosdata", NULL, 0); if (con == NULL) { @@ -134,49 +150,45 @@ void *threadFunc(void *param) { TAOS_RES *pSql = taos_query(con, qstr); taos_free_result(pSql); - int64_t startMs = taosGetTimestampMs(); - - if (replica != 0) { + if (createTable) { + int64_t startMs = taosGetTimestampMs(); for (int32_t t = pInfo->tableBeginIndex; t < pInfo->tableEndIndex; ++t) { - sprintf(qstr, "create table %s%d (ts timestamp, i int)", stableName, t); + sprintf(qstr, "create table t%d using %s tags(%d)", t, stbName, t); TAOS_RES *pSql = taos_query(con, qstr); code = taos_errno(pSql); if (code != 0) { - pError("failed to create table %s%d, reason:%s", stableName, t, tstrerror(code)); + pError("failed to create table t%d, reason:%s", t, tstrerror(code)); } taos_free_result(pSql); } - } else { + int64_t endMs = taosGetTimestampMs(); + int32_t totalTables = pInfo->tableEndIndex - pInfo->tableBeginIndex; + float seconds = (endMs - startMs) / 1000.0; + float speed = totalTables / seconds; + pInfo->createTableSpeed = speed; + pPrint("thread:%d, time:%.2f sec, speed:%.1f tables/second, ", pInfo->threadIndex, seconds, speed); + } + + if (insertData) { + int64_t startMs = taosGetTimestampMs(); for (int32_t t = pInfo->tableBeginIndex; t < pInfo->tableEndIndex; ++t) { - sprintf(qstr, "insert into %s%d values(now, 1)", stableName, t); + sprintf(qstr, "insert into %s%d values(now, 1)", stbName, t); TAOS_RES *pSql = taos_query(con, qstr); code = taos_errno(pSql); if (code != 0) { - if (code != TSDB_CODE_MND_INVALID_TABLE_NAME) { - pError("failed to create table %s%d, reason:%s", stableName, t, tstrerror(code)); - } - if (code == TSDB_CODE_VND_INVALID_VGROUP_ID) { - exit(0); - } + pError("failed to create table %s%d, reason:%s", stbName, t, tstrerror(code)); } taos_free_result(pSql); } + int64_t endMs = taosGetTimestampMs(); + int32_t totalTables = pInfo->tableEndIndex - pInfo->tableBeginIndex; + float seconds = (endMs - startMs) / 1000.0; + float speed = totalTables / seconds; + pInfo->insertDataSpeed = speed; + pPrint("thread:%d, time:%.2f sec, speed:%.1f rows/second, ", pInfo->threadIndex, seconds, speed); } - float createTableSpeed = 0; - for (int i = 0; i < numOfThreads; ++i) { - createTableSpeed += pInfo[i].createTableSpeed; - } - - int64_t endMs = taosGetTimestampMs(); - int32_t totalTables = pInfo->tableEndIndex - pInfo->tableBeginIndex; - float seconds = (endMs - startMs) / 1000.0; - float speed = totalTables / seconds; - pInfo->createTableSpeed = speed; - - pPrint("thread:%d, time:%.2f sec, speed:%.1f tables/second, ", pInfo->threadIndex, seconds, speed); taos_close(con); - return 0; } @@ -189,20 +201,24 @@ void printHelp() { printf("%s%s\n", indent, "-d"); printf("%s%s%s%s\n", indent, indent, "The name of the database to be created, default is ", dbName); printf("%s%s\n", indent, "-s"); - printf("%s%s%s%s\n", indent, indent, "The name of the super table to be created, default is ", stableName); + printf("%s%s%s%s\n", indent, indent, "The name of the super table to be created, default is ", stbName); printf("%s%s\n", indent, "-t"); printf("%s%s%s%d\n", indent, indent, "numOfThreads, default is ", numOfThreads); printf("%s%s\n", indent, "-n"); printf("%s%s%s%d\n", indent, indent, "numOfTables, default is ", numOfTables); - printf("%s%s\n", indent, "-r"); - printf("%s%s%s%d\n", indent, indent, "replica, default is ", replica); - printf("%s%s\n", indent, "-columns"); - printf("%s%s%s%d\n", indent, indent, "numOfColumns, default is ", numOfColumns); - + printf("%s%s\n", indent, "-v"); + printf("%s%s%s%d\n", indent, indent, "numOfVgroups, default is ", numOfVgroups); + printf("%s%s\n", indent, "-a"); + printf("%s%s%s%d\n", indent, indent, "createTable, default is ", createTable); + printf("%s%s\n", indent, "-i"); + printf("%s%s%s%d\n", indent, indent, "insertData, default is ", insertData); + printf("%s%s\n", indent, "-b"); + printf("%s%s%s%d\n", indent, indent, "batchNum, default is ", batchNum); + exit(EXIT_SUCCESS); } -void shellParseArgument(int argc, char *argv[]) { +void parseArgument(int argc, char *argv[]) { for (int i = 1; i < argc; i++) { if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { printHelp(); @@ -212,26 +228,32 @@ void shellParseArgument(int argc, char *argv[]) { } else if (strcmp(argv[i], "-c") == 0) { strcpy(configDir, argv[++i]); } else if (strcmp(argv[i], "-s") == 0) { - strcpy(stableName, argv[++i]); + strcpy(stbName, argv[++i]); } else if (strcmp(argv[i], "-t") == 0) { numOfThreads = atoi(argv[++i]); } else if (strcmp(argv[i], "-n") == 0) { numOfTables = atoi(argv[++i]); - } else if (strcmp(argv[i], "-r") == 0) { - replica = atoi(argv[++i]); - } else if (strcmp(argv[i], "-columns") == 0) { - numOfColumns = atoi(argv[++i]); + } else if (strcmp(argv[i], "-n") == 0) { + numOfVgroups = atoi(argv[++i]); + } else if (strcmp(argv[i], "-a") == 0) { + createTable = atoi(argv[++i]); + } else if (strcmp(argv[i], "-i") == 0) { + insertData = atoi(argv[++i]); + } else if (strcmp(argv[i], "-b") == 0) { + batchNum = atoi(argv[++i]); } else { } } pPrint("%s dbName:%s %s", GREEN, dbName, NC); - pPrint("%s stableName:%s %s", GREEN, stableName, NC); + pPrint("%s stbName:%s %s", GREEN, stbName, NC); pPrint("%s configDir:%s %s", GREEN, configDir, NC); pPrint("%s numOfTables:%d %s", GREEN, numOfTables, NC); pPrint("%s numOfThreads:%d %s", GREEN, numOfThreads, NC); - pPrint("%s numOfColumns:%d %s", GREEN, numOfColumns, NC); - pPrint("%s replica:%d %s", GREEN, replica, NC); - + pPrint("%s numOfVgroups:%d %s", GREEN, numOfVgroups, NC); + pPrint("%s createTable:%d %s", GREEN, createTable, NC); + pPrint("%s insertData:%d %s", GREEN, insertData, NC); + pPrint("%s batchNum:%d %s", GREEN, batchNum, NC); + pPrint("%s start create table performace test %s", GREEN, NC); } diff --git a/tests/test/c/hashIterator.c b/tests/test/c/hashIterator.c deleted file mode 100644 index 0d3dbb64d724c09c135eec5abee1486f05695e88..0000000000000000000000000000000000000000 --- a/tests/test/c/hashIterator.c +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "../../../include/client/taos.h" -#include "hash.h" -#include "os.h" -#include "tulog.h" -#include "tutil.h" - -typedef struct HashTestRow { - int32_t keySize; - char key[100]; -} HashTestRow; - -int main(int argc, char *argv[]) { - _hash_fn_t hashFp = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); - void * hashHandle = taosHashInit(100, hashFp, true, HASH_ENTRY_LOCK); - - pPrint("insert 3 rows to hash"); - for (int32_t t = 0; t < 3; ++t) { - HashTestRow row = {0}; - row.keySize = sprintf(row.key, "0.db.st%d", t); - - taosHashPut(hashHandle, row.key, row.keySize, &row, sizeof(HashTestRow)); - } - - pPrint("start iterator"); - HashTestRow *row = taosHashIterate(hashHandle, NULL); - while (row) { - pPrint("drop key:%s", row->key); - taosHashRemove(hashHandle, row->key, row->keySize); - - pPrint("get rows from hash"); - for (int32_t t = 0; t < 3; ++t) { - HashTestRow r = {0}; - r.keySize = sprintf(r.key, "0.db.st%d", t); - - void *result = taosHashGet(hashHandle, r.key, r.keySize); - pPrint("get key:%s result:%p", r.key, result); - } - - //Before getting the next iterator, the object just deleted can be obtained - row = taosHashIterate(hashHandle, row); - } - - pPrint("stop iterator"); - taosHashCancelIterate(hashHandle, row); - - pPrint("get rows from hash"); - for (int32_t t = 0; t < 3; ++t) { - HashTestRow r = {0}; - r.keySize = sprintf(r.key, "0.db.st%d", t); - - void *result = taosHashGet(hashHandle, r.key, r.keySize); - pPrint("get key:%s result:%p", r.key, result); - } - - return 0; -} \ No newline at end of file diff --git a/tests/test/c/hashPerformance.c b/tests/test/c/hashPerformance.c deleted file mode 100644 index 0f14fbff6a3bb491b43e0f96f11136e21e1638ce..0000000000000000000000000000000000000000 --- a/tests/test/c/hashPerformance.c +++ /dev/null @@ -1,166 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "../../../include/client/taos.h" -#include "hash.h" -#include "os.h" -#include "tulog.h" -#include "tutil.h" - -#define MAX_RANDOM_POINTS 20000 -#define GREEN "\033[1;32m" -#define NC "\033[0m" - -int32_t capacity = 128; -int32_t q1Times = 10; -int32_t q2Times = 10; -int32_t keyNum = 100000; -int32_t printInterval = 1000; -void * hashHandle; -pthread_t thread; - -typedef struct HashTestRow { - int32_t keySize; - char key[100]; -} HashTestRow; - -void shellParseArgument(int argc, char *argv[]); - -void testHashPerformance() { - int64_t initialMs = taosGetTimestampMs(); - _hash_fn_t hashFp = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); - hashHandle = taosHashInit(128, hashFp, true, HASH_NO_LOCK); - - int64_t startMs = taosGetTimestampMs(); - float seconds = (startMs - initialMs) / 1000.0; - pPrint("initial time %.2f sec", seconds); - - for (int32_t t = 1; t <= keyNum; ++t) { - HashTestRow row = {0}; - row.keySize = sprintf(row.key, "0.db.st%d", t); - - for (int32_t q = 0; q < q1Times; q++) { - taosHashGet(hashHandle, row.key, row.keySize); - } - - taosHashPut(hashHandle, row.key, row.keySize, &row, sizeof(HashTestRow)); - - for (int32_t q = 0; q < q2Times; q++) { - taosHashGet(hashHandle, row.key, row.keySize); - } - - // test iterator - { - HashTestRow *row = taosHashIterate(hashHandle, NULL); - while (row) { - taosHashGet(hashHandle, row->key, row->keySize); - row = taosHashIterate(hashHandle, row); - } - } - - if (t % printInterval == 0) { - int64_t endMs = taosGetTimestampMs(); - int64_t hashSize = taosHashGetSize(hashHandle); - float seconds = (endMs - startMs) / 1000.0; - float speed = printInterval / seconds; - pPrint("time:%.2f sec, speed:%.1f rows/second, hashSize:%ld", seconds, speed, hashSize); - startMs = endMs; - } - } - - int64_t endMs = taosGetTimestampMs(); - int64_t hashSize = taosHashGetSize(hashHandle); - seconds = (endMs - initialMs) / 1000.0; - float speed = hashSize / seconds; - - pPrint("total time:%.2f sec, avg speed:%.1f rows/second, hashSize:%ld", seconds, speed, hashSize); - taosHashCleanup(hashHandle); -} - -void *multiThreadFunc(void *param) { - for (int i = 0; i < 100; ++i) { - taosMsleep(1000); - HashTestRow *row = taosHashIterate(hashHandle, NULL); - while (row) { - taosHashGet(hashHandle, row->key, row->keySize); - row = taosHashIterate(hashHandle, row); - } - int64_t hashSize = taosHashGetSize(hashHandle); - pPrint("i:%d hashSize:%ld", i, hashSize); - } - - return NULL; -} - -void multiThreadTest() { - pthread_attr_t thattr; - pthread_attr_init(&thattr); - pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE); - - // Start threads to write - pthread_create(&thread, &thattr, multiThreadFunc, NULL); -} - -int main(int argc, char *argv[]) { - shellParseArgument(argc, argv); - multiThreadTest(); - testHashPerformance(); - pthread_join(thread, NULL); -} - -void printHelp() { - char indent[10] = " "; - printf("Used to test the performance of cache\n"); - - printf("%s%s\n", indent, "-k"); - printf("%s%s%s%d\n", indent, indent, "key num, default is ", keyNum); - printf("%s%s\n", indent, "-p"); - printf("%s%s%s%d\n", indent, indent, "print interval while put into hash, default is ", printInterval); - printf("%s%s\n", indent, "-c"); - printf("%s%s%s%d\n", indent, indent, "the initial capacity of hash ", capacity); - printf("%s%s\n", indent, "-q1"); - printf("%s%s%s%d\n", indent, indent, "query times before put into hash", q1Times); - printf("%s%s\n", indent, "-q2"); - printf("%s%s%s%d\n", indent, indent, "query times after put into hash", q2Times); - - exit(EXIT_SUCCESS); -} - -void shellParseArgument(int argc, char *argv[]) { - for (int i = 1; i < argc; i++) { - if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { - printHelp(); - exit(0); - } else if (strcmp(argv[i], "-k") == 0) { - keyNum = atoi(argv[++i]); - } else if (strcmp(argv[i], "-p") == 0) { - printInterval = atoi(argv[++i]); - } else if (strcmp(argv[i], "-c") == 0) { - capacity = atoi(argv[++i]); - } else if (strcmp(argv[i], "-q1") == 0) { - q1Times = atoi(argv[++i]); - } else if (strcmp(argv[i], "-q2") == 0) { - q2Times = atoi(argv[++i]); - } else { - } - } - - pPrint("%s capacity:%d %s", GREEN, capacity, NC); - pPrint("%s printInterval:%d %s", GREEN, printInterval, NC); - pPrint("%s q1Times:%d %s", GREEN, q1Times, NC); - pPrint("%s q2Times:%d %s", GREEN, q2Times, NC); - pPrint("%s keyNum:%d %s", GREEN, keyNum, NC); -} diff --git a/tests/test/c/httpTest.c b/tests/test/c/httpTest.c deleted file mode 100644 index 261546770eed889894ec93cbbdfb2cdad9f4cad0..0000000000000000000000000000000000000000 --- a/tests/test/c/httpTest.c +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#include "os.h" -#include "os.h" -#include "tglobal.h" -#include "taoserror.h" -#include "httpSystem.h" - -void signal_handler(int signum) { - httpStopSystem(); - httpCleanUpSystem(); - exit(EXIT_SUCCESS); -} - -int main(int argc, char *argv[]) { - struct sigaction act; - act.sa_handler = signal_handler; - sigaction(SIGTERM, &act, NULL); - sigaction(SIGHUP, &act, NULL); - sigaction(SIGINT, &act, NULL); - sigaction(SIGABRT, &act, NULL); - - // Initialize the system - if (httpInitSystem() < 0) { - exit(EXIT_FAILURE); - } - - if (httpStartSystem() < 0) { - exit(EXIT_FAILURE); - } - - while (1) { - sleep(1000); - } -} diff --git a/tests/test/c/importOneRow.c b/tests/test/c/importOneRow.c deleted file mode 100644 index 510f780163f9c04bca31a3ec97b8e5447d55f182..0000000000000000000000000000000000000000 --- a/tests/test/c/importOneRow.c +++ /dev/null @@ -1,182 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "../../../include/client/taos.h" -#include "os.h" -#include "tglobal.h" -#include "ttimer.h" -#include "tulog.h" -#include "tutil.h" - -#define MAX_RANDOM_POINTS 20000 -#define GREEN "\033[1;32m" -#define NC "\033[0m" - -void taos_error(TAOS *taos); -void* taos_execute(void *param); - -typedef struct { - pthread_t pid; - int index; -} ThreadObj; - -int threadNum = 1; -int rowNum = 1000; -int replica = 1; - -void printHelp() { - char indent[10] = " "; - printf("Used to test the performance of TDengine\n After writing one row of data to all tables, write the next row\n"); - - printf("%s%s\n", indent, "-r"); - printf("%s%s%s%d\n", indent, indent, "Number of records to write table, default is ", rowNum); - printf("%s%s\n", indent, "-t"); - printf("%s%s%s%d\n", indent, indent, "Number of threads to be used, default is ", threadNum); - printf("%s%s\n", indent, "-replica"); - printf("%s%s%s%d\n", indent, indent, "Database parameters replica, default is ", replica); - - exit(EXIT_SUCCESS); -} - -void shellParseArgument(int argc, char *argv[]) { - for (int i = 1; i < argc; i++) { - if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { - printHelp(); - exit(0); - } else if (strcmp(argv[i], "-r") == 0) { - rowNum = atoi(argv[++i]); - } else if (strcmp(argv[i], "-t") == 0) { - threadNum = atoi(argv[++i]); - } else if (strcmp(argv[i], "-replica") == 0) { - replica = atoi(argv[++i]); - } else { - } - } - - pPrint("%s rowNum:%d %s", GREEN, rowNum, NC); - pPrint("%s threadNum:%d %s", GREEN, threadNum, NC); - pPrint("%s replica:%d %s", GREEN, replica, NC); -} - -int main(int argc, char *argv[]) { - shellParseArgument(argc, argv); - - taos_init(); - - ThreadObj *threads = calloc(threadNum, sizeof(ThreadObj)); - for (int i = 0; i < threadNum; ++i) { - ThreadObj * pthread = threads + i; - pthread_attr_t thattr; - pthread->index = i; - pthread_attr_init(&thattr); - pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE); - pthread_create(&pthread->pid, &thattr, taos_execute, pthread); - } - - for (int i = 0; i < threadNum; i++) { - pthread_join(threads[i].pid, NULL); - } - - printf("all finished\n"); - - return 0; -} - -void taos_error(TAOS *con) { - fprintf(stderr, "TDengine error: %s\n", taos_errstr(con)); - taos_close(con); - exit(1); -} - -void* taos_execute(void *param) { - ThreadObj *pThread = (ThreadObj *)param; - - char fqdn[TSDB_FQDN_LEN]; - uint16_t port; - - taosGetFqdnPortFromEp(tsFirst, fqdn, &port); - - void *taos = taos_connect(fqdn, "root", "taosdata", NULL, port); - if (taos == NULL) taos_error(taos); - - char sql[1024] = {0}; - sprintf(sql, "create database if not exists db replica %d", replica); - taos_query(taos, sql); - - sprintf(sql, "create table if not exists db.t%d (ts timestamp, i int, j float, k double)", pThread->index); - taos_query(taos, sql); - - int64_t timestamp = 1530374400000L; - - sprintf(sql, "insert into db.t%d values(%ld, %d, %d, %d)", pThread->index, timestamp, 0, 0, 0); - TAOS_RES *pSql = taos_query(taos, sql); - int code = taos_errno(pSql); - if (code != 0) - { - printf("error code:%d, sql:%s\n", code, sql); - taos_free_result(pSql); - taos_close(taos); - return NULL; - } - int affectrows = taos_affected_rows(taos); - if (affectrows != 1) - { - printf("affect rows:%d, sql:%s\n", affectrows, sql); - taos_free_result(pSql); - taos_close(taos); - return NULL; - } - taos_free_result(pSql); - pSql = NULL; - - - timestamp -= 1000; - - int total_affect_rows = affectrows; - - for (int i = 1; i < rowNum; ++i) { - sprintf(sql, "import into db.t%d values(%ld, %d, %d, %d)", pThread->index, timestamp, i, i, i); - - pSql = taos_query(taos, sql); - code = taos_errno(pSql); - if (code != 0) - { - printf("error code:%d, sql:%s\n", code, sql); - taos_free_result(pSql); - pSql = NULL; - taos_close(taos); - return NULL; - } - int affectrows = taos_affected_rows(taos); - if (affectrows != 1) { - printf("affect rows:%d, sql:%s\n", affectrows, sql); - taos_free_result(pSql); - pSql = NULL; - taos_close(taos); - } - - total_affect_rows += affectrows; - taos_free_result(pSql); - pSql = NULL; - - timestamp -= 1000; - } - - printf("thread:%d run finished total_affect_rows:%d\n", pThread->index, total_affect_rows); - taos_close(taos); - - return NULL; -} diff --git a/tests/test/c/importPerTable.c b/tests/test/c/importPerTable.c deleted file mode 100644 index 7aef676c973dee349498a16e5ec87a96d8ca60e1..0000000000000000000000000000000000000000 --- a/tests/test/c/importPerTable.c +++ /dev/null @@ -1,356 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "../../../include/client/taos.h" -#include "os.h" -#include "osTime.h" -#include "tglobal.h" -#include "ttimer.h" -#include "tulog.h" -#include "tutil.h" - -#define MAX_RANDOM_POINTS 20000 -#define GREEN "\033[1;32m" -#define NC "\033[0m" - -typedef struct { - int64_t rowsPerTable; - int64_t pointsPerTable; - int64_t tableBeginIndex; - int64_t tableEndIndex; - int threadIndex; - char dbName[32]; - char stableName[64]; - pthread_t thread; -} SInfo; - -void *syncTest(void *param); -void generateRandomPoints(); -void shellParseArgument(int argc, char *argv[]); -void createDbAndTable(); -void insertData(); - -int32_t randomData[MAX_RANDOM_POINTS]; -int64_t rowsPerTable = 1000000; -int64_t pointsPerTable = 1; -int64_t numOfThreads = 10; -int64_t numOfTablesPerThread = 100; -char dbName[32] = "db"; -char stableName[64] = "st"; -int64_t totalUs = 0; -int64_t reqNum = 0; -int64_t maxUs = 0; -int64_t minUs = 100000000; - -int main(int argc, char *argv[]) { - shellParseArgument(argc, argv); - generateRandomPoints(); - taos_init(); - createDbAndTable(); - insertData(); - int64_t avgUs = totalUs / reqNum; - pError("%s totalUs:%ld, avgUs:%ld maxUs:%ld minUs:%ld reqNum:%ld %s\n", GREEN, totalUs, avgUs, maxUs, minUs, reqNum, NC); -} - -int32_t query(void *con, char *qstr) { - int64_t begin = taosGetTimestampUs(); - - TAOS_RES *pSql = taos_query(con, qstr); - int32_t code = taos_errno(pSql); - if (code != 0) { - pError("failed to exec sql:%s, code:%d reason:%s", qstr, taos_errno(con), taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - - int64_t us = taosGetTimestampUs() - begin; - maxUs = MAX(us, maxUs); - minUs = MIN(us, minUs); - atomic_add_fetch_64(&totalUs, us); - atomic_add_fetch_64(&reqNum, 1); - if (reqNum > 100000) { - int64_t avgUs = totalUs / reqNum; - if (us > avgUs * 100) { - pError("sql:%s", qstr); - pError("%s totalUs:%ld, avgUs:%ld maxUs:%ld minUs:%ld reqNum:%ld %s\n", GREEN, totalUs, avgUs, maxUs, minUs, - reqNum, NC); - taosMsleep(1000); - exit(0); - } - } - - return code; -} - -void createDbAndTable() { - pPrint("start to create table"); - - TAOS * con; - struct timeval systemTime; - int64_t st, et; - char qstr[64000]; - - char fqdn[TSDB_FQDN_LEN]; - uint16_t port; - - taosGetFqdnPortFromEp(tsFirst, fqdn, &port); - - con = taos_connect(fqdn, "root", "taosdata", NULL, port); - if (con == NULL) { - pError("failed to connect to DB, reason:%s", taos_errstr(con)); - exit(1); - } - - sprintf(qstr, "create database if not exists %s", dbName); - if (query(con, qstr)) { - pError("failed to create database:%s, code:%d reason:%s", dbName, taos_errno(con), taos_errstr(con)); - exit(0); - } - - sprintf(qstr, "use %s", dbName); - if (query(con, qstr)) { - pError("failed to use db, code:%d reason:%s", taos_errno(con), taos_errstr(con)); - exit(0); - } - - gettimeofday(&systemTime, NULL); - st = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - int64_t totalTables = numOfTablesPerThread * numOfThreads; - - if (strcmp(stableName, "no") != 0) { - int len = sprintf(qstr, "create table if not exists %s(ts timestamp", stableName); - for (int64_t f = 0; f < pointsPerTable; ++f) { - len += sprintf(qstr + len, ", f%ld double", f); - } - sprintf(qstr + len, ") tags(t int)"); - - if (query(con, qstr)) { - pError("failed to create stable, code:%d reason:%s", taos_errno(con), taos_errstr(con)); - exit(0); - } - - for (int64_t t = 0; t < totalTables; ++t) { - sprintf(qstr, "create table if not exists %s%ld using %s tags(%ld)", stableName, t, stableName, t); - if (query(con, qstr)) { - pError("failed to create table %s%" PRId64 ", reason:%s", stableName, t, taos_errstr(con)); - exit(0); - } - } - } else { - for (int64_t t = 0; t < totalTables; ++t) { - int len = sprintf(qstr, "create table if not exists %s%ld(ts timestamp", stableName, t); - for (int64_t f = 0; f < pointsPerTable; ++f) { - len += sprintf(qstr + len, ", f%ld double", f); - } - sprintf(qstr + len, ")"); - - if (query(con, qstr)) { - pError("failed to create table %s%ld, reason:%s", stableName, t, taos_errstr(con)); - exit(0); - } - } - } - - gettimeofday(&systemTime, NULL); - et = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - pPrint("%.1f seconds to create %ld tables", (et - st) / 1000.0 / 1000.0, totalTables); -} - -void insertData() { - struct timeval systemTime; - int64_t st, et; - - gettimeofday(&systemTime, NULL); - st = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - - pPrint("%" PRId64 " threads are spawned to import data", numOfThreads); - - pthread_attr_t thattr; - pthread_attr_init(&thattr); - pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE); - SInfo *pInfo = (SInfo *)malloc(sizeof(SInfo) * numOfThreads); - - // Start threads to write - for (int i = 0; i < numOfThreads; ++i) { - pInfo[i].rowsPerTable = rowsPerTable; - pInfo[i].pointsPerTable = pointsPerTable; - pInfo[i].tableBeginIndex = i * numOfTablesPerThread; - pInfo[i].tableEndIndex = (i + 1) * numOfTablesPerThread; - pInfo[i].threadIndex = i; - strcpy(pInfo[i].dbName, dbName); - strcpy(pInfo[i].stableName, stableName); - pthread_create(&(pInfo[i].thread), &thattr, syncTest, (void *)(pInfo + i)); - } - - taosMsleep(300); - for (int i = 0; i < numOfThreads; i++) { - pthread_join(pInfo[i].thread, NULL); - } - - gettimeofday(&systemTime, NULL); - et = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - double seconds = (et - st) / 1000.0 / 1000.0; - - int64_t totalTables = numOfTablesPerThread * numOfThreads; - int64_t totalRows = totalTables * rowsPerTable; - int64_t totalPoints = totalTables * rowsPerTable * pointsPerTable; - double speedOfRows = totalRows / seconds; - double speedOfPoints = totalPoints / seconds; - - pPrint( - "%sall threads:%ld finished, use %.1lf seconds, tables:%.ld rows:%ld points:%ld, speed RowsPerSecond:%.1lf " - "PointsPerSecond:%.1lf%s", - GREEN, numOfThreads, seconds, totalTables, totalRows, totalPoints, speedOfRows, speedOfPoints, NC); - - pPrint("threads exit"); - - pthread_attr_destroy(&thattr); - free(pInfo); -} - -void *syncTest(void *param) { - TAOS * con; - SInfo * pInfo = (SInfo *)param; - struct timeval systemTime; - int64_t st, et; - char qstr[65000]; - int maxBytes = 60000; - - pPrint("thread:%d, start to run", pInfo->threadIndex); - char fqdn[TSDB_FQDN_LEN]; - uint16_t port; - - taosGetFqdnPortFromEp(tsFirst, fqdn, &port); - - con = taos_connect(fqdn, "root", "taosdata", NULL, port); - if (con == NULL) { - pError("index:%d, failed to connect to DB, reason:%s", pInfo->threadIndex, taos_errstr(con)); - exit(1); - } - - sprintf(qstr, "use %s", pInfo->dbName); - query(con, qstr); - - gettimeofday(&systemTime, NULL); - st = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - - int64_t start = 1587225600000; - int64_t interval = 1000; // 1000 ms - - char *sql = qstr; - char inserStr[] = "import into"; - int len = sprintf(sql, "%s", inserStr); - - for (int64_t table = pInfo->tableBeginIndex; table < pInfo->tableEndIndex; ++table) { - len += sprintf(sql + len, " %s%ld values", pInfo->stableName, table); - for (int64_t row = 0; row < pInfo->rowsPerTable; row++) { - len += sprintf(sql + len, "(%ld", start - row * interval); - for (int64_t point = 0; point < pInfo->pointsPerTable; ++point) { - len += sprintf(sql + len, ",%d", randomData[(123 * table + 456 * row + 789 * point) % MAX_RANDOM_POINTS]); - // len += sprintf(sql + len, ",%ld", row); - } - len += sprintf(sql + len, ")"); - if (len > maxBytes) { - if (query(con, qstr)) { - pError("thread:%d, failed to import table:%s%ld row:%ld, reason:%s", pInfo->threadIndex, pInfo->stableName, - table, row, taos_errstr(con)); - } - - // "insert into" - len = sprintf(sql, "%s", inserStr); - - // "insert into st1 values" - if (row != pInfo->rowsPerTable - 1) { - len += sprintf(sql + len, " %s%ld values", pInfo->stableName, table); - } - } - } - } - - if (len != strlen(inserStr)) { - query(con, qstr); - } - - gettimeofday(&systemTime, NULL); - et = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - int64_t totalTables = pInfo->tableEndIndex - pInfo->tableBeginIndex; - int64_t totalRows = totalTables * pInfo->rowsPerTable; - int64_t totalPoints = totalRows * pInfo->pointsPerTable; - pPrint("thread:%d, import finished, use %.2f seconds, tables:%ld rows:%ld points:%ld", pInfo->threadIndex, - (et - st) / 1000.0 / 1000.0, totalTables, totalRows, totalPoints); - - return NULL; -} - -void generateRandomPoints() { - for (int r = 0; r < MAX_RANDOM_POINTS; ++r) { - randomData[r] = rand() % 1000; - } -} - -void printHelp() { - char indent[10] = " "; - printf("Used to test the performance of TDengine\n After writing all the data in one table, start the next table\n"); - - printf("%s%s\n", indent, "-d"); - printf("%s%s%s%s\n", indent, indent, "The name of the database to be created, default is ", dbName); - printf("%s%s\n", indent, "-s"); - printf("%s%s%s%s%s\n", indent, indent, "The name of the super table to be created, default is ", stableName, ", if 'no' then create normal table"); - printf("%s%s\n", indent, "-c"); - printf("%s%s%s%s\n", indent, indent, "Configuration directory, default is ", configDir); - printf("%s%s\n", indent, "-r"); - printf("%s%s%s%ld\n", indent, indent, "Number of records to write to each table, default is ", rowsPerTable); - printf("%s%s\n", indent, "-p"); - printf("%s%s%s%" PRId64 "\n", indent, indent, "Number of columns per table, default is ", pointsPerTable); - printf("%s%s\n", indent, "-t"); - printf("%s%s%s%" PRId64 "\n", indent, indent, "Number of threads to be used, default is ", numOfThreads); - printf("%s%s\n", indent, "-n"); - printf("%s%s%s%" PRId64 "\n", indent, indent, "Number of tables per thread, default is ", numOfTablesPerThread); - - exit(EXIT_SUCCESS); -} - -void shellParseArgument(int argc, char *argv[]) { - for (int i = 1; i < argc; i++) { - if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { - printHelp(); - exit(0); - } else if (strcmp(argv[i], "-d") == 0) { - strcpy(dbName, argv[++i]); - } else if (strcmp(argv[i], "-c") == 0) { - strcpy(configDir, argv[++i]); - } else if (strcmp(argv[i], "-s") == 0) { - strcpy(stableName, argv[++i]); - } else if (strcmp(argv[i], "-r") == 0) { - rowsPerTable = atoi(argv[++i]); - } else if (strcmp(argv[i], "-p") == 0) { - pointsPerTable = atoi(argv[++i]); - } else if (strcmp(argv[i], "-t") == 0) { - numOfThreads = atoi(argv[++i]); - } else if (strcmp(argv[i], "-n") == 0) { - numOfTablesPerThread = atoi(argv[++i]); - } else { - } - } - - pPrint("%srowsPerTable:%" PRId64 "%s", GREEN, rowsPerTable, NC); - pPrint("%spointsPerTable:%" PRId64 "%s", GREEN, pointsPerTable, NC); - pPrint("%snumOfThreads:%" PRId64 "%s", GREEN, numOfThreads, NC); - pPrint("%snumOfTablesPerThread:%" PRId64 "%s", GREEN, numOfTablesPerThread, NC); - pPrint("%sdbName:%s%s", GREEN, dbName, NC); - pPrint("%stableName:%s%s", GREEN, stableName, NC); - pPrint("%sstart to run%s", GREEN, NC); -} diff --git a/tests/test/c/insertPerRow.c b/tests/test/c/insertPerRow.c deleted file mode 100644 index bdf27180b2c896762339f436aae132eb95feaca4..0000000000000000000000000000000000000000 --- a/tests/test/c/insertPerRow.c +++ /dev/null @@ -1,366 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "../../../include/client/taos.h" -#include "os.h" -#include "tglobal.h" -#include "ttimer.h" -#include "tulog.h" -#include "tutil.h" - -#define MAX_RANDOM_POINTS 20000 -#define GREEN "\033[1;32m" -#define NC "\033[0m" - -typedef struct { - int64_t rowsPerTable; - int64_t pointsPerTable; - int64_t tableBeginIndex; - int64_t tableEndIndex; - int threadIndex; - char dbName[32]; - char stableName[64]; - float createTableSpeed; - pthread_t thread; -} SInfo; - -void *syncTest(void *param); -void generateRandomPoints(); -void shellParseArgument(int argc, char *argv[]); -void createDbAndTable(); -void insertData(); - -int32_t randomData[MAX_RANDOM_POINTS]; -int64_t rowsPerTable = 1000000000; -int64_t pointsPerTable = 1; -int64_t numOfThreads = 10; -int64_t numOfTablesPerThread = 100; -char dbName[32] = "db"; -char stableName[64] = "st"; -int32_t cache = 1; -int32_t replica = 3; -int32_t days = 10; -int32_t interval = 1000; - -int main(int argc, char *argv[]) { - shellParseArgument(argc, argv); - generateRandomPoints(); - taos_init(); - createDbAndTable(); - insertData(); -} - -void createDbAndTable() { - pPrint("start to create table"); - - TAOS_RES * pSql; - TAOS * con; - char qstr[64000]; - - char fqdn[TSDB_FQDN_LEN]; - uint16_t port; - taosGetFqdnPortFromEp(tsFirst, fqdn, &port); - con = taos_connect(fqdn, "root", "taosdata", NULL, port); - if (con == NULL) { - pError("failed to connect to DB, reason:%s", taos_errstr(con)); - exit(1); - } - - sprintf(qstr, "create database if not exists %s cache %d replica %d days %d", dbName, cache, replica, days); - pSql = taos_query(con, qstr); - int32_t code = taos_errno(pSql); - if (code != 0) { - pError("failed to create database:%s, sql:%s, code:%d reason:%s", dbName, qstr, taos_errno(con), taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - - sprintf(qstr, "use %s", dbName); - pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to use db, code:%d reason:%s", taos_errno(con), taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - - if (strcmp(stableName, "no") != 0) { - int len = sprintf(qstr, "create table if not exists %s(ts timestamp", stableName); - for (int64_t f = 0; f < pointsPerTable; ++f) { - len += sprintf(qstr + len, ", f%ld double", f); - } - sprintf(qstr + len, ") tags(t int)"); - - pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to create stable, code:%d reason:%s", taos_errno(con), taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - } -} - -void insertData() { - struct timeval systemTime; - int64_t st, et; - - gettimeofday(&systemTime, NULL); - st = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - - pPrint("%" PRId64 " threads are spawned to insert data", numOfThreads); - - pthread_attr_t thattr; - pthread_attr_init(&thattr); - pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE); - SInfo *pInfo = (SInfo *)calloc(numOfThreads, sizeof(SInfo)); - - // Start threads to write - for (int i = 0; i < numOfThreads; ++i) { - pInfo[i].rowsPerTable = rowsPerTable; - pInfo[i].pointsPerTable = pointsPerTable; - pInfo[i].tableBeginIndex = i * numOfTablesPerThread; - pInfo[i].tableEndIndex = (i + 1) * numOfTablesPerThread; - pInfo[i].threadIndex = i; - strcpy(pInfo[i].dbName, dbName); - strcpy(pInfo[i].stableName, stableName); - pthread_create(&(pInfo[i].thread), &thattr, syncTest, (void *)(pInfo + i)); - } - - taosMsleep(300); - for (int i = 0; i < numOfThreads; i++) { - pthread_join(pInfo[i].thread, NULL); - } - - gettimeofday(&systemTime, NULL); - et = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - double seconds = (et - st) / 1000.0 / 1000.0; - - int64_t totalTables = numOfTablesPerThread * numOfThreads; - int64_t totalRows = totalTables * rowsPerTable; - int64_t totalPoints = totalTables * rowsPerTable * pointsPerTable; - double speedOfRows = totalRows / seconds; - double speedOfPoints = totalPoints / seconds; - - float createTableSpeed = 0; - for (int i = 0; i < numOfThreads; ++i) { - createTableSpeed += pInfo[i].createTableSpeed; - } - - pPrint( - "%sall threads:%ld finished, use %.1lf seconds, tables:%.ld rows:%ld points:%ld, speed RowsPerSecond:%.1lf " - "PointsPerSecond:%.1lf CreateTableSpeed:%.1f t/s %s", - GREEN, numOfThreads, seconds, totalTables, totalRows, totalPoints, speedOfRows, speedOfPoints, createTableSpeed, NC); - - pPrint("threads exit"); - - pthread_attr_destroy(&thattr); - free(pInfo); -} - -void *syncTest(void *param) { - TAOS * con; - SInfo * pInfo = (SInfo *)param; - struct timeval systemTime; - int64_t st, et; - char qstr[65000]; - int maxBytes = 60000; - int code; - - pPrint("thread:%d, start to run", pInfo->threadIndex); - - char fqdn[TSDB_FQDN_LEN]; - uint16_t port; - - taosGetFqdnPortFromEp(tsFirst, fqdn, &port); - con = taos_connect(fqdn, "root", "taosdata", NULL, port); - if (con == NULL) { - pError("index:%d, failed to connect to DB, reason:%s", pInfo->threadIndex, taos_errstr(con)); - exit(1); - } - - sprintf(qstr, "use %s", pInfo->dbName); - taos_query(con, qstr); - - gettimeofday(&systemTime, NULL); - st = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - - if (strcmp(stableName, "no") != 0) { - for (int64_t t = pInfo->tableBeginIndex; t < pInfo->tableEndIndex; ++t) { - sprintf(qstr, "create table if not exists %s%ld using %s tags(%ld)", stableName, t, stableName, t); - TAOS_RES *pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to create table %s%" PRId64 ", reason:%s", stableName, t, taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - } - } else { - for (int64_t t = pInfo->tableBeginIndex; t < pInfo->tableEndIndex; ++t) { - int len = sprintf(qstr, "create table if not exists %s%ld(ts timestamp", stableName, t); - for (int64_t f = 0; f < pointsPerTable; ++f) { - len += sprintf(qstr + len, ", f%ld double", f); - } - sprintf(qstr + len, ")"); - - TAOS_RES *pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to create table %s%ld, reason:%s", stableName, t, taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - } - } - - gettimeofday(&systemTime, NULL); - et = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - float seconds = (et - st) / 1000.0 / 1000.0; - int64_t tables = pInfo->tableEndIndex - pInfo->tableBeginIndex; - pInfo->createTableSpeed = (float)tables / seconds; - pPrint("thread:%d, %.1f seconds to create %ld tables, speed:%.1f", pInfo->threadIndex, seconds, tables, - pInfo->createTableSpeed); - - if (pInfo->rowsPerTable == 0) return NULL; - - gettimeofday(&systemTime, NULL); - st = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - - int64_t start = 1430000000000; - interval = 1000; // 1000 ms - - char *sql = qstr; - char inserStr[] = "insert into"; - int len = sprintf(sql, "%s", inserStr); - - for (int64_t row = 0; row < pInfo->rowsPerTable; row++) { - for (int64_t table = pInfo->tableBeginIndex; table < pInfo->tableEndIndex; ++table) { - len += sprintf(sql + len, " %s%ld values", pInfo->stableName, table); - len += sprintf(sql + len, "(%ld", start + row * interval); - for (int64_t point = 0; point < pInfo->pointsPerTable; ++point) { - len += sprintf(sql + len, ",%d", randomData[(123 * table + 456 * row + 789 * point) % MAX_RANDOM_POINTS]); - // len += sprintf(sql + len, ",%ld", row); - } - len += sprintf(sql + len, ")"); - if (len > maxBytes) { - TAOS_RES *pSql = taos_query(con, qstr); - int32_t code = taos_errno(pSql); - if (code != 0) { - pError("thread:%d, failed to insert table:%s%ld row:%ld, reason:%s", pInfo->threadIndex, pInfo->stableName, - table, row, taos_errstr(con)); - } - taos_free_result(pSql); - - // "insert into" - len = sprintf(sql, "%s", inserStr); - } - } - } - - if (len != strlen(inserStr)) { - TAOS_RES *pSql = taos_query(con, qstr); - taos_free_result(pSql); - } - - gettimeofday(&systemTime, NULL); - et = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - int64_t totalTables = pInfo->tableEndIndex - pInfo->tableBeginIndex; - int64_t totalRows = totalTables * pInfo->rowsPerTable; - int64_t totalPoints = totalRows * pInfo->pointsPerTable; - pPrint("thread:%d, insert finished, use %.2f seconds, tables:%ld rows:%ld points:%ld", pInfo->threadIndex, - (et - st) / 1000.0 / 1000.0, totalTables, totalRows, totalPoints); - - return NULL; -} - -void generateRandomPoints() { - for (int r = 0; r < MAX_RANDOM_POINTS; ++r) { - randomData[r] = rand() % 1000; - } -} - -void printHelp() { - char indent[10] = " "; - printf("Used to test the performance of TDengine\n After writing one row of data to all tables, write the next row\n"); - - printf("%s%s\n", indent, "-d"); - printf("%s%s%s%s\n", indent, indent, "The name of the database to be created, default is ", dbName); - printf("%s%s\n", indent, "-s"); - printf("%s%s%s%s%s\n", indent, indent, "The name of the super table to be created, default is ", stableName, ", if 'no' then create normal table"); - printf("%s%s\n", indent, "-c"); - printf("%s%s%s%s\n", indent, indent, "Configuration directory, default is ", configDir); - printf("%s%s\n", indent, "-r"); - printf("%s%s%s%ld\n", indent, indent, "Number of records to write to each table, default is ", rowsPerTable); - printf("%s%s\n", indent, "-p"); - printf("%s%s%s%" PRId64 "\n", indent, indent, "Number of columns per table, default is ", pointsPerTable); - printf("%s%s\n", indent, "-t"); - printf("%s%s%s%" PRId64 "\n", indent, indent, "Number of threads to be used, default is ", numOfThreads); - printf("%s%s\n", indent, "-n"); - printf("%s%s%s%" PRId64 "\n", indent, indent, "Number of tables per thread, default is ", numOfTablesPerThread); - printf("%s%s\n", indent, "-replica"); - printf("%s%s%s%d\n", indent, indent, "Database parameters replica, default is ", replica); - printf("%s%s\n", indent, "-cache"); - printf("%s%s%s%d\n", indent, indent, "Database parameters replica, default is ", cache); - printf("%s%s\n", indent, "-days"); - printf("%s%s%s%d\n", indent, indent, "Database parameters days, default is ", days); - printf("%s%s\n", indent, "-interval"); - printf("%s%s%s%d\n", indent, indent, "Interval of each rows in ms, default is ", interval); - - exit(EXIT_SUCCESS); -} - -void shellParseArgument(int argc, char *argv[]) { - for (int i = 1; i < argc; i++) { - if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { - printHelp(); - exit(0); - } else if (strcmp(argv[i], "-d") == 0) { - strcpy(dbName, argv[++i]); - } else if (strcmp(argv[i], "-c") == 0) { - strcpy(configDir, argv[++i]); - } else if (strcmp(argv[i], "-s") == 0) { - strcpy(stableName, argv[++i]); - } else if (strcmp(argv[i], "-r") == 0) { - rowsPerTable = atoi(argv[++i]); - } else if (strcmp(argv[i], "-p") == 0) { - pointsPerTable = atoi(argv[++i]); - } else if (strcmp(argv[i], "-t") == 0) { - numOfThreads = atoi(argv[++i]); - } else if (strcmp(argv[i], "-n") == 0) { - numOfTablesPerThread = atoi(argv[++i]); - } else if (strcmp(argv[i], "-replica") == 0) { - replica = atoi(argv[++i]); - } else if (strcmp(argv[i], "-cache") == 0) { - cache = atoi(argv[++i]); - } else if (strcmp(argv[i], "-days") == 0) { - days = atoi(argv[++i]); - } else if (strcmp(argv[i], "-interval") == 0) { - interval = atoi(argv[++i]); - } else { - } - } - - pPrint("%srowsPerTable:%" PRId64 "%s", GREEN, rowsPerTable, NC); - pPrint("%spointsPerTable:%" PRId64 "%s", GREEN, pointsPerTable, NC); - pPrint("%snumOfThreads:%" PRId64 "%s", GREEN, numOfThreads, NC); - pPrint("%snumOfTablesPerThread:%" PRId64 "%s", GREEN, numOfTablesPerThread, NC); - pPrint("%scache:%" PRId32 "%s", GREEN, cache, NC); - pPrint("%stables:%" PRId32 "%s", GREEN, replica, NC); - pPrint("%sdbName:%s%s", GREEN, dbName, NC); - pPrint("%stableName:%s%s", GREEN, stableName, NC); - pPrint("%sstart to run%s", GREEN, NC); -} diff --git a/tests/test/c/insertPerTable.c b/tests/test/c/insertPerTable.c deleted file mode 100644 index ac3c06f0f314d6c5839bf8cfd26419c3988a6ed6..0000000000000000000000000000000000000000 --- a/tests/test/c/insertPerTable.c +++ /dev/null @@ -1,357 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "../../../include/client/taos.h" -#include "os.h" -#include "tglobal.h" -#include "ttimer.h" -#include "tulog.h" -#include "tutil.h" - -#define MAX_RANDOM_POINTS 20000 -#define GREEN "\033[1;32m" -#define NC "\033[0m" - -typedef struct { - int64_t rowsPerTable; - int64_t pointsPerTable; - int64_t tableBeginIndex; - int64_t tableEndIndex; - int threadIndex; - char dbName[32]; - char stableName[64]; - pthread_t thread; -} SInfo; - -void *syncTest(void *param); -void generateRandomPoints(); -void shellParseArgument(int argc, char *argv[]); -void createDbAndTable(); -void insertData(); - -int32_t randomData[MAX_RANDOM_POINTS]; -int64_t rowsPerTable = 10000; -int64_t pointsPerTable = 1; -int64_t numOfThreads = 1; -int64_t numOfTablesPerThread = 1; -char dbName[32] = "db"; -char stableName[64] = "st"; -int32_t cache = 16; -int32_t tables = 5000; - -int main(int argc, char *argv[]) { - shellParseArgument(argc, argv); - generateRandomPoints(); - taos_init(); - createDbAndTable(); - insertData(); -} - -void createDbAndTable() { - pPrint("start to create table"); - - TAOS_RES * pSql; - TAOS * con; - struct timeval systemTime; - int64_t st, et; - char qstr[64000]; - - char fqdn[TSDB_FQDN_LEN]; - uint16_t port; - - taosGetFqdnPortFromEp(tsFirst, fqdn, &port); - - con = taos_connect(fqdn, "root", "taosdata", NULL, port); - if (con == NULL) { - pError("failed to connect to DB, reason:%s", taos_errstr(con)); - exit(1); - } - - sprintf(qstr, "create database if not exists %s cache %d maxtables %d", dbName, cache, tables); - pSql = taos_query(con, qstr); - int32_t code = taos_errno(pSql); - if (code != 0) { - pError("failed to create database:%s, sql:%s, code:%d reason:%s", dbName, qstr, taos_errno(con), taos_errstr(con)); - exit(0); - } - - sprintf(qstr, "use %s", dbName); - pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to use db, code:%d reason:%s", taos_errno(con), taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - - gettimeofday(&systemTime, NULL); - st = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - int64_t totalTables = numOfTablesPerThread * numOfThreads; - - if (strcmp(stableName, "no") != 0) { - int len = sprintf(qstr, "create table if not exists %s(ts timestamp", stableName); - for (int64_t f = 0; f < pointsPerTable; ++f) { - len += sprintf(qstr + len, ", f%ld double", f); - } - sprintf(qstr + len, ") tags(t int)"); - - pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to create stable, code:%d reason:%s", taos_errno(con), taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - - for (int64_t t = 0; t < totalTables; ++t) { - sprintf(qstr, "create table if not exists %s%ld using %s tags(%ld)", stableName, t, stableName, t); - pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to create table %s%" PRId64 ", reason:%s", stableName, t, taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - } - } else { - for (int64_t t = 0; t < totalTables; ++t) { - int len = sprintf(qstr, "create table if not exists %s%ld(ts timestamp", stableName, t); - for (int64_t f = 0; f < pointsPerTable; ++f) { - len += sprintf(qstr + len, ", f%ld double", f); - } - sprintf(qstr + len, ")"); - - pSql = taos_query(con, qstr); - code = taos_errno(pSql); - if (code != 0) { - pError("failed to create table %s%ld, reason:%s", stableName, t, taos_errstr(con)); - exit(0); - } - taos_free_result(pSql); - } - } - - gettimeofday(&systemTime, NULL); - et = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - float seconds = (et - st) / 1000.0 / 1000.0; - pPrint("%.1f seconds to create %ld tables, speed:%.1f", seconds, totalTables, totalTables / seconds); - taos_close(con); -} - -void insertData() { - struct timeval systemTime; - int64_t st, et; - - gettimeofday(&systemTime, NULL); - st = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - - if (rowsPerTable <= 0) { - pPrint("not insert data for rowsPerTable is :%" PRId64, rowsPerTable); - exit(0); - } else { - pPrint("%" PRId64 " threads are spawned to insert data", numOfThreads); - } - - pthread_attr_t thattr; - pthread_attr_init(&thattr); - pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE); - SInfo *pInfo = (SInfo *)malloc(sizeof(SInfo) * numOfThreads); - - // Start threads to write - for (int i = 0; i < numOfThreads; ++i) { - pInfo[i].rowsPerTable = rowsPerTable; - pInfo[i].pointsPerTable = pointsPerTable; - pInfo[i].tableBeginIndex = i * numOfTablesPerThread; - pInfo[i].tableEndIndex = (i + 1) * numOfTablesPerThread; - pInfo[i].threadIndex = i; - strcpy(pInfo[i].dbName, dbName); - strcpy(pInfo[i].stableName, stableName); - pthread_create(&(pInfo[i].thread), &thattr, syncTest, (void *)(pInfo + i)); - } - - taosMsleep(300); - for (int i = 0; i < numOfThreads; i++) { - pthread_join(pInfo[i].thread, NULL); - } - - gettimeofday(&systemTime, NULL); - et = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - double seconds = (et - st) / 1000.0 / 1000.0; - - int64_t totalTables = numOfTablesPerThread * numOfThreads; - int64_t totalRows = totalTables * rowsPerTable; - int64_t totalPoints = totalTables * rowsPerTable * pointsPerTable; - double speedOfRows = totalRows / seconds; - double speedOfPoints = totalPoints / seconds; - - pPrint( - "%sall threads:%ld finished, use %.1lf seconds, tables:%.ld rows:%ld points:%ld, speed RowsPerSecond:%.1lf " - "PointsPerSecond:%.1lf%s", - GREEN, numOfThreads, seconds, totalTables, totalRows, totalPoints, speedOfRows, speedOfPoints, NC); - - pPrint("threads exit"); - - pthread_attr_destroy(&thattr); - free(pInfo); -} - -void *syncTest(void *param) { - TAOS * con; - SInfo * pInfo = (SInfo *)param; - struct timeval systemTime; - int64_t st, et; - char qstr[65000]; - int maxBytes = 60000; - - pPrint("thread:%d, start to run", pInfo->threadIndex); - - char fqdn[TSDB_FQDN_LEN]; - uint16_t port; - - taosGetFqdnPortFromEp(tsFirst, fqdn, &port); - - con = taos_connect(fqdn, "root", "taosdata", NULL, port); - if (con == NULL) { - pError("index:%d, failed to connect to DB, reason:%s", pInfo->threadIndex, taos_errstr(con)); - exit(1); - } - - sprintf(qstr, "use %s", pInfo->dbName); - taos_query(con, qstr); - - gettimeofday(&systemTime, NULL); - st = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - - int64_t start = 1430000000000; - int64_t interval = 1000; // 1000 ms - - char *sql = qstr; - char inserStr[] = "insert into"; - int len = sprintf(sql, "%s", inserStr); - - for (int64_t table = pInfo->tableBeginIndex; table < pInfo->tableEndIndex; ++table) { - len += sprintf(sql + len, " %s%ld values", pInfo->stableName, table); - for (int64_t row = 0; row < pInfo->rowsPerTable; row++) { - len += sprintf(sql + len, "(%ld", start + row * interval); - for (int64_t point = 0; point < pInfo->pointsPerTable; ++point) { - len += sprintf(sql + len, ",%d", randomData[(123 * table + 456 * row + 789 * point) % MAX_RANDOM_POINTS]); - // len += sprintf(sql + len, ",%ld", row); - } - len += sprintf(sql + len, ")"); - if (len > maxBytes) { - TAOS_RES *pSql = taos_query(con, qstr); - int32_t code = taos_errno(pSql); - if (code != 0) { - pError("thread:%d, failed to insert table:%s%ld row:%ld, reason:%s", pInfo->threadIndex, pInfo->stableName, - table, row, taos_errstr(con)); - } - taos_free_result(pSql); - - // "insert into" - len = sprintf(sql, "%s", inserStr); - - // "insert into st1 values" - if (row != pInfo->rowsPerTable - 1) { - len += sprintf(sql + len, " %s%ld values", pInfo->stableName, table); - } - } - } - } - - if (len != strlen(inserStr)) { - taos_query(con, qstr); - } - - gettimeofday(&systemTime, NULL); - et = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - int64_t totalTables = pInfo->tableEndIndex - pInfo->tableBeginIndex; - int64_t totalRows = totalTables * pInfo->rowsPerTable; - int64_t totalPoints = totalRows * pInfo->pointsPerTable; - pPrint("thread:%d, insert finished, use %.2f seconds, tables:%ld rows:%ld points:%ld", pInfo->threadIndex, - (et - st) / 1000.0 / 1000.0, totalTables, totalRows, totalPoints); - - return NULL; -} - -void generateRandomPoints() { - for (int r = 0; r < MAX_RANDOM_POINTS; ++r) { - randomData[r] = rand() % 1000; - } -} - -void printHelp() { - char indent[10] = " "; - printf("Used to test the performance of TDengine\n After writing all the data in one table, start the next table\n"); - - printf("%s%s\n", indent, "-d"); - printf("%s%s%s%s\n", indent, indent, "The name of the database to be created, default is ", dbName); - printf("%s%s\n", indent, "-s"); - printf("%s%s%s%s%s\n", indent, indent, "The name of the super table to be created, default is ", stableName, ", if 'no' then create normal table"); - printf("%s%s\n", indent, "-c"); - printf("%s%s%s%s\n", indent, indent, "Configuration directory, default is ", configDir); - printf("%s%s\n", indent, "-r"); - printf("%s%s%s%ld\n", indent, indent, "Number of records to write to each table, default is ", rowsPerTable); - printf("%s%s\n", indent, "-p"); - printf("%s%s%s%" PRId64 "\n", indent, indent, "Number of columns per table, default is ", pointsPerTable); - printf("%s%s\n", indent, "-t"); - printf("%s%s%s%" PRId64 "\n", indent, indent, "Number of threads to be used, default is ", numOfThreads); - printf("%s%s\n", indent, "-n"); - printf("%s%s%s%" PRId64 "\n", indent, indent, "Number of tables per thread, default is ", numOfTablesPerThread); - printf("%s%s\n", indent, "-tables"); - printf("%s%s%s%d\n", indent, indent, "Database parameters tables, default is ", tables); - printf("%s%s\n", indent, "-cache"); - printf("%s%s%s%d\n", indent, indent, "Database parameters cache, default is ", cache); - - exit(EXIT_SUCCESS); -} - -void shellParseArgument(int argc, char *argv[]) { - for (int i = 1; i < argc; i++) { - if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { - printHelp(); - exit(0); - } else if (strcmp(argv[i], "-d") == 0) { - strcpy(dbName, argv[++i]); - } else if (strcmp(argv[i], "-c") == 0) { - strcpy(configDir, argv[++i]); - } else if (strcmp(argv[i], "-s") == 0) { - strcpy(stableName, argv[++i]); - } else if (strcmp(argv[i], "-r") == 0) { - rowsPerTable = atoi(argv[++i]); - } else if (strcmp(argv[i], "-p") == 0) { - pointsPerTable = atoi(argv[++i]); - } else if (strcmp(argv[i], "-t") == 0) { - numOfThreads = atoi(argv[++i]); - } else if (strcmp(argv[i], "-n") == 0) { - numOfTablesPerThread = atoi(argv[++i]); - } else if (strcmp(argv[i], "-tables") == 0) { - tables = atoi(argv[++i]); - } else if (strcmp(argv[i], "-cache") == 0) { - cache = atoi(argv[++i]); - } else { - } - } - - pPrint("%srowsPerTable:%" PRId64 "%s", GREEN, rowsPerTable, NC); - pPrint("%spointsPerTable:%" PRId64 "%s", GREEN, pointsPerTable, NC); - pPrint("%snumOfThreads:%" PRId64 "%s", GREEN, numOfThreads, NC); - pPrint("%snumOfTablesPerThread:%" PRId64 "%s", GREEN, numOfTablesPerThread, NC); - pPrint("%scache:%" PRId32 "%s", GREEN, cache, NC); - pPrint("%stables:%" PRId32 "%s", GREEN, tables, NC); - pPrint("%sdbName:%s%s", GREEN, dbName, NC); - pPrint("%stableName:%s%s", GREEN, stableName, NC); - pPrint("%sstart to run%s", GREEN, NC); -} diff --git a/tests/test/c/invalidTableId.c b/tests/test/c/invalidTableId.c deleted file mode 100644 index 286d0f12919608a6594b3f8fdc33fb863c93b3bd..0000000000000000000000000000000000000000 --- a/tests/test/c/invalidTableId.c +++ /dev/null @@ -1,220 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "../../../include/client/taos.h" -#include "hash.h" -#include "os.h" -#include "taoserror.h" -#include "tglobal.h" -#include "tulog.h" -#include "tutil.h" - -#define MAX_RANDOM_POINTS 20000 -#define GREEN "\033[1;32m" -#define NC "\033[0m" - -#define MAX_DB_NUM 100 -void * con; -char dbNames[MAX_DB_NUM][48]; -int32_t dbNum = 0; -void parseArgument(int argc, char *argv[]); -void connDb(); -void getDbNames(); -void printDbNames(); -void queryTables(char *dbName); -void checkTables(char *dbName); - -int main(int argc, char *argv[]) { - parseArgument(argc, argv); - taos_init(); - connDb(); - getDbNames(); - printDbNames(); - for (int dbIndex = 0; dbIndex < dbNum; ++dbIndex) { - queryTables((char*)(dbNames[dbIndex])); - checkTables((char*)(dbNames[dbIndex])); - } - - pPrint("all %d database is checked", dbNum); -} - -void connDb() { - con = taos_connect(NULL, "root", "taosdata", NULL, 0); - if (con == NULL) { - pError("failed to connect to DB, reason:%s", taos_errstr(con)); - exit(0); - } -} - -void getDbNames() { - if (dbNum != 0) return; - - char * qstr = "show databases"; - TAOS_RES *result = taos_query(con, qstr); - int32_t code = taos_errno(result); - if (result == NULL || code != 0) { - pError("failed to exec sql:%s, code:0x%x reason:%s", qstr, code & 0XFFFF, tstrerror(code)); - exit(0); - } - - TAOS_ROW row; - int num_fields = taos_num_fields(result); - if (num_fields <= 0) return; - while ((row = taos_fetch_row(result))) { - char * dbName = (char*)dbNames[dbNum]; - int32_t *length = taos_fetch_lengths(result); - int len = length[0]; - memcpy(dbName, (char *)row[0], len); - dbName[len] = 0; - dbNum++; - } - - taos_free_result(result); -} - -void printDbNames() { - for (int dbIndex = 0; dbIndex < dbNum; ++dbIndex) { - pPrint("db:%d %s", dbIndex, dbNames[dbIndex]); - } -} - -void queryTables(char *dbName) { - char qstr[1024]; - char fileName[1024]; - char ts[35] = {0}; - int32_t precision = 1000; - - sprintf(qstr, "show %s.tables", dbName); - sprintf(fileName, "%s_tables.txt", dbName); - - TAOS_RES *result = taos_query(con, qstr); - int32_t code = taos_errno(result); - if (result == NULL || code != 0) { - pError("failed to exec sql:%s, code:0x%x reason:%s", qstr, code & 0XFFFF, tstrerror(code)); - exit(0); - } - - FILE *fp = fopen(fileName, "w"); - if (!fp) return; - - TAOS_ROW row; - int32_t rows = 0; - while ((row = taos_fetch_row(result))) { - char tableName[256] = {0}; - int32_t *length = taos_fetch_lengths(result); - int len = length[0]; - memcpy(tableName, (char *)row[0], len); - tableName[len] = 0; - - int64_t t = *((int64_t *)row[1]); - time_t tt = t / 1000; - struct tm *ptm = localtime(&tt); - int32_t tl = (int32_t)strftime(ts, 35, "%Y-%m-%d %H:%M:%S", ptm); - snprintf(ts + tl, 5, ".%03ld", t % precision); - - // fprintf(fp, "%s %s\n", tableName, ts); - fprintf(fp, "%s.%s\n", dbName, tableName); - rows++; - } - - taos_free_result(result); - fclose(fp); - pPrint("db:%s has %d tables, write to %s", dbName, rows, fileName); -} - -void checkTables(char *dbName) { - char qstr[1024]; - char fileName1[1024]; - char fileName2[1024]; - - sprintf(qstr, "show %s.tables", dbName); - sprintf(fileName1, "%s_tables.txt", dbName); - sprintf(fileName2, "%s_count.txt", dbName); - - FILE *fp1 = fopen(fileName1, "r"); - if (!fp1) return; - - FILE *fp2 = fopen(fileName2, "w"); - if (!fp2) return; - - int32_t successRows = 0; - int32_t failedRows = 0; - char tbName[256]; - while (!feof(fp1)) { - int size = fscanf(fp1, "%s", tbName); - if (size <= 0) { - break; - } - - sprintf(qstr, "select count(*) from %s", tbName); - TAOS_RES *result = taos_query(con, qstr); - int32_t code = taos_errno(result); - if (result == NULL || code != 0) { - pError("failed to exec sql:%s, code:0x%x reason:%s", qstr, code & 0XFFFF, tstrerror(code)); - fprintf(fp2, "%s failed to exec sql:%s, code:0x%x reason:%s", tbName, qstr, code & 0XFFFF, tstrerror(code)); - taos_free_result(result); - failedRows++; - continue; - } - - TAOS_ROW row; - int64_t count = 0; - while ((row = taos_fetch_row(result))) { - count = *((int64_t *)row[0]); - } - fprintf(fp2, "%s %" PRId64 "\n", tbName, count); - - successRows++; - if (successRows % 1000 == 0) { - pPrint("query %d tables", successRows); - } - taos_free_result(result); - } - - fclose(fp1); - fclose(fp2); - pPrint("db:%s query tables, success:%d failed:%d write to %s", dbName, successRows, failedRows, fileName2); -} - -void printHelp() { - char indent[10] = " "; - printf("Used to checkTables\n"); - - printf("%s%s\n", indent, "-c"); - printf("%s%s%s%s\n", indent, indent, "Configuration directory, default is ", configDir); - printf("%s%s\n", indent, "-d"); - printf("%s%s%s%s\n", indent, indent, "The name of the database to be checked, default is ", "all"); - - exit(EXIT_SUCCESS); -} - -void parseArgument(int argc, char *argv[]) { - for (int i = 1; i < argc; i++) { - if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { - printHelp(); - exit(0); - } else if (strcmp(argv[i], "-d") == 0) { - strcpy(dbNames[0], argv[++i]); - dbNum++; - } else if (strcmp(argv[i], "-c") == 0) { - strcpy(configDir, argv[++i]); - } else { - } - } - - pPrint("%s configDir:%s %s", GREEN, configDir, NC); - pPrint("%s start to checkTables %s", GREEN, NC); -} diff --git a/tests/test/c/queryPerformance.c b/tests/test/c/queryPerformance.c deleted file mode 100644 index afe5cd0ccbf11a2ba8595666614d7faf81817fa3..0000000000000000000000000000000000000000 --- a/tests/test/c/queryPerformance.c +++ /dev/null @@ -1,183 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "../../../include/client/taos.h" -#include "os.h" -#include "tglobal.h" -#include "ttimer.h" -#include "tulog.h" -#include "tutil.h" - -#define MAX_RANDOM_POINTS 20000 -#define GREEN "\033[1;32m" -#define NC "\033[0m" - -typedef struct { - int64_t startTimeMs; - int64_t endTimeMs; - int threadIndex; - pthread_t thread; -} SInfo; - -void *syncTest(void *param); -void shellParseArgument(int argc, char *argv[]); -void queryData(); - -int numOfThreads = 10; -int useGlobalConn = 1; -int requestPerThread = 10000; -char requestSql[10240] = "show dnodes"; -TAOS *globalConn; - -int main(int argc, char *argv[]) { - shellParseArgument(argc, argv); - taos_init(); - queryData(); -} - -void queryData() { - struct timeval systemTime; - int64_t st, et; - char fqdn[TSDB_FQDN_LEN]; - uint16_t port; - - if (useGlobalConn) { - taosGetFqdnPortFromEp(tsFirst, fqdn, &port); - - globalConn = taos_connect(fqdn, "root", "taosdata", NULL, port); - if (globalConn == NULL) { - pError("failed to connect to DB, reason:%s", taos_errstr(globalConn)); - exit(1); - } - } - - pPrint("%d threads are spawned to query", numOfThreads); - - gettimeofday(&systemTime, NULL); - st = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - - pthread_attr_t thattr; - pthread_attr_init(&thattr); - pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE); - SInfo *pInfo = (SInfo *)malloc(sizeof(SInfo) * numOfThreads); - - // Start threads to write - for (int i = 0; i < numOfThreads; ++i) { - pInfo[i].threadIndex = i; - pthread_create(&(pInfo[i].thread), &thattr, syncTest, (void *)(pInfo + i)); - } - - taosMsleep(300); - for (int i = 0; i < numOfThreads; i++) { - pthread_join(pInfo[i].thread, NULL); - } - - gettimeofday(&systemTime, NULL); - et = systemTime.tv_sec * 1000000 + systemTime.tv_usec; - double totalTimeMs = (et - st) / 1000.0; - - int totalReq = requestPerThread * numOfThreads; - float rspTime = totalTimeMs / requestPerThread; - float qps = totalReq / (totalTimeMs / 1000); - - pPrint("%s threads:%d, totalTime %.1fms totalReq:%d qps:%.1f rspTime:%.3fms %s", GREEN, numOfThreads, totalTimeMs, - totalReq, qps, rspTime, NC); - - pthread_attr_destroy(&thattr); - free(pInfo); -} - -void *syncTest(void *param) { - TAOS * con; - SInfo * pInfo = (SInfo *)param; - char fqdn[TSDB_FQDN_LEN]; - uint16_t port; - - if (useGlobalConn) { - pPrint("thread:%d, start to run use global connection", pInfo->threadIndex); - con = globalConn; - } else { - pPrint("thread:%d, start to run, and create new conn", pInfo->threadIndex); - taosGetFqdnPortFromEp(tsFirst, fqdn, &port); - - con = taos_connect(fqdn, "root", "taosdata", NULL, port); - if (con == NULL) { - pError("index:%d, failed to connect to DB, reason:%s", pInfo->threadIndex, taos_errstr(con)); - exit(1); - } - } - - for (int i = 0; i < requestPerThread; ++i) { - void *tres = taos_query(con, requestSql); - - TAOS_ROW row = taos_fetch_row(tres); - if (row == NULL) { - taos_free_result(tres); - exit(0); - } - - do { - row = taos_fetch_row(tres); - } while (row != NULL); - - taos_free_result(tres); - } - return NULL; -} - -void printHelp() { - char indent[10] = " "; - printf("Used to test the query performance of TDengine\n"); - - printf("%s%s\n", indent, "-c"); - printf("%s%s%s%s\n", indent, indent, "Configuration directory, default is ", configDir); - printf("%s%s\n", indent, "-s"); - printf("%s%s%s%s\n", indent, indent, "The sql to be executed, default is ", requestSql); - printf("%s%s\n", indent, "-r"); - printf("%s%s%s%d\n", indent, indent, "Request per thread, default is ", requestPerThread); - printf("%s%s\n", indent, "-t"); - printf("%s%s%s%d\n", indent, indent, "Number of threads to be used, default is ", numOfThreads); - printf("%s%s\n", indent, "-g"); - printf("%s%s%s%d\n", indent, indent, "Whether to share connections between threads, default is ", useGlobalConn); - - exit(EXIT_SUCCESS); -} - -void shellParseArgument(int argc, char *argv[]) { - for (int i = 1; i < argc; i++) { - if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { - printHelp(); - exit(0); - } else if (strcmp(argv[i], "-c") == 0) { - strcpy(configDir, argv[++i]); - } else if (strcmp(argv[i], "-s") == 0) { - strcpy(requestSql, argv[++i]); - } else if (strcmp(argv[i], "-r") == 0) { - requestPerThread = atoi(argv[++i]); - } else if (strcmp(argv[i], "-t") == 0) { - numOfThreads = atoi(argv[++i]); - } else if (strcmp(argv[i], "-g") == 0) { - useGlobalConn = atoi(argv[++i]); - } else { - } - } - - pPrint("%s sql:%s %s", GREEN, requestSql, NC); - pPrint("%s requestPerThread:%d %s", GREEN, requestPerThread, NC); - pPrint("%s numOfThreads:%d %s", GREEN, numOfThreads, NC); - pPrint("%s useGlobalConn:%d %s", GREEN, useGlobalConn, NC); - pPrint("%s start to run %s", GREEN, NC); -} diff --git a/tools/shell/CMakeLists.txt b/tools/shell/CMakeLists.txt index def421c21230a05fbec31b1cd8fe8f528e33638a..b351675e4784a2ce31f321d8e224dc802fef1399 100644 --- a/tools/shell/CMakeLists.txt +++ b/tools/shell/CMakeLists.txt @@ -1,6 +1,4 @@ aux_source_directory(src SHELL_SRC) -list(REMOVE_ITEM SHELL_SRC src/shellWindows.c) -list(REMOVE_ITEM SHELL_SRC src/shellDarwin.c) add_executable(shell ${SHELL_SRC}) target_link_libraries(