taosdata / TDengine / #3633

coverage: 0.0% (-60.7%) from 60.719%
#3633

push

travis-ci

web-flow 
Merge pull request #30118 from taosdata/wl30

udpate ci workflow

0 of 280412 branches covered (0.0%)

Branch coverage included in aggregate %.

0 of 275582 relevant lines covered (0.0%)

0.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0
/source/libs/command/src/command.c
1 
/*
2 
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3 
 *
4 
 * This program is free software: you can use, redistribute, and/or modify
5 
 * it under the terms of the GNU Affero General Public License, version 3
6 
 * or later ("AGPL"), as published by the Free Software Foundation.
7 
 *
8 
 * This program is distributed in the hope that it will be useful, but WITHOUT
9 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 
 * FITNESS FOR A PARTICULAR PURPOSE.
11 
 *
12 
 * You should have received a copy of the GNU Affero General Public License
13 
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14 
 */
15 









16



#include "catalog.h"










17



#include "command.h"










18



#include "commandInt.h"










19



#include "scheduler.h"










20



#include "systable.h"










21



#include "taosdef.h"










22



#include "tdatablock.h"










23



#include "tdataformat.h"










24



#include "tglobal.h"










25



#include "tgrant.h"










26












27



#define COL_DATA_SET_VAL_AND_CHECK(pCol, rows, buf, isNull) \










28



  do {                                                      \










29



    int _code = colDataSetVal(pCol, rows, buf, isNull);     \










30



    if (TSDB_CODE_SUCCESS != _code) {                       \










31



      terrno = _code;                                       \










32



      return _code;                                         \










33



    }                                                       \










34



  } while (0)










35












36



extern SConfig* tsCfg;










37












38



static int32_t buildRetrieveTableRsp(SSDataBlock* pBlock, int32_t numOfCols, SRetrieveTableRsp** pRsp) {




×







39



  if (NULL == pBlock || NULL == pRsp) {





×







40



    return TSDB_CODE_INVALID_PARA;




×







41



  }










42



  size_t dataEncodeBufSize = blockGetEncodeSize(pBlock);




×







43



  size_t rspSize = sizeof(SRetrieveTableRsp) + dataEncodeBufSize + PAYLOAD_PREFIX_LEN;




×







44



  *pRsp = taosMemoryCalloc(1, rspSize);





×







45



  if (NULL == *pRsp) {





×







46



    return terrno;




×







47



  }










48












49



  (*pRsp)->useconds = 0;




×







50



  (*pRsp)->completed = 1;




×







51



  (*pRsp)->precision = 0;




×







52



  (*pRsp)->compressed = 0;




×







53












54



  (*pRsp)->numOfRows = htobe64((int64_t)pBlock->info.rows);




×







55



  (*pRsp)->numOfCols = htonl(numOfCols);




×







56












57



  int32_t len = 0;




×







58



  if (pBlock->info.rows > 0) {





×







59



    len = blockEncode(pBlock, (*pRsp)->data + PAYLOAD_PREFIX_LEN, dataEncodeBufSize, numOfCols);




×







60



    if (len < 0) {





×







61



      taosMemoryFree(*pRsp);





×







62



      *pRsp = NULL;




×







63



      return terrno;




×







64



    }










65



    SET_PAYLOAD_LEN((*pRsp)->data, len, len);




×







66



  }










67












68



  int32_t payloadLen = len + PAYLOAD_PREFIX_LEN;




×







69



  (*pRsp)->payloadLen = htonl(payloadLen);




×







70



  (*pRsp)->compLen = htonl(payloadLen);




×







71












72



  return TSDB_CODE_SUCCESS;




×







73



}










74












75



static int32_t getSchemaBytes(const SSchema* pSchema) {




×







76



  switch (pSchema->type) {





×







77



    case TSDB_DATA_TYPE_BINARY:




×







78



    case TSDB_DATA_TYPE_VARBINARY:










79



    case TSDB_DATA_TYPE_GEOMETRY:










80



      return (pSchema->bytes - VARSTR_HEADER_SIZE);




×







81



    case TSDB_DATA_TYPE_NCHAR:




×







82



    case TSDB_DATA_TYPE_JSON:










83



      return (pSchema->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE;




×







84



    default:




×







85



      return pSchema->bytes;




×







86



  }










87



}










88












89



static int32_t buildDescResultDataBlock(SSDataBlock** pOutput) {




×







90



  QRY_PARAM_CHECK(pOutput);





×







91












92



  SSDataBlock* pBlock = NULL;




×







93



  int32_t      code = createDataBlock(&pBlock);




×







94



  if (code) {





×







95



    return code;




×







96



  }










97












98



  SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_FIELD_LEN, 1);




×







99



  code = blockDataAppendColInfo(pBlock, &infoData);




×







100



  if (TSDB_CODE_SUCCESS == code) {





×







101



    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_TYPE_LEN, 2);




×







102



    code = blockDataAppendColInfo(pBlock, &infoData);




×







103



  }










104



  if (TSDB_CODE_SUCCESS == code) {





×







105



    infoData = createColumnInfoData(TSDB_DATA_TYPE_INT, tDataTypes[TSDB_DATA_TYPE_INT].bytes, 3);




×







106



    code = blockDataAppendColInfo(pBlock, &infoData);




×







107



  }










108



  if (TSDB_CODE_SUCCESS == code) {





×







109



    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_NOTE_LEN, 4);




×







110



    code = blockDataAppendColInfo(pBlock, &infoData);




×







111



  }










112



  if (TSDB_CODE_SUCCESS == code) {





×







113



    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_COPRESS_OPTION_LEN, 5);




×







114



    code = blockDataAppendColInfo(pBlock, &infoData);




×







115



  }










116



  if (TSDB_CODE_SUCCESS == code) {





×







117



    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_COPRESS_OPTION_LEN, 6);




×







118



    code = blockDataAppendColInfo(pBlock, &infoData);




×







119



  }










120



  if (TSDB_CODE_SUCCESS == code) {





×







121



    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, DESCRIBE_RESULT_COPRESS_OPTION_LEN, 7);




×







122



    code = blockDataAppendColInfo(pBlock, &infoData);




×







123



  }










124












125



  if (TSDB_CODE_SUCCESS == code) {





×







126



    *pOutput = pBlock;




×







127



  } else {










128



    (void)blockDataDestroy(pBlock);




×







129



  }










130



  return code;




×







131



}










132












133



static int32_t setDescResultIntoDataBlock(bool sysInfoUser, SSDataBlock* pBlock, int32_t numOfRows, STableMeta* pMeta,




×







134



                                          int8_t biMode) {










135



  int32_t blockCap = (biMode != 0) ? numOfRows + 1 : numOfRows;





×







136



  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, blockCap));





×







137



  pBlock->info.rows = 0;




×







138












139



  // field










140



  SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);




×







141



  // Type










142



  SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);




×







143



  // Length










144



  SColumnInfoData* pCol3 = taosArrayGet(pBlock->pDataBlock, 2);




×







145



  // Note










146



  SColumnInfoData* pCol4 = taosArrayGet(pBlock->pDataBlock, 3);




×







147



  // encode










