dCDAstProcess.c 33.2 KB
Newer Older
1 2
#include <astGenerator.h>
#include <tmsg.h>
H
Haojun Liao 已提交
3
#include "astToMsg.h"
4
#include "parserInt.h"
H
Haojun Liao 已提交
5 6
#include "parserUtil.h"
#include "queryInfoUtil.h"
7
#include "tglobal.h"
8 9
#include "tmsg.h"
#include "ttime.h"
H
Haojun Liao 已提交
10 11 12 13 14 15 16 17 18 19 20 21

/* is contained in pFieldList or not */
static bool has(SArray* pFieldList, int32_t startIndex, const char* name) {
  size_t numOfCols = taosArrayGetSize(pFieldList);
  for (int32_t j = startIndex; j < numOfCols; ++j) {
    TAOS_FIELD* field = taosArrayGet(pFieldList, j);
    if (strncasecmp(name, field->name, sizeof(field->name) - 1) == 0) return true;
  }

  return false;
}

H
Hongze Cheng 已提交
22
static int32_t setShowInfo(SShowInfo* pShowInfo, SParseBasicCtx* pCtx, void** output, int32_t* outputLen,
23
                           SEpSet* pEpSet, void** pExtension, SMsgBuf* pMsgBuf) {
H
Haojun Liao 已提交
24 25 26 27 28 29 30 31 32 33 34
  const char* msg1 = "invalid name";
  const char* msg2 = "wildcard string should be less than %d characters";
  const char* msg3 = "database name too long";
  const char* msg4 = "pattern is invalid";
  const char* msg5 = "database name is empty";
  const char* msg6 = "pattern string is empty";

  /*
   * database prefix in pInfo->pMiscInfo->a[0]
   * wildcard in like clause in pInfo->pMiscInfo->a[1]
   */
H
Hongze Cheng 已提交
35
  int16_t showType = pShowInfo->showType;
H
Haojun Liao 已提交
36 37 38
  if (showType == TSDB_MGMT_TABLE_TABLE) {
    SVShowTablesReq* pShowReq = calloc(1, sizeof(SVShowTablesReq));

39
    SArray* array = NULL;
H
Hongze Cheng 已提交
40
    SName   name = {0};
41 42 43 44 45 46 47 48 49 50 51 52
    tNameSetDbName(&name, pCtx->acctId, pCtx->db, strlen(pCtx->db));

    char dbFname[TSDB_DB_FNAME_LEN] = {0};
    tNameGetFullDbName(&name, dbFname);

    catalogGetDBVgroup(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, dbFname, 0, &array);

    SVgroupInfo* info = taosArrayGet(array, 0);
    pShowReq->head.vgId = htonl(info->vgId);
    pEpSet->numOfEps = info->numOfEps;
    pEpSet->inUse = info->inUse;

H
Hongze Cheng 已提交
53
    for (int32_t i = 0; i < pEpSet->numOfEps; ++i) {
54 55 56 57
      strncpy(pEpSet->fqdn[i], info->epAddr[i].fqdn, tListLen(pEpSet->fqdn[i]));
      pEpSet->port[i] = info->epAddr[i].port;
    }

H
Haojun Liao 已提交
58 59
    *outputLen = sizeof(SVShowTablesReq);
    *output = pShowReq;
60 61

    *pExtension = array;
H
Haojun Liao 已提交
62 63 64 65 66 67 68
  } else {
    if (showType == TSDB_MGMT_TABLE_STB || showType == TSDB_MGMT_TABLE_VGROUP) {
      SToken* pDbPrefixToken = &pShowInfo->prefix;
      if (pDbPrefixToken->type != 0) {
        if (pDbPrefixToken->n >= TSDB_DB_NAME_LEN) {  // db name is too long
          return buildInvalidOperationMsg(pMsgBuf, msg3);
        }
H
Haojun Liao 已提交
69

H
Haojun Liao 已提交
70 71 72
        if (pDbPrefixToken->n <= 0) {
          return buildInvalidOperationMsg(pMsgBuf, msg5);
        }
H
Haojun Liao 已提交
73

H
Haojun Liao 已提交
74 75 76 77 78 79 80 81
        if (parserValidateIdToken(pDbPrefixToken) != TSDB_CODE_SUCCESS) {
          return buildInvalidOperationMsg(pMsgBuf, msg1);
        }

        //      int32_t ret = tNameSetDbName(&pTableMetaInfo->name, getAccountId(pRequest->pTsc), pDbPrefixToken);
        //      if (ret != TSDB_CODE_SUCCESS) {
        //        return buildInvalidOperationMsg(pMsgBuf, msg1);
        //      }
H
Haojun Liao 已提交
82 83
      }

H
Haojun Liao 已提交
84 85 86 87 88 89
      // show table/stable like 'xxxx', set the like pattern for show tables
      SToken* pPattern = &pShowInfo->pattern;
      if (pPattern->type != 0) {
        if (pPattern->type == TK_ID && pPattern->z[0] == TS_ESCAPE_CHAR) {
          return buildInvalidOperationMsg(pMsgBuf, msg4);
        }
H
Haojun Liao 已提交
90

H
Haojun Liao 已提交
91 92 93 94
        pPattern->n = strdequote(pPattern->z);
        if (pPattern->n <= 0) {
          return buildInvalidOperationMsg(pMsgBuf, msg6);
        }
H
Haojun Liao 已提交
95

H
Haojun Liao 已提交
96 97 98 99 100 101 102 103 104
        if (pPattern->n > tsMaxWildCardsLen) {
          char tmp[64] = {0};
          sprintf(tmp, msg2, tsMaxWildCardsLen);
          return buildInvalidOperationMsg(pMsgBuf, tmp);
        }
      }
    } else if (showType == TSDB_MGMT_TABLE_VNODES) {
      if (pShowInfo->prefix.type == 0) {
        return buildInvalidOperationMsg(pMsgBuf, "No specified dnode ep");
H
Haojun Liao 已提交
105 106
      }

H
Haojun Liao 已提交
107 108
      if (pShowInfo->prefix.type == TK_STRING) {
        pShowInfo->prefix.n = strdequote(pShowInfo->prefix.z);
H
Haojun Liao 已提交
109 110 111
      }
    }

H
Haojun Liao 已提交
112 113 114
    *pEpSet = pCtx->mgmtEpSet;
    *output = buildShowMsg(pShowInfo, pCtx, pMsgBuf->buf, pMsgBuf->len);
    *outputLen = sizeof(SShowMsg) /* + htons(pShowMsg->payloadLen)*/;
H
Haojun Liao 已提交
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
  }

  return TSDB_CODE_SUCCESS;
}

