Merge pull request #893 from taosdata/feature/liaohj

remove the compiler warnings

src/client/src/tscSQLParser.c

@@ -20,13 +20,13 @@
 #include "taos.h"
 #include "taosmsg.h"
 #include "tstoken.h"
-#include "ttime.h"
 #include "tstrbuild.h"
+#include "ttime.h"
 
+#include "tscSQLParser.h"
 #include "tscUtil.h"
 #include "tschemautil.h"
 #include "tsclient.h"
-#include "tscSQLParser.h"
 
 #define DEFAULT_PRIMARY_TIMESTAMP_COL_NAME "_c0"
 
@@ -110,7 +110,7 @@ static int32_t optrToString(tSQLExpr* pExpr, char** exprString);
 static int32_t getMeterIndex(SSQLToken* pTableToken, SSqlCmd* pCmd, SColumnIndex* pIndex);
 static int32_t doFunctionsCompatibleCheck(SSqlObj* pSql);
 static int32_t doLocalQueryProcess(SQuerySQL* pQuerySql, SSqlCmd* pCmd);
-static int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg *pCreate);
+static int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg* pCreate);
 
 static SColumnList getColumnList(int32_t num, int16_t tableIndex, int32_t columnIndex);
 
@@ -118,7 +118,7 @@ static SColumnList getColumnList(int32_t num, int16_t tableIndex, int32_t column
  * Used during parsing query sql. Since the query sql usually small in length, error position
  * is not needed in the final error message.
  */
-static int32_t invalidSqlErrMsg(SSqlCmd *pCmd, const char* errMsg) {
+static int32_t invalidSqlErrMsg(SSqlCmd* pCmd, const char* errMsg) {
   return tscInvalidSQLErrMsg(pCmd->payload, errMsg, NULL);
 }
 
@@ -293,7 +293,6 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     case ALTER_DATABASE:
     case CREATE_DATABASE: {
-
       if (pInfo->sqlType == ALTER_DATABASE) {
         pCmd->command = TSDB_SQL_ALTER_DB;
       } else {
@@ -1018,7 +1017,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       setColumnOffsetValueInResultset(pCmd);
 
-      for(int32_t i = 0; i < pCmd->numOfTables; ++i) {
+      for (int32_t i = 0; i < pCmd->numOfTables; ++i) {
         updateTagColumnIndex(pCmd, i);
       }
 
@@ -2186,7 +2185,6 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, int32_t colIdx, tSQLExprItem* pItem
         SSqlExpr* pExpr = tscSqlExprInsert(pCmd, colIdx, functionId, &index, resultType, resultSize, resultSize);
         addExprParams(pExpr, val, TSDB_DATA_TYPE_DOUBLE, sizeof(double), 0);
       } else {
-
         tVariantDump(pVariant, val, TSDB_DATA_TYPE_BIGINT);
 
         int64_t nTop = *((int32_t*)val);
@@ -2545,7 +2543,7 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         }
       }
     }
-  }else if (type == SHOW_VNODES) {
+  } else if (type == SHOW_VNODES) {
     if (NULL == pInfo->pDCLInfo) {
       return invalidSqlErrMsg(pCmd, "No specified ip of dnode");
     }
@@ -2674,8 +2672,7 @@ void tscRestoreSQLFunctionForMetricQuery(SSqlCmd* pCmd) {
 
 bool hasUnsupportFunctionsForMetricQuery(SSqlCmd* pCmd) {
   const char* msg1 = "TWA not allowed to apply to super table directly";
-  const char* msg2 = "functions not supported for super table";
-  const char* msg3 = "TWA only support group by tbname for super table query";
+  const char* msg2 = "TWA only support group by tbname for super table query";
 
   // filter sql function not supported by metric query yet.
   for (int32_t i = 0; i < pCmd->fieldsInfo.numOfOutputCols; ++i) {
@@ -2692,7 +2689,7 @@ bool hasUnsupportFunctionsForMetricQuery(SSqlCmd* pCmd) {
     }
 
     if (pCmd->groupbyExpr.numOfGroupCols != 1 || pCmd->groupbyExpr.columnInfo[0].colIdx != TSDB_TBNAME_COLUMN_INDEX) {
-      invalidSqlErrMsg(pCmd, msg3);
+      invalidSqlErrMsg(pCmd, msg2);
       return true;
     }
   }
@@ -2701,8 +2698,6 @@ bool hasUnsupportFunctionsForMetricQuery(SSqlCmd* pCmd) {
 }
 
 static bool functionCompatibleCheck(SSqlCmd* pCmd) {
-  const char* msg1 = "column on select clause not allowed";
-
   int32_t startIdx = 0;
   int32_t functionID = tscSqlExprGet(pCmd, startIdx)->functionId;
 
@@ -2787,7 +2782,7 @@ void updateTagColumnIndex(SSqlCmd* pCmd, int32_t tableIndex) {
 
   // the join condition expression node belongs to this table(super table)
   if (pMeterMetaInfo->pMeterMeta->uid == pJoinInfo->left.uid) {
-    for(int32_t i = 0; i < pMeterMetaInfo->numOfTags; ++i) {
+    for (int32_t i = 0; i < pMeterMetaInfo->numOfTags; ++i) {
       if (pJoinInfo->left.tagCol == pMeterMetaInfo->tagColumnIndex[i]) {
         pJoinInfo->left.tagCol = i;
       }
@@ -2795,21 +2790,18 @@ void updateTagColumnIndex(SSqlCmd* pCmd, int32_t tableIndex) {
   }
 
   if (pMeterMetaInfo->pMeterMeta->uid == pJoinInfo->right.uid) {
-    for(int32_t i = 0; i < pMeterMetaInfo->numOfTags; ++i) {
+    for (int32_t i = 0; i < pMeterMetaInfo->numOfTags; ++i) {
       if (pJoinInfo->right.tagCol == pMeterMetaInfo->tagColumnIndex[i]) {
         pJoinInfo->right.tagCol = i;
       }
     }
   }
-  
 }
 
 int32_t parseGroupbyClause(SSqlCmd* pCmd, tVariantList* pList) {
   const char* msg1 = "too many columns in group by clause";
   const char* msg2 = "invalid column name in group by clause";
-  const char* msg4 = "group by only available for STable query";
-  const char* msg5 = "group by columns must belong to one table";
-  const char* msg6 = "only support group by one ordinary column";
+  const char* msg3 = "group by columns must belong to one table";
   const char* msg7 = "not support group by expression";
   const char* msg8 = "not allowed column type for group by";
   const char* msg9 = "tags not allowed for table query";
@@ -2828,9 +2820,8 @@ int32_t parseGroupbyClause(SSqlCmd* pCmd, tVariantList* pList) {
 
   SMeterMeta* pMeterMeta = NULL;
   SSchema*    pSchema = NULL;
+  SSchema     s = tsGetTbnameColumnSchema();
 
-  SSchema s = {0};
-  int32_t numOfReqTags = 0;
   int32_t tableIndex = COLUMN_INDEX_INITIAL_VAL;
 
   for (int32_t i = 0; i < pList->nExpr; ++i) {
@@ -2844,7 +2835,7 @@ int32_t parseGroupbyClause(SSqlCmd* pCmd, tVariantList* pList) {
     }
 
     if (tableIndex != index.tableIndex && tableIndex >= 0) {
-      return invalidSqlErrMsg(pCmd, msg5);
+      return invalidSqlErrMsg(pCmd, msg3);
     }
 
     tableIndex = index.tableIndex;
@@ -2852,22 +2843,12 @@ int32_t parseGroupbyClause(SSqlCmd* pCmd, tVariantList* pList) {
     pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, index.tableIndex);
     pMeterMeta = pMeterMetaInfo->pMeterMeta;
 
-    // TODO refactor!!!!!!!!!!!!!!1
     if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
-      s.colId = TSDB_TBNAME_COLUMN_INDEX;
-      s.type = TSDB_DATA_TYPE_BINARY;
-      s.bytes = TSDB_METER_NAME_LEN;
-      strcpy(s.name, TSQL_TBNAME_L);
-
       pSchema = &s;
     } else {
       pSchema = tsGetColumnSchema(pMeterMeta, index.columnIndex);
     }
 
-    int16_t type = 0;
-    int16_t bytes = 0;
-    char*   name = NULL;
-
     bool groupTag = false;
     if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX || index.columnIndex >= pMeterMeta->numOfColumns) {
       groupTag = true;
@@ -3138,7 +3119,7 @@ static int32_t optrToString(tSQLExpr* pExpr, char** exprString) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t tablenameListToString(tSQLExpr* pExpr, /*char* str*/SStringBuilder* sb) {
+static int32_t tablenameListToString(tSQLExpr* pExpr, /*char* str*/ SStringBuilder* sb) {
   tSQLExprList* pList = pExpr->pParam;
   if (pList->nExpr <= 0) {
     return TSDB_CODE_INVALID_SQL;
@@ -3148,7 +3129,6 @@ static int32_t tablenameListToString(tSQLExpr* pExpr, /*char* str*/SStringBuilde
     taosStringBuilderAppendStringLen(sb, QUERY_COND_REL_PREFIX_IN, QUERY_COND_REL_PREFIX_IN_LEN);
   }
 
-  int32_t len = 0;
   for (int32_t i = 0; i < pList->nExpr; ++i) {
     tSQLExpr* pSub = pList->a[i].pNode;
     taosStringBuilderAppendStringLen(sb, pSub->val.pz, pSub->val.nLen);
@@ -3165,7 +3145,7 @@ static int32_t tablenameListToString(tSQLExpr* pExpr, /*char* str*/SStringBuilde
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t tablenameCondToString(tSQLExpr* pExpr, /*char* str*/SStringBuilder* sb) {
+static int32_t tablenameCondToString(tSQLExpr* pExpr, /*char* str*/ SStringBuilder* sb) {
   taosStringBuilderAppendStringLen(sb, QUERY_COND_REL_PREFIX_LIKE, QUERY_COND_REL_PREFIX_LIKE_LEN);
   taosStringBuilderAppendString(sb, pExpr->val.pz);
 
@@ -3187,7 +3167,6 @@ static int32_t extractColumnFilterInfo(SSqlCmd* pCmd, SColumnIndex* pIndex, tSQL
 
   const char* msg1 = "non binary column not support like operator";
   const char* msg2 = "binary column not support this operator";
-  const char* msg3 = "OR is not supported on different column filter";
 
   SColumnBase*       pColumn = tscColumnBaseInfoInsert(pCmd, pIndex);
   SColumnFilterInfo* pColFilter = NULL;
@@ -3271,7 +3250,7 @@ static int32_t getTagCondString(SSqlCmd* pCmd, tSQLExpr* pExpr, char** str) {
   return tSQLExprLeafToString(pExpr, true, str);
 }
 
-static int32_t getTablenameCond(SSqlCmd* pCmd, tSQLExpr* pTableCond, /*char* str*/SStringBuilder* sb) {
+static int32_t getTablenameCond(SSqlCmd* pCmd, tSQLExpr* pTableCond, /*char* str*/ SStringBuilder* sb) {
   const char* msg0 = "invalid table name list";
 
   if (pTableCond == NULL) {
@@ -3615,10 +3594,9 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, tSQLExpr** pExpr, SCondExpr*
   const char* msg2 = "illegal column name";
   const char* msg3 = "only one query time range allowed";
   const char* msg4 = "only one join condition allowed";
-  const char* msg5 = "AND is allowed to filter on different ordinary columns";
-  const char* msg6 = "not support ordinary column join";
-  const char* msg7 = "only one query condition on tbname allowed";
-  const char* msg8 = "only in/like allowed in filter table name";
+  const char* msg5 = "not support ordinary column join";
+  const char* msg6 = "only one query condition on tbname allowed";
+  const char* msg7 = "only in/like allowed in filter table name";
 
   tSQLExpr* pLeft = (*pExpr)->pLeft;
   tSQLExpr* pRight = (*pExpr)->pRight;
@@ -3680,7 +3658,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, tSQLExpr** pExpr, SCondExpr*
     // in case of in operator, keep it in a seperate attribute
     if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
       if (!validTableNameOptr(*pExpr)) {
-        return invalidSqlErrMsg(pCmd, msg8);
+        return invalidSqlErrMsg(pCmd, msg7);
       }
 
       if (pCondExpr->pTableCond == NULL) {
@@ -3688,7 +3666,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, tSQLExpr** pExpr, SCondExpr*
         pCondExpr->relType = parentOptr;
         pCondExpr->tableCondIndex = index.tableIndex;
       } else {
-        return invalidSqlErrMsg(pCmd, msg7);
+        return invalidSqlErrMsg(pCmd, msg6);
       }
 
       *type = TSQL_EXPR_TBNAME;
@@ -3719,7 +3697,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, tSQLExpr** pExpr, SCondExpr*
     *type = TSQL_EXPR_COLUMN;
 
     if (pRight->nSQLOptr == TK_ID) {  // other column cannot be served as the join column
-      return invalidSqlErrMsg(pCmd, msg6);
+      return invalidSqlErrMsg(pCmd, msg5);
     }
 
     ret = setExprToCond(pCmd, &pCondExpr->pColumnCond, *pExpr, NULL, parentOptr);
@@ -4052,7 +4030,6 @@ static void cleanQueryExpr(SCondExpr* pCondExpr) {
   }
 }
 
-
 static void doAddJoinTagsColumnsIntoTagList(SSqlCmd* pCmd, SCondExpr* pCondExpr) {
   SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
   if (QUERY_IS_JOIN_QUERY(pCmd->type) && UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
@@ -4113,7 +4090,7 @@ int32_t parseWhereClause(SSqlObj* pSql, tSQLExpr** pExpr) {
   pCmd->stime = 0;
   pCmd->etime = INT64_MAX;
 
-  //tags query condition may be larger than 512bytes, therefore, we need to prepare enough large space
+  // tags query condition may be larger than 512bytes, therefore, we need to prepare enough large space
   SStringBuilder sb = {0};
   SCondExpr      condExpr = {0};
 
@@ -4447,7 +4424,6 @@ int32_t parseOrderbyClause(SSqlCmd* pCmd, SQuerySQL* pQuerySql, SSchema* pSchema
 
     bool orderByTags = false;
     bool orderByTS = false;
-    bool orderByCol = false;
 
     if (index.columnIndex >= pMeterMetaInfo->pMeterMeta->numOfColumns) {
       int32_t relTagIndex = index.columnIndex - pMeterMetaInfo->pMeterMeta->numOfColumns;
@@ -4824,7 +4800,6 @@ int32_t validateSqlFunctionInStreamSql(SSqlCmd* pCmd) {
 int32_t validateFunctionsInIntervalOrGroupbyQuery(SSqlCmd* pCmd) {
   bool        isProjectionFunction = false;
   const char* msg1 = "column projection is not compatible with interval";
-  const char* msg2 = "interval not allowed for tag queries";
 
   // multi-output set/ todo refactor
   for (int32_t k = 0; k < pCmd->fieldsInfo.numOfOutputCols; ++k) {
@@ -5098,9 +5073,7 @@ static int32_t setKeepOption(SSqlCmd* pCmd, SCreateDbMsg* pMsg, SCreateDBInfo* p
         pMsg->daysToKeep2 = htonl(pKeep->a[2].pVar.i64Key);
         break;
       }
-      default: {
-        return invalidSqlErrMsg(pCmd, msg);
-      }
+      default: { return invalidSqlErrMsg(pCmd, msg); }
     }
   }
 
@@ -5135,7 +5108,7 @@ static void setCreateDBOption(SCreateDbMsg* pMsg, SCreateDBInfo* pCreateDb) {
   pMsg->blocksPerMeter = htons(pCreateDb->numOfBlocksPerTable);
   pMsg->compression = pCreateDb->compressionLevel;
 
-  pMsg->commitLog = (char) pCreateDb->commitLog;
+  pMsg->commitLog = (char)pCreateDb->commitLog;
   pMsg->commitTime = htonl(pCreateDb->commitTime);
   pMsg->maxSessions = htonl(pCreateDb->tablesPerVnode);
   pMsg->cacheNumOfBlocks.fraction = pCreateDb->numOfAvgCacheBlocks;
@@ -5254,9 +5227,6 @@ static void doUpdateSqlFunctionForTagPrj(SSqlCmd* pCmd) {
     }
   }
 
-  int16_t resType = 0;
-  int16_t resBytes = 0;
-
   SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
   SSchema*        pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
 
@@ -5353,11 +5323,9 @@ static void updateTagPrjFunction(SSqlCmd* pCmd) {
  */
 static int32_t checkUpdateTagPrjFunctions(SSqlCmd* pCmd) {
   const char* msg1 = "only one selectivity function allowed in presence of tags function";
-  const char* msg2 = "functions not allowed";
   const char* msg3 = "aggregation function should not be mixed up with projection";
 
   bool    tagColExists = false;
-  int16_t numOfTimestamp = 0;  // primary timestamp column
   int16_t numOfSelectivity = 0;
   int16_t numOfAggregation = 0;
 
@@ -5499,13 +5467,10 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd) {
 
 int32_t doFunctionsCompatibleCheck(SSqlObj* pSql) {
   const char* msg1 = "functions/columns not allowed in group by query";
-  const char* msg2 = "interval not allowed in group by normal column";
   const char* msg3 = "group by not allowed on projection query";
-  const char* msg4 = "tags retrieve not compatible with group by";
   const char* msg5 = "retrieve tags not compatible with group by or interval query";
 
   SSqlCmd* pCmd = &pSql->cmd;
-  SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
 
   // only retrieve tags, group by is not supportted
   if (pCmd->command == TSDB_SQL_RETRIEVE_TAGS) {
@@ -5517,11 +5482,6 @@ int32_t doFunctionsCompatibleCheck(SSqlObj* pSql) {
   }
 
   if (pCmd->groupbyExpr.numOfGroupCols > 0) {
-    SSchema* pSchema = tsGetSchema(pMeterMetaInfo->pMeterMeta);
-    int16_t  bytes = 0;
-    int16_t  type = 0;
-    char*    name = NULL;
-
     // check if all the tags prj columns belongs to the group by columns
     if (onlyTagPrjFunction(pCmd) && allTagPrjInGroupby(pCmd)) {
       updateTagPrjFunction(pCmd);
@@ -5639,14 +5599,12 @@ int32_t doLocalQueryProcess(SQuerySQL* pQuerySql, SSqlCmd* pCmd) {
     case 4:
       pCmd->command = TSDB_SQL_CURRENT_USER;
       return TSDB_CODE_SUCCESS;
-    default: {
-      return invalidSqlErrMsg(pCmd, msg3);
-    }
+    default: { return invalidSqlErrMsg(pCmd, msg3); }
   }
 }
 
 // can only perform the parameters based on the macro definitation
-int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg *pCreate) {
+int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg* pCreate) {
   char msg[512] = {0};
 
   if (pCreate->commitLog != -1 && (pCreate->commitLog < 0 || pCreate->commitLog > 1)) {
@@ -5656,8 +5614,8 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg *pCreate) {
 
   if (pCreate->replications != -1 &&
       (pCreate->replications < TSDB_REPLICA_MIN_NUM || pCreate->replications > TSDB_REPLICA_MAX_NUM)) {
-    snprintf(msg, tListLen(msg), "invalid db option replications: %d valid range: [%d, %d]", pCreate->replications, TSDB_REPLICA_MIN_NUM,
-             TSDB_REPLICA_MAX_NUM);
+    snprintf(msg, tListLen(msg), "invalid db option replications: %d valid range: [%d, %d]", pCreate->replications,
+             TSDB_REPLICA_MIN_NUM, TSDB_REPLICA_MAX_NUM);
     return invalidSqlErrMsg(pCmd, msg);
   }
 
@@ -5684,22 +5642,21 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg *pCreate) {
 
   val = htonl(pCreate->maxSessions);
   if (val != -1 && (val < TSDB_MIN_TABLES_PER_VNODE || val > TSDB_MAX_TABLES_PER_VNODE)) {
-    snprintf(msg, tListLen(msg), "invalid db option maxSessions: %d valid range: [%d, %d]", val, TSDB_MIN_TABLES_PER_VNODE,
-             TSDB_MAX_TABLES_PER_VNODE);
+    snprintf(msg, tListLen(msg), "invalid db option maxSessions: %d valid range: [%d, %d]", val,
+             TSDB_MIN_TABLES_PER_VNODE, TSDB_MAX_TABLES_PER_VNODE);
     return invalidSqlErrMsg(pCmd, msg);
   }
 
-  if (pCreate->precision != -1 &&
-      (pCreate->precision != TSDB_TIME_PRECISION_MILLI && pCreate->precision != TSDB_TIME_PRECISION_MICRO)) {
-    snprintf(msg, tListLen(msg), "invalid db option timePrecision: %d valid value: [%d, %d]", pCreate->precision, TSDB_TIME_PRECISION_MILLI,
-             TSDB_TIME_PRECISION_MICRO);
+  if (pCreate->precision != TSDB_TIME_PRECISION_MILLI && pCreate->precision != TSDB_TIME_PRECISION_MICRO) {
+    snprintf(msg, tListLen(msg), "invalid db option timePrecision: %d valid value: [%d, %d]", pCreate->precision,
+             TSDB_TIME_PRECISION_MILLI, TSDB_TIME_PRECISION_MICRO);
     return invalidSqlErrMsg(pCmd, msg);
   }
 
   if (pCreate->cacheNumOfBlocks.fraction != -1 && (pCreate->cacheNumOfBlocks.fraction < TSDB_MIN_AVG_BLOCKS ||
                                                    pCreate->cacheNumOfBlocks.fraction > TSDB_MAX_AVG_BLOCKS)) {
-    snprintf(msg, tListLen(msg), "invalid db option ablocks: %f valid value: [%d, %d]", pCreate->cacheNumOfBlocks.fraction,
-             TSDB_MIN_AVG_BLOCKS, TSDB_MAX_AVG_BLOCKS);
+    snprintf(msg, tListLen(msg), "invalid db option ablocks: %f valid value: [%d, %d]",
+             pCreate->cacheNumOfBlocks.fraction, TSDB_MIN_AVG_BLOCKS, TSDB_MAX_AVG_BLOCKS);
     return invalidSqlErrMsg(pCmd, msg);
   }
 
@@ -5712,8 +5669,8 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg *pCreate) {
 
   if (pCreate->compression != -1 &&
       (pCreate->compression < TSDB_MIN_COMPRESSION_LEVEL || pCreate->compression > TSDB_MAX_COMPRESSION_LEVEL)) {
-    snprintf(msg, tListLen(msg), "invalid db option compression: %d valid range: [%d, %d]", pCreate->compression, TSDB_MIN_COMPRESSION_LEVEL,
-             TSDB_MAX_COMPRESSION_LEVEL);
+    snprintf(msg, tListLen(msg), "invalid db option compression: %d valid range: [%d, %d]", pCreate->compression,
+             TSDB_MIN_COMPRESSION_LEVEL, TSDB_MAX_COMPRESSION_LEVEL);
     return invalidSqlErrMsg(pCmd, msg);
   }
 
@@ -5730,7 +5687,7 @@ void tscPrintSelectClause(SSqlCmd* pCmd) {
   int32_t offset = 0;
 
   offset += sprintf(str, "%d [", pCmd->exprsInfo.numOfExprs);
-  for(int32_t i = 0; i < pCmd->exprsInfo.numOfExprs; ++i) {
+  for (int32_t i = 0; i < pCmd->exprsInfo.numOfExprs; ++i) {
     SSqlExpr* pExpr = tscSqlExprGet(pCmd, i);
 
     int32_t size = sprintf(str + offset, "%s(%d)", aAggs[pExpr->functionId].aName, pExpr->colInfo.colId);

src/client/src/tscSchemaUtil.c

@@ -83,6 +83,13 @@ struct SSchema* tsGetColumnSchema(SMeterMeta* pMeta, int32_t startCol) {
   return (SSchema*)(((char*)pMeta + sizeof(SMeterMeta)) + startCol * sizeof(SSchema));
 }
 
+struct SSchema tsGetTbnameColumnSchema() {
+  struct SSchema s = {.colId = TSDB_TBNAME_COLUMN_INDEX, .type = TSDB_DATA_TYPE_BINARY, .bytes = TSDB_METER_NAME_LEN};
+  strcpy(s.name, TSQL_TBNAME_L);
+  
+  return s;
+}
+
 /**
  * the MeterMeta data format in memory is as follows:
  *
@@ -123,7 +130,7 @@ bool tsMeterMetaIdentical(SMeterMeta* p1, SMeterMeta* p2) {
   return memcmp(p1, p2, size) == 0;
 }
 
-//todo refactor
+// todo refactor
 static FORCE_INLINE char* skipSegments(char* input, char delimiter, int32_t num) {
   for (int32_t i = 0; i < num; ++i) {
     while (*input != 0 && *input++ != delimiter) {

src/inc/tschemautil.h

@@ -47,6 +47,7 @@ struct SSchema *tsGetSchema(SMeterMeta *pMeta);
 struct SSchema *tsGetTagSchema(SMeterMeta *pMeta);
 
 struct SSchema *tsGetColumnSchema(SMeterMeta *pMeta, int32_t startCol);
+struct SSchema tsGetTbnameColumnSchema();
 
 char *tsGetTagsValue(SMeterMeta *pMeta);
 

src/inc/tsqlfunction.h

@@ -227,8 +227,6 @@ typedef struct SPatternCompareInfo {
 int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionId, int32_t param, int16_t *type,
                           int16_t *len, int16_t *interResBytes, int16_t extLength, bool isSuperTable);
 
-SResultInfo *getResultSupportInfo(SQLFunctionCtx *pCtx);
-
 int patternMatch(const char *zPattern, const char *zString, size_t size, const SPatternCompareInfo *pInfo);
 
 int WCSPatternMatch(const wchar_t *zPattern, const wchar_t *zString, size_t size, const SPatternCompareInfo *pInfo);

src/inc/ttypes.h

@@ -50,7 +50,7 @@ bool isNull(const char *val, int32_t type);
 void setNull(char *val, int32_t type, int32_t bytes);
 void setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems);
 
-void assignVal(char *val, char *src, int32_t len, int32_t type);
+void assignVal(char *val, const char *src, int32_t len, int32_t type);
 void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size);
 
 // variant, each number/string/field_id has a corresponding struct during parsing sql

src/util/src/ttypes.c

@@ -970,7 +970,7 @@ void setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems) {
   }
 }
 
-void assignVal(char *val, char *src, int32_t len, int32_t type) {
+void assignVal(char *val, const char *src, int32_t len, int32_t type) {
   switch (type) {
     case TSDB_DATA_TYPE_INT: {
       *((int32_t *)val) = GET_INT32_VAL(src);