148



  SColumnInfoData* pCol5 = NULL;




×







149



  // compress










150



  SColumnInfoData* pCol6 = NULL;




×







151



  // level










152



  SColumnInfoData* pCol7 = NULL;




×







153



  if (useCompress(pMeta->tableType)) {





×







154



    pCol5 = taosArrayGet(pBlock->pDataBlock, 4);




×







155



    pCol6 = taosArrayGet(pBlock->pDataBlock, 5);




×







156



    pCol7 = taosArrayGet(pBlock->pDataBlock, 6);




×







157



  }










158












159



  int32_t fillTagCol = 0;




×







160



  char    buf[DESCRIBE_RESULT_FIELD_LEN] = {0};




×







161



  for (int32_t i = 0; i < numOfRows; ++i) {





×







162



    if (invisibleColumn(sysInfoUser, pMeta->tableType, pMeta->schema[i].flags)) {





×







163



      continue;




×







164



    }










165



    STR_TO_VARSTR(buf, pMeta->schema[i].name);




×







166



    COL_DATA_SET_VAL_AND_CHECK(pCol1, pBlock->info.rows, buf, false);





×







167












168



    STR_TO_VARSTR(buf, tDataTypes[pMeta->schema[i].type].name);




×







169



    COL_DATA_SET_VAL_AND_CHECK(pCol2, pBlock->info.rows, buf, false);





×







170



    int32_t bytes = getSchemaBytes(pMeta->schema + i);




×







171



    COL_DATA_SET_VAL_AND_CHECK(pCol3, pBlock->info.rows, (const char*)&bytes, false);





×







172



    if (TSDB_VIEW_TABLE != pMeta->tableType) {





×







173



      if (i >= pMeta->tableInfo.numOfColumns) {





×







174



        STR_TO_VARSTR(buf, "TAG");




×







175



        fillTagCol = 1;




×







176



      } else if (i == 1 && pMeta->schema[i].flags & COL_IS_KEY) {





×







177



        STR_TO_VARSTR(buf, "PRIMARY KEY")




×







178



      } else {










179



        STR_TO_VARSTR(buf, "");




×







180



      }










181



    } else {










182



      STR_TO_VARSTR(buf, "VIEW COL");




×







183



    }










184



    COL_DATA_SET_VAL_AND_CHECK(pCol4, pBlock->info.rows, buf, false);





×







185



    if (useCompress(pMeta->tableType) && pMeta->schemaExt) {





×







186



      if (i < pMeta->tableInfo.numOfColumns) {





×







187



        STR_TO_VARSTR(buf, columnEncodeStr(COMPRESS_L1_TYPE_U32(pMeta->schemaExt[i].compress)));




×







188



        COL_DATA_SET_VAL_AND_CHECK(pCol5, pBlock->info.rows, buf, false);





×







189



        STR_TO_VARSTR(buf, columnCompressStr(COMPRESS_L2_TYPE_U32(pMeta->schemaExt[i].compress)));




×







190



        COL_DATA_SET_VAL_AND_CHECK(pCol6, pBlock->info.rows, buf, false);





×







191



        STR_TO_VARSTR(buf, columnLevelStr(COMPRESS_L2_TYPE_LEVEL_U32(pMeta->schemaExt[i].compress)));




×







192



        COL_DATA_SET_VAL_AND_CHECK(pCol7, pBlock->info.rows, buf, false);





×







193



      } else {










194



        STR_TO_VARSTR(buf, fillTagCol == 0 ? "" : "disabled");





×







195



        COL_DATA_SET_VAL_AND_CHECK(pCol5, pBlock->info.rows, buf, false);





×







196



        STR_TO_VARSTR(buf, fillTagCol == 0 ? "" : "disabled");





×







197



        COL_DATA_SET_VAL_AND_CHECK(pCol6, pBlock->info.rows, buf, false);





×







198



        STR_TO_VARSTR(buf, fillTagCol == 0 ? "" : "disabled");





×







199



        COL_DATA_SET_VAL_AND_CHECK(pCol7, pBlock->info.rows, buf, false);





×







200



      }










201



    }










202












203



    fillTagCol = 0;




×







204












205



    ++(pBlock->info.rows);




×







206



  }










207



  if (pMeta->tableType == TSDB_SUPER_TABLE && biMode != 0) {





×







208



    STR_TO_VARSTR(buf, "tbname");




×







209



    COL_DATA_SET_VAL_AND_CHECK(pCol1, pBlock->info.rows, buf, false);





×







210



    STR_TO_VARSTR(buf, "VARCHAR");




×







211



    COL_DATA_SET_VAL_AND_CHECK(pCol2, pBlock->info.rows, buf, false);





×







212



    int32_t bytes = TSDB_TABLE_NAME_LEN - 1;




×







213



    COL_DATA_SET_VAL_AND_CHECK(pCol3, pBlock->info.rows, (const char*)&bytes, false);





×







214



    STR_TO_VARSTR(buf, "TAG");




×







215



    COL_DATA_SET_VAL_AND_CHECK(pCol4, pBlock->info.rows, buf, false);





×







216



    ++(pBlock->info.rows);




×







217



  }










218



  if (pBlock->info.rows <= 0) {





×







219



    qError("no permission to view any columns");





×







220



    return TSDB_CODE_PAR_PERMISSION_DENIED;




×







221



  }










222



  return TSDB_CODE_SUCCESS;




×







223



}










224












225



static int32_t execDescribe(bool sysInfoUser, SNode* pStmt, SRetrieveTableRsp** pRsp, int8_t biMode) {




×







226



  SDescribeStmt* pDesc = (SDescribeStmt*)pStmt;




×







227



  if (NULL == pDesc || NULL == pDesc->pMeta) {





×







228



    return TSDB_CODE_INVALID_PARA;




×







229



  }










230



  int32_t numOfRows = TABLE_TOTAL_COL_NUM(pDesc->pMeta);




×







231












232



  SSDataBlock* pBlock = NULL;




×







233



  int32_t      code = buildDescResultDataBlock(&pBlock);




×







234



  if (TSDB_CODE_SUCCESS == code) {





×







235



    code = setDescResultIntoDataBlock(sysInfoUser, pBlock, numOfRows, pDesc->pMeta, biMode);




×







236



  }










237



  if (TSDB_CODE_SUCCESS == code) {





×







238



    if (pDesc->pMeta && useCompress(pDesc->pMeta->tableType) && pDesc->pMeta->schemaExt) {





×







239



      code = buildRetrieveTableRsp(pBlock, DESCRIBE_RESULT_COLS_COMPRESS, pRsp);




×







240



    } else {










241



      code = buildRetrieveTableRsp(pBlock, DESCRIBE_RESULT_COLS, pRsp);




×







242



    }










243



  }










244



  (void)blockDataDestroy(pBlock);




×







245



  return code;




×







246



}










247












248



static int32_t execResetQueryCache() { return catalogClearCache(); }




×







249












250



static int32_t buildCreateDBResultDataBlock(SSDataBlock** pOutput) {




×







251



  QRY_PARAM_CHECK(pOutput);





×







252












253



  SSDataBlock* pBlock = NULL;




×







254



  int32_t      code = createDataBlock(&pBlock);




×







255



  if (code) {





×







256



    return code;




×







257



  }










258












259



  SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_DB_RESULT_COLS, 1);