// can only perform the parameters based on the macro definitation
static int32_t doCheckDbOptions(SCreateDbMsg* pCreate, SMsgBuf* pMsgBuf) {
  char msg[512] = {0};

  if (pCreate->walLevel != -1 && (pCreate->walLevel < TSDB_MIN_WAL_LEVEL || pCreate->walLevel > TSDB_MAX_WAL_LEVEL)) {
    snprintf(msg, tListLen(msg), "invalid db option walLevel: %d, only 1-2 allowed", pCreate->walLevel);
    return buildInvalidOperationMsg(pMsgBuf, msg);
  }

  if (pCreate->replications != -1 &&
      (pCreate->replications < TSDB_MIN_DB_REPLICA_OPTION || pCreate->replications > TSDB_MAX_DB_REPLICA_OPTION)) {
    snprintf(msg, tListLen(msg), "invalid db option replications: %d valid range: [%d, %d]", pCreate->replications,
             TSDB_MIN_DB_REPLICA_OPTION, TSDB_MAX_DB_REPLICA_OPTION);
    return buildInvalidOperationMsg(pMsgBuf, msg);
  }

  int32_t blocks = ntohl(pCreate->totalBlocks);
  if (blocks != -1 && (blocks < TSDB_MIN_TOTAL_BLOCKS || blocks > TSDB_MAX_TOTAL_BLOCKS)) {
    snprintf(msg, tListLen(msg), "invalid db option totalBlocks: %d valid range: [%d, %d]", blocks,
             TSDB_MIN_TOTAL_BLOCKS, TSDB_MAX_TOTAL_BLOCKS);
    return buildInvalidOperationMsg(pMsgBuf, msg);
  }

  if (pCreate->quorum != -1 &&
      (pCreate->quorum < TSDB_MIN_DB_QUORUM_OPTION || pCreate->quorum > TSDB_MAX_DB_QUORUM_OPTION)) {
    snprintf(msg, tListLen(msg), "invalid db option quorum: %d valid range: [%d, %d]", pCreate->quorum,
             TSDB_MIN_DB_QUORUM_OPTION, TSDB_MAX_DB_QUORUM_OPTION);
    return buildInvalidOperationMsg(pMsgBuf, msg);
  }

  int32_t val = htonl(pCreate->daysPerFile);
  if (val != -1 && (val < TSDB_MIN_DAYS_PER_FILE || val > TSDB_MAX_DAYS_PER_FILE)) {
H
Hongze Cheng 已提交
152 153
    snprintf(msg, tListLen(msg), "invalid db option daysPerFile: %d valid range: [%d, %d]", val, TSDB_MIN_DAYS_PER_FILE,
             TSDB_MAX_DAYS_PER_FILE);
H
Haojun Liao 已提交
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
    return buildInvalidOperationMsg(pMsgBuf, msg);
  }

  val = htonl(pCreate->cacheBlockSize);
  if (val != -1 && (val < TSDB_MIN_CACHE_BLOCK_SIZE || val > TSDB_MAX_CACHE_BLOCK_SIZE)) {
    snprintf(msg, tListLen(msg), "invalid db option cacheBlockSize: %d valid range: [%d, %d]", val,
             TSDB_MIN_CACHE_BLOCK_SIZE, TSDB_MAX_CACHE_BLOCK_SIZE);
    return buildInvalidOperationMsg(pMsgBuf, msg);
  }

  if (pCreate->precision != TSDB_TIME_PRECISION_MILLI && pCreate->precision != TSDB_TIME_PRECISION_MICRO &&
      pCreate->precision != TSDB_TIME_PRECISION_NANO) {
    snprintf(msg, tListLen(msg), "invalid db option timePrecision: %d valid value: [%d, %d, %d]", pCreate->precision,
             TSDB_TIME_PRECISION_MILLI, TSDB_TIME_PRECISION_MICRO, TSDB_TIME_PRECISION_NANO);
    return buildInvalidOperationMsg(pMsgBuf, msg);
  }

  val = htonl(pCreate->commitTime);
  if (val != -1 && (val < TSDB_MIN_COMMIT_TIME || val > TSDB_MAX_COMMIT_TIME)) {
H
Hongze Cheng 已提交
173 174
    snprintf(msg, tListLen(msg), "invalid db option commitTime: %d valid range: [%d, %d]", val, TSDB_MIN_COMMIT_TIME,
             TSDB_MAX_COMMIT_TIME);
H
Haojun Liao 已提交
175 176 177 178 179
    return buildInvalidOperationMsg(pMsgBuf, msg);
  }

  val = htonl(pCreate->fsyncPeriod);
  if (val != -1 && (val < TSDB_MIN_FSYNC_PERIOD || val > TSDB_MAX_FSYNC_PERIOD)) {
H
Hongze Cheng 已提交
180 181
    snprintf(msg, tListLen(msg), "invalid db option fsyncPeriod: %d valid range: [%d, %d]", val, TSDB_MIN_FSYNC_PERIOD,
             TSDB_MAX_FSYNC_PERIOD);
H
Haojun Liao 已提交
182 183 184 185 186 187 188 189 190 191
    return buildInvalidOperationMsg(pMsgBuf, msg);
  }

  if (pCreate->compression != -1 &&
      (pCreate->compression < TSDB_MIN_COMP_LEVEL || pCreate->compression > TSDB_MAX_COMP_LEVEL)) {
    snprintf(msg, tListLen(msg), "invalid db option compression: %d valid range: [%d, %d]", pCreate->compression,
             TSDB_MIN_COMP_LEVEL, TSDB_MAX_COMP_LEVEL);
    return buildInvalidOperationMsg(pMsgBuf, msg);
  }

H
Haojun Liao 已提交
192 193 194
  val = htonl(pCreate->numOfVgroups);
  if (val < TSDB_MIN_VNODES_PER_DB || val > TSDB_MAX_VNODES_PER_DB) {
    snprintf(msg, tListLen(msg), "invalid number of vgroups for DB:%d valid range: [%d, %d]", val,
H
Hongze Cheng 已提交
195
             TSDB_MIN_VNODES_PER_DB, TSDB_MAX_VNODES_PER_DB);
H
Haojun Liao 已提交
196 197
  }

H
Haojun Liao 已提交
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
  return TSDB_CODE_SUCCESS;
}

