fix: corrent error code

include/util/taoserror.h

@@ -111,59 +111,37 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_OUT_OF_RPC_MEMORY_QUEUE       TAOS_DEF_ERROR_CODE(0, 0x0126)
 #define TSDB_CODE_INVALID_TIMESTAMP             TAOS_DEF_ERROR_CODE(0, 0x0127)
 #define TSDB_CODE_MSG_DECODE_ERROR              TAOS_DEF_ERROR_CODE(0, 0x0128)
-#define TSDB_CODE_NO_AVAIL_DISK                 TAOS_DEF_ERROR_CODE(0, 0x0129)
 #define TSDB_CODE_NOT_FOUND                     TAOS_DEF_ERROR_CODE(0, 0x012A)
 #define TSDB_CODE_NO_DISKSPACE                  TAOS_DEF_ERROR_CODE(0, 0x012B)
 #define TSDB_CODE_TIMEOUT_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x012C)
-#define TSDB_CODE_MSG_ENCODE_ERROR              TAOS_DEF_ERROR_CODE(0, 0x012D)
-#define TSDB_CODE_NO_ENOUGH_DISKSPACE           TAOS_DEF_ERROR_CODE(0, 0x012E)
 #define TSDB_CODE_CHECKSUM_ERROR                TAOS_DEF_ERROR_CODE(0, 0x012F) // internal
 
 #define TSDB_CODE_APP_IS_STARTING               TAOS_DEF_ERROR_CODE(0, 0x0130)
 #define TSDB_CODE_APP_IS_STOPPING               TAOS_DEF_ERROR_CODE(0, 0x0131)
 #define TSDB_CODE_INVALID_DATA_FMT              TAOS_DEF_ERROR_CODE(0, 0x0132)
-#define TSDB_CODE_INVALID_CFG_VALUE             TAOS_DEF_ERROR_CODE(0, 0x0133)
+#define TSDB_CODE_INVALID_OPERATION             TAOS_DEF_ERROR_CODE(0, 0x0133)
+#define TSDB_CODE_INVALID_VALUE                 TAOS_DEF_ERROR_CODE(0, 0x0134)
+#define TSDB_CODE_INVALID_FQDN                  TAOS_DEF_ERROR_CODE(0, 0x0135)
 
 //client
-#define TSDB_CODE_TSC_INVALID_OPERATION         TAOS_DEF_ERROR_CODE(0, 0x0200)
-#define TSDB_CODE_TSC_INVALID_QHANDLE           TAOS_DEF_ERROR_CODE(0, 0x0201)
-#define TSDB_CODE_TSC_INVALID_TIME_STAMP        TAOS_DEF_ERROR_CODE(0, 0x0202)
-#define TSDB_CODE_TSC_INVALID_VALUE             TAOS_DEF_ERROR_CODE(0, 0x0203)
-#define TSDB_CODE_TSC_INVALID_VERSION           TAOS_DEF_ERROR_CODE(0, 0x0204)
-#define TSDB_CODE_TSC_INVALID_IE                TAOS_DEF_ERROR_CODE(0, 0x0205)
-#define TSDB_CODE_TSC_INVALID_FQDN              TAOS_DEF_ERROR_CODE(0, 0x0206)
 #define TSDB_CODE_TSC_INVALID_USER_LENGTH       TAOS_DEF_ERROR_CODE(0, 0x0207)
 #define TSDB_CODE_TSC_INVALID_PASS_LENGTH       TAOS_DEF_ERROR_CODE(0, 0x0208)
 #define TSDB_CODE_TSC_INVALID_DB_LENGTH         TAOS_DEF_ERROR_CODE(0, 0x0209)
 #define TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH   TAOS_DEF_ERROR_CODE(0, 0x020A)
-#define TSDB_CODE_TSC_INVALID_CONNECTION        TAOS_DEF_ERROR_CODE(0, 0x020B)
 // #define TSDB_CODE_TSC_OUT_OF_MEMORY          TAOS_DEF_ERROR_CODE(0, 0x020C) // 2.x
-#define TSDB_CODE_TSC_QUERY_CACHE_ERASED        TAOS_DEF_ERROR_CODE(0, 0x020E)
 #define TSDB_CODE_TSC_QUERY_CANCELLED           TAOS_DEF_ERROR_CODE(0, 0x020F)
-#define TSDB_CODE_TSC_SORTED_RES_TOO_MANY       TAOS_DEF_ERROR_CODE(0, 0x0210)
 // #define TSDB_CODE_TSC_APP_ERROR              TAOS_DEF_ERROR_CODE(0, 0x0211) // 2.x
-#define TSDB_CODE_TSC_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0212)
 #define TSDB_CODE_TSC_DISCONNECTED              TAOS_DEF_ERROR_CODE(0, 0x0213)
-#define TSDB_CODE_TSC_NO_WRITE_AUTH             TAOS_DEF_ERROR_CODE(0, 0x0214)
-#define TSDB_CODE_TSC_CONN_KILLED               TAOS_DEF_ERROR_CODE(0, 0x0215)
 #define TSDB_CODE_TSC_SQL_SYNTAX_ERROR          TAOS_DEF_ERROR_CODE(0, 0x0216)
-#define TSDB_CODE_TSC_DB_NOT_SELECTED           TAOS_DEF_ERROR_CODE(0, 0x0217)
 //#define TSDB_CODE_TSC_INVALID_TABLE_NAME        TAOS_DEF_ERROR_CODE(0, 0x0218)
 #define TSDB_CODE_TSC_EXCEED_SQL_LIMIT          TAOS_DEF_ERROR_CODE(0, 0x0219)
 #define TSDB_CODE_TSC_FILE_EMPTY                TAOS_DEF_ERROR_CODE(0, 0x021A)
-#define TSDB_CODE_TSC_LINE_SYNTAX_ERROR         TAOS_DEF_ERROR_CODE(0, 0x021B)
-#define TSDB_CODE_TSC_NO_META_CACHED            TAOS_DEF_ERROR_CODE(0, 0x021C)
-#define TSDB_CODE_TSC_DUP_COL_NAMES             TAOS_DEF_ERROR_CODE(0, 0x021D)
-#define TSDB_CODE_TSC_INVALID_TAG_LENGTH        TAOS_DEF_ERROR_CODE(0, 0x021E)
 #define TSDB_CODE_TSC_INVALID_COLUMN_LENGTH     TAOS_DEF_ERROR_CODE(0, 0x021F)
-#define TSDB_CODE_TSC_DUP_NAMES                 TAOS_DEF_ERROR_CODE(0, 0x0220)
-#define TSDB_CODE_TSC_INVALID_JSON              TAOS_DEF_ERROR_CODE(0, 0x0221)
 #define TSDB_CODE_TSC_INVALID_JSON_TYPE         TAOS_DEF_ERROR_CODE(0, 0x0222)
 #define TSDB_CODE_TSC_VALUE_OUT_OF_RANGE        TAOS_DEF_ERROR_CODE(0, 0x0224)
 #define TSDB_CODE_TSC_INVALID_INPUT             TAOS_DEF_ERROR_CODE(0, 0X0229)
 #define TSDB_CODE_TSC_STMT_API_ERROR            TAOS_DEF_ERROR_CODE(0, 0X022A)
 #define TSDB_CODE_TSC_STMT_TBNAME_ERROR         TAOS_DEF_ERROR_CODE(0, 0X022B)
-#define TSDB_CODE_TSC_STMT_CLAUSE_ERROR         TAOS_DEF_ERROR_CODE(0, 0X022C)
 #define TSDB_CODE_TSC_QUERY_KILLED              TAOS_DEF_ERROR_CODE(0, 0X022D)
 #define TSDB_CODE_TSC_NO_EXEC_NODE              TAOS_DEF_ERROR_CODE(0, 0X022E)
 #define TSDB_CODE_TSC_NOT_STABLE_ERROR          TAOS_DEF_ERROR_CODE(0, 0X022F)
@@ -483,40 +461,22 @@ int32_t* taosGetErrno();
 
 // query
 #define TSDB_CODE_QRY_INVALID_QHANDLE           TAOS_DEF_ERROR_CODE(0, 0x0700)
-#define TSDB_CODE_QRY_INVALID_MSG               TAOS_DEF_ERROR_CODE(0, 0x0701)
 // #define TSDB_CODE_QRY_NO_DISKSPACE           TAOS_DEF_ERROR_CODE(0, 0x0702) // 2.x
 // #define TSDB_CODE_QRY_OUT_OF_MEMORY          TAOS_DEF_ERROR_CODE(0, 0x0703) // 2.x
 // #define TSDB_CODE_QRY_APP_ERROR              TAOS_DEF_ERROR_CODE(0, 0x0704) // 2.x
-#define TSDB_CODE_QRY_DUP_JOIN_KEY              TAOS_DEF_ERROR_CODE(0, 0x0705)
-#define TSDB_CODE_QRY_EXCEED_TAGS_LIMIT         TAOS_DEF_ERROR_CODE(0, 0x0706)
-#define TSDB_CODE_QRY_NOT_READY                 TAOS_DEF_ERROR_CODE(0, 0x0707)
-#define TSDB_CODE_QRY_HAS_RSP                   TAOS_DEF_ERROR_CODE(0, 0x0708)
 #define TSDB_CODE_QRY_IN_EXEC                   TAOS_DEF_ERROR_CODE(0, 0x0709)
 #define TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW       TAOS_DEF_ERROR_CODE(0, 0x070A)
 #define TSDB_CODE_QRY_NOT_ENOUGH_BUFFER         TAOS_DEF_ERROR_CODE(0, 0x070B)
-#define TSDB_CODE_QRY_INCONSISTAN               TAOS_DEF_ERROR_CODE(0, 0x070C)
 #define TSDB_CODE_QRY_SYS_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x070D)
-#define TSDB_CODE_QRY_INVALID_TIME_CONDITION    TAOS_DEF_ERROR_CODE(0, 0x070E)
-#define TSDB_CODE_QRY_INVALID_INPUT             TAOS_DEF_ERROR_CODE(0, 0x070F)
 // #define TSDB_CODE_QRY_INVALID_SCHEMA_VERSION TAOS_DEF_ERROR_CODE(0, 0x0710) // 2.x
 // #define TSDB_CODE_QRY_RESULT_TOO_LARGE       TAOS_DEF_ERROR_CODE(0, 0x0711) // 2.x
 #define TSDB_CODE_QRY_SCH_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x0720)
 #define TSDB_CODE_QRY_TASK_NOT_EXIST            TAOS_DEF_ERROR_CODE(0, 0x0721)
 #define TSDB_CODE_QRY_TASK_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0722)
-#define TSDB_CODE_QRY_TASK_CTX_NOT_EXIST        TAOS_DEF_ERROR_CODE(0, 0x0723)
-#define TSDB_CODE_QRY_TASK_CANCELLED            TAOS_DEF_ERROR_CODE(0, 0x0724)
-#define TSDB_CODE_QRY_TASK_DROPPED              TAOS_DEF_ERROR_CODE(0, 0x0725)
-#define TSDB_CODE_QRY_TASK_CANCELLING           TAOS_DEF_ERROR_CODE(0, 0x0726)
-#define TSDB_CODE_QRY_TASK_DROPPING             TAOS_DEF_ERROR_CODE(0, 0x0727)
-#define TSDB_CODE_QRY_DUPLICATTED_OPERATION     TAOS_DEF_ERROR_CODE(0, 0x0728)
 #define TSDB_CODE_QRY_TASK_MSG_ERROR            TAOS_DEF_ERROR_CODE(0, 0x0729)
-#define TSDB_CODE_QRY_JOB_FREED                 TAOS_DEF_ERROR_CODE(0, 0x072A)
 #define TSDB_CODE_QRY_TASK_STATUS_ERROR         TAOS_DEF_ERROR_CODE(0, 0x072B)
-#define TSDB_CODE_QRY_JSON_IN_ERROR             TAOS_DEF_ERROR_CODE(0, 0x072C)
-#define TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR    TAOS_DEF_ERROR_CODE(0, 0x072D)
-#define TSDB_CODE_QRY_JSON_IN_GROUP_ERROR       TAOS_DEF_ERROR_CODE(0, 0x072E)
+#define TSDB_CODE_QRY_JSON_USAGE_ERROR          TAOS_DEF_ERROR_CODE(0, 0x072C)
 #define TSDB_CODE_QRY_JOB_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x072F)
-#define TSDB_CODE_QRY_QWORKER_QUIT              TAOS_DEF_ERROR_CODE(0, 0x0730)
 
 // grant
 #define TSDB_CODE_GRANT_EXPIRED                 TAOS_DEF_ERROR_CODE(0, 0x0800)
@@ -606,8 +566,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_CTG_SYS_ERROR                 TAOS_DEF_ERROR_CODE(0, 0x2403)
 #define TSDB_CODE_CTG_DB_DROPPED                TAOS_DEF_ERROR_CODE(0, 0x2404)
 #define TSDB_CODE_CTG_OUT_OF_SERVICE            TAOS_DEF_ERROR_CODE(0, 0x2405)
-#define TSDB_CODE_CTG_VG_META_MISMATCH          TAOS_DEF_ERROR_CODE(0, 0x2406)
-#define TSDB_CODE_CTG_EXIT                      TAOS_DEF_ERROR_CODE(0, 0x2407)
 
 //scheduler&qworker
 #define TSDB_CODE_QW_MSG_ERROR                  TAOS_DEF_ERROR_CODE(0, 0x2550)
@@ -633,7 +591,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_NOT_SINGLE_GROUP          TAOS_DEF_ERROR_CODE(0, 0x260C)
 #define TSDB_CODE_PAR_TAGS_NOT_MATCHED          TAOS_DEF_ERROR_CODE(0, 0x260D)
 #define TSDB_CODE_PAR_INVALID_TAG_NAME          TAOS_DEF_ERROR_CODE(0, 0x260E)
-#define TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG   TAOS_DEF_ERROR_CODE(0, 0x2610)
+#define TSDB_CODE_PAR_VALUE_TOO_LONG            TAOS_DEF_ERROR_CODE(0, 0x2610)
 #define TSDB_CODE_PAR_PASSWD_EMPTY              TAOS_DEF_ERROR_CODE(0, 0x2611)
 #define TSDB_CODE_PAR_INVALID_PORT              TAOS_DEF_ERROR_CODE(0, 0x2612)
 #define TSDB_CODE_PAR_INVALID_ENDPOINT          TAOS_DEF_ERROR_CODE(0, 0x2613)
@@ -688,7 +646,6 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY     TAOS_DEF_ERROR_CODE(0, 0x2650)
 #define TSDB_CODE_PAR_INVALID_DROP_COL          TAOS_DEF_ERROR_CODE(0, 0x2651)
 #define TSDB_CODE_PAR_INVALID_COL_JSON          TAOS_DEF_ERROR_CODE(0, 0x2652)