×







260



  code = blockDataAppendColInfo(pBlock, &infoData);




×







261



  if (TSDB_CODE_SUCCESS == code) {





×







262



    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_DB_RESULT_FIELD2_LEN, 2);




×







263



    code = blockDataAppendColInfo(pBlock, &infoData);




×







264



  }










265












266



  if (TSDB_CODE_SUCCESS == code) {





×







267



    *pOutput = pBlock;




×







268



  } else {










269



    (void)blockDataDestroy(pBlock);




×







270



  }










271



  return code;




×







272



}










273












274



int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {




×







275



  int64_t v = 0;




×







276



  switch (unit) {





×







277



    case 's':




×







278



      v = val / 1000;




×







279



      break;




×







280



    case 'm':




×







281



      v = val / tsTickPerMin[TSDB_TIME_PRECISION_MILLI];




×







282



      break;




×







283



    case 'h':




×







284



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 60);




×







285



      break;




×







286



    case 'd':




×







287



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60);




×







288



      break;




×







289



    case 'w':




×







290



      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60 * 7);




×







291



      break;




×







292



    default:




×







293



      break;




×







294



  }










295












296



  return v;




×







297



}










298












299



static int32_t buildRetension(SArray* pRetension, char** ppRetentions) {




×







300



  size_t size = taosArrayGetSize(pRetension);




×







301



  if (size == 0) {





×







302



    *ppRetentions = NULL;




×







303



    return TSDB_CODE_SUCCESS;




×







304



  }










305












306



  const int lMaxLen = 128;




×







307



  char*     p1 = taosMemoryCalloc(1, lMaxLen);





×







308



  if (NULL == p1) {





×







309



    return terrno;




×







310



  }










311



  int32_t len = 0;




×







312












313



  for (int32_t i = 0; i < size; ++i) {





×







314



    SRetention* p = TARRAY_GET_ELEM(pRetension, i);




×







315



    int64_t     v1 = getValOfDiffPrecision(p->freqUnit, p->freq);




×







316



    int64_t     v2 = getValOfDiffPrecision(p->keepUnit, p->keep);




×







317



    if (i == 0) {





×







318



      len += tsnprintf(p1 + len, lMaxLen - len, "-:%" PRId64 "%c", v2, p->keepUnit);




×







319



    } else {










320



      len += tsnprintf(p1 + len, lMaxLen - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);




×







321



    }










322












323



    if (i < size - 1) {





×







324



      len += tsnprintf(p1 + len, lMaxLen - len, ",");




×







325



    }










326



  }










327












328



  *ppRetentions = p1;




×







329



  return TSDB_CODE_SUCCESS;




×







330



}










331












332



static const char* cacheModelStr(int8_t cacheModel) {




×







333



  switch (cacheModel) {





×







334



    case TSDB_CACHE_MODEL_NONE:




×







335



      return TSDB_CACHE_MODEL_NONE_STR;




×







336



    case TSDB_CACHE_MODEL_LAST_ROW:




×







337



      return TSDB_CACHE_MODEL_LAST_ROW_STR;




×







338



    case TSDB_CACHE_MODEL_LAST_VALUE:




×







339



      return TSDB_CACHE_MODEL_LAST_VALUE_STR;




×







340



    case TSDB_CACHE_MODEL_BOTH:




×







341



      return TSDB_CACHE_MODEL_BOTH_STR;




×







342



    default:




×







343



      break;




×







344



  }










345



  return TSDB_CACHE_MODEL_NONE_STR;




×







346



}










347












348



static const char* encryptAlgorithmStr(int8_t encryptAlgorithm) {




×







349



  switch (encryptAlgorithm) {





×







350



    case TSDB_ENCRYPT_ALGO_NONE:




×







351



      return TSDB_ENCRYPT_ALGO_NONE_STR;




×







352



    case TSDB_ENCRYPT_ALGO_SM4:




×







353



      return TSDB_ENCRYPT_ALGO_SM4_STR;




×







354



    default:




×







355



      break;




×







356



  }










357



  return TSDB_CACHE_MODEL_NONE_STR;




×







358



}










359












360



int32_t formatDurationOrKeep(char* buffer, int64_t bufSize, int32_t timeInMinutes) {




×







361



  if (buffer == NULL || bufSize <= 0) {





×







362



    return 0;




×







363



  }










364



  int32_t len = 0;




×







365



  if (timeInMinutes % 1440 == 0) {





×







366



    int32_t days = timeInMinutes / 1440;




×







367



    len = tsnprintf(buffer, bufSize, "%dd", days);




×







368



  } else if (timeInMinutes % 60 == 0) {





×







369



    int32_t hours = timeInMinutes / 60;




×







370



    len = tsnprintf(buffer, bufSize, "%dh", hours);




×







371



  } else {










372



    len = tsnprintf(buffer, bufSize, "%dm", timeInMinutes);




×







373



  }










374



  return len;




×







375



}










376












377



static int32_t setCreateDBResultIntoDataBlock(SSDataBlock* pBlock, char* dbName, char* dbFName, SDbCfgInfo* pCfg) {




×







378



  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));





×







379



  pBlock->info.rows = 1;




×







380












381



  SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);




×







382



  char             buf1[SHOW_CREATE_DB_RESULT_FIELD1_LEN] = {0};




×







383



  STR_TO_VARSTR(buf1, dbName);




×







384



  COL_DATA_SET_VAL_AND_CHECK(pCol1, 0, buf1, false);





×







385












386



  SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);




×







387



  char             buf2[SHOW_CREATE_DB_RESULT_FIELD2_LEN] = {0};




×







388



  int32_t          len = 0;




×







389



  char*            prec = NULL;




×







390



  switch (pCfg->precision) {





×







391



    case TSDB_TIME_PRECISION_MILLI:




×







392



      prec = TSDB_TIME_PRECISION_MILLI_STR;




×







393



      break;




×







394



    case TSDB_TIME_PRECISION_MICRO:




×







395



      prec = TSDB_TIME_PRECISION_MICRO_STR;




×







396



      break;




×







397



    case TSDB_TIME_PRECISION_NANO:




×







398



      prec = TSDB_TIME_PRECISION_NANO_STR;




×







399



      break;




×







400



    default:




×







401



      prec = "none";




×







402



      break;




×







403



  }










404












405



  char* pRetentions = NULL;




×







406



  QRY_ERR_RET(buildRetension(pCfg->pRetensions, &pRetentions));





×







407



  int32_t dbFNameLen = strlen(dbFName);




×







408



  int32_t hashPrefix = 0;




×







409



  if (pCfg->hashPrefix > 0) {





×







410



    hashPrefix = pCfg->hashPrefix - dbFNameLen - 1;




×







411



  } else if (pCfg->hashPrefix < 0) {





×







412



    hashPrefix = pCfg->hashPrefix + dbFNameLen + 1;




×







413



  }










414



  char durationStr[128] = {0};




×







415



  char keep0Str[128] = {0};