static int32_t validateTableColumns(SArray* pFieldList, int32_t maxRowLength, int32_t maxColumns, SMsgBuf* pMsgBuf) {
  const char* msg2 = "row length exceeds max length";
  const char* msg3 = "duplicated column names";
  const char* msg4 = "invalid data type";
  const char* msg5 = "invalid binary/nchar column length";
  const char* msg6 = "invalid column name";
  const char* msg7 = "too many columns";
  const char* msg8 = "illegal number of columns";

  size_t numOfCols = taosArrayGetSize(pFieldList);
  if (numOfCols > maxColumns) {
    return buildInvalidOperationMsg(pMsgBuf, msg7);
  }

  int32_t rowLen = 0;
  for (int32_t i = 0; i < numOfCols; ++i) {
    TAOS_FIELD* pField = taosArrayGet(pFieldList, i);
    if (!isValidDataType(pField->type)) {
      return buildInvalidOperationMsg(pMsgBuf, msg4);
    }

    if (pField->bytes == 0) {
      return buildInvalidOperationMsg(pMsgBuf, msg5);
    }

    if ((pField->type == TSDB_DATA_TYPE_BINARY && (pField->bytes <= 0 || pField->bytes > TSDB_MAX_BINARY_LEN)) ||
        (pField->type == TSDB_DATA_TYPE_NCHAR && (pField->bytes <= 0 || pField->bytes > TSDB_MAX_NCHAR_LEN))) {
      return buildInvalidOperationMsg(pMsgBuf, msg5);
    }

    SToken nameToken = {.z = pField->name, .n = strlen(pField->name), .type = TK_ID};
    if (parserValidateNameToken(&nameToken) != TSDB_CODE_SUCCESS) {
      return buildInvalidOperationMsg(pMsgBuf, msg6);
    }

    // field name must be unique
    if (has(pFieldList, i + 1, pField->name) == true) {
      return buildInvalidOperationMsg(pMsgBuf, msg3);
    }

    rowLen += pField->bytes;
  }

  // max row length must be less than TSDB_MAX_BYTES_PER_ROW
  if (rowLen > maxRowLength) {
    return buildInvalidOperationMsg(pMsgBuf, msg2);
  }

  return TSDB_CODE_SUCCESS;
}

static int32_t validateTableColumnInfo(SArray* pFieldList, SMsgBuf* pMsgBuf) {
253
  assert(pFieldList != NULL && pMsgBuf != NULL);
H
Haojun Liao 已提交
254 255

  const char* msg1 = "first column must be timestamp";
256
  const char* msg2 = "illegal number of columns";
H
Haojun Liao 已提交
257 258 259 260 261 262 263 264 265 266

  // first column must be timestamp
  SField* pField = taosArrayGet(pFieldList, 0);
  if (pField->type != TSDB_DATA_TYPE_TIMESTAMP) {
    return buildInvalidOperationMsg(pMsgBuf, msg1);
  }

  // number of fields no less than 2
  size_t numOfCols = taosArrayGetSize(pFieldList);
  if (numOfCols <= 1) {
267
    return buildInvalidOperationMsg(pMsgBuf, msg2);
H
Haojun Liao 已提交
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
  }

  return validateTableColumns(pFieldList, TSDB_MAX_BYTES_PER_ROW, TSDB_MAX_COLUMNS, pMsgBuf);
}

static int32_t validateTagParams(SArray* pTagsList, SArray* pFieldList, SMsgBuf* pMsgBuf) {
  assert(pTagsList != NULL);

  const char* msg1 = "invalid number of tag columns";
  const char* msg3 = "duplicated column names";

  // number of fields at least 1
  size_t numOfTags = taosArrayGetSize(pTagsList);
  if (numOfTags < 1) {
    return buildInvalidOperationMsg(pMsgBuf, msg1);
  }

  // field name must be unique
  for (int32_t i = 0; i < numOfTags; ++i) {
    SField* p = taosArrayGet(pTagsList, i);
    if (has(pFieldList, 0, p->name) == true) {
      return buildInvalidOperationMsg(pMsgBuf, msg3);
    }
  }

  return validateTableColumns(pFieldList, TSDB_MAX_TAGS_LEN, TSDB_MAX_TAGS, pMsgBuf);
}

296
int32_t doCheckForCreateTable(SCreateTableSql* pCreateTable, SMsgBuf* pMsgBuf) {
H
Haojun Liao 已提交
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
  const char* msg1 = "invalid table name";

  SArray* pFieldList = pCreateTable->colInfo.pColumns;
  SArray* pTagList = pCreateTable->colInfo.pTagColumns;
  assert(pFieldList != NULL);

  // if sql specifies db, use it, otherwise use default db
  SToken* pzTableName = &(pCreateTable->name);

  if (parserValidateNameToken(pzTableName) != TSDB_CODE_SUCCESS) {
    return buildInvalidOperationMsg(pMsgBuf, msg1);
  }

  if (validateTableColumnInfo(pFieldList, pMsgBuf) != TSDB_CODE_SUCCESS ||
      (pTagList != NULL && validateTagParams(pTagList, pFieldList, pMsgBuf) != TSDB_CODE_SUCCESS)) {
    return TSDB_CODE_TSC_INVALID_OPERATION;
  }

  return TSDB_CODE_SUCCESS;
}

318 319 320 321 322
typedef struct SVgroupTablesBatch {
  SVCreateTbBatchReq req;
  SVgroupInfo        info;
} SVgroupTablesBatch;

323 324
static SArray* doSerializeVgroupCreateTableInfo(SHashObj* pVgroupHashmap);

H
Haojun Liao 已提交
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
static int32_t doParseSerializeTagValue(SSchema* pTagSchema, int32_t numOfInputTag, SKVRowBuilder* pKvRowBuilder,
                                        SArray* pTagValList, int32_t tsPrecision, SMsgBuf* pMsgBuf) {
  const char* msg1 = "illegal value or data overflow";
  int32_t     code = TSDB_CODE_SUCCESS;

  for (int32_t i = 0; i < numOfInputTag; ++i) {
    SSchema* pSchema = &pTagSchema[i];

    char* endPtr = NULL;
    char  tmpTokenBuf[TSDB_MAX_TAGS_LEN] = {0};

    SKvParam param = {.builder = pKvRowBuilder, .schema = pSchema};

    SToken* pItem = taosArrayGet(pTagValList, i);
    code = parseValueToken(&endPtr, pItem, pSchema, tsPrecision, tmpTokenBuf, KvRowAppend, &param, pMsgBuf);

    if (code != TSDB_CODE_SUCCESS) {
      return buildInvalidOperationMsg(pMsgBuf, msg1);
    }
  }

  return code;
}