-#define TSDB_CODE_PAR_VALUE_TOO_LONG            TAOS_DEF_ERROR_CODE(0, 0x2653)
 #define TSDB_CODE_PAR_INVALID_DELETE_WHERE      TAOS_DEF_ERROR_CODE(0, 0x2655)
 #define TSDB_CODE_PAR_INVALID_REDISTRIBUTE_VG   TAOS_DEF_ERROR_CODE(0, 0x2656)
 #define TSDB_CODE_PAR_FILL_NOT_ALLOWED_FUNC     TAOS_DEF_ERROR_CODE(0, 0x2657)

source/client/src/clientHb.c

@@ -221,7 +221,7 @@ static int32_t hbProcessStbInfoRsp(void *value, int32_t valueLen, struct SCatalo
       if (rsp->pSchemas[0].colId != PRIMARYKEY_TIMESTAMP_COL_ID) {
         tscError("invalid colId[%" PRIi16 "] for the first column in table meta rsp msg", rsp->pSchemas[0].colId);
         tFreeSSTbHbRsp(&hbRsp);
-        return TSDB_CODE_TSC_INVALID_VALUE;
+        return TSDB_CODE_INVALID_MSG;
       }
 
       catalogAsyncUpdateTableMeta(pCatalog, rsp);

source/client/src/clientImpl.c

@@ -1204,13 +1204,13 @@ int initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSe
 
   if (firstEp && firstEp[0] != 0) {
     if (strlen(firstEp) >= TSDB_EP_LEN) {
-      terrno = TSDB_CODE_TSC_INVALID_FQDN;
+      terrno = TSDB_CODE_INVALID_FQDN;
       return -1;
     }
 
     int32_t code = taosGetFqdnPortFromEp(firstEp, &mgmtEpSet->eps[0]);
     if (code != TSDB_CODE_SUCCESS) {
-      terrno = TSDB_CODE_TSC_INVALID_FQDN;
+      terrno = TSDB_CODE_INVALID_FQDN;
       return terrno;
     }
 
@@ -1219,7 +1219,7 @@ int initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSe
 
   if (secondEp && secondEp[0] != 0) {
     if (strlen(secondEp) >= TSDB_EP_LEN) {
-      terrno = TSDB_CODE_TSC_INVALID_FQDN;
+      terrno = TSDB_CODE_INVALID_FQDN;
       return -1;
     }
 
@@ -1228,7 +1228,7 @@ int initEpSetFromCfg(const char* firstEp, const char* secondEp, SCorEpSet* pEpSe
   }
 
   if (mgmtEpSet->numOfEps == 0) {
-    terrno = TSDB_CODE_TSC_INVALID_FQDN;
+    terrno = TSDB_CODE_INVALID_FQDN;
     return -1;
   }
 
@@ -2260,7 +2260,7 @@ int32_t transferTableNameList(const char* tbList, int32_t acctId, char* dbName,
 
 _return:
 
-  terrno = TSDB_CODE_TSC_INVALID_OPERATION;
+  terrno = TSDB_CODE_INVALID_OPERATION;
 
   pIter = taosHashIterate(pHash, NULL);
   while (pIter) {

source/client/src/clientMain.c

@@ -1337,7 +1337,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
     return TSDB_CODE_SUCCESS;
   } else if (length > MAX_TABLE_NAME_LENGTH) {
     tscError("tableNameList too long, length:%d, maximum allowed:%d", length, MAX_TABLE_NAME_LENGTH);
-    return TSDB_CODE_TSC_INVALID_OPERATION;
+    return TSDB_CODE_INVALID_OPERATION;
   }
 
   char *sql = "taos_load_table_info";

source/client/src/clientMsgHandler.c

@@ -70,7 +70,7 @@ int32_t processConnectRsp(void* param, SDataBuf* pMsg, int32_t code) {
 
   SConnectRsp connectRsp = {0};
   if (tDeserializeSConnectRsp(pMsg->pData, pMsg->len, &connectRsp) != 0) {
-    code = TSDB_CODE_TSC_INVALID_VERSION;
+    code = TSDB_CODE_INVALID_MSG;
     setErrno(pRequest, code);
     tsem_post(&pRequest->body.rspSem);
     goto End;
@@ -298,7 +298,7 @@ int32_t processUseDbRsp(void* param, SDataBuf* pMsg, int32_t code) {
 
 int32_t processCreateSTableRsp(void* param, SDataBuf* pMsg, int32_t code) {
   if (pMsg == NULL || param == NULL) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
   SRequestObj* pRequest = param;
 
@@ -485,7 +485,7 @@ static int32_t buildShowVariablesRsp(SArray* pVars, SRetrieveTableRsp** pRsp) {
   if (len != rspSize - sizeof(SRetrieveTableRsp)) {
     uError("buildShowVariablesRsp error, len:%d != rspSize - sizeof(SRetrieveTableRsp):%" PRIu64, len,
            (uint64_t)(rspSize - sizeof(SRetrieveTableRsp)));
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   return TSDB_CODE_SUCCESS;

source/client/src/clientRawBlockWrite.c

@@ -1717,7 +1717,7 @@ static int32_t tmqWriteRawMetaDataImpl(TAOS* taos, void* data, int32_t dataLen)
 
       if (pCreateReq.type != TSDB_CHILD_TABLE) {
         uError("WriteRaw:pCreateReq.type != TSDB_CHILD_TABLE. table name: %s", tbName);
-        code = TSDB_CODE_TSC_INVALID_VALUE;
+        code = TSDB_CODE_INVALID_VALUE;
         tDecoderClear(&decoderTmp);
         tDestroySVCreateTbReq(&pCreateReq, TSDB_MSG_FLG_DECODE);
         goto end;

source/client/src/clientSmlJson.c

@@ -594,17 +594,17 @@ static int32_t smlParseValueFromJSONObj(cJSON *root, SSmlKv *kv) {
   int32_t size = cJSON_GetArraySize(root);
 
   if (size != OTD_JSON_SUB_FIELDS_NUM) {
-    return TSDB_CODE_TSC_INVALID_JSON;
+    return TSDB_CODE_INVALID_JSON_FORMAT;
   }
 
   cJSON *value = cJSON_GetObjectItem(root, "value");
   if (value == NULL) {
-    return TSDB_CODE_TSC_INVALID_JSON;
+    return TSDB_CODE_INVALID_JSON_FORMAT;
   }
 
   cJSON *type = cJSON_GetObjectItem(root, "type");
   if (!cJSON_IsString(type)) {
-    return TSDB_CODE_TSC_INVALID_JSON;
+    return TSDB_CODE_INVALID_JSON_FORMAT;
   }
 
   switch (value->type) {
@@ -670,7 +670,7 @@ static int32_t smlParseValueFromJSON(cJSON *root, SSmlKv *kv) {
       break;
     }
     default:
-      return TSDB_CODE_TSC_INVALID_JSON;
+      return TSDB_CODE_INVALID_JSON_FORMAT;
   }
 
   return TSDB_CODE_SUCCESS;
@@ -713,12 +713,12 @@ static int32_t smlParseTagsFromJSON(SSmlHandle *info, cJSON *tags, SSmlLineInfo
   int32_t tagNum = cJSON_GetArraySize(tags);
   if (unlikely(tagNum == 0)) {
     uError("SML:Tag should not be empty");
-    return TSDB_CODE_TSC_INVALID_JSON;
+    return TSDB_CODE_INVALID_JSON_FORMAT;
   }
   for (int32_t i = 0; i < tagNum; ++i) {
     cJSON *tag = cJSON_GetArrayItem(tags, i);
     if (unlikely(tag == NULL)) {
-      return TSDB_CODE_TSC_INVALID_JSON;
+      return TSDB_CODE_INVALID_JSON_FORMAT;
     }
     //    if(unlikely(tag == cMeasure)) continue;
     size_t keyLen = strlen(tag->string);
@@ -936,7 +936,7 @@ static int32_t smlParseJSONStringExt(SSmlHandle *info, cJSON *root, SSmlLineInfo
   // outmost json fields has to be exactly 4
   if (size != OTD_JSON_FIELDS_NUM) {
     uError("OTD:0x%" PRIx64 " Invalid number of JSON fields in data point %d", info->id, size);
-    return TSDB_CODE_TSC_INVALID_JSON;
+    return TSDB_CODE_INVALID_JSON_FORMAT;
   }
 
   cJSON **marks[OTD_JSON_FIELDS_NUM] = {&metricJson, &tsJson, &valueJson, &tagsJson};
@@ -1029,13 +1029,13 @@ static int32_t smlParseJSONExt(SSmlHandle *info, char *payload) {
 
   if (unlikely(payload == NULL)) {
     uError("SML:0x%" PRIx64 " empty JSON Payload", info->id);
-    return TSDB_CODE_TSC_INVALID_JSON;
+    return TSDB_CODE_INVALID_JSON_FORMAT;
   }
 
   info->root = cJSON_Parse(payload);
   if (unlikely(info->root == NULL)) {
     uError("SML:0x%" PRIx64 " parse json failed:%s", info->id, payload);
-    return TSDB_CODE_TSC_INVALID_JSON;
+    return TSDB_CODE_INVALID_JSON_FORMAT;
   }
 
   // multiple data points must be sent in JSON array
@@ -1045,7 +1045,7 @@ static int32_t smlParseJSONExt(SSmlHandle *info, char *payload) {
     payloadNum = 1;
   } else {
     uError("SML:0x%" PRIx64 " Invalid JSON Payload 3:%s", info->id, payload);
-    return TSDB_CODE_TSC_INVALID_JSON;
+    return TSDB_CODE_INVALID_JSON_FORMAT;
   }
 
   info->lineNum = payloadNum;
@@ -1103,7 +1103,7 @@ static int32_t smlParseJSONString(SSmlHandle *info, char **start, SSmlLineInfo *
   }
 
   if (ret != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   if (unlikely(**start == '\0' && elements->measure == NULL)) return TSDB_CODE_SUCCESS;
@@ -1117,26 +1117,26 @@ static int32_t smlParseJSONString(SSmlHandle *info, char **start, SSmlLineInfo *
 
   if (unlikely(elements->colsLen == 0)) {
     uError("SML:colsLen == 0");
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_VALUE;
   } else if (unlikely(elements->cols[0] == '{')) {
     char tmp = elements->cols[elements->colsLen];
     elements->cols[elements->colsLen] = '\0';
     cJSON *valueJson = cJSON_Parse(elements->cols);
     if (unlikely(valueJson == NULL)) {
       uError("SML:0x%" PRIx64 " parse json cols failed:%s", info->id, elements->cols);
-      return TSDB_CODE_TSC_INVALID_JSON;
+      return TSDB_CODE_INVALID_JSON_FORMAT;
     }
     taosArrayPush(info->tagJsonArray, &valueJson);
     ret = smlParseValueFromJSONObj(valueJson, &kv);
     if (ret != TSDB_CODE_SUCCESS) {
       uError("SML:Failed to parse value from JSON Obj:%s", elements->cols);
       elements->cols[elements->colsLen] = tmp;
-      return TSDB_CODE_TSC_INVALID_VALUE;
+      return TSDB_CODE_INVALID_VALUE;
     }
     elements->cols[elements->colsLen] = tmp;
   } else if (smlParseValue(&kv, &info->msgBuf) != TSDB_CODE_SUCCESS) {
     uError("SML:cols invalidate:%s", elements->cols);
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   // Parse tags
@@ -1147,7 +1147,7 @@ static int32_t smlParseJSONString(SSmlHandle *info, char **start, SSmlLineInfo *
     *(elements->tags + elements->tagsLen) = tmp;
     if (unlikely(tagsJson == NULL)) {
       uError("SML:0x%" PRIx64 " parse json tag failed:%s", info->id, elements->tags);
-      return TSDB_CODE_TSC_INVALID_JSON;
+      return TSDB_CODE_INVALID_JSON_FORMAT;
     }
 
     taosArrayPush(info->tagJsonArray, &tagsJson);

source/client/src/clientSmlLine.c

@@ -86,7 +86,7 @@ int32_t smlParseValue(SSmlKv *pVal, SSmlMsgBuf *msg) {
       pVal->value += (BINARY_ADD_LEN - 1);
       return TSDB_CODE_SUCCESS;
     }
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   if (pVal->value[0] == 'l' || pVal->value[0] == 'L') {  // nchar
@@ -99,7 +99,7 @@ int32_t smlParseValue(SSmlKv *pVal, SSmlMsgBuf *msg) {
       pVal->value += (NCHAR_ADD_LEN - 1);
       return TSDB_CODE_SUCCESS;
     }
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   if (pVal->value[0] == 't' || pVal->value[0] == 'T') {
@@ -111,7 +111,7 @@ int32_t smlParseValue(SSmlKv *pVal, SSmlMsgBuf *msg) {
       pVal->length = (int16_t)tDataTypes[pVal->type].bytes;
       return TSDB_CODE_SUCCESS;
     }
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   if (pVal->value[0] == 'f' || pVal->value[0] == 'F') {
@@ -124,7 +124,7 @@ int32_t smlParseValue(SSmlKv *pVal, SSmlMsgBuf *msg) {
       pVal->length = (int16_t)tDataTypes[pVal->type].bytes;
       return TSDB_CODE_SUCCESS;
     }
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   // number
@@ -133,7 +133,7 @@ int32_t smlParseValue(SSmlKv *pVal, SSmlMsgBuf *msg) {
     return TSDB_CODE_SUCCESS;
   }
 
-  return TSDB_CODE_TSC_INVALID_VALUE;
+  return TSDB_CODE_INVALID_VALUE;
 }
 
 static int32_t smlParseTagKv(SSmlHandle *info, char **sql, char *sqlEnd, SSmlLineInfo *currElement, bool isSameMeasure,

source/client/src/clientSmlTelnet.c

@@ -155,7 +155,7 @@ static int32_t smlParseTelnetTags(SSmlHandle *info, char *data, char *sqlEnd, SS
 
     if (unlikely(valueLen == 0)) {
       smlBuildInvalidDataMsg(msg, "invalid value", value);
-      return TSDB_CODE_TSC_INVALID_VALUE;
+      return TSDB_CODE_INVALID_VALUE;
     }
 
     if (unlikely(valueLen > (TSDB_MAX_TAGS_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)) {
@@ -266,12 +266,12 @@ int32_t smlParseTelnetString(SSmlHandle *info, char *sql, char *sqlEnd, SSmlLine
   smlParseTelnetElement(&sql, sqlEnd, &elements->cols, &elements->colsLen);
   if (unlikely(!elements->cols || elements->colsLen == 0)) {
     smlBuildInvalidDataMsg(&info->msgBuf, "invalid value", sql);
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   SSmlKv kv = {.key = VALUE, .keyLen = VALUE_LEN, .value = elements->cols, .length = (size_t)elements->colsLen};
   if (smlParseValue(&kv, &info->msgBuf) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   JUMP_SPACE(sql, sqlEnd)
@@ -280,7 +280,7 @@ int32_t smlParseTelnetString(SSmlHandle *info, char *sql, char *sqlEnd, SSmlLine
   elements->tagsLen = sqlEnd - sql;
   if (unlikely(!elements->tags || elements->tagsLen == 0)) {
     smlBuildInvalidDataMsg(&info->msgBuf, "invalid value", sql);
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   int ret = smlParseTelnetTags(info, sql, sqlEnd, elements, &info->msgBuf);

source/common/src/tdatablock.c

@@ -803,7 +803,7 @@ int32_t dataBlockCompar(const void* p1, const void* p2, const void* param) {
     void* right1 = colDataGetData(pColInfoData, right);
     if (pColInfoData->info.type == TSDB_DATA_TYPE_JSON) {
       if (tTagIsJson(left1) || tTagIsJson(right1)) {
-        terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR;
+        terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
         return 0;
       }
     }

source/common/src/tglobal.c

@@ -733,7 +733,7 @@ static int32_t taosSetSlowLogScope(char *pScope) {
   }
 
   uError("Invalid slowLog scope value:%s", pScope);
-  terrno = TSDB_CODE_INVALID_CFG_VALUE;
+  terrno = TSDB_CODE_INVALID_CFG;
   return -1;
 }
 

source/common/src/ttime.c

@@ -613,31 +613,31 @@ static int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t time
   switch (unit) {
     case 's':
       if (val > INT64_MAX / MILLISECOND_PER_SECOND) {
-        return -1;
+        return TSDB_CODE_INVALID_TIMESTAMP;
       }
       (*result) = convertTimePrecision(val * MILLISECOND_PER_SECOND, TSDB_TIME_PRECISION_MILLI, timePrecision);
       break;
     case 'm':
       if (val > INT64_MAX / MILLISECOND_PER_MINUTE) {
-        return -1;
+        return TSDB_CODE_INVALID_TIMESTAMP;
       }
       (*result) = convertTimePrecision(val * MILLISECOND_PER_MINUTE, TSDB_TIME_PRECISION_MILLI, timePrecision);
       break;
     case 'h':
       if (val > INT64_MAX / MILLISECOND_PER_MINUTE) {
-        return -1;
+        return TSDB_CODE_INVALID_TIMESTAMP;
       }
       (*result) = convertTimePrecision(val * MILLISECOND_PER_HOUR, TSDB_TIME_PRECISION_MILLI, timePrecision);
       break;
     case 'd':
       if (val > INT64_MAX / MILLISECOND_PER_DAY) {
-        return -1;
+        return TSDB_CODE_INVALID_TIMESTAMP;
       }
       (*result) = convertTimePrecision(val * MILLISECOND_PER_DAY, TSDB_TIME_PRECISION_MILLI, timePrecision);
       break;
     case 'w':
       if (val > INT64_MAX / MILLISECOND_PER_WEEK) {
-        return -1;
+        return TSDB_CODE_INVALID_TIMESTAMP;
       }
       (*result) = convertTimePrecision(val * MILLISECOND_PER_WEEK, TSDB_TIME_PRECISION_MILLI, timePrecision);
       break;
@@ -651,7 +651,7 @@ static int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t time
       (*result) = convertTimePrecision(val, TSDB_TIME_PRECISION_NANO, timePrecision);
       break;
     default: {
-      return -1;
+      return TSDB_CODE_INVALID_TIMESTAMP;
     }
   }
   return 0;
@@ -679,13 +679,13 @@ int32_t parseAbsoluteDuration(const char* token, int32_t tokenlen, int64_t* dura
   /* get the basic numeric value */
   int64_t timestamp = taosStr2Int64(token, &endPtr, 10);
   if (timestamp < 0 || errno != 0) {
-    return -1;
+    return TSDB_CODE_INVALID_TIMESTAMP;
   }
 
   /* natual month/year are not allowed in absolute duration */
   *unit = token[tokenlen - 1];
   if (*unit == 'n' || *unit == 'y') {
-    return -1;
+    return TSDB_CODE_INVALID_OPTION;
   }
 
   return getDuration(timestamp, *unit, duration, timePrecision);

source/dnode/mgmt/mgmt_vnode/src/vmWorker.c

@@ -204,7 +204,7 @@ static int32_t vmPutMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg, EQueueType qtyp
       break;
     case WRITE_QUEUE:
       if (!osDataSpaceSufficient()) {
-        terrno = TSDB_CODE_NO_ENOUGH_DISKSPACE;
+        terrno = TSDB_CODE_NO_DISKSPACE;
         code = terrno;
         dError("vgId:%d, msg:%p put into vnode-write queue failed since %s", pVnode->vgId, pMsg, terrstr(code));
         break;

source/dnode/mnode/impl/src/mndScheduler.c

@@ -48,12 +48,12 @@ int32_t mndConvertRsmaTask(char** pDst, int32_t* pDstLen, const char* ast, int64
   terrno = TSDB_CODE_SUCCESS;
 
   if (nodesStringToNode(ast, &pAst) < 0) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    terrno = TSDB_CODE_INVALID_MSG;
     goto END;
   }
 
   if (qSetSTableIdForRsma(pAst, uid) < 0) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    terrno = TSDB_CODE_INVALID_VALUE;
     goto END;
   }
 
@@ -68,26 +68,25 @@ int32_t mndConvertRsmaTask(char** pDst, int32_t* pDstLen, const char* ast, int64
   };
 
   if (qCreateQueryPlan(&cxt, &pPlan, NULL) < 0) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
     goto END;
   }
 
   int32_t levelNum = LIST_LENGTH(pPlan->pSubplans);
   if (levelNum != 1) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    terrno = TSDB_CODE_INVALID_VALUE;
     goto END;
   }
   SNodeListNode* inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0);
 
   int32_t opNum = LIST_LENGTH(inner->pNodeList);
   if (opNum != 1) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    terrno = TSDB_CODE_INVALID_VALUE;
     goto END;
   }
 
   SSubplan* plan = (SSubplan*)nodesListGetNode(inner->pNodeList, 0);
   if (qSubPlanToString(plan, pDst, pDstLen) < 0) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    terrno = TSDB_CODE_INVALID_MSG;
     goto END;
   }
 
@@ -165,7 +164,7 @@ int32_t mndAssignTaskToVg(SMnode* pMnode, SStreamTask* pTask, SSubplan* plan, co
   plan->execNode.epSet = pTask->epSet;
 
   if (qSubPlanToString(plan, &pTask->exec.qmsg, &msgLen) < 0) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
   return 0;
@@ -189,7 +188,7 @@ int32_t mndAssignTaskToSnode(SMnode* pMnode, SStreamTask* pTask, SSubplan* plan,
   plan->execNode.epSet = pTask->epSet;
 
   if (qSubPlanToString(plan, &pTask->exec.qmsg, &msgLen) < 0) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
   return 0;
@@ -298,7 +297,7 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
   SSdb*       pSdb = pMnode->pSdb;
   SQueryPlan* pPlan = qStringToQueryPlan(pStream->physicalPlan);
   if (pPlan == NULL) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
   int32_t planTotLevel = LIST_LENGTH(pPlan->pSubplans);
@@ -309,7 +308,7 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
   bool    externalTargetDB = strcmp(pStream->sourceDb, pStream->targetDb) != 0;
   SDbObj* pDbObj = mndAcquireDb(pMnode, pStream->targetDb);
   if (pDbObj == NULL) {
-    terrno = TSDB_CODE_QRY_INVALID_INPUT;
+    terrno = TSDB_CODE_INVALID_VALUE;
     return -1;
   }
 
@@ -346,7 +345,7 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
       SNodeListNode* inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0);
       SSubplan*      plan = (SSubplan*)nodesListGetNode(inner->pNodeList, 0);
       if (plan->subplanType != SUBPLAN_TYPE_MERGE) {
-        terrno = TSDB_CODE_QRY_INVALID_INPUT;
+        terrno = TSDB_CODE_INVALID_VALUE;
         return -1;
       }
 
@@ -408,7 +407,7 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
     SNodeListNode* inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 1);
     SSubplan*      plan = (SSubplan*)nodesListGetNode(inner->pNodeList, 0);
     if (plan->subplanType != SUBPLAN_TYPE_SCAN) {
-      terrno = TSDB_CODE_QRY_INVALID_INPUT;
+      terrno = TSDB_CODE_INVALID_VALUE;
       return -1;
     }
 
@@ -473,12 +472,12 @@ int32_t mndScheduleStream(SMnode* pMnode, SStreamObj* pStream) {
 
     SNodeListNode* inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0);
     if (LIST_LENGTH(inner->pNodeList) != 1) {
-      terrno = TSDB_CODE_QRY_INVALID_INPUT;
+      terrno = TSDB_CODE_INVALID_VALUE;
       return -1;
     }
     SSubplan* plan = (SSubplan*)nodesListGetNode(inner->pNodeList, 0);
     if (plan->subplanType != SUBPLAN_TYPE_SCAN) {
-      terrno = TSDB_CODE_QRY_INVALID_INPUT;
+      terrno = TSDB_CODE_INVALID_VALUE;
       return -1;
     }
 
@@ -535,7 +534,7 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
   if (pTopic->subType == TOPIC_SUB_TYPE__COLUMN) {
     pPlan = qStringToQueryPlan(pTopic->physicalPlan);
     if (pPlan == NULL) {
-      terrno = TSDB_CODE_QRY_INVALID_INPUT;
+      terrno = TSDB_CODE_INVALID_MSG;
       return -1;
     }
 
@@ -588,7 +587,7 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
       if (qSubPlanToString(pSubplan, &pVgEp->qmsg, &msgLen) < 0) {
         sdbRelease(pSdb, pVgroup);
         qDestroyQueryPlan(pPlan);
-        terrno = TSDB_CODE_QRY_INVALID_INPUT;
+        terrno = TSDB_CODE_INVALID_MSG;
         return -1;
       }
     } else {

source/libs/catalog/src/ctgCache.c

@@ -851,7 +851,7 @@ int32_t ctgEnqueue(SCatalog *pCtg, SCtgCacheOperation *operation) {
   if (gCtgMgmt.queue.stopQueue) {
     ctgFreeQNode(node);
     CTG_UNLOCK(CTG_WRITE, &gCtgMgmt.queue.qlock);
-    CTG_RET(TSDB_CODE_CTG_EXIT);
+    CTG_RET(TSDB_CODE_CTG_OUT_OF_SERVICE);
   }
 
   gCtgMgmt.queue.tail->next = node;

source/libs/catalog/src/ctgUtil.c

@@ -979,7 +979,7 @@ int32_t ctgGetVgInfoFromHashValue(SCatalog* pCtg, SDBVgInfo* dbInfo, const SName
 
   if (vgNum <= 0) {
     ctgError("db vgroup cache invalid, db:%s, vgroup number:%d", db, vgNum);
-    CTG_ERR_RET(TSDB_CODE_TSC_DB_NOT_SELECTED);
+    CTG_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   SVgroupInfo* vgInfo = NULL;
@@ -1117,7 +1117,7 @@ int32_t ctgGetVgIdsFromHashValue(SCatalog* pCtg, SDBVgInfo* dbInfo, char* dbFNam
 
   if (vgNum <= 0) {
     ctgError("db vgroup cache invalid, db:%s, vgroup number:%d", dbFName, vgNum);
-    CTG_ERR_RET(TSDB_CODE_TSC_DB_NOT_SELECTED);
+    CTG_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   SVgroupInfo* vgInfo = NULL;

source/libs/command/src/explain.c

@@ -1597,13 +1597,13 @@ int32_t qExplainPrepareCtx(SQueryPlan *pDag, SExplainCtx **pCtx) {
 
   if (pDag->numOfSubplans <= 0) {
     qError("invalid subplan num:%d", pDag->numOfSubplans);
-    QRY_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QRY_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   int32_t levelNum = (int32_t)LIST_LENGTH(pDag->pSubplans);
   if (levelNum <= 0) {
     qError("invalid level num:%d", levelNum);
-    QRY_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QRY_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   SHashObj *groupHash =
@@ -1620,13 +1620,13 @@ int32_t qExplainPrepareCtx(SQueryPlan *pDag, SExplainCtx **pCtx) {
     plans = (SNodeListNode *)nodesListGetNode(pDag->pSubplans, i);
     if (NULL == plans) {
       qError("empty level plan, level:%d", i);
-      QRY_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+      QRY_ERR_JRET(TSDB_CODE_INVALID_VALUE);
     }
 
     taskNum = (int32_t)LIST_LENGTH(plans->pNodeList);
     if (taskNum <= 0) {
       qError("invalid level plan number:%d, level:%d", taskNum, i);
-      QRY_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+      QRY_ERR_JRET(TSDB_CODE_INVALID_VALUE);
     }
 
     SSubplan *plan = NULL;
@@ -1651,7 +1651,7 @@ int32_t qExplainPrepareCtx(SQueryPlan *pDag, SExplainCtx **pCtx) {
     if (0 == i) {
       if (taskNum > 1) {
         qError("invalid taskNum %d for level 0", taskNum);
-        QRY_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+        QRY_ERR_JRET(TSDB_CODE_INVALID_VALUE);
       }
 
       ctx->rootGroupId = plan->id.groupId;

source/libs/executor/src/dataDeleter.c

@@ -257,7 +257,7 @@ int32_t createDataDeleter(SDataSinkManager* pManager, const SDataSinkNode* pData
   deleter->pSchema = pDataSink->pInputDataBlockDesc;
 
   if (pParam == NULL) {
-    code = TSDB_CODE_QRY_INVALID_INPUT;
+    code = TSDB_CODE_INVALID_PTR;
     qError("invalid input param in creating data deleter, code%s", tstrerror(code));
     goto _end;
   }

source/libs/executor/src/dataSinkMgt.c

@@ -46,7 +46,7 @@ int32_t dsCreateDataSinker(const SDataSinkNode* pDataSink, DataSinkHandle* pHand
   }
 
   qError("invalid input node type:%d, %s", nodeType(pDataSink), id);
-  return TSDB_CODE_QRY_INVALID_INPUT;
+  return TSDB_CODE_INVALID_VALUE;
 }
 
 int32_t dsPutDataBlock(DataSinkHandle handle, const SInputData* pInput, bool* pContinue) {

source/libs/executor/src/executil.c

@@ -602,7 +602,7 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
         char* data = colDataGetData(pValue, i);
         if (pValue->info.type == TSDB_DATA_TYPE_JSON) {
           if (tTagIsJson(data)) {
-            code = TSDB_CODE_QRY_JSON_IN_GROUP_ERROR;
+            code = TSDB_CODE_QRY_JSON_USAGE_ERROR;
             goto end;
           }
           if (tTagIsJsonNull(data)) {
@@ -1204,7 +1204,7 @@ int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode,
       char* data = nodesGetValueFromNode(pValue);
       if (pValue->node.resType.type == TSDB_DATA_TYPE_JSON) {
         if (tTagIsJson(data)) {
-          terrno = TSDB_CODE_QRY_JSON_IN_GROUP_ERROR;
+          terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
           nodesDestroyList(groupNew);
           pAPI->metaReaderFn.clearReader(&mr);
           return terrno;

source/libs/executor/src/filloperator.c

@@ -303,7 +303,7 @@ static int32_t createPrimaryTsExprIfNeeded(SFillOperatorInfo* pInfo, SFillPhysiN
   if (wstartExist == false) {
     if (pPhyFillNode->pWStartTs->type != QUERY_NODE_TARGET) {
       qError("pWStartTs of fill physical node is not a target node, %s", idStr);
-      return TSDB_CODE_QRY_SYS_ERROR;
+      return TSDB_CODE_INVALID_VALUE;
     }
 
     SExprInfo* pExpr = taosMemoryRealloc(pExprSupp->pExprInfo, (pExprSupp->numOfExprs + 1) * sizeof(SExprInfo));

source/libs/executor/src/groupoperator.c

@@ -194,7 +194,7 @@ static void recordNewGroupKeys(SArray* pGroupCols, SArray* pGroupColVals, SSData
       char* val = colDataGetData(pColInfoData, rowIndex);
       if (pkey->type == TSDB_DATA_TYPE_JSON) {
         if (tTagIsJson(val)) {
-          terrno = TSDB_CODE_QRY_JSON_IN_GROUP_ERROR;
+          terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
           return;
         }
         int32_t dataLen = getJsonValueLen(val);

source/libs/executor/src/projectoperator.c

@@ -211,7 +211,7 @@ static int32_t doIngroupLimitOffset(SLimitInfo* pLimitInfo, uint64_t groupId, SS
   if (pBlock->info.rows == 0) {
     return PROJECT_RETRIEVE_CONTINUE;
   } else {
-    if (limitReached && (pLimitInfo->slimit.limit >= 0 && pLimitInfo->slimit.limit <= pLimitInfo->numOfOutputGroups)) {
+    if (limitReached && (0 == pLimitInfo->currentGroupId || (pLimitInfo->slimit.limit >= 0 && pLimitInfo->slimit.limit <= pLimitInfo->numOfOutputGroups))) {
       setOperatorCompleted(pOperator);
     }
   }

source/libs/executor/src/scanoperator.c

@@ -3119,11 +3119,11 @@ int32_t tblCountScanGetGroupTagsSlotId(const SNodeList* scanCols, STableCountSca
     SNode* pNode = NULL;
     FOREACH(pNode, scanCols) {
       if (nodeType(pNode) != QUERY_NODE_TARGET) {
-        return TSDB_CODE_QRY_SYS_ERROR;
+        return TSDB_CODE_INVALID_VALUE;
       }
       STargetNode* targetNode = (STargetNode*)pNode;
       if (nodeType(targetNode->pExpr) != QUERY_NODE_COLUMN) {
-        return TSDB_CODE_QRY_SYS_ERROR;
+        return TSDB_CODE_INVALID_VALUE;
       }
       SColumnNode* colNode = (SColumnNode*)(targetNode->pExpr);
       if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {
@@ -3141,11 +3141,11 @@ int32_t tblCountScanGetCountSlotId(const SNodeList* pseudoCols, STableCountScanS
     SNode* pNode = NULL;
     FOREACH(pNode, pseudoCols) {
       if (nodeType(pNode) != QUERY_NODE_TARGET) {
-        return TSDB_CODE_QRY_SYS_ERROR;
+        return TSDB_CODE_INVALID_VALUE;
       }
       STargetNode* targetNode = (STargetNode*)pNode;
       if (nodeType(targetNode->pExpr) != QUERY_NODE_FUNCTION) {
-        return TSDB_CODE_QRY_SYS_ERROR;
+        return TSDB_CODE_INVALID_VALUE;
       }
       SFunctionNode* funcNode = (SFunctionNode*)(targetNode->pExpr);
       if (funcNode->funcType == FUNCTION_TYPE_TABLE_COUNT) {
@@ -3161,7 +3161,7 @@ int32_t tblCountScanGetInputs(SNodeList* groupTags, SName* tableName, STableCoun
     SNode* pNode = NULL;
     FOREACH(pNode, groupTags) {
       if (nodeType(pNode) != QUERY_NODE_COLUMN) {
-        return TSDB_CODE_QRY_SYS_ERROR;
+        return TSDB_CODE_INVALID_VALUE;
       }
       SColumnNode* colNode = (SColumnNode*)pNode;
       if (strcmp(colNode->colName, GROUP_TAG_DB_NAME) == 0) {

source/libs/executor/src/sysscanoperator.c

@@ -814,7 +814,7 @@ int32_t convertTagDataToStr(char* str, int type, void* buf, int32_t bufSize, int
 
     case TSDB_DATA_TYPE_BINARY:
       if (bufSize < 0) {
-        return TSDB_CODE_TSC_INVALID_VALUE;
+        return TSDB_CODE_INVALID_VALUE;
       }
 
       memcpy(str, buf, bufSize);
@@ -822,12 +822,12 @@ int32_t convertTagDataToStr(char* str, int type, void* buf, int32_t bufSize, int
       break;
     case TSDB_DATA_TYPE_NCHAR:
       if (bufSize < 0) {
-        return TSDB_CODE_TSC_INVALID_VALUE;
+        return TSDB_CODE_INVALID_VALUE;
       }
 
       int32_t length = taosUcs4ToMbs((TdUcs4*)buf, bufSize, str);
       if (length <= 0) {
-        return TSDB_CODE_TSC_INVALID_VALUE;
+        return TSDB_CODE_INVALID_VALUE;
       }
       n = length;
       break;
@@ -848,7 +848,7 @@ int32_t convertTagDataToStr(char* str, int type, void* buf, int32_t bufSize, int
       break;
 
     default:
-      return TSDB_CODE_TSC_INVALID_VALUE;
+      return TSDB_CODE_INVALID_VALUE;
   }
 
   if (len) *len = n;

source/libs/function/src/udfd.c

@@ -1023,13 +1023,13 @@ int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSe
 
   if (firstEp && firstEp[0] != 0) {
     if (strlen(firstEp) >= TSDB_EP_LEN) {
-      terrno = TSDB_CODE_TSC_INVALID_FQDN;
+      terrno = TSDB_CODE_INVALID_FQDN;
       return -1;
     }
 
     int32_t code = taosGetFqdnPortFromEp(firstEp, &mgmtEpSet->eps[0]);
     if (code != TSDB_CODE_SUCCESS) {
-      terrno = TSDB_CODE_TSC_INVALID_FQDN;
+      terrno = TSDB_CODE_INVALID_FQDN;
       return terrno;
     }
 
@@ -1038,7 +1038,7 @@ int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSe
 
   if (secondEp && secondEp[0] != 0) {
     if (strlen(secondEp) >= TSDB_EP_LEN) {
-      terrno = TSDB_CODE_TSC_INVALID_FQDN;
+      terrno = TSDB_CODE_INVALID_FQDN;
       return -1;
     }
 
@@ -1047,7 +1047,7 @@ int initEpSetFromCfg(const char *firstEp, const char *secondEp, SCorEpSet *pEpSe
   }
 
   if (mgmtEpSet->numOfEps == 0) {
-    terrno = TSDB_CODE_TSC_INVALID_FQDN;
+    terrno = TSDB_CODE_INVALID_FQDN;
     return -1;
   }
 

source/libs/index/src/indexFilter.c

@@ -105,7 +105,7 @@ static FORCE_INLINE int32_t sifGetFuncFromSql(EOperatorType src, EIndexQueryType
   } else if (src == OP_TYPE_JSON_CONTAINS) {
     *dst = QUERY_PREFIX;
   } else {
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_VALUE;
   }
   return TSDB_CODE_SUCCESS;
 }
@@ -141,10 +141,10 @@ static FORCE_INLINE int32_t sifValidOp(EOperatorType ty) {
 static FORCE_INLINE int32_t sifValidColumn(SColumnNode *cn) {
   // add more check
   if (cn == NULL) {
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
   if (cn->colType != COLUMN_TYPE_TAG) {
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_VALUE;
   }
   return TSDB_CODE_SUCCESS;
 }
@@ -216,7 +216,7 @@ static FORCE_INLINE int32_t sifInitJsonParam(SNode *node, SIFParam *param, SIFCt
   param->colId = l->colId;
   param->colValType = l->node.resType.type;
   memcpy(param->dbName, l->dbName, sizeof(l->dbName));
-  if (r->literal == NULL) return TSDB_CODE_QRY_INVALID_INPUT;
+  if (r->literal == NULL) return TSDB_CODE_INVALID_PTR;
   memcpy(param->colName, r->literal, strlen(r->literal));
   param->colValType = r->typeData;
   param->status = SFLT_COARSE_INDEX;
@@ -323,7 +323,7 @@ static int32_t sifInitParam(SNode *node, SIFParam *param, SIFCtx *ctx) {
       SNodeListNode *nl = (SNodeListNode *)node;
       if (LIST_LENGTH(nl->pNodeList) <= 0) {
         indexError("invalid length for node:%p, length: %d", node, LIST_LENGTH(nl->pNodeList));
-        SIF_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+        SIF_ERR_RET(TSDB_CODE_INVALID_VALUE);
       }
       SIF_ERR_RET(scalarGenerateSetFromList((void **)&param->pFilter, node, nl->node.resType.type));
       if (taosHashPut(ctx->pRes, &node, POINTER_BYTES, param, sizeof(*param))) {
@@ -355,7 +355,7 @@ static int32_t sifInitOperParams(SIFParam **params, SOperatorNode *node, SIFCtx
   int32_t nParam = sifGetOperParamNum(node->opType);
   if (NULL == node->pLeft || (nParam == 2 && NULL == node->pRight)) {
     indexError("invalid operation node, left: %p, rigth: %p", node->pLeft, node->pRight);
-    SIF_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    SIF_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
   if (node->opType == OP_TYPE_JSON_GET_VALUE) {
     return code;
@@ -364,7 +364,7 @@ static int32_t sifInitOperParams(SIFParam **params, SOperatorNode *node, SIFCtx
       (node->pRight != NULL && nodeType(node->pRight) == QUERY_NODE_VALUE)) {
     SColumnNode *cn = (SColumnNode *)(node->pLeft);
     if (cn->node.resType.type == TSDB_DATA_TYPE_JSON) {
-      SIF_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+      SIF_ERR_RET(TSDB_CODE_INVALID_VALUE);
     }
   }
 
@@ -417,7 +417,7 @@ static int32_t sifInitParamList(SIFParam **params, SNodeList *nodeList, SIFCtx *
   SListCell *cell = nodeList->pHead;
   for (int32_t i = 0; i < nodeList->length; i++) {
     if (NULL == cell || NULL == cell->pNode) {
-      SIF_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+      SIF_ERR_JRET(TSDB_CODE_INVALID_VALUE);
     }
     SIF_ERR_JRET(sifInitParam(cell->pNode, &tParams[i], ctx));
     cell = cell->pNext;
@@ -431,7 +431,7 @@ _return:
 }
 static int32_t sifExecFunction(SFunctionNode *node, SIFCtx *ctx, SIFParam *output) {
   indexError("index-filter not support buildin function");
-  return TSDB_CODE_QRY_INVALID_INPUT;
+  return TSDB_CODE_INVALID_VALUE;
 }
 
 typedef int (*FilterFunc)(void *a, void *b, int16_t dtype);
@@ -730,7 +730,7 @@ static FORCE_INLINE int32_t sifJsonGetValue(SIFParam *left, SIFParam *rigth, SIF
 
 static FORCE_INLINE int32_t sifDefaultFunc(SIFParam *left, SIFParam *right, SIFParam *output) {
   // add more except
-  return TSDB_CODE_QRY_INVALID_INPUT;
+  return TSDB_CODE_INVALID_VALUE;
 }
 
 static FORCE_INLINE int32_t sifGetOperFn(int32_t funcId, sif_func_t *func, SIdxFltStatus *status) {
@@ -799,7 +799,7 @@ static FORCE_INLINE int32_t sifGetOperFn(int32_t funcId, sif_func_t *func, SIdxF
 static int32_t sifExecOper(SOperatorNode *node, SIFCtx *ctx, SIFParam *output) {
   int32_t code = -1;
   if (sifValidOp(node->opType) < 0) {
-    code = TSDB_CODE_QRY_INVALID_INPUT;
+    code = TSDB_CODE_INVALID_VALUE;
     ctx->code = code;
     output->status = SFLT_NOT_INDEX;
     return code;
@@ -854,7 +854,7 @@ static int32_t sifExecLogic(SLogicConditionNode *node, SIFCtx *ctx, SIFParam *ou
   if (NULL == node->pParameterList || node->pParameterList->length <= 0) {
     indexError("invalid logic parameter list, list:%p, paramNum:%d", node->pParameterList,
                node->pParameterList ? node->pParameterList->length : 0);
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_VALUE;
   }
 
   int32_t   code = TSDB_CODE_SUCCESS;
@@ -957,7 +957,7 @@ EDealRes sifCalcWalker(SNode *node, void *context) {
   }
 
   // indexError("invalid node type for index filter calculating, type:%d", nodeType(node));
-  ctx->code = TSDB_CODE_QRY_INVALID_INPUT;
+  ctx->code = TSDB_CODE_INVALID_VALUE;
   return DEAL_RES_ERROR;
 }
 
@@ -974,7 +974,7 @@ void sifFreeRes(SHashObj *res) {
 }
 static int32_t sifCalculate(SNode *pNode, SIFParam *pDst) {
   if (pNode == NULL || pDst == NULL) {
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   int32_t code = 0;
@@ -1014,7 +1014,7 @@ static int32_t sifCalculate(SNode *pNode, SIFParam *pDst) {
 static int32_t sifGetFltHint(SNode *pNode, SIdxFltStatus *status, SMetaDataFilterAPI* pAPI) {
   int32_t code = TSDB_CODE_SUCCESS;
   if (pNode == NULL) {
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SIFCtx ctx = {.code = 0, .noExec = true, .pAPI = pAPI};

source/libs/nodes/src/nodesCodeFuncs.c

@@ -3168,7 +3168,7 @@ static int32_t datumToJson(const void* pObj, SJson* pJson) {
       code = taosHexEncode(varDataVal(pNode->datum.p), buf, varDataLen(pNode->datum.p));
       if (code != TSDB_CODE_SUCCESS) {
         taosMemoryFree(buf);
-        return TSDB_CODE_TSC_INVALID_VALUE;
+        return TSDB_CODE_INVALID_VALUE;
       }
       code = tjsonAddStringToObject(pJson, jkValueDatum, buf);
       taosMemoryFree(buf);
@@ -3185,7 +3185,7 @@ static int32_t datumToJson(const void* pObj, SJson* pJson) {
       code = taosHexEncode(pNode->datum.p, buf, len);
       if (code != TSDB_CODE_SUCCESS) {
         taosMemoryFree(buf);
-        return TSDB_CODE_TSC_INVALID_VALUE;
+        return TSDB_CODE_INVALID_VALUE;
       }
       code = tjsonAddStringToObject(pJson, jkValueDatum, buf);
       taosMemoryFree(buf);

source/libs/parser/src/parAstCreater.c

@@ -72,7 +72,7 @@ static bool checkUserName(SAstCreateContext* pCxt, SToken* pUserName) {
     pCxt->errCode = TSDB_CODE_PAR_SYNTAX_ERROR;
   } else {
     if (pUserName->n >= TSDB_USER_LEN) {
-      pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG);
+      pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG);
     }
   }
   if (TSDB_CODE_SUCCESS == pCxt->errCode) {
@@ -98,7 +98,7 @@ static bool checkPassword(SAstCreateContext* pCxt, const SToken* pPasswordToken,
   if (NULL == pPasswordToken) {
     pCxt->errCode = TSDB_CODE_PAR_SYNTAX_ERROR;
   } else if (pPasswordToken->n >= (TSDB_USET_PASSWORD_LEN + 2)) {
-    pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG);
+    pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG);
   } else {
     strncpy(pPassword, pPasswordToken->z, pPasswordToken->n);
     strdequote(pPassword);
@@ -121,7 +121,7 @@ static int32_t parsePort(SAstCreateContext* pCxt, const char* p, int32_t* pPort)
 
 static int32_t parseEndpoint(SAstCreateContext* pCxt, const SToken* pEp, char* pFqdn, int32_t* pPort) {
   if (pEp->n >= (NULL == pPort ? (TSDB_FQDN_LEN + 1 + 5) : TSDB_FQDN_LEN)) {  // format 'fqdn:port' or 'fqdn'
-    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG);
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG);
   }
 
   char ep[TSDB_FQDN_LEN + 1 + 5] = {0};

source/libs/parser/src/parInsertSml.c

@@ -232,7 +232,7 @@ int32_t smlBuildCol(STableDataCxt* pTableCxt, SSchema* schema, void* data, int32
         goto end;
       }
       taosMemoryFree(pUcs4);
-      ret = TSDB_CODE_TSC_INVALID_VALUE;
+      ret = TSDB_CODE_INVALID_VALUE;
       goto end;
     }
     pVal->value.pData = pUcs4;

source/libs/parser/src/parInsertSql.c

@@ -289,8 +289,9 @@ static int parseTime(const char** end, SToken* pToken, int16_t timePrec, int64_t
     }
 
     char unit = 0;
-    if (parseAbsoluteDuration(valueToken.z, valueToken.n, &interval, &unit, timePrec) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_OPERATION;
+    int32_t code = parseAbsoluteDuration(valueToken.z, valueToken.n, &interval, &unit, timePrec);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
     }
 
     if (token.type == TK_NK_PLUS) {

source/libs/parser/src/parTranslater.c

@@ -2667,7 +2667,7 @@ static int32_t translateTable(STranslateContext* pCxt, SNode* pTable) {
           if (isSelectStmt(pCxt->pCurrStmt)) {
             ((SSelectStmt*)pCxt->pCurrStmt)->isTimeLineResult = false;
           } else if (isDeleteStmt(pCxt->pCurrStmt)) {
-            code = TSDB_CODE_TSC_INVALID_OPERATION;
+            code = TSDB_CODE_INVALID_OPERATION;
             break;
           }
         }

source/libs/parser/src/parUtil.c

@@ -51,8 +51,8 @@ static char* getSyntaxErrFormat(int32_t errCode) {
       return "Tags number not matched";
     case TSDB_CODE_PAR_INVALID_TAG_NAME:
       return "Invalid tag name: %s";
-    case TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG:
-      return "Name or password too long";
+    case TSDB_CODE_PAR_VALUE_TOO_LONG:
+      return "Value is too long";
     case TSDB_CODE_PAR_PASSWD_EMPTY:
       return "Password can not be empty";
     case TSDB_CODE_PAR_INVALID_PORT:
@@ -201,7 +201,7 @@ int32_t generateSyntaxErrMsgExt(SMsgBuf* pBuf, int32_t errCode, const char* pFor
 
 int32_t buildInvalidOperationMsg(SMsgBuf* pBuf, const char* msg) {
   strncpy(pBuf->buf, msg, pBuf->len);
-  return TSDB_CODE_TSC_INVALID_OPERATION;
+  return TSDB_CODE_INVALID_OPERATION;
 }
 
 int32_t buildSyntaxErrMsg(SMsgBuf* pBuf, const char* additionalInfo, const char* sourceStr) {

source/libs/qcom/src/queryUtil.c

@@ -304,7 +304,7 @@ int32_t dataConverToStr(char* str, int type, void* buf, int32_t bufSize, int32_t
     case TSDB_DATA_TYPE_GEOMETRY:
       if (bufSize < 0) {
         //        tscError("invalid buf size");
-        return TSDB_CODE_TSC_INVALID_VALUE;
+        return TSDB_CODE_INVALID_VALUE;
       }
 
       *str = '"';
@@ -315,13 +315,13 @@ int32_t dataConverToStr(char* str, int type, void* buf, int32_t bufSize, int32_t
     case TSDB_DATA_TYPE_NCHAR:
       if (bufSize < 0) {
         //        tscError("invalid buf size");
-        return TSDB_CODE_TSC_INVALID_VALUE;
+        return TSDB_CODE_INVALID_VALUE;
       }
 
       *str = '"';
       int32_t length = taosUcs4ToMbs((TdUcs4*)buf, bufSize, str + 1);
       if (length <= 0) {
-        return TSDB_CODE_TSC_INVALID_VALUE;
+        return TSDB_CODE_INVALID_VALUE;
       }
       *(str + length + 1) = '"';
       n = length + 2;
@@ -344,7 +344,7 @@ int32_t dataConverToStr(char* str, int type, void* buf, int32_t bufSize, int32_t
 
     default:
       //      tscError("unsupported type:%d", type);
-      return TSDB_CODE_TSC_INVALID_VALUE;
+      return TSDB_CODE_INVALID_VALUE;
   }
 
   if (len) *len = n;

source/libs/qcom/src/querymsg.c

@@ -72,7 +72,7 @@ int32_t queryBuildTableMetaReqMsg(void *input, char **msg, int32_t msgSize, int3
                                   void *(*mallcFp)(int64_t)) {
   SBuildTableInput *pInput = input;
   if (NULL == input || NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   STableInfoReq infoReq = {0};
@@ -95,7 +95,7 @@ int32_t queryBuildTableMetaReqMsg(void *input, char **msg, int32_t msgSize, int3
 int32_t queryBuildUseDbMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
   SBuildUseDBInput *pInput = input;
   if (NULL == pInput || NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SUseDbReq usedbReq = {0};
@@ -118,7 +118,7 @@ int32_t queryBuildUseDbMsg(void *input, char **msg, int32_t msgSize, int32_t *ms
 
 int32_t queryBuildQnodeListMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
   if (NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SQnodeListReq qnodeListReq = {0};
@@ -136,7 +136,7 @@ int32_t queryBuildQnodeListMsg(void *input, char **msg, int32_t msgSize, int32_t
 
 int32_t queryBuildDnodeListMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
   if (NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SDnodeListReq dnodeListReq = {0};
@@ -154,7 +154,7 @@ int32_t queryBuildDnodeListMsg(void *input, char **msg, int32_t msgSize, int32_t
 
 int32_t queryBuildGetSerVerMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
   if (NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SServerVerReq req = {0};
@@ -171,7 +171,7 @@ int32_t queryBuildGetSerVerMsg(void *input, char **msg, int32_t msgSize, int32_t
 
 int32_t queryBuildGetDBCfgMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
   if (NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SDbCfgReq dbCfgReq = {0};
@@ -189,7 +189,7 @@ int32_t queryBuildGetDBCfgMsg(void *input, char **msg, int32_t msgSize, int32_t
 
 int32_t queryBuildGetIndexMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
   if (NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SUserIndexReq indexReq = {0};
@@ -208,7 +208,7 @@ int32_t queryBuildGetIndexMsg(void *input, char **msg, int32_t msgSize, int32_t
 int32_t queryBuildRetrieveFuncMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, 
                                   void *(*mallcFp)(int64_t)) {
   if (NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SRetrieveFuncReq funcReq = {0};
@@ -231,7 +231,7 @@ int32_t queryBuildRetrieveFuncMsg(void *input, char **msg, int32_t msgSize, int3
 
 int32_t queryBuildGetUserAuthMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
   if (NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SGetUserAuthReq req = {0};
@@ -249,7 +249,7 @@ int32_t queryBuildGetUserAuthMsg(void *input, char **msg, int32_t msgSize, int32
 
 int32_t queryBuildGetTbIndexMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
   if (NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   STableIndexReq indexReq = {0};
@@ -267,7 +267,7 @@ int32_t queryBuildGetTbIndexMsg(void *input, char **msg, int32_t msgSize, int32_
 
 int32_t queryBuildGetTbCfgMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
   if (NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SBuildTableInput *pInput = input;
@@ -292,7 +292,7 @@ int32_t queryProcessUseDBRsp(void *output, char *msg, int32_t msgSize) {
   int32_t       code = -1;
 
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    code = TSDB_CODE_TSC_INVALID_INPUT;
+    code = TSDB_CODE_INVALID_PTR;
     goto PROCESS_USEDB_OVER;
   }
 
@@ -304,7 +304,7 @@ int32_t queryProcessUseDBRsp(void *output, char *msg, int32_t msgSize) {
 
   if (usedbRsp.vgNum < 0) {
     qError("invalid db[%s] vgroup number[%d]", usedbRsp.db, usedbRsp.vgNum);
-    code = TSDB_CODE_TSC_INVALID_VALUE;
+    code = TSDB_CODE_INVALID_MSG;
     goto PROCESS_USEDB_OVER;
   }
 
@@ -336,33 +336,33 @@ PROCESS_USEDB_OVER:
 static int32_t queryConvertTableMetaMsg(STableMetaRsp *pMetaMsg) {
   if (pMetaMsg->numOfTags < 0 || pMetaMsg->numOfTags > TSDB_MAX_TAGS) {
     qError("invalid numOfTags[%d] in table meta rsp msg", pMetaMsg->numOfTags);
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_MSG;
   }
 
   if (pMetaMsg->numOfColumns > TSDB_MAX_COLUMNS || pMetaMsg->numOfColumns <= 0) {
     qError("invalid numOfColumns[%d] in table meta rsp msg", pMetaMsg->numOfColumns);
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_MSG;
   }
 
   if (pMetaMsg->tableType != TSDB_SUPER_TABLE && pMetaMsg->tableType != TSDB_CHILD_TABLE &&
       pMetaMsg->tableType != TSDB_NORMAL_TABLE && pMetaMsg->tableType != TSDB_SYSTEM_TABLE) {
     qError("invalid tableType[%d] in table meta rsp msg", pMetaMsg->tableType);
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_MSG;
   }
 
   if (pMetaMsg->sversion < 0) {
     qError("invalid sversion[%d] in table meta rsp msg", pMetaMsg->sversion);
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_MSG;
   }
 
   if (pMetaMsg->tversion < 0) {
     qError("invalid tversion[%d] in table meta rsp msg", pMetaMsg->tversion);
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_MSG;
   }
 
   if (pMetaMsg->pSchemas[0].colId != PRIMARYKEY_TIMESTAMP_COL_ID) {
     qError("invalid colId[%" PRIi16 "] for the first column in table meta rsp msg", pMetaMsg->pSchemas[0].colId);
-    return TSDB_CODE_TSC_INVALID_VALUE;
+    return TSDB_CODE_INVALID_MSG;
   }
 
   return TSDB_CODE_SUCCESS;
@@ -422,7 +422,7 @@ int32_t queryProcessTableMetaRsp(void *output, char *msg, int32_t msgSize) {
   STableMetaRsp metaRsp = {0};
 
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    code = TSDB_CODE_TSC_INVALID_INPUT;
+    code = TSDB_CODE_INVALID_PTR;
     goto PROCESS_META_OVER;
   }
 
@@ -438,7 +438,7 @@ int32_t queryProcessTableMetaRsp(void *output, char *msg, int32_t msgSize) {
 
   if (0 != strcmp(metaRsp.dbFName, TSDB_INFORMATION_SCHEMA_DB) &&
       !tIsValidSchema(metaRsp.pSchemas, metaRsp.numOfColumns, metaRsp.numOfTags)) {
-    code = TSDB_CODE_TSC_INVALID_VALUE;
+    code = TSDB_CODE_INVALID_MSG;
     goto PROCESS_META_OVER;
   }
 
@@ -478,7 +478,7 @@ int32_t queryProcessQnodeListRsp(void *output, char *msg, int32_t msgSize) {
   int32_t       code = 0;
 
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    code = TSDB_CODE_TSC_INVALID_INPUT;
+    code = TSDB_CODE_INVALID_PTR;
     return code;
   }
 
@@ -497,7 +497,7 @@ int32_t queryProcessDnodeListRsp(void *output, char *msg, int32_t msgSize) {
   int32_t       code = 0;
 
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    code = TSDB_CODE_TSC_INVALID_INPUT;
+    code = TSDB_CODE_INVALID_PTR;
     return code;
   }
 
@@ -517,7 +517,7 @@ int32_t queryProcessGetSerVerRsp(void *output, char *msg, int32_t msgSize) {
   int32_t       code = 0;
 
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    code = TSDB_CODE_TSC_INVALID_INPUT;
+    code = TSDB_CODE_INVALID_PTR;
     return code;
   }
 
@@ -536,7 +536,7 @@ int32_t queryProcessGetDbCfgRsp(void *output, char *msg, int32_t msgSize) {
   SDbCfgRsp out = {0};
 
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   if (tDeserializeSDbCfgRsp(msg, msgSize, &out) != 0) {
@@ -553,7 +553,7 @@ int32_t queryProcessGetIndexRsp(void *output, char *msg, int32_t msgSize) {
   SUserIndexRsp out = {0};
 
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   if (tDeserializeSUserIndexRsp(msg, msgSize, &out) != 0) {
@@ -570,7 +570,7 @@ int32_t queryProcessRetrieveFuncRsp(void *output, char *msg, int32_t msgSize) {
   SRetrieveFuncRsp out = {0};
 
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   if (tDeserializeSRetrieveFuncRsp(msg, msgSize, &out) != 0) {
@@ -594,7 +594,7 @@ int32_t queryProcessRetrieveFuncRsp(void *output, char *msg, int32_t msgSize) {
 
 int32_t queryProcessGetUserAuthRsp(void *output, char *msg, int32_t msgSize) {
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   if (tDeserializeSGetUserAuthRsp(msg, msgSize, (SGetUserAuthRsp *)output) != 0) {
@@ -607,7 +607,7 @@ int32_t queryProcessGetUserAuthRsp(void *output, char *msg, int32_t msgSize) {
 
 int32_t queryProcessGetTbIndexRsp(void *output, char *msg, int32_t msgSize) {
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   STableIndexRsp *out = (STableIndexRsp *)output;
@@ -621,7 +621,7 @@ int32_t queryProcessGetTbIndexRsp(void *output, char *msg, int32_t msgSize) {
 
 int32_t queryProcessGetTbCfgRsp(void *output, char *msg, int32_t msgSize) {
   if (NULL == output || NULL == msg || msgSize <= 0) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   STableCfgRsp *out = taosMemoryCalloc(1, sizeof(STableCfgRsp));

source/libs/qworker/inc/qwInt.h

@@ -208,7 +208,7 @@ typedef struct SQWorkerMgmt {
   int32_t    paramIdx;
 } SQWorkerMgmt;
 
-#define QW_CTX_NOT_EXISTS_ERR_CODE(mgmt) (atomic_load_8(&(mgmt)->nodeStopped) ? TSDB_CODE_VND_STOPPED : TSDB_CODE_QRY_TASK_CTX_NOT_EXIST)
+#define QW_CTX_NOT_EXISTS_ERR_CODE(mgmt) (atomic_load_8(&(mgmt)->nodeStopped) ? TSDB_CODE_VND_STOPPED : TSDB_CODE_QRY_TASK_NOT_EXIST)
 
 #define QW_FPARAMS_DEF SQWorker *mgmt, uint64_t sId, uint64_t qId, uint64_t tId, int64_t rId, int32_t eId
 #define QW_IDS()       sId, qId, tId, rId, eId

source/libs/qworker/src/qwDbg.c

@@ -261,7 +261,7 @@ void qwDbgSimulateDead(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *rsped) {
   if (++ignoreTime > 10 && 0 == taosRand() % 9) {
     if (ctx->fetchMsgType == TDMT_SCH_FETCH) {
       qwBuildAndSendErrorRsp(TDMT_SCH_LINK_BROKEN, &ctx->ctrlConnInfo, TSDB_CODE_RPC_BROKEN_LINK);
-      qwBuildAndSendErrorRsp(ctx->fetchMsgType + 1, &ctx->dataConnInfo, TSDB_CODE_QRY_TASK_CTX_NOT_EXIST);
+      qwBuildAndSendErrorRsp(ctx->fetchMsgType + 1, &ctx->dataConnInfo, TSDB_CODE_QRY_TASK_NOT_EXIST);
       *rsped = true;
       
       taosSsleep(3);

source/libs/qworker/src/qwMsg.c

@@ -355,7 +355,7 @@ int32_t qwRegisterHbBrokenLinkArg(SQWorker *mgmt, uint64_t sId, SRpcHandleInfo *
 
 int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg, bool chkGrant) {
   if (NULL == qWorkerMgmt || NULL == pMsg) {
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_PTR);
   }
 
   int32_t       code = 0;
@@ -363,7 +363,7 @@ int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg, bool chkGran
   SSubQueryMsg  msg = {0};
   if (tDeserializeSSubQueryMsg(pMsg->pCont, pMsg->contLen, &msg) < 0) {
     QW_ELOG("tDeserializeSSubQueryMsg failed, contLen:%d", pMsg->contLen);
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_MSG);
   }
 
   if (chkGrant && (!TEST_SHOW_REWRITE_MASK(msg.msgMask)) && (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS)) {
@@ -392,14 +392,14 @@ int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg, bool chkGran
 
 int32_t qWorkerAbortPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg) {
   if (NULL == qWorkerMgmt || NULL == pMsg) {
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_PTR);
   }
 
   SQWorker     *mgmt = (SQWorker *)qWorkerMgmt;
   SSubQueryMsg msg = {0};
   if (tDeserializeSSubQueryMsg(pMsg->pCont, pMsg->contLen, &msg) < 0) {
     QW_ELOG("tDeserializeSSubQueryMsg failed, contLen:%d", pMsg->contLen);
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_MSG);
   }
 
   uint64_t sId = msg.sId;
@@ -419,7 +419,7 @@ int32_t qWorkerAbortPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg) {
 
 int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts) {
   if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) {
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_PTR);
   }
 
   int32_t       code = 0;
@@ -431,7 +431,7 @@ int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int
   SSubQueryMsg  msg = {0};
   if (tDeserializeSSubQueryMsg(pMsg->pCont, pMsg->contLen, &msg) < 0) {
     QW_ELOG("tDeserializeSSubQueryMsg failed, contLen:%d", pMsg->contLen);
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_MSG);
   }
 
   uint64_t sId = msg.sId;
@@ -470,7 +470,7 @@ int32_t qWorkerProcessCQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, in
 
   if (NULL == msg || pMsg->contLen < sizeof(*msg)) {
     QW_ELOG("invalid cquery msg, msg:%p, msgLen:%d", msg, pMsg->contLen);
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_MSG);
   }
 
   uint64_t sId = msg->sId;
@@ -492,7 +492,7 @@ int32_t qWorkerProcessCQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, in
 
 int32_t qWorkerProcessFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts) {
   if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) {
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   SResFetchReq req = {0};
@@ -503,7 +503,7 @@ int32_t qWorkerProcessFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int
 
   if (tDeserializeSResFetchReq(pMsg->pCont, pMsg->contLen, &req) < 0) {
     QW_ELOG("tDeserializeSResFetchReq %d failed", pMsg->contLen);
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_MSG);
   }
 
   uint64_t sId = req.sId;
@@ -580,7 +580,7 @@ _return:
 
 int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts) {
   if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) {
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   int32_t       code = 0;
@@ -592,7 +592,7 @@ int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int6
   STaskDropReq  msg = {0};
   if (tDeserializeSTaskDropReq(pMsg->pCont, pMsg->contLen, &msg) < 0) {
     QW_ELOG("tDeserializeSTaskDropReq failed, contLen:%d", pMsg->contLen);
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_MSG);
   }
 
   uint64_t sId = msg.sId;
@@ -618,7 +618,7 @@ int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int6
 
 int32_t qWorkerProcessHbMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts) {
   if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) {
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   int32_t         code = 0;
@@ -630,13 +630,13 @@ int32_t qWorkerProcessHbMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_
 
   if (NULL == pMsg->pCont) {
     QW_ELOG("invalid hb msg, msg:%p, msgLen:%d", pMsg->pCont, pMsg->contLen);
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_MSG);
   }
 
   if (tDeserializeSSchedulerHbReq(pMsg->pCont, pMsg->contLen, &req)) {
     QW_ELOG("invalid hb msg, msg:%p, msgLen:%d", pMsg->pCont, pMsg->contLen);
     tFreeSSchedulerHbReq(&req);
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_MSG);
   }
 
   uint64_t sId = req.sId;
@@ -656,7 +656,7 @@ int32_t qWorkerProcessHbMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_
 
 int32_t qWorkerProcessDeleteMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SDeleteRes *pRes) {
   if (NULL == node || NULL == qWorkerMgmt || NULL == pMsg) {
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_PTR);
   }
 
   int32_t     code = 0;

source/libs/qworker/src/qworker.c

@@ -318,7 +318,7 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen,
 
     if (len < 0) {
       QW_TASK_ELOG("invalid length from dsGetDataLength, length:%" PRId64 "", len);
-      QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+      QW_ERR_RET(TSDB_CODE_INVALID_VALUE);
     }
 
     if (len == 0) {
@@ -408,7 +408,7 @@ int32_t qwGetDeleteResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, SDeleteRes *pRes
 
   if (len <= 0 || len != sizeof(SDeleterRes)) {
     QW_TASK_ELOG("invalid length from dsGetDataLength, length:%" PRId64, len);
-    QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   output.pData = taosMemoryCalloc(1, len);
@@ -515,7 +515,7 @@ int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inpu
 
       if (QW_EVENT_RECEIVED(ctx, QW_EVENT_FETCH)) {
         QW_TASK_WLOG("last fetch still not processed, phase:%s", qwPhaseStr(phase));
-        QW_ERR_JRET(TSDB_CODE_QRY_DUPLICATTED_OPERATION);
+        QW_ERR_JRET(TSDB_CODE_QRY_TASK_MSG_ERROR);
       }
 
       if (ctx->rspCode) {
@@ -931,7 +931,7 @@ int32_t qwProcessDrop(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
 
   if (QW_EVENT_RECEIVED(ctx, QW_EVENT_DROP)) {
     QW_TASK_WLOG_E("task already dropping");
-    QW_ERR_JRET(TSDB_CODE_QRY_DUPLICATTED_OPERATION);
+    QW_ERR_JRET(TSDB_CODE_QRY_TASK_MSG_ERROR);
   }
 
   if (QW_QUERY_RUNNING(ctx)) {
@@ -1157,7 +1157,7 @@ _return:
 int32_t qWorkerInit(int8_t nodeType, int32_t nodeId, void **qWorkerMgmt, const SMsgCb *pMsgCb) {
   if (NULL == qWorkerMgmt || (pMsgCb && pMsgCb->mgmt == NULL)) {
     qError("invalid param to init qworker");
-    QW_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_RET(TSDB_CODE_INVALID_PTR);
   }
 
   int32_t qwNum = atomic_add_fetch_32(&gQwMgmt.qwNum, 1);
@@ -1279,7 +1279,7 @@ void qWorkerDestroy(void **qWorkerMgmt) {
 
 int32_t qWorkerGetStat(SReadHandle *handle, void *qWorkerMgmt, SQWorkerStat *pStat) {
   if (NULL == handle || NULL == qWorkerMgmt || NULL == pStat) {
-    QW_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    QW_RET(TSDB_CODE_INVALID_PTR);
   }
 
   SQWorker     *mgmt = (SQWorker *)qWorkerMgmt;

source/libs/scalar/src/filter.c

@@ -197,7 +197,7 @@ int8_t filterGetCompFuncIdx(int32_t type, int32_t optr) {
       case TSDB_DATA_TYPE_TIMESTAMP:
         return 18;
       case TSDB_DATA_TYPE_JSON:
-        terrno = TSDB_CODE_QRY_JSON_IN_ERROR;
+        terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
         return 0;
       default:
         return 0;
@@ -223,7 +223,7 @@ int8_t filterGetCompFuncIdx(int32_t type, int32_t optr) {
       case TSDB_DATA_TYPE_TIMESTAMP:
         return 24;
       case TSDB_DATA_TYPE_JSON:
-        terrno = TSDB_CODE_QRY_JSON_IN_ERROR;
+        terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
         return 0;
       default:
         return 0;
@@ -1517,7 +1517,7 @@ EDealRes fltTreeToGroup(SNode *pNode, void *pContext) {
 
   fltError("invalid node type for filter, type:%d", nodeType(pNode));
 
-  code = TSDB_CODE_QRY_INVALID_INPUT;
+  code = TSDB_CODE_INVALID_VALUE;
 
 _return:
 
@@ -1572,7 +1572,7 @@ int32_t fltConverToStr(char *str, int type, void *buf, int32_t bufSize, int32_t
     case TSDB_DATA_TYPE_GEOMETRY:
       if (bufSize < 0) {
         //        tscError("invalid buf size");
-        return TSDB_CODE_TSC_INVALID_VALUE;
+        return TSDB_CODE_INVALID_VALUE;
       }
 
       *str = '"';
@@ -1599,7 +1599,7 @@ int32_t fltConverToStr(char *str, int type, void *buf, int32_t bufSize, int32_t
 
     default:
       //      tscError("unsupported type:%d", type);
-      return TSDB_CODE_TSC_INVALID_VALUE;
+      return TSDB_CODE_INVALID_VALUE;
   }
 
   *len = n;
@@ -1973,7 +1973,7 @@ int32_t fltInitValFieldData(SFilterInfo *info) {
       int32_t code = sclConvertValueToSclParam(var, &out, NULL);
       if (code != TSDB_CODE_SUCCESS) {
         qError("convert value to type[%d] failed", type);
-        return TSDB_CODE_TSC_INVALID_OPERATION;
+        return code;
       }
 
       memcpy(fi->data, out.columnData->pData, out.columnData->info.bytes);
@@ -3715,7 +3715,7 @@ EDealRes fltReviseRewriter(SNode **pNode, void *pContext) {
     for (int32_t i = 0; i < node->pParameterList->length; ++i) {
       if (NULL == cell || NULL == cell->pNode) {
         fltError("invalid cell");
-        stat->code = TSDB_CODE_QRY_INVALID_INPUT;
+        stat->code = TSDB_CODE_INVALID_VALUE;
         return DEAL_RES_ERROR;
       }
 
@@ -3920,7 +3920,7 @@ EDealRes fltReviseRewriter(SNode **pNode, void *pContext) {
 
   fltError("invalid node type for filter, type:%d", nodeType(*pNode));
 
-  stat->code = TSDB_CODE_QRY_INVALID_INPUT;
+  stat->code = TSDB_CODE_INVALID_VALUE;
 
   return DEAL_RES_ERROR;
 }
@@ -3983,7 +3983,7 @@ int32_t fltGetDataFromSlotId(void *param, int32_t id, void **data) {
 
 int32_t filterSetDataFromSlotId(SFilterInfo *info, void *param) {
   if (NULL == info) {
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_PTR;
   }
 
   return fltSetColFieldDataImpl(info, param, fltGetDataFromSlotId, false);

source/libs/scalar/src/scalar.c

@@ -332,7 +332,7 @@ int32_t sclInitParam(SNode *node, SScalarParam *param, SScalarCtx *ctx, int32_t
 
       if (param->columnData != NULL) {
         sclError("columnData should be NULL");
-        SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+        SCL_ERR_RET(TSDB_CODE_INVALID_VALUE);
       }
       param->numOfRows = 1;
       int32_t code = sclCreateColumnInfoData(&valueNode->node.resType, 1, param);
@@ -350,7 +350,7 @@ int32_t sclInitParam(SNode *node, SScalarParam *param, SScalarCtx *ctx, int32_t
       SNodeListNode *nodeList = (SNodeListNode *)node;
       if (LIST_LENGTH(nodeList->pNodeList) <= 0) {
         sclError("invalid length in nodeList, length:%d", LIST_LENGTH(nodeList->pNodeList));
-        SCL_RET(TSDB_CODE_QRY_INVALID_INPUT);
+        SCL_RET(TSDB_CODE_INVALID_VALUE);
       }
 
       int32_t type = vectorGetConvertType(ctx->type.selfType, ctx->type.peerType);
@@ -390,18 +390,18 @@ int32_t sclInitParam(SNode *node, SScalarParam *param, SScalarCtx *ctx, int32_t
       if (index == -1) {
         sclError("column tupleId is too big, tupleId:%d, dataBlockNum:%d", ref->dataBlockId,
                  (int32_t)taosArrayGetSize(ctx->pBlockList));
-        SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+        SCL_ERR_RET(TSDB_CODE_INVALID_VALUE);
       }
 
       SSDataBlock *block = *(SSDataBlock **)taosArrayGet(ctx->pBlockList, index);
       if (NULL == block) {
-        SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+        SCL_ERR_RET(TSDB_CODE_INVALID_VALUE);
       }
 
       if (ref->slotId >= taosArrayGetSize(block->pDataBlock)) {
         sclError("column slotId is too big, slodId:%d, dataBlockSize:%d", ref->slotId,
                  (int32_t)taosArrayGetSize(block->pDataBlock));
-        SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+        SCL_ERR_RET(TSDB_CODE_INVALID_VALUE);
       }
 
       SColumnInfoData *columnData = (SColumnInfoData *)taosArrayGet(block->pDataBlock, ref->slotId);
@@ -433,7 +433,7 @@ int32_t sclInitParam(SNode *node, SScalarParam *param, SScalarCtx *ctx, int32_t
   if (param->numOfRows > *rowNum) {
     if ((1 != param->numOfRows) && (1 < *rowNum)) {
       sclError("different row nums, rowNum:%d, newRowNum:%d", *rowNum, param->numOfRows);
-      SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+      SCL_ERR_RET(TSDB_CODE_INVALID_VALUE);
     }
 
     *rowNum = param->numOfRows;
@@ -545,7 +545,7 @@ int32_t sclInitOperatorParams(SScalarParam **pParams, SOperatorNode *node, SScal
   int32_t paramNum = scalarGetOperatorParamNum(node->opType);
   if (NULL == node->pLeft || (paramNum == 2 && NULL == node->pRight)) {
     sclError("invalid operation node, left:%p, right:%p", node->pLeft, node->pRight);
-    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    SCL_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   SScalarParam *paramList = taosMemoryCalloc(paramNum, sizeof(SScalarParam));
@@ -764,17 +764,17 @@ int32_t sclExecLogic(SLogicConditionNode *node, SScalarCtx *ctx, SScalarParam *o
   if (NULL == node->pParameterList || node->pParameterList->length <= 0) {
     sclError("invalid logic parameter list, list:%p, paramNum:%d", node->pParameterList,
              node->pParameterList ? node->pParameterList->length : 0);
-    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    SCL_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   if (TSDB_DATA_TYPE_BOOL != node->node.resType.type) {
     sclError("invalid logic resType, type:%d", node->node.resType.type);
-    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    SCL_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   if (LOGIC_COND_TYPE_NOT == node->condType && node->pParameterList->length > 1) {
     sclError("invalid NOT operation parameter number, paramNum:%d", node->pParameterList->length);
-    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    SCL_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   SScalarParam *params = NULL;
@@ -851,7 +851,7 @@ int32_t sclExecOperator(SOperatorNode *node, SScalarCtx *ctx, SScalarParam *outp
     SValueNode *valueNode = (SValueNode *)node->pLeft;
     if (valueNode->node.resType.type == TSDB_DATA_TYPE_JSON &&
         (node->opType == OP_TYPE_IN || node->opType == OP_TYPE_NOT_IN)) {
-      SCL_RET(TSDB_CODE_QRY_JSON_IN_ERROR);
+      SCL_RET(TSDB_CODE_QRY_JSON_USAGE_ERROR);
     }
   }
 
@@ -1455,7 +1455,7 @@ EDealRes sclWalkTarget(SNode *pNode, SScalarCtx *ctx) {
   if (target->dataBlockId >= taosArrayGetSize(ctx->pBlockList)) {
     sclError("target tupleId is too big, tupleId:%d, dataBlockNum:%d", target->dataBlockId,
              (int32_t)taosArrayGetSize(ctx->pBlockList));
-    ctx->code = TSDB_CODE_QRY_INVALID_INPUT;
+    ctx->code = TSDB_CODE_INVALID_VALUE;
     return DEAL_RES_ERROR;
   }
 
@@ -1471,7 +1471,7 @@ EDealRes sclWalkTarget(SNode *pNode, SScalarCtx *ctx) {
   if (index == -1) {
     sclError("column tupleId is too big, tupleId:%d, dataBlockNum:%d", target->dataBlockId,
              (int32_t)taosArrayGetSize(ctx->pBlockList));
-    ctx->code = TSDB_CODE_QRY_INVALID_INPUT;
+    ctx->code = TSDB_CODE_INVALID_VALUE;
     return DEAL_RES_ERROR;
   }
 
@@ -1480,7 +1480,7 @@ EDealRes sclWalkTarget(SNode *pNode, SScalarCtx *ctx) {
   if (target->slotId >= taosArrayGetSize(block->pDataBlock)) {
     sclError("target slot not exist, dataBlockId:%d, slotId:%d, dataBlockNum:%d", target->dataBlockId, target->slotId,
              (int32_t)taosArrayGetSize(block->pDataBlock));
-    ctx->code = TSDB_CODE_QRY_INVALID_INPUT;
+    ctx->code = TSDB_CODE_INVALID_VALUE;
     return DEAL_RES_ERROR;
   }
 
@@ -1548,13 +1548,13 @@ EDealRes sclCalcWalker(SNode *pNode, void *pContext) {
   }
 
   sclError("invalid node type for scalar calculating, type:%d", nodeType(pNode));
-  ctx->code = TSDB_CODE_QRY_INVALID_INPUT;
+  ctx->code = TSDB_CODE_INVALID_VALUE;
   return DEAL_RES_ERROR;
 }
 
 int32_t sclCalcConstants(SNode *pNode, bool dual, SNode **pRes) {
   if (NULL == pNode) {
-    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    SCL_ERR_RET(TSDB_CODE_INVALID_PTR);
   }
 
   int32_t    code = 0;
@@ -1578,7 +1578,7 @@ _return:
 
 static int32_t sclGetMinusOperatorResType(SOperatorNode *pOp) {
   if (!IS_MATHABLE_TYPE(((SExprNode *)(pOp->pLeft))->resType.type)) {
-    return TSDB_CODE_TSC_INVALID_OPERATION;
+    return TSDB_CODE_INVALID_OPERATION;
   }
   pOp->node.resType.type = TSDB_DATA_TYPE_DOUBLE;
   pOp->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes;
@@ -1587,7 +1587,7 @@ static int32_t sclGetMinusOperatorResType(SOperatorNode *pOp) {
 
 static int32_t sclGetMathOperatorResType(SOperatorNode *pOp) {
   if (pOp == NULL || pOp->pLeft == NULL || pOp->pRight == NULL) {
-    return TSDB_CODE_TSC_INVALID_OPERATION;
+    return TSDB_CODE_INVALID_OPERATION;
   }
 
   SDataType ldt = ((SExprNode *)(pOp->pLeft))->resType;
@@ -1596,7 +1596,7 @@ static int32_t sclGetMathOperatorResType(SOperatorNode *pOp) {
   if ((TSDB_DATA_TYPE_TIMESTAMP == ldt.type && TSDB_DATA_TYPE_TIMESTAMP == rdt.type) ||
       (TSDB_DATA_TYPE_TIMESTAMP == ldt.type && (IS_VAR_DATA_TYPE(rdt.type) || IS_FLOAT_TYPE(rdt.type))) ||
       (TSDB_DATA_TYPE_TIMESTAMP == rdt.type && (IS_VAR_DATA_TYPE(ldt.type) || IS_FLOAT_TYPE(ldt.type)))) {
-    return TSDB_CODE_TSC_INVALID_OPERATION;
+    return TSDB_CODE_INVALID_OPERATION;
   }
 
   if ((TSDB_DATA_TYPE_TIMESTAMP == ldt.type && IS_INTEGER_TYPE(rdt.type)) ||
@@ -1614,24 +1614,24 @@ static int32_t sclGetMathOperatorResType(SOperatorNode *pOp) {
 
 static int32_t sclGetCompOperatorResType(SOperatorNode *pOp) {
   if (pOp == NULL || pOp->pLeft == NULL) {
-    return TSDB_CODE_TSC_INVALID_OPERATION;
+    return TSDB_CODE_INVALID_OPERATION;
   }
 
   SDataType ldt = ((SExprNode *)(pOp->pLeft))->resType;
 
   if (OP_TYPE_IN == pOp->opType || OP_TYPE_NOT_IN == pOp->opType) {
     if (pOp->pRight == NULL) {
-      return TSDB_CODE_TSC_INVALID_OPERATION;
+      return TSDB_CODE_INVALID_OPERATION;
     }
     ((SExprNode *)(pOp->pRight))->resType = ldt;
   } else if (nodesIsRegularOp(pOp)) {
     if (pOp->pRight == NULL) {
-      return TSDB_CODE_TSC_INVALID_OPERATION;
+      return TSDB_CODE_INVALID_OPERATION;
     }
     SDataType rdt = ((SExprNode *)(pOp->pRight))->resType;
     if (!IS_VAR_DATA_TYPE(ldt.type) || QUERY_NODE_VALUE != nodeType(pOp->pRight) ||
         (!IS_STR_DATA_TYPE(rdt.type) && (rdt.type != TSDB_DATA_TYPE_NULL))) {
-      return TSDB_CODE_TSC_INVALID_OPERATION;
+      return TSDB_CODE_INVALID_OPERATION;
     }
   }
   pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
@@ -1641,14 +1641,14 @@ static int32_t sclGetCompOperatorResType(SOperatorNode *pOp) {
 
 static int32_t sclGetJsonOperatorResType(SOperatorNode *pOp) {
   if (pOp == NULL || pOp->pLeft == NULL || pOp->pRight == NULL) {
-    return TSDB_CODE_TSC_INVALID_OPERATION;
+    return TSDB_CODE_INVALID_OPERATION;
   }
 
   SDataType ldt = ((SExprNode *)(pOp->pLeft))->resType;
   SDataType rdt = ((SExprNode *)(pOp->pRight))->resType;
 
   if (TSDB_DATA_TYPE_JSON != ldt.type || !IS_STR_DATA_TYPE(rdt.type)) {
-    return TSDB_CODE_TSC_INVALID_OPERATION;
+    return TSDB_CODE_INVALID_OPERATION;
   }
   if (pOp->opType == OP_TYPE_JSON_GET_VALUE) {
     pOp->node.resType.type = TSDB_DATA_TYPE_JSON;
@@ -1671,7 +1671,7 @@ int32_t scalarCalculateConstantsFromDual(SNode *pNode, SNode **pRes) { return sc
 
 int32_t scalarCalculate(SNode *pNode, SArray *pBlockList, SScalarParam *pDst) {
   if (NULL == pNode || NULL == pBlockList) {
-    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    SCL_ERR_RET(TSDB_CODE_INVALID_PTR);
   }
 
   int32_t    code = 0;
@@ -1715,7 +1715,7 @@ _return:
 int32_t scalarGetOperatorResultType(SOperatorNode *pOp) {
   if (TSDB_DATA_TYPE_BLOB == ((SExprNode *)(pOp->pLeft))->resType.type ||
       (NULL != pOp->pRight && TSDB_DATA_TYPE_BLOB == ((SExprNode *)(pOp->pRight))->resType.type)) {
-    return TSDB_CODE_TSC_INVALID_OPERATION;
+    return TSDB_CODE_INVALID_OPERATION;
   }
 
   switch (pOp->opType) {

source/libs/scalar/src/sclvector.c

@@ -145,7 +145,7 @@ int64_t getVectorBigintValue_JSON(void *src, int32_t index) {
   } else if (*data == TSDB_DATA_TYPE_NCHAR) {  // json inner type can not be BINARY
     convertNcharToDouble(data + CHAR_BYTES, &out);
   } else if (tTagIsJson(data)) {
-    terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR;
+    terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
     return 0;
   } else {
     convertNumberToNumber(data + CHAR_BYTES, &out, *data, TSDB_DATA_TYPE_DOUBLE);
@@ -422,7 +422,7 @@ int32_t vectorConvertFromVarData(SSclVectorConvCtx *pCtx, int32_t *overflow) {
         data += CHAR_BYTES;
         convertType = TSDB_DATA_TYPE_NCHAR;
       } else if (tTagIsJson(data) || *data == TSDB_DATA_TYPE_NULL) {
-        terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR;
+        terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
         return terrno;
       } else {
         convertNumberToNumber(data + CHAR_BYTES, colDataGetNumData(pCtx->pOut->columnData, i), *data, pCtx->outType);
@@ -481,7 +481,7 @@ double getVectorDoubleValue_JSON(void *src, int32_t index) {
   } else if (*data == TSDB_DATA_TYPE_NCHAR) {  // json inner type can not be BINARY
     convertNcharToDouble(data + CHAR_BYTES, &out);
   } else if (tTagIsJson(data)) {
-    terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR;
+    terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
     return 0;
   } else {
     convertNumberToNumber(data + CHAR_BYTES, &out, *data, TSDB_DATA_TYPE_DOUBLE);
@@ -517,7 +517,7 @@ bool convertJsonValue(__compar_fn_t *fp, int32_t optr, int8_t typeLeft, int8_t t
 
   if (typeLeft == TSDB_DATA_TYPE_JSON) {
     if (tTagIsJson(*pLeftData)) {
-      terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR;
+      terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
       return false;
     }
     typeLeft = **pLeftData;
@@ -525,7 +525,7 @@ bool convertJsonValue(__compar_fn_t *fp, int32_t optr, int8_t typeLeft, int8_t t
   }
   if (typeRight == TSDB_DATA_TYPE_JSON) {
     if (tTagIsJson(*pRightData)) {
-      terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR;
+      terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
       return false;
     }
     typeRight = **pRightData;
@@ -1819,7 +1819,7 @@ void vectorIsTrue(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut,
 STagVal getJsonValue(char *json, char *key, bool *isExist) {
   STagVal val = {.pKey = key};
   if (json == NULL || tTagIsJson((const STag *)json) == false) {
-    terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR;
+    terrno = TSDB_CODE_QRY_JSON_USAGE_ERROR;
     if (isExist) {
       *isExist = false;
     }

source/libs/scheduler/src/schJob.c

@@ -134,7 +134,7 @@ int32_t schUpdateJobStatus(SSchJob *pJob, int8_t newStatus) {
 
         break;
       case JOB_TASK_STATUS_DROP:
-        SCH_ERR_JRET(TSDB_CODE_QRY_JOB_FREED);
+        SCH_ERR_JRET(TSDB_CODE_SCH_STATUS_ERROR);
 
       default:
         SCH_JOB_ELOG("invalid job status:%s", jobTaskStatusStr(oriStatus));
@@ -271,7 +271,7 @@ int32_t schValidateAndBuildJob(SQueryPlan *pDag, SSchJob *pJob) {
 
   if (pDag->numOfSubplans <= 0) {
     SCH_JOB_ELOG("invalid subplan num:%d", pDag->numOfSubplans);
-    SCH_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    SCH_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   pJob->dataSrcTasks = taosArrayInit(pDag->numOfSubplans, POINTER_BYTES);
@@ -282,7 +282,7 @@ int32_t schValidateAndBuildJob(SQueryPlan *pDag, SSchJob *pJob) {
   int32_t levelNum = (int32_t)LIST_LENGTH(pDag->pSubplans);
   if (levelNum <= 0) {
     SCH_JOB_ELOG("invalid level num:%d", levelNum);
-    SCH_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    SCH_ERR_RET(TSDB_CODE_INVALID_VALUE);
   }
 
   SHashObj *planToTask = taosHashInit(
@@ -322,13 +322,13 @@ int32_t schValidateAndBuildJob(SQueryPlan *pDag, SSchJob *pJob) {
     plans = (SNodeListNode *)nodesListGetNode(pDag->pSubplans, i);
     if (NULL == plans) {
       SCH_JOB_ELOG("empty level plan, level:%d", i);
-      SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+      SCH_ERR_JRET(TSDB_CODE_INVALID_VALUE);
     }
 
     taskNum = (int32_t)LIST_LENGTH(plans->pNodeList);
     if (taskNum <= 0) {
       SCH_JOB_ELOG("invalid level plan number:%d, level:%d", taskNum, i);
-      SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+      SCH_ERR_JRET(TSDB_CODE_INVALID_VALUE);
     }
 
     pLevel->taskNum = taskNum;

source/libs/scheduler/src/schRemote.c

@@ -79,7 +79,7 @@ int32_t schProcessFetchRsp(SSchJob *pJob, SSchTask *pTask, char *msg, int32_t rs
   SCH_ERR_JRET(rspCode);
   
   if (NULL == msg) {
-    SCH_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
+    SCH_ERR_RET(TSDB_CODE_INVALID_PTR);
   }
   
   if (SCH_IS_EXPLAIN_JOB(pJob)) {
@@ -235,7 +235,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD
       SCH_ERR_JRET(rspCode);
 
       if (NULL == msg) {
-        SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+        SCH_ERR_JRET(TSDB_CODE_INVALID_PTR);
       }
 
       taosMemoryFreeClear(msg);
@@ -325,7 +325,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD
     case TDMT_SCH_MERGE_QUERY_RSP: {
       SCH_ERR_JRET(rspCode);
       if (NULL == msg) {
-        SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+        SCH_ERR_JRET(TSDB_CODE_INVALID_PTR);
       }
 
       if (taosArrayGetSize(pTask->parents) == 0 && SCH_IS_EXPLAIN_JOB(pJob) && SCH_IS_INSERT_JOB(pJob)) {
@@ -339,7 +339,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD
       SQueryTableRsp rsp = {0};
       if (tDeserializeSQueryTableRsp(msg, msgSize, &rsp) < 0) {
         SCH_TASK_ELOG("tDeserializeSQueryTableRsp failed, msgSize:%d", msgSize);
-        SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_MSG);
+        SCH_ERR_JRET(TSDB_CODE_INVALID_MSG);
       }
       
       SCH_ERR_JRET(rsp.code);
@@ -357,12 +357,12 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD
     case TDMT_SCH_EXPLAIN_RSP: {
       SCH_ERR_JRET(rspCode);
       if (NULL == msg) {
-        SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+        SCH_ERR_JRET(TSDB_CODE_INVALID_PTR);
       }
 
       if (!SCH_IS_EXPLAIN_JOB(pJob)) {
         SCH_TASK_ELOG("invalid msg received for none explain query, msg type:%s", TMSG_INFO(msgType));
-        SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+        SCH_ERR_JRET(TSDB_CODE_INVALID_MSG);
       }
 
       if (pJob->fetchRes) {
@@ -399,7 +399,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD
       break;
     default:
       SCH_TASK_ELOG("unknown rsp msg, type:%d, status:%s", msgType, SCH_GET_TASK_STATUS_STR(pTask));
-      SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+      SCH_ERR_JRET(TSDB_CODE_INVALID_MSG);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -517,7 +517,7 @@ int32_t schHandleHbCallback(void *param, SDataBuf *pMsg, int32_t code) {
 
   if (tDeserializeSSchedulerHbRsp(pMsg->pData, pMsg->len, &rsp)) {
     qError("invalid hb rsp msg, size:%d", pMsg->len);
-    SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT);
+    SCH_ERR_JRET(TSDB_CODE_INVALID_MSG);
   }
 
   SSchTrans trans = {0};

source/libs/scheduler/src/scheduler.c

@@ -27,7 +27,7 @@ SSchedulerMgmt schMgmt = {
 int32_t schedulerInit() {
   if (schMgmt.jobRef >= 0) {
     qError("scheduler already initialized");
-    return TSDB_CODE_QRY_INVALID_INPUT;
+    return TSDB_CODE_INVALID_OPERATION;
   }
 
   schMgmt.cfg.maxJobNum = SCHEDULE_DEFAULT_MAX_JOB_NUM;
@@ -141,7 +141,7 @@ int32_t schedulerUpdatePolicy(int32_t policy) {
       qDebug("schedule policy updated to %d", schMgmt.cfg.schPolicy);
       break;
     default:
-      return TSDB_CODE_TSC_INVALID_INPUT;
+      return TSDB_CODE_INVALID_CFG;
   }
 
   return TSDB_CODE_SUCCESS;

source/libs/sync/src/syncUtil.c

@@ -44,7 +44,7 @@ bool syncUtilNodeInfo2RaftId(const SNodeInfo* pInfo, SyncGroupId vgId, SRaftId*
   uint32_t ipv4 = taosGetIpv4FromFqdn(pInfo->nodeFqdn);
   if (ipv4 == 0xFFFFFFFF || ipv4 == 1) {
     sError("failed to resolve ipv4 addr, fqdn:%s", pInfo->nodeFqdn);
-    terrno = TSDB_CODE_TSC_INVALID_FQDN;
+    terrno = TSDB_CODE_INVALID_FQDN;
     return false;
   }
 

source/libs/sync/test/sync_test_lib/src/syncIO.c

@@ -528,7 +528,7 @@ uint64_t syncUtilAddr2U64(const char* host, uint16_t port) {
   uint32_t hostU32 = taosGetIpv4FromFqdn(host);
   if (hostU32 == (uint32_t)-1) {
     sError("failed to resolve ipv4 addr, host:%s", host);
-    terrno = TSDB_CODE_TSC_INVALID_FQDN;
+    terrno = TSDB_CODE_INVALID_FQDN;
     return -1;
   }
 

source/util/src/terror.c

@@ -90,61 +90,39 @@ TAOS_DEFINE_ERROR(TSDB_CODE_NEED_RETRY,                   "Retry needed")
 TAOS_DEFINE_ERROR(TSDB_CODE_OUT_OF_RPC_MEMORY_QUEUE,      "Out of memory in rpc queue")
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TIMESTAMP,            "Invalid timestamp format")
 TAOS_DEFINE_ERROR(TSDB_CODE_MSG_DECODE_ERROR,             "Msg decode error")
-TAOS_DEFINE_ERROR(TSDB_CODE_MSG_ENCODE_ERROR,             "Msg encode error")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_AVAIL_DISK,                "No available disk")
 TAOS_DEFINE_ERROR(TSDB_CODE_NOT_FOUND,                    "Not found")
 TAOS_DEFINE_ERROR(TSDB_CODE_NO_DISKSPACE,                 "Out of disk space")
 TAOS_DEFINE_ERROR(TSDB_CODE_TIMEOUT_ERROR,                "Operation timeout")
-TAOS_DEFINE_ERROR(TSDB_CODE_NO_ENOUGH_DISKSPACE,          "No enough disk space")
 
 TAOS_DEFINE_ERROR(TSDB_CODE_APP_IS_STARTING,              "Database is starting up")
 TAOS_DEFINE_ERROR(TSDB_CODE_APP_IS_STOPPING,              "Database is closing down")
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_DATA_FMT,             "Invalid data format")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CFG_VALUE,            "Invalid configuration value")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_OPERATION,            "Invalid operation")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VALUE,                "Invalid value")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_FQDN,                 "Invalid fqdn")
 
 //client
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_OPERATION,        "Invalid operation")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_QHANDLE,          "Invalid qhandle")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TIME_STAMP,       "Invalid combination of client/service time")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_VALUE,            "Invalid value in client")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_VERSION,          "Invalid client version")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_IE,               "Invalid client ie")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_FQDN,             "Invalid host name")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_USER_LENGTH,      "Invalid user name")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_PASS_LENGTH,      "Invalid password")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_DB_LENGTH,        "Database name too long")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH,  "Table name too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_CONNECTION,       "Invalid connection")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_QUERY_CACHE_ERASED,       "Query cache erased")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_QUERY_CANCELLED,          "Query terminated")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_SORTED_RES_TOO_MANY,      "Result set too large to be sorted")      // too many result for ordered super table projection query
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_ACTION_IN_PROGRESS,       "Action in progress")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DISCONNECTED,             "Disconnected from service")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NO_WRITE_AUTH,            "No write permission")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_CONN_KILLED,              "Connection killed")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DISCONNECTED,             "Disconnected from server")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_SQL_SYNTAX_ERROR,         "Syntax error in SQL")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DB_NOT_SELECTED,          "Database not specified or available")
 //TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TABLE_NAME,       "Table does not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_EXCEED_SQL_LIMIT,         "SQL statement too long")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_FILE_EMPTY,               "File is empty")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_LINE_SYNTAX_ERROR,        "Syntax error in Line")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NO_META_CACHED,           "No table meta cached")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DUP_COL_NAMES,            "duplicated column names")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TAG_LENGTH,       "Invalid tag length")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_COLUMN_LENGTH,    "Invalid column length")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DUP_NAMES,                "duplicated names")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_JSON,             "Invalid JSON format")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_JSON_TYPE,        "Invalid JSON data type")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_VALUE_OUT_OF_RANGE,       "Value out of range")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_INPUT,            "Invalid tsc input")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_STMT_API_ERROR,           "Stmt API usage error")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_STMT_TBNAME_ERROR,        "Stmt table name not set")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_STMT_CLAUSE_ERROR,        "not supported stmt clause")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_QUERY_KILLED,             "Query killed")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NO_EXEC_NODE,             "No available execution node in current query policy configuration")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NO_EXEC_NODE,             "No available execution node")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NOT_STABLE_ERROR,         "Table is not a super table")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_STMT_CACHE_ERROR,         "Stmt cache error")
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INTERNAL_ERROR,           "Internal error")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INTERNAL_ERROR,           "Tsc internal error")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_STMT_APP_ERROR,           "Stmt application error")
 
 // mnode-common
@@ -376,36 +354,18 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TDB_TDB_ENV_OPEN_ERROR,       "TDB env open error")
 TAOS_DEFINE_ERROR(TSDB_CODE_TDB_TABLE_IN_OTHER_STABLE,    "Table already exists in other stables")
 
 // query
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_QHANDLE,          "Invalid handle")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_MSG,              "Invalid message")    // failed to validate the sql expression msg by vnode
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_DUP_JOIN_KEY,             "Duplicated join key")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_EXCEED_TAGS_LIMIT,        "Tag conditon too many")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_NOT_READY,                "Query not ready")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_HAS_RSP,                  "Query should response")
+TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_QHANDLE,          "Invalid query handle")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_IN_EXEC,                  "Multiple retrieval of this query")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TOO_MANY_TIMEWINDOW,      "Too many time window in query")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_NOT_ENOUGH_BUFFER,        "Query buffer limit has reached")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INCONSISTAN,              "File inconsistance in replica")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_SYS_ERROR,                "System error")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_TIME_CONDITION,   "One valid time range condition expected")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_INPUT,            "invalid input")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_SCH_NOT_EXIST,            "Scheduler not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_NOT_EXIST,           "Task not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_ALREADY_EXIST,       "Task already exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_CTX_NOT_EXIST,       "Task context not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_CANCELLED,           "Task cancelled")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_DROPPED,             "Task dropped")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_CANCELLING,          "Task cancelling")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_DROPPING,            "Task dropping")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_DUPLICATTED_OPERATION,    "Duplicatted operation")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_MSG_ERROR,           "Task message error")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JOB_FREED,                "Job already freed")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_TASK_STATUS_ERROR,        "Task status error")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JSON_IN_ERROR,            "Json not support in in/notin operator")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR,   "Json not support in this place")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JSON_IN_GROUP_ERROR,      "Json not support in group/partition by")
+TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JSON_USAGE_ERROR,         "Not supported Json usage")
 TAOS_DEFINE_ERROR(TSDB_CODE_QRY_JOB_NOT_EXIST,            "Job not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_QRY_QWORKER_QUIT,             "Vnode/Qnode is quitting")
 
 // grant
 TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_EXPIRED,                "License expired")
@@ -467,17 +427,15 @@ TAOS_DEFINE_ERROR(TSDB_CODE_FS_NO_VALID_DISK,             "tfs no valid disk")
 
 // catalog
 TAOS_DEFINE_ERROR(TSDB_CODE_CTG_INTERNAL_ERROR,           "catalog internal error")
-TAOS_DEFINE_ERROR(TSDB_CODE_CTG_INVALID_INPUT,            "invalid catalog input parameters")
+TAOS_DEFINE_ERROR(TSDB_CODE_CTG_INVALID_INPUT,            "catalog invalid input parameters")
 TAOS_DEFINE_ERROR(TSDB_CODE_CTG_NOT_READY,                "catalog is not ready")
 TAOS_DEFINE_ERROR(TSDB_CODE_CTG_SYS_ERROR,                "catalog system error")
 TAOS_DEFINE_ERROR(TSDB_CODE_CTG_DB_DROPPED,               "Database is dropped")
 TAOS_DEFINE_ERROR(TSDB_CODE_CTG_OUT_OF_SERVICE,           "catalog is out of service")
-TAOS_DEFINE_ERROR(TSDB_CODE_CTG_VG_META_MISMATCH,         "table meta and vgroup mismatch")
-TAOS_DEFINE_ERROR(TSDB_CODE_CTG_EXIT,                     "catalog exit")
 
 //scheduler
 TAOS_DEFINE_ERROR(TSDB_CODE_QW_MSG_ERROR,                 "Invalid msg order")
-TAOS_DEFINE_ERROR(TSDB_CODE_SCH_STATUS_ERROR,             "scheduler status error")
+TAOS_DEFINE_ERROR(TSDB_CODE_SCH_STATUS_ERROR,             "Job status error")
 TAOS_DEFINE_ERROR(TSDB_CODE_SCH_INTERNAL_ERROR,           "scheduler internal error")
 TAOS_DEFINE_ERROR(TSDB_CODE_SCH_TIMEOUT_ERROR,            "Task timeout")
 TAOS_DEFINE_ERROR(TSDB_CODE_SCH_JOB_IS_DROPPING,          "Job is dropping")
@@ -498,7 +456,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_SELECTED_EXPRESSION,   "Not SELECTed express
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_SINGLE_GROUP,          "Not a single-group group function")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_TAGS_NOT_MATCHED,          "Tags number not matched")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_TAG_NAME,          "Invalid tag name")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG,   "Name or password too long")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_VALUE_TOO_LONG,            "Value is too long")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_PASSWD_EMPTY,              "Password can not be empty")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_PORT,              "Port should be an integer that is less than 65535 and greater than 0")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_ENDPOINT,          "Endpoint should be in the format of 'fqdn:port'")
@@ -549,12 +507,10 @@ TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_MODIFY_COL,         "Only binary/nchar c
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_TBNAME,             "Invalid tbname pseudo column")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_FUNCTION_NAME,      "Invalid function name")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_COMMENT_TOO_LONG,           "Comment too long")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_ALLOWED_FUNC,           "Some functions are allowed only in the SELECT list of a query. "
-                                                            "And, cannot be mixed with other non scalar functions or columns.")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY,      "Window query not supported, since the result of subquery not include valid timestamp column")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_ALLOWED_FUNC,           "Function(s) only allowed in SELECT list, cannot mixed with non scalar functions or columns")
+TAOS_DEFINE_ERROR(TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY,      "Window query not supported, since no valid timestamp column included in the result of subquery")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_DROP_COL,           "No columns can be dropped")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_COL_JSON,           "Only tag can be json type")
-TAOS_DEFINE_ERROR(TSDB_CODE_PAR_VALUE_TOO_LONG,             "Value too long for column/tag")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_DELETE_WHERE,       "The DELETE statement must have a definite time window range")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_INVALID_REDISTRIBUTE_VG,    "The REDISTRIBUTE VGROUP statement only support 1 to 3 dnodes")
 TAOS_DEFINE_ERROR(TSDB_CODE_PAR_FILL_NOT_ALLOWED_FUNC,      "Fill now allowed")