×







416



  char keep1Str[128] = {0};




×







417



  char keep2Str[128] = {0};




×







418



  char compactIntervalStr[13] = {0};




×







419



  char compactStartTimeStr[13] = {0};




×







420



  char compactEndTimeStr[13] = {0};




×







421












422



  int32_t lenDuration = formatDurationOrKeep(durationStr, sizeof(durationStr), pCfg->daysPerFile);




×







423



  int32_t lenKeep0 = formatDurationOrKeep(keep0Str, sizeof(keep0Str), pCfg->daysToKeep0);




×







424



  int32_t lenKeep1 = formatDurationOrKeep(keep1Str, sizeof(keep1Str), pCfg->daysToKeep1);




×







425



  int32_t lenKeep2 = formatDurationOrKeep(keep2Str, sizeof(keep2Str), pCfg->daysToKeep2);




×







426



  UNUSED(formatDurationOrKeep(compactIntervalStr, sizeof(compactIntervalStr), pCfg->compactInterval));




×







427



  UNUSED(formatDurationOrKeep(compactStartTimeStr, sizeof(compactStartTimeStr), pCfg->compactStartTime));




×







428



  UNUSED(formatDurationOrKeep(compactEndTimeStr, sizeof(compactEndTimeStr), pCfg->compactEndTime));




×







429












430



  if (IS_SYS_DBNAME(dbName)) {





×







431



    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE, SHOW_CREATE_DB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,




×







432



                     "CREATE DATABASE `%s`", dbName);




×







433



  } else {










434



    len +=




×







435



        tsnprintf(buf2 + VARSTR_HEADER_SIZE, SHOW_CREATE_DB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,




×







436



                  "CREATE DATABASE `%s` BUFFER %d CACHESIZE %d CACHEMODEL '%s' COMP %d DURATION %s "










437



                  "WAL_FSYNC_PERIOD %d MAXROWS %d MINROWS %d STT_TRIGGER %d KEEP %s,%s,%s PAGES %d PAGESIZE %d "










438



                  "PRECISION '%s' REPLICA %d "










439



                  "WAL_LEVEL %d VGROUPS %d SINGLE_STABLE %d TABLE_PREFIX %d TABLE_SUFFIX %d TSDB_PAGESIZE %d "










440



                  "WAL_RETENTION_PERIOD %d WAL_RETENTION_SIZE %" PRId64










441



                  " KEEP_TIME_OFFSET %d ENCRYPT_ALGORITHM '%s' S3_CHUNKPAGES %d S3_KEEPLOCAL %dm S3_COMPACT %d "










442



                  "COMPACT_INTERVAL %s COMPACT_TIME_RANGE %s,%s COMPACT_TIME_OFFSET %"PRIi8 "h",










443



                  dbName, pCfg->buffer, pCfg->cacheSize, cacheModelStr(pCfg->cacheLast), pCfg->compression, durationStr,




×







444



                  pCfg->walFsyncPeriod, pCfg->maxRows, pCfg->minRows, pCfg->sstTrigger, keep0Str, keep1Str, keep2Str,




×







445



                  pCfg->pages, pCfg->pageSize, prec, pCfg->replications, pCfg->walLevel, pCfg->numOfVgroups,




×







446



                  1 == pCfg->numOfStables, hashPrefix, pCfg->hashSuffix, pCfg->tsdbPageSize, pCfg->walRetentionPeriod,




×







447



                  pCfg->walRetentionSize, pCfg->keepTimeOffset, encryptAlgorithmStr(pCfg->encryptAlgorithm),




×







448



                  pCfg->s3ChunkSize, pCfg->s3KeepLocal, pCfg->s3Compact, compactIntervalStr, compactStartTimeStr,




×







449



                  compactEndTimeStr, pCfg->compactTimeOffset);




×







450












451



    if (pRetentions) {





×







452



      len += tsnprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_DB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,




×







453



                       " RETENTIONS %s", pRetentions);










454



    }










455



  }










456












457



  taosMemoryFree(pRetentions);





×







458












459



  (varDataLen(buf2)) = len;




×







460












461



  COL_DATA_SET_VAL_AND_CHECK(pCol2, 0, buf2, false);





×







462












463



  return TSDB_CODE_SUCCESS;




×







464



}










465












466



static int32_t execShowCreateDatabase(SShowCreateDatabaseStmt* pStmt, SRetrieveTableRsp** pRsp) {




×







467



  SSDataBlock* pBlock = NULL;




×







468



  int32_t      code = buildCreateDBResultDataBlock(&pBlock);




×







469



  if (TSDB_CODE_SUCCESS == code) {





×







470



    code = setCreateDBResultIntoDataBlock(pBlock, pStmt->dbName, pStmt->dbFName, pStmt->pCfg);




×







471



  }










472



  if (TSDB_CODE_SUCCESS == code) {





×







473



    code = buildRetrieveTableRsp(pBlock, SHOW_CREATE_DB_RESULT_COLS, pRsp);




×







474



  }










475



  (void)blockDataDestroy(pBlock);




×







476



  return code;




×







477



}










478












479



static int32_t buildCreateTbResultDataBlock(SSDataBlock** pOutput) {




×







480



  QRY_PARAM_CHECK(pOutput);





×







481












482



  SSDataBlock* pBlock = NULL;




×







483



  int32_t      code = createDataBlock(&pBlock);




×







484



  if (code) {





×







485



    return code;




×







486



  }










487












488



  SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_TB_RESULT_FIELD1_LEN, 1);




×







489



  code = blockDataAppendColInfo(pBlock, &infoData);




×







490



  if (TSDB_CODE_SUCCESS == code) {





×







491



    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_TB_RESULT_FIELD2_LEN, 2);




×







492



    code = blockDataAppendColInfo(pBlock, &infoData);




×







493



  }










494












495



  if (TSDB_CODE_SUCCESS == code) {





×







496



    *pOutput = pBlock;




×







497



  } else {










498



    (void)blockDataDestroy(pBlock);




×







499



  }










500



  return code;




×







501



}










502












503



static int32_t buildCreateViewResultDataBlock(SSDataBlock** pOutput) {




×







504



  QRY_PARAM_CHECK(pOutput);





×







505












506



  SSDataBlock* pBlock = NULL;




×







507



  int32_t      code = createDataBlock(&pBlock);




×







508



  if (code) {





×







509



    return code;




×







510



  }










511












512



  SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_VIEW_RESULT_FIELD1_LEN, 1);




×







513



  code = blockDataAppendColInfo(pBlock, &infoData);




×







514



  if (TSDB_CODE_SUCCESS == code) {





×







515



    infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, SHOW_CREATE_VIEW_RESULT_FIELD2_LEN, 2);




×







516



    code = blockDataAppendColInfo(pBlock, &infoData);




×







517



  }










518












519



  if (TSDB_CODE_SUCCESS == code) {





×







520



    *pOutput = pBlock;




×







521



  } else {










522



    (void)blockDataDestroy(pBlock);




×







523



  }










524



  return code;




×







525



}










526












527