349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
static void addCreateTbReqIntoVgroup(SHashObj* pVgroupHashmap, const SName* pTableName, SKVRow row, uint64_t suid, SVgroupInfo* pVgInfo) {
  struct SVCreateTbReq req = {0};
  req.type        = TD_CHILD_TABLE;
  req.name        = strdup(tNameGetTableName(pTableName));
  req.ctbCfg.suid = suid;
  req.ctbCfg.pTag = row;

  SVgroupTablesBatch* pTableBatch = taosHashGet(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId));
  if (pTableBatch == NULL) {
    SVgroupTablesBatch tBatch = {0};
    tBatch.info = *pVgInfo;

    tBatch.req.pArray = taosArrayInit(4, sizeof(struct SVCreateTbReq));
    taosArrayPush(tBatch.req.pArray, &req);

    taosHashPut(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &tBatch, sizeof(tBatch));
  } else {  // add to the correct vgroup
    assert(pVgInfo->vgId == pTableBatch->info.vgId);
    taosArrayPush(pTableBatch->req.pArray, &req);
  }
}

static void destroyCreateTbReqBatch(SVgroupTablesBatch* pTbBatch) {
  size_t size = taosArrayGetSize(pTbBatch->req.pArray);
  for(int32_t i = 0; i < size; ++i) {
    SVCreateTbReq* pTableReq = taosArrayGet(pTbBatch->req.pArray, i);
    tfree(pTableReq->name);
376 377 378 379 380 381 382 383

    if (pTableReq->type == TSDB_NORMAL_TABLE) {
      tfree(pTableReq->ntbCfg.pSchema);
    } else if (pTableReq->type == TSDB_CHILD_TABLE) {
      tfree(pTableReq->ctbCfg.pTag);
    } else {
      assert(0);
    }
384 385 386 387 388
  }

  taosArrayDestroy(pTbBatch->req.pArray);
}

389
static int32_t doCheckAndBuildCreateCTableReq(SCreateTableSql* pCreateTable, SParseBasicCtx* pCtx, SMsgBuf* pMsgBuf, SArray** pBufArray) {
H
Haojun Liao 已提交
390 391 392 393 394
  const char* msg1 = "invalid table name";
  const char* msg2 = "tags number not matched";
  const char* msg3 = "tag value too long";
  const char* msg4 = "illegal value or data overflow";

395 396 397
  int32_t code = 0;
  STableMeta* pSuperTableMeta = NULL;

398 399
  SHashObj* pVgroupHashmap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);

H
Haojun Liao 已提交
400
  // super table name, create table by using dst
401
  size_t numOfTables = taosArrayGetSize(pCreateTable->childTableInfo);
