From 7e2abf0e08d158f716f8d9d8628c0e0cc0142093 Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Sat, 6 Jun 2020 06:30:50 +0000 Subject: [PATCH] [TD-527] Group error codes by module --- src/client/src/TSDBJNIConnector.c | 2 +- src/client/src/tscAsync.c | 34 +-- src/client/src/tscFunctionImpl.c | 4 +- src/client/src/tscLocal.c | 8 +- src/client/src/tscParseInsert.c | 40 ++-- src/client/src/tscPrepare.c | 40 ++-- src/client/src/tscSQLParser.c | 212 +++++++++---------- src/client/src/tscSecondaryMerge.c | 22 +- src/client/src/tscServer.c | 102 ++++----- src/client/src/tscSql.c | 56 ++--- src/client/src/tscStream.c | 12 +- src/client/src/tscSub.c | 6 +- src/client/src/tscSubquery.c | 38 ++-- src/client/src/tscUtil.c | 50 ++--- src/common/src/tglobal.c | 2 +- src/dnode/src/dnodeMPeer.c | 4 +- src/dnode/src/dnodeMRead.c | 6 +- src/dnode/src/dnodeMWrite.c | 6 +- src/dnode/src/dnodeMgmt.c | 6 +- src/dnode/src/dnodePeer.c | 6 +- src/dnode/src/dnodeShell.c | 6 +- src/dnode/src/dnodeVRead.c | 6 +- src/dnode/src/dnodeVWrite.c | 2 +- src/inc/taoserror.h | 293 ++++++++++++++------------ src/kit/shell/src/shellEngine.c | 2 +- src/mnode/src/mnodeAcct.c | 2 +- src/mnode/src/mnodeBalance.c | 2 +- src/mnode/src/mnodeDb.c | 80 +++---- src/mnode/src/mnodeDnode.c | 34 +-- src/mnode/src/mnodeInt.c | 2 +- src/mnode/src/mnodeMnode.c | 14 +- src/mnode/src/mnodePeer.c | 6 +- src/mnode/src/mnodeProfile.c | 24 +-- src/mnode/src/mnodeRead.c | 6 +- src/mnode/src/mnodeSdb.c | 6 +- src/mnode/src/mnodeShow.c | 22 +- src/mnode/src/mnodeTable.c | 150 ++++++------- src/mnode/src/mnodeUser.c | 44 ++-- src/mnode/src/mnodeVgroup.c | 24 +-- src/mnode/src/mnodeWrite.c | 8 +- src/plugins/http/src/httpJson.c | 4 +- src/plugins/http/src/httpSql.c | 6 +- src/plugins/http/src/tgJson.c | 4 +- src/plugins/monitor/src/monitorMain.c | 2 +- src/query/src/qExecutor.c | 44 ++-- src/query/src/qast.c | 6 +- src/query/src/qresultBuf.c | 10 +- src/query/src/tlosertree.c | 2 +- src/query/tests/unitTest.cpp | 104 ++++----- src/rpc/src/rpcMain.c | 82 +++---- src/tsdb/src/tsdbMain.c | 23 +- src/tsdb/src/tsdbMeta.c | 12 +- src/tsdb/src/tsdbRead.c | 16 +- src/util/src/tbuffer.c | 6 +- src/util/src/tqueue.c | 4 +- src/util/src/tutil.c | 6 +- src/vnode/src/vnodeMain.c | 22 +- src/vnode/src/vnodeRead.c | 8 +- src/vnode/src/vnodeWrite.c | 6 +- tests/examples/C#/TDengineDriver.cs | 2 - tests/tsim/src/simExe.c | 8 +- 61 files changed, 896 insertions(+), 870 deletions(-) diff --git a/src/client/src/TSDBJNIConnector.c b/src/client/src/TSDBJNIConnector.c index cec4737226..459b0f2b98 100644 --- a/src/client/src/TSDBJNIConnector.c +++ b/src/client/src/TSDBJNIConnector.c @@ -309,7 +309,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrCodeImp(JNI TAOS *tscon = (TAOS *)con; if (tscon == NULL) { jniError("jobj:%p, connection is closed", jobj); - return (jint)TSDB_CODE_INVALID_CONNECTION; + return (jint)TSDB_CODE_TSC_INVALID_CONNECTION; } if ((void *)tres == NULL) { diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c index ebcdddffde..3414ff8d98 100644 --- a/src/client/src/tscAsync.c +++ b/src/client/src/tscAsync.c @@ -53,7 +53,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const sem_init(&pSql->rspSem, 0, 0); if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE)) { tscError("failed to malloc payload"); - tscQueueAsyncError(fp, param, TSDB_CODE_CLI_OUT_OF_MEMORY); + tscQueueAsyncError(fp, param, TSDB_CODE_TSC_OUT_OF_MEMORY); return; } @@ -61,7 +61,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const pSql->sqlstr = calloc(1, sqlLen + 1); if (pSql->sqlstr == NULL) { tscError("%p failed to malloc sql string buffer", pSql); - tscQueueAsyncError(fp, param, TSDB_CODE_CLI_OUT_OF_MEMORY); + tscQueueAsyncError(fp, param, TSDB_CODE_TSC_OUT_OF_MEMORY); free(pCmd->payload); return; } @@ -73,7 +73,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const tscDump("%p SQL: %s", pSql, pSql->sqlstr); int32_t code = tsParseSql(pSql, true); - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return; if (code != TSDB_CODE_SUCCESS) { pSql->res.code = code; @@ -89,16 +89,16 @@ void taos_query_a(TAOS *taos, const char *sqlstr, __async_cb_func_t fp, void *pa STscObj *pObj = (STscObj *)taos; if (pObj == NULL || pObj->signature != pObj) { tscError("bug!!! pObj:%p", pObj); - terrno = TSDB_CODE_DISCONNECTED; - tscQueueAsyncError(fp, param, TSDB_CODE_DISCONNECTED); + terrno = TSDB_CODE_TSC_DISCONNECTED; + tscQueueAsyncError(fp, param, TSDB_CODE_TSC_DISCONNECTED); return; } int32_t sqlLen = strlen(sqlstr); if (sqlLen > tsMaxSQLStringLen) { tscError("sql string exceeds max length:%d", tsMaxSQLStringLen); - terrno = TSDB_CODE_INVALID_SQL; - tscQueueAsyncError(fp, param, TSDB_CODE_INVALID_SQL); + terrno = TSDB_CODE_TSC_INVALID_SQL; + tscQueueAsyncError(fp, param, TSDB_CODE_TSC_INVALID_SQL); return; } @@ -107,8 +107,8 @@ void taos_query_a(TAOS *taos, const char *sqlstr, __async_cb_func_t fp, void *pa SSqlObj *pSql = (SSqlObj *)calloc(1, sizeof(SSqlObj)); if (pSql == NULL) { tscError("failed to malloc sqlObj"); - terrno = TSDB_CODE_CLI_OUT_OF_MEMORY; - tscQueueAsyncError(fp, param, TSDB_CODE_CLI_OUT_OF_MEMORY); + terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; + tscQueueAsyncError(fp, param, TSDB_CODE_TSC_OUT_OF_MEMORY); return; } @@ -203,7 +203,7 @@ void taos_fetch_rows_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, int), voi SSqlObj *pSql = (SSqlObj *)taosa; if (pSql == NULL || pSql->signature != pSql) { tscError("sql object is NULL"); - tscQueueAsyncError(fp, param, TSDB_CODE_DISCONNECTED); + tscQueueAsyncError(fp, param, TSDB_CODE_TSC_DISCONNECTED); return; } @@ -212,7 +212,7 @@ void taos_fetch_rows_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, int), voi if (pRes->qhandle == 0) { tscError("qhandle is NULL"); - tscQueueAsyncError(fp, param, TSDB_CODE_INVALID_QHANDLE); + tscQueueAsyncError(fp, param, TSDB_CODE_TSC_INVALID_QHANDLE); return; } @@ -260,7 +260,7 @@ void taos_fetch_row_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, TAOS_ROW), SSqlObj *pSql = (SSqlObj *)taosa; if (pSql == NULL || pSql->signature != pSql) { tscError("sql object is NULL"); - tscQueueAsyncError(fp, param, TSDB_CODE_DISCONNECTED); + tscQueueAsyncError(fp, param, TSDB_CODE_TSC_DISCONNECTED); return; } @@ -269,7 +269,7 @@ void taos_fetch_row_a(TAOS_RES *taosa, void (*fp)(void *, TAOS_RES *, TAOS_ROW), if (pRes->qhandle == 0) { tscError("qhandle is NULL"); - tscQueueAsyncError(fp, param, TSDB_CODE_INVALID_QHANDLE); + tscQueueAsyncError(fp, param, TSDB_CODE_TSC_INVALID_QHANDLE); return; } @@ -466,7 +466,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) { code = tscGetSTableVgroupInfo(pSql, 0); pRes->code = code; - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return; } else { // normal async query continues if (pCmd->parseFinished) { tscTrace("%p re-send data to vnode in table Meta callback since sql parsed completed", pSql); @@ -491,7 +491,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) { return; } - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return; } } @@ -500,13 +500,13 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) { code = tscGetTableMeta(pSql, pTableMetaInfo); pRes->code = code; - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return; if (code == TSDB_CODE_SUCCESS && UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) { code = tscGetSTableVgroupInfo(pSql, pCmd->clauseIndex); pRes->code = code; - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return; } } diff --git a/src/client/src/tscFunctionImpl.c b/src/client/src/tscFunctionImpl.c index baefdbe102..9edb7d59cc 100644 --- a/src/client/src/tscFunctionImpl.c +++ b/src/client/src/tscFunctionImpl.c @@ -156,7 +156,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI int16_t *bytes, int32_t *interBytes, int16_t extLength, bool isSuperTable) { if (!isValidDataType(dataType, dataBytes)) { tscError("Illegal data type %d or data type length %d", dataType, dataBytes); - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TS_DUMMY || functionId == TSDB_FUNC_TAG_DUMMY || @@ -325,7 +325,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI *bytes = (int16_t)dataBytes; *interBytes = dataBytes + sizeof(SLastrowInfo); } else { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return TSDB_CODE_SUCCESS; diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c index 5ffdcd2167..d28f7a6673 100644 --- a/src/client/src/tscLocal.c +++ b/src/client/src/tscLocal.c @@ -312,12 +312,12 @@ static void tscProcessServStatus(SSqlObj *pSql) { STscObj* pObj = pSql->pTscObj; if (pObj->pHb != NULL) { - if (pObj->pHb->res.code == TSDB_CODE_NETWORK_UNAVAIL) { - pSql->res.code = TSDB_CODE_NETWORK_UNAVAIL; + if (pObj->pHb->res.code == TSDB_CODE_RPC_NETWORK_UNAVAIL) { + pSql->res.code = TSDB_CODE_RPC_NETWORK_UNAVAIL; return; } } else { - if (pSql->res.code == TSDB_CODE_NETWORK_UNAVAIL) { + if (pSql->res.code == TSDB_CODE_RPC_NETWORK_UNAVAIL) { return; } } @@ -378,7 +378,7 @@ int tscProcessLocalCmd(SSqlObj *pSql) { } else if (pCmd->command == TSDB_SQL_SERV_STATUS) { tscProcessServStatus(pSql); } else { - pSql->res.code = TSDB_CODE_INVALID_SQL; + pSql->res.code = TSDB_CODE_TSC_INVALID_SQL; tscError("%p not support command:%d", pSql, pCmd->command); } diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c index 8f4bcedfd6..abab32d71b 100644 --- a/src/client/src/tscParseInsert.c +++ b/src/client/src/tscParseInsert.c @@ -134,7 +134,7 @@ int tsParseTime(SSQLToken *pToken, int64_t *time, char **next, char *error, int1 } if (getTimestampInUsFromStr(valueToken.z, valueToken.n, &interval) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (timePrec == TSDB_TIME_PRECISION_MILLI) { @@ -423,7 +423,7 @@ int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[ } strcpy(error, "client out of memory"); - *code = TSDB_CODE_CLI_OUT_OF_MEMORY; + *code = TSDB_CODE_TSC_OUT_OF_MEMORY; return -1; } @@ -431,7 +431,7 @@ int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[ if ((type != TK_NOW && type != TK_INTEGER && type != TK_STRING && type != TK_FLOAT && type != TK_BOOL && type != TK_NULL && type != TK_HEX && type != TK_OCT && type != TK_BIN) || (sToken.n == 0) || (type == TK_RP)) { tscInvalidSQLErrMsg(error, "invalid data or symbol", sToken.z); - *code = TSDB_CODE_INVALID_SQL; + *code = TSDB_CODE_TSC_INVALID_SQL; return -1; } @@ -463,13 +463,13 @@ int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[ bool isPrimaryKey = (colIndex == PRIMARYKEY_TIMESTAMP_COL_INDEX); int32_t ret = tsParseOneColumnData(pSchema, &sToken, start, error, str, isPrimaryKey, timePrec); if (ret != TSDB_CODE_SUCCESS) { - *code = TSDB_CODE_INVALID_SQL; + *code = TSDB_CODE_TSC_INVALID_SQL; return -1; // NOTE: here 0 mean error! } if (isPrimaryKey && tsCheckTimestamp(pDataBlocks, start) != TSDB_CODE_SUCCESS) { tscInvalidSQLErrMsg(error, "client time/server time can not be mixed up", sToken.z); - *code = TSDB_CODE_INVALID_TIME_STAMP; + *code = TSDB_CODE_TSC_INVALID_TIME_STAMP; return -1; } } @@ -526,7 +526,7 @@ int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pTableMe if (spd->hasVal[0] == false) { strcpy(error, "primary timestamp column can not be null"); - *code = TSDB_CODE_INVALID_SQL; + *code = TSDB_CODE_TSC_INVALID_SQL; return -1; } @@ -560,7 +560,7 @@ int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pTableMe *str += index; if (sToken.n == 0 || sToken.type != TK_RP) { tscInvalidSQLErrMsg(error, ") expected", *str); - *code = TSDB_CODE_INVALID_SQL; + *code = TSDB_CODE_TSC_INVALID_SQL; return -1; } @@ -569,7 +569,7 @@ int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pTableMe if (numOfRows <= 0) { strcpy(error, "no any data points"); - *code = TSDB_CODE_INVALID_SQL; + *code = TSDB_CODE_TSC_INVALID_SQL; return -1; } else { return numOfRows; @@ -611,7 +611,7 @@ int32_t tscAllocateMemIfNeed(STableDataBlocks *pDataBlock, int32_t rowSize, int3 // do nothing, if allocate more memory failed pDataBlock->nAllocSize = nAllocSizeOld; *numOfRows = (int32_t)(pDataBlock->nAllocSize - pDataBlock->headerSize) / rowSize; - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } } @@ -687,13 +687,13 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableList, char **st int32_t maxNumOfRows; ret = tscAllocateMemIfNeed(dataBuf, tinfo.rowSize, &maxNumOfRows); if (TSDB_CODE_SUCCESS != ret) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } - int32_t code = TSDB_CODE_INVALID_SQL; + int32_t code = TSDB_CODE_TSC_INVALID_SQL; char * tmpTokenBuf = calloc(1, 4096); // used for deleting Escape character: \\, \', \" if (NULL == tmpTokenBuf) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } int32_t numOfRows = tsParseValues(str, dataBuf, pTableMeta, maxNumOfRows, spd, pCmd->payload, &code, tmpTokenBuf); @@ -772,7 +772,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) { } if (numOfColList == 0 && cstart != NULL) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, TABLE_INDEX); @@ -954,7 +954,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) { createTable = true; code = tscGetMeterMetaEx(pSql, pTableMetaInfo, true); - if (TSDB_CODE_ACTION_IN_PROGRESS == code) { + if (TSDB_CODE_TSC_ACTION_IN_PROGRESS == code) { return code; } @@ -967,7 +967,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) { code = tscGetMeterMetaEx(pSql, pTableMetaInfo, false); if (pCmd->curSql == NULL) { - assert(code == TSDB_CODE_ACTION_IN_PROGRESS); + assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS); } } @@ -981,7 +981,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) { } if (*sqlstr == NULL) { - code = TSDB_CODE_INVALID_SQL; + code = TSDB_CODE_TSC_INVALID_SQL; } return code; @@ -1046,7 +1046,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) { pSql->cmd.pDataBlocks = tscCreateBlockArrayList(); if (NULL == pCmd->pTableList || NULL == pSql->cmd.pDataBlocks) { - code = TSDB_CODE_CLI_OUT_OF_MEMORY; + code = TSDB_CODE_TSC_OUT_OF_MEMORY; goto _error_clean; } } else { @@ -1075,7 +1075,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) { * Otherwise, create the first submit block and submit to virtual node. */ if (totalNum == 0) { - code = TSDB_CODE_INVALID_SQL; + code = TSDB_CODE_TSC_INVALID_SQL; goto _error_clean; } else { break; @@ -1103,7 +1103,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) { * And during the getMeterMetaCallback function, the sql string will be parsed from the * interrupted position. */ - if (TSDB_CODE_ACTION_IN_PROGRESS == code) { + if (TSDB_CODE_TSC_ACTION_IN_PROGRESS == code) { tscTrace("%p waiting for get table meta during insert, then resume from offset: %" PRId64 " , %s", pSql, pos, pCmd->curSql); return code; @@ -1297,7 +1297,7 @@ _clean: int tsParseInsertSql(SSqlObj *pSql) { if (!pSql->pTscObj->writeAuth) { - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_TSC_NO_WRITE_AUTH; } int32_t index = 0; diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c index 1a76bd5e61..ba97c7d00a 100644 --- a/src/client/src/tscPrepare.c +++ b/src/client/src/tscPrepare.c @@ -62,7 +62,7 @@ static int normalStmtAddPart(SNormalStmt* stmt, bool isParam, char* str, uint32_ size *= 2; void* tmp = realloc(stmt->parts, sizeof(SNormalStmtPart) * size); if (tmp == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } stmt->sizeParts = size; stmt->parts = (SNormalStmtPart*)tmp; @@ -133,7 +133,7 @@ static int normalStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) { case TSDB_DATA_TYPE_NCHAR: var->pz = (char*)malloc((*tb->length) + 1); if (var->pz == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } memcpy(var->pz, tb->buffer, (*tb->length)); var->pz[*tb->length] = 0; @@ -142,7 +142,7 @@ static int normalStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) { default: tscTrace("param %d: type mismatch or invalid", i); - return TSDB_CODE_INVALID_VALUE; + return TSDB_CODE_TSC_INVALID_VALUE; } } @@ -187,7 +187,7 @@ static int normalStmtPrepare(STscStmt* stmt) { if (normal->numParams > 0) { normal->params = calloc(normal->numParams, sizeof(tVariant)); if (normal->params == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } } @@ -273,7 +273,7 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) { } if (bind->buffer_type != param->type) { - return TSDB_CODE_INVALID_VALUE; + return TSDB_CODE_TSC_INVALID_VALUE; } short size = 0; @@ -300,7 +300,7 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) { case TSDB_DATA_TYPE_BINARY: if ((*bind->length) > param->bytes) { - return TSDB_CODE_INVALID_VALUE; + return TSDB_CODE_TSC_INVALID_VALUE; } size = (short)*bind->length; STR_WITH_SIZE_TO_VARSTR(data + param->offset, bind->buffer, size); @@ -309,14 +309,14 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) { case TSDB_DATA_TYPE_NCHAR: { size_t output = 0; if (!taosMbsToUcs4(bind->buffer, *bind->length, varDataVal(data + param->offset), param->bytes - VARSTR_HEADER_SIZE, &output)) { - return TSDB_CODE_INVALID_VALUE; + return TSDB_CODE_TSC_INVALID_VALUE; } varDataSetLen(data + param->offset, output); return TSDB_CODE_SUCCESS; } default: assert(false); - return TSDB_CODE_INVALID_VALUE; + return TSDB_CODE_TSC_INVALID_VALUE; } memcpy(data + param->offset, bind->buffer, size); @@ -344,7 +344,7 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) { const double factor = 1.5; void* tmp = realloc(pBlock->pData, (uint32_t)(totalDataSize * factor)); if (tmp == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } pBlock->pData = (char*)tmp; pBlock->nAllocSize = (uint32_t)(totalDataSize * factor); @@ -416,7 +416,7 @@ static int insertStmtReset(STscStmt* pStmt) { static int insertStmtExecute(STscStmt* stmt) { SSqlCmd* pCmd = &stmt->pSql->cmd; if (pCmd->batchSize == 0) { - return TSDB_CODE_INVALID_VALUE; + return TSDB_CODE_TSC_INVALID_VALUE; } if ((pCmd->batchSize % 2) == 1) { ++pCmd->batchSize; @@ -470,14 +470,14 @@ static int insertStmtExecute(STscStmt* stmt) { TAOS_STMT* taos_stmt_init(TAOS* taos) { STscObj* pObj = (STscObj*)taos; if (pObj == NULL || pObj->signature != pObj) { - terrno = TSDB_CODE_DISCONNECTED; + terrno = TSDB_CODE_TSC_DISCONNECTED; tscError("connection disconnected"); return NULL; } STscStmt* pStmt = calloc(1, sizeof(STscStmt)); if (pStmt == NULL) { - terrno = TSDB_CODE_CLI_OUT_OF_MEMORY; + terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; tscError("failed to allocate memory for statement"); return NULL; } @@ -486,7 +486,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) { SSqlObj* pSql = calloc(1, sizeof(SSqlObj)); if (pSql == NULL) { free(pStmt); - terrno = TSDB_CODE_CLI_OUT_OF_MEMORY; + terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; tscError("failed to allocate memory for statement"); return NULL; } @@ -505,8 +505,8 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) { STscStmt* pStmt = (STscStmt*)stmt; if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) { - terrno = TSDB_CODE_DISCONNECTED; - return TSDB_CODE_DISCONNECTED; + terrno = TSDB_CODE_TSC_DISCONNECTED; + return TSDB_CODE_TSC_DISCONNECTED; } SSqlObj* pSql = pStmt->pSql; @@ -521,7 +521,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) { if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE)) { tscError("%p failed to malloc payload buffer", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1); @@ -529,7 +529,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) { if (pSql->sqlstr == NULL) { tscError("%p failed to malloc sql string buffer", pSql); free(pCmd->payload); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } pRes->qhandle = 0; @@ -545,7 +545,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) { pSql->cmd.batchSize = 0; int32_t code = tsParseSql(pSql, true); - if (code == TSDB_CODE_ACTION_IN_PROGRESS) { + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) { // wait for the callback function to post the semaphore tsem_wait(&pSql->rspSem); return pSql->res.code; @@ -590,7 +590,7 @@ int taos_stmt_add_batch(TAOS_STMT* stmt) { if (pStmt->isInsert) { return insertStmtAddBatch(pStmt); } - return TSDB_CODE_OPS_NOT_SUPPORT; + return TSDB_CODE_COM_OPS_NOT_SUPPORT; } int taos_stmt_reset(TAOS_STMT* stmt) { @@ -609,7 +609,7 @@ int taos_stmt_execute(TAOS_STMT* stmt) { } else { char* sql = normalStmtBuildSql(pStmt); if (sql == NULL) { - ret = TSDB_CODE_CLI_OUT_OF_MEMORY; + ret = TSDB_CODE_TSC_OUT_OF_MEMORY; } else { tfree(pStmt->pSql->sqlstr); pStmt->pSql->sqlstr = sql; diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index bfa8a93791..e1f7f97637 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -179,7 +179,7 @@ static int32_t handlePassword(SSqlCmd* pCmd, SSQLToken* pPwd) { // todo handle memory leak in error handle function int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) { if (pInfo == NULL || pSql == NULL || pSql->signature != pSql) { - return TSDB_CODE_APP_ERROR; + return TSDB_CODE_TSC_APP_ERROR; } SSqlCmd* pCmd = &(pSql->cmd); @@ -264,7 +264,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) { case TSDB_SQL_SHOW: { if (setShowInfo(pSql, pInfo) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } break; @@ -286,7 +286,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) { } if (parseCreateDBOptions(pCmd, pCreateDB) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } break; @@ -314,7 +314,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) { SSQLToken* pPwd = &pInfo->pDCLInfo->user.passwd; if (handlePassword(pCmd, pPwd) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (pName->n > TSDB_USER_LEN) { @@ -411,12 +411,12 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) { if (pCmd->command == TSDB_SQL_CREATE_USER) { if (handlePassword(pCmd, pPwd) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } else { if (pUser->type == TSDB_ALTER_USER_PASSWD) { if (handlePassword(pCmd, pPwd) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } else if (pUser->type == TSDB_ALTER_USER_PRIVILEGES) { assert(pPwd->type == TSDB_DATA_TYPE_NULL); @@ -577,7 +577,7 @@ int32_t parseIntervalClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) { // interval is not null SSQLToken* t = &pQuerySql->interval; if (getTimestampInUsFromStr(t->z, t->n, &pQueryInfo->intervalTime) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } // if the unit of time window value is millisecond, change the value from microsecond @@ -596,7 +596,7 @@ int32_t parseIntervalClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) { // for top/bottom + interval query, we do not add additional timestamp column in the front if (isTopBottomQuery(pQueryInfo)) { if (parseSlidingClause(pQueryInfo, pQuerySql) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return TSDB_CODE_SUCCESS; @@ -635,7 +635,7 @@ int32_t parseIntervalClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) { } if (tableIndex == COLUMN_INDEX_INITIAL_VAL) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } SColumnIndex index = {tableIndex, PRIMARYKEY_TIMESTAMP_COL_INDEX}; @@ -651,7 +651,7 @@ int32_t parseIntervalClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) { } if (parseSlidingClause(pQueryInfo, pQuerySql) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return TSDB_CODE_SUCCESS; @@ -1040,7 +1040,7 @@ int32_t setObjFullName(char* fullName, const char* account, SSQLToken* pDB, SSQL /* db name is not specified, the tableName dose not include db name */ if (pDB != NULL) { if (pDB->n > TSDB_DB_NAME_LEN) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } memcpy(&fullName[totalLen], pDB->z, pDB->n); @@ -1054,12 +1054,12 @@ int32_t setObjFullName(char* fullName, const char* account, SSQLToken* pDB, SSQL /* here we only check the table name length limitation */ if (tableName->n > TSDB_TABLE_NAME_LEN) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } else { // pDB == NULL, the db prefix name is specified in tableName /* the length limitation includes tablename + dbname + sep */ if (tableName->n > TSDB_TABLE_NAME_LEN + TSDB_DB_NAME_LEN + tListLen(TS_PATH_DELIMITER)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -1075,7 +1075,7 @@ int32_t setObjFullName(char* fullName, const char* account, SSQLToken* pDB, SSQL fullName[totalLen] = 0; } - return (totalLen <= TSDB_TABLE_ID_LEN) ? TSDB_CODE_SUCCESS : TSDB_CODE_INVALID_SQL; + return (totalLen <= TSDB_TABLE_ID_LEN) ? TSDB_CODE_SUCCESS : TSDB_CODE_TSC_INVALID_SQL; } static void extractColumnNameFromString(tSQLExprItem* pItem) { @@ -1122,12 +1122,12 @@ int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSel // select table_name1.field_name1, table_name2.field_name2 from table_name1, table_name2 if (addProjectionExprAndResultField(pQueryInfo, pItem) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } else if (pItem->pNode->nSQLOptr >= TK_COUNT && pItem->pNode->nSQLOptr <= TK_TBID) { // sql function in selection clause, append sql function info in pSqlCmd structure sequentially if (addExprAndResultField(pQueryInfo, outputIndex, pItem, true) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } else if (pItem->pNode->nSQLOptr >= TK_PLUS && pItem->pNode->nSQLOptr <= TK_REM) { @@ -1154,7 +1154,7 @@ int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSel } if (buildArithmeticExprString(pItem->pNode, &p) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } // expr string is set as the parameter of function @@ -1230,7 +1230,7 @@ int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSel } if (pQueryInfo->fieldsInfo.numOfOutput > TSDB_MAX_COLUMNS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -1246,7 +1246,7 @@ int32_t parseSelectClause(SSqlCmd* pCmd, int32_t clauseIndex, tSQLExprList* pSel tscTansformSQLFuncForSTableQuery(pQueryInfo); if (hasUnsupportFunctionsForSTableQuery(pQueryInfo)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -1414,7 +1414,7 @@ int32_t addProjectionExprAndResultField(SQueryInfo* pQueryInfo, tSQLExprItem* pI addProjectQueryCol(pQueryInfo, startPos, &index, pItem); } } else { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return TSDB_CODE_SUCCESS; @@ -1483,7 +1483,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr int16_t functionID = 0; if (changeFunctionID(optr, &functionID) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } SSqlExpr* pExpr = NULL; @@ -1596,12 +1596,12 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr int16_t functionID = 0; if (changeFunctionID(optr, &functionID) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (getResultDataInfo(pSchema->type, pSchema->bytes, functionID, 0, &resultType, &resultSize, &intermediateResSize, 0, false) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } // set the first column ts for diff query @@ -1626,14 +1626,14 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr /* set the leastsquares parameters */ char val[8] = {0}; if (tVariantDump(&pParamElem[1].pNode->val, val, TSDB_DATA_TYPE_DOUBLE, true) < 0) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } addExprParams(pExpr, val, TSDB_DATA_TYPE_DOUBLE, DOUBLE_BYTES, 0); memset(val, 0, tListLen(val)); if (tVariantDump(&pParamElem[2].pNode->val, val, TSDB_DATA_TYPE_DOUBLE, true) < 0) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } addExprParams(pExpr, val, TSDB_DATA_TYPE_DOUBLE, sizeof(double), 0); @@ -1698,7 +1698,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr for (int32_t j = 0; j < tscGetNumOfColumns(pTableMetaInfo->pTableMeta); ++j) { index.columnIndex = j; if (setExprInfoForFunctions(pQueryInfo, pSchema, functionID, pItem->aliasName, colIndex++, &index) != 0) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -1716,7 +1716,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr } if (setExprInfoForFunctions(pQueryInfo, pSchema, functionID, pItem->aliasName, colIndex + i, &index) != 0) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } } @@ -1733,7 +1733,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr SColumnIndex index = {.tableIndex = j, .columnIndex = i}; if (setExprInfoForFunctions(pQueryInfo, pSchema, functionID, pItem->aliasName, colIndex + i + j, &index) != 0) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -1809,7 +1809,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr */ int16_t functionId = 0; if (changeFunctionID(optr, &functionId) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, resultSize, false); @@ -1824,7 +1824,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr int16_t functionId = 0; if (changeFunctionID(optr, &functionId) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } // set the first column ts for top/bottom query @@ -1914,7 +1914,7 @@ int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExpr } default: - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -2014,7 +2014,7 @@ int32_t doGetColumnIndexByName(SSQLToken* pToken, SQueryInfo* pQueryInfo, SColum if (COLUMN_INDEX_VALIDE(*pIndex)) { return TSDB_CODE_SUCCESS; } else { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -2041,7 +2041,7 @@ int32_t getTableIndexImpl(SSQLToken* pTableToken, SQueryInfo* pQueryInfo, SColum } if (pIndex->tableIndex < 0) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return TSDB_CODE_SUCCESS; @@ -2052,7 +2052,7 @@ int32_t getTableIndexByName(SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIn extractTableNameFromToken(pToken, &tableToken); if (getTableIndexImpl(&tableToken, pQueryInfo, pIndex) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return TSDB_CODE_SUCCESS; @@ -2060,13 +2060,13 @@ int32_t getTableIndexByName(SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIn int32_t getColumnIndexByName(const SSQLToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex) { if (pQueryInfo->pTableMetaInfo == NULL || pQueryInfo->numOfTables == 0) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } SSQLToken tmpToken = *pToken; if (getTableIndexByName(&tmpToken, pQueryInfo, pIndex) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return doGetColumnIndexByName(&tmpToken, pQueryInfo, pIndex); @@ -2239,7 +2239,7 @@ int32_t setKillInfo(SSqlObj* pSql, struct SSqlInfo* pInfo, int32_t killType) { SSQLToken* idStr = &(pInfo->pDCLInfo->ip); if (idStr->n > TSDB_KILL_MSG_LEN) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } strncpy(pCmd->payload, idStr->z, idStr->n); @@ -2286,7 +2286,7 @@ int32_t tscTansformSQLFuncForSTableQuery(SQueryInfo* pQueryInfo) { STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0); if (pTableMetaInfo->pTableMeta == NULL || !UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } assert(tscGetNumOfTags(pTableMetaInfo->pTableMeta) >= 0); @@ -2308,7 +2308,7 @@ int32_t tscTansformSQLFuncForSTableQuery(SQueryInfo* pQueryInfo) { (functionId >= TSDB_FUNC_RATE && functionId <= TSDB_FUNC_AVG_IRATE)) { if (getResultDataInfo(pSrcSchema->type, pSrcSchema->bytes, functionId, pExpr->param[0].i64Key, &type, &bytes, &interBytes, 0, true) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } tscSqlExprUpdate(pQueryInfo, k, functionId, pExpr->colInfo.colIndex, TSDB_DATA_TYPE_BINARY, bytes); @@ -2732,7 +2732,7 @@ static bool isExprDirectParentOfLeaftNode(tSQLExpr* pExpr) { static int32_t tSQLExprLeafToString(tSQLExpr* pExpr, bool addParentheses, char** output) { if (!isExprDirectParentOfLeaftNode(pExpr)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } tSQLExpr* pLeft = pExpr->pLeft; @@ -2745,7 +2745,7 @@ static int32_t tSQLExprLeafToString(tSQLExpr* pExpr, bool addParentheses, char** tSQLExprNodeToString(pLeft, output); if (optrToString(pExpr, output) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } tSQLExprNodeToString(pRight, output); @@ -2811,7 +2811,7 @@ static int32_t optrToString(tSQLExpr* pExpr, char** exprString) { break; } default: - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } *exprString += 1; @@ -2822,7 +2822,7 @@ static int32_t optrToString(tSQLExpr* pExpr, char** exprString) { static int32_t tablenameListToString(tSQLExpr* pExpr, SStringBuilder* sb) { tSQLExprList* pList = pExpr->pParam; if (pList->nExpr <= 0) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (pList->nExpr > 0) { @@ -2838,7 +2838,7 @@ static int32_t tablenameListToString(tSQLExpr* pExpr, SStringBuilder* sb) { } if (pSub->val.nLen <= 0 || pSub->val.nLen > TSDB_TABLE_NAME_LEN) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -2886,7 +2886,7 @@ static int32_t extractColumnFilterInfo(SQueryInfo* pQueryInfo, SColumnIndex* pIn // TODO fixme: failed to invalid the filter expression: "col1 = 1 OR col2 = 2" pColFilter = addColumnFilterInfo(pColumn); } else { // error; - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } pColFilter->filterstr = @@ -2961,7 +2961,7 @@ static int32_t getTablenameCond(SQueryInfo* pQueryInfo, tSQLExpr* pTableCond, SS tSQLExpr* pRight = pTableCond->pRight; if (!isTablenameToken(&pLeft->colInfo)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } int32_t ret = TSDB_CODE_SUCCESS; @@ -2994,7 +2994,7 @@ static int32_t getColumnQueryCondInfo(SQueryInfo* pQueryInfo, tSQLExpr* pExpr, i } else { // handle leaf node SColumnIndex index = COLUMN_INDEX_INITIALIZER; if (getColumnIndexByName(&pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return extractColumnFilterInfo(pQueryInfo, &index, pExpr, relOptr); @@ -3018,7 +3018,7 @@ static int32_t getJoinCondInfo(SQueryInfo* pQueryInfo, tSQLExpr* pExpr) { SColumnIndex index = COLUMN_INDEX_INITIALIZER; if (getColumnIndexByName(&pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex); @@ -3030,7 +3030,7 @@ static int32_t getJoinCondInfo(SQueryInfo* pQueryInfo, tSQLExpr* pExpr) { index = (SColumnIndex)COLUMN_INDEX_INITIALIZER; if (getColumnIndexByName(&pExpr->pRight->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex); @@ -3056,7 +3056,7 @@ int32_t buildArithmeticExprString(tSQLExpr* pExpr, char** exprString) { } else { int32_t ret = tSQLExprNodeToString(pLeft, exprString); if (ret != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -3067,7 +3067,7 @@ int32_t buildArithmeticExprString(tSQLExpr* pExpr, char** exprString) { } else { int32_t ret = tSQLExprNodeToString(pRight, exprString); if (ret != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -3081,12 +3081,12 @@ static int32_t validateSQLExpr(tSQLExpr* pExpr, SQueryInfo* pQueryInfo, SColumnL if (*type == NON_ARITHMEIC_EXPR) { *type = NORMAL_ARITHMETIC; } else if (*type == AGG_ARIGHTMEIC) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } SColumnIndex index = COLUMN_INDEX_INITIALIZER; if (getColumnIndexByName(&pExpr->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } // if column is timestamp, bool, binary, nchar, not support arithmetic, so return invalid sql @@ -3095,17 +3095,17 @@ static int32_t validateSQLExpr(tSQLExpr* pExpr, SQueryInfo* pQueryInfo, SColumnL if ((pSchema->type == TSDB_DATA_TYPE_TIMESTAMP) || (pSchema->type == TSDB_DATA_TYPE_BOOL) || (pSchema->type == TSDB_DATA_TYPE_BINARY) || (pSchema->type == TSDB_DATA_TYPE_NCHAR)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } pList->ids[pList->num++] = index; } else if (pExpr->nSQLOptr == TK_FLOAT && (isnan(pExpr->val.dKey) || isinf(pExpr->val.dKey))) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } else if (pExpr->nSQLOptr >= TK_COUNT && pExpr->nSQLOptr <= TK_AVG_IRATE) { if (*type == NON_ARITHMEIC_EXPR) { *type = AGG_ARIGHTMEIC; } else if (*type == NORMAL_ARITHMETIC) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } int32_t outputIndex = tscSqlExprNumOfExprs(pQueryInfo); @@ -3114,7 +3114,7 @@ static int32_t validateSQLExpr(tSQLExpr* pExpr, SQueryInfo* pQueryInfo, SColumnL // sql function in selection clause, append sql function info in pSqlCmd structure sequentially if (addExprAndResultField(pQueryInfo, outputIndex, &item, false) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -3318,7 +3318,7 @@ static int32_t handleExprInQueryCond(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, S if (index.columnIndex == PRIMARYKEY_TIMESTAMP_COL_INDEX) { // query on time range if (!validateJoinExprNode(pQueryInfo, *pExpr, &index)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } // set join query condition @@ -3380,7 +3380,7 @@ static int32_t handleExprInQueryCond(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, S } else { if (pRight->nSQLOptr == TK_ID) { // join on tag columns for stable query if (!validateJoinExprNode(pQueryInfo, *pExpr, &index)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (pCondExpr->pJoinExpr != NULL) { @@ -3425,7 +3425,7 @@ int32_t getQueryCondExpr(SQueryInfo* pQueryInfo, tSQLExpr** pExpr, SCondExpr* pC tSQLExpr* pRight = (*pExpr)->pRight; if (!isValidExpr(pLeft, pRight, (*pExpr)->nSQLOptr)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } int32_t leftType = -1; @@ -3663,7 +3663,7 @@ static int32_t getTimeRangeFromExpr(SQueryInfo* pQueryInfo, tSQLExpr* pExpr) { } else { SColumnIndex index = COLUMN_INDEX_INITIALIZER; if (getColumnIndexByName(&pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex); @@ -3891,7 +3891,7 @@ int32_t getTimeRange(STimeWindow* win, tSQLExpr* pRight, int32_t optr, int16_t t * where ts in ('2015-12-12 4:8:12') */ if (pRight->nSQLOptr == TK_SET || optr == TK_IN) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } int64_t val = 0; @@ -3904,14 +3904,14 @@ int32_t getTimeRange(STimeWindow* win, tSQLExpr* pRight, int32_t optr, int16_t t if (taosParseTime(pRight->val.pz, &val, pRight->val.nLen, TSDB_TIME_PRECISION_MICRO) == TSDB_CODE_SUCCESS) { parsed = true; } else { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } else { SSQLToken token = {.z = pRight->val.pz, .n = pRight->val.nLen, .type = TK_ID}; int32_t len = tSQLGetToken(pRight->val.pz, &token.type); if ((token.type != TK_INTEGER && token.type != TK_FLOAT) || len != pRight->val.nLen) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } } else if (pRight->nSQLOptr == TK_INTEGER && timePrecision == TSDB_TIME_PRECISION_MILLI) { @@ -4019,7 +4019,7 @@ int32_t parseFillClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySQL) { if (pQueryInfo->fillVal == NULL) { pQueryInfo->fillVal = calloc(size, sizeof(int64_t)); if (pQueryInfo->fillVal == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } } @@ -4330,7 +4330,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { } if (!validateOneTags(pCmd, &pFieldList->p[0])) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &pFieldList->p[0]); @@ -4353,7 +4353,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { SSQLToken name = {.z = pItem->pVar.pz, .n = pItem->pVar.nLen, .type = TK_STRING}; if (getColumnIndexByName(&name, pQueryInfo, &index) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (index.columnIndex < tscGetNumOfColumns(pTableMeta)) { @@ -4370,7 +4370,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { } else if (pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) { tVariantList* pVarList = pAlterSQL->varList; if (pVarList->nExpr > 2) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } tVariantListItem* pSrcItem = &pAlterSQL->varList->a[0]; @@ -4389,12 +4389,12 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { SSQLToken srcToken = {.z = pSrcItem->pVar.pz, .n = pSrcItem->pVar.nLen, .type = TK_STRING}; if (getColumnIndexByName(&srcToken, pQueryInfo, &srcIndex) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } SSQLToken destToken = {.z = pDstItem->pVar.pz, .n = pDstItem->pVar.nLen, .type = TK_STRING}; if (getColumnIndexByName(&destToken, pQueryInfo, &destIndex) == TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } char name[TSDB_COL_NAME_LEN + 1] = {0}; @@ -4417,7 +4417,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER; SSQLToken name = {.type = TK_STRING, .z = pTagName->pz, .n = pTagName->nLen}; if (getColumnIndexByName(&name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (columnIndex.columnIndex < tscGetNumOfColumns(pTableMeta)) { @@ -4440,7 +4440,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { int32_t size = sizeof(SUpdateTableTagValMsg) + pTagsSchema->bytes + TSDB_EXTRA_PAYLOAD_SIZE; if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) { tscError("%p failed to malloc for alter table msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SUpdateTableTagValMsg* pUpdateMsg = (SUpdateTableTagValMsg*) (pCmd->payload + tsRpcHeadSize); @@ -4474,7 +4474,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { } if (!validateOneColumn(pCmd, &pFieldList->p[0])) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &pFieldList->p[0]); @@ -4563,7 +4563,7 @@ int32_t validateFunctionsInIntervalOrGroupbyQuery(SQueryInfo* pQueryInfo) { invalidSqlErrMsg(pQueryInfo->msg, msg1); } - return isProjectionFunction == true ? TSDB_CODE_INVALID_SQL : TSDB_CODE_SUCCESS; + return isProjectionFunction == true ? TSDB_CODE_TSC_INVALID_SQL : TSDB_CODE_SUCCESS; } typedef struct SDNodeDynConfOption { @@ -4573,7 +4573,7 @@ typedef struct SDNodeDynConfOption { int32_t validateDNodeConfig(tDCLSQL* pOptions) { if (pOptions->nTokens < 2 || pOptions->nTokens > 3) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } const int DNODE_DYNAMIC_CFG_OPTIONS_SIZE = 17; @@ -4599,7 +4599,7 @@ int32_t validateDNodeConfig(tDCLSQL* pOptions) { SSQLToken* pValToken = &pOptions->a[2]; int32_t val = strtol(pValToken->z, NULL, 10); if (val != 0 && val != 1) { - return TSDB_CODE_INVALID_SQL; // options value is invalid + return TSDB_CODE_TSC_INVALID_SQL; // options value is invalid } return TSDB_CODE_SUCCESS; } else { @@ -4608,7 +4608,7 @@ int32_t validateDNodeConfig(tDCLSQL* pOptions) { int32_t val = strtol(pValToken->z, NULL, 10); if (val < 131 || val > 199) { /* options value is out of valid range */ - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } for (int32_t i = 2; i < DNODE_DYNAMIC_CFG_OPTIONS_SIZE - 1; ++i) { @@ -4621,12 +4621,12 @@ int32_t validateDNodeConfig(tDCLSQL* pOptions) { } } - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } int32_t validateLocalConfig(tDCLSQL* pOptions) { if (pOptions->nTokens < 1 || pOptions->nTokens > 2) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } SDNodeDynConfOption LOCAL_DYNAMIC_CFG_OPTIONS[6] = {{"resetLog", 8}, {"rpcDebugFlag", 12}, {"tmrDebugFlag", 12}, @@ -4648,7 +4648,7 @@ int32_t validateLocalConfig(tDCLSQL* pOptions) { int32_t val = strtol(pValToken->z, NULL, 10); if (val < 131 || val > 199) { // options value is out of valid range - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } for (int32_t i = 1; i < tListLen(LOCAL_DYNAMIC_CFG_OPTIONS); ++i) { @@ -4659,20 +4659,20 @@ int32_t validateLocalConfig(tDCLSQL* pOptions) { } } } - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } int32_t validateColumnName(char* name) { bool ret = isKeyWord(name, strlen(name)); if (ret) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } SSQLToken token = {.z = name}; token.n = tSQLGetToken(name, &token.type); if (token.type != TK_STRING && token.type != TK_ID) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (token.type == TK_STRING) { @@ -4681,13 +4681,13 @@ int32_t validateColumnName(char* name) { int32_t k = tSQLGetToken(token.z, &token.type); if (k != token.n) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return validateColumnName(token.z); } else { if (isNumber(&token)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -4885,15 +4885,15 @@ int32_t parseCreateDBOptions(SSqlCmd* pCmd, SCreateDBInfo* pCreateDbSql) { setCreateDBOption(pMsg, pCreateDbSql); if (setKeepOption(pCmd, pMsg, pCreateDbSql) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (setTimePrecision(pCmd, pMsg, pCreateDbSql) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (tscCheckCreateDbParams(pCmd, pMsg) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return TSDB_CODE_SUCCESS; @@ -5324,7 +5324,7 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) { } if (checkUpdateTagPrjFunctions(pQueryInfo) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } /* @@ -5332,7 +5332,7 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) { * divide the subset of final result. */ if (doAddGroupbyColumnsOnDemand(pQueryInfo) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } // projection query on super table does not compatible with "group by" syntax @@ -5527,7 +5527,7 @@ int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* p if (!validateTableColumnInfo(pFieldList, pCmd) || (pTagList != NULL && !validateTagParams(pTagList, pFieldList, pCmd))) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } int32_t col = 0; @@ -5676,22 +5676,22 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) { bool isSTable = UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo); if (parseSelectClause(&pSql->cmd, 0, pQuerySql->pSelection, isSTable) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (pQuerySql->pWhere != NULL) { // query condition in stream computing if (parseWhereClause(pQueryInfo, &pQuerySql->pWhere, pSql) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } // set interval value if (parseIntervalClause(pQueryInfo, pQuerySql) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } else { if ((pQueryInfo->intervalTime > 0) && (validateFunctionsInIntervalOrGroupbyQuery(pQueryInfo) != TSDB_CODE_SUCCESS)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } @@ -5705,13 +5705,13 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) { } if (tsRewriteFieldNameIfNecessary(pQueryInfo) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } pCmd->numOfCols = pQueryInfo->fieldsInfo.numOfOutput; if (validateSqlFunctionInStreamSql(pQueryInfo) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } /* @@ -5832,26 +5832,26 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) { // parse the group by clause in the first place if (parseGroupbyClause(pQueryInfo, pQuerySql->pGroupby, pCmd) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (parseSelectClause(pCmd, index, pQuerySql->pSelection, isSTable) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } // set interval value if (parseIntervalClause(pQueryInfo, pQuerySql) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } else { if ((pQueryInfo->intervalTime > 0) && (validateFunctionsInIntervalOrGroupbyQuery(pQueryInfo) != TSDB_CODE_SUCCESS)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } // set order by info if (parseOrderbyClause(pQueryInfo, pQuerySql, tscGetTableSchema(pTableMetaInfo->pTableMeta)) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } // set where info @@ -5859,7 +5859,7 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) { if (pQuerySql->pWhere != NULL) { if (parseWhereClause(pQueryInfo, &pQuerySql->pWhere, pSql) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } pQuerySql->pWhere = NULL; @@ -6008,7 +6008,7 @@ int32_t exprTreeFromSqlExpr(tExprNode **pExpr, const tSQLExpr* pSqlExpr, SArray* return TSDB_CODE_SUCCESS; } else { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } else { @@ -6027,9 +6027,9 @@ int32_t exprTreeFromSqlExpr(tExprNode **pExpr, const tSQLExpr* pSqlExpr, SArray* if ((*pExpr)->_node.optr == TSDB_BINARY_OP_DIVIDE) { if (pRight->nodeType == TSQL_NODE_VALUE) { if (pRight->pVal->nType == TSDB_DATA_TYPE_INT && pRight->pVal->i64Key == 0) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } else if (pRight->pVal->nType == TSDB_DATA_TYPE_FLOAT && pRight->pVal->dKey == 0) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } } diff --git a/src/client/src/tscSecondaryMerge.c b/src/client/src/tscSecondaryMerge.c index 5737564877..5e6516f898 100644 --- a/src/client/src/tscSecondaryMerge.c +++ b/src/client/src/tscSecondaryMerge.c @@ -161,7 +161,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, numOfBuffer); tscError("%p pMemBuffer is NULL", pMemBuffer); - pRes->code = TSDB_CODE_APP_ERROR; + pRes->code = TSDB_CODE_TSC_APP_ERROR; return; } @@ -169,7 +169,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, numOfBuffer); tscError("%p no local buffer or intermediate result format model", pSql); - pRes->code = TSDB_CODE_APP_ERROR; + pRes->code = TSDB_CODE_TSC_APP_ERROR; return; } @@ -196,7 +196,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd pMemBuffer[0]->pageSize); tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, numOfBuffer); - pRes->code = TSDB_CODE_APP_ERROR; + pRes->code = TSDB_CODE_TSC_APP_ERROR; return; } @@ -207,7 +207,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd tscError("%p failed to create local merge structure, out of memory", pSql); tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, numOfBuffer); - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; return; } @@ -229,7 +229,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd SLocalDataSource *ds = (SLocalDataSource *)malloc(sizeof(SLocalDataSource) + pMemBuffer[0]->pageSize); if (ds == NULL) { tscError("%p failed to create merge structure", pSql); - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; return; } @@ -326,7 +326,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd // tfree(pReducer->pBufForInterpo); tfree(pReducer->prevRowOfInput); - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; return; } @@ -560,7 +560,7 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm int32_t *orderIdx = (int32_t *)calloc(numOfGroupByCols, sizeof(int32_t)); if (orderIdx == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } if (numOfGroupByCols > 0) { @@ -581,7 +581,7 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm tfree(orderIdx); if (*pOrderDesc == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } else { return TSDB_CODE_SUCCESS; } @@ -641,7 +641,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr (*pMemBuffer) = (tExtMemBuffer **)malloc(POINTER_BYTES * pSql->numOfSubs); if (*pMemBuffer == NULL) { tscError("%p failed to allocate memory", pSql); - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; return pRes->code; } @@ -650,7 +650,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr pSchema = (SSchema *)calloc(1, sizeof(SSchema) * size); if (pSchema == NULL) { tscError("%p failed to allocate memory", pSql); - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; return pRes->code; } @@ -678,7 +678,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr } if (createOrderDescriptor(pOrderDesc, pCmd, pModel) != TSDB_CODE_SUCCESS) { - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; return pRes->code; } diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c index 3fe2dde307..a71a8eca5e 100644 --- a/src/client/src/tscServer.c +++ b/src/client/src/tscServer.c @@ -179,7 +179,7 @@ int tscSendMsgToServer(SSqlObj *pSql) { char *pMsg = rpcMallocCont(pCmd->payloadLen); if (NULL == pMsg) { tscError("%p msg:%s malloc fail", pSql, taosMsg[pSql->cmd.msgType]); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } if (pSql->cmd.command < TSDB_SQL_MGMT) { @@ -234,11 +234,11 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) { } if (rpcMsg->pCont == NULL) { - rpcMsg->code = TSDB_CODE_NETWORK_UNAVAIL; + rpcMsg->code = TSDB_CODE_RPC_NETWORK_UNAVAIL; } else { STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0); - if (rpcMsg->code == TSDB_CODE_INVALID_TABLE_ID || rpcMsg->code == TSDB_CODE_INVALID_VGROUP_ID || - rpcMsg->code == TSDB_CODE_NETWORK_UNAVAIL) { + if (rpcMsg->code == TSDB_CODE_TDB_INVALID_TABLE_ID || rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID || + rpcMsg->code == TSDB_CODE_RPC_NETWORK_UNAVAIL) { /* * not_active_table: 1. the virtual node may fail to create table, since the procedure of create table is asynchronized, * the virtual node may have not create table till now, so try again by using the new metermeta. @@ -250,11 +250,11 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) { * not_active_session: db has been move to other node, the vnode does not exist on this dnode anymore. */ if (pCmd->command == TSDB_SQL_CONNECT) { - rpcMsg->code = TSDB_CODE_NETWORK_UNAVAIL; + rpcMsg->code = TSDB_CODE_RPC_NETWORK_UNAVAIL; rpcFreeCont(rpcMsg->pCont); return; } else if (pCmd->command == TSDB_SQL_HB) { - rpcMsg->code = TSDB_CODE_NOT_READY; + rpcMsg->code = TSDB_CODE_RPC_NOT_READY; rpcFreeCont(rpcMsg->pCont); return; } else if (pCmd->command == TSDB_SQL_META) { @@ -281,8 +281,8 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) { pRes->rspLen = 0; - if (pRes->code != TSDB_CODE_QUERY_CANCELLED) { - pRes->code = (rpcMsg->code != TSDB_CODE_SUCCESS) ? rpcMsg->code : TSDB_CODE_NETWORK_UNAVAIL; + if (pRes->code != TSDB_CODE_TSC_QUERY_CANCELLED) { + pRes->code = (rpcMsg->code != TSDB_CODE_SUCCESS) ? rpcMsg->code : TSDB_CODE_RPC_NETWORK_UNAVAIL; } else { tscTrace("%p query is cancelled, code:%d", pSql, tstrerror(pRes->code)); } @@ -292,7 +292,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) { pSql->retry = 0; } - if (pRes->code != TSDB_CODE_QUERY_CANCELLED) { + if (pRes->code != TSDB_CODE_TSC_QUERY_CANCELLED) { assert(rpcMsg->msgType == pCmd->msgType + 1); pRes->code = rpcMsg->code; pRes->rspType = rpcMsg->msgType; @@ -301,7 +301,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) { if (pRes->rspLen > 0 && rpcMsg->pCont) { char *tmp = (char *)realloc(pRes->pRsp, pRes->rspLen); if (tmp == NULL) { - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; } else { pRes->pRsp = tmp; memcpy(pRes->pRsp, rpcMsg->pCont, pRes->rspLen); @@ -333,7 +333,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) { if (pRes->code == TSDB_CODE_SUCCESS && tscProcessMsgRsp[pCmd->command]) rpcMsg->code = (*tscProcessMsgRsp[pCmd->command])(pSql); - if (rpcMsg->code != TSDB_CODE_ACTION_IN_PROGRESS) { + if (rpcMsg->code != TSDB_CODE_TSC_ACTION_IN_PROGRESS) { rpcMsg->code = pRes->code ? pRes->code : pRes->numOfRows; tscTrace("%p SQL result:%s res:%p", pSql, tstrerror(pRes->code), pSql); @@ -402,7 +402,7 @@ int tscProcessSql(SSqlObj *pSql) { tscTrace("%p SQL cmd:%s will be processed, name:%s, type:%d", pSql, sqlCmd[pCmd->command], name, type); if (pCmd->command < TSDB_SQL_MGMT) { // the pTableMetaInfo cannot be NULL if (pTableMetaInfo == NULL) { - pSql->res.code = TSDB_CODE_OTHERS; + pSql->res.code = TSDB_CODE_TSC_APP_ERROR; return pSql->res.code; } } else if (pCmd->command < TSDB_SQL_LOCAL) { @@ -433,7 +433,7 @@ void tscKillSTableQuery(SSqlObj *pSql) { * here, we cannot set the command = TSDB_SQL_KILL_QUERY. Otherwise, it may cause * sub-queries not correctly released and master sql object of metric query reaches an abnormal state. */ - pSql->pSubs[i]->res.code = TSDB_CODE_QUERY_CANCELLED; + pSql->pSubs[i]->res.code = TSDB_CODE_TSC_QUERY_CANCELLED; //taosStopRpcConn(pSql->pSubs[i]->thandle); } @@ -678,7 +678,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) { pSql, pTableMeta->sid, pTableMeta->uid, pTableMetaInfo->name, tscGetNumOfColumns(pTableMeta), pCol->colIndex, pColSchema->name); - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } pQueryMsg->colList[i].colId = htons(pColSchema->colId); @@ -796,7 +796,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) { pSql, pTableMeta->sid, pTableMeta->uid, pTableMetaInfo->name, total, numOfTagColumns, pCol->colIndex, pColSchema->name); - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } SColumnInfo* pTagCol = (SColumnInfo*) pMsg; @@ -886,7 +886,7 @@ int32_t tscBuildCreateDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) { pCmd->payloadLen = sizeof(SCMCreateDnodeMsg); if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMCreateDnodeMsg *pCreate = (SCMCreateDnodeMsg *)pCmd->payload; @@ -902,7 +902,7 @@ int32_t tscBuildAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) { pCmd->payloadLen = sizeof(SCMCreateAcctMsg); if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMCreateAcctMsg *pAlterMsg = (SCMCreateAcctMsg *)pCmd->payload; @@ -948,7 +948,7 @@ int32_t tscBuildUserMsg(SSqlObj *pSql, SSqlInfo *pInfo) { if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMCreateUserMsg *pAlterMsg = (SCMCreateUserMsg*)pCmd->payload; @@ -987,7 +987,7 @@ int32_t tscBuildDropDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) { if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMDropDbMsg *pDropDbMsg = (SCMDropDbMsg*)pCmd->payload; @@ -1006,7 +1006,7 @@ int32_t tscBuildDropTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) { if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMDropTableMsg *pDropTableMsg = (SCMDropTableMsg*)pCmd->payload; @@ -1023,7 +1023,7 @@ int32_t tscBuildDropDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) { pCmd->payloadLen = sizeof(SCMDropDnodeMsg); if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMDropDnodeMsg *pDrop = (SCMDropDnodeMsg *)pCmd->payload; @@ -1041,7 +1041,7 @@ int32_t tscBuildDropUserMsg(SSqlObj *pSql, SSqlInfo *pInfo) { if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMDropUserMsg *pDropMsg = (SCMDropUserMsg*)pCmd->payload; @@ -1058,7 +1058,7 @@ int32_t tscBuildDropAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) { if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMDropUserMsg *pDropMsg = (SCMDropUserMsg*)pCmd->payload; @@ -1074,7 +1074,7 @@ int32_t tscBuildUseDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) { if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMUseDbMsg *pUseDbMsg = (SCMUseDbMsg*)pCmd->payload; @@ -1093,7 +1093,7 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) { if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMShowMsg *pShowMsg = (SCMShowMsg*)pCmd->payload; @@ -1177,7 +1177,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) { size = tscEstimateCreateTableMsgLength(pSql, pInfo); if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) { tscError("%p failed to malloc for create table msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } @@ -1322,7 +1322,7 @@ int tscBuildRetrieveFromMgmtMsg(SSqlObj *pSql, SSqlInfo *pInfo) { if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0); @@ -1445,7 +1445,7 @@ int tscBuildConnectMsg(SSqlObj *pSql, SSqlInfo *pInfo) { if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) { tscError("%p failed to malloc for query msg", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } SCMConnectMsg *pConnect = (SCMConnectMsg*)pCmd->payload; @@ -1470,7 +1470,7 @@ int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) { if (len > 0) { tmpData = calloc(1, len); if (NULL == tmpData) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } // STagData is in binary format, strncpy is not available @@ -1792,17 +1792,17 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) { if (pMetaMsg->sid < 0 || pMetaMsg->vgroup.numOfIps < 0) { tscError("invalid meter vgId:%d, sid%d", pMetaMsg->vgroup.numOfIps, pMetaMsg->sid); - return TSDB_CODE_INVALID_VALUE; + return TSDB_CODE_TSC_INVALID_VALUE; } if (pMetaMsg->numOfTags > TSDB_MAX_TAGS || pMetaMsg->numOfTags < 0) { tscError("invalid numOfTags:%d", pMetaMsg->numOfTags); - return TSDB_CODE_INVALID_VALUE; + return TSDB_CODE_TSC_INVALID_VALUE; } if (pMetaMsg->numOfColumns > TSDB_MAX_COLUMNS || pMetaMsg->numOfColumns <= 0) { tscError("invalid numOfColumns:%d", pMetaMsg->numOfColumns); - return TSDB_CODE_INVALID_VALUE; + return TSDB_CODE_TSC_INVALID_VALUE; } for (int i = 0; i < pMetaMsg->vgroup.numOfIps; ++i) { @@ -1832,7 +1832,7 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) { // todo handle out of memory case if (pTableMetaInfo->pTableMeta == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } tscTrace("%p recv table meta: %"PRId64 ", tid:%d, name:%s", pSql, pTableMeta->uid, pTableMeta->sid, pTableMetaInfo->name); @@ -1853,9 +1853,9 @@ int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) { ieType = *rsp; if (ieType != TSDB_IE_TYPE_META) { tscError("invalid ie type:%d", ieType); - pSql->res.code = TSDB_CODE_INVALID_IE; + pSql->res.code = TSDB_CODE_TSC_INVALID_IE; pSql->res.numOfTotal = 0; - return TSDB_CODE_OTHERS; + return TSDB_CODE_TSC_APP_ERROR; } rsp++; @@ -1875,32 +1875,32 @@ int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) { if (pMeta->sid <= 0 || pMeta->vgId < 0) { tscError("invalid meter vgId:%d, sid%d", pMeta->vgId, pMeta->sid); - pSql->res.code = TSDB_CODE_INVALID_VALUE; + pSql->res.code = TSDB_CODE_TSC_INVALID_VALUE; pSql->res.numOfTotal = i; - return TSDB_CODE_OTHERS; + return TSDB_CODE_TSC_APP_ERROR; } // pMeta->numOfColumns = htons(pMeta->numOfColumns); // // if (pMeta->numOfTags > TSDB_MAX_TAGS || pMeta->numOfTags < 0) { // tscError("invalid tag value count:%d", pMeta->numOfTags); - // pSql->res.code = TSDB_CODE_INVALID_VALUE; + // pSql->res.code = TSDB_CODE_TSC_INVALID_VALUE; // pSql->res.numOfTotal = i; - // return TSDB_CODE_OTHERS; + // return TSDB_CODE_TSC_APP_ERROR; // } // // if (pMeta->numOfTags > TSDB_MAX_TAGS || pMeta->numOfTags < 0) { // tscError("invalid numOfTags:%d", pMeta->numOfTags); - // pSql->res.code = TSDB_CODE_INVALID_VALUE; + // pSql->res.code = TSDB_CODE_TSC_INVALID_VALUE; // pSql->res.numOfTotal = i; - // return TSDB_CODE_OTHERS; + // return TSDB_CODE_TSC_APP_ERROR; // } // // if (pMeta->numOfColumns > TSDB_MAX_COLUMNS || pMeta->numOfColumns < 0) { // tscError("invalid numOfColumns:%d", pMeta->numOfColumns); - // pSql->res.code = TSDB_CODE_INVALID_VALUE; + // pSql->res.code = TSDB_CODE_TSC_INVALID_VALUE; // pSql->res.numOfTotal = i; - // return TSDB_CODE_OTHERS; + // return TSDB_CODE_TSC_APP_ERROR; // } // // for (int j = 0; j < TSDB_REPLICA_MAX_NUM; ++j) { @@ -1965,7 +1965,7 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) { if (metricMetaList == NULL || sizes == NULL) { tfree(metricMetaList); tfree(sizes); - pSql->res.code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pSql->res.code = TSDB_CODE_TSC_OUT_OF_MEMORY; return pSql->res.code; } @@ -1984,7 +1984,7 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) { char *pBuf = calloc(1, size); if (pBuf == NULL) { - pSql->res.code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pSql->res.code = TSDB_CODE_TSC_OUT_OF_MEMORY; goto _error_clean; } @@ -2044,7 +2044,7 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) { // failed to put into cache if (pTableMetaInfo->pMetricMeta == NULL) { - pSql->res.code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pSql->res.code = TSDB_CODE_TSC_OUT_OF_MEMORY; goto _error_clean; } } @@ -2338,7 +2338,7 @@ static int32_t getTableMetaFromMgmt(SSqlObj *pSql, STableMetaInfo *pTableMetaInf SSqlObj *pNew = calloc(1, sizeof(SSqlObj)); if (NULL == pNew) { tscError("%p malloc failed for new sqlobj to get table meta", pSql); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } pNew->pTscObj = pSql->pTscObj; @@ -2355,7 +2355,7 @@ static int32_t getTableMetaFromMgmt(SSqlObj *pSql, STableMetaInfo *pTableMetaInf tscError("%p malloc failed for payload to get table meta", pSql); free(pNew); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } STableMetaInfo *pNewMeterMetaInfo = tscAddEmptyMetaInfo(pNewQueryInfo); @@ -2371,7 +2371,7 @@ static int32_t getTableMetaFromMgmt(SSqlObj *pSql, STableMetaInfo *pTableMetaInf int32_t code = tscProcessSql(pNew); if (code == TSDB_CODE_SUCCESS) { - code = TSDB_CODE_ACTION_IN_PROGRESS; + code = TSDB_CODE_TSC_ACTION_IN_PROGRESS; } return code; @@ -2468,7 +2468,7 @@ static bool allVgroupInfoRetrieved(SSqlCmd* pCmd, int32_t clauseIndex) { } int tscGetSTableVgroupInfo(SSqlObj *pSql, int32_t clauseIndex) { - int code = TSDB_CODE_NETWORK_UNAVAIL; + int code = TSDB_CODE_RPC_NETWORK_UNAVAIL; SSqlCmd *pCmd = &pSql->cmd; if (allVgroupInfoRetrieved(pCmd, clauseIndex)) { @@ -2505,7 +2505,7 @@ int tscGetSTableVgroupInfo(SSqlObj *pSql, int32_t clauseIndex) { pNew->param = pSql; code = tscProcessSql(pNew); if (code == TSDB_CODE_SUCCESS) { - code = TSDB_CODE_ACTION_IN_PROGRESS; + code = TSDB_CODE_TSC_ACTION_IN_PROGRESS; } return code; diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c index 5ff417f7d5..2a861ab533 100644 --- a/src/client/src/tscSql.c +++ b/src/client/src/tscSql.c @@ -57,12 +57,12 @@ SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con taos_init(); if (!validUserName(user)) { - terrno = TSDB_CODE_INVALID_ACCT; + terrno = TSDB_CODE_TSC_INVALID_USER_LENGTH; return NULL; } if (!validPassword(pass)) { - terrno = TSDB_CODE_INVALID_PASS; + terrno = TSDB_CODE_TSC_INVALID_PASS_LENGTH; return NULL; } @@ -73,13 +73,13 @@ SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con void *pDnodeConn = NULL; if (tscInitRpc(user, pass, &pDnodeConn) != 0) { - terrno = TSDB_CODE_NETWORK_UNAVAIL; + terrno = TSDB_CODE_RPC_NETWORK_UNAVAIL; return NULL; } STscObj *pObj = (STscObj *)calloc(1, sizeof(STscObj)); if (NULL == pObj) { - terrno = TSDB_CODE_CLI_OUT_OF_MEMORY; + terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; rpcClose(pDnodeConn); return NULL; } @@ -94,7 +94,7 @@ SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con int32_t len = strlen(db); /* db name is too long */ if (len > TSDB_DB_NAME_LEN) { - terrno = TSDB_CODE_INVALID_DB; + terrno = TSDB_CODE_TSC_INVALID_DB_LENGTH; rpcClose(pDnodeConn); free(pObj); return NULL; @@ -111,7 +111,7 @@ SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con SSqlObj *pSql = (SSqlObj *)calloc(1, sizeof(SSqlObj)); if (NULL == pSql) { - terrno = TSDB_CODE_CLI_OUT_OF_MEMORY; + terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; rpcClose(pDnodeConn); free(pObj); return NULL; @@ -132,7 +132,7 @@ SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con pSql->cmd.command = TSDB_SQL_CONNECT; if (TSDB_CODE_SUCCESS != tscAllocPayload(&pSql->cmd, TSDB_DEFAULT_PAYLOAD_SIZE)) { - terrno = TSDB_CODE_CLI_OUT_OF_MEMORY; + terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; rpcClose(pDnodeConn); free(pSql); free(pObj); @@ -265,14 +265,14 @@ void waitForQueryRsp(void *param, TAOS_RES *tres, int code) { TAOS_RES* taos_query(TAOS *taos, const char *sqlstr) { STscObj *pObj = (STscObj *)taos; if (pObj == NULL || pObj->signature != pObj) { - terrno = TSDB_CODE_DISCONNECTED; + terrno = TSDB_CODE_TSC_DISCONNECTED; return NULL; } int32_t sqlLen = strlen(sqlstr); if (sqlLen > tsMaxSQLStringLen) { tscError("sql string exceeds max length:%d", tsMaxSQLStringLen); - terrno = TSDB_CODE_INVALID_SQL; + terrno = TSDB_CODE_TSC_INVALID_SQL; return NULL; } @@ -281,7 +281,7 @@ TAOS_RES* taos_query(TAOS *taos, const char *sqlstr) { SSqlObj* pSql = calloc(1, sizeof(SSqlObj)); if (pSql == NULL) { tscError("failed to malloc sqlObj"); - terrno = TSDB_CODE_CLI_OUT_OF_MEMORY; + terrno = TSDB_CODE_TSC_OUT_OF_MEMORY; return NULL; } @@ -424,7 +424,7 @@ static void waitForRetrieveRsp(void *param, TAOS_RES *tres, int numOfRows) { TAOS_ROW taos_fetch_row(TAOS_RES *res) { SSqlObj *pSql = (SSqlObj *)res; if (pSql == NULL || pSql->signature != pSql) { - terrno = TSDB_CODE_DISCONNECTED; + terrno = TSDB_CODE_TSC_DISCONNECTED; return NULL; } @@ -462,7 +462,7 @@ int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) { int nRows = 0; if (pSql == NULL || pSql->signature != pSql) { - terrno = TSDB_CODE_DISCONNECTED; + terrno = TSDB_CODE_TSC_DISCONNECTED; *rows = NULL; return 0; } @@ -505,8 +505,8 @@ int taos_select_db(TAOS *taos, const char *db) { STscObj *pObj = (STscObj *)taos; if (pObj == NULL || pObj->signature != pObj) { - terrno = TSDB_CODE_DISCONNECTED; - return TSDB_CODE_DISCONNECTED; + terrno = TSDB_CODE_TSC_DISCONNECTED; + return TSDB_CODE_TSC_DISCONNECTED; } snprintf(sql, tListLen(sql), "use %s", db); @@ -587,7 +587,7 @@ int taos_errno(TAOS_RES *tres) { * why the sql is invalid */ static bool hasAdditionalErrorInfo(int32_t code, SSqlCmd *pCmd) { - if (code != TSDB_CODE_INVALID_SQL) { + if (code != TSDB_CODE_TSC_INVALID_SQL) { return false; } @@ -649,7 +649,7 @@ void taos_stop_query(TAOS_RES *res) { if (pSql->signature != pSql) return; tscTrace("%p start to cancel query", res); - pSql->res.code = TSDB_CODE_QUERY_CANCELLED; + pSql->res.code = TSDB_CODE_TSC_QUERY_CANCELLED; SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex); if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) { @@ -734,8 +734,8 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) int taos_validate_sql(TAOS *taos, const char *sql) { STscObj *pObj = (STscObj *)taos; if (pObj == NULL || pObj->signature != pObj) { - terrno = TSDB_CODE_DISCONNECTED; - return TSDB_CODE_DISCONNECTED; + terrno = TSDB_CODE_TSC_DISCONNECTED; + return TSDB_CODE_TSC_DISCONNECTED; } SSqlObj* pSql = calloc(1, sizeof(SSqlObj)); @@ -752,13 +752,13 @@ int taos_validate_sql(TAOS *taos, const char *sql) { int32_t sqlLen = strlen(sql); if (sqlLen > tsMaxSQLStringLen) { tscError("%p sql too long", pSql); - pRes->code = TSDB_CODE_INVALID_SQL; + pRes->code = TSDB_CODE_TSC_INVALID_SQL; return pRes->code; } pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1); if (pSql->sqlstr == NULL) { - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; tscError("%p failed to malloc sql string buffer", pSql); tscTrace("%p Valid SQL result:%d, %s pObj:%p", pSql, pRes->code, taos_errstr(taos), pObj); return pRes->code; @@ -790,7 +790,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t pCmd->command = TSDB_SQL_MULTI_META; pCmd->count = 0; - int code = TSDB_CODE_INVALID_TABLE_ID; + int code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH; char *str = (char *)tblNameList; SQueryInfo *pQueryInfo = NULL; @@ -824,7 +824,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t // Check if the table name available or not if (tscValidateName(&sToken) != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_INVALID_TABLE_ID; + code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH; sprintf(pCmd->payload, "table name is invalid"); return code; } @@ -834,7 +834,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t } if (++pCmd->count > TSDB_MULTI_METERMETA_MAX_NUM) { - code = TSDB_CODE_INVALID_TABLE_ID; + code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH; sprintf(pCmd->payload, "tables over the max number"); return code; } @@ -842,7 +842,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t if (payloadLen + strlen(pTableMetaInfo->name) + 128 >= pCmd->allocSize) { char *pNewMem = realloc(pCmd->payload, pCmd->allocSize + tblListLen); if (pNewMem == NULL) { - code = TSDB_CODE_CLI_OUT_OF_MEMORY; + code = TSDB_CODE_TSC_OUT_OF_MEMORY; sprintf(pCmd->payload, "failed to allocate memory"); return code; } @@ -866,8 +866,8 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) { STscObj *pObj = (STscObj *)taos; if (pObj == NULL || pObj->signature != pObj) { - terrno = TSDB_CODE_DISCONNECTED; - return TSDB_CODE_DISCONNECTED; + terrno = TSDB_CODE_TSC_DISCONNECTED; + return TSDB_CODE_TSC_DISCONNECTED; } SSqlObj* pSql = calloc(1, sizeof(SSqlObj)); @@ -884,13 +884,13 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) { int32_t tblListLen = strlen(tableNameList); if (tblListLen > MAX_TABLE_NAME_LENGTH) { tscError("%p tableNameList too long, length:%d, maximum allowed:%d", pSql, tblListLen, MAX_TABLE_NAME_LENGTH); - pRes->code = TSDB_CODE_INVALID_SQL; + pRes->code = TSDB_CODE_TSC_INVALID_SQL; return pRes->code; } char *str = calloc(1, tblListLen + 1); if (str == NULL) { - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; tscError("%p failed to malloc sql string buffer", pSql); return pRes->code; } diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c index 9e1628bb9b..4e92e9dd70 100644 --- a/src/client/src/tscStream.c +++ b/src/client/src/tscStream.c @@ -77,13 +77,13 @@ static void tscProcessStreamLaunchQuery(SSchedMsg *pMsg) { int code = tscGetTableMeta(pSql, pTableMetaInfo); pSql->res.code = code; - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return; if (code == 0 && UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) { code = tscGetSTableVgroupInfo(pSql, 0); pSql->res.code = code; - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return; } tscTansformSQLFuncForSTableQuery(pQueryInfo); @@ -480,7 +480,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p SSqlObj *pSql = (SSqlObj *)calloc(1, sizeof(SSqlObj)); if (pSql == NULL) { - setErrorInfo(pSql, TSDB_CODE_CLI_OUT_OF_MEMORY, NULL); + setErrorInfo(pSql, TSDB_CODE_TSC_OUT_OF_MEMORY, NULL); return NULL; } @@ -497,7 +497,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p pSql->sqlstr = strdup(sqlstr); if (pSql->sqlstr == NULL) { - setErrorInfo(pSql, TSDB_CODE_CLI_OUT_OF_MEMORY, NULL); + setErrorInfo(pSql, TSDB_CODE_TSC_OUT_OF_MEMORY, NULL); tfree(pSql); return NULL; @@ -512,7 +512,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p ret = tscAllocPayload(&pSql->cmd, TSDB_DEFAULT_PAYLOAD_SIZE); if (TSDB_CODE_SUCCESS != ret) { setErrorInfo(pSql, ret, NULL); - tscError("%p open stream failed, sql:%s, code:%d", pSql, sqlstr, TSDB_CODE_CLI_OUT_OF_MEMORY); + tscError("%p open stream failed, sql:%s, code:%d", pSql, sqlstr, TSDB_CODE_TSC_OUT_OF_MEMORY); tscFreeSqlObj(pSql); return NULL; } @@ -530,7 +530,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p SSqlStream *pStream = (SSqlStream *)calloc(1, sizeof(SSqlStream)); if (pStream == NULL) { - setErrorInfo(pSql, TSDB_CODE_CLI_OUT_OF_MEMORY, NULL); + setErrorInfo(pSql, TSDB_CODE_TSC_OUT_OF_MEMORY, NULL); tscError("%p open stream failed, sql:%s, reason:%s, code:%d", pSql, sqlstr, pCmd->payload, pRes->code); tscFreeSqlObj(pSql); diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c index f6cbe4a42e..9baf49ff21 100644 --- a/src/client/src/tscSub.c +++ b/src/client/src/tscSub.c @@ -124,7 +124,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char* strtolower(pSql->sqlstr, pSql->sqlstr); code = tsParseSql(pSql, false); - if (code == TSDB_CODE_ACTION_IN_PROGRESS) { + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) { // wait for the callback function to post the semaphore sem_wait(&pSql->rspSem); code = pSql->res.code; @@ -148,7 +148,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char* pSub->topic[sizeof(pSub->topic) - 1] = 0; pSub->progress = taosArrayInit(32, sizeof(SSubscriptionProgress)); if (pSub->progress == NULL) { - THROW(TSDB_CODE_CLI_OUT_OF_MEMORY); + THROW(TSDB_CODE_TSC_OUT_OF_MEMORY); } CLEANUP_EXECUTE(); @@ -324,7 +324,7 @@ void tscSaveSubscriptionProgress(void* sub) { TAOS_SUB *taos_subscribe(TAOS *taos, int restart, const char* topic, const char *sql, TAOS_SUBSCRIBE_CALLBACK fp, void *param, int interval) { STscObj* pObj = (STscObj*)taos; if (pObj == NULL || pObj->signature != pObj) { - terrno = TSDB_CODE_DISCONNECTED; + terrno = TSDB_CODE_TSC_DISCONNECTED; tscError("connection disconnected"); return NULL; } diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c index 1fdbd43408..2aad3eafc1 100644 --- a/src/client/src/tscSubquery.c +++ b/src/client/src/tscSubquery.c @@ -348,7 +348,7 @@ int32_t tscLaunchSecondPhaseSubqueries(SSqlObj* pSql) { //prepare the subqueries object failed, abort if (!success) { - pSql->res.code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pSql->res.code = TSDB_CODE_TSC_OUT_OF_MEMORY; tscError("%p failed to prepare subqueries objs for secondary phase query, numOfSub:%d, code:%d", pSql, pSql->numOfSubs, pSql->res.code); freeJoinSubqueryObj(pSql); @@ -698,7 +698,7 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) { if (pBuf == NULL) { tscError("%p invalid ts comp file from vnode, abort subquery, file size:%d", pSql, numOfRows); - pSupporter->pState->code = TSDB_CODE_APP_ERROR; // todo set the informative code + pSupporter->pState->code = TSDB_CODE_TSC_APP_ERROR; // todo set the informative code quitAllSubquery(pParentSql, pSupporter); return; } @@ -1019,13 +1019,13 @@ int32_t tscLaunchJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter if (pSql->pSubs == NULL) { pSql->pSubs = calloc(pSupporter->pState->numOfTotal, POINTER_BYTES); if (pSql->pSubs == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } } SSqlObj *pNew = createSubqueryObj(pSql, tableIndex, tscJoinQueryCallback, pSupporter, TSDB_SQL_SELECT, NULL); if (pNew == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } pSql->pSubs[pSql->numOfSubs++] = pNew; @@ -1163,7 +1163,7 @@ int32_t tscHandleMasterJoinQuery(SSqlObj* pSql) { if (pSupporter == NULL) { // failed to create support struct, abort current query tscError("%p tableIndex:%d, failed to allocate join support object, abort further query", pSql, i); pState->numOfCompleted = pQueryInfo->numOfTables - i - 1; - pSql->res.code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pSql->res.code = TSDB_CODE_TSC_OUT_OF_MEMORY; return pSql->res.code; } @@ -1171,7 +1171,7 @@ int32_t tscHandleMasterJoinQuery(SSqlObj* pSql) { int32_t code = tscLaunchJoinSubquery(pSql, i, pSupporter); if (code != TSDB_CODE_SUCCESS) { // failed to create subquery object, quit query tscDestroyJoinSupporter(pSupporter); - pSql->res.code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pSql->res.code = TSDB_CODE_TSC_OUT_OF_MEMORY; break; } @@ -1209,7 +1209,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) { SSqlCmd *pCmd = &pSql->cmd; // pRes->code check only serves in launching metric sub-queries - if (pRes->code == TSDB_CODE_QUERY_CANCELLED) { + if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) { pCmd->command = TSDB_SQL_RETRIEVE_LOCALMERGE; // enable the abort of kill super table function. return pRes->code; } @@ -1230,7 +1230,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) { int32_t ret = tscLocalReducerEnvCreate(pSql, &pMemoryBuf, &pDesc, &pModel, nBufferSize); if (ret != 0) { - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; tscQueueAsyncRes(pSql); return ret; } @@ -1291,14 +1291,14 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) { if (i < pSql->numOfSubs) { tscError("%p failed to prepare subquery structure and launch subqueries", pSql); - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; tscLocalReducerEnvDestroy(pMemoryBuf, pDesc, pModel, pSql->numOfSubs); doCleanupSubqueries(pSql, i, pState); return pRes->code; // free all allocated resource } - if (pRes->code == TSDB_CODE_QUERY_CANCELLED) { + if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) { tscLocalReducerEnvDestroy(pMemoryBuf, pDesc, pModel, pSql->numOfSubs); doCleanupSubqueries(pSql, i, pState); return pRes->code; @@ -1369,7 +1369,7 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO /* * kill current sub-query connection, which may retrieve data from vnodes; - * Here we get: pPObj->res.code == TSDB_CODE_QUERY_CANCELLED + * Here we get: pPObj->res.code == TSDB_CODE_TSC_QUERY_CANCELLED */ pSql->res.numOfRows = 0; trsupport->numOfRetry = MAX_NUM_OF_SUBQUERY_RETRY; // disable retry efforts @@ -1401,7 +1401,7 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO tscError("%p sub:%p failed to create new subquery sqlObj due to out of memory, abort retry", trsupport->pParentSqlObj, pSql); - pState->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pState->code = TSDB_CODE_TSC_OUT_OF_MEMORY; trsupport->numOfRetry = MAX_NUM_OF_SUBQUERY_RETRY; return; } @@ -1475,7 +1475,7 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p if (tsTotalTmpDirGB != 0 && tsAvailTmpDirGB < tsMinimalTmpDirGB) { tscError("%p sub:%p client disk space remain %.3f GB, need at least %.3f GB, stop query", pPObj, pSql, tsAvailTmpDirGB, tsMinimalTmpDirGB); - tscAbortFurtherRetryRetrieval(trsupport, pSql, TSDB_CODE_CLI_NO_DISKSPACE); + tscAbortFurtherRetryRetrieval(trsupport, pSql, TSDB_CODE_TSC_NO_DISKSPACE); return; } @@ -1484,7 +1484,7 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p int32_t ret = tscFlushTmpBuffer(trsupport->pExtMemBuffer[idx], pDesc, trsupport->localBuffer, pQueryInfo->groupbyExpr.orderType); if (ret != 0) { // set no disk space error info, and abort retry - return tscAbortFurtherRetryRetrieval(trsupport, pSql, TSDB_CODE_CLI_NO_DISKSPACE); + return tscAbortFurtherRetryRetrieval(trsupport, pSql, TSDB_CODE_TSC_NO_DISKSPACE); } // keep this value local variable, since the pState variable may be released by other threads, if atomic_add opertion @@ -1563,7 +1563,7 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR if (num > tsMaxNumOfOrderedResults && tscIsProjectionQueryOnSTable(pQueryInfo, 0)) { tscError("%p sub:%p num of OrderedRes is too many, max allowed:%" PRId64 " , current:%" PRId64, pPObj, pSql, tsMaxNumOfOrderedResults, num); - tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_SORTED_RES_TOO_MANY); + tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_TSC_SORTED_RES_TOO_MANY); return; } @@ -1578,14 +1578,14 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR if (tsTotalTmpDirGB != 0 && tsAvailTmpDirGB < tsMinimalTmpDirGB) { tscError("%p sub:%p client disk space remain %.3f GB, need at least %.3f GB, stop query", pPObj, pSql, tsAvailTmpDirGB, tsMinimalTmpDirGB); - tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_CLI_NO_DISKSPACE); + tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_TSC_NO_DISKSPACE); return; } int32_t ret = saveToBuffer(trsupport->pExtMemBuffer[idx], pDesc, trsupport->localBuffer, pRes->data, pRes->numOfRows, pQueryInfo->groupbyExpr.orderType); if (ret < 0) { // set no disk space error info, and abort retry - tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_CLI_NO_DISKSPACE); + tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_TSC_NO_DISKSPACE); } else if (pRes->completed) { tscAllDataRetrievedFromDnode(trsupport, pSql); @@ -1672,7 +1672,7 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) { tscError("%p sub:%p failed to create new subquery due to out of memory, abort retry, vgId:%d, orderOfSub:%d", trsupport->pParentSqlObj, pSql, pVgroup->vgId, trsupport->subqueryIndex); - pState->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pState->code = TSDB_CODE_TSC_OUT_OF_MEMORY; trsupport->numOfRetry = MAX_NUM_OF_SUBQUERY_RETRY; } else { SQueryInfo *pNewQueryInfo = tscGetQueryInfoDetail(&pNew->cmd, 0); @@ -1778,7 +1778,7 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) { if (i < pSql->numOfSubs) { tscError("%p failed to prepare subObj structure and launch sub-insertion", pSql); - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; return pRes->code; // free all allocated resource } diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c index 4c158ac77a..56dcc37e25 100644 --- a/src/client/src/tscUtil.c +++ b/src/client/src/tscUtil.c @@ -299,7 +299,7 @@ int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) { tfree(pRes->buffer); tfree(pRes->length); - pRes->code = TSDB_CODE_CLI_OUT_OF_MEMORY; + pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY; return pRes->code; } } @@ -576,7 +576,7 @@ int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOff STableDataBlocks* dataBuf = (STableDataBlocks*)calloc(1, sizeof(STableDataBlocks)); if (dataBuf == NULL) { tscError("failed to allocated memory, reason:%s", strerror(errno)); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } dataBuf->nAllocSize = (uint32_t)initialSize; @@ -711,7 +711,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SDataBlockList* pTableDataBlockLi tscDestroyBlockArrayList(pVnodeDataBlockList); tfree(dataBuf->pData); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } } @@ -782,12 +782,12 @@ int tscAllocPayload(SSqlCmd* pCmd, int size) { assert(pCmd->allocSize == 0); pCmd->payload = (char*)calloc(1, size); - if (pCmd->payload == NULL) return TSDB_CODE_CLI_OUT_OF_MEMORY; + if (pCmd->payload == NULL) return TSDB_CODE_TSC_OUT_OF_MEMORY; pCmd->allocSize = size; } else { if (pCmd->allocSize < size) { char* b = realloc(pCmd->payload, size); - if (b == NULL) return TSDB_CODE_CLI_OUT_OF_MEMORY; + if (b == NULL) return TSDB_CODE_TSC_OUT_OF_MEMORY; pCmd->payload = b; pCmd->allocSize = size; } @@ -1242,14 +1242,14 @@ static int32_t validateQuoteToken(SSQLToken* pToken) { } if (k != pToken->n || pToken->type != TK_ID) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return TSDB_CODE_SUCCESS; } int32_t tscValidateName(SSQLToken* pToken) { if (pToken->type != TK_STRING && pToken->type != TK_ID) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } char* sep = strnchr(pToken->z, TS_PATH_DELIMITER[0], pToken->n, true); @@ -1266,14 +1266,14 @@ int32_t tscValidateName(SSQLToken* pToken) { } else { sep = strnchr(pToken->z, TS_PATH_DELIMITER[0], pToken->n, true); if (sep == NULL) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } return tscValidateName(pToken); } } else { if (isNumber(pToken)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } } } else { // two part @@ -1286,15 +1286,15 @@ int32_t tscValidateName(SSQLToken* pToken) { pToken->n = tSQLGetToken(pToken->z, &pToken->type); if (pToken->z[pToken->n] != TS_PATH_DELIMITER[0]) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (pToken->type != TK_STRING && pToken->type != TK_ID) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (pToken->type == TK_STRING && validateQuoteToken(pToken) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } int32_t firstPartLen = pToken->n; @@ -1303,11 +1303,11 @@ int32_t tscValidateName(SSQLToken* pToken) { pToken->n = oldLen - (sep - pStr) - 1; int32_t len = tSQLGetToken(pToken->z, &pToken->type); if (len != pToken->n || (pToken->type != TK_STRING && pToken->type != TK_ID)) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } if (pToken->type == TK_STRING && validateQuoteToken(pToken) != TSDB_CODE_SUCCESS) { - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } // re-build the whole name string @@ -1576,7 +1576,7 @@ int32_t tscAddSubqueryInfo(SSqlCmd* pCmd) { size_t s = pCmd->numOfClause + 1; char* tmp = realloc(pCmd->pQueryInfo, s * POINTER_BYTES); if (tmp == NULL) { - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_TSC_OUT_OF_MEMORY; } pCmd->pQueryInfo = (SQueryInfo**)tmp; @@ -1944,8 +1944,8 @@ int16_t tscGetJoinTagColIndexByUid(STagCond* pTagCond, uint64_t uid) { bool tscIsUpdateQuery(SSqlObj* pSql) { if (pSql == NULL || pSql->signature != pSql) { - terrno = TSDB_CODE_DISCONNECTED; - return TSDB_CODE_DISCONNECTED; + terrno = TSDB_CODE_TSC_DISCONNECTED; + return TSDB_CODE_TSC_DISCONNECTED; } SSqlCmd* pCmd = &pSql->cmd; @@ -1962,7 +1962,7 @@ int32_t tscInvalidSQLErrMsg(char* msg, const char* additionalInfo, const char* s if (sql == NULL) { assert(additionalInfo != NULL); sprintf(msg, msgFormat1, additionalInfo); - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } char buf[64] = {0}; // only extract part of sql string @@ -1974,7 +1974,7 @@ int32_t tscInvalidSQLErrMsg(char* msg, const char* additionalInfo, const char* s sprintf(msg, msgFormat3, buf); // no additional information for invalid sql error } - return TSDB_CODE_INVALID_SQL; + return TSDB_CODE_TSC_INVALID_SQL; } bool tscHasReachLimitation(SQueryInfo* pQueryInfo, SSqlRes* pRes) { @@ -2143,7 +2143,7 @@ void tscGetResultColumnChr(SSqlRes* pRes, SFieldInfo* pFieldInfo, int32_t column void* malloc_throw(size_t size) { void* p = malloc(size); if (p == NULL) { - THROW(TSDB_CODE_CLI_OUT_OF_MEMORY); + THROW(TSDB_CODE_TSC_OUT_OF_MEMORY); } return p; } @@ -2151,7 +2151,7 @@ void* malloc_throw(size_t size) { void* calloc_throw(size_t nmemb, size_t size) { void* p = calloc(nmemb, size); if (p == NULL) { - THROW(TSDB_CODE_CLI_OUT_OF_MEMORY); + THROW(TSDB_CODE_TSC_OUT_OF_MEMORY); } return p; } @@ -2159,7 +2159,7 @@ void* calloc_throw(size_t nmemb, size_t size) { char* strdup_throw(const char* str) { char* p = strdup(str); if (p == NULL) { - THROW(TSDB_CODE_CLI_OUT_OF_MEMORY); + THROW(TSDB_CODE_TSC_OUT_OF_MEMORY); } return p; } @@ -2170,7 +2170,7 @@ int tscSetMgmtIpListFromCfg(const char *first, const char *second) { if (first && first[0] != 0) { if (strlen(first) >= TSDB_EP_LEN) { - terrno = TSDB_CODE_INVALID_FQDN; + terrno = TSDB_CODE_TSC_INVALID_FQDN; return -1; } taosGetFqdnPortFromEp(first, tscMgmtIpSet.fqdn[tscMgmtIpSet.numOfIps], &tscMgmtIpSet.port[tscMgmtIpSet.numOfIps]); @@ -2179,7 +2179,7 @@ int tscSetMgmtIpListFromCfg(const char *first, const char *second) { if (second && second[0] != 0) { if (strlen(second) >= TSDB_EP_LEN) { - terrno = TSDB_CODE_INVALID_FQDN; + terrno = TSDB_CODE_TSC_INVALID_FQDN; return -1; } taosGetFqdnPortFromEp(second, tscMgmtIpSet.fqdn[tscMgmtIpSet.numOfIps], &tscMgmtIpSet.port[tscMgmtIpSet.numOfIps]); @@ -2187,7 +2187,7 @@ int tscSetMgmtIpListFromCfg(const char *first, const char *second) { } if ( tscMgmtIpSet.numOfIps == 0) { - terrno = TSDB_CODE_INVALID_FQDN; + terrno = TSDB_CODE_TSC_INVALID_FQDN; return -1; } diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c index 673ba2a6f5..ed1ee3d3d7 100644 --- a/src/common/src/tglobal.c +++ b/src/common/src/tglobal.c @@ -234,7 +234,7 @@ bool taosCfgDynamicOptions(char *msg) { int32_t vint = 0; paGetToken(msg, &option, &olen); - if (olen == 0) return TSDB_CODE_INVALID_MSG_CONTENT; + if (olen == 0) return TSDB_CODE_COM_INVALID_CFG_MSG; paGetToken(option + olen + 1, &value, &vlen); if (vlen == 0) diff --git a/src/dnode/src/dnodeMPeer.c b/src/dnode/src/dnodeMPeer.c index e3ba5fcf01..71c2d0e65f 100644 --- a/src/dnode/src/dnodeMPeer.c +++ b/src/dnode/src/dnodeMPeer.c @@ -79,7 +79,7 @@ void dnodeCleanupMnodePeer() { int32_t dnodeAllocateMnodePqueue() { tsMPeerQueue = taosOpenQueue(); - if (tsMPeerQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (tsMPeerQueue == NULL) return TSDB_CODE_DND_OUT_OF_MEMORY; taosAddIntoQset(tsMPeerQset, tsMPeerQueue, NULL); @@ -125,7 +125,7 @@ static void dnodeFreeMnodePeerMsg(SMnodeMsg *pPeer) { } static void dnodeSendRpcMnodePeerRsp(SMnodeMsg *pPeer, int32_t code) { - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) return; SRpcMsg rpcRsp = { .handle = pPeer->rpcMsg.handle, diff --git a/src/dnode/src/dnodeMRead.c b/src/dnode/src/dnodeMRead.c index f22346b61c..cb02ffbb1d 100644 --- a/src/dnode/src/dnodeMRead.c +++ b/src/dnode/src/dnodeMRead.c @@ -84,7 +84,7 @@ void dnodeCleanupMnodeRead() { int32_t dnodeAllocateMnodeRqueue() { tsMReadQueue = taosOpenQueue(); - if (tsMReadQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (tsMReadQueue == NULL) return TSDB_CODE_DND_OUT_OF_MEMORY; taosAddIntoQset(tsMReadQset, tsMReadQueue, NULL); @@ -130,8 +130,8 @@ static void dnodeFreeMnodeReadMsg(SMnodeMsg *pRead) { } static void dnodeSendRpcMnodeReadRsp(SMnodeMsg *pRead, int32_t code) { - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; - if (code == TSDB_CODE_ACTION_NEED_REPROCESSED) { + if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_MND_ACTION_NEED_REPROCESSED) { // may be a auto create req, should put into write queue dnodeReprocessMnodeWriteMsg(pRead); return; diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c index 95fa9f0bdd..eb9d8653e5 100644 --- a/src/dnode/src/dnodeMWrite.c +++ b/src/dnode/src/dnodeMWrite.c @@ -81,7 +81,7 @@ void dnodeCleanupMnodeWrite() { int32_t dnodeAllocateMnodeWqueue() { tsMWriteQueue = taosOpenQueue(); - if (tsMWriteQueue == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (tsMWriteQueue == NULL) return TSDB_CODE_DND_OUT_OF_MEMORY; taosAddIntoQset(tsMWriteQset, tsMWriteQueue, NULL); @@ -128,8 +128,8 @@ static void dnodeFreeMnodeWriteMsg(SMnodeMsg *pWrite) { void dnodeSendRpcMnodeWriteRsp(void *pRaw, int32_t code) { SMnodeMsg *pWrite = pRaw; - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; - if (code == TSDB_CODE_ACTION_NEED_REPROCESSED) { + if (code == TSDB_CODE_MND_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_MND_ACTION_NEED_REPROCESSED) { dnodeReprocessMnodeWriteMsg(pWrite); return; } diff --git a/src/dnode/src/dnodeMgmt.c b/src/dnode/src/dnodeMgmt.c index 7c457defca..69e91fd4ee 100644 --- a/src/dnode/src/dnodeMgmt.c +++ b/src/dnode/src/dnodeMgmt.c @@ -180,7 +180,7 @@ void dnodeDispatchToMgmtQueue(SRpcMsg *pMsg) { SRpcMsg rsp; rsp.handle = pMsg->handle; rsp.pCont = NULL; - rsp.code = TSDB_CODE_SERV_OUT_OF_MEMORY; + rsp.code = TSDB_CODE_DND_OUT_OF_MEMORY; rpcSendResponse(&rsp); rpcFreeCont(pMsg->pCont); } @@ -202,7 +202,7 @@ static void *dnodeProcessMgmtQueue(void *param) { if (dnodeProcessMgmtMsgFp[pMsg->msgType]) { rsp.code = (*dnodeProcessMgmtMsgFp[pMsg->msgType])(pMsg); } else { - rsp.code = TSDB_CODE_MSG_NOT_PROCESSED; + rsp.code = TSDB_CODE_DND_MSG_NOT_PROCESSED; } rsp.handle = pMsg->handle; @@ -219,7 +219,7 @@ static void *dnodeProcessMgmtQueue(void *param) { static int32_t dnodeGetVnodeList(int32_t vnodeList[], int32_t *numOfVnodes) { DIR *dir = opendir(tsVnodeDir); if (dir == NULL) { - return TSDB_CODE_NO_WRITE_ACCESS; + return TSDB_CODE_DND_NO_WRITE_ACCESS; } *numOfVnodes = 0; diff --git a/src/dnode/src/dnodePeer.c b/src/dnode/src/dnodePeer.c index ea3af08d71..734a2b6aeb 100644 --- a/src/dnode/src/dnodePeer.c +++ b/src/dnode/src/dnodePeer.c @@ -89,7 +89,7 @@ static void dnodeProcessReqMsgFromDnode(SRpcMsg *pMsg, SRpcIpSet *pIpSet) { rspMsg.contLen = 0; if (dnodeGetRunStatus() != TSDB_DNODE_RUN_STATUS_RUNING) { - rspMsg.code = TSDB_CODE_NOT_READY; + rspMsg.code = TSDB_CODE_RPC_NOT_READY; rpcSendResponse(&rspMsg); rpcFreeCont(pMsg->pCont); dTrace("RPC %p, msg:%s is ignored since dnode not running", pMsg->handle, taosMsg[pMsg->msgType]); @@ -97,7 +97,7 @@ static void dnodeProcessReqMsgFromDnode(SRpcMsg *pMsg, SRpcIpSet *pIpSet) { } if (pMsg->pCont == NULL) { - rspMsg.code = TSDB_CODE_INVALID_MSG_LEN; + rspMsg.code = TSDB_CODE_DND_INVALID_MSG_LEN; rpcSendResponse(&rspMsg); return; } @@ -106,7 +106,7 @@ static void dnodeProcessReqMsgFromDnode(SRpcMsg *pMsg, SRpcIpSet *pIpSet) { (*dnodeProcessReqMsgFp[pMsg->msgType])(pMsg); } else { dTrace("RPC %p, message:%s not processed", pMsg->handle, taosMsg[pMsg->msgType]); - rspMsg.code = TSDB_CODE_MSG_NOT_PROCESSED; + rspMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED; rpcSendResponse(&rspMsg); rpcFreeCont(pMsg->pCont); } diff --git a/src/dnode/src/dnodeShell.c b/src/dnode/src/dnodeShell.c index 074f21f972..8eba1f3775 100644 --- a/src/dnode/src/dnodeShell.c +++ b/src/dnode/src/dnodeShell.c @@ -115,7 +115,7 @@ void dnodeProcessMsgFromShell(SRpcMsg *pMsg, SRpcIpSet *pIpSet) { if (dnodeGetRunStatus() != TSDB_DNODE_RUN_STATUS_RUNING) { dError("RPC %p, shell msg:%s is ignored since dnode not running", pMsg->handle, taosMsg[pMsg->msgType]); - rpcMsg.code = TSDB_CODE_NOT_READY; + rpcMsg.code = TSDB_CODE_RPC_NOT_READY; rpcSendResponse(&rpcMsg); rpcFreeCont(pMsg->pCont); return; @@ -131,7 +131,7 @@ void dnodeProcessMsgFromShell(SRpcMsg *pMsg, SRpcIpSet *pIpSet) { (*dnodeProcessShellMsgFp[pMsg->msgType])(pMsg); } else { dError("RPC %p, shell msg:%s is not processed", pMsg->handle, taosMsg[pMsg->msgType]); - rpcMsg.code = TSDB_CODE_MSG_NOT_PROCESSED; + rpcMsg.code = TSDB_CODE_DND_MSG_NOT_PROCESSED; rpcSendResponse(&rpcMsg); rpcFreeCont(pMsg->pCont); return; @@ -140,7 +140,7 @@ void dnodeProcessMsgFromShell(SRpcMsg *pMsg, SRpcIpSet *pIpSet) { static int dnodeRetrieveUserAuthInfo(char *user, char *spi, char *encrypt, char *secret, char *ckey) { int code = mnodeRetriveAuth(user, spi, encrypt, secret, ckey); - if (code != TSDB_CODE_NOT_READY) return code; + if (code != TSDB_CODE_RPC_NOT_READY) return code; SDMAuthMsg *pMsg = rpcMallocCont(sizeof(SDMAuthMsg)); strcpy(pMsg->user, user); diff --git a/src/dnode/src/dnodeVRead.c b/src/dnode/src/dnodeVRead.c index 72882b679b..7f1a5b2580 100644 --- a/src/dnode/src/dnodeVRead.c +++ b/src/dnode/src/dnodeVRead.c @@ -134,7 +134,7 @@ void dnodeDispatchToVnodeReadQueue(SRpcMsg *pMsg) { .handle = pMsg->handle, .pCont = NULL, .contLen = 0, - .code = TSDB_CODE_INVALID_VGROUP_ID, + .code = TSDB_CODE_VND_INVALID_VGROUP_ID, .msgType = 0 }; rpcSendResponse(&rpcRsp); @@ -189,8 +189,8 @@ static void dnodeContinueExecuteQuery(void* pVnode, void* qhandle, SReadMsg *pMs } void dnodeSendRpcReadRsp(void *pVnode, SReadMsg *pRead, int32_t code) { - if (code == TSDB_CODE_ACTION_IN_PROGRESS) return; - if (code == TSDB_CODE_ACTION_NEED_REPROCESSED) { + if (code == TSDB_CODE_VND_ACTION_IN_PROGRESS) return; + if (code == TSDB_CODE_VND_ACTION_NEED_REPROCESSED) { dnodeContinueExecuteQuery(pVnode, pRead->rspRet.qhandle, pRead); } diff --git a/src/dnode/src/dnodeVWrite.c b/src/dnode/src/dnodeVWrite.c index 4b26c05649..53533b8183 100644 --- a/src/dnode/src/dnodeVWrite.c +++ b/src/dnode/src/dnodeVWrite.c @@ -115,7 +115,7 @@ void dnodeDispatchToVnodeWriteQueue(SRpcMsg *pMsg) { .handle = pMsg->handle, .pCont = NULL, .contLen = 0, - .code = TSDB_CODE_INVALID_VGROUP_ID, + .code = TSDB_CODE_VND_INVALID_VGROUP_ID, .msgType = 0 }; rpcSendResponse(&rpcRsp); diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h index 62c97c92f1..c1c0d28253 100644 --- a/src/inc/taoserror.h +++ b/src/inc/taoserror.h @@ -46,135 +46,170 @@ static STaosError errors[] = { #endif // rpc -TAOS_DEFINE_ERROR(TSDB_CODE_ACTION_IN_PROGRESS, 0, 0x0001, "action in progress") -TAOS_DEFINE_ERROR(TSDB_CODE_ACTION_NEED_REPROCESSED, 0, 0x0003, "action need to be reprocessed") -TAOS_DEFINE_ERROR(TSDB_CODE_MSG_NOT_PROCESSED, 0, 0x0004, "message not processed") -TAOS_DEFINE_ERROR(TSDB_CODE_ALREADY_PROCESSED, 0, 0x0005, "message already processed") -TAOS_DEFINE_ERROR(TSDB_CODE_REDIRECT, 0, 0x0006, "redirect") -TAOS_DEFINE_ERROR(TSDB_CODE_LAST_SESSION_NOT_FINISHED, 0, 0x0007, "last session not finished") -TAOS_DEFINE_ERROR(TSDB_CODE_MAX_SESSIONS, 0, 0x0008, "max sessions") // too many sessions -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_SESSION_ID, 0, 0x0009, "invalid session id") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TRAN_ID, 0, 0x000A, "invalid transaction id") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_TYPE, 0, 0x000B, "invalid message type") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_LEN, 0, 0x000C, "invalid message length") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_CONTENT, 0, 0x000D, "invalid message content") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_MSG_VERSION, 0, 0x000E, "invalid message version") -TAOS_DEFINE_ERROR(TSDB_CODE_UNEXPECTED_RESPONSE, 0, 0x000F, "unexpected response") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_RESPONSE_TYPE, 0, 0x0010, "invalid response type") -TAOS_DEFINE_ERROR(TSDB_CODE_MISMATCHED_METER_ID, 0, 0x0011, "mismatched meter id") -TAOS_DEFINE_ERROR(TSDB_CODE_DISCONNECTED, 0, 0x0012, "disconnected") -TAOS_DEFINE_ERROR(TSDB_CODE_NOT_READY, 0, 0x0013, "not ready") // peer is not ready to process data -TAOS_DEFINE_ERROR(TSDB_CODE_TOO_SLOW, 0, 0x0014, "too slow") -TAOS_DEFINE_ERROR(TSDB_CODE_OTHERS, 0, 0x0015, "others") -TAOS_DEFINE_ERROR(TSDB_CODE_APP_ERROR, 0, 0x0016, "app error") -TAOS_DEFINE_ERROR(TSDB_CODE_ALREADY_THERE, 0, 0x0017, "already there") -TAOS_DEFINE_ERROR(TSDB_CODE_NO_RESOURCE, 0, 0x0018, "no resource") -TAOS_DEFINE_ERROR(TSDB_CODE_OPS_NOT_SUPPORT, 0, 0x0019, "operations not support") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_OPTION, 0, 0x001A, "invalid option") -TAOS_DEFINE_ERROR(TSDB_CODE_NOT_CONFIGURED, 0, 0x001B, "not configured") -TAOS_DEFINE_ERROR(TSDB_CODE_NETWORK_UNAVAIL, 0, 0x001C, "network unavailable") -TAOS_DEFINE_ERROR(TSDB_CODE_AUTH_REQUIRED, 0, 0x001D, "auth required") - -// db -TAOS_DEFINE_ERROR(TSDB_CODE_DB_NOT_SELECTED, 0, 0x0100, "db not selected") -TAOS_DEFINE_ERROR(TSDB_CODE_DB_ALREADY_EXIST, 0, 0x0101, "database aleady exist") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_DB, 0, 0x0102, "invalid database") -TAOS_DEFINE_ERROR(TSDB_CODE_MONITOR_DB_FORBIDDEN, 0, 0x0103, "monitor db forbidden") - -// user -TAOS_DEFINE_ERROR(TSDB_CODE_USER_ALREADY_EXIST, 0, 0x0180, "user already exist") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_USER, 0, 0x0181, "invalid user") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_PASS, 0, 0x0182, "invalid password") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_USER_FORMAT, 0, 0x0183, "invalid user format") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_PASS_FORMAT, 0, 0x0184, "invalid password format") -TAOS_DEFINE_ERROR(TSDB_CODE_NO_USER_FROM_CONN, 0, 0x0185, "can not get user from conn") - -// table -TAOS_DEFINE_ERROR(TSDB_CODE_TABLE_ALREADY_EXIST, 0, 0x0200, "table already exist") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_ID, 0, 0x0201, "invalid table id") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_TYPE, 0, 0x0202, "invalid table type") -TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUPER_TABLE, 0, 0x0203, "no super table") // operation only available for super table -TAOS_DEFINE_ERROR(TSDB_CODE_TAG_ALREAY_EXIST, 0, 0x0204, "tag already exist") -TAOS_DEFINE_ERROR(TSDB_CODE_TAG_NOT_EXIST, 0, 0x0205, "tag not exist") -TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_ALREAY_EXIST, 0, 0x0206, "field already exist") -TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_NOT_EXIST, 0, 0x0207, "field not exist") -TAOS_DEFINE_ERROR(TSDB_CODE_COL_NAME_TOO_LONG, 0, 0x0208, "column name too long") -TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TAGS, 0, 0x0209, "too many tags") - -// dnode & mnode -TAOS_DEFINE_ERROR(TSDB_CODE_NO_ENOUGH_DNODES, 0, 0x0280, "no enough dnodes") -TAOS_DEFINE_ERROR(TSDB_CODE_DNODE_ALREADY_EXIST, 0, 0x0281, "dnode already exist") -TAOS_DEFINE_ERROR(TSDB_CODE_DNODE_NOT_EXIST, 0, 0x0282, "dnode not exist") -TAOS_DEFINE_ERROR(TSDB_CODE_NO_MASTER, 0, 0x0283, "no master") -TAOS_DEFINE_ERROR(TSDB_CODE_NO_REMOVE_MASTER, 0, 0x0284, "no remove master") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_QUERY_ID, 0, 0x0285, "invalid query id") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_STREAM_ID, 0, 0x0286, "invalid stream id") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CONNECTION, 0, 0x0287, "invalid connection") -TAOS_DEFINE_ERROR(TSDB_CODE_SDB_ERROR, 0, 0x0288, "sdb error") -TAOS_DEFINE_ERROR(TSDB_CODE_TIMESTAMP_OUT_OF_RANGE, 0, 0x0289, "timestamp is out of range") - -// acct -TAOS_DEFINE_ERROR(TSDB_CODE_ACCT_ALREADY_EXIST, 0, 0x0300, "accounts already exist") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_ACCT, 0, 0x0301, "invalid account") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_ACCT_PARAMETER, 0, 0x0302, "invalid account parameter") -TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_ACCTS, 0, 0x0303, "too many accounts") -TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_USERS, 0, 0x0304, "too many users") -TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TABLES, 0, 0x0305, "too many tables") -TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_DATABASES, 0, 0x0306, "too many databases") -TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TIME_SERIES, 0, 0x0307, "not enough time series") - -// grant -TAOS_DEFINE_ERROR(TSDB_CODE_AUTH_FAILURE, 0, 0x0380, "auth failure") -TAOS_DEFINE_ERROR(TSDB_CODE_NO_RIGHTS, 0, 0x0381, "no rights") -TAOS_DEFINE_ERROR(TSDB_CODE_NO_WRITE_ACCESS, 0, 0x0382, "no write access") -TAOS_DEFINE_ERROR(TSDB_CODE_NO_READ_ACCESS, 0, 0x0383, "no read access") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_EXPIRED, 0, 0x0384, "grant expired") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_DNODE_LIMITED, 0, 0x0385, "grant dnode limited") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_ACCT_LIMITED, 0, 0x0386, "grant account limited") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_TIMESERIES_LIMITED, 0, 0x0387, "grant timeseries limited") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_DB_LIMITED, 0, 0x0388, "grant db limited") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_USER_LIMITED, 0, 0x0389, "grant user limited") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_CONN_LIMITED, 0, 0x038A, "grant conn limited") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_STREAM_LIMITED, 0, 0x038B, "grant stream limited") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_SPEED_LIMITED, 0, 0x038C, "grant speed limited") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_STORAGE_LIMITED, 0, 0x038D, "grant storage limited") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_QUERYTIME_LIMITED, 0, 0x038E, "grant query time limited") -TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_CPU_LIMITED, 0, 0x038F, "grant cpu limited") - -// server -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VGROUP_ID, 0, 0x0400, "invalid vgroup id") -TAOS_DEFINE_ERROR(TSDB_CODE_VG_INIT_FAILED, 0, 0x0402, "vgroup init failed") -TAOS_DEFINE_ERROR(TSDB_CODE_SERV_NO_DISKSPACE, 0, 0x0403, "server no diskspace") -TAOS_DEFINE_ERROR(TSDB_CODE_SERV_OUT_OF_MEMORY, 0, 0x0404, "server out of memory") -TAOS_DEFINE_ERROR(TSDB_CODE_NO_DISK_PERMISSIONS, 0, 0x0405, "no disk permissions") -TAOS_DEFINE_ERROR(TSDB_CODE_FILE_CORRUPTED, 0, 0x0406, "file corrupted") -TAOS_DEFINE_ERROR(TSDB_CODE_MEMORY_CORRUPTED, 0, 0x0407, "memory corrupted") -TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUCH_FILE_OR_DIR, 0, 0x0408, "no such file or directory") -TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_SHELL_CONNS, 0, 0x0409, "too many shell conns") - -// client -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CLIENT_VERSION, 0, 0x0481, "invalid client version") -TAOS_DEFINE_ERROR(TSDB_CODE_CLI_OUT_OF_MEMORY, 0, 0x0482, "client out of memory") -TAOS_DEFINE_ERROR(TSDB_CODE_CLI_NO_DISKSPACE, 0, 0x0483, "client no disk space") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TIME_STAMP, 0, 0x0484, "invalid timestamp") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_SQL, 0, 0x0485, "invalid sql") -TAOS_DEFINE_ERROR(TSDB_CODE_QUERY_CACHE_ERASED, 0, 0x0486, "query cache erased") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_QUERY_MSG, 0, 0x0487, "invalid query message") // failed to validate the sql expression msg by vnode -TAOS_DEFINE_ERROR(TSDB_CODE_SORTED_RES_TOO_MANY, 0, 0x0488, "sorted res too many") // too many result for ordered super table projection query -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_QHANDLE, 0, 0x0489, "invalid handle") -TAOS_DEFINE_ERROR(TSDB_CODE_QUERY_CANCELLED, 0, 0x048A, "query cancelled") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_IE, 0, 0x048B, "invalid ie") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_VALUE, 0, 0x048C, "invalid value") -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_FQDN, 0, 0x048D, "invalid FQDN") - -// others -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_FILE_FORMAT, 0, 0x0500, "invalid file format") - -// TSDB -TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CONFIG, 0, 0x0580, "invalid TSDB configuration") -TAOS_DEFINE_ERROR(TSDB_CODE_TAG_VER_OUT_OF_DATE, 0, 0x0581, "tag version is out of date") -TAOS_DEFINE_ERROR(TSDB_CODE_TABLE_SCHEMA_VERSION, 0, 0x0582, "invalid table schema version from client") - +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_ACTION_IN_PROGRESS, 0, 0x0001, "action in progress") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_AUTH_REQUIRED, 0, 0x0002, "auth required") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_AUTH_FAILURE, 0, 0x0003, "auth failure") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_REDIRECT, 0, 0x0004, "redirect") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_NOT_READY, 0, 0x0005, "not ready") // peer is not ready to process data +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_ALREADY_PROCESSED, 0, 0x0006, "message already processed") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_LAST_SESSION_NOT_FINISHED,0, 0x0007, "last session not finished") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_MISMATCHED_LINK_ID, 0, 0x0008, "mismatched meter id") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_TOO_SLOW, 0, 0x0009, "too slow") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_MAX_SESSIONS, 0, 0x000A, "max sessions") // too many sessions +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_NETWORK_UNAVAIL, 0, 0x000B, "network unavailable") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_APP_ERROR, 0, 0x000C, "rpc app error") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_UNEXPECTED_RESPONSE, 0, 0x000D, "unexpected response") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_INVALID_VALUE, 0, 0x000E, "invalid value") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_INVALID_TRAN_ID, 0, 0x000F, "invalid transaction id") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_INVALID_SESSION_ID, 0, 0x0010, "invalid session id") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_INVALID_MSG_TYPE, 0, 0x0011, "invalid message type") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_INVALID_RESPONSE_TYPE, 0, 0x0012, "invalid response type") +TAOS_DEFINE_ERROR(TSDB_CODE_RPC_INVALID_TIME_STAMP, 0, 0x0013, "invalid timestamp") + +//common & util +TAOS_DEFINE_ERROR(TSDB_CODE_COM_OPS_NOT_SUPPORT, 0, 0x0100, "operations not support") +TAOS_DEFINE_ERROR(TSDB_CODE_COM_MEMORY_CORRUPTED, 0, 0x0101, "memory corrupted") +TAOS_DEFINE_ERROR(TSDB_CODE_COM_OUT_OF_MEMORY, 0, 0x0102, "out of memory") +TAOS_DEFINE_ERROR(TSDB_CODE_COM_INVALID_CFG_MSG, 0, 0x0103, "invalid config message") + +//client +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_SQL, 0, 0x0200, "invalid sql") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_QHANDLE, 0, 0x0201, "client invalid qhandle") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TIME_STAMP, 0, 0x0202, "client time/server time can not be mixed up") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_VALUE, 0, 0x0203, "clientinvalid value") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_VERSION, 0, 0x0204, "client invalid version") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_IE, 0, 0x0205, "client invalid ie") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_FQDN, 0, 0x0206, "client invalid fqdn") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_USER_LENGTH, 0, 0x0207, "client invalid username length") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_PASS_LENGTH, 0, 0x0208, "client invalid password length") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_DB_LENGTH, 0, 0x0209, "client invalid database length") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH, 0, 0x020A, "client invalid table length") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_CONNECTION, 0, 0x020B, "client invalid connection") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_OUT_OF_MEMORY, 0, 0x020C, "client out of memory") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NO_DISKSPACE, 0, 0x020D, "client no disk space") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_QUERY_CACHE_ERASED, 0, 0x020E, "client query cache erased") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_QUERY_CANCELLED, 0, 0x020F, "client query cancelled") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_SORTED_RES_TOO_MANY, 0, 0x0210, "client sorted res too many") // too many result for ordered super table projection query +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_APP_ERROR, 0, 0x0211, "client app error") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_ACTION_IN_PROGRESS, 0, 0x0212, "client action in progress") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DISCONNECTED, 0, 0x0213, "client disconnected") +TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NO_WRITE_AUTH, 0, 0x0214, "client no write auth") + +// mnode +TAOS_DEFINE_ERROR(TSDB_CODE_MND_MSG_NOT_PROCESSED, 0, 0x0300, "mnode message not processed") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACTION_IN_PROGRESS, 0, 0x0301, "mnode action in progress") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACTION_NEED_REPROCESSED, 0, 0x0302, "mnode action need to be reprocessed") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_RIGHTS, 0, 0x0303, "mnode no rights") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_APP_ERROR, 0, 0x0304, "mnode app error") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CONNECTION, 0, 0x0305, "mnode invalid message connection") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_MSG_VERSION, 0, 0x0306, "mnode invalid message version") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_MSG_LEN, 0, 0x0307, "mnode invalid message length") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_MSG_TYPE, 0, 0x0308, "mnode invalid message type") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_SHELL_CONNS, 0, 0x0309, "mnode too many shell conns") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_OUT_OF_MEMORY, 0, 0x030A, "mnode out of memory") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_SHOWOBJ, 0, 0x030B, "mnode invalid show handle") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_QUERY_ID, 0, 0x030C, "mnode invalid query id") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_STREAM_ID, 0, 0x030D, "mnode invalid stream id") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_CONN_ID, 0, 0x030E, "mnode invalid connection") + +TAOS_DEFINE_ERROR(TSDB_CODE_MND_SDB_OBJ_ALREADY_THERE, 0, 0x0320, "mnode object already there") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_SDB_ERROR, 0, 0x0321, "mnode sdb error") + +TAOS_DEFINE_ERROR(TSDB_CODE_MND_DNODE_ALREADY_EXIST, 0, 0x0330, "mnode dnode already exist") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_DNODE_NOT_EXIST, 0, 0x0331, "mnode dnode not exist") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_VGROUP_NOT_EXIST, 0, 0x0332, "mnode vgroup not exist") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_REMOVE_MASTER, 0, 0x0333, "mnode cant not remove master") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_ENOUGH_DNODES, 0, 0x0334, "mnode no enough dnodes") + +TAOS_DEFINE_ERROR(TSDB_CODE_MND_ACCT_ALREADY_EXIST, 0, 0x0340, "mnode accounts already exist") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ACCT, 0, 0x0341, "mnode invalid account") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ACCT_PARA, 0, 0x0342, "mnode invalid account parameter") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_ACCT_OPTION, 0, 0x0343, "mnode invalid acct option") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_ACCTS, 0, 0x0344, "mnode too many accounts") + +TAOS_DEFINE_ERROR(TSDB_CODE_MND_USER_ALREADY_EXIST, 0, 0x0350, "mnode user already exist") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_USER, 0, 0x0351, "mnode invalid user") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_USER_FORMAT, 0, 0x0352, "mnode invalid user format") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_PASS_FORMAT, 0, 0x0353, "mnode invalid password format") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_NO_USER_FROM_CONN, 0, 0x0354, "mnode can not get user from conn") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_USERS, 0, 0x0355, "mnode too many users") + +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TABLE_ALREADY_EXIST, 0, 0x0360, "mnode table already exist") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_ID, 0, 0x0361, "mnode invalid table id") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TABLE_TYPE, 0, 0x0362, "mnode invalid table type") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TAGS, 0, 0x0363, "mnode too many tags") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TABLES, 0, 0x0364, "mnode too many tables") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_TIMESERIES, 0, 0x0365, "mnode not enough time series") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_NOT_SUPER_TABLE, 0, 0x0366, "mnode no super table") // operation only available for super table +TAOS_DEFINE_ERROR(TSDB_CODE_MND_COL_NAME_TOO_LONG, 0, 0x0367, "mnode column name too long") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TAG_ALREAY_EXIST, 0, 0x0368, "mnode tag already exist") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TAG_NOT_EXIST, 0, 0x0369, "mnode tag not exist") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_ALREAY_EXIST, 0, 0x036A, "mnode field already exist") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_FIELD_NOT_EXIST, 0, 0x036B, "mnode field not exist") + +TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_SELECTED, 0, 0x0380, "mnode db not selected") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_ALREADY_EXIST, 0, 0x0381, "mnode database aleady exist") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION, 0, 0x0382, "mnode invalid db option") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB, 0, 0x0383, "mnode invalid database") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_MONITOR_DB_FORBIDDEN, 0, 0x0384, "mnode monitor db forbidden") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_DATABASES, 0, 0x0385, "mnode too many databases") + +// dnode +TAOS_DEFINE_ERROR(TSDB_CODE_DND_MSG_NOT_PROCESSED, 0, 0x0400, "dnode message not processed") +TAOS_DEFINE_ERROR(TSDB_CODE_DND_OUT_OF_MEMORY, 0, 0x0401, "dnode out of memory") +TAOS_DEFINE_ERROR(TSDB_CODE_DND_NO_WRITE_ACCESS, 0, 0x0402, "dnode no disk write access") +TAOS_DEFINE_ERROR(TSDB_CODE_DND_INVALID_MSG_LEN, 0, 0x0403, "dnode invalid message length") +TAOS_DEFINE_ERROR(TSDB_CODE_DND_INVALID_FILE_FORMAT, 0, 0x0404, "dnode invalid file format") + +// vnode +TAOS_DEFINE_ERROR(TSDB_CODE_VND_ACTION_IN_PROGRESS, 0, 0x0500, "vnode action in progress") +TAOS_DEFINE_ERROR(TSDB_CODE_VND_MSG_NOT_PROCESSED, 0, 0x0501, "vnode message not processed") +TAOS_DEFINE_ERROR(TSDB_CODE_VND_ACTION_NEED_REPROCESSED, 0, 0x0502, "vnode action need to be reprocessed") +TAOS_DEFINE_ERROR(TSDB_CODE_VND_INVALID_VGROUP_ID, 0, 0x0503, "vnode invalid vgroup id") +TAOS_DEFINE_ERROR(TSDB_CODE_VND_INIT_FAILED, 0, 0x0504, "vnode init failed") +TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_DISKSPACE, 0, 0x0505, "vnode no diskspace") +TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_DISK_PERMISSIONS, 0, 0x0506, "vnode no disk permissions") +TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_SUCH_FILE_OR_DIR, 0, 0x0507, "vnode no such file or directory") +TAOS_DEFINE_ERROR(TSDB_CODE_VND_OUT_OF_MEMORY, 0, 0x0508, "vnode out of memory") +TAOS_DEFINE_ERROR(TSDB_CODE_VND_APP_ERROR, 0, 0x0509, "vnode app error") + +// tsdb +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_INVALID_TABLE_ID, 0, 0x0600, "tsdb invalid table id") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_INVALID_TABLE_TYPE, 0, 0x0601, "tsdb invalid table schema version") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_TABLE_SCHEMA_VERSION, 0, 0x0602, "tsdb invalid table schema version") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_TABLE_ALREADY_EXIST, 0, 0x0603, "tsdb table already exist") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_INVALID_CONFIG, 0, 0x0604, "tsdb invalid configuration") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_INIT_FAILED, 0, 0x0605, "tsdb init failed") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_NO_DISKSPACE, 0, 0x0606, "tsdb no diskspace") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_NO_DISK_PERMISSIONS, 0, 0x0607, "tsdb no disk permissions") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_FILE_CORRUPTED, 0, 0x0608, "tsdb file corrupted") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_OUT_OF_MEMORY, 0, 0x0609, "tsdb out of memory") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_TAG_VER_OUT_OF_DATE, 0, 0x060A, "tsdb tag version is out of date") +TAOS_DEFINE_ERROR(TSDB_CODE_TDB_TIMESTAMP_OUT_OF_RANGE, 0, 0x060B, "tsdb timestamp is out of range") + +// query +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_QHANDLE, 0, 0x0700, "query invalid handle") +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_MSG, 0, 0x0701, "query invalid message") // failed to validate the sql expression msg by vnode +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_NO_DISKSPACE, 0, 0x0702, "query no diskspace") +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_OUT_OF_MEMORY, 0, 0x0703, "query out of memory") +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_APP_ERROR, 0, 0x0704, "query app error") + +// gran +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_EXPIRED, 0, 0x0800, "grant expired") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_DNODE_LIMITED, 0, 0x0801, "grant dnode limited") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_ACCT_LIMITED, 0, 0x0802, "grant account limited") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_TIMESERIES_LIMITED, 0, 0x0803, "grant timeseries limited") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_DB_LIMITED, 0, 0x0804, "grant db limited") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_USER_LIMITED, 0, 0x0805, "grant user limited") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_CONN_LIMITED, 0, 0x0806, "grant conn limited") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_STREAM_LIMITED, 0, 0x0807, "grant stream limited") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_SPEED_LIMITED, 0, 0x0808, "grant speed limited") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_STORAGE_LIMITED, 0, 0x0809, "grant storage limited") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_QUERYTIME_LIMITED, 0, 0x080A, "grant query time limited") +TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_CPU_LIMITED, 0, 0x080B, "grant cpu limited") + +// sync 0x1400 +TAOS_DEFINE_ERROR(TSDB_CODE_SYN_INVALID_CONFIG, 0, 0x1900, "sync invalid configuration") #ifdef TAOS_ERROR_C }; diff --git a/src/kit/shell/src/shellEngine.c b/src/kit/shell/src/shellEngine.c index a01decc6c6..cc7957f6e1 100644 --- a/src/kit/shell/src/shellEngine.c +++ b/src/kit/shell/src/shellEngine.c @@ -862,7 +862,7 @@ void shellGetGrantInfo(void *con) { int code = taos_errno(pSql); if (code != TSDB_CODE_SUCCESS) { - if (code == TSDB_CODE_OPS_NOT_SUPPORT) { + if (code == TSDB_CODE_COM_OPS_NOT_SUPPORT) { fprintf(stdout, "Server is Community Edition, version is %s\n\n", taos_get_server_info(con)); } else { fprintf(stderr, "Failed to check Server Edition, Reason:%d:%s\n\n", taos_errno(con), taos_errstr(con)); diff --git a/src/mnode/src/mnodeAcct.c b/src/mnode/src/mnodeAcct.c index 3836bcea52..9634d2c645 100644 --- a/src/mnode/src/mnodeAcct.c +++ b/src/mnode/src/mnodeAcct.c @@ -70,7 +70,7 @@ static int32_t mnodeActionActionEncode(SSdbOper *pOper) { static int32_t mnodeAcctActionDecode(SSdbOper *pOper) { SAcctObj *pAcct = (SAcctObj *) calloc(1, sizeof(SAcctObj)); - if (pAcct == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (pAcct == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY; memcpy(pAcct, pOper->rowData, tsAcctUpdateSize); pOper->pObj = pAcct; diff --git a/src/mnode/src/mnodeBalance.c b/src/mnode/src/mnodeBalance.c index 64d3c6d7c7..14acffdb62 100644 --- a/src/mnode/src/mnodeBalance.c +++ b/src/mnode/src/mnodeBalance.c @@ -56,7 +56,7 @@ int32_t balanceAllocVnodes(SVgObj *pVgroup) { if (pSelDnode == NULL) { mError("failed to alloc vnode to vgroup"); - return TSDB_CODE_NO_ENOUGH_DNODES; + return TSDB_CODE_MND_NO_ENOUGH_DNODES; } pVgroup->vnodeGid[0].dnodeId = pSelDnode->dnodeId; diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c index 23e903dd25..90569b4a95 100644 --- a/src/mnode/src/mnodeDb.c +++ b/src/mnode/src/mnodeDb.c @@ -71,7 +71,7 @@ static int32_t mnodeDbActionInsert(SSdbOper *pOper) { } else { mError("db:%s, acct:%s info not exist in sdb", pDb->name, pDb->acct); - return TSDB_CODE_INVALID_ACCT; + return TSDB_CODE_MND_INVALID_ACCT; } return TSDB_CODE_SUCCESS; @@ -111,7 +111,7 @@ static int32_t mnodeDbActionEncode(SSdbOper *pOper) { static int32_t mnodeDbActionDecode(SSdbOper *pOper) { SDbObj *pDb = (SDbObj *) calloc(1, sizeof(SDbObj)); - if (pDb == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (pDb == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY; memcpy(pDb, pOper->rowData, tsDbUpdateSize); pOper->pObj = pDb; @@ -189,102 +189,102 @@ static int32_t mnodeCheckDbCfg(SDbCfg *pCfg) { if (pCfg->cacheBlockSize < TSDB_MIN_CACHE_BLOCK_SIZE || pCfg->cacheBlockSize > TSDB_MAX_CACHE_BLOCK_SIZE) { mError("invalid db option cacheBlockSize:%d valid range: [%d, %d]", pCfg->cacheBlockSize, TSDB_MIN_CACHE_BLOCK_SIZE, TSDB_MAX_CACHE_BLOCK_SIZE); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->totalBlocks < TSDB_MIN_TOTAL_BLOCKS || pCfg->totalBlocks > TSDB_MAX_TOTAL_BLOCKS) { mError("invalid db option totalBlocks:%d valid range: [%d, %d]", pCfg->totalBlocks, TSDB_MIN_TOTAL_BLOCKS, TSDB_MAX_TOTAL_BLOCKS); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->maxTables < TSDB_MIN_TABLES || pCfg->maxTables > TSDB_MAX_TABLES) { mError("invalid db option maxTables:%d valid range: [%d, %d]", pCfg->maxTables, TSDB_MIN_TABLES, TSDB_MAX_TABLES); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) { mError("invalid db option daysPerFile:%d valid range: [%d, %d]", pCfg->daysPerFile, TSDB_MIN_DAYS_PER_FILE, TSDB_MAX_DAYS_PER_FILE); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->daysToKeep < TSDB_MIN_KEEP || pCfg->daysToKeep > TSDB_MAX_KEEP) { mError("invalid db option daysToKeep:%d valid range: [%d, %d]", pCfg->daysToKeep, TSDB_MIN_KEEP, TSDB_MAX_KEEP); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->daysToKeep < pCfg->daysPerFile) { mError("invalid db option daysToKeep:%d should larger than daysPerFile:%d", pCfg->daysToKeep, pCfg->daysPerFile); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->daysToKeep2 < TSDB_MIN_KEEP || pCfg->daysToKeep2 > pCfg->daysToKeep) { mError("invalid db option daysToKeep2:%d valid range: [%d, %d]", pCfg->daysToKeep, TSDB_MIN_KEEP, pCfg->daysToKeep); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->daysToKeep1 < TSDB_MIN_KEEP || pCfg->daysToKeep1 > pCfg->daysToKeep2) { mError("invalid db option daysToKeep1:%d valid range: [%d, %d]", pCfg->daysToKeep1, TSDB_MIN_KEEP, pCfg->daysToKeep2); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->maxRowsPerFileBlock < TSDB_MIN_MAX_ROW_FBLOCK || pCfg->maxRowsPerFileBlock > TSDB_MAX_MAX_ROW_FBLOCK) { mError("invalid db option maxRowsPerFileBlock:%d valid range: [%d, %d]", pCfg->maxRowsPerFileBlock, TSDB_MIN_MAX_ROW_FBLOCK, TSDB_MAX_MAX_ROW_FBLOCK); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->minRowsPerFileBlock < TSDB_MIN_MIN_ROW_FBLOCK || pCfg->minRowsPerFileBlock > TSDB_MAX_MIN_ROW_FBLOCK) { mError("invalid db option minRowsPerFileBlock:%d valid range: [%d, %d]", pCfg->minRowsPerFileBlock, TSDB_MIN_MIN_ROW_FBLOCK, TSDB_MAX_MIN_ROW_FBLOCK); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->minRowsPerFileBlock > pCfg->maxRowsPerFileBlock) { mError("invalid db option minRowsPerFileBlock:%d should smaller than maxRowsPerFileBlock:%d", pCfg->minRowsPerFileBlock, pCfg->maxRowsPerFileBlock); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->commitTime < TSDB_MIN_COMMIT_TIME || pCfg->commitTime > TSDB_MAX_COMMIT_TIME) { mError("invalid db option commitTime:%d valid range: [%d, %d]", pCfg->commitTime, TSDB_MIN_COMMIT_TIME, TSDB_MAX_COMMIT_TIME); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) { mError("invalid db option timePrecision:%d valid value: [%d, %d]", pCfg->precision, TSDB_MIN_PRECISION, TSDB_MAX_PRECISION); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) { mError("invalid db option compression:%d valid range: [%d, %d]", pCfg->compression, TSDB_MIN_COMP_LEVEL, TSDB_MAX_COMP_LEVEL); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) { mError("invalid db option walLevel:%d, valid range: [%d, %d]", pCfg->walLevel, TSDB_MIN_WAL_LEVEL, TSDB_MAX_WAL_LEVEL); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->replications < TSDB_MIN_REPLICA_NUM || pCfg->replications > TSDB_MAX_REPLICA_NUM) { mError("invalid db option replications:%d valid range: [%d, %d]", pCfg->replications, TSDB_MIN_REPLICA_NUM, TSDB_MAX_REPLICA_NUM); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL) { mError("invalid db option walLevel:%d must be greater than 0", pCfg->walLevel); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } #ifndef _SYNC if (pCfg->replications != 1) { mError("invalid db option replications:%d can only be 1 in this version", pCfg->replications); - return TSDB_CODE_INVALID_OPTION; + return TSDB_CODE_MND_INVALID_DB_OPTION; } #endif @@ -320,7 +320,7 @@ static int32_t mnodeCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) { return TSDB_CODE_SUCCESS; } else { mError("db:%s, is already exist, ignore exist not set", pCreate->db); - return TSDB_CODE_DB_ALREADY_EXIST; + return TSDB_CODE_MND_DB_ALREADY_EXIST; } } @@ -366,7 +366,7 @@ static int32_t mnodeCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate) { code = sdbInsertRow(&oper); if (code != TSDB_CODE_SUCCESS) { tfree(pDb); - code = TSDB_CODE_SDB_ERROR; + code = TSDB_CODE_MND_SDB_ERROR; } return code; @@ -743,7 +743,7 @@ static int32_t mnodeSetDbDropping(SDbObj *pDb) { int32_t code = sdbUpdateRow(&oper); if (code != TSDB_CODE_SUCCESS) { - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } return code; @@ -766,7 +766,7 @@ static int32_t mnodeProcessCreateDbMsg(SMnodeMsg *pMsg) { if (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) { code = TSDB_CODE_GRANT_EXPIRED; } else if (!pMsg->pUser->writeAuth) { - code = TSDB_CODE_NO_RIGHTS; + code = TSDB_CODE_MND_NO_RIGHTS; } else { code = mnodeCreateDb(pMsg->pUser->pAcct, pCreate); if (code == TSDB_CODE_SUCCESS) { @@ -800,7 +800,7 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) { if (cacheBlockSize > 0 && cacheBlockSize != pDb->cfg.cacheBlockSize) { mError("db:%s, can't alter cache option", pDb->name); - terrno = TSDB_CODE_INVALID_OPTION; + terrno = TSDB_CODE_MND_INVALID_DB_OPTION; } if (totalBlocks > 0 && totalBlocks != pDb->cfg.totalBlocks) { @@ -813,13 +813,13 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) { newCfg.maxTables = maxTables; if (newCfg.maxTables < pDb->cfg.maxTables) { mError("db:%s, tables:%d should larger than origin:%d", pDb->name, newCfg.maxTables, pDb->cfg.maxTables); - terrno = TSDB_CODE_INVALID_OPTION; + terrno = TSDB_CODE_MND_INVALID_DB_OPTION; } } if (daysPerFile > 0 && daysPerFile != pDb->cfg.daysPerFile) { mError("db:%s, can't alter days option", pDb->name); - terrno = TSDB_CODE_INVALID_OPTION; + terrno = TSDB_CODE_MND_INVALID_DB_OPTION; } if (daysToKeep > 0 && daysToKeep != pDb->cfg.daysToKeep) { @@ -839,22 +839,22 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) { if (minRows > 0 && minRows != pDb->cfg.minRowsPerFileBlock) { mError("db:%s, can't alter minRows option", pDb->name); - terrno = TSDB_CODE_INVALID_OPTION; + terrno = TSDB_CODE_MND_INVALID_DB_OPTION; } if (maxRows > 0 && maxRows != pDb->cfg.maxRowsPerFileBlock) { mError("db:%s, can't alter maxRows option", pDb->name); - terrno = TSDB_CODE_INVALID_OPTION; + terrno = TSDB_CODE_MND_INVALID_DB_OPTION; } if (commitTime > 0 && commitTime != pDb->cfg.commitTime) { mError("db:%s, can't alter commitTime option", pDb->name); - terrno = TSDB_CODE_INVALID_OPTION; + terrno = TSDB_CODE_MND_INVALID_DB_OPTION; } if (precision > 0 && precision != pDb->cfg.precision) { mError("db:%s, can't alter precision option", pDb->name); - terrno = TSDB_CODE_INVALID_OPTION; + terrno = TSDB_CODE_MND_INVALID_DB_OPTION; } if (compression >= 0 && compression != pDb->cfg.compression) { @@ -864,7 +864,7 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) { if (walLevel > 0 && walLevel != pDb->cfg.walLevel) { mError("db:%s, can't alter walLevel option", pDb->name); - terrno = TSDB_CODE_INVALID_OPTION; + terrno = TSDB_CODE_MND_INVALID_DB_OPTION; } if (replications > 0 && replications != pDb->cfg.replications) { @@ -873,17 +873,17 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) { if (pDb->cfg.walLevel < TSDB_MIN_WAL_LEVEL) { mError("db:%s, walLevel:%d must be greater than 0", pDb->name, pDb->cfg.walLevel); - terrno = TSDB_CODE_INVALID_OPTION; + terrno = TSDB_CODE_MND_INVALID_DB_OPTION; } if (replications > mnodeGetDnodesNum()) { mError("db:%s, no enough dnode to change replica:%d", pDb->name, replications); - terrno = TSDB_CODE_NO_ENOUGH_DNODES; + terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES; } if (pDb->cfg.replications - replications >= 2) { mError("db:%s, replica number can't change from 3 to 1", pDb->name, replications); - terrno = TSDB_CODE_INVALID_OPTION; + terrno = TSDB_CODE_MND_INVALID_DB_OPTION; } } @@ -914,7 +914,7 @@ static int32_t mnodeAlterDb(SDbObj *pDb, SCMAlterDbMsg *pAlter) { int32_t code = sdbUpdateRow(&oper); if (code != TSDB_CODE_SUCCESS) { - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } } @@ -942,7 +942,7 @@ static int32_t mnodeProcessAlterDbMsg(SMnodeMsg *pMsg) { if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pAlter->db); if (pMsg->pDb == NULL) { mError("db:%s, failed to alter, invalid db", pAlter->db); - return TSDB_CODE_INVALID_DB; + return TSDB_CODE_MND_INVALID_DB; } int32_t code = mnodeAlterDb(pMsg->pDb, pAlter); @@ -966,7 +966,7 @@ static int32_t mnodeDropDb(SMnodeMsg *pMsg) { }; int32_t code = sdbDeleteRow(&oper); if (code != 0) { - code = TSDB_CODE_SDB_ERROR; + code = TSDB_CODE_MND_SDB_ERROR; } return code; @@ -983,13 +983,13 @@ static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg) { return TSDB_CODE_SUCCESS; } else { mError("db:%s, failed to drop, invalid db", pDrop->db); - return TSDB_CODE_INVALID_DB; + return TSDB_CODE_MND_INVALID_DB; } } if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) { mError("db:%s, can't drop monitor database", pDrop->db); - return TSDB_CODE_MONITOR_DB_FORBIDDEN; + return TSDB_CODE_MND_MONITOR_DB_FORBIDDEN; } int32_t code = mnodeSetDbDropping(pMsg->pDb); diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c index 506511ece9..6fd565b5e6 100644 --- a/src/mnode/src/mnodeDnode.c +++ b/src/mnode/src/mnodeDnode.c @@ -107,7 +107,7 @@ static int32_t mnodeDnodeActionEncode(SSdbOper *pOper) { static int32_t mnodeDnodeActionDecode(SSdbOper *pOper) { SDnodeObj *pDnode = (SDnodeObj *) calloc(1, sizeof(SDnodeObj)); - if (pDnode == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (pDnode == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY; memcpy(pDnode, pOper->rowData, tsDnodeUpdateSize); pOper->pObj = pDnode; @@ -249,7 +249,7 @@ static int32_t mnodeProcessCfgDnodeMsg(SMnodeMsg *pMsg) { } if (strcmp(pMsg->pUser->user, "root") != 0) { - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } SRpcIpSet ipSet = mnodeGetIpSetFromIp(pCmCfgDnode->ep); @@ -286,7 +286,7 @@ static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) { uint32_t version = htonl(pStatus->version); if (version != tsVersion) { mError("status msg version:%d not equal with mnode:%d", version, tsVersion); - return TSDB_CODE_INVALID_MSG_VERSION; + return TSDB_CODE_MND_INVALID_MSG_VERSION; } SDnodeObj *pDnode = NULL; @@ -294,13 +294,13 @@ static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) { pDnode = mnodeGetDnodeByEp(pStatus->dnodeEp); if (pDnode == NULL) { mTrace("dnode %s not created", pStatus->dnodeEp); - return TSDB_CODE_DNODE_NOT_EXIST; + return TSDB_CODE_MND_DNODE_NOT_EXIST; } } else { pDnode = mnodeGetDnode(pStatus->dnodeId); if (pDnode == NULL) { mError("dnode id:%d, %s not exist", pStatus->dnodeId, pStatus->dnodeEp); - return TSDB_CODE_DNODE_NOT_EXIST; + return TSDB_CODE_MND_DNODE_NOT_EXIST; } } @@ -347,7 +347,7 @@ static int32_t mnodeProcessDnodeStatusMsg(SMnodeMsg *pMsg) { int32_t contLen = sizeof(SDMStatusRsp) + TSDB_MAX_VNODES * sizeof(SDMVgroupAccess); SDMStatusRsp *pRsp = rpcMallocCont(contLen); if (pRsp == NULL) { - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } mnodeGetMnodeInfos(&pRsp->mnodes); @@ -376,7 +376,7 @@ static int32_t mnodeCreateDnode(char *ep) { if (pDnode != NULL) { mnodeDecDnodeRef(pDnode); mError("dnode:%d is alredy exist, %s:%d", pDnode->dnodeId, pDnode->dnodeFqdn, pDnode->dnodePort); - return TSDB_CODE_DNODE_ALREADY_EXIST; + return TSDB_CODE_MND_DNODE_ALREADY_EXIST; } pDnode = (SDnodeObj *) calloc(1, sizeof(SDnodeObj)); @@ -398,7 +398,7 @@ static int32_t mnodeCreateDnode(char *ep) { int dnodeId = pDnode->dnodeId; tfree(pDnode); mError("failed to create dnode:%d, result:%s", dnodeId, tstrerror(code)); - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } mPrint("dnode:%d is created, result:%s", pDnode->dnodeId, tstrerror(code)); @@ -414,7 +414,7 @@ int32_t mnodeDropDnode(SDnodeObj *pDnode) { int32_t code = sdbDeleteRow(&oper); if (code != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_SDB_ERROR; + code = TSDB_CODE_MND_SDB_ERROR; } mLPrint("dnode:%d, is dropped from cluster, result:%s", pDnode->dnodeId, tstrerror(code)); @@ -425,13 +425,13 @@ static int32_t mnodeDropDnodeByEp(char *ep) { SDnodeObj *pDnode = mnodeGetDnodeByEp(ep); if (pDnode == NULL) { mError("dnode:%s, is not exist", ep); - return TSDB_CODE_DNODE_NOT_EXIST; + return TSDB_CODE_MND_DNODE_NOT_EXIST; } mnodeDecDnodeRef(pDnode); if (strcmp(pDnode->dnodeEp, dnodeGetMnodeMasterEp()) == 0) { mError("dnode:%d, can't drop dnode:%s which is master", pDnode->dnodeId, ep); - return TSDB_CODE_NO_REMOVE_MASTER; + return TSDB_CODE_MND_NO_REMOVE_MASTER; } mPrint("dnode:%d, start to drop it", pDnode->dnodeId); @@ -446,7 +446,7 @@ static int32_t mnodeProcessCreateDnodeMsg(SMnodeMsg *pMsg) { SCMCreateDnodeMsg *pCreate = pMsg->rpcMsg.pCont; if (strcmp(pMsg->pUser->user, "root") != 0) { - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } else { int32_t code = mnodeCreateDnode(pCreate->ep); @@ -466,7 +466,7 @@ static int32_t mnodeProcessDropDnodeMsg(SMnodeMsg *pMsg) { SCMDropDnodeMsg *pDrop = pMsg->rpcMsg.pCont; if (strcmp(pMsg->pUser->user, "root") != 0) { - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } else { int32_t code = mnodeDropDnodeByEp(pDrop->ep); @@ -486,7 +486,7 @@ static int32_t mnodeGetDnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pC if (strcmp(pUser->pAcct->user, "root") != 0) { mnodeDecUserRef(pUser); - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } int32_t cols = 0; @@ -615,7 +615,7 @@ static int32_t mnodeGetModuleMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *p if (strcmp(pUser->user, "root") != 0) { mnodeDecUserRef(pUser); - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } SSchema *pSchema = pMeta->schema; @@ -725,7 +725,7 @@ static int32_t mnodeGetConfigMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *p if (strcmp(pUser->user, "root") != 0) { mnodeDecUserRef(pUser); - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } SSchema *pSchema = pMeta->schema; @@ -812,7 +812,7 @@ static int32_t mnodeGetVnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pC if (strcmp(pUser->user, "root") != 0) { mnodeDecUserRef(pUser); - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } SSchema *pSchema = pMeta->schema; diff --git a/src/mnode/src/mnodeInt.c b/src/mnode/src/mnodeInt.c index 1cb421bef7..c2dd46d981 100644 --- a/src/mnode/src/mnodeInt.c +++ b/src/mnode/src/mnodeInt.c @@ -41,7 +41,7 @@ void mnodeCreateMsg(SMnodeMsg *pMsg, SRpcMsg *rpcMsg) { int32_t mnodeInitMsg(SMnodeMsg *pMsg) { pMsg->pUser = mnodeGetUserFromConn(pMsg->rpcMsg.handle); if (pMsg->pUser == NULL) { - return TSDB_CODE_INVALID_USER; + return TSDB_CODE_MND_INVALID_USER; } return TSDB_CODE_SUCCESS; diff --git a/src/mnode/src/mnodeMnode.c b/src/mnode/src/mnodeMnode.c index de1826a174..43ee45f3b1 100644 --- a/src/mnode/src/mnodeMnode.c +++ b/src/mnode/src/mnodeMnode.c @@ -63,7 +63,7 @@ static int32_t mnodeMnodeActionDestroy(SSdbOper *pOper) { static int32_t mnodeMnodeActionInsert(SSdbOper *pOper) { SMnodeObj *pMnode = pOper->pObj; SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId); - if (pDnode == NULL) return TSDB_CODE_DNODE_NOT_EXIST; + if (pDnode == NULL) return TSDB_CODE_MND_DNODE_NOT_EXIST; pDnode->isMgmt = true; mnodeDecDnodeRef(pDnode); @@ -75,7 +75,7 @@ static int32_t mnodeMnodeActionDelete(SSdbOper *pOper) { SMnodeObj *pMnode = pOper->pObj; SDnodeObj *pDnode = mnodeGetDnode(pMnode->mnodeId); - if (pDnode == NULL) return TSDB_CODE_DNODE_NOT_EXIST; + if (pDnode == NULL) return TSDB_CODE_MND_DNODE_NOT_EXIST; pDnode->isMgmt = false; mnodeDecDnodeRef(pDnode); @@ -103,7 +103,7 @@ static int32_t mnodeMnodeActionEncode(SSdbOper *pOper) { static int32_t mnodeMnodeActionDecode(SSdbOper *pOper) { SMnodeObj *pMnode = calloc(1, sizeof(SMnodeObj)); - if (pMnode == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (pMnode == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY; memcpy(pMnode, pOper->rowData, tsMnodeUpdateSize); pOper->pObj = pMnode; @@ -285,7 +285,7 @@ int32_t mnodeAddMnode(int32_t dnodeId) { int32_t code = sdbInsertRow(&oper); if (code != TSDB_CODE_SUCCESS) { tfree(pMnode); - code = TSDB_CODE_SDB_ERROR; + code = TSDB_CODE_MND_SDB_ERROR; } mnodeUpdateMnodeIpSet(); @@ -307,7 +307,7 @@ void mnodeDropMnodeLocal(int32_t dnodeId) { int32_t mnodeDropMnode(int32_t dnodeId) { SMnodeObj *pMnode = mnodeGetMnode(dnodeId); if (pMnode == NULL) { - return TSDB_CODE_DNODE_NOT_EXIST; + return TSDB_CODE_MND_DNODE_NOT_EXIST; } SSdbOper oper = { @@ -318,7 +318,7 @@ int32_t mnodeDropMnode(int32_t dnodeId) { int32_t code = sdbDeleteRow(&oper); if (code != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_SDB_ERROR; + code = TSDB_CODE_MND_SDB_ERROR; } sdbDecRef(tsMnodeSdb, pMnode); @@ -335,7 +335,7 @@ static int32_t mnodeGetMnodeMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pC if (strcmp(pUser->pAcct->user, "root") != 0) { mnodeDecUserRef(pUser); - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } int32_t cols = 0; diff --git a/src/mnode/src/mnodePeer.c b/src/mnode/src/mnodePeer.c index d3699948f2..9aefc73b77 100644 --- a/src/mnode/src/mnodePeer.c +++ b/src/mnode/src/mnodePeer.c @@ -48,7 +48,7 @@ void mnodeAddPeerRspHandle(uint8_t msgType, void (*fp)(SRpcMsg *rpcMsg)) { int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) { if (pMsg->rpcMsg.pCont == NULL) { mError("%p, msg:%s in mpeer queue, content is null", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); - return TSDB_CODE_INVALID_MSG_LEN; + return TSDB_CODE_MND_INVALID_MSG_LEN; } if (!sdbIsMaster()) { @@ -63,12 +63,12 @@ int32_t mnodeProcessPeerReq(SMnodeMsg *pMsg) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } - return TSDB_CODE_REDIRECT; + return TSDB_CODE_RPC_REDIRECT; } if (tsMnodeProcessPeerMsgFp[pMsg->rpcMsg.msgType] == NULL) { mError("%p, msg:%s in mpeer queue, not processed", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); - return TSDB_CODE_MSG_NOT_PROCESSED; + return TSDB_CODE_MND_MSG_NOT_PROCESSED; } return (*tsMnodeProcessPeerMsgFp[pMsg->rpcMsg.msgType])(pMsg); diff --git a/src/mnode/src/mnodeProfile.c b/src/mnode/src/mnodeProfile.c index 49f79a54f1..541fc9cbd8 100644 --- a/src/mnode/src/mnodeProfile.c +++ b/src/mnode/src/mnodeProfile.c @@ -84,7 +84,7 @@ SConnObj *mnodeCreateConn(char *user, uint32_t ip, uint16_t port) { if (connSize > tsMaxShellConns) { mError("failed to create conn for user:%s ip:%s:%u, conns:%d larger than maxShellConns:%d, ", user, taosIpStr(ip), port, connSize, tsMaxShellConns); - terrno = TSDB_CODE_TOO_MANY_SHELL_CONNS; + terrno = TSDB_CODE_MND_TOO_MANY_SHELL_CONNS; return NULL; } @@ -168,7 +168,7 @@ static void *mnodeGetNextConn(SHashMutableIterator *pIter, SConnObj **pConn) { static int32_t mnodeGetConnsMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) return 0; - if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS; + if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_MND_NO_RIGHTS; int32_t cols = 0; SSchema *pSchema = pMeta->schema; @@ -282,7 +282,7 @@ int32_t mnodeSaveQueryStreamList(SConnObj *pConn, SCMHeartBeatMsg *pHBMsg) { static int32_t mnodeGetQueryMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) return 0; - if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS; + if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_MND_NO_RIGHTS; int32_t cols = 0; SSchema *pSchema = pMeta->schema; @@ -391,7 +391,7 @@ static int32_t mnodeRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, v static int32_t mnodeGetStreamMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) return 0; - if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS; + if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_MND_NO_RIGHTS; int32_t cols = 0; SSchema *pSchema = pMeta->schema; @@ -519,7 +519,7 @@ static int32_t mnodeRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, v static int32_t mnodeProcessKillQueryMsg(SMnodeMsg *pMsg) { SUserObj *pUser = pMsg->pUser; - if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS; + if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_MND_NO_RIGHTS; SCMKillQueryMsg *pKill = pMsg->rpcMsg.pCont; mPrint("kill query msg is received, queryId:%s", pKill->queryId); @@ -530,7 +530,7 @@ static int32_t mnodeProcessKillQueryMsg(SMnodeMsg *pMsg) { if (queryIdStr == NULL || connIdStr == NULL) { mPrint("failed to kill query, queryId:%s", pKill->queryId); - return TSDB_CODE_INVALID_QUERY_ID; + return TSDB_CODE_MND_INVALID_QUERY_ID; } int32_t queryId = (int32_t)strtol(queryIdStr, NULL, 10); @@ -538,7 +538,7 @@ static int32_t mnodeProcessKillQueryMsg(SMnodeMsg *pMsg) { SConnObj *pConn = taosCacheAcquireByName(tsMnodeConnCache, connIdStr); if (pConn == NULL) { mError("connId:%s, failed to kill queryId:%d, conn not exist", connIdStr, queryId); - return TSDB_CODE_INVALID_CONNECTION; + return TSDB_CODE_MND_INVALID_CONN_ID; } else { mPrint("connId:%s, queryId:%d is killed by user:%s", connIdStr, queryId, pUser->user); pConn->queryId = queryId; @@ -549,7 +549,7 @@ static int32_t mnodeProcessKillQueryMsg(SMnodeMsg *pMsg) { static int32_t mnodeProcessKillStreamMsg(SMnodeMsg *pMsg) { SUserObj *pUser = pMsg->pUser; - if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS; + if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_MND_NO_RIGHTS; SCMKillQueryMsg *pKill = pMsg->rpcMsg.pCont; mPrint("kill stream msg is received, streamId:%s", pKill->queryId); @@ -560,7 +560,7 @@ static int32_t mnodeProcessKillStreamMsg(SMnodeMsg *pMsg) { if (streamIdStr == NULL || connIdStr == NULL) { mPrint("failed to kill stream, streamId:%s", pKill->queryId); - return TSDB_CODE_INVALID_STREAM_ID; + return TSDB_CODE_MND_INVALID_STREAM_ID; } int32_t streamId = (int32_t)strtol(streamIdStr, NULL, 10); @@ -568,7 +568,7 @@ static int32_t mnodeProcessKillStreamMsg(SMnodeMsg *pMsg) { SConnObj *pConn = taosCacheAcquireByName(tsMnodeConnCache, connIdStr); if (pConn == NULL) { mError("connId:%s, failed to kill streamId:%d, conn not exist", connIdStr, streamId); - return TSDB_CODE_INVALID_CONNECTION; + return TSDB_CODE_MND_INVALID_CONN_ID; } else { mPrint("connId:%s, streamId:%d is killed by user:%s", connIdStr, streamId, pUser->user); pConn->streamId = streamId; @@ -579,13 +579,13 @@ static int32_t mnodeProcessKillStreamMsg(SMnodeMsg *pMsg) { static int32_t mnodeProcessKillConnectionMsg(SMnodeMsg *pMsg) { SUserObj *pUser = pMsg->pUser; - if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_NO_RIGHTS; + if (strcmp(pUser->user, "root") != 0) return TSDB_CODE_MND_NO_RIGHTS; SCMKillConnMsg *pKill = pMsg->rpcMsg.pCont; SConnObj * pConn = taosCacheAcquireByName(tsMnodeConnCache, pKill->queryId); if (pConn == NULL) { mError("connId:%s, failed to kill, conn not exist", pKill->queryId); - return TSDB_CODE_INVALID_CONNECTION; + return TSDB_CODE_MND_INVALID_CONN_ID; } else { mPrint("connId:%s, is killed by user:%s", pKill->queryId, pUser->user); pConn->killed = 1; diff --git a/src/mnode/src/mnodeRead.c b/src/mnode/src/mnodeRead.c index 0ee917f2d1..2c1f204277 100644 --- a/src/mnode/src/mnodeRead.c +++ b/src/mnode/src/mnodeRead.c @@ -44,7 +44,7 @@ void mnodeAddReadMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *pMsg)) { int32_t mnodeProcessRead(SMnodeMsg *pMsg) { if (pMsg->rpcMsg.pCont == NULL) { mError("%p, msg:%s in mread queue, content is null", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); - return TSDB_CODE_INVALID_MSG_LEN; + return TSDB_CODE_MND_INVALID_MSG_LEN; } if (!sdbIsMaster()) { @@ -59,12 +59,12 @@ int32_t mnodeProcessRead(SMnodeMsg *pMsg) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } - return TSDB_CODE_REDIRECT; + return TSDB_CODE_RPC_REDIRECT; } if (tsMnodeProcessReadMsgFp[pMsg->rpcMsg.msgType] == NULL) { mError("%p, msg:%s in mread queue, not processed", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); - return TSDB_CODE_MSG_NOT_PROCESSED; + return TSDB_CODE_MND_MSG_NOT_PROCESSED; } int32_t code = mnodeInitMsg(pMsg); diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c index 51b5fb0d2d..b9033cdf3c 100644 --- a/src/mnode/src/mnodeSdb.c +++ b/src/mnode/src/mnodeSdb.c @@ -518,7 +518,7 @@ static int sdbWrite(void *param, void *data, int type) { sdbError("table:%s, failed to restore %s record:%s from wal, version:%" PRId64 " too large, sdb version:%" PRId64, pTable->tableName, sdbGetActionStr(action), sdbGetKeyStr(pTable, pHead->cont), pHead->version, tsSdbObj.version); - return TSDB_CODE_OTHERS; + return TSDB_CODE_MND_APP_ERROR; } else { tsSdbObj.version = pHead->version; } @@ -561,7 +561,7 @@ static int sdbWrite(void *param, void *data, int type) { SSdbOper oper = {.rowSize = pHead->len, .rowData = pHead->cont, .table = pTable}; code = (*pTable->decodeFp)(&oper); return sdbUpdateHash(pTable, &oper); - } else { return TSDB_CODE_INVALID_MSG_TYPE; } + } else { return TSDB_CODE_MND_INVALID_MSG_TYPE; } } int32_t sdbInsertRow(SSdbOper *pOper) { @@ -571,7 +571,7 @@ int32_t sdbInsertRow(SSdbOper *pOper) { if (sdbGetRowFromObj(pTable, pOper->pObj)) { sdbError("table:%s, failed to insert record:%s, already exist", pTable->tableName, sdbGetKeyStrFromObj(pTable, pOper->pObj)); sdbDecRef(pTable, pOper->pObj); - return TSDB_CODE_ALREADY_THERE; + return TSDB_CODE_MND_SDB_OBJ_ALREADY_THERE; } if (pTable->keyType == SDB_KEY_AUTO) { diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c index c1edd309c8..36e7d13a86 100644 --- a/src/mnode/src/mnodeShow.c +++ b/src/mnode/src/mnodeShow.c @@ -110,12 +110,12 @@ static char *mnodeGetShowType(int32_t showType) { static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) { SCMShowMsg *pShowMsg = pMsg->rpcMsg.pCont; if (pShowMsg->type >= TSDB_MGMT_TABLE_MAX) { - return TSDB_CODE_INVALID_MSG_TYPE; + return TSDB_CODE_MND_INVALID_MSG_TYPE; } if (!tsMnodeShowMetaFp[pShowMsg->type] || !tsMnodeShowRetrieveFp[pShowMsg->type]) { mError("show type:%s is not support", mnodeGetShowType(pShowMsg->type)); - return TSDB_CODE_OPS_NOT_SUPPORT; + return TSDB_CODE_COM_OPS_NOT_SUPPORT; } int32_t showObjSize = sizeof(SShowObj) + htons(pShowMsg->payloadLen); @@ -127,14 +127,14 @@ static int32_t mnodeProcessShowMsg(SMnodeMsg *pMsg) { pShow = mnodePutShowObj(pShow, showObjSize); if (pShow == NULL) { - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } int32_t size = sizeof(SCMShowRsp) + sizeof(SSchema) * TSDB_MAX_COLUMNS + TSDB_EXTRA_PAYLOAD_SIZE; SCMShowRsp *pShowRsp = rpcMallocCont(size); if (pShowRsp == NULL) { mnodeReleaseShowObj(pShow, true); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } pShowRsp->qhandle = htobe64((uint64_t) pShow); @@ -169,7 +169,7 @@ static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { */ if (!mnodeAccquireShowObj(pShow)) { mError("%p, show is invalid", pShow); - return TSDB_CODE_INVALID_QHANDLE; + return TSDB_CODE_MND_INVALID_SHOWOBJ; } if (mnodeCheckShowFinished(pShow)) { @@ -202,7 +202,7 @@ static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { rpcFreeCont(pRsp); mnodeReleaseShowObj(pShow, false); assert(false); - return TSDB_CODE_ACTION_IN_PROGRESS; + return TSDB_CODE_MND_ACTION_IN_PROGRESS; } pRsp->numOfRows = htonl(rowsRead); @@ -224,7 +224,7 @@ static int32_t mnodeProcessRetrieveMsg(SMnodeMsg *pMsg) { static int32_t mnodeProcessHeartBeatMsg(SMnodeMsg *pMsg) { SCMHeartBeatRsp *pHBRsp = (SCMHeartBeatRsp *) rpcMallocCont(sizeof(SCMHeartBeatRsp)); if (pHBRsp == NULL) { - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } SCMHeartBeatMsg *pHBMsg = pMsg->rpcMsg.pCont; @@ -278,7 +278,7 @@ static int32_t mnodeProcessConnectMsg(SMnodeMsg *pMsg) { SRpcConnInfo connInfo; if (rpcGetConnInfo(pMsg->rpcMsg.handle, &connInfo) != 0) { mError("thandle:%p is already released while process connect msg", pMsg->rpcMsg.handle); - code = TSDB_CODE_INVALID_MSG_CONTENT; + code = TSDB_CODE_MND_INVALID_CONNECTION; goto connect_over; } @@ -295,7 +295,7 @@ static int32_t mnodeProcessConnectMsg(SMnodeMsg *pMsg) { sprintf(dbName, "%x%s%s", pAcct->acctId, TS_PATH_DELIMITER, pConnectMsg->db); SDbObj *pDb = mnodeGetDb(dbName); if (pDb == NULL) { - code = TSDB_CODE_INVALID_DB; + code = TSDB_CODE_MND_INVALID_DB; goto connect_over; } mnodeDecDbRef(pDb); @@ -303,7 +303,7 @@ static int32_t mnodeProcessConnectMsg(SMnodeMsg *pMsg) { SCMConnectRsp *pConnectRsp = rpcMallocCont(sizeof(SCMConnectRsp)); if (pConnectRsp == NULL) { - code = TSDB_CODE_SERV_OUT_OF_MEMORY; + code = TSDB_CODE_MND_OUT_OF_MEMORY; goto connect_over; } @@ -340,7 +340,7 @@ static int32_t mnodeProcessUseMsg(SMnodeMsg *pMsg) { int32_t code = TSDB_CODE_SUCCESS; if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pUseDbMsg->db); if (pMsg->pDb == NULL) { - code = TSDB_CODE_INVALID_DB; + code = TSDB_CODE_MND_INVALID_DB; } return code; diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c index 56592aff4b..73bd883e6c 100644 --- a/src/mnode/src/mnodeTable.c +++ b/src/mnode/src/mnodeTable.c @@ -107,21 +107,21 @@ static int32_t mnodeChildTableActionInsert(SSdbOper *pOper) { SVgObj *pVgroup = mnodeGetVgroup(pTable->vgId); if (pVgroup == NULL) { mError("ctable:%s, not in vgId:%d", pTable->info.tableId, pTable->vgId); - return TSDB_CODE_INVALID_VGROUP_ID; + return TSDB_CODE_MND_VGROUP_NOT_EXIST; } mnodeDecVgroupRef(pVgroup); SDbObj *pDb = mnodeGetDb(pVgroup->dbName); if (pDb == NULL) { mError("ctable:%s, vgId:%d not in db:%s", pTable->info.tableId, pVgroup->vgId, pVgroup->dbName); - return TSDB_CODE_INVALID_DB; + return TSDB_CODE_MND_INVALID_DB; } mnodeDecDbRef(pDb); SAcctObj *pAcct = mnodeGetAcct(pDb->acct); if (pAcct == NULL) { mError("ctable:%s, acct:%s not exists", pTable->info.tableId, pDb->acct); - return TSDB_CODE_INVALID_ACCT; + return TSDB_CODE_MND_INVALID_ACCT; } mnodeDecAcctRef(pAcct); @@ -145,7 +145,7 @@ static int32_t mnodeChildTableActionInsert(SSdbOper *pOper) { static int32_t mnodeChildTableActionDelete(SSdbOper *pOper) { SChildTableObj *pTable = pOper->pObj; if (pTable->vgId == 0) { - return TSDB_CODE_INVALID_VGROUP_ID; + return TSDB_CODE_MND_VGROUP_NOT_EXIST; } SVgObj *pVgroup = NULL; @@ -201,7 +201,7 @@ static int32_t mnodeChildTableActionEncode(SSdbOper *pOper) { assert(pTable != NULL && pOper->rowData != NULL); int32_t len = strlen(pTable->info.tableId); - if (len > TSDB_TABLE_ID_LEN) return TSDB_CODE_INVALID_TABLE_ID; + if (len > TSDB_TABLE_ID_LEN) return TSDB_CODE_MND_INVALID_TABLE_ID; memcpy(pOper->rowData, pTable->info.tableId, len); memset(pOper->rowData + len, 0, 1); @@ -229,12 +229,12 @@ static int32_t mnodeChildTableActionEncode(SSdbOper *pOper) { static int32_t mnodeChildTableActionDecode(SSdbOper *pOper) { assert(pOper->rowData != NULL); SChildTableObj *pTable = calloc(1, sizeof(SChildTableObj)); - if (pTable == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (pTable == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY; int32_t len = strlen(pOper->rowData); if (len > TSDB_TABLE_ID_LEN) { free(pTable); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_MND_INVALID_TABLE_ID; } pTable->info.tableId = strdup(pOper->rowData); len++; @@ -247,7 +247,7 @@ static int32_t mnodeChildTableActionDecode(SSdbOper *pOper) { pTable->schema = (SSchema *)malloc(schemaSize); if (pTable->schema == NULL) { mnodeDestroyChildTable(pTable); - return TSDB_CODE_INVALID_TABLE_TYPE; + return TSDB_CODE_MND_INVALID_TABLE_TYPE; } memcpy(pTable->schema, pOper->rowData + len, schemaSize); len += schemaSize; @@ -256,7 +256,7 @@ static int32_t mnodeChildTableActionDecode(SSdbOper *pOper) { pTable->sql = malloc(pTable->sqlLen); if (pTable->sql == NULL) { mnodeDestroyChildTable(pTable); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } memcpy(pTable->sql, pOper->rowData + len, pTable->sqlLen); } @@ -453,7 +453,7 @@ static int32_t mnodeSuperTableActionEncode(SSdbOper *pOper) { assert(pOper->pObj != NULL && pOper->rowData != NULL); int32_t len = strlen(pStable->info.tableId); - if (len > TSDB_TABLE_ID_LEN) len = TSDB_CODE_INVALID_TABLE_ID; + if (len > TSDB_TABLE_ID_LEN) len = TSDB_CODE_MND_INVALID_TABLE_ID; memcpy(pOper->rowData, pStable->info.tableId, len); memset(pOper->rowData + len, 0, 1); @@ -474,12 +474,12 @@ static int32_t mnodeSuperTableActionEncode(SSdbOper *pOper) { static int32_t mnodeSuperTableActionDecode(SSdbOper *pOper) { assert(pOper->rowData != NULL); SSuperTableObj *pStable = (SSuperTableObj *) calloc(1, sizeof(SSuperTableObj)); - if (pStable == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (pStable == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY; int32_t len = strlen(pOper->rowData); if (len > TSDB_TABLE_ID_LEN){ free(pStable); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_MND_INVALID_TABLE_ID; } pStable->info.tableId = strdup(pOper->rowData); len++; @@ -491,7 +491,7 @@ static int32_t mnodeSuperTableActionDecode(SSdbOper *pOper) { pStable->schema = malloc(schemaSize); if (pStable->schema == NULL) { mnodeDestroySuperTable(pStable); - return TSDB_CODE_NOT_SUPER_TABLE; + return TSDB_CODE_MND_NOT_SUPER_TABLE; } memcpy(pStable->schema, pOper->rowData + len, schemaSize); @@ -668,7 +668,7 @@ static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) { if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pCreate->db); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { mError("table:%s, failed to create, db not selected", pCreate->tableId); - return TSDB_CODE_DB_NOT_SELECTED; + return TSDB_CODE_MND_DB_NOT_SELECTED; } if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pCreate->tableId); @@ -681,7 +681,7 @@ static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) { return TSDB_CODE_SUCCESS; } else { mError("table:%s, failed to create, table already exist", pCreate->tableId); - return TSDB_CODE_TABLE_ALREADY_EXIST; + return TSDB_CODE_MND_TABLE_ALREADY_EXIST; } } @@ -699,12 +699,12 @@ static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg) { if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableId(pDrop->tableId); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { mError("table:%s, failed to drop table, db not selected", pDrop->tableId); - return TSDB_CODE_DB_NOT_SELECTED; + return TSDB_CODE_MND_DB_NOT_SELECTED; } if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) { mError("table:%s, failed to drop table, in monitor database", pDrop->tableId); - return TSDB_CODE_MONITOR_DB_FORBIDDEN; + return TSDB_CODE_MND_MONITOR_DB_FORBIDDEN; } if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pDrop->tableId); @@ -714,7 +714,7 @@ static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg) { return TSDB_CODE_SUCCESS; } else { mError("table:%s, failed to drop table, table not exist", pDrop->tableId); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_MND_INVALID_TABLE_ID; } } @@ -735,14 +735,14 @@ static int32_t mnodeProcessTableMetaMsg(SMnodeMsg *pMsg) { if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableId(pInfo->tableId); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { mError("table:%s, failed to get table meta, db not selected", pInfo->tableId); - return TSDB_CODE_DB_NOT_SELECTED; + return TSDB_CODE_MND_DB_NOT_SELECTED; } if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pInfo->tableId); if (pMsg->pTable == NULL) { if (!pInfo->createFlag) { mError("table:%s, failed to get table meta, table not exist", pInfo->tableId); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_MND_INVALID_TABLE_ID; } else { mTrace("table:%s, failed to get table meta, start auto create table ", pInfo->tableId); return mnodeAutoCreateChildTable(pMsg); @@ -761,7 +761,7 @@ static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) { SSuperTableObj *pStable = calloc(1, sizeof(SSuperTableObj)); if (pStable == NULL) { mError("table:%s, failed to create, no enough memory", pCreate->tableId); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } pStable->info.tableId = strdup(pCreate->tableId); @@ -779,7 +779,7 @@ static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) { if (pStable->schema == NULL) { free(pStable); mError("table:%s, failed to create, no schema input", pCreate->tableId); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_MND_INVALID_TABLE_ID; } memcpy(pStable->schema, pCreate->schema, numOfCols * sizeof(SSchema)); @@ -804,7 +804,7 @@ static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) { if (code != TSDB_CODE_SUCCESS) { mnodeDestroySuperTable(pStable); mError("table:%s, failed to create, sdb error", pCreate->tableId); - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } else { mLPrint("table:%s, is created, tags:%d fields:%d", pStable->info.tableId, pStable->numOfTags, pStable->numOfColumns); return TSDB_CODE_SUCCESS; @@ -862,18 +862,18 @@ static int32_t mnodeFindSuperTableTagIndex(SSuperTableObj *pStable, const char * static int32_t mnodeAddSuperTableTag(SSuperTableObj *pStable, SSchema schema[], int32_t ntags) { if (pStable->numOfTags + ntags > TSDB_MAX_TAGS) { mError("stable:%s, add tag, too many tags", pStable->info.tableId); - return TSDB_CODE_TOO_MANY_TAGS; + return TSDB_CODE_MND_TOO_MANY_TAGS; } for (int32_t i = 0; i < ntags; i++) { if (mnodeFindSuperTableColumnIndex(pStable, schema[i].name) > 0) { mError("stable:%s, add tag, column:%s already exist", pStable->info.tableId, schema[i].name); - return TSDB_CODE_TAG_ALREAY_EXIST; + return TSDB_CODE_MND_TAG_ALREAY_EXIST; } if (mnodeFindSuperTableTagIndex(pStable, schema[i].name) > 0) { mError("stable:%s, add tag, tag:%s already exist", pStable->info.tableId, schema[i].name); - return TSDB_CODE_FIELD_ALREAY_EXIST; + return TSDB_CODE_MND_FIELD_ALREAY_EXIST; } } @@ -898,7 +898,7 @@ static int32_t mnodeAddSuperTableTag(SSuperTableObj *pStable, SSchema schema[], int32_t code = sdbUpdateRow(&oper); if (code != TSDB_CODE_SUCCESS) { - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } mPrint("stable %s, succeed to add tag %s", pStable->info.tableId, schema[0].name); @@ -909,7 +909,7 @@ static int32_t mnodeDropSuperTableTag(SSuperTableObj *pStable, char *tagName) { int32_t col = mnodeFindSuperTableTagIndex(pStable, tagName); if (col < 0) { mError("stable:%s, drop tag, tag:%s not exist", pStable->info.tableId, tagName); - return TSDB_CODE_TAG_NOT_EXIST; + return TSDB_CODE_MND_TAG_NOT_EXIST; } memmove(pStable->schema + pStable->numOfColumns + col, pStable->schema + pStable->numOfColumns + col + 1, @@ -925,7 +925,7 @@ static int32_t mnodeDropSuperTableTag(SSuperTableObj *pStable, char *tagName) { int32_t code = sdbUpdateRow(&oper); if (code != TSDB_CODE_SUCCESS) { - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } mPrint("stable %s, succeed to drop tag %s", pStable->info.tableId, tagName); @@ -936,17 +936,17 @@ static int32_t mnodeModifySuperTableTagName(SSuperTableObj *pStable, char *oldTa int32_t col = mnodeFindSuperTableTagIndex(pStable, oldTagName); if (col < 0) { mError("stable:%s, failed to modify table tag, oldName: %s, newName: %s", pStable->info.tableId, oldTagName, newTagName); - return TSDB_CODE_TAG_NOT_EXIST; + return TSDB_CODE_MND_TAG_NOT_EXIST; } // int32_t rowSize = 0; uint32_t len = strlen(newTagName); if (len >= TSDB_COL_NAME_LEN) { - return TSDB_CODE_COL_NAME_TOO_LONG; + return TSDB_CODE_MND_COL_NAME_TOO_LONG; } if (mnodeFindSuperTableTagIndex(pStable, newTagName) >= 0) { - return TSDB_CODE_TAG_ALREAY_EXIST; + return TSDB_CODE_MND_TAG_ALREAY_EXIST; } // update @@ -961,7 +961,7 @@ static int32_t mnodeModifySuperTableTagName(SSuperTableObj *pStable, char *oldTa int32_t code = sdbUpdateRow(&oper); if (code != TSDB_CODE_SUCCESS) { - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } mPrint("stable %s, succeed to modify tag %s to %s", pStable->info.tableId, oldTagName, newTagName); @@ -982,18 +982,18 @@ static int32_t mnodeFindSuperTableColumnIndex(SSuperTableObj *pStable, char *col static int32_t mnodeAddSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, SSchema schema[], int32_t ncols) { if (ncols <= 0) { mError("stable:%s, add column, ncols:%d <= 0", pStable->info.tableId); - return TSDB_CODE_APP_ERROR; + return TSDB_CODE_MND_APP_ERROR; } for (int32_t i = 0; i < ncols; i++) { if (mnodeFindSuperTableColumnIndex(pStable, schema[i].name) > 0) { mError("stable:%s, add column, column:%s already exist", pStable->info.tableId, schema[i].name); - return TSDB_CODE_FIELD_ALREAY_EXIST; + return TSDB_CODE_MND_FIELD_ALREAY_EXIST; } if (mnodeFindSuperTableTagIndex(pStable, schema[i].name) > 0) { mError("stable:%s, add column, tag:%s already exist", pStable->info.tableId, schema[i].name); - return TSDB_CODE_TAG_ALREAY_EXIST; + return TSDB_CODE_MND_TAG_ALREAY_EXIST; } } @@ -1026,7 +1026,7 @@ static int32_t mnodeAddSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, SS int32_t code = sdbUpdateRow(&oper); if (code != TSDB_CODE_SUCCESS) { - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } mPrint("stable %s, succeed to add column", pStable->info.tableId); @@ -1037,7 +1037,7 @@ static int32_t mnodeDropSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, c int32_t col = mnodeFindSuperTableColumnIndex(pStable, colName); if (col <= 0) { mError("stable:%s, drop column, column:%s not exist", pStable->info.tableId, colName); - return TSDB_CODE_FIELD_NOT_EXIST; + return TSDB_CODE_MND_FIELD_NOT_EXIST; } memmove(pStable->schema + col, pStable->schema + col + 1, @@ -1063,7 +1063,7 @@ static int32_t mnodeDropSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, c int32_t code = sdbUpdateRow(&oper); if (code != TSDB_CODE_SUCCESS) { - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } mPrint("stable %s, succeed to delete column", pStable->info.tableId); @@ -1073,7 +1073,7 @@ static int32_t mnodeDropSuperTableColumn(SDbObj *pDb, SSuperTableObj *pStable, c // show super tables static int32_t mnodeGetShowSuperTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { SDbObj *pDb = mnodeGetDb(pShow->db); - if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED; + if (pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED; int32_t cols = 0; SSchema *pSchema = pMeta->schema; @@ -1277,7 +1277,7 @@ static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) { SCMSTableVgroupRspMsg *pRsp = rpcMallocCont(contLen); if (pRsp == NULL) { - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } pRsp->numOfTables = 0; @@ -1333,7 +1333,7 @@ static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) { if (pRsp->numOfTables != numOfTable) { rpcFreeCont(pRsp); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_MND_INVALID_TABLE_ID; } else { pRsp->numOfTables = htonl(pRsp->numOfTables); pMsg->rpcRsp.rsp = pRsp; @@ -1367,7 +1367,7 @@ static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SChildTableO SMDCreateTableMsg *pCreate = rpcMallocCont(contLen); if (pCreate == NULL) { - terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + terrno = TSDB_CODE_MND_OUT_OF_MEMORY; return NULL; } @@ -1424,7 +1424,7 @@ static SChildTableObj* mnodeDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgOb SChildTableObj *pTable = calloc(1, sizeof(SChildTableObj)); if (pTable == NULL) { mError("table:%s, failed to alloc memory", pCreate->tableId); - terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + terrno = TSDB_CODE_MND_OUT_OF_MEMORY; return NULL; } @@ -1445,7 +1445,7 @@ static SChildTableObj* mnodeDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgOb if (pSuperTable == NULL) { mError("table:%s, corresponding super table:%s does not exist", pCreate->tableId, pTagData->name); mnodeDestroyChildTable(pTable); - terrno = TSDB_CODE_INVALID_TABLE_ID; + terrno = TSDB_CODE_MND_INVALID_TABLE_ID; return NULL; } mnodeDecTableRef(pSuperTable); @@ -1465,7 +1465,7 @@ static SChildTableObj* mnodeDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgOb pTable->schema = (SSchema *) calloc(1, schemaSize); if (pTable->schema == NULL) { free(pTable); - terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + terrno = TSDB_CODE_MND_OUT_OF_MEMORY; return NULL; } memcpy(pTable->schema, pCreate->schema, numOfCols * sizeof(SSchema)); @@ -1482,7 +1482,7 @@ static SChildTableObj* mnodeDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgOb pTable->sql = calloc(1, pTable->sqlLen); if (pTable->sql == NULL) { free(pTable); - terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + terrno = TSDB_CODE_MND_OUT_OF_MEMORY; return NULL; } memcpy(pTable->sql, (char *) (pCreate->schema) + numOfCols * sizeof(SSchema), pTable->sqlLen); @@ -1499,7 +1499,7 @@ static SChildTableObj* mnodeDoCreateChildTable(SCMCreateTableMsg *pCreate, SVgOb if (sdbInsertRow(&desc) != TSDB_CODE_SUCCESS) { free(pTable); mError("table:%s, update sdb error", pCreate->tableId); - terrno = TSDB_CODE_SDB_ERROR; + terrno = TSDB_CODE_MND_SDB_ERROR; return NULL; } @@ -1560,7 +1560,7 @@ static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) { dnodeSendMsgToDnode(&ipSet, &rpcMsg); - return TSDB_CODE_ACTION_IN_PROGRESS; + return TSDB_CODE_MND_ACTION_IN_PROGRESS; } static int32_t mnodeProcessDropChildTableMsg(SMnodeMsg *pMsg) { @@ -1568,13 +1568,13 @@ static int32_t mnodeProcessDropChildTableMsg(SMnodeMsg *pMsg) { if (pMsg->pVgroup == NULL) pMsg->pVgroup = mnodeGetVgroup(pTable->vgId); if (pMsg->pVgroup == NULL) { mError("table:%s, failed to drop ctable, vgroup not exist", pTable->info.tableId); - return TSDB_CODE_OTHERS; + return TSDB_CODE_MND_APP_ERROR; } SMDDropTableMsg *pDrop = rpcMallocCont(sizeof(SMDDropTableMsg)); if (pDrop == NULL) { mError("table:%s, failed to drop ctable, no enough memory", pTable->info.tableId); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } strcpy(pDrop->tableId, pTable->info.tableId); @@ -1596,11 +1596,11 @@ static int32_t mnodeProcessDropChildTableMsg(SMnodeMsg *pMsg) { dnodeSendMsgToDnode(&ipSet, &rpcMsg); - return TSDB_CODE_ACTION_IN_PROGRESS; + return TSDB_CODE_MND_ACTION_IN_PROGRESS; } static int32_t mnodeModifyChildTableTagValue(SChildTableObj *pTable, char *tagName, char *nContent) { - return TSDB_CODE_OPS_NOT_SUPPORT; + return TSDB_CODE_COM_OPS_NOT_SUPPORT; } static int32_t mnodeFindNormalTableColumnIndex(SChildTableObj *pTable, char *colName) { @@ -1617,13 +1617,13 @@ static int32_t mnodeFindNormalTableColumnIndex(SChildTableObj *pTable, char *col static int32_t mnodeAddNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, SSchema schema[], int32_t ncols) { if (ncols <= 0) { mError("table:%s, add column, ncols:%d <= 0", pTable->info.tableId); - return TSDB_CODE_APP_ERROR; + return TSDB_CODE_MND_APP_ERROR; } for (int32_t i = 0; i < ncols; i++) { if (mnodeFindNormalTableColumnIndex(pTable, schema[i].name) > 0) { mError("table:%s, add column, column:%s already exist", pTable->info.tableId, schema[i].name); - return TSDB_CODE_FIELD_ALREAY_EXIST; + return TSDB_CODE_MND_FIELD_ALREAY_EXIST; } } @@ -1654,7 +1654,7 @@ static int32_t mnodeAddNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, SS int32_t code = sdbUpdateRow(&oper); if (code != TSDB_CODE_SUCCESS) { - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } mPrint("table %s, succeed to add column", pTable->info.tableId); @@ -1665,7 +1665,7 @@ static int32_t mnodeDropNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, c int32_t col = mnodeFindNormalTableColumnIndex(pTable, colName); if (col <= 0) { mError("table:%s, drop column, column:%s not exist", pTable->info.tableId, colName); - return TSDB_CODE_FIELD_NOT_EXIST; + return TSDB_CODE_MND_FIELD_NOT_EXIST; } memmove(pTable->schema + col, pTable->schema + col + 1, sizeof(SSchema) * (pTable->numOfColumns - col - 1)); @@ -1686,7 +1686,7 @@ static int32_t mnodeDropNormalTableColumn(SDbObj *pDb, SChildTableObj *pTable, c int32_t code = sdbUpdateRow(&oper); if (code != TSDB_CODE_SUCCESS) { - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } mPrint("table %s, succeed to drop column %s", pTable->info.tableId, colName); @@ -1732,8 +1732,8 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) { if (pMsg->pVgroup == NULL) pMsg->pVgroup = mnodeGetVgroup(pTable->vgId); if (pMsg->pVgroup == NULL) { - mError("table:%s, failed to get table meta, db not selected", pTable->info.tableId); - return TSDB_CODE_INVALID_VGROUP_ID; + mError("table:%s, failed to get table meta, vgroup not exist", pTable->info.tableId); + return TSDB_CODE_MND_VGROUP_NOT_EXIST; } for (int32_t i = 0; i < pMsg->pVgroup->numOfVnodes; ++i) { @@ -1759,7 +1759,7 @@ static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) { SCMCreateTableMsg *pCreateMsg = rpcMallocCont(contLen); if (pCreateMsg == NULL) { mError("table:%s, failed to create table while get meta info, no enough memory", pInfo->tableId); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } strncpy(pCreateMsg->tableId, pInfo->tableId, tListLen(pInfo->tableId)); @@ -1776,14 +1776,14 @@ static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) { pMsg->rpcMsg.pCont = pCreateMsg; pMsg->rpcMsg.contLen = contLen; - return TSDB_CODE_ACTION_NEED_REPROCESSED; + return TSDB_CODE_MND_ACTION_NEED_REPROCESSED; } static int32_t mnodeGetChildTableMeta(SMnodeMsg *pMsg) { STableMetaMsg *pMeta = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)); if (pMeta == NULL) { mError("table:%s, failed to get table meta, no enough memory", pMsg->pTable->tableId); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } mnodeDoGetChildTableMeta(pMsg, pMeta); @@ -1902,7 +1902,7 @@ static int32_t mnodeProcessTableCfgMsg(SMnodeMsg *pMsg) { SChildTableObj *pTable = mnodeGetTableByPos(pCfg->vgId, pCfg->sid); if (pTable == NULL) { mError("dnode:%d, vgId:%d sid:%d, table not found", pCfg->dnodeId, pCfg->vgId, pCfg->sid); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_MND_INVALID_TABLE_ID; } SMDCreateTableMsg *pCreate = NULL; @@ -1936,7 +1936,7 @@ static void mnodeProcessDropChildTableRsp(SRpcMsg *rpcMsg) { if (mnodeMsg->pVgroup == NULL) mnodeMsg->pVgroup = mnodeGetVgroup(pTable->vgId); if (mnodeMsg->pVgroup == NULL) { mError("table:%s, failed to get vgroup", pTable->info.tableId); - dnodeSendRpcMnodeWriteRsp(mnodeMsg, TSDB_CODE_INVALID_VGROUP_ID); + dnodeSendRpcMnodeWriteRsp(mnodeMsg, TSDB_CODE_MND_VGROUP_NOT_EXIST); return; } @@ -1949,7 +1949,7 @@ static void mnodeProcessDropChildTableRsp(SRpcMsg *rpcMsg) { int32_t code = sdbDeleteRow(&oper); if (code != TSDB_CODE_SUCCESS) { mError("table:%s, update ctables sdb error", pTable->info.tableId); - dnodeSendRpcMnodeWriteRsp(mnodeMsg, TSDB_CODE_SDB_ERROR); + dnodeSendRpcMnodeWriteRsp(mnodeMsg, TSDB_CODE_MND_SDB_ERROR); return; } @@ -2018,7 +2018,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) { int32_t totalMallocLen = 4 * 1024 * 1024; // first malloc 4 MB, subsequent reallocation as twice SMultiTableMeta *pMultiMeta = rpcMallocCont(totalMallocLen); if (pMultiMeta == NULL) { - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } pMultiMeta->contLen = sizeof(SMultiTableMeta); @@ -2041,7 +2041,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) { pMultiMeta = rpcReallocCont(pMultiMeta, totalMallocLen); if (pMultiMeta == NULL) { mnodeDecTableRef(pTable); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_MND_OUT_OF_MEMORY; } else { t--; mnodeDecTableRef(pTable); @@ -2067,7 +2067,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) { static int32_t mnodeGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { SDbObj *pDb = mnodeGetDb(pShow->db); - if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED; + if (pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED; int32_t cols = 0; SSchema *pSchema = pMeta->schema; @@ -2194,18 +2194,18 @@ static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) { if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableId(pAlter->tableId); if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) { mError("table:%s, failed to alter table, db not selected", pAlter->tableId); - return TSDB_CODE_DB_NOT_SELECTED; + return TSDB_CODE_MND_DB_NOT_SELECTED; } if (mnodeCheckIsMonitorDB(pMsg->pDb->name, tsMonitorDbName)) { mError("table:%s, failed to alter table, its log db", pAlter->tableId); - return TSDB_CODE_MONITOR_DB_FORBIDDEN; + return TSDB_CODE_MND_MONITOR_DB_FORBIDDEN; } if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pAlter->tableId); if (pMsg->pTable == NULL) { mError("table:%s, failed to alter table, table not exist", pMsg->pTable->tableId); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_MND_INVALID_TABLE_ID; } pAlter->type = htons(pAlter->type); @@ -2214,14 +2214,14 @@ static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) { if (pAlter->numOfCols > 2) { mError("table:%s, error numOfCols:%d in alter table", pAlter->tableId, pAlter->numOfCols); - return TSDB_CODE_APP_ERROR; + return TSDB_CODE_MND_APP_ERROR; } for (int32_t i = 0; i < pAlter->numOfCols; ++i) { pAlter->schema[i].bytes = htons(pAlter->schema[i].bytes); } - int32_t code = TSDB_CODE_OPS_NOT_SUPPORT; + int32_t code = TSDB_CODE_COM_OPS_NOT_SUPPORT; if (pMsg->pTable->type == TSDB_SUPER_TABLE) { SSuperTableObj *pTable = (SSuperTableObj *)pMsg->pTable; mTrace("table:%s, start to alter stable", pAlter->tableId); @@ -2256,7 +2256,7 @@ static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) { static int32_t mnodeGetStreamTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { SDbObj *pDb = mnodeGetDb(pShow->db); - if (pDb == NULL) return TSDB_CODE_DB_NOT_SELECTED; + if (pDb == NULL) return TSDB_CODE_MND_DB_NOT_SELECTED; int32_t cols = 0; SSchema *pSchema = pMeta->schema; diff --git a/src/mnode/src/mnodeUser.c b/src/mnode/src/mnodeUser.c index 209b439275..aab0847a6b 100644 --- a/src/mnode/src/mnodeUser.c +++ b/src/mnode/src/mnodeUser.c @@ -56,7 +56,7 @@ static int32_t mnodeUserActionInsert(SSdbOper *pOper) { mnodeDecAcctRef(pAcct); } else { mError("user:%s, acct:%s info not exist in sdb", pUser->user, pUser->acct); - return TSDB_CODE_INVALID_ACCT; + return TSDB_CODE_MND_INVALID_ACCT; } return TSDB_CODE_SUCCESS; @@ -94,7 +94,7 @@ static int32_t mnodeUserActionEncode(SSdbOper *pOper) { static int32_t mnodeUserActionDecode(SSdbOper *pOper) { SUserObj *pUser = (SUserObj *)calloc(1, sizeof(SUserObj)); - if (pUser == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (pUser == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY; memcpy(pUser, pOper->rowData, tsUserUpdateSize); pOper->pObj = pUser; @@ -179,7 +179,7 @@ static int32_t mnodeUpdateUser(SUserObj *pUser) { int32_t code = sdbUpdateRow(&oper); if (code != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_SDB_ERROR; + code = TSDB_CODE_MND_SDB_ERROR; } return code; @@ -192,18 +192,18 @@ int32_t mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass) { } if (name[0] == 0) { - return TSDB_CODE_INVALID_USER_FORMAT; + return TSDB_CODE_MND_INVALID_USER_FORMAT; } if (pass[0] == 0) { - return TSDB_CODE_INVALID_PASS_FORMAT; + return TSDB_CODE_MND_INVALID_PASS_FORMAT; } SUserObj *pUser = mnodeGetUser(name); if (pUser != NULL) { mTrace("user:%s, is already there", name); mnodeDecUserRef(pUser); - return TSDB_CODE_USER_ALREADY_EXIST; + return TSDB_CODE_MND_USER_ALREADY_EXIST; } code = grantCheck(TSDB_GRANT_USER); @@ -232,7 +232,7 @@ int32_t mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass) { code = sdbInsertRow(&oper); if (code != TSDB_CODE_SUCCESS) { tfree(pUser); - code = TSDB_CODE_SDB_ERROR; + code = TSDB_CODE_MND_SDB_ERROR; } return code; @@ -247,7 +247,7 @@ static int32_t mnodeDropUser(SUserObj *pUser) { int32_t code = sdbDeleteRow(&oper); if (code != TSDB_CODE_SUCCESS) { - code = TSDB_CODE_SDB_ERROR; + code = TSDB_CODE_MND_SDB_ERROR; } return code; @@ -256,7 +256,7 @@ static int32_t mnodeDropUser(SUserObj *pUser) { static int32_t mnodeGetUserMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { SUserObj *pUser = mnodeGetUserFromConn(pConn); if (pUser == NULL) { - return TSDB_CODE_NO_USER_FROM_CONN; + return TSDB_CODE_MND_NO_USER_FROM_CONN; } int32_t cols = 0; @@ -369,7 +369,7 @@ static int32_t mnodeProcessCreateUserMsg(SMnodeMsg *pMsg) { } } else { mError("user:%s, no rights to create user", pOperUser->user); - code = TSDB_CODE_NO_RIGHTS; + code = TSDB_CODE_MND_NO_RIGHTS; } return code; @@ -382,12 +382,12 @@ static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg) { SCMAlterUserMsg *pAlter = pMsg->rpcMsg.pCont; SUserObj *pUser = mnodeGetUser(pAlter->user); if (pUser == NULL) { - return TSDB_CODE_INVALID_USER; + return TSDB_CODE_MND_INVALID_USER; } if (strcmp(pUser->user, "monitor") == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) { mnodeDecUserRef(pUser); - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } if ((pAlter->flag & TSDB_ALTER_USER_PASSWD) != 0) { @@ -413,7 +413,7 @@ static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg) { mLPrint("user:%s, password is altered by %s, result:%s", pUser->user, pOperUser->user, tstrerror(code)); } else { mError("user:%s, no rights to alter user", pOperUser->user); - code = TSDB_CODE_NO_RIGHTS; + code = TSDB_CODE_MND_NO_RIGHTS; } } else if ((pAlter->flag & TSDB_ALTER_USER_PRIVILEGES) != 0) { bool hasRight = false; @@ -454,11 +454,11 @@ static int32_t mnodeProcessAlterUserMsg(SMnodeMsg *pMsg) { mLPrint("user:%s, privilege is altered by %s, result:%s", pUser->user, pOperUser->user, tstrerror(code)); } else { mError("user:%s, no rights to alter user", pOperUser->user); - code = TSDB_CODE_NO_RIGHTS; + code = TSDB_CODE_MND_NO_RIGHTS; } } else { mError("user:%s, no rights to alter user", pOperUser->user); - code = TSDB_CODE_NO_RIGHTS; + code = TSDB_CODE_MND_NO_RIGHTS; } mnodeDecUserRef(pUser); @@ -472,13 +472,13 @@ static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg) { SCMDropUserMsg *pDrop = pMsg->rpcMsg.pCont; SUserObj *pUser = mnodeGetUser(pDrop->user); if (pUser == NULL) { - return TSDB_CODE_INVALID_USER; + return TSDB_CODE_MND_INVALID_USER; } if (strcmp(pUser->user, "monitor") == 0 || strcmp(pUser->user, pUser->acct) == 0 || (strcmp(pUser->user + 1, pUser->acct) == 0 && pUser->user[0] == '_')) { mnodeDecUserRef(pUser); - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } bool hasRight = false; @@ -502,7 +502,7 @@ static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg) { mLPrint("user:%s, is dropped by %s, result:%s", pUser->user, pOperUser->user, tstrerror(code)); } } else { - code = TSDB_CODE_NO_RIGHTS; + code = TSDB_CODE_MND_NO_RIGHTS; } mnodeDecUserRef(pUser); @@ -540,15 +540,15 @@ void mnodeDropAllUsers(SAcctObj *pAcct) { int32_t mnodeRetriveAuth(char *user, char *spi, char *encrypt, char *secret, char *ckey) { if (!sdbIsMaster()) { *secret = 0; - mTrace("user:%s, failed to auth user, reason:%s", user, tstrerror(TSDB_CODE_NOT_READY)); - return TSDB_CODE_NOT_READY; + mTrace("user:%s, failed to auth user, reason:%s", user, tstrerror(TSDB_CODE_RPC_NOT_READY)); + return TSDB_CODE_RPC_NOT_READY; } SUserObj *pUser = mnodeGetUser(user); if (pUser == NULL) { *secret = 0; - mError("user:%s, failed to auth user, reason:%s", user, tstrerror(TSDB_CODE_INVALID_USER)); - return TSDB_CODE_INVALID_USER; + mError("user:%s, failed to auth user, reason:%s", user, tstrerror(TSDB_CODE_MND_INVALID_USER)); + return TSDB_CODE_MND_INVALID_USER; } else { *spi = 1; *encrypt = 0; diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c index 920d8503b2..7274c879c6 100644 --- a/src/mnode/src/mnodeVgroup.c +++ b/src/mnode/src/mnodeVgroup.c @@ -68,7 +68,7 @@ static int32_t mnodeVgroupActionInsert(SSdbOper *pOper) { // refer to db SDbObj *pDb = mnodeGetDb(pVgroup->dbName); if (pDb == NULL) { - return TSDB_CODE_INVALID_DB; + return TSDB_CODE_MND_INVALID_DB; } pVgroup->pDb = pDb; @@ -185,7 +185,7 @@ static int32_t mnodeVgroupActionEncode(SSdbOper *pOper) { static int32_t mnodeVgroupActionDecode(SSdbOper *pOper) { SVgObj *pVgroup = (SVgObj *) calloc(1, sizeof(SVgObj)); - if (pVgroup == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (pVgroup == NULL) return TSDB_CODE_MND_OUT_OF_MEMORY; memcpy(pVgroup, pOper->rowData, tsVgUpdateSize); pOper->pObj = pVgroup; @@ -307,7 +307,7 @@ int32_t mnodeCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { if (balanceAllocVnodes(pVgroup) != 0) { mError("db:%s, no enough dnode to alloc %d vnodes to vgroup", pDb->name, pVgroup->numOfVnodes); free(pVgroup); - return TSDB_CODE_NO_ENOUGH_DNODES; + return TSDB_CODE_MND_NO_ENOUGH_DNODES; } SSdbOper oper = { @@ -320,7 +320,7 @@ int32_t mnodeCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { int32_t code = sdbInsertRow(&oper); if (code != TSDB_CODE_SUCCESS) { tfree(pVgroup); - return TSDB_CODE_SDB_ERROR; + return TSDB_CODE_MND_SDB_ERROR; } mPrint("vgId:%d, is created in mnode, db:%s replica:%d", pVgroup->vgId, pDb->name, pVgroup->numOfVnodes); @@ -333,7 +333,7 @@ int32_t mnodeCreateVgroup(SMnodeMsg *pMsg, SDbObj *pDb) { pMsg->expected = pVgroup->numOfVnodes; mnodeSendCreateVgroupMsg(pVgroup, pMsg); - return TSDB_CODE_ACTION_IN_PROGRESS; + return TSDB_CODE_MND_ACTION_IN_PROGRESS; } void mnodeDropVgroup(SVgObj *pVgroup, void *ahandle) { @@ -358,7 +358,7 @@ void mnodeCleanupVgroups() { int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { SDbObj *pDb = mnodeGetDb(pShow->db); if (pDb == NULL) { - return TSDB_CODE_DB_NOT_SELECTED; + return TSDB_CODE_MND_DB_NOT_SELECTED; } int32_t cols = 0; @@ -383,11 +383,11 @@ int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) { pTable = mnodeGetTable(pShow->payload); if (NULL == pTable || pTable->type == TSDB_SUPER_TABLE) { mnodeDecTableRef(pTable); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_MND_INVALID_TABLE_ID; } mnodeDecTableRef(pTable); pVgroup = mnodeGetVgroup(((SChildTableObj*)pTable)->vgId); - if (NULL == pVgroup) return TSDB_CODE_INVALID_TABLE_ID; + if (NULL == pVgroup) return TSDB_CODE_MND_INVALID_TABLE_ID; mnodeDecVgroupRef(pVgroup); maxReplica = pVgroup->numOfVnodes > maxReplica ? pVgroup->numOfVnodes : maxReplica; } else { @@ -643,7 +643,7 @@ static void mnodeProcessCreateVnodeRsp(SRpcMsg *rpcMsg) { }; int32_t code = sdbDeleteRow(&oper); if (code != 0) { - code = TSDB_CODE_SDB_ERROR; + code = TSDB_CODE_MND_SDB_ERROR; } dnodeSendRpcMnodeWriteRsp(mnodeMsg, code); @@ -704,7 +704,7 @@ static void mnodeProcessDropVnodeRsp(SRpcMsg *rpcMsg) { }; int32_t code = sdbDeleteRow(&oper); if (code != 0) { - code = TSDB_CODE_SDB_ERROR; + code = TSDB_CODE_MND_SDB_ERROR; } dnodeReprocessMnodeWriteMsg(mnodeMsg); @@ -718,14 +718,14 @@ static int32_t mnodeProcessVnodeCfgMsg(SMnodeMsg *pMsg) { SDnodeObj *pDnode = mnodeGetDnode(pCfg->dnodeId); if (pDnode == NULL) { mTrace("dnode:%s, invalid dnode", taosIpStr(pCfg->dnodeId), pCfg->vgId); - return TSDB_CODE_INVALID_VGROUP_ID; + return TSDB_CODE_MND_VGROUP_NOT_EXIST; } mnodeDecDnodeRef(pDnode); SVgObj *pVgroup = mnodeGetVgroup(pCfg->vgId); if (pVgroup == NULL) { mTrace("dnode:%s, vgId:%d, no vgroup info", taosIpStr(pCfg->dnodeId), pCfg->vgId); - return TSDB_CODE_INVALID_VGROUP_ID; + return TSDB_CODE_MND_VGROUP_NOT_EXIST; } mnodeDecVgroupRef(pVgroup); diff --git a/src/mnode/src/mnodeWrite.c b/src/mnode/src/mnodeWrite.c index 8b3d82d32a..29b2e6c82b 100644 --- a/src/mnode/src/mnodeWrite.c +++ b/src/mnode/src/mnodeWrite.c @@ -44,7 +44,7 @@ void mnodeAddWriteMsgHandle(uint8_t msgType, int32_t (*fp)(SMnodeMsg *mnodeMsg)) int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { if (pMsg->rpcMsg.pCont == NULL) { mError("%p, msg:%s in mwrite queue, content is null", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); - return TSDB_CODE_INVALID_MSG_LEN; + return TSDB_CODE_MND_INVALID_MSG_LEN; } if (!sdbIsMaster()) { @@ -59,12 +59,12 @@ int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { mTrace("mnode index:%d ip:%s:%d", i, ipSet->fqdn[i], htons(ipSet->port[i])); } - return TSDB_CODE_REDIRECT; + return TSDB_CODE_RPC_REDIRECT; } if (tsMnodeProcessWriteMsgFp[pMsg->rpcMsg.msgType] == NULL) { mError("%p, msg:%s in mwrite queue, not processed", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); - return TSDB_CODE_MSG_NOT_PROCESSED; + return TSDB_CODE_MND_MSG_NOT_PROCESSED; } int32_t code = mnodeInitMsg(pMsg); @@ -75,7 +75,7 @@ int32_t mnodeProcessWrite(SMnodeMsg *pMsg) { if (!pMsg->pUser->writeAuth) { mError("%p, msg:%s in mwrite queue, not processed, no write auth", pMsg->rpcMsg.ahandle, taosMsg[pMsg->rpcMsg.msgType]); - return TSDB_CODE_NO_RIGHTS; + return TSDB_CODE_MND_NO_RIGHTS; } return (*tsMnodeProcessWriteMsgFp[pMsg->rpcMsg.msgType])(pMsg); diff --git a/src/plugins/http/src/httpJson.c b/src/plugins/http/src/httpJson.c index 74e3c409a1..950258533f 100644 --- a/src/plugins/http/src/httpJson.c +++ b/src/plugins/http/src/httpJson.c @@ -443,9 +443,9 @@ void httpJsonPairStatus(JsonBuf* buf, int code) { httpJsonPairIntVal(buf, "code", 4, code); if (code >= 0) { httpJsonItemToken(buf); - if (code == TSDB_CODE_DB_NOT_SELECTED) { + if (code == TSDB_CODE_MND_DB_NOT_SELECTED) { httpJsonPair(buf, "desc", 4, "failed to create database", 23); - } else if (code == TSDB_CODE_INVALID_TABLE_ID) { + } else if (code == TSDB_CODE_MND_INVALID_TABLE_ID) { httpJsonPair(buf, "desc", 4, "failed to create table", 22); } else httpJsonPair(buf, "desc", 4, (char*)tstrerror(code), (int)strlen(tstrerror(code))); diff --git a/src/plugins/http/src/httpSql.c b/src/plugins/http/src/httpSql.c index c82a235eba..af9ad8e38a 100644 --- a/src/plugins/http/src/httpSql.c +++ b/src/plugins/http/src/httpSql.c @@ -80,7 +80,7 @@ void httpProcessMultiSqlCallBack(void *param, TAOS_RES *result, int code) { HttpSqlCmd *singleCmd = multiCmds->cmds + multiCmds->pos; char * sql = httpGetCmdsString(pContext, singleCmd->sql); - if (code == TSDB_CODE_ACTION_IN_PROGRESS) { + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) { httpWarn("context:%p, fd:%d, ip:%s, user:%s, process pos:%d, code:%s:inprogress, sql:%s", pContext, pContext->fd, pContext->ipstr, pContext->user, multiCmds->pos, tstrerror(code), sql); return; @@ -234,7 +234,7 @@ void httpProcessSingleSqlCallBack(void *param, TAOS_RES *result, int code) { HttpEncodeMethod *encode = pContext->encodeMethod; - if (code == TSDB_CODE_ACTION_IN_PROGRESS) { + if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) { httpError("context:%p, fd:%d, ip:%s, user:%s, query error, taos:%p, code:%s:inprogress, sqlObj:%p", pContext, pContext->fd, pContext->ipstr, pContext->user, pContext->session->taos, tstrerror(code), (SSqlObj *)result); return; @@ -242,7 +242,7 @@ void httpProcessSingleSqlCallBack(void *param, TAOS_RES *result, int code) { if (code < 0) { SSqlObj *pObj = (SSqlObj *)result; - if (code == TSDB_CODE_INVALID_SQL) { + if (code == TSDB_CODE_TSC_INVALID_SQL) { httpError("context:%p, fd:%d, ip:%s, user:%s, query error, taos:%p, code:%s, sqlObj:%p, error:%s", pContext, pContext->fd, pContext->ipstr, pContext->user, pContext->session->taos, tstrerror(code), pObj, pObj->cmd.payload); httpSendTaosdInvalidSqlErrorResp(pContext, pObj->cmd.payload); diff --git a/src/plugins/http/src/tgJson.c b/src/plugins/http/src/tgJson.c index 27059010b8..6c0b3c8663 100644 --- a/src/plugins/http/src/tgJson.c +++ b/src/plugins/http/src/tgJson.c @@ -103,7 +103,7 @@ bool tgCheckFinished(struct HttpContext *pContext, HttpSqlCmd *cmd, int code) { if (cmd->cmdType == HTTP_CMD_TYPE_INSERT) { if (cmd->cmdState == HTTP_CMD_STATE_NOT_RUN_YET) { - if (code == TSDB_CODE_DB_NOT_SELECTED || code == TSDB_CODE_INVALID_DB) { + if (code == TSDB_CODE_MND_DB_NOT_SELECTED || code == TSDB_CODE_MND_INVALID_DB) { cmd->cmdState = HTTP_CMD_STATE_RUN_FINISHED; if (multiCmds->cmds[0].cmdState == HTTP_CMD_STATE_NOT_RUN_YET) { multiCmds->pos = (int16_t)-1; @@ -111,7 +111,7 @@ bool tgCheckFinished(struct HttpContext *pContext, HttpSqlCmd *cmd, int code) { pContext->ipstr); return false; } - } else if (code == TSDB_CODE_INVALID_TABLE_ID) { + } else if (code == TSDB_CODE_MND_INVALID_TABLE_ID) { cmd->cmdState = HTTP_CMD_STATE_RUN_FINISHED; if (multiCmds->cmds[multiCmds->pos - 1].cmdState == HTTP_CMD_STATE_NOT_RUN_YET) { multiCmds->pos = (int16_t)(multiCmds->pos - 2); diff --git a/src/plugins/monitor/src/monitorMain.c b/src/plugins/monitor/src/monitorMain.c index 5275dd9d6c..01e276da64 100644 --- a/src/plugins/monitor/src/monitorMain.c +++ b/src/plugins/monitor/src/monitorMain.c @@ -207,7 +207,7 @@ static void monitorInitDatabase() { } static void monitorInitDatabaseCb(void *param, TAOS_RES *result, int32_t code) { - if (-code == TSDB_CODE_TABLE_ALREADY_EXIST || -code == TSDB_CODE_DB_ALREADY_EXIST || code >= 0) { + if (-code == TSDB_CODE_MND_TABLE_ALREADY_EXIST || -code == TSDB_CODE_MND_DB_ALREADY_EXIST || code >= 0) { monitorTrace("monitor:%p, sql success, reason:%d, %s", tsMonitorConn.conn, tstrerror(code), tsMonitorConn.sql); if (tsMonitorConn.cmdIndex == MONITOR_CMD_CREATE_TB_LOG) { monitorPrint("dnode:%s is started", tsLocalEp); diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c index 6824d305c3..f148e25e6a 100644 --- a/src/query/src/qExecutor.c +++ b/src/query/src/qExecutor.c @@ -1434,7 +1434,7 @@ _clean: tfree(pRuntimeEnv->resultInfo); tfree(pRuntimeEnv->pCtx); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_QRY_OUT_OF_MEMORY; } static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) { @@ -1475,7 +1475,7 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) { } static bool isQueryKilled(SQInfo *pQInfo) { - return (pQInfo->code == TSDB_CODE_QUERY_CANCELLED); + return (pQInfo->code == TSDB_CODE_TSC_QUERY_CANCELLED); #if 0 /* * check if the queried meter is going to be deleted. @@ -1491,7 +1491,7 @@ static bool isQueryKilled(SQInfo *pQInfo) { #endif } -static void setQueryKilled(SQInfo *pQInfo) { pQInfo->code = TSDB_CODE_QUERY_CANCELLED; } +static void setQueryKilled(SQInfo *pQInfo) { pQInfo->code = TSDB_CODE_TSC_QUERY_CANCELLED; } static bool isFixedOutputQuery(SQuery *pQuery) { if (pQuery->intervalTime != 0) { @@ -4973,7 +4973,7 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList, // query msg safety check if (!validateQueryMsg(pQueryMsg)) { - return TSDB_CODE_INVALID_QUERY_MSG; + return TSDB_CODE_QRY_INVALID_MSG; } char *pMsg = (char *)(pQueryMsg->colList) + sizeof(SColumnInfo) * pQueryMsg->numOfCols; @@ -5046,11 +5046,11 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList, if (pExprMsg->functionId == TSDB_FUNC_TAG || pExprMsg->functionId == TSDB_FUNC_TAGPRJ || pExprMsg->functionId == TSDB_FUNC_TAG_DUMMY) { if (pExprMsg->colInfo.flag != TSDB_COL_TAG) { // ignore the column index check for arithmetic expression. - return TSDB_CODE_INVALID_QUERY_MSG; + return TSDB_CODE_QRY_INVALID_MSG; } } else { // if (!validateExprColumnInfo(pQueryMsg, pExprMsg)) { -// return TSDB_CODE_INVALID_QUERY_MSG; +// return TSDB_CODE_QRY_INVALID_MSG; // } } @@ -5060,7 +5060,7 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList, if (!validateQuerySourceCols(pQueryMsg, *pExpr)) { tfree(*pExpr); - return TSDB_CODE_INVALID_QUERY_MSG; + return TSDB_CODE_QRY_INVALID_MSG; } pMsg = createTableIdList(pQueryMsg, pMsg, pTableIdList); @@ -5149,7 +5149,7 @@ static int32_t buildAirthmeticExprFromMsg(SExprInfo *pArithExprInfo, SQueryTable if (pExprNode == NULL) { qError("qmsg:%p failed to create arithmetic expression string from:%s", pQueryMsg, pArithExprInfo->base.arg[0].argValue.pz); - return TSDB_CODE_APP_ERROR; + return TSDB_CODE_QRY_APP_ERROR; } pArithExprInfo->pExpr = pExprNode; @@ -5163,7 +5163,7 @@ static int32_t createSqlFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SExprInfo SExprInfo *pExprs = (SExprInfo *)calloc(1, sizeof(SExprInfo) * pQueryMsg->numOfOutput); if (pExprs == NULL) { - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_QRY_OUT_OF_MEMORY; } bool isSuperTable = QUERY_IS_STABLE_QUERY(pQueryMsg->queryType); @@ -5203,7 +5203,7 @@ static int32_t createSqlFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SExprInfo if (getResultDataInfo(type, bytes, pExprs[i].base.functionId, param, &pExprs[i].type, &pExprs[i].bytes, &pExprs[i].interBytes, 0, isSuperTable) != TSDB_CODE_SUCCESS) { tfree(pExprs); - return TSDB_CODE_INVALID_QUERY_MSG; + return TSDB_CODE_QRY_INVALID_MSG; } if (pExprs[i].base.functionId == TSDB_FUNC_TAG_DUMMY || pExprs[i].base.functionId == TSDB_FUNC_TS_DUMMY) { @@ -5244,7 +5244,7 @@ static SSqlGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SCol // using group by tag columns SSqlGroupbyExpr *pGroupbyExpr = (SSqlGroupbyExpr *)calloc(1, sizeof(SSqlGroupbyExpr)); if (pGroupbyExpr == NULL) { - *code = TSDB_CODE_SERV_OUT_OF_MEMORY; + *code = TSDB_CODE_QRY_OUT_OF_MEMORY; return NULL; } @@ -5292,7 +5292,7 @@ static int32_t createFilterInfo(void *pQInfo, SQuery *pQuery) { if (lower == TSDB_RELATION_INVALID && upper == TSDB_RELATION_INVALID) { qError("QInfo:%p invalid filter info", pQInfo); - return TSDB_CODE_INVALID_QUERY_MSG; + return TSDB_CODE_QRY_INVALID_MSG; } int16_t type = pQuery->colList[i].type; @@ -5304,7 +5304,7 @@ static int32_t createFilterInfo(void *pQInfo, SQuery *pQuery) { if (rangeFilterArray == NULL && filterArray == NULL) { qError("QInfo:%p failed to get filter function, invalid data type:%d", pQInfo, type); - return TSDB_CODE_INVALID_QUERY_MSG; + return TSDB_CODE_QRY_INVALID_MSG; } if ((lower == TSDB_RELATION_GREATER_EQUAL || lower == TSDB_RELATION_GREATER) && @@ -5328,7 +5328,7 @@ static int32_t createFilterInfo(void *pQInfo, SQuery *pQuery) { if (upper != TSDB_RELATION_INVALID) { qError("pQInfo:%p failed to get filter function, invalid filter condition", pQInfo, type); - return TSDB_CODE_INVALID_QUERY_MSG; + return TSDB_CODE_QRY_INVALID_MSG; } } else { pSingleColFilter->fp = filterArray[upper]; @@ -5777,13 +5777,13 @@ int32_t qCreateQueryInfo(void *tsdb, int32_t vgId, SQueryTableMsg *pQueryMsg, qi if (pQueryMsg->numOfTables <= 0) { qError("Invalid number of tables to query, numOfTables:%d", pQueryMsg->numOfTables); - code = TSDB_CODE_INVALID_QUERY_MSG; + code = TSDB_CODE_QRY_INVALID_MSG; goto _over; } if (pTableIdList == NULL || taosArrayGetSize(pTableIdList) == 0) { qError("qmsg:%p, SQueryTableMsg wrong format", pQueryMsg); - code = TSDB_CODE_INVALID_QUERY_MSG; + code = TSDB_CODE_QRY_INVALID_MSG; goto _over; } @@ -5846,7 +5846,7 @@ int32_t qCreateQueryInfo(void *tsdb, int32_t vgId, SQueryTableMsg *pQueryMsg, qi (*pQInfo) = createQInfoImpl(pQueryMsg, pTableIdList, pGroupbyExpr, pExprs, &groupInfo, pTagColumnInfo); if ((*pQInfo) == NULL) { - code = TSDB_CODE_SERV_OUT_OF_MEMORY; + code = TSDB_CODE_QRY_OUT_OF_MEMORY; goto _over; } @@ -5905,7 +5905,7 @@ int32_t qRetrieveQueryResultInfo(qinfo_t qinfo) { SQInfo *pQInfo = (SQInfo *)qinfo; if (pQInfo == NULL || !isValidQInfo(pQInfo)) { - return TSDB_CODE_INVALID_QHANDLE; + return TSDB_CODE_QRY_INVALID_QHANDLE; } SQuery *pQuery = pQInfo->runtimeEnv.pQuery; @@ -5944,7 +5944,7 @@ int32_t qDumpRetrieveResult(qinfo_t qinfo, SRetrieveTableRsp **pRsp, int32_t *co SQInfo *pQInfo = (SQInfo *)qinfo; if (pQInfo == NULL || !isValidQInfo(pQInfo)) { - return TSDB_CODE_INVALID_QHANDLE; + return TSDB_CODE_QRY_INVALID_QHANDLE; } SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv; @@ -5980,12 +5980,6 @@ int32_t qDumpRetrieveResult(qinfo_t qinfo, SRetrieveTableRsp **pRsp, int32_t *co } return code; - - // if (numOfRows == 0 && (pRetrieve->qhandle == (uint64_t)pObj->qhandle) && (code != TSDB_CODE_ACTION_IN_PROGRESS)) { - // qTrace("QInfo:%p %s free qhandle code:%d", pObj->qhandle, __FUNCTION__, code); - // vnodeDecRefCount(pObj->qhandle); - // pObj->qhandle = NULL; - // } } static void buildTagQueryResult(SQInfo* pQInfo) { diff --git a/src/query/src/qast.c b/src/query/src/qast.c index f35f4d0184..0a0fe56ebd 100644 --- a/src/query/src/qast.c +++ b/src/query/src/qast.c @@ -1035,7 +1035,7 @@ void exprTreeToBinary(SBufferWriter* bw, tExprNode* expr) { static void* exception_calloc(size_t nmemb, size_t size) { void* p = calloc(nmemb, size); if (p == NULL) { - THROW(TSDB_CODE_SERV_OUT_OF_MEMORY); + THROW(TSDB_CODE_QRY_OUT_OF_MEMORY); } return p; } @@ -1043,7 +1043,7 @@ static void* exception_calloc(size_t nmemb, size_t size) { static void* exception_malloc(size_t size) { void* p = malloc(size); if (p == NULL) { - THROW(TSDB_CODE_SERV_OUT_OF_MEMORY); + THROW(TSDB_CODE_QRY_OUT_OF_MEMORY); } return p; } @@ -1051,7 +1051,7 @@ static void* exception_malloc(size_t size) { static UNUSED_FUNC char* exception_strdup(const char* str) { char* p = strdup(str); if (p == NULL) { - THROW(TSDB_CODE_SERV_OUT_OF_MEMORY); + THROW(TSDB_CODE_QRY_OUT_OF_MEMORY); } return p; } diff --git a/src/query/src/qresultBuf.c b/src/query/src/qresultBuf.c index 8910d84830..222e922176 100644 --- a/src/query/src/qresultBuf.c +++ b/src/query/src/qresultBuf.c @@ -28,19 +28,19 @@ int32_t createDiskbasedResultBuffer(SDiskbasedResultBuf** pResultBuf, int32_t si if (!FD_VALID(pResBuf->fd)) { qError("failed to create tmp file: %s on disk. %s", pResBuf->path, strerror(errno)); - return TSDB_CODE_CLI_NO_DISKSPACE; + return TSDB_CODE_QRY_NO_DISKSPACE; } int32_t ret = ftruncate(pResBuf->fd, pResBuf->numOfPages * DEFAULT_INTERN_BUF_PAGE_SIZE); if (ret != TSDB_CODE_SUCCESS) { qError("failed to create tmp file: %s on disk. %s", pResBuf->path, strerror(errno)); - return TSDB_CODE_CLI_NO_DISKSPACE; + return TSDB_CODE_QRY_NO_DISKSPACE; } pResBuf->pBuf = mmap(NULL, pResBuf->totalBufSize, PROT_READ | PROT_WRITE, MAP_SHARED, pResBuf->fd, 0); if (pResBuf->pBuf == MAP_FAILED) { qError("QInfo:%p failed to map temp file: %s. %s", handle, pResBuf->path, strerror(errno)); - return TSDB_CODE_CLI_OUT_OF_MEMORY; // todo change error code + return TSDB_CODE_QRY_OUT_OF_MEMORY; // todo change error code } qTrace("QInfo:%p create tmp file for output result, %s, %" PRId64 "bytes", handle, pResBuf->path, @@ -74,7 +74,7 @@ static int32_t extendDiskFileSize(SDiskbasedResultBuf* pResultBuf, int32_t numOf if (ret != 0) { // dError("QInfo:%p failed to create intermediate result output file:%s. %s", pQInfo, pSupporter->extBufFile, // strerror(errno)); - return -TSDB_CODE_SERV_NO_DISKSPACE; + return -TSDB_CODE_QRY_NO_DISKSPACE; } pResultBuf->totalBufSize = pResultBuf->numOfPages * DEFAULT_INTERN_BUF_PAGE_SIZE; @@ -82,7 +82,7 @@ static int32_t extendDiskFileSize(SDiskbasedResultBuf* pResultBuf, int32_t numOf if (pResultBuf->pBuf == MAP_FAILED) { // dError("QInfo:%p failed to map temp file: %s. %s", pQInfo, pSupporter->extBufFile, strerror(errno)); - return -TSDB_CODE_SERV_OUT_OF_MEMORY; + return -TSDB_CODE_QRY_OUT_OF_MEMORY; } return TSDB_CODE_SUCCESS; diff --git a/src/query/src/tlosertree.c b/src/query/src/tlosertree.c index 0d81f4604b..5d471bb927 100644 --- a/src/query/src/tlosertree.c +++ b/src/query/src/tlosertree.c @@ -46,7 +46,7 @@ uint32_t tLoserTreeCreate(SLoserTreeInfo** pTree, int32_t numOfEntries, void* pa *pTree = (SLoserTreeInfo*)calloc(1, sizeof(SLoserTreeInfo) + sizeof(SLoserTreeNode) * totalEntries); if ((*pTree) == NULL) { qError("allocate memory for loser-tree failed. reason:%s", strerror(errno)); - return TSDB_CODE_CLI_OUT_OF_MEMORY; + return TSDB_CODE_QRY_OUT_OF_MEMORY; } (*pTree)->pNode = (SLoserTreeNode*)(((char*)(*pTree)) + sizeof(SLoserTreeInfo)); diff --git a/src/query/tests/unitTest.cpp b/src/query/tests/unitTest.cpp index df28a3e4d1..c33ebeb58b 100644 --- a/src/query/tests/unitTest.cpp +++ b/src/query/tests/unitTest.cpp @@ -99,47 +99,47 @@ TEST(testCase, db_table_name) { EXPECT_EQ(testValidateName(t4), TSDB_CODE_SUCCESS); char t5[] = "table.'def'"; - EXPECT_EQ(testValidateName(t5), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t5), TSDB_CODE_TSC_INVALID_SQL); char t6[] = "'table'.'def'"; - EXPECT_EQ(testValidateName(t6), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t6), TSDB_CODE_TSC_INVALID_SQL); char t7[] = "'_ab1234'.'def'"; EXPECT_EQ(testValidateName(t7), TSDB_CODE_SUCCESS); printf("%s\n", t7); char t8[] = "'_ab&^%1234'.'def'"; - EXPECT_EQ(testValidateName(t8), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t8), TSDB_CODE_TSC_INVALID_SQL); char t9[] = "'_123'.'gtest中文'"; - EXPECT_EQ(testValidateName(t9), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t9), TSDB_CODE_TSC_INVALID_SQL); char t10[] = "abc.'gtest中文'"; - EXPECT_EQ(testValidateName(t10), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t10), TSDB_CODE_TSC_INVALID_SQL); char t10_1[] = "abc.'中文gtest'"; - EXPECT_EQ(testValidateName(t10_1), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t10_1), TSDB_CODE_TSC_INVALID_SQL); char t11[] = "'192.168.0.1'.abc"; - EXPECT_EQ(testValidateName(t11), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t11), TSDB_CODE_TSC_INVALID_SQL); char t12[] = "192.168.0.1.abc"; - EXPECT_EQ(testValidateName(t12), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t12), TSDB_CODE_TSC_INVALID_SQL); char t13[] = "abc."; - EXPECT_EQ(testValidateName(t13), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t13), TSDB_CODE_TSC_INVALID_SQL); char t14[] = ".abc"; - EXPECT_EQ(testValidateName(t14), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t14), TSDB_CODE_TSC_INVALID_SQL); char t15[] = ".'abc'"; - EXPECT_EQ(testValidateName(t15), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t15), TSDB_CODE_TSC_INVALID_SQL); char t16[] = ".abc'"; - EXPECT_EQ(testValidateName(t16), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t16), TSDB_CODE_TSC_INVALID_SQL); char t17[] = "123a.\"abc\""; - EXPECT_EQ(testValidateName(t17), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t17), TSDB_CODE_TSC_INVALID_SQL); printf("%s\n", t17); char t18[] = "a.\"abc\""; @@ -147,13 +147,13 @@ TEST(testCase, db_table_name) { printf("%s\n", t18); char t19[] = "'_ab1234'.'def'.'ab123'"; - EXPECT_EQ(testValidateName(t19), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t19), TSDB_CODE_TSC_INVALID_SQL); char t20[] = "'_ab1234*&^'"; - EXPECT_EQ(testValidateName(t20), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t20), TSDB_CODE_TSC_INVALID_SQL); char t21[] = "'1234_abc'"; - EXPECT_EQ(testValidateName(t21), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t21), TSDB_CODE_TSC_INVALID_SQL); // =======Containing capital letters================= @@ -167,10 +167,10 @@ TEST(testCase, db_table_name) { EXPECT_EQ(testValidateName(t32), TSDB_CODE_SUCCESS); char t33[] = "'ABC.def"; - EXPECT_EQ(testValidateName(t33), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t33), TSDB_CODE_TSC_INVALID_SQL); char t33_0[] = "abc.DEF'"; - EXPECT_EQ(testValidateName(t33_0), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t33_0), TSDB_CODE_TSC_INVALID_SQL); char t34[] = "'ABC.def'"; //int32_t tmp0 = testValidateName(t34); @@ -193,38 +193,38 @@ TEST(testCase, db_table_name) { // do not use key words char t39[] = "table.'DEF'"; - EXPECT_EQ(testValidateName(t39), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t39), TSDB_CODE_TSC_INVALID_SQL); char t40[] = "'table'.'DEF'"; - EXPECT_EQ(testValidateName(t40), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t40), TSDB_CODE_TSC_INVALID_SQL); char t41[] = "'_abXYZ1234'.'deFF'"; EXPECT_EQ(testValidateName(t41), TSDB_CODE_SUCCESS); char t42[] = "'_abDEF&^%1234'.'DIef'"; - EXPECT_EQ(testValidateName(t42), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t42), TSDB_CODE_TSC_INVALID_SQL); char t43[] = "'_123'.'Gtest中文'"; - EXPECT_EQ(testValidateName(t43), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t43), TSDB_CODE_TSC_INVALID_SQL); char t44[] = "'aABC'.'Gtest中文'"; - EXPECT_EQ(testValidateName(t44), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t44), TSDB_CODE_TSC_INVALID_SQL); char t45[] = "'ABC'."; - EXPECT_EQ(testValidateName(t45), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t45), TSDB_CODE_TSC_INVALID_SQL); char t46[] = ".'ABC'"; - EXPECT_EQ(testValidateName(t46), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t46), TSDB_CODE_TSC_INVALID_SQL); char t47[] = "a.\"aTWc\""; EXPECT_EQ(testValidateName(t47), TSDB_CODE_SUCCESS); // ================has space ================= char t60[] = " ABC "; - EXPECT_EQ(testValidateName(t60), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t60), TSDB_CODE_TSC_INVALID_SQL); char t60_1[] = " ABC "; - EXPECT_EQ(testValidateName(t60_1), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t60_1), TSDB_CODE_TSC_INVALID_SQL); char t61[] = "' ABC '"; EXPECT_EQ(testValidateName(t61), TSDB_CODE_SUCCESS); @@ -233,96 +233,96 @@ TEST(testCase, db_table_name) { EXPECT_EQ(testValidateName(t61_1), TSDB_CODE_SUCCESS); char t62[] = " ABC . def "; - EXPECT_EQ(testValidateName(t62), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t62), TSDB_CODE_TSC_INVALID_SQL); char t63[] = "' ABC . def "; - EXPECT_EQ(testValidateName(t63), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t63), TSDB_CODE_TSC_INVALID_SQL); char t63_0[] = " abc . DEF ' "; - EXPECT_EQ(testValidateName(t63_0), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t63_0), TSDB_CODE_TSC_INVALID_SQL); char t64[] = " ' ABC . def ' "; //int32_t tmp1 = testValidateName(t64); - EXPECT_EQ(testValidateName(t64), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t64), TSDB_CODE_TSC_INVALID_SQL); char t65[] = " ' ABC '. def "; - EXPECT_EQ(testValidateName(t65), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t65), TSDB_CODE_TSC_INVALID_SQL); char t66[] = "' ABC '.' DEF '"; EXPECT_EQ(testValidateName(t66), TSDB_CODE_SUCCESS); char t67[] = "abc . ' DEF '"; - EXPECT_EQ(testValidateName(t67), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t67), TSDB_CODE_TSC_INVALID_SQL); char t68[] = "' abc '.' DEF '"; EXPECT_EQ(testValidateName(t68), TSDB_CODE_SUCCESS); // do not use key words char t69[] = "table.'DEF'"; - EXPECT_EQ(testValidateName(t69), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t69), TSDB_CODE_TSC_INVALID_SQL); char t70[] = "'table'.'DEF'"; - EXPECT_EQ(testValidateName(t70), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t70), TSDB_CODE_TSC_INVALID_SQL); char t71[] = "'_abXYZ1234 '.' deFF '"; EXPECT_EQ(testValidateName(t71), TSDB_CODE_SUCCESS); char t72[] = "'_abDEF&^%1234'.' DIef'"; - EXPECT_EQ(testValidateName(t72), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t72), TSDB_CODE_TSC_INVALID_SQL); char t73[] = "'_123'.' Gtest中文'"; - EXPECT_EQ(testValidateName(t73), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t73), TSDB_CODE_TSC_INVALID_SQL); char t74[] = "' aABC'.'Gtest中文'"; - EXPECT_EQ(testValidateName(t74), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t74), TSDB_CODE_TSC_INVALID_SQL); char t75[] = "' ABC '."; - EXPECT_EQ(testValidateName(t75), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t75), TSDB_CODE_TSC_INVALID_SQL); char t76[] = ".' ABC'"; - EXPECT_EQ(testValidateName(t76), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t76), TSDB_CODE_TSC_INVALID_SQL); char t77[] = " a . \"aTWc\" "; - EXPECT_EQ(testValidateName(t77), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t77), TSDB_CODE_TSC_INVALID_SQL); char t78[] = " a.\"aTWc \""; - EXPECT_EQ(testValidateName(t78), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t78), TSDB_CODE_TSC_INVALID_SQL); // ===============muti string by space =================== // There's no such case. //char t160[] = "A BC"; - //EXPECT_EQ(testValidateName(t160), TSDB_CODE_INVALID_SQL); + //EXPECT_EQ(testValidateName(t160), TSDB_CODE_TSC_INVALID_SQL); //printf("end:%s\n", t160); // There's no such case. //char t161[] = "' A BC '"; - //EXPECT_EQ(testValidateName(t161), TSDB_CODE_INVALID_SQL); + //EXPECT_EQ(testValidateName(t161), TSDB_CODE_TSC_INVALID_SQL); char t162[] = " AB C . de f "; - EXPECT_EQ(testValidateName(t162), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t162), TSDB_CODE_TSC_INVALID_SQL); char t163[] = "' AB C . de f "; - EXPECT_EQ(testValidateName(t163), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t163), TSDB_CODE_TSC_INVALID_SQL); char t163_0[] = " ab c . DE F ' "; - EXPECT_EQ(testValidateName(t163_0), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t163_0), TSDB_CODE_TSC_INVALID_SQL); char t164[] = " ' AB C . de f ' "; //int32_t tmp2 = testValidateName(t164); - EXPECT_EQ(testValidateName(t164), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t164), TSDB_CODE_TSC_INVALID_SQL); char t165[] = " ' A BC '. de f "; - EXPECT_EQ(testValidateName(t165), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t165), TSDB_CODE_TSC_INVALID_SQL); char t166[] = "' AB C '.' DE F '"; - EXPECT_EQ(testValidateName(t166), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t166), TSDB_CODE_TSC_INVALID_SQL); char t167[] = "ab c . ' D EF '"; - EXPECT_EQ(testValidateName(t167), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t167), TSDB_CODE_TSC_INVALID_SQL); char t168[] = "' a bc '.' DE F '"; - EXPECT_EQ(testValidateName(t168), TSDB_CODE_INVALID_SQL); + EXPECT_EQ(testValidateName(t168), TSDB_CODE_TSC_INVALID_SQL); } diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c index e7861201d3..f245214ed9 100644 --- a/src/rpc/src/rpcMain.c +++ b/src/rpc/src/rpcMain.c @@ -418,7 +418,7 @@ void rpcSendResponse(const SRpcMsg *pRsp) { rpcFreeMsg(pConn->pRspMsg); pConn->pRspMsg = msg; pConn->rspMsgLen = msgLen; - if (pMsg->code == TSDB_CODE_ACTION_IN_PROGRESS) pConn->inTranId--; + if (pMsg->code == TSDB_CODE_RPC_ACTION_IN_PROGRESS) pConn->inTranId--; SRpcInfo *pRpc = pConn->pRpc; taosTmrStopA(&pConn->pTimer); @@ -443,7 +443,7 @@ void rpcSendRedirectRsp(void *thandle, const SRpcIpSet *pIpSet) { memcpy(rpcMsg.pCont, pIpSet, sizeof(SRpcIpSet)); - rpcMsg.code = TSDB_CODE_REDIRECT; + rpcMsg.code = TSDB_CODE_RPC_REDIRECT; rpcMsg.handle = thandle; rpcSendResponse(&rpcMsg); @@ -496,7 +496,7 @@ static SRpcConn *rpcOpenConn(SRpcInfo *pRpc, char *peerFqdn, uint16_t peerPort, uint32_t peerIp = taosGetIpFromFqdn(peerFqdn); if (peerIp == -1) { tError("%s, failed to resolve FQDN:%s", pRpc->label, peerFqdn); - terrno = TSDB_CODE_APP_ERROR; + terrno = TSDB_CODE_RPC_APP_ERROR; return NULL; } @@ -513,7 +513,7 @@ static SRpcConn *rpcOpenConn(SRpcInfo *pRpc, char *peerFqdn, uint16_t peerPort, void *shandle = (connType & RPC_CONN_TCP)? pRpc->tcphandle:pRpc->udphandle; pConn->chandle = (*taosOpenConn[connType])(shandle, pConn, pConn->peerIp, pConn->peerPort); if (pConn->chandle == NULL) { - terrno = TSDB_CODE_NETWORK_UNAVAIL; + terrno = TSDB_CODE_RPC_NETWORK_UNAVAIL; rpcCloseConn(pConn); pConn = NULL; } @@ -570,7 +570,7 @@ static SRpcConn *rpcAllocateClientConn(SRpcInfo *pRpc) { int sid = taosAllocateId(pRpc->idPool); if (sid <= 0) { tError("%s maximum number of sessions:%d is reached", pRpc->label, pRpc->sessions); - terrno = TSDB_CODE_MAX_SESSIONS; + terrno = TSDB_CODE_RPC_MAX_SESSIONS; } else { pConn = pRpc->connList + sid; memset(pConn, 0, sizeof(SRpcConn)); @@ -606,7 +606,7 @@ static SRpcConn *rpcAllocateServerConn(SRpcInfo *pRpc, SRecvInfo *pRecv) { int sid = taosAllocateId(pRpc->idPool); if (sid <= 0) { tError("%s maximum number of sessions:%d is reached", pRpc->label, pRpc->sessions); - terrno = TSDB_CODE_MAX_SESSIONS; + terrno = TSDB_CODE_RPC_MAX_SESSIONS; } else { pConn = pRpc->connList + sid; memset(pConn, 0, sizeof(SRpcConn)); @@ -618,7 +618,7 @@ static SRpcConn *rpcAllocateServerConn(SRpcInfo *pRpc, SRecvInfo *pRecv) { pConn->linkUid = pHead->linkUid; if (pRpc->afp) { if (pConn->user[0] == 0) { - terrno = TSDB_CODE_AUTH_REQUIRED; + terrno = TSDB_CODE_RPC_AUTH_REQUIRED; } else { terrno = (*pRpc->afp)(pConn->user, &pConn->spi, &pConn->encrypt, pConn->secret, pConn->ckey); } @@ -656,13 +656,13 @@ static SRpcConn *rpcGetConnObj(SRpcInfo *pRpc, int sid, SRecvInfo *pRecv) { if (pRpc->connType == TAOS_CONN_SERVER) { pConn = rpcAllocateServerConn(pRpc, pRecv); } else { - terrno = TSDB_CODE_UNEXPECTED_RESPONSE; + terrno = TSDB_CODE_RPC_UNEXPECTED_RESPONSE; } } if (pConn) { if (pConn->linkUid != pHead->linkUid) { - terrno = TSDB_CODE_MISMATCHED_METER_ID; + terrno = TSDB_CODE_RPC_MISMATCHED_LINK_ID; pConn = NULL; } } @@ -700,7 +700,7 @@ static int rpcProcessReqHead(SRpcConn *pConn, SRpcHead *pHead) { if (pConn->peerId != pHead->sourceId) { tTrace("%s, source Id is changed, old:0x%08x new:0x%08x", pConn->info, pConn->peerId, pHead->sourceId); - return TSDB_CODE_INVALID_VALUE; + return TSDB_CODE_RPC_INVALID_VALUE; } } @@ -708,7 +708,7 @@ static int rpcProcessReqHead(SRpcConn *pConn, SRpcHead *pHead) { if (pConn->inType == pHead->msgType) { if (pHead->code == 0) { tTrace("%s, %s is retransmitted", pConn->info, taosMsg[pHead->msgType]); - rpcSendQuickRsp(pConn, TSDB_CODE_ACTION_IN_PROGRESS); + rpcSendQuickRsp(pConn, TSDB_CODE_RPC_ACTION_IN_PROGRESS); } else { // do nothing, it is heart beat from client } @@ -720,13 +720,13 @@ static int rpcProcessReqHead(SRpcConn *pConn, SRpcHead *pHead) { } // do not reply any message - return TSDB_CODE_ALREADY_PROCESSED; + return TSDB_CODE_RPC_ALREADY_PROCESSED; } if (pConn->inType != 0) { tTrace("%s, last session is not finished, inTranId:%d tranId:%d", pConn->info, pConn->inTranId, pHead->tranId); - return TSDB_CODE_LAST_SESSION_NOT_FINISHED; + return TSDB_CODE_RPC_LAST_SESSION_NOT_FINISHED; } pConn->inTranId = pHead->tranId; @@ -740,39 +740,39 @@ static int rpcProcessRspHead(SRpcConn *pConn, SRpcHead *pHead) { pConn->peerId = pHead->sourceId; if (pConn->outType == 0 || pConn->pContext == NULL) { - return TSDB_CODE_UNEXPECTED_RESPONSE; + return TSDB_CODE_RPC_UNEXPECTED_RESPONSE; } if (pHead->tranId != pConn->outTranId) { - return TSDB_CODE_INVALID_TRAN_ID; + return TSDB_CODE_RPC_INVALID_TRAN_ID; } if (pHead->msgType != pConn->outType + 1) { - return TSDB_CODE_INVALID_RESPONSE_TYPE; + return TSDB_CODE_RPC_INVALID_RESPONSE_TYPE; } taosTmrStopA(&pConn->pTimer); pConn->retry = 0; - if (pHead->code == TSDB_CODE_AUTH_REQUIRED && pRpc->spi) { + if (pHead->code == TSDB_CODE_RPC_AUTH_REQUIRED && pRpc->spi) { tTrace("%s, authentication shall be restarted", pConn->info); pConn->secured = 0; rpcSendMsgToPeer(pConn, pConn->pReqMsg, pConn->reqMsgLen); pConn->pTimer = taosTmrStart(rpcProcessRetryTimer, tsRpcTimer, pConn, pRpc->tmrCtrl); - return TSDB_CODE_ALREADY_PROCESSED; + return TSDB_CODE_RPC_ALREADY_PROCESSED; } - if (pHead->code == TSDB_CODE_ACTION_IN_PROGRESS) { + if (pHead->code == TSDB_CODE_RPC_ACTION_IN_PROGRESS) { if (pConn->tretry <= tsRpcMaxRetry) { tTrace("%s, peer is still processing the transaction, retry:%d", pConn->info, pConn->tretry); pConn->tretry++; rpcSendReqHead(pConn); pConn->pTimer = taosTmrStart(rpcProcessRetryTimer, tsRpcTimer, pConn, pRpc->tmrCtrl); - return TSDB_CODE_ALREADY_PROCESSED; + return TSDB_CODE_RPC_ALREADY_PROCESSED; } else { // peer still in processing, give up tTrace("%s, server processing takes too long time, give up", pConn->info); - pHead->code = TSDB_CODE_TOO_SLOW; + pHead->code = TSDB_CODE_RPC_TOO_SLOW; } } @@ -793,13 +793,13 @@ static SRpcConn *rpcProcessMsgHead(SRpcInfo *pRpc, SRecvInfo *pRecv) { if (pHead->msgType >= TSDB_MSG_TYPE_MAX || pHead->msgType <= 0) { tTrace("%s sid:%d, invalid message type:%d", pRpc->label, sid, pHead->msgType); - terrno = TSDB_CODE_INVALID_MSG_TYPE; return NULL; + terrno = TSDB_CODE_RPC_INVALID_MSG_TYPE; return NULL; } if (sid < 0 || sid >= pRpc->sessions) { tTrace("%s sid:%d, sid is out of range, max sid:%d, %s discarded", pRpc->label, sid, pRpc->sessions, taosMsg[pHead->msgType]); - terrno = TSDB_CODE_INVALID_SESSION_ID; return NULL; + terrno = TSDB_CODE_RPC_INVALID_SESSION_ID; return NULL; } pConn = rpcGetConnObj(pRpc, sid, pRecv); @@ -855,7 +855,7 @@ static void rpcProcessBrokenLink(SRpcConn *pConn) { if (pConn->outType) { SRpcReqContext *pContext = pConn->pContext; - pContext->code = TSDB_CODE_NETWORK_UNAVAIL; + pContext->code = TSDB_CODE_RPC_NETWORK_UNAVAIL; taosTmrStart(rpcProcessConnError, 0, pContext, pRpc->tmrCtrl); } @@ -868,7 +868,7 @@ static void rpcProcessBrokenLink(SRpcConn *pConn) { rpcMsg.contLen = 0; rpcMsg.handle = pConn; rpcMsg.msgType = pConn->inType; - rpcMsg.code = TSDB_CODE_NETWORK_UNAVAIL; + rpcMsg.code = TSDB_CODE_RPC_NETWORK_UNAVAIL; (*(pRpc->cfp))(&rpcMsg); */ } @@ -901,7 +901,7 @@ static void *rpcProcessMsgFromPeer(SRecvInfo *pRecv) { } int32_t code = terrno; - if (code != TSDB_CODE_ALREADY_PROCESSED) { + if (code != TSDB_CODE_RPC_ALREADY_PROCESSED) { if (code != 0) { // parsing error if (rpcIsReq(pHead->msgType)) { rpcSendErrorMsgToPeer(pRecv, code); @@ -960,28 +960,28 @@ static void rpcProcessIncomingMsg(SRpcConn *pConn, SRpcHead *pHead) { pConn->pContext = NULL; // for UDP, port may be changed by server, the port in ipSet shall be used for cache - if (pHead->code != TSDB_CODE_TOO_SLOW) { + if (pHead->code != TSDB_CODE_RPC_TOO_SLOW) { rpcAddConnIntoCache(pRpc->pCache, pConn, pConn->peerFqdn, pContext->ipSet.port[pContext->ipSet.inUse], pConn->connType); } else { rpcCloseConn(pConn); } - if (pHead->code == TSDB_CODE_REDIRECT) { + if (pHead->code == TSDB_CODE_RPC_REDIRECT) { pContext->redirect++; if (pContext->redirect > TSDB_MAX_REPLICA) { - pHead->code = TSDB_CODE_NETWORK_UNAVAIL; + pHead->code = TSDB_CODE_RPC_NETWORK_UNAVAIL; tWarn("%s, too many redirects, quit", pConn->info); } } - if (pHead->code == TSDB_CODE_REDIRECT) { + if (pHead->code == TSDB_CODE_RPC_REDIRECT) { pContext->numOfTry = 0; memcpy(&pContext->ipSet, pHead->content, sizeof(pContext->ipSet)); tTrace("%s, redirect is received, numOfIps:%d", pConn->info, pContext->ipSet.numOfIps); for (int i=0; iipSet.numOfIps; ++i) pContext->ipSet.port[i] = htons(pContext->ipSet.port[i]); rpcSendReqToServer(pRpc, pContext); - } else if (pHead->code == TSDB_CODE_NOT_READY) { + } else if (pHead->code == TSDB_CODE_RPC_NOT_READY) { pContext->code = pHead->code; rpcProcessConnError(pContext, NULL); } else { @@ -1058,7 +1058,7 @@ static void rpcSendErrorMsgToPeer(SRecvInfo *pRecv, int32_t code) { pReplyHead->code = htonl(code); msgLen = sizeof(SRpcHead); - if (code == TSDB_CODE_INVALID_TIME_STAMP) { + if (code == TSDB_CODE_RPC_INVALID_TIME_STAMP) { // include a time stamp if client's time is not synchronized well uint8_t *pContent = pReplyHead->content; timeStamp = htonl(taosGetTimestampSec()); @@ -1200,7 +1200,7 @@ static void rpcProcessRetryTimer(void *param, void *tmrId) { rpcUnlockConn(pConn); if (reportDisc && pConn->pContext) { - pConn->pContext->code = TSDB_CODE_NETWORK_UNAVAIL; + pConn->pContext->code = TSDB_CODE_RPC_NETWORK_UNAVAIL; rpcProcessConnError(pConn->pContext, NULL); rpcCloseConn(pConn); } @@ -1221,7 +1221,7 @@ static void rpcProcessIdleTimer(void *param, void *tmrId) { rpcMsg.contLen = 0; rpcMsg.handle = pConn; rpcMsg.msgType = pConn->inType; - rpcMsg.code = TSDB_CODE_NETWORK_UNAVAIL; + rpcMsg.code = TSDB_CODE_RPC_NETWORK_UNAVAIL; (*(pRpc->cfp))(&rpcMsg); */ } @@ -1239,7 +1239,7 @@ static void rpcProcessProgressTimer(void *param, void *tmrId) { if (pConn->inType && pConn->user[0]) { tTrace("%s, progress timer expired, send progress", pConn->info); - rpcSendQuickRsp(pConn, TSDB_CODE_ACTION_IN_PROGRESS); + rpcSendQuickRsp(pConn, TSDB_CODE_RPC_ACTION_IN_PROGRESS); pConn->pTimer = taosTmrStart(rpcProcessProgressTimer, tsProgressTimer, pConn, pRpc->tmrCtrl); } else { tTrace("%s, progress timer:%p not processed", pConn->info, tmrId); @@ -1379,12 +1379,12 @@ static int rpcCheckAuthentication(SRpcConn *pConn, char *msg, int msgLen) { if ( !rpcIsReq(pHead->msgType) ) { // for response, if code is auth failure, it shall bypass the auth process code = htonl(pHead->code); - if (code==TSDB_CODE_INVALID_TIME_STAMP || code==TSDB_CODE_AUTH_FAILURE || code == TSDB_CODE_AUTH_REQUIRED || - code==TSDB_CODE_INVALID_USER || code == TSDB_CODE_NOT_READY) { + if (code == TSDB_CODE_RPC_INVALID_TIME_STAMP || code == TSDB_CODE_RPC_AUTH_FAILURE || + code == TSDB_CODE_RPC_AUTH_REQUIRED || code == TSDB_CODE_MND_INVALID_USER || code == TSDB_CODE_RPC_NOT_READY) { pHead->msgLen = (int32_t)htonl((uint32_t)pHead->msgLen); // tTrace("%s, dont check authentication since code is:0x%x", pConn->info, code); return 0; - } + } } code = 0; @@ -1397,11 +1397,11 @@ static int rpcCheckAuthentication(SRpcConn *pConn, char *msg, int msgLen) { delta -= (int32_t)taosGetTimestampSec(); if (abs(delta) > 900) { tWarn("%s, time diff:%d is too big, msg discarded", pConn->info, delta); - code = TSDB_CODE_INVALID_TIME_STAMP; + code = TSDB_CODE_RPC_INVALID_TIME_STAMP; } else { if (rpcAuthenticateMsg(pHead, msgLen-TSDB_AUTH_LEN, pDigest->auth, pConn->secret) < 0) { tTrace("%s, authentication failed, msg discarded", pConn->info); - code = TSDB_CODE_AUTH_FAILURE; + code = TSDB_CODE_RPC_AUTH_FAILURE; } else { pHead->msgLen = (int32_t)htonl((uint32_t)pHead->msgLen) - sizeof(SRpcDigest); if ( !rpcIsReq(pHead->msgType) ) pConn->secured = 1; // link is secured for client @@ -1410,7 +1410,7 @@ static int rpcCheckAuthentication(SRpcConn *pConn, char *msg, int msgLen) { } } else { tTrace("%s, auth spi:%d not matched with received:%d", pConn->info, pConn->spi, pHead->spi); - code = pHead->spi ? TSDB_CODE_AUTH_FAILURE : TSDB_CODE_AUTH_REQUIRED; + code = pHead->spi ? TSDB_CODE_RPC_AUTH_FAILURE : TSDB_CODE_RPC_AUTH_REQUIRED; } return code; diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c index 0efb477e73..8f102795b5 100644 --- a/src/tsdb/src/tsdbMain.c +++ b/src/tsdb/src/tsdbMain.c @@ -92,16 +92,15 @@ STsdbCfg *tsdbGetCfg(const TsdbRepoT *repo) { * @return a TSDB repository handle on success, NULL for failure */ int32_t tsdbCreateRepo(char *rootDir, STsdbCfg *pCfg, void *limiter /* TODO */) { - if (mkdir(rootDir, 0755) != 0) { tsdbError("vgId:%d, failed to create rootDir! rootDir:%s, reason:%s", pCfg->tsdbId, rootDir, strerror(errno)); if (errno == EACCES) { - return TSDB_CODE_NO_DISK_PERMISSIONS; + return TSDB_CODE_TDB_NO_DISK_PERMISSIONS; } else if (errno == ENOSPC) { - return TSDB_CODE_SERV_NO_DISKSPACE; + return TSDB_CODE_TDB_NO_DISKSPACE; } else if (errno == EEXIST) { } else { - return TSDB_CODE_VG_INIT_FAILED; + return TSDB_CODE_TDB_INIT_FAILED; } } @@ -315,7 +314,7 @@ int32_t tsdbConfigRepo(TsdbRepoT *repo, STsdbCfg *pCfg) { STsdbRepo *pRepo = (STsdbRepo *)repo; STsdbCfg * pRCfg = &pRepo->config; - if (tsdbCheckAndSetDefaultCfg(pCfg) < 0) return TSDB_CODE_INVALID_CONFIG; + if (tsdbCheckAndSetDefaultCfg(pCfg) < 0) return TSDB_CODE_TDB_INVALID_CONFIG; ASSERT(pRCfg->tsdbId == pCfg->tsdbId); ASSERT(pRCfg->cacheBlockSize == pCfg->cacheBlockSize); @@ -416,13 +415,13 @@ int tsdbUpdateTagValue(TsdbRepoT *repo, SUpdateTableTagValMsg *pMsg) { int16_t tversion = htons(pMsg->tversion); STable *pTable = tsdbGetTableByUid(pMeta, htobe64(pMsg->uid)); - if (pTable == NULL) return TSDB_CODE_INVALID_TABLE_ID; - if (pTable->tableId.tid != htonl(pMsg->tid)) return TSDB_CODE_INVALID_TABLE_ID; + if (pTable == NULL) return TSDB_CODE_TDB_INVALID_TABLE_ID; + if (pTable->tableId.tid != htonl(pMsg->tid)) return TSDB_CODE_TDB_INVALID_TABLE_ID; if (pTable->type != TSDB_CHILD_TABLE) { tsdbError("vgId:%d failed to update tag value of table %s since its type is %d", pRepo->config.tsdbId, varDataVal(pTable->name), pTable->type); - return TSDB_CODE_INVALID_TABLE_TYPE; + return TSDB_CODE_TDB_INVALID_TABLE_TYPE; } if (schemaVersion(tsdbGetTableTagSchema(pMeta, pTable)) < tversion) { @@ -452,7 +451,7 @@ int tsdbUpdateTagValue(TsdbRepoT *repo, SUpdateTableTagValMsg *pMsg) { "vgId:%d failed to update tag value of table %s since version out of date, client tag version:%d server tag " "version:%d", pRepo->config.tsdbId, varDataVal(pTable->name), tversion, schemaVersion(pTable->tagSchema)); - return TSDB_CODE_TAG_VER_OUT_OF_DATE; + return TSDB_CODE_TDB_TAG_VER_OUT_OF_DATE; } if (schemaColAt(pTagSchema, DEFAULT_TAG_INDEX_COLUMN)->colId == htons(pMsg->colId)) { tsdbRemoveTableFromIndex(pMeta, pTable); @@ -948,7 +947,7 @@ static int32_t tsdbInsertDataToTable(TsdbRepoT *repo, SSubmitBlk *pBlock, TSKEY if (pTable == NULL) { tsdbError("vgId:%d, failed to get table for insert, uid:" PRIu64 ", tid:%d", pRepo->config.tsdbId, pBlock->uid, pBlock->tid); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_TDB_INVALID_TABLE_ID; } // Check schema version @@ -980,7 +979,7 @@ static int32_t tsdbInsertDataToTable(TsdbRepoT *repo, SSubmitBlk *pBlock, TSKEY if (tsdbGetTableSchemaByVersion(pMeta, pTable, tversion) == NULL) { tsdbError("vgId:%d table:%s tid:%d invalid schema version %d from client", pRepo->config.tsdbId, varDataVal(pTable->name), pTable->tableId.tid, tversion); - return TSDB_CODE_TABLE_SCHEMA_VERSION; + return TSDB_CODE_TDB_TABLE_SCHEMA_VERSION; } } @@ -996,7 +995,7 @@ static int32_t tsdbInsertDataToTable(TsdbRepoT *repo, SSubmitBlk *pBlock, TSKEY tsdbError("vgId:%d, table:%s, tid:%d, talbe uid:%ld timestamp is out of range. now:" PRId64 ", maxKey:" PRId64 ", minKey:" PRId64, pRepo->config.tsdbId, varDataVal(pTable->name), pTable->tableId.tid, pTable->tableId.uid, now, minKey, maxKey); - return TSDB_CODE_TIMESTAMP_OUT_OF_RANGE; + return TSDB_CODE_TDB_TIMESTAMP_OUT_OF_RANGE; } if (tdInsertRowToTable(pRepo, row, pTable) < 0) { diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c index 9f1e507d54..34d3c27893 100644 --- a/src/tsdb/src/tsdbMeta.c +++ b/src/tsdb/src/tsdbMeta.c @@ -323,7 +323,7 @@ static STable *tsdbNewTable(STableCfg *pCfg, bool isSuper) { pTable = (STable *)calloc(1, sizeof(STable)); if (pTable == NULL) { - terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + terrno = TSDB_CODE_TDB_OUT_OF_MEMORY; goto _err; } @@ -343,7 +343,7 @@ static STable *tsdbNewTable(STableCfg *pCfg, bool isSuper) { tsize = strnlen(pCfg->sname, TSDB_TABLE_NAME_LEN); pTable->name = calloc(1, tsize + VARSTR_HEADER_SIZE + 1); if (pTable->name == NULL) { - terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + terrno = TSDB_CODE_TDB_OUT_OF_MEMORY; goto _err; } STR_WITH_SIZE_TO_VARSTR(pTable->name, pCfg->sname, tsize); @@ -352,7 +352,7 @@ static STable *tsdbNewTable(STableCfg *pCfg, bool isSuper) { pTable->pIndex = tSkipListCreate(TSDB_SUPER_TABLE_SL_LEVEL, pColSchema->type, pColSchema->bytes, 1, 0, 0, getTagIndexKey); // Allow duplicate key, no lock if (pTable->pIndex == NULL) { - terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + terrno = TSDB_CODE_TDB_OUT_OF_MEMORY; goto _err; } } else { @@ -364,7 +364,7 @@ static STable *tsdbNewTable(STableCfg *pCfg, bool isSuper) { tsize = strnlen(pCfg->name, TSDB_TABLE_NAME_LEN); pTable->name = calloc(1, tsize + VARSTR_HEADER_SIZE + 1); if (pTable->name == NULL) { - terrno = TSDB_CODE_SERV_OUT_OF_MEMORY; + terrno = TSDB_CODE_TDB_OUT_OF_MEMORY; goto _err; } STR_WITH_SIZE_TO_VARSTR(pTable->name, pCfg->name, tsize); @@ -399,7 +399,7 @@ static int tsdbUpdateTableTagSchema(STable *pTable, STSchema *newSchema) { ASSERT(schemaVersion(pTable->tagSchema) < schemaVersion(newSchema)); STSchema *pOldSchema = pTable->tagSchema; STSchema *pNewSchema = tdDupSchema(newSchema); - if (pNewSchema == NULL) return TSDB_CODE_SERV_OUT_OF_MEMORY; + if (pNewSchema == NULL) return TSDB_CODE_TDB_OUT_OF_MEMORY; pTable->tagSchema = pNewSchema; tdFreeSchema(pOldSchema); @@ -454,7 +454,7 @@ int tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg) { if (pTable != NULL) { tsdbError("vgId:%d table %s already exists, tid %d uid %" PRId64, pRepo->config.tsdbId, varDataVal(pTable->name), pTable->tableId.tid, pTable->tableId.uid); - return TSDB_CODE_TABLE_ALREADY_EXIST; + return TSDB_CODE_TDB_TABLE_ALREADY_EXIST; } STable *super = NULL; diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c index 4a48bcefe7..ef0e2ab3f6 100644 --- a/src/tsdb/src/tsdbRead.c +++ b/src/tsdb/src/tsdbRead.c @@ -1147,7 +1147,7 @@ static int32_t dataBlockOrderCompar(const void* pLeft, const void* pRight, void* static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numOfBlocks, int32_t* numOfAllocBlocks) { char* tmp = realloc(pQueryHandle->pDataBlockInfo, sizeof(STableBlockInfo) * numOfBlocks); if (tmp == NULL) { - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_TDB_OUT_OF_MEMORY; } pQueryHandle->pDataBlockInfo = (STableBlockInfo*) tmp; @@ -1164,7 +1164,7 @@ static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numO if (sup.numOfBlocksPerTable == NULL || sup.blockIndexArray == NULL || sup.pDataBlockInfo == NULL) { cleanBlockOrderSupporter(&sup, 0); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_TDB_OUT_OF_MEMORY; } int32_t cnt = 0; @@ -1182,7 +1182,7 @@ static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numO char* buf = calloc(1, sizeof(STableBlockInfo) * pTableCheck->numOfBlocks); if (buf == NULL) { cleanBlockOrderSupporter(&sup, numOfQualTables); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_TDB_OUT_OF_MEMORY; } sup.pDataBlockInfo[numOfQualTables] = (STableBlockInfo*)buf; @@ -1209,7 +1209,7 @@ static int32_t createDataBlocksInfo(STsdbQueryHandle* pQueryHandle, int32_t numO uint8_t ret = tLoserTreeCreate(&pTree, sup.numOfTables, &sup, dataBlockOrderCompar); if (ret != TSDB_CODE_SUCCESS) { cleanBlockOrderSupporter(&sup, numOfTables); - return TSDB_CODE_SERV_OUT_OF_MEMORY; + return TSDB_CODE_TDB_OUT_OF_MEMORY; } int32_t numOfTotal = 0; @@ -2070,14 +2070,14 @@ int32_t tsdbQuerySTableByTagCond(TsdbRepoT* tsdb, uint64_t uid, const char* pTag STable* pTable = tsdbGetTableByUid(tsdbGetMeta(tsdb), uid); if (pTable == NULL) { tsdbError("%p failed to get stable, uid:%" PRIu64, tsdb, uid); - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_TDB_INVALID_TABLE_ID; } if (pTable->type != TSDB_SUPER_TABLE) { tsdbError("%p query normal tag not allowed, uid:%" PRIu64 ", tid:%d, name:%s", tsdb, uid, pTable->tableId.tid, pTable->name); - return TSDB_CODE_OPS_NOT_SUPPORT; //basically, this error is caused by invalid sql issued by client + return TSDB_CODE_COM_OPS_NOT_SUPPORT; //basically, this error is caused by invalid sql issued by client } SArray* res = taosArrayInit(8, sizeof(STableId)); @@ -2114,7 +2114,7 @@ int32_t tsdbQuerySTableByTagCond(TsdbRepoT* tsdb, uint64_t uid, const char* pTag tExprNode* tbnameExpr = expr; expr = calloc(1, sizeof(tExprNode)); if (expr == NULL) { - THROW( TSDB_CODE_SERV_OUT_OF_MEMORY ); + THROW( TSDB_CODE_TDB_OUT_OF_MEMORY ); } expr->nodeType = TSQL_NODE_EXPR; expr->_node.optr = tagNameRelType; @@ -2141,7 +2141,7 @@ int32_t tsdbQuerySTableByTagCond(TsdbRepoT* tsdb, uint64_t uid, const char* pTag int32_t tsdbGetOneTableGroup(TsdbRepoT* tsdb, uint64_t uid, STableGroupInfo* pGroupInfo) { STable* pTable = tsdbGetTableByUid(tsdbGetMeta(tsdb), uid); if (pTable == NULL) { - return TSDB_CODE_INVALID_TABLE_ID; + return TSDB_CODE_TDB_INVALID_TABLE_ID; } //todo assert table type, add the table ref count diff --git a/src/util/src/tbuffer.c b/src/util/src/tbuffer.c index 3b4cc74cc3..4b37cbd2d5 100644 --- a/src/util/src/tbuffer.c +++ b/src/util/src/tbuffer.c @@ -26,7 +26,7 @@ size_t tbufSkip(SBufferReader* buf, size_t size) { if( (buf->pos + size) > buf->size ) { - THROW( TSDB_CODE_MEMORY_CORRUPTED ); + THROW( TSDB_CODE_COM_MEMORY_CORRUPTED ); } size_t old = buf->pos; buf->pos += size; @@ -58,7 +58,7 @@ const char* tbufReadString( SBufferReader* buf, size_t* len ) { const char* ret = buf->data + buf->pos; tbufSkip( buf, l + 1 ); if( ret[l] != 0 ) { - THROW( TSDB_CODE_MEMORY_CORRUPTED ); + THROW( TSDB_CODE_COM_MEMORY_CORRUPTED ); } if( len != NULL ) { *len = l; @@ -204,7 +204,7 @@ void tbufEnsureCapacity( SBufferWriter* buf, size_t size ) { char* data = (*buf->allocator)( buf->data, nsize ); // TODO: the exception should be thrown by the allocator function if( data == NULL ) { - THROW( TSDB_CODE_SERV_OUT_OF_MEMORY ); + THROW( TSDB_CODE_COM_OUT_OF_MEMORY ); } buf->data = data; buf->size = nsize; diff --git a/src/util/src/tqueue.c b/src/util/src/tqueue.c index 4cf7eb3164..7e9392f410 100644 --- a/src/util/src/tqueue.c +++ b/src/util/src/tqueue.c @@ -55,7 +55,7 @@ taos_queue taosOpenQueue() { STaosQueue *queue = (STaosQueue *) calloc(sizeof(STaosQueue), 1); if (queue == NULL) { - terrno = TSDB_CODE_NO_RESOURCE; + terrno = TSDB_CODE_COM_OUT_OF_MEMORY; return NULL; } @@ -216,7 +216,7 @@ taos_qset taosOpenQset() { STaosQset *qset = (STaosQset *) calloc(sizeof(STaosQset), 1); if (qset == NULL) { - terrno = TSDB_CODE_NO_RESOURCE; + terrno = TSDB_CODE_COM_OUT_OF_MEMORY; return NULL; } diff --git a/src/util/src/tutil.c b/src/util/src/tutil.c index 6a5c8b6799..383d9b8f98 100644 --- a/src/util/src/tutil.c +++ b/src/util/src/tutil.c @@ -582,18 +582,18 @@ int taosCheckVersion(char *input_client_version, char *input_server_version, int if (!taosGetVersionNumber(client_version, clientVersionNumber)) { uError("invalid client version:%s", client_version); - return TSDB_CODE_INVALID_CLIENT_VERSION; + return TSDB_CODE_TSC_INVALID_VERSION; } if (!taosGetVersionNumber(server_version, serverVersionNumber)) { uError("invalid server version:%s", server_version); - return TSDB_CODE_INVALID_CLIENT_VERSION; + return TSDB_CODE_TSC_INVALID_VERSION; } for(int32_t i = 0; i < comparedSegments; ++i) { if (clientVersionNumber[i] != serverVersionNumber[i]) { uError("the %d-th number of server version:%s not matched with client version:%s", i, server_version, version); - return TSDB_CODE_INVALID_CLIENT_VERSION; + return TSDB_CODE_TSC_INVALID_VERSION; } } diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c index 3d8cf67d02..d1dfa24cbe 100644 --- a/src/vnode/src/vnodeMain.c +++ b/src/vnode/src/vnodeMain.c @@ -82,14 +82,14 @@ int32_t vnodeCreate(SMDCreateVnodeMsg *pVnodeCfg) { if (mkdir(rootDir, 0755) != 0) { vPrint("vgId:%d, failed to create vnode, reason:%s dir:%s", pVnodeCfg->cfg.vgId, strerror(errno), rootDir); if (errno == EACCES) { - return TSDB_CODE_NO_DISK_PERMISSIONS; + return TSDB_CODE_VND_NO_DISK_PERMISSIONS; } else if (errno == ENOSPC) { - return TSDB_CODE_SERV_NO_DISKSPACE; + return TSDB_CODE_VND_NO_DISKSPACE; } else if (errno == ENOENT) { - return TSDB_CODE_NOT_SUCH_FILE_OR_DIR; + return TSDB_CODE_VND_NO_SUCH_FILE_OR_DIR; } else if (errno == EEXIST) { } else { - return TSDB_CODE_VG_INIT_FAILED; + return TSDB_CODE_VND_INIT_FAILED; } } @@ -116,7 +116,7 @@ int32_t vnodeCreate(SMDCreateVnodeMsg *pVnodeCfg) { code = tsdbCreateRepo(tsdbDir, &tsdbCfg, NULL); if (code != TSDB_CODE_SUCCESS) { vError("vgId:%d, failed to create tsdb in vnode, reason:%s", pVnodeCfg->cfg.vgId, tstrerror(code)); - return TSDB_CODE_VG_INIT_FAILED; + return TSDB_CODE_VND_INIT_FAILED; } vPrint("vgId:%d, vnode is created, clog:%d", pVnodeCfg->cfg.vgId, pVnodeCfg->cfg.walLevel); @@ -128,13 +128,13 @@ int32_t vnodeCreate(SMDCreateVnodeMsg *pVnodeCfg) { int32_t vnodeDrop(int32_t vgId) { if (tsDnodeVnodesHash == NULL) { vTrace("vgId:%d, failed to drop, vgId not exist", vgId); - return TSDB_CODE_INVALID_VGROUP_ID; + return TSDB_CODE_VND_INVALID_VGROUP_ID; } SVnodeObj **ppVnode = (SVnodeObj **)taosHashGet(tsDnodeVnodesHash, (const char *)&vgId, sizeof(int32_t)); if (ppVnode == NULL || *ppVnode == NULL) { vTrace("vgId:%d, failed to drop, vgId not find", vgId); - return TSDB_CODE_INVALID_VGROUP_ID; + return TSDB_CODE_VND_INVALID_VGROUP_ID; } SVnodeObj *pVnode = *ppVnode; @@ -326,7 +326,7 @@ void *vnodeGetVnode(int32_t vgId) { SVnodeObj **ppVnode = (SVnodeObj **)taosHashGet(tsDnodeVnodesHash, (const char *)&vgId, sizeof(int32_t)); if (ppVnode == NULL || *ppVnode == NULL) { - terrno = TSDB_CODE_INVALID_VGROUP_ID; + terrno = TSDB_CODE_VND_INVALID_VGROUP_ID; vPrint("vgId:%d, not exist", vgId); return NULL; } @@ -494,7 +494,7 @@ static int32_t vnodeSaveCfg(SMDCreateVnodeMsg *pVnodeCfg) { char * content = calloc(1, maxLen + 1); if (content == NULL) { fclose(fp); - return TSDB_CODE_NO_RESOURCE; + return TSDB_CODE_VND_OUT_OF_MEMORY; } len += snprintf(content + len, maxLen - len, "{\n"); @@ -545,7 +545,7 @@ static int32_t vnodeReadCfg(SVnodeObj *pVnode) { char cfgFile[TSDB_FILENAME_LEN + 30] = {0}; int maxLen = 1000; - terrno = TSDB_CODE_OTHERS; + terrno = TSDB_CODE_VND_APP_ERROR; sprintf(cfgFile, "%s/vnode%d/config.json", tsVnodeDir, pVnode->vgId); FILE *fp = fopen(cfgFile, "r"); if (!fp) { @@ -777,7 +777,7 @@ static int32_t vnodeReadVersion(SVnodeObj *pVnode) { cJSON *root = NULL; int maxLen = 100; - terrno = TSDB_CODE_OTHERS; + terrno = TSDB_CODE_VND_APP_ERROR; sprintf(versionFile, "%s/vnode%d/version.json", tsVnodeDir, pVnode->vgId); FILE *fp = fopen(versionFile, "r"); if (!fp) { diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c index ef2cb20171..af8052b0c7 100644 --- a/src/vnode/src/vnodeRead.c +++ b/src/vnode/src/vnodeRead.c @@ -40,10 +40,10 @@ int32_t vnodeProcessRead(void *param, int msgType, void *pCont, int32_t contLen, SVnodeObj *pVnode = (SVnodeObj *)param; if (vnodeProcessReadMsgFp[msgType] == NULL) - return TSDB_CODE_MSG_NOT_PROCESSED; + return TSDB_CODE_VND_MSG_NOT_PROCESSED; if (pVnode->status == TAOS_VN_STATUS_DELETING || pVnode->status == TAOS_VN_STATUS_CLOSING) - return TSDB_CODE_INVALID_VGROUP_ID; + return TSDB_CODE_VND_INVALID_VGROUP_ID; return (*vnodeProcessReadMsgFp[msgType])(pVnode, pCont, contLen, ret); } @@ -69,7 +69,7 @@ static int32_t vnodeProcessQueryMsg(SVnodeObj *pVnode, void *pCont, int32_t cont } else { assert(pCont != NULL); pQInfo = pCont; - code = TSDB_CODE_ACTION_IN_PROGRESS; + code = TSDB_CODE_VND_ACTION_IN_PROGRESS; } if (pQInfo != NULL) { @@ -99,7 +99,7 @@ static int32_t vnodeProcessFetchMsg(SVnodeObj *pVnode, void *pCont, int32_t cont if (qHasMoreResultsToRetrieve(pQInfo)) { pRet->qhandle = pQInfo; - code = TSDB_CODE_ACTION_NEED_REPROCESSED; + code = TSDB_CODE_VND_ACTION_NEED_REPROCESSED; } else { // no further execution invoked, release the ref to vnode qDestroyQueryInfo(pQInfo); diff --git a/src/vnode/src/vnodeWrite.c b/src/vnode/src/vnodeWrite.c index 4dfe492932..fa322757e2 100644 --- a/src/vnode/src/vnodeWrite.c +++ b/src/vnode/src/vnodeWrite.c @@ -51,14 +51,14 @@ int32_t vnodeProcessWrite(void *param1, int qtype, void *param2, void *item) { SWalHead *pHead = param2; if (vnodeProcessWriteMsgFp[pHead->msgType] == NULL) - return TSDB_CODE_MSG_NOT_PROCESSED; + return TSDB_CODE_VND_MSG_NOT_PROCESSED; if (pHead->version == 0) { // from client or CQ if (pVnode->status != TAOS_VN_STATUS_READY) - return TSDB_CODE_INVALID_VGROUP_ID; // it may be in deleting or closing state + return TSDB_CODE_VND_INVALID_VGROUP_ID; // it may be in deleting or closing state if (pVnode->syncCfg.replica > 1 && pVnode->role != TAOS_SYNC_ROLE_MASTER) - return TSDB_CODE_NOT_READY; + return TSDB_CODE_RPC_NOT_READY; // assign version pVnode->version++; diff --git a/tests/examples/C#/TDengineDriver.cs b/tests/examples/C#/TDengineDriver.cs index a11dae8e48..2797c362c1 100644 --- a/tests/examples/C#/TDengineDriver.cs +++ b/tests/examples/C#/TDengineDriver.cs @@ -79,8 +79,6 @@ namespace TDengineDriver class TDengine { public const int TSDB_CODE_SUCCESS = 0; - public const int TSDB_CODE_DB_ALREADY_EXIST = 33; - public const int TSDB_CODE_TABLE_ALREADY_EXIST = 34; [DllImport("taos.dll", EntryPoint = "taos_init", CallingConvention = CallingConvention.StdCall)] static extern public void Init(); diff --git a/tests/tsim/src/simExe.c b/tests/tsim/src/simExe.c index 1230f52f63..f13e861907 100644 --- a/tests/tsim/src/simExe.c +++ b/tests/tsim/src/simExe.c @@ -538,7 +538,7 @@ int simExecuteRestFulCommand(SScript *script, char *command) { FILE *fp = popen(buf, "r"); if (fp == NULL) { simError("failed to execute %s", buf); - return TSDB_CODE_OTHERS; + return -1; } int mallocSize = 2000; @@ -642,7 +642,7 @@ bool simExecuteNativeSqlCommand(SScript *script, char *rest, bool isSlow) { pSql = taos_query(script->taos, rest); ret = taos_errno(pSql); - if (ret == TSDB_CODE_TABLE_ALREADY_EXIST || ret == TSDB_CODE_DB_ALREADY_EXIST) { + if (ret == TSDB_CODE_MND_TABLE_ALREADY_EXIST || ret == TSDB_CODE_MND_DB_ALREADY_EXIST) { simTrace("script:%s, taos:%p, %s success, ret:%d:%s", script->fileName, script->taos, rest, ret, tstrerror(ret)); ret = 0; break; @@ -791,8 +791,8 @@ bool simExecuteRestFulSqlCommand(SScript *script, char *rest) { int ret = -1; for (int attempt = 0; attempt < 10; ++attempt) { ret = simExecuteRestFulCommand(script, command); - if (ret == TSDB_CODE_TABLE_ALREADY_EXIST || - ret == TSDB_CODE_DB_ALREADY_EXIST) { + if (ret == TSDB_CODE_MND_TABLE_ALREADY_EXIST || + ret == TSDB_CODE_MND_DB_ALREADY_EXIST) { simTrace("script:%s, taos:%p, %s success, ret:%d:%s", script->fileName, script->taos, rest, ret, tstrerror(ret)); ret = 0; break; -- GitLab