static void appendColumnFields(char* buf, int32_t* len, STableCfg* pCfg) {




×







528



  for (int32_t i = 0; i < pCfg->numOfColumns; ++i) {





×







529



    SSchema* pSchema = pCfg->pSchemas + i;




×







530



#define LTYPE_LEN (32 + 60)  // 60 byte for compress info










531



    char type[LTYPE_LEN];










532



    snprintf(type, LTYPE_LEN, "%s", tDataTypes[pSchema->type].name);




×







533



    int typeLen = strlen(type);




×







534



    if (TSDB_DATA_TYPE_VARCHAR == pSchema->type || TSDB_DATA_TYPE_VARBINARY == pSchema->type ||





×







535



        TSDB_DATA_TYPE_GEOMETRY == pSchema->type) {





×







536



      typeLen += tsnprintf(type + typeLen, LTYPE_LEN - typeLen, "(%d)", (int32_t)(pSchema->bytes - VARSTR_HEADER_SIZE));




×







537



    } else if (TSDB_DATA_TYPE_NCHAR == pSchema->type) {





×







538



      typeLen += tsnprintf(type + typeLen, LTYPE_LEN - typeLen, "(%d)",




×







539



                           (int32_t)((pSchema->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));




×







540



    }










541












542



    if (useCompress(pCfg->tableType) && pCfg->pSchemaExt) {





×







543



      typeLen += tsnprintf(type + typeLen, LTYPE_LEN - typeLen, " ENCODE \'%s\'",




×







544



                           columnEncodeStr(COMPRESS_L1_TYPE_U32(pCfg->pSchemaExt[i].compress)));




×







545



      typeLen += tsnprintf(type + typeLen, LTYPE_LEN - typeLen, " COMPRESS \'%s\'",




×







546



                           columnCompressStr(COMPRESS_L2_TYPE_U32(pCfg->pSchemaExt[i].compress)));




×







547



      typeLen += tsnprintf(type + typeLen, LTYPE_LEN - typeLen, " LEVEL \'%s\'",




×







548



                           columnLevelStr(COMPRESS_L2_TYPE_LEVEL_U32(pCfg->pSchemaExt[i].compress)));




×







549



    }










550



    if (!(pSchema->flags & COL_IS_KEY)) {





×







551



      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







552



                        "%s`%s` %s", ((i > 0) ? ", " : ""), pSchema->name, type);





×







553



    } else {










554



      char* pk = "PRIMARY KEY";




×







555



      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







556



                        "%s`%s` %s %s", ((i > 0) ? ", " : ""), pSchema->name, type, pk);





×







557



    }










558



  }










559



}




×







560












561



static void appendTagFields(char* buf, int32_t* len, STableCfg* pCfg) {




×







562



  for (int32_t i = 0; i < pCfg->numOfTags; ++i) {





×







563



    SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;




×







564



    char     type[32];










565



    snprintf(type, sizeof(type), "%s", tDataTypes[pSchema->type].name);




×







566



    if (TSDB_DATA_TYPE_VARCHAR == pSchema->type || TSDB_DATA_TYPE_VARBINARY == pSchema->type ||





×







567



        TSDB_DATA_TYPE_GEOMETRY == pSchema->type) {





×







568



      snprintf(type + strlen(type), sizeof(type) - strlen(type), "(%d)",




×







569



               (int32_t)(pSchema->bytes - VARSTR_HEADER_SIZE));




×







570



    } else if (TSDB_DATA_TYPE_NCHAR == pSchema->type) {





×







571



      snprintf(type + strlen(type), sizeof(type) - strlen(type), "(%d)",




×







572



               (int32_t)((pSchema->bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));




×







573



    }










574












575



    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







576



                      "%s`%s` %s", ((i > 0) ? ", " : ""), pSchema->name, type);





×







577



  }










578



}




×







579












580



static void appendTagNameFields(char* buf, int32_t* len, STableCfg* pCfg) {




×







581



  for (int32_t i = 0; i < pCfg->numOfTags; ++i) {





×







582



    SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;




×







583



    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







584



                      "%s`%s`", ((i > 0) ? ", " : ""), pSchema->name);





×







585



  }










586



}




×







587












588



static int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg, void* charsetCxt) {




×







589



  int32_t code = TSDB_CODE_SUCCESS;




×







590



  SArray* pTagVals = NULL;




×







591



  STag*   pTag = (STag*)pCfg->pTags;




×







592












593



  if (NULL == pCfg->pTags || pCfg->numOfTags <= 0) {





×







594



    qError("tag missed in table cfg, pointer:%p, numOfTags:%d", pCfg->pTags, pCfg->numOfTags);





×







595



    return TSDB_CODE_APP_ERROR;




×







596



  }










597












598



  if (tTagIsJson(pTag)) {





×







599



    char* pJson = NULL;




×







600



    parseTagDatatoJson(pTag, &pJson, charsetCxt);




×







601



    if (NULL == pJson) {





×







602



      qError("failed to parse tag to json, pJson is NULL");





×







603



      return terrno;




×







604



    }










605



    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







606



                      "%s", pJson);










607



    taosMemoryFree(pJson);





×







608












609



    return TSDB_CODE_SUCCESS;




×







610



  }










611












612



  QRY_ERR_RET(tTagToValArray((const STag*)pCfg->pTags, &pTagVals));





×







613



  int16_t valueNum = taosArrayGetSize(pTagVals);




×







614



  int32_t num = 0;




×







615



  int32_t j = 0;




×







616



  for (int32_t i = 0; i < pCfg->numOfTags; ++i) {





×







617



    SSchema* pSchema = pCfg->pSchemas + pCfg->numOfColumns + i;




×







618



    if (i > 0) {





×







619



      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







620



                        ", ");










621



    }










622












623



    if (j >= valueNum) {





×







624



      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







625



                        "NULL");










626



      continue;




×







627



    }










628












629



    STagVal* pTagVal = (STagVal*)taosArrayGet(pTagVals, j);




×







630



    if (pSchema->colId > pTagVal->cid) {





×







631



      qError("tag value and column mismatch, schemaId:%d, valId:%d", pSchema->colId, pTagVal->cid);





×







632



      code = TSDB_CODE_APP_ERROR;




×







633



      TAOS_CHECK_ERRNO(code);





×







634



    } else if (pSchema->colId == pTagVal->cid) {





×







635



      char    type = pTagVal->type;




×







636



      int32_t tlen = 0;




×







637












638



      int64_t leftSize = SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len);




×







639



      if (leftSize <= 0) {





×







640



        qError("no enough space to store tag value, leftSize:%" PRId64, leftSize);





×







641



        code = TSDB_CODE_APP_ERROR;




×







642



        TAOS_CHECK_ERRNO(code);





×







643



      }










644



      if (IS_VAR_DATA_TYPE(type)) {





×







645



        code = dataConverToStr(buf + VARSTR_HEADER_SIZE + *len, leftSize, type, pTagVal->pData, pTagVal->nData, &tlen);




×







646



        TAOS_CHECK_ERRNO(code);





×







647



      } else {










648



        code = dataConverToStr(buf + VARSTR_HEADER_SIZE + *len, leftSize, type, &pTagVal->i64, tDataTypes[type].bytes,




×







649



                               &tlen);










650



        TAOS_CHECK_ERRNO(code);





×







651



      }










