From 419a061075590949f9255fa7b020bb08dd73dd2f Mon Sep 17 00:00:00 2001 From: slguan Date: Sat, 14 Mar 2020 17:57:06 +0800 Subject: [PATCH] [TD-10] --- src/client/inc/tscUtil.h | 4 +- src/client/src/tscLocal.c | 4 +- src/client/src/tscServer.c | 4 +- src/common/inc/dataformat.h | 1 - src/dnode/src/dnodeMgmt.c | 56 +++++++++----- src/dnode/src/dnodeWrite.c | 115 ++++++++++++++++++----------- src/inc/taosdef.h | 14 ++++ src/inc/taosmsg.h | 1 - src/mnode/CMakeLists.txt | 1 + src/mnode/src/mgmtNormalTable.c | 43 +++++------ src/mnode/src/mgmtSuperTable.c | 2 +- src/mnode/src/mgmtTable.c | 32 ++++---- src/vnode/tsdb/inc/tsdb.h | 7 -- src/vnode/tsdb/inc/tsdbMeta.h | 2 +- src/vnode/tsdb/src/tsdbMain.c | 8 +- src/vnode/tsdb/src/tsdbMeta.c | 20 ++--- src/vnode/tsdb/tests/tsdbTests.cpp | 2 +- 17 files changed, 180 insertions(+), 136 deletions(-) diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h index a869e45198..01537d716b 100644 --- a/src/client/inc/tscUtil.h +++ b/src/client/inc/tscUtil.h @@ -30,10 +30,10 @@ extern "C" { #include "taosdef.h" #define UTIL_METER_IS_SUPERTABLE(metaInfo) \ - (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->tableType == TSDB_TABLE_TYPE_SUPER_TABLE)) + (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->tableType == TSDB_SUPER_TABLE)) #define UTIL_METER_IS_NOMRAL_METER(metaInfo) (!(UTIL_METER_IS_SUPERTABLE(metaInfo))) #define UTIL_METER_IS_CREATE_FROM_METRIC(metaInfo) \ - (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->tableType == TSDB_TABLE_TYPE_CHILD_TABLE)) + (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->tableType == TSDB_CHILD_TABLE)) #define TSDB_COL_IS_TAG(f) (((f)&TSDB_COL_TAG) != 0) diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c index 89b43816c8..988e08c1ad 100644 --- a/src/client/src/tscLocal.c +++ b/src/client/src/tscLocal.c @@ -79,8 +79,8 @@ static int32_t getToStringLength(const char *pData, int32_t length, int32_t type static int32_t tscMaxLengthOfTagsFields(SSqlObj *pSql) { STableMeta *pMeta = tscGetMeterMetaInfo(&pSql->cmd, 0, 0)->pMeterMeta; - if (pMeta->tableType == TSDB_TABLE_TYPE_SUPER_TABLE || pMeta->tableType == TSDB_TABLE_TYPE_NORMAL_TABLE || - pMeta->tableType == TSDB_TABLE_TYPE_STREAM_TABLE) { + if (pMeta->tableType == TSDB_SUPER_TABLE || pMeta->tableType == TSDB_NORMAL_TABLE || + pMeta->tableType == TSDB_STREAM_TABLE) { return 0; } diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c index 83cf638133..14b8e335e5 100644 --- a/src/client/src/tscServer.c +++ b/src/client/src/tscServer.c @@ -2625,7 +2625,7 @@ int tscProcessMeterMetaRsp(SSqlObj *pSql) { // int32_t tagLen = 0; // SSchema *pTagsSchema = tsGetTagSchema(pMeta); // -// if (pMeta->tableType == TSDB_TABLE_TYPE_CHILD_TABLE) { +// if (pMeta->tableType == TSDB_CHILD_TABLE) { // for (int32_t i = 0; i < pMeta->numOfTags; ++i) { // tagLen += pTagsSchema[i].bytes; // } @@ -2740,7 +2740,7 @@ int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) { int32_t tagLen = 0; SSchema *pTagsSchema = tsGetTagSchema(pMeta); - if (pMeta->tableType == TSDB_TABLE_TYPE_CHILD_TABLE) { + if (pMeta->tableType == TSDB_CHILD_TABLE) { for (int32_t j = 0; j < pMeta->numOfTags; ++j) { tagLen += pTagsSchema[j].bytes; } diff --git a/src/common/inc/dataformat.h b/src/common/inc/dataformat.h index 4589a0573a..a269bdc258 100644 --- a/src/common/inc/dataformat.h +++ b/src/common/inc/dataformat.h @@ -21,7 +21,6 @@ #include "taosdef.h" - #ifdef __cplusplus extern "C" { #endif diff --git a/src/dnode/src/dnodeMgmt.c b/src/dnode/src/dnodeMgmt.c index 79d2de7739..33bd21bd31 100644 --- a/src/dnode/src/dnodeMgmt.c +++ b/src/dnode/src/dnodeMgmt.c @@ -87,18 +87,7 @@ int32_t dnodeInitMgmt() { cfg.cfg.maxSessions = 1000; cfg.cfg.daysPerFile = 10; - dnodeCreateVnode(&cfg); - SVnodeObj *pVnode = dnodeGetVnode(cfg.cfg.vgId); - dnodeDropVnode(pVnode); - - // dnodeCreateVnode(&cfg); - // SVnodeObj *pVnode = dnodeGetVnode(cfg.cfg.vgId); - // dnodeCleanupVnodes(); - - dnodeOpenVnodes(); - dnodeCleanupVnodes(); - - //return dnodeOpenVnodes(); + return dnodeOpenVnodes(); } void dnodeCleanupMgmt() { @@ -182,9 +171,9 @@ static int32_t dnodeOpenVnodes() { int32_t vnode = atoi(de->d_name + 5); if (vnode == 0) continue; - char tsdbDir[TSDB_FILENAME_LEN]; - sprintf(tsdbDir, "%s/%s", tsVnodeDir, de->d_name); - int32_t code = dnodeOpenVnode(vnode, tsdbDir); + char vnodeDir[TSDB_FILENAME_LEN]; + sprintf(vnodeDir, "%s/%s", tsVnodeDir, de->d_name); + int32_t code = dnodeOpenVnode(vnode, vnodeDir); if (code == 0) { numOfVnodes++; } @@ -203,9 +192,11 @@ static void dnodeCleanupVnodes() { } static int32_t dnodeOpenVnode(int32_t vnode, char *rootDir) { - void *pTsdb = tsdbOpenRepo(rootDir); + char tsdbDir[TSDB_FILENAME_LEN]; + sprintf(tsdbDir, "%s/tsdb", rootDir); + void *pTsdb = tsdbOpenRepo(tsdbDir); if (pTsdb == NULL) { - dError("failed to open vnode:%d in dir:%s, reason:%s", vnode, rootDir, tstrerror(terrno)); + dError("failed to open tsdb in vnode:%d %s, reason:%s", vnode, tsdbDir, tstrerror(terrno)); return terrno; } @@ -260,7 +251,7 @@ static void dnodeCleanupVnode(SVnodeObj *pVnode) { } static int32_t dnodeCreateVnode(SMDCreateVnodeMsg *pVnodeCfg) { - STsdbCfg tsdbCfg; + STsdbCfg tsdbCfg = {0}; tsdbCfg.vgId = pVnodeCfg->cfg.vgId; tsdbCfg.precision = pVnodeCfg->cfg.precision; tsdbCfg.tsdbId = pVnodeCfg->vnode; @@ -273,9 +264,32 @@ static int32_t dnodeCreateVnode(SMDCreateVnodeMsg *pVnodeCfg) { char rootDir[TSDB_FILENAME_LEN] = {0}; sprintf(rootDir, "%s/vnode%d", tsVnodeDir, pVnodeCfg->cfg.vgId); + if (mkdir(rootDir, 0755) != 0) { + if (errno == EACCES) { + return TSDB_CODE_NO_DISK_PERMISSIONS; + } else if (errno == ENOSPC) { + return TSDB_CODE_SERV_NO_DISKSPACE; + } else if (errno == EEXIST) { + } else { + return TSDB_CODE_VG_INIT_FAILED; + } + } + + sprintf(rootDir, "%s/vnode%d/tsdb", tsVnodeDir, pVnodeCfg->cfg.vgId); + if (mkdir(rootDir, 0755) != 0) { + if (errno == EACCES) { + return TSDB_CODE_NO_DISK_PERMISSIONS; + } else if (errno == ENOSPC) { + return TSDB_CODE_SERV_NO_DISKSPACE; + } else if (errno == EEXIST) { + } else { + return TSDB_CODE_VG_INIT_FAILED; + } + } void *pTsdb = tsdbCreateRepo(rootDir, &tsdbCfg, NULL); if (pTsdb == NULL) { + dError("failed to create tsdb in vnode:%d, reason:%s", pVnodeCfg->vnode, tstrerror(terrno)); return terrno; } @@ -295,6 +309,7 @@ static int32_t dnodeCreateVnode(SMDCreateVnodeMsg *pVnodeCfg) { taosAddIntHash(tsDnodeVnodesHash, vnodeObj.vgId, (char *) (&vnodeObj)); + dPrint("vnode:%d is created", pVnodeCfg->vnode); return TSDB_CODE_SUCCESS; } @@ -324,13 +339,16 @@ static void dnodeProcessCreateVnodeMsg(SRpcMsg *rpcMsg) { pCreate->cfg.maxSessions = htonl(pCreate->cfg.maxSessions); pCreate->cfg.daysPerFile = htonl(pCreate->cfg.daysPerFile); + dTrace("start to create vnode:%d", pCreate->vnode); + SVnodeObj *pVnodeObj = (SVnodeObj *) taosGetIntHashData(tsDnodeVnodesHash, pCreate->cfg.vgId); if (pVnodeObj != NULL) { rpcRsp.code = TSDB_CODE_SUCCESS; + dPrint("vnode:%d is already exist", pCreate->vnode); } else { rpcRsp.code = dnodeCreateVnode(pCreate); } - rpcRsp.code = TSDB_CODE_SUCCESS; + rpcSendResponse(&rpcRsp); } diff --git a/src/dnode/src/dnodeWrite.c b/src/dnode/src/dnodeWrite.c index c5d44cc95a..8182e0826c 100644 --- a/src/dnode/src/dnodeWrite.c +++ b/src/dnode/src/dnodeWrite.c @@ -20,6 +20,8 @@ #include "tlog.h" #include "tqueue.h" #include "trpc.h" +#include "tsdb.h" +#include "dataformat.h" #include "dnodeWrite.h" #include "dnodeMgmt.h" @@ -106,13 +108,13 @@ void dnodeWrite(SRpcMsg *pMsg) { while (leftLen > 0) { SWriteMsgHead *pHead = (SWriteMsgHead *) pCont; - int32_t vgId = htonl(pHead->vgId); - int32_t contLen = htonl(pHead->contLen); + pHead->vgId = htonl(pHead->vgId); + pHead->contLen = htonl(pHead->contLen); - void *pVnode = dnodeGetVnode(vgId); + void *pVnode = dnodeGetVnode(pHead->vgId); if (pVnode == NULL) { - leftLen -= contLen; - pCont -= contLen; + leftLen -= pHead->contLen; + pCont -= pHead->contLen; continue; } @@ -120,7 +122,7 @@ void dnodeWrite(SRpcMsg *pMsg) { SWriteMsg writeMsg; writeMsg.rpcMsg = *pMsg; writeMsg.pCont = pCont; - writeMsg.contLen = contLen; + writeMsg.contLen = pHead->contLen; writeMsg.pRpcContext = pRpcContext; writeMsg.pVnode = pVnode; // pVnode shall be saved for usage later @@ -128,8 +130,8 @@ void dnodeWrite(SRpcMsg *pMsg) { taosWriteQitem(queue, &writeMsg); // next vnode - leftLen -= contLen; - pCont -= contLen; + leftLen -= pHead->contLen; + pCont -= pHead->contLen; queuedMsgNum++; } @@ -148,7 +150,7 @@ void dnodeWrite(SRpcMsg *pMsg) { void *dnodeAllocateWriteWorker() { SWriteWorker *pWorker = wWorkerPool.writeWorker + wWorkerPool.nextId; taos_queue *queue = taosOpenQueue(sizeof(SWriteMsg)); - if (queue != NULL) return queue; + if (queue == NULL) return NULL; if (pWorker->qset == NULL) { pWorker->qset = taosOpenQset(); @@ -289,45 +291,68 @@ static void dnodeProcessSubmitMsg(SWriteMsg *pMsg) { static void dnodeProcessCreateTableMsg(SWriteMsg *pMsg) { SMDCreateTableMsg *pTable = pMsg->rpcMsg.pCont; - if (pTable->tableType == TSDB_TABLE_TYPE_CHILD_TABLE) { - dTrace("table:%s, start to create child table, stable:%s", pTable->tableId, pTable->superTableId); - } else if (pTable->tableType == TSDB_TABLE_TYPE_NORMAL_TABLE){ - dTrace("table:%s, start to create normal table", pTable->tableId); - } else if (pTable->tableType == TSDB_TABLE_TYPE_STREAM_TABLE){ - dTrace("table:%s, start to create stream table", pTable->tableId); - } else { - dError("table:%s, invalid table type:%d", pTable->tableType); + dTrace("start to create table:%s in vgroup:%d", pTable->tableId, pTable->vgId); + + SRpcMsg rpcRsp = {.handle = pMsg->rpcMsg.handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; + void *pVnode = dnodeGetVnode(pTable->vgId); + if (pVnode == NULL) { + rpcRsp.code = TSDB_CODE_INVALID_VGROUP_ID; + dTrace("failed to create table:%s in vgroup:%d, reason:%s", pTable->tableId, pTable->vgId, tstrerror(rpcRsp.code)); + rpcSendResponse(&rpcRsp); + return; } -// pTable->numOfColumns = htons(pTable->numOfColumns); -// pTable->numOfTags = htons(pTable->numOfTags); -// pTable->sid = htonl(pTable->sid); -// pTable->sversion = htonl(pTable->sversion); -// pTable->tagDataLen = htonl(pTable->tagDataLen); -// pTable->sqlDataLen = htonl(pTable->sqlDataLen); -// pTable->contLen = htonl(pTable->contLen); -// pTable->numOfVPeers = htonl(pTable->numOfVPeers); -// pTable->uid = htobe64(pTable->uid); -// pTable->superTableUid = htobe64(pTable->superTableUid); -// pTable->createdTime = htobe64(pTable->createdTime); -// -// for (int i = 0; i < pTable->numOfVPeers; ++i) { -// pTable->vpeerDesc[i].ip = htonl(pTable->vpeerDesc[i].ip); -// pTable->vpeerDesc[i].vnode = htonl(pTable->vpeerDesc[i].vnode); -// } -// -// int32_t totalCols = pTable->numOfColumns + pTable->numOfTags; -// SSchema *pSchema = (SSchema *) pTable->data; -// for (int32_t col = 0; col < totalCols; ++col) { -// pSchema->bytes = htons(pSchema->bytes); -// pSchema->colId = htons(pSchema->colId); -// pSchema++; -// } -// -// int32_t code = dnodeCreateTable(pTable); + void *pTsdb = dnodeGetVnodeTsdb(pVnode); + if (pTsdb == NULL) { + dnodeReleaseVnode(pVnode); + rpcRsp.code = TSDB_CODE_NOT_ACTIVE_VNODE; + dTrace("failed to create table:%s in vgroup:%d, reason:%s", pTable->tableId, pTable->vgId, tstrerror(rpcRsp.code)); + rpcSendResponse(&rpcRsp); + return; + } - SRpcMsg rpcRsp = {.handle = pMsg->rpcMsg.handle, .pCont = NULL, .contLen = 0, .code = 0, .msgType = 0}; - rpcSendResponse(&rpcRsp); + pTable->numOfColumns = htons(pTable->numOfColumns); + pTable->numOfTags = htons(pTable->numOfTags); + pTable->sid = htonl(pTable->sid); + pTable->sversion = htonl(pTable->sversion); + pTable->tagDataLen = htonl(pTable->tagDataLen); + pTable->sqlDataLen = htonl(pTable->sqlDataLen); + pTable->uid = htobe64(pTable->uid); + pTable->superTableUid = htobe64(pTable->superTableUid); + pTable->createdTime = htobe64(pTable->createdTime); + SSchema *pSchema = (SSchema *) pTable->data; + + STableCfg tCfg; + tsdbInitTableCfg(&tCfg, pTable->tableType, pTable->uid, pTable->sid); + + STSchema *pDestSchema = tdNewSchema(pTable->numOfColumns); + for (int i = 0; i < pTable->numOfColumns; i++) { + tdSchemaAppendCol(pDestSchema, pSchema[i].type, htons(pSchema[i].colId), htons(pSchema[i].bytes)); + } + tsdbTableSetSchema(&tCfg, pDestSchema, false); + + if (pTable->numOfTags != NULL) { + STSchema *pDestTagSchema = tdNewSchema(pTable->numOfTags); + for (int i = pTable->numOfColumns; i < pTable->numOfColumns + pTable->numOfTags; i++) { + tdSchemaAppendCol(pDestTagSchema, pSchema[i].type, htons(pSchema[i].colId), htons(pSchema[i].bytes)); + } + tsdbTableSetSchema(&tCfg, pDestTagSchema, false); + } + + if (pTable->tableType == TSDB_CHILD_TABLE) { + // TODO: add data row + } + + rpcRsp.code = tsdbCreateTable(pTsdb, &tCfg); + dnodeReleaseVnode(pVnode); + + if (rpcRsp.code != TSDB_CODE_SUCCESS) { + dError("failed to create table:%s in vgroup:%d, reason:%s", pTable->tableId, pTable->vgId, tstrerror(rpcRsp.code)); + rpcSendResponse(&rpcRsp); + } else { + dTrace("create table:%s in vgroup:%d finished", pTable->tableId, pTable->vgId); + rpcSendResponse(&rpcRsp); + } } static void dnodeProcessDropTableMsg(SWriteMsg *pMsg) { diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h index 85bdfea98f..712c99adc2 100644 --- a/src/inc/taosdef.h +++ b/src/inc/taosdef.h @@ -297,6 +297,20 @@ void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size); #define TSDB_SESSIONS_PER_VNODE (300) #define TSDB_SESSIONS_PER_DNODE (TSDB_SESSIONS_PER_VNODE * TSDB_MAX_VNODES) +enum { + TSDB_PRECISION_MILLI, + TSDB_PRECISION_MICRO, + TSDB_PRECISION_NANO +}; + +typedef enum { + TSDB_SUPER_TABLE = 0, // super table + TSDB_CHILD_TABLE = 1, // table created from super table + TSDB_NORMAL_TABLE = 2, // ordinary table + TSDB_STREAM_TABLE = 3, // table created from stream computing + TSDB_TABLE_MAX = 4 +} TSDB_TABLE_TYPE; + #ifdef __cplusplus } #endif diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h index 34ef1eb67c..f78c82c758 100644 --- a/src/inc/taosmsg.h +++ b/src/inc/taosmsg.h @@ -251,7 +251,6 @@ typedef struct { typedef struct { int32_t contLen; int32_t vgId; - int8_t tableType; int16_t numOfColumns; int16_t numOfTags; diff --git a/src/mnode/CMakeLists.txt b/src/mnode/CMakeLists.txt index 16dbbcb740..5bf4cfd604 100644 --- a/src/mnode/CMakeLists.txt +++ b/src/mnode/CMakeLists.txt @@ -4,6 +4,7 @@ PROJECT(TDengine) IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM)) INCLUDE_DIRECTORIES(${TD_OS_DIR}/inc) INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc) + INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc) INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc) INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/query/inc) INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/dnode/inc) diff --git a/src/mnode/src/mgmtNormalTable.c b/src/mnode/src/mgmtNormalTable.c index 7734672599..fc178b81c6 100644 --- a/src/mnode/src/mgmtNormalTable.c +++ b/src/mnode/src/mgmtNormalTable.c @@ -291,31 +291,26 @@ static void *mgmtBuildCreateNormalTableMsg(SNormalTableObj *pTable, SVgObj *pVgr int32_t totalCols = pTable->numOfColumns; int32_t contLen = sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema) + pTable->sqlLen; - SMDCreateTableMsg *pCreateTable = rpcMallocCont(contLen); - if (pCreateTable == NULL) { + SMDCreateTableMsg *pCreate = rpcMallocCont(contLen); + if (pCreate == NULL) { return NULL; } - memcpy(pCreateTable->tableId, pTable->tableId, TSDB_TABLE_ID_LEN); - pCreateTable->tableType = pTable->type; - pCreateTable->numOfColumns = htons(pTable->numOfColumns); - pCreateTable->numOfTags = htons(0); - pCreateTable->sid = htonl(pTable->sid); - pCreateTable->sversion = htonl(pTable->sversion); - pCreateTable->tagDataLen = htonl(0); - pCreateTable->sqlDataLen = htonl(pTable->sqlLen); - pCreateTable->contLen = htonl(contLen); - pCreateTable->numOfVPeers = htonl(pVgroup->numOfVnodes); - pCreateTable->uid = htobe64(pTable->uid); - pCreateTable->superTableUid = htobe64(0); - pCreateTable->createdTime = htobe64(pTable->createdTime); - - for (int i = 0; i < pVgroup->numOfVnodes; ++i) { - pCreateTable->vpeerDesc[i].ip = htonl(pVgroup->vnodeGid[i].ip); - pCreateTable->vpeerDesc[i].vnode = htonl(pVgroup->vnodeGid[i].vnode); - } - - SSchema *pSchema = (SSchema *) pCreateTable->data; + memcpy(pCreate->tableId, pTable->tableId, TSDB_TABLE_ID_LEN + 1); + pCreate->contLen = htonl(contLen); + pCreate->vgId = htonl(pVgroup->vgId); + pCreate->tableType = pTable->type; + pCreate->numOfColumns = htons(pTable->numOfColumns); + pCreate->numOfTags = htons(0); + pCreate->sid = htonl(pTable->sid); + pCreate->sversion = htonl(pTable->sversion); + pCreate->tagDataLen = htonl(0); + pCreate->sqlDataLen = htonl(pTable->sqlLen); + pCreate->uid = htobe64(pTable->uid); + pCreate->superTableUid = htobe64(0); + pCreate->createdTime = htobe64(pTable->createdTime); + + SSchema *pSchema = (SSchema *) pCreate->data; memcpy(pSchema, pTable->schema, totalCols * sizeof(SSchema)); for (int32_t col = 0; col < totalCols; ++col) { pSchema->bytes = htons(pSchema->bytes); @@ -323,9 +318,9 @@ static void *mgmtBuildCreateNormalTableMsg(SNormalTableObj *pTable, SVgObj *pVgr pSchema++; } - memcpy(pCreateTable + sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema), pTable->sql, pTable->sqlLen); + memcpy(pCreate + sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema), pTable->sql, pTable->sqlLen); - return pCreateTable; + return pCreate; } int32_t mgmtCreateNormalTable(SCMCreateTableMsg *pCreate, int32_t contLen, SVgObj *pVgroup, int32_t sid, diff --git a/src/mnode/src/mgmtSuperTable.c b/src/mnode/src/mgmtSuperTable.c index 088792bfac..65d4907e22 100644 --- a/src/mnode/src/mgmtSuperTable.c +++ b/src/mnode/src/mgmtSuperTable.c @@ -213,7 +213,7 @@ int32_t mgmtCreateSuperTable(SDbObj *pDb, SCMCreateTableMsg *pCreate) { } strcpy(pStable->tableId, pCreate->tableId); - pStable->type = TSDB_TABLE_TYPE_SUPER_TABLE; + pStable->type = TSDB_SUPER_TABLE; pStable->createdTime = taosGetTimestampMs(); pStable->vgId = 0; pStable->sid = 0; diff --git a/src/mnode/src/mgmtTable.c b/src/mnode/src/mgmtTable.c index ee0f19b89b..cbd1a11b91 100644 --- a/src/mnode/src/mgmtTable.c +++ b/src/mnode/src/mgmtTable.c @@ -119,11 +119,11 @@ STableInfo* mgmtGetTableByPos(uint32_t dnodeIp, int32_t vnode, int32_t sid) { } int32_t mgmtGetTableMeta(SDbObj *pDb, STableInfo *pTable, STableMeta *pMeta, bool usePublicIp) { - if (pTable->type == TSDB_TABLE_TYPE_CHILD_TABLE) { + if (pTable->type == TSDB_CHILD_TABLE) { mgmtGetChildTableMeta(pDb, (SChildTableObj *) pTable, pMeta, usePublicIp); - } else if (pTable->type == TSDB_TABLE_TYPE_NORMAL_TABLE) { + } else if (pTable->type == TSDB_NORMAL_TABLE) { mgmtGetNormalTableMeta(pDb, (SNormalTableObj *) pTable, pMeta, usePublicIp); - } else if (pTable->type == TSDB_TABLE_TYPE_SUPER_TABLE) { + } else if (pTable->type == TSDB_SUPER_TABLE) { mgmtGetSuperTableMeta(pDb, (SSuperTableObj *) pTable, pMeta, usePublicIp); } else { mTrace("%s, uid:%" PRIu64 " table meta retrieve failed, invalid type", pTable->tableId, pTable->uid); @@ -176,7 +176,7 @@ static void mgmtCreateTable(SVgObj *pVgroup, SQueuedMsg *pMsg) { SRpcIpSet ipSet = mgmtGetIpSetFromVgroup(pVgroup); SRpcMsg rpcMsg = { .handle = pMsg, - .pCont = pCreate, + .pCont = pMDCreate, .contLen = htonl(pMDCreate->contLen), .code = 0, .msgType = TSDB_MSG_TYPE_MD_CREATE_TABLE @@ -204,16 +204,16 @@ int32_t mgmtDropTable(SDbObj *pDb, char *tableId, int32_t ignore) { } switch (pTable->type) { - case TSDB_TABLE_TYPE_SUPER_TABLE: + case TSDB_SUPER_TABLE: mTrace("table:%s, start to drop super table", tableId); return mgmtDropSuperTable(pDb, (SSuperTableObj *) pTable); - case TSDB_TABLE_TYPE_CHILD_TABLE: + case TSDB_CHILD_TABLE: mTrace("table:%s, start to drop child table", tableId); return mgmtDropChildTable(pDb, (SChildTableObj *) pTable); - case TSDB_TABLE_TYPE_NORMAL_TABLE: + case TSDB_NORMAL_TABLE: mTrace("table:%s, start to drop normal table", tableId); return mgmtDropNormalTable(pDb, (SNormalTableObj *) pTable); - case TSDB_TABLE_TYPE_STREAM_TABLE: + case TSDB_STREAM_TABLE: mTrace("table:%s, start to drop stream table", tableId); return mgmtDropNormalTable(pDb, (SNormalTableObj *) pTable); default: @@ -233,31 +233,31 @@ int32_t mgmtAlterTable(SDbObj *pDb, SCMAlterTableMsg *pAlter) { } if (pAlter->type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) { - if (pTable->type == TSDB_TABLE_TYPE_SUPER_TABLE) { + if (pTable->type == TSDB_SUPER_TABLE) { return mgmtAddSuperTableTag((SSuperTableObj *) pTable, pAlter->schema, 1); } } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_TAG_COLUMN) { - if (pTable->type == TSDB_TABLE_TYPE_SUPER_TABLE) { + if (pTable->type == TSDB_SUPER_TABLE) { return mgmtDropSuperTableTag((SSuperTableObj *) pTable, pAlter->schema[0].name); } } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) { - if (pTable->type == TSDB_TABLE_TYPE_SUPER_TABLE) { + if (pTable->type == TSDB_SUPER_TABLE) { return mgmtModifySuperTableTagNameByName((SSuperTableObj *) pTable, pAlter->schema[0].name, pAlter->schema[1].name); } } else if (pAlter->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) { - if (pTable->type == TSDB_TABLE_TYPE_CHILD_TABLE) { + if (pTable->type == TSDB_CHILD_TABLE) { return mgmtModifyChildTableTagValueByName((SChildTableObj *) pTable, pAlter->schema[0].name, pAlter->tagVal); } } else if (pAlter->type == TSDB_ALTER_TABLE_ADD_COLUMN) { - if (pTable->type == TSDB_TABLE_TYPE_NORMAL_TABLE) { + if (pTable->type == TSDB_NORMAL_TABLE) { return mgmtAddNormalTableColumn((SNormalTableObj *) pTable, pAlter->schema, 1); - } else if (pTable->type == TSDB_TABLE_TYPE_SUPER_TABLE) { + } else if (pTable->type == TSDB_SUPER_TABLE) { return mgmtAddSuperTableColumn((SSuperTableObj *) pTable, pAlter->schema, 1); } else {} } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_COLUMN) { - if (pTable->type == TSDB_TABLE_TYPE_NORMAL_TABLE) { + if (pTable->type == TSDB_NORMAL_TABLE) { return mgmtDropNormalTableColumnByName((SNormalTableObj *) pTable, pAlter->schema[0].name); - } else if (pTable->type == TSDB_TABLE_TYPE_SUPER_TABLE) { + } else if (pTable->type == TSDB_SUPER_TABLE) { return mgmtDropSuperTableColumnByName((SSuperTableObj *) pTable, pAlter->schema[0].name); } else {} } else {} diff --git a/src/vnode/tsdb/inc/tsdb.h b/src/vnode/tsdb/inc/tsdb.h index 267b462b91..740451dafb 100644 --- a/src/vnode/tsdb/inc/tsdb.h +++ b/src/vnode/tsdb/inc/tsdb.h @@ -33,13 +33,6 @@ extern "C" { #define TSDB_INVALID_SUPER_TABLE_ID -1 // --------- TSDB REPOSITORY CONFIGURATION DEFINITION -enum { TSDB_PRECISION_MILLI, TSDB_PRECISION_MICRO, TSDB_PRECISION_NANO }; -typedef enum { - TSDB_SUPER_TABLE, // super table - TSDB_NTABLE, // table not created from super table - TSDB_STABLE // table created from super table -} TSDB_TABLE_TYPE; - typedef struct { int8_t precision; int32_t vgId; diff --git a/src/vnode/tsdb/inc/tsdbMeta.h b/src/vnode/tsdb/inc/tsdbMeta.h index be7c7d0406..5beba14057 100644 --- a/src/vnode/tsdb/inc/tsdbMeta.h +++ b/src/vnode/tsdb/inc/tsdbMeta.h @@ -42,7 +42,7 @@ typedef struct STable { STSchema * tagSchema; SDataRow tagVal; union { - void *pData; // For TSDB_NTABLE and TSDB_STABLE, it is the skiplist for cache data + void *pData; // For TSDB_NORMAL_TABLE and TSDB_CHILD_TABLE, it is the skiplist for cache data void *pIndex; // For TSDB_SUPER_TABLE, it is the skiplist index } content; void * eventHandler; // TODO diff --git a/src/vnode/tsdb/src/tsdbMain.c b/src/vnode/tsdb/src/tsdbMain.c index 0f70875c63..5b86ddbd48 100644 --- a/src/vnode/tsdb/src/tsdbMain.c +++ b/src/vnode/tsdb/src/tsdbMain.c @@ -340,7 +340,7 @@ int32_t tsdbInsertData(tsdb_repo_t *repo, SSubmitMsg *pMsg) { */ int tsdbInitTableCfg(STableCfg *config, TSDB_TABLE_TYPE type, int64_t uid, int32_t tid) { if (config == NULL) return -1; - if (type != TSDB_NTABLE && type != TSDB_STABLE) return -1; + if (type != TSDB_NORMAL_TABLE && type != TSDB_CHILD_TABLE) return -1; memset((void *)config, 0, sizeof(STableCfg)); @@ -355,7 +355,7 @@ int tsdbInitTableCfg(STableCfg *config, TSDB_TABLE_TYPE type, int64_t uid, int32 * Set the super table UID of the created table */ int tsdbTableSetSuperUid(STableCfg *config, int64_t uid) { - if (config->type != TSDB_STABLE) return -1; + if (config->type != TSDB_CHILD_TABLE) return -1; if (uid == TSDB_INVALID_SUPER_TABLE_ID) return -1; config->superUid = uid; @@ -388,7 +388,7 @@ int tsdbTableSetSchema(STableCfg *config, STSchema *pSchema, bool dup) { * @return 0 for success and -1 for failure */ int tsdbTableSetTagSchema(STableCfg *config, STSchema *pSchema, bool dup) { - if (config->type != TSDB_STABLE) return -1; + if (config->type != TSDB_CHILD_TABLE) return -1; if (dup) { config->tagSchema = tdDupSchema(pSchema); @@ -399,7 +399,7 @@ int tsdbTableSetTagSchema(STableCfg *config, STSchema *pSchema, bool dup) { } int tsdbTableSetTagValue(STableCfg *config, SDataRow row, bool dup) { - if (config->type != TSDB_STABLE) return -1; + if (config->type != TSDB_CHILD_TABLE) return -1; if (dup) { config->tagValues = tdDataRowDup(row); diff --git a/src/vnode/tsdb/src/tsdbMeta.c b/src/vnode/tsdb/src/tsdbMeta.c index 5c5c5c50f0..45ffdf36ad 100644 --- a/src/vnode/tsdb/src/tsdbMeta.c +++ b/src/vnode/tsdb/src/tsdbMeta.c @@ -137,7 +137,7 @@ int32_t tsdbCreateTableImpl(STsdbMeta *pMeta, STableCfg *pCfg) { STable *super = NULL; int newSuper = 0; - if (pCfg->type == TSDB_STABLE) { + if (pCfg->type == TSDB_CHILD_TABLE) { super = tsdbGetTableByUid(pMeta, pCfg->superUid); if (super == NULL) { // super table not exists, try to create it newSuper = 1; @@ -174,12 +174,12 @@ int32_t tsdbCreateTableImpl(STsdbMeta *pMeta, STableCfg *pCfg) { } table->tableId = pCfg->tableId; - if (IS_CREATE_STABLE(pCfg)) { // TSDB_STABLE - table->type = TSDB_STABLE; + if (IS_CREATE_STABLE(pCfg)) { // TSDB_CHILD_TABLE + table->type = TSDB_CHILD_TABLE; table->superUid = pCfg->superUid; table->tagVal = tdDataRowDup(pCfg->tagValues); - } else { // TSDB_NTABLE - table->type = TSDB_NTABLE; + } else { // TSDB_NORMAL_TABLE + table->type = TSDB_NORMAL_TABLE; table->superUid = -1; table->schema = tdDupSchema(pCfg->schema); } @@ -220,7 +220,7 @@ int32_t tsdbDropTableImpl(STsdbMeta *pMeta, STableId tableId) { pMeta->tables[pTable->tableId.tid] = NULL; pMeta->nTables--; assert(pMeta->nTables >= 0); - if (pTable->type == TSDB_STABLE) { + if (pTable->type == TSDB_CHILD_TABLE) { tsdbRemoveTableFromIndex(pMeta, pTable); } @@ -237,7 +237,7 @@ int32_t tsdbInsertRowToTableImpl(SSkipListNode *pNode, STable *pTable) { static int tsdbFreeTable(STable *pTable) { // TODO: finish this function - if (pTable->type == TSDB_STABLE) { + if (pTable->type == TSDB_CHILD_TABLE) { tdFreeDataRow(pTable->tagVal); } else { tdFreeSchema(pTable->schema); @@ -281,7 +281,7 @@ static int tsdbAddTableToMeta(STsdbMeta *pMeta, STable *pTable) { } else { // add non-super table to the array pMeta->tables[pTable->tableId.tid] = pTable; - if (pTable->type == TSDB_STABLE) { + if (pTable->type == TSDB_CHILD_TABLE) { // add STABLE to the index tsdbAddTableIntoIndex(pMeta, pTable); } @@ -305,13 +305,13 @@ static int tsdbAddTableIntoMap(STsdbMeta *pMeta, STable *pTable) { return 0; } static int tsdbAddTableIntoIndex(STsdbMeta *pMeta, STable *pTable) { - assert(pTable->type == TSDB_STABLE); + assert(pTable->type == TSDB_CHILD_TABLE); // TODO return 0; } static int tsdbRemoveTableFromIndex(STsdbMeta *pMeta, STable *pTable) { - assert(pTable->type == TSDB_STABLE); + assert(pTable->type == TSDB_CHILD_TABLE); // TODO return 0; } diff --git a/src/vnode/tsdb/tests/tsdbTests.cpp b/src/vnode/tsdb/tests/tsdbTests.cpp index 7b09fdfcde..cf24791fd1 100644 --- a/src/vnode/tsdb/tests/tsdbTests.cpp +++ b/src/vnode/tsdb/tests/tsdbTests.cpp @@ -15,7 +15,7 @@ TEST(TsdbTest, createRepo) { // 2. Create a normal table STableCfg tCfg; ASSERT_EQ(tsdbInitTableCfg(&tCfg, TSDB_SUPER_TABLE, 987607499877672L, 0), -1); - ASSERT_EQ(tsdbInitTableCfg(&tCfg, TSDB_NTABLE, 987607499877672L, 0), 0); + ASSERT_EQ(tsdbInitTableCfg(&tCfg, TSDB_NORMAL_TABLE, 987607499877672L, 0), 0); int nCols = 5; STSchema *schema = tdNewSchema(nCols); -- GitLab