From 60ffaddc92da61b2f286cbd81e0d6c5138a682a5 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Thu, 5 Dec 2024 16:57:25 +0800 Subject: [PATCH] fix: CI issue --- source/dnode/vnode/src/meta/metaEntry2.c | 305 ++++++++++++++++++----- source/dnode/vnode/src/meta/metaTable2.c | 218 ++++++++++++++++ 2 files changed, 458 insertions(+), 65 deletions(-) diff --git a/source/dnode/vnode/src/meta/metaEntry2.c b/source/dnode/vnode/src/meta/metaEntry2.c index b500ff474c..33694c6443 100644 --- a/source/dnode/vnode/src/meta/metaEntry2.c +++ b/source/dnode/vnode/src/meta/metaEntry2.c @@ -17,8 +17,32 @@ 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_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 { + EMetaTable table; + EMetaTableOp op; +} SMetaTableOp; + // Entry Table -static int32_t metaEntryTableInsert(SMeta *pMeta, const SMetaEntry *pEntry) { +static int32_t metaEntryTableUpsert(SMeta *pMeta, const SMetaEntry *pEntry, EMetaTableOp op) { int32_t code = TSDB_CODE_SUCCESS; int32_t vgId = TD_VID(pMeta->pVnode); void *value = NULL; @@ -53,7 +77,13 @@ static int32_t metaEntryTableInsert(SMeta *pMeta, const SMetaEntry *pEntry) { tEncoderClear(&encoder); // put to tdb - code = tdbTbInsert(pMeta->pTbDb, &key, sizeof(key), value, valueSize, pMeta->txn); + 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 { + code = TSDB_CODE_INVALID_PARA; + } if (TSDB_CODE_SUCCESS != code) { metaErr(vgId, code); } @@ -61,7 +91,15 @@ static int32_t metaEntryTableInsert(SMeta *pMeta, const SMetaEntry *pEntry) { return code; } -static int32_t metaEntryTableDrop(SMeta *pMeta, const SMetaEntry *pEntry) { +static int32_t metaEntryTableInsert(SMeta *pMeta, const SMetaEntry *pEntry) { + return metaEntryTableUpsert(pMeta, pEntry, META_TABLE_OP_INSERT); +} + +static int32_t metaEntryTableUpdate(SMeta *pMeta, const SMetaEntry *pEntry) { + return metaEntryTableUpsert(pMeta, pEntry, META_TABLE_OP_UPDATA); +} + +static int32_t metaEntryTableDelete(SMeta *pMeta, const SMetaEntry *pEntry) { int32_t code = TSDB_CODE_SUCCESS; int32_t vgId = TD_VID(pMeta->pVnode); @@ -71,7 +109,7 @@ static int32_t metaEntryTableDrop(SMeta *pMeta, const SMetaEntry *pEntry) { } // Schema Table -static int32_t metaSchemaTableInsert(SMeta *pMeta, const SMetaEntry *pEntry) { +static int32_t metaSchemaTableUpsert(SMeta *pMeta, const SMetaEntry *pEntry, EMetaTableOp op) { int32_t code = TSDB_CODE_SUCCESS; int32_t vgId = TD_VID(pMeta->pVnode); SEncoder encoder = {0}; @@ -115,7 +153,13 @@ static int32_t metaSchemaTableInsert(SMeta *pMeta, const SMetaEntry *pEntry) { tEncoderClear(&encoder); // put to tdb - code = tdbTbInsert(pMeta->pSkmDb, &key, sizeof(key), value, valueSize, pMeta->txn); + 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); } @@ -123,6 +167,14 @@ static int32_t metaSchemaTableInsert(SMeta *pMeta, const SMetaEntry *pEntry) { return code; } +static int32_t metaSchemaTableInsert(SMeta *pMeta, const SMetaEntry *pEntry) { + return metaSchemaTableUpsert(pMeta, pEntry, META_TABLE_OP_INSERT); +} + +static int32_t metaSchemaTableUpdate(SMeta *pMeta, const SMetaEntry *pEntry) { + return metaSchemaTableUpsert(pMeta, pEntry, META_TABLE_OP_UPDATA); +} + // Uid Index static void metaBuildEntryInfo(const SMetaEntry *pEntry, SMetaInfo *pInfo) { pInfo->uid = pEntry->uid; @@ -138,7 +190,8 @@ static void metaBuildEntryInfo(const SMetaEntry *pEntry, SMetaInfo *pInfo) { pInfo->skmVer = pEntry->ntbEntry.schemaRow.version; } } -static int32_t metaUidIdxUpsert(SMeta *pMeta, const SMetaEntry *pEntry) { + +static int32_t metaUidIdxUpsert(SMeta *pMeta, const SMetaEntry *pEntry, EMetaTableOp op) { int32_t code = TSDB_CODE_SUCCESS; int32_t vgId = TD_VID(pMeta->pVnode); @@ -152,30 +205,48 @@ static int32_t metaUidIdxUpsert(SMeta *pMeta, const SMetaEntry *pEntry) { // put to tdb SUidIdxVal value = { - .suid = 0, - .skmVer = 0, + .suid = info.suid, + .skmVer = info.skmVer, .version = pEntry->version, }; - code = tdbTbUpsert(pMeta->pUidIdx, &pEntry->uid, sizeof(pEntry->uid), &value, sizeof(value), pMeta->txn); + 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 SMetaEntry *pEntry) { + return metaUidIdxUpsert(pMeta, pEntry, META_TABLE_OP_INSERT); +} + +static int32_t metaUidIdxUpdate(SMeta *pMeta, const SMetaEntry *pEntry) { + return metaUidIdxUpsert(pMeta, pEntry, META_TABLE_OP_UPDATA); +} + // Name Index -static int32_t metaNameIdxInsert(SMeta *pMeta, const SMetaEntry *pEntry) { - int32_t code = tdbTbInsert(pMeta->pNameIdx, pEntry->name, strlen(pEntry->name) + 1, &pEntry->uid, sizeof(pEntry->uid), - pMeta->txn); - if (code) { - metaErr(TD_VID(pMeta->pVnode), code); +static int32_t metaNameIdxUpsert(SMeta *pMeta, const SMetaEntry *pEntry, EMetaTableOp op) { + int32_t code = TSDB_CODE_SUCCESS; + 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 SMetaEntry *pEntry) { + return metaNameIdxUpsert(pMeta, pEntry, META_TABLE_OP_INSERT); +} + static int32_t metaNameIdxDelete(SMeta *pMeta, const SMetaEntry *pEntry) { - int32_t code = tdbTbDelete(pMeta->pNameIdx, pEntry->name, strlen(pEntry->name) + 1, pMeta->txn); - if (code) { - metaErr(TD_VID(pMeta->pVnode), code); - } - return code; + // TODO + return 0; } // Suid Index @@ -189,51 +260,109 @@ static int32_t metaSUidIdxInsert(SMeta *pMeta, const SMetaEntry *pEntry) { // Tag Index +// Btime Index +static int32_t metaBtimeIdxUpsert(SMeta *pMeta, const SMetaEntry *pEntry, EMetaTableOp op) { + 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) { + return tdbTbInsert(pMeta->pBtimeIdx, &key, sizeof(key), NULL, 0, pMeta->txn); + } else if (META_TABLE_OP_UPDATA == op) { + return tdbTbUpsert(pMeta->pBtimeIdx, &key, sizeof(key), NULL, 0, pMeta->txn); + } else { + return TSDB_CODE_INVALID_PARA; + } +} + +static int32_t metaBtimeIdxInsert(SMeta *pMeta, const SMetaEntry *pEntry) { + return metaBtimeIdxUpsert(pMeta, pEntry, META_TABLE_OP_INSERT); +} + +static int32_t (*metaTableOpFn[META_TABLE_MAX][META_TABLE_OP_MAX])(SMeta *pMeta, const SMetaEntry *pEntry) = { + [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] = NULL, + [META_TABLE_OP_DELETE] = NULL, + }, + [META_UID_IDX] = + { + [META_TABLE_OP_INSERT] = metaUidIdxInsert, + [META_TABLE_OP_UPDATA] = metaUidIdxUpdate, + [META_TABLE_OP_DELETE] = NULL, + }, + [META_NAME_IDX] = + { + [META_TABLE_OP_INSERT] = metaNameIdxInsert, + [META_TABLE_OP_UPDATA] = NULL, + [META_TABLE_OP_DELETE] = NULL, + }, + [META_SUID_IDX] = + { + [META_TABLE_OP_INSERT] = metaSUidIdxInsert, + [META_TABLE_OP_UPDATA] = NULL, + [META_TABLE_OP_DELETE] = NULL, + }, + [META_TAG_IDX] = + { + [META_TABLE_OP_INSERT] = NULL, + [META_TABLE_OP_UPDATA] = NULL, + [META_TABLE_OP_DELETE] = NULL, + }, + [META_BTIME_IDX] = + { + [META_TABLE_OP_INSERT] = metaBtimeIdxInsert, + [META_TABLE_OP_UPDATA] = NULL, + [META_TABLE_OP_DELETE] = NULL, + }, + [META_TTL_IDX] = + { + [META_TABLE_OP_INSERT] = NULL, + [META_TABLE_OP_UPDATA] = NULL, + [META_TABLE_OP_DELETE] = NULL, + }, +}; + static int32_t metaHandleSuperTableCreateImpl(SMeta *pMeta, const SMetaEntry *pEntry) { int32_t code = TSDB_CODE_SUCCESS; - int32_t vgId = TD_VID(pMeta->pVnode); - // Insert into Entry Table - code = metaEntryTableInsert(pMeta, pEntry); - if (TSDB_CODE_SUCCESS != code) { - metaErr(vgId, code); - return code; - } + SMetaTableOp ops[] = { + {META_ENTRY_TABLE, META_TABLE_OP_INSERT}, // + {META_SCHEMA_TABLE, META_TABLE_OP_INSERT}, // + {META_UID_IDX, META_TABLE_OP_INSERT}, // + {META_NAME_IDX, META_TABLE_OP_INSERT}, // + {META_SUID_IDX, META_TABLE_OP_INSERT}, // + }; - // Insert into Schema Table - code = metaSchemaTableInsert(pMeta, pEntry); - if (TSDB_CODE_SUCCESS != code) { - metaErr(vgId, code); - return code; - } + for (int i = 0; i < sizeof(ops) / sizeof(ops[0]); i++) { + SMetaTableOp *op = &ops[i]; - // Insert to Uid Index - code = metaUidIdxUpsert(pMeta, pEntry); - if (TSDB_CODE_SUCCESS != code) { - metaErr(vgId, code); - return code; - } - - // Insert to Name Index - code = metaNameIdxInsert(pMeta, pEntry); - if (TSDB_CODE_SUCCESS != code) { - metaErr(vgId, code); - return code; - } - - // Insert to Suid Index - code = metaSUidIdxInsert(pMeta, pEntry); - if (TSDB_CODE_SUCCESS != code) { - metaErr(vgId, code); - return code; + code = metaTableOpFn[op->table][op->op](pMeta, pEntry); + 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; - int32_t vgId = TD_VID(pMeta->pVnode); metaWLock(pMeta); code = metaHandleSuperTableCreateImpl(pMeta, pEntry); @@ -243,14 +372,52 @@ static int32_t metaHandleSuperTableCreate(SMeta *pMeta, const SMetaEntry *pEntry pMeta->pVnode->config.vndStats.numOfSTables++; pMeta->changed = true; - metaInfo("vgId:%d, %s success, version:%" PRId64 " type:%d uid:%" PRId64 " name:%s", vgId, __func__, - pEntry->version, pEntry->type, pEntry->uid, pEntry->name); + 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(vgId, code); + 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_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]; + + code = metaTableOpFn[op->table][op->op](pMeta, pEntry); + 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; + + metaWLock(pMeta); + code = metaHandleNormalTableCreateImpl(pMeta, pEntry); + metaULock(pMeta); + + { + // TODO: other stuff + } + + return code; +} + static int32_t metaHandleNormalTableDrop(SMeta *pMeta, const SMetaEntry *pEntry) { int32_t code = TSDB_CODE_SUCCESS; // TODO @@ -287,45 +454,53 @@ int32_t metaHandleEntry2(SMeta *pMeta, const SMetaEntry *pEntry) { } switch (type) { - case TSDB_SUPER_TABLE: + case TSDB_SUPER_TABLE: { if (isExist) { // code = metaHandleSuperTableUpdate(pMeta, pEntry); } else { code = metaHandleSuperTableCreate(pMeta, pEntry); } break; - case TSDB_CHILD_TABLE: + } + case TSDB_CHILD_TABLE: { if (isExist) { // code = metaHandleChildTableUpdate(pMeta, pEntry); } else { // code = metaHandleChildTableCreate(pMeta, pEntry); } break; - case TSDB_NORMAL_TABLE: + } + case TSDB_NORMAL_TABLE: { if (isExist) { // code = metaHandleNormalTableUpdate(pMeta, pEntry); } else { - // code = metaHandleNormalTableCreate(pMeta, pEntry); + code = metaHandleNormalTableCreate(pMeta, pEntry); } break; - default: + } + default: { code = TSDB_CODE_INVALID_PARA; break; + } } } else { switch (type) { - case TSDB_SUPER_TABLE: + case TSDB_SUPER_TABLE: { // code = metaHandleSuperTableDrop(pMeta, pEntry); break; - case TSDB_CHILD_TABLE: + } + case TSDB_CHILD_TABLE: { // code = metaHandleChildTableDrop(pMeta, pEntry); break; - case TSDB_NORMAL_TABLE: + } + case TSDB_NORMAL_TABLE: { // code = metaHandleNormalTableDrop(pMeta, pEntry); break; - default: + } + default: { code = TSDB_CODE_INVALID_PARA; break; + } } } diff --git a/source/dnode/vnode/src/meta/metaTable2.c b/source/dnode/vnode/src/meta/metaTable2.c index 4e0b41fb93..d1a90455ff 100644 --- a/source/dnode/vnode/src/meta/metaTable2.c +++ b/source/dnode/vnode/src/meta/metaTable2.c @@ -131,8 +131,226 @@ int32_t metaCreateSuperTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq // Alter Super Table +// Create Child Table +static int32_t metaCreateChildTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq, STableMetaRsp **ppRsp) { + int32_t code = TSDB_CODE_SUCCESS; + // TODO + return code; + +#if 0 + SMetaEntry me = {0}; + SMetaReader mr = {0}; + int32_t ret; + + if (pReq->type == TSDB_CHILD_TABLE) { + tb_uid_t suid = metaGetTableEntryUidByName(pMeta, pReq->ctb.stbName); + if (suid != pReq->ctb.suid) { + return terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST; + } + } + + // validate req + metaReaderDoInit(&mr, pMeta, META_READER_LOCK); + if (metaGetTableEntryByName(&mr, pReq->name) == 0) { + if (pReq->type == TSDB_CHILD_TABLE && pReq->ctb.suid != mr.me.ctbEntry.suid) { + metaReaderClear(&mr); + return terrno = TSDB_CODE_TDB_TABLE_IN_OTHER_STABLE; + } + pReq->uid = mr.me.uid; + if (pReq->type == TSDB_CHILD_TABLE) { + pReq->ctb.suid = mr.me.ctbEntry.suid; + } + metaReaderClear(&mr); + return terrno = TSDB_CODE_TDB_TABLE_ALREADY_EXIST; + } else if (terrno == TSDB_CODE_PAR_TABLE_NOT_EXIST) { + terrno = TSDB_CODE_SUCCESS; + } + metaReaderClear(&mr); + + bool sysTbl = (pReq->type == TSDB_CHILD_TABLE) && metaTbInFilterCache(pMeta, pReq->ctb.stbName, 1); + + if (!sysTbl && ((terrno = grantCheck(TSDB_GRANT_TIMESERIES)) < 0)) goto _err; + + // build SMetaEntry + SVnodeStats *pStats = &pMeta->pVnode->config.vndStats; + me.version = version; + me.type = pReq->type; + me.uid = pReq->uid; + me.name = pReq->name; + me.ctbEntry.btime = pReq->btime; + me.ctbEntry.ttlDays = pReq->ttl; + me.ctbEntry.commentLen = pReq->commentLen; + me.ctbEntry.comment = pReq->comment; + me.ctbEntry.suid = pReq->ctb.suid; + me.ctbEntry.pTags = pReq->ctb.pTag; + + ++pStats->numOfCTables; + + if (!sysTbl) { + int32_t nCols = 0; + ret = metaGetStbStats(pMeta->pVnode, me.ctbEntry.suid, 0, &nCols); + if (ret < 0) { + metaError("vgId:%d, failed to get stb stats:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name, + pReq->ctb.suid, tstrerror(ret)); + } + pStats->numOfTimeSeries += nCols - 1; + } + + metaWLock(pMeta); + metaUpdateStbStats(pMeta, me.ctbEntry.suid, 1, 0); + ret = metaUidCacheClear(pMeta, me.ctbEntry.suid); + if (ret < 0) { + metaError("vgId:%d, failed to clear uid cache:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name, + pReq->ctb.suid, tstrerror(ret)); + } + ret = metaTbGroupCacheClear(pMeta, me.ctbEntry.suid); + if (ret < 0) { + metaError("vgId:%d, failed to clear group cache:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name, + pReq->ctb.suid, tstrerror(ret)); + } + metaULock(pMeta); + + if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { + ret = tsdbCacheNewTable(pMeta->pVnode->pTsdb, me.uid, me.ctbEntry.suid, NULL); + if (ret < 0) { + metaError("vgId:%d, failed to create table:%s since %s", TD_VID(pMeta->pVnode), pReq->name, tstrerror(ret)); + goto _err; + } + } + + if (metaHandleEntry(pMeta, &me) < 0) goto _err; + + metaTimeSeriesNotifyCheck(pMeta); + + if (pMetaRsp) { + *pMetaRsp = taosMemoryCalloc(1, sizeof(STableMetaRsp)); + + if (*pMetaRsp) { + (*pMetaRsp)->tableType = TSDB_CHILD_TABLE; + (*pMetaRsp)->tuid = pReq->uid; + (*pMetaRsp)->suid = pReq->ctb.suid; + strcpy((*pMetaRsp)->tbName, pReq->name); + } + } + + pMeta->changed = true; + metaDebug("vgId:%d, table:%s uid %" PRId64 " is created, type:%" PRId8, TD_VID(pMeta->pVnode), pReq->name, pReq->uid, + pReq->type); + return 0; + +_err: + metaError("vgId:%d, failed to create table:%s type:%s since %s", TD_VID(pMeta->pVnode), pReq->name, + pReq->type == TSDB_CHILD_TABLE ? "child table" : "normal table", tstrerror(terrno)); + return TSDB_CODE_FAILED; +#endif +} + +// Drop Child Table + +// Alter Child Table + // Create Normal Table +static int32_t metaCreateNormalTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq, STableMetaRsp **ppRsp) { + int32_t code = TSDB_CODE_SUCCESS; + +#if 0 + SMetaEntry me = {0}; + SMetaReader mr = {0}; + int32_t ret; + + // validate req + metaReaderDoInit(&mr, pMeta, META_READER_LOCK); + if (metaGetTableEntryByName(&mr, pReq->name) == 0) { + if (pReq->type == TSDB_CHILD_TABLE && pReq->ctb.suid != mr.me.ctbEntry.suid) { + metaReaderClear(&mr); + return terrno = TSDB_CODE_TDB_TABLE_IN_OTHER_STABLE; + } + pReq->uid = mr.me.uid; + if (pReq->type == TSDB_CHILD_TABLE) { + pReq->ctb.suid = mr.me.ctbEntry.suid; + } + metaReaderClear(&mr); + return terrno = TSDB_CODE_TDB_TABLE_ALREADY_EXIST; + } else if (terrno == TSDB_CODE_PAR_TABLE_NOT_EXIST) { + terrno = TSDB_CODE_SUCCESS; + } + metaReaderClear(&mr); + + bool sysTbl = (pReq->type == TSDB_CHILD_TABLE) && metaTbInFilterCache(pMeta, pReq->ctb.stbName, 1); + + if (!sysTbl && ((terrno = grantCheck(TSDB_GRANT_TIMESERIES)) < 0)) goto _err; + + // build SMetaEntry + SVnodeStats *pStats = &pMeta->pVnode->config.vndStats; + me.version = version; + me.type = pReq->type; + me.uid = pReq->uid; + me.name = pReq->name; + me.ntbEntry.btime = pReq->btime; + me.ntbEntry.ttlDays = pReq->ttl; + me.ntbEntry.commentLen = pReq->commentLen; + me.ntbEntry.comment = pReq->comment; + me.ntbEntry.schemaRow = pReq->ntb.schemaRow; + me.ntbEntry.ncid = me.ntbEntry.schemaRow.pSchema[me.ntbEntry.schemaRow.nCols - 1].colId + 1; + me.colCmpr = pReq->colCmpr; + TABLE_SET_COL_COMPRESSED(me.flags); + + ++pStats->numOfNTables; + pStats->numOfNTimeSeries += me.ntbEntry.schemaRow.nCols - 1; + + if (!TSDB_CACHE_NO(pMeta->pVnode->config)) { + ret = tsdbCacheNewTable(pMeta->pVnode->pTsdb, me.uid, -1, &me.ntbEntry.schemaRow); + if (ret < 0) { + metaError("vgId:%d, failed to create table:%s since %s", TD_VID(pMeta->pVnode), pReq->name, tstrerror(ret)); + goto _err; + } + } + + if (metaHandleEntry(pMeta, &me) < 0) goto _err; + + metaTimeSeriesNotifyCheck(pMeta); + + if (pMetaRsp) { + *pMetaRsp = taosMemoryCalloc(1, sizeof(STableMetaRsp)); + + if (*pMetaRsp) { + ret = metaUpdateMetaRsp(pReq->uid, pReq->name, &pReq->ntb.schemaRow, *pMetaRsp); + if (ret < 0) { + metaError("vgId:%d, failed to update meta rsp:%s since %s", TD_VID(pMeta->pVnode), pReq->name, tstrerror(ret)); + } + for (int32_t i = 0; i < pReq->colCmpr.nCols; i++) { + SColCmpr *p = &pReq->colCmpr.pColCmpr[i]; + (*pMetaRsp)->pSchemaExt[i].colId = p->id; + (*pMetaRsp)->pSchemaExt[i].compress = p->alg; + } + } + } + + pMeta->changed = true; + metaDebug("vgId:%d, table:%s uid %" PRId64 " is created, type:%" PRId8, TD_VID(pMeta->pVnode), pReq->name, pReq->uid, + pReq->type); + return 0; + +_err: + metaError("vgId:%d, failed to create table:%s type:%s since %s", TD_VID(pMeta->pVnode), pReq->name, + pReq->type == TSDB_CHILD_TABLE ? "child table" : "normal table", tstrerror(terrno)); + return TSDB_CODE_FAILED; +#endif + return code; +} // 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; + } + return code; +}