652



      *len += tlen;




×







653



      j++;




×







654



    } else {










655



      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







656



                        "NULL");










657



    }










658



  }










659



_exit:




×







660



  taosArrayDestroy(pTagVals);




×







661












662



  return code;




×







663



}










664












665



static void appendTableOptions(char* buf, int32_t* len, SDbCfgInfo* pDbCfg, STableCfg* pCfg) {




×







666



  if (pCfg->commentLen > 0) {





×







667



    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







668



                      " COMMENT '%s'", pCfg->pComment);










669



  } else if (0 == pCfg->commentLen) {





×







670



    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







671



                      " COMMENT ''");










672



  }










673












674



  if (NULL != pDbCfg->pRetensions && pCfg->watermark1 > 0) {





×







675



    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







676



                      " WATERMARK %" PRId64 "a", pCfg->watermark1);










677



    if (pCfg->watermark2 > 0) {





×







678



      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







679



                        ", %" PRId64 "a", pCfg->watermark2);










680



    }










681



  }










682












683



  if (NULL != pDbCfg->pRetensions && pCfg->delay1 > 0) {





×







684



    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







685



                      " MAX_DELAY %" PRId64 "a", pCfg->delay1);










686



    if (pCfg->delay2 > 0) {





×







687



      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







688



                        ", %" PRId64 "a", pCfg->delay2);










689



    }










690



  }










691












692



  int32_t funcNum = taosArrayGetSize(pCfg->pFuncs);




×







693



  if (NULL != pDbCfg->pRetensions && funcNum > 0) {





×







694



    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







695



                      " ROLLUP(");










696



    for (int32_t i = 0; i < funcNum; ++i) {





×







697



      char* pFunc = taosArrayGet(pCfg->pFuncs, i);




×







698



      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),





×







699



                        "%s%s", ((i > 0) ? ", " : ""), pFunc);










700



    }










701



    *len +=




×







702



        snprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len), ")");




×







703



  }










704












705



  if (pCfg->ttl > 0) {





×







706



    *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







707



                      " TTL %d", pCfg->ttl);










708



  }










709












710



  if (TSDB_SUPER_TABLE == pCfg->tableType || TSDB_NORMAL_TABLE == pCfg->tableType) {





×







711



    int32_t nSma = 0;




×







712



    for (int32_t i = 0; i < pCfg->numOfColumns; ++i) {





×







713



      if (IS_BSMA_ON(pCfg->pSchemas + i)) {





×







714



        ++nSma;




×







715



      }










716



    }










717












718



    if (nSma < pCfg->numOfColumns && nSma > 0) {





×







719



      bool smaOn = false;




×







720



      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len),




×







721



                        " SMA(");










722



      for (int32_t i = 0; i < pCfg->numOfColumns; ++i) {





×







723



        if (IS_BSMA_ON(pCfg->pSchemas + i)) {





×







724



          if (smaOn) {





×







725



            *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len,




×







726



                              SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len), ",`%s`",




×







727



                              (pCfg->pSchemas + i)->name);




×







728



          } else {










729



            smaOn = true;




×







730



            *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len,




×







731



                              SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + *len), "`%s`",




×







732



                              (pCfg->pSchemas + i)->name);




×







733



          }










734



        }










735



      }










736



      *len += tsnprintf(buf + VARSTR_HEADER_SIZE + *len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE, ")");




×







737



    }










738



  }










739



}




×







740












741



static int32_t setCreateTBResultIntoDataBlock(SSDataBlock* pBlock, SDbCfgInfo* pDbCfg, char* tbName, STableCfg* pCfg,




×







742



                                              void* charsetCxt) {










743



  int32_t code = TSDB_CODE_SUCCESS;




×







744



  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));





×







745



  pBlock->info.rows = 1;




×







746












747



  SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);




×







748



  char             buf1[SHOW_CREATE_TB_RESULT_FIELD1_LEN] = {0};




×







749



  STR_TO_VARSTR(buf1, tbName);




×







750



  QRY_ERR_RET(colDataSetVal(pCol1, 0, buf1, false));





×







751












752



  SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);




×







753



  char*            buf2 = taosMemoryMalloc(SHOW_CREATE_TB_RESULT_FIELD2_LEN);





×







754



  if (NULL == buf2) {





×







755



    QRY_ERR_RET(terrno);





×







756



  }










757












758



  int32_t len = 0;




×







759












760



  if (TSDB_SUPER_TABLE == pCfg->tableType) {





×







761



    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE, SHOW_CREATE_TB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,




×







762



                     "CREATE STABLE `%s` (", tbName);










763



    appendColumnFields(buf2, &len, pCfg);




×







764



    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + len),




×







765



                     ") TAGS (");










766



    appendTagFields(buf2, &len, pCfg);




×







767



    len +=




×







768



        snprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + len), ")");




×







769



    appendTableOptions(buf2, &len, pDbCfg, pCfg);




×







770



  } else if (TSDB_CHILD_TABLE == pCfg->tableType) {





×







771



    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE, SHOW_CREATE_TB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,




×







772



                     "CREATE TABLE `%s` USING `%s` (", tbName, pCfg->stbName);




×







773



    appendTagNameFields(buf2, &len, pCfg);




×







774



    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + len),




×







775



                     ") TAGS (");










776



    code = appendTagValues(buf2, &len, pCfg, charsetCxt);




×







777



    TAOS_CHECK_ERRNO(code);





×







778



    len +=




×







779



        snprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + len), ")");




×







780



    appendTableOptions(buf2, &len, pDbCfg, pCfg);




×







781



  } else {










782



    len += tsnprintf(buf2 + VARSTR_HEADER_SIZE, SHOW_CREATE_TB_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE,




×







783



                     "CREATE TABLE `%s` (", tbName);










784



    appendColumnFields(buf2, &len, pCfg);




×







785



    len +=




×







786



        snprintf(buf2 + VARSTR_HEADER_SIZE + len, SHOW_CREATE_TB_RESULT_FIELD2_LEN - (VARSTR_HEADER_SIZE + len), ")");




×







787



    appendTableOptions(buf2, &len, pDbCfg, pCfg);




×







788



  }










789












790



  varDataLen(buf2) = (len > 65535) ? 65535 : len;




×







791












792



  code = colDataSetVal(pCol2, 0, buf2, false);




×







793



  TAOS_CHECK_ERRNO(code);





×







794












795



_exit:




×







796



  taosMemoryFree(buf2);





×







797












798



  return code;




×







799



}










800












801



static int32_t setCreateViewResultIntoDataBlock(SSDataBlock* pBlock, SShowCreateViewStmt* pStmt) {




×







802



  int32_t code = 0;




×







803



  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));





×







804



  pBlock->info.rows = 1;




×







805












806



  SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);




×







807



  char             buf1[SHOW_CREATE_VIEW_RESULT_FIELD1_LEN + 1] = {0};




×







808



  snprintf(varDataVal(buf1), TSDB_VIEW_FNAME_LEN + 4, "`%s`.`%s`", pStmt->dbName, pStmt->viewName);




