diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h index b37bc5241dba2679ad3d166cbbdd739354073b4e..1b7b9161845d428c42b9b12b5f89996684e361bc 100644 --- a/src/client/inc/tscUtil.h +++ b/src/client/inc/tscUtil.h @@ -30,10 +30,10 @@ extern "C" { #include "tsdb.h" #define UTIL_METER_IS_SUPERTABLE(metaInfo) \ - (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->meterType == TSDB_TABLE_TYPE_SUPER_TABLE)) + (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->tableType == TSDB_TABLE_TYPE_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->meterType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE)) + (((metaInfo)->pMeterMeta != NULL) && ((metaInfo)->pMeterMeta->tableType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE)) #define TSDB_COL_IS_TAG(f) (((f)&TSDB_COL_TAG) != 0) diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h index fcbd3dac1f27a2bfadc470fcbab7075c1fab6246..7220a343598313a2be727159e75b5139af1701f7 100644 --- a/src/client/inc/tsclient.h +++ b/src/client/inc/tsclient.h @@ -54,7 +54,7 @@ typedef struct SMeterMetaInfo { * 2. keep the vnode index for multi-vnode insertion */ int32_t vnodeIndex; - char name[TSDB_METER_ID_LEN + 1]; // table(super table) name + char name[TSDB_TABLE_ID_LEN + 1]; // table(super table) name int16_t numOfTags; // total required tags in query, including groupby tags int16_t tagColumnIndex[TSDB_MAX_TAGS]; // clause + tag projection } SMeterMetaInfo; @@ -119,7 +119,7 @@ typedef struct SCond { } SCond; typedef struct SJoinNode { - char meterId[TSDB_METER_ID_LEN]; + char meterId[TSDB_TABLE_ID_LEN]; uint64_t uid; int16_t tagCol; } SJoinNode; @@ -154,7 +154,7 @@ typedef struct SParamInfo { } SParamInfo; typedef struct STableDataBlocks { - char meterId[TSDB_METER_ID_LEN]; + char meterId[TSDB_TABLE_ID_LEN]; int8_t tsSource; // where does the UNIX timestamp come from, server or client bool ordered; // if current rows are ordered or not int64_t vgid; // virtual group id @@ -302,7 +302,7 @@ typedef struct _tsc_obj { char user[TSDB_USER_LEN]; char pass[TSDB_KEY_LEN]; char acctId[TSDB_DB_NAME_LEN]; - char db[TSDB_METER_ID_LEN]; + char db[TSDB_TABLE_ID_LEN]; char sversion[TSDB_VERSION_LEN]; char writeAuth : 1; char superAuth : 1; diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c index d0a02e290ed06a90afa7e81f24d579737ea2bd6d..f5e34e5132d8b3f4b57598178f7c80e8e9d7f801 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) { SMeterMeta *pMeta = tscGetMeterMetaInfo(&pSql->cmd, 0, 0)->pMeterMeta; - if (pMeta->meterType == TSDB_TABLE_TYPE_SUPER_TABLE || pMeta->meterType == TSDB_TABLE_TYPE_NORMAL_TABLE || - pMeta->meterType == TSDB_TABLE_TYPE_STREAM_TABLE) { + if (pMeta->tableType == TSDB_TABLE_TYPE_SUPER_TABLE || pMeta->tableType == TSDB_TABLE_TYPE_NORMAL_TABLE || + pMeta->tableType == TSDB_TABLE_TYPE_STREAM_TABLE) { return 0; } diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c index 6ef28a55f60fc847dc36de26856682d2fb6b65c8..df3bc3331052156288e8de2ef44ff57375a1b315 100644 --- a/src/client/src/tscParseInsert.c +++ b/src/client/src/tscParseInsert.c @@ -776,7 +776,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) { SMeterMetaInfo *pSTableMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, STABLE_INDEX); setMeterID(pSTableMeterMetaInfo, &sToken, pSql); - strncpy(pTag->name, pSTableMeterMetaInfo->name, TSDB_METER_ID_LEN); + strncpy(pTag->name, pSTableMeterMetaInfo->name, TSDB_TABLE_ID_LEN); code = tscGetMeterMeta(pSql, pSTableMeterMetaInfo); if (code != TSDB_CODE_SUCCESS) { return code; @@ -950,7 +950,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) { } int validateTableName(char *tblName, int len) { - char buf[TSDB_METER_ID_LEN] = {0}; + char buf[TSDB_TABLE_ID_LEN] = {0}; strncpy(buf, tblName, len); SSQLToken token = {.n = len, .type = TK_ID, .z = buf}; @@ -1544,7 +1544,7 @@ void tscProcessMultiVnodesInsertFromFile(SSqlObj *pSql) { continue; } - strncpy(pMeterMetaInfo->name, pDataBlock->meterId, TSDB_METER_ID_LEN); + strncpy(pMeterMetaInfo->name, pDataBlock->meterId, TSDB_TABLE_ID_LEN); memset(pDataBlock->pData, 0, pDataBlock->nAllocSize); int32_t ret = tscGetMeterMeta(pSql, pMeterMetaInfo); diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index ef5ec5808b66b3a100fd72714d7e0972eb574298..f4b1216d33065ab934009b5a74b9bbbeb363f178 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -1072,11 +1072,11 @@ int32_t setObjFullName(char* fullName, const char* account, SSQLToken* pDB, SSQL *xlen = totalLen; } - if (totalLen < TSDB_METER_ID_LEN) { + if (totalLen < TSDB_TABLE_ID_LEN) { fullName[totalLen] = 0; } - return (totalLen <= TSDB_METER_ID_LEN) ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_SQL; + return (totalLen <= TSDB_TABLE_ID_LEN) ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_SQL; } static void extractColumnNameFromString(tSQLExprItem* pItem) { @@ -1901,7 +1901,7 @@ int32_t getMeterIndex(SSQLToken* pTableToken, SQueryInfo* pQueryInfo, SColumnInd } pIndex->tableIndex = COLUMN_INDEX_INITIAL_VAL; - char tableName[TSDB_METER_ID_LEN + 1] = {0}; + char tableName[TSDB_TABLE_ID_LEN + 1] = {0}; for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) { SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfoFromQueryInfo(pQueryInfo, i); @@ -3365,7 +3365,7 @@ static int32_t setTableCondForMetricQuery(SQueryInfo* pQueryInfo, const char* ac SStringBuilder sb1 = {0}; taosStringBuilderAppendStringLen(&sb1, QUERY_COND_REL_PREFIX_IN, QUERY_COND_REL_PREFIX_IN_LEN); - char db[TSDB_METER_ID_LEN] = {0}; + char db[TSDB_TABLE_ID_LEN] = {0}; // remove the duplicated input table names int32_t num = 0; @@ -3389,7 +3389,7 @@ static int32_t setTableCondForMetricQuery(SQueryInfo* pQueryInfo, const char* ac taosStringBuilderAppendStringLen(&sb1, TBNAME_LIST_SEP, 1); } - char idBuf[TSDB_METER_ID_LEN + 1] = {0}; + char idBuf[TSDB_TABLE_ID_LEN + 1] = {0}; int32_t xlen = strlen(segments[i]); SSQLToken t = {.z = segments[i], .n = xlen, .type = TK_STRING}; @@ -5300,7 +5300,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) { } // get meter meta from mnode - strncpy(pCreateTable->usingInfo.tagdata.name, pStableMeterMetaInfo->name, TSDB_METER_ID_LEN); + strncpy(pCreateTable->usingInfo.tagdata.name, pStableMeterMetaInfo->name, TSDB_TABLE_ID_LEN); tVariantList* pList = pInfo->pCreateTableInfo->usingInfo.pTagVals; int32_t code = tscGetMeterMeta(pSql, pStableMeterMetaInfo); diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c index 32236cd63b81fe3fc6d92556f201fbb3edaeb9de..971031d503140bf1f2f10be34cebdc1c960ad8e0 100644 --- a/src/client/src/tscServer.c +++ b/src/client/src/tscServer.c @@ -2685,7 +2685,7 @@ int tscBuildMultiMeterMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) { // fill head info SMgmtHead *pMgmt = (SMgmtHead *)(pCmd->payload + tsRpcHeadSize); - memset(pMgmt->db, 0, TSDB_METER_ID_LEN); // server don't need the db + memset(pMgmt->db, 0, TSDB_TABLE_ID_LEN); // server don't need the db SMultiMeterInfoMsg *pInfoMsg = (SMultiMeterInfoMsg *)(pCmd->payload + tsRpcHeadSize + sizeof(SMgmtHead)); pInfoMsg->numOfMeters = htonl((int32_t)pCmd->count); @@ -2709,7 +2709,7 @@ int tscBuildMultiMeterMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) { static int32_t tscEstimateMetricMetaMsgSize(SSqlCmd *pCmd) { const int32_t defaultSize = - minMsgSize() + sizeof(SMetricMetaMsg) + sizeof(SMgmtHead) + sizeof(int16_t) * TSDB_MAX_TAGS; + minMsgSize() + sizeof(SSuperTableMetaMsg) + sizeof(SMgmtHead) + sizeof(int16_t) * TSDB_MAX_TAGS; SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0); int32_t n = 0; @@ -2722,7 +2722,7 @@ static int32_t tscEstimateMetricMetaMsgSize(SSqlCmd *pCmd) { tagLen += strlen(pQueryInfo->tagCond.tbnameCond.cond) * TSDB_NCHAR_SIZE; } - int32_t joinCondLen = (TSDB_METER_ID_LEN + sizeof(int16_t)) * 2; + int32_t joinCondLen = (TSDB_TABLE_ID_LEN + sizeof(int16_t)) * 2; int32_t elemSize = sizeof(SMetricMetaElemMsg) * pQueryInfo->numOfTables; int32_t len = tagLen + joinCondLen + elemSize + defaultSize; @@ -2731,7 +2731,7 @@ static int32_t tscEstimateMetricMetaMsgSize(SSqlCmd *pCmd) { } int tscBuildMetricMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) { - SMetricMetaMsg *pMetaMsg; + SSuperTableMetaMsg *pMetaMsg; char * pMsg, *pStart; int msgLen = 0; int tableIndex = 0; @@ -2757,25 +2757,25 @@ int tscBuildMetricMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) { pMsg += sizeof(SMgmtHead); - pMetaMsg = (SMetricMetaMsg *)pMsg; + pMetaMsg = (SSuperTableMetaMsg *)pMsg; pMetaMsg->numOfMeters = htonl(pQueryInfo->numOfTables); - pMsg += sizeof(SMetricMetaMsg); + pMsg += sizeof(SSuperTableMetaMsg); int32_t offset = pMsg - (char *)pMetaMsg; pMetaMsg->join = htonl(offset); // todo refactor - pMetaMsg->joinCondLen = htonl((TSDB_METER_ID_LEN + sizeof(int16_t)) * 2); + pMetaMsg->joinCondLen = htonl((TSDB_TABLE_ID_LEN + sizeof(int16_t)) * 2); - memcpy(pMsg, pTagCond->joinInfo.left.meterId, TSDB_METER_ID_LEN); - pMsg += TSDB_METER_ID_LEN; + memcpy(pMsg, pTagCond->joinInfo.left.meterId, TSDB_TABLE_ID_LEN); + pMsg += TSDB_TABLE_ID_LEN; *(int16_t *)pMsg = pTagCond->joinInfo.left.tagCol; pMsg += sizeof(int16_t); - memcpy(pMsg, pTagCond->joinInfo.right.meterId, TSDB_METER_ID_LEN); - pMsg += TSDB_METER_ID_LEN; + memcpy(pMsg, pTagCond->joinInfo.right.meterId, TSDB_TABLE_ID_LEN); + pMsg += TSDB_TABLE_ID_LEN; *(int16_t *)pMsg = pTagCond->joinInfo.right.tagCol; pMsg += sizeof(int16_t); @@ -2991,7 +2991,7 @@ int tscProcessMeterMetaRsp(SSqlObj *pSql) { int32_t tagLen = 0; SSchema *pTagsSchema = tsGetTagSchema(pMeta); - if (pMeta->meterType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE) { + if (pMeta->tableType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE) { for (int32_t i = 0; i < pMeta->numOfTags; ++i) { tagLen += pTagsSchema[i].bytes; } @@ -3106,7 +3106,7 @@ int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) { int32_t tagLen = 0; SSchema *pTagsSchema = tsGetTagSchema(pMeta); - if (pMeta->meterType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE) { + if (pMeta->tableType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE) { for (int32_t j = 0; j < pMeta->numOfTags; ++j) { tagLen += pTagsSchema[j].bytes; } @@ -3304,7 +3304,7 @@ int tscProcessShowRsp(SSqlObj *pSql) { } int tscProcessConnectRsp(SSqlObj *pSql) { - char temp[TSDB_METER_ID_LEN * 2]; + char temp[TSDB_TABLE_ID_LEN * 2]; SConnectRsp *pConnect; STscObj *pObj = pSql->pTscObj; diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c index 6a03278a077bab0aa078685acd8a0ecd3402acce..2c0d0f898a39b0cab5d62bd00a51d0c0461ecd4b 100644 --- a/src/client/src/tscSql.c +++ b/src/client/src/tscSql.c @@ -1047,7 +1047,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t } char *nextStr; - char tblName[TSDB_METER_ID_LEN]; + char tblName[TSDB_TABLE_ID_LEN]; int payloadLen = 0; char *pMsg = pCmd->payload; while (1) { diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c index e9395d7dde46e478ae5058e6842579eb33079b57..cea80360e0b1c82ca6efcf4b04a4075427dd4d61 100644 --- a/src/client/src/tscUtil.c +++ b/src/client/src/tscUtil.c @@ -657,7 +657,7 @@ int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOff dataBuf->size = startOffset; dataBuf->tsSource = -1; - strncpy(dataBuf->meterId, name, TSDB_METER_ID_LEN); + strncpy(dataBuf->meterId, name, TSDB_TABLE_ID_LEN); /* * The metermeta may be released since the metermeta cache are completed clean by other thread @@ -1810,7 +1810,7 @@ SMeterMetaInfo* tscAddMeterMetaInfo(SQueryInfo* pQueryInfo, const char* name, SM assert(pMeterMetaInfo != NULL); if (name != NULL) { - assert(strlen(name) <= TSDB_METER_ID_LEN); + assert(strlen(name) <= TSDB_TABLE_ID_LEN); strcpy(pMeterMetaInfo->name, name); } diff --git a/src/dnode/src/dnodeMgmt.c b/src/dnode/src/dnodeMgmt.c index 482e6ae477fea672719092c3a831026bb1c76e07..90cbf5e983ef82a0606e85ec28a2638abd57e4bf 100644 --- a/src/dnode/src/dnodeMgmt.c +++ b/src/dnode/src/dnodeMgmt.c @@ -312,7 +312,7 @@ int vnodeProcessCreateMeterMsg(char *pMsg, int msgLen) { pObj->vnode = pCreate->vnode; pObj->sid = pCreate->sid; pObj->uid = pCreate->uid; - memcpy(pObj->meterId, pCreate->meterId, TSDB_METER_ID_LEN); + memcpy(pObj->meterId, pCreate->meterId, TSDB_TABLE_ID_LEN); pObj->numOfColumns = pCreate->numOfColumns; pObj->timeStamp = pCreate->timeStamp; pObj->sversion = htonl(pCreate->sversion); @@ -377,7 +377,7 @@ int vnodeProcessRemoveMeterRequest(char *pMsg, int msgLen, SMgmtObj *pMgmtObj) { pObj = vnodeList[pRemove->vnode].meterList[pRemove->sid]; if (pObj == NULL) goto _remove_over; - if (memcmp(pObj->meterId, pRemove->meterId, TSDB_METER_ID_LEN) != 0) { + if (memcmp(pObj->meterId, pRemove->meterId, TSDB_TABLE_ID_LEN) != 0) { dWarn("vid:%d sid:%d id:%s, remove ID:%s, meter ID not matched", pObj->vnode, pObj->sid, pObj->meterId, pRemove->meterId); goto _remove_over; diff --git a/src/inc/mnode.h b/src/inc/mnode.h index 998567a4ed0a46aec2ef60a686794b8d5d043849..7933f0461a60208d2ce829bf8a3f51b15d76f441 100644 --- a/src/inc/mnode.h +++ b/src/inc/mnode.h @@ -95,7 +95,7 @@ typedef struct { } SMeterGid; typedef struct _tab_obj { - char meterId[TSDB_METER_ID_LEN + 1]; + char meterId[TSDB_TABLE_ID_LEN + 1]; uint64_t uid; SMeterGid gid; @@ -106,7 +106,7 @@ typedef struct _tab_obj { int32_t numOfColumns; int32_t schemaSize; short nextColId; - char meterType : 4; + char tableType : 4; char status : 3; char isDirty : 1; // if the table change tag column 1 value char reserved[15]; @@ -116,7 +116,7 @@ typedef struct _tab_obj { tSkipList * pSkipList; struct _tab_obj *pHead; // for metric, a link list for all meters created // according to this metric - char *pTagData; // TSDB_METER_ID_LEN(metric_name)+ + char *pTagData; // TSDB_TABLE_ID_LEN(metric_name)+ // tags_value1/tags_value2/tags_value3 struct _tab_obj *prev, *next; char * pSql; // pointer to SQL, for SC, null-terminated string @@ -262,8 +262,8 @@ extern SDnodeObj dnodeObj; // dnodeInt API int mgmtInitDnodeInt(); void mgmtCleanUpDnodeInt(); -int mgmtSendCreateMsgToVgroup(STabObj *pMeter, SVgObj *pVgroup); -int mgmtSendRemoveMeterMsgToDnode(STabObj *pMeter, SVgObj *pVgroup); +int mgmtSendCreateMsgToVgroup(STabObj *pTable, SVgObj *pVgroup); +int mgmtSendRemoveMeterMsgToDnode(STabObj *pTable, SVgObj *pVgroup); int mgmtSendVPeersMsg(SVgObj *pVgroup); int mgmtSendFreeVnodeMsg(SVgObj *pVgroup); int mgmtSendOneFreeVnodeMsg(SVnodeGid *pVnodeGid); @@ -284,8 +284,8 @@ int mgmtRetrieveUsers(SShowObj *pShow, char *data, int rows, SConnObj *pConn); void mgmtCleanUpUsers(); // metric API -int mgmtAddMeterIntoMetric(STabObj *pMetric, STabObj *pMeter); -int mgmtRemoveMeterFromMetric(STabObj *pMetric, STabObj *pMeter); +int mgmtAddMeterIntoMetric(STabObj *pMetric, STabObj *pTable); +int mgmtRemoveMeterFromMetric(STabObj *pMetric, STabObj *pTable); int mgmtGetMetricMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn); int mgmtRetrieveMetrics(SShowObj *pShow, char *data, int rows, SConnObj *pConn); @@ -326,14 +326,14 @@ void mgmtCleanUpVgroups(); int mgmtInitMeters(); STabObj *mgmtGetTable(char *meterId); STabObj *mgmtGetTableInfo(char *src, char *tags[]); -int mgmtRetrieveMetricMeta(SConnObj *pConn, char **pStart, SMetricMetaMsg *pInfo); +int mgmtRetrieveMetricMeta(SConnObj *pConn, char **pStart, SSuperTableMetaMsg *pInfo); int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate); int mgmtDropMeter(SDbObj *pDb, char *meterId, int ignore); int mgmtAlterMeter(SDbObj *pDb, SAlterTableMsg *pAlter); int mgmtGetTableMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn); int mgmtRetrieveMeters(SShowObj *pShow, char *data, int rows, SConnObj *pConn); void mgmtCleanUpMeters(); -SSchema *mgmtGetTableSchema(STabObj *pMeter); // get schema for a meter +SSchema *mgmtGetTableSchema(STabObj *pTable); // get schema for a meter // dnode API diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h index 8a8d672da29be9b179b0faace2e86fd9b4bb47d7..af60cc893a233779e14a1eef947199200da3833e 100644 --- a/src/inc/taosmsg.h +++ b/src/inc/taosmsg.h @@ -301,7 +301,7 @@ typedef struct { uint64_t uid; char spi; char encrypt; - char meterId[TSDB_METER_ID_LEN]; + char meterId[TSDB_TABLE_ID_LEN]; char secret[TSDB_KEY_LEN]; char cipheringKey[TSDB_KEY_LEN]; uint64_t timeStamp; @@ -314,7 +314,7 @@ typedef struct { } SCreateMsg; typedef struct { - char db[TSDB_METER_ID_LEN]; + char db[TSDB_TABLE_ID_LEN]; uint8_t ignoreNotExists; } SDropDbMsg, SUseDbMsg; @@ -327,7 +327,7 @@ typedef struct { } SShowTableMsg; typedef struct { - char meterId[TSDB_METER_ID_LEN]; + char meterId[TSDB_TABLE_ID_LEN]; char igExists; short numOfTags; @@ -341,12 +341,12 @@ typedef struct { } SCreateTableMsg; typedef struct { - char meterId[TSDB_METER_ID_LEN]; + char meterId[TSDB_TABLE_ID_LEN]; char igNotExists; } SDropTableMsg; typedef struct { - char meterId[TSDB_METER_ID_LEN]; + char meterId[TSDB_TABLE_ID_LEN]; short type; /* operation type */ char tagVal[TSDB_MAX_BYTES_PER_ROW]; short numOfCols; /* number of schema */ @@ -355,7 +355,7 @@ typedef struct { typedef struct { char clientVersion[TSDB_VERSION_LEN]; - char db[TSDB_METER_ID_LEN]; + char db[TSDB_TABLE_ID_LEN]; } SConnectMsg; typedef struct { @@ -386,7 +386,7 @@ typedef struct { } SCreateUserMsg, SAlterUserMsg; typedef struct { - char db[TSDB_METER_ID_LEN]; + char db[TSDB_TABLE_ID_LEN]; } SMgmtHead; typedef struct { @@ -400,7 +400,7 @@ typedef struct { short vnode; int32_t sid; uint64_t uid; - char meterId[TSDB_METER_ID_LEN]; + char meterId[TSDB_TABLE_ID_LEN]; } SRemoveMeterMsg; typedef struct { @@ -604,7 +604,7 @@ typedef struct { * the message is too large, so it may will overwrite the cfg information in meterobj.v* * recover to origin codes */ - //char db[TSDB_METER_ID_LEN+2]; // 8bytes align + //char db[TSDB_TABLE_ID_LEN+2]; // 8bytes align char db[TSDB_DB_NAME_LEN]; uint32_t vgId; int32_t maxSessions; @@ -695,7 +695,7 @@ typedef struct { } SVPeersMsg; typedef struct { - char meterId[TSDB_METER_ID_LEN]; + char meterId[TSDB_TABLE_ID_LEN]; short createFlag; char tags[]; } SMeterInfoMsg; @@ -708,7 +708,7 @@ typedef struct { typedef struct { int16_t elemLen; - char meterId[TSDB_METER_ID_LEN]; + char meterId[TSDB_TABLE_ID_LEN]; int16_t orderIndex; int16_t orderType; // used in group by xx order by xxx @@ -732,7 +732,7 @@ typedef struct { int32_t join; int32_t joinCondLen; // for join condition int32_t metaElem[TSDB_MAX_JOIN_TABLE_NUM]; -} SMetricMetaMsg; +} SSuperTableMetaMsg; typedef struct { SVPeerDesc vpeerDesc[TSDB_VNODES_SUPPORT]; @@ -751,7 +751,7 @@ typedef struct { typedef struct SMeterMeta { uint8_t numOfTags : 6; uint8_t precision : 2; - uint8_t meterType : 4; + uint8_t tableType : 4; uint8_t index : 4; // used locally int16_t numOfColumns; @@ -767,12 +767,12 @@ typedef struct SMeterMeta { } SMeterMeta; typedef struct SMultiMeterMeta { - char meterId[TSDB_METER_ID_LEN]; // note: This field must be at the front + char meterId[TSDB_TABLE_ID_LEN]; // note: This field must be at the front SMeterMeta meta; } SMultiMeterMeta; typedef struct { - char name[TSDB_METER_ID_LEN]; + char name[TSDB_TABLE_ID_LEN]; char data[TSDB_MAX_TAGS_LEN]; } STagData; diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h index aa712ab62296c806b530cea14bacba525530d93d..becc630068c09dc1697f63fa3d010fe4f9bdcac5 100644 --- a/src/inc/tsdb.h +++ b/src/inc/tsdb.h @@ -86,7 +86,7 @@ extern "C" { #define TS_PATH_DELIMITER_LEN 1 #define TSDB_METER_ID_LEN_MARGIN 10 -#define TSDB_METER_ID_LEN (TSDB_DB_NAME_LEN+TSDB_METER_NAME_LEN+2*TS_PATH_DELIMITER_LEN+TSDB_USERID_LEN+TSDB_METER_ID_LEN_MARGIN) //TSDB_DB_NAME_LEN+TSDB_METER_NAME_LEN+2*strlen(TS_PATH_DELIMITER)+strlen(USERID) +#define TSDB_TABLE_ID_LEN (TSDB_DB_NAME_LEN+TSDB_METER_NAME_LEN+2*TS_PATH_DELIMITER_LEN+TSDB_USERID_LEN+TSDB_METER_ID_LEN_MARGIN) //TSDB_DB_NAME_LEN+TSDB_METER_NAME_LEN+2*strlen(TS_PATH_DELIMITER)+strlen(USERID) #define TSDB_UNI_LEN 24 #define TSDB_USER_LEN TSDB_UNI_LEN #define TSDB_ACCT_LEN TSDB_UNI_LEN diff --git a/src/mnode/inc/mgmtSupertableQuery.h b/src/mnode/inc/mgmtSupertableQuery.h new file mode 100644 index 0000000000000000000000000000000000000000..86d880db446a7afc7d109213a16f9acf2b757a75 --- /dev/null +++ b/src/mnode/inc/mgmtSupertableQuery.h @@ -0,0 +1,29 @@ +/* + * 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 . + */ + +#ifndef TBASE_MNODE_SUPER_TABLE_QUERY_H +#define TBASE_MNODE_SUPER_TABLE_QUERY_H + +#include +#include +#include +#include "mnode.h" + +int32_t mgmtRetrieveMetersFromSuperTable(SSuperTableMetaMsg* pInfo, int32_t tableIndex, tQueryResultset* pRes); +int32_t mgmtDoJoin(SSuperTableMetaMsg* pSuperTableMetaMsg, tQueryResultset* pRes); +void mgmtReorganizeMetersInMetricMeta(SSuperTableMetaMsg* pInfo, int32_t index, tQueryResultset* pRes); + + +#endif diff --git a/src/mnode/inc/mgmtTable.h b/src/mnode/inc/mgmtTable.h index 70f7bba7290db3229bcb831a134adce1fb2dccf9..cf4186146d3be2413e014ef4dbe4b95ab62e55f2 100644 --- a/src/mnode/inc/mgmtTable.h +++ b/src/mnode/inc/mgmtTable.h @@ -11,28 +11,16 @@ * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . - */#include -#include -#include - -#include "tast.h" + */ -#ifndef TBASE_MNODE_UTIL_H -#define TBASE_MNODE_UTIL_H +#ifndef TBASE_MNODE_TABLE_H +#define TBASE_MNODE_TABLE_H -bool mgmtTableCreateFromSuperTable(STabObj *pTableObj); -bool mgmtIsSuperTable(STabObj *pTableObj); -bool mgmtIsNormalTable(STabObj *pTableObj); - -typedef struct SSyntaxTreeFilterSupporter { - SSchema* pTagSchema; - int32_t numOfTags; - int32_t optr; -} SSyntaxTreeFilterSupporter; +#include +#include +#include +#include "mnode.h" -char* mgmtTableGetTag(STabObj* pMeter, int32_t col, SSchema* pTagColSchema); -int32_t mgmtGetTagsLength(STabObj* pMetric, int32_t col); -bool mgmtCheckIsMonitorDB(char *db, char *monitordb); -int32_t mgmtCheckDBParams(SCreateDbMsg *pCreate); +int32_t mgmtFindTagCol(STabObj * pTable, const char * tagName); #endif diff --git a/src/mnode/inc/mgmtUtil.h b/src/mnode/inc/mgmtUtil.h index d727df561e786813fc34fe074369a89d160326e8..f6fc4d0b6d6eb4ef268f3a76f18acdf49611d9d6 100644 --- a/src/mnode/inc/mgmtUtil.h +++ b/src/mnode/inc/mgmtUtil.h @@ -11,37 +11,22 @@ * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . - */#include -#include -#include - -#include "tast.h" + */ #ifndef TBASE_MNODE_UTIL_H #define TBASE_MNODE_UTIL_H -bool mgmtTableCreateFromSuperTable(STabObj *pTableObj); -bool mgmtIsSuperTable(STabObj *pTableObj); -bool mgmtIsNormalTable(STabObj *pTableObj); - -typedef struct SSyntaxTreeFilterSupporter { - SSchema* pTagSchema; - int32_t numOfTags; - int32_t optr; -} SSyntaxTreeFilterSupporter; +#include +#include +#include +#include "mnode.h" -char* mgmtTableGetTag(STabObj* pMeter, int32_t col, SSchema* pTagColSchema); -int32_t mgmtGetTagsLength(STabObj* pMetric, int32_t col); +bool mgmtTableCreateFromSuperTable(STabObj *pTableObj); +bool mgmtIsSuperTable(STabObj *pTableObj); +bool mgmtIsNormalTable(STabObj *pTableObj); +char* mgmtTableGetTag(STabObj* pTable, int32_t col, SSchema* pTagColSchema); +int32_t mgmtGetTagsLength(STabObj* pSuperTable, int32_t col); bool mgmtCheckIsMonitorDB(char *db, char *monitordb); int32_t mgmtCheckDBParams(SCreateDbMsg *pCreate); -int32_t mgmtFindTagCol(STabObj * pMetric, const char * tagName); - -int32_t mgmtRetrieveMetersFromMetric(SMetricMetaMsg* pInfo, int32_t tableIndex, tQueryResultset* pRes); -int32_t mgmtDoJoin(SMetricMetaMsg* pMetricMetaMsg, tQueryResultset* pRes); -void mgmtReorganizeMetersInMetricMeta(SMetricMetaMsg* pInfo, int32_t index, tQueryResultset* pRes); - -bool tSkipListNodeFilterCallback(const void *pNode, void *param); - - #endif diff --git a/src/mnode/src/mgmtConn.c b/src/mnode/src/mgmtConn.c index 15cf297ae28835e92c151339b67b54ee58c6abd3..0b09b76871714f5b9404387bc27ecd3b62fb650c 100644 --- a/src/mnode/src/mgmtConn.c +++ b/src/mnode/src/mgmtConn.c @@ -20,7 +20,7 @@ #include "tschemautil.h" typedef struct { - char user[TSDB_METER_ID_LEN]; + char user[TSDB_TABLE_ID_LEN]; uint64_t stime; uint32_t ip; uint16_t port; diff --git a/src/mnode/src/mgmtDb.c b/src/mnode/src/mgmtDb.c index 850ab1680dd3d4a1514fe77377be0a737f4c370e..4470f58b2d9a011c1d045c9f4c66d35b3d858bb4 100644 --- a/src/mnode/src/mgmtDb.c +++ b/src/mnode/src/mgmtDb.c @@ -116,7 +116,7 @@ int mgmtInitDbs() { SDbObj *mgmtGetDb(char *db) { return (SDbObj *)sdbGetRow(dbSdb, db); } SDbObj *mgmtGetDbByMeterId(char *meterId) { - char db[TSDB_METER_ID_LEN], *pos; + char db[TSDB_TABLE_ID_LEN], *pos; pos = strstr(meterId, TS_PATH_DELIMITER); pos = strstr(pos + 1, TS_PATH_DELIMITER); diff --git a/src/mnode/src/mgmtDnodeInt.c b/src/mnode/src/mgmtDnodeInt.c index 9c1617fa916b693b067107a3c95379703e88612d..e2e9749f4b7e2671cb960eb5c5c1e66f052c37cd 100644 --- a/src/mnode/src/mgmtDnodeInt.c +++ b/src/mnode/src/mgmtDnodeInt.c @@ -24,7 +24,7 @@ void mgmtProcessMsgFromDnode(char *content, int msgLen, int msgType, SDnodeObj *pObj); int mgmtSendVPeersMsg(SVgObj *pVgroup); char *mgmtBuildVpeersIe(char *pMsg, SVgObj *pVgroup, int vnode); -char *mgmtBuildCreateMeterIe(STabObj *pMeter, char *pMsg, int vnode); +char *mgmtBuildCreateMeterIe(STabObj *pTable, char *pMsg, int vnode); /* * functions for communicate between dnode and mnode @@ -39,7 +39,7 @@ int taosSendMsgToDnode(SDnodeObj *pObj, char *msg, int msgLen); int mgmtProcessMeterCfgMsg(char *cont, int contLen, SDnodeObj *pObj) { char * pMsg, *pStart; int msgLen = 0; - STabObj * pMeter = NULL; + STabObj * pTable = NULL; SMeterCfgMsg *pCfg = (SMeterCfgMsg *)cont; SVgObj * pVgroup; @@ -63,13 +63,13 @@ int mgmtProcessMeterCfgMsg(char *cont, int contLen, SDnodeObj *pObj) { int vgId = pObj->vload[vnode].vgId; pVgroup = mgmtGetVgroup(vgId); - if (pVgroup) pMeter = pVgroup->meterList[sid]; + if (pVgroup) pTable = pVgroup->meterList[sid]; } - if (pMeter) { + if (pTable) { *pMsg = 0; // code pMsg++; - pMsg = mgmtBuildCreateMeterIe(pMeter, pMsg, vnode); + pMsg = mgmtBuildCreateMeterIe(pTable, pMsg, vnode); } else { mTrace("dnode:%s, vnode:%d sid:%d, meter not there", taosIpStr(pObj->privateIp), vnode, sid); *pMsg = TSDB_CODE_INVALID_METER_ID; @@ -187,48 +187,48 @@ void mgmtProcessMsgFromDnode(char *content, int msgLen, int msgType, SDnodeObj * } } -char *mgmtBuildCreateMeterIe(STabObj *pMeter, char *pMsg, int vnode) { +char *mgmtBuildCreateMeterIe(STabObj *pTable, char *pMsg, int vnode) { SCreateMsg *pCreateMeter; pCreateMeter = (SCreateMsg *)pMsg; pCreateMeter->vnode = htons(vnode); - pCreateMeter->sid = htonl(pMeter->gid.sid); - pCreateMeter->uid = pMeter->uid; - memcpy(pCreateMeter->meterId, pMeter->meterId, TSDB_METER_ID_LEN); + pCreateMeter->sid = htonl(pTable->gid.sid); + pCreateMeter->uid = pTable->uid; + memcpy(pCreateMeter->meterId, pTable->meterId, TSDB_TABLE_ID_LEN); // pCreateMeter->lastCreate = htobe64(pVgroup->lastCreate); - pCreateMeter->timeStamp = htobe64(pMeter->createdTime); + pCreateMeter->timeStamp = htobe64(pTable->createdTime); /* pCreateMeter->spi = pSec->spi; pCreateMeter->encrypt = pSec->encrypt; memcpy(pCreateMeter->cipheringKey, pSec->cipheringKey, TSDB_KEY_LEN); memcpy(pCreateMeter->secret, pSec->secret, TSDB_KEY_LEN); */ - pCreateMeter->sversion = htonl(pMeter->sversion); - pCreateMeter->numOfColumns = htons(pMeter->numOfColumns); - SSchema *pSchema = mgmtGetTableSchema(pMeter); + pCreateMeter->sversion = htonl(pTable->sversion); + pCreateMeter->numOfColumns = htons(pTable->numOfColumns); + SSchema *pSchema = mgmtGetTableSchema(pTable); - for (int i = 0; i < pMeter->numOfColumns; ++i) { + for (int i = 0; i < pTable->numOfColumns; ++i) { pCreateMeter->schema[i].type = pSchema[i].type; /* strcpy(pCreateMeter->schema[i].name, pSchema[i].name); */ pCreateMeter->schema[i].bytes = htons(pSchema[i].bytes); pCreateMeter->schema[i].colId = htons(pSchema[i].colId); } - pMsg = ((char *)(pCreateMeter->schema)) + pMeter->numOfColumns * sizeof(SMColumn); + pMsg = ((char *)(pCreateMeter->schema)) + pTable->numOfColumns * sizeof(SMColumn); pCreateMeter->sqlLen = 0; - if (pMeter->pSql) { - int len = strlen(pMeter->pSql) + 1; + if (pTable->pSql) { + int len = strlen(pTable->pSql) + 1; pCreateMeter->sqlLen = htons(len); - strcpy(pMsg, pMeter->pSql); + strcpy(pMsg, pTable->pSql); pMsg += len; } return pMsg; } -int mgmtSendCreateMsgToVgroup(STabObj *pMeter, SVgObj *pVgroup) { +int mgmtSendCreateMsgToVgroup(STabObj *pTable, SVgObj *pVgroup) { char * pMsg, *pStart; int i, msgLen = 0; SDnodeObj *pObj; @@ -244,7 +244,7 @@ int mgmtSendCreateMsgToVgroup(STabObj *pMeter, SVgObj *pVgroup) { pStart = taosBuildReqMsgToDnodeWithSize(pObj, TSDB_MSG_TYPE_CREATE, 64000); if (pStart == NULL) continue; - pMsg = mgmtBuildCreateMeterIe(pMeter, pStart, pVgroup->vnodeGid[i].vnode); + pMsg = mgmtBuildCreateMeterIe(pTable, pStart, pVgroup->vnodeGid[i].vnode); msgLen = pMsg - pStart; taosSendMsgToDnode(pObj, pStart, msgLen); @@ -255,7 +255,7 @@ int mgmtSendCreateMsgToVgroup(STabObj *pMeter, SVgObj *pVgroup) { return 0; } -int mgmtSendRemoveMeterMsgToDnode(STabObj *pMeter, SVgObj *pVgroup) { +int mgmtSendRemoveMeterMsgToDnode(STabObj *pTable, SVgObj *pVgroup) { SRemoveMeterMsg *pRemove; char * pMsg, *pStart; int i, msgLen = 0; @@ -277,8 +277,8 @@ int mgmtSendRemoveMeterMsgToDnode(STabObj *pMeter, SVgObj *pVgroup) { pRemove = (SRemoveMeterMsg *)pMsg; pRemove->vnode = htons(pVgroup->vnodeGid[i].vnode); - pRemove->sid = htonl(pMeter->gid.sid); - memcpy(pRemove->meterId, pMeter->meterId, TSDB_METER_ID_LEN); + pRemove->sid = htonl(pTable->gid.sid); + memcpy(pRemove->meterId, pTable->meterId, TSDB_TABLE_ID_LEN); pMsg += sizeof(SRemoveMeterMsg); msgLen = pMsg - pStart; @@ -287,7 +287,7 @@ int mgmtSendRemoveMeterMsgToDnode(STabObj *pMeter, SVgObj *pVgroup) { tinet_ntoa(ipstr, pVgroup->vnodeGid[i].ip); mTrace("dnode:%s vid:%d, send remove meter msg, sid:%d status:%d", ipstr, pVgroup->vnodeGid[i].vnode, - pMeter->gid.sid, pObj->status); + pTable->gid.sid, pObj->status); } pVgroup->lastRemove = timeStamp; @@ -295,7 +295,7 @@ int mgmtSendRemoveMeterMsgToDnode(STabObj *pMeter, SVgObj *pVgroup) { return 0; } -int mgmtSendAlterStreamMsgToDnode(STabObj *pMeter, SVgObj *pVgroup) { +int mgmtSendAlterStreamMsgToDnode(STabObj *pTable, SVgObj *pVgroup) { SAlterStreamMsg *pAlter; char * pMsg, *pStart; int i, msgLen = 0; @@ -313,9 +313,9 @@ int mgmtSendAlterStreamMsgToDnode(STabObj *pMeter, SVgObj *pVgroup) { pAlter = (SAlterStreamMsg *)pMsg; pAlter->vnode = htons(pVgroup->vnodeGid[i].vnode); - pAlter->sid = htonl(pMeter->gid.sid); - pAlter->uid = pMeter->uid; - pAlter->status = pMeter->status; + pAlter->sid = htonl(pTable->gid.sid); + pAlter->uid = pTable->uid; + pAlter->status = pTable->status; pMsg += sizeof(SAlterStreamMsg); msgLen = pMsg - pStart; diff --git a/src/mnode/src/mgmtMeter.c b/src/mnode/src/mgmtMeter.c index bc62270414eb746e93a4f79a99aa28f0ba9cb6b1..325d880d332493c9541b87fb257a5c7e48012ecc 100644 --- a/src/mnode/src/mgmtMeter.c +++ b/src/mnode/src/mgmtMeter.c @@ -33,11 +33,11 @@ extern int64_t sdbVersion; -#define mgmtDestroyMeter(pMeter) \ +#define mgmtDestroyMeter(pTable) \ do { \ - tfree(pMeter->schema); \ - pMeter->pSkipList = tSkipListDestroy((pMeter)->pSkipList); \ - tfree(pMeter); \ + tfree(pTable->schema); \ + pTable->pSkipList = tSkipListDestroy((pTable)->pSkipList); \ + tfree(pTable); \ } while (0) enum _Meter_Update_Action { @@ -55,14 +55,14 @@ typedef struct { } SchemaUnit; typedef struct { - char meterId[TSDB_METER_ID_LEN + 1]; + char meterId[TSDB_TABLE_ID_LEN + 1]; char type; uint32_t cols; char data[]; } SMeterBatchUpdateMsg; typedef struct { - char meterId[TSDB_METER_ID_LEN + 1]; + char meterId[TSDB_TABLE_ID_LEN + 1]; char action; int32_t dataSize; char data[]; @@ -83,14 +83,14 @@ void *mgmtMeterActionAfterBatchUpdate(void *row, char *str, int size, int *ssize void *mgmtMeterActionReset(void *row, char *str, int size, int *ssize); void *mgmtMeterActionDestroy(void *row, char *str, int size, int *ssize); int32_t mgmtMeterAddTags(STabObj *pMetric, SSchema schema[], int ntags); -static void removeMeterFromMetricIndex(STabObj *pMetric, STabObj *pMeter); -static void addMeterIntoMetricIndex(STabObj *pMetric, STabObj *pMeter); +static void removeMeterFromMetricIndex(STabObj *pMetric, STabObj *pTable); +static void addMeterIntoMetricIndex(STabObj *pMetric, STabObj *pTable); int32_t mgmtMeterDropTagByName(STabObj *pMetric, char *name); int32_t mgmtMeterModifyTagNameByName(STabObj *pMetric, const char *oname, const char *nname); -int32_t mgmtMeterModifyTagValueByName(STabObj *pMeter, char *tagName, char *nContent); -int32_t mgmtMeterAddColumn(STabObj *pMeter, SSchema schema[], int ncols); -int32_t mgmtMeterDropColumnByName(STabObj *pMeter, const char *name); -static int dropMeterImp(SDbObj *pDb, STabObj * pMeter, SAcctObj *pAcct); +int32_t mgmtMeterModifyTagValueByName(STabObj *pTable, char *tagName, char *nContent); +int32_t mgmtMeterAddColumn(STabObj *pTable, SSchema schema[], int ncols); +int32_t mgmtMeterDropColumnByName(STabObj *pTable, const char *name); +static int dropMeterImp(SDbObj *pDb, STabObj * pTable, SAcctObj *pAcct); static void dropAllMetersOfMetric(SDbObj *pDb, STabObj * pMetric, SAcctObj *pAcct); int mgmtCheckTableLimit(SAcctObj *pAcct, SCreateTableMsg *pCreate); @@ -136,38 +136,38 @@ static void mgmtVacuumResult(char *data, int32_t numOfCols, int32_t rows, int32_ } void *mgmtMeterActionReset(void *row, char *str, int size, int *ssize) { - STabObj *pMeter = (STabObj *)row; - int tsize = pMeter->updateEnd - (char *)pMeter; - memcpy(pMeter, str, tsize); - pMeter->schema = (char *)realloc(pMeter->schema, pMeter->schemaSize); - memcpy(pMeter->schema, str + tsize, pMeter->schemaSize); + STabObj *pTable = (STabObj *)row; + int tsize = pTable->updateEnd - (char *)pTable; + memcpy(pTable, str, tsize); + pTable->schema = (char *)realloc(pTable->schema, pTable->schemaSize); + memcpy(pTable->schema, str + tsize, pTable->schemaSize); - if (mgmtTableCreateFromSuperTable(pMeter)) { - pMeter->pTagData = pMeter->schema; + if (mgmtTableCreateFromSuperTable(pTable)) { + pTable->pTagData = pTable->schema; } return NULL; } void *mgmtMeterActionDestroy(void *row, char *str, int size, int *ssize) { - STabObj *pMeter = (STabObj *)row; - mgmtDestroyMeter(pMeter); + STabObj *pTable = (STabObj *)row; + mgmtDestroyMeter(pTable); return NULL; } void *mgmtMeterActionInsert(void *row, char *str, int size, int *ssize) { - STabObj * pMeter = NULL; + STabObj * pTable = NULL; SVgObj * pVgroup = NULL; SDbObj * pDb = NULL; STabObj * pMetric = NULL; SAcctObj *pAcct = NULL; - pMeter = (STabObj *)row; + pTable = (STabObj *)row; - if (mgmtIsNormalTable(pMeter)) { - pVgroup = mgmtGetVgroup(pMeter->gid.vgId); + if (mgmtIsNormalTable(pTable)) { + pVgroup = mgmtGetVgroup(pTable->gid.vgId); if (pVgroup == NULL) { - mError("id:%s not in vgroup:%d", pMeter->meterId, pMeter->gid.vgId); + mError("id:%s not in vgroup:%d", pTable->meterId, pTable->gid.vgId); return NULL; } @@ -185,40 +185,40 @@ void *mgmtMeterActionInsert(void *row, char *str, int size, int *ssize) { } } - if (mgmtTableCreateFromSuperTable(pMeter)) { - pMeter->pTagData = (char *)pMeter->schema; - pMetric = mgmtGetTable(pMeter->pTagData); + if (mgmtTableCreateFromSuperTable(pTable)) { + pTable->pTagData = (char *)pTable->schema; + pMetric = mgmtGetTable(pTable->pTagData); assert(pMetric != NULL); } - if (pMeter->meterType == TSDB_TABLE_TYPE_STREAM_TABLE) { - pMeter->pSql = (char *)pMeter->schema + sizeof(SSchema) * pMeter->numOfColumns; + if (pTable->tableType == TSDB_TABLE_TYPE_STREAM_TABLE) { + pTable->pSql = (char *)pTable->schema + sizeof(SSchema) * pTable->numOfColumns; } - if (mgmtIsNormalTable(pMeter)) { - if (pMetric) mgmtAddMeterIntoMetric(pMetric, pMeter); + if (mgmtIsNormalTable(pTable)) { + if (pMetric) mgmtAddMeterIntoMetric(pMetric, pTable); if (!sdbMaster) { int sid = taosAllocateId(pVgroup->idPool); - if (sid != pMeter->gid.sid) { - mError("sid:%d is not matched from the master:%d", sid, pMeter->gid.sid); + if (sid != pTable->gid.sid) { + mError("sid:%d is not matched from the master:%d", sid, pTable->gid.sid); return NULL; } } - pAcct->acctInfo.numOfTimeSeries += (pMeter->numOfColumns - 1); + pAcct->acctInfo.numOfTimeSeries += (pTable->numOfColumns - 1); pVgroup->numOfMeters++; pDb->numOfTables++; - pVgroup->meterList[pMeter->gid.sid] = pMeter; + pVgroup->meterList[pTable->gid.sid] = pTable; if (pVgroup->numOfMeters >= pDb->cfg.maxSessions - 1 && pDb->numOfVgroups > 1) mgmtMoveVgroupToTail(pDb, pVgroup); } else { // insert a metric - pMeter->pHead = NULL; - pMeter->pSkipList = NULL; - pDb = mgmtGetDbByMeterId(pMeter->meterId); + pTable->pHead = NULL; + pTable->pSkipList = NULL; + pDb = mgmtGetDbByMeterId(pTable->meterId); if (pDb) { - mgmtAddMetricIntoDb(pDb, pMeter); + mgmtAddMetricIntoDb(pDb, pTable); } } @@ -226,21 +226,21 @@ void *mgmtMeterActionInsert(void *row, char *str, int size, int *ssize) { } void *mgmtMeterActionDelete(void *row, char *str, int size, int *ssize) { - STabObj *pMeter = NULL; + STabObj *pTable = NULL; SVgObj * pVgroup = NULL; SDbObj * pDb = NULL; STabObj *pMetric = NULL; - pMeter = (STabObj *)row; + pTable = (STabObj *)row; - if (mgmtIsNormalTable(pMeter)) { - if (pMeter->gid.vgId == 0) { + if (mgmtIsNormalTable(pTable)) { + if (pTable->gid.vgId == 0) { return NULL; } - pVgroup = mgmtGetVgroup(pMeter->gid.vgId); + pVgroup = mgmtGetVgroup(pTable->gid.vgId); if (pVgroup == NULL) { - mError("id:%s not in vgroup:%d", pMeter->meterId, pMeter->gid.vgId); + mError("id:%s not in vgroup:%d", pTable->meterId, pTable->gid.vgId); return NULL; } @@ -251,48 +251,48 @@ void *mgmtMeterActionDelete(void *row, char *str, int size, int *ssize) { } } - if (mgmtTableCreateFromSuperTable(pMeter)) { - pMeter->pTagData = (char *)pMeter->schema; - pMetric = mgmtGetTable(pMeter->pTagData); + if (mgmtTableCreateFromSuperTable(pTable)) { + pTable->pTagData = (char *)pTable->schema; + pMetric = mgmtGetTable(pTable->pTagData); assert(pMetric != NULL); } - if (mgmtIsNormalTable(pMeter)) { - if (pMetric) mgmtRemoveMeterFromMetric(pMetric, pMeter); + if (mgmtIsNormalTable(pTable)) { + if (pMetric) mgmtRemoveMeterFromMetric(pMetric, pTable); - pVgroup->meterList[pMeter->gid.sid] = NULL; + pVgroup->meterList[pTable->gid.sid] = NULL; pVgroup->numOfMeters--; pDb->numOfTables--; - taosFreeId(pVgroup->idPool, pMeter->gid.sid); + taosFreeId(pVgroup->idPool, pTable->gid.sid); if (pVgroup->numOfMeters > 0) mgmtMoveVgroupToHead(pDb, pVgroup); } else { // remove a metric // remove all the associated meters - pDb = mgmtGetDbByMeterId(pMeter->meterId); - if (pDb) mgmtRemoveMetricFromDb(pDb, pMeter); + pDb = mgmtGetDbByMeterId(pTable->meterId); + if (pDb) mgmtRemoveMetricFromDb(pDb, pTable); } return NULL; } void *mgmtMeterActionUpdate(void *row, char *str, int size, int *ssize) { - STabObj *pMeter = NULL; + STabObj *pTable = NULL; STabObj *pMetric = NULL; - pMeter = (STabObj *)row; + pTable = (STabObj *)row; STabObj *pNew = (STabObj *)str; if (pNew->isDirty) { - pMetric = mgmtGetTable(pMeter->pTagData); - removeMeterFromMetricIndex(pMetric, pMeter); + pMetric = mgmtGetTable(pTable->pTagData); + removeMeterFromMetricIndex(pMetric, pTable); } - mgmtMeterActionReset(pMeter, str, size, NULL); - pMeter->pTagData = pMeter->schema; + mgmtMeterActionReset(pTable, str, size, NULL); + pTable->pTagData = pTable->schema; if (pNew->isDirty) { - addMeterIntoMetricIndex(pMetric, pMeter); - pMeter->isDirty = 0; + addMeterIntoMetricIndex(pMetric, pTable); + pTable->isDirty = 0; } return NULL; @@ -301,18 +301,18 @@ void *mgmtMeterActionUpdate(void *row, char *str, int size, int *ssize) { void *mgmtMeterActionEncode(void *row, char *str, int size, int *ssize) { assert(row != NULL && str != NULL); - STabObj *pMeter = (STabObj *)row; - int tsize = pMeter->updateEnd - (char *)pMeter; + STabObj *pTable = (STabObj *)row; + int tsize = pTable->updateEnd - (char *)pTable; - if (size < tsize + pMeter->schemaSize + 1) { + if (size < tsize + pTable->schemaSize + 1) { *ssize = -1; return NULL; } - memcpy(str, pMeter, tsize); - memcpy(str + tsize, pMeter->schema, pMeter->schemaSize); + memcpy(str, pTable, tsize); + memcpy(str + tsize, pTable->schema, pTable->schemaSize); - *ssize = tsize + pMeter->schemaSize; + *ssize = tsize + pTable->schemaSize; return NULL; } @@ -320,25 +320,25 @@ void *mgmtMeterActionEncode(void *row, char *str, int size, int *ssize) { void *mgmtMeterActionDecode(void *row, char *str, int size, int *ssize) { assert(str != NULL); - STabObj *pMeter = (STabObj *)malloc(sizeof(STabObj)); - if (pMeter == NULL) return NULL; - memset(pMeter, 0, sizeof(STabObj)); + STabObj *pTable = (STabObj *)malloc(sizeof(STabObj)); + if (pTable == NULL) return NULL; + memset(pTable, 0, sizeof(STabObj)); - int tsize = pMeter->updateEnd - (char *)pMeter; + int tsize = pTable->updateEnd - (char *)pTable; if (size < tsize) { - mgmtDestroyMeter(pMeter); + mgmtDestroyMeter(pTable); return NULL; } - memcpy(pMeter, str, tsize); + memcpy(pTable, str, tsize); - pMeter->schema = (char *)malloc(pMeter->schemaSize); - if (pMeter->schema == NULL) { - mgmtDestroyMeter(pMeter); + pTable->schema = (char *)malloc(pTable->schemaSize); + if (pTable->schema == NULL) { + mgmtDestroyMeter(pTable); return NULL; } - memcpy(pMeter->schema, str + tsize, pMeter->schemaSize); - return (void *)pMeter; + memcpy(pTable->schema, str + tsize, pTable->schemaSize); + return (void *)pTable; } void *mgmtMeterActionBeforeBatchUpdate(void *row, char *str, int size, int *ssize) { @@ -350,61 +350,61 @@ void *mgmtMeterActionBeforeBatchUpdate(void *row, char *str, int size, int *ssiz } void *mgmtMeterActionBatchUpdate(void *row, char *str, int size, int *ssize) { - STabObj * pMeter = (STabObj *)row; + STabObj * pTable = (STabObj *)row; SMeterBatchUpdateMsg *msg = (SMeterBatchUpdateMsg *)str; - if (mgmtIsSuperTable(pMeter)) { + if (mgmtIsSuperTable(pTable)) { if (msg->type == SDB_TYPE_INSERT) { // Insert schema - uint32_t total_cols = pMeter->numOfColumns + pMeter->numOfTags; - pMeter->schema = realloc(pMeter->schema, (total_cols + msg->cols) * sizeof(SSchema)); - pMeter->schemaSize = (total_cols + msg->cols) * sizeof(SSchema); - pMeter->numOfTags += msg->cols; - memcpy(pMeter->schema + total_cols * sizeof(SSchema), msg->data, msg->cols * sizeof(SSchema)); + uint32_t total_cols = pTable->numOfColumns + pTable->numOfTags; + pTable->schema = realloc(pTable->schema, (total_cols + msg->cols) * sizeof(SSchema)); + pTable->schemaSize = (total_cols + msg->cols) * sizeof(SSchema); + pTable->numOfTags += msg->cols; + memcpy(pTable->schema + total_cols * sizeof(SSchema), msg->data, msg->cols * sizeof(SSchema)); } else if (msg->type == SDB_TYPE_DELETE) { // Delete schema // Make sure the order of tag columns SchemaUnit *schemaUnit = (SchemaUnit *)(msg->data); int col = schemaUnit->col; - assert(col > 0 && col < pMeter->numOfTags); - if (col < pMeter->numOfTags - 1) { - memmove(pMeter->schema + sizeof(SSchema) * (pMeter->numOfColumns + col), - pMeter->schema + sizeof(SSchema) * (pMeter->numOfColumns + col + 1), - pMeter->schemaSize - (sizeof(SSchema) * (pMeter->numOfColumns + col + 1))); + assert(col > 0 && col < pTable->numOfTags); + if (col < pTable->numOfTags - 1) { + memmove(pTable->schema + sizeof(SSchema) * (pTable->numOfColumns + col), + pTable->schema + sizeof(SSchema) * (pTable->numOfColumns + col + 1), + pTable->schemaSize - (sizeof(SSchema) * (pTable->numOfColumns + col + 1))); } - pMeter->schemaSize -= sizeof(SSchema); - pMeter->numOfTags--; - pMeter->schema = realloc(pMeter->schema, pMeter->schemaSize); + pTable->schemaSize -= sizeof(SSchema); + pTable->numOfTags--; + pTable->schema = realloc(pTable->schema, pTable->schemaSize); } - return pMeter->pHead; + return pTable->pHead; - } else if (mgmtTableCreateFromSuperTable(pMeter)) { + } else if (mgmtTableCreateFromSuperTable(pTable)) { if (msg->type == SDB_TYPE_INSERT) { SSchema *schemas = (SSchema *)msg->data; int total_size = 0; for (int i = 0; i < msg->cols; i++) { total_size += schemas[i].bytes; } - pMeter->schema = realloc(pMeter->schema, pMeter->schemaSize + total_size); - pMeter->pTagData = pMeter->schema; - memset(pMeter->schema + pMeter->schemaSize, 0, total_size); - pMeter->schemaSize += total_size; + pTable->schema = realloc(pTable->schema, pTable->schemaSize + total_size); + pTable->pTagData = pTable->schema; + memset(pTable->schema + pTable->schemaSize, 0, total_size); + pTable->schemaSize += total_size; // TODO: set the data as default value } else if (msg->type == SDB_TYPE_DELETE) { // Delete values in MTABLEs SchemaUnit *schemaUnit = (SchemaUnit *)(msg->data); int32_t pos = schemaUnit->pos; int32_t bytes = schemaUnit->schema.bytes; - assert(pos + bytes <= pMeter->schemaSize); + assert(pos + bytes <= pTable->schemaSize); - if (pos + bytes != pMeter->schemaSize) { - memmove(pMeter->schema + pos, pMeter->schema + pos + bytes, pMeter->schemaSize - (pos + bytes)); + if (pos + bytes != pTable->schemaSize) { + memmove(pTable->schema + pos, pTable->schema + pos + bytes, pTable->schemaSize - (pos + bytes)); } - pMeter->schemaSize -= bytes; - pMeter->schema = realloc(pMeter->schema, pMeter->schemaSize); + pTable->schemaSize -= bytes; + pTable->schema = realloc(pTable->schema, pTable->schemaSize); } - return pMeter->next; + return pTable->next; } return NULL; @@ -425,15 +425,15 @@ void *mgmtMeterAction(char action, void *row, char *str, int size, int *ssize) { return NULL; } -void mgmtAddMeterStatisticToAcct(STabObj *pMeter, SAcctObj *pAcct) { - pAcct->acctInfo.numOfTimeSeries += (pMeter->numOfColumns - 1); +void mgmtAddMeterStatisticToAcct(STabObj *pTable, SAcctObj *pAcct) { + pAcct->acctInfo.numOfTimeSeries += (pTable->numOfColumns - 1); } int mgmtInitMeters() { void * pNode = NULL; void * pLastNode = NULL; SVgObj * pVgroup = NULL; - STabObj * pMeter = NULL; + STabObj * pTable = NULL; STabObj * pMetric = NULL; SDbObj * pDb = NULL; SAcctObj *pAcct = NULL; @@ -450,71 +450,71 @@ int mgmtInitMeters() { pNode = NULL; while (1) { - pNode = sdbFetchRow(meterSdb, pNode, (void **)&pMeter); - if (pMeter == NULL) break; - if (mgmtIsSuperTable(pMeter)) pMeter->numOfMeters = 0; + pNode = sdbFetchRow(meterSdb, pNode, (void **)&pTable); + if (pTable == NULL) break; + if (mgmtIsSuperTable(pTable)) pTable->numOfMeters = 0; } pNode = NULL; while (1) { pLastNode = pNode; - pNode = sdbFetchRow(meterSdb, pNode, (void **)&pMeter); - if (pMeter == NULL) break; + pNode = sdbFetchRow(meterSdb, pNode, (void **)&pTable); + if (pTable == NULL) break; - pDb = mgmtGetDbByMeterId(pMeter->meterId); + pDb = mgmtGetDbByMeterId(pTable->meterId); if (pDb == NULL) { - mError("meter:%s, failed to get db, discard it", pMeter->meterId, pMeter->gid.vgId, pMeter->gid.sid); - pMeter->gid.vgId = 0; - sdbDeleteRow(meterSdb, pMeter); + mError("meter:%s, failed to get db, discard it", pTable->meterId, pTable->gid.vgId, pTable->gid.sid); + pTable->gid.vgId = 0; + sdbDeleteRow(meterSdb, pTable); pNode = pLastNode; continue; } - if (mgmtIsNormalTable(pMeter)) { - pVgroup = mgmtGetVgroup(pMeter->gid.vgId); + if (mgmtIsNormalTable(pTable)) { + pVgroup = mgmtGetVgroup(pTable->gid.vgId); if (pVgroup == NULL) { - mError("meter:%s, failed to get vgroup:%d sid:%d, discard it", pMeter->meterId, pMeter->gid.vgId, pMeter->gid.sid); - pMeter->gid.vgId = 0; - sdbDeleteRow(meterSdb, pMeter); + mError("meter:%s, failed to get vgroup:%d sid:%d, discard it", pTable->meterId, pTable->gid.vgId, pTable->gid.sid); + pTable->gid.vgId = 0; + sdbDeleteRow(meterSdb, pTable); pNode = pLastNode; continue; } if (strcmp(pVgroup->dbName, pDb->name) != 0) { mError("meter:%s, db:%s not match with vgroup:%d db:%s sid:%d, discard it", - pMeter->meterId, pDb->name, pMeter->gid.vgId, pVgroup->dbName, pMeter->gid.sid); - pMeter->gid.vgId = 0; - sdbDeleteRow(meterSdb, pMeter); + pTable->meterId, pDb->name, pTable->gid.vgId, pVgroup->dbName, pTable->gid.sid); + pTable->gid.vgId = 0; + sdbDeleteRow(meterSdb, pTable); pNode = pLastNode; continue; } if ( pVgroup->meterList == NULL) { - mError("meter:%s, vgroup:%d meterlist is null", pMeter->meterId, pMeter->gid.vgId); - pMeter->gid.vgId = 0; - sdbDeleteRow(meterSdb, pMeter); + mError("meter:%s, vgroup:%d meterlist is null", pTable->meterId, pTable->gid.vgId); + pTable->gid.vgId = 0; + sdbDeleteRow(meterSdb, pTable); pNode = pLastNode; continue; } - pVgroup->meterList[pMeter->gid.sid] = pMeter; - taosIdPoolMarkStatus(pVgroup->idPool, pMeter->gid.sid, 1); + pVgroup->meterList[pTable->gid.sid] = pTable; + taosIdPoolMarkStatus(pVgroup->idPool, pTable->gid.sid, 1); - if (pMeter->meterType == TSDB_TABLE_TYPE_STREAM_TABLE) { - pMeter->pSql = (char *)pMeter->schema + sizeof(SSchema) * pMeter->numOfColumns; + if (pTable->tableType == TSDB_TABLE_TYPE_STREAM_TABLE) { + pTable->pSql = (char *)pTable->schema + sizeof(SSchema) * pTable->numOfColumns; } - if (mgmtTableCreateFromSuperTable(pMeter)) { - pMeter->pTagData = (char *)pMeter->schema; // + sizeof(SSchema)*pMeter->numOfColumns; - pMetric = mgmtGetTable(pMeter->pTagData); - if (pMetric) mgmtAddMeterIntoMetric(pMetric, pMeter); + if (mgmtTableCreateFromSuperTable(pTable)) { + pTable->pTagData = (char *)pTable->schema; // + sizeof(SSchema)*pTable->numOfColumns; + pMetric = mgmtGetTable(pTable->pTagData); + if (pMetric) mgmtAddMeterIntoMetric(pMetric, pTable); } pAcct = mgmtGetAcct(pDb->cfg.acct); - if (pAcct) mgmtAddMeterStatisticToAcct(pMeter, pAcct); + if (pAcct) mgmtAddMeterStatisticToAcct(pTable, pAcct); } else { - if (pDb) mgmtAddMetricIntoDb(pDb, pMeter); + if (pDb) mgmtAddMetricIntoDb(pDb, pTable); } } @@ -527,7 +527,7 @@ int mgmtInitMeters() { STabObj *mgmtGetTable(char *meterId) { return (STabObj *)sdbGetRow(meterSdb, meterId); } int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) { - STabObj * pMeter = NULL; + STabObj * pTable = NULL; STabObj * pMetric = NULL; SVgObj * pVgroup = NULL; int size = 0; @@ -548,8 +548,8 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) { } // does table exist? - pMeter = mgmtGetTable(pCreate->meterId); - if (pMeter) { + pTable = mgmtGetTable(pCreate->meterId); + if (pTable) { if (pCreate->igExists) { return TSDB_CODE_SUCCESS; } else { @@ -558,12 +558,12 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) { } // Create the table object - pMeter = (STabObj *)malloc(sizeof(STabObj)); - if (pMeter == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; - memset(pMeter, 0, sizeof(STabObj)); + pTable = (STabObj *)malloc(sizeof(STabObj)); + if (pTable == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + memset(pTable, 0, sizeof(STabObj)); if (pCreate->numOfColumns == 0 && pCreate->numOfTags == 0) { // MTABLE - pMeter->meterType = TSDB_TABLE_TYPE_CREATE_FROM_STABLE; + pTable->tableType = TSDB_TABLE_TYPE_CREATE_FROM_STABLE; char *pTagData = (char *)pCreate->schema; // it is a tag key pMetric = mgmtGetTable(pTagData); if (pMetric == NULL) { @@ -576,74 +576,74 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) { * so, we don't allocate memory for it in order to save a huge amount of * memory when a large amount of meters are created according to this super table. */ - size = mgmtGetTagsLength(pMetric, INT_MAX) + (uint32_t)TSDB_METER_ID_LEN; - pMeter->schema = (char *)malloc(size); - if (pMeter->schema == NULL) { - mgmtDestroyMeter(pMeter); + size = mgmtGetTagsLength(pMetric, INT_MAX) + (uint32_t)TSDB_TABLE_ID_LEN; + pTable->schema = (char *)malloc(size); + if (pTable->schema == NULL) { + mgmtDestroyMeter(pTable); mError("table:%s, corresponding super table schema is null", pCreate->meterId); return TSDB_CODE_INVALID_TABLE; } - memset(pMeter->schema, 0, size); + memset(pTable->schema, 0, size); - pMeter->schemaSize = size; + pTable->schemaSize = size; - pMeter->numOfColumns = pMetric->numOfColumns; - pMeter->sversion = pMetric->sversion; - pMeter->pTagData = pMeter->schema; - pMeter->nextColId = pMetric->nextColId; - memcpy(pMeter->pTagData, pTagData, size); + pTable->numOfColumns = pMetric->numOfColumns; + pTable->sversion = pMetric->sversion; + pTable->pTagData = pTable->schema; + pTable->nextColId = pMetric->nextColId; + memcpy(pTable->pTagData, pTagData, size); } else { int numOfCols = pCreate->numOfColumns + pCreate->numOfTags; size = numOfCols * sizeof(SSchema) + pCreate->sqlLen; - pMeter->schema = (char *)malloc(size); - if (pMeter->schema == NULL) { - mgmtDestroyMeter(pMeter); + pTable->schema = (char *)malloc(size); + if (pTable->schema == NULL) { + mgmtDestroyMeter(pTable); mError("table:%s, no schema input", pCreate->meterId); return TSDB_CODE_SERV_OUT_OF_MEMORY; } - memset(pMeter->schema, 0, size); + memset(pTable->schema, 0, size); - pMeter->numOfColumns = pCreate->numOfColumns; - pMeter->sversion = 0; - pMeter->numOfTags = pCreate->numOfTags; - pMeter->schemaSize = size; - memcpy(pMeter->schema, pCreate->schema, numOfCols * sizeof(SSchema)); + pTable->numOfColumns = pCreate->numOfColumns; + pTable->sversion = 0; + pTable->numOfTags = pCreate->numOfTags; + pTable->schemaSize = size; + memcpy(pTable->schema, pCreate->schema, numOfCols * sizeof(SSchema)); for (int k = 0; k < pCreate->numOfColumns; k++) { - SSchema *tschema = (SSchema *)pMeter->schema; - tschema[k].colId = pMeter->nextColId++; + SSchema *tschema = (SSchema *)pTable->schema; + tschema[k].colId = pTable->nextColId++; } if (pCreate->sqlLen > 0) { - pMeter->meterType = TSDB_TABLE_TYPE_STREAM_TABLE; - pMeter->pSql = pMeter->schema + numOfCols * sizeof(SSchema); - memcpy(pMeter->pSql, (char *)(pCreate->schema) + numOfCols * sizeof(SSchema), pCreate->sqlLen); - pMeter->pSql[pCreate->sqlLen - 1] = 0; - mTrace("table:%s, stream sql len:%d sql:%s", pCreate->meterId, pCreate->sqlLen, pMeter->pSql); + pTable->tableType = TSDB_TABLE_TYPE_STREAM_TABLE; + pTable->pSql = pTable->schema + numOfCols * sizeof(SSchema); + memcpy(pTable->pSql, (char *)(pCreate->schema) + numOfCols * sizeof(SSchema), pCreate->sqlLen); + pTable->pSql[pCreate->sqlLen - 1] = 0; + mTrace("table:%s, stream sql len:%d sql:%s", pCreate->meterId, pCreate->sqlLen, pTable->pSql); } else { if (pCreate->numOfTags > 0) { - pMeter->meterType = TSDB_TABLE_TYPE_SUPER_TABLE; + pTable->tableType = TSDB_TABLE_TYPE_SUPER_TABLE; } else { - pMeter->meterType = TSDB_TABLE_TYPE_NORMAL_TABLE; + pTable->tableType = TSDB_TABLE_TYPE_NORMAL_TABLE; } } } - pMeter->createdTime = taosGetTimestampMs(); - strcpy(pMeter->meterId, pCreate->meterId); - if (pthread_rwlock_init(&pMeter->rwLock, NULL)) { + pTable->createdTime = taosGetTimestampMs(); + strcpy(pTable->meterId, pCreate->meterId); + if (pthread_rwlock_init(&pTable->rwLock, NULL)) { mError("table:%s, failed to init meter lock", pCreate->meterId); - mgmtDestroyMeter(pMeter); + mgmtDestroyMeter(pTable); return TSDB_CODE_FAILED_TO_LOCK_RESOURCES; } if (mgmtCheckExpired()) { - mError("failed to create meter:%s, reason:grant expired", pMeter->meterId); + mError("failed to create meter:%s, reason:grant expired", pTable->meterId); return TSDB_CODE_GRANT_EXPIRED; } if (pCreate->numOfTags == 0) { - int grantCode = mgmtCheckTimeSeries(pMeter->numOfColumns); + int grantCode = mgmtCheckTimeSeries(pTable->numOfColumns); if (grantCode != 0) { mError("table:%s, grant expired", pCreate->meterId); return grantCode; @@ -654,13 +654,13 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) { pVgroup = pDb->pHead; if (pDb->vgStatus == TSDB_VG_STATUS_IN_PROGRESS) { - mgmtDestroyMeter(pMeter); + mgmtDestroyMeter(pTable); //mTrace("table:%s, vgroup in creating progress", pCreate->meterId); return TSDB_CODE_ACTION_IN_PROGRESS; } if (pDb->vgStatus == TSDB_VG_STATUS_FULL) { - mgmtDestroyMeter(pMeter); + mgmtDestroyMeter(pTable); mError("table:%s, vgroup is full", pCreate->meterId); return TSDB_CODE_NO_ENOUGH_DNODES; } @@ -669,7 +669,7 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) { pDb->vgStatus == TSDB_VG_STATUS_SERVER_NO_PACE || pDb->vgStatus == TSDB_VG_STATUS_SERV_OUT_OF_MEMORY || pDb->vgStatus == TSDB_VG_STATUS_INIT_FAILED ) { - mgmtDestroyMeter(pMeter); + mgmtDestroyMeter(pTable); mError("table:%s, vgroup init failed, reason:%d %s", pCreate->meterId, pDb->vgStatus, taosGetVgroupStatusStr(pDb->vgStatus)); return pDb->vgStatus; } @@ -677,7 +677,7 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) { if (pVgroup == NULL) { pDb->vgStatus = TSDB_VG_STATUS_IN_PROGRESS; mgmtCreateVgroup(pDb); - mgmtDestroyMeter(pMeter); + mgmtDestroyMeter(pTable); mTrace("table:%s, vgroup malloced, wait for create progress finished", pCreate->meterId); return TSDB_CODE_ACTION_IN_PROGRESS; } @@ -687,22 +687,22 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) { mWarn("table:%s, vgroup:%d run out of ID, num:%d", pCreate->meterId, pVgroup->vgId, taosIdPoolNumOfUsed(pVgroup->idPool)); pDb->vgStatus = TSDB_VG_STATUS_IN_PROGRESS; mgmtCreateVgroup(pDb); - mgmtDestroyMeter(pMeter); + mgmtDestroyMeter(pTable); return TSDB_CODE_ACTION_IN_PROGRESS; } - pMeter->gid.sid = sid; - pMeter->gid.vgId = pVgroup->vgId; - pMeter->uid = (((uint64_t)pMeter->gid.vgId) << 40) + ((((uint64_t)pMeter->gid.sid) & ((1ul << 24) - 1ul)) << 16) + + pTable->gid.sid = sid; + pTable->gid.vgId = pVgroup->vgId; + pTable->uid = (((uint64_t)pTable->gid.vgId) << 40) + ((((uint64_t)pTable->gid.sid) & ((1ul << 24) - 1ul)) << 16) + ((uint64_t)sdbVersion & ((1ul << 16) - 1ul)); mTrace("table:%s, create table in vgroup, vgId:%d sid:%d vnode:%d uid:%" PRIu64 " db:%s", - pMeter->meterId, pVgroup->vgId, sid, pVgroup->vnodeGid[0].vnode, pMeter->uid, pDb->name); + pTable->meterId, pVgroup->vgId, sid, pVgroup->vnodeGid[0].vnode, pTable->uid, pDb->name); } else { - pMeter->uid = (((uint64_t)pMeter->createdTime) << 16) + ((uint64_t)sdbVersion & ((1ul << 16) - 1ul)); + pTable->uid = (((uint64_t)pTable->createdTime) << 16) + ((uint64_t)sdbVersion & ((1ul << 16) - 1ul)); } - if (sdbInsertRow(meterSdb, pMeter, 0) < 0) { + if (sdbInsertRow(meterSdb, pTable, 0) < 0) { mError("table:%s, update sdb error", pCreate->meterId); return TSDB_CODE_SDB_ERROR; } @@ -710,21 +710,21 @@ int mgmtCreateMeter(SDbObj *pDb, SCreateTableMsg *pCreate) { // send create message to the selected vnode servers if (pCreate->numOfTags == 0) { mTrace("table:%s, send create table msg to dnode, vgId:%d, sid:%d, vnode:%d", - pMeter->meterId, pMeter->gid.vgId, pMeter->gid.sid, pVgroup->vnodeGid[0].vnode); + pTable->meterId, pTable->gid.vgId, pTable->gid.sid, pVgroup->vnodeGid[0].vnode); - mgmtAddTimeSeries(pMeter->numOfColumns - 1); - mgmtSendCreateMsgToVgroup(pMeter, pVgroup); + mgmtAddTimeSeries(pTable->numOfColumns - 1); + mgmtSendCreateMsgToVgroup(pTable, pVgroup); } return 0; } int mgmtDropMeter(SDbObj *pDb, char *meterId, int ignore) { - STabObj * pMeter; + STabObj * pTable; SAcctObj *pAcct; - pMeter = mgmtGetTable(meterId); - if (pMeter == NULL) { + pTable = mgmtGetTable(meterId); + if (pTable == NULL) { if (ignore) { return TSDB_CODE_SUCCESS; } else { @@ -739,31 +739,31 @@ int mgmtDropMeter(SDbObj *pDb, char *meterId, int ignore) { return TSDB_CODE_MONITOR_DB_FORBEIDDEN; } - if (mgmtIsNormalTable(pMeter)) { - return dropMeterImp(pDb, pMeter, pAcct); + if (mgmtIsNormalTable(pTable)) { + return dropMeterImp(pDb, pTable, pAcct); } else { // remove a metric /* - if (pMeter->numOfMeters > 0) { - assert(pMeter->pSkipList != NULL && pMeter->pSkipList->nSize > 0); + if (pTable->numOfMeters > 0) { + assert(pTable->pSkipList != NULL && pTable->pSkipList->nSize > 0); return TSDB_CODE_RELATED_TABLES_EXIST; } */ // first delet all meters of metric - dropAllMetersOfMetric(pDb, pMeter, pAcct); + dropAllMetersOfMetric(pDb, pTable, pAcct); // finally delete metric - sdbDeleteRow(meterSdb, pMeter); + sdbDeleteRow(meterSdb, pTable); } return 0; } int mgmtAlterMeter(SDbObj *pDb, SAlterTableMsg *pAlter) { - STabObj *pMeter; + STabObj *pTable; - pMeter = mgmtGetTable(pAlter->meterId); - if (pMeter == NULL) { + pTable = mgmtGetTable(pAlter->meterId); + if (pTable == NULL) { return TSDB_CODE_INVALID_TABLE; } @@ -771,7 +771,7 @@ int mgmtAlterMeter(SDbObj *pDb, SAlterTableMsg *pAlter) { if (mgmtCheckIsMonitorDB(pDb->name, tsMonitorDbName)) return TSDB_CODE_MONITOR_DB_FORBEIDDEN; if (pAlter->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) { - if (!mgmtIsNormalTable(pMeter) || !mgmtTableCreateFromSuperTable(pMeter)) { + if (!mgmtIsNormalTable(pTable) || !mgmtTableCreateFromSuperTable(pTable)) { return TSDB_CODE_OPS_NOT_SUPPORT; } } @@ -779,25 +779,25 @@ int mgmtAlterMeter(SDbObj *pDb, SAlterTableMsg *pAlter) { // todo add /* mgmtMeterAddTags */ if (pAlter->type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) { - mTrace("alter table %s to add tag column:%s, type:%d", pMeter->meterId, pAlter->schema[0].name, + mTrace("alter table %s to add tag column:%s, type:%d", pTable->meterId, pAlter->schema[0].name, pAlter->schema[0].type); - return mgmtMeterAddTags(pMeter, pAlter->schema, 1); + return mgmtMeterAddTags(pTable, pAlter->schema, 1); } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_TAG_COLUMN) { - mTrace("alter table %s to drop tag column:%s", pMeter->meterId, pAlter->schema[0].name); - return mgmtMeterDropTagByName(pMeter, pAlter->schema[0].name); + mTrace("alter table %s to drop tag column:%s", pTable->meterId, pAlter->schema[0].name); + return mgmtMeterDropTagByName(pTable, pAlter->schema[0].name); } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) { - mTrace("alter table %s to change tag column name, old: %s, new: %s", pMeter->meterId, pAlter->schema[0].name, + mTrace("alter table %s to change tag column name, old: %s, new: %s", pTable->meterId, pAlter->schema[0].name, pAlter->schema[1].name); - return mgmtMeterModifyTagNameByName(pMeter, pAlter->schema[0].name, pAlter->schema[1].name); + return mgmtMeterModifyTagNameByName(pTable, pAlter->schema[0].name, pAlter->schema[1].name); } else if (pAlter->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) { - mTrace("alter table %s to modify tag value, tag name:%s", pMeter->meterId, pAlter->schema[0].name); - return mgmtMeterModifyTagValueByName(pMeter, pAlter->schema[0].name, pAlter->tagVal); + mTrace("alter table %s to modify tag value, tag name:%s", pTable->meterId, pAlter->schema[0].name); + return mgmtMeterModifyTagValueByName(pTable, pAlter->schema[0].name, pAlter->tagVal); } else if (pAlter->type == TSDB_ALTER_TABLE_ADD_COLUMN) { - mTrace("alter table %s to add column:%s, type:%d", pMeter->meterId, pAlter->schema[0].name, pAlter->schema[0].type); - return mgmtMeterAddColumn(pMeter, pAlter->schema, 1); + mTrace("alter table %s to add column:%s, type:%d", pTable->meterId, pAlter->schema[0].name, pAlter->schema[0].type); + return mgmtMeterAddColumn(pTable, pAlter->schema, 1); } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_COLUMN) { - mTrace("alter table %s to drop column:%s", pMeter->meterId, pAlter->schema[0].name); - return mgmtMeterDropColumnByName(pMeter, pAlter->schema[0].name); + mTrace("alter table %s to drop column:%s", pTable->meterId, pAlter->schema[0].name); + return mgmtMeterDropColumnByName(pTable, pAlter->schema[0].name); } else { return TSDB_CODE_INVALID_MSG_TYPE; } @@ -805,17 +805,17 @@ int mgmtAlterMeter(SDbObj *pDb, SAlterTableMsg *pAlter) { return TSDB_CODE_SUCCESS; } -static int dropMeterImp(SDbObj *pDb, STabObj * pMeter, SAcctObj *pAcct) { +static int dropMeterImp(SDbObj *pDb, STabObj * pTable, SAcctObj *pAcct) { SVgObj * pVgroup; - if (pAcct != NULL) pAcct->acctInfo.numOfTimeSeries -= (pMeter->numOfColumns - 1); + if (pAcct != NULL) pAcct->acctInfo.numOfTimeSeries -= (pTable->numOfColumns - 1); - pVgroup = mgmtGetVgroup(pMeter->gid.vgId); + pVgroup = mgmtGetVgroup(pTable->gid.vgId); if (pVgroup == NULL) return TSDB_CODE_OTHERS; - mgmtRestoreTimeSeries(pMeter->numOfColumns - 1); - mgmtSendRemoveMeterMsgToDnode(pMeter, pVgroup); - sdbDeleteRow(meterSdb, pMeter); + mgmtRestoreTimeSeries(pTable->numOfColumns - 1); + mgmtSendRemoveMeterMsgToDnode(pTable, pVgroup); + sdbDeleteRow(meterSdb, pTable); if (pVgroup->numOfMeters <= 0) mgmtDropVgroup(pDb, pVgroup); @@ -823,10 +823,10 @@ static int dropMeterImp(SDbObj *pDb, STabObj * pMeter, SAcctObj *pAcct) { } static void dropAllMetersOfMetric(SDbObj *pDb, STabObj * pMetric, SAcctObj *pAcct) { - STabObj * pMeter = NULL; + STabObj * pTable = NULL; - while ((pMeter = pMetric->pHead) != NULL) { - (void)dropMeterImp(pDb, pMeter, pAcct); + while ((pTable = pMetric->pHead) != NULL) { + (void)dropMeterImp(pDb, pTable, pAcct); } } @@ -834,18 +834,18 @@ static void dropAllMetersOfMetric(SDbObj *pDb, STabObj * pMetric, SAcctObj *pAcc * create key of each meter for skip list, which is generated from first tag * column */ -static void createKeyFromTagValue(STabObj *pMetric, STabObj *pMeter, tSkipListKey *pKey) { +static void createKeyFromTagValue(STabObj *pMetric, STabObj *pTable, tSkipListKey *pKey) { SSchema * pTagSchema = (SSchema *)(pMetric->schema + pMetric->numOfColumns * sizeof(SSchema)); const int16_t KEY_COLUMN_OF_TAGS = 0; - char *tagVal = pMeter->pTagData + TSDB_METER_ID_LEN; // tag start position + char *tagVal = pTable->pTagData + TSDB_TABLE_ID_LEN; // tag start position *pKey = tSkipListCreateKey(pTagSchema[KEY_COLUMN_OF_TAGS].type, tagVal, pTagSchema[KEY_COLUMN_OF_TAGS].bytes); } /* * add a meter into a metric's skip list */ -static void addMeterIntoMetricIndex(STabObj *pMetric, STabObj *pMeter) { +static void addMeterIntoMetricIndex(STabObj *pMetric, STabObj *pTable) { const int16_t KEY_COLUMN_OF_TAGS = 0; SSchema * pTagSchema = (SSchema *)(pMetric->schema + pMetric->numOfColumns * sizeof(SSchema)); @@ -856,27 +856,27 @@ static void addMeterIntoMetricIndex(STabObj *pMetric, STabObj *pMeter) { if (pMetric->pSkipList) { tSkipListKey key = {0}; - createKeyFromTagValue(pMetric, pMeter, &key); - tSkipListPut(pMetric->pSkipList, pMeter, &key, 1); + createKeyFromTagValue(pMetric, pTable, &key); + tSkipListPut(pMetric->pSkipList, pTable, &key, 1); tSkipListDestroyKey(&key); } } -static void removeMeterFromMetricIndex(STabObj *pMetric, STabObj *pMeter) { +static void removeMeterFromMetricIndex(STabObj *pMetric, STabObj *pTable) { if (pMetric->pSkipList == NULL) { return; } tSkipListKey key = {0}; - createKeyFromTagValue(pMetric, pMeter, &key); + createKeyFromTagValue(pMetric, pTable, &key); tSkipListNode **pRes = NULL; int32_t num = tSkipListGets(pMetric->pSkipList, &key, &pRes); for (int32_t i = 0; i < num; ++i) { STabObj *pOneMeter = (STabObj *)pRes[i]->pData; - if (pOneMeter->gid.sid == pMeter->gid.sid && pOneMeter->gid.vgId == pMeter->gid.vgId) { - assert(pMeter == pOneMeter); + if (pOneMeter->gid.sid == pTable->gid.sid && pOneMeter->gid.vgId == pTable->gid.vgId) { + assert(pTable == pOneMeter); tSkipListRemoveNode(pMetric->pSkipList, pRes[i]); } } @@ -887,38 +887,38 @@ static void removeMeterFromMetricIndex(STabObj *pMetric, STabObj *pMeter) { } } -int mgmtAddMeterIntoMetric(STabObj *pMetric, STabObj *pMeter) { - if (pMeter == NULL || pMetric == NULL) return -1; +int mgmtAddMeterIntoMetric(STabObj *pMetric, STabObj *pTable) { + if (pTable == NULL || pMetric == NULL) return -1; pthread_rwlock_wrlock(&(pMetric->rwLock)); // add meter into skip list - pMeter->next = pMetric->pHead; - pMeter->prev = NULL; + pTable->next = pMetric->pHead; + pTable->prev = NULL; - if (pMetric->pHead) pMetric->pHead->prev = pMeter; + if (pMetric->pHead) pMetric->pHead->prev = pTable; - pMetric->pHead = pMeter; + pMetric->pHead = pTable; pMetric->numOfMeters++; - addMeterIntoMetricIndex(pMetric, pMeter); + addMeterIntoMetricIndex(pMetric, pTable); pthread_rwlock_unlock(&(pMetric->rwLock)); return 0; } -int mgmtRemoveMeterFromMetric(STabObj *pMetric, STabObj *pMeter) { +int mgmtRemoveMeterFromMetric(STabObj *pMetric, STabObj *pTable) { pthread_rwlock_wrlock(&(pMetric->rwLock)); - if (pMeter->prev) pMeter->prev->next = pMeter->next; + if (pTable->prev) pTable->prev->next = pTable->next; - if (pMeter->next) pMeter->next->prev = pMeter->prev; + if (pTable->next) pTable->next->prev = pTable->prev; - if (pMeter->prev == NULL) pMetric->pHead = pMeter->next; + if (pTable->prev == NULL) pMetric->pHead = pTable->next; pMetric->numOfMeters--; - removeMeterFromMetricIndex(pMetric, pMeter); + removeMeterFromMetricIndex(pMetric, pTable); pthread_rwlock_unlock(&(pMetric->rwLock)); @@ -974,34 +974,34 @@ int mgmtGetTableMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) { return 0; } -SSchema *mgmtGetTableSchema(STabObj *pMeter) { - if (pMeter == NULL) { +SSchema *mgmtGetTableSchema(STabObj *pTable) { + if (pTable == NULL) { return NULL; } - if (!mgmtTableCreateFromSuperTable(pMeter)) { - return (SSchema *)pMeter->schema; + if (!mgmtTableCreateFromSuperTable(pTable)) { + return (SSchema *)pTable->schema; } - STabObj *pMetric = mgmtGetTable(pMeter->pTagData); + STabObj *pMetric = mgmtGetTable(pTable->pTagData); assert(pMetric != NULL); return (SSchema *)pMetric->schema; } -static int32_t mgmtSerializeTagValue(char* pMsg, STabObj* pMeter, int16_t* tagsId, int32_t numOfTags) { +static int32_t mgmtSerializeTagValue(char* pMsg, STabObj* pTable, int16_t* tagsId, int32_t numOfTags) { int32_t offset = 0; for (int32_t j = 0; j < numOfTags; ++j) { if (tagsId[j] == TSDB_TBNAME_COLUMN_INDEX) { // handle the table name tags char name[TSDB_METER_NAME_LEN] = {0}; - extractTableName(pMeter->meterId, name); + extractTableName(pTable->meterId, name); memcpy(pMsg + offset, name, TSDB_METER_NAME_LEN); offset += TSDB_METER_NAME_LEN; } else { SSchema s = {0}; - char * tag = mgmtTableGetTag(pMeter, tagsId[j], &s); + char * tag = mgmtTableGetTag(pTable, tagsId[j], &s); memcpy(pMsg + offset, tag, (size_t)s.bytes); offset += s.bytes; @@ -1014,10 +1014,10 @@ static int32_t mgmtSerializeTagValue(char* pMsg, STabObj* pMeter, int16_t* tagsI /* * serialize SVnodeSidList to byte array */ -static char *mgmtBuildMetricMetaMsg(SConnObj *pConn, STabObj *pMeter, int32_t *ovgId, SVnodeSidList **pList, SMetricMeta *pMeta, +static char *mgmtBuildMetricMetaMsg(SConnObj *pConn, STabObj *pTable, int32_t *ovgId, SVnodeSidList **pList, SMetricMeta *pMeta, int32_t tagLen, int16_t numOfTags, int16_t *tagsId, int32_t maxNumOfMeters, char *pMsg) { - if (pMeter->gid.vgId != *ovgId || ((*pList) != NULL && (*pList)->numOfSids >= maxNumOfMeters)) { + if (pTable->gid.vgId != *ovgId || ((*pList) != NULL && (*pList)->numOfSids >= maxNumOfMeters)) { /* * here we construct a new vnode group for 2 reasons * 1. the query msg may be larger than 64k, @@ -1028,7 +1028,7 @@ static char *mgmtBuildMetricMetaMsg(SConnObj *pConn, STabObj *pMeter, int32_t *o (*pList)->index = 0; pMeta->numOfVnodes++; - SVgObj *pVgroup = mgmtGetVgroup(pMeter->gid.vgId); + SVgObj *pVgroup = mgmtGetVgroup(pTable->gid.vgId); for (int i = 0; i < TSDB_VNODES_SUPPORT; ++i) { if (pConn->usePublicIp) { (*pList)->vpeerDesc[i].ip = pVgroup->vnodeGid[i].publicIp; @@ -1040,18 +1040,18 @@ static char *mgmtBuildMetricMetaMsg(SConnObj *pConn, STabObj *pMeter, int32_t *o } pMsg += sizeof(SVnodeSidList); - (*ovgId) = pMeter->gid.vgId; + (*ovgId) = pTable->gid.vgId; } pMeta->numOfMeters++; (*pList)->numOfSids++; SMeterSidExtInfo *pSMeterTagInfo = (SMeterSidExtInfo *)pMsg; - pSMeterTagInfo->sid = htonl(pMeter->gid.sid); - pSMeterTagInfo->uid = htobe64(pMeter->uid); + pSMeterTagInfo->sid = htonl(pTable->gid.sid); + pSMeterTagInfo->uid = htobe64(pTable->uid); pMsg += sizeof(SMeterSidExtInfo); - int32_t offset = mgmtSerializeTagValue(pMsg, pMeter, tagsId, numOfTags); + int32_t offset = mgmtSerializeTagValue(pMsg, pTable, tagsId, numOfTags); assert(offset == tagLen); pMsg += offset; @@ -1064,12 +1064,12 @@ static int32_t mgmtGetNumOfVnodesInResult(tQueryResultset *pResult) { int32_t prevGid = -1; for (int32_t i = 0; i < pResult->num; ++i) { - STabObj *pMeter = pResult->pRes[i]; + STabObj *pTable = pResult->pRes[i]; if (prevGid == -1) { - prevGid = pMeter->gid.vgId; + prevGid = pTable->gid.vgId; numOfVnodes++; - } else if (prevGid != pMeter->gid.vgId) { - prevGid = pMeter->gid.vgId; + } else if (prevGid != pTable->gid.vgId) { + prevGid = pTable->gid.vgId; numOfVnodes++; } } @@ -1087,8 +1087,8 @@ static int32_t mgmtGetMetricMetaMsgSize(tQueryResultset *pResult, int32_t tagLen return size; } -static SMetricMetaElemMsg *doConvertMetricMetaMsg(SMetricMetaMsg *pMetricMetaMsg, int32_t tableIndex) { - SMetricMetaElemMsg *pElem = (SMetricMetaElemMsg *)((char *)pMetricMetaMsg + pMetricMetaMsg->metaElem[tableIndex]); +static SMetricMetaElemMsg *doConvertMetricMetaMsg(SSuperTableMetaMsg *pSuperTableMetaMsg, int32_t tableIndex) { + SMetricMetaElemMsg *pElem = (SMetricMetaElemMsg *)((char *)pSuperTableMetaMsg + pSuperTableMetaMsg->metaElem[tableIndex]); pElem->orderIndex = htons(pElem->orderIndex); pElem->orderType = htons(pElem->orderType); @@ -1111,7 +1111,7 @@ static SMetricMetaElemMsg *doConvertMetricMetaMsg(SMetricMetaMsg *pMetricMetaMsg pElem->groupbyTagColumnList = htonl(pElem->groupbyTagColumnList); - SColIndexEx *groupColIds = (SColIndexEx*) (((char *)pMetricMetaMsg) + pElem->groupbyTagColumnList); + SColIndexEx *groupColIds = (SColIndexEx*) (((char *)pSuperTableMetaMsg) + pElem->groupbyTagColumnList); for (int32_t i = 0; i < pElem->numOfGroupCols; ++i) { groupColIds[i].colId = htons(groupColIds[i].colId); groupColIds[i].colIdx = htons(groupColIds[i].colIdx); @@ -1122,7 +1122,7 @@ static SMetricMetaElemMsg *doConvertMetricMetaMsg(SMetricMetaMsg *pMetricMetaMsg return pElem; } -static int32_t mgmtBuildMetricMetaRspMsg(SConnObj *pConn, SMetricMetaMsg *pMetricMetaMsg, tQueryResultset *pResult, +static int32_t mgmtBuildMetricMetaRspMsg(SConnObj *pConn, SSuperTableMetaMsg *pSuperTableMetaMsg, tQueryResultset *pResult, char **pStart, int32_t *tagLen, int32_t rspMsgSize, int32_t maxTablePerVnode, int32_t code) { *pStart = taosBuildRspMsgWithSize(pConn->thandle, TSDB_MSG_TYPE_METRIC_META_RSP, rspMsgSize); @@ -1144,10 +1144,10 @@ static int32_t mgmtBuildMetricMetaRspMsg(SConnObj *pConn, SMetricMetaMsg *pMetri int32_t msgLen = 0; - *(int16_t *)pMsg = htons(pMetricMetaMsg->numOfMeters); + *(int16_t *)pMsg = htons(pSuperTableMetaMsg->numOfMeters); pMsg += sizeof(int16_t); - for (int32_t j = 0; j < pMetricMetaMsg->numOfMeters; ++j) { + for (int32_t j = 0; j < pSuperTableMetaMsg->numOfMeters; ++j) { SVnodeSidList *pList = NULL; int ovgId = -1; @@ -1159,11 +1159,11 @@ static int32_t mgmtBuildMetricMetaRspMsg(SConnObj *pConn, SMetricMetaMsg *pMetri pMsg = (char *)pMeta + sizeof(SMetricMeta); - SMetricMetaElemMsg *pElem = (SMetricMetaElemMsg *)((char *)pMetricMetaMsg + pMetricMetaMsg->metaElem[j]); + SMetricMetaElemMsg *pElem = (SMetricMetaElemMsg *)((char *)pSuperTableMetaMsg + pSuperTableMetaMsg->metaElem[j]); for (int32_t i = 0; i < pResult[j].num; ++i) { - STabObj *pMeter = pResult[j].pRes[i]; - pMsg = mgmtBuildMetricMetaMsg(pConn, pMeter, &ovgId, &pList, pMeta, tagLen[j], pElem->numOfTags, pElem->tagCols, + STabObj *pTable = pResult[j].pRes[i]; + pMsg = mgmtBuildMetricMetaMsg(pConn, pTable, &ovgId, &pList, pMeta, tagLen[j], pElem->numOfTags, pElem->tagCols, maxTablePerVnode, pMsg); } @@ -1179,7 +1179,7 @@ static int32_t mgmtBuildMetricMetaRspMsg(SConnObj *pConn, SMetricMetaMsg *pMetri return msgLen; } -int mgmtRetrieveMetricMeta(SConnObj *pConn, char **pStart, SMetricMetaMsg *pMetricMetaMsg) { +int mgmtRetrieveMetricMeta(SConnObj *pConn, char **pStart, SSuperTableMetaMsg *pSuperTableMetaMsg) { /* * naive method: Do not limit the maximum number of meters in each * vnode(subquery), split the result according to vnodes @@ -1190,8 +1190,8 @@ int mgmtRetrieveMetricMeta(SConnObj *pConn, char **pStart, SMetricMetaMsg *pMetr int32_t maxMetersPerVNodeForQuery = INT32_MAX; int msgLen = 0; int ret = TSDB_CODE_SUCCESS; - tQueryResultset *result = calloc(1, pMetricMetaMsg->numOfMeters * sizeof(tQueryResultset)); - int32_t * tagLen = calloc(1, sizeof(int32_t) * pMetricMetaMsg->numOfMeters); + tQueryResultset *result = calloc(1, pSuperTableMetaMsg->numOfMeters * sizeof(tQueryResultset)); + int32_t * tagLen = calloc(1, sizeof(int32_t) * pSuperTableMetaMsg->numOfMeters); if (result == NULL || tagLen == NULL) { tfree(result); @@ -1199,8 +1199,8 @@ int mgmtRetrieveMetricMeta(SConnObj *pConn, char **pStart, SMetricMetaMsg *pMetr return -1; } - for (int32_t i = 0; i < pMetricMetaMsg->numOfMeters; ++i) { - SMetricMetaElemMsg *pElem = doConvertMetricMetaMsg(pMetricMetaMsg, i); + for (int32_t i = 0; i < pSuperTableMetaMsg->numOfMeters; ++i) { + SMetricMetaElemMsg *pElem = doConvertMetricMetaMsg(pSuperTableMetaMsg, i); STabObj * pMetric = mgmtGetTable(pElem->meterId); if (!mgmtIsSuperTable(pMetric)) { @@ -1216,8 +1216,8 @@ int mgmtRetrieveMetricMeta(SConnObj *pConn, char **pStart, SMetricMetaMsg *pMetr int64_t num = 0; int32_t index = 0; - for (int32_t i = 0; i < pMetricMetaMsg->numOfMeters; ++i) { - SMetricMetaElemMsg *pElem = (SMetricMetaElemMsg*) ((char *) pMetricMetaMsg + pMetricMetaMsg->metaElem[i]); + for (int32_t i = 0; i < pSuperTableMetaMsg->numOfMeters; ++i) { + SMetricMetaElemMsg *pElem = (SMetricMetaElemMsg*) ((char *) pSuperTableMetaMsg + pSuperTableMetaMsg->metaElem[i]); STabObj *pMetric = mgmtGetTable(pElem->meterId); if (pMetric->pSkipList->nSize > num) { @@ -1229,32 +1229,32 @@ int mgmtRetrieveMetricMeta(SConnObj *pConn, char **pStart, SMetricMetaMsg *pMetr if (ret == TSDB_CODE_SUCCESS) { // todo opt performance - for (int32_t i = 0; i < pMetricMetaMsg->numOfMeters; ++i) { - ret = mgmtRetrieveMetersFromMetric(pMetricMetaMsg, i, &result[i]); + for (int32_t i = 0; i < pSuperTableMetaMsg->numOfMeters; ++i) { + ret = mgmtRetrieveMetersFromSuperTable(pSuperTableMetaMsg, i, &result[i]); } } if (ret == TSDB_CODE_SUCCESS) { - ret = mgmtDoJoin(pMetricMetaMsg, result); + ret = mgmtDoJoin(pSuperTableMetaMsg, result); } if (ret == TSDB_CODE_SUCCESS) { - for (int32_t i = 0; i < pMetricMetaMsg->numOfMeters; ++i) { - mgmtReorganizeMetersInMetricMeta(pMetricMetaMsg, i, &result[i]); + for (int32_t i = 0; i < pSuperTableMetaMsg->numOfMeters; ++i) { + mgmtReorganizeMetersInMetricMeta(pSuperTableMetaMsg, i, &result[i]); } } if (ret == TSDB_CODE_SUCCESS) { - for (int32_t i = 0; i < pMetricMetaMsg->numOfMeters; ++i) { + for (int32_t i = 0; i < pSuperTableMetaMsg->numOfMeters; ++i) { msgLen += mgmtGetMetricMetaMsgSize(&result[i], tagLen[i], maxMetersPerVNodeForQuery); } } else { msgLen = 512; } - msgLen = mgmtBuildMetricMetaRspMsg(pConn, pMetricMetaMsg, result, pStart, tagLen, msgLen, maxMetersPerVNodeForQuery, ret); + msgLen = mgmtBuildMetricMetaRspMsg(pConn, pSuperTableMetaMsg, result, pStart, tagLen, msgLen, maxMetersPerVNodeForQuery, ret); - for (int32_t i = 0; i < pMetricMetaMsg->numOfMeters; ++i) { + for (int32_t i = 0; i < pSuperTableMetaMsg->numOfMeters; ++i) { tQueryResultClean(&result[i]); } @@ -1266,7 +1266,7 @@ int mgmtRetrieveMetricMeta(SConnObj *pConn, char **pStart, SMetricMetaMsg *pMetr int mgmtRetrieveMeters(SShowObj *pShow, char *data, int rows, SConnObj *pConn) { int numOfRows = 0; - STabObj *pMeter = NULL; + STabObj *pTable = NULL; char * pWrite; int cols = 0; int prefixLen; @@ -1291,19 +1291,19 @@ int mgmtRetrieveMeters(SShowObj *pShow, char *data, int rows, SConnObj *pConn) { char meterName[TSDB_METER_NAME_LEN] = {0}; while (numOfRows < rows) { - pShow->pNode = sdbFetchRow(meterSdb, pShow->pNode, (void **)&pMeter); - if (pMeter == NULL) break; + pShow->pNode = sdbFetchRow(meterSdb, pShow->pNode, (void **)&pTable); + if (pTable == NULL) break; - if (mgmtIsSuperTable(pMeter)) continue; + if (mgmtIsSuperTable(pTable)) continue; // not belong to current db - if (strncmp(pMeter->meterId, prefix, prefixLen)) continue; + if (strncmp(pTable->meterId, prefix, prefixLen)) continue; numOfRead++; memset(meterName, 0, tListLen(meterName)); // pattern compare for meter name - extractTableName(pMeter->meterId, meterName); + extractTableName(pTable->meterId, meterName); if (pShow->payloadLen > 0 && patternMatch(pShow->payload, meterName, TSDB_METER_NAME_LEN, &info) != TSDB_PATTERN_MATCH) @@ -1316,16 +1316,16 @@ int mgmtRetrieveMeters(SShowObj *pShow, char *data, int rows, SConnObj *pConn) { cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - *(int64_t *)pWrite = pMeter->createdTime; + *(int64_t *)pWrite = pTable->createdTime; cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - *(int16_t *)pWrite = pMeter->numOfColumns; + *(int16_t *)pWrite = pTable->numOfColumns; cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - if (pMeter->pTagData) { - extractTableName(pMeter->pTagData, pWrite); + if (pTable->pTagData) { + extractTableName(pTable->pTagData, pWrite); } cols++; @@ -1515,11 +1515,11 @@ int32_t mgmtMeterModifyTagNameByName(STabObj *pMetric, const char *oname, const return mgmtMeterModifyTagNameByCol(pMetric, index, nname); } -int32_t mgmtMeterModifyTagValueByCol(STabObj *pMeter, int col, const char *nContent) { +int32_t mgmtMeterModifyTagValueByCol(STabObj *pTable, int col, const char *nContent) { int rowSize = 0; - if (pMeter == NULL || nContent == NULL || (!mgmtTableCreateFromSuperTable(pMeter))) return TSDB_CODE_APP_ERROR; + if (pTable == NULL || nContent == NULL || (!mgmtTableCreateFromSuperTable(pTable))) return TSDB_CODE_APP_ERROR; - STabObj *pMetric = mgmtGetTable(pMeter->pTagData); + STabObj *pMetric = mgmtGetTable(pTable->pTagData); assert(pMetric != NULL); if (col < 0 || col > pMetric->numOfTags) return TSDB_CODE_APP_ERROR; @@ -1527,12 +1527,12 @@ int32_t mgmtMeterModifyTagValueByCol(STabObj *pMeter, int col, const char *nCont SSchema *schema = (SSchema *)(pMetric->schema + (pMetric->numOfColumns + col) * sizeof(SSchema)); if (col == 0) { - pMeter->isDirty = 1; - removeMeterFromMetricIndex(pMetric, pMeter); + pTable->isDirty = 1; + removeMeterFromMetricIndex(pMetric, pTable); } - memcpy(pMeter->pTagData + mgmtGetTagsLength(pMetric, col) + TSDB_METER_ID_LEN, nContent, schema->bytes); + memcpy(pTable->pTagData + mgmtGetTagsLength(pMetric, col) + TSDB_TABLE_ID_LEN, nContent, schema->bytes); if (col == 0) { - addMeterIntoMetricIndex(pMetric, pMeter); + addMeterIntoMetricIndex(pMetric, pTable); } // Encode the string @@ -1544,33 +1544,33 @@ int32_t mgmtMeterModifyTagValueByCol(STabObj *pMeter, int col, const char *nCont } memset(msg, 0, size); - mgmtMeterActionEncode(pMeter, msg, size, &rowSize); + mgmtMeterActionEncode(pTable, msg, size, &rowSize); int32_t ret = sdbUpdateRow(meterSdb, msg, rowSize, 1); // Need callback function tfree(msg); - if (pMeter->isDirty) pMeter->isDirty = 0; + if (pTable->isDirty) pTable->isDirty = 0; if (ret < 0) { - mError("Failed to modify tag column %d of table %s", col, pMeter->meterId); + mError("Failed to modify tag column %d of table %s", col, pTable->meterId); return TSDB_CODE_APP_ERROR; } - mTrace("Succeed to modify tag column %d of table %s", col, pMeter->meterId); + mTrace("Succeed to modify tag column %d of table %s", col, pTable->meterId); return TSDB_CODE_SUCCESS; } -int32_t mgmtMeterModifyTagValueByName(STabObj *pMeter, char *tagName, char *nContent) { - if (pMeter == NULL || tagName == NULL || nContent == NULL || (!mgmtTableCreateFromSuperTable(pMeter))) +int32_t mgmtMeterModifyTagValueByName(STabObj *pTable, char *tagName, char *nContent) { + if (pTable == NULL || tagName == NULL || nContent == NULL || (!mgmtTableCreateFromSuperTable(pTable))) return TSDB_CODE_INVALID_MSG_TYPE; - STabObj *pMetric = mgmtGetTable(pMeter->pTagData); + STabObj *pMetric = mgmtGetTable(pTable->pTagData); if (pMetric == NULL) return TSDB_CODE_APP_ERROR; int col = mgmtFindTagCol(pMetric, tagName); if (col < 0) return TSDB_CODE_APP_ERROR; - return mgmtMeterModifyTagValueByCol(pMeter, col, nContent); + return mgmtMeterModifyTagValueByCol(pTable, col, nContent); } int32_t mgmtMeterAddTags(STabObj *pMetric, SSchema schema[], int ntags) { @@ -1597,7 +1597,7 @@ int32_t mgmtMeterAddTags(STabObj *pMetric, SSchema schema[], int ntags) { SMeterBatchUpdateMsg *msg = (SMeterBatchUpdateMsg *)malloc(size); memset(msg, 0, size); - memcpy(msg->meterId, pMetric->meterId, TSDB_METER_ID_LEN); + memcpy(msg->meterId, pMetric->meterId, TSDB_TABLE_ID_LEN); msg->type = SDB_TYPE_INSERT; msg->cols = ntags; memcpy(msg->data, schema, sizeof(SSchema) * ntags); @@ -1622,12 +1622,12 @@ int32_t mgmtMeterDropTagByCol(STabObj *pMetric, int col) { SMeterBatchUpdateMsg *msg = (SMeterBatchUpdateMsg *)malloc(size); memset(msg, 0, size); - memcpy(msg->meterId, pMetric->meterId, TSDB_METER_ID_LEN); + memcpy(msg->meterId, pMetric->meterId, TSDB_TABLE_ID_LEN); msg->type = SDB_TYPE_DELETE; // TODO: what should here be ? msg->cols = 1; ((SchemaUnit *)(msg->data))->col = col; - ((SchemaUnit *)(msg->data))->pos = mgmtGetTagsLength(pMetric, col) + TSDB_METER_ID_LEN; + ((SchemaUnit *)(msg->data))->pos = mgmtGetTagsLength(pMetric, col) + TSDB_TABLE_ID_LEN; ((SchemaUnit *)(msg->data))->schema = *(SSchema *)(pMetric->schema + sizeof(SSchema) * (pMetric->numOfColumns + col)); int32_t ret = sdbBatchUpdateRow(meterSdb, msg, size); @@ -1653,22 +1653,22 @@ int32_t mgmtMeterDropTagByName(STabObj *pMetric, char *name) { return mgmtMeterDropTagByCol(pMetric, col); } -int32_t mgmtFindColumnIndex(STabObj *pMeter, const char *colName) { +int32_t mgmtFindColumnIndex(STabObj *pTable, const char *colName) { STabObj *pMetric = NULL; SSchema *schema = NULL; - if (pMeter->meterType == TSDB_TABLE_TYPE_NORMAL_TABLE || pMeter->meterType == TSDB_TABLE_TYPE_SUPER_TABLE) { - schema = (SSchema *)pMeter->schema; - for (int32_t i = 0; i < pMeter->numOfColumns; i++) { + if (pTable->tableType == TSDB_TABLE_TYPE_NORMAL_TABLE || pTable->tableType == TSDB_TABLE_TYPE_SUPER_TABLE) { + schema = (SSchema *)pTable->schema; + for (int32_t i = 0; i < pTable->numOfColumns; i++) { if (strcasecmp(schema[i].name, colName) == 0) { return i; } } - } else if (pMeter->meterType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE) { - pMetric = mgmtGetTable(pMeter->pTagData); + } else if (pTable->tableType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE) { + pMetric = mgmtGetTable(pTable->pTagData); if (pMetric == NULL) { - mError("MTable not belongs to any metric, meter: %s", pMeter->meterId); + mError("MTable not belongs to any metric, meter: %s", pTable->meterId); return -1; } schema = (SSchema *)pMetric->schema; @@ -1682,20 +1682,20 @@ int32_t mgmtFindColumnIndex(STabObj *pMeter, const char *colName) { return -1; } -int32_t mgmtMeterAddColumn(STabObj *pMeter, SSchema schema[], int ncols) { +int32_t mgmtMeterAddColumn(STabObj *pTable, SSchema schema[], int ncols) { SAcctObj *pAcct = NULL; SDbObj * pDb = NULL; - if (pMeter == NULL || pMeter->meterType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE || pMeter->meterType == TSDB_TABLE_TYPE_STREAM_TABLE || ncols <= 0) + if (pTable == NULL || pTable->tableType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE || pTable->tableType == TSDB_TABLE_TYPE_STREAM_TABLE || ncols <= 0) return TSDB_CODE_APP_ERROR; // ASSUMPTION: no two tags are the same for (int i = 0; i < ncols; i++) - if (mgmtFindColumnIndex(pMeter, schema[i].name) > 0) return TSDB_CODE_APP_ERROR; + if (mgmtFindColumnIndex(pTable, schema[i].name) > 0) return TSDB_CODE_APP_ERROR; - pDb = mgmtGetDbByMeterId(pMeter->meterId); + pDb = mgmtGetDbByMeterId(pTable->meterId); if (pDb == NULL) { - mError("meter: %s not belongs to any database", pMeter->meterId); + mError("meter: %s not belongs to any database", pTable->meterId); return TSDB_CODE_APP_ERROR; } @@ -1705,33 +1705,33 @@ int32_t mgmtMeterAddColumn(STabObj *pMeter, SSchema schema[], int ncols) { return TSDB_CODE_APP_ERROR; } - pMeter->schema = realloc(pMeter->schema, pMeter->schemaSize + sizeof(SSchema) * ncols); + pTable->schema = realloc(pTable->schema, pTable->schemaSize + sizeof(SSchema) * ncols); - if (pMeter->meterType == TSDB_TABLE_TYPE_NORMAL_TABLE) { - memcpy(pMeter->schema + pMeter->schemaSize, schema, sizeof(SSchema) * ncols); - } else if (pMeter->meterType == TSDB_TABLE_TYPE_SUPER_TABLE) { - memmove(pMeter->schema + sizeof(SSchema) * (pMeter->numOfColumns + ncols), - pMeter->schema + sizeof(SSchema) * pMeter->numOfColumns, sizeof(SSchema) * pMeter->numOfTags); - memcpy(pMeter->schema + sizeof(SSchema) * pMeter->numOfColumns, schema, sizeof(SSchema) * ncols); + if (pTable->tableType == TSDB_TABLE_TYPE_NORMAL_TABLE) { + memcpy(pTable->schema + pTable->schemaSize, schema, sizeof(SSchema) * ncols); + } else if (pTable->tableType == TSDB_TABLE_TYPE_SUPER_TABLE) { + memmove(pTable->schema + sizeof(SSchema) * (pTable->numOfColumns + ncols), + pTable->schema + sizeof(SSchema) * pTable->numOfColumns, sizeof(SSchema) * pTable->numOfTags); + memcpy(pTable->schema + sizeof(SSchema) * pTable->numOfColumns, schema, sizeof(SSchema) * ncols); } - SSchema *tschema = (SSchema *)(pMeter->schema + sizeof(SSchema) * pMeter->numOfColumns); - for (int i = 0; i < ncols; i++) tschema[i].colId = pMeter->nextColId++; + SSchema *tschema = (SSchema *)(pTable->schema + sizeof(SSchema) * pTable->numOfColumns); + for (int i = 0; i < ncols; i++) tschema[i].colId = pTable->nextColId++; - pMeter->schemaSize += sizeof(SSchema) * ncols; - pMeter->numOfColumns += ncols; - pMeter->sversion++; - if (mgmtIsNormalTable(pMeter)) + pTable->schemaSize += sizeof(SSchema) * ncols; + pTable->numOfColumns += ncols; + pTable->sversion++; + if (mgmtIsNormalTable(pTable)) pAcct->acctInfo.numOfTimeSeries += ncols; else - pAcct->acctInfo.numOfTimeSeries += (ncols * pMeter->numOfMeters); - sdbUpdateRow(meterSdb, pMeter, 0, 1); + pAcct->acctInfo.numOfTimeSeries += (ncols * pTable->numOfMeters); + sdbUpdateRow(meterSdb, pTable, 0, 1); - if (pMeter->meterType == TSDB_TABLE_TYPE_SUPER_TABLE) { - for (STabObj *pObj = pMeter->pHead; pObj != NULL; pObj = pObj->next) { + if (pTable->tableType == TSDB_TABLE_TYPE_SUPER_TABLE) { + for (STabObj *pObj = pTable->pHead; pObj != NULL; pObj = pObj->next) { pObj->numOfColumns++; - pObj->nextColId = pMeter->nextColId; - pObj->sversion = pMeter->sversion; + pObj->nextColId = pTable->nextColId; + pObj->sversion = pTable->sversion; sdbUpdateRow(meterSdb, pObj, 0, 1); } } @@ -1739,19 +1739,19 @@ int32_t mgmtMeterAddColumn(STabObj *pMeter, SSchema schema[], int ncols) { return TSDB_CODE_SUCCESS; } -int32_t mgmtMeterDropColumnByName(STabObj *pMeter, const char *name) { +int32_t mgmtMeterDropColumnByName(STabObj *pTable, const char *name) { SAcctObj *pAcct = NULL; SDbObj * pDb = NULL; - if (pMeter == NULL || pMeter->meterType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE || pMeter->meterType == TSDB_TABLE_TYPE_STREAM_TABLE) + if (pTable == NULL || pTable->tableType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE || pTable->tableType == TSDB_TABLE_TYPE_STREAM_TABLE) return TSDB_CODE_APP_ERROR; - int32_t index = mgmtFindColumnIndex(pMeter, name); + int32_t index = mgmtFindColumnIndex(pTable, name); if (index < 0) return TSDB_CODE_APP_ERROR; - pDb = mgmtGetDbByMeterId(pMeter->meterId); + pDb = mgmtGetDbByMeterId(pTable->meterId); if (pDb == NULL) { - mError("meter: %s not belongs to any database", pMeter->meterId); + mError("meter: %s not belongs to any database", pTable->meterId); return TSDB_CODE_APP_ERROR; } @@ -1761,28 +1761,28 @@ int32_t mgmtMeterDropColumnByName(STabObj *pMeter, const char *name) { return TSDB_CODE_APP_ERROR; } - if (pMeter->meterType == TSDB_TABLE_TYPE_NORMAL_TABLE) { - memmove(pMeter->schema + sizeof(SSchema) * index, pMeter->schema + sizeof(SSchema) * (index + 1), - sizeof(SSchema) * (pMeter->numOfColumns - index - 1)); - } else if (pMeter->meterType == TSDB_TABLE_TYPE_SUPER_TABLE) { - memmove(pMeter->schema + sizeof(SSchema) * index, pMeter->schema + sizeof(SSchema) * (index + 1), - sizeof(SSchema) * (pMeter->numOfColumns + pMeter->numOfTags - index - 1)); + if (pTable->tableType == TSDB_TABLE_TYPE_NORMAL_TABLE) { + memmove(pTable->schema + sizeof(SSchema) * index, pTable->schema + sizeof(SSchema) * (index + 1), + sizeof(SSchema) * (pTable->numOfColumns - index - 1)); + } else if (pTable->tableType == TSDB_TABLE_TYPE_SUPER_TABLE) { + memmove(pTable->schema + sizeof(SSchema) * index, pTable->schema + sizeof(SSchema) * (index + 1), + sizeof(SSchema) * (pTable->numOfColumns + pTable->numOfTags - index - 1)); } - pMeter->schemaSize -= sizeof(SSchema); - pMeter->numOfColumns--; - if (mgmtIsNormalTable(pMeter)) + pTable->schemaSize -= sizeof(SSchema); + pTable->numOfColumns--; + if (mgmtIsNormalTable(pTable)) pAcct->acctInfo.numOfTimeSeries--; else - pAcct->acctInfo.numOfTimeSeries -= (pMeter->numOfMeters); + pAcct->acctInfo.numOfTimeSeries -= (pTable->numOfMeters); - pMeter->schema = realloc(pMeter->schema, pMeter->schemaSize); - pMeter->sversion++; - sdbUpdateRow(meterSdb, pMeter, 0, 1); + pTable->schema = realloc(pTable->schema, pTable->schemaSize); + pTable->sversion++; + sdbUpdateRow(meterSdb, pTable, 0, 1); - if (pMeter->meterType == TSDB_TABLE_TYPE_SUPER_TABLE) { - for (STabObj *pObj = pMeter->pHead; pObj != NULL; pObj = pObj->next) { + if (pTable->tableType == TSDB_TABLE_TYPE_SUPER_TABLE) { + for (STabObj *pObj = pTable->pHead; pObj != NULL; pObj = pObj->next) { pObj->numOfColumns--; - pObj->sversion = pMeter->sversion; + pObj->sversion = pTable->sversion; sdbUpdateRow(meterSdb, pObj, 0, 1); } } diff --git a/src/mnode/src/mgmtProfile.c b/src/mnode/src/mgmtProfile.c index e58d7f5a52d2c674c35eed018cb8333ae09fb54f..298767d2eae8b674141f5a529929bb338b01b60d 100644 --- a/src/mnode/src/mgmtProfile.c +++ b/src/mnode/src/mgmtProfile.c @@ -24,7 +24,7 @@ typedef struct { uint32_t ip; uint16_t port; - char user[TSDB_METER_ID_LEN]; + char user[TSDB_TABLE_ID_LEN]; } SCDesc; typedef struct { diff --git a/src/mnode/src/mgmtShell.c b/src/mnode/src/mgmtShell.c index 7773d1944fda6b4609dcceb2d55146c42736cf45..7867422301f1ad4ad9901f8163311e898dca7165 100644 --- a/src/mnode/src/mgmtShell.c +++ b/src/mnode/src/mgmtShell.c @@ -118,7 +118,7 @@ static void mgmtSetSchemaFromMeters(SSchema *pSchema, STabObj *pMeterObj, uint32 static uint32_t mgmtSetMeterTagValue(char *pTags, STabObj *pMetric, STabObj *pMeterObj) { SSchema *pTagSchema = (SSchema *)(pMetric->schema + pMetric->numOfColumns * sizeof(SSchema)); - char *tagVal = pMeterObj->pTagData + TSDB_METER_ID_LEN; // tag start position + char *tagVal = pMeterObj->pTagData + TSDB_TABLE_ID_LEN; // tag start position uint32_t tagsLen = 0; for (int32_t i = 0; i < pMetric->numOfTags; ++i) { @@ -224,8 +224,8 @@ int mgmtProcessMeterMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) { int32_t code = mgmtCreateMeter(pDb, pCreateMsg); - char stableName[TSDB_METER_ID_LEN] = {0}; - strncpy(stableName, pInfo->tags, TSDB_METER_ID_LEN); + char stableName[TSDB_TABLE_ID_LEN] = {0}; + strncpy(stableName, pInfo->tags, TSDB_TABLE_ID_LEN); mTrace("meter:%s is automatically created by %s from %s, code:%d", pCreateMsg->meterId, pConn->pUser->user, stableName, code); @@ -274,7 +274,7 @@ int mgmtProcessMeterMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) { pMeta->numOfTags = pMeterObj->numOfTags; pMeta->numOfColumns = htons(pMeterObj->numOfColumns); - pMeta->meterType = pMeterObj->meterType; + pMeta->tableType = pMeterObj->tableType; pMsg += sizeof(SMeterMeta); pSchema = (SSchema *)pMsg; // schema locates at the end of SMeterMeta struct @@ -361,7 +361,7 @@ int mgmtProcessMultiMeterMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) { } int32_t totalNum = 0; - char tblName[TSDB_METER_ID_LEN]; + char tblName[TSDB_TABLE_ID_LEN]; char* nextStr; char* pCurMeter = pStart + sizeof(STaosRsp) + sizeof(SMultiMeterInfoMsg) + 1; // 1: ie type byte @@ -414,7 +414,7 @@ int mgmtProcessMultiMeterMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) { pMeta->meta.precision = pDbObj->cfg.precision; pMeta->meta.numOfTags = pMeterObj->numOfTags; pMeta->meta.numOfColumns = htons(pMeterObj->numOfColumns); - pMeta->meta.meterType = pMeterObj->meterType; + pMeta->meta.tableType = pMeterObj->tableType; pCurMeter += sizeof(SMultiMeterMeta); pSchema = (SSchema *)pCurMeter; // schema locates at the end of SMeterMeta struct @@ -494,21 +494,21 @@ _exit_code: } int mgmtProcessMetricMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) { - SMetricMetaMsg *pMetricMetaMsg = (SMetricMetaMsg *)pMsg; + SSuperTableMetaMsg *pSuperTableMetaMsg = (SSuperTableMetaMsg *)pMsg; STabObj * pMetric; STaosRsp * pRsp; char * pStart; - pMetricMetaMsg->numOfMeters = htonl(pMetricMetaMsg->numOfMeters); + pSuperTableMetaMsg->numOfMeters = htonl(pSuperTableMetaMsg->numOfMeters); - pMetricMetaMsg->join = htonl(pMetricMetaMsg->join); - pMetricMetaMsg->joinCondLen = htonl(pMetricMetaMsg->joinCondLen); + pSuperTableMetaMsg->join = htonl(pSuperTableMetaMsg->join); + pSuperTableMetaMsg->joinCondLen = htonl(pSuperTableMetaMsg->joinCondLen); - for (int32_t i = 0; i < pMetricMetaMsg->numOfMeters; ++i) { - pMetricMetaMsg->metaElem[i] = htonl(pMetricMetaMsg->metaElem[i]); + for (int32_t i = 0; i < pSuperTableMetaMsg->numOfMeters; ++i) { + pSuperTableMetaMsg->metaElem[i] = htonl(pSuperTableMetaMsg->metaElem[i]); } - SMetricMetaElemMsg *pElem = (SMetricMetaElemMsg *)(((char *)pMetricMetaMsg) + pMetricMetaMsg->metaElem[0]); + SMetricMetaElemMsg *pElem = (SMetricMetaElemMsg *)(((char *)pSuperTableMetaMsg) + pSuperTableMetaMsg->metaElem[0]); pMetric = mgmtGetTable(pElem->meterId); SDbObj *pDb = NULL; @@ -531,7 +531,7 @@ int mgmtProcessMetricMetaMsg(char *pMsg, int msgLen, SConnObj *pConn) { msgLen = pMsg - pStart; } else { - msgLen = mgmtRetrieveMetricMeta(pConn, &pStart, pMetricMetaMsg); + msgLen = mgmtRetrieveMetricMeta(pConn, &pStart, pSuperTableMetaMsg); if (msgLen <= 0) { taosSendSimpleRsp(pConn->thandle, TSDB_MSG_TYPE_METRIC_META_RSP, TSDB_CODE_SERV_OUT_OF_MEMORY); return 0; @@ -1076,11 +1076,11 @@ int mgmtProcessCreateTableMsg(char *pMsg, int msgLen, SConnObj *pConn) { } else if (code != TSDB_CODE_SUCCESS) { if (code == TSDB_CODE_TABLE_ALREADY_EXIST) { // table already created when the second attempt to create table - STabObj* pMeter = mgmtGetTable(pCreate->meterId); - assert(pMeter != NULL); + STabObj* pTable = mgmtGetTable(pCreate->meterId); + assert(pTable != NULL); mWarn("table:%s, table already created, failed to create table, ts:%" PRId64 ", code:%d", pCreate->meterId, - pMeter->createdTime, code); + pTable->createdTime, code); } else { // other errors mError("table:%s, failed to create table, code:%d", pCreate->meterId, code); } diff --git a/src/mnode/src/mgmtSupertableQuery.c b/src/mnode/src/mgmtSupertableQuery.c index dfc0d36b770a093c2b96f41a756ef87e048e3d3e..022251ab57b14c107d5497afd5f783f810b3cba9 100644 --- a/src/mnode/src/mgmtSupertableQuery.c +++ b/src/mnode/src/mgmtSupertableQuery.c @@ -23,6 +23,12 @@ #include "tsqlfunction.h" #include "vnodeTagMgmt.h" +typedef struct SSyntaxTreeFilterSupporter { + SSchema* pTagSchema; + int32_t numOfTags; + int32_t optr; +} SSyntaxTreeFilterSupporter; + typedef struct SJoinSupporter { void** val; void** pTabObjs; @@ -41,6 +47,7 @@ typedef struct SMeterNameFilterSupporter { } SMeterNameFilterSupporter; static void tansformQueryResult(tQueryResultset* pRes); +static bool tSkipListNodeFilterCallback(const void *pNode, void *param); static int32_t tabObjVGIDComparator(const void* pLeft, const void* pRight) { STabObj* p1 = *(STabObj**)pLeft; @@ -82,7 +89,7 @@ static int32_t tabObjResultComparator(const void* p1, const void* p2, void* para f1 = pNode1->meterId; f2 = pNode2->meterId; schema.type = TSDB_DATA_TYPE_BINARY; - schema.bytes = TSDB_METER_ID_LEN; + schema.bytes = TSDB_TABLE_ID_LEN; } else { f1 = mgmtTableGetTag(pNode1, colIdx, NULL); f2 = mgmtTableGetTag(pNode2, colIdx, &schema); @@ -104,15 +111,15 @@ static int32_t tabObjResultComparator(const void* p1, const void* p2, void* para * update the tag order index according to the tags column index. The tags column index needs to be checked one-by-one, * since the normal columns may be passed to server for handling the group by on status column. * - * @param pMetricMetaMsg + * @param pSuperTableMetaMsg * @param tableIndex * @param pOrderIndexInfo * @param numOfTags */ -static void mgmtUpdateOrderTagColIndex(SMetricMetaMsg* pMetricMetaMsg, int32_t tableIndex, tOrderIdx* pOrderIndexInfo, +static void mgmtUpdateOrderTagColIndex(SSuperTableMetaMsg* pSuperTableMetaMsg, int32_t tableIndex, tOrderIdx* pOrderIndexInfo, int32_t numOfTags) { - SMetricMetaElemMsg* pElem = (SMetricMetaElemMsg*)((char*)pMetricMetaMsg + pMetricMetaMsg->metaElem[tableIndex]); - SColIndexEx* groupColumnList = (SColIndexEx*)((char*)pMetricMetaMsg + pElem->groupbyTagColumnList); + SMetricMetaElemMsg* pElem = (SMetricMetaElemMsg*)((char*)pSuperTableMetaMsg + pSuperTableMetaMsg->metaElem[tableIndex]); + SColIndexEx* groupColumnList = (SColIndexEx*)((char*)pSuperTableMetaMsg + pElem->groupbyTagColumnList); int32_t numOfGroupbyTags = 0; for (int32_t i = 0; i < pElem->numOfGroupCols; ++i) { @@ -127,12 +134,12 @@ static void mgmtUpdateOrderTagColIndex(SMetricMetaMsg* pMetricMetaMsg, int32_t t } // todo merge sort function with losertree used -void mgmtReorganizeMetersInMetricMeta(SMetricMetaMsg* pMetricMetaMsg, int32_t tableIndex, tQueryResultset* pRes) { +void mgmtReorganizeMetersInMetricMeta(SSuperTableMetaMsg* pSuperTableMetaMsg, int32_t tableIndex, tQueryResultset* pRes) { if (pRes->num <= 0) { // no result, no need to pagination return; } - SMetricMetaElemMsg* pElem = (SMetricMetaElemMsg*)((char*)pMetricMetaMsg + pMetricMetaMsg->metaElem[tableIndex]); + SMetricMetaElemMsg* pElem = (SMetricMetaElemMsg*)((char*)pSuperTableMetaMsg + pSuperTableMetaMsg->metaElem[tableIndex]); STabObj* pMetric = mgmtGetTable(pElem->meterId); SSchema* pTagSchema = (SSchema*)(pMetric->schema + pMetric->numOfColumns * sizeof(SSchema)); @@ -149,7 +156,7 @@ void mgmtReorganizeMetersInMetricMeta(SMetricMetaMsg* pMetricMetaMsg, int32_t ta int32_t* startPos = NULL; int32_t numOfSubset = 1; - mgmtUpdateOrderTagColIndex(pMetricMetaMsg, tableIndex, &descriptor->orderIdx, pMetric->numOfTags); + mgmtUpdateOrderTagColIndex(pSuperTableMetaMsg, tableIndex, &descriptor->orderIdx, pMetric->numOfTags); if (descriptor->orderIdx.numOfOrderedCols > 0) { tQSortEx(pRes->pRes, POINTER_BYTES, 0, pRes->num - 1, descriptor, tabObjResultComparator); startPos = calculateSubGroup(pRes->pRes, pRes->num, &numOfSubset, descriptor, tabObjResultComparator); @@ -193,7 +200,7 @@ static void mgmtRetrieveByMeterName(tQueryResultset* pRes, char* str, STabObj* p } /* not a table created from metric, ignore */ - if (pMeterObj->meterType != TSDB_TABLE_TYPE_CREATE_FROM_STABLE) { + if (pMeterObj->tableType != TSDB_TABLE_TYPE_CREATE_FROM_STABLE) { continue; } @@ -202,7 +209,7 @@ static void mgmtRetrieveByMeterName(tQueryResultset* pRes, char* str, STabObj* p * uid, so compare according to meterid */ STabObj* parentMetric = mgmtGetTable(pMeterObj->pTagData); - if (strncasecmp(parentMetric->meterId, pMetric->meterId, TSDB_METER_ID_LEN) != 0 || + if (strncasecmp(parentMetric->meterId, pMetric->meterId, TSDB_TABLE_ID_LEN) != 0 || (parentMetric->uid != pMetric->uid)) { continue; } @@ -214,13 +221,13 @@ static void mgmtRetrieveByMeterName(tQueryResultset* pRes, char* str, STabObj* p static bool mgmtTablenameFilterCallback(tSkipListNode* pNode, void* param) { SMeterNameFilterSupporter* pSupporter = (SMeterNameFilterSupporter*)param; - char name[TSDB_METER_ID_LEN] = {0}; + char name[TSDB_TABLE_ID_LEN] = {0}; // pattern compare for meter name STabObj* pMeterObj = (STabObj*)pNode->pData; extractTableName(pMeterObj->meterId, name); - return patternMatch(pSupporter->pattern, name, TSDB_METER_ID_LEN, &pSupporter->info) == TSDB_PATTERN_MATCH; + return patternMatch(pSupporter->pattern, name, TSDB_TABLE_ID_LEN, &pSupporter->info) == TSDB_PATTERN_MATCH; } static void mgmtRetrieveFromLikeOptr(tQueryResultset* pRes, const char* str, STabObj* pMetric) { @@ -282,8 +289,8 @@ UNUSED_FUNC static bool mgmtJoinFilterCallback(tSkipListNode* pNode, void* param return false; } -static void orderResult(SMetricMetaMsg* pMetricMetaMsg, tQueryResultset* pRes, int16_t colIndex, int32_t tableIndex) { - SMetricMetaElemMsg* pElem = (SMetricMetaElemMsg*)((char*)pMetricMetaMsg + pMetricMetaMsg->metaElem[tableIndex]); +static void orderResult(SSuperTableMetaMsg* pSuperTableMetaMsg, tQueryResultset* pRes, int16_t colIndex, int32_t tableIndex) { + SMetricMetaElemMsg* pElem = (SMetricMetaElemMsg*)((char*)pSuperTableMetaMsg + pSuperTableMetaMsg->metaElem[tableIndex]); tOrderDescriptor* descriptor = (tOrderDescriptor*)calloc(1, sizeof(tOrderDescriptor) + sizeof(int32_t) * 1); // only one column for join @@ -322,13 +329,13 @@ static int32_t mgmtCheckForDuplicateTagValue(tQueryResultset* pRes, int32_t inde return TSDB_CODE_SUCCESS; } -int32_t mgmtDoJoin(SMetricMetaMsg* pMetricMetaMsg, tQueryResultset* pRes) { - if (pMetricMetaMsg->numOfMeters == 1) { +int32_t mgmtDoJoin(SSuperTableMetaMsg* pSuperTableMetaMsg, tQueryResultset* pRes) { + if (pSuperTableMetaMsg->numOfMeters == 1) { return TSDB_CODE_SUCCESS; } bool allEmpty = false; - for (int32_t i = 0; i < pMetricMetaMsg->numOfMeters; ++i) { + for (int32_t i = 0; i < pSuperTableMetaMsg->numOfMeters; ++i) { if (pRes[i].num == 0) { // all results are empty if one of them is empty allEmpty = true; break; @@ -336,7 +343,7 @@ int32_t mgmtDoJoin(SMetricMetaMsg* pMetricMetaMsg, tQueryResultset* pRes) { } if (allEmpty) { - for (int32_t i = 0; i < pMetricMetaMsg->numOfMeters; ++i) { + for (int32_t i = 0; i < pSuperTableMetaMsg->numOfMeters; ++i) { pRes[i].num = 0; tfree(pRes[i].pRes); } @@ -344,15 +351,15 @@ int32_t mgmtDoJoin(SMetricMetaMsg* pMetricMetaMsg, tQueryResultset* pRes) { return TSDB_CODE_SUCCESS; } - char* cond = (char*)pMetricMetaMsg + pMetricMetaMsg->join; + char* cond = (char*)pSuperTableMetaMsg + pSuperTableMetaMsg->join; - char left[TSDB_METER_ID_LEN + 1] = {0}; + char left[TSDB_TABLE_ID_LEN + 1] = {0}; strcpy(left, cond); - int16_t leftTagColIndex = *(int16_t*)(cond + TSDB_METER_ID_LEN); + int16_t leftTagColIndex = *(int16_t*)(cond + TSDB_TABLE_ID_LEN); - char right[TSDB_METER_ID_LEN + 1] = {0}; - strcpy(right, cond + TSDB_METER_ID_LEN + sizeof(int16_t)); - int16_t rightTagColIndex = *(int16_t*)(cond + TSDB_METER_ID_LEN * 2 + sizeof(int16_t)); + char right[TSDB_TABLE_ID_LEN + 1] = {0}; + strcpy(right, cond + TSDB_TABLE_ID_LEN + sizeof(int16_t)); + int16_t rightTagColIndex = *(int16_t*)(cond + TSDB_TABLE_ID_LEN * 2 + sizeof(int16_t)); STabObj* pLeftMetric = mgmtGetTable(left); STabObj* pRightMetric = mgmtGetTable(right); @@ -361,7 +368,7 @@ int32_t mgmtDoJoin(SMetricMetaMsg* pMetricMetaMsg, tQueryResultset* pRes) { int32_t leftIndex = 0; int32_t rightIndex = 0; - for (int32_t i = 0; i < pMetricMetaMsg->numOfMeters; ++i) { + for (int32_t i = 0; i < pSuperTableMetaMsg->numOfMeters; ++i) { STabObj* pObj = (STabObj*)pRes[i].pRes[0]; STabObj* pMetric1 = mgmtGetTable(pObj->pTagData); if (pMetric1 == pLeftMetric) { @@ -371,8 +378,8 @@ int32_t mgmtDoJoin(SMetricMetaMsg* pMetricMetaMsg, tQueryResultset* pRes) { } } - orderResult(pMetricMetaMsg, &pRes[leftIndex], leftTagColIndex, leftIndex); - orderResult(pMetricMetaMsg, &pRes[rightIndex], rightTagColIndex, rightIndex); + orderResult(pSuperTableMetaMsg, &pRes[leftIndex], leftTagColIndex, leftIndex); + orderResult(pSuperTableMetaMsg, &pRes[rightIndex], rightTagColIndex, rightIndex); int32_t i = 0; int32_t j = 0; @@ -727,7 +734,7 @@ static int32_t mgmtFilterMeterByIndex(STabObj* pMetric, tQueryResultset* pRes, c return TSDB_CODE_SUCCESS; } -int mgmtRetrieveMetersFromMetric(SMetricMetaMsg* pMsg, int32_t tableIndex, tQueryResultset* pRes) { +int32_t mgmtRetrieveMetersFromSuperTable(SSuperTableMetaMsg* pMsg, int32_t tableIndex, tQueryResultset* pRes) { SMetricMetaElemMsg* pElem = (SMetricMetaElemMsg*)((char*)pMsg + pMsg->metaElem[tableIndex]); STabObj* pMetric = mgmtGetTable(pElem->meterId); char* pCond = NULL; @@ -806,11 +813,11 @@ int mgmtRetrieveMetersFromMetric(SMetricMetaMsg* pMsg, int32_t tableIndex, tQuer } // todo refactor!!!!! -static char* getTagValueFromMeter(STabObj* pMeter, int32_t offset, int32_t len, char* param) { +static char* getTagValueFromMeter(STabObj* pTable, int32_t offset, int32_t len, char* param) { if (offset == TSDB_TBNAME_COLUMN_INDEX) { - extractTableName(pMeter->meterId, param); + extractTableName(pTable->meterId, param); } else { - char* tags = pMeter->pTagData + offset + TSDB_METER_ID_LEN; // tag start position + char* tags = pTable->pTagData + offset + TSDB_TABLE_ID_LEN; // tag start position memcpy(param, tags, len); // make sure the value is null-terminated string } @@ -820,11 +827,11 @@ static char* getTagValueFromMeter(STabObj* pMeter, int32_t offset, int32_t len, bool tSkipListNodeFilterCallback(const void* pNode, void* param) { tQueryInfo* pInfo = (tQueryInfo*)param; - STabObj* pMeter = (STabObj*)(((tSkipListNode*)pNode)->pData); + STabObj* pTable = (STabObj*)(((tSkipListNode*)pNode)->pData); char buf[TSDB_MAX_TAGS_LEN] = {0}; - char* val = getTagValueFromMeter(pMeter, pInfo->offset, pInfo->sch.bytes, buf); + char* val = getTagValueFromMeter(pTable, pInfo->offset, pInfo->sch.bytes, buf); int8_t type = pInfo->sch.type; int32_t ret = 0; diff --git a/src/mnode/src/mgmtUtil.c b/src/mnode/src/mgmtUtil.c index c1d0dcaaf74e60068ac06c5377d7c1b6672da080..99f57b9bae9aedf89b29e1efb4acc1ae506a0e38 100644 --- a/src/mnode/src/mgmtUtil.c +++ b/src/mnode/src/mgmtUtil.c @@ -15,19 +15,16 @@ #define _DEFAULT_SOURCE #include "os.h" - #include "mnode.h" #include "mgmtUtil.h" -#include "textbuffer.h" #include "tschemautil.h" -#include "tsqlfunction.h" bool mgmtTableCreateFromSuperTable(STabObj* pTableObj) { - return pTableObj->meterType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE; + return pTableObj->tableType == TSDB_TABLE_TYPE_CREATE_FROM_STABLE; } bool mgmtIsSuperTable(STabObj* pTableObj) { - return pTableObj->meterType == TSDB_TABLE_TYPE_SUPER_TABLE; + return pTableObj->tableType == TSDB_TABLE_TYPE_SUPER_TABLE; } bool mgmtIsNormalTable(STabObj* pTableObj) { @@ -37,7 +34,7 @@ bool mgmtIsNormalTable(STabObj* pTableObj) { /** * TODO: the tag offset value should be kept in memory to avoid dynamically calculating the value * - * @param pMeter + * @param pTable * @param col * @param pTagColSchema * @return @@ -48,7 +45,7 @@ char* mgmtTableGetTag(STabObj* pTable, int32_t col, SSchema* pTagColSchema) { } STabObj* pSuperTable = mgmtGetTable(pTable->pTagData); - int32_t offset = mgmtGetTagsLength(pSuperTable, col) + TSDB_METER_ID_LEN; + int32_t offset = mgmtGetTagsLength(pSuperTable, col) + TSDB_TABLE_ID_LEN; assert(offset > 0); if (pTagColSchema != NULL) { diff --git a/src/mnode/src/mgmtVgroup.c b/src/mnode/src/mgmtVgroup.c index 21baf9276a35a8d73fa3c90e503973c0ea79a5ed..4594da1a910bdfc1d7b35c954b0ac79abdcba05a 100644 --- a/src/mnode/src/mgmtVgroup.c +++ b/src/mnode/src/mgmtVgroup.c @@ -168,13 +168,13 @@ SVgObj *mgmtCreateVgroup(SDbObj *pDb) { } int mgmtDropVgroup(SDbObj *pDb, SVgObj *pVgroup) { - STabObj *pMeter; + STabObj *pTable; if (pVgroup->numOfMeters > 0) { for (int i = 0; i < pDb->cfg.maxSessions; ++i) { if (pVgroup->meterList != NULL) { - pMeter = pVgroup->meterList[i]; - if (pMeter) mgmtDropMeter(pDb, pMeter->meterId, 0); + pTable = pVgroup->meterList[i]; + if (pTable) mgmtDropMeter(pDb, pTable->meterId, 0); } } } @@ -239,14 +239,14 @@ int mgmtGetVgroupMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) { int maxReplica = 0; SVgObj *pVgroup = NULL; - STabObj *pMeter = NULL; + STabObj *pTable = NULL; if (pShow->payloadLen > 0 ) { - pMeter = mgmtGetTable(pShow->payload); - if (NULL == pMeter) { + pTable = mgmtGetTable(pShow->payload); + if (NULL == pTable) { return TSDB_CODE_INVALID_METER_ID; } - pVgroup = mgmtGetVgroup(pMeter->gid.vgId); + pVgroup = mgmtGetVgroup(pTable->gid.vgId); if (NULL == pVgroup) return TSDB_CODE_INVALID_METER_ID; maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica; @@ -292,7 +292,7 @@ int mgmtGetVgroupMeta(SMeterMeta *pMeta, SShowObj *pShow, SConnObj *pConn) { pShow->rowSize = pShow->offset[cols - 1] + pShow->bytes[cols - 1]; - if (NULL == pMeter) { + if (NULL == pTable) { pShow->numOfRows = pDb->numOfVgroups; pShow->pNode = pDb->pHead; } else { diff --git a/src/modules/monitor/src/monitorSystem.c b/src/modules/monitor/src/monitorSystem.c index 133e826aa035027dfc0a428676c396438cc3790c..649b1a3baae8f78b183fb29a41026105065f0b69 100644 --- a/src/modules/monitor/src/monitorSystem.c +++ b/src/modules/monitor/src/monitorSystem.c @@ -188,7 +188,7 @@ void dnodeBuildMonitorSql(char *sql, int cmd) { snprintf(sql, SQL_LENGTH, "create table if not exists %s.slowquery(ts timestamp, username " "binary(%d), created_time timestamp, time bigint, sql binary(%d))", - tsMonitorDbName, TSDB_METER_ID_LEN, TSDB_SHOW_SQL_LEN); + tsMonitorDbName, TSDB_TABLE_ID_LEN, TSDB_SHOW_SQL_LEN); } else if (cmd == MONITOR_CMD_CREATE_TB_LOG) { snprintf(sql, SQL_LENGTH, "create table if not exists %s.log(ts timestamp, level tinyint, " diff --git a/src/rpc/src/trpc.c b/src/rpc/src/trpc.c index 9e0b5dab0f1f2ca587af3dd9f3233b355d1d80af..2bd800cad7a9fee92b45e2d7e7f56d87bb40afa0 100755 --- a/src/rpc/src/trpc.c +++ b/src/rpc/src/trpc.c @@ -722,7 +722,7 @@ int taosSetSecurityInfo(int chann, int sid, char *id, int spi, int encrypt, char pConn->encrypt = encrypt; memcpy(pConn->secret, pConn->secret, TSDB_KEY_LEN); memcpy(pConn->cipheringKey, ckey, TSDB_KEY_LEN); - memcpy(pConn->meterId, id, TSDB_METER_ID_LEN); + memcpy(pConn->meterId, id, TSDB_TABLE_ID_LEN); */ return -1; } diff --git a/src/sdb/src/hashstr.c b/src/sdb/src/hashstr.c index 4b9aa3392853424618e574b03a50b17a51f2b320..c34d61f1deed689bd77fbc10453da92072d50234 100644 --- a/src/sdb/src/hashstr.c +++ b/src/sdb/src/hashstr.c @@ -19,7 +19,7 @@ #define MAX_STR_LEN 40 typedef struct _str_node_t { - char string[TSDB_METER_ID_LEN]; + char string[TSDB_TABLE_ID_LEN]; int hash; struct _str_node_t *prev; struct _str_node_t *next; diff --git a/src/vnode/detail/inc/vnode.h b/src/vnode/detail/inc/vnode.h index b7d2dcbf0926ebed346b81b8f5599895a40f8148..13831d17bdfd2ebbc376f11a6f747ae380600a2d 100644 --- a/src/vnode/detail/inc/vnode.h +++ b/src/vnode/detail/inc/vnode.h @@ -158,7 +158,7 @@ typedef struct SColumn { typedef struct _meter_obj { uint64_t uid; - char meterId[TSDB_METER_ID_LEN]; + char meterId[TSDB_TABLE_ID_LEN]; int sid; short vnode; short numOfColumns; diff --git a/src/vnode/detail/inc/vnodeRead.h b/src/vnode/detail/inc/vnodeRead.h index ee88e5e36681a2a9d22faa5f757fa3c4f1f57a59..c43c5172095929f1ff847b9293be975739077a20 100644 --- a/src/vnode/detail/inc/vnodeRead.h +++ b/src/vnode/detail/inc/vnodeRead.h @@ -253,7 +253,7 @@ typedef struct SMeterQuerySupportObj { typedef struct _qinfo { uint64_t signature; int32_t refCount; // QInfo reference count, when the value is 0, it can be released safely - char user[TSDB_METER_ID_LEN + 1]; + char user[TSDB_TABLE_ID_LEN + 1]; char sql[TSDB_SHOW_SQL_LEN]; uint8_t stream; uint16_t port; diff --git a/src/vnode/detail/src/vnodeFile.c b/src/vnode/detail/src/vnodeFile.c index 9c53d47507b18582333aa64abc9f39fb1cab5407..120b9ef1d1b225a2bb3a48c1a0eaad3409a96dd4 100644 --- a/src/vnode/detail/src/vnodeFile.c +++ b/src/vnode/detail/src/vnodeFile.c @@ -492,7 +492,7 @@ void *vnodeCommitMultiToFile(SVnodeObj *pVnode, int ssid, int esid) { SMeterObj * pObj = NULL; SCompInfo compInfo = {0}; SCompHeader * pHeader; - SMeterInfo * meterInfo = NULL, *pMeter = NULL; + SMeterInfo * meterInfo = NULL, *pTable = NULL; SQuery query; SColumnInfoEx colList[TSDB_MAX_COLUMNS] = {0}; SSqlFunctionExpr pExprs[TSDB_MAX_COLUMNS] = {0}; @@ -617,7 +617,7 @@ _again: continue; } - pMeter = meterInfo + sid; + pTable = meterInfo + sid; pHeader = ((SCompHeader *)tmem) + sid; if (pVnode->hfd > 0) { @@ -633,18 +633,18 @@ _again: goto _over; } else { if (pObj->uid == compInfo.uid) { - pMeter->oldNumOfBlocks = compInfo.numOfBlocks; - pMeter->oldCompBlockOffset = pHeader->compInfoOffset + sizeof(SCompInfo); - pMeter->last = compInfo.last; + pTable->oldNumOfBlocks = compInfo.numOfBlocks; + pTable->oldCompBlockOffset = pHeader->compInfoOffset + sizeof(SCompInfo); + pTable->last = compInfo.last; if (compInfo.numOfBlocks > maxOldBlocks) maxOldBlocks = compInfo.numOfBlocks; - if (pMeter->last) { + if (pTable->last) { lseek(pVnode->hfd, sizeof(SCompBlock) * (compInfo.numOfBlocks - 1), SEEK_CUR); - read(pVnode->hfd, &pMeter->lastBlock, sizeof(SCompBlock)); + read(pVnode->hfd, &pTable->lastBlock, sizeof(SCompBlock)); } } else { dTrace("vid:%d sid:%d id:%s, uid:%" PRIu64 " is not matched with old:%" PRIu64 ", old data will be thrown away", vnode, sid, pObj->meterId, pObj->uid, compInfo.uid); - pMeter->oldNumOfBlocks = 0; + pTable->oldNumOfBlocks = 0; } } } else { @@ -669,8 +669,8 @@ _again: pObj->pointsPerFileBlock * pObj->schema[col - 1].bytes + EXTRA_BYTES + sizeof(TSCKSUM)); } - pMeter = meterInfo + sid; - pMeter->tempHeadOffset = headLen; + pTable = meterInfo + sid; + pTable->tempHeadOffset = headLen; memset(&query, 0, sizeof(query)); query.colList = colList; @@ -690,27 +690,27 @@ _again: pointsReadLast = 0; // last block is at last file - if (pMeter->last) { - if ((pMeter->lastBlock.sversion != pObj->sversion) || (query.over)) { + if (pTable->last) { + if ((pTable->lastBlock.sversion != pObj->sversion) || (query.over)) { // TODO : Check the correctness of this code. write the last block to // .data file pCompBlock = (SCompBlock *)(hmem + headLen); assert(dmem - (char *)pCompBlock >= sizeof(SCompBlock)); - *pCompBlock = pMeter->lastBlock; - if (pMeter->lastBlock.sversion != pObj->sversion) { + *pCompBlock = pTable->lastBlock; + if (pTable->lastBlock.sversion != pObj->sversion) { pCompBlock->last = 0; pCompBlock->offset = lseek(pVnode->dfd, 0, SEEK_END); - pMeter->last = 0; - lseek(pVnode->lfd, pMeter->lastBlock.offset, SEEK_SET); - tsendfile(pVnode->dfd, pVnode->lfd, NULL, pMeter->lastBlock.len); - pVnode->dfSize = pCompBlock->offset + pMeter->lastBlock.len; + pTable->last = 0; + lseek(pVnode->lfd, pTable->lastBlock.offset, SEEK_SET); + tsendfile(pVnode->dfd, pVnode->lfd, NULL, pTable->lastBlock.len); + pVnode->dfSize = pCompBlock->offset + pTable->lastBlock.len; } else { if (ssid == 0) { assert(pCompBlock->last && pVnode->tfd != -1); pCompBlock->offset = lseek(pVnode->tfd, 0, SEEK_END); - lseek(pVnode->lfd, pMeter->lastBlock.offset, SEEK_SET); - tsendfile(pVnode->tfd, pVnode->lfd, NULL, pMeter->lastBlock.len); - pVnode->lfSize = pCompBlock->offset + pMeter->lastBlock.len; + lseek(pVnode->lfd, pTable->lastBlock.offset, SEEK_SET); + tsendfile(pVnode->tfd, pVnode->lfd, NULL, pTable->lastBlock.len); + pVnode->lfSize = pCompBlock->offset + pTable->lastBlock.len; } else { assert(pVnode->tfd == -1); } @@ -718,12 +718,12 @@ _again: } headLen += sizeof(SCompBlock); - pMeter->newNumOfBlocks++; + pTable->newNumOfBlocks++; } else { // read last block into memory - if (vnodeReadLastBlockToMem(pObj, &pMeter->lastBlock, data) < 0) goto _over; - pMeter->last = 0; - pointsReadLast = pMeter->lastBlock.numOfPoints; + if (vnodeReadLastBlockToMem(pObj, &pTable->lastBlock, data) < 0) goto _over; + pTable->last = 0; + pointsReadLast = pTable->lastBlock.numOfPoints; query.over = 0; headInfo.totalStorage -= (pointsReadLast * pObj->bytesPerPoint); @@ -731,8 +731,8 @@ _again: pObj->vnode, pObj->sid, pObj->meterId, pointsReadLast); } - pMeter->changed = 1; - pMeter->oldNumOfBlocks--; + pTable->changed = 1; + pTable->oldNumOfBlocks--; } while (query.over == 0) { @@ -753,17 +753,17 @@ _again: pCompBlock->last = 1; if (vnodeWriteBlockToFile(pObj, pCompBlock, data, cdata, pointsRead) < 0) goto _over; if (pCompBlock->keyLast > pObj->lastKeyOnFile) pObj->lastKeyOnFile = pCompBlock->keyLast; - pMeter->last = pCompBlock->last; + pTable->last = pCompBlock->last; // write block info into header buffer headLen += sizeof(SCompBlock); - pMeter->newNumOfBlocks++; - pMeter->committedPoints += (pointsRead - pointsReadLast); + pTable->newNumOfBlocks++; + pTable->committedPoints += (pointsRead - pointsReadLast); dTrace("vid:%d sid:%d id:%s, pointsRead:%d, pointsReadLast:%d lastKey:%" PRId64 ", " "slot:%d pos:%d newNumOfBlocks:%d headLen:%d", pObj->vnode, pObj->sid, pObj->meterId, pointsRead, pointsReadLast, pObj->lastKeyOnFile, query.slot, query.pos, - pMeter->newNumOfBlocks, headLen); + pTable->newNumOfBlocks, headLen); if (pointsRead < pObj->pointsPerFileBlock || query.keyIsMet) break; @@ -772,12 +772,12 @@ _again: } dTrace("vid:%d sid:%d id:%s, %d points are committed, lastKey:%" PRId64 " slot:%d pos:%d newNumOfBlocks:%d", - pObj->vnode, pObj->sid, pObj->meterId, pMeter->committedPoints, pObj->lastKeyOnFile, query.slot, query.pos, - pMeter->newNumOfBlocks); + pObj->vnode, pObj->sid, pObj->meterId, pTable->committedPoints, pObj->lastKeyOnFile, query.slot, query.pos, + pTable->newNumOfBlocks); - if (pMeter->committedPoints > 0) { - pMeter->commitSlot = query.slot; - pMeter->commitPos = query.pos; + if (pTable->committedPoints > 0) { + pTable->commitSlot = query.slot; + pTable->commitPos = query.pos; } TSKEY nextKey = 0; @@ -805,19 +805,19 @@ _again: continue; } - pMeter = meterInfo + sid; - pMeter->compInfoOffset = compInfoOffset; - pMeter->finalNumOfBlocks = pMeter->oldNumOfBlocks + pMeter->newNumOfBlocks; + pTable = meterInfo + sid; + pTable->compInfoOffset = compInfoOffset; + pTable->finalNumOfBlocks = pTable->oldNumOfBlocks + pTable->newNumOfBlocks; - if (pMeter->finalNumOfBlocks > 0) { - pHeader->compInfoOffset = pMeter->compInfoOffset; - compInfoOffset += sizeof(SCompInfo) + pMeter->finalNumOfBlocks * sizeof(SCompBlock) + sizeof(TSCKSUM); + if (pTable->finalNumOfBlocks > 0) { + pHeader->compInfoOffset = pTable->compInfoOffset; + compInfoOffset += sizeof(SCompInfo) + pTable->finalNumOfBlocks * sizeof(SCompBlock) + sizeof(TSCKSUM); } else { pHeader->compInfoOffset = 0; } dTrace("vid:%d sid:%d id:%s, oldBlocks:%d numOfBlocks:%d compInfoOffset:%d", pObj->vnode, pObj->sid, pObj->meterId, - pMeter->oldNumOfBlocks, pMeter->finalNumOfBlocks, compInfoOffset); + pTable->oldNumOfBlocks, pTable->finalNumOfBlocks, compInfoOffset); } // write the comp header into new file @@ -838,16 +838,16 @@ _again: pObj = (SMeterObj *)(pVnode->meterList[sid]); if (pObj == NULL) continue; - pMeter = meterInfo + sid; - if (pMeter->finalNumOfBlocks <= 0) continue; + pTable = meterInfo + sid; + if (pTable->finalNumOfBlocks <= 0) continue; - compInfo.last = pMeter->last; + compInfo.last = pTable->last; compInfo.uid = pObj->uid; - compInfo.numOfBlocks = pMeter->finalNumOfBlocks; - /* compInfo.compBlockLen = pMeter->finalCompBlockLen; */ + compInfo.numOfBlocks = pTable->finalNumOfBlocks; + /* compInfo.compBlockLen = pTable->finalCompBlockLen; */ compInfo.delimiter = TSDB_VNODE_DELIMITER; taosCalcChecksumAppend(0, (uint8_t *)(&compInfo), sizeof(SCompInfo)); - lseek(pVnode->nfd, pMeter->compInfoOffset, SEEK_SET); + lseek(pVnode->nfd, pTable->compInfoOffset, SEEK_SET); if (twrite(pVnode->nfd, &compInfo, sizeof(compInfo)) <= 0) { dError("vid:%d sid:%d id:%s, failed to write:%s, reason:%s", vnode, sid, pObj->meterId, pVnode->nfn, strerror(errno)); @@ -857,23 +857,23 @@ _again: // write the old comp blocks chksum = 0; - if (pVnode->hfd && pMeter->oldNumOfBlocks) { - lseek(pVnode->hfd, pMeter->oldCompBlockOffset, SEEK_SET); - if (pMeter->changed) { - int compBlockLen = pMeter->oldNumOfBlocks * sizeof(SCompBlock); + if (pVnode->hfd && pTable->oldNumOfBlocks) { + lseek(pVnode->hfd, pTable->oldCompBlockOffset, SEEK_SET); + if (pTable->changed) { + int compBlockLen = pTable->oldNumOfBlocks * sizeof(SCompBlock); read(pVnode->hfd, pOldCompBlocks, compBlockLen); twrite(pVnode->nfd, pOldCompBlocks, compBlockLen); chksum = taosCalcChecksum(0, pOldCompBlocks, compBlockLen); } else { - tsendfile(pVnode->nfd, pVnode->hfd, NULL, pMeter->oldNumOfBlocks * sizeof(SCompBlock)); + tsendfile(pVnode->nfd, pVnode->hfd, NULL, pTable->oldNumOfBlocks * sizeof(SCompBlock)); read(pVnode->hfd, &chksum, sizeof(TSCKSUM)); } } - if (pMeter->newNumOfBlocks) { - chksum = taosCalcChecksum(chksum, (uint8_t *)(hmem + pMeter->tempHeadOffset), - pMeter->newNumOfBlocks * sizeof(SCompBlock)); - if (twrite(pVnode->nfd, hmem + pMeter->tempHeadOffset, pMeter->newNumOfBlocks * sizeof(SCompBlock)) <= 0) { + if (pTable->newNumOfBlocks) { + chksum = taosCalcChecksum(chksum, (uint8_t *)(hmem + pTable->tempHeadOffset), + pTable->newNumOfBlocks * sizeof(SCompBlock)); + if (twrite(pVnode->nfd, hmem + pTable->tempHeadOffset, pTable->newNumOfBlocks * sizeof(SCompBlock)) <= 0) { dError("vid:%d sid:%d id:%s, failed to write:%s, reason:%s", vnode, sid, pObj->meterId, pVnode->nfn, strerror(errno)); vnodeRecoverFromPeer(pVnode, pVnode->commitFileId); @@ -891,11 +891,11 @@ _again: pObj = (SMeterObj *)(pVnode->meterList[sid]); if (pObj == NULL) continue; - pMeter = meterInfo + sid; - if (pMeter->finalNumOfBlocks <= 0) continue; + pTable = meterInfo + sid; + if (pTable->finalNumOfBlocks <= 0) continue; - if (pMeter->committedPoints > 0) { - vnodeUpdateCommitInfo(pObj, pMeter->commitSlot, pMeter->commitPos, pMeter->commitCount); + if (pTable->committedPoints > 0) { + vnodeUpdateCommitInfo(pObj, pTable->commitSlot, pTable->commitPos, pTable->commitCount); } } diff --git a/src/vnode/detail/src/vnodeImport.c b/src/vnode/detail/src/vnodeImport.c index 7ebab90f0baed0b79936fced88c3a129cff6f170..9179a89ca70496623743538279b63c22b542f9dc 100644 --- a/src/vnode/detail/src/vnodeImport.c +++ b/src/vnode/detail/src/vnodeImport.c @@ -1236,12 +1236,12 @@ _error_merge: } \ } -int isCacheEnd(SBlockIter iter, SMeterObj *pMeter) { - SCacheInfo *pInfo = (SCacheInfo *)(pMeter->pCache); +int isCacheEnd(SBlockIter iter, SMeterObj *pTable) { + SCacheInfo *pInfo = (SCacheInfo *)(pTable->pCache); int slot = 0; int pos = 0; - if (pInfo->cacheBlocks[pInfo->currentSlot]->numOfPoints == pMeter->pointsPerBlock) { + if (pInfo->cacheBlocks[pInfo->currentSlot]->numOfPoints == pTable->pointsPerBlock) { slot = (pInfo->currentSlot + 1) % (pInfo->maxBlocks); pos = 0; } else { diff --git a/src/vnode/detail/src/vnodeQueryImpl.c b/src/vnode/detail/src/vnodeQueryImpl.c index 81fce50bd6f950c2f50fc60efb4ce251481855bb..8e1d595712ef853df30809ea2fe37af2278216ba 100644 --- a/src/vnode/detail/src/vnodeQueryImpl.c +++ b/src/vnode/detail/src/vnodeQueryImpl.c @@ -4506,7 +4506,7 @@ int32_t vnodeMultiMeterQueryPrepare(SQInfo *pQInfo, SQuery *pQuery, void *param) } // get one queried meter - SMeterObj *pMeter = getMeterObj(pSupporter->pMetersHashTable, pSupporter->pSidSet->pSids[0]->sid); + SMeterObj *pTable = getMeterObj(pSupporter->pMetersHashTable, pSupporter->pSidSet->pSids[0]->sid); pRuntimeEnv->pTSBuf = param; pRuntimeEnv->cur.vnodeIndex = -1; @@ -4517,18 +4517,18 @@ int32_t vnodeMultiMeterQueryPrepare(SQInfo *pQInfo, SQuery *pQuery, void *param) tsBufSetTraverseOrder(pRuntimeEnv->pTSBuf, order); } - int32_t ret = setupQueryRuntimeEnv(pMeter, pQuery, &pSupporter->runtimeEnv, pTagSchema, TSQL_SO_ASC, true); + int32_t ret = setupQueryRuntimeEnv(pTable, pQuery, &pSupporter->runtimeEnv, pTagSchema, TSQL_SO_ASC, true); if (ret != TSDB_CODE_SUCCESS) { return ret; } - ret = allocateRuntimeEnvBuf(pRuntimeEnv, pMeter); + ret = allocateRuntimeEnvBuf(pRuntimeEnv, pTable); if (ret != TSDB_CODE_SUCCESS) { return ret; } tSidSetSort(pSupporter->pSidSet); - vnodeRecordAllFiles(pQInfo, pMeter->vnode); + vnodeRecordAllFiles(pQInfo, pTable->vnode); if ((ret = allocateOutputBufForGroup(pSupporter, pQuery, true)) != TSDB_CODE_SUCCESS) { return ret; @@ -4595,12 +4595,12 @@ void vnodeDecMeterRefcnt(SQInfo *pQInfo) { } else { int32_t num = 0; for (int32_t i = 0; i < pSupporter->numOfMeters; ++i) { - SMeterObj *pMeter = getMeterObj(pSupporter->pMetersHashTable, pSupporter->pSidSet->pSids[i]->sid); - atomic_fetch_sub_32(&(pMeter->numOfQueries), 1); + SMeterObj *pTable = getMeterObj(pSupporter->pMetersHashTable, pSupporter->pSidSet->pSids[i]->sid); + atomic_fetch_sub_32(&(pTable->numOfQueries), 1); - if (pMeter->numOfQueries > 0) { - dTrace("QInfo:%p vid:%d sid:%d meterId:%s, query is over, numOfQueries:%d", pQInfo, pMeter->vnode, pMeter->sid, - pMeter->meterId, pMeter->numOfQueries); + if (pTable->numOfQueries > 0) { + dTrace("QInfo:%p vid:%d sid:%d meterId:%s, query is over, numOfQueries:%d", pQInfo, pTable->vnode, pTable->sid, + pTable->meterId, pTable->numOfQueries); num++; } } diff --git a/src/vnode/detail/src/vnodeStream.c b/src/vnode/detail/src/vnodeStream.c index 7ee20a2e59562f63903fb2ea13228070f14f0932..d3f1d0fdc1068db947b01a85bfa4f3d9dfebc0f3 100644 --- a/src/vnode/detail/src/vnodeStream.c +++ b/src/vnode/detail/src/vnodeStream.c @@ -186,15 +186,15 @@ void vnodeUpdateStreamRole(SVnodeObj *pVnode) { // Callback function called from client void vnodeCloseStreamCallback(void *param) { - SMeterObj *pMeter = (SMeterObj *)param; + SMeterObj *pTable = (SMeterObj *)param; SVnodeObj *pVnode = NULL; - if (pMeter == NULL || pMeter->sqlLen == 0) return; - pVnode = vnodeList + pMeter->vnode; + if (pTable == NULL || pTable->sqlLen == 0) return; + pVnode = vnodeList + pTable->vnode; - pMeter->sqlLen = 0; - pMeter->pSql = NULL; - pMeter->pStream = NULL; + pTable->sqlLen = 0; + pTable->pSql = NULL; + pTable->pStream = NULL; pVnode->numOfStreams--; @@ -203,5 +203,5 @@ void vnodeCloseStreamCallback(void *param) { pVnode->dbConn = NULL; } - vnodeSaveMeterObjToFile(pMeter); + vnodeSaveMeterObjToFile(pTable); } \ No newline at end of file diff --git a/src/vnode/detail/src/vnodeUtil.c b/src/vnode/detail/src/vnodeUtil.c index c9d7ca0cf42d099c3e30906992084841950c6ef1..8c90c10a29d30965be57a580384ccf1aa4f23c8b 100644 --- a/src/vnode/detail/src/vnodeUtil.c +++ b/src/vnode/detail/src/vnodeUtil.c @@ -527,7 +527,7 @@ bool vnodeIsProjectionQuery(SSqlFunctionExpr* pExpr, int32_t numOfOutput) { } /* - * the pMeter->state may be changed by vnodeIsSafeToDeleteMeter and import/update processor, the check of + * the pTable->state may be changed by vnodeIsSafeToDeleteMeter and import/update processor, the check of * the state will not always be correct. * * The import/update/deleting is actually blocked by current query processing if the check of meter state is @@ -548,30 +548,30 @@ int32_t vnodeIncQueryRefCount(SQueryMeterMsg* pQueryMsg, SMeterSidExtInfo** pSid int32_t code = TSDB_CODE_SUCCESS; for (int32_t i = 0; i < pQueryMsg->numOfSids; ++i) { - SMeterObj* pMeter = pVnode->meterList[pSids[i]->sid]; + SMeterObj* pTable = pVnode->meterList[pSids[i]->sid]; /* * If table is missing or is in dropping status, config it from management node, and ignore it * during query processing. The error code of TSDB_CODE_NOT_ACTIVE_TABLE will never return to client. * The missing table needs to be removed from pSids list */ - if (pMeter == NULL || vnodeIsMeterState(pMeter, TSDB_METER_STATE_DROPPING)) { + if (pTable == NULL || vnodeIsMeterState(pTable, TSDB_METER_STATE_DROPPING)) { dWarn("qmsg:%p, vid:%d sid:%d, not there or will be dropped, ignore this table in query", pQueryMsg, pQueryMsg->vnode, pSids[i]->sid); vnodeSendMeterCfgMsg(pQueryMsg->vnode, pSids[i]->sid); continue; - } else if (pMeter->uid != pSids[i]->uid || pMeter->sid != pSids[i]->sid) { + } else if (pTable->uid != pSids[i]->uid || pTable->sid != pSids[i]->sid) { code = TSDB_CODE_TABLE_ID_MISMATCH; dError("qmsg:%p, vid:%d sid:%d id:%s uid:%" PRIu64 ", id mismatch. sid:%d uid:%" PRId64 " in msg", pQueryMsg, - pQueryMsg->vnode, pMeter->sid, pMeter->meterId, pMeter->uid, pSids[i]->sid, pSids[i]->uid); + pQueryMsg->vnode, pTable->sid, pTable->meterId, pTable->uid, pSids[i]->sid, pSids[i]->uid); vnodeSendMeterCfgMsg(pQueryMsg->vnode, pSids[i]->sid); continue; - } else if (pMeter->state > TSDB_METER_STATE_INSERTING) { //update or import + } else if (pTable->state > TSDB_METER_STATE_INSERTING) { //update or import code = TSDB_CODE_ACTION_IN_PROGRESS; dTrace("qmsg:%p, vid:%d sid:%d id:%s, it is in state:%s, wait!", pQueryMsg, pQueryMsg->vnode, pSids[i]->sid, - pMeter->meterId, taosGetTableStatusStr(pMeter->state)); + pTable->meterId, taosGetTableStatusStr(pTable->state)); continue; } @@ -579,15 +579,15 @@ int32_t vnodeIncQueryRefCount(SQueryMeterMsg* pQueryMsg, SMeterSidExtInfo** pSid * vnodeIsSafeToDeleteMeter will wait for this function complete, and then it can * check if the numOfQueries is 0 or not. */ - pMeterObjList[(*numOfIncTables)++] = pMeter; - atomic_fetch_add_32(&pMeter->numOfQueries, 1); + pMeterObjList[(*numOfIncTables)++] = pTable; + atomic_fetch_add_32(&pTable->numOfQueries, 1); pSids[index++] = pSids[i]; // output for meter more than one query executed - if (pMeter->numOfQueries > 1) { - dTrace("qmsg:%p, vid:%d sid:%d id:%s, inc query ref, numOfQueries:%d", pQueryMsg, pMeter->vnode, pMeter->sid, - pMeter->meterId, pMeter->numOfQueries); + if (pTable->numOfQueries > 1) { + dTrace("qmsg:%p, vid:%d sid:%d id:%s, inc query ref, numOfQueries:%d", pQueryMsg, pTable->vnode, pTable->sid, + pTable->meterId, pTable->numOfQueries); num++; } } @@ -605,14 +605,14 @@ void vnodeDecQueryRefCount(SQueryMeterMsg* pQueryMsg, SMeterObj** pMeterObjList, int32_t num = 0; for (int32_t i = 0; i < numOfIncTables; ++i) { - SMeterObj* pMeter = pMeterObjList[i]; + SMeterObj* pTable = pMeterObjList[i]; - if (pMeter != NULL) { // here, do not need to lock to perform operations - atomic_fetch_sub_32(&pMeter->numOfQueries, 1); + if (pTable != NULL) { // here, do not need to lock to perform operations + atomic_fetch_sub_32(&pTable->numOfQueries, 1); - if (pMeter->numOfQueries > 0) { - dTrace("qmsg:%p, vid:%d sid:%d id:%s dec query ref, numOfQueries:%d", pQueryMsg, pMeter->vnode, pMeter->sid, - pMeter->meterId, pMeter->numOfQueries); + if (pTable->numOfQueries > 0) { + dTrace("qmsg:%p, vid:%d sid:%d id:%s dec query ref, numOfQueries:%d", pQueryMsg, pTable->vnode, pTable->sid, + pTable->meterId, pTable->numOfQueries); num++; } }