H
Hongze Cheng 已提交
402
  for (int32_t j = 0; j < numOfTables; ++j) {
H
Haojun Liao 已提交
403 404 405
    SCreatedTableInfo* pCreateTableInfo = taosArrayGet(pCreateTable->childTableInfo, j);

    SToken* pSTableNameToken = &pCreateTableInfo->stbName;
406
    code = parserValidateNameToken(pSTableNameToken);
H
Haojun Liao 已提交
407
    if (code != TSDB_CODE_SUCCESS) {
408 409
      code = buildInvalidOperationMsg(pMsgBuf, msg1);
      goto _error;
H
Haojun Liao 已提交
410 411 412 413 414
    }

    SName name = {0};
    code = createSName(&name, pSTableNameToken, pCtx, pMsgBuf);
    if (code != TSDB_CODE_SUCCESS) {
415
      goto _error;
H
Haojun Liao 已提交
416 417
    }

H
Haojun Liao 已提交
418 419
    SKVRowBuilder kvRowBuilder = {0};
    if (tdInitKVRowBuilder(&kvRowBuilder) < 0) {
420 421
      code = TSDB_CODE_TSC_OUT_OF_MEMORY;
      goto _error;
H
Haojun Liao 已提交
422 423
    }

H
Haojun Liao 已提交
424
    SArray* pValList = pCreateTableInfo->pTagVals;
H
Haojun Liao 已提交
425
    size_t  numOfInputTag = taosArrayGetSize(pValList);
H
Haojun Liao 已提交
426

427 428
    code = catalogGetTableMeta(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, &name, &pSuperTableMeta);
    if (code != TSDB_CODE_SUCCESS) {
429
      goto _error;
430 431
    }

432
    assert(pSuperTableMeta != NULL);
433

H
Haojun Liao 已提交
434
    // too long tag values will return invalid sql, not be truncated automatically
H
Hongze Cheng 已提交
435
    SSchema*      pTagSchema = getTableTagSchema(pSuperTableMeta);
H
Haojun Liao 已提交
436 437 438
    STableComInfo tinfo = getTableInfo(pSuperTableMeta);

    SArray* pNameList = NULL;
H
Haojun Liao 已提交
439
    size_t  numOfBoundTags = 0;
H
Haojun Liao 已提交
440 441 442 443
    int32_t schemaSize = getNumOfTags(pSuperTableMeta);

    if (pCreateTableInfo->pTagNames) {
      pNameList = pCreateTableInfo->pTagNames;
H
Haojun Liao 已提交
444
      numOfBoundTags = taosArrayGetSize(pNameList);
H
Haojun Liao 已提交
445

H
Haojun Liao 已提交
446
      if (numOfInputTag != numOfBoundTags || schemaSize < numOfInputTag) {
H
Haojun Liao 已提交
447
        tdDestroyKVRowBuilder(&kvRowBuilder);
448 449
        code = buildInvalidOperationMsg(pMsgBuf, msg2);
        goto _error;
H
Haojun Liao 已提交
450 451 452
      }

      bool findColumnIndex = false;
H
Haojun Liao 已提交
453
      for (int32_t i = 0; i < numOfBoundTags; ++i) {
H
Haojun Liao 已提交
454 455
        SToken* sToken = taosArrayGet(pNameList, i);

H
Hongze Cheng 已提交
456
        char tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW] = {0};  // create tmp buf to avoid alter orginal sqlstr
H
Haojun Liao 已提交
457 458 459
        strncpy(tmpTokenBuf, sToken->z, sToken->n);
        sToken->z = tmpTokenBuf;

H
Hongze Cheng 已提交
460 461 462
        //        if (TK_STRING == sToken->type) {
        //          tscDequoteAndTrimToken(sToken);
        //        }
H
Haojun Liao 已提交
463

H
Hongze Cheng 已提交
464 465 466
        //        if (TK_ID == sToken->type) {
        //          tscRmEscapeAndTrimToken(sToken);
        //        }
H
Haojun Liao 已提交
467

468
        SListItem* pItem = taosArrayGet(pValList, i);
H
Haojun Liao 已提交
469 470 471 472 473 474

        findColumnIndex = false;

        // todo speedup by using hash list
        for (int32_t t = 0; t < schemaSize; ++t) {
          if (strncmp(sToken->z, pTagSchema[t].name, sToken->n) == 0 && strlen(pTagSchema[t].name) == sToken->n) {
H
Hongze Cheng 已提交
475
            SSchema* pSchema = &pTagSchema[t];
H
Haojun Liao 已提交
476 477 478 479 480

            char tagVal[TSDB_MAX_TAGS_LEN] = {0};
            if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
              if (pItem->pVar.nLen > pSchema->bytes) {
                tdDestroyKVRowBuilder(&kvRowBuilder);
481 482
                code = buildInvalidOperationMsg(pMsgBuf, msg3);
                goto _error;
H
Haojun Liao 已提交
483 484 485
              }
            } else if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP) {
              if (pItem->pVar.nType == TSDB_DATA_TYPE_BINARY) {
H
Hongze Cheng 已提交
486 487 488 489
                //                code = convertTimestampStrToInt64(&(pItem->pVar), tinfo.precision);
                //                if (code != TSDB_CODE_SUCCESS) {
                //                  return buildInvalidOperationMsg(pMsgBuf, msg4);
                //                }
H
Haojun Liao 已提交
490
              } else if (pItem->pVar.nType == TSDB_DATA_TYPE_TIMESTAMP) {
491
                pItem->pVar.i = convertTimePrecision(pItem->pVar.i, TSDB_TIME_PRECISION_NANO, tinfo.precision);
H
Haojun Liao 已提交
492 493 494
              }
            }

495
            code = taosVariantDump(&(pItem->pVar), tagVal, pSchema->type, true);
H
Haojun Liao 已提交
496 497

            // check again after the convert since it may be converted from binary to nchar.
498
            if (IS_VAR_DATA_TYPE(pSchema->type)) {
H
Haojun Liao 已提交
499 500 501
              int16_t len = varDataTLen(tagVal);
              if (len > pSchema->bytes) {
                tdDestroyKVRowBuilder(&kvRowBuilder);
502 503
                code = buildInvalidOperationMsg(pMsgBuf, msg3);
                goto _error;
H
Haojun Liao 已提交
504 505 506 507 508
              }
            }

            if (code != TSDB_CODE_SUCCESS) {
              tdDestroyKVRowBuilder(&kvRowBuilder);
509 510
              code = buildInvalidOperationMsg(pMsgBuf, msg4);
              goto _error;
H
Haojun Liao 已提交
511 512 513 514 515 516 517 518 519 520 521
            }

            tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);

            findColumnIndex = true;
            break;
          }
        }

        if (!findColumnIndex) {
          tdDestroyKVRowBuilder(&kvRowBuilder);
H
Hongze Cheng 已提交
522
          //          return buildInvalidOperationMsg(pMsgBuf, "invalid tag name", sToken->z);
H
Haojun Liao 已提交
523 524 525
        }
      }
    } else {
526
      if (schemaSize != numOfInputTag) {
H
Haojun Liao 已提交
527
        tdDestroyKVRowBuilder(&kvRowBuilder);
528 529
        code = buildInvalidOperationMsg(pMsgBuf, msg2);
        goto _error;
H
Haojun Liao 已提交
530 531
      }

H
Haojun Liao 已提交
532 533
      code = doParseSerializeTagValue(pTagSchema, numOfInputTag, &kvRowBuilder, pValList, tinfo.precision, pMsgBuf);
      if (code != TSDB_CODE_SUCCESS) {
H
Haojun Liao 已提交
534
        tdDestroyKVRowBuilder(&kvRowBuilder);
535
        goto _error;
H
Haojun Liao 已提交
536 537 538 539 540 541
      }
    }

    SKVRow row = tdGetKVRowFromBuilder(&kvRowBuilder);
    tdDestroyKVRowBuilder(&kvRowBuilder);
    if (row == NULL) {
542 543
      code = TSDB_CODE_QRY_OUT_OF_MEMORY;
      goto _error;
H
Haojun Liao 已提交
544
    }
545

H
Haojun Liao 已提交
546 547
    tdSortKVRowByColIdx(row);

548 549 550
    SName tableName = {0};
    code = createSName(&tableName, &pCreateTableInfo->name, pCtx, pMsgBuf);
    if (code != TSDB_CODE_SUCCESS) {
551
      goto _error;
H
Haojun Liao 已提交
552 553
    }

554
    // Find a appropriate vgroup to accommodate this table , according to the table name
555
    SVgroupInfo info = {0};
556 557 558 559
    code = catalogGetTableHashVgroup(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, &tableName, &info);
    if (code != TSDB_CODE_SUCCESS) {
      goto _error;
    }
560

561 562 563
    addCreateTbReqIntoVgroup(pVgroupHashmap, &tableName, row, pSuperTableMeta->uid, &info);
    tfree(pSuperTableMeta);
  }
564

565
  *pBufArray = doSerializeVgroupCreateTableInfo(pVgroupHashmap);
566 567 568 569
  if (*pBufArray == NULL) {
    code = terrno;
    goto _error;
  }
570 571 572

  taosHashCleanup(pVgroupHashmap);
  return TSDB_CODE_SUCCESS;
573 574 575 576 577 578

  _error:
  taosHashCleanup(pVgroupHashmap);
  tfree(pSuperTableMeta);
  terrno = code;
  return code;
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
}

static int32_t serializeVgroupTablesBatchImpl(SVgroupTablesBatch* pTbBatch, SArray* pBufArray) {
  int   tlen = sizeof(SMsgHead) + tSVCreateTbBatchReqSerialize(NULL, &(pTbBatch->req));
  void* buf = malloc(tlen);
  if (buf == NULL) {
    // TODO: handle error
  }

  ((SMsgHead*)buf)->vgId = htonl(pTbBatch->info.vgId);
  ((SMsgHead*)buf)->contLen = htonl(tlen);

  void* pBuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
  tSVCreateTbBatchReqSerialize(&pBuf, &(pTbBatch->req));

  SVgDataBlocks* pVgData = calloc(1, sizeof(SVgDataBlocks));
  pVgData->vg    = pTbBatch->info;
  pVgData->pData = buf;
  pVgData->size  = tlen;
  pVgData->numOfTables = (int32_t) taosArrayGetSize(pTbBatch->req.pArray);

  taosArrayPush(pBufArray, &pVgData);
}