×







809



  varDataSetLen(buf1, strlen(varDataVal(buf1)));




×







810



  QRY_ERR_RET(colDataSetVal(pCol1, 0, buf1, false));





×







811












812



  SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);




×







813



  char*            buf2 = taosMemoryMalloc(SHOW_CREATE_VIEW_RESULT_FIELD2_LEN);





×







814



  if (NULL == buf2) {





×







815



    return terrno;




×







816



  }










817












818



  SViewMeta* pMeta = pStmt->pViewMeta;




×







819



  if (NULL == pMeta) {





×







820



    qError("exception: view meta is null");





×







821



    return TSDB_CODE_APP_ERROR;




×







822



  }










823



  snprintf(varDataVal(buf2), SHOW_CREATE_VIEW_RESULT_FIELD2_LEN - VARSTR_HEADER_SIZE, "CREATE VIEW `%s`.`%s` AS %s",




×







824



           pStmt->dbName, pStmt->viewName, pMeta->querySql);




×







825



  int32_t len = strlen(varDataVal(buf2));




×







826



  varDataLen(buf2) = (len > 65535) ? 65535 : len;




×







827



  code = colDataSetVal(pCol2, 0, buf2, false);




×







828



  taosMemoryFree(buf2);





×







829












830



  return code;




×







831



}










832












833



static int32_t execShowCreateTable(SShowCreateTableStmt* pStmt, SRetrieveTableRsp** pRsp, void* charsetCxt) {




×







834



  SSDataBlock* pBlock = NULL;




×







835



  int32_t      code = buildCreateTbResultDataBlock(&pBlock);




×







836



  if (TSDB_CODE_SUCCESS == code) {





×







837



    code = setCreateTBResultIntoDataBlock(pBlock, pStmt->pDbCfg, pStmt->tableName, pStmt->pTableCfg, charsetCxt);




×







838



  }










839



  if (TSDB_CODE_SUCCESS == code) {





×







840



    code = buildRetrieveTableRsp(pBlock, SHOW_CREATE_TB_RESULT_COLS, pRsp);




×







841



  }










842



  (void)blockDataDestroy(pBlock);




×







843



  return code;




×







844



}










845












846



static int32_t execShowCreateSTable(SShowCreateTableStmt* pStmt, SRetrieveTableRsp** pRsp, void* charsetCxt) {




×







847



  STableCfg* pCfg = (STableCfg*)pStmt->pTableCfg;




×







848



  if (TSDB_SUPER_TABLE != pCfg->tableType) {





×







849



    terrno = TSDB_CODE_TSC_NOT_STABLE_ERROR;




×







850



    return terrno;




×







851



  }










852












853



  return execShowCreateTable(pStmt, pRsp, charsetCxt);




×







854



}










855












856



static int32_t execAlterCmd(char* cmd, char* value, bool* processed) {




×







857



  int32_t code = 0;




×







858












859



  if (0 == strcasecmp(cmd, COMMAND_RESET_LOG)) {





×







860



    taosResetLog();




×







861



    cfgDumpCfg(tsCfg, 0, false);




×







862



  } else if (0 == strcasecmp(cmd, COMMAND_SCHEDULE_POLICY)) {





×







863



    int32_t tmp = 0;




×







864



    code = taosStr2int32(value, &tmp);




×







865



    if (code) {





×







866



      qError("invalid value:%s, error:%s", value, tstrerror(code));





×







867



      return code;




×







868



    }










869



    code = schedulerUpdatePolicy(tmp);




×







870



  } else if (0 == strcasecmp(cmd, COMMAND_ENABLE_RESCHEDULE)) {





×







871



    int32_t tmp = 0;




×







872



    code = taosStr2int32(value, &tmp);




×







873



    if (code) {





×







874



      qError("invalid value:%s, error:%s", value, tstrerror(code));





×







875



      return code;




×







876



    }










877



    code = schedulerEnableReSchedule(tmp != 0);




×







878



  } else if (0 == strcasecmp(cmd, COMMAND_CATALOG_DEBUG)) {





×







879



    code = ctgdHandleDbgCommand(value);




×







880



  } else if (0 == strcasecmp(cmd, COMMAND_ENABLE_MEM_DEBUG)) {





×







881



    code = taosMemoryDbgInit();




×







882



    if (code) {





×







883



      qError("failed to init memory dbg, error:%s", tstrerror(code));





×







884



      return code;




×







885



    }










886



    tsAsyncLog = false;




×







887



    qInfo("memory dbg enabled");





×







888



  } else if (0 == strcasecmp(cmd, COMMAND_DISABLE_MEM_DEBUG)) {





×







889



    code = taosMemoryDbgInitRestore();




×







890



    if (code) {





×







891



      qError("failed to restore from memory dbg, error:%s", tstrerror(code));





×







892



      return code;




×







893



    }










894



    qInfo("memory dbg disabled");





×







895



  } else {










896



    goto _return;




×







897



  }










898












899



  *processed = true;




×







900












901



_return:




×







902












903



  if (code) {





×







904



    terrno = code;




×







905



  }










906












907



  return code;




×







908



}










909












910



static int32_t execAlterLocal(SAlterLocalStmt* pStmt) {




×







911



  bool processed = false;




×







912












913



  if (execAlterCmd(pStmt->config, pStmt->value, &processed)) {





×







914



    return terrno;




×







915



  }










916












917



  if (processed) {





×







918



    goto _return;




×







919



  }










920












921



  if (cfgCheckRangeForDynUpdate(tsCfg, pStmt->config, pStmt->value, false, CFG_ALTER_LOCAL)) {





×







922



    return terrno;




×







923



  }










924












925



  if (cfgSetItem(tsCfg, pStmt->config, pStmt->value, CFG_STYPE_ALTER_CLIENT_CMD, true)) {





×







926



    return terrno;




×







927



  }










928












929



  TAOS_CHECK_RETURN(taosCfgDynamicOptions(tsCfg, pStmt->config, false));





×







930












931



_return:




×







932












933



  return TSDB_CODE_SUCCESS;




×







934



}










935












936



static int32_t buildLocalVariablesResultDataBlock(SSDataBlock** pOutput) {




×







937



  SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock));





×







938



  if (NULL == pBlock) {





×







939



    return terrno;




×







940



  }










941












942



  pBlock->info.hasVarCol = true;




×







943












944



  pBlock->pDataBlock = taosArrayInit(SHOW_LOCAL_VARIABLES_RESULT_COLS, sizeof(SColumnInfoData));




×







945



  if (NULL == pBlock->pDataBlock) {





×







946



    taosMemoryFree(pBlock);





×







947



    return terrno;




×







948



  }










949












950



  SColumnInfoData infoData = {0};




×







951












952



  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;




×







953



  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD1_LEN;




×







954



  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {





×







955



    goto _exit;




×







956



  }










957












958



  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;




×







959



  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN;




×







960



  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {





×







961



    goto _exit;




×







962



  }










963












964



  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;




×







965



  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD3_LEN;




×







966



  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {





×







967



    goto _exit;




×







968



  }










969












970



  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;




×







971



  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD4_LEN;




×







