diff --git a/include/libs/executor/storageapi.h b/include/libs/executor/storageapi.h index 6721d72996..a2be706dc0 100644 --- a/include/libs/executor/storageapi.h +++ b/include/libs/executor/storageapi.h @@ -62,7 +62,7 @@ typedef struct SMetaEntry { struct { int64_t btime; int32_t ttlDays; - int32_t commentLen; + int32_t commentLen; // not include '\0' char* comment; tb_uid_t suid; uint8_t* pTags; diff --git a/include/util/tutil.h b/include/util/tutil.h index 01977e27b6..32fc9f215a 100644 --- a/include/util/tutil.h +++ b/include/util/tutil.h @@ -122,10 +122,10 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen, * only in very hot code paths. Misuse or abuse can lead to performance degradation. */ #if __GNUC__ >= 3 -#define LIKELY(x) __builtin_expect((x) != 0, 1) +#define LIKELY(x) __builtin_expect((x) != 0, 1) #define UNLIKELY(x) __builtin_expect((x) != 0, 0) #else -#define LIKELY(x) ((x) != 0) +#define LIKELY(x) ((x) != 0) #define UNLIKELY(x) ((x) != 0) #endif diff --git a/source/dnode/vnode/CMakeLists.txt b/source/dnode/vnode/CMakeLists.txt index c377e69f03..8f63cc8779 100644 --- a/source/dnode/vnode/CMakeLists.txt +++ b/source/dnode/vnode/CMakeLists.txt @@ -32,6 +32,8 @@ set( "src/meta/metaSnapshot.c" "src/meta/metaCache.c" "src/meta/metaTtl.c" + "src/meta/metaEntry2.c" + "src/meta/metaTable2.c" # sma "src/sma/smaEnv.c" diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h index 11b3cdf3c6..5d4ffc604a 100644 --- a/source/dnode/vnode/inc/vnode.h +++ b/source/dnode/vnode/inc/vnode.h @@ -162,25 +162,25 @@ typedef struct STsdbReader STsdbReader; #define CACHESCAN_RETRIEVE_LAST_ROW 0x4 #define CACHESCAN_RETRIEVE_LAST 0x8 -int32_t tsdbReaderOpen2(void *pVnode, SQueryTableDataCond *pCond, void *pTableList, int32_t numOfTables, - SSDataBlock *pResBlock, void **ppReader, const char *idstr, SHashObj **pIgnoreTables); -int32_t tsdbSetTableList2(STsdbReader *pReader, const void *pTableList, int32_t num); -int32_t tsdbReaderSetId(void *pReader, const char *idstr); -void tsdbReaderClose2(STsdbReader *pReader); -int32_t tsdbNextDataBlock2(STsdbReader *pReader, bool *hasNext); -int32_t tsdbRetrieveDatablockSMA2(STsdbReader *pReader, SSDataBlock *pDataBlock, bool *allHave, bool *hasNullSMA); -void tsdbReleaseDataBlock2(STsdbReader *pReader); -int32_t tsdbRetrieveDataBlock2(STsdbReader *pReader, SSDataBlock **pBlock, SArray *pIdList); -int32_t tsdbReaderReset2(STsdbReader *pReader, SQueryTableDataCond *pCond); -int32_t tsdbGetFileBlocksDistInfo2(STsdbReader *pReader, STableBlockDistInfo *pTableBlockInfo); -int64_t tsdbGetNumOfRowsInMemTable2(STsdbReader *pHandle, uint32_t *rows); -void *tsdbGetIdx2(SMeta *pMeta); -void *tsdbGetIvtIdx2(SMeta *pMeta); -uint64_t tsdbGetReaderMaxVersion2(STsdbReader *pReader); -void tsdbReaderSetCloseFlag(STsdbReader *pReader); -int64_t tsdbGetLastTimestamp2(SVnode *pVnode, void *pTableList, int32_t numOfTables, const char *pIdStr); -void tsdbSetFilesetDelimited(STsdbReader *pReader); -void tsdbReaderSetNotifyCb(STsdbReader *pReader, TsdReaderNotifyCbFn notifyFn, void *param); +int32_t tsdbReaderOpen2(void *pVnode, SQueryTableDataCond *pCond, void *pTableList, int32_t numOfTables, + SSDataBlock *pResBlock, void **ppReader, const char *idstr, SHashObj **pIgnoreTables); +int32_t tsdbSetTableList2(STsdbReader *pReader, const void *pTableList, int32_t num); +int32_t tsdbReaderSetId(void *pReader, const char *idstr); +void tsdbReaderClose2(STsdbReader *pReader); +int32_t tsdbNextDataBlock2(STsdbReader *pReader, bool *hasNext); +int32_t tsdbRetrieveDatablockSMA2(STsdbReader *pReader, SSDataBlock *pDataBlock, bool *allHave, bool *hasNullSMA); +void tsdbReleaseDataBlock2(STsdbReader *pReader); +int32_t tsdbRetrieveDataBlock2(STsdbReader *pReader, SSDataBlock **pBlock, SArray *pIdList); +int32_t tsdbReaderReset2(STsdbReader *pReader, SQueryTableDataCond *pCond); +int32_t tsdbGetFileBlocksDistInfo2(STsdbReader *pReader, STableBlockDistInfo *pTableBlockInfo); +int64_t tsdbGetNumOfRowsInMemTable2(STsdbReader *pHandle, uint32_t *rows); +void *tsdbGetIdx2(SMeta *pMeta); +void *tsdbGetIvtIdx2(SMeta *pMeta); +uint64_t tsdbGetReaderMaxVersion2(STsdbReader *pReader); +void tsdbReaderSetCloseFlag(STsdbReader *pReader); +int64_t tsdbGetLastTimestamp2(SVnode *pVnode, void *pTableList, int32_t numOfTables, const char *pIdStr); +void tsdbSetFilesetDelimited(STsdbReader *pReader); +void tsdbReaderSetNotifyCb(STsdbReader *pReader, TsdReaderNotifyCbFn notifyFn, void *param); int32_t tsdbReuseCacherowsReader(void *pReader, void *pTableIdList, int32_t numOfTables); int32_t tsdbCacherowsReaderOpen(void *pVnode, int32_t type, void *pTableIdList, int32_t numOfTables, int32_t numOfCols, diff --git a/source/dnode/vnode/src/inc/meta.h b/source/dnode/vnode/src/inc/meta.h index 87d7d2150e..c329bc8812 100644 --- a/source/dnode/vnode/src/inc/meta.h +++ b/source/dnode/vnode/src/inc/meta.h @@ -60,7 +60,7 @@ int metaRemoveTableFromIdx(SMeta* pMeta, tb_uid_t uid); static FORCE_INLINE tb_uid_t metaGenerateUid(SMeta* pMeta) { return tGenIdPI64(); } // metaTable ================== -int metaHandleEntry(SMeta* pMeta, const SMetaEntry* pME); +int32_t metaHandleEntry2(SMeta* pMeta, const SMetaEntry* pEntry); // metaCache ================== int32_t metaCacheOpen(SMeta* pMeta); diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h index 0ac475f41b..ef4b233f94 100644 --- a/source/dnode/vnode/src/inc/vnodeInt.h +++ b/source/dnode/vnode/src/inc/vnodeInt.h @@ -155,13 +155,13 @@ int metaCommit(SMeta* pMeta, TXN* txn); int metaFinishCommit(SMeta* pMeta, TXN* txn); int metaPrepareAsyncCommit(SMeta* pMeta); int metaAbort(SMeta* pMeta); -int metaCreateSTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq); -int metaAlterSTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq); -int metaDropSTable(SMeta* pMeta, int64_t verison, SVDropStbReq* pReq, SArray* tbUidList); -int metaCreateTable(SMeta* pMeta, int64_t version, SVCreateTbReq* pReq, STableMetaRsp** pMetaRsp); -int metaDropTable(SMeta* pMeta, int64_t version, SVDropTbReq* pReq, SArray* tbUids, int64_t* tbUid); +int metaCreateSuperTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq); +int32_t metaAlterSuperTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq); +int32_t metaDropSuperTable(SMeta* pMeta, int64_t verison, SVDropStbReq* pReq); +int32_t metaCreateTable2(SMeta* pMeta, int64_t version, SVCreateTbReq* pReq, STableMetaRsp** ppRsp); +int32_t metaDropTable2(SMeta* pMeta, int64_t version, SVDropTbReq* pReq); int32_t metaTrimTables(SMeta* pMeta); -int32_t metaDropTables(SMeta* pMeta, SArray* tbUids); +int32_t metaDropMultipleTables(SMeta* pMeta, int64_t version, SArray* tbUids); int metaTtlFindExpired(SMeta* pMeta, int64_t timePointMs, SArray* tbUids, int32_t ttlDropMaxCount); int metaAlterTable(SMeta* pMeta, int64_t version, SVAlterTbReq* pReq, STableMetaRsp* pMetaRsp); int metaUpdateChangeTimeWithLock(SMeta* pMeta, tb_uid_t uid, int64_t changeTimeMs); @@ -176,8 +176,8 @@ int metaAlterCache(SMeta* pMeta, int32_t nPage); int32_t metaUidCacheClear(SMeta* pMeta, uint64_t suid); int32_t metaTbGroupCacheClear(SMeta* pMeta, uint64_t suid); -int metaAddIndexToSTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq); -int metaDropIndexFromSTable(SMeta* pMeta, int64_t version, SDropIndexReq* pReq); +int32_t metaAddIndexToSuperTable(SMeta* pMeta, int64_t version, SVCreateStbReq* pReq); +int32_t metaDropIndexFromSuperTable(SMeta* pMeta, int64_t version, SDropIndexReq* pReq); int64_t metaGetTimeSeriesNum(SMeta* pMeta, int type); void metaUpdTimeSeriesNum(SMeta* pMeta); @@ -217,7 +217,7 @@ int32_t tsdbBegin(STsdb* pTsdb); // int32_t tsdbPrepareCommit(STsdb* pTsdb); // int32_t tsdbCommit(STsdb* pTsdb, SCommitInfo* pInfo); int32_t tsdbCacheCommit(STsdb* pTsdb); -int32_t tsdbCacheNewTable(STsdb* pTsdb, int64_t uid, tb_uid_t suid, SSchemaWrapper* pSchemaRow); +int32_t tsdbCacheNewTable(STsdb* pTsdb, int64_t uid, tb_uid_t suid, const SSchemaWrapper* pSchemaRow); int32_t tsdbCacheDropTable(STsdb* pTsdb, int64_t uid, tb_uid_t suid, SSchemaWrapper* pSchemaRow); int32_t tsdbCacheDropSubTables(STsdb* pTsdb, SArray* uids, tb_uid_t suid); int32_t tsdbCacheNewSTableColumn(STsdb* pTsdb, SArray* uids, int16_t cid, int8_t col_type); diff --git a/source/dnode/vnode/src/meta/metaEntry.c b/source/dnode/vnode/src/meta/metaEntry.c index 3b6eaf45d3..302a1eb04a 100644 --- a/source/dnode/vnode/src/meta/metaEntry.c +++ b/source/dnode/vnode/src/meta/metaEntry.c @@ -65,50 +65,71 @@ static FORCE_INLINE int32_t metatInitDefaultSColCmprWrapper(SDecoder *pDecoder, return 0; } +static int32_t metaCloneColCmpr(const SColCmprWrapper *pSrc, SColCmprWrapper *pDst) { + if (pSrc->nCols > 0) { + pDst->nCols = pSrc->nCols; + pDst->version = pSrc->version; + pDst->pColCmpr = (SColCmpr *)taosMemoryCalloc(pSrc->nCols, sizeof(SColCmpr)); + if (NULL == pDst->pColCmpr) { + return terrno; + } + memcpy(pDst->pColCmpr, pSrc->pColCmpr, pSrc->nCols * sizeof(SColCmpr)); + } + return 0; +} + +static void metaCloneColCmprFree(SColCmprWrapper *pCmpr) { + if (pCmpr) { + taosMemoryFreeClear(pCmpr->pColCmpr); + } +} + int metaEncodeEntry(SEncoder *pCoder, const SMetaEntry *pME) { TAOS_CHECK_RETURN(tStartEncode(pCoder)); TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->version)); TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->type)); TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->uid)); - if (pME->name == NULL) { - return TSDB_CODE_INVALID_PARA; - } + if (pME->type > 0) { + if (pME->name == NULL) { + return TSDB_CODE_INVALID_PARA; + } - TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->name)); + TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->name)); - if (pME->type == TSDB_SUPER_TABLE) { - TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->flags)); - TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaRow)); - TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaTag)); - if (TABLE_IS_ROLLUP(pME->flags)) { - TAOS_CHECK_RETURN(tEncodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam)); + if (pME->type == TSDB_SUPER_TABLE) { + TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->flags)); + TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaRow)); + TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaTag)); + if (TABLE_IS_ROLLUP(pME->flags)) { + TAOS_CHECK_RETURN(tEncodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam)); + } + } else if (pME->type == TSDB_CHILD_TABLE) { + TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.btime)); + TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ctbEntry.ttlDays)); + TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ctbEntry.commentLen)); + if (pME->ctbEntry.commentLen > 0) { + TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ctbEntry.comment)); + } + TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.suid)); + TAOS_CHECK_RETURN(tEncodeTag(pCoder, (const STag *)pME->ctbEntry.pTags)); + } else if (pME->type == TSDB_NORMAL_TABLE) { + TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ntbEntry.btime)); + TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ntbEntry.ttlDays)); + TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.commentLen)); + if (pME->ntbEntry.commentLen > 0) { + TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ntbEntry.comment)); + } + TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.ncid)); + TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->ntbEntry.schemaRow)); + } else if (pME->type == TSDB_TSMA_TABLE) { + TAOS_CHECK_RETURN(tEncodeTSma(pCoder, pME->smaEntry.tsma)); + } else { + metaError("meta/entry: invalide table type: %" PRId8 " encode failed.", pME->type); + return TSDB_CODE_INVALID_PARA; } - } else if (pME->type == TSDB_CHILD_TABLE) { - TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.btime)); - TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ctbEntry.ttlDays)); - TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ctbEntry.commentLen)); - if (pME->ctbEntry.commentLen > 0) { - TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ctbEntry.comment)); - } - TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.suid)); - TAOS_CHECK_RETURN(tEncodeTag(pCoder, (const STag *)pME->ctbEntry.pTags)); - } else if (pME->type == TSDB_NORMAL_TABLE) { - TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ntbEntry.btime)); - TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ntbEntry.ttlDays)); - TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.commentLen)); - if (pME->ntbEntry.commentLen > 0) { - TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ntbEntry.comment)); - } - TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.ncid)); - TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->ntbEntry.schemaRow)); - } else if (pME->type == TSDB_TSMA_TABLE) { - TAOS_CHECK_RETURN(tEncodeTSma(pCoder, pME->smaEntry.tsma)); - } else { - metaError("meta/entry: invalide table type: %" PRId8 " encode failed.", pME->type); - return TSDB_CODE_INVALID_PARA; + TAOS_CHECK_RETURN(meteEncodeColCmprEntry(pCoder, pME)); } - TAOS_CHECK_RETURN(meteEncodeColCmprEntry(pCoder, pME)); tEndEncode(pCoder); return 0; @@ -119,68 +140,227 @@ int metaDecodeEntry(SDecoder *pCoder, SMetaEntry *pME) { TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->version)); TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->type)); TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->uid)); - TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->name)); - if (pME->type == TSDB_SUPER_TABLE) { - TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->flags)); - TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaRow)); - TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaTag)); - if (TABLE_IS_ROLLUP(pME->flags)) { - TAOS_CHECK_RETURN(tDecodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam)); - } - } else if (pME->type == TSDB_CHILD_TABLE) { - TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.btime)); - TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ctbEntry.ttlDays)); - TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ctbEntry.commentLen)); - if (pME->ctbEntry.commentLen > 0) { - TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ctbEntry.comment)); - } - TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.suid)); - TAOS_CHECK_RETURN(tDecodeTag(pCoder, (STag **)&pME->ctbEntry.pTags)); - } else if (pME->type == TSDB_NORMAL_TABLE) { - TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ntbEntry.btime)); - TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ntbEntry.ttlDays)); - TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.commentLen)); - if (pME->ntbEntry.commentLen > 0) { - TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ntbEntry.comment)); - } - TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.ncid)); - TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->ntbEntry.schemaRow)); - } else if (pME->type == TSDB_TSMA_TABLE) { - pME->smaEntry.tsma = tDecoderMalloc(pCoder, sizeof(STSma)); - if (!pME->smaEntry.tsma) { - return terrno; - } - TAOS_CHECK_RETURN(tDecodeTSma(pCoder, pME->smaEntry.tsma, true)); - } else { - metaError("meta/entry: invalide table type: %" PRId8 " decode failed.", pME->type); - return TSDB_CODE_INVALID_PARA; - } - if (pME->type == TSDB_SUPER_TABLE) { - if (TABLE_IS_COL_COMPRESSED(pME->flags)) { - TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME)); + if (pME->type > 0) { + TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->name)); - if (pME->colCmpr.nCols == 0) { - TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow)); + if (pME->type == TSDB_SUPER_TABLE) { + TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->flags)); + TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaRow)); + TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaTag)); + if (TABLE_IS_ROLLUP(pME->flags)) { + TAOS_CHECK_RETURN(tDecodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam)); } + } else if (pME->type == TSDB_CHILD_TABLE) { + TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.btime)); + TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ctbEntry.ttlDays)); + TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ctbEntry.commentLen)); + if (pME->ctbEntry.commentLen > 0) { + TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ctbEntry.comment)); + } + TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.suid)); + TAOS_CHECK_RETURN(tDecodeTag(pCoder, (STag **)&pME->ctbEntry.pTags)); + } else if (pME->type == TSDB_NORMAL_TABLE) { + TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ntbEntry.btime)); + TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ntbEntry.ttlDays)); + TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.commentLen)); + if (pME->ntbEntry.commentLen > 0) { + TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ntbEntry.comment)); + } + TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.ncid)); + TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->ntbEntry.schemaRow)); + } else if (pME->type == TSDB_TSMA_TABLE) { + pME->smaEntry.tsma = tDecoderMalloc(pCoder, sizeof(STSma)); + if (!pME->smaEntry.tsma) { + return terrno; + } + TAOS_CHECK_RETURN(tDecodeTSma(pCoder, pME->smaEntry.tsma, true)); } else { - TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow)); - TABLE_SET_COL_COMPRESSED(pME->flags); + metaError("meta/entry: invalide table type: %" PRId8 " decode failed.", pME->type); + return TSDB_CODE_INVALID_PARA; } - } else if (pME->type == TSDB_NORMAL_TABLE) { - if (!tDecodeIsEnd(pCoder)) { - uDebug("set type: %d, tableName:%s", pME->type, pME->name); - TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME)); - if (pME->colCmpr.nCols == 0) { + if (pME->type == TSDB_SUPER_TABLE) { + if (TABLE_IS_COL_COMPRESSED(pME->flags)) { + TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME)); + + if (pME->colCmpr.nCols == 0) { + TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow)); + } + } else { + TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow)); + TABLE_SET_COL_COMPRESSED(pME->flags); + } + } else if (pME->type == TSDB_NORMAL_TABLE) { + if (!tDecodeIsEnd(pCoder)) { + uDebug("set type: %d, tableName:%s", pME->type, pME->name); + TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME)); + if (pME->colCmpr.nCols == 0) { + TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow)); + } + } else { + uDebug("set default type: %d, tableName:%s", pME->type, pME->name); TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow)); } - } else { - uDebug("set default type: %d, tableName:%s", pME->type, pME->name); - TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow)); + TABLE_SET_COL_COMPRESSED(pME->flags); } - TABLE_SET_COL_COMPRESSED(pME->flags); } tEndDecode(pCoder); return 0; } + +static int32_t metaCloneSchema(const SSchemaWrapper *pSrc, SSchemaWrapper *pDst) { + if (pSrc == NULL || pDst == NULL) { + return TSDB_CODE_INVALID_PARA; + } + + pDst->nCols = pSrc->nCols; + pDst->version = pSrc->version; + pDst->pSchema = (SSchema *)taosMemoryMalloc(pSrc->nCols * sizeof(SSchema)); + if (pDst->pSchema == NULL) { + return terrno; + } + memcpy(pDst->pSchema, pSrc->pSchema, pSrc->nCols * sizeof(SSchema)); + return TSDB_CODE_SUCCESS; +} + +static void metaCloneSchemaFree(SSchemaWrapper *pSchema) { + if (pSchema) { + taosMemoryFreeClear(pSchema->pSchema); + } +} + +void metaCloneEntryFree(SMetaEntry **ppEntry) { + if (ppEntry == NULL || *ppEntry == NULL) { + return; + } + + taosMemoryFreeClear((*ppEntry)->name); + + if ((*ppEntry)->type < 0) { + taosMemoryFreeClear(*ppEntry); + return; + } + + if (TSDB_SUPER_TABLE == (*ppEntry)->type) { + metaCloneSchemaFree(&(*ppEntry)->stbEntry.schemaRow); + metaCloneSchemaFree(&(*ppEntry)->stbEntry.schemaTag); + } else if (TSDB_CHILD_TABLE == (*ppEntry)->type) { + taosMemoryFreeClear((*ppEntry)->ctbEntry.comment); + taosMemoryFreeClear((*ppEntry)->ctbEntry.pTags); + } else if (TSDB_NORMAL_TABLE == (*ppEntry)->type) { + metaCloneSchemaFree(&(*ppEntry)->ntbEntry.schemaRow); + taosMemoryFreeClear((*ppEntry)->ntbEntry.comment); + } else { + return; + } + metaCloneColCmprFree(&(*ppEntry)->colCmpr); + + taosMemoryFreeClear(*ppEntry); + return; +} + +int32_t metaCloneEntry(const SMetaEntry *pEntry, SMetaEntry **ppEntry) { + int32_t code = TSDB_CODE_SUCCESS; + + if (NULL == pEntry || NULL == ppEntry) { + return TSDB_CODE_INVALID_PARA; + } + + *ppEntry = (SMetaEntry *)taosMemoryCalloc(1, sizeof(SMetaEntry)); + if (NULL == *ppEntry) { + return terrno; + } + + (*ppEntry)->version = pEntry->version; + (*ppEntry)->type = pEntry->type; + (*ppEntry)->uid = pEntry->uid; + + if (pEntry->type < 0) { + return TSDB_CODE_SUCCESS; + } + + if (pEntry->name) { + (*ppEntry)->name = tstrdup(pEntry->name); + if (NULL == (*ppEntry)->name) { + code = terrno; + metaCloneEntryFree(ppEntry); + return code; + } + } + + if (pEntry->type == TSDB_SUPER_TABLE) { + (*ppEntry)->flags = pEntry->flags; + + code = metaCloneSchema(&pEntry->stbEntry.schemaRow, &(*ppEntry)->stbEntry.schemaRow); + if (code) { + metaCloneEntryFree(ppEntry); + return code; + } + + code = metaCloneSchema(&pEntry->stbEntry.schemaTag, &(*ppEntry)->stbEntry.schemaTag); + if (code) { + metaCloneEntryFree(ppEntry); + return code; + } + } else if (pEntry->type == TSDB_CHILD_TABLE) { + (*ppEntry)->ctbEntry.btime = pEntry->ctbEntry.btime; + (*ppEntry)->ctbEntry.ttlDays = pEntry->ctbEntry.ttlDays; + (*ppEntry)->ctbEntry.suid = pEntry->ctbEntry.suid; + + // comment + (*ppEntry)->ctbEntry.commentLen = pEntry->ctbEntry.commentLen; + if (pEntry->ctbEntry.commentLen > 0) { + (*ppEntry)->ctbEntry.comment = taosMemoryMalloc(pEntry->ctbEntry.commentLen + 1); + if (NULL == (*ppEntry)->ctbEntry.comment) { + code = terrno; + metaCloneEntryFree(ppEntry); + return code; + } + memcpy((*ppEntry)->ctbEntry.comment, pEntry->ctbEntry.comment, pEntry->ctbEntry.commentLen + 1); + } + + // tags + STag *pTags = (STag *)pEntry->ctbEntry.pTags; + (*ppEntry)->ctbEntry.pTags = taosMemoryCalloc(1, pTags->len); + if (NULL == (*ppEntry)->ctbEntry.pTags) { + code = terrno; + metaCloneEntryFree(ppEntry); + return code; + } + memcpy((*ppEntry)->ctbEntry.pTags, pEntry->ctbEntry.pTags, pTags->len); + } else if (pEntry->type == TSDB_NORMAL_TABLE) { + (*ppEntry)->ntbEntry.btime = pEntry->ntbEntry.btime; + (*ppEntry)->ntbEntry.ttlDays = pEntry->ntbEntry.ttlDays; + (*ppEntry)->ntbEntry.ncid = pEntry->ntbEntry.ncid; + + // schema + code = metaCloneSchema(&pEntry->ntbEntry.schemaRow, &(*ppEntry)->ntbEntry.schemaRow); + if (code) { + metaCloneEntryFree(ppEntry); + return code; + } + + // comment + (*ppEntry)->ntbEntry.commentLen = pEntry->ntbEntry.commentLen; + if (pEntry->ntbEntry.commentLen > 0) { + (*ppEntry)->ntbEntry.comment = taosMemoryMalloc(pEntry->ntbEntry.commentLen + 1); + if (NULL == (*ppEntry)->ntbEntry.comment) { + code = terrno; + metaCloneEntryFree(ppEntry); + return code; + } + memcpy((*ppEntry)->ntbEntry.comment, pEntry->ntbEntry.comment, pEntry->ntbEntry.commentLen + 1); + } + } else { + return TSDB_CODE_INVALID_PARA; + } + + code = metaCloneColCmpr(&pEntry->colCmpr, &(*ppEntry)->colCmpr); + if (code) { + metaCloneEntryFree(ppEntry); + return code; + } + + return code; +} diff --git a/source/dnode/vnode/src/meta/metaEntry2.c b/source/dnode/vnode/src/meta/metaEntry2.c new file mode 100644 index 0000000000..7aa57edf73 --- /dev/null +++ b/source/dnode/vnode/src/meta/metaEntry2.c @@ -0,0 +1,1919 @@ +/* + * Copyright (c) 2023 Hongze Cheng . + * All rights reserved. + * + * This code is the intellectual property of Hongze Cheng. + * Any reproduction or distribution, in whole or in part, + * without the express written permission of Hongze Cheng is + * strictly prohibited. + */ + +#include "meta.h" + +int32_t metaCloneEntry(const SMetaEntry *pEntry, SMetaEntry **ppEntry); +void metaCloneEntryFree(SMetaEntry **ppEntry); +void metaDestroyTagIdxKey(STagIdxKey *pTagIdxKey); +int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema); +int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema); +void metaTimeSeriesNotifyCheck(SMeta *pMeta); +int tagIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2); + +static int32_t metaGetChildUidsOfSuperTable(SMeta *pMeta, tb_uid_t suid, SArray **childList); +static int32_t metaFetchTagIdxKey(SMeta *pMeta, const SMetaEntry *pEntry, const SSchema *pTagColumn, + STagIdxKey **ppTagIdxKey, int32_t *pTagIdxKeySize); +static void metaFetchTagIdxKeyFree(STagIdxKey **ppTagIdxKey); + +#define metaErr(VGID, ERRNO) \ + do { \ + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64 " type:%d uid:%" PRId64 " name:%s", VGID, \ + __func__, __FILE__, __LINE__, tstrerror(ERRNO), pEntry->version, pEntry->type, pEntry->uid, \ + pEntry->type > 0 ? pEntry->name : NULL); \ + } while (0) + +typedef enum { + META_ENTRY_TABLE = 0, + META_SCHEMA_TABLE, + META_UID_IDX, + META_NAME_IDX, + META_SUID_IDX, + META_CHILD_IDX, + META_TAG_IDX, + META_BTIME_IDX, + META_TTL_IDX, + META_TABLE_MAX, +} EMetaTable; + +typedef enum { + META_TABLE_OP_INSERT = 0, + META_TABLE_OP_UPDATA, + META_TABLE_OP_DELETE, + META_TABLE_OP_MAX, +} EMetaTableOp; + +typedef struct { + const SMetaEntry *pEntry; + const SMetaEntry *pSuperEntry; + const SMetaEntry *pOldEntry; +} SMetaHandleParam; + +typedef struct { + EMetaTable table; + EMetaTableOp op; +} SMetaTableOp; + +int32_t metaFetchEntryByUid(SMeta *pMeta, int64_t uid, SMetaEntry **ppEntry) { + int32_t code = TSDB_CODE_SUCCESS; + void *value = NULL; + int32_t valueSize = 0; + + // search uid index + code = tdbTbGet(pMeta->pUidIdx, &uid, sizeof(uid), &value, &valueSize); + if (TSDB_CODE_SUCCESS != code) { + metaError("vgId:%d, failed to get entry by uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), uid, tstrerror(code)); + return code; + } + + // search entry table + STbDbKey key = { + .version = ((SUidIdxVal *)value)->version, + .uid = uid, + }; + tdbFreeClear(value); + + code = tdbTbGet(pMeta->pTbDb, &key, sizeof(key), &value, &valueSize); + if (TSDB_CODE_SUCCESS != code) { + metaError("vgId:%d, failed to get entry by uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), uid, tstrerror(code)); + code = TSDB_CODE_INTERNAL_ERROR; + return code; + } + + // decode entry + SDecoder decoder = {0}; + SMetaEntry entry = {0}; + + tDecoderInit(&decoder, value, valueSize); + code = metaDecodeEntry(&decoder, &entry); + if (code) { + metaError("vgId:%d, failed to decode entry by uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), uid, + tstrerror(code)); + tDecoderClear(&decoder); + tdbFreeClear(value); + return code; + } + + code = metaCloneEntry(&entry, ppEntry); + if (code) { + metaError("vgId:%d, failed to clone entry by uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), uid, + tstrerror(code)); + tDecoderClear(&decoder); + tdbFreeClear(value); + return code; + } + + tdbFreeClear(value); + tDecoderClear(&decoder); + return code; +} + +int32_t metaFetchEntryByName(SMeta *pMeta, const char *name, SMetaEntry **ppEntry) { + int32_t code = TSDB_CODE_SUCCESS; + void *value = NULL; + int32_t valueSize = 0; + + code = tdbTbGet(pMeta->pNameIdx, name, strlen(name) + 1, &value, &valueSize); + if (TSDB_CODE_SUCCESS != code) { + metaError("vgId:%d, failed to get entry by name:%s since %s", TD_VID(pMeta->pVnode), name, tstrerror(code)); + return code; + } + int64_t uid = *(int64_t *)value; + tdbFreeClear(value); + + code = metaFetchEntryByUid(pMeta, uid, ppEntry); + if (TSDB_CODE_SUCCESS != code) { + metaError("vgId:%d, failed to get entry by uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), uid, tstrerror(code)); + code = TSDB_CODE_INTERNAL_ERROR; + } + return code; +} + +void metaFetchEntryFree(SMetaEntry **ppEntry) { metaCloneEntryFree(ppEntry); } + +// Entry Table +static int32_t metaEntryTableUpsert(SMeta *pMeta, const SMetaHandleParam *pParam, EMetaTableOp op) { + const SMetaEntry *pEntry = pParam->pEntry; + + int32_t code = TSDB_CODE_SUCCESS; + int32_t vgId = TD_VID(pMeta->pVnode); + void *value = NULL; + int32_t valueSize = 0; + SEncoder encoder = {0}; + STbDbKey key = { + .version = pEntry->version, + .uid = pEntry->uid, + }; + + // encode entry + tEncodeSize(metaEncodeEntry, pEntry, valueSize, code); + if (code != 0) { + metaErr(vgId, code); + return code; + } + + value = taosMemoryMalloc(valueSize); + if (NULL == value) { + metaErr(vgId, terrno); + return terrno; + } + + tEncoderInit(&encoder, value, valueSize); + code = metaEncodeEntry(&encoder, pEntry); + if (code) { + metaErr(vgId, code); + tEncoderClear(&encoder); + taosMemoryFree(value); + return code; + } + tEncoderClear(&encoder); + + // put to tdb + if (META_TABLE_OP_INSERT == op) { + code = tdbTbInsert(pMeta->pTbDb, &key, sizeof(key), value, valueSize, pMeta->txn); + } else if (META_TABLE_OP_UPDATA == op) { + code = tdbTbUpsert(pMeta->pTbDb, &key, sizeof(key), value, valueSize, pMeta->txn); + } else if (META_TABLE_OP_DELETE == op) { + code = tdbTbInsert(pMeta->pTbDb, &key, sizeof(key), value, valueSize, pMeta->txn); + } else { + code = TSDB_CODE_INVALID_PARA; + } + if (TSDB_CODE_SUCCESS != code) { + metaErr(vgId, code); + } + taosMemoryFree(value); + return code; +} + +static int32_t metaEntryTableInsert(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaEntryTableUpsert(pMeta, pParam, META_TABLE_OP_INSERT); +} + +static int32_t metaEntryTableUpdate(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaEntryTableUpsert(pMeta, pParam, META_TABLE_OP_UPDATA); +} + +static int32_t metaEntryTableDelete(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaEntryTableUpsert(pMeta, pParam, META_TABLE_OP_DELETE); +} + +// Schema Table +static int32_t metaSchemaTableUpsert(SMeta *pMeta, const SMetaHandleParam *pParam, EMetaTableOp op) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t vgId = TD_VID(pMeta->pVnode); + SEncoder encoder = {0}; + void *value = NULL; + int32_t valueSize = 0; + + const SMetaEntry *pEntry = pParam->pEntry; + const SSchemaWrapper *pSchema = NULL; + if (pEntry->type == TSDB_SUPER_TABLE) { + pSchema = &pEntry->stbEntry.schemaRow; + } else if (pEntry->type == TSDB_NORMAL_TABLE) { + pSchema = &pEntry->ntbEntry.schemaRow; + } else { + return TSDB_CODE_INVALID_PARA; + } + SSkmDbKey key = { + .uid = pEntry->uid, + .sver = pSchema->version, + }; + + // encode schema + tEncodeSize(tEncodeSSchemaWrapper, pSchema, valueSize, code); + if (TSDB_CODE_SUCCESS != code) { + metaErr(vgId, code); + return code; + } + + value = taosMemoryMalloc(valueSize); + if (NULL == value) { + metaErr(vgId, terrno); + return terrno; + } + + tEncoderInit(&encoder, value, valueSize); + code = tEncodeSSchemaWrapper(&encoder, pSchema); + if (TSDB_CODE_SUCCESS != code) { + metaErr(vgId, code); + tEncoderClear(&encoder); + taosMemoryFree(value); + return code; + } + tEncoderClear(&encoder); + + // put to tdb + if (META_TABLE_OP_INSERT == op) { + code = tdbTbInsert(pMeta->pSkmDb, &key, sizeof(key), value, valueSize, pMeta->txn); + } else if (META_TABLE_OP_UPDATA == op) { + code = tdbTbUpsert(pMeta->pSkmDb, &key, sizeof(key), value, valueSize, pMeta->txn); + } else { + code = TSDB_CODE_INVALID_PARA; + } + if (TSDB_CODE_SUCCESS != code) { + metaErr(vgId, code); + } + taosMemoryFree(value); + return code; +} + +static int32_t metaSchemaTableInsert(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaSchemaTableUpsert(pMeta, pParam, META_TABLE_OP_INSERT); +} + +static int32_t metaAddOrDropTagIndexOfSuperTable(SMeta *pMeta, const SMetaHandleParam *pParam, + const SSchema *pOldColumn, const SSchema *pNewColumn) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pOldEntry = pParam->pOldEntry; + enum { ADD_INDEX, DROP_INDEX } action; + + if (pOldColumn && pNewColumn) { + if (IS_IDX_ON(pOldColumn) && IS_IDX_ON(pNewColumn)) { + return TSDB_CODE_SUCCESS; + } else if (IS_IDX_ON(pOldColumn) && !IS_IDX_ON(pNewColumn)) { + action = DROP_INDEX; + } else if (!IS_IDX_ON(pOldColumn) && IS_IDX_ON(pNewColumn)) { + action = ADD_INDEX; + } else { + return TSDB_CODE_SUCCESS; + } + } else if (pOldColumn) { + if (IS_IDX_ON(pOldColumn)) { + action = DROP_INDEX; + } else { + return TSDB_CODE_SUCCESS; + } + } else { + if (IS_IDX_ON(pNewColumn)) { + action = ADD_INDEX; + } else { + return TSDB_CODE_SUCCESS; + } + } + + // fetch all child tables + SArray *childTables = 0; + code = metaGetChildUidsOfSuperTable(pMeta, pEntry->uid, &childTables); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + // do drop or add index + for (int32_t i = 0; i < taosArrayGetSize(childTables); i++) { + int64_t uid = *(int64_t *)taosArrayGet(childTables, i); + + // fetch child entry + SMetaEntry *pChildEntry = NULL; + code = metaFetchEntryByUid(pMeta, uid, &pChildEntry); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + taosArrayDestroy(childTables); + return code; + } + + STagIdxKey *pTagIdxKey = NULL; + int32_t tagIdxKeySize = 0; + + if (action == ADD_INDEX) { + code = metaFetchTagIdxKey(pMeta, pChildEntry, pNewColumn, &pTagIdxKey, &tagIdxKeySize); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + taosArrayDestroy(childTables); + metaFetchEntryFree(&pChildEntry); + return code; + } + + code = tdbTbInsert(pMeta->pTagIdx, pTagIdxKey, tagIdxKeySize, NULL, 0, pMeta->txn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + taosArrayDestroy(childTables); + metaFetchEntryFree(&pChildEntry); + metaFetchTagIdxKeyFree(&pTagIdxKey); + return code; + } + } else { + code = metaFetchTagIdxKey(pMeta, pChildEntry, pOldColumn, &pTagIdxKey, &tagIdxKeySize); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + taosArrayDestroy(childTables); + metaFetchEntryFree(&pChildEntry); + return code; + } + + code = tdbTbDelete(pMeta->pTagIdx, pTagIdxKey, tagIdxKeySize, pMeta->txn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + taosArrayDestroy(childTables); + metaFetchEntryFree(&pChildEntry); + metaFetchTagIdxKeyFree(&pTagIdxKey); + return code; + } + } + + metaFetchTagIdxKeyFree(&pTagIdxKey); + metaFetchEntryFree(&pChildEntry); + } + + taosArrayDestroy(childTables); + return code; +} + +static int32_t metaUpdateSuperTableTagSchema(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pOldEntry = pParam->pOldEntry; + const SSchemaWrapper *pNewTagSchema = &pEntry->stbEntry.schemaTag; + const SSchemaWrapper *pOldTagSchema = &pOldEntry->stbEntry.schemaTag; + + int32_t iOld = 0, iNew = 0; + for (; iOld < pOldTagSchema->nCols && iNew < pNewTagSchema->nCols;) { + SSchema *pOldColumn = pOldTagSchema->pSchema + iOld; + SSchema *pNewColumn = pNewTagSchema->pSchema + iNew; + + if (pOldColumn->colId == pNewColumn->colId) { + code = metaAddOrDropTagIndexOfSuperTable(pMeta, pParam, pOldColumn, pNewColumn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + iOld++; + iNew++; + } else if (pOldColumn->colId < pNewColumn->colId) { + code = metaAddOrDropTagIndexOfSuperTable(pMeta, pParam, pOldColumn, NULL); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + iOld++; + } else { + code = metaAddOrDropTagIndexOfSuperTable(pMeta, pParam, NULL, pNewColumn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + iNew++; + } + } + + for (; iOld < pOldTagSchema->nCols; iOld++) { + SSchema *pOldColumn = pOldTagSchema->pSchema + iOld; + code = metaAddOrDropTagIndexOfSuperTable(pMeta, pParam, pOldColumn, NULL); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } + + for (; iNew < pNewTagSchema->nCols; iNew++) { + SSchema *pNewColumn = pNewTagSchema->pSchema + iNew; + code = metaAddOrDropTagIndexOfSuperTable(pMeta, pParam, NULL, pNewColumn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } + + return code; +} + +static int32_t metaSchemaTableUpdate(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pOldEntry = pParam->pOldEntry; + + if (NULL == pOldEntry) { + return metaSchemaTableUpsert(pMeta, pParam, META_TABLE_OP_UPDATA); + } + + if (pEntry->type == TSDB_NORMAL_TABLE) { + // check row schema + if (pOldEntry->ntbEntry.schemaRow.version != pEntry->ntbEntry.schemaRow.version) { + return metaSchemaTableUpsert(pMeta, pParam, META_TABLE_OP_UPDATA); + } + } else if (pEntry->type == TSDB_SUPER_TABLE) { + // check row schema + if (pOldEntry->stbEntry.schemaRow.version != pEntry->stbEntry.schemaRow.version) { + return metaSchemaTableUpsert(pMeta, pParam, META_TABLE_OP_UPDATA); + } + + // check tag schema + code = metaUpdateSuperTableTagSchema(pMeta, pParam); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + } else { + return TSDB_CODE_INVALID_PARA; + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t metaSchemaTableDelete(SMeta *pMeta, const SMetaHandleParam *pEntry) { + // TODO + return TSDB_CODE_SUCCESS; +} + +// Uid Index +static void metaBuildEntryInfo(const SMetaEntry *pEntry, SMetaInfo *pInfo) { + pInfo->uid = pEntry->uid; + pInfo->version = pEntry->version; + if (pEntry->type == TSDB_SUPER_TABLE) { + pInfo->suid = pEntry->uid; + pInfo->skmVer = pEntry->stbEntry.schemaRow.version; + } else if (pEntry->type == TSDB_CHILD_TABLE) { + pInfo->suid = pEntry->ctbEntry.suid; + pInfo->skmVer = 0; + } else if (pEntry->type == TSDB_NORMAL_TABLE) { + pInfo->suid = 0; + pInfo->skmVer = pEntry->ntbEntry.schemaRow.version; + } +} + +static int32_t metaUidIdxUpsert(SMeta *pMeta, const SMetaHandleParam *pParam, EMetaTableOp op) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t vgId = TD_VID(pMeta->pVnode); + + const SMetaEntry *pEntry = pParam->pEntry; + + // update cache + SMetaInfo info = {0}; + metaBuildEntryInfo(pEntry, &info); + code = metaCacheUpsert(pMeta, &info); + if (code) { + metaErr(vgId, code); + } + + // put to tdb + SUidIdxVal value = { + .suid = info.suid, + .skmVer = info.skmVer, + .version = pEntry->version, + }; + if (META_TABLE_OP_INSERT == op) { + code = tdbTbInsert(pMeta->pUidIdx, &pEntry->uid, sizeof(pEntry->uid), &value, sizeof(value), pMeta->txn); + } else if (META_TABLE_OP_UPDATA == op) { + code = tdbTbUpsert(pMeta->pUidIdx, &pEntry->uid, sizeof(pEntry->uid), &value, sizeof(value), pMeta->txn); + } + return code; +} + +static int32_t metaUidIdxInsert(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaUidIdxUpsert(pMeta, pParam, META_TABLE_OP_INSERT); +} + +static int32_t metaUidIdxUpdate(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaUidIdxUpsert(pMeta, pParam, META_TABLE_OP_UPDATA); +} + +static int32_t metaUidIdxDelete(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = 0; + + const SMetaEntry *pEntry = pParam->pOldEntry; + + // delete tdb + code = tdbTbDelete(pMeta->pUidIdx, &pEntry->uid, sizeof(pEntry->uid), pMeta->txn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + } + + // delete cache + (void)metaCacheDrop(pMeta, pEntry->uid); + return code; +} + +// Name Index +static int32_t metaNameIdxUpsert(SMeta *pMeta, const SMetaHandleParam *pParam, EMetaTableOp op) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + + if (META_TABLE_OP_INSERT == op) { + code = tdbTbInsert(pMeta->pNameIdx, pEntry->name, strlen(pEntry->name) + 1, &pEntry->uid, sizeof(pEntry->uid), + pMeta->txn); + } else if (META_TABLE_OP_UPDATA == op) { + code = tdbTbUpsert(pMeta->pNameIdx, pEntry->name, strlen(pEntry->name) + 1, &pEntry->uid, sizeof(pEntry->uid), + pMeta->txn); + } else { + code = TSDB_CODE_INVALID_PARA; + } + return code; +} + +static int32_t metaNameIdxInsert(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + return metaNameIdxUpsert(pMeta, pParam, META_TABLE_OP_INSERT); +} + +static int32_t metaNameIdxUpdate(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaNameIdxUpsert(pMeta, pParam, META_TABLE_OP_UPDATA); +} + +static int32_t metaNameIdxDelete(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pOldEntry; + code = tdbTbDelete(pMeta->pNameIdx, pEntry->name, strlen(pEntry->name) + 1, pMeta->txn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + } + return code; +} + +// Suid Index +static int32_t metaSUidIdxInsert(SMeta *pMeta, const SMetaHandleParam *pParam) { + const SMetaEntry *pEntry = pParam->pEntry; + + int32_t code = tdbTbInsert(pMeta->pSuidIdx, &pEntry->uid, sizeof(pEntry->uid), NULL, 0, pMeta->txn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + } + return code; +} + +static int32_t metaSUidIdxDelete(SMeta *pMeta, const SMetaHandleParam *pParam) { + const SMetaEntry *pEntry = pParam->pOldEntry; + + int32_t code = tdbTbDelete(pMeta->pSuidIdx, &pEntry->uid, sizeof(pEntry->uid), pMeta->txn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + } + return code; +} + +// Child Index +static int32_t metaChildIdxUpsert(SMeta *pMeta, const SMetaHandleParam *pParam, EMetaTableOp op) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + + SCtbIdxKey key = { + .suid = pEntry->ctbEntry.suid, + .uid = pEntry->uid, + }; + + if (META_TABLE_OP_INSERT == op) { + code = tdbTbInsert(pMeta->pCtbIdx, &key, sizeof(key), pEntry->ctbEntry.pTags, + ((STag *)(pEntry->ctbEntry.pTags))->len, pMeta->txn); + } else if (META_TABLE_OP_UPDATA == op) { + code = tdbTbUpsert(pMeta->pCtbIdx, &key, sizeof(key), pEntry->ctbEntry.pTags, + ((STag *)(pEntry->ctbEntry.pTags))->len, pMeta->txn); + } else { + code = TSDB_CODE_INVALID_PARA; + } + return code; +} + +static int32_t metaChildIdxInsert(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaChildIdxUpsert(pMeta, pParam, META_TABLE_OP_INSERT); +} + +static int32_t metaChildIdxUpdate(SMeta *pMeta, const SMetaHandleParam *pParam) { + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pOldEntry = pParam->pOldEntry; + const SMetaEntry *pSuperEntry = pParam->pSuperEntry; + + const STag *pNewTags = (const STag *)pEntry->ctbEntry.pTags; + const STag *pOldTags = (const STag *)pOldEntry->ctbEntry.pTags; + if (pNewTags->len != pOldTags->len || memcmp(pNewTags, pOldTags, pNewTags->len)) { + return metaChildIdxUpsert(pMeta, pParam, META_TABLE_OP_UPDATA); + } + return 0; +} + +static int32_t metaChildIdxDelete(SMeta *pMeta, const SMetaHandleParam *pParam) { + const SMetaEntry *pEntry = pParam->pOldEntry; + + SCtbIdxKey key = { + .suid = pEntry->ctbEntry.suid, + .uid = pEntry->uid, + }; + return tdbTbDelete(pMeta->pCtbIdx, &key, sizeof(key), pMeta->txn); +} + +// Tag Index +static int32_t metaFetchTagIdxKey(SMeta *pMeta, const SMetaEntry *pEntry, const SSchema *pTagColumn, + STagIdxKey **ppTagIdxKey, int32_t *pTagIdxKeySize) { + int32_t code = TSDB_CODE_SUCCESS; + + STagIdxKey *pTagIdxKey = NULL; + int32_t nTagIdxKey; + const void *pTagData = NULL; + int32_t nTagData = 0; + + STagVal tagVal = { + .cid = pTagColumn->colId, + }; + + if (tTagGet((const STag *)pEntry->ctbEntry.pTags, &tagVal)) { + if (IS_VAR_DATA_TYPE(pTagColumn->type)) { + pTagData = tagVal.pData; + nTagData = (int32_t)tagVal.nData; + } else { + pTagData = &(tagVal.i64); + nTagData = tDataTypes[pTagColumn->type].bytes; + } + } else { + if (!IS_VAR_DATA_TYPE(pTagColumn->type)) { + nTagData = tDataTypes[pTagColumn->type].bytes; + } + } + + code = metaCreateTagIdxKey(pEntry->ctbEntry.suid, pTagColumn->colId, pTagData, nTagData, pTagColumn->type, + pEntry->uid, &pTagIdxKey, &nTagIdxKey); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + *ppTagIdxKey = pTagIdxKey; + *pTagIdxKeySize = nTagIdxKey; + return code; +} + +static void metaFetchTagIdxKeyFree(STagIdxKey **ppTagIdxKey) { + metaDestroyTagIdxKey(*ppTagIdxKey); + *ppTagIdxKey = NULL; +} + +static int32_t metaTagIdxInsert(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pSuperEntry = pParam->pSuperEntry; + + const SSchemaWrapper *pTagSchema = &pSuperEntry->stbEntry.schemaTag; + if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) { + const SSchema *pTagColumn = &pTagSchema->pSchema[0]; + + STagVal tagVal = { + .cid = pTagColumn->colId, + }; + + const void *pTagData = pEntry->ctbEntry.pTags; + int32_t nTagData = ((const STag *)pEntry->ctbEntry.pTags)->len; + code = metaSaveJsonVarToIdx(pMeta, pEntry, pTagColumn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + } + } else { + for (int32_t i = 0; i < pTagSchema->nCols; i++) { + STagIdxKey *pTagIdxKey = NULL; + int32_t nTagIdxKey; + const SSchema *pTagColumn = &pTagSchema->pSchema[i]; + + if (!IS_IDX_ON(pTagColumn)) { + continue; + } + + code = metaFetchTagIdxKey(pMeta, pEntry, pTagColumn, &pTagIdxKey, &nTagIdxKey); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + code = tdbTbInsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchTagIdxKeyFree(&pTagIdxKey); + return code; + } + metaFetchTagIdxKeyFree(&pTagIdxKey); + } + } + return code; +} + +static int32_t metaTagIdxUpdate(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pOldEntry = pParam->pOldEntry; + const SMetaEntry *pSuperEntry = pParam->pSuperEntry; + const SSchemaWrapper *pTagSchema = &pSuperEntry->stbEntry.schemaTag; + const STag *pNewTags = (const STag *)pEntry->ctbEntry.pTags; + const STag *pOldTags = (const STag *)pOldEntry->ctbEntry.pTags; + + if (pNewTags->len == pOldTags->len && !memcmp(pNewTags, pOldTags, pNewTags->len)) { + return code; + } + + if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) { + code = metaDelJsonVarFromIdx(pMeta, pOldEntry, &pTagSchema->pSchema[0]); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + code = metaSaveJsonVarToIdx(pMeta, pEntry, &pTagSchema->pSchema[0]); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } else { + for (int32_t i = 0; i < pTagSchema->nCols; i++) { + const SSchema *pTagColumn = &pTagSchema->pSchema[i]; + + if (!IS_IDX_ON(pTagColumn)) { + continue; + } + + STagIdxKey *pOldTagIdxKey = NULL; + int32_t oldTagIdxKeySize = 0; + STagIdxKey *pNewTagIdxKey = NULL; + int32_t newTagIdxKeySize = 0; + + code = metaFetchTagIdxKey(pMeta, pOldEntry, pTagColumn, &pOldTagIdxKey, &oldTagIdxKeySize); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + code = metaFetchTagIdxKey(pMeta, pEntry, pTagColumn, &pNewTagIdxKey, &newTagIdxKeySize); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchTagIdxKeyFree(&pOldTagIdxKey); + return code; + } + + if (tagIdxKeyCmpr(pOldTagIdxKey, oldTagIdxKeySize, pNewTagIdxKey, newTagIdxKeySize)) { + code = tdbTbDelete(pMeta->pTagIdx, pOldTagIdxKey, oldTagIdxKeySize, pMeta->txn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchTagIdxKeyFree(&pOldTagIdxKey); + metaFetchTagIdxKeyFree(&pNewTagIdxKey); + return code; + } + + code = tdbTbInsert(pMeta->pTagIdx, pNewTagIdxKey, newTagIdxKeySize, NULL, 0, pMeta->txn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchTagIdxKeyFree(&pOldTagIdxKey); + metaFetchTagIdxKeyFree(&pNewTagIdxKey); + return code; + } + } + + metaFetchTagIdxKeyFree(&pOldTagIdxKey); + metaFetchTagIdxKeyFree(&pNewTagIdxKey); + } + } + return code; +} + +static int32_t metaTagIdxDelete(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pChild = pParam->pOldEntry; + const SMetaEntry *pSuper = pParam->pSuperEntry; + const SSchemaWrapper *pTagSchema = &pSuper->stbEntry.schemaTag; + const SSchema *pTagColumn = NULL; + const STag *pTags = (const STag *)pChild->ctbEntry.pTags; + + if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) { + pTagColumn = &pTagSchema->pSchema[0]; + code = metaDelJsonVarFromIdx(pMeta, pChild, pTagColumn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + } + } else { + for (int32_t i = 0; i < pTagSchema->nCols; i++) { + pTagColumn = &pTagSchema->pSchema[i]; + if (!IS_IDX_ON(pTagColumn)) { + continue; + } + + STagIdxKey *pTagIdxKey = NULL; + int32_t nTagIdxKey; + + code = metaFetchTagIdxKey(pMeta, pChild, pTagColumn, &pTagIdxKey, &nTagIdxKey); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + code = tdbTbDelete(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, pMeta->txn); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchTagIdxKeyFree(&pTagIdxKey); + return code; + } + metaFetchTagIdxKeyFree(&pTagIdxKey); + } + } + return code; +} + +// Btime Index +static int32_t metaBtimeIdxUpsert(SMeta *pMeta, const SMetaHandleParam *pParam, EMetaTableOp op) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry; + if (META_TABLE_OP_DELETE == op) { + pEntry = pParam->pOldEntry; + } else { + pEntry = pParam->pEntry; + } + + SBtimeIdxKey key = { + .uid = pEntry->uid, + }; + + if (TSDB_CHILD_TABLE == pEntry->type) { + key.btime = pEntry->ctbEntry.btime; + } else if (TSDB_NORMAL_TABLE == pEntry->type) { + key.btime = pEntry->ntbEntry.btime; + } else { + return TSDB_CODE_INVALID_PARA; + } + + if (META_TABLE_OP_INSERT == op) { + code = tdbTbInsert(pMeta->pBtimeIdx, &key, sizeof(key), NULL, 0, pMeta->txn); + } else if (META_TABLE_OP_UPDATA == op) { + code = tdbTbUpsert(pMeta->pBtimeIdx, &key, sizeof(key), NULL, 0, pMeta->txn); + } else if (META_TABLE_OP_DELETE == op) { + code = tdbTbDelete(pMeta->pBtimeIdx, &key, sizeof(key), pMeta->txn); + } else { + code = TSDB_CODE_INVALID_PARA; + } + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + } + return code; +} + +static int32_t metaBtimeIdxInsert(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaBtimeIdxUpsert(pMeta, pParam, META_TABLE_OP_INSERT); +} + +static int32_t metaBtimeIdxUpdate(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaBtimeIdxUpsert(pMeta, pParam, META_TABLE_OP_UPDATA); +} + +static int32_t metaBtimeIdxDelete(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaBtimeIdxUpsert(pMeta, pParam, META_TABLE_OP_DELETE); +} + +// TTL Index +static int32_t metaTtlIdxUpsert(SMeta *pMeta, const SMetaHandleParam *pParam, EMetaTableOp op) { + const SMetaEntry *pEntry = pParam->pEntry; + + STtlUpdTtlCtx ctx = { + .uid = pEntry->uid, + .pTxn = pMeta->txn, + }; + if (TSDB_CHILD_TABLE == pEntry->type) { + ctx.ttlDays = pEntry->ctbEntry.ttlDays; + ctx.changeTimeMs = pEntry->ctbEntry.btime; + } else if (TSDB_NORMAL_TABLE == pEntry->type) { + ctx.ttlDays = pEntry->ntbEntry.ttlDays; + ctx.changeTimeMs = pEntry->ntbEntry.btime; + } else { + return TSDB_CODE_INVALID_PARA; + } + + int32_t ret = ttlMgrInsertTtl(pMeta->pTtlMgr, &ctx); + if (ret < 0) { + metaError("vgId:%d, failed to insert ttl, uid: %" PRId64 " %s", TD_VID(pMeta->pVnode), pEntry->uid, tstrerror(ret)); + } + return TSDB_CODE_SUCCESS; +} + +static int32_t metaTtlIdxInsert(SMeta *pMeta, const SMetaHandleParam *pParam) { + return metaTtlIdxUpsert(pMeta, pParam, META_TABLE_OP_INSERT); +} + +static int32_t metaTtlIdxDelete(SMeta *pMeta, const SMetaHandleParam *pParam); + +static int32_t metaTtlIdxUpdate(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pOldEntry = pParam->pOldEntry; + + if ((pEntry->type == TSDB_CHILD_TABLE && pOldEntry->ctbEntry.ttlDays != pEntry->ctbEntry.ttlDays) || + (pEntry->type == TSDB_NORMAL_TABLE && pOldEntry->ntbEntry.ttlDays != pEntry->ntbEntry.ttlDays)) { + code = metaTtlIdxDelete(pMeta, pParam); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + } + + code = metaTtlIdxInsert(pMeta, pParam); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + } + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t metaTtlIdxDelete(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pOldEntry; + STtlDelTtlCtx ctx = { + .uid = pEntry->uid, + .pTxn = pMeta->txn, + }; + + if (TSDB_CHILD_TABLE == pEntry->type) { + ctx.ttlDays = pEntry->ctbEntry.ttlDays; + } else if (TSDB_NORMAL_TABLE == pEntry->type) { + ctx.ttlDays = pEntry->ntbEntry.ttlDays; + } else { + code = TSDB_CODE_INVALID_PARA; + } + + if (TSDB_CODE_SUCCESS == code) { + int32_t ret = ttlMgrDeleteTtl(pMeta->pTtlMgr, &ctx); + if (ret < 0) { + metaError("vgId:%d, failed to delete ttl, uid: %" PRId64 " %s", TD_VID(pMeta->pVnode), pEntry->uid, + tstrerror(ret)); + } + } + return code; +} + +static int32_t (*metaTableOpFn[META_TABLE_MAX][META_TABLE_OP_MAX])(SMeta *pMeta, const SMetaHandleParam *pParam) = + { + [META_ENTRY_TABLE] = + { + [META_TABLE_OP_INSERT] = metaEntryTableInsert, + [META_TABLE_OP_UPDATA] = metaEntryTableUpdate, + [META_TABLE_OP_DELETE] = metaEntryTableDelete, + }, + [META_SCHEMA_TABLE] = + { + [META_TABLE_OP_INSERT] = metaSchemaTableInsert, + [META_TABLE_OP_UPDATA] = metaSchemaTableUpdate, + [META_TABLE_OP_DELETE] = metaSchemaTableDelete, + }, + [META_UID_IDX] = + { + [META_TABLE_OP_INSERT] = metaUidIdxInsert, + [META_TABLE_OP_UPDATA] = metaUidIdxUpdate, + [META_TABLE_OP_DELETE] = metaUidIdxDelete, + }, + [META_NAME_IDX] = + { + [META_TABLE_OP_INSERT] = metaNameIdxInsert, + [META_TABLE_OP_UPDATA] = metaNameIdxUpdate, + [META_TABLE_OP_DELETE] = metaNameIdxDelete, + }, + [META_SUID_IDX] = + { + [META_TABLE_OP_INSERT] = metaSUidIdxInsert, + [META_TABLE_OP_UPDATA] = NULL, + [META_TABLE_OP_DELETE] = metaSUidIdxDelete, + }, + [META_CHILD_IDX] = + { + [META_TABLE_OP_INSERT] = metaChildIdxInsert, + [META_TABLE_OP_UPDATA] = metaChildIdxUpdate, + [META_TABLE_OP_DELETE] = metaChildIdxDelete, + }, + [META_TAG_IDX] = + { + [META_TABLE_OP_INSERT] = metaTagIdxInsert, + [META_TABLE_OP_UPDATA] = metaTagIdxUpdate, + [META_TABLE_OP_DELETE] = metaTagIdxDelete, + }, + [META_BTIME_IDX] = + { + [META_TABLE_OP_INSERT] = metaBtimeIdxInsert, + [META_TABLE_OP_UPDATA] = metaBtimeIdxUpdate, + [META_TABLE_OP_DELETE] = metaBtimeIdxDelete, + }, + [META_TTL_IDX] = + { + [META_TABLE_OP_INSERT] = metaTtlIdxInsert, + [META_TABLE_OP_UPDATA] = metaTtlIdxUpdate, + [META_TABLE_OP_DELETE] = metaTtlIdxDelete, + }, +}; + +static int32_t metaHandleSuperTableCreateImpl(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + + SMetaTableOp ops[] = { + {META_ENTRY_TABLE, META_TABLE_OP_INSERT}, // + {META_SCHEMA_TABLE, META_TABLE_OP_UPDATA}, // TODO: here should be insert + {META_UID_IDX, META_TABLE_OP_INSERT}, // + {META_NAME_IDX, META_TABLE_OP_INSERT}, // + {META_SUID_IDX, META_TABLE_OP_INSERT}, // + }; + + for (int i = 0; i < sizeof(ops) / sizeof(ops[0]); i++) { + SMetaTableOp *op = &ops[i]; + const SMetaHandleParam param = { + .pEntry = pEntry, + }; + + code = metaTableOpFn[op->table][op->op](pMeta, ¶m); + if (TSDB_CODE_SUCCESS != code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } + + return code; +} +static int32_t metaHandleSuperTableCreate(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + + metaWLock(pMeta); + code = metaHandleSuperTableCreateImpl(pMeta, pEntry); + metaULock(pMeta); + + if (TSDB_CODE_SUCCESS == code) { + pMeta->pVnode->config.vndStats.numOfSTables++; + + metaInfo("vgId:%d, %s success, version:%" PRId64 " type:%d uid:%" PRId64 " name:%s", TD_VID(pMeta->pVnode), + __func__, pEntry->version, pEntry->type, pEntry->uid, pEntry->name); + } else { + metaErr(TD_VID(pMeta->pVnode), code); + } + return code; +} + +static int32_t metaHandleNormalTableCreateImpl(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + + SMetaTableOp ops[] = { + {META_ENTRY_TABLE, META_TABLE_OP_INSERT}, // + {META_SCHEMA_TABLE, META_TABLE_OP_UPDATA}, // TODO: need to be insert + {META_UID_IDX, META_TABLE_OP_INSERT}, // + {META_NAME_IDX, META_TABLE_OP_INSERT}, // + {META_BTIME_IDX, META_TABLE_OP_INSERT}, // + {META_TTL_IDX, META_TABLE_OP_INSERT}, // + }; + + for (int i = 0; i < sizeof(ops) / sizeof(ops[0]); i++) { + SMetaTableOp *op = &ops[i]; + + SMetaHandleParam param = { + .pEntry = pEntry, + }; + + code = metaTableOpFn[op->table][op->op](pMeta, ¶m); + if (TSDB_CODE_SUCCESS != code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } + + return code; +} +static int32_t metaHandleNormalTableCreate(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + + // update TDB + metaWLock(pMeta); + code = metaHandleNormalTableCreateImpl(pMeta, pEntry); + metaULock(pMeta); + + // update other stuff + if (TSDB_CODE_SUCCESS == code) { + pMeta->pVnode->config.vndStats.numOfNTables++; + pMeta->pVnode->config.vndStats.numOfNTimeSeries += pEntry->ntbEntry.schemaRow.nCols - 1; + + if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { + int32_t rc = tsdbCacheNewTable(pMeta->pVnode->pTsdb, pEntry->uid, -1, &pEntry->ntbEntry.schemaRow); + if (rc < 0) { + metaError("vgId:%d, failed to create table:%s since %s", TD_VID(pMeta->pVnode), pEntry->name, tstrerror(rc)); + } + } + } else { + metaErr(TD_VID(pMeta->pVnode), code); + } + return code; +} + +static int32_t metaHandleChildTableCreateImpl(SMeta *pMeta, const SMetaEntry *pEntry, const SMetaEntry *pSuperEntry) { + int32_t code = TSDB_CODE_SUCCESS; + + SMetaTableOp ops[] = { + {META_ENTRY_TABLE, META_TABLE_OP_INSERT}, // + {META_UID_IDX, META_TABLE_OP_INSERT}, // + {META_NAME_IDX, META_TABLE_OP_INSERT}, // + {META_CHILD_IDX, META_TABLE_OP_INSERT}, // + {META_TAG_IDX, META_TABLE_OP_INSERT}, // + {META_BTIME_IDX, META_TABLE_OP_INSERT}, // + {META_TTL_IDX, META_TABLE_OP_INSERT}, // + }; + + for (int i = 0; i < sizeof(ops) / sizeof(ops[0]); i++) { + SMetaTableOp *op = &ops[i]; + + SMetaHandleParam param = { + .pEntry = pEntry, + .pSuperEntry = pSuperEntry, + }; + + code = metaTableOpFn[op->table][op->op](pMeta, ¶m); + if (TSDB_CODE_SUCCESS != code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } + + if (TSDB_CODE_SUCCESS == code) { + metaUpdateStbStats(pMeta, pSuperEntry->uid, 1, 0); + int32_t ret = metaUidCacheClear(pMeta, pSuperEntry->uid); + if (ret < 0) { + metaErr(TD_VID(pMeta->pVnode), ret); + } + + ret = metaTbGroupCacheClear(pMeta, pSuperEntry->uid); + if (ret < 0) { + metaErr(TD_VID(pMeta->pVnode), ret); + } + } + return code; +} + +static int32_t metaHandleChildTableCreate(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + SMetaEntry *pSuperEntry = NULL; + + // get the super table entry + code = metaFetchEntryByUid(pMeta, pEntry->ctbEntry.suid, &pSuperEntry); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + // update TDB + metaWLock(pMeta); + code = metaHandleChildTableCreateImpl(pMeta, pEntry, pSuperEntry); + metaULock(pMeta); + + // update other stuff + if (TSDB_CODE_SUCCESS == code) { + pMeta->pVnode->config.vndStats.numOfCTables++; + + if (!metaTbInFilterCache(pMeta, pSuperEntry->name, 1)) { + int32_t nCols = 0; + int32_t ret = metaGetStbStats(pMeta->pVnode, pSuperEntry->uid, 0, &nCols); + if (ret < 0) { + metaErr(TD_VID(pMeta->pVnode), ret); + } + pMeta->pVnode->config.vndStats.numOfNTimeSeries += (nCols - 1); + } + + if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { + int32_t rc = tsdbCacheNewTable(pMeta->pVnode->pTsdb, pEntry->uid, pEntry->ctbEntry.suid, NULL); + if (rc < 0) { + metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, + tstrerror(rc)); + } + } + + } else { + metaErr(TD_VID(pMeta->pVnode), code); + } + + metaFetchEntryFree(&pSuperEntry); + return code; +} + +static int32_t metaHandleNormalTableDropImpl(SMeta *pMeta, SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + SMetaTableOp ops[] = { + {META_ENTRY_TABLE, META_TABLE_OP_DELETE}, // + {META_UID_IDX, META_TABLE_OP_DELETE}, // + {META_NAME_IDX, META_TABLE_OP_DELETE}, // + {META_BTIME_IDX, META_TABLE_OP_DELETE}, // + {META_TTL_IDX, META_TABLE_OP_DELETE}, // + + // {META_SCHEMA_TABLE, META_TABLE_OP_DELETE}, // + }; + + for (int32_t i = 0; i < sizeof(ops) / sizeof(ops[0]); i++) { + SMetaTableOp *op = &ops[i]; + code = metaTableOpFn[op->table][op->op](pMeta, pParam); + if (code) { + const SMetaEntry *pEntry = pParam->pEntry; + metaErr(TD_VID(pMeta->pVnode), code); + } + } + + return code; +} + +static int32_t metaHandleNormalTableDrop(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + SMetaEntry *pOldEntry = NULL; + + // fetch the entry + code = metaFetchEntryByUid(pMeta, pEntry->uid, &pOldEntry); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + SMetaHandleParam param = { + .pEntry = pEntry, + .pOldEntry = pOldEntry, + }; + + // do the drop + metaWLock(pMeta); + code = metaHandleNormalTableDropImpl(pMeta, ¶m); + metaULock(pMeta); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pOldEntry); + return code; + } + + // update other stuff + pMeta->pVnode->config.vndStats.numOfNTables--; + pMeta->pVnode->config.vndStats.numOfNTimeSeries -= (pOldEntry->ntbEntry.schemaRow.nCols - 1); + +#if 0 + if (tbUids) { + if (taosArrayPush(tbUids, &uid) == NULL) { + rc = terrno; + goto _exit; + } + } +#endif + + if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { + int32_t ret = tsdbCacheDropTable(pMeta->pVnode->pTsdb, pOldEntry->uid, 0, NULL); + if (ret < 0) { + metaErr(TD_VID(pMeta->pVnode), ret); + } + } + + metaFetchEntryFree(&pOldEntry); + return code; +} + +static int32_t metaHandleChildTableDropImpl(SMeta *pMeta, const SMetaHandleParam *pParam, bool superDropped) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pChild = pParam->pOldEntry; + const SMetaEntry *pSuper = pParam->pSuperEntry; + + SMetaTableOp ops[] = { + {META_ENTRY_TABLE, META_TABLE_OP_DELETE}, // + {META_UID_IDX, META_TABLE_OP_DELETE}, // + {META_NAME_IDX, META_TABLE_OP_DELETE}, // + {META_CHILD_IDX, META_TABLE_OP_DELETE}, // + {META_TAG_IDX, META_TABLE_OP_DELETE}, // + {META_BTIME_IDX, META_TABLE_OP_DELETE}, // + {META_TTL_IDX, META_TABLE_OP_DELETE}, // + }; + + for (int i = 0; i < sizeof(ops) / sizeof(ops[0]); i++) { + SMetaTableOp *op = &ops[i]; + + if (op->table == META_ENTRY_TABLE && superDropped) { + continue; + } + + code = metaTableOpFn[op->table][op->op](pMeta, pParam); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } + + --pMeta->pVnode->config.vndStats.numOfCTables; + metaUpdateStbStats(pMeta, pParam->pSuperEntry->uid, -1, 0); + int32_t ret = metaUidCacheClear(pMeta, pSuper->uid); + if (ret < 0) { + metaErr(TD_VID(pMeta->pVnode), ret); + } + + ret = metaTbGroupCacheClear(pMeta, pSuper->uid); + if (ret < 0) { + metaErr(TD_VID(pMeta->pVnode), ret); + } + return code; +} + +static int32_t metaHandleChildTableDrop(SMeta *pMeta, const SMetaEntry *pEntry, bool superDropped) { + int32_t code = TSDB_CODE_SUCCESS; + SMetaEntry *pChild = NULL; + SMetaEntry *pSuper = NULL; + + // fetch old entry + code = metaFetchEntryByUid(pMeta, pEntry->uid, &pChild); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + // fetch super entry + code = metaFetchEntryByUid(pMeta, pChild->ctbEntry.suid, &pSuper); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pChild); + return code; + } + + SMetaHandleParam param = { + .pEntry = pEntry, + .pOldEntry = pChild, + .pSuperEntry = pSuper, + }; + + // do the drop + metaWLock(pMeta); + code = metaHandleChildTableDropImpl(pMeta, ¶m, superDropped); + metaULock(pMeta); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + return code; + } + + // do other stuff + if (!metaTbInFilterCache(pMeta, pSuper->name, 1)) { + int32_t nCols = 0; + SVnodeStats *pStats = &pMeta->pVnode->config.vndStats; + if (metaGetStbStats(pMeta->pVnode, pSuper->uid, NULL, &nCols) == 0) { + pStats->numOfTimeSeries -= nCols - 1; + } + } + + if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { + int32_t ret = tsdbCacheDropTable(pMeta->pVnode->pTsdb, pChild->uid, pSuper->uid, NULL); + if (ret < 0) { + metaErr(TD_VID(pMeta->pVnode), ret); + } + } + +#if 0 + if (tbUids) { + if (taosArrayPush(tbUids, &uid) == NULL) { + rc = terrno; + goto _exit; + } + } + + if ((type == TSDB_CHILD_TABLE) && tbUid) { + *tbUid = uid; + } +#endif + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + return code; +} + +static int32_t metaGetChildUidsOfSuperTable(SMeta *pMeta, tb_uid_t suid, SArray **childList) { + int32_t code = TSDB_CODE_SUCCESS; + void *key = NULL; + int32_t keySize = 0; + int32_t c; + + *childList = taosArrayInit(64, sizeof(tb_uid_t)); + if (*childList == NULL) { + return terrno; + } + + TBC *cursor = NULL; + code = tdbTbcOpen(pMeta->pCtbIdx, &cursor, NULL); + if (code) { + taosArrayDestroy(*childList); + *childList = NULL; + return code; + } + + int32_t rc = tdbTbcMoveTo(cursor, + &(SCtbIdxKey){ + .suid = suid, + .uid = INT64_MIN, + }, + sizeof(SCtbIdxKey), &c); + if (rc < 0) { + tdbTbcClose(cursor); + return 0; + } + + for (;;) { + if (tdbTbcNext(cursor, &key, &keySize, NULL, NULL) < 0) { + break; + } + + if (((SCtbIdxKey *)key)->suid < suid) { + continue; + } else if (((SCtbIdxKey *)key)->suid > suid) { + break; + } + + if (taosArrayPush(*childList, &(((SCtbIdxKey *)key)->uid)) == NULL) { + tdbFreeClear(key); + tdbTbcClose(cursor); + taosArrayDestroy(*childList); + *childList = NULL; + return terrno; + } + } + + tdbTbcClose(cursor); + tdbFreeClear(key); + return code; +} + +static int32_t metaHandleSuperTableDropImpl(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + const SMetaEntry *pEntry = pParam->pEntry; + + SMetaTableOp ops[] = { + {META_ENTRY_TABLE, META_TABLE_OP_DELETE}, // + {META_UID_IDX, META_TABLE_OP_DELETE}, // + {META_NAME_IDX, META_TABLE_OP_DELETE}, // + {META_SUID_IDX, META_TABLE_OP_DELETE}, // + + // {META_SCHEMA_TABLE, META_TABLE_OP_UPDATA}, // TODO: here should be insert + }; + + for (int i = 0; i < sizeof(ops) / sizeof(ops[0]); i++) { + SMetaTableOp *op = &ops[i]; + + code = metaTableOpFn[op->table][op->op](pMeta, pParam); + if (TSDB_CODE_SUCCESS != code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } + + int32_t ret = metaStatsCacheDrop(pMeta, pEntry->uid); + if (ret < 0) { + metaErr(TD_VID(pMeta->pVnode), ret); + } + return code; +} + +static int32_t metaHandleNormalTableUpdateImpl(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + + SMetaTableOp ops[] = { + {META_ENTRY_TABLE, META_TABLE_OP_UPDATA}, // + {META_SCHEMA_TABLE, META_TABLE_OP_UPDATA}, // + {META_UID_IDX, META_TABLE_OP_UPDATA}, // + {META_TTL_IDX, META_TABLE_OP_UPDATA}, // + }; + for (int32_t i = 0; i < sizeof(ops) / sizeof(ops[0]); i++) { + SMetaTableOp *op = &ops[i]; + code = metaTableOpFn[op->table][op->op](pMeta, pParam); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } +#if 0 + if (metaUpdateChangeTime(pMeta, entry.uid, pAlterTbReq->ctimeMs) < 0) { + metaError("vgId:%d, failed to update change time:%s uid:%" PRId64, TD_VID(pMeta->pVnode), entry.name, entry.uid); + } +#endif + return code; +} + +static int32_t metaHandleChildTableUpdateImpl(SMeta *pMeta, const SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pOldEntry = pParam->pOldEntry; + const SMetaEntry *pSuperEntry = pParam->pSuperEntry; + + SMetaTableOp ops[] = { + {META_ENTRY_TABLE, META_TABLE_OP_UPDATA}, // + {META_UID_IDX, META_TABLE_OP_UPDATA}, // + {META_TAG_IDX, META_TABLE_OP_UPDATA}, // + {META_CHILD_IDX, META_TABLE_OP_UPDATA}, // + {META_TTL_IDX, META_TABLE_OP_UPDATA}, // + }; + + for (int i = 0; i < sizeof(ops) / sizeof(ops[0]); i++) { + SMetaTableOp *op = &ops[i]; + code = metaTableOpFn[op->table][op->op](pMeta, pParam); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } + + if (metaUidCacheClear(pMeta, pSuperEntry->uid) < 0) { + metaErr(TD_VID(pMeta->pVnode), code); + } + + if (metaTbGroupCacheClear(pMeta, pSuperEntry->uid) < 0) { + metaErr(TD_VID(pMeta->pVnode), code); + } + return code; +#if 0 + if (metaUpdateChangeTime(pMeta, ctbEntry.uid, pReq->ctimeMs) < 0) { + metaError("meta/table: failed to update change time:%s uid:%" PRId64, ctbEntry.name, ctbEntry.uid); + } +#endif +} + +static int32_t metaHandleSuperTableUpdateImpl(SMeta *pMeta, SMetaHandleParam *pParam) { + int32_t code = TSDB_CODE_SUCCESS; + + const SMetaEntry *pEntry = pParam->pEntry; + const SMetaEntry *pOldEntry = pParam->pOldEntry; + + SMetaTableOp ops[] = { + {META_ENTRY_TABLE, META_TABLE_OP_UPDATA}, // + {META_UID_IDX, META_TABLE_OP_UPDATA}, // + {META_SCHEMA_TABLE, META_TABLE_OP_UPDATA}, // + }; + + for (int i = 0; i < sizeof(ops) / sizeof(ops[0]); i++) { + SMetaTableOp *op = &ops[i]; + code = metaTableOpFn[op->table][op->op](pMeta, pParam); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + } + + return code; +} + +static int32_t metaHandleSuperTableUpdate(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + + SMetaEntry *pOldEntry = NULL; + + code = metaFetchEntryByUid(pMeta, pEntry->uid, &pOldEntry); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + SMetaHandleParam param = { + .pEntry = pEntry, + .pOldEntry = pOldEntry, + }; + metaWLock(pMeta); + code = metaHandleSuperTableUpdateImpl(pMeta, ¶m); + metaULock(pMeta); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pOldEntry); + return code; + } + + int nCols = pEntry->stbEntry.schemaRow.nCols; + int onCols = pOldEntry->stbEntry.schemaRow.nCols; + int32_t deltaCol = nCols - onCols; + bool updStat = deltaCol != 0 && !metaTbInFilterCache(pMeta, pEntry->name, 1); + + if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { + STsdb *pTsdb = pMeta->pVnode->pTsdb; + SArray *uids = NULL; /*taosArrayInit(8, sizeof(int64_t)); + if (uids == NULL) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pOldEntry); + return terrno; + }*/ + if (deltaCol == 1) { + int16_t cid = pEntry->stbEntry.schemaRow.pSchema[nCols - 1].colId; + int8_t col_type = pEntry->stbEntry.schemaRow.pSchema[nCols - 1].type; + + code = metaGetChildUidsOfSuperTable(pMeta, pEntry->uid, &uids); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pOldEntry); + return code; + } + // TAOS_CHECK_RETURN(metaGetSubtables(pMeta, pEntry->uid, uids)); + TAOS_CHECK_RETURN(tsdbCacheNewSTableColumn(pTsdb, uids, cid, col_type)); + } else if (deltaCol == -1) { + int16_t cid = -1; + bool hasPrimaryKey = false; + if (onCols >= 2) { + hasPrimaryKey = (pOldEntry->stbEntry.schemaRow.pSchema[1].flags & COL_IS_KEY) ? true : false; + } + for (int i = 0, j = 0; i < nCols && j < onCols; ++i, ++j) { + if (pEntry->stbEntry.schemaRow.pSchema[i].colId != pOldEntry->stbEntry.schemaRow.pSchema[j].colId) { + cid = pOldEntry->stbEntry.schemaRow.pSchema[j].colId; + break; + } + } + + if (cid != -1) { + code = metaGetChildUidsOfSuperTable(pMeta, pEntry->uid, &uids); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pOldEntry); + return code; + } + // TAOS_CHECK_RETURN(metaGetSubtables(pMeta, pEntry->uid, uids)); + TAOS_CHECK_RETURN(tsdbCacheDropSTableColumn(pTsdb, uids, cid, hasPrimaryKey)); + } + } + if (uids) taosArrayDestroy(uids); + + tsdbCacheInvalidateSchema(pTsdb, pEntry->uid, -1, pEntry->stbEntry.schemaRow.version); + } + + metaFetchEntryFree(&pOldEntry); + return code; +} + +static int32_t metaHandleChildTableUpdate(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + + SMetaEntry *pOldEntry = NULL; + SMetaEntry *pSuperEntry = NULL; + + code = metaFetchEntryByUid(pMeta, pEntry->uid, &pOldEntry); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + code = metaFetchEntryByUid(pMeta, pEntry->ctbEntry.suid, &pSuperEntry); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pOldEntry); + return code; + } + + SMetaHandleParam param = { + .pEntry = pEntry, + .pOldEntry = pOldEntry, + .pSuperEntry = pSuperEntry, + }; + + metaWLock(pMeta); + code = metaHandleChildTableUpdateImpl(pMeta, ¶m); + metaULock(pMeta); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pOldEntry); + metaFetchEntryFree(&pSuperEntry); + return code; + } + + metaFetchEntryFree(&pOldEntry); + metaFetchEntryFree(&pSuperEntry); + return code; +} + +static int32_t metaHandleNormalTableUpdate(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + SMetaEntry *pOldEntry = NULL; + + // fetch old entry + code = metaFetchEntryByUid(pMeta, pEntry->uid, &pOldEntry); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + // handle update + SMetaHandleParam param = { + .pEntry = pEntry, + .pOldEntry = pOldEntry, + }; + metaWLock(pMeta); + code = metaHandleNormalTableUpdateImpl(pMeta, ¶m); + metaULock(pMeta); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pOldEntry); + return code; + } + + // do other stuff + if (!TSDB_CACHE_NO(pMeta->pVnode->config) && + pEntry->ntbEntry.schemaRow.version != pOldEntry->ntbEntry.schemaRow.version) { +#if 0 + { // for add column + int16_t cid = pSchema->pSchema[entry.ntbEntry.schemaRow.nCols - 1].colId; + int8_t col_type = pSchema->pSchema[entry.ntbEntry.schemaRow.nCols - 1].type; + int32_t ret = tsdbCacheNewNTableColumn(pMeta->pVnode->pTsdb, entry.uid, cid, col_type); + if (ret < 0) { + terrno = ret; + goto _err; + } + } + { // for drop column + + if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { + int16_t cid = pColumn->colId; + + if (tsdbCacheDropNTableColumn(pMeta->pVnode->pTsdb, entry.uid, cid, hasPrimayKey) != 0) { + metaError("vgId:%d, failed to drop ntable column:%s uid:%" PRId64, TD_VID(pMeta->pVnode), entry.name, + entry.uid); + } + tsdbCacheInvalidateSchema(pMeta->pVnode->pTsdb, 0, entry.uid, pSchema->version); + } + } + } +#endif + tsdbCacheInvalidateSchema(pMeta->pVnode->pTsdb, 0, pEntry->uid, pEntry->ntbEntry.schemaRow.version); + } + metaTimeSeriesNotifyCheck(pMeta); + metaFetchEntryFree(&pOldEntry); + return code; +} + +static int32_t metaHandleSuperTableDrop(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + SArray *childList = NULL; + SMetaEntry *pOldEntry = NULL; + + code = metaFetchEntryByUid(pMeta, pEntry->uid, &pOldEntry); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + return code; + } + + code = metaGetChildUidsOfSuperTable(pMeta, pEntry->uid, &childList); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + metaFetchEntryFree(&pOldEntry); + return code; + } + + if (tsdbCacheDropSubTables(pMeta->pVnode->pTsdb, childList, pEntry->uid) < 0) { + metaError("vgId:%d, failed to drop stb:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pEntry->name, + pEntry->uid, tstrerror(terrno)); + } + + // loop to drop all child tables + for (int32_t i = 0; i < taosArrayGetSize(childList); i++) { + SMetaEntry childEntry = { + .version = pEntry->version, + .uid = *(tb_uid_t *)taosArrayGet(childList, i), + .type = -TSDB_CHILD_TABLE, + }; + + code = metaHandleChildTableDrop(pMeta, &childEntry, true); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + } + } + + // do drop super table + SMetaHandleParam param = { + .pEntry = pEntry, + .pOldEntry = pOldEntry, + }; + metaWLock(pMeta); + code = metaHandleSuperTableDropImpl(pMeta, ¶m); + metaULock(pMeta); + if (code) { + metaErr(TD_VID(pMeta->pVnode), code); + taosArrayDestroy(childList); + metaFetchEntryFree(&pOldEntry); + return code; + } + + // do other stuff + metaUpdTimeSeriesNum(pMeta); + + // free resource and return + taosArrayDestroy(childList); + metaFetchEntryFree(&pOldEntry); + return code; +} + +int32_t metaHandleEntry2(SMeta *pMeta, const SMetaEntry *pEntry) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t vgId = TD_VID(pMeta->pVnode); + SMetaInfo info = {0}; + int8_t type = pEntry->type > 0 ? pEntry->type : -pEntry->type; + + if (NULL == pMeta || NULL == pEntry) { + metaError("%s failed at %s:%d since invalid parameter", __func__, __FILE__, __LINE__); + return TSDB_CODE_INVALID_PARA; + } + + if (pEntry->type > 0) { + bool isExist = false; + if (TSDB_CODE_SUCCESS == metaGetInfo(pMeta, pEntry->uid, &info, NULL)) { + isExist = true; + } + + switch (type) { + case TSDB_SUPER_TABLE: { + if (isExist) { + code = metaHandleSuperTableUpdate(pMeta, pEntry); + } else { + code = metaHandleSuperTableCreate(pMeta, pEntry); + } + break; + } + case TSDB_CHILD_TABLE: { + if (isExist) { + code = metaHandleChildTableUpdate(pMeta, pEntry); + } else { + code = metaHandleChildTableCreate(pMeta, pEntry); + } + break; + } + case TSDB_NORMAL_TABLE: { + if (isExist) { + code = metaHandleNormalTableUpdate(pMeta, pEntry); + } else { + code = metaHandleNormalTableCreate(pMeta, pEntry); + } + break; + } + default: { + code = TSDB_CODE_INVALID_PARA; + break; + } + } + } else { + switch (type) { + case TSDB_SUPER_TABLE: { + code = metaHandleSuperTableDrop(pMeta, pEntry); + break; + } + case TSDB_CHILD_TABLE: { + code = metaHandleChildTableDrop(pMeta, pEntry, false); + break; + } + case TSDB_NORMAL_TABLE: { + code = metaHandleNormalTableDrop(pMeta, pEntry); + break; + } + default: { + code = TSDB_CODE_INVALID_PARA; + break; + } + } + } + + if (TSDB_CODE_SUCCESS == code) { + pMeta->changed = true; + metaDebug("vgId:%d, %s success, version:%" PRId64 " type:%d uid:%" PRId64 " name:%s", vgId, __func__, + pEntry->version, pEntry->type, pEntry->uid, pEntry->type > 0 ? pEntry->name : ""); + } else { + metaErr(vgId, code); + } + TAOS_RETURN(code); +} diff --git a/source/dnode/vnode/src/meta/metaOpen.c b/source/dnode/vnode/src/meta/metaOpen.c index cc440fd73b..35e761e51e 100644 --- a/source/dnode/vnode/src/meta/metaOpen.c +++ b/source/dnode/vnode/src/meta/metaOpen.c @@ -19,7 +19,7 @@ static int tbDbKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2); static int skmDbKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2); static int ctbIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2); -static int tagIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2); +int tagIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2); static int uidIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2); static int smaIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2); static int taskIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2); @@ -330,7 +330,7 @@ static int32_t metaGenerateNewMeta(SMeta **ppMeta) { tdbTbGet(pMeta->pUidIdx, &me.ctbEntry.suid, sizeof(me.ctbEntry.suid), NULL, NULL) != 0) { metaError("vgId:%d failed to get super table uid:%" PRId64 " for child table uid:%" PRId64, TD_VID(pVnode), me.ctbEntry.suid, uid); - } else if (metaHandleEntry(pNewMeta, &me) != 0) { + } else if (metaHandleEntry2(pNewMeta, &me) != 0) { metaError("vgId:%d failed to handle entry, uid:%" PRId64, TD_VID(pVnode), uid); } } @@ -598,7 +598,7 @@ static int ctbIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kL return 0; } -static int tagIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2) { +int tagIdxKeyCmpr(const void *pKey1, int kLen1, const void *pKey2, int kLen2) { STagIdxKey *pTagIdxKey1 = (STagIdxKey *)pKey1; STagIdxKey *pTagIdxKey2 = (STagIdxKey *)pKey2; tb_uid_t uid1 = 0, uid2 = 0; diff --git a/source/dnode/vnode/src/meta/metaSnapshot.c b/source/dnode/vnode/src/meta/metaSnapshot.c index b2826ec45a..30a20cd68d 100644 --- a/source/dnode/vnode/src/meta/metaSnapshot.c +++ b/source/dnode/vnode/src/meta/metaSnapshot.c @@ -72,7 +72,6 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) { int32_t nKey = 0; int32_t nData = 0; STbDbKey key; - SMetaInfo info; *ppData = NULL; for (;;) { @@ -85,8 +84,7 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) { goto _exit; } - if (key.version < pReader->sver // - || metaGetInfo(pReader->pMeta, key.uid, &info, NULL) == TSDB_CODE_NOT_FOUND) { + if (key.version < pReader->sver) { if (tdbTbcMoveToNext(pReader->pTbc) != 0) { metaTrace("vgId:%d, vnode snapshot meta read data done", TD_VID(pReader->pMeta->pVnode)); } @@ -199,7 +197,7 @@ int32_t metaSnapWrite(SMetaSnapWriter* pWriter, uint8_t* pData, uint32_t nData) code = metaDecodeEntry(pDecoder, &metaEntry); TSDB_CHECK_CODE(code, lino, _exit); - code = metaHandleEntry(pMeta, &metaEntry); + code = metaHandleEntry2(pMeta, &metaEntry); TSDB_CHECK_CODE(code, lino, _exit); _exit: diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c index c32d4b30b0..ee37dd1f90 100644 --- a/source/dnode/vnode/src/meta/metaTable.c +++ b/source/dnode/vnode/src/meta/metaTable.c @@ -17,8 +17,18 @@ extern SDmNotifyHandle dmNotifyHdl; -static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema); -static int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema); +int32_t metaAddTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMetaRsp *pRsp); +int32_t metaDropTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMetaRsp *pRsp); +int32_t metaAlterTableColumnName(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMetaRsp *pRsp); +int32_t metaAlterTableColumnBytes(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMetaRsp *pRsp); +int32_t metaUpdateTableTagValue(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq); +int32_t metaUpdateTableMultiTagValue(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq); +int32_t metaUpdateTableOptions2(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq); +int32_t metaUpdateTableColCompress2(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq); + +int32_t metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema); + +int32_t metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema); static int metaSaveToTbDb(SMeta *pMeta, const SMetaEntry *pME); static int metaUpdateUidIdx(SMeta *pMeta, const SMetaEntry *pME); static int metaUpdateNameIdx(SMeta *pMeta, const SMetaEntry *pME); @@ -29,30 +39,30 @@ static int metaUpdateCtbIdx(SMeta *pMeta, const SMetaEntry *pME); static int metaUpdateSuidIdx(SMeta *pMeta, const SMetaEntry *pME); static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry); static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *pSuid, int8_t *pSysTbl); -static void metaDestroyTagIdxKey(STagIdxKey *pTagIdxKey); +void metaDestroyTagIdxKey(STagIdxKey *pTagIdxKey); // opt ins_tables query static int metaUpdateBtimeIdx(SMeta *pMeta, const SMetaEntry *pME); static int metaDeleteBtimeIdx(SMeta *pMeta, const SMetaEntry *pME); static int metaUpdateNcolIdx(SMeta *pMeta, const SMetaEntry *pME); static int metaDeleteNcolIdx(SMeta *pMeta, const SMetaEntry *pME); -static int32_t updataTableColCmpr(SColCmprWrapper *pWp, SSchema *pSchema, int8_t add, uint32_t compress) { +int metaHandleEntry(SMeta *pMeta, const SMetaEntry *pME); + +int32_t updataTableColCmpr(SColCmprWrapper *pWp, SSchema *pSchema, int8_t add, uint32_t compress) { int32_t nCols = pWp->nCols; int32_t ver = pWp->version; if (add) { - SColCmpr *p = taosMemoryCalloc(1, sizeof(SColCmpr) * (nCols + 1)); + SColCmpr *p = taosMemoryRealloc(pWp->pColCmpr, sizeof(SColCmpr) * (nCols + 1)); if (p == NULL) { return terrno; } - - memcpy(p, pWp->pColCmpr, sizeof(SColCmpr) * nCols); + pWp->pColCmpr = p; SColCmpr *pCol = p + nCols; pCol->id = pSchema->colId; pCol->alg = compress; pWp->nCols = nCols + 1; pWp->version = ver; - pWp->pColCmpr = p; } else { for (int32_t i = 0; i < nCols; i++) { SColCmpr *pOCmpr = &pWp->pColCmpr[i]; @@ -87,7 +97,7 @@ static void metaGetEntryInfo(const SMetaEntry *pEntry, SMetaInfo *pInfo) { } } -static int metaUpdateMetaRsp(tb_uid_t uid, char *tbName, SSchemaWrapper *pSchema, STableMetaRsp *pMetaRsp) { +int metaUpdateMetaRsp(tb_uid_t uid, char *tbName, SSchemaWrapper *pSchema, STableMetaRsp *pMetaRsp) { pMetaRsp->pSchemas = taosMemoryMalloc(pSchema->nCols * sizeof(SSchema)); if (NULL == pMetaRsp->pSchemas) { return terrno; @@ -110,7 +120,7 @@ static int metaUpdateMetaRsp(tb_uid_t uid, char *tbName, SSchemaWrapper *pSchema return 0; } -static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema) { +int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema) { int32_t code = 0; #ifdef USE_INVERTED_INDEX @@ -279,7 +289,7 @@ _exception: return code; } -static inline void metaTimeSeriesNotifyCheck(SMeta *pMeta) { +void metaTimeSeriesNotifyCheck(SMeta *pMeta) { #if defined(TD_ENTERPRISE) int64_t nTimeSeries = metaGetTimeSeriesNum(pMeta, 0); int64_t deltaTS = nTimeSeries - pMeta->pVnode->config.vndStats.numOfReportedTimeSeries; @@ -293,7 +303,7 @@ static inline void metaTimeSeriesNotifyCheck(SMeta *pMeta) { #endif } -int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { +static int metaCreateSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { SMetaEntry me = {0}; int kLen = 0; int vLen = 0; @@ -353,7 +363,7 @@ _err: return code; } -int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq, SArray *tbUidList) { +static int metaDropSTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq, SArray *tbUidList) { void *pKey = NULL; int nKey = 0; void *pData = NULL; @@ -437,6 +447,12 @@ _drop_super_table: tstrerror(terrno)); } + ret = metaCacheDrop(pMeta, pReq->suid); + if (ret < 0) { + metaError("vgId:%d, failed to drop stb:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name, pReq->suid, + tstrerror(terrno)); + } + ret = tdbTbDelete(pMeta->pUidIdx, &pReq->suid, sizeof(tb_uid_t), pMeta->txn); if (ret < 0) { metaError("vgId:%d, failed to drop stb:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name, pReq->suid, @@ -507,7 +523,7 @@ static int32_t metaGetSubtables(SMeta *pMeta, int64_t suid, SArray *uids) { return 0; } -int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { +static int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { SMetaEntry oStbEntry = {0}; SMetaEntry nStbEntry = {0}; TBC *pUidIdxc = NULL; @@ -675,7 +691,8 @@ _exit: tdbTbcClose(pUidIdxc); return 0; } -int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { + +static int metaAddIndexToSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { SMetaEntry oStbEntry = {0}; SMetaEntry nStbEntry = {0}; STbDbKey tbDbKey = {0}; @@ -860,7 +877,8 @@ _err: return code; } -int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq) { + +static int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq) { int32_t code = 0; SMetaEntry oStbEntry = {0}; SMetaEntry nStbEntry = {0}; @@ -1047,7 +1065,7 @@ _err: return code; } -int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRsp **pMetaRsp) { +static int metaCreateTable(SMeta *pMeta, int64_t ver, SVCreateTbReq *pReq, STableMetaRsp **pMetaRsp) { SMetaEntry me = {0}; SMetaReader mr = {0}; int32_t ret; @@ -1216,7 +1234,7 @@ _err: return TSDB_CODE_FAILED; } -int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUids, tb_uid_t *tbUid) { +static int metaDropTable(SMeta *pMeta, int64_t version, SVDropTbReq *pReq, SArray *tbUids, tb_uid_t *tbUid) { void *pData = NULL; int nData = 0; int rc = 0; @@ -1270,7 +1288,7 @@ _exit: return rc; } -int32_t metaDropTables(SMeta *pMeta, SArray *tbUids) { +static int32_t metaDropTables(SMeta *pMeta, SArray *tbUids) { int32_t code = 0; if (taosArrayGetSize(tbUids) == 0) return TSDB_CODE_SUCCESS; @@ -1662,7 +1680,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p return 0; } // opt ins_tables -int metaUpdateBtimeIdx(SMeta *pMeta, const SMetaEntry *pME) { +static int metaUpdateBtimeIdx(SMeta *pMeta, const SMetaEntry *pME) { SBtimeIdxKey btimeKey = {0}; if (metaBuildBtimeIdxKey(&btimeKey, pME) < 0) { return 0; @@ -1673,13 +1691,14 @@ int metaUpdateBtimeIdx(SMeta *pMeta, const SMetaEntry *pME) { return tdbTbUpsert(pMeta->pBtimeIdx, &btimeKey, sizeof(btimeKey), NULL, 0, pMeta->txn); } -int metaDeleteBtimeIdx(SMeta *pMeta, const SMetaEntry *pME) { +static int metaDeleteBtimeIdx(SMeta *pMeta, const SMetaEntry *pME) { SBtimeIdxKey btimeKey = {0}; if (metaBuildBtimeIdxKey(&btimeKey, pME) < 0) { return 0; } return tdbTbDelete(pMeta->pBtimeIdx, &btimeKey, sizeof(btimeKey), pMeta->txn); } + int metaUpdateNcolIdx(SMeta *pMeta, const SMetaEntry *pME) { SNcolIdxKey ncolKey = {0}; if (metaBuildNColIdxKey(&ncolKey, pME) < 0) { @@ -2611,144 +2630,6 @@ static int metaUpdateTableOptions(SMeta *pMeta, int64_t version, SVAlterTbReq *p return 0; } -static int metaAddTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) { - SMetaEntry stbEntry = {0}; - void *pVal = NULL; - int nVal = 0; - int ret; - int c; - tb_uid_t uid, suid; - int64_t oversion; - const void *pData = NULL; - int nData = 0; - SDecoder dc = {0}; - - if (pAlterTbReq->tagName == NULL) { - return terrno = TSDB_CODE_INVALID_MSG; - } - - // search name index - ret = tdbTbGet(pMeta->pNameIdx, pAlterTbReq->tbName, strlen(pAlterTbReq->tbName) + 1, &pVal, &nVal); - if (ret < 0) { - return terrno = TSDB_CODE_TDB_TABLE_NOT_EXIST; - } else { - uid = *(tb_uid_t *)pVal; - tdbFree(pVal); - pVal = NULL; - } - - if (tdbTbGet(pMeta->pUidIdx, &uid, sizeof(tb_uid_t), &pVal, &nVal) == -1) { - ret = -1; - goto _err; - } - suid = ((SUidIdxVal *)pVal)[0].suid; - - STbDbKey tbDbKey = {0}; - tbDbKey.uid = suid; - tbDbKey.version = ((SUidIdxVal *)pVal)[0].version; - ret = tdbTbGet(pMeta->pTbDb, &tbDbKey, sizeof(tbDbKey), &pVal, &nVal); - if (ret < 0) { - goto _err; - } - tDecoderInit(&dc, pVal, nVal); - ret = metaDecodeEntry(&dc, &stbEntry); - if (ret < 0) { - tDecoderClear(&dc); - goto _err; - } - - // Get target schema info - SSchemaWrapper *pTagSchema = &stbEntry.stbEntry.schemaTag; - if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) { - terrno = TSDB_CODE_VND_COL_ALREADY_EXISTS; - goto _err; - } - SSchema *pCol = NULL; - int32_t iCol = 0; - for (;;) { - pCol = NULL; - if (iCol >= pTagSchema->nCols) break; - pCol = &pTagSchema->pSchema[iCol]; - if (strcmp(pCol->name, pAlterTbReq->tagName) == 0) break; - iCol++; - } - - if (iCol == 0) { - terrno = TSDB_CODE_VND_COL_ALREADY_EXISTS; - goto _err; - } - if (pCol == NULL) { - terrno = TSDB_CODE_VND_COL_NOT_EXISTS; - goto _err; - } - - /* - * iterator all pTdDbc by uid and version - */ - TBC *pCtbIdxc = NULL; - TAOS_CHECK_RETURN(tdbTbcOpen(pMeta->pCtbIdx, &pCtbIdxc, NULL)); - int rc = tdbTbcMoveTo(pCtbIdxc, &(SCtbIdxKey){.suid = suid, .uid = INT64_MIN}, sizeof(SCtbIdxKey), &c); - if (rc < 0) { - tdbTbcClose(pCtbIdxc); - goto _err; - } - for (;;) { - void *pKey, *pVal; - int nKey, nVal; - rc = tdbTbcNext(pCtbIdxc, &pKey, &nKey, &pVal, &nVal); - if (rc < 0) break; - if (((SCtbIdxKey *)pKey)->suid != uid) { - tdbFree(pKey); - tdbFree(pVal); - continue; - } - STagIdxKey *pTagIdxKey = NULL; - int32_t nTagIdxKey; - - const void *pTagData = NULL; - int32_t nTagData = 0; - - STagVal tagVal = {.cid = pCol->colId}; - if (tTagGet((const STag *)pVal, &tagVal)) { - if (IS_VAR_DATA_TYPE(pCol->type)) { - pTagData = tagVal.pData; - nTagData = (int32_t)tagVal.nData; - } else { - pTagData = &(tagVal.i64); - nTagData = tDataTypes[pCol->type].bytes; - } - } else { - if (!IS_VAR_DATA_TYPE(pCol->type)) { - nTagData = tDataTypes[pCol->type].bytes; - } - } - if (metaCreateTagIdxKey(suid, pCol->colId, pTagData, nTagData, pCol->type, uid, &pTagIdxKey, &nTagIdxKey) < 0) { - tdbFree(pKey); - tdbFree(pVal); - metaDestroyTagIdxKey(pTagIdxKey); - tdbTbcClose(pCtbIdxc); - goto _err; - } - ret = tdbTbUpsert(pMeta->pTagIdx, pTagIdxKey, nTagIdxKey, NULL, 0, pMeta->txn); - if (ret < 0) { - metaError("meta/table: failed to upsert tag idx:%s uid:%" PRId64, stbEntry.name, stbEntry.uid); - } - metaDestroyTagIdxKey(pTagIdxKey); - pTagIdxKey = NULL; - } - tdbTbcClose(pCtbIdxc); - return 0; - -_err: - // tDecoderClear(&dc1); - // tDecoderClear(&dc2); - // if (ctbEntry.pBuf) taosMemoryFree(ctbEntry.pBuf); - // if (stbEntry.pBuf) tdbFree(stbEntry.pBuf); - // tdbTbcClose(pTbDbc); - // tdbTbcClose(pUidIdxc); - return TSDB_CODE_FAILED; -} - typedef struct SMetaPair { void *key; int nkey; @@ -2873,7 +2754,7 @@ static int metaDropTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterT _err: return TSDB_CODE_FAILED; } -int32_t metaUpdateTableColCompress(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { +static int32_t metaUpdateTableColCompress(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { // impl later SMetaEntry tbEntry = {0}; void *pVal = NULL; @@ -2976,23 +2857,21 @@ int metaAlterTable(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMeta switch (pReq->action) { case TSDB_ALTER_TABLE_ADD_COLUMN: case TSDB_ALTER_TABLE_ADD_COLUMN_WITH_COMPRESS_OPTION: + return metaAddTableColumn(pMeta, version, pReq, pMetaRsp); case TSDB_ALTER_TABLE_DROP_COLUMN: + return metaDropTableColumn(pMeta, version, pReq, pMetaRsp); case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES: + return metaAlterTableColumnBytes(pMeta, version, pReq, pMetaRsp); case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME: - return metaAlterTableColumn(pMeta, version, pReq, pMetaRsp); + return metaAlterTableColumnName(pMeta, version, pReq, pMetaRsp); case TSDB_ALTER_TABLE_UPDATE_TAG_VAL: - return metaUpdateTableTagVal(pMeta, version, pReq); + return metaUpdateTableTagValue(pMeta, version, pReq); case TSDB_ALTER_TABLE_UPDATE_MULTI_TAG_VAL: - return metaUpdateTableMultiTagVal(pMeta, version, pReq); - return terrno = TSDB_CODE_VND_INVALID_TABLE_ACTION; + return metaUpdateTableMultiTagValue(pMeta, version, pReq); case TSDB_ALTER_TABLE_UPDATE_OPTIONS: - return metaUpdateTableOptions(pMeta, version, pReq); - case TSDB_ALTER_TABLE_ADD_TAG_INDEX: - return metaAddTagIndex(pMeta, version, pReq); - case TSDB_ALTER_TABLE_DROP_TAG_INDEX: - return metaDropTagIndex(pMeta, version, pReq); + return metaUpdateTableOptions2(pMeta, version, pReq); case TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS: - return metaUpdateTableColCompress(pMeta, version, pReq); + return metaUpdateTableColCompress2(pMeta, version, pReq); default: return terrno = TSDB_CODE_VND_INVALID_TABLE_ACTION; break; @@ -3155,7 +3034,7 @@ int metaCreateTagIdxKey(tb_uid_t suid, int32_t cid, const void *pTagData, int32_ return 0; } -static void metaDestroyTagIdxKey(STagIdxKey *pTagIdxKey) { +void metaDestroyTagIdxKey(STagIdxKey *pTagIdxKey) { if (pTagIdxKey) taosMemoryFree(pTagIdxKey); } diff --git a/source/dnode/vnode/src/meta/metaTable2.c b/source/dnode/vnode/src/meta/metaTable2.c new file mode 100644 index 0000000000..6ff4cd6fdc --- /dev/null +++ b/source/dnode/vnode/src/meta/metaTable2.c @@ -0,0 +1,1827 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#include "meta.h" + +extern int32_t metaHandleEntry2(SMeta *pMeta, const SMetaEntry *pEntry); +extern int32_t metaUpdateMetaRsp(tb_uid_t uid, char *tbName, SSchemaWrapper *pSchema, STableMetaRsp *pMetaRsp); +extern int32_t metaFetchEntryByUid(SMeta *pMeta, int64_t uid, SMetaEntry **ppEntry); +extern int32_t metaFetchEntryByName(SMeta *pMeta, const char *name, SMetaEntry **ppEntry); +extern void metaFetchEntryFree(SMetaEntry **ppEntry); +extern int32_t updataTableColCmpr(SColCmprWrapper *pWp, SSchema *pSchema, int8_t add, uint32_t compress); + +static int32_t metaCheckCreateSuperTableReq(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { + int32_t vgId = TD_VID(pMeta->pVnode); + void *value = NULL; + int32_t valueSize = 0; + SMetaInfo info; + + // check name + if (NULL == pReq->name || strlen(pReq->name) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid name:%s, version:%" PRId64, vgId, __func__, __FILE__, __LINE__, + pReq->name, version); + return TSDB_CODE_INVALID_MSG; + } + + int32_t r = tdbTbGet(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, &value, &valueSize); + if (r == 0) { // name exists, check uid and type + int64_t uid = *(tb_uid_t *)value; + tdbFree(value); + + if (pReq->suid != uid) { + metaError("vgId:%d, %s failed at %s:%d since table %s uid:%" PRId64 " already exists, request uid:%" PRId64 + " version:%" PRId64, + vgId, __func__, __FILE__, __LINE__, pReq->name, uid, pReq->suid, version); + return TSDB_CODE_TDB_TABLE_ALREADY_EXIST; + } + + if (metaGetInfo(pMeta, uid, &info, NULL) == TSDB_CODE_NOT_FOUND) { + metaError("vgId:%d, %s failed at %s:%d since table %s uid:%" PRId64 + " not found, this is an internal error in meta, version:%" PRId64, + vgId, __func__, __FILE__, __LINE__, pReq->name, uid, version); + return TSDB_CODE_PAR_TABLE_NOT_EXIST; + } + + if (info.uid == info.suid) { + return TSDB_CODE_TDB_STB_ALREADY_EXIST; + } else { + metaError("vgId:%d, %s failed at %s:%d since table %s uid:%" PRId64 + " already exists but not a super table, version:%" PRId64, + vgId, __func__, __FILE__, __LINE__, pReq->name, uid, version); + return TSDB_CODE_TDB_TABLE_ALREADY_EXIST; + } + } + + // check suid + if (metaGetInfo(pMeta, pReq->suid, &info, NULL) != TSDB_CODE_NOT_FOUND) { + metaError("vgId:%d, %s failed at %s:%d since table with uid:%" PRId64 " already exist, name:%s version:%" PRId64, + vgId, __func__, __FILE__, __LINE__, pReq->suid, pReq->name, version); + return TSDB_CODE_INVALID_MSG; + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t metaCheckDropTableReq(SMeta *pMeta, int64_t version, SVDropTbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + void *value = NULL; + int32_t valueSize = 0; + SMetaInfo info; + + if (NULL == pReq->name || strlen(pReq->name) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid name:%s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->name, version); + return TSDB_CODE_INVALID_MSG; + } + + code = tdbTbGet(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, &value, &valueSize); + if (TSDB_CODE_SUCCESS != code) { + if (pReq->igNotExists) { + metaTrace("vgId:%d, %s success since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + pReq->name, version); + } else { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->name, version); + } + return TSDB_CODE_TDB_TABLE_NOT_EXIST; + } + pReq->uid = *(tb_uid_t *)value; + tdbFreeClear(value); + + code = metaGetInfo(pMeta, pReq->uid, &info, NULL); + if (TSDB_CODE_SUCCESS != code) { + metaError("vgId:%d, %s failed at %s:%d since table %s uid %" PRId64 + " not found, this is an internal error, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, pReq->uid, version); + code = TSDB_CODE_INTERNAL_ERROR; + return code; + } + pReq->suid = info.suid; + + return code; +} + +static int32_t metaCheckDropSuperTableReq(SMeta *pMeta, int64_t version, SVDropStbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + void *value = NULL; + int32_t valueSize = 0; + SMetaInfo info; + + if (NULL == pReq->name || strlen(pReq->name) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid name:%s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->name, version); + return TSDB_CODE_INVALID_MSG; + } + + code = tdbTbGet(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, &value, &valueSize); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->name, version); + return TSDB_CODE_TDB_STB_NOT_EXIST; + } else { + int64_t uid = *(int64_t *)value; + tdbFreeClear(value); + + if (uid != pReq->suid) { + metaError("vgId:%d, %s failed at %s:%d since table %s uid:%" PRId64 " not match, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, pReq->suid, version); + return TSDB_CODE_TDB_STB_NOT_EXIST; + } + } + + code = metaGetInfo(pMeta, pReq->suid, &info, NULL); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s uid %" PRId64 + " not found, this is an internal error, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, pReq->suid, version); + return TSDB_CODE_INTERNAL_ERROR; + } + if (info.suid != info.uid) { + metaError("vgId:%d, %s failed at %s:%d since table %s uid %" PRId64 " is not a super table, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, pReq->suid, version); + return TSDB_CODE_INVALID_MSG; + } + return code; +} + +// Create Super Table +int32_t metaCreateSuperTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + + // check request + code = metaCheckCreateSuperTableReq(pMeta, version, pReq); + if (code != TSDB_CODE_SUCCESS) { + if (code == TSDB_CODE_TDB_STB_ALREADY_EXIST) { + metaWarn("vgId:%d, super table %s uid:%" PRId64 " already exists, version:%" PRId64, TD_VID(pMeta->pVnode), + pReq->name, pReq->suid, version); + TAOS_RETURN(TSDB_CODE_SUCCESS); + } else { + TAOS_RETURN(code); + } + } + + // handle entry + SMetaEntry entry = { + .version = version, + .type = TSDB_SUPER_TABLE, + .uid = pReq->suid, + .name = pReq->name, + .stbEntry.schemaRow = pReq->schemaRow, + .stbEntry.schemaTag = pReq->schemaTag, + }; + if (pReq->rollup) { + TABLE_SET_ROLLUP(entry.flags); + entry.stbEntry.rsmaParam = pReq->rsmaParam; + } + if (pReq->colCmpred) { + TABLE_SET_COL_COMPRESSED(entry.flags); + entry.colCmpr = pReq->colCmpr; + } + + code = metaHandleEntry2(pMeta, &entry); + if (TSDB_CODE_SUCCESS == code) { + metaInfo("vgId:%d, super table %s suid:%" PRId64 " is created, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->name, + pReq->suid, version); + } else { + metaError("vgId:%d, failed to create stb:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name, + pReq->suid, tstrerror(code)); + } + TAOS_RETURN(code); +} + +// Drop Super Table +int32_t metaDropSuperTable(SMeta *pMeta, int64_t verison, SVDropStbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + + // check request + code = metaCheckDropSuperTableReq(pMeta, verison, pReq); + if (code) { + TAOS_RETURN(code); + } + + // handle entry + SMetaEntry entry = { + .version = verison, + .type = -TSDB_SUPER_TABLE, + .uid = pReq->suid, + }; + code = metaHandleEntry2(pMeta, &entry); + if (code) { + metaError("vgId:%d, failed to drop stb:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name, pReq->suid, + tstrerror(code)); + } else { + metaInfo("vgId:%d, super table %s uid:%" PRId64 " is dropped, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->name, + pReq->suid, verison); + } + TAOS_RETURN(code); +} + +// Alter Super Table + +// Create Child Table +static int32_t metaCheckCreateChildTableReq(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + void *value = NULL; + int32_t valueSize = 0; + SMetaInfo info; + + if (NULL == pReq->name || strlen(pReq->name) == 0 || NULL == pReq->ctb.stbName || strlen(pReq->ctb.stbName) == 0 || + pReq->ctb.suid == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid name:%s stb name:%s, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->name, pReq->ctb.stbName, version); + return TSDB_CODE_INVALID_MSG; + } + + // check table existence + if (tdbTbGet(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, &value, &valueSize) == 0) { + pReq->uid = *(int64_t *)value; + tdbFreeClear(value); + + if (metaGetInfo(pMeta, pReq->uid, &info, NULL) != 0) { + metaError("vgId:%d, %s failed at %s:%d since cannot find table with uid %" PRId64 + ", which is an internal error, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->uid, version); + return TSDB_CODE_INTERNAL_ERROR; + } + + // check table type + if (info.suid == info.uid || info.suid == 0) { + metaError("vgId:%d, %s failed at %s:%d since table with uid %" PRId64 " is not a super table, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->uid, version); + return TSDB_CODE_TDB_TABLE_IN_OTHER_STABLE; + } + + // check suid + if (info.suid != pReq->ctb.suid) { + metaError("vgId:%d, %s failed at %s:%d since table %s uid %" PRId64 " exists in another stable with uid %" PRId64 + " instead of stable with uid %" PRId64 " version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, pReq->uid, info.suid, pReq->ctb.suid, + version); + return TSDB_CODE_TDB_TABLE_IN_OTHER_STABLE; + } + + return TSDB_CODE_TDB_TABLE_ALREADY_EXIST; + } + + // check super table existence + if (tdbTbGet(pMeta->pNameIdx, pReq->ctb.stbName, strlen(pReq->ctb.stbName) + 1, &value, &valueSize) == 0) { + int64_t suid = *(int64_t *)value; + tdbFreeClear(value); + if (suid != pReq->ctb.suid) { + metaError("vgId:%d, %s failed at %s:%d since super table %s has uid %" PRId64 " instead of %" PRId64 + ", version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->ctb.stbName, suid, pReq->ctb.suid, version); + return TSDB_CODE_PAR_TABLE_NOT_EXIST; + } + } else { + metaError("vgId:%d, %s failed at %s:%d since super table %s does not eixst, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->ctb.stbName, version); + return TSDB_CODE_PAR_TABLE_NOT_EXIST; + } + + // check super table is a super table + if (metaGetInfo(pMeta, pReq->ctb.suid, &info, NULL) != TSDB_CODE_SUCCESS) { + metaError("vgId:%d, %s failed at %s:%d since cannot find table with uid %" PRId64 + ", which is an internal error, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->ctb.suid, version); + return TSDB_CODE_INTERNAL_ERROR; + } else if (info.suid != info.uid) { + metaError("vgId:%d, %s failed at %s:%d since table with uid %" PRId64 " is not a super table, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->ctb.suid, version); + return TSDB_CODE_INVALID_MSG; + } + + // check grant + if (!metaTbInFilterCache(pMeta, pReq->ctb.stbName, 1)) { + code = grantCheck(TSDB_GRANT_TIMESERIES); + if (TSDB_CODE_SUCCESS != code) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64 " name:%s", TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, tstrerror(code), version, pReq->name); + } + } + return code; +} + +static int32_t metaBuildCreateChildTableRsp(SMeta *pMeta, const SMetaEntry *pEntry, STableMetaRsp **ppRsp) { + int32_t code = TSDB_CODE_SUCCESS; + + if (NULL == ppRsp) { + return code; + } + + *ppRsp = taosMemoryCalloc(1, sizeof(STableMetaRsp)); + if (NULL == ppRsp) { + return terrno; + } + + (*ppRsp)->tableType = TSDB_CHILD_TABLE; + (*ppRsp)->tuid = pEntry->uid; + (*ppRsp)->suid = pEntry->ctbEntry.suid; + tstrncpy((*ppRsp)->tbName, pEntry->name, TSDB_TABLE_NAME_LEN); + + return code; +} + +static int32_t metaCreateChildTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq, STableMetaRsp **ppRsp) { + int32_t code = TSDB_CODE_SUCCESS; + + // check request + code = metaCheckCreateChildTableReq(pMeta, version, pReq); + if (code) { + if (TSDB_CODE_TDB_TABLE_ALREADY_EXIST != code) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64 " name:%s", TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, tstrerror(code), version, pReq->name); + } + return code; + } + + SMetaEntry entry = { + .version = version, + .type = TSDB_CHILD_TABLE, + .uid = pReq->uid, + .name = pReq->name, + .ctbEntry.btime = pReq->btime, + .ctbEntry.ttlDays = pReq->ttl, + .ctbEntry.commentLen = pReq->commentLen, + .ctbEntry.comment = pReq->comment, + .ctbEntry.suid = pReq->ctb.suid, + .ctbEntry.pTags = pReq->ctb.pTag, + }; + + // build response + code = metaBuildCreateChildTableRsp(pMeta, &entry, ppRsp); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, + tstrerror(code)); + } + + // handle entry + code = metaHandleEntry2(pMeta, &entry); + if (TSDB_CODE_SUCCESS == code) { + metaInfo("vgId:%d, child table:%s uid %" PRId64 " suid:%" PRId64 " is created, version:%" PRId64, + TD_VID(pMeta->pVnode), pReq->name, pReq->uid, pReq->ctb.suid, version); + } else { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s suid:%" PRId64 " version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, tstrerror(code), pReq->uid, pReq->name, + pReq->ctb.suid, version); + } + return code; + +#if 0 + metaTimeSeriesNotifyCheck(pMeta); +#endif +} + +// Drop Child Table + +// Alter Child Table + +// Create Normal Table +static int32_t metaCheckCreateNormalTableReq(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq) { + int32_t code = 0; + void *value = NULL; + int32_t valueSize = 0; + + if (NULL == pReq->name || strlen(pReq->name) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid name:%s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->name, version); + return TSDB_CODE_INVALID_MSG; + } + + // check name + if (tdbTbGet(pMeta->pNameIdx, pReq->name, strlen(pReq->name) + 1, &value, &valueSize) == 0) { + // for auto create table, we return the uid of the existing table + pReq->uid = *(tb_uid_t *)value; + tdbFree(value); + return TSDB_CODE_TDB_TABLE_ALREADY_EXIST; + } + + // grant check + code = grantCheck(TSDB_GRANT_TIMESERIES); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64 " name:%s", TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, tstrerror(code), version, pReq->name); + } + return code; +} + +static int32_t metaBuildCreateNormalTableRsp(SMeta *pMeta, SMetaEntry *pEntry, STableMetaRsp **ppRsp) { + int32_t code = TSDB_CODE_SUCCESS; + + if (NULL == ppRsp) { + return code; + } + + *ppRsp = taosMemoryCalloc(1, sizeof(STableMetaRsp)); + if (NULL == *ppRsp) { + return terrno; + } + + code = metaUpdateMetaRsp(pEntry->uid, pEntry->name, &pEntry->ntbEntry.schemaRow, *ppRsp); + if (code) { + taosMemoryFreeClear(*ppRsp); + return code; + } + + for (int32_t i = 0; i < pEntry->colCmpr.nCols; i++) { + SColCmpr *p = &pEntry->colCmpr.pColCmpr[i]; + (*ppRsp)->pSchemaExt[i].colId = p->id; + (*ppRsp)->pSchemaExt[i].compress = p->alg; + } + + return code; +} + +static int32_t metaCreateNormalTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq, STableMetaRsp **ppRsp) { + int32_t code = TSDB_CODE_SUCCESS; + + // check request + code = metaCheckCreateNormalTableReq(pMeta, version, pReq); + if (code) { + if (TSDB_CODE_TDB_TABLE_ALREADY_EXIST != code) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64 " name:%s", TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, tstrerror(code), version, pReq->name); + } + TAOS_RETURN(code); + } + + SMetaEntry entry = { + .version = version, + .type = TSDB_NORMAL_TABLE, + .uid = pReq->uid, + .name = pReq->name, + .ntbEntry.btime = pReq->btime, + .ntbEntry.ttlDays = pReq->ttl, + .ntbEntry.commentLen = pReq->commentLen, + .ntbEntry.comment = pReq->comment, + .ntbEntry.schemaRow = pReq->ntb.schemaRow, + .ntbEntry.ncid = pReq->ntb.schemaRow.pSchema[pReq->ntb.schemaRow.nCols - 1].colId + 1, + .colCmpr = pReq->colCmpr, + }; + TABLE_SET_COL_COMPRESSED(entry.flags); + + // build response + code = metaBuildCreateNormalTableRsp(pMeta, &entry, ppRsp); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, + tstrerror(code)); + } + + // handle entry + code = metaHandleEntry2(pMeta, &entry); + if (TSDB_CODE_SUCCESS == code) { + metaInfo("vgId:%d, normal table:%s uid %" PRId64 " is created, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->name, + pReq->uid, version); + } else { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pReq->uid, pReq->name, version); + } + TAOS_RETURN(code); +#if 0 + metaTimeSeriesNotifyCheck(pMeta); +#endif +} + +// Drop Normal Table + +// Alter Normal Table + +int32_t metaCreateTable2(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq, STableMetaRsp **ppRsp) { + int32_t code = TSDB_CODE_SUCCESS; + if (TSDB_CHILD_TABLE == pReq->type) { + code = metaCreateChildTable(pMeta, version, pReq, ppRsp); + } else if (TSDB_NORMAL_TABLE == pReq->type) { + code = metaCreateNormalTable(pMeta, version, pReq, ppRsp); + } else { + code = TSDB_CODE_INVALID_MSG; + } + TAOS_RETURN(code); +} + +int32_t metaDropTable2(SMeta *pMeta, int64_t version, SVDropTbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + + // check request + code = metaCheckDropTableReq(pMeta, version, pReq); + if (code) { + if (TSDB_CODE_TDB_TABLE_NOT_EXIST != code) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64 " name:%s", TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, tstrerror(code), version, pReq->name); + } + TAOS_RETURN(code); + } + + if (pReq->suid == pReq->uid) { + code = TSDB_CODE_INVALID_PARA; + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pReq->uid, pReq->name, version); + TAOS_RETURN(code); + } + + SMetaEntry entry = { + .version = version, + .uid = pReq->uid, + }; + + if (pReq->suid == 0) { + entry.type = -TSDB_NORMAL_TABLE; + } else { + entry.type = -TSDB_CHILD_TABLE; + } + code = metaHandleEntry2(pMeta, &entry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pReq->uid, pReq->name, version); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is dropped, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->name, + pReq->uid, version); + } + TAOS_RETURN(code); +} + +static int32_t metaCheckAlterTableColumnReq(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { + int32_t code = 0; + + if (NULL == pReq->colName || strlen(pReq->colName) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid column name:%s, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->colName, version); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + // check name + void *value = NULL; + int32_t valueSize = 0; + code = tdbTbGet(pMeta->pNameIdx, pReq->tbName, strlen(pReq->tbName) + 1, &value, &valueSize); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + code = TSDB_CODE_TDB_TABLE_NOT_EXIST; + TAOS_RETURN(code); + } + int64_t uid = *(int64_t *)value; + tdbFreeClear(value); + + // check table type + SMetaInfo info; + if (metaGetInfo(pMeta, uid, &info, NULL) != 0) { + metaError("vgId:%d, %s failed at %s:%d since table %s uid %" PRId64 + " not found, this is an internal error in meta, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->tbName, uid, version); + code = TSDB_CODE_INTERNAL_ERROR; + TAOS_RETURN(code); + } + if (info.suid != 0) { + metaError("vgId:%d, %s failed at %s:%d since table %s uid %" PRId64 " is not a normal table, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->tbName, uid, version); + code = TSDB_CODE_VND_INVALID_TABLE_ACTION; + TAOS_RETURN(code); + } + + // check grant + code = grantCheck(TSDB_GRANT_TIMESERIES); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64 " name:%s", TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, tstrerror(code), version, pReq->tbName); + TAOS_RETURN(code); + } + TAOS_RETURN(code); +} + +int32_t metaAddTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMetaRsp *pRsp) { + int32_t code = TSDB_CODE_SUCCESS; + + // check request + code = metaCheckAlterTableColumnReq(pMeta, version, pReq); + if (code) { + TAOS_RETURN(code); + } + + // fetch old entry + SMetaEntry *pEntry = NULL; + code = metaFetchEntryByName(pMeta, pReq->tbName, &pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + TAOS_RETURN(code); + } + if (pEntry->version >= version) { + metaError("vgId:%d, %s failed at %s:%d since table %s version %" PRId64 " is not less than %" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->tbName, pEntry->version, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_PARA); + } + + // do add column + int32_t rowSize = 0; + SSchemaWrapper *pSchema = &pEntry->ntbEntry.schemaRow; + SSchema *pColumn; + pEntry->version = version; + for (int32_t i = 0; i < pSchema->nCols; i++) { + pColumn = &pSchema->pSchema[i]; + if (strncmp(pColumn->name, pReq->colName, TSDB_COL_NAME_LEN) == 0) { + metaError("vgId:%d, %s failed at %s:%d since column %s already exists in table %s, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->colName, pReq->tbName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_COL_ALREADY_EXISTS); + } + rowSize += pColumn->bytes; + } + + if (rowSize + pReq->bytes > TSDB_MAX_BYTES_PER_ROW) { + metaError("vgId:%d, %s failed at %s:%d since row size %d + %d > %d, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, rowSize, pReq->bytes, TSDB_MAX_BYTES_PER_ROW, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_PAR_INVALID_ROW_LENGTH); + } + + SSchema *pNewSchema = taosMemoryRealloc(pSchema->pSchema, sizeof(SSchema) * (pSchema->nCols + 1)); + if (NULL == pNewSchema) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(terrno), version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(terrno); + } + pSchema->pSchema = pNewSchema; + pSchema->version++; + pSchema->nCols++; + pColumn = &pSchema->pSchema[pSchema->nCols - 1]; + pColumn->bytes = pReq->bytes; + pColumn->type = pReq->type; + pColumn->flags = pReq->flags; + pColumn->colId = pEntry->ntbEntry.ncid++; + tstrncpy(pColumn->name, pReq->colName, TSDB_COL_NAME_LEN); + uint32_t compress; + if (TSDB_ALTER_TABLE_ADD_COLUMN == pReq->action) { + compress = createDefaultColCmprByType(pColumn->type); + } else { + compress = pReq->compress; + } + code = updataTableColCmpr(&pEntry->colCmpr, pColumn, 1, compress); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(code), version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } + + // do handle entry + code = metaHandleEntry2(pMeta, pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->tbName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->tbName, + pEntry->uid, version); + } + + if (metaUpdateMetaRsp(pEntry->uid, pReq->tbName, pSchema, pRsp) < 0) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->tbName, version); + } else { + for (int32_t i = 0; i < pEntry->colCmpr.nCols; i++) { + SColCmpr *p = &pEntry->colCmpr.pColCmpr[i]; + pRsp->pSchemaExt[i].colId = p->id; + pRsp->pSchemaExt[i].compress = p->alg; + } + } + + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); +} + +int32_t metaDropTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMetaRsp *pRsp) { + int32_t code = TSDB_CODE_SUCCESS; + + // check request + code = metaCheckAlterTableColumnReq(pMeta, version, pReq); + if (code) { + TAOS_RETURN(code); + } + + // fetch old entry + SMetaEntry *pEntry = NULL; + code = metaFetchEntryByName(pMeta, pReq->tbName, &pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + TAOS_RETURN(code); + } + + if (pEntry->version >= version) { + metaError("vgId:%d, %s failed at %s:%d since table %s version %" PRId64 " is not less than %" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->tbName, pEntry->version, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_PARA); + } + + // search the column to drop + SSchemaWrapper *pSchema = &pEntry->ntbEntry.schemaRow; + SSchema *pColumn = NULL; + SSchema tColumn; + int32_t iColumn = 0; + for (; iColumn < pSchema->nCols; iColumn++) { + pColumn = &pSchema->pSchema[iColumn]; + if (strncmp(pColumn->name, pReq->colName, TSDB_COL_NAME_LEN) == 0) { + break; + } + } + + if (iColumn == pSchema->nCols) { + metaError("vgId:%d, %s failed at %s:%d since column %s not found in table %s, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->colName, pReq->tbName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_COL_NOT_EXISTS); + } + + if (pColumn->colId == 0 || pColumn->flags & COL_IS_KEY) { + metaError("vgId:%d, %s failed at %s:%d since column %s is primary key, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->colName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + if (tqCheckColModifiable(pMeta->pVnode->pTq, pEntry->uid, pColumn->colId) != 0) { + metaError("vgId:%d, %s failed at %s:%d since column %s is not modifiable, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->colName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + tColumn = *pColumn; + + // do drop column + pEntry->version = version; + if (pSchema->nCols - iColumn - 1 > 0) { + memmove(pColumn, pColumn + 1, (pSchema->nCols - iColumn - 1) * sizeof(SSchema)); + } + pSchema->nCols--; + pSchema->version++; + code = updataTableColCmpr(&pEntry->colCmpr, &tColumn, 0, 0); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(code), version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } + if (pEntry->colCmpr.nCols != pSchema->nCols) { + metaError("vgId:%d, %s failed at %s:%d since column count mismatch, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + // do handle entry + code = metaHandleEntry2(pMeta, pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->tbName, version); + metaFetchEntryFree(&pEntry); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->tbName, + pEntry->uid, version); + } + + // build response + if (metaUpdateMetaRsp(pEntry->uid, pReq->tbName, pSchema, pRsp) < 0) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->tbName, version); + } else { + for (int32_t i = 0; i < pEntry->colCmpr.nCols; i++) { + SColCmpr *p = &pEntry->colCmpr.pColCmpr[i]; + pRsp->pSchemaExt[i].colId = p->id; + pRsp->pSchemaExt[i].compress = p->alg; + } + } + + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); +} + +int32_t metaAlterTableColumnName(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMetaRsp *pRsp) { + int32_t code = TSDB_CODE_SUCCESS; + + // check request + code = metaCheckAlterTableColumnReq(pMeta, version, pReq); + if (code) { + TAOS_RETURN(code); + } + + if (NULL == pReq->colNewName) { + metaError("vgId:%d, %s failed at %s:%d since invalid new column name, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, version); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + // fetch old entry + SMetaEntry *pEntry = NULL; + code = metaFetchEntryByName(pMeta, pReq->tbName, &pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + TAOS_RETURN(code); + } + + if (pEntry->version >= version) { + metaError("vgId:%d, %s failed at %s:%d since table %s version %" PRId64 " is not less than %" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->tbName, pEntry->version, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_PARA); + } + + // search the column to update + SSchemaWrapper *pSchema = &pEntry->ntbEntry.schemaRow; + SSchema *pColumn = NULL; + int32_t iColumn = 0; + for (int32_t i = 0; i < pSchema->nCols; i++) { + if (strncmp(pSchema->pSchema[i].name, pReq->colName, TSDB_COL_NAME_LEN) == 0) { + pColumn = &pSchema->pSchema[i]; + iColumn = i; + break; + } + } + + if (NULL == pColumn) { + metaError("vgId:%d, %s failed at %s:%d since column id %d not found in table %s, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->colId, pReq->tbName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_COL_NOT_EXISTS); + } + + if (tqCheckColModifiable(pMeta->pVnode->pTq, pEntry->uid, pColumn->colId) != 0) { + metaError("vgId:%d, %s failed at %s:%d since column %s is not modifiable, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pColumn->name, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_COL_SUBSCRIBED); + } + + // do update column name + pEntry->version = version; + tstrncpy(pColumn->name, pReq->colNewName, TSDB_COL_NAME_LEN); + pSchema->version++; + + // do handle entry + code = metaHandleEntry2(pMeta, pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->tbName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->tbName, + pEntry->uid, version); + } + + // build response + if (metaUpdateMetaRsp(pEntry->uid, pReq->tbName, pSchema, pRsp) < 0) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->tbName, version); + } else { + for (int32_t i = 0; i < pEntry->colCmpr.nCols; i++) { + SColCmpr *p = &pEntry->colCmpr.pColCmpr[i]; + pRsp->pSchemaExt[i].colId = p->id; + pRsp->pSchemaExt[i].compress = p->alg; + } + } + + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); +} + +int32_t metaAlterTableColumnBytes(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq, STableMetaRsp *pRsp) { + int32_t code = TSDB_CODE_SUCCESS; + + // check request + code = metaCheckAlterTableColumnReq(pMeta, version, pReq); + if (code) { + TAOS_RETURN(code); + } + + // fetch old entry + SMetaEntry *pEntry = NULL; + code = metaFetchEntryByName(pMeta, pReq->tbName, &pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + TAOS_RETURN(code); + } + + if (pEntry->version >= version) { + metaError("vgId:%d, %s failed at %s:%d since table %s version %" PRId64 " is not less than %" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->tbName, pEntry->version, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_PARA); + } + + // search the column to update + SSchemaWrapper *pSchema = &pEntry->ntbEntry.schemaRow; + SSchema *pColumn = NULL; + int32_t iColumn = 0; + int32_t rowSize = 0; + for (int32_t i = 0; i < pSchema->nCols; i++) { + if (strncmp(pSchema->pSchema[i].name, pReq->colName, TSDB_COL_NAME_LEN) == 0) { + pColumn = &pSchema->pSchema[i]; + iColumn = i; + } + rowSize += pSchema->pSchema[i].bytes; + } + + if (NULL == pColumn) { + metaError("vgId:%d, %s failed at %s:%d since column %s not found in table %s, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->colName, pReq->tbName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_COL_NOT_EXISTS); + } + + if (!IS_VAR_DATA_TYPE(pColumn->type) || pColumn->bytes >= pReq->colModBytes) { + metaError("vgId:%d, %s failed at %s:%d since column %s is not var data type or bytes %d >= %d, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->colName, pColumn->bytes, pReq->colModBytes, + version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + if (tqCheckColModifiable(pMeta->pVnode->pTq, pEntry->uid, pColumn->colId) != 0) { + metaError("vgId:%d, %s failed at %s:%d since column %s is not modifiable, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->colName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_COL_SUBSCRIBED); + } + + if (rowSize + pReq->colModBytes - pColumn->bytes > TSDB_MAX_BYTES_PER_ROW) { + metaError("vgId:%d, %s failed at %s:%d since row size %d + %d - %d > %d, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, rowSize, pReq->colModBytes, pColumn->bytes, TSDB_MAX_BYTES_PER_ROW, + version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_PAR_INVALID_ROW_LENGTH); + } + + // do change the column bytes + pEntry->version = version; + pSchema->version++; + pColumn->bytes = pReq->colModBytes; + + // do handle entry + code = metaHandleEntry2(pMeta, pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->tbName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->tbName, + pEntry->uid, version); + } + + // build response + if (metaUpdateMetaRsp(pEntry->uid, pReq->tbName, pSchema, pRsp) < 0) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->tbName, version); + } else { + for (int32_t i = 0; i < pEntry->colCmpr.nCols; i++) { + SColCmpr *p = &pEntry->colCmpr.pColCmpr[i]; + pRsp->pSchemaExt[i].colId = p->id; + pRsp->pSchemaExt[i].compress = p->alg; + } + } + + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); +} + +static int32_t metaCheckUpdateTableTagValReq(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { + int32_t code = 0; + + // check tag name + if (NULL == pReq->tagName || strlen(pReq->tagName) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid tag name:%s, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->tagName, version); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + // check name + void *value = NULL; + int32_t valueSize = 0; + code = tdbTbGet(pMeta->pNameIdx, pReq->tbName, strlen(pReq->tbName) + 1, &value, &valueSize); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + code = TSDB_CODE_TDB_TABLE_NOT_EXIST; + TAOS_RETURN(code); + } + tdbFreeClear(value); + + TAOS_RETURN(code); +} + +int32_t metaUpdateTableTagValue(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + + // check request + code = metaCheckUpdateTableTagValReq(pMeta, version, pReq); + if (code) { + TAOS_RETURN(code); + } + + // fetch child entry + SMetaEntry *pChild = NULL; + code = metaFetchEntryByName(pMeta, pReq->tbName, &pChild); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + TAOS_RETURN(code); + } + + if (pChild->type != TSDB_CHILD_TABLE) { + metaError("vgId:%d, %s failed at %s:%d since table %s is not a child table, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->tbName, version); + metaFetchEntryFree(&pChild); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + // fetch super entry + SMetaEntry *pSuper = NULL; + code = metaFetchEntryByUid(pMeta, pChild->ctbEntry.suid, &pSuper); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since super table uid %" PRId64 " not found, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pChild->ctbEntry.suid, version); + metaFetchEntryFree(&pChild); + TAOS_RETURN(TSDB_CODE_INTERNAL_ERROR); + } + + // search the tag to update + SSchemaWrapper *pTagSchema = &pSuper->stbEntry.schemaTag; + SSchema *pColumn = NULL; + int32_t iColumn = 0; + for (int32_t i = 0; i < pTagSchema->nCols; i++) { + if (strncmp(pTagSchema->pSchema[i].name, pReq->tagName, TSDB_COL_NAME_LEN) == 0) { + pColumn = &pTagSchema->pSchema[i]; + iColumn = i; + break; + } + } + + if (NULL == pColumn) { + metaError("vgId:%d, %s failed at %s:%d since tag %s not found in table %s, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->tagName, pReq->tbName, version); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(TSDB_CODE_VND_COL_NOT_EXISTS); + } + + // do change tag value + pChild->version = version; + if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) { + void *pNewTag = taosMemoryRealloc(pChild->ctbEntry.pTags, pReq->nTagVal); + if (NULL == pNewTag) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(terrno), version); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(terrno); + } + pChild->ctbEntry.pTags = pNewTag; + memcpy(pChild->ctbEntry.pTags, pReq->pTagVal, pReq->nTagVal); + } else { + STag *pOldTag = (STag *)pChild->ctbEntry.pTags; + + SArray *pTagArray = taosArrayInit(pTagSchema->nCols, sizeof(STagVal)); + if (NULL == pTagArray) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(terrno), version); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(terrno); + } + + for (int32_t i = 0; i < pTagSchema->nCols; i++) { + STagVal value = { + .type = pTagSchema->pSchema[i].type, + .cid = pTagSchema->pSchema[i].colId, + }; + + if (iColumn == i) { + if (pReq->isNull) { + continue; + } + if (IS_VAR_DATA_TYPE(value.type)) { + value.pData = pReq->pTagVal; + value.nData = pReq->nTagVal; + } else { + memcpy(&value.i64, pReq->pTagVal, pReq->nTagVal); + } + } else if (!tTagGet(pOldTag, &value)) { + continue; + } + + if (NULL == taosArrayPush(pTagArray, &value)) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(terrno), version); + taosArrayDestroy(pTagArray); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(terrno); + } + } + + STag *pNewTag = NULL; + code = tTagNew(pTagArray, pTagSchema->version, false, &pNewTag); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(code), version); + taosArrayDestroy(pTagArray); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(code); + } + taosArrayDestroy(pTagArray); + taosMemoryFree(pChild->ctbEntry.pTags); + pChild->ctbEntry.pTags = (uint8_t *)pNewTag; + } + + // do handle entry + code = metaHandleEntry2(pMeta, pChild); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pChild->uid, pReq->tbName, version); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(code); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->tbName, + pChild->uid, version); + } + + // free resource and return + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(code); +} + +static int32_t metaCheckUpdateTableMultiTagValueReq(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { + int32_t code = 0; + + // check tag name + if (NULL == pReq->pMultiTag || taosArrayGetSize(pReq->pMultiTag) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid tag name, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, version); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + // check name + void *value = NULL; + int32_t valueSize = 0; + code = tdbTbGet(pMeta->pNameIdx, pReq->tbName, strlen(pReq->tbName) + 1, &value, &valueSize); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + code = TSDB_CODE_TDB_TABLE_NOT_EXIST; + TAOS_RETURN(code); + } + tdbFreeClear(value); + + if (taosArrayGetSize(pReq->pMultiTag) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid tag name, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, version); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + TAOS_RETURN(code); +} + +int32_t metaUpdateTableMultiTagValue(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + + code = metaCheckUpdateTableMultiTagValueReq(pMeta, version, pReq); + if (code) { + TAOS_RETURN(code); + } + + // fetch child entry + SMetaEntry *pChild = NULL; + code = metaFetchEntryByName(pMeta, pReq->tbName, &pChild); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + TAOS_RETURN(code); + } + + if (pChild->type != TSDB_CHILD_TABLE) { + metaError("vgId:%d, %s failed at %s:%d since table %s is not a child table, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->tbName, version); + metaFetchEntryFree(&pChild); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + // fetch super entry + SMetaEntry *pSuper = NULL; + code = metaFetchEntryByUid(pMeta, pChild->ctbEntry.suid, &pSuper); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since super table uid %" PRId64 " not found, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pChild->ctbEntry.suid, version); + metaFetchEntryFree(&pChild); + TAOS_RETURN(TSDB_CODE_INTERNAL_ERROR); + } + + // search the tags to update + SSchemaWrapper *pTagSchema = &pSuper->stbEntry.schemaTag; + + if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) { + metaError("vgId:%d, %s failed at %s:%d since table %s has no tag, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->tbName, version); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(TSDB_CODE_VND_COL_NOT_EXISTS); + } + + // do check if tag name exists + SHashObj *pTagTable = + taosHashInit(pTagSchema->nCols, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK); + if (pTagTable == NULL) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(terrno), version); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(terrno); + } + + for (int32_t i = 0; i < taosArrayGetSize(pReq->pMultiTag); i++) { + SMultiTagUpateVal *pTagVal = taosArrayGet(pReq->pMultiTag, i); + if (taosHashPut(pTagTable, pTagVal->tagName, strlen(pTagVal->tagName), pTagVal, sizeof(*pTagVal)) != 0) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(terrno), version); + taosHashCleanup(pTagTable); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(terrno); + } + } + + int32_t numOfChangedTags = 0; + for (int32_t i = 0; i < pTagSchema->nCols; i++) { + taosHashGet(pTagTable, pTagSchema->pSchema[i].name, strlen(pTagSchema->pSchema[i].name)) != NULL + ? numOfChangedTags++ + : 0; + } + if (numOfChangedTags < taosHashGetSize(pTagTable)) { + metaError("vgId:%d, %s failed at %s:%d since tag count mismatch, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, version); + taosHashCleanup(pTagTable); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(TSDB_CODE_VND_COL_NOT_EXISTS); + } + + // do change tag value + pChild->version = version; + const STag *pOldTag = (const STag *)pChild->ctbEntry.pTags; + SArray *pTagArray = taosArrayInit(pTagSchema->nCols, sizeof(STagVal)); + if (NULL == pTagArray) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(terrno), version); + taosHashCleanup(pTagTable); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(terrno); + } + + for (int32_t i = 0; i < pTagSchema->nCols; i++) { + SSchema *pCol = &pTagSchema->pSchema[i]; + STagVal value = { + .cid = pCol->colId, + }; + + SMultiTagUpateVal *pTagVal = taosHashGet(pTagTable, pCol->name, strlen(pCol->name)); + if (pTagVal == NULL) { + if (!tTagGet(pOldTag, &value)) { + continue; + } + } else { + value.type = pCol->type; + if (pTagVal->isNull) { + continue; + } + + if (IS_VAR_DATA_TYPE(pCol->type)) { + value.pData = pTagVal->pTagVal; + value.nData = pTagVal->nTagVal; + } else { + memcpy(&value.i64, pTagVal->pTagVal, pTagVal->nTagVal); + } + } + + if (taosArrayPush(pTagArray, &value) == NULL) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(terrno), version); + taosHashCleanup(pTagTable); + taosArrayDestroy(pTagArray); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(terrno); + } + } + + STag *pNewTag = NULL; + code = tTagNew(pTagArray, pTagSchema->version, false, &pNewTag); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(code), version); + taosHashCleanup(pTagTable); + taosArrayDestroy(pTagArray); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(code); + } + taosArrayDestroy(pTagArray); + taosMemoryFree(pChild->ctbEntry.pTags); + pChild->ctbEntry.pTags = (uint8_t *)pNewTag; + + // do handle entry + code = metaHandleEntry2(pMeta, pChild); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pChild->uid, pReq->tbName, version); + taosHashCleanup(pTagTable); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(code); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->tbName, + pChild->uid, version); + } + + taosHashCleanup(pTagTable); + metaFetchEntryFree(&pChild); + metaFetchEntryFree(&pSuper); + TAOS_RETURN(code); +} + +static int32_t metaCheckUpdateTableOptionsReq(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + + if (pReq->tbName == NULL || strlen(pReq->tbName) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid table name, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, version); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + return code; +} + +int32_t metaUpdateTableOptions2(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { + int32_t code = 0; + + code = metaCheckUpdateTableOptionsReq(pMeta, version, pReq); + if (code) { + TAOS_RETURN(code); + } + + // fetch entry + SMetaEntry *pEntry = NULL; + code = metaFetchEntryByName(pMeta, pReq->tbName, &pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + TAOS_RETURN(code); + } + + // do change the entry + pEntry->version = version; + if (pEntry->type == TSDB_CHILD_TABLE) { + if (pReq->updateTTL) { + pEntry->ctbEntry.ttlDays = pReq->newTTL; + } + if (pReq->newCommentLen >= 0) { + char *pNewComment = NULL; + if (pReq->newCommentLen) { + pNewComment = taosMemoryRealloc(pEntry->ctbEntry.comment, pReq->newCommentLen + 1); + if (NULL == pNewComment) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(terrno), version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(terrno); + } + memcpy(pNewComment, pReq->newComment, pReq->newCommentLen + 1); + } else { + taosMemoryFreeClear(pEntry->ctbEntry.comment); + } + pEntry->ctbEntry.comment = pNewComment; + pEntry->ctbEntry.commentLen = pReq->newCommentLen; + } + } else if (pEntry->type == TSDB_NORMAL_TABLE) { + if (pReq->updateTTL) { + pEntry->ntbEntry.ttlDays = pReq->newTTL; + } + if (pReq->newCommentLen >= 0) { + char *pNewComment = NULL; + if (pReq->newCommentLen > 0) { + pNewComment = taosMemoryRealloc(pEntry->ntbEntry.comment, pReq->newCommentLen + 1); + if (NULL == pNewComment) { + metaError("vgId:%d, %s failed at %s:%d since %s, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, __FILE__, + __LINE__, tstrerror(terrno), version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(terrno); + } + memcpy(pNewComment, pReq->newComment, pReq->newCommentLen + 1); + } else { + taosMemoryFreeClear(pEntry->ntbEntry.comment); + } + pEntry->ntbEntry.comment = pNewComment; + pEntry->ntbEntry.commentLen = pReq->newCommentLen; + } + } else { + metaError("vgId:%d, %s failed at %s:%d since table %s type %d is invalid, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->tbName, pEntry->type, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + // do handle entry + code = metaHandleEntry2(pMeta, pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->tbName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->tbName, + pEntry->uid, version); + } + + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); +} + +int32_t metaUpdateTableColCompress2(SMeta *pMeta, int64_t version, SVAlterTbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + + if (NULL == pReq->tbName || strlen(pReq->tbName) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid table name, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, version); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + SMetaEntry *pEntry = NULL; + code = metaFetchEntryByName(pMeta, pReq->tbName, &pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->tbName, version); + TAOS_RETURN(code); + } + + if (pEntry->version >= version) { + metaError("vgId:%d, %s failed at %s:%d since table %s version %" PRId64 " is not less than %" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->tbName, pEntry->version, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_PARA); + } + + if (pEntry->type != TSDB_NORMAL_TABLE && pEntry->type != TSDB_SUPER_TABLE) { + metaError("vgId:%d, %s failed at %s:%d since table %s type %d is invalid, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->tbName, pEntry->type, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + // do change the entry + int8_t updated = 0; + SColCmprWrapper *wp = &pEntry->colCmpr; + for (int32_t i = 0; i < wp->nCols; i++) { + SColCmpr *p = &wp->pColCmpr[i]; + if (p->id == pReq->colId) { + uint32_t dst = 0; + updated = tUpdateCompress(p->alg, pReq->compress, TSDB_COLVAL_COMPRESS_DISABLED, TSDB_COLVAL_LEVEL_DISABLED, + TSDB_COLVAL_LEVEL_MEDIUM, &dst); + if (updated > 0) { + p->alg = dst; + } + } + } + + if (updated == 0) { + code = TSDB_CODE_VND_COLUMN_COMPRESS_ALREADY_EXIST; + metaError("vgId:%d, %s failed at %s:%d since column %d compress level is not changed, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->colId, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } else if (updated < 0) { + code = TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR; + metaError("vgId:%d, %s failed at %s:%d since column %d compress level is invalid, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->colId, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } + + pEntry->version = version; + + // do handle entry + code = metaHandleEntry2(pMeta, pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->tbName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->tbName, + pEntry->uid, version); + } + + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); +} + +int32_t metaAddIndexToSuperTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + + if (NULL == pReq->name || strlen(pReq->name) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid table name, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, version); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + SMetaEntry *pEntry = NULL; + code = metaFetchEntryByName(pMeta, pReq->name, &pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->name, version); + TAOS_RETURN(code); + } + + if (pEntry->type != TSDB_SUPER_TABLE) { + metaError("vgId:%d, %s failed at %s:%d since table %s type %d is invalid, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->name, pEntry->type, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + if (pEntry->uid != pReq->suid) { + metaError("vgId:%d, %s failed at %s:%d since table %s uid %" PRId64 " is not equal to %" PRId64 + ", version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, pEntry->uid, pReq->suid, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + // if (pEntry->stbEntry.schemaTag.version >= pReq->schemaTag.version) { + // metaError("vgId:%d, %s failed at %s:%d since table %s tag schema version %d is not less than %d, version:%" + // PRId64, + // TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, pEntry->stbEntry.schemaTag.version, + // pReq->schemaTag.version, version); + // metaFetchEntryFree(&pEntry); + // TAOS_RETURN(TSDB_CODE_INVALID_MSG); + // } + + // do change the entry + SSchemaWrapper *pOldTagSchema = &pEntry->stbEntry.schemaTag; + SSchemaWrapper *pNewTagSchema = &pReq->schemaTag; + if (pOldTagSchema->nCols == 1 && pOldTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) { + metaError("vgId:%d, %s failed at %s:%d since table %s has no tag, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->name, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_COL_NOT_EXISTS); + } + + if (pOldTagSchema->nCols != pNewTagSchema->nCols) { + metaError( + "vgId:%d, %s failed at %s:%d since table %s tag schema column count %d is not equal to %d, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, pOldTagSchema->nCols, pNewTagSchema->nCols, + version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + // if (pOldTagSchema->version >= pNewTagSchema->version) { + // metaError("vgId:%d, %s failed at %s:%d since table %s tag schema version %d is not less than %d, version:%" + // PRId64, + // TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, pOldTagSchema->version, + // pNewTagSchema->version, version); + // metaFetchEntryFree(&pEntry); + // TAOS_RETURN(TSDB_CODE_INVALID_MSG); + // } + + int32_t numOfChangedTags = 0; + for (int32_t i = 0; i < pOldTagSchema->nCols; i++) { + SSchema *pOldColumn = pOldTagSchema->pSchema + i; + SSchema *pNewColumn = pNewTagSchema->pSchema + i; + + if (pOldColumn->type != pNewColumn->type || pOldColumn->colId != pNewColumn->colId || + strncmp(pOldColumn->name, pNewColumn->name, sizeof(pNewColumn->name))) { + metaError("vgId:%d, %s failed at %s:%d since table %s tag schema column %d is not equal, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, i, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + if (IS_IDX_ON(pNewColumn) && !IS_IDX_ON(pOldColumn)) { + numOfChangedTags++; + SSCHMEA_SET_IDX_ON(pOldColumn); + } else if (!IS_IDX_ON(pNewColumn) && IS_IDX_ON(pOldColumn)) { + metaError("vgId:%d, %s failed at %s:%d since table %s tag schema column %d is not equal, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, i, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + } + + if (numOfChangedTags != 1) { + metaError( + "vgId:%d, %s failed at %s:%d since table %s tag schema column count %d is not equal to 1, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->name, numOfChangedTags, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + pEntry->version = version; + pEntry->stbEntry.schemaTag.version = pNewTagSchema->version; + + // do handle the entry + code = metaHandleEntry2(pMeta, pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->name, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->name, + pEntry->uid, version); + } + + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); +} + +int32_t metaDropIndexFromSuperTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + + if (strlen(pReq->colName) == 0 || strlen(pReq->stb) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid table name or column name, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, version); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + SMetaEntry *pEntry = NULL; + code = metaFetchEntryByUid(pMeta, pReq->stbUid, &pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->stb, version); + TAOS_RETURN(code); + } + + if (TSDB_SUPER_TABLE != pEntry->type) { + metaError("vgId:%d, %s failed at %s:%d since table %s type %d is invalid, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->stb, pEntry->type, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + SSchemaWrapper *pTagSchema = &pEntry->stbEntry.schemaTag; + if (pTagSchema->nCols == 1 && pTagSchema->pSchema[0].type == TSDB_DATA_TYPE_JSON) { + metaError("vgId:%d, %s failed at %s:%d since table %s has no tag, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->stb, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + // search and set the tag index off + int32_t numOfChangedTags = 0; + for (int32_t i = 0; i < pTagSchema->nCols; i++) { + SSchema *pCol = pTagSchema->pSchema + i; + if (0 == strncmp(pCol->name, pReq->colName, sizeof(pReq->colName))) { + if (!IS_IDX_ON(pCol)) { + metaError("vgId:%d, %s failed at %s:%d since table %s column %s is not indexed, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->stb, pReq->colName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + numOfChangedTags++; + SSCHMEA_SET_IDX_OFF(pCol); + break; + } + } + + if (numOfChangedTags != 1) { + metaError("vgId:%d, %s failed at %s:%d since table %s column %s is not found, version:%" PRId64, + TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__, pReq->stb, pReq->colName, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_COL_NOT_EXISTS); + } + + // do handle the entry + pEntry->version = version; + pTagSchema->version++; + code = metaHandleEntry2(pMeta, pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pEntry->uid, pReq->stb, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->stb, + pEntry->uid, version); + } + + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); +} + +int32_t metaAlterSuperTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) { + int32_t code = TSDB_CODE_SUCCESS; + + if (NULL == pReq->name || strlen(pReq->name) == 0) { + metaError("vgId:%d, %s failed at %s:%d since invalid table name, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, version); + TAOS_RETURN(TSDB_CODE_INVALID_MSG); + } + + SMetaEntry *pEntry = NULL; + code = metaFetchEntryByName(pMeta, pReq->name, &pEntry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table %s not found, version:%" PRId64, TD_VID(pMeta->pVnode), __func__, + __FILE__, __LINE__, pReq->name, version); + TAOS_RETURN(TSDB_CODE_TDB_STB_NOT_EXIST); + } + + if (pEntry->type != TSDB_SUPER_TABLE) { + metaError("vgId:%d, %s failed at %s:%d since table %s type %d is invalid, version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, pReq->name, pEntry->type, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(TSDB_CODE_VND_INVALID_TABLE_ACTION); + } + + SMetaEntry entry = { + .version = version, + .type = TSDB_SUPER_TABLE, + .uid = pReq->suid, + .name = pReq->name, + .stbEntry.schemaRow = pReq->schemaRow, + .stbEntry.schemaTag = pReq->schemaTag, + .colCmpr = pReq->colCmpr, + }; + TABLE_SET_COL_COMPRESSED(entry.flags); + + // do handle the entry + code = metaHandleEntry2(pMeta, &entry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " name:%s version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), pReq->suid, pReq->name, version); + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); + } else { + metaInfo("vgId:%d, table %s uid %" PRId64 " is updated, version:%" PRId64, TD_VID(pMeta->pVnode), pReq->name, + pReq->suid, version); + } + + metaFetchEntryFree(&pEntry); + TAOS_RETURN(code); +} + +int32_t metaDropMultipleTables(SMeta *pMeta, int64_t version, SArray *uidArray) { + int32_t code = 0; + + if (taosArrayGetSize(uidArray) == 0) { + return TSDB_CODE_SUCCESS; + } + + for (int32_t i = 0; i < taosArrayGetSize(uidArray); i++) { + tb_uid_t uid = *(tb_uid_t *)taosArrayGet(uidArray, i); + SMetaInfo info; + code = metaGetInfo(pMeta, uid, &info, NULL); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since table uid %" PRId64 " not found, code:%d", TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, uid, code); + return code; + } + + SMetaEntry entry = { + .version = version, + .uid = uid, + }; + + if (info.suid == 0) { + entry.type = -TSDB_NORMAL_TABLE; + } else if (info.suid == uid) { + entry.type = -TSDB_SUPER_TABLE; + } else { + entry.type = -TSDB_CHILD_TABLE; + } + code = metaHandleEntry2(pMeta, &entry); + if (code) { + metaError("vgId:%d, %s failed at %s:%d since %s, uid:%" PRId64 " version:%" PRId64, TD_VID(pMeta->pVnode), + __func__, __FILE__, __LINE__, tstrerror(code), uid, version); + return code; + } + } + return code; +} \ No newline at end of file diff --git a/source/dnode/vnode/src/sma/smaTimeRange.c b/source/dnode/vnode/src/sma/smaTimeRange.c index 86246aace1..c9868f0398 100644 --- a/source/dnode/vnode/src/sma/smaTimeRange.c +++ b/source/dnode/vnode/src/sma/smaTimeRange.c @@ -129,7 +129,7 @@ static int32_t tdProcessTSmaCreateImpl(SSma *pSma, int64_t ver, const char *pMsg pReq.schemaRow = pCfg->schemaRow; pReq.schemaTag = pCfg->schemaTag; - TAOS_CHECK_EXIT(metaCreateSTable(SMA_META(pSma), ver, &pReq)); + TAOS_CHECK_EXIT(metaCreateSuperTable(SMA_META(pSma), ver, &pReq)); } else { TAOS_CHECK_EXIT(TSDB_CODE_TSMA_INVALID_STAT); } @@ -204,7 +204,7 @@ int32_t smaBlockToSubmit(SVnode *pVnode, const SArray *pBlocks, const STSchema * continue; } - if( taosArrayPush(pReq->aSubmitTbData, &tbData) == NULL) { + if (taosArrayPush(pReq->aSubmitTbData, &tbData) == NULL) { code = terrno; continue; } diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index ce84f08d3a..8fd0d47969 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -1050,7 +1050,7 @@ _exit: TAOS_RETURN(code); } -int32_t tsdbCacheNewTable(STsdb *pTsdb, tb_uid_t uid, tb_uid_t suid, SSchemaWrapper *pSchemaRow) { +int32_t tsdbCacheNewTable(STsdb *pTsdb, tb_uid_t uid, tb_uid_t suid, const SSchemaWrapper *pSchemaRow) { int32_t code = 0; (void)taosThreadMutexLock(&pTsdb->lruMutex); diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c index d9b41869c7..5ecea42d2f 100644 --- a/source/dnode/vnode/src/vnd/vnodeSvr.c +++ b/source/dnode/vnode/src/vnd/vnodeSvr.c @@ -491,7 +491,7 @@ static int32_t vnodePreProcessArbCheckSyncMsg(SVnode *pVnode, SRpcMsg *pMsg) { return code; } -int32_t vnodePreProcessDropTbMsg(SVnode* pVnode, SRpcMsg* pMsg) { +int32_t vnodePreProcessDropTbMsg(SVnode *pVnode, SRpcMsg *pMsg) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; int32_t size = 0; @@ -514,14 +514,14 @@ int32_t vnodePreProcessDropTbMsg(SVnode* pVnode, SRpcMsg* pMsg) { } for (int32_t i = 0; i < receivedBatchReqs.nReqs; ++i) { - SVDropTbReq* pReq = receivedBatchReqs.pReqs + i; - tb_uid_t uid = metaGetTableEntryUidByName(pVnode->pMeta, pReq->name); + SVDropTbReq *pReq = receivedBatchReqs.pReqs + i; + tb_uid_t uid = metaGetTableEntryUidByName(pVnode->pMeta, pReq->name); if (uid == 0) { vWarn("vgId:%d, preprocess drop ctb: %s not found", TD_VID(pVnode), pReq->name); continue; } pReq->uid = uid; - vDebug("vgId:%d %s for: %s, uid: %"PRId64, TD_VID(pVnode), __func__, pReq->name, pReq->uid); + vDebug("vgId:%d %s for: %s, uid: %" PRId64, TD_VID(pVnode), __func__, pReq->name, pReq->uid); if (taosArrayPush(sentBatchReqs.pArray, pReq) == NULL) { code = terrno; goto _exit; @@ -1038,7 +1038,7 @@ static int32_t vnodeProcessDropTtlTbReq(SVnode *pVnode, int64_t ver, void *pReq, } if (ttlReq.nUids > 0) { - int32_t code = metaDropTables(pVnode->pMeta, ttlReq.pTbUids); + int32_t code = metaDropMultipleTables(pVnode->pMeta, ver, ttlReq.pTbUids); if (code) return code; code = tqUpdateTbUidList(pVnode->pTq, ttlReq.pTbUids, false); @@ -1150,7 +1150,7 @@ static int32_t vnodeProcessCreateStbReq(SVnode *pVnode, int64_t ver, void *pReq, goto _err; } - code = metaCreateSTable(pVnode->pMeta, ver, &req); + code = metaCreateSuperTable(pVnode->pMeta, ver, &req); if (code) { pRsp->code = code; goto _err; @@ -1238,7 +1238,7 @@ static int32_t vnodeProcessCreateTbReq(SVnode *pVnode, int64_t ver, void *pReq, } // do create table - if (metaCreateTable(pVnode->pMeta, ver, pCreateReq, &cRsp.pMeta) < 0) { + if (metaCreateTable2(pVnode->pMeta, ver, pCreateReq, &cRsp.pMeta) < 0) { if (pCreateReq->flags & TD_CREATE_IF_NOT_EXISTS && terrno == TSDB_CODE_TDB_TABLE_ALREADY_EXIST) { cRsp.code = TSDB_CODE_SUCCESS; } else { @@ -1344,7 +1344,7 @@ static int32_t vnodeProcessAlterStbReq(SVnode *pVnode, int64_t ver, void *pReq, return code; } - code = metaAlterSTable(pVnode->pMeta, ver, &req); + code = metaAlterSuperTable(pVnode->pMeta, ver, &req); if (code) { pRsp->code = code; tDecoderClear(&dc); @@ -1376,7 +1376,7 @@ static int32_t vnodeProcessDropStbReq(SVnode *pVnode, int64_t ver, void *pReq, i // process request tbUidList = taosArrayInit(8, sizeof(int64_t)); if (tbUidList == NULL) goto _exit; - if (metaDropSTable(pVnode->pMeta, ver, &req, tbUidList) < 0) { + if (metaDropSuperTable(pVnode->pMeta, ver, &req) < 0) { rcode = terrno; goto _exit; } @@ -1490,7 +1490,7 @@ static int32_t vnodeProcessDropTbReq(SVnode *pVnode, int64_t ver, void *pReq, in tb_uid_t tbUid = 0; /* code */ - ret = metaDropTable(pVnode->pMeta, ver, pDropTbReq, tbUids, &tbUid); + ret = metaDropTable2(pVnode->pMeta, ver, pDropTbReq); if (ret < 0) { if (pDropTbReq->igNotExists && terrno == TSDB_CODE_TDB_TABLE_NOT_EXIST) { dropTbRsp.code = TSDB_CODE_SUCCESS; @@ -1966,7 +1966,7 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t ver, void *pReq, in SVCreateTbRsp *pCreateTbRsp = taosArrayReserve(pSubmitRsp->aCreateTbRsp, 1); // create table - if (metaCreateTable(pVnode->pMeta, ver, pSubmitTbData->pCreateTbReq, &pCreateTbRsp->pMeta) == 0) { + if (metaCreateTable2(pVnode->pMeta, ver, pSubmitTbData->pCreateTbReq, &pCreateTbRsp->pMeta) == 0) { // create table success if (newTbUids == NULL && @@ -2433,7 +2433,7 @@ static int32_t vnodeProcessCreateIndexReq(SVnode *pVnode, int64_t ver, void *pRe return terrno = TSDB_CODE_INVALID_MSG; } - code = metaAddIndexToSTable(pVnode->pMeta, ver, &req); + code = metaAddIndexToSuperTable(pVnode->pMeta, ver, &req); if (code) { pRsp->code = code; goto _err; @@ -2458,7 +2458,7 @@ static int32_t vnodeProcessDropIndexReq(SVnode *pVnode, int64_t ver, void *pReq, return code; } - code = metaDropIndexFromSTable(pVnode->pMeta, ver, &req); + code = metaDropIndexFromSuperTable(pVnode->pMeta, ver, &req); if (code) { pRsp->code = code; return code; @@ -2584,4 +2584,3 @@ _OVER: int32_t vnodeAsyncCompact(SVnode *pVnode, int64_t ver, void *pReq, int32_t len, SRpcMsg *pRsp) { return 0; } int32_t tsdbAsyncCompact(STsdb *tsdb, const STimeWindow *tw, bool sync) { return 0; } #endif - diff --git a/source/libs/tdb/inc/tdb.h b/source/libs/tdb/inc/tdb.h index 52ff749191..01d5daf9f5 100644 --- a/source/libs/tdb/inc/tdb.h +++ b/source/libs/tdb/inc/tdb.h @@ -88,6 +88,11 @@ void tdbTxnCloseImpl(TXN *pTxn); // other void tdbFree(void *); +#define tdbFreeClear(p) \ + do { \ + tdbFree(p); \ + p = NULL; \ + } while (0) typedef struct hashset_st *hashset_t;