static int32_t doBuildSingleTableBatchReq(SName* pTableName, SArray* pColumns, SVgroupInfo* pVgroupInfo, SVgroupTablesBatch* pBatch) {
  struct SVCreateTbReq req = {0};
  req.type = TD_NORMAL_TABLE;
  req.name = strdup(tNameGetTableName(pTableName));

  req.ntbCfg.nCols = taosArrayGetSize(pColumns);
  int32_t num = req.ntbCfg.nCols;

  req.ntbCfg.pSchema = calloc(num, sizeof(SSchema));
  for(int32_t i = 0; i < num; ++i) {
    SSchema* pSchema = taosArrayGet(pColumns, i);
    memcpy(&req.ntbCfg.pSchema[i], pSchema, sizeof(SSchema));
  }

  pBatch->info = *pVgroupInfo;
  pBatch->req.pArray = taosArrayInit(1, sizeof(struct SVCreateTbReq));
  if (pBatch->req.pArray == NULL) {
    return TSDB_CODE_QRY_OUT_OF_MEMORY;
  }

  taosArrayPush(pBatch->req.pArray, &req);
  return TSDB_CODE_SUCCESS;
}

int32_t doCheckAndBuildCreateTableReq(SCreateTableSql* pCreateTable, SParseBasicCtx* pCtx, SMsgBuf* pMsgBuf, char** pOutput, int32_t* len) {
  SArray* pBufArray = NULL;
H
Haojun Liao 已提交
629
  int32_t code = 0;
630 631 632 633

  // it is a sql statement to create a normal table
  if (pCreateTable->childTableInfo == NULL) {
    assert(taosArrayGetSize(pCreateTable->colInfo.pColumns) > 0 && pCreateTable->colInfo.pTagColumns == NULL);
H
Haojun Liao 已提交
634
    code = doCheckForCreateTable(pCreateTable, pMsgBuf);
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
    if (code != TSDB_CODE_SUCCESS) {
      return code;
    }

    SName tableName = {0};
    code = createSName(&tableName, &pCreateTable->name, pCtx, pMsgBuf);
    if (code != TSDB_CODE_SUCCESS) {
      return code;
    }

    SVgroupInfo info = {0};
    catalogGetTableHashVgroup(pCtx->pCatalog, pCtx->pTransporter, &pCtx->mgmtEpSet, &tableName, &info);

    SVgroupTablesBatch tbatch = {0};
    code = doBuildSingleTableBatchReq(&tableName, pCreateTable->colInfo.pColumns, &info, &tbatch);
    if (code != TSDB_CODE_SUCCESS) {
      return code;
    }

    pBufArray = taosArrayInit(1, POINTER_BYTES);
    if (pBufArray == NULL) {
      return TSDB_CODE_QRY_OUT_OF_MEMORY;
    }

    serializeVgroupTablesBatchImpl(&tbatch, pBufArray);
    destroyCreateTbReqBatch(&tbatch);

  } else { // it is a child table, created according to a super table
H
Haojun Liao 已提交
663 664 665 666
    code = doCheckAndBuildCreateCTableReq(pCreateTable, pCtx, pMsgBuf, &pBufArray);
    if (code != 0) {
      return code;
    }
667
  }
668

669 670 671
  SVnodeModifOpStmtInfo* pStmtInfo = calloc(1, sizeof(SVnodeModifOpStmtInfo));
  pStmtInfo->nodeType    = TSDB_SQL_CREATE_TABLE;
  pStmtInfo->pDataBlocks = pBufArray;
672

673 674
  *pOutput = (char*) pStmtInfo;
  *len     = sizeof(SVnodeModifOpStmtInfo);
H
Haojun Liao 已提交
675

676 677
  return TSDB_CODE_SUCCESS;
}
H
Haojun Liao 已提交
678

679
SArray* doSerializeVgroupCreateTableInfo(SHashObj* pVgroupHashmap) {
680 681 682
  SArray* pBufArray = taosArrayInit(taosHashGetSize(pVgroupHashmap), sizeof(void*));

  SVgroupTablesBatch* pTbBatch = NULL;
H
Hongze Cheng 已提交
683
  do {
684
    pTbBatch = taosHashIterate(pVgroupHashmap, pTbBatch);
685 686 687
    if (pTbBatch == NULL) {
      break;
    }
H
Hongze Cheng 已提交
688

689
    /*int32_t code = */serializeVgroupTablesBatchImpl(pTbBatch, pBufArray);
690
    destroyCreateTbReqBatch(pTbBatch);
H
Hongze Cheng 已提交
691
  } while (true);
692

693
  return pBufArray;
H
Haojun Liao 已提交
694 695
}