972



  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {





×







973



    goto _exit;




×







974



  }










975












976



  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;




×







977



  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD5_LEN;




×







978



  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {





×







979



    goto _exit;




×







980



  }










981












982



  *pOutput = pBlock;




×







983












984



_exit:




×







985



  if (terrno != TSDB_CODE_SUCCESS) {





×







986



    taosArrayDestroy(pBlock->pDataBlock);




×







987



    taosMemoryFree(pBlock);





×







988



  }










989



  return terrno;




×







990



}










991












992



static int32_t execShowLocalVariables(SShowStmt* pStmt, SRetrieveTableRsp** pRsp) {




×







993



  SSDataBlock* pBlock = NULL;




×







994



  char*        likePattern = NULL;




×







995



  int32_t      code = buildLocalVariablesResultDataBlock(&pBlock);




×







996



  if (TSDB_CODE_SUCCESS == code) {





×







997



    if (pStmt->tableCondType == OP_TYPE_LIKE) {





×







998



      likePattern = ((SValueNode*)pStmt->pTbName)->literal;




×







999



    }










1000



  }










1001



  if (TSDB_CODE_SUCCESS == code) {





×







1002



    code = dumpConfToDataBlock(pBlock, 0, likePattern);




×







1003



  }










1004



  if (TSDB_CODE_SUCCESS == code) {





×







1005



    code = buildRetrieveTableRsp(pBlock, SHOW_LOCAL_VARIABLES_RESULT_COLS, pRsp);




×







1006



  }










1007



  (void)blockDataDestroy(pBlock);




×







1008



  return code;




×







1009



}










1010












1011



static int32_t createSelectResultDataBlock(SNodeList* pProjects, SSDataBlock** pOutput) {




×







1012



  QRY_PARAM_CHECK(pOutput);





×







1013












1014



  SSDataBlock* pBlock = NULL;




×







1015



  int32_t      code = createDataBlock(&pBlock);




×







1016



  if (code) {





×







1017



    return code;




×







1018



  }










1019












1020



  SNode* pProj = NULL;




×







1021



  FOREACH(pProj, pProjects) {





×







1022



    SExprNode*      pExpr = (SExprNode*)pProj;




×







1023



    SColumnInfoData infoData = {0};




×







1024



    if (TSDB_DATA_TYPE_NULL == pExpr->resType.type) {





×







1025



      infoData.info.type = TSDB_DATA_TYPE_VARCHAR;




×







1026



      infoData.info.bytes = 0;




×







1027



    } else {










1028



      infoData.info.type = pExpr->resType.type;




×







1029



      infoData.info.bytes = pExpr->resType.bytes;




×







1030



    }










1031



    QRY_ERR_RET(blockDataAppendColInfo(pBlock, &infoData));





×







1032



  }










1033












1034



  *pOutput = pBlock;




×







1035



  return code;




×







1036



}










1037












1038



static int32_t buildSelectResultDataBlock(SNodeList* pProjects, SSDataBlock* pBlock) {




×







1039



  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));





×







1040












1041



  int32_t index = 0;




×







1042



  SNode*  pProj = NULL;




×







1043



  FOREACH(pProj, pProjects) {





×







1044



    if (QUERY_NODE_VALUE != nodeType(pProj)) {





×







1045



      return TSDB_CODE_PAR_INVALID_SELECTED_EXPR;




×







1046



    } else {










1047



      if (((SValueNode*)pProj)->isNull) {





×







1048



        QRY_ERR_RET(colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0, NULL, true));





×







1049



      } else {










1050



        QRY_ERR_RET(colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0,





×







1051



                                  nodesGetValueFromNode((SValueNode*)pProj), false));










1052



      }










1053



    }










1054



  }










1055












1056



  pBlock->info.rows = 1;




×







1057



  return TSDB_CODE_SUCCESS;




×







1058



}










1059












1060



static int32_t execSelectWithoutFrom(SSelectStmt* pSelect, SRetrieveTableRsp** pRsp) {




×







1061



  SSDataBlock* pBlock = NULL;




×







1062



  int32_t      code = createSelectResultDataBlock(pSelect->pProjectionList, &pBlock);




×







1063



  if (TSDB_CODE_SUCCESS == code) {





×







1064



    code = buildSelectResultDataBlock(pSelect->pProjectionList, pBlock);




×







1065



  }










1066



  if (TSDB_CODE_SUCCESS == code) {





×







1067



    code = buildRetrieveTableRsp(pBlock, LIST_LENGTH(pSelect->pProjectionList), pRsp);





×







1068



  }










1069



  (void)blockDataDestroy(pBlock);




×







1070



  return code;




×







1071



}










1072












1073



static int32_t execShowCreateView(SShowCreateViewStmt* pStmt, SRetrieveTableRsp** pRsp) {




×







1074



  SSDataBlock* pBlock = NULL;




×







1075



  int32_t      code = buildCreateViewResultDataBlock(&pBlock);




×







1076



  if (TSDB_CODE_SUCCESS == code) {





×







1077



    code = setCreateViewResultIntoDataBlock(pBlock, pStmt);




×







1078



  }










1079



  if (TSDB_CODE_SUCCESS == code) {





×







1080



    code = buildRetrieveTableRsp(pBlock, SHOW_CREATE_VIEW_RESULT_COLS, pRsp);




×







1081



  }










1082



  (void)blockDataDestroy(pBlock);




×







1083



  return code;




×







1084



}










1085












1086



int32_t qExecCommand(int64_t* pConnId, bool sysInfoUser, SNode* pStmt, SRetrieveTableRsp** pRsp, int8_t biMode,




×







1087



                     void* charsetCxt) {










1088



  switch (nodeType(pStmt)) {





×







1089



    case QUERY_NODE_DESCRIBE_STMT:




×







1090



      return execDescribe(sysInfoUser, pStmt, pRsp, biMode);




×







1091



    case QUERY_NODE_RESET_QUERY_CACHE_STMT:




×







1092



      return execResetQueryCache();




×







1093



    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:




×







1094



      return execShowCreateDatabase((SShowCreateDatabaseStmt*)pStmt, pRsp);




×







1095



    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:




×







1096



      return execShowCreateTable((SShowCreateTableStmt*)pStmt, pRsp, charsetCxt);




×







1097



    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:




×







1098



      return execShowCreateSTable((SShowCreateTableStmt*)pStmt, pRsp, charsetCxt);




×







1099



    case QUERY_NODE_SHOW_CREATE_VIEW_STMT:




×







1100



      return execShowCreateView((SShowCreateViewStmt*)pStmt, pRsp);




×







1101



    case QUERY_NODE_ALTER_LOCAL_STMT:




×







1102



      return execAlterLocal((SAlterLocalStmt*)pStmt);




×







1103



    case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT:




×







1104



      return execShowLocalVariables((SShowStmt*)pStmt, pRsp);




×







1105



    case QUERY_NODE_SELECT_STMT:




×







1106



      return execSelectWithoutFrom((SSelectStmt*)pStmt, pRsp);




×







1107



    default:




×







1108



      break;




×







1109



  }










1110



  return TSDB_CODE_FAILED;




×







1111



}
























    

  • 

    •