696
SDclStmtInfo* qParserValidateDclSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, char* msgBuf, int32_t msgBufLen) {
H
Haojun Liao 已提交
697 698
  int32_t code = 0;

699 700
  SDclStmtInfo* pDcl = calloc(1, sizeof(SDclStmtInfo));

H
Hongze Cheng 已提交
701 702
  SMsgBuf  m = {.buf = msgBuf, .len = msgBufLen};
  SMsgBuf* pMsgBuf = &m;
H
Haojun Liao 已提交
703 704 705 706 707 708 709 710 711 712 713 714 715 716

  switch (pInfo->type) {
    case TSDB_SQL_CREATE_USER:
    case TSDB_SQL_ALTER_USER: {
      const char* msg1 = "not support options";
      const char* msg2 = "invalid user/account name";
      const char* msg3 = "name too long";
      const char* msg4 = "invalid user rights";

      SUserInfo* pUser = &pInfo->pMiscInfo->user;
      SToken*    pName = &pUser->user;
      SToken*    pPwd = &pUser->passwd;

      if (pName->n >= TSDB_USER_LEN) {
717 718
        code = buildInvalidOperationMsg(pMsgBuf, msg3);
        goto _error;
H
Haojun Liao 已提交
719 720 721
      }

      if (parserValidateIdToken(pName) != TSDB_CODE_SUCCESS) {
722 723
        code = buildInvalidOperationMsg(pMsgBuf, msg2);
        goto _error;
H
Haojun Liao 已提交
724 725 726 727
      }

      if (pInfo->type == TSDB_SQL_CREATE_USER) {
        if (parserValidatePassword(pPwd, pMsgBuf) != TSDB_CODE_SUCCESS) {
728 729
          code = TSDB_CODE_TSC_INVALID_OPERATION;
          goto _error;
H
Haojun Liao 已提交
730 731 732 733
        }
      } else {
        if (pUser->type == TSDB_ALTER_USER_PASSWD) {
          if (parserValidatePassword(pPwd, pMsgBuf) != TSDB_CODE_SUCCESS) {
734 735
            code = TSDB_CODE_TSC_INVALID_OPERATION;
            goto _error;
H
Haojun Liao 已提交
736 737 738 739 740 741 742 743 744 745
          }
        } else if (pUser->type == TSDB_ALTER_USER_PRIVILEGES) {
          assert(pPwd->type == TSDB_DATA_TYPE_NULL);

          SToken* pPrivilege = &pUser->privilege;
          if (strncasecmp(pPrivilege->z, "super", 5) == 0 && pPrivilege->n == 5) {
            //            pCmd->count = 1;
          } else if (strncasecmp(pPrivilege->z, "normal", 4) == 0 && pPrivilege->n == 4) {
            //            pCmd->count = 2;
          } else {
746 747
            code = buildInvalidOperationMsg(pMsgBuf, msg4);
            goto _error;
H
Haojun Liao 已提交
748 749
          }
        } else {
750 751
          code = buildInvalidOperationMsg(pMsgBuf, msg1);
          goto _error;
H
Haojun Liao 已提交
752 753 754 755
        }
      }

      pDcl->pMsg = (char*)buildUserManipulationMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
H
Hongze Cheng 已提交
756
      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_USER) ? TDMT_MND_CREATE_USER : TDMT_MND_ALTER_USER;
H
Haojun Liao 已提交
757 758 759 760 761 762 763 764 765 766 767 768 769
      break;
    }

    case TSDB_SQL_CREATE_ACCT:
    case TSDB_SQL_ALTER_ACCT: {
      const char* msg1 = "invalid state option, available options[no, r, w, all]";
      const char* msg2 = "invalid user/account name";
      const char* msg3 = "name too long";

      SToken* pName = &pInfo->pMiscInfo->user.user;
      SToken* pPwd = &pInfo->pMiscInfo->user.passwd;

      if (parserValidatePassword(pPwd, pMsgBuf) != TSDB_CODE_SUCCESS) {
770 771
        code = TSDB_CODE_TSC_INVALID_OPERATION;
        goto _error;
H
Haojun Liao 已提交
772 773 774
      }

      if (pName->n >= TSDB_USER_LEN) {
775 776
        code = buildInvalidOperationMsg(pMsgBuf, msg3);
        goto _error;
H
Haojun Liao 已提交
777 778 779
      }

      if (parserValidateNameToken(pName) != TSDB_CODE_SUCCESS) {
780 781
        code = buildInvalidOperationMsg(pMsgBuf, msg2);
        goto _error;
H
Haojun Liao 已提交
782 783 784 785 786 787 788 789 790
      }

      SCreateAcctInfo* pAcctOpt = &pInfo->pMiscInfo->acctOpt;
      if (pAcctOpt->stat.n > 0) {
        if (pAcctOpt->stat.z[0] == 'r' && pAcctOpt->stat.n == 1) {
        } else if (pAcctOpt->stat.z[0] == 'w' && pAcctOpt->stat.n == 1) {
        } else if (strncmp(pAcctOpt->stat.z, "all", 3) == 0 && pAcctOpt->stat.n == 3) {
        } else if (strncmp(pAcctOpt->stat.z, "no", 2) == 0 && pAcctOpt->stat.n == 2) {
        } else {
791 792
          code = buildInvalidOperationMsg(pMsgBuf, msg1);
          goto _error;
H
Haojun Liao 已提交
793 794 795 796
        }
      }

      pDcl->pMsg = (char*)buildAcctManipulationMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
H
Hongze Cheng 已提交
797
      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_ACCT) ? TDMT_MND_CREATE_ACCT : TDMT_MND_ALTER_ACCT;
H
Haojun Liao 已提交
798 799 800 801 802 803
      break;
    }

    case TSDB_SQL_DROP_ACCT:
    case TSDB_SQL_DROP_USER: {
      pDcl->pMsg = (char*)buildDropUserMsg(pInfo, &pDcl->msgLen, pCtx->requestId, msgBuf, msgBufLen);
H
Hongze Cheng 已提交
804
      pDcl->msgType = (pInfo->type == TSDB_SQL_DROP_ACCT) ? TDMT_MND_DROP_ACCT : TDMT_MND_DROP_USER;
H
Haojun Liao 已提交
805 806 807 808
      break;
    }

    case TSDB_SQL_SHOW: {
H
Haojun Liao 已提交
809
      SShowInfo* pShowInfo = &pInfo->pMiscInfo->showOpt;
810
      code = setShowInfo(pShowInfo, pCtx, (void**)&pDcl->pMsg, &pDcl->msgLen, &pDcl->epSet, &pDcl->pExtension, pMsgBuf);
811 812 813 814
      if (code != TSDB_CODE_SUCCESS) {
        goto _error;
      }
      
H
Hongze Cheng 已提交
815
      pDcl->msgType = (pShowInfo->showType == TSDB_MGMT_TABLE_TABLE) ? TDMT_VND_SHOW_TABLES : TDMT_MND_SHOW;
H
Haojun Liao 已提交
816 817 818 819 820 821 822 823
      break;
    }

    case TSDB_SQL_USE_DB: {
      const char* msg = "invalid db name";

      SToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
      if (parserValidateNameToken(pToken) != TSDB_CODE_SUCCESS) {
824 825
        code = buildInvalidOperationMsg(pMsgBuf, msg);
        goto _error;
H
Haojun Liao 已提交
826 827
      }

H
Hongze Cheng 已提交
828
      SName   n = {0};
H
Haojun Liao 已提交
829 830
      int32_t ret = tNameSetDbName(&n, pCtx->acctId, pToken->z, pToken->n);
      if (ret != TSDB_CODE_SUCCESS) {
831 832
        code = buildInvalidOperationMsg(pMsgBuf, msg);
        goto _error;
H
Haojun Liao 已提交
833 834
      }

H
Hongze Cheng 已提交
835
      SUseDbMsg* pUseDbMsg = (SUseDbMsg*)calloc(1, sizeof(SUseDbMsg));
H
Haojun Liao 已提交
836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
      tNameExtractFullName(&n, pUseDbMsg->db);

      pDcl->pMsg = (char*)pUseDbMsg;
      pDcl->msgLen = sizeof(SUseDbMsg);
      pDcl->msgType = TDMT_MND_USE_DB;
      break;
    }

    case TSDB_SQL_ALTER_DB:
    case TSDB_SQL_CREATE_DB: {
      const char* msg1 = "invalid db name";
      const char* msg2 = "name too long";

      SCreateDbInfo* pCreateDB = &(pInfo->pMiscInfo->dbOpt);
      if (pCreateDB->dbname.n >= TSDB_DB_NAME_LEN) {
851 852
        code = buildInvalidOperationMsg(pMsgBuf, msg2);
        goto _error;
H
Haojun Liao 已提交
853 854
      }

H
Hongze Cheng 已提交
855
      char   buf[TSDB_DB_NAME_LEN] = {0};
H
Haojun Liao 已提交
856 857 858
      SToken token = taosTokenDup(&pCreateDB->dbname, buf, tListLen(buf));

      if (parserValidateNameToken(&token) != TSDB_CODE_SUCCESS) {
859 860
        code = buildInvalidOperationMsg(pMsgBuf, msg1);
        goto _error;
H
Haojun Liao 已提交
861 862 863 864
      }

      SCreateDbMsg* pCreateMsg = buildCreateDbMsg(pCreateDB, pCtx, pMsgBuf);
      if (doCheckDbOptions(pCreateMsg, pMsgBuf) != TSDB_CODE_SUCCESS) {
865 866
        code = TSDB_CODE_TSC_INVALID_OPERATION;
        goto _error;
H
Haojun Liao 已提交
867 868 869 870
      }

      pDcl->pMsg = (char*)pCreateMsg;
      pDcl->msgLen = sizeof(SCreateDbMsg);
H
Hongze Cheng 已提交
871
      pDcl->msgType = (pInfo->type == TSDB_SQL_CREATE_DB) ? TDMT_MND_CREATE_DB : TDMT_MND_ALTER_DB;
H
Haojun Liao 已提交
872 873 874 875 876 877 878 879 880 881 882 883
      break;
    }

    case TSDB_SQL_DROP_DB: {
      const char* msg1 = "invalid database name";

      assert(taosArrayGetSize(pInfo->pMiscInfo->a) == 1);
      SToken* dbName = taosArrayGet(pInfo->pMiscInfo->a, 0);

      SName name = {0};
      code = tNameSetDbName(&name, pCtx->acctId, dbName->z, dbName->n);
      if (code != TSDB_CODE_SUCCESS) {
884 885
        code = buildInvalidOperationMsg(pMsgBuf, msg1);
        goto _error;
H
Haojun Liao 已提交
886 887
      }

H
Hongze Cheng 已提交
888
      SDropDbMsg* pDropDbMsg = (SDropDbMsg*)calloc(1, sizeof(SDropDbMsg));
H
Haojun Liao 已提交
889 890 891 892 893 894 895 896

      code = tNameExtractFullName(&name, pDropDbMsg->db);
      pDropDbMsg->ignoreNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
      assert(code == TSDB_CODE_SUCCESS && name.type == TSDB_DB_NAME_T);

      pDcl->msgType = TDMT_MND_DROP_DB;
      pDcl->msgLen = sizeof(SDropDbMsg);
      pDcl->pMsg = (char*)pDropDbMsg;
897
      break;
H
Haojun Liao 已提交
898 899
    }

H
Haojun Liao 已提交
900
    case TSDB_SQL_CREATE_STABLE: {
H
Haojun Liao 已提交
901
      SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
902 903 904
      if ((code = doCheckForCreateTable(pCreateTable, pMsgBuf)) != TSDB_CODE_SUCCESS) {
        terrno = code;
        goto _error;
H
Haojun Liao 已提交
905 906
      }

907 908
      pDcl->pMsg = (char*)buildCreateStbMsg(pCreateTable, &pDcl->msgLen, pCtx, pMsgBuf);
      pDcl->msgType = TDMT_MND_CREATE_STB;
H
Haojun Liao 已提交
909 910 911 912
      break;
    }

    case TSDB_SQL_DROP_TABLE: {
H
Haojun Liao 已提交
913
      pDcl->pMsg = (char*)buildDropStableMsg(pInfo, &pDcl->msgLen, pCtx, pMsgBuf);
H
Haojun Liao 已提交
914
      if (pDcl->pMsg == NULL) {
915
        goto _error;
H
Haojun Liao 已提交
916 917 918
      }

      pDcl->msgType = TDMT_MND_DROP_STB;
919 920 921 922
      break;
    }

    case TSDB_SQL_CREATE_DNODE: {
H
Hongze Cheng 已提交
923
      pDcl->pMsg = (char*)buildCreateDnodeMsg(pInfo, &pDcl->msgLen, pMsgBuf);
924
      if (pDcl->pMsg == NULL) {
925
        goto _error;
926 927 928 929 930 931 932
      }

      pDcl->msgType = TDMT_MND_CREATE_DNODE;
      break;
    }

    case TSDB_SQL_DROP_DNODE: {
H
Hongze Cheng 已提交
933
      pDcl->pMsg = (char*)buildDropDnodeMsg(pInfo, &pDcl->msgLen, pMsgBuf);
934
      if (pDcl->pMsg == NULL) {
935
        goto _error;
936 937 938
      }

      pDcl->msgType = TDMT_MND_DROP_DNODE;
H
Haojun Liao 已提交
939 940 941 942 943 944 945
      break;
    }

    default:
      break;
  }

946 947 948 949 950 951
  return pDcl;

  _error:
    terrno = code;
    tfree(pDcl);
    return NULL;
H
Haojun Liao 已提交
952
}
953

H
Haojun Liao 已提交
954
SVnodeModifOpStmtInfo* qParserValidateCreateTbSqlNode(SSqlInfo* pInfo, SParseBasicCtx* pCtx, char* msgBuf, int32_t msgBufLen) {
955
  SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
956
  assert(pCreateTable->type == TSDB_SQL_CREATE_TABLE);
957 958 959 960

  SMsgBuf  m = {.buf = msgBuf, .len = msgBufLen};
  SMsgBuf* pMsgBuf = &m;

961
  SVnodeModifOpStmtInfo* pModifSqlStmt = NULL;
962 963

  int32_t msgLen = 0;
964
  int32_t code = doCheckAndBuildCreateTableReq(pCreateTable, pCtx, pMsgBuf, (char**) &pModifSqlStmt, &msgLen);
965
  if (code != TSDB_CODE_SUCCESS) {
966
    tfree(pModifSqlStmt);
967 968 969
    return NULL;
  }

970
  return pModifSqlStmt;
971
}