diff --git a/include/common/tdatablock.h b/include/common/tdatablock.h
index 89f6beaab4..c09e96d16d 100644
--- a/include/common/tdatablock.h
+++ b/include/common/tdatablock.h
@@ -49,7 +49,7 @@ typedef struct SBlockOrderInfo {
#define colDataSetNull_f_s(c_, r_) \
do { \
colDataSetNull_f((c_)->nullbitmap, r_); \
- memset(((char*)(c_)->pData) + (c_)->info.bytes * (r_), 0, (c_)->info.bytes); \
+ (void)memset(((char*)(c_)->pData) + (c_)->info.bytes * (r_), 0, (c_)->info.bytes); \
} while (0)
#define colDataClearNull_f(bm_, r_) \
diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index a5dea8a44e..e9cde9e99b 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -2828,19 +2828,24 @@ static FORCE_INLINE int32_t tSerializeSCMSubscribeReq(void** buf, const SCMSubsc
return tlen;
}
-static FORCE_INLINE void* tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq* pReq) {
+static FORCE_INLINE int32_t tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq* pReq) {
buf = taosDecodeFixedI64(buf, &pReq->consumerId);
buf = taosDecodeStringTo(buf, pReq->cgroup);
buf = taosDecodeStringTo(buf, pReq->clientId);
- int32_t topicNum;
+ int32_t topicNum = 0;
buf = taosDecodeFixedI32(buf, &topicNum);
pReq->topicNames = taosArrayInit(topicNum, sizeof(void*));
+ if (pReq->topicNames == NULL){
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
for (int32_t i = 0; i < topicNum; i++) {
- char* name;
+ char* name = NULL;
buf = taosDecodeString(buf, &name);
- taosArrayPush(pReq->topicNames, &name);
+ if (taosArrayPush(pReq->topicNames, &name) == NULL){
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
}
buf = taosDecodeFixedI8(buf, &pReq->withTbName);
@@ -2849,7 +2854,7 @@ static FORCE_INLINE void* tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq
buf = taosDecodeFixedI8(buf, &pReq->resetOffsetCfg);
buf = taosDecodeFixedI8(buf, &pReq->enableReplay);
buf = taosDecodeFixedI8(buf, &pReq->enableBatchMeta);
- return buf;
+ return 0;
}
typedef struct {
diff --git a/include/dnode/qnode/qnode.h b/include/dnode/qnode/qnode.h
index e7f9d00ff3..d6efa52ea7 100644
--- a/include/dnode/qnode/qnode.h
+++ b/include/dnode/qnode/qnode.h
@@ -34,9 +34,10 @@ typedef struct {
* @brief Start one Qnode in Dnode.
*
* @param pOption Option of the qnode.
- * @return SQnode* The qnode object.
+ * @param pQnode The qnode object.
+ * @return int32_t The error code.
*/
-SQnode *qndOpen(const SQnodeOpt *pOption);
+int32_t qndOpen(const SQnodeOpt *pOption, SQnode **pQnode);
/**
* @brief Stop Qnode in Dnode.
diff --git a/include/libs/function/function.h b/include/libs/function/function.h
index 700cc5ba7f..24fa2898ea 100644
--- a/include/libs/function/function.h
+++ b/include/libs/function/function.h
@@ -36,7 +36,7 @@ typedef struct SFuncExecEnv {
} SFuncExecEnv;
typedef bool (*FExecGetEnv)(struct SFunctionNode *pFunc, SFuncExecEnv *pEnv);
-typedef bool (*FExecInit)(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo);
+typedef int32_t (*FExecInit)(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo);
typedef int32_t (*FExecProcess)(struct SqlFunctionCtx *pCtx);
typedef int32_t (*FExecFinalize)(struct SqlFunctionCtx *pCtx, SSDataBlock *pBlock);
typedef int32_t (*FScalarExecProcess)(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
diff --git a/include/libs/function/functionMgt.h b/include/libs/function/functionMgt.h
index d3fb953dc3..1da1cbf716 100644
--- a/include/libs/function/functionMgt.h
+++ b/include/libs/function/functionMgt.h
@@ -260,7 +260,7 @@ bool fmIsProcessByRowFunc(int32_t funcId);
bool fmisSelectGroupConstValueFunc(int32_t funcId);
void getLastCacheDataType(SDataType* pType, int32_t pkBytes);
-SFunctionNode* createFunction(const char* pName, SNodeList* pParameterList);
+int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** pFunc);
int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMidFunc, SFunctionNode** pMergeFunc);
@@ -273,7 +273,7 @@ typedef enum EFuncDataRequired {
} EFuncDataRequired;
EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow);
-EFuncDataRequired fmFuncDynDataRequired(int32_t funcId, void* pRes, SDataBlockInfo* pBlockInfo);
+int32_t fmFuncDynDataRequired(int32_t funcId, void* pRes, SDataBlockInfo* pBlockInfo, int32_t *reqStatus);
int32_t fmGetFuncExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet);
int32_t fmGetScalarFuncExecFuncs(int32_t funcId, SScalarFuncExecFuncs* pFpSet);
diff --git a/include/libs/function/tudf.h b/include/libs/function/tudf.h
index 6b15833917..7a8927ca90 100644
--- a/include/libs/function/tudf.h
+++ b/include/libs/function/tudf.h
@@ -77,7 +77,7 @@ void freeUdfInterBuf(SUdfInterBuf *buf);
// high level APIs
bool udfAggGetEnv(struct SFunctionNode *pFunc, SFuncExecEnv *pEnv);
-bool udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo);
+int32_t udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo);
int32_t udfAggProcess(struct SqlFunctionCtx *pCtx);
int32_t udfAggFinalize(struct SqlFunctionCtx *pCtx, SSDataBlock *pBlock);
diff --git a/include/libs/wal/wal.h b/include/libs/wal/wal.h
index 155da9d116..66ea5ea5c7 100644
--- a/include/libs/wal/wal.h
+++ b/include/libs/wal/wal.h
@@ -12,6 +12,7 @@
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
+
#ifndef _TD_WAL_H_
#define _TD_WAL_H_
@@ -20,19 +21,11 @@
#include "tdef.h"
#include "tlog.h"
#include "tmsg.h"
+
#ifdef __cplusplus
extern "C" {
#endif
-// clang-format off
-#define wFatal(...) { if (wDebugFlag & DEBUG_FATAL) { taosPrintLog("WAL FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); }}
-#define wError(...) { if (wDebugFlag & DEBUG_ERROR) { taosPrintLog("WAL ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }}
-#define wWarn(...) { if (wDebugFlag & DEBUG_WARN) { taosPrintLog("WAL WARN ", DEBUG_WARN, 255, __VA_ARGS__); }}
-#define wInfo(...) { if (wDebugFlag & DEBUG_INFO) { taosPrintLog("WAL ", DEBUG_INFO, 255, __VA_ARGS__); }}
-#define wDebug(...) { if (wDebugFlag & DEBUG_DEBUG) { taosPrintLog("WAL ", DEBUG_DEBUG, wDebugFlag, __VA_ARGS__); }}
-#define wTrace(...) { if (wDebugFlag & DEBUG_TRACE) { taosPrintLog("WAL ", DEBUG_TRACE, wDebugFlag, __VA_ARGS__); }}
-// clang-format on
-
#define WAL_PROTO_VER 0
#define WAL_NOSUFFIX_LEN 20
#define WAL_SUFFIX_AT (WAL_NOSUFFIX_LEN + 1)
@@ -131,8 +124,7 @@ typedef struct SWal {
typedef struct {
int64_t refId;
int64_t refVer;
- // int64_t refFile;
- SWal *pWal;
+ SWal *pWal;
} SWalRef;
typedef struct {
@@ -143,10 +135,8 @@ typedef struct {
int8_t enableRef;
} SWalFilterCond;
-typedef struct SWalReader SWalReader;
-
// todo hide this struct
-struct SWalReader {
+typedef struct SWalReader {
SWal *pWal;
int64_t readerId;
TdFilePtr pLogFile;
@@ -159,7 +149,7 @@ struct SWalReader {
TdThreadMutex mutex;
SWalFilterCond cond;
SWalCkHead *pHead;
-};
+} SWalReader;
// module initialization
int32_t walInit();
@@ -172,17 +162,9 @@ int32_t walPersist(SWal *);
void walClose(SWal *);
// write interfaces
-
// By assigning index by the caller, wal gurantees linearizability
-int32_t walWrite(SWal *, int64_t index, tmsg_t msgType, const void *body, int32_t bodyLen);
-int32_t walWriteWithSyncInfo(SWal *, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body,
- int32_t bodyLen);
-
-// Assign version automatically and return to caller,
-// -1 will be returned for failed writes
-int64_t walAppendLog(SWal *, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body, int32_t bodyLen);
-
-void walFsync(SWal *, bool force);
+int32_t walAppendLog(SWal *, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body, int32_t bodyLen);
+int32_t walFsync(SWal *, bool force);
// apis for lifecycle management
int32_t walCommit(SWal *, int64_t ver);
@@ -191,17 +173,13 @@ int32_t walRollback(SWal *, int64_t ver);
int32_t walBeginSnapshot(SWal *, int64_t ver, int64_t logRetention);
int32_t walEndSnapshot(SWal *);
int32_t walRestoreFromSnapshot(SWal *, int64_t ver);
-// for tq
int32_t walApplyVer(SWal *, int64_t ver);
-// int32_t walDataCorrupted(SWal*);
-
// wal reader
SWalReader *walOpenReader(SWal *, SWalFilterCond *pCond, int64_t id);
void walCloseReader(SWalReader *pRead);
void walReadReset(SWalReader *pReader);
int32_t walReadVer(SWalReader *pRead, int64_t ver);
-void decryptBody(SWalCfg *cfg, SWalCkHead *pHead, int32_t plainBodyLen, const char *func);
int32_t walReaderSeekVer(SWalReader *pRead, int64_t ver);
int32_t walNextValidMsg(SWalReader *pRead);
int64_t walReaderGetCurrentVer(const SWalReader *pReader);
@@ -216,12 +194,11 @@ int32_t walFetchHead(SWalReader *pRead, int64_t ver);
int32_t walFetchBody(SWalReader *pRead);
int32_t walSkipFetchBody(SWalReader *pRead);
-void walRefFirstVer(SWal *, SWalRef *);
-void walRefLastVer(SWal *, SWalRef *);
-
SWalRef *walOpenRef(SWal *);
void walCloseRef(SWal *pWal, int64_t refId);
int32_t walSetRefVer(SWalRef *, int64_t ver);
+void walRefFirstVer(SWal *, SWalRef *);
+void walRefLastVer(SWal *, SWalRef *);
// helper function for raft
bool walLogExist(SWal *, int64_t ver);
diff --git a/include/os/os.h b/include/os/os.h
index ac1a750b78..1749687d97 100644
--- a/include/os/os.h
+++ b/include/os/os.h
@@ -97,6 +97,7 @@ extern "C" {
#include
#endif
+
#include "osThread.h"
#include "osAtomic.h"
diff --git a/include/os/osEnv.h b/include/os/osEnv.h
index 4f4a58d4e8..5f7cdf44dc 100644
--- a/include/os/osEnv.h
+++ b/include/os/osEnv.h
@@ -54,7 +54,7 @@ extern SDiskSpace tsDataSpace;
extern SDiskSpace tsLogSpace;
extern SDiskSpace tsTempSpace;
-void osDefaultInit();
+int32_t osDefaultInit();
void osUpdate();
void osCleanup();
@@ -66,7 +66,7 @@ bool osLogSpaceSufficient();
bool osDataSpaceSufficient();
bool osTempSpaceSufficient();
-void osSetTimezone(const char *timezone);
+int32_t osSetTimezone(const char *timezone);
void osSetSystemLocale(const char *inLocale, const char *inCharSet);
void osSetProcPath(int32_t argc, char **argv);
diff --git a/include/os/osTime.h b/include/os/osTime.h
index 87df3a2650..c367416175 100644
--- a/include/os/osTime.h
+++ b/include/os/osTime.h
@@ -65,28 +65,28 @@ int32_t taosGetTimestampSec();
//@return timestamp in millisecond
static FORCE_INLINE int64_t taosGetTimestampMs() {
struct timeval systemTime;
- taosGetTimeOfDay(&systemTime);
+ (void)taosGetTimeOfDay(&systemTime);
return (int64_t)systemTime.tv_sec * 1000LL + (int64_t)systemTime.tv_usec / 1000;
}
//@return timestamp in microsecond
static FORCE_INLINE int64_t taosGetTimestampUs() {
struct timeval systemTime;
- taosGetTimeOfDay(&systemTime);
+ (void)taosGetTimeOfDay(&systemTime);
return (int64_t)systemTime.tv_sec * 1000000LL + (int64_t)systemTime.tv_usec;
}
//@return timestamp in nanosecond
static FORCE_INLINE int64_t taosGetTimestampNs() {
struct timespec systemTime = {0};
- taosClockGetTime(CLOCK_REALTIME, &systemTime);
+ (void)taosClockGetTime(CLOCK_REALTIME, &systemTime);
return (int64_t)systemTime.tv_sec * 1000000000LL + (int64_t)systemTime.tv_nsec;
}
//@return timestamp of monotonic clock in millisecond
static FORCE_INLINE int64_t taosGetMonoTimestampMs() {
struct timespec systemTime = {0};
- taosClockGetTime(CLOCK_MONOTONIC, &systemTime);
+ (void)taosClockGetTime(CLOCK_MONOTONIC, &systemTime);
return (int64_t)systemTime.tv_sec * 1000LL + (int64_t)systemTime.tv_nsec / 1000000;
}
diff --git a/include/os/osTimezone.h b/include/os/osTimezone.h
index ce573d320b..fab42e8e11 100644
--- a/include/os/osTimezone.h
+++ b/include/os/osTimezone.h
@@ -55,7 +55,7 @@ enum TdTimezone {
};
void taosGetSystemTimezone(char *outTimezone, enum TdTimezone *tsTimezone);
-void taosSetSystemTimezone(const char *inTimezone, char *outTimezone, int8_t *outDaylight, enum TdTimezone *tsTimezone);
+int32_t taosSetSystemTimezone(const char *inTimezone, char *outTimezone, int8_t *outDaylight, enum TdTimezone *tsTimezone);
#ifdef __cplusplus
}
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index 22da6d5390..9b49c1908d 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -860,6 +860,11 @@ int32_t taosGetErrSize();
#define TSDB_CODE_FUNC_TO_TIMESTAMP_FAILED_TS_ERR TAOS_DEF_ERROR_CODE(0, 0x2807)
#define TSDB_CODE_FUNC_TO_TIMESTAMP_FAILED_NOT_SUPPORTED TAOS_DEF_ERROR_CODE(0, 0x2808)
#define TSDB_CODE_FUNC_TO_CHAR_NOT_SUPPORTED TAOS_DEF_ERROR_CODE(0, 0x2809)
+#define TSDB_CODE_FUNC_TIME_UNIT_INVALID TAOS_DEF_ERROR_CODE(0, 0x280A)
+#define TSDB_CODE_FUNC_TIME_UNIT_TOO_SMALL TAOS_DEF_ERROR_CODE(0, 0x280B)
+#define TSDB_CODE_FUNC_INVALID_VALUE_RANGE TAOS_DEF_ERROR_CODE(0, 0x280C)
+#define TSDB_CODE_FUNC_SETUP_ERROR TAOS_DEF_ERROR_CODE(0, 0x280D)
+
//udf
#define TSDB_CODE_UDF_STOPPING TAOS_DEF_ERROR_CODE(0, 0x2901)
diff --git a/include/util/tdef.h b/include/util/tdef.h
index 9c2858ed30..53bb8a493c 100644
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@@ -556,7 +556,8 @@ typedef struct {
char name[TSDB_LOG_VAR_LEN];
} SLogVar;
-#define TMQ_SEPARATOR ':'
+#define TMQ_SEPARATOR ":"
+#define TMQ_SEPARATOR_CHAR ':'
enum {
SND_WORKER_TYPE__SHARED = 1,
diff --git a/include/util/tdigest.h b/include/util/tdigest.h
index 836af92e78..03519b4c7b 100644
--- a/include/util/tdigest.h
+++ b/include/util/tdigest.h
@@ -64,10 +64,10 @@ typedef struct TDigest {
} TDigest;
TDigest *tdigestNewFrom(void *pBuf, int32_t compression);
-void tdigestAdd(TDigest *t, double x, int64_t w);
-void tdigestMerge(TDigest *t1, TDigest *t2);
+int32_t tdigestAdd(TDigest *t, double x, int64_t w);
+int32_t tdigestMerge(TDigest *t1, TDigest *t2);
double tdigestQuantile(TDigest *t, double q);
-void tdigestCompress(TDigest *t);
+int32_t tdigestCompress(TDigest *t);
void tdigestFreeFrom(TDigest *t);
void tdigestAutoFill(TDigest *t, int32_t compression);
diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c
index 724229af16..f640618897 100644
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@@ -897,7 +897,11 @@ void taos_init_imp(void) {
tscError("failed to init task queue");
return;
}
- fmFuncMgtInit();
+ if (fmFuncMgtInit() != TSDB_CODE_SUCCESS) {
+ tscInitRes = -1;
+ tscError("failed to init function manager");
+ return;
+ }
nodesInitAllocatorSet();
clientConnRefPool = taosOpenRef(200, destroyTscObj);
diff --git a/source/client/src/clientMonitor.c b/source/client/src/clientMonitor.c
index b8b57160fe..e3b073dbc8 100644
--- a/source/client/src/clientMonitor.c
+++ b/source/client/src/clientMonitor.c
@@ -801,9 +801,8 @@ int32_t monitorInit() {
}
if (taosMulModeMkDir(tmpSlowLogPath, 0777, true) != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
tscError("failed to create dir:%s since %s", tmpSlowLogPath, terrstr());
- return -1;
+ return terrno;
}
if (tsem2_init(&monitorSem, 0, 0) != 0) {
diff --git a/source/client/src/clientTmq.c b/source/client/src/clientTmq.c
index c363686343..09fbed4ba4 100644
--- a/source/client/src/clientTmq.c
+++ b/source/client/src/clientTmq.c
@@ -456,11 +456,7 @@ static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffse
pOffset.consumerId = tmq->consumerId;
pOffset.offset.val = *offset;
- int32_t groupLen = strlen(tmq->groupId);
- memcpy(pOffset.offset.subKey, tmq->groupId, groupLen);
- pOffset.offset.subKey[groupLen] = TMQ_SEPARATOR;
- strcpy(pOffset.offset.subKey + groupLen + 1, pTopicName);
-
+ (void)snprintf(pOffset.offset.subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, pTopicName);
int32_t len = 0;
int32_t code = 0;
tEncodeSize(tEncodeMqVgOffset, &pOffset, len, code);
@@ -1667,11 +1663,7 @@ static bool doUpdateLocalEp(tmq_t* tmq, int32_t epoch, const SMqAskEpRsp* pRsp)
}
void tmqBuildConsumeReqImpl(SMqPollReq* pReq, tmq_t* tmq, int64_t timeout, SMqClientTopic* pTopic, SMqClientVg* pVg) {
- int32_t groupLen = strlen(tmq->groupId);
- memcpy(pReq->subKey, tmq->groupId, groupLen);
- pReq->subKey[groupLen] = TMQ_SEPARATOR;
- strcpy(pReq->subKey + groupLen + 1, pTopic->topicName);
-
+ (void)snprintf(pReq->subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, pTopic->topicName);
pReq->withTbName = tmq->withTbName;
pReq->consumerId = tmq->consumerId;
pReq->timeout = timeout;
@@ -2902,11 +2894,7 @@ int64_t getCommittedFromServer(tmq_t* tmq, char* tname, int32_t vgId, SEpSet* ep
SMqVgOffset pOffset = {0};
pOffset.consumerId = tmq->consumerId;
-
- int32_t groupLen = strlen(tmq->groupId);
- memcpy(pOffset.offset.subKey, tmq->groupId, groupLen);
- pOffset.offset.subKey[groupLen] = TMQ_SEPARATOR;
- strcpy(pOffset.offset.subKey + groupLen + 1, tname);
+ (void)snprintf(pOffset.offset.subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, tname);
int32_t len = 0;
tEncodeSize(tEncodeMqVgOffset, &pOffset, len, code);
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index f126b2d6c9..44eec0852d 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -1306,7 +1306,6 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
taosSetAllDebugFlag(pCfg, cfgGetItem(pCfg, "debugFlag")->i32);
if (taosMulModeMkDir(tsLogDir, 0777, true) != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
printf("failed to create dir:%s since %s", tsLogDir, terrstr());
cfgCleanup(pCfg);
return -1;
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index 9efff055bf..a15afa64db 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -9197,23 +9197,23 @@ int32_t tDecodeSTqOffsetVal(SDecoder *pDecoder, STqOffsetVal *pOffsetVal) {
int32_t tFormatOffset(char *buf, int32_t maxLen, const STqOffsetVal *pVal) {
if (pVal->type == TMQ_OFFSET__RESET_NONE) {
- snprintf(buf, maxLen, "none");
+ (void)snprintf(buf, maxLen, "none");
} else if (pVal->type == TMQ_OFFSET__RESET_EARLIEST) {
- snprintf(buf, maxLen, "earliest");
+ (void)snprintf(buf, maxLen, "earliest");
} else if (pVal->type == TMQ_OFFSET__RESET_LATEST) {
- snprintf(buf, maxLen, "latest");
+ (void)snprintf(buf, maxLen, "latest");
} else if (pVal->type == TMQ_OFFSET__LOG) {
- snprintf(buf, maxLen, "wal:%" PRId64, pVal->version);
+ (void)snprintf(buf, maxLen, "wal:%" PRId64, pVal->version);
} else if (pVal->type == TMQ_OFFSET__SNAPSHOT_DATA || pVal->type == TMQ_OFFSET__SNAPSHOT_META) {
if (IS_VAR_DATA_TYPE(pVal->primaryKey.type)) {
char *tmp = taosMemoryCalloc(1, pVal->primaryKey.nData + 1);
if (tmp == NULL) return TSDB_CODE_OUT_OF_MEMORY;
- memcpy(tmp, pVal->primaryKey.pData, pVal->primaryKey.nData);
- snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%s", pVal->uid, pVal->ts,
+ (void)memcpy(tmp, pVal->primaryKey.pData, pVal->primaryKey.nData);
+ (void)snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%s", pVal->uid, pVal->ts,
pVal->primaryKey.type, tmp);
taosMemoryFree(tmp);
} else {
- snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%" PRId64, pVal->uid, pVal->ts,
+ (void)snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%" PRId64, pVal->uid, pVal->ts,
pVal->primaryKey.type, pVal->primaryKey.val);
}
} else {
diff --git a/source/dnode/mgmt/mgmt_qnode/src/qmInt.c b/source/dnode/mgmt/mgmt_qnode/src/qmInt.c
index 553f39e5da..3138614189 100644
--- a/source/dnode/mgmt/mgmt_qnode/src/qmInt.c
+++ b/source/dnode/mgmt/mgmt_qnode/src/qmInt.c
@@ -34,11 +34,8 @@ static void qmClose(SQnodeMgmt *pMgmt) {
}
static int32_t qndOpenWrapper(SQnodeOpt *pOption, SQnode **pQnode) {
- *pQnode = qndOpen(pOption);
- if (*pQnode == NULL) {
- return terrno;
- }
- return 0;
+ int32_t code = qndOpen(pOption, pQnode);
+ return code;
}
static int32_t qmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
int32_t code = 0;
@@ -62,7 +59,7 @@ static int32_t qmOpen(SMgmtInputOpt *pInput, SMgmtOutputOpt *pOutput) {
if (code != 0) {
dError("failed to open qnode since %s", tstrerror(code));
qmClose(pMgmt);
- return -1;
+ return code;
}
tmsgReportStartup("qnode-impl", "initialized");
diff --git a/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c b/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c
index 23a2aa36e8..5b380c2a0b 100644
--- a/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c
+++ b/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c
@@ -48,8 +48,8 @@ static int32_t qmPutNodeMsgToWorker(SSingleWorker *pWorker, SRpcMsg *pMsg) {
}
int32_t qmPutNodeMsgToQueryQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg) {
- qndPreprocessQueryMsg(pMgmt->pQnode, pMsg);
-
+ int32_t code = qndPreprocessQueryMsg(pMgmt->pQnode, pMsg);
+ if (code) return code;
return qmPutNodeMsgToWorker(&pMgmt->queryWorker, pMsg);
}
diff --git a/source/dnode/mgmt/node_mgmt/src/dmEnv.c b/source/dnode/mgmt/node_mgmt/src/dmEnv.c
index ea82d21fba..759c168529 100644
--- a/source/dnode/mgmt/node_mgmt/src/dmEnv.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmEnv.c
@@ -262,7 +262,7 @@ static int32_t dmProcessCreateNodeReq(EDndNodeType ntype, SRpcMsg *pMsg) {
pWrapper = &pDnode->wrappers[ntype];
if (taosMkDir(pWrapper->path) != 0) {
dmReleaseWrapper(pWrapper);
- code = TAOS_SYSTEM_ERROR(errno);
+ code = terrno;
dError("failed to create dir:%s since %s", pWrapper->path, tstrerror(code));
return code;
}
@@ -333,7 +333,7 @@ static int32_t dmProcessAlterNodeTypeReq(EDndNodeType ntype, SRpcMsg *pMsg) {
pWrapper = &pDnode->wrappers[ntype];
if (taosMkDir(pWrapper->path) != 0) {
taosThreadMutexUnlock(&pDnode->mutex);
- code = TAOS_SYSTEM_ERROR(errno);
+ code = terrno;
dError("failed to create dir:%s since %s", pWrapper->path, tstrerror(code));
return code;
}
diff --git a/source/dnode/mgmt/node_mgmt/src/dmNodes.c b/source/dnode/mgmt/node_mgmt/src/dmNodes.c
index 9c950ac592..175e470b4a 100644
--- a/source/dnode/mgmt/node_mgmt/src/dmNodes.c
+++ b/source/dnode/mgmt/node_mgmt/src/dmNodes.c
@@ -21,7 +21,7 @@ int32_t dmOpenNode(SMgmtWrapper *pWrapper) {
SDnode *pDnode = pWrapper->pDnode;
if (taosMkDir(pWrapper->path) != 0) {
- code = TAOS_SYSTEM_ERROR(errno);
+ code = terrno;
dError("node:%s, failed to create dir:%s since %s", pWrapper->name, pWrapper->path, tstrerror(code));
return code;
}
diff --git a/source/dnode/mgmt/node_util/src/dmFile.c b/source/dnode/mgmt/node_util/src/dmFile.c
index c6ad535b9e..5031f46ef2 100644
--- a/source/dnode/mgmt/node_util/src/dmFile.c
+++ b/source/dnode/mgmt/node_util/src/dmFile.c
@@ -417,7 +417,7 @@ int32_t dmUpdateEncryptKey(char *key, bool toLogFile) {
}
if (taosMkDir(folder) != 0) {
- code = TAOS_SYSTEM_ERROR(errno);
+ code = terrno;
encryptError("failed to create dir:%s since %s", folder, tstrerror(code));
goto _OVER;
}
@@ -578,4 +578,4 @@ _OVER:
#else
return 0;
#endif
-}
\ No newline at end of file
+}
diff --git a/source/dnode/mnode/impl/inc/mndConsumer.h b/source/dnode/mnode/impl/inc/mndConsumer.h
index 5184ad0eca..e1a790867e 100644
--- a/source/dnode/mnode/impl/inc/mndConsumer.h
+++ b/source/dnode/mnode/impl/inc/mndConsumer.h
@@ -30,10 +30,10 @@ enum {
int32_t mndInitConsumer(SMnode *pMnode);
void mndCleanupConsumer(SMnode *pMnode);
-void mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo* info);
+int32_t mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo* info);
-SMqConsumerObj *mndAcquireConsumer(SMnode *pMnode, int64_t consumerId);
-void mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer);
+int32_t mndAcquireConsumer(SMnode *pMnode, int64_t consumerId, SMqConsumerObj** pConsumer);
+void mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer);
SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer);
SSdbRow *mndConsumerActionDecode(SSdbRaw *pRaw);
@@ -43,6 +43,22 @@ int32_t mndSetConsumerDropLogs(STrans *pTrans, SMqConsumerObj *pConsumer);
const char *mndConsumerStatusName(int status);
+#define MND_TMQ_NULL_CHECK(c) \
+ do { \
+ if (c == NULL) { \
+ code = TSDB_CODE_OUT_OF_MEMORY; \
+ goto END; \
+ } \
+ } while (0)
+
+#define MND_TMQ_RETURN_CHECK(c) \
+ do { \
+ code = c; \
+ if (code != 0) { \
+ goto END; \
+ } \
+ } while (0)
+
#ifdef __cplusplus
}
#endif
diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h
index 089c4a10b3..5319cc88eb 100644
--- a/source/dnode/mnode/impl/inc/mndDef.h
+++ b/source/dnode/mnode/impl/inc/mndDef.h
@@ -622,7 +622,8 @@ typedef struct {
int32_t resetOffsetCfg;
} SMqConsumerObj;
-SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType, char *topic, SCMSubscribeReq *subscribe);
+int32_t tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType,
+ char *topic, SCMSubscribeReq *subscribe, SMqConsumerObj** ppConsumer);
void tClearSMqConsumerObj(SMqConsumerObj* pConsumer);
void tDeleteSMqConsumerObj(SMqConsumerObj* pConsumer);
int32_t tEncodeSMqConsumerObj(void** buf, const SMqConsumerObj* pConsumer);
@@ -665,8 +666,8 @@ typedef struct {
char* qmsg; // SubPlanToString
} SMqSubscribeObj;
-SMqSubscribeObj* tNewSubscribeObj(const char key[TSDB_SUBSCRIBE_KEY_LEN]);
-SMqSubscribeObj* tCloneSubscribeObj(const SMqSubscribeObj* pSub);
+int32_t tNewSubscribeObj(const char *key, SMqSubscribeObj **ppSub);
+int32_t tCloneSubscribeObj(const SMqSubscribeObj* pSub, SMqSubscribeObj **ppSub);
void tDeleteSubscribeObj(SMqSubscribeObj* pSub);
int32_t tEncodeSubscribeObj(void** buf, const SMqSubscribeObj* pSub);
void* tDecodeSubscribeObj(const void* buf, SMqSubscribeObj* pSub, int8_t sver);
diff --git a/source/dnode/mnode/impl/inc/mndSubscribe.h b/source/dnode/mnode/impl/inc/mndSubscribe.h
index eb9902a75c..614c14c7d2 100644
--- a/source/dnode/mnode/impl/inc/mndSubscribe.h
+++ b/source/dnode/mnode/impl/inc/mndSubscribe.h
@@ -26,12 +26,9 @@ int32_t mndInitSubscribe(SMnode *pMnode);
void mndCleanupSubscribe(SMnode *pMnode);
int32_t mndGetGroupNumByTopic(SMnode *pMnode, const char *topicName);
-SMqSubscribeObj *mndAcquireSubscribe(SMnode *pMnode, const char *CGroup, const char *topicName);
-SMqSubscribeObj *mndAcquireSubscribeByKey(SMnode *pMnode, const char *key);
+int32_t mndAcquireSubscribeByKey(SMnode *pMnode, const char *key, SMqSubscribeObj** pSub);
void mndReleaseSubscribe(SMnode *pMnode, SMqSubscribeObj *pSub);
-void mndMakeSubscribeKey(char *key, const char *cgroup, const char *topicName);
-
int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topic);
int32_t mndSetDropSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub);
diff --git a/source/dnode/mnode/impl/inc/mndTopic.h b/source/dnode/mnode/impl/inc/mndTopic.h
index b2b86775ab..dc6c137455 100644
--- a/source/dnode/mnode/impl/inc/mndTopic.h
+++ b/source/dnode/mnode/impl/inc/mndTopic.h
@@ -25,13 +25,12 @@ extern "C" {
int32_t mndInitTopic(SMnode *pMnode);
void mndCleanupTopic(SMnode *pMnode);
-SMqTopicObj *mndAcquireTopic(SMnode *pMnode, const char *topicName);
+int32_t mndAcquireTopic(SMnode *pMnode, const char *topicName, SMqTopicObj **pTopic);
void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic);
int32_t mndDropTopicByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
bool mndTopicExistsForDb(SMnode *pMnode, SDbObj *pDb);
-const char *mndTopicGetShowName(const char topic[TSDB_TOPIC_FNAME_LEN]);
+void mndTopicGetShowName(const char* fullTopic, char* topic);
-int32_t mndSetTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic);
int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics);
#ifdef __cplusplus
diff --git a/source/dnode/mnode/impl/src/mndConsumer.c b/source/dnode/mnode/impl/src/mndConsumer.c
index 7788bf005a..1b77a0ad6a 100644
--- a/source/dnode/mnode/impl/src/mndConsumer.c
+++ b/source/dnode/mnode/impl/src/mndConsumer.c
@@ -40,7 +40,6 @@ static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg);
static int32_t mndProcessAskEpReq(SRpcMsg *pMsg);
static int32_t mndProcessMqHbReq(SRpcMsg *pMsg);
static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg);
-static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg);
int32_t mndInitConsumer(SMnode *pMnode) {
SSdbTable table = {
@@ -57,7 +56,6 @@ int32_t mndInitConsumer(SMnode *pMnode) {
mndSetMsgHandle(pMnode, TDMT_MND_TMQ_HB, mndProcessMqHbReq);
mndSetMsgHandle(pMnode, TDMT_MND_TMQ_ASK_EP, mndProcessAskEpReq);
// mndSetMsgHandle(pMnode, TDMT_MND_TMQ_TIMER, mndProcessMqTimerMsg);
- mndSetMsgHandle(pMnode, TDMT_MND_TMQ_CONSUMER_RECOVER, mndProcessConsumerRecoverMsg);
mndSetMsgHandle(pMnode, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, mndProcessConsumerClearMsg);
mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_CONSUMERS, mndRetrieveConsumer);
@@ -68,13 +66,10 @@ int32_t mndInitConsumer(SMnode *pMnode) {
void mndCleanupConsumer(SMnode *pMnode) {}
-void mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo *info) {
- void *msg = rpcMallocCont(sizeof(int64_t));
- if (msg == NULL) {
- mError("consumer:0x%" PRIx64 " failed to clear consumer due to out of memory. alloc size:%d", consumerId,
- (int32_t)sizeof(int64_t));
- return;
- }
+int32_t mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo *info) {
+ int32_t code = 0;
+ void *msg = rpcMallocCont(sizeof(int64_t));
+ MND_TMQ_NULL_CHECK(msg);
*(int64_t*)msg = consumerId;
SRpcMsg rpcMsg = {
@@ -85,108 +80,51 @@ void mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SR
};
mInfo("mndSendConsumerMsg type:%d consumer:0x%" PRIx64, msgType, consumerId);
- int32_t code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
- if (code != 0){
- mError("consumer:%"PRId64" send consumer msg:%d error:%d", consumerId, msgType, code);
- }
+ MND_TMQ_RETURN_CHECK(tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg));
+ return code;
+
+END:
+ taosMemoryFree(msg);
+ return code;
}
static int32_t validateTopics(const SArray *pTopicList, SMnode *pMnode, const char *pUser,
bool enableReplay) {
SMqTopicObj *pTopic = NULL;
int32_t code = 0;
- int32_t lino = 0;
int32_t numOfTopics = taosArrayGetSize(pTopicList);
for (int32_t i = 0; i < numOfTopics; i++) {
char *pOneTopic = taosArrayGetP(pTopicList, i);
- pTopic = mndAcquireTopic(pMnode, pOneTopic);
- if (pTopic == NULL) { // terrno has been set by callee function
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- goto FAILED;
- }
-
- TAOS_CHECK_GOTO(mndCheckTopicPrivilege(pMnode, pUser, MND_OPER_SUBSCRIBE, pTopic), &lino, FAILED);
-
- TAOS_CHECK_GOTO(grantCheckExpire(TSDB_GRANT_SUBSCRIPTION), &lino, FAILED);
+ MND_TMQ_RETURN_CHECK(mndAcquireTopic(pMnode, pOneTopic, &pTopic));
+ MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pUser, MND_OPER_SUBSCRIBE, pTopic));
+ MND_TMQ_RETURN_CHECK(grantCheckExpire(TSDB_GRANT_SUBSCRIPTION));
if (enableReplay) {
if (pTopic->subType != TOPIC_SUB_TYPE__COLUMN) {
code = TSDB_CODE_TMQ_REPLAY_NOT_SUPPORT;
- goto FAILED;
+ goto END;
} else if (pTopic->ntbUid == 0 && pTopic->ctbStbUid == 0) {
SDbObj *pDb = mndAcquireDb(pMnode, pTopic->db);
if (pDb == NULL) {
code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- goto FAILED;
+ goto END;
}
if (pDb->cfg.numOfVgroups != 1) {
mndReleaseDb(pMnode, pDb);
code = TSDB_CODE_TMQ_REPLAY_NEED_ONE_VGROUP;
- goto FAILED;
+ goto END;
}
mndReleaseDb(pMnode, pDb);
}
}
-
mndReleaseTopic(pMnode, pTopic);
}
-
return 0;
-FAILED:
- mndReleaseTopic(pMnode, pTopic);
- TAOS_RETURN(code);
-}
-static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg) {
- int32_t code = 0;
- int32_t lino = 0;
- SMnode *pMnode = pMsg->info.node;
- SMqConsumerRecoverMsg *pRecoverMsg = pMsg->pCont;
- SMqConsumerObj *pConsumerNew = NULL;
- STrans *pTrans = NULL;
- SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, pRecoverMsg->consumerId);
- if (pConsumer == NULL) {
- mError("cannot find consumer %" PRId64 " when processing consumer recover msg", pRecoverMsg->consumerId);
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- goto END;
- }
-
- mInfo("receive consumer recover msg, consumer:0x%" PRIx64 " status:%d(%s)", pRecoverMsg->consumerId,
- pConsumer->status, mndConsumerStatusName(pConsumer->status));
-
- if (pConsumer->status != MQ_CONSUMER_STATUS_LOST) {
- code = TSDB_CODE_MND_CONSUMER_NOT_READY;
- goto END;
- }
-
- pConsumerNew = tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, CONSUMER_UPDATE_REC, NULL, NULL);
- if (pConsumerNew == NULL){
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- goto END;
- }
-
- pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_NOTHING, pMsg, "recover-csm");
- if (pTrans == NULL) {
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- goto END;
- }
-
- TAOS_CHECK_GOTO(validateTopics(pConsumer->assignedTopics, pMnode, pMsg->info.conn.user, false), &lino, END);
-
- TAOS_CHECK_GOTO(mndSetConsumerCommitLogs(pTrans, pConsumerNew), &lino, END);
-
- code = mndTransPrepare(pMnode, pTrans);
END:
- mndReleaseConsumer(pMnode, pConsumer);
- tDeleteSMqConsumerObj(pConsumerNew);
- mndTransDrop(pTrans);
- TAOS_RETURN(code);
+ mndReleaseTopic(pMnode, pTopic);
+ return code;
}
static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg) {
@@ -196,55 +134,39 @@ static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg) {
SMqConsumerClearMsg *pClearMsg = pMsg->pCont;
SMqConsumerObj *pConsumerNew = NULL;
STrans *pTrans = NULL;
+ SMqConsumerObj *pConsumer = NULL;
- SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, pClearMsg->consumerId);
- if (pConsumer == NULL) {
- mError("consumer:0x%" PRIx64 " failed to be found to clear it", pClearMsg->consumerId);
- TAOS_RETURN(code);
- }
-
+ MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, pClearMsg->consumerId, &pConsumer));
mInfo("consumer:0x%" PRIx64 " needs to be cleared, status %s", pClearMsg->consumerId,
mndConsumerStatusName(pConsumer->status));
- pConsumerNew = tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, -1, NULL, NULL);
- if (pConsumerNew == NULL){
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- goto END;
- }
-
+ MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, -1, NULL, NULL, &pConsumerNew));
pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pMsg, "clear-csm");
- if (pTrans == NULL) {
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- goto END;
- }
-
- // this is the drop action, not the update action
- TAOS_CHECK_GOTO(mndSetConsumerDropLogs(pTrans, pConsumerNew), &lino, END);
-
+ MND_TMQ_NULL_CHECK(pTrans);
+ MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumerNew));
code = mndTransPrepare(pMnode, pTrans);
END:
mndReleaseConsumer(pMnode, pConsumer);
tDeleteSMqConsumerObj(pConsumerNew);
mndTransDrop(pTrans);
- TAOS_RETURN(code);
+ return code;
}
static int32_t checkPrivilege(SMnode *pMnode, SMqConsumerObj *pConsumer, SMqHbRsp *rsp, char *user) {
+ int32_t code = 0;
rsp->topicPrivileges = taosArrayInit(taosArrayGetSize(pConsumer->currentTopics), sizeof(STopicPrivilege));
- if (rsp->topicPrivileges == NULL) {
- return TSDB_CODE_OUT_OF_MEMORY;
- }
+ MND_TMQ_NULL_CHECK(rsp->topicPrivileges);
for (int32_t i = 0; i < taosArrayGetSize(pConsumer->currentTopics); i++) {
char *topic = taosArrayGetP(pConsumer->currentTopics, i);
- SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic);
- if (pTopic == NULL) { // terrno has been set by callee function
+ SMqTopicObj *pTopic = NULL;
+ code = mndAcquireTopic(pMnode, topic, &pTopic);
+ if (code != TDB_CODE_SUCCESS) {
continue;
}
STopicPrivilege *data = taosArrayReserve(rsp->topicPrivileges, 1);
- strcpy(data->topic, topic);
+ MND_TMQ_NULL_CHECK(data);
+ (void)strcpy(data->topic, topic);
if (mndCheckTopicPrivilege(pMnode, user, MND_OPER_SUBSCRIBE, pTopic) != 0 ||
grantCheckExpire(TSDB_GRANT_SUBSCRIPTION) < 0) {
data->noPrivilege = 1;
@@ -253,22 +175,30 @@ static int32_t checkPrivilege(SMnode *pMnode, SMqConsumerObj *pConsumer, SMqHbRs
}
mndReleaseTopic(pMnode, pTopic);
}
- return 0;
+END:
+ return code;
}
static void storeOffsetRows(SMnode *pMnode, SMqHbReq *req, SMqConsumerObj *pConsumer){
for (int i = 0; i < taosArrayGetSize(req->topics); i++) {
TopicOffsetRows *data = taosArrayGet(req->topics, i);
+ if (data == NULL){
+ continue;
+ }
mInfo("heartbeat report offset rows.%s:%s", pConsumer->cgroup, data->topicName);
- SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, data->topicName);
- if (pSub == NULL) {
+ SMqSubscribeObj *pSub = NULL;
+ char key[TSDB_SUBSCRIBE_KEY_LEN] = {0};
+ (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", pConsumer->cgroup, TMQ_SEPARATOR, data->topicName);
+ int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub);
+ if (code != 0) {
+ mError("failed to acquire subscribe by key:%s, code:%d", key, code);
continue;
}
taosWLockLatch(&pSub->lock);
SMqConsumerEp *pConsumerEp = taosHashGet(pSub->consumerHash, &pConsumer->consumerId, sizeof(int64_t));
if (pConsumerEp) {
- taosArrayDestroy(pConsumerEp->offsetRows);
+ (void)taosArrayDestroy(pConsumerEp->offsetRows);
pConsumerEp->offsetRows = data->offsetRows;
data->offsetRows = NULL;
}
@@ -303,36 +233,24 @@ static int32_t mndProcessMqHbReq(SRpcMsg *pMsg) {
SMqHbReq req = {0};
SMqHbRsp rsp = {0};
SMqConsumerObj *pConsumer = NULL;
-
- TAOS_CHECK_GOTO(tDeserializeSMqHbReq(pMsg->pCont, pMsg->contLen, &req), NULL, end);
-
+ MND_TMQ_RETURN_CHECK(tDeserializeSMqHbReq(pMsg->pCont, pMsg->contLen, &req));
int64_t consumerId = req.consumerId;
- pConsumer = mndAcquireConsumer(pMnode, consumerId);
- if (pConsumer == NULL) {
- mError("consumer:0x%" PRIx64 " not exist", consumerId);
- code = TSDB_CODE_MND_CONSUMER_NOT_EXIST;
- goto end;
- }
-
- TAOS_CHECK_GOTO(checkPrivilege(pMnode, pConsumer, &rsp, pMsg->info.conn.user), NULL, end);
-
+ MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, consumerId, &pConsumer));
+ MND_TMQ_RETURN_CHECK(checkPrivilege(pMnode, pConsumer, &rsp, pMsg->info.conn.user));
atomic_store_32(&pConsumer->hbStatus, 0);
-
int32_t status = atomic_load_32(&pConsumer->status);
-
if (status == MQ_CONSUMER_STATUS_LOST) {
mInfo("try to recover consumer:0x%" PRIx64, consumerId);
- mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info);
+ MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info));
}
-
storeOffsetRows(pMnode, &req, pConsumer);
code = buildMqHbRsp(pMsg, &rsp);
-end:
+END:
tDestroySMqHbRsp(&rsp);
mndReleaseConsumer(pMnode, pConsumer);
tDestroySMqHbReq(&req);
- TAOS_RETURN(code);
+ return code;
}
static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t epoch, SMqAskEpRsp *rsp){
@@ -349,19 +267,22 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e
// handle all topics subscribed by this consumer
for (int32_t i = 0; i < numOfTopics; i++) {
char *topic = taosArrayGetP(pConsumer->currentTopics, i);
- SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, topic);
- // txn guarantees pSub is created
- if (pSub == NULL) {
+ SMqSubscribeObj *pSub = NULL;
+ char key[TSDB_SUBSCRIBE_KEY_LEN] = {0};
+ (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", pConsumer->cgroup, TMQ_SEPARATOR, topic);
+ int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub);
+ if (code != 0) {
continue;
}
taosRLockLatch(&pSub->lock);
SMqSubTopicEp topicEp = {0};
- strcpy(topicEp.topic, topic);
+ (void)strcpy(topicEp.topic, topic);
// 2.1 fetch topic schema
- SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic);
- if (pTopic == NULL) {
+ SMqTopicObj *pTopic = NULL;
+ code = mndAcquireTopic(pMnode, topic, &pTopic);
+ if (code != TDB_CODE_SUCCESS) {
taosRUnLockLatch(&pSub->lock);
mndReleaseSubscribe(pMnode, pSub);
continue;
@@ -371,16 +292,27 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e
topicEp.schema.nCols = pTopic->schema.nCols;
if (topicEp.schema.nCols) {
topicEp.schema.pSchema = taosMemoryCalloc(topicEp.schema.nCols, sizeof(SSchema));
- memcpy(topicEp.schema.pSchema, pTopic->schema.pSchema, topicEp.schema.nCols * sizeof(SSchema));
+ if (topicEp.schema.pSchema == NULL) {
+ taosRUnLockLatch(&pTopic->lock);
+ taosRUnLockLatch(&pSub->lock);
+ mndReleaseSubscribe(pMnode, pSub);
+ mndReleaseTopic(pMnode, pTopic);
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(topicEp.schema.pSchema, pTopic->schema.pSchema, topicEp.schema.nCols * sizeof(SSchema));
}
taosRUnLockLatch(&pTopic->lock);
mndReleaseTopic(pMnode, pTopic);
// 2.2 iterate all vg assigned to the consumer of that topic
SMqConsumerEp *pConsumerEp = taosHashGet(pSub->consumerHash, &pConsumer->consumerId, sizeof(int64_t));
- int32_t vgNum = taosArrayGetSize(pConsumerEp->vgs);
-
- // this customer assigned vgroups
+ if (pConsumerEp == NULL) {
+ taosRUnLockLatch(&pConsumer->lock);
+ taosRUnLockLatch(&pSub->lock);
+ mndReleaseSubscribe(pMnode, pSub);
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ int32_t vgNum = taosArrayGetSize(pConsumerEp->vgs);
topicEp.vgs = taosArrayInit(vgNum, sizeof(SMqSubVgEp));
if (topicEp.vgs == NULL) {
taosRUnLockLatch(&pConsumer->lock);
@@ -391,9 +323,9 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e
for (int32_t j = 0; j < vgNum; j++) {
SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j);
- // char offsetKey[TSDB_PARTITION_KEY_LEN];
- // mndMakePartitionKey(offsetKey, pConsumer->cgroup, topic, pVgEp->vgId);
-
+ if (pVgEp == NULL) {
+ continue;
+ }
if (epoch == -1) {
SVgObj *pVgroup = mndAcquireVgroup(pMnode, pVgEp->vgId);
if (pVgroup) {
@@ -401,17 +333,10 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e
mndReleaseVgroup(pMnode, pVgroup);
}
}
- // 2.2.1 build vg ep
- SMqSubVgEp vgEp = {
- .epSet = pVgEp->epSet,
- .vgId = pVgEp->vgId,
- .offset = -1,
- };
-
- taosArrayPush(topicEp.vgs, &vgEp);
+ SMqSubVgEp vgEp = {.epSet = pVgEp->epSet, .vgId = pVgEp->vgId, .offset = -1};
+ (void)taosArrayPush(topicEp.vgs, &vgEp);
}
- taosArrayPush(rsp->topics, &topicEp);
-
+ (void)taosArrayPush(rsp->topics, &topicEp);
taosRUnLockLatch(&pSub->lock);
mndReleaseSubscribe(pMnode, pSub);
}
@@ -437,12 +362,15 @@ static int32_t buildAskEpRsp(SRpcMsg *pMsg, SMqAskEpRsp *rsp, int32_t serverEpoc
pHead->walever = 0;
void *abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead));
- tEncodeSMqAskEpRsp(&abuf, rsp);
+ if (tEncodeSMqAskEpRsp(&abuf, rsp) < 0) {
+ rpcFreeCont(buf);
+ return TSDB_CODE_TSC_INTERNAL_ERROR;
+ }
// send rsp
pMsg->info.rsp = buf;
pMsg->info.rspLen = tlen;
- TAOS_RETURN(code);
+ return code;
}
static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
@@ -450,33 +378,22 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
SMqAskEpReq req = {0};
SMqAskEpRsp rsp = {0};
int32_t code = 0;
+ SMqConsumerObj *pConsumer = NULL;
- TAOS_CHECK_RETURN(tDeserializeSMqAskEpReq(pMsg->pCont, pMsg->contLen, &req));
-
+ MND_TMQ_RETURN_CHECK(tDeserializeSMqAskEpReq(pMsg->pCont, pMsg->contLen, &req));
int64_t consumerId = req.consumerId;
-
- SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, consumerId);
- if (pConsumer == NULL) {
- mError("consumer:0x%" PRIx64 " group:%s not exists in sdb", consumerId, req.cgroup);
- return TSDB_CODE_MND_CONSUMER_NOT_EXIST;
- }
-
+ MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, consumerId, &pConsumer));
if (strncmp(req.cgroup, pConsumer->cgroup, tListLen(pConsumer->cgroup)) != 0) {
mError("consumer:0x%" PRIx64 " group:%s not consistent with data in sdb, saved cgroup:%s", consumerId, req.cgroup,
pConsumer->cgroup);
code = TSDB_CODE_MND_CONSUMER_NOT_EXIST;
goto END;
}
-
atomic_store_32(&pConsumer->hbStatus, 0);
-
- // 1. check consumer status
int32_t status = atomic_load_32(&pConsumer->status);
-
if (status == MQ_CONSUMER_STATUS_LOST) {
- mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info);
+ MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info));
}
-
if (status != MQ_CONSUMER_STATUS_READY) {
mInfo("consumer:0x%" PRIx64 " not ready, status: %s", consumerId, mndConsumerStatusName(status));
code = TSDB_CODE_MND_CONSUMER_NOT_READY;
@@ -490,10 +407,7 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
if (epoch != serverEpoch) {
mInfo("process ask ep, consumer:0x%" PRIx64 "(epoch %d) update with server epoch %d",
consumerId, epoch, serverEpoch);
- code = addEpSetInfo(pMnode, pConsumer, epoch, &rsp);
- if(code != 0){
- goto END;
- }
+ MND_TMQ_RETURN_CHECK(addEpSetInfo(pMnode, pConsumer, epoch, &rsp));
}
code = buildAskEpRsp(pMsg, &rsp, serverEpoch, consumerId);
@@ -507,27 +421,29 @@ END:
int32_t mndSetConsumerDropLogs(STrans *pTrans, SMqConsumerObj *pConsumer) {
int32_t code = 0;
SSdbRaw *pCommitRaw = mndConsumerActionEncode(pConsumer);
- if (pCommitRaw == NULL) {
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- TAOS_RETURN(code);
+ MND_TMQ_NULL_CHECK(pCommitRaw);
+ code = mndTransAppendCommitlog(pTrans, pCommitRaw);
+ if (code != 0) {
+ sdbFreeRaw(pCommitRaw);
+ goto END;
}
- TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));
- TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));
- TAOS_RETURN(code);
+ MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));
+END:
+ return code;
}
int32_t mndSetConsumerCommitLogs(STrans *pTrans, SMqConsumerObj *pConsumer) {
int32_t code = 0;
SSdbRaw *pCommitRaw = mndConsumerActionEncode(pConsumer);
- if (pCommitRaw == NULL) {
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- TAOS_RETURN(code);
+ MND_TMQ_NULL_CHECK(pCommitRaw);
+ code = mndTransAppendCommitlog(pTrans, pCommitRaw);
+ if (code != 0) {
+ sdbFreeRaw(pCommitRaw);
+ goto END;
}
- TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));
- TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));
- TAOS_RETURN(code);
+ MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));
+END:
+ return code;
}
static void freeItem(void *param) {
@@ -538,29 +454,35 @@ static void freeItem(void *param) {
}
static int32_t getTopicAddDelete(SMqConsumerObj *pExistedConsumer, SMqConsumerObj *pConsumerNew){
+ int32_t code = 0;
pConsumerNew->rebNewTopics = taosArrayInit(0, sizeof(void *));
+ MND_TMQ_NULL_CHECK(pConsumerNew->rebNewTopics);
pConsumerNew->rebRemovedTopics = taosArrayInit(0, sizeof(void *));
- if(pConsumerNew->rebNewTopics == NULL || pConsumerNew->rebRemovedTopics == NULL){
- return TSDB_CODE_OUT_OF_MEMORY;
- }
+ MND_TMQ_NULL_CHECK(pConsumerNew->rebRemovedTopics);
+
int32_t newTopicNum = taosArrayGetSize(pConsumerNew->assignedTopics);
int32_t oldTopicNum = taosArrayGetSize(pExistedConsumer->currentTopics);
-
int32_t i = 0, j = 0;
while (i < oldTopicNum || j < newTopicNum) {
if (i >= oldTopicNum) {
- char *newTopicCopy = taosStrdup(taosArrayGetP(pConsumerNew->assignedTopics, j));
- taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy);
+ void* tmp = taosArrayGetP(pConsumerNew->assignedTopics, j);
+ MND_TMQ_NULL_CHECK(tmp);
+ char *newTopicCopy = taosStrdup(tmp);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy));
j++;
continue;
} else if (j >= newTopicNum) {
- char *oldTopicCopy = taosStrdup(taosArrayGetP(pExistedConsumer->currentTopics, i));
- taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy);
+ void* tmp = taosArrayGetP(pExistedConsumer->currentTopics, i);
+ MND_TMQ_NULL_CHECK(tmp);
+ char *oldTopicCopy = taosStrdup(tmp);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy));
i++;
continue;
} else {
char *oldTopic = taosArrayGetP(pExistedConsumer->currentTopics, i);
+ MND_TMQ_NULL_CHECK(oldTopic);
char *newTopic = taosArrayGetP(pConsumerNew->assignedTopics, j);
+ MND_TMQ_NULL_CHECK(newTopic);
int comp = strcmp(oldTopic, newTopic);
if (comp == 0) {
i++;
@@ -568,22 +490,22 @@ static int32_t getTopicAddDelete(SMqConsumerObj *pExistedConsumer, SMqConsumerOb
continue;
} else if (comp < 0) {
char *oldTopicCopy = taosStrdup(oldTopic);
- taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy));
i++;
continue;
} else {
char *newTopicCopy = taosStrdup(newTopic);
- taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy));
j++;
continue;
}
}
}
- return 0;
+END:
+ return code;
}
static int32_t checkAndSortTopic(SMnode *pMnode, SArray *pTopicList){
- int32_t code = 0;
taosArraySort(pTopicList, taosArrayCompareString);
taosArrayRemoveDuplicate(pTopicList, taosArrayCompareString, freeItem);
@@ -594,24 +516,21 @@ static int32_t checkAndSortTopic(SMnode *pMnode, SArray *pTopicList){
return TSDB_CODE_TMQ_GROUP_OUT_OF_RANGE;
}
}
- TAOS_RETURN(code);
+ return 0;
}
-static SMqConsumerObj* buildSubConsumer(SMnode *pMnode, SCMSubscribeReq *subscribe){
+static int32_t buildSubConsumer(SMnode *pMnode, SCMSubscribeReq *subscribe, SMqConsumerObj** ppConsumer){
int64_t consumerId = subscribe->consumerId;
char *cgroup = subscribe->cgroup;
SMqConsumerObj *pConsumerNew = NULL;
SMqConsumerObj *pExistedConsumer = NULL;
- pExistedConsumer = mndAcquireConsumer(pMnode, consumerId);
- if (pExistedConsumer == NULL) {
+ int32_t code = mndAcquireConsumer(pMnode, consumerId, &pExistedConsumer);
+ if (code != 0) {
mInfo("receive subscribe request from new consumer:0x%" PRIx64
",cgroup:%s, numOfTopics:%d", consumerId,
subscribe->cgroup, (int32_t)taosArrayGetSize(subscribe->topicNames));
- pConsumerNew = tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_INSERT_SUB, NULL, subscribe);
- if (pConsumerNew == NULL) {
- goto _over;
- }
+ MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_INSERT_SUB, NULL, subscribe, &pConsumerNew));
} else {
int32_t status = atomic_load_32(&pExistedConsumer->status);
@@ -621,82 +540,53 @@ static SMqConsumerObj* buildSubConsumer(SMnode *pMnode, SCMSubscribeReq *subscri
(int32_t)taosArrayGetSize(subscribe->topicNames));
if (status != MQ_CONSUMER_STATUS_READY) {
- terrno = TSDB_CODE_MND_CONSUMER_NOT_READY;
- goto _over;
- }
- pConsumerNew = tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_UPDATE_SUB, NULL, subscribe);
- if (pConsumerNew == NULL) {
- goto _over;
- }
-
- int32_t code = getTopicAddDelete(pExistedConsumer, pConsumerNew);
- if (code != 0){
- terrno = code;
- goto _over;
+ code = TSDB_CODE_MND_CONSUMER_NOT_READY;
+ goto END;
}
+ MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_UPDATE_SUB, NULL, subscribe, &pConsumerNew));
+ MND_TMQ_RETURN_CHECK(getTopicAddDelete(pExistedConsumer, pConsumerNew));
}
mndReleaseConsumer(pMnode, pExistedConsumer);
- return pConsumerNew;
+ if (ppConsumer){
+ *ppConsumer = pConsumerNew;
+ }
+ return code;
-_over:
+END:
mndReleaseConsumer(pMnode, pExistedConsumer);
tDeleteSMqConsumerObj(pConsumerNew);
- return NULL;
+ return code;
}
int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
SMnode *pMnode = pMsg->info.node;
char *msgStr = pMsg->pCont;
int32_t code = 0;
-
- SCMSubscribeReq subscribe = {0};
- tDeserializeSCMSubscribeReq(msgStr, &subscribe);
-
SMqConsumerObj *pConsumerNew = NULL;
STrans *pTrans = NULL;
+ SCMSubscribeReq subscribe = {0};
+ MND_TMQ_RETURN_CHECK(tDeserializeSCMSubscribeReq(msgStr, &subscribe));
if(taosArrayGetSize(subscribe.topicNames) == 0){
- SMqConsumerObj *pConsumerTmp = mndAcquireConsumer(pMnode, subscribe.consumerId);
- if(pConsumerTmp == NULL){
- goto _over;
- }
+ SMqConsumerObj *pConsumerTmp = NULL;
+ MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, subscribe.consumerId, &pConsumerTmp));
mndReleaseConsumer(pMnode, pConsumerTmp);
}
-
- code = checkAndSortTopic(pMnode, subscribe.topicNames);
- if(code != TSDB_CODE_SUCCESS){
- goto _over;
- }
-
+ MND_TMQ_RETURN_CHECK(checkAndSortTopic(pMnode, subscribe.topicNames));
pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_NOTHING, pMsg, "subscribe");
- if (pTrans == NULL) {
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- goto _over;
- }
+ MND_TMQ_NULL_CHECK(pTrans);
- code = validateTopics(subscribe.topicNames, pMnode, pMsg->info.conn.user, subscribe.enableReplay);
- if (code != TSDB_CODE_SUCCESS) {
- goto _over;
- }
-
- pConsumerNew = buildSubConsumer(pMnode, &subscribe);
- if(pConsumerNew == NULL){
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- goto _over;
- }
-
- TAOS_CHECK_GOTO(mndSetConsumerCommitLogs(pTrans, pConsumerNew), NULL, _over);
-
- TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _over);
+ MND_TMQ_RETURN_CHECK(validateTopics(subscribe.topicNames, pMnode, pMsg->info.conn.user, subscribe.enableReplay));
+ MND_TMQ_RETURN_CHECK(buildSubConsumer(pMnode, &subscribe, &pConsumerNew));
+ MND_TMQ_RETURN_CHECK(mndSetConsumerCommitLogs(pTrans, pConsumerNew));
+ MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));
code = TSDB_CODE_ACTION_IN_PROGRESS;
-_over:
+END:
mndTransDrop(pTrans);
tDeleteSMqConsumerObj(pConsumerNew);
taosArrayDestroyP(subscribe.topicNames, (FDelete)taosMemoryFree);
- TAOS_RETURN(code);
+ return code;
}
SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) {
@@ -713,7 +603,9 @@ SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) {
if (buf == NULL) goto CM_ENCODE_OVER;
void *abuf = buf;
- tEncodeSMqConsumerObj(&abuf, pConsumer);
+ if(tEncodeSMqConsumerObj(&abuf, pConsumer) < 0){
+ goto CM_ENCODE_OVER;
+ }
int32_t dataPos = 0;
SDB_SET_INT32(pRaw, dataPos, tlen, CM_ENCODE_OVER);
@@ -838,8 +730,7 @@ static bool existInCurrentTopicList(const SMqConsumerObj *pConsumer, const char
int32_t size = taosArrayGetSize(pConsumer->currentTopics);
for (int32_t i = 0; i < size; i++) {
char *topic = taosArrayGetP(pConsumer->currentTopics, i);
-
- if (strcmp(topic, pTopic) == 0) {
+ if (topic && strcmp(topic, pTopic) == 0) {
existing = true;
break;
}
@@ -865,32 +756,45 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
} else if (pNewConsumer->updateType == CONSUMER_UPDATE_REC) {
int32_t sz = taosArrayGetSize(pOldConsumer->assignedTopics);
for (int32_t i = 0; i < sz; i++) {
- char *topic = taosStrdup(taosArrayGetP(pOldConsumer->assignedTopics, i));
- taosArrayPush(pOldConsumer->rebNewTopics, &topic);
+ void * tmp = taosArrayGetP(pOldConsumer->assignedTopics, i);
+ if (tmp == NULL){
+ return TSDB_CODE_TMQ_INVALID_MSG;
+ }
+ char *topic = taosStrdup(tmp);
+ if (taosArrayPush(pOldConsumer->rebNewTopics, &topic) == NULL) {
+ taosMemoryFree(topic);
+ return TSDB_CODE_TMQ_INVALID_MSG;
+ }
}
pOldConsumer->status = MQ_CONSUMER_STATUS_REBALANCE;
mInfo("consumer:0x%" PRIx64 " recover update", pOldConsumer->consumerId);
} else if (pNewConsumer->updateType == CONSUMER_UPDATE_REB) {
- atomic_add_fetch_32(&pOldConsumer->epoch, 1);
-
+ (void)atomic_add_fetch_32(&pOldConsumer->epoch, 1);
pOldConsumer->rebalanceTime = taosGetTimestampMs();
mInfo("[rebalance] consumer:0x%" PRIx64 " rebalance update, only rebalance time", pOldConsumer->consumerId);
} else if (pNewConsumer->updateType == CONSUMER_ADD_REB) {
- char *pNewTopic = taosStrdup(taosArrayGetP(pNewConsumer->rebNewTopics, 0));
+ void *tmp = taosArrayGetP(pNewConsumer->rebNewTopics, 0);
+ if (tmp == NULL){
+ return TSDB_CODE_TMQ_INVALID_MSG;
+ }
+ char *pNewTopic = taosStrdup(tmp);
removeFromTopicList(pOldConsumer->rebNewTopics, pNewTopic, pOldConsumer->consumerId, "new");
bool existing = existInCurrentTopicList(pOldConsumer, pNewTopic);
if (existing) {
mError("[rebalance] consumer:0x%" PRIx64 " add new topic:%s should not in currentTopics", pOldConsumer->consumerId, pNewTopic);
taosMemoryFree(pNewTopic);
} else {
- taosArrayPush(pOldConsumer->currentTopics, &pNewTopic);
+ if (taosArrayPush(pOldConsumer->currentTopics, &pNewTopic) == NULL) {
+ taosMemoryFree(pNewTopic);
+ return TSDB_CODE_TMQ_INVALID_MSG;
+ }
taosArraySort(pOldConsumer->currentTopics, taosArrayCompareString);
}
int32_t status = pOldConsumer->status;
updateConsumerStatus(pOldConsumer);
pOldConsumer->rebalanceTime = taosGetTimestampMs();
- atomic_add_fetch_32(&pOldConsumer->epoch, 1);
+ (void)atomic_add_fetch_32(&pOldConsumer->epoch, 1);
mInfo("[rebalance] consumer:0x%" PRIx64 " rebalance update add, state (%d)%s -> (%d)%s, new epoch:%d, reb-time:%" PRId64
", current topics:%d, newTopics:%d, removeTopics:%d",
@@ -901,13 +805,16 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
} else if (pNewConsumer->updateType == CONSUMER_REMOVE_REB) {
char *topic = taosArrayGetP(pNewConsumer->rebRemovedTopics, 0);
+ if (topic == NULL){
+ return TSDB_CODE_TMQ_INVALID_MSG;
+ }
removeFromTopicList(pOldConsumer->rebRemovedTopics, topic, pOldConsumer->consumerId, "remove");
removeFromTopicList(pOldConsumer->currentTopics, topic, pOldConsumer->consumerId, "current");
int32_t status = pOldConsumer->status;
updateConsumerStatus(pOldConsumer);
pOldConsumer->rebalanceTime = taosGetTimestampMs();
- atomic_add_fetch_32(&pOldConsumer->epoch, 1);
+ (void)atomic_add_fetch_32(&pOldConsumer->epoch, 1);
mInfo("[rebalance]consumer:0x%" PRIx64 " rebalance update remove, state (%d)%s -> (%d)%s, new epoch:%d, reb-time:%" PRId64
", current topics:%d, newTopics:%d, removeTopics:%d",
@@ -921,13 +828,13 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
return 0;
}
-SMqConsumerObj *mndAcquireConsumer(SMnode *pMnode, int64_t consumerId) {
+int32_t mndAcquireConsumer(SMnode *pMnode, int64_t consumerId, SMqConsumerObj** pConsumer) {
SSdb *pSdb = pMnode->pSdb;
- SMqConsumerObj *pConsumer = sdbAcquire(pSdb, SDB_CONSUMER, &consumerId);
- if (pConsumer == NULL) {
- terrno = TSDB_CODE_MND_CONSUMER_NOT_EXIST;
+ *pConsumer = sdbAcquire(pSdb, SDB_CONSUMER, &consumerId);
+ if (*pConsumer == NULL) {
+ return TSDB_CODE_MND_CONSUMER_NOT_EXIST;
}
- return pConsumer;
+ return 0;
}
void mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer) {
@@ -940,6 +847,7 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
SSdb *pSdb = pMnode->pSdb;
int32_t numOfRows = 0;
SMqConsumerObj *pConsumer = NULL;
+ int32_t code = 0;
while (numOfRows < rowsCapacity) {
pShow->pIter = sdbFetch(pSdb, SDB_CONSUMER, pShow->pIter, (void **)&pConsumer);
@@ -964,34 +872,37 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
}
if (numOfRows + topicSz > rowsCapacity) {
- blockDataEnsureCapacity(pBlock, numOfRows + topicSz);
+ MND_TMQ_RETURN_CHECK(blockDataEnsureCapacity(pBlock, numOfRows + topicSz));
}
for (int32_t i = 0; i < topicSz; i++) {
- SColumnInfoData *pColInfo;
+ SColumnInfoData *pColInfo = NULL;
int32_t cols = 0;
// consumer id
char consumerIdHex[32] = {0};
- sprintf(varDataVal(consumerIdHex), "0x%" PRIx64, pConsumer->consumerId);
+ (void)sprintf(varDataVal(consumerIdHex), "0x%" PRIx64, pConsumer->consumerId);
varDataSetLen(consumerIdHex, strlen(varDataVal(consumerIdHex)));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)consumerIdHex, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)consumerIdHex, false));
// consumer group
char cgroup[TSDB_CGROUP_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(cgroup, pConsumer->cgroup);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)cgroup, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)cgroup, false));
// client id
char clientId[256 + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(clientId, pConsumer->clientId);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)clientId, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)clientId, false));
// status
char status[20 + VARSTR_HEADER_SIZE] = {0};
@@ -999,46 +910,48 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
STR_TO_VARSTR(status, pStatusName);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)status, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)status, false));
// one subscribed topic
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+ MND_TMQ_NULL_CHECK(pColInfo);
if (hasTopic) {
char topic[TSDB_TOPIC_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
- const char *topicName = mndTopicGetShowName(taosArrayGetP(pConsumer->assignedTopics, i));
- STR_TO_VARSTR(topic, topicName);
- colDataSetVal(pColInfo, numOfRows, (const char *)topic, false);
+ mndTopicGetShowName(taosArrayGetP(pConsumer->assignedTopics, i), topic + VARSTR_HEADER_SIZE);
+ *(VarDataLenT *)(topic) = strlen(topic + VARSTR_HEADER_SIZE);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)topic, false));
} else {
- colDataSetVal(pColInfo, numOfRows, NULL, true);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, NULL, true));
}
- // end point
- /*pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);*/
- /*colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->ep, true);*/
-
// up time
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->createTime, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->createTime, false));
// subscribe time
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->subscribeTime, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->subscribeTime, false));
// rebalance time
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->rebalanceTime, pConsumer->rebalanceTime == 0);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->rebalanceTime, pConsumer->rebalanceTime == 0));
char buf[TSDB_OFFSET_LEN] = {0};
STqOffsetVal pVal = {.type = pConsumer->resetOffsetCfg};
- tFormatOffset(buf, TSDB_OFFSET_LEN, &pVal);
+ MND_TMQ_RETURN_CHECK(tFormatOffset(buf, TSDB_OFFSET_LEN, &pVal));
char parasStr[64 + TSDB_OFFSET_LEN + VARSTR_HEADER_SIZE] = {0};
- sprintf(varDataVal(parasStr), "tbname:%d,commit:%d,interval:%dms,reset:%s", pConsumer->withTbName,
+ (void)sprintf(varDataVal(parasStr), "tbname:%d,commit:%d,interval:%dms,reset:%s", pConsumer->withTbName,
pConsumer->autoCommit, pConsumer->autoCommitInterval, buf);
varDataSetLen(parasStr, strlen(varDataVal(parasStr)));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)parasStr, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)parasStr, false));
numOfRows++;
}
@@ -1051,6 +964,9 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
pShow->numOfRows += numOfRows;
return numOfRows;
+
+END:
+ return code;
}
static void mndCancelGetNextConsumer(SMnode *pMnode, void *pIter) {
diff --git a/source/dnode/mnode/impl/src/mndDef.c b/source/dnode/mnode/impl/src/mndDef.c
index 9dc5f920ad..32f8fb8548 100644
--- a/source/dnode/mnode/impl/src/mndDef.c
+++ b/source/dnode/mnode/impl/src/mndDef.c
@@ -12,173 +12,179 @@
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
-
#define _DEFAULT_SOURCE
#include "mndDef.h"
#include "mndConsumer.h"
+#include "taoserror.h"
static void *freeStreamTasks(SArray *pTaskLevel);
int32_t tEncodeSStreamObj(SEncoder *pEncoder, const SStreamObj *pObj) {
- if (tStartEncode(pEncoder) < 0) return -1;
- if (tEncodeCStr(pEncoder, pObj->name) < 0) return -1;
+ TAOS_CHECK_RETURN(tStartEncode(pEncoder));
+ TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->name));
- if (tEncodeI64(pEncoder, pObj->createTime) < 0) return -1;
- if (tEncodeI64(pEncoder, pObj->updateTime) < 0) return -1;
- if (tEncodeI32(pEncoder, pObj->version) < 0) return -1;
- if (tEncodeI32(pEncoder, pObj->totalLevel) < 0) return -1;
- if (tEncodeI64(pEncoder, pObj->smaId) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->createTime));
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->updateTime));
+ TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pObj->version));
+ TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pObj->totalLevel));
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->smaId));
- if (tEncodeI64(pEncoder, pObj->uid) < 0) return -1;
- if (tEncodeI8(pEncoder, pObj->status) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->uid));
+ TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->status));
- if (tEncodeI8(pEncoder, pObj->conf.igExpired) < 0) return -1;
- if (tEncodeI8(pEncoder, pObj->conf.trigger) < 0) return -1;
- if (tEncodeI8(pEncoder, pObj->conf.fillHistory) < 0) return -1;
- if (tEncodeI64(pEncoder, pObj->conf.triggerParam) < 0) return -1;
- if (tEncodeI64(pEncoder, pObj->conf.watermark) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->conf.igExpired));
+ TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->conf.trigger));
+ TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->conf.fillHistory));
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->conf.triggerParam));
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->conf.watermark));
- if (tEncodeI64(pEncoder, pObj->sourceDbUid) < 0) return -1;
- if (tEncodeI64(pEncoder, pObj->targetDbUid) < 0) return -1;
- if (tEncodeCStr(pEncoder, pObj->sourceDb) < 0) return -1;
- if (tEncodeCStr(pEncoder, pObj->targetDb) < 0) return -1;
- if (tEncodeCStr(pEncoder, pObj->targetSTbName) < 0) return -1;
- if (tEncodeI64(pEncoder, pObj->targetStbUid) < 0) return -1;
- if (tEncodeI32(pEncoder, pObj->fixedSinkVgId) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->sourceDbUid));
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->targetDbUid));
+ TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->sourceDb));
+ TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->targetDb));
+ TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->targetSTbName));
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->targetStbUid));
+ TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pObj->fixedSinkVgId));
if (pObj->sql != NULL) {
- if (tEncodeCStr(pEncoder, pObj->sql) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->sql));
} else {
- if (tEncodeCStr(pEncoder, "") < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, ""));
}
if (pObj->ast != NULL) {
- if (tEncodeCStr(pEncoder, pObj->ast) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->ast));
} else {
- if (tEncodeCStr(pEncoder, "") < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, ""));
}
if (pObj->physicalPlan != NULL) {
- if (tEncodeCStr(pEncoder, pObj->physicalPlan) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pObj->physicalPlan));
} else {
- if (tEncodeCStr(pEncoder, "") < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, ""));
}
int32_t sz = taosArrayGetSize(pObj->tasks);
- if (tEncodeI32(pEncoder, sz) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI32(pEncoder, sz));
for (int32_t i = 0; i < sz; i++) {
SArray *pArray = taosArrayGetP(pObj->tasks, i);
int32_t innerSz = taosArrayGetSize(pArray);
- if (tEncodeI32(pEncoder, innerSz) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI32(pEncoder, innerSz));
for (int32_t j = 0; j < innerSz; j++) {
SStreamTask *pTask = taosArrayGetP(pArray, j);
if (pTask->ver < SSTREAM_TASK_SUBTABLE_CHANGED_VER){
pTask->ver = SSTREAM_TASK_VER;
}
- if (tEncodeStreamTask(pEncoder, pTask) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeStreamTask(pEncoder, pTask));
}
}
- if (tEncodeSSchemaWrapper(pEncoder, &pObj->outputSchema) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pEncoder, &pObj->outputSchema));
// 3.0.20 ver =2
- if (tEncodeI64(pEncoder, pObj->checkpointFreq) < 0) return -1;
- if (tEncodeI8(pEncoder, pObj->igCheckUpdate) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->checkpointFreq));
+ TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->igCheckUpdate));
// 3.0.50 ver = 3
- if (tEncodeI64(pEncoder, pObj->checkpointId) < 0) return -1;
- if (tEncodeI8(pEncoder, pObj->subTableWithoutMd5) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pObj->checkpointId));
+ TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pObj->subTableWithoutMd5));
- if (tEncodeCStrWithLen(pEncoder, pObj->reserve, sizeof(pObj->reserve) - 1) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeCStrWithLen(pEncoder, pObj->reserve, sizeof(pObj->reserve) - 1));
tEndEncode(pEncoder);
return pEncoder->pos;
}
int32_t tDecodeSStreamObj(SDecoder *pDecoder, SStreamObj *pObj, int32_t sver) {
- if (tStartDecode(pDecoder) < 0) return -1;
- if (tDecodeCStrTo(pDecoder, pObj->name) < 0) return -1;
+ int32_t code = 0;
+ TAOS_CHECK_RETURN(tStartDecode(pDecoder));
+ TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pObj->name));
- if (tDecodeI64(pDecoder, &pObj->createTime) < 0) return -1;
- if (tDecodeI64(pDecoder, &pObj->updateTime) < 0) return -1;
- if (tDecodeI32(pDecoder, &pObj->version) < 0) return -1;
- if (tDecodeI32(pDecoder, &pObj->totalLevel) < 0) return -1;
- if (tDecodeI64(pDecoder, &pObj->smaId) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->createTime));
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->updateTime));
+ TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pObj->version));
+ TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pObj->totalLevel));
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->smaId));
- if (tDecodeI64(pDecoder, &pObj->uid) < 0) return -1;
- if (tDecodeI8(pDecoder, &pObj->status) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->uid));
+ TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->status));
- if (tDecodeI8(pDecoder, &pObj->conf.igExpired) < 0) return -1;
- if (tDecodeI8(pDecoder, &pObj->conf.trigger) < 0) return -1;
- if (tDecodeI8(pDecoder, &pObj->conf.fillHistory) < 0) return -1;
- if (tDecodeI64(pDecoder, &pObj->conf.triggerParam) < 0) return -1;
- if (tDecodeI64(pDecoder, &pObj->conf.watermark) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->conf.igExpired));
+ TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->conf.trigger));
+ TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->conf.fillHistory));
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->conf.triggerParam));
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->conf.watermark));
- if (tDecodeI64(pDecoder, &pObj->sourceDbUid) < 0) return -1;
- if (tDecodeI64(pDecoder, &pObj->targetDbUid) < 0) return -1;
- if (tDecodeCStrTo(pDecoder, pObj->sourceDb) < 0) return -1;
- if (tDecodeCStrTo(pDecoder, pObj->targetDb) < 0) return -1;
- if (tDecodeCStrTo(pDecoder, pObj->targetSTbName) < 0) return -1;
- if (tDecodeI64(pDecoder, &pObj->targetStbUid) < 0) return -1;
- if (tDecodeI32(pDecoder, &pObj->fixedSinkVgId) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->sourceDbUid));
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->targetDbUid));
+ TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pObj->sourceDb));
+ TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pObj->targetDb));
+ TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pObj->targetSTbName));
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->targetStbUid));
+ TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pObj->fixedSinkVgId));
- if (tDecodeCStrAlloc(pDecoder, &pObj->sql) < 0) return -1;
- if (tDecodeCStrAlloc(pDecoder, &pObj->ast) < 0) return -1;
- if (tDecodeCStrAlloc(pDecoder, &pObj->physicalPlan) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeCStrAlloc(pDecoder, &pObj->sql));
+ TAOS_CHECK_RETURN(tDecodeCStrAlloc(pDecoder, &pObj->ast));
+ TAOS_CHECK_RETURN(tDecodeCStrAlloc(pDecoder, &pObj->physicalPlan));
if (pObj->tasks != NULL) {
pObj->tasks = freeStreamTasks(pObj->tasks);
}
int32_t sz;
- if (tDecodeI32(pDecoder, &sz) < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &sz));
if (sz != 0) {
pObj->tasks = taosArrayInit(sz, sizeof(void *));
+ if (pObj->tasks == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ TAOS_RETURN(code);
+ }
for (int32_t i = 0; i < sz; i++) {
int32_t innerSz;
- if (tDecodeI32(pDecoder, &innerSz) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &innerSz));
SArray *pArray = taosArrayInit(innerSz, sizeof(void *));
- for (int32_t j = 0; j < innerSz; j++) {
- SStreamTask *pTask = taosMemoryCalloc(1, sizeof(SStreamTask));
- if (pTask == NULL) {
- taosArrayDestroy(pArray);
- return -1;
+ if (pArray != NULL) {
+ for (int32_t j = 0; j < innerSz; j++) {
+ SStreamTask *pTask = taosMemoryCalloc(1, sizeof(SStreamTask));
+ if (pTask == NULL) {
+ taosArrayDestroy(pArray);
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ TAOS_RETURN(code);
+ }
+ if ((code = tDecodeStreamTask(pDecoder, pTask)) < 0) {
+ taosMemoryFree(pTask);
+ taosArrayDestroy(pArray);
+ TAOS_RETURN(code);
+ }
+ taosArrayPush(pArray, &pTask);
}
- if (tDecodeStreamTask(pDecoder, pTask) < 0) {
- taosMemoryFree(pTask);
- taosArrayDestroy(pArray);
- return -1;
- }
- taosArrayPush(pArray, &pTask);
}
taosArrayPush(pObj->tasks, &pArray);
}
}
- if (tDecodeSSchemaWrapper(pDecoder, &pObj->outputSchema) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeSSchemaWrapper(pDecoder, &pObj->outputSchema));
// 3.0.20
if (sver >= 2) {
- if (tDecodeI64(pDecoder, &pObj->checkpointFreq) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->checkpointFreq));
if (!tDecodeIsEnd(pDecoder)) {
- if (tDecodeI8(pDecoder, &pObj->igCheckUpdate) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->igCheckUpdate));
}
}
if (sver >= 3) {
- if (tDecodeI64(pDecoder, &pObj->checkpointId) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pObj->checkpointId));
}
if (sver >= 5) {
- if (tDecodeI8(pDecoder, &pObj->subTableWithoutMd5) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pObj->subTableWithoutMd5));
}
- if (tDecodeCStrTo(pDecoder, pObj->reserve) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pObj->reserve));
tEndDecode(pDecoder);
- return 0;
+ TAOS_RETURN(code);
}
void *freeStreamTasks(SArray *pTaskLevel) {
@@ -220,7 +226,10 @@ void tFreeStreamObj(SStreamObj *pStream) {
SMqVgEp *tCloneSMqVgEp(const SMqVgEp *pVgEp) {
SMqVgEp *pVgEpNew = taosMemoryMalloc(sizeof(SMqVgEp));
- if (pVgEpNew == NULL) return NULL;
+ if (pVgEpNew == NULL) {
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
+ return NULL;
+ }
pVgEpNew->vgId = pVgEp->vgId;
// pVgEpNew->qmsg = taosStrdup(pVgEp->qmsg);
pVgEpNew->epSet = pVgEp->epSet;
@@ -255,15 +264,17 @@ void *tDecodeSMqVgEp(const void *buf, SMqVgEp *pVgEp, int8_t sver) {
static void *topicNameDup(void *p) { return taosStrdup((char *)p); }
-SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType, char *topic, SCMSubscribeReq *subscribe) {
+int32_t tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType,
+ char *topic, SCMSubscribeReq *subscribe, SMqConsumerObj** ppConsumer) {
+ int32_t code = 0;
SMqConsumerObj *pConsumer = taosMemoryCalloc(1, sizeof(SMqConsumerObj));
if (pConsumer == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return NULL;
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto END;
}
pConsumer->consumerId = consumerId;
- memcpy(pConsumer->cgroup, cgroup, TSDB_CGROUP_LEN);
+ (void)memcpy(pConsumer->cgroup, cgroup, TSDB_CGROUP_LEN);
pConsumer->epoch = 0;
pConsumer->status = MQ_CONSUMER_STATUS_REBALANCE;
@@ -276,20 +287,26 @@ SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t upda
if (updateType == CONSUMER_ADD_REB){
pConsumer->rebNewTopics = taosArrayInit(0, sizeof(void *));
if(pConsumer->rebNewTopics == NULL){
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto END;
}
char* topicTmp = taosStrdup(topic);
- taosArrayPush(pConsumer->rebNewTopics, &topicTmp);
+ if (taosArrayPush(pConsumer->rebNewTopics, &topicTmp) == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto END;
+ }
}else if (updateType == CONSUMER_REMOVE_REB) {
pConsumer->rebRemovedTopics = taosArrayInit(0, sizeof(void *));
if(pConsumer->rebRemovedTopics == NULL){
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto END;
}
char* topicTmp = taosStrdup(topic);
- taosArrayPush(pConsumer->rebRemovedTopics, &topicTmp);
+ if (taosArrayPush(pConsumer->rebRemovedTopics, &topicTmp) == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto END;
+ }
}else if (updateType == CONSUMER_INSERT_SUB){
tstrncpy(pConsumer->clientId, subscribe->clientId, tListLen(pConsumer->clientId));
pConsumer->withTbName = subscribe->withTbName;
@@ -297,10 +314,9 @@ SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t upda
pConsumer->autoCommitInterval = subscribe->autoCommitInterval;
pConsumer->resetOffsetCfg = subscribe->resetOffsetCfg;
-
pConsumer->rebNewTopics = taosArrayDup(subscribe->topicNames, topicNameDup);
if (pConsumer->rebNewTopics == NULL){
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto END;
}
pConsumer->assignedTopics = subscribe->topicNames;
@@ -310,11 +326,12 @@ SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t upda
subscribe->topicNames = NULL;
}
- return pConsumer;
+ *ppConsumer = pConsumer;
+ return 0;
END:
tDeleteSMqConsumerObj(pConsumer);
- return NULL;
+ return code;
}
void tClearSMqConsumerObj(SMqConsumerObj *pConsumer) {
@@ -530,27 +547,36 @@ void *tDecodeSMqConsumerEp(const void *buf, SMqConsumerEp *pConsumerEp, int8_t s
return (void *)buf;
}
-SMqSubscribeObj *tNewSubscribeObj(const char *key) {
+int32_t tNewSubscribeObj(const char *key, SMqSubscribeObj **ppSub) {
+ int32_t code = 0;
SMqSubscribeObj *pSubObj = taosMemoryCalloc(1, sizeof(SMqSubscribeObj));
- if (pSubObj == NULL) {
- return NULL;
- }
+ MND_TMQ_NULL_CHECK(pSubObj);
- memcpy(pSubObj->key, key, TSDB_SUBSCRIBE_KEY_LEN);
+ (void)memcpy(pSubObj->key, key, TSDB_SUBSCRIBE_KEY_LEN);
taosInitRWLatch(&pSubObj->lock);
pSubObj->vgNum = 0;
pSubObj->consumerHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
-
- // TODO set hash free fp
- /*taosHashSetFreeFp(pSubObj->consumerHash, tDeleteSMqConsumerEp);*/
+ MND_TMQ_NULL_CHECK(pSubObj->consumerHash);
pSubObj->unassignedVgs = taosArrayInit(0, POINTER_BYTES);
- return pSubObj;
+ MND_TMQ_NULL_CHECK(pSubObj->unassignedVgs);
+ if (ppSub){
+ *ppSub = pSubObj;
+ }
+ return code;
+
+END:
+ taosMemoryFree(pSubObj);
+ return code;
}
-SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) {
+int32_t tCloneSubscribeObj(const SMqSubscribeObj *pSub, SMqSubscribeObj **ppSub) {
+ int32_t code = 0;
SMqSubscribeObj *pSubNew = taosMemoryMalloc(sizeof(SMqSubscribeObj));
- if (pSubNew == NULL) return NULL;
- memcpy(pSubNew->key, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
+ if (pSubNew == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto END;
+ }
+ (void)memcpy(pSubNew->key, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
taosInitRWLatch(&pSubNew->lock);
pSubNew->dbUid = pSub->dbUid;
@@ -560,8 +586,7 @@ SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) {
pSubNew->vgNum = pSub->vgNum;
pSubNew->consumerHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
- // TODO set hash free fp
- /*taosHashSetFreeFp(pSubNew->consumerHash, tDeleteSMqConsumerEp);*/
+
void *pIter = NULL;
SMqConsumerEp *pConsumerEp = NULL;
while (1) {
@@ -576,9 +601,13 @@ SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) {
}
pSubNew->unassignedVgs = taosArrayDup(pSub->unassignedVgs, (__array_item_dup_fn_t)tCloneSMqVgEp);
pSubNew->offsetRows = taosArrayDup(pSub->offsetRows, NULL);
- memcpy(pSubNew->dbName, pSub->dbName, TSDB_DB_FNAME_LEN);
+ (void)memcpy(pSubNew->dbName, pSub->dbName, TSDB_DB_FNAME_LEN);
pSubNew->qmsg = taosStrdup(pSub->qmsg);
- return pSubNew;
+ if (ppSub) {
+ *ppSub = pSubNew;
+ }
+END:
+ return code;
}
void tDeleteSubscribeObj(SMqSubscribeObj *pSub) {
diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c
index 73addea6fe..b7446dbd3c 100644
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@@ -165,15 +165,24 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
}
pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, NULL, "create-dnode");
- if (pTrans == NULL) goto _OVER;
+ if (pTrans == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
mInfo("trans:%d, used to create dnode:%s on first deploy", pTrans->id, dnodeObj.ep);
pRaw = mndDnodeActionEncode(&dnodeObj);
- if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
+ if (pRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pRaw), NULL, _OVER);
(void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
pRaw = NULL;
- if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
code = 0;
mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1);
@@ -563,10 +572,7 @@ static int32_t mndProcessStatisReq(SRpcMsg *pReq) {
SStatisReq statisReq = {0};
int32_t code = -1;
- if (tDeserializeSStatisReq(pReq->pCont, pReq->contLen, &statisReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
- return code;
- }
+ TAOS_CHECK_RETURN(tDeserializeSStatisReq(pReq->pCont, pReq->contLen, &statisReq));
if (tsMonitorLogProtocol) {
mInfo("process statis req,\n %s", statisReq.pCont);
@@ -586,23 +592,28 @@ static int32_t mndUpdateDnodeObj(SMnode *pMnode, SDnodeObj *pDnode) {
int32_t code = 0;
STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, NULL, "update-dnode-obj");
if (pTrans == NULL) {
- code = terrno;
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
goto _exit;
}
pDnode->updateTime = taosGetTimestampMs();
SSdbRaw *pCommitRaw = mndDnodeActionEncode(pDnode);
- if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
- mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
+ if (pCommitRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _exit;
+ }
+ if ((code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
+ mError("trans:%d, failed to append commit log since %s", pTrans->id, tstrerror(code));
code = terrno;
goto _exit;
}
(void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
- if (mndTransPrepare(pMnode, pTrans) != 0) {
- mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
- code = terrno;
+ if ((code = mndTransPrepare(pMnode, pTrans)) != 0) {
+ mError("trans:%d, failed to prepare since %s", pTrans->id, tstrerror(code));
goto _exit;
}
@@ -617,10 +628,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
SDnodeObj *pDnode = NULL;
int32_t code = -1;
- if (tDeserializeSStatusReq(pReq->pCont, pReq->contLen, &statusReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
- goto _OVER;
- }
+ TAOS_CHECK_GOTO(tDeserializeSStatusReq(pReq->pCont, pReq->contLen, &statusReq), NULL, _OVER);
int64_t clusterid = mndGetClusterId(pMnode);
if (statusReq.clusterId != 0 && statusReq.clusterId != clusterid) {
@@ -634,6 +642,8 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
pDnode = mndAcquireDnodeByEp(pMnode, statusReq.dnodeEp);
if (pDnode == NULL) {
mInfo("dnode:%s, not created yet", statusReq.dnodeEp);
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
goto _OVER;
}
} else {
@@ -871,16 +881,25 @@ static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pC
snprintf(dnodeObj.ep, TSDB_EP_LEN - 1, "%s:%u", pCreate->fqdn, pCreate->port);
pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_GLOBAL, pReq, "create-dnode");
- if (pTrans == NULL) goto _OVER;
+ if (pTrans == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
mInfo("trans:%d, used to create dnode:%s", pTrans->id, dnodeObj.ep);
- if (mndTransCheckConflict(pMnode, pTrans) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);
pRaw = mndDnodeActionEncode(&dnodeObj);
- if (pRaw == NULL || mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
+ if (pRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pRaw), NULL, _OVER);
(void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
pRaw = NULL;
- if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
code = 0;
mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1);
@@ -901,7 +920,7 @@ static int32_t mndProcessDnodeListReq(SRpcMsg *pReq) {
rsp.dnodeList = taosArrayInit(5, sizeof(SEpSet));
if (NULL == rsp.dnodeList) {
mError("failed to alloc epSet while process dnode list req");
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto _OVER;
}
@@ -922,7 +941,7 @@ static int32_t mndProcessDnodeListReq(SRpcMsg *pReq) {
int32_t rspLen = tSerializeSDnodeListRsp(NULL, 0, &rsp);
void *pRsp = rpcMallocCont(rspLen);
if (pRsp == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto _OVER;
}
@@ -935,12 +954,12 @@ static int32_t mndProcessDnodeListReq(SRpcMsg *pReq) {
_OVER:
if (code != 0) {
- mError("failed to get dnode list since %s", terrstr());
+ mError("failed to get dnode list since %s", tstrerror(code));
}
tFreeSDnodeListRsp(&rsp);
- return code;
+ TAOS_RETURN(code);
}
static void getSlowLogScopeString(int32_t scope, char* result){
@@ -980,7 +999,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
rsp.variables = taosArrayInit(16, sizeof(SVariablesInfo));
if (NULL == rsp.variables) {
mError("failed to alloc SVariablesInfo array while process show variables req");
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto _OVER;
}
@@ -1036,7 +1055,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
int32_t rspLen = tSerializeSShowVariablesRsp(NULL, 0, &rsp);
void *pRsp = rpcMallocCont(rspLen);
if (pRsp == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto _OVER;
}
@@ -1049,11 +1068,11 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
_OVER:
if (code != 0) {
- mError("failed to get show variables info since %s", terrstr());
+ mError("failed to get show variables info since %s", tstrerror(code));
}
tFreeSShowVariablesRsp(&rsp);
- return code;
+ TAOS_RETURN(code);
}
static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
@@ -1062,23 +1081,17 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
SDnodeObj *pDnode = NULL;
SCreateDnodeReq createReq = {0};
- if ((terrno = grantCheck(TSDB_GRANT_DNODE)) != 0 || (terrno = grantCheck(TSDB_GRANT_CPU_CORES)) != 0) {
- code = terrno;
+ if ((code = grantCheck(TSDB_GRANT_DNODE)) != 0 || (code = grantCheck(TSDB_GRANT_CPU_CORES)) != 0) {
goto _OVER;
}
- if (tDeserializeSCreateDnodeReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
- goto _OVER;
- }
+ TAOS_CHECK_GOTO(tDeserializeSCreateDnodeReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER);
mInfo("dnode:%s:%d, start to create", createReq.fqdn, createReq.port);
- if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_DNODE) != 0) {
- goto _OVER;
- }
+ TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_DNODE), NULL, _OVER);
if (createReq.fqdn[0] == 0 || createReq.port <= 0 || createReq.port > UINT16_MAX) {
- terrno = TSDB_CODE_MND_INVALID_DNODE_EP;
+ code = TSDB_CODE_MND_INVALID_DNODE_EP;
goto _OVER;
}
@@ -1086,7 +1099,7 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
snprintf(ep, TSDB_EP_LEN, "%s:%d", createReq.fqdn, createReq.port);
pDnode = mndAcquireDnodeByEp(pMnode, ep);
if (pDnode != NULL) {
- terrno = TSDB_CODE_MND_DNODE_ALREADY_EXIST;
+ code = TSDB_CODE_MND_DNODE_ALREADY_EXIST;
goto _OVER;
}
@@ -1103,12 +1116,12 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
_OVER:
if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
- mError("dnode:%s:%d, failed to create since %s", createReq.fqdn, createReq.port, terrstr());
+ mError("dnode:%s:%d, failed to create since %s", createReq.fqdn, createReq.port, tstrerror(code));
}
mndReleaseDnode(pMnode, pDnode);
tFreeSCreateDnodeReq(&createReq);
- return code;
+ TAOS_RETURN(code);
}
extern int32_t mndProcessRestoreDnodeReqImpl(SRpcMsg *pReq);
@@ -1126,44 +1139,56 @@ static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SM
STrans *pTrans = NULL;
pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "drop-dnode");
- if (pTrans == NULL) goto _OVER;
+ if (pTrans == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
mndTransSetSerial(pTrans);
mInfo("trans:%d, used to drop dnode:%d, force:%d", pTrans->id, pDnode->id, force);
- if (mndTransCheckConflict(pMnode, pTrans) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);
pRaw = mndDnodeActionEncode(pDnode);
- if (pRaw == NULL) goto _OVER;
- if (mndTransAppendRedolog(pTrans, pRaw) != 0) goto _OVER;
+ if (pRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendRedolog(pTrans, pRaw), NULL, _OVER);
(void)sdbSetRawStatus(pRaw, SDB_STATUS_DROPPING);
pRaw = NULL;
pRaw = mndDnodeActionEncode(pDnode);
- if (pRaw == NULL) goto _OVER;
- if (mndTransAppendCommitlog(pTrans, pRaw) != 0) goto _OVER;
+ if (pRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pRaw), NULL, _OVER);
(void)sdbSetRawStatus(pRaw, SDB_STATUS_DROPPED);
pRaw = NULL;
if (pMObj != NULL) {
mInfo("trans:%d, mnode on dnode:%d will be dropped", pTrans->id, pDnode->id);
- if (mndSetDropMnodeInfoToTrans(pMnode, pTrans, pMObj, force) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndSetDropMnodeInfoToTrans(pMnode, pTrans, pMObj, force), NULL, _OVER);
}
if (pQObj != NULL) {
mInfo("trans:%d, qnode on dnode:%d will be dropped", pTrans->id, pDnode->id);
- if (mndSetDropQnodeInfoToTrans(pMnode, pTrans, pQObj, force) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndSetDropQnodeInfoToTrans(pMnode, pTrans, pQObj, force), NULL, _OVER);
}
if (pSObj != NULL) {
mInfo("trans:%d, snode on dnode:%d will be dropped", pTrans->id, pDnode->id);
- if (mndSetDropSnodeInfoToTrans(pMnode, pTrans, pSObj, force) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndSetDropSnodeInfoToTrans(pMnode, pTrans, pSObj, force), NULL, _OVER);
}
if (numOfVnodes > 0) {
mInfo("trans:%d, %d vnodes on dnode:%d will be dropped", pTrans->id, numOfVnodes, pDnode->id);
- if (mndSetMoveVgroupsInfoToTrans(pMnode, pTrans, pDnode->id, force, unsafe) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndSetMoveVgroupsInfoToTrans(pMnode, pTrans, pDnode->id, force, unsafe), NULL, _OVER);
}
- if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, 1);
code = 0;
@@ -1171,7 +1196,7 @@ static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SM
_OVER:
mndTransDrop(pTrans);
sdbFreeRaw(pRaw);
- return code;
+ TAOS_RETURN(code);
}
static bool mndIsEmptyDnode(SMnode *pMnode, int32_t dnodeId) {
@@ -1209,16 +1234,11 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
SSnodeObj *pSObj = NULL;
SDropDnodeReq dropReq = {0};
- if (tDeserializeSDropDnodeReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
- goto _OVER;
- }
+ TAOS_CHECK_GOTO(tDeserializeSDropDnodeReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER);
mInfo("dnode:%d, start to drop, ep:%s:%d, force:%s, unsafe:%s", dropReq.dnodeId, dropReq.fqdn, dropReq.port,
dropReq.force ? "true" : "false", dropReq.unsafe ? "true" : "false");
- if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_MNODE) != 0) {
- goto _OVER;
- }
+ TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_MNODE), NULL, _OVER);
bool force = dropReq.force;
if (dropReq.unsafe) {
@@ -1232,7 +1252,7 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
snprintf(ep, sizeof(ep), dropReq.fqdn, dropReq.port);
pDnode = mndAcquireDnodeByEp(pMnode, ep);
if (pDnode == NULL) {
- terrno = err;
+ code = err;
goto _OVER;
}
}
@@ -1242,11 +1262,11 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
pMObj = mndAcquireMnode(pMnode, dropReq.dnodeId);
if (pMObj != NULL) {
if (sdbGetSize(pMnode->pSdb, SDB_MNODE) <= 1) {
- terrno = TSDB_CODE_MND_TOO_FEW_MNODES;
+ code = TSDB_CODE_MND_TOO_FEW_MNODES;
goto _OVER;
}
if (pMnode->selfDnodeId == dropReq.dnodeId) {
- terrno = TSDB_CODE_MND_CANT_DROP_LEADER;
+ code = TSDB_CODE_MND_CANT_DROP_LEADER;
goto _OVER;
}
}
@@ -1255,16 +1275,16 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
bool isonline = mndIsDnodeOnline(pDnode, taosGetTimestampMs());
if (isonline && force) {
- terrno = TSDB_CODE_DNODE_ONLY_USE_WHEN_OFFLINE;
- mError("dnode:%d, failed to drop since %s, vnodes:%d mnode:%d qnode:%d snode:%d", pDnode->id, terrstr(),
+ code = TSDB_CODE_DNODE_ONLY_USE_WHEN_OFFLINE;
+ mError("dnode:%d, failed to drop since %s, vnodes:%d mnode:%d qnode:%d snode:%d", pDnode->id, tstrerror(code),
numOfVnodes, pMObj != NULL, pQObj != NULL, pSObj != NULL);
goto _OVER;
}
bool isEmpty = mndIsEmptyDnode(pMnode, pDnode->id);
if (!isonline && !force && !isEmpty) {
- terrno = TSDB_CODE_DNODE_OFFLINE;
- mError("dnode:%d, failed to drop since %s, vnodes:%d mnode:%d qnode:%d snode:%d", pDnode->id, terrstr(),
+ code = TSDB_CODE_DNODE_OFFLINE;
+ mError("dnode:%d, failed to drop since %s, vnodes:%d mnode:%d qnode:%d snode:%d", pDnode->id, tstrerror(code),
numOfVnodes, pMObj != NULL, pQObj != NULL, pSObj != NULL);
goto _OVER;
}
@@ -1279,7 +1299,7 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
_OVER:
if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
- mError("dnode:%d, failed to drop since %s", dropReq.dnodeId, terrstr());
+ mError("dnode:%d, failed to drop since %s", dropReq.dnodeId, tstrerror(code));
}
mndReleaseDnode(pMnode, pDnode);
@@ -1287,11 +1307,11 @@ _OVER:
mndReleaseQnode(pMnode, pQObj);
mndReleaseSnode(pMnode, pSObj);
tFreeSDropDnodeReq(&dropReq);
- return code;
+ TAOS_RETURN(code);
}
static int32_t mndMCfg2DCfg(SMCfgDnodeReq *pMCfgReq, SDCfgDnodeReq *pDCfgReq) {
- terrno = 0;
+ int32_t code = 0;
char *p = pMCfgReq->config;
while (*p) {
if (*p == ' ') {
@@ -1314,12 +1334,12 @@ static int32_t mndMCfg2DCfg(SMCfgDnodeReq *pMCfgReq, SDCfgDnodeReq *pDCfgReq) {
strcpy(pDCfgReq->value, pMCfgReq->value);
}
- return 0;
+ TAOS_RETURN(code);
_err:
mError("dnode:%d, failed to config since invalid conf:%s", pMCfgReq->dnodeId, pMCfgReq->config);
- terrno = TSDB_CODE_INVALID_CFG;
- return -1;
+ code = TSDB_CODE_INVALID_CFG;
+ TAOS_RETURN(code);
}
static int32_t mndSendCfgDnodeReq(SMnode *pMnode, int32_t dnodeId, SDCfgDnodeReq *pDcfgReq) {
@@ -1349,23 +1369,21 @@ static int32_t mndSendCfgDnodeReq(SMnode *pMnode, int32_t dnodeId, SDCfgDnodeReq
}
if (code == -1) {
- terrno = TSDB_CODE_MND_DNODE_NOT_EXIST;
+ code = TSDB_CODE_MND_DNODE_NOT_EXIST;
}
- return code;
+ TAOS_RETURN(code);
}
static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
+ int32_t code = 0;
SMnode *pMnode = pReq->info.node;
SMCfgDnodeReq cfgReq = {0};
- if (tDeserializeSMCfgDnodeReq(pReq->pCont, pReq->contLen, &cfgReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
- return -1;
- }
+ TAOS_CHECK_RETURN(tDeserializeSMCfgDnodeReq(pReq->pCont, pReq->contLen, &cfgReq));
int8_t updateIpWhiteList = 0;
mInfo("dnode:%d, start to config, option:%s, value:%s", cfgReq.dnodeId, cfgReq.config, cfgReq.value);
- if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CONFIG_DNODE) != 0) {
+ if ((code = mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CONFIG_DNODE)) != 0) {
tFreeSMCfgDnodeReq(&cfgReq);
- return -1;
+ TAOS_RETURN(code);
}
SDCfgDnodeReq dcfgReq = {0};
@@ -1381,26 +1399,26 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
if (flag > 1024 * 1024 || (flag > -1 && flag < 1024) || flag < -1) {
mError("dnode:%d, failed to config s3blocksize since value:%d. Valid range: -1 or [1024, 1024 * 1024]",
cfgReq.dnodeId, flag);
- terrno = TSDB_CODE_INVALID_CFG;
+ code = TSDB_CODE_INVALID_CFG;
tFreeSMCfgDnodeReq(&cfgReq);
- return -1;
+ TAOS_RETURN(code);
}
strcpy(dcfgReq.config, "s3blocksize");
snprintf(dcfgReq.value, TSDB_DNODE_VALUE_LEN, "%d", flag);
#endif
} else {
- if (mndMCfg2DCfg(&cfgReq, &dcfgReq)) goto _err_out;
+ TAOS_CHECK_GOTO (mndMCfg2DCfg(&cfgReq, &dcfgReq), NULL, _err_out);
if (strlen(dcfgReq.config) > TSDB_DNODE_CONFIG_LEN) {
mError("dnode:%d, failed to config since config is too long", cfgReq.dnodeId);
- terrno = TSDB_CODE_INVALID_CFG;
+ code = TSDB_CODE_INVALID_CFG;
goto _err_out;
}
if (strncasecmp(dcfgReq.config, "enableWhiteList", strlen("enableWhiteList")) == 0) {
updateIpWhiteList = 1;
}
- if (cfgCheckRangeForDynUpdate(taosGetCfg(), dcfgReq.config, dcfgReq.value, true) != 0) goto _err_out;
+ TAOS_CHECK_GOTO(cfgCheckRangeForDynUpdate(taosGetCfg(), dcfgReq.config, dcfgReq.value, true), NULL, _err_out);
}
{ // audit
@@ -1412,15 +1430,15 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
tFreeSMCfgDnodeReq(&cfgReq);
- int32_t code = mndSendCfgDnodeReq(pMnode, cfgReq.dnodeId, &dcfgReq);
+ code = mndSendCfgDnodeReq(pMnode, cfgReq.dnodeId, &dcfgReq);
// dont care suss or succ;
if (updateIpWhiteList) mndRefreshUserIpWhiteList(pMnode);
- return code;
+ TAOS_RETURN(code);
_err_out:
tFreeSMCfgDnodeReq(&cfgReq);
- return -1;
+ TAOS_RETURN(code);
}
static int32_t mndProcessConfigDnodeRsp(SRpcMsg *pRsp) {
@@ -1503,17 +1521,16 @@ _exit:
}
static int32_t mndProcessCreateEncryptKeyReq(SRpcMsg *pReq) {
+ int32_t code = 0;
+
#ifdef TD_ENTERPRISE
SMnode *pMnode = pReq->info.node;
SMCfgDnodeReq cfgReq = {0};
- if (tDeserializeSMCfgDnodeReq(pReq->pCont, pReq->contLen, &cfgReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
- return -1;
- }
+ TAOS_CHECK_RETURN(tDeserializeSMCfgDnodeReq(pReq->pCont, pReq->contLen, &cfgReq));
- if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CONFIG_DNODE) != 0) {
+ if ((code = mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CONFIG_DNODE)) != 0) {
tFreeSMCfgDnodeReq(&cfgReq);
- return -1;
+ TAOS_RETURN(code);
}
const STraceId *trace = &pReq->info.traceId;
SDCfgDnodeReq dcfgReq = {0};
@@ -1523,13 +1540,13 @@ static int32_t mndProcessCreateEncryptKeyReq(SRpcMsg *pReq) {
tFreeSMCfgDnodeReq(&cfgReq);
return mndProcessCreateEncryptKeyReqImpl(pReq, cfgReq.dnodeId, &dcfgReq);
} else {
- terrno = TSDB_CODE_PAR_INTERNAL_ERROR;
+ code = TSDB_CODE_PAR_INTERNAL_ERROR;
tFreeSMCfgDnodeReq(&cfgReq);
- return -1;
+ TAOS_RETURN(code);
}
#else
- return 0;
+ TAOS_RETURN(code);
#endif
}
@@ -1710,7 +1727,7 @@ static void mndCancelGetNextDnode(SMnode *pMnode, void *pIter) {
// get int32_t value from 'SMCfgDnodeReq'
static int32_t mndMCfgGetValInt32(SMCfgDnodeReq *pMCfgReq, int32_t optLen, int32_t *pOutValue) {
- terrno = 0;
+ int32_t code = 0;
if (' ' != pMCfgReq->config[optLen] && 0 != pMCfgReq->config[optLen]) {
goto _err;
}
@@ -1725,12 +1742,12 @@ static int32_t mndMCfgGetValInt32(SMCfgDnodeReq *pMCfgReq, int32_t optLen, int32
*pOutValue = atoi(pMCfgReq->value);
}
- return 0;
+ TAOS_RETURN(code);
_err:
mError("dnode:%d, failed to config since invalid conf:%s", pMCfgReq->dnodeId, pMCfgReq->config);
- terrno = TSDB_CODE_INVALID_CFG;
- return -1;
+ code = TSDB_CODE_INVALID_CFG;
+ TAOS_RETURN(code);
}
SArray *mndGetAllDnodeFqdns(SMnode *pMnode) {
diff --git a/source/dnode/mnode/impl/src/mndDump.c b/source/dnode/mnode/impl/src/mndDump.c
index 5561eea405..22dbc8eb57 100644
--- a/source/dnode/mnode/impl/src/mndDump.c
+++ b/source/dnode/mnode/impl/src/mndDump.c
@@ -29,12 +29,14 @@ void reportStartup(const char *name, const char *desc) {}
void sendRsp(SRpcMsg *pMsg) { rpcFreeCont(pMsg->pCont); }
int32_t sendReq(const SEpSet *pEpSet, SRpcMsg *pMsg) {
- terrno = TSDB_CODE_INVALID_PTR;
- return -1;
+ int32_t code = 0;
+ code = TSDB_CODE_INVALID_PTR;
+ TAOS_RETURN(code);
}
int32_t sendSyncReq(const SEpSet *pEpSet, SRpcMsg *pMsg) {
- terrno = TSDB_CODE_INVALID_PTR;
- return -1;
+ int32_t code = 0;
+ code = TSDB_CODE_INVALID_PTR;
+ TAOS_RETURN(code);
}
char *i642str(int64_t val) {
diff --git a/source/dnode/mnode/impl/src/mndFunc.c b/source/dnode/mnode/impl/src/mndFunc.c
index 333fdf83bb..5ad1c33015 100644
--- a/source/dnode/mnode/impl/src/mndFunc.c
+++ b/source/dnode/mnode/impl/src/mndFunc.c
@@ -223,6 +223,7 @@ static int32_t mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOld, SFuncObj *pNew) {
}
static SFuncObj *mndAcquireFunc(SMnode *pMnode, char *funcName) {
+ terrno = 0;
SSdb *pSdb = pMnode->pSdb;
SFuncObj *pFunc = sdbAcquire(pSdb, SDB_FUNC, funcName);
if (pFunc == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {
@@ -240,7 +241,7 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre
int32_t code = -1;
STrans *pTrans = NULL;
- if ((terrno = grantCheck(TSDB_GRANT_USER)) < 0) {
+ if ((code = grantCheck(TSDB_GRANT_USER)) < 0) {
return code;
}
@@ -260,7 +261,7 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre
func.codeSize = pCreate->codeLen;
func.pCode = taosMemoryMalloc(func.codeSize);
if (func.pCode == NULL || func.pCode == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto _OVER;
}
@@ -270,7 +271,11 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre
memcpy(func.pCode, pCreate->pCode, func.codeSize);
pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pReq, "create-func");
- if (pTrans == NULL) goto _OVER;
+ if (pTrans == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
mInfo("trans:%d, used to create func:%s", pTrans->id, pCreate->name);
SFuncObj *oldFunc = mndAcquireFunc(pMnode, pCreate->name);
@@ -279,31 +284,61 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre
func.createdTime = oldFunc->createdTime;
SSdbRaw *pRedoRaw = mndFuncActionEncode(oldFunc);
- if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER;
- if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY) != 0) goto _OVER;
+ if (pRedoRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendRedolog(pTrans, pRedoRaw), NULL, _OVER);
+ TAOS_CHECK_GOTO(sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY), NULL, _OVER);
SSdbRaw *pUndoRaw = mndFuncActionEncode(oldFunc);
- if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER;
- if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY) != 0) goto _OVER;
+ if (pUndoRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendUndolog(pTrans, pUndoRaw), NULL, _OVER);
+ TAOS_CHECK_GOTO(sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY), NULL, _OVER);
SSdbRaw *pCommitRaw = mndFuncActionEncode(&func);
- if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER;
- if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto _OVER;
+ if (pCommitRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pCommitRaw), NULL, _OVER);
+ TAOS_CHECK_GOTO(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY), NULL, _OVER);
} else {
SSdbRaw *pRedoRaw = mndFuncActionEncode(&func);
- if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER;
- if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) goto _OVER;
+ if (pRedoRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendRedolog(pTrans, pRedoRaw), NULL, _OVER);
+ TAOS_CHECK_GOTO(sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING), NULL, _OVER);
SSdbRaw *pUndoRaw = mndFuncActionEncode(&func);
- if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER;
- if (sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED) != 0) goto _OVER;
+ if (pUndoRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendUndolog(pTrans, pUndoRaw), NULL, _OVER);
+ TAOS_CHECK_GOTO(sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED), NULL, _OVER);
SSdbRaw *pCommitRaw = mndFuncActionEncode(&func);
- if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER;
- if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) goto _OVER;
+ if (pCommitRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pCommitRaw), NULL, _OVER);
+ TAOS_CHECK_GOTO(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY), NULL, _OVER);
}
- if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
code = 0;
@@ -315,32 +350,48 @@ _OVER:
taosMemoryFree(func.pCode);
taosMemoryFree(func.pComment);
mndTransDrop(pTrans);
- return code;
+ TAOS_RETURN(code);
}
static int32_t mndDropFunc(SMnode *pMnode, SRpcMsg *pReq, SFuncObj *pFunc) {
int32_t code = -1;
STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pReq, "drop-func");
- if (pTrans == NULL) goto _OVER;
+ if (pTrans == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
mInfo("trans:%d, used to drop user:%s", pTrans->id, pFunc->name);
SSdbRaw *pRedoRaw = mndFuncActionEncode(pFunc);
- if (pRedoRaw == NULL) goto _OVER;
- if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) goto _OVER;
+ if (pRedoRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendRedolog(pTrans, pRedoRaw), NULL, _OVER);
(void)sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING);
SSdbRaw *pUndoRaw = mndFuncActionEncode(pFunc);
- if (pUndoRaw == NULL) goto _OVER;
- if (mndTransAppendUndolog(pTrans, pUndoRaw) != 0) goto _OVER;
+ if (pUndoRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendUndolog(pTrans, pUndoRaw), NULL, _OVER);
(void)sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY);
SSdbRaw *pCommitRaw = mndFuncActionEncode(pFunc);
- if (pCommitRaw == NULL) goto _OVER;
- if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER;
+ if (pCommitRaw == NULL) {
+ code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+ if (terrno != 0) code = terrno;
+ goto _OVER;
+ }
+ TAOS_CHECK_GOTO(mndTransAppendCommitlog(pTrans, pCommitRaw), NULL, _OVER);
(void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
- if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+ TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
code = 0;
@@ -355,18 +406,14 @@ static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) {
SFuncObj *pFunc = NULL;
SCreateFuncReq createReq = {0};
- if (tDeserializeSCreateFuncReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
- goto _OVER;
- }
+ TAOS_CHECK_GOTO(tDeserializeSCreateFuncReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER);
+
#ifdef WINDOWS
- terrno = TSDB_CODE_MND_INVALID_PLATFORM;
+ code = TSDB_CODE_MND_INVALID_PLATFORM;
goto _OVER;
#endif
mInfo("func:%s, start to create, size:%d", createReq.name, createReq.codeLen);
- if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_FUNC) != 0) {
- goto _OVER;
- }
+ TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_FUNC), NULL, _OVER);
pFunc = mndAcquireFunc(pMnode, createReq.name);
if (pFunc != NULL) {
@@ -378,7 +425,7 @@ static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) {
mInfo("func:%s, replace function is set", createReq.name);
code = 0;
} else {
- terrno = TSDB_CODE_MND_FUNC_ALREADY_EXIST;
+ code = TSDB_CODE_MND_FUNC_ALREADY_EXIST;
goto _OVER;
}
} else if (terrno == TSDB_CODE_MND_FUNC_ALREADY_EXIST) {
@@ -386,22 +433,22 @@ static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) {
}
if (createReq.name[0] == 0) {
- terrno = TSDB_CODE_MND_INVALID_FUNC_NAME;
+ code = TSDB_CODE_MND_INVALID_FUNC_NAME;
goto _OVER;
}
if (createReq.pCode == NULL) {
- terrno = TSDB_CODE_MND_INVALID_FUNC_CODE;
+ code = TSDB_CODE_MND_INVALID_FUNC_CODE;
goto _OVER;
}
if (createReq.codeLen <= 1) {
- terrno = TSDB_CODE_MND_INVALID_FUNC_CODE;
+ code = TSDB_CODE_MND_INVALID_FUNC_CODE;
goto _OVER;
}
if (createReq.bufSize < 0 || createReq.bufSize > TSDB_FUNC_BUF_SIZE) {
- terrno = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
+ code = TSDB_CODE_MND_INVALID_FUNC_BUFSIZE;
goto _OVER;
}
@@ -410,12 +457,12 @@ static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) {
_OVER:
if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
- mError("func:%s, failed to create since %s", createReq.name, terrstr());
+ mError("func:%s, failed to create since %s", createReq.name, tstrerror(code));
}
mndReleaseFunc(pMnode, pFunc);
tFreeSCreateFuncReq(&createReq);
- return code;
+ TAOS_RETURN(code);
}
static int32_t mndProcessDropFuncReq(SRpcMsg *pReq) {
@@ -424,18 +471,13 @@ static int32_t mndProcessDropFuncReq(SRpcMsg *pReq) {
SFuncObj *pFunc = NULL;
SDropFuncReq dropReq = {0};
- if (tDeserializeSDropFuncReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
- goto _OVER;
- }
+ TAOS_CHECK_GOTO(tDeserializeSDropFuncReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER);
mInfo("func:%s, start to drop", dropReq.name);
- if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_FUNC) != 0) {
- goto _OVER;
- }
+ TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_FUNC), NULL, _OVER);
if (dropReq.name[0] == 0) {
- terrno = TSDB_CODE_MND_INVALID_FUNC_NAME;
+ code = TSDB_CODE_MND_INVALID_FUNC_NAME;
goto _OVER;
}
@@ -446,7 +488,7 @@ static int32_t mndProcessDropFuncReq(SRpcMsg *pReq) {
code = 0;
goto _OVER;
} else {
- terrno = TSDB_CODE_MND_FUNC_NOT_EXIST;
+ code = TSDB_CODE_MND_FUNC_NOT_EXIST;
goto _OVER;
}
}
@@ -456,11 +498,11 @@ static int32_t mndProcessDropFuncReq(SRpcMsg *pReq) {
_OVER:
if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
- mError("func:%s, failed to drop since %s", dropReq.name, terrstr());
+ mError("func:%s, failed to drop since %s", dropReq.name, tstrerror(code));
}
mndReleaseFunc(pMnode, pFunc);
- return code;
+ TAOS_RETURN(code);
}
static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) {
@@ -470,25 +512,25 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) {
SRetrieveFuncRsp retrieveRsp = {0};
if (tDeserializeSRetrieveFuncReq(pReq->pCont, pReq->contLen, &retrieveReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
+ code = TSDB_CODE_INVALID_MSG;
goto RETRIEVE_FUNC_OVER;
}
if (retrieveReq.numOfFuncs <= 0 || retrieveReq.numOfFuncs > TSDB_FUNC_MAX_RETRIEVE) {
- terrno = TSDB_CODE_MND_INVALID_FUNC_RETRIEVE;
+ code = TSDB_CODE_MND_INVALID_FUNC_RETRIEVE;
goto RETRIEVE_FUNC_OVER;
}
retrieveRsp.numOfFuncs = retrieveReq.numOfFuncs;
retrieveRsp.pFuncInfos = taosArrayInit(retrieveReq.numOfFuncs, sizeof(SFuncInfo));
if (retrieveRsp.pFuncInfos == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto RETRIEVE_FUNC_OVER;
}
retrieveRsp.pFuncExtraInfos = taosArrayInit(retrieveReq.numOfFuncs, sizeof(SFuncExtraInfo));
if (retrieveRsp.pFuncExtraInfos == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto RETRIEVE_FUNC_OVER;
}
@@ -497,6 +539,7 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) {
SFuncObj *pFunc = mndAcquireFunc(pMnode, funcName);
if (pFunc == NULL) {
+ if (terrno != 0) code = terrno;
goto RETRIEVE_FUNC_OVER;
}
@@ -541,7 +584,7 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) {
int32_t contLen = tSerializeSRetrieveFuncRsp(NULL, 0, &retrieveRsp);
void *pRsp = rpcMallocCont(contLen);
if (pRsp == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto RETRIEVE_FUNC_OVER;
}
@@ -556,7 +599,7 @@ RETRIEVE_FUNC_OVER:
tFreeSRetrieveFuncReq(&retrieveReq);
tFreeSRetrieveFuncRsp(&retrieveRsp);
- return code;
+ TAOS_RETURN(code);
}
static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int32_t len) {
diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c
index 7b98378725..906d6aba28 100644
--- a/source/dnode/mnode/impl/src/mndMain.c
+++ b/source/dnode/mnode/impl/src/mndMain.c
@@ -457,7 +457,7 @@ static int32_t mndCreateDir(SMnode *pMnode, const char *path) {
}
if (taosMkDir(pMnode->path) != 0) {
- code = TAOS_SYSTEM_ERROR(errno);
+ code = terrno;
TAOS_RETURN(code);
}
diff --git a/source/dnode/mnode/impl/src/mndScheduler.c b/source/dnode/mnode/impl/src/mndScheduler.c
index 155975d580..3593e21e11 100644
--- a/source/dnode/mnode/impl/src/mndScheduler.c
+++ b/source/dnode/mnode/impl/src/mndScheduler.c
@@ -771,21 +771,22 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
if (pTopic->subType == TOPIC_SUB_TYPE__COLUMN) {
pPlan = qStringToQueryPlan(pTopic->physicalPlan);
if (pPlan == NULL) {
- code = TSDB_CODE_QRY_INVALID_INPUT;
- TAOS_RETURN(code);
+ return TSDB_CODE_QRY_INVALID_INPUT;
}
} else if (pTopic->subType == TOPIC_SUB_TYPE__TABLE && pTopic->ast != NULL) {
SNode* pAst = NULL;
- if ((code = nodesStringToNode(pTopic->ast, &pAst)) != 0) {
+ code = nodesStringToNode(pTopic->ast, &pAst);
+ if (code != 0) {
mError("topic:%s, failed to create since %s", pTopic->name, terrstr());
- TAOS_RETURN(code);
+ return code;
}
SPlanContext cxt = {.pAstRoot = pAst, .topicQuery = true};
- if ((code = qCreateQueryPlan(&cxt, &pPlan, NULL)) != 0) {
+ code = qCreateQueryPlan(&cxt, &pPlan, NULL);
+ if (code != 0) {
mError("failed to create topic:%s since %s", pTopic->name, terrstr());
nodesDestroyNode(pAst);
- TAOS_RETURN(code);
+ return code;
}
nodesDestroyNode(pAst);
}
@@ -793,18 +794,19 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
if (pPlan) {
int32_t levelNum = LIST_LENGTH(pPlan->pSubplans);
if (levelNum != 1) {
- qDestroyQueryPlan(pPlan);
code = TSDB_CODE_MND_INVALID_TOPIC_QUERY;
- TAOS_RETURN(code);
+ goto END;
}
SNodeListNode* pNodeListNode = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0);
-
+ if (pNodeListNode == NULL){
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto END;
+ }
int32_t opNum = LIST_LENGTH(pNodeListNode->pNodeList);
if (opNum != 1) {
- qDestroyQueryPlan(pPlan);
code = TSDB_CODE_MND_INVALID_TOPIC_QUERY;
- TAOS_RETURN(code);
+ goto END;
}
pSubplan = (SSubplan*)nodesListGetNode(pNodeListNode->pNodeList, 0);
@@ -825,12 +827,18 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
pSub->vgNum++;
SMqVgEp* pVgEp = taosMemoryMalloc(sizeof(SMqVgEp));
+ if (pVgEp == NULL){
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto END;
+ }
pVgEp->epSet = mndGetVgroupEpset(pMnode, pVgroup);
pVgEp->vgId = pVgroup->vgId;
- taosArrayPush(pSub->unassignedVgs, &pVgEp);
-
+ if (taosArrayPush(pSub->unassignedVgs, &pVgEp) == NULL){
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ taosMemoryFree(pVgEp);
+ goto END;
+ }
mInfo("init subscription %s for topic:%s assign vgId:%d", pSub->key, pTopic->name, pVgEp->vgId);
-
sdbRelease(pSdb, pVgroup);
}
@@ -838,14 +846,14 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
int32_t msgLen;
if (qSubPlanToString(pSubplan, &pSub->qmsg, &msgLen) < 0) {
- qDestroyQueryPlan(pPlan);
code = TSDB_CODE_QRY_INVALID_INPUT;
- TAOS_RETURN(code);
+ goto END;
}
} else {
pSub->qmsg = taosStrdup("");
}
+END:
qDestroyQueryPlan(pPlan);
- TAOS_RETURN(code);
+ return code;
}
diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c
index c61949b316..a110d442cf 100644
--- a/source/dnode/mnode/impl/src/mndSubscribe.c
+++ b/source/dnode/mnode/impl/src/mndSubscribe.c
@@ -41,19 +41,21 @@ static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg);
static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg);
static int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
static void mndCancelGetNextSubscribe(SMnode *pMnode, void *pIter);
-static void mndCheckConsumer(SRpcMsg *pMsg, SHashObj *hash);
+static int32_t mndCheckConsumer(SRpcMsg *pMsg, SHashObj *hash);
static int32_t mndSetSubCommitLogs(STrans *pTrans, SMqSubscribeObj *pSub) {
int32_t code = 0;
SSdbRaw *pCommitRaw = mndSubActionEncode(pSub);
- if (pCommitRaw == NULL) {
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- TAOS_RETURN(code);
+ MND_TMQ_NULL_CHECK(pCommitRaw);
+ code = mndTransAppendCommitlog(pTrans, pCommitRaw);
+ if (code != 0) {
+ sdbFreeRaw(pCommitRaw);
+ goto END;
}
- TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));
- TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));
- TAOS_RETURN(code);
+ code = sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
+
+END:
+ return code;
}
int32_t mndInitSubscribe(SMnode *pMnode) {
@@ -79,43 +81,37 @@ int32_t mndInitSubscribe(SMnode *pMnode) {
return sdbSetTable(pMnode->pSdb, table);
}
-static SMqSubscribeObj *mndCreateSubscription(SMnode *pMnode, const SMqTopicObj *pTopic, const char *subKey) {
- int32_t code = 0;
- SMqSubscribeObj *pSub = tNewSubscribeObj(subKey);
- if (pSub == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return NULL;
- }
+static int32_t mndCreateSubscription(SMnode *pMnode, const SMqTopicObj *pTopic, const char *subKey, SMqSubscribeObj** pSub) {
+ int32_t code = 0;
+ MND_TMQ_RETURN_CHECK(tNewSubscribeObj(subKey, pSub));
+ (*pSub)->dbUid = pTopic->dbUid;
+ (*pSub)->stbUid = pTopic->stbUid;
+ (*pSub)->subType = pTopic->subType;
+ (*pSub)->withMeta = pTopic->withMeta;
- pSub->dbUid = pTopic->dbUid;
- pSub->stbUid = pTopic->stbUid;
- pSub->subType = pTopic->subType;
- pSub->withMeta = pTopic->withMeta;
+ MND_TMQ_RETURN_CHECK(mndSchedInitSubEp(pMnode, pTopic, *pSub));
+ return code;
- if ((terrno = mndSchedInitSubEp(pMnode, pTopic, pSub)) < 0) {
- tDeleteSubscribeObj(pSub);
- taosMemoryFree(pSub);
- return NULL;
- }
-
- return pSub;
+END:
+ tDeleteSubscribeObj(*pSub);
+ taosMemoryFree(*pSub);
+ return code;
}
static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj *pSub, const SMqRebOutputVg *pRebVg,
SSubplan *pPlan) {
- int32_t code = 0;
SMqRebVgReq req = {0};
+ int32_t code = 0;
+ SEncoder encoder = {0};
+
req.oldConsumerId = pRebVg->oldConsumerId;
req.newConsumerId = pRebVg->newConsumerId;
req.vgId = pRebVg->pVgEp->vgId;
if (pPlan) {
pPlan->execNode.epSet = pRebVg->pVgEp->epSet;
pPlan->execNode.nodeId = pRebVg->pVgEp->vgId;
- int32_t msgLen;
- if (qSubPlanToString(pPlan, &req.qmsg, &msgLen) < 0) {
- code = TSDB_CODE_QRY_INVALID_INPUT;
- TAOS_RETURN(code);
- }
+ int32_t msgLen = 0;
+ MND_TMQ_RETURN_CHECK(qSubPlanToString(pPlan, &req.qmsg, &msgLen));
} else {
req.qmsg = taosStrdup("");
}
@@ -125,63 +121,47 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj
tstrncpy(req.subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
int32_t tlen = 0;
- int32_t ret = 0;
- tEncodeSize(tEncodeSMqRebVgReq, &req, tlen, ret);
- if (ret < 0) {
- taosMemoryFree(req.qmsg);
- TAOS_RETURN(ret);
+ tEncodeSize(tEncodeSMqRebVgReq, &req, tlen, code);
+ if (code < 0) {
+ goto END;
}
tlen += sizeof(SMsgHead);
void *buf = taosMemoryMalloc(tlen);
- if (buf == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- taosMemoryFree(req.qmsg);
- TAOS_RETURN(ret);
- }
-
+ MND_TMQ_NULL_CHECK(buf);
SMsgHead *pMsgHead = (SMsgHead *)buf;
-
pMsgHead->contLen = htonl(tlen);
pMsgHead->vgId = htonl(pRebVg->pVgEp->vgId);
- SEncoder encoder = {0};
tEncoderInit(&encoder, POINTER_SHIFT(buf, sizeof(SMsgHead)), tlen);
- if ((code = tEncodeSMqRebVgReq(&encoder, &req)) < 0) {
- taosMemoryFreeClear(buf);
- tEncoderClear(&encoder);
- taosMemoryFree(req.qmsg);
- TAOS_RETURN(code);
- }
- tEncoderClear(&encoder);
+ MND_TMQ_RETURN_CHECK(tEncodeSMqRebVgReq(&encoder, &req));
*pBuf = buf;
*pLen = tlen;
+END:
+ tEncoderClear(&encoder);
taosMemoryFree(req.qmsg);
- TAOS_RETURN(code);
+ return code;
}
static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub,
const SMqRebOutputVg *pRebVg, SSubplan *pPlan) {
int32_t code = 0;
+ void *buf = NULL;
+
if (pRebVg->oldConsumerId == pRebVg->newConsumerId) {
if (pRebVg->oldConsumerId == -1) return 0; // drop stream, no consumer, while split vnode,all consumerId is -1
code = TSDB_CODE_MND_INVALID_SUB_OPTION;
- TAOS_RETURN(code);
- }
-
- void *buf;
- int32_t tlen;
- if ((code = mndBuildSubChangeReq(&buf, &tlen, pSub, pRebVg, pPlan)) < 0) {
- TAOS_RETURN(code);
+ goto END;
}
+ int32_t tlen = 0;
+ MND_TMQ_RETURN_CHECK(mndBuildSubChangeReq(&buf, &tlen, pSub, pRebVg, pPlan));
int32_t vgId = pRebVg->pVgEp->vgId;
SVgObj *pVgObj = mndAcquireVgroup(pMnode, vgId);
if (pVgObj == NULL) {
- taosMemoryFree(buf);
code = TSDB_CODE_MND_VGROUP_NOT_EXIST;
- TAOS_RETURN(code);
+ goto END;
}
STransAction action = {0};
@@ -191,72 +171,87 @@ static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, SMqSubsc
action.msgType = TDMT_VND_TMQ_SUBSCRIBE;
mndReleaseVgroup(pMnode, pVgObj);
- if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
- taosMemoryFree(buf);
- TAOS_RETURN(code);
- }
- TAOS_RETURN(code);
+ MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action));
+ return code;
+
+END:
+ taosMemoryFree(buf);
+ return code;
}
-static int32_t mndSplitSubscribeKey(const char *key, char *topic, char *cgroup, bool fullName) {
+static void mndSplitSubscribeKey(const char *key, char *topic, char *cgroup, bool fullName) {
int32_t i = 0;
- while (key[i] != TMQ_SEPARATOR) {
+ while (key[i] != TMQ_SEPARATOR_CHAR) {
i++;
}
- memcpy(cgroup, key, i);
+ (void)memcpy(cgroup, key, i);
cgroup[i] = 0;
if (fullName) {
- strcpy(topic, &key[i + 1]);
+ (void)strcpy(topic, &key[i + 1]);
} else {
while (key[i] != '.') {
i++;
}
- strcpy(topic, &key[i + 1]);
+ (void)strcpy(topic, &key[i + 1]);
}
- return 0;
}
-static SMqRebInfo *mndGetOrCreateRebSub(SHashObj *pHash, const char *key) {
- terrno = 0;
- SMqRebInfo *pRebInfo = taosHashGet(pHash, key, strlen(key) + 1);
+static int32_t mndGetOrCreateRebSub(SHashObj *pHash, const char *key, SMqRebInfo **pReb) {
+ int32_t code = 0;
+ SMqRebInfo* pRebInfo = taosHashGet(pHash, key, strlen(key) + 1);
if (pRebInfo == NULL) {
pRebInfo = tNewSMqRebSubscribe(key);
if (pRebInfo == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return NULL;
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto END;
+ }
+ code = taosHashPut(pHash, key, strlen(key) + 1, pRebInfo, sizeof(SMqRebInfo));
+ taosMemoryFreeClear(pRebInfo);
+ if (code != 0) {
+ goto END;
}
- taosHashPut(pHash, key, strlen(key) + 1, pRebInfo, sizeof(SMqRebInfo));
- taosMemoryFree(pRebInfo);
pRebInfo = taosHashGet(pHash, key, strlen(key) + 1);
+ MND_TMQ_NULL_CHECK(pRebInfo);
}
- return pRebInfo;
+ if (pReb){
+ *pReb = pRebInfo;
+ }
+
+END:
+ return code;
}
-static void pushVgDataToHash(SArray *vgs, SHashObj *pHash, int64_t consumerId, char *key) {
- SMqVgEp *pVgEp = *(SMqVgEp **)taosArrayPop(vgs);
- SMqRebOutputVg outputVg = {consumerId, -1, pVgEp};
- taosHashPut(pHash, &pVgEp->vgId, sizeof(int32_t), &outputVg, sizeof(SMqRebOutputVg));
- mInfo("[rebalance] sub:%s mq rebalance remove vgId:%d from consumer:0x%" PRIx64, key, pVgEp->vgId, consumerId);
+static int32_t pushVgDataToHash(SArray *vgs, SHashObj *pHash, int64_t consumerId, char *key) {
+ int32_t code = 0;
+ SMqVgEp **pVgEp = (SMqVgEp **)taosArrayPop(vgs);
+ MND_TMQ_NULL_CHECK(pVgEp);
+ SMqRebOutputVg outputVg = {consumerId, -1, *pVgEp};
+ MND_TMQ_RETURN_CHECK(taosHashPut(pHash, &(*pVgEp)->vgId, sizeof(int32_t), &outputVg, sizeof(SMqRebOutputVg)));
+ mInfo("[rebalance] sub:%s mq rebalance remove vgId:%d from consumer:0x%" PRIx64, key, (*pVgEp)->vgId, consumerId);
+END:
+ return code;
}
-static void processRemovedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, const SMqRebInputObj *pInput) {
+static int32_t processRemovedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, const SMqRebInputObj *pInput) {
+ int32_t code = 0;
int32_t numOfRemoved = taosArrayGetSize(pInput->pRebInfo->removedConsumers);
int32_t actualRemoved = 0;
for (int32_t i = 0; i < numOfRemoved; i++) {
- uint64_t consumerId = *(uint64_t *)taosArrayGet(pInput->pRebInfo->removedConsumers, i);
- SMqConsumerEp *pConsumerEp = taosHashGet(pOutput->pSub->consumerHash, &consumerId, sizeof(int64_t));
+ int64_t* consumerId = (int64_t *)taosArrayGet(pInput->pRebInfo->removedConsumers, i);
+ MND_TMQ_NULL_CHECK(consumerId);
+ SMqConsumerEp *pConsumerEp = taosHashGet(pOutput->pSub->consumerHash, consumerId, sizeof(int64_t));
if (pConsumerEp == NULL) {
continue;
}
int32_t consumerVgNum = taosArrayGetSize(pConsumerEp->vgs);
for (int32_t j = 0; j < consumerVgNum; j++) {
- pushVgDataToHash(pConsumerEp->vgs, pHash, consumerId, pOutput->pSub->key);
+ MND_TMQ_RETURN_CHECK(pushVgDataToHash(pConsumerEp->vgs, pHash, *consumerId, pOutput->pSub->key));
}
- taosArrayDestroy(pConsumerEp->vgs);
- taosHashRemove(pOutput->pSub->consumerHash, &consumerId, sizeof(int64_t));
- taosArrayPush(pOutput->removedConsumers, &consumerId);
+ (void)taosArrayDestroy(pConsumerEp->vgs);
+ MND_TMQ_RETURN_CHECK(taosHashRemove(pOutput->pSub->consumerHash, consumerId, sizeof(int64_t)));
+ MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->removedConsumers, consumerId));
actualRemoved++;
}
@@ -266,45 +261,42 @@ static void processRemovedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, c
} else {
mInfo("[rebalance] sub:%s removed %d consumers", pOutput->pSub->key, numOfRemoved);
}
+END:
+ return code;
}
-static void processNewConsumers(SMqRebOutputObj *pOutput, const SMqRebInputObj *pInput) {
+static int32_t processNewConsumers(SMqRebOutputObj *pOutput, const SMqRebInputObj *pInput) {
+ int32_t code = 0;
int32_t numOfNewConsumers = taosArrayGetSize(pInput->pRebInfo->newConsumers);
for (int32_t i = 0; i < numOfNewConsumers; i++) {
- int64_t consumerId = *(int64_t *)taosArrayGet(pInput->pRebInfo->newConsumers, i);
-
+ int64_t* consumerId = (int64_t *)taosArrayGet(pInput->pRebInfo->newConsumers, i);
+ MND_TMQ_NULL_CHECK(consumerId);
SMqConsumerEp newConsumerEp = {0};
- newConsumerEp.consumerId = consumerId;
+ newConsumerEp.consumerId = *consumerId;
newConsumerEp.vgs = taosArrayInit(0, sizeof(void *));
-
- taosHashPut(pOutput->pSub->consumerHash, &consumerId, sizeof(int64_t), &newConsumerEp, sizeof(SMqConsumerEp));
- taosArrayPush(pOutput->newConsumers, &consumerId);
- mInfo("[rebalance] sub:%s mq rebalance add new consumer:0x%" PRIx64, pOutput->pSub->key, consumerId);
+ MND_TMQ_NULL_CHECK(newConsumerEp.vgs);
+ MND_TMQ_RETURN_CHECK(taosHashPut(pOutput->pSub->consumerHash, consumerId, sizeof(int64_t), &newConsumerEp, sizeof(SMqConsumerEp)));
+ MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->newConsumers, consumerId));
+ mInfo("[rebalance] sub:%s mq rebalance add new consumer:0x%" PRIx64, pOutput->pSub->key, *consumerId);
}
+END:
+ return code;
}
-static void processUnassignedVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash) {
+static int32_t processUnassignedVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash) {
+ int32_t code = 0;
int32_t numOfVgroups = taosArrayGetSize(pOutput->pSub->unassignedVgs);
for (int32_t i = 0; i < numOfVgroups; i++) {
- pushVgDataToHash(pOutput->pSub->unassignedVgs, pHash, -1, pOutput->pSub->key);
+ MND_TMQ_RETURN_CHECK(pushVgDataToHash(pOutput->pSub->unassignedVgs, pHash, -1, pOutput->pSub->key));
}
+END:
+ return code;
}
-// static void putNoTransferToOutput(SMqRebOutputObj *pOutput, SMqConsumerEp *pConsumerEp){
-// for(int i = 0; i < taosArrayGetSize(pConsumerEp->vgs); i++){
-// SMqVgEp *pVgEp = (SMqVgEp *)taosArrayGetP(pConsumerEp->vgs, i);
-// SMqRebOutputVg outputVg = {
-// .oldConsumerId = pConsumerEp->consumerId,
-// .newConsumerId = pConsumerEp->consumerId,
-// .pVgEp = pVgEp,
-// };
-// taosArrayPush(pOutput->rebVgs, &outputVg);
-// }
-// }
-
-static void processModifiedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt,
+static int32_t processModifiedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt,
int32_t remainderVgCnt) {
+ int32_t code = 0;
int32_t cnt = 0;
void *pIter = NULL;
@@ -317,28 +309,31 @@ static void processModifiedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash,
SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;
int32_t consumerVgNum = taosArrayGetSize(pConsumerEp->vgs);
- taosArrayPush(pOutput->modifyConsumers, &pConsumerEp->consumerId);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->modifyConsumers, &pConsumerEp->consumerId));
if (consumerVgNum > minVgCnt) {
if (cnt < remainderVgCnt) {
while (taosArrayGetSize(pConsumerEp->vgs) > minVgCnt + 1) { // pop until equal minVg + 1
- pushVgDataToHash(pConsumerEp->vgs, pHash, pConsumerEp->consumerId, pOutput->pSub->key);
+ MND_TMQ_RETURN_CHECK(pushVgDataToHash(pConsumerEp->vgs, pHash, pConsumerEp->consumerId, pOutput->pSub->key));
}
cnt++;
} else {
while (taosArrayGetSize(pConsumerEp->vgs) > minVgCnt) {
- pushVgDataToHash(pConsumerEp->vgs, pHash, pConsumerEp->consumerId, pOutput->pSub->key);
+ MND_TMQ_RETURN_CHECK(pushVgDataToHash(pConsumerEp->vgs, pHash, pConsumerEp->consumerId, pOutput->pSub->key));
}
}
}
- // putNoTransferToOutput(pOutput, pConsumerEp);
}
+END:
+ return code;
}
static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput) {
+ int32_t code = 0;
int32_t totalVgNum = 0;
SVgObj *pVgroup = NULL;
void *pIter = NULL;
SArray *newVgs = taosArrayInit(0, POINTER_BYTES);
+ MND_TMQ_NULL_CHECK(newVgs);
while (1) {
pIter = sdbFetch(pMnode->pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);
if (pIter == NULL) {
@@ -352,9 +347,10 @@ static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput) {
totalVgNum++;
SMqVgEp *pVgEp = taosMemoryMalloc(sizeof(SMqVgEp));
+ MND_TMQ_NULL_CHECK(pVgEp);
pVgEp->epSet = mndGetVgroupEpset(pMnode, pVgroup);
pVgEp->vgId = pVgroup->vgId;
- taosArrayPush(newVgs, &pVgEp);
+ MND_TMQ_NULL_CHECK(taosArrayPush(newVgs, &pVgEp));
sdbRelease(pMnode->pSdb, pVgroup);
}
@@ -363,13 +359,14 @@ static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput) {
pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter);
if (pIter == NULL) break;
SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;
-
int32_t j = 0;
while (j < taosArrayGetSize(pConsumerEp->vgs)) {
SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j);
+ MND_TMQ_NULL_CHECK(pVgEp);
bool find = false;
for (int32_t k = 0; k < taosArrayGetSize(newVgs); k++) {
SMqVgEp *pnewVgEp = taosArrayGetP(newVgs, k);
+ MND_TMQ_NULL_CHECK(pnewVgEp);
if (pVgEp->vgId == pnewVgEp->vgId) {
tDeleteSMqVgEp(pnewVgEp);
taosArrayRemove(newVgs, k);
@@ -388,23 +385,31 @@ static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput) {
}
if (taosArrayGetSize(pOutput->pSub->unassignedVgs) == 0 && taosArrayGetSize(newVgs) != 0) {
- taosArrayAddAll(pOutput->pSub->unassignedVgs, newVgs);
+ MND_TMQ_NULL_CHECK(taosArrayAddAll(pOutput->pSub->unassignedVgs, newVgs));
mInfo("[rebalance] processRemoveAddVgs add new vg num:%d", (int)taosArrayGetSize(newVgs));
- taosArrayDestroy(newVgs);
+ (void)taosArrayDestroy(newVgs);
} else {
- taosArrayDestroyP(newVgs, (FDelete)tDeleteSMqVgEp);
+ (void)taosArrayDestroyP(newVgs, (FDelete)tDeleteSMqVgEp);
}
return totalVgNum;
+END:
+ return code;
}
-static void processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) {
- SMqSubscribeObj *pSub = mndAcquireSubscribeByKey(pMnode, pInput->pRebInfo->key); // put all offset rows
- if (pSub == NULL) {
- return;
+static int32_t processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) {
+ SMqSubscribeObj *pSub = NULL;
+ int32_t code = mndAcquireSubscribeByKey(pMnode, pInput->pRebInfo->key, &pSub); // put all offset rows
+ if( code != 0){
+ return 0;
}
taosRLockLatch(&pSub->lock);
if (pOutput->pSub->offsetRows == NULL) {
pOutput->pSub->offsetRows = taosArrayInit(4, sizeof(OffsetRows));
+ if(pOutput->pSub->offsetRows == NULL) {
+ taosRUnLockLatch(&pSub->lock);
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto END;
+ }
}
void *pIter = NULL;
while (1) {
@@ -415,9 +420,11 @@ static void processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, S
for (int j = 0; j < taosArrayGetSize(pConsumerEp->offsetRows); j++) {
OffsetRows *d1 = taosArrayGet(pConsumerEp->offsetRows, j);
+ MND_TMQ_NULL_CHECK(d1);
bool jump = false;
for (int i = 0; pConsumerEpNew && i < taosArrayGetSize(pConsumerEpNew->vgs); i++) {
SMqVgEp *pVgEp = taosArrayGetP(pConsumerEpNew->vgs, i);
+ MND_TMQ_NULL_CHECK(pVgEp);
if (pVgEp->vgId == d1->vgId) {
jump = true;
mInfo("pSub->offsetRows jump, because consumer id:0x%" PRIx64 " and vgId:%d not change",
@@ -429,6 +436,7 @@ static void processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, S
bool find = false;
for (int i = 0; i < taosArrayGetSize(pOutput->pSub->offsetRows); i++) {
OffsetRows *d2 = taosArrayGet(pOutput->pSub->offsetRows, i);
+ MND_TMQ_NULL_CHECK(d2);
if (d1->vgId == d2->vgId) {
d2->rows += d1->rows;
d2->offset = d1->offset;
@@ -439,18 +447,22 @@ static void processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, S
}
}
if (!find) {
- taosArrayPush(pOutput->pSub->offsetRows, d1);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->pSub->offsetRows, d1));
}
}
}
taosRUnLockLatch(&pSub->lock);
mndReleaseSubscribe(pMnode, pSub);
+
+END:
+ return code;
}
static void printRebalanceLog(SMqRebOutputObj *pOutput) {
mInfo("sub:%s mq rebalance calculation completed, re-balanced vg", pOutput->pSub->key);
for (int32_t i = 0; i < taosArrayGetSize(pOutput->rebVgs); i++) {
SMqRebOutputVg *pOutputRebVg = taosArrayGet(pOutput->rebVgs, i);
+ if (pOutputRebVg == NULL) continue;
mInfo("sub:%s mq rebalance vgId:%d, moved from consumer:0x%" PRIx64 ", to consumer:0x%" PRIx64, pOutput->pSub->key,
pOutputRebVg->pVgEp->vgId, pOutputRebVg->oldConsumerId, pOutputRebVg->newConsumerId);
}
@@ -465,6 +477,7 @@ static void printRebalanceLog(SMqRebOutputObj *pOutput) {
pConsumerEp->consumerId, sz);
for (int32_t i = 0; i < sz; i++) {
SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, i);
+ if (pVgEp == NULL) continue;
mInfo("sub:%s mq rebalance final cfg: vg %d to consumer:0x%" PRIx64, pOutput->pSub->key, pVgEp->vgId,
pConsumerEp->consumerId);
}
@@ -489,10 +502,11 @@ static void calcVgroupsCnt(const SMqRebInputObj *pInput, int32_t totalVgNum, con
pSubKey, totalVgNum, pInput->oldConsumerNum, numOfAdded, numOfRemoved, *minVgCnt, *remainderVgCnt);
}
-static void assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt) {
+static int32_t assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt) {
SMqRebOutputVg *pRebVg = NULL;
void *pAssignIter = NULL;
void *pIter = NULL;
+ int32_t code = 0;
while (1) {
pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter);
@@ -509,7 +523,7 @@ static void assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t min
pRebVg = (SMqRebOutputVg *)pAssignIter;
pRebVg->newConsumerId = pConsumerEp->consumerId;
- taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp));
mInfo("[rebalance] mq rebalance: add vgId:%d to consumer:0x%" PRIx64 " for average", pRebVg->pVgEp->vgId,
pConsumerEp->consumerId);
}
@@ -530,7 +544,7 @@ static void assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t min
pRebVg = (SMqRebOutputVg *)pAssignIter;
pRebVg->newConsumerId = pConsumerEp->consumerId;
- taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp));
mInfo("[rebalance] mq rebalance: add vgId:%d to consumer:0x%" PRIx64 " for average + 1", pRebVg->pVgEp->vgId,
pConsumerEp->consumerId);
}
@@ -539,6 +553,8 @@ static void assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t min
taosHashCancelIterate(pOutput->pSub->consumerHash, pIter);
if (pAssignIter != NULL) {
mError("[rebalance]sub:%s assign iter is not NULL, never should reach here", pOutput->pSub->key);
+ code = TSDB_CODE_PAR_INTERNAL_ERROR;
+ goto END;
}
while (1) {
pAssignIter = taosHashIterate(pHash, pAssignIter);
@@ -547,30 +563,39 @@ static void assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t min
}
SMqRebOutputVg *pRebOutput = (SMqRebOutputVg *)pAssignIter;
- taosArrayPush(pOutput->rebVgs, pRebOutput);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->rebVgs, pRebOutput));
if (taosHashGetSize(pOutput->pSub->consumerHash) == 0) { // if all consumer is removed
- taosArrayPush(pOutput->pSub->unassignedVgs, &pRebOutput->pVgEp); // put all vg into unassigned
+ MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->pSub->unassignedVgs, &pRebOutput->pVgEp)); // put all vg into unassigned
}
}
+
+END:
+ return code;
}
-static void mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) {
+static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) {
int32_t totalVgNum = processRemoveAddVgs(pMnode, pOutput);
+ if (totalVgNum < 0){
+ return totalVgNum;
+ }
const char *pSubKey = pOutput->pSub->key;
int32_t minVgCnt = 0;
int32_t remainderVgCnt = 0;
-
- SHashObj *pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
-
- processRemovedConsumers(pOutput, pHash, pInput);
- processUnassignedVgroups(pOutput, pHash);
+ int32_t code = 0;
+ SHashObj *pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
+ MND_TMQ_NULL_CHECK(pHash);
+ MND_TMQ_RETURN_CHECK(processRemovedConsumers(pOutput, pHash, pInput));
+ MND_TMQ_RETURN_CHECK(processUnassignedVgroups(pOutput, pHash));
calcVgroupsCnt(pInput, totalVgNum, pSubKey, &minVgCnt, &remainderVgCnt);
- processModifiedConsumers(pOutput, pHash, minVgCnt, remainderVgCnt);
- processNewConsumers(pOutput, pInput);
- assignVgroups(pOutput, pHash, minVgCnt);
- processSubOffsetRows(pMnode, pInput, pOutput);
+ MND_TMQ_RETURN_CHECK(processModifiedConsumers(pOutput, pHash, minVgCnt, remainderVgCnt));
+ MND_TMQ_RETURN_CHECK(processNewConsumers(pOutput, pInput));
+ MND_TMQ_RETURN_CHECK(assignVgroups(pOutput, pHash, minVgCnt));
+ MND_TMQ_RETURN_CHECK(processSubOffsetRows(pMnode, pInput, pOutput));
printRebalanceLog(pOutput);
taosHashCleanup(pHash);
+
+END:
+ return code;
}
static int32_t presistConsumerByType(STrans *pTrans, SArray *consumers, int8_t type, char *cgroup, char *topic) {
@@ -578,18 +603,10 @@ static int32_t presistConsumerByType(STrans *pTrans, SArray *consumers, int8_t t
SMqConsumerObj *pConsumerNew = NULL;
int32_t consumerNum = taosArrayGetSize(consumers);
for (int32_t i = 0; i < consumerNum; i++) {
- int64_t consumerId = *(int64_t *)taosArrayGet(consumers, i);
- pConsumerNew = tNewSMqConsumerObj(consumerId, cgroup, type, topic, NULL);
- if (pConsumerNew == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto END;
- }
-
- code = mndSetConsumerCommitLogs(pTrans, pConsumerNew);
- if (code != 0) {
- goto END;
- }
-
+ int64_t* consumerId = (int64_t *)taosArrayGet(consumers, i);
+ MND_TMQ_NULL_CHECK(consumerId);
+ MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(*consumerId, cgroup, type, topic, NULL, &pConsumerNew));
+ MND_TMQ_RETURN_CHECK(mndSetConsumerCommitLogs(pTrans, pConsumerNew));
tDeleteSMqConsumerObj(pConsumerNew);
}
pConsumerNew = NULL;
@@ -600,17 +617,12 @@ END:
}
static int32_t mndPresistConsumer(STrans *pTrans, const SMqRebOutputObj *pOutput, char *cgroup, char *topic) {
- int32_t code = presistConsumerByType(pTrans, pOutput->modifyConsumers, CONSUMER_UPDATE_REB, cgroup, NULL);
- if (code != 0) {
- return code;
- }
-
- code = presistConsumerByType(pTrans, pOutput->newConsumers, CONSUMER_ADD_REB, cgroup, topic);
- if (code != 0) {
- return code;
- }
-
- return presistConsumerByType(pTrans, pOutput->removedConsumers, CONSUMER_REMOVE_REB, cgroup, topic);
+ int32_t code = 0;
+ MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->modifyConsumers, CONSUMER_UPDATE_REB, cgroup, NULL));
+ MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->newConsumers, CONSUMER_ADD_REB, cgroup, topic));
+ MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->removedConsumers, CONSUMER_REMOVE_REB, cgroup, topic));
+END:
+ return code;
}
static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOutputObj *pOutput) {
@@ -619,10 +631,7 @@ static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOu
STrans *pTrans = NULL;
if (strcmp(pOutput->pSub->qmsg, "") != 0) {
- code = qStringToSubplan(pOutput->pSub->qmsg, &pPlan);
- if (code != 0) {
- goto END;
- }
+ MND_TMQ_RETURN_CHECK(qStringToSubplan(pOutput->pSub->qmsg, &pPlan));
}
char topic[TSDB_TOPIC_FNAME_LEN] = {0};
@@ -637,39 +646,28 @@ static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOu
}
mndTransSetDbName(pTrans, pOutput->pSub->dbName, cgroup);
- code = mndTransCheckConflict(pMnode, pTrans);
- if (code != 0) {
- goto END;
- }
+ MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));
// 1. redo action: action to all vg
const SArray *rebVgs = pOutput->rebVgs;
int32_t vgNum = taosArrayGetSize(rebVgs);
for (int32_t i = 0; i < vgNum; i++) {
SMqRebOutputVg *pRebVg = taosArrayGet(rebVgs, i);
- code = mndPersistSubChangeVgReq(pMnode, pTrans, pOutput->pSub, pRebVg, pPlan);
- if (code != 0) {
- goto END;
- }
+ MND_TMQ_NULL_CHECK(pRebVg);
+ MND_TMQ_RETURN_CHECK(mndPersistSubChangeVgReq(pMnode, pTrans, pOutput->pSub, pRebVg, pPlan));
}
// 2. commit log: subscribe and vg assignment
- code = mndSetSubCommitLogs(pTrans, pOutput->pSub);
- if (code != 0) {
- goto END;
- }
+ MND_TMQ_RETURN_CHECK(mndSetSubCommitLogs(pTrans, pOutput->pSub));
// 3. commit log: consumer to update status and epoch
- code = mndPresistConsumer(pTrans, pOutput, cgroup, topic);
- if (code != 0) {
- goto END;
- }
+ MND_TMQ_RETURN_CHECK(mndPresistConsumer(pTrans, pOutput, cgroup, topic));
// 4. set cb
mndTransSetCb(pTrans, TRANS_START_FUNC_MQ_REB, TRANS_STOP_FUNC_MQ_REB, NULL, 0);
// 5. execution
- code = mndTransPrepare(pMnode, pTrans);
+ MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));
END:
nodesDestroyNode((SNode *)pPlan);
@@ -679,46 +677,63 @@ END:
static void freeRebalanceItem(void *param) {
SMqRebInfo *pInfo = param;
- taosArrayDestroy(pInfo->newConsumers);
- taosArrayDestroy(pInfo->removedConsumers);
+ (void)taosArrayDestroy(pInfo->newConsumers);
+ (void)taosArrayDestroy(pInfo->removedConsumers);
}
// type = 0 remove type = 1 add
-static void buildRebInfo(SHashObj *rebSubHash, SArray *topicList, int8_t type, char *group, int64_t consumerId) {
+static int32_t buildRebInfo(SHashObj *rebSubHash, SArray *topicList, int8_t type, char *group, int64_t consumerId) {
+ int32_t code = 0;
int32_t topicNum = taosArrayGetSize(topicList);
for (int32_t i = 0; i < topicNum; i++) {
- char key[TSDB_SUBSCRIBE_KEY_LEN];
char *removedTopic = taosArrayGetP(topicList, i);
- mndMakeSubscribeKey(key, group, removedTopic);
- SMqRebInfo *pRebSub = mndGetOrCreateRebSub(rebSubHash, key);
+ MND_TMQ_NULL_CHECK(removedTopic);
+ char key[TSDB_SUBSCRIBE_KEY_LEN] = {0};
+ (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", group, TMQ_SEPARATOR, removedTopic);
+ SMqRebInfo *pRebSub = NULL;
+ MND_TMQ_RETURN_CHECK(mndGetOrCreateRebSub(rebSubHash, key, &pRebSub));
if (type == 0)
- taosArrayPush(pRebSub->removedConsumers, &consumerId);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pRebSub->removedConsumers, &consumerId));
else if (type == 1)
- taosArrayPush(pRebSub->newConsumers, &consumerId);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pRebSub->newConsumers, &consumerId));
}
+
+END:
+ return code;
}
static void checkForVgroupSplit(SMnode *pMnode, SMqConsumerObj *pConsumer, SHashObj *rebSubHash) {
int32_t newTopicNum = taosArrayGetSize(pConsumer->currentTopics);
for (int32_t i = 0; i < newTopicNum; i++) {
char *topic = taosArrayGetP(pConsumer->currentTopics, i);
- SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, topic);
- if (pSub == NULL) {
+ if (topic == NULL){
+ continue;
+ }
+ SMqSubscribeObj *pSub = NULL;
+ char key[TSDB_SUBSCRIBE_KEY_LEN] = {0};
+ (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", pConsumer->cgroup, TMQ_SEPARATOR, topic);
+ int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub);
+ if (code != 0) {
continue;
}
taosRLockLatch(&pSub->lock);
// iterate all vg assigned to the consumer of that topic
SMqConsumerEp *pConsumerEp = taosHashGet(pSub->consumerHash, &pConsumer->consumerId, sizeof(int64_t));
- int32_t vgNum = taosArrayGetSize(pConsumerEp->vgs);
-
+ if (pConsumerEp == NULL){
+ taosRUnLockLatch(&pSub->lock);
+ mndReleaseSubscribe(pMnode, pSub);
+ continue;
+ }
+ int32_t vgNum = taosArrayGetSize(pConsumerEp->vgs);
for (int32_t j = 0; j < vgNum; j++) {
SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j);
+ if (pVgEp == NULL) {
+ continue;
+ }
SVgObj *pVgroup = mndAcquireVgroup(pMnode, pVgEp->vgId);
if (!pVgroup) {
- char key[TSDB_SUBSCRIBE_KEY_LEN];
- mndMakeSubscribeKey(key, pConsumer->cgroup, topic);
- mndGetOrCreateRebSub(rebSubHash, key);
+ (void)mndGetOrCreateRebSub(rebSubHash, key, NULL);
mInfo("vnode splitted, vgId:%d rebalance will be triggered", pVgEp->vgId);
}
mndReleaseVgroup(pMnode, pVgroup);
@@ -728,11 +743,12 @@ static void checkForVgroupSplit(SMnode *pMnode, SMqConsumerObj *pConsumer, SHash
}
}
-static void mndCheckConsumer(SRpcMsg *pMsg, SHashObj *rebSubHash) {
+static int32_t mndCheckConsumer(SRpcMsg *pMsg, SHashObj *rebSubHash) {
SMnode *pMnode = pMsg->info.node;
SSdb *pSdb = pMnode->pSdb;
SMqConsumerObj *pConsumer = NULL;
void *pIter = NULL;
+ int32_t code = 0;
// iterate all consumers, find all modification
while (1) {
@@ -751,27 +767,29 @@ static void mndCheckConsumer(SRpcMsg *pMsg, SHashObj *rebSubHash) {
if (status == MQ_CONSUMER_STATUS_READY) {
if (taosArrayGetSize(pConsumer->assignedTopics) == 0) { // unsubscribe or close
- mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, &pMsg->info);
+ MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, &pMsg->info));
} else if (hbStatus > MND_CONSUMER_LOST_HB_CNT) {
taosRLockLatch(&pConsumer->lock);
- buildRebInfo(rebSubHash, pConsumer->currentTopics, 0, pConsumer->cgroup, pConsumer->consumerId);
+ MND_TMQ_RETURN_CHECK(buildRebInfo(rebSubHash, pConsumer->currentTopics, 0, pConsumer->cgroup, pConsumer->consumerId));
taosRUnLockLatch(&pConsumer->lock);
} else {
checkForVgroupSplit(pMnode, pConsumer, rebSubHash);
}
} else if (status == MQ_CONSUMER_STATUS_LOST) {
if (hbStatus > MND_CONSUMER_LOST_CLEAR_THRESHOLD) { // clear consumer if lost a day
- mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, &pMsg->info);
+ MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, &pMsg->info));
}
} else {
taosRLockLatch(&pConsumer->lock);
- buildRebInfo(rebSubHash, pConsumer->rebNewTopics, 1, pConsumer->cgroup, pConsumer->consumerId);
- buildRebInfo(rebSubHash, pConsumer->rebRemovedTopics, 0, pConsumer->cgroup, pConsumer->consumerId);
+ MND_TMQ_RETURN_CHECK(buildRebInfo(rebSubHash, pConsumer->rebNewTopics, 1, pConsumer->cgroup, pConsumer->consumerId));
+ MND_TMQ_RETURN_CHECK(buildRebInfo(rebSubHash, pConsumer->rebRemovedTopics, 0, pConsumer->cgroup, pConsumer->consumerId));
taosRUnLockLatch(&pConsumer->lock);
}
mndReleaseConsumer(pMnode, pConsumer);
}
+END:
+ return code;
}
bool mndRebTryStart() {
@@ -790,31 +808,35 @@ void mndRebCntDec() {
}
static void clearRebOutput(SMqRebOutputObj *rebOutput) {
- taosArrayDestroy(rebOutput->newConsumers);
- taosArrayDestroy(rebOutput->modifyConsumers);
- taosArrayDestroy(rebOutput->removedConsumers);
- taosArrayDestroy(rebOutput->rebVgs);
+ (void)taosArrayDestroy(rebOutput->newConsumers);
+ (void)taosArrayDestroy(rebOutput->modifyConsumers);
+ (void)taosArrayDestroy(rebOutput->removedConsumers);
+ (void)taosArrayDestroy(rebOutput->rebVgs);
tDeleteSubscribeObj(rebOutput->pSub);
taosMemoryFree(rebOutput->pSub);
}
static int32_t initRebOutput(SMqRebOutputObj *rebOutput) {
+ int32_t code = 0;
rebOutput->newConsumers = taosArrayInit(0, sizeof(int64_t));
+ MND_TMQ_NULL_CHECK(rebOutput->newConsumers);
rebOutput->removedConsumers = taosArrayInit(0, sizeof(int64_t));
+ MND_TMQ_NULL_CHECK(rebOutput->removedConsumers);
rebOutput->modifyConsumers = taosArrayInit(0, sizeof(int64_t));
+ MND_TMQ_NULL_CHECK(rebOutput->modifyConsumers);
rebOutput->rebVgs = taosArrayInit(0, sizeof(SMqRebOutputVg));
+ MND_TMQ_NULL_CHECK(rebOutput->rebVgs);
+ return code;
- if (rebOutput->newConsumers == NULL || rebOutput->removedConsumers == NULL || rebOutput->modifyConsumers == NULL ||
- rebOutput->rebVgs == NULL) {
- clearRebOutput(rebOutput);
- return TSDB_CODE_OUT_OF_MEMORY;
- }
- return 0;
+END:
+ clearRebOutput(rebOutput);
+ return code;
}
// This function only works when there are dirty consumers
-static void checkConsumer(SMnode *pMnode, SMqSubscribeObj *pSub) {
- void *pIter = NULL;
+static int32_t checkConsumer(SMnode *pMnode, SMqSubscribeObj *pSub) {
+ int32_t code = 0;
+ void *pIter = NULL;
while (1) {
pIter = taosHashIterate(pSub->consumerHash, pIter);
if (pIter == NULL) {
@@ -822,89 +844,89 @@ static void checkConsumer(SMnode *pMnode, SMqSubscribeObj *pSub) {
}
SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter;
- SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, pConsumerEp->consumerId);
- if (pConsumer != NULL) {
+ SMqConsumerObj *pConsumer = NULL;
+ code = mndAcquireConsumer(pMnode, pConsumerEp->consumerId, &pConsumer);
+ if (code == 0) {
mndReleaseConsumer(pMnode, pConsumer);
continue;
}
mError("consumer:0x%" PRIx64 " not exists in sdb for exception", pConsumerEp->consumerId);
- taosArrayAddAll(pSub->unassignedVgs, pConsumerEp->vgs);
+ MND_TMQ_NULL_CHECK(taosArrayAddAll(pSub->unassignedVgs, pConsumerEp->vgs));
- taosArrayDestroy(pConsumerEp->vgs);
- taosHashRemove(pSub->consumerHash, &pConsumerEp->consumerId, sizeof(int64_t));
+ (void)taosArrayDestroy(pConsumerEp->vgs);
+ MND_TMQ_RETURN_CHECK(taosHashRemove(pSub->consumerHash, &pConsumerEp->consumerId, sizeof(int64_t)));
}
+END:
+ return code;
}
static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOutputObj *rebOutput) {
- int32_t code = 0;
const char *key = rebInput->pRebInfo->key;
- SMqSubscribeObj *pSub = mndAcquireSubscribeByKey(pMnode, key);
+ SMqSubscribeObj *pSub = NULL;
+ int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub);
- if (pSub == NULL) {
+ if (code != 0) {
// split sub key and extract topic
- char topic[TSDB_TOPIC_FNAME_LEN];
- char cgroup[TSDB_CGROUP_LEN];
+ char topic[TSDB_TOPIC_FNAME_LEN] = {0};
+ char cgroup[TSDB_CGROUP_LEN] = {0};
mndSplitSubscribeKey(key, topic, cgroup, true);
-
- SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic);
- if (pTopic == NULL) {
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- mError("[rebalance] mq rebalance %s ignored since topic %s doesn't exist", key, topic);
- TAOS_RETURN(code);
- }
-
+ SMqTopicObj *pTopic = NULL;
+ MND_TMQ_RETURN_CHECK(mndAcquireTopic(pMnode, topic, &pTopic));
taosRLockLatch(&pTopic->lock);
rebInput->oldConsumerNum = 0;
- rebOutput->pSub = mndCreateSubscription(pMnode, pTopic, key);
-
- if (rebOutput->pSub == NULL) {
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- mError("[rebalance] mq rebalance %s failed create sub since %s, ignore", key, tstrerror(code));
+ code = mndCreateSubscription(pMnode, pTopic, key, &rebOutput->pSub);
+ if (code != 0) {
+ mError("[rebalance] mq rebalance %s failed create sub since %s, ignore", key, terrstr());
taosRUnLockLatch(&pTopic->lock);
mndReleaseTopic(pMnode, pTopic);
- TAOS_RETURN(code);
+ return code;
}
- memcpy(rebOutput->pSub->dbName, pTopic->db, TSDB_DB_FNAME_LEN);
+ (void)memcpy(rebOutput->pSub->dbName, pTopic->db, TSDB_DB_FNAME_LEN);
taosRUnLockLatch(&pTopic->lock);
mndReleaseTopic(pMnode, pTopic);
mInfo("[rebalance] sub topic:%s has no consumers sub yet", key);
} else {
taosRLockLatch(&pSub->lock);
- rebOutput->pSub = tCloneSubscribeObj(pSub);
- checkConsumer(pMnode, rebOutput->pSub);
+ code = tCloneSubscribeObj(pSub, &rebOutput->pSub);
+ if(code != 0){
+ taosRUnLockLatch(&pSub->lock);
+ goto END;
+ }
+ code = checkConsumer(pMnode, rebOutput->pSub);
+ if(code != 0){
+ taosRUnLockLatch(&pSub->lock);
+ goto END;
+ }
rebInput->oldConsumerNum = taosHashGetSize(rebOutput->pSub->consumerHash);
taosRUnLockLatch(&pSub->lock);
mInfo("[rebalance] sub topic:%s has %d consumers sub till now", key, rebInput->oldConsumerNum);
mndReleaseSubscribe(pMnode, pSub);
}
- TAOS_RETURN(code);
+
+END:
+ return code;
}
static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg) {
int code = 0;
void *pIter = NULL;
SMnode *pMnode = pMsg->info.node;
- mDebug("[rebalance] start to process mq timer")
-
- if (!mndRebTryStart()) {
- mInfo("[rebalance] mq rebalance already in progress, do nothing") return code;
+ mDebug("[rebalance] start to process mq timer");
+ if (!mndRebTryStart()) {
+ mInfo("[rebalance] mq rebalance already in progress, do nothing");
+ return code;
}
SHashObj *rebSubHash = taosHashInit(64, MurmurHash3_32, true, HASH_NO_LOCK);
- if (rebSubHash == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- if (terrno != 0) code = terrno;
- goto END;
- }
+ MND_TMQ_NULL_CHECK(rebSubHash);
+
taosHashSetFreeFp(rebSubHash, freeRebalanceItem);
- mndCheckConsumer(pMsg, rebSubHash);
+ MND_TMQ_RETURN_CHECK(mndCheckConsumer(pMsg, rebSubHash));
if (taosHashGetSize(rebSubHash) > 0) {
mInfo("[rebalance] mq rebalance start, total required re-balanced trans:%d", taosHashGetSize(rebSubHash))
}
@@ -917,21 +939,25 @@ static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg) {
SMqRebInputObj rebInput = {0};
SMqRebOutputObj rebOutput = {0};
- code = initRebOutput(&rebOutput);
- if (code != 0) {
- goto END;
- }
-
+ MND_TMQ_RETURN_CHECK(initRebOutput(&rebOutput));
rebInput.pRebInfo = (SMqRebInfo *)pIter;
-
- if (buildRebOutput(pMnode, &rebInput, &rebOutput) != 0) {
- continue;
+ code = buildRebOutput(pMnode, &rebInput, &rebOutput);
+ if (code != 0) {
+ mError("mq rebalance buildRebOutput, msg:%s", tstrerror(code))
}
- mndDoRebalance(pMnode, &rebInput, &rebOutput);
+ if (code == 0){
+ code = mndDoRebalance(pMnode, &rebInput, &rebOutput);
+ if (code != 0) {
+ mError("mq rebalance do rebalance error, msg:%s", tstrerror(code))
+ }
+ }
- if ((code = mndPersistRebResult(pMnode, pMsg, &rebOutput)) != 0) {
- mError("mq rebalance persist output error, possibly vnode splitted or dropped,msg:%s", tstrerror(code))
+ if (code == 0){
+ code = mndPersistRebResult(pMnode, pMsg, &rebOutput);
+ if (code != 0) {
+ mError("mq rebalance persist output error, possibly vnode splitted or dropped,msg:%s", tstrerror(code))
+ }
}
clearRebOutput(&rebOutput);
@@ -952,7 +978,7 @@ END:
static int32_t sendDeleteSubToVnode(SMnode *pMnode, SMqSubscribeObj *pSub, STrans *pTrans) {
void *pIter = NULL;
SVgObj *pVgObj = NULL;
- int32_t ret = 0;
+ int32_t code = 0;
while (1) {
pIter = sdbFetch(pMnode->pSdb, SDB_VGROUP, pIter, (void **)&pVgObj);
if (pIter == NULL) {
@@ -964,38 +990,33 @@ static int32_t sendDeleteSubToVnode(SMnode *pMnode, SMqSubscribeObj *pSub, STran
continue;
}
SMqVDeleteReq *pReq = taosMemoryCalloc(1, sizeof(SMqVDeleteReq));
- if (pReq == NULL) {
- ret = TSDB_CODE_OUT_OF_MEMORY;
- goto END;
- }
+ MND_TMQ_NULL_CHECK(pReq);
pReq->head.vgId = htonl(pVgObj->vgId);
pReq->vgId = pVgObj->vgId;
pReq->consumerId = -1;
- memcpy(pReq->subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
+ (void)memcpy(pReq->subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
STransAction action = {0};
action.epSet = mndGetVgroupEpset(pMnode, pVgObj);
- ;
action.pCont = pReq;
action.contLen = sizeof(SMqVDeleteReq);
action.msgType = TDMT_VND_TMQ_DELETE_SUB;
action.acceptableCode = TSDB_CODE_MND_VGROUP_NOT_EXIST;
sdbRelease(pMnode->pSdb, pVgObj);
- if ((ret = mndTransAppendRedoAction(pTrans, &action)) != 0) {
- goto END;
- }
+ MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action));
}
+
END:
sdbRelease(pMnode->pSdb, pVgObj);
sdbCancelFetch(pMnode->pSdb, pIter);
- TAOS_RETURN(ret);
+ return code;
}
static int32_t mndDropConsumerByGroup(SMnode *pMnode, STrans *pTrans, char *cgroup, char *topic) {
void *pIter = NULL;
SMqConsumerObj *pConsumer = NULL;
- int ret = 0;
+ int code = 0;
while (1) {
pIter = sdbFetch(pMnode->pSdb, SDB_CONSUMER, pIter, (void **)&pConsumer);
if (pIter == NULL) {
@@ -1010,12 +1031,8 @@ static int32_t mndDropConsumerByGroup(SMnode *pMnode, STrans *pTrans, char *cgro
int32_t sz = taosArrayGetSize(pConsumer->assignedTopics);
for (int32_t i = 0; i < sz; i++) {
char *name = taosArrayGetP(pConsumer->assignedTopics, i);
- if (strcmp(topic, name) == 0) {
- int32_t code = mndSetConsumerDropLogs(pTrans, pConsumer);
- if (code != 0) {
- ret = code;
- goto END;
- }
+ if (name && strcmp(topic, name) == 0) {
+ MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumer));
}
}
@@ -1025,7 +1042,7 @@ static int32_t mndDropConsumerByGroup(SMnode *pMnode, STrans *pTrans, char *cgro
END:
sdbRelease(pMnode->pSdb, pConsumer);
sdbCancelFetch(pMnode->pSdb, pIter);
- TAOS_RETURN(ret);
+ return code;
}
static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) {
@@ -1033,68 +1050,41 @@ static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) {
SMDropCgroupReq dropReq = {0};
STrans *pTrans = NULL;
int32_t code = TSDB_CODE_ACTION_IN_PROGRESS;
+ SMqSubscribeObj *pSub = NULL;
- if (tDeserializeSMDropCgroupReq(pMsg->pCont, pMsg->contLen, &dropReq) != 0) {
- code = TSDB_CODE_INVALID_MSG;
- TAOS_RETURN(code);
- }
-
- SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, dropReq.cgroup, dropReq.topic);
- if (pSub == NULL) {
+ MND_TMQ_RETURN_CHECK(tDeserializeSMDropCgroupReq(pMsg->pCont, pMsg->contLen, &dropReq));
+ char key[TSDB_SUBSCRIBE_KEY_LEN] = {0};
+ (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", dropReq.cgroup, TMQ_SEPARATOR, dropReq.topic);
+ code = mndAcquireSubscribeByKey(pMnode, key, &pSub);
+ if (code != 0) {
if (dropReq.igNotExists) {
mInfo("cgroup:%s on topic:%s, not exist, ignore not exist is set", dropReq.cgroup, dropReq.topic);
return 0;
} else {
code = TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST;
- mError("topic:%s, cgroup:%s, failed to drop since %s", dropReq.topic, dropReq.cgroup, tstrerror(code));
- TAOS_RETURN(code);
+ mError("topic:%s, cgroup:%s, failed to drop since %s", dropReq.topic, dropReq.cgroup, terrstr());
+ return code;
}
}
taosWLockLatch(&pSub->lock);
if (taosHashGetSize(pSub->consumerHash) != 0) {
code = TSDB_CODE_MND_CGROUP_USED;
- mError("cgroup:%s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, tstrerror(code));
- goto end;
+ mError("cgroup:%s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, terrstr());
+ goto END;
}
pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_DB_INSIDE, pMsg, "drop-cgroup");
- if (pTrans == NULL) {
- code = TSDB_CODE_MND_RETURN_VALUE_NULL;
- if (terrno != 0) code = terrno;
- mError("cgroup: %s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, tstrerror(code));
- goto end;
- }
-
+ MND_TMQ_NULL_CHECK(pTrans);
mInfo("trans:%d, used to drop cgroup:%s on topic %s", pTrans->id, dropReq.cgroup, dropReq.topic);
mndTransSetDbName(pTrans, pSub->dbName, dropReq.cgroup);
- code = mndTransCheckConflict(pMnode, pTrans);
- if (code != 0) {
- goto end;
- }
+ MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));
+ MND_TMQ_RETURN_CHECK(mndDropConsumerByGroup(pMnode, pTrans, dropReq.cgroup, dropReq.topic));
+ MND_TMQ_RETURN_CHECK(sendDeleteSubToVnode(pMnode, pSub, pTrans));
+ MND_TMQ_RETURN_CHECK(mndSetDropSubCommitLogs(pMnode, pTrans, pSub));
+ MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));
- code = mndDropConsumerByGroup(pMnode, pTrans, dropReq.cgroup, dropReq.topic);
- if (code != 0) {
- goto end;
- }
-
- code = sendDeleteSubToVnode(pMnode, pSub, pTrans);
- if (code != 0) {
- goto end;
- }
-
- code = mndSetDropSubCommitLogs(pMnode, pTrans, pSub);
- if (code != 0) {
- mError("cgroup %s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, terrstr());
- goto end;
- }
-
- code = mndTransPrepare(pMnode, pTrans);
- if (code != 0) {
- goto end;
- }
-
-end:
+END:
taosWUnLockLatch(&pSub->lock);
mndReleaseSubscribe(pMnode, pSub);
mndTransDrop(pTrans);
@@ -1122,7 +1112,9 @@ static SSdbRaw *mndSubActionEncode(SMqSubscribeObj *pSub) {
if (buf == NULL) goto SUB_ENCODE_OVER;
void *abuf = buf;
- tEncodeSubscribeObj(&abuf, pSub);
+ if (tEncodeSubscribeObj(&abuf, pSub) < 0){
+ goto SUB_ENCODE_OVER;
+ }
int32_t dataPos = 0;
SDB_SET_INT32(pRaw, dataPos, tlen, SUB_ENCODE_OVER);
@@ -1242,31 +1234,13 @@ static int32_t mndSubActionUpdate(SSdb *pSdb, SMqSubscribeObj *pOldSub, SMqSubsc
return 0;
}
-void mndMakeSubscribeKey(char *key, const char *cgroup, const char *topicName) {
- int32_t tlen = strlen(cgroup);
- memcpy(key, cgroup, tlen);
- key[tlen] = TMQ_SEPARATOR;
- strcpy(key + tlen + 1, topicName);
-}
-
-SMqSubscribeObj *mndAcquireSubscribe(SMnode *pMnode, const char *cgroup, const char *topicName) {
- SSdb *pSdb = pMnode->pSdb;
- char key[TSDB_SUBSCRIBE_KEY_LEN];
- mndMakeSubscribeKey(key, cgroup, topicName);
- SMqSubscribeObj *pSub = sdbAcquire(pSdb, SDB_SUBSCRIBE, key);
- if (pSub == NULL) {
- terrno = TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST;
- }
- return pSub;
-}
-
-SMqSubscribeObj *mndAcquireSubscribeByKey(SMnode *pMnode, const char *key) {
+int32_t mndAcquireSubscribeByKey(SMnode *pMnode, const char *key, SMqSubscribeObj** pSub) {
SSdb *pSdb = pMnode->pSdb;
- SMqSubscribeObj *pSub = sdbAcquire(pSdb, SDB_SUBSCRIBE, key);
- if (pSub == NULL) {
- terrno = TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST;
+ *pSub = sdbAcquire(pSdb, SDB_SUBSCRIBE, key);
+ if (*pSub == NULL) {
+ return TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST;
}
- return pSub;
+ return 0;
}
int32_t mndGetGroupNumByTopic(SMnode *pMnode, const char *topicName) {
@@ -1299,20 +1273,18 @@ void mndReleaseSubscribe(SMnode *pMnode, SMqSubscribeObj *pSub) {
sdbRelease(pSdb, pSub);
}
-static int32_t mndSetDropSubRedoLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub) {
- SSdbRaw *pRedoRaw = mndSubActionEncode(pSub);
- if (pRedoRaw == NULL) return -1;
- if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1;
- if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPED) != 0) return -1;
- return 0;
-}
-
int32_t mndSetDropSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub) {
+ int32_t code = 0;
SSdbRaw *pCommitRaw = mndSubActionEncode(pSub);
- if (pCommitRaw == NULL) return -1;
- if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
- if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1;
- return 0;
+ MND_TMQ_NULL_CHECK(pCommitRaw);
+ code = mndTransAppendCommitlog(pTrans, pCommitRaw);
+ if (code != 0){
+ sdbFreeRaw(pCommitRaw);
+ goto END;
+ }
+ code = sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
+END:
+ return code;
}
int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName) {
@@ -1338,15 +1310,8 @@ int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName)
goto END;
}
- code = sendDeleteSubToVnode(pMnode, pSub, pTrans);
- if (code != 0) {
- goto END;
- }
-
- code = mndSetDropSubCommitLogs(pMnode, pTrans, pSub);
- if (code != 0) {
- goto END;
- }
+ MND_TMQ_RETURN_CHECK(sendDeleteSubToVnode(pMnode, pSub, pTrans));
+ MND_TMQ_RETURN_CHECK(mndSetDropSubCommitLogs(pMnode, pTrans, pSub));
}
END:
@@ -1358,30 +1323,36 @@ END:
static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t consumerId, const char *topic,
const char *cgroup, SArray *vgs, SArray *offsetRows) {
+ int32_t code = 0;
int32_t sz = taosArrayGetSize(vgs);
for (int32_t j = 0; j < sz; j++) {
SMqVgEp *pVgEp = taosArrayGetP(vgs, j);
+ MND_TMQ_NULL_CHECK(pVgEp);
- SColumnInfoData *pColInfo;
+ SColumnInfoData *pColInfo = NULL;
int32_t cols = 0;
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, *numOfRows, (const char *)topic, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)topic, false));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, *numOfRows, (const char *)cgroup, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)cgroup, false));
// vg id
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, *numOfRows, (const char *)&pVgEp->vgId, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)&pVgEp->vgId, false));
// consumer id
char consumerIdHex[32] = {0};
- sprintf(varDataVal(consumerIdHex), "0x%" PRIx64, consumerId);
+ (void)sprintf(varDataVal(consumerIdHex), "0x%" PRIx64, consumerId);
varDataSetLen(consumerIdHex, strlen(varDataVal(consumerIdHex)));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, *numOfRows, (const char *)consumerIdHex, consumerId == -1);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)consumerIdHex, consumerId == -1));
mInfo("mnd show subscriptions: topic %s, consumer:0x%" PRIx64 " cgroup %s vgid %d", varDataVal(topic), consumerId,
varDataVal(cgroup), pVgEp->vgId);
@@ -1390,6 +1361,7 @@ static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t cons
OffsetRows *data = NULL;
for (int i = 0; i < taosArrayGetSize(offsetRows); i++) {
OffsetRows *tmp = taosArrayGet(offsetRows, i);
+ MND_TMQ_NULL_CHECK(tmp);
if (tmp->vgId != pVgEp->vgId) {
mError("mnd show subscriptions: do not find vgId:%d, %d in offsetRows", tmp->vgId, pVgEp->vgId);
continue;
@@ -1399,23 +1371,29 @@ static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t cons
if (data) {
// vg id
char buf[TSDB_OFFSET_LEN * 2 + VARSTR_HEADER_SIZE] = {0};
- tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset);
- sprintf(varDataVal(buf) + strlen(varDataVal(buf)), "/%" PRId64, data->ever);
+ MND_TMQ_RETURN_CHECK(tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset));
+ (void)sprintf(varDataVal(buf) + strlen(varDataVal(buf)), "/%" PRId64, data->ever);
varDataSetLen(buf, strlen(varDataVal(buf)));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, *numOfRows, (const char *)buf, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)buf, false));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, *numOfRows, (const char *)&data->rows, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)&data->rows, false));
} else {
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+ MND_TMQ_NULL_CHECK(pColInfo);
colDataSetNULL(pColInfo, *numOfRows);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+ MND_TMQ_NULL_CHECK(pColInfo);
colDataSetNULL(pColInfo, *numOfRows);
mError("mnd show subscriptions: do not find vgId:%d in offsetRows", pVgEp->vgId);
}
(*numOfRows)++;
}
return 0;
+END:
+ return code;
}
int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
@@ -1423,6 +1401,7 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock
SSdb *pSdb = pMnode->pSdb;
int32_t numOfRows = 0;
SMqSubscribeObj *pSub = NULL;
+ int32_t code = 0;
mInfo("mnd show subscriptions begin");
@@ -1435,7 +1414,7 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock
taosRLockLatch(&pSub->lock);
if (numOfRows + pSub->vgNum > rowsCapacity) {
- blockDataEnsureCapacity(pBlock, numOfRows + pSub->vgNum);
+ MND_TMQ_RETURN_CHECK(blockDataEnsureCapacity(pBlock, numOfRows + pSub->vgNum)) ;
}
// topic and cgroup
@@ -1452,11 +1431,11 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock
if (pIter == NULL) break;
pConsumerEp = (SMqConsumerEp *)pIter;
- buildResult(pBlock, &numOfRows, pConsumerEp->consumerId, topic, cgroup, pConsumerEp->vgs,
- pConsumerEp->offsetRows);
+ MND_TMQ_RETURN_CHECK(buildResult(pBlock, &numOfRows, pConsumerEp->consumerId, topic, cgroup, pConsumerEp->vgs,
+ pConsumerEp->offsetRows));
}
- buildResult(pBlock, &numOfRows, -1, topic, cgroup, pSub->unassignedVgs, pSub->offsetRows);
+ MND_TMQ_RETURN_CHECK(buildResult(pBlock, &numOfRows, -1, topic, cgroup, pSub->unassignedVgs, pSub->offsetRows));
pBlock->info.rows = numOfRows;
@@ -1468,6 +1447,9 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock
pShow->numOfRows += numOfRows;
return numOfRows;
+
+END:
+ return code;
}
void mndCancelGetNextSubscribe(SMnode *pMnode, void *pIter) {
diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c
index bcb38a3902..2fb0870ed6 100644
--- a/source/dnode/mnode/impl/src/mndTopic.c
+++ b/source/dnode/mnode/impl/src/mndTopic.c
@@ -44,8 +44,6 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq);
static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
static void mndCancelGetNextTopic(SMnode *pMnode, void *pIter);
-static int32_t mndSetDropTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic);
-
int32_t mndInitTopic(SMnode *pMnode) {
SSdbTable table = {
.sdbType = SDB_TOPIC,
@@ -70,9 +68,16 @@ int32_t mndInitTopic(SMnode *pMnode) {
void mndCleanupTopic(SMnode *pMnode) {}
-const char *mndTopicGetShowName(const char topic[TSDB_TOPIC_FNAME_LEN]) {
- //
- return strchr(topic, '.') + 1;
+void mndTopicGetShowName(const char* fullTopic, char* topic) {
+ if (fullTopic == NULL) {
+ return;
+ }
+ char* tmp = strchr(fullTopic, '.');
+ if (tmp == NULL) {
+ tstrncpy(topic, fullTopic, TSDB_TOPIC_FNAME_LEN);
+ }else {
+ tstrncpy(topic, tmp+1, TSDB_TOPIC_FNAME_LEN);
+ }
}
SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
@@ -129,7 +134,9 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
goto TOPIC_ENCODE_OVER;
}
void *aswBuf = swBuf;
- taosEncodeSSchemaWrapper(&aswBuf, &pTopic->schema);
+ if(taosEncodeSSchemaWrapper(&aswBuf, &pTopic->schema) < 0){
+ goto TOPIC_ENCODE_OVER;
+ }
SDB_SET_BINARY(pRaw, dataPos, swBuf, schemaLen, TOPIC_ENCODE_OVER);
}
@@ -259,7 +266,7 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
}
int16_t colId;
SDB_GET_INT16(pRaw, dataPos, &colId, TOPIC_DECODE_OVER);
- taosArrayPush(pTopic->ntbColIds, &colId);
+ (void)taosArrayPush(pTopic->ntbColIds, &colId);
}
SDB_GET_INT64(pRaw, dataPos, &pTopic->ctbStbUid, TOPIC_DECODE_OVER);
@@ -289,25 +296,25 @@ static int32_t mndTopicActionDelete(SSdb *pSdb, SMqTopicObj *pTopic) {
taosMemoryFreeClear(pTopic->ast);
taosMemoryFreeClear(pTopic->physicalPlan);
if (pTopic->schema.nCols) taosMemoryFreeClear(pTopic->schema.pSchema);
- taosArrayDestroy(pTopic->ntbColIds);
+ (void)taosArrayDestroy(pTopic->ntbColIds);
return 0;
}
static int32_t mndTopicActionUpdate(SSdb *pSdb, SMqTopicObj *pOldTopic, SMqTopicObj *pNewTopic) {
mTrace("topic:%s perform update action", pOldTopic->name);
- atomic_exchange_64(&pOldTopic->updateTime, pNewTopic->updateTime);
- atomic_exchange_32(&pOldTopic->version, pNewTopic->version);
+ (void)atomic_exchange_64(&pOldTopic->updateTime, pNewTopic->updateTime);
+ (void)atomic_exchange_32(&pOldTopic->version, pNewTopic->version);
return 0;
}
-SMqTopicObj *mndAcquireTopic(SMnode *pMnode, const char *topicName) {
+int32_t mndAcquireTopic(SMnode *pMnode, const char *topicName, SMqTopicObj **pTopic) {
SSdb *pSdb = pMnode->pSdb;
- SMqTopicObj *pTopic = sdbAcquire(pSdb, SDB_TOPIC, topicName);
- if (pTopic == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {
- terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST;
+ *pTopic = sdbAcquire(pSdb, SDB_TOPIC, topicName);
+ if (*pTopic == NULL) {
+ return TSDB_CODE_MND_TOPIC_NOT_EXIST;
}
- return pTopic;
+ return TDB_CODE_SUCCESS;
}
void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic) {
@@ -316,25 +323,23 @@ void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic) {
}
static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) {
- terrno = TSDB_CODE_MND_INVALID_TOPIC;
-
- if (pCreate->sql == NULL) return -1;
+ if (pCreate->sql == NULL) return TSDB_CODE_MND_INVALID_TOPIC;
if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) {
- if (pCreate->ast == NULL || pCreate->ast[0] == 0) return -1;
+ if (pCreate->ast == NULL || pCreate->ast[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC;
} else if (pCreate->subType == TOPIC_SUB_TYPE__TABLE) {
- if (pCreate->subStbName[0] == 0) return -1;
+ if (pCreate->subStbName[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC;
} else if (pCreate->subType == TOPIC_SUB_TYPE__DB) {
- if (pCreate->subDbName[0] == 0) return -1;
+ if (pCreate->subDbName[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC;
}
- terrno = TSDB_CODE_SUCCESS;
return 0;
}
static int32_t extractTopicTbInfo(SNode *pAst, SMqTopicObj *pTopic) {
SNodeList *pNodeList = NULL;
- nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList);
+ int32_t code = 0;
+ MND_TMQ_RETURN_CHECK(nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList));
int64_t suid = ((SRealTableNode *)((SSelectStmt *)pAst)->pFromTable)->pMeta->suid;
int8_t tableType = ((SRealTableNode *)((SSelectStmt *)pAst)->pFromTable)->pMeta->tableType;
if (tableType == TSDB_CHILD_TABLE) {
@@ -345,17 +350,19 @@ static int32_t extractTopicTbInfo(SNode *pAst, SMqTopicObj *pTopic) {
SColumnNode *pCol = (SColumnNode *)pNode;
if (pCol->tableType == TSDB_NORMAL_TABLE) {
pTopic->ntbUid = pCol->tableId;
- taosArrayPush(pTopic->ntbColIds, &pCol->colId);
+ MND_TMQ_NULL_CHECK(taosArrayPush(pTopic->ntbColIds, &pCol->colId));
}
}
}
nodesDestroyList(pNodeList);
- return 0;
+
+END:
+ return code;
}
static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj *topicObj){
- STqCheckInfo info;
- memcpy(info.topic, topicObj->name, TSDB_TOPIC_FNAME_LEN);
+ STqCheckInfo info = {0};
+ (void)memcpy(info.topic, topicObj->name, TSDB_TOPIC_FNAME_LEN);
info.ntbUid = topicObj->ntbUid;
info.colIdList = topicObj->ntbColIds;
// broadcast forbid alter info
@@ -363,7 +370,7 @@ static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj
SSdb *pSdb = pMnode->pSdb;
SVgObj *pVgroup = NULL;
int32_t code = 0;
- void *buf = NULL;
+ void *buf = NULL;
while (1) {
// iterate vg
@@ -378,16 +385,17 @@ static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj
int32_t len;
tEncodeSize(tEncodeSTqCheckInfo, &info, len, code);
if (code != 0) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto END;
}
buf = taosMemoryCalloc(1, sizeof(SMsgHead) + len);
+ MND_TMQ_NULL_CHECK(buf);
void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
- SEncoder encoder;
+ SEncoder encoder = {0};
tEncoderInit(&encoder, abuf, len);
code = tEncodeSTqCheckInfo(&encoder, &info);
if (code < 0) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ tEncoderClear(&encoder);
goto END;
}
tEncoderClear(&encoder);
@@ -398,10 +406,7 @@ static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj
action.pCont = buf;
action.contLen = sizeof(SMsgHead) + len;
action.msgType = TDMT_VND_TMQ_ADD_CHECKINFO;
- code = mndTransAppendRedoAction(pTrans, &action);
- if (code != 0) {
- goto END;
- }
+ MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action));
sdbRelease(pSdb, pVgroup);
buf = NULL;
}
@@ -417,33 +422,22 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
const char *userName) {
mInfo("start to create topic:%s", pCreate->name);
STrans *pTrans = NULL;
- int32_t code = -1;
+ int32_t code = 0;
SNode *pAst = NULL;
SQueryPlan *pPlan = NULL;
SMqTopicObj topicObj = {0};
pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_DB, pReq, "create-topic");
- if (pTrans == NULL) {
- mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
- code = -1;
- goto _OUT;
- }
-
+ MND_TMQ_NULL_CHECK(pTrans);
mndTransSetDbName(pTrans, pDb->name, NULL);
- code = mndTransCheckConflict(pMnode, pTrans);
- if (code != 0) {
- goto _OUT;
- }
+ MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));
mInfo("trans:%d to create topic:%s", pTrans->id, pCreate->name);
tstrncpy(topicObj.name, pCreate->name, TSDB_TOPIC_FNAME_LEN);
tstrncpy(topicObj.db, pDb->name, TSDB_DB_FNAME_LEN);
tstrncpy(topicObj.createUser, userName, TSDB_USER_LEN);
- code = mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_TOPIC, &topicObj);
- if (code != 0) {
- goto _OUT;
- }
+ MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_TOPIC, &topicObj));
topicObj.createTime = taosGetTimestampMs();
topicObj.updateTime = topicObj.createTime;
@@ -458,56 +452,25 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) {
topicObj.ast = taosStrdup(pCreate->ast);
topicObj.astLen = strlen(pCreate->ast) + 1;
-
qDebugL("topic:%s ast %s", topicObj.name, topicObj.ast);
-
- code = nodesStringToNode(pCreate->ast, &pAst);
- if (code != 0) {
- mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
- goto _OUT;
- }
-
+ MND_TMQ_RETURN_CHECK(nodesStringToNode(pCreate->ast, &pAst));
SPlanContext cxt = {.pAstRoot = pAst, .topicQuery = true};
- code = qCreateQueryPlan(&cxt, &pPlan, NULL);
- if (code != 0) {
- mError("failed to create topic:%s since %s", pCreate->name, terrstr());
- goto _OUT;
- }
+ MND_TMQ_RETURN_CHECK(qCreateQueryPlan(&cxt, &pPlan, NULL));
topicObj.ntbColIds = taosArrayInit(0, sizeof(int16_t));
- if (topicObj.ntbColIds == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- code = terrno;
- goto _OUT;
- }
-
- extractTopicTbInfo(pAst, &topicObj);
-
+ MND_TMQ_NULL_CHECK(topicObj.ntbColIds);
+ MND_TMQ_RETURN_CHECK(extractTopicTbInfo(pAst, &topicObj));
if (topicObj.ntbUid == 0) {
- taosArrayDestroy(topicObj.ntbColIds);
+ (void)taosArrayDestroy(topicObj.ntbColIds);
topicObj.ntbColIds = NULL;
}
- code = qExtractResultSchema(pAst, &topicObj.schema.nCols, &topicObj.schema.pSchema);
- if (code != 0) {
- mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
- goto _OUT;
- }
-
- code = nodesNodeToString((SNode *)pPlan, false, &topicObj.physicalPlan, NULL);
- if (code != 0) {
- mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
- goto _OUT;
- }
+ MND_TMQ_RETURN_CHECK(qExtractResultSchema(pAst, &topicObj.schema.nCols, &topicObj.schema.pSchema));
+ MND_TMQ_RETURN_CHECK(nodesNodeToString((SNode *)pPlan, false, &topicObj.physicalPlan, NULL));
} else if (pCreate->subType == TOPIC_SUB_TYPE__TABLE) {
SStbObj *pStb = mndAcquireStb(pMnode, pCreate->subStbName);
- if (pStb == NULL) {
- terrno = TSDB_CODE_MND_STB_NOT_EXIST;
- code = terrno;
- goto _OUT;
- }
-
- strcpy(topicObj.stbName, pCreate->subStbName);
+ MND_TMQ_NULL_CHECK(pStb);
+ tstrncpy(topicObj.stbName, pCreate->subStbName, TSDB_TABLE_FNAME_LEN);
topicObj.stbUid = pStb->uid;
mndReleaseStb(pMnode, pStb);
if(pCreate->ast != NULL){
@@ -518,34 +481,25 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
}
SSdbRaw *pCommitRaw = mndTopicActionEncode(&topicObj);
- if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
- mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
- code = -1;
- goto _OUT;
+ MND_TMQ_NULL_CHECK(pCommitRaw);
+ code = mndTransAppendCommitlog(pTrans, pCommitRaw);
+ if(code != 0) {
+ sdbFreeRaw(pCommitRaw);
+ goto END;
}
- (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
-
+ MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));
if (topicObj.ntbUid != 0) {
- code = sendCheckInfoToVnode(pTrans, pMnode, &topicObj);
- if (code != 0){
- goto _OUT;
- }
+ MND_TMQ_RETURN_CHECK(sendCheckInfoToVnode(pTrans, pMnode, &topicObj));
}
-
- if (mndTransPrepare(pMnode, pTrans) != 0) {
- mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
- code = -1;
- goto _OUT;
- }
-
+ MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));
code = TSDB_CODE_ACTION_IN_PROGRESS;
-_OUT:
+END:
taosMemoryFreeClear(topicObj.physicalPlan);
taosMemoryFreeClear(topicObj.sql);
taosMemoryFreeClear(topicObj.ast);
- taosArrayDestroy(topicObj.ntbColIds);
+ (void)taosArrayDestroy(topicObj.ntbColIds);
if (topicObj.schema.nCols) {
taosMemoryFreeClear(topicObj.schema.pSchema);
}
@@ -557,75 +511,64 @@ _OUT:
static int32_t mndProcessCreateTopicReq(SRpcMsg *pReq) {
SMnode *pMnode = pReq->info.node;
- int32_t code = -1;
+ int32_t code = TDB_CODE_SUCCESS;
SMqTopicObj *pTopic = NULL;
SDbObj *pDb = NULL;
SCMCreateTopicReq createTopicReq = {0};
if (tDeserializeSCMCreateTopicReq(pReq->pCont, pReq->contLen, &createTopicReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
- goto _OVER;
+ code = TSDB_CODE_INVALID_MSG;
+ goto END;
}
mInfo("topic:%s start to create, sql:%s", createTopicReq.name, createTopicReq.sql);
- if (mndCheckCreateTopicReq(&createTopicReq) != 0) {
- mError("topic:%s failed to create since %s", createTopicReq.name, terrstr());
- goto _OVER;
- }
+ MND_TMQ_RETURN_CHECK(mndCheckCreateTopicReq(&createTopicReq));
- pTopic = mndAcquireTopic(pMnode, createTopicReq.name);
- if (pTopic != NULL) {
+ code = mndAcquireTopic(pMnode, createTopicReq.name, &pTopic);
+ if (code == TDB_CODE_SUCCESS) {
if (createTopicReq.igExists) {
mInfo("topic:%s already exist, ignore exist is set", createTopicReq.name);
- code = 0;
- goto _OVER;
+ goto END;
} else {
- terrno = TSDB_CODE_MND_TOPIC_ALREADY_EXIST;
- goto _OVER;
+ code = TSDB_CODE_MND_TOPIC_ALREADY_EXIST;
+ goto END;
}
- } else if (terrno != TSDB_CODE_MND_TOPIC_NOT_EXIST) {
- goto _OVER;
+ } else if (code != TSDB_CODE_MND_TOPIC_NOT_EXIST) {
+ goto END;
}
pDb = mndAcquireDb(pMnode, createTopicReq.subDbName);
- if (pDb == NULL) {
- terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
- goto _OVER;
- }
+ MND_TMQ_NULL_CHECK(pDb);
if (pDb->cfg.walRetentionPeriod == 0) {
- terrno = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;
+ code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;
mError("db:%s, not allowed to create topic when WAL_RETENTION_PERIOD is zero", pDb->name);
- goto _OVER;
+ goto END;
}
if (sdbGetSize(pMnode->pSdb, SDB_TOPIC) >= tmqMaxTopicNum){
- terrno = TSDB_CODE_TMQ_TOPIC_OUT_OF_RANGE;
+ code = TSDB_CODE_TMQ_TOPIC_OUT_OF_RANGE;
mError("topic num out of range");
- goto _OVER;
- }
-
- if ((terrno = grantCheck(TSDB_GRANT_SUBSCRIPTION)) < 0) {
- goto _OVER;
+ goto END;
}
+ MND_TMQ_RETURN_CHECK(grantCheck(TSDB_GRANT_SUBSCRIPTION));
code = mndCreateTopic(pMnode, pReq, &createTopicReq, pDb, pReq->info.conn.user);
if (code == 0) {
code = TSDB_CODE_ACTION_IN_PROGRESS;
}
- SName dbname = {0};
- tNameFromString(&dbname, createTopicReq.subDbName, T_NAME_ACCT | T_NAME_DB);
+ {
+ SName dbname = {0};
+ (void)tNameFromString(&dbname, createTopicReq.subDbName, T_NAME_ACCT | T_NAME_DB); // ignore error
+ SName topicName = {0};
+ (void)tNameFromString(&topicName, createTopicReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); // ignore error
+ auditRecord(pReq, pMnode->clusterId, "createTopic", dbname.dbname, topicName.dbname,
+ createTopicReq.sql, strlen(createTopicReq.sql));
+ }
- SName topicName = {0};
- tNameFromString(&topicName, createTopicReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
- //reuse this function for topic
-
- auditRecord(pReq, pMnode->clusterId, "createTopic", dbname.dbname, topicName.dbname,
- createTopicReq.sql, strlen(createTopicReq.sql));
-
-_OVER:
+END:
if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
mError("failed to create topic:%s since %s", createTopicReq.name, terrstr());
}
@@ -638,22 +581,20 @@ _OVER:
}
static int32_t mndDropTopic(SMnode *pMnode, STrans *pTrans, SRpcMsg *pReq, SMqTopicObj *pTopic) {
- int32_t code = -1;
- if (mndUserRemoveTopic(pMnode, pTrans, pTopic->name) != 0) {
- goto _OVER;
+ int32_t code = 0;
+ SSdbRaw *pCommitRaw = NULL;
+ MND_TMQ_RETURN_CHECK(mndUserRemoveTopic(pMnode, pTrans, pTopic->name));
+ pCommitRaw = mndTopicActionEncode(pTopic);
+ MND_TMQ_NULL_CHECK(pCommitRaw);
+ code = mndTransAppendCommitlog(pTrans, pCommitRaw);
+ if(code != 0) {
+ sdbFreeRaw(pCommitRaw);
+ goto END;
}
+ MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));
+ MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));
- SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic);
- if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER;
- (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
-
- if (mndTransPrepare(pMnode, pTrans) != 0) {
- goto _OVER;
- }
-
- code = 0;
-
-_OVER:
+END:
return code;
}
@@ -661,7 +602,7 @@ static bool checkTopic(SArray *topics, char *topicName){
int32_t sz = taosArrayGetSize(topics);
for (int32_t i = 0; i < sz; i++) {
char *name = taosArrayGetP(topics, i);
- if (strcmp(name, topicName) == 0) {
+ if (name && strcmp(name, topicName) == 0) {
return true;
}
}
@@ -682,29 +623,26 @@ static int32_t mndDropConsumerByTopic(SMnode *pMnode, STrans *pTrans, char *topi
bool found = checkTopic(pConsumer->assignedTopics, topicName);
if (found){
if (pConsumer->status == MQ_CONSUMER_STATUS_LOST) {
- code = mndSetConsumerDropLogs(pTrans, pConsumer);
- if (code != 0) {
- goto end;
- }
+ MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumer));
sdbRelease(pSdb, pConsumer);
continue;
}
mError("topic:%s, failed to drop since subscribed by consumer:0x%" PRIx64 ", in consumer group %s",
topicName, pConsumer->consumerId, pConsumer->cgroup);
code = TSDB_CODE_MND_TOPIC_SUBSCRIBED;
- goto end;
+ goto END;
}
if (checkTopic(pConsumer->rebNewTopics, topicName) || checkTopic(pConsumer->rebRemovedTopics, topicName)) {
code = TSDB_CODE_MND_TOPIC_SUBSCRIBED;
mError("topic:%s, failed to drop since subscribed by consumer:%" PRId64 ", in consumer group %s (reb new)",
topicName, pConsumer->consumerId, pConsumer->cgroup);
- goto end;
+ goto END;
}
sdbRelease(pSdb, pConsumer);
}
-end:
+END:
sdbRelease(pSdb, pConsumer);
sdbCancelFetch(pSdb, pIter);
return code;
@@ -726,13 +664,10 @@ static int32_t mndDropCheckInfoByTopic(SMnode *pMnode, STrans *pTrans, SMqTopicO
}
buf = taosMemoryCalloc(1, sizeof(SMsgHead) + TSDB_TOPIC_FNAME_LEN);
- if (buf == NULL){
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto end;
- }
+ MND_TMQ_NULL_CHECK(buf);
void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
((SMsgHead *)buf)->vgId = htonl(pVgroup->vgId);
- memcpy(abuf, pTopic->name, TSDB_TOPIC_FNAME_LEN);
+ (void)memcpy(abuf, pTopic->name, TSDB_TOPIC_FNAME_LEN);
STransAction action = {0};
action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
@@ -742,12 +677,12 @@ static int32_t mndDropCheckInfoByTopic(SMnode *pMnode, STrans *pTrans, SMqTopicO
code = mndTransAppendRedoAction(pTrans, &action);
if (code != 0) {
taosMemoryFree(buf);
- goto end;
+ goto END;
}
sdbRelease(pSdb, pVgroup);
}
-end:
+END:
sdbRelease(pSdb, pVgroup);
sdbCancelFetch(pSdb, pIter);
return code;
@@ -761,70 +696,40 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) {
STrans *pTrans = NULL;
if (tDeserializeSMDropTopicReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
- terrno = TSDB_CODE_INVALID_MSG;
- return -1;
+ return TSDB_CODE_INVALID_MSG;
}
- pTopic = mndAcquireTopic(pMnode, dropReq.name);
- if (pTopic == NULL) {
+ code = mndAcquireTopic(pMnode, dropReq.name, &pTopic);
+ if (code != 0) {
if (dropReq.igNotExists) {
mInfo("topic:%s, not exist, ignore not exist is set", dropReq.name);
tFreeSMDropTopicReq(&dropReq);
return 0;
} else {
- terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST;
mError("topic:%s, failed to drop since %s", dropReq.name, terrstr());
tFreeSMDropTopicReq(&dropReq);
- return -1;
+ return code;
}
}
pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "drop-topic");
- if (pTrans == NULL) {
- mError("topic:%s, failed to drop since %s", pTopic->name, terrstr());
- code = -1;
- goto end;
- }
+ MND_TMQ_NULL_CHECK(pTrans);
mndTransSetDbName(pTrans, pTopic->db, NULL);
- code = mndTransCheckConflict(pMnode, pTrans);
- if (code != 0) {
- goto end;
- }
-
+ MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));
mInfo("trans:%d, used to drop topic:%s", pTrans->id, pTopic->name);
-
- code = mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_TOPIC, pTopic);
- if (code != 0) {
- goto end;
- }
-
- code = mndCheckDbPrivilegeByName(pMnode, pReq->info.conn.user, MND_OPER_READ_DB, pTopic->db);
- if (code != 0) {
- goto end;
- }
-
- code = mndDropConsumerByTopic(pMnode, pTrans, dropReq.name);
- if (code != 0) {
- goto end;
- }
-
- code = mndDropSubByTopic(pMnode, pTrans, dropReq.name);
- if (code < 0) {
- mError("topic:%s, failed to drop since %s", pTopic->name, terrstr());
- goto end;
- }
+ MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_TOPIC, pTopic));
+ MND_TMQ_RETURN_CHECK(mndCheckDbPrivilegeByName(pMnode, pReq->info.conn.user, MND_OPER_READ_DB, pTopic->db));
+ MND_TMQ_RETURN_CHECK(mndDropConsumerByTopic(pMnode, pTrans, dropReq.name));
+ MND_TMQ_RETURN_CHECK(mndDropSubByTopic(pMnode, pTrans, dropReq.name));
if (pTopic->ntbUid != 0) {
- code = mndDropCheckInfoByTopic(pMnode, pTrans, pTopic);
- if (code != 0) {
- goto end;
- }
+ MND_TMQ_RETURN_CHECK(mndDropCheckInfoByTopic(pMnode, pTrans, pTopic));
}
code = mndDropTopic(pMnode, pTrans, pReq, pTopic);
-end:
+END:
mndReleaseTopic(pMnode, pTopic);
mndTransDrop(pTrans);
if (code != 0) {
@@ -834,8 +739,7 @@ end:
}
SName name = {0};
- tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
-
+ (void)tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); // ignore error
auditRecord(pReq, pMnode->clusterId, "dropTopic", name.dbname, name.tname, dropReq.sql, dropReq.sqlLen);
tFreeSMDropTopicReq(&dropReq);
@@ -849,8 +753,7 @@ int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics) {
SSdb *pSdb = pMnode->pSdb;
SDbObj *pDb = mndAcquireDb(pMnode, dbName);
if (pDb == NULL) {
- terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
- return -1;
+ return TSDB_CODE_MND_DB_NOT_SELECTED;
}
int32_t numOfTopics = 0;
@@ -875,18 +778,24 @@ int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics) {
}
static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){
- char* string = NULL;
+ char* string = NULL;
+ int32_t code = 0;
cJSON* columns = cJSON_CreateArray();
- if (columns == NULL) {
- return;
- }
+ MND_TMQ_NULL_CHECK(columns);
for (int i = 0; i < nCols; i++) {
cJSON* column = cJSON_CreateObject();
+ MND_TMQ_NULL_CHECK(column);
SSchema* s = schema + i;
cJSON* cname = cJSON_CreateString(s->name);
- cJSON_AddItemToObject(column, "name", cname);
+ MND_TMQ_NULL_CHECK(cname);
+ if (!cJSON_AddItemToObject(column, "name", cname)) {
+ return;
+ }
cJSON* ctype = cJSON_CreateString(tDataTypes[s->type].name);
- cJSON_AddItemToObject(column, "type", ctype);
+ MND_TMQ_NULL_CHECK(ctype);
+ if (!cJSON_AddItemToObject(column, "type", ctype)) {
+ return;
+ }
int32_t length = 0;
if (s->type == TSDB_DATA_TYPE_BINARY || s->type == TSDB_DATA_TYPE_VARBINARY ||
s->type == TSDB_DATA_TYPE_GEOMETRY) {
@@ -897,8 +806,13 @@ static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){
length = s->bytes;
}
cJSON* cbytes = cJSON_CreateNumber(length);
- cJSON_AddItemToObject(column, "length", cbytes);
- cJSON_AddItemToArray(columns, column);
+ MND_TMQ_NULL_CHECK(cbytes);
+ if (!cJSON_AddItemToObject(column, "length", cbytes)){
+ return;
+ }
+ if (!cJSON_AddItemToArray(columns, column)){
+ return;
+ }
}
string = cJSON_PrintUnformatted(columns);
cJSON_Delete(columns);
@@ -910,6 +824,9 @@ static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){
mError("mndRetrieveTopic build schema error json:%p, json len:%zu", string, len);
}
taosMemoryFree(string);
+
+END:
+ return;
}
static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
@@ -917,13 +834,16 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
SSdb *pSdb = pMnode->pSdb;
int32_t numOfRows = 0;
SMqTopicObj *pTopic = NULL;
+ int32_t code = 0;
+ char *sql = NULL;
+ char *schemaJson = NULL;
while (numOfRows < rowsCapacity) {
pShow->pIter = sdbFetch(pSdb, SDB_TOPIC, pShow->pIter, (void **)&pTopic);
if (pShow->pIter == NULL) break;
- SColumnInfoData *pColInfo;
- SName n;
+ SColumnInfoData *pColInfo= NULL;
+ SName n = {0};
int32_t cols = 0;
char topicName[TSDB_TOPIC_NAME_LEN + VARSTR_HEADER_SIZE + 5] = {0};
@@ -931,28 +851,34 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
STR_TO_VARSTR(topicName, pName);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)topicName, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)topicName, false));
char dbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
- tNameFromString(&n, pTopic->db, T_NAME_ACCT | T_NAME_DB);
- tNameGetDbName(&n, varDataVal(dbName));
+ MND_TMQ_RETURN_CHECK(tNameFromString(&n, pTopic->db, T_NAME_ACCT | T_NAME_DB));
+ MND_TMQ_RETURN_CHECK(tNameGetDbName(&n, varDataVal(dbName)));
varDataSetLen(dbName, strlen(varDataVal(dbName)));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)dbName, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)dbName, false));
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)&pTopic->createTime, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pTopic->createTime, false));
- char *sql = taosMemoryMalloc(strlen(pTopic->sql) + VARSTR_HEADER_SIZE);
+ sql = taosMemoryMalloc(strlen(pTopic->sql) + VARSTR_HEADER_SIZE);
+ MND_TMQ_NULL_CHECK(sql);
STR_TO_VARSTR(sql, pTopic->sql);
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)sql, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)sql, false));
- taosMemoryFree(sql);
+ taosMemoryFreeClear(sql);
- char *schemaJson = taosMemoryMalloc(TSDB_SHOW_SCHEMA_JSON_LEN + VARSTR_HEADER_SIZE);
+ schemaJson = taosMemoryMalloc(TSDB_SHOW_SCHEMA_JSON_LEN + VARSTR_HEADER_SIZE);
+ MND_TMQ_NULL_CHECK(schemaJson);
if(pTopic->subType == TOPIC_SUB_TYPE__COLUMN){
schemaToJson(pTopic->schema.pSchema, pTopic->schema.nCols, schemaJson);
}else if(pTopic->subType == TOPIC_SUB_TYPE__TABLE){
@@ -969,8 +895,9 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
}
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)schemaJson, false);
- taosMemoryFree(schemaJson);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)schemaJson, false));
+ taosMemoryFreeClear(schemaJson);
char mete[4 + VARSTR_HEADER_SIZE] = {0};
if(pTopic->withMeta){
@@ -980,7 +907,8 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
}
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)mete, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)mete, false));
char type[8 + VARSTR_HEADER_SIZE] = {0};
if(pTopic->subType == TOPIC_SUB_TYPE__COLUMN){
@@ -992,7 +920,8 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
}
pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
- colDataSetVal(pColInfo, numOfRows, (const char *)type, false);
+ MND_TMQ_NULL_CHECK(pColInfo);
+ MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)type, false));
numOfRows++;
sdbRelease(pSdb, pTopic);
@@ -1000,24 +929,11 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
pShow->numOfRows += numOfRows;
return numOfRows;
-}
-int32_t mndSetTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic) {
- SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic);
- if (pCommitRaw == NULL) return -1;
- if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
- if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1;
-
- return 0;
-}
-
-static int32_t mndSetDropTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic) {
- SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic);
- if (pCommitRaw == NULL) return -1;
- if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
- if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1;
-
- return 0;
+END:
+ taosMemoryFreeClear(schemaJson);
+ taosMemoryFreeClear(sql);
+ return code;
}
static void mndCancelGetNextTopic(SMnode *pMnode, void *pIter) {
@@ -1047,33 +963,3 @@ bool mndTopicExistsForDb(SMnode *pMnode, SDbObj *pDb) {
return false;
}
-
-#if 0
-int32_t mndDropTopicByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
- int32_t code = 0;
- SSdb *pSdb = pMnode->pSdb;
-
- void *pIter = NULL;
- SMqTopicObj *pTopic = NULL;
- while (1) {
- pIter = sdbFetch(pSdb, SDB_TOPIC, pIter, (void **)&pTopic);
- if (pIter == NULL) break;
-
- if (pTopic->dbUid != pDb->uid) {
- sdbRelease(pSdb, pTopic);
- continue;
- }
-
- if (mndSetDropTopicCommitLogs(pMnode, pTrans, pTopic) < 0) {
- sdbRelease(pSdb, pTopic);
- sdbCancelFetch(pSdb, pIter);
- code = -1;
- break;
- }
-
- sdbRelease(pSdb, pTopic);
- }
-
- return code;
-}
-#endif
diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c
index fd5267e471..cd0cd97026 100644
--- a/source/dnode/mnode/impl/src/mndUser.c
+++ b/source/dnode/mnode/impl/src/mndUser.c
@@ -1357,7 +1357,7 @@ SHashObj *mndDupUseDbHash(SHashObj *pOld) {
}
int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew) {
- memcpy(pNew, pUser, sizeof(SUserObj));
+ (void)memcpy(pNew, pUser, sizeof(SUserObj));
pNew->authVersion++;
pNew->updateTime = taosGetTimestampMs();
@@ -1377,7 +1377,7 @@ int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew) {
taosRUnLockLatch(&pUser->lock);
if (pNew->readDbs == NULL || pNew->writeDbs == NULL || pNew->topics == NULL) {
- return -1;
+ return TSDB_CODE_INVALID_PARA;
}
return 0;
}
@@ -1983,10 +1983,11 @@ static int32_t mndProcessAlterUserPrivilegesReq(SAlterUserReq *pAlterReq, SMnode
if (ALTER_USER_ADD_SUBSCRIBE_TOPIC_PRIV(pAlterReq->alterType, pAlterReq->privileges)) {
int32_t len = strlen(pAlterReq->objname) + 1;
- SMqTopicObj *pTopic = mndAcquireTopic(pMnode, pAlterReq->objname);
- if (pTopic == NULL) {
+ SMqTopicObj *pTopic = NULL;
+ int32_t code = mndAcquireTopic(pMnode, pAlterReq->objname, &pTopic);
+ if (code != 0) {
mndReleaseTopic(pMnode, pTopic);
- return -1;
+ return code;
}
taosHashPut(pNewUser->topics, pTopic->name, len, pTopic->name, TSDB_TOPIC_FNAME_LEN);
mndReleaseTopic(pMnode, pTopic);
@@ -1994,10 +1995,11 @@ static int32_t mndProcessAlterUserPrivilegesReq(SAlterUserReq *pAlterReq, SMnode
if (ALTER_USER_DEL_SUBSCRIBE_TOPIC_PRIV(pAlterReq->alterType, pAlterReq->privileges)) {
int32_t len = strlen(pAlterReq->objname) + 1;
- SMqTopicObj *pTopic = mndAcquireTopic(pMnode, pAlterReq->objname);
- if (pTopic == NULL) {
+ SMqTopicObj *pTopic = NULL;
+ int32_t code = mndAcquireTopic(pMnode, pAlterReq->objname, &pTopic);
+ if (code != 0) {
mndReleaseTopic(pMnode, pTopic);
- return -1;
+ return code;
}
taosHashRemove(pNewUser->topics, pAlterReq->objname, len);
mndReleaseTopic(pMnode, pTopic);
diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c
index 0422bfabff..d100f84d5a 100644
--- a/source/dnode/mnode/impl/src/mndVgroup.c
+++ b/source/dnode/mnode/impl/src/mndVgroup.c
@@ -2725,15 +2725,6 @@ int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgro
SDbObj dbObj = {0};
SArray *pArray = mndBuildDnodesArray(pMnode, 0);
- // int32_t numOfTopics = 0;
- // if (mndGetNumOfTopics(pMnode, pDb->name, &numOfTopics) != 0) {
- // goto _OVER;
- // }
- // if (numOfTopics > 0) {
- // terrno = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;
- // goto _OVER;
- // }
-
int32_t numOfStreams = 0;
if (mndGetNumOfStreams(pMnode, pDb->name, &numOfStreams) != 0) {
goto _OVER;
diff --git a/source/dnode/qnode/src/qnode.c b/source/dnode/qnode/src/qnode.c
index 8cd967a8a8..b0fcd3400d 100644
--- a/source/dnode/qnode/src/qnode.c
+++ b/source/dnode/qnode/src/qnode.c
@@ -19,21 +19,22 @@
#include "query.h"
#include "qworker.h"
-SQnode *qndOpen(const SQnodeOpt *pOption) {
- SQnode *pQnode = taosMemoryCalloc(1, sizeof(SQnode));
- if (NULL == pQnode) {
+int32_t qndOpen(const SQnodeOpt *pOption, SQnode **pQnode) {
+ *pQnode = taosMemoryCalloc(1, sizeof(SQnode));
+ if (NULL == *pQnode) {
qError("calloc SQnode failed");
- return NULL;
+ return TSDB_CODE_OUT_OF_MEMORY;
}
- pQnode->qndId = QNODE_HANDLE;
+ (*pQnode)->qndId = QNODE_HANDLE;
- if (qWorkerInit(NODE_TYPE_QNODE, pQnode->qndId, (void **)&pQnode->pQuery, &pOption->msgCb)) {
+ int32_t code = qWorkerInit(NODE_TYPE_QNODE, (*pQnode)->qndId, (void **)&(*pQnode)->pQuery, &pOption->msgCb);
+ if (TSDB_CODE_SUCCESS != code) {
taosMemoryFreeClear(pQnode);
- return NULL;
+ return code;
}
- pQnode->msgCb = pOption->msgCb;
- return pQnode;
+ (*pQnode)->msgCb = pOption->msgCb;
+ return TSDB_CODE_SUCCESS;
}
void qndClose(SQnode *pQnode) {
diff --git a/source/dnode/vnode/CMakeLists.txt b/source/dnode/vnode/CMakeLists.txt
index 400725b041..f70a8844ba 100644
--- a/source/dnode/vnode/CMakeLists.txt
+++ b/source/dnode/vnode/CMakeLists.txt
@@ -22,7 +22,6 @@ set(
# meta
"src/meta/metaOpen.c"
- "src/meta/metaIdx.c"
"src/meta/metaTable.c"
"src/meta/metaSma.c"
"src/meta/metaQuery.c"
diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h
index 3d26104722..d496853cd5 100644
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -226,7 +226,7 @@ void tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32
int32_t tMapDataSearch(SMapData *pMapData, void *pSearchItem, int32_t (*tGetItemFn)(uint8_t *, void *),
int32_t (*tItemCmprFn)(const void *, const void *), void *pItem);
int32_t tPutMapData(uint8_t *p, SMapData *pMapData);
-int32_t tGetMapData(uint8_t *p, SMapData *pMapData);
+int32_t tGetMapData(uint8_t *p, SMapData *pMapData, int32_t *decodedSize);
int32_t tMapDataToArray(SMapData *pMapData, int32_t itemSize, int32_t (*tGetItemFn)(uint8_t *, void *),
SArray **ppArray);
// other
@@ -706,7 +706,6 @@ typedef TARRAY2(STsdbFSetPartition *) STsdbFSetPartList;
STsdbFSetPartList *tsdbFSetPartListCreate();
void tsdbFSetPartListDestroy(STsdbFSetPartList **ppList);
-int32_t tSerializeTsdbFSetPartList(void *buf, int32_t bufLen, STsdbFSetPartList *pList);
int32_t tDeserializeTsdbFSetPartList(void *buf, int32_t bufLen, STsdbFSetPartList *pList);
int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList *pList, TFileSetRangeArray **ppRanges);
diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h
index 0dc53afc48..32e4fea336 100644
--- a/source/dnode/vnode/src/inc/vnodeInt.h
+++ b/source/dnode/vnode/src/inc/vnodeInt.h
@@ -318,7 +318,7 @@ void* tdUidStoreFree(STbUidStore* pStore);
// SMetaSnapReader ========================================
int32_t metaSnapReaderOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapReader** ppReader);
-int32_t metaSnapReaderClose(SMetaSnapReader** ppReader);
+void metaSnapReaderClose(SMetaSnapReader** ppReader);
int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData);
// SMetaSnapWriter ========================================
int32_t metaSnapWriterOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapWriter** ppWriter);
diff --git a/source/dnode/vnode/src/meta/metaCache.c b/source/dnode/vnode/src/meta/metaCache.c
index 64cee3513c..3d4757d3e4 100644
--- a/source/dnode/vnode/src/meta/metaCache.c
+++ b/source/dnode/vnode/src/meta/metaCache.c
@@ -117,91 +117,81 @@ static void freeCacheEntryFp(void* param) {
}
int32_t metaCacheOpen(SMeta* pMeta) {
- int32_t code = 0;
- SMetaCache* pCache = NULL;
+ int32_t code = 0;
+ int32_t lino;
- pCache = (SMetaCache*)taosMemoryMalloc(sizeof(SMetaCache));
- if (pCache == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err;
+ pMeta->pCache = (SMetaCache*)taosMemoryCalloc(1, sizeof(SMetaCache));
+ if (pMeta->pCache == NULL) {
+ TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
}
// open entry cache
- pCache->sEntryCache.nEntry = 0;
- pCache->sEntryCache.nBucket = META_CACHE_BASE_BUCKET;
- pCache->sEntryCache.aBucket =
- (SMetaCacheEntry**)taosMemoryCalloc(pCache->sEntryCache.nBucket, sizeof(SMetaCacheEntry*));
- if (pCache->sEntryCache.aBucket == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err;
+ pMeta->pCache->sEntryCache.nEntry = 0;
+ pMeta->pCache->sEntryCache.nBucket = META_CACHE_BASE_BUCKET;
+ pMeta->pCache->sEntryCache.aBucket =
+ (SMetaCacheEntry**)taosMemoryCalloc(pMeta->pCache->sEntryCache.nBucket, sizeof(SMetaCacheEntry*));
+ if (pMeta->pCache->sEntryCache.aBucket == NULL) {
+ TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
}
// open stats cache
- pCache->sStbStatsCache.nEntry = 0;
- pCache->sStbStatsCache.nBucket = META_CACHE_STATS_BUCKET;
- pCache->sStbStatsCache.aBucket =
- (SMetaStbStatsEntry**)taosMemoryCalloc(pCache->sStbStatsCache.nBucket, sizeof(SMetaStbStatsEntry*));
- if (pCache->sStbStatsCache.aBucket == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err2;
+ pMeta->pCache->sStbStatsCache.nEntry = 0;
+ pMeta->pCache->sStbStatsCache.nBucket = META_CACHE_STATS_BUCKET;
+ pMeta->pCache->sStbStatsCache.aBucket =
+ (SMetaStbStatsEntry**)taosMemoryCalloc(pMeta->pCache->sStbStatsCache.nBucket, sizeof(SMetaStbStatsEntry*));
+ if (pMeta->pCache->sStbStatsCache.aBucket == NULL) {
+ TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
}
- pCache->sTagFilterResCache.pUidResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5);
- if (pCache->sTagFilterResCache.pUidResCache == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err2;
+ pMeta->pCache->sTagFilterResCache.pUidResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5);
+ if (pMeta->pCache->sTagFilterResCache.pUidResCache == NULL) {
+ TSDB_CHECK_CODE(code = terrno, lino, _exit);
}
- pCache->sTagFilterResCache.accTimes = 0;
- pCache->sTagFilterResCache.pTableEntry =
+ pMeta->pCache->sTagFilterResCache.accTimes = 0;
+ pMeta->pCache->sTagFilterResCache.pTableEntry =
taosHashInit(1024, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK);
- if (pCache->sTagFilterResCache.pTableEntry == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err2;
+ if (pMeta->pCache->sTagFilterResCache.pTableEntry == NULL) {
+ TSDB_CHECK_CODE(code = terrno, lino, _exit);
}
- taosHashSetFreeFp(pCache->sTagFilterResCache.pTableEntry, freeCacheEntryFp);
- taosThreadMutexInit(&pCache->sTagFilterResCache.lock, NULL);
+ taosHashSetFreeFp(pMeta->pCache->sTagFilterResCache.pTableEntry, freeCacheEntryFp);
+ taosThreadMutexInit(&pMeta->pCache->sTagFilterResCache.lock, NULL);
- pCache->STbGroupResCache.pResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5);
- if (pCache->STbGroupResCache.pResCache == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err2;
+ pMeta->pCache->STbGroupResCache.pResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5);
+ if (pMeta->pCache->STbGroupResCache.pResCache == NULL) {
+ TSDB_CHECK_CODE(code = terrno, lino, _exit);
}
- pCache->STbGroupResCache.accTimes = 0;
- pCache->STbGroupResCache.pTableEntry =
+ pMeta->pCache->STbGroupResCache.accTimes = 0;
+ pMeta->pCache->STbGroupResCache.pTableEntry =
taosHashInit(1024, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK);
- if (pCache->STbGroupResCache.pTableEntry == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err2;
+ if (pMeta->pCache->STbGroupResCache.pTableEntry == NULL) {
+ TSDB_CHECK_CODE(code = terrno, lino, _exit);
}
- taosHashSetFreeFp(pCache->STbGroupResCache.pTableEntry, freeCacheEntryFp);
- taosThreadMutexInit(&pCache->STbGroupResCache.lock, NULL);
+ taosHashSetFreeFp(pMeta->pCache->STbGroupResCache.pTableEntry, freeCacheEntryFp);
+ taosThreadMutexInit(&pMeta->pCache->STbGroupResCache.lock, NULL);
- pCache->STbFilterCache.pStb = taosHashInit(0, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
- if (pCache->STbFilterCache.pStb == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err2;
+ pMeta->pCache->STbFilterCache.pStb =
+ taosHashInit(0, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
+ if (pMeta->pCache->STbFilterCache.pStb == NULL) {
+ TSDB_CHECK_CODE(code = terrno, lino, _exit);
}
- pCache->STbFilterCache.pStbName =
+ pMeta->pCache->STbFilterCache.pStbName =
taosHashInit(0, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK);
- if (pCache->STbFilterCache.pStbName == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err2;
+ if (pMeta->pCache->STbFilterCache.pStbName == NULL) {
+ TSDB_CHECK_CODE(code = terrno, lino, _exit);
}
- pMeta->pCache = pCache;
- return code;
-
-_err2:
- entryCacheClose(pMeta);
-
-_err:
- taosMemoryFree(pCache);
- metaError("vgId:%d, meta open cache failed since %s", TD_VID(pMeta->pVnode), tstrerror(code));
+_exit:
+ if (code) {
+ metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, lino, tstrerror(code));
+ metaCacheClose(pMeta);
+ } else {
+ metaDebug("vgId:%d, %s success", TD_VID(pMeta->pVnode), __func__);
+ }
return code;
}
@@ -289,8 +279,7 @@ int32_t metaCacheUpsert(SMeta* pMeta, SMetaInfo* pInfo) {
}
} else { // insert
if (pCache->sEntryCache.nEntry >= pCache->sEntryCache.nBucket) {
- code = metaRehashCache(pCache, 1);
- if (code) goto _exit;
+ TAOS_UNUSED(metaRehashCache(pCache, 1));
iBucket = TABS(pInfo->uid) % pCache->sEntryCache.nBucket;
}
@@ -328,8 +317,7 @@ int32_t metaCacheDrop(SMeta* pMeta, int64_t uid) {
pCache->sEntryCache.nEntry--;
if (pCache->sEntryCache.nEntry < pCache->sEntryCache.nBucket / 4 &&
pCache->sEntryCache.nBucket > META_CACHE_BASE_BUCKET) {
- code = metaRehashCache(pCache, 0);
- if (code) goto _exit;
+ TAOS_UNUSED(metaRehashCache(pCache, 0));
}
} else {
code = TSDB_CODE_NOT_FOUND;
@@ -351,7 +339,9 @@ int32_t metaCacheGet(SMeta* pMeta, int64_t uid, SMetaInfo* pInfo) {
}
if (pEntry) {
- *pInfo = pEntry->info;
+ if (pInfo) {
+ *pInfo = pEntry->info;
+ }
} else {
code = TSDB_CODE_NOT_FOUND;
}
@@ -415,9 +405,7 @@ int32_t metaStatsCacheUpsert(SMeta* pMeta, SMetaStbStats* pInfo) {
(*ppEntry)->info.ctbNum = pInfo->ctbNum;
} else { // insert
if (pCache->sStbStatsCache.nEntry >= pCache->sStbStatsCache.nBucket) {
- code = metaRehashStatsCache(pCache, 1);
- if (code) goto _exit;
-
+ TAOS_UNUSED(metaRehashStatsCache(pCache, 1));
iBucket = TABS(pInfo->uid) % pCache->sStbStatsCache.nBucket;
}
@@ -454,8 +442,7 @@ int32_t metaStatsCacheDrop(SMeta* pMeta, int64_t uid) {
pCache->sStbStatsCache.nEntry--;
if (pCache->sStbStatsCache.nEntry < pCache->sStbStatsCache.nBucket / 4 &&
pCache->sStbStatsCache.nBucket > META_CACHE_STATS_BUCKET) {
- code = metaRehashStatsCache(pCache, 0);
- if (code) goto _exit;
+ TAOS_UNUSED(metaRehashStatsCache(pCache, 0));
}
} else {
code = TSDB_CODE_NOT_FOUND;
@@ -477,7 +464,9 @@ int32_t metaStatsCacheGet(SMeta* pMeta, int64_t uid, SMetaStbStats* pInfo) {
}
if (pEntry) {
- *pInfo = pEntry->info;
+ if (pInfo) {
+ *pInfo = pEntry->info;
+ }
} else {
code = TSDB_CODE_NOT_FOUND;
}
@@ -502,7 +491,9 @@ static int checkAllEntriesInCache(const STagFilterResEntry* pEntry, SArray* pInv
// check whether it is existed in LRU cache, and remove it from linked list if not.
LRUHandle* pRes = taosLRUCacheLookup(pCache, buf, len);
if (pRes == NULL) { // remove the item in the linked list
- taosArrayPush(pInvalidRes, &pNode);
+ if (taosArrayPush(pInvalidRes, &pNode) == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
} else {
taosLRUCacheRelease(pCache, pRes, false);
}
@@ -626,7 +617,7 @@ static int32_t addNewEntry(SHashObj* pTableEntry, const void* pKey, int32_t keyL
p->hitTimes = 0;
tdListInit(&p->list, keyLen);
- taosHashPut(pTableEntry, &suid, sizeof(uint64_t), &p, POINTER_BYTES);
+ TAOS_CHECK_RETURN(taosHashPut(pTableEntry, &suid, sizeof(uint64_t), &p, POINTER_BYTES));
tdListAppend(&p->list, pKey);
return 0;
}
@@ -956,9 +947,7 @@ int32_t metaInitTbFilterCache(SMeta* pMeta) {
}
if (tbNum && pTbArr) {
for (int32_t i = 0; i < tbNum; ++i) {
- if (metaPutTbToFilterCache(pMeta, pTbArr[i], 1) != 0) {
- return terrno ? terrno : -1;
- }
+ TAOS_CHECK_RETURN(metaPutTbToFilterCache(pMeta, pTbArr[i], 1));
}
}
#else
diff --git a/source/dnode/vnode/src/meta/metaCommit.c b/source/dnode/vnode/src/meta/metaCommit.c
index f8b41e413b..bbf2217b31 100644
--- a/source/dnode/vnode/src/meta/metaCommit.c
+++ b/source/dnode/vnode/src/meta/metaCommit.c
@@ -21,7 +21,10 @@ static FORCE_INLINE void *metaMalloc(void *pPool, size_t size) {
static FORCE_INLINE void metaFree(void *pPool, void *p) { vnodeBufPoolFree((SVBufPool *)pPool, p); }
// begin a meta txn
-int metaBegin(SMeta *pMeta, int8_t heap) {
+int32_t metaBegin(SMeta *pMeta, int8_t heap) {
+ int32_t code = 0;
+ int32_t lino;
+
void *(*xMalloc)(void *, size_t) = NULL;
void (*xFree)(void *, void *) = NULL;
void *xArg = NULL;
@@ -36,12 +39,19 @@ int metaBegin(SMeta *pMeta, int8_t heap) {
xArg = pMeta->pVnode->inUse;
}
- if (tdbBegin(pMeta->pEnv, &pMeta->txn, xMalloc, xFree, xArg, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED) < 0) {
- return -1;
+ code = tdbBegin(pMeta->pEnv, &pMeta->txn, xMalloc, xFree, xArg, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED);
+ TSDB_CHECK_CODE(code, lino, _exit);
+
+ code = tdbCommit(pMeta->pEnv, pMeta->txn);
+ TSDB_CHECK_CODE(code, lino, _exit);
+
+_exit:
+ if (code) {
+ metaError("vgId:%d %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__,
+ tstrerror(terrno));
+ } else {
+ metaDebug("vgId:%d %s success", TD_VID(pMeta->pVnode), __func__);
}
-
- tdbCommit(pMeta->pEnv, pMeta->txn);
-
return 0;
}
@@ -49,20 +59,36 @@ int metaBegin(SMeta *pMeta, int8_t heap) {
TXN *metaGetTxn(SMeta *pMeta) { return pMeta->txn; }
int metaCommit(SMeta *pMeta, TXN *txn) { return tdbCommit(pMeta->pEnv, txn); }
int metaFinishCommit(SMeta *pMeta, TXN *txn) { return tdbPostCommit(pMeta->pEnv, txn); }
-int metaPrepareAsyncCommit(SMeta *pMeta) {
- // return tdbPrepareAsyncCommit(pMeta->pEnv, pMeta->txn);
- int code = 0;
+
+int metaPrepareAsyncCommit(SMeta *pMeta) {
+ // return tdbPrepareAsyncCommit(pMeta->pEnv, pMeta->txn);
+ int code = 0;
+ int32_t lino;
+
metaWLock(pMeta);
- code = ttlMgrFlush(pMeta->pTtlMgr, pMeta->txn);
+ TAOS_UNUSED(ttlMgrFlush(pMeta->pTtlMgr, pMeta->txn));
metaULock(pMeta);
+
code = tdbCommit(pMeta->pEnv, pMeta->txn);
+ TSDB_CHECK_CODE(code, lino, _exit);
pMeta->changed = false;
+
+_exit:
+ if (code) {
+ metaError("vgId:%d %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, __LINE__,
+ tstrerror(terrno));
+ } else {
+ metaDebug("vgId:%d %s success", TD_VID(pMeta->pVnode), __func__);
+ }
return code;
}
// abort the meta txn
int metaAbort(SMeta *pMeta) {
- if (!pMeta->txn) return 0;
+ if (!pMeta->txn) {
+ return 0;
+ }
+
int code = tdbAbort(pMeta->pEnv, pMeta->txn);
if (code) {
metaError("vgId:%d, failed to abort meta since %s", TD_VID(pMeta->pVnode), tstrerror(terrno));
diff --git a/source/dnode/vnode/src/meta/metaEntry.c b/source/dnode/vnode/src/meta/metaEntry.c
index 9a111ae2d4..6e94cca390 100644
--- a/source/dnode/vnode/src/meta/metaEntry.c
+++ b/source/dnode/vnode/src/meta/metaEntry.c
@@ -17,159 +17,166 @@
int meteEncodeColCmprEntry(SEncoder *pCoder, const SMetaEntry *pME) {
const SColCmprWrapper *pw = &pME->colCmpr;
- if (tEncodeI32v(pCoder, pw->nCols) < 0) return -1;
- if (tEncodeI32v(pCoder, pw->version) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pw->nCols));
+ TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pw->version));
uDebug("encode cols:%d", pw->nCols);
for (int32_t i = 0; i < pw->nCols; i++) {
SColCmpr *p = &pw->pColCmpr[i];
- if (tEncodeI16v(pCoder, p->id) < 0) return -1;
- if (tEncodeU32(pCoder, p->alg) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI16v(pCoder, p->id));
+ TAOS_CHECK_RETURN(tEncodeU32(pCoder, p->alg));
}
return 0;
}
int meteDecodeColCmprEntry(SDecoder *pDecoder, SMetaEntry *pME) {
SColCmprWrapper *pWrapper = &pME->colCmpr;
- if (tDecodeI32v(pDecoder, &pWrapper->nCols) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pWrapper->nCols));
if (pWrapper->nCols == 0) {
return 0;
}
- if (tDecodeI32v(pDecoder, &pWrapper->version) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pWrapper->version));
uDebug("dencode cols:%d", pWrapper->nCols);
pWrapper->pColCmpr = (SColCmpr *)tDecoderMalloc(pDecoder, pWrapper->nCols * sizeof(SColCmpr));
- if (pWrapper->pColCmpr == NULL) return -1;
+ if (pWrapper->pColCmpr == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
for (int i = 0; i < pWrapper->nCols; i++) {
SColCmpr *p = &pWrapper->pColCmpr[i];
- if (tDecodeI16v(pDecoder, &p->id) < 0) return -1;
- if (tDecodeU32(pDecoder, &p->alg) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI16v(pDecoder, &p->id));
+ TAOS_CHECK_RETURN(tDecodeU32(pDecoder, &p->alg));
}
return 0;
}
-static FORCE_INLINE void metatInitDefaultSColCmprWrapper(SDecoder *pDecoder, SColCmprWrapper *pCmpr,
- SSchemaWrapper *pSchema) {
+static FORCE_INLINE int32_t metatInitDefaultSColCmprWrapper(SDecoder *pDecoder, SColCmprWrapper *pCmpr,
+ SSchemaWrapper *pSchema) {
pCmpr->nCols = pSchema->nCols;
- pCmpr->pColCmpr = (SColCmpr *)tDecoderMalloc(pDecoder, pCmpr->nCols * sizeof(SColCmpr));
+ if ((pCmpr->pColCmpr = (SColCmpr *)tDecoderMalloc(pDecoder, pCmpr->nCols * sizeof(SColCmpr))) == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+
for (int32_t i = 0; i < pCmpr->nCols; i++) {
SColCmpr *pColCmpr = &pCmpr->pColCmpr[i];
SSchema *pColSchema = &pSchema->pSchema[i];
pColCmpr->id = pColSchema->colId;
pColCmpr->alg = createDefaultColCmprByType(pColSchema->type);
}
+ return 0;
}
int metaEncodeEntry(SEncoder *pCoder, const SMetaEntry *pME) {
- if (tStartEncode(pCoder) < 0) return -1;
+ TAOS_CHECK_RETURN(tStartEncode(pCoder));
+ TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->version));
+ TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->type));
+ TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->uid));
- if (tEncodeI64(pCoder, pME->version) < 0) return -1;
- if (tEncodeI8(pCoder, pME->type) < 0) return -1;
- if (tEncodeI64(pCoder, pME->uid) < 0) return -1;
- if (pME->name == NULL || tEncodeCStr(pCoder, pME->name) < 0) return -1;
+ if (pME->name == NULL) {
+ return TSDB_CODE_INVALID_PARA;
+ }
+
+ TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->name));
if (pME->type == TSDB_SUPER_TABLE) {
- if (tEncodeI8(pCoder, pME->flags) < 0) return -1; // TODO: need refactor?
- if (tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaRow) < 0) return -1;
- if (tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaTag) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI8(pCoder, pME->flags));
+ TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaRow));
+ TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->stbEntry.schemaTag));
if (TABLE_IS_ROLLUP(pME->flags)) {
- if (tEncodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam));
}
} else if (pME->type == TSDB_CHILD_TABLE) {
- if (tEncodeI64(pCoder, pME->ctbEntry.btime) < 0) return -1;
- if (tEncodeI32(pCoder, pME->ctbEntry.ttlDays) < 0) return -1;
- if (tEncodeI32v(pCoder, pME->ctbEntry.commentLen) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.btime));
+ TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ctbEntry.ttlDays));
+ TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ctbEntry.commentLen));
if (pME->ctbEntry.commentLen > 0) {
- if (tEncodeCStr(pCoder, pME->ctbEntry.comment) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ctbEntry.comment));
}
- if (tEncodeI64(pCoder, pME->ctbEntry.suid) < 0) return -1;
- if (tEncodeTag(pCoder, (const STag *)pME->ctbEntry.pTags) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ctbEntry.suid));
+ TAOS_CHECK_RETURN(tEncodeTag(pCoder, (const STag *)pME->ctbEntry.pTags));
} else if (pME->type == TSDB_NORMAL_TABLE) {
- if (tEncodeI64(pCoder, pME->ntbEntry.btime) < 0) return -1;
- if (tEncodeI32(pCoder, pME->ntbEntry.ttlDays) < 0) return -1;
- if (tEncodeI32v(pCoder, pME->ntbEntry.commentLen) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI64(pCoder, pME->ntbEntry.btime));
+ TAOS_CHECK_RETURN(tEncodeI32(pCoder, pME->ntbEntry.ttlDays));
+ TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.commentLen));
if (pME->ntbEntry.commentLen > 0) {
- if (tEncodeCStr(pCoder, pME->ntbEntry.comment) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeCStr(pCoder, pME->ntbEntry.comment));
}
- if (tEncodeI32v(pCoder, pME->ntbEntry.ncid) < 0) return -1;
- if (tEncodeSSchemaWrapper(pCoder, &pME->ntbEntry.schemaRow) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeI32v(pCoder, pME->ntbEntry.ncid));
+ TAOS_CHECK_RETURN(tEncodeSSchemaWrapper(pCoder, &pME->ntbEntry.schemaRow));
} else if (pME->type == TSDB_TSMA_TABLE) {
- if (tEncodeTSma(pCoder, pME->smaEntry.tsma) < 0) return -1;
+ TAOS_CHECK_RETURN(tEncodeTSma(pCoder, pME->smaEntry.tsma));
} else {
metaError("meta/entry: invalide table type: %" PRId8 " encode failed.", pME->type);
-
- return -1;
+ return TSDB_CODE_INVALID_PARA;
}
- if (meteEncodeColCmprEntry(pCoder, pME) < 0) return -1;
+ TAOS_CHECK_RETURN(meteEncodeColCmprEntry(pCoder, pME));
tEndEncode(pCoder);
return 0;
}
int metaDecodeEntry(SDecoder *pCoder, SMetaEntry *pME) {
- if (tStartDecode(pCoder) < 0) return -1;
-
- if (tDecodeI64(pCoder, &pME->version) < 0) return -1;
- if (tDecodeI8(pCoder, &pME->type) < 0) return -1;
- if (tDecodeI64(pCoder, &pME->uid) < 0) return -1;
- if (tDecodeCStr(pCoder, &pME->name) < 0) return -1;
+ TAOS_CHECK_RETURN(tStartDecode(pCoder));
+ TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->version));
+ TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->type));
+ TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->uid));
+ TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->name));
if (pME->type == TSDB_SUPER_TABLE) {
- if (tDecodeI8(pCoder, &pME->flags) < 0) return -1; // TODO: need refactor?
- if (tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaRow) < 0) return -1;
- if (tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaTag) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI8(pCoder, &pME->flags));
+ TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaRow));
+ TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->stbEntry.schemaTag));
if (TABLE_IS_ROLLUP(pME->flags)) {
- if (tDecodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeSRSmaParam(pCoder, &pME->stbEntry.rsmaParam));
}
} else if (pME->type == TSDB_CHILD_TABLE) {
- if (tDecodeI64(pCoder, &pME->ctbEntry.btime) < 0) return -1;
- if (tDecodeI32(pCoder, &pME->ctbEntry.ttlDays) < 0) return -1;
- if (tDecodeI32v(pCoder, &pME->ctbEntry.commentLen) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.btime));
+ TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ctbEntry.ttlDays));
+ TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ctbEntry.commentLen));
if (pME->ctbEntry.commentLen > 0) {
- if (tDecodeCStr(pCoder, &pME->ctbEntry.comment) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ctbEntry.comment));
}
- if (tDecodeI64(pCoder, &pME->ctbEntry.suid) < 0) return -1;
- if (tDecodeTag(pCoder, (STag **)&pME->ctbEntry.pTags) < 0) return -1; // (TODO)
+ TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ctbEntry.suid));
+ TAOS_CHECK_RETURN(tDecodeTag(pCoder, (STag **)&pME->ctbEntry.pTags));
} else if (pME->type == TSDB_NORMAL_TABLE) {
- if (tDecodeI64(pCoder, &pME->ntbEntry.btime) < 0) return -1;
- if (tDecodeI32(pCoder, &pME->ntbEntry.ttlDays) < 0) return -1;
- if (tDecodeI32v(pCoder, &pME->ntbEntry.commentLen) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI64(pCoder, &pME->ntbEntry.btime));
+ TAOS_CHECK_RETURN(tDecodeI32(pCoder, &pME->ntbEntry.ttlDays));
+ TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.commentLen));
if (pME->ntbEntry.commentLen > 0) {
- if (tDecodeCStr(pCoder, &pME->ntbEntry.comment) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeCStr(pCoder, &pME->ntbEntry.comment));
}
- if (tDecodeI32v(pCoder, &pME->ntbEntry.ncid) < 0) return -1;
- if (tDecodeSSchemaWrapperEx(pCoder, &pME->ntbEntry.schemaRow) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeI32v(pCoder, &pME->ntbEntry.ncid));
+ TAOS_CHECK_RETURN(tDecodeSSchemaWrapperEx(pCoder, &pME->ntbEntry.schemaRow));
} else if (pME->type == TSDB_TSMA_TABLE) {
pME->smaEntry.tsma = tDecoderMalloc(pCoder, sizeof(STSma));
if (!pME->smaEntry.tsma) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return -1;
+ return TSDB_CODE_OUT_OF_MEMORY;
}
- if (tDecodeTSma(pCoder, pME->smaEntry.tsma, true) < 0) return -1;
+ TAOS_CHECK_RETURN(tDecodeTSma(pCoder, pME->smaEntry.tsma, true));
} else {
metaError("meta/entry: invalide table type: %" PRId8 " decode failed.", pME->type);
- return -1;
+ return TSDB_CODE_INVALID_PARA;
}
if (pME->type == TSDB_SUPER_TABLE) {
if (TABLE_IS_COL_COMPRESSED(pME->flags)) {
- if (meteDecodeColCmprEntry(pCoder, pME) < 0) return -1;
+ TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME));
if (pME->colCmpr.nCols == 0) {
- metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow);
+ TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow));
}
} else {
- metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow);
+ TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->stbEntry.schemaRow));
TABLE_SET_COL_COMPRESSED(pME->flags);
}
} else if (pME->type == TSDB_NORMAL_TABLE) {
if (!tDecodeIsEnd(pCoder)) {
uDebug("set type: %d, tableName:%s", pME->type, pME->name);
- if (meteDecodeColCmprEntry(pCoder, pME) < 0) return -1;
+ TAOS_CHECK_RETURN(meteDecodeColCmprEntry(pCoder, pME));
if (pME->colCmpr.nCols == 0) {
- metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow);
+ TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow));
}
} else {
uDebug("set default type: %d, tableName:%s", pME->type, pME->name);
- metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow);
+ TAOS_CHECK_RETURN(metatInitDefaultSColCmprWrapper(pCoder, &pME->colCmpr, &pME->ntbEntry.schemaRow));
}
TABLE_SET_COL_COMPRESSED(pME->flags);
}
diff --git a/source/dnode/vnode/src/meta/metaIdx.c b/source/dnode/vnode/src/meta/metaIdx.c
deleted file mode 100644
index dc62ab2b9f..0000000000
--- a/source/dnode/vnode/src/meta/metaIdx.c
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see .
- */
-
-#ifdef USE_INVERTED_INDEX
-#include "index.h"
-#endif
-#include "meta.h"
-
-struct SMetaIdx {
-#ifdef USE_INVERTED_INDEX
- SIndex *pIdx;
-#endif
- /* data */
-#ifdef WINDOWS
- size_t avoidCompilationErrors;
-#endif
-};
-
-int metaOpenIdx(SMeta *pMeta) {
-#if 0
- char idxDir[128]; // TODO
- char * err = NULL;
- rocksdb_options_t *options = rocksdb_options_create();
-
- // TODO
- sprintf(idxDir, "%s/index", pMeta->path);
-
- if (pMeta->pCache) {
- rocksdb_options_set_row_cache(options, pMeta->pCache);
- }
- rocksdb_options_set_create_if_missing(options, 1);
-
- pMeta->pIdx = rocksdb_open(options, idxDir, &err);
- if (pMeta->pIdx == NULL) {
- // TODO: handle error
- rocksdb_options_destroy(options);
- return -1;
- }
-
- rocksdb_options_destroy(options);
-#endif
-
-#ifdef USE_INVERTED_INDEX
- // SIndexOpts opts;
- // if (indexOpen(&opts, pMeta->path, &pMeta->pIdx->pIdx) != 0) {
- // return -1;
- //}
-
-#endif
- return 0;
-}
-
-#ifdef BUILD_NO_CALL
-void metaCloseIdx(SMeta *pMeta) { /* TODO */
-#if 0
- if (pMeta->pIdx) {
- rocksdb_close(pMeta->pIdx);
- pMeta->pIdx = NULL;
- }
-#endif
-
-#ifdef USE_INVERTED_INDEX
- // SIndexOpts opts;
- // if (indexClose(pMeta->pIdx->pIdx) != 0) {
- // return -1;
- //}
- // return 0;
-
-#endif
-}
-
-int metaSaveTableToIdx(SMeta *pMeta, const STbCfg *pTbCfg) {
-#ifdef USE_INVERTED_INDEX
- // if (pTbCfgs->type == META_CHILD_TABLE) {
- // char buf[8] = {0};
- // int16_t colId = (kvRowColIdx(pTbCfg->ctbCfg.pTag))[0].colId;
- // sprintf(buf, "%d", colId); // colname
-
- // char *pTagVal = (char *)tdGetKVRowValOfCol(pTbCfg->ctbCfg.pTag, (kvRowColIdx(pTbCfg->ctbCfg.pTag))[0].colId);
-
- // tb_uid_t suid = pTbCfg->ctbCfg.suid; // super id
- // tb_uid_t tuid = 0; // child table uid
- // SIndexMultiTerm *terms = indexMultiTermCreate();
- // SIndexTerm *term =
- // indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_BINARY, buf, strlen(buf), pTagVal, strlen(pTagVal), tuid);
- // indexMultiTermAdd(terms, term);
-
- // int ret = indexPut(pMeta->pIdx->pIdx, terms);
- // indexMultiTermDestroy(terms);
- // return ret;
- //} else {
- // return DB_DONOTINDEX;
- //}
-#endif
- // TODO
- return 0;
-}
-
-int metaRemoveTableFromIdx(SMeta *pMeta, tb_uid_t uid) {
-#ifdef USE_INVERTED_INDEX
-
-#endif
- // TODO
- return 0;
-}
-#endif
\ No newline at end of file
diff --git a/source/dnode/vnode/src/meta/metaOpen.c b/source/dnode/vnode/src/meta/metaOpen.c
index e3b3de6cd6..ec26e94c5a 100644
--- a/source/dnode/vnode/src/meta/metaOpen.c
+++ b/source/dnode/vnode/src/meta/metaOpen.c
@@ -39,13 +39,13 @@ static int32_t metaDestroyLock(SMeta *pMeta) { return taosThreadRwlockDestroy(&p
static void metaCleanup(SMeta **ppMeta);
-int metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) {
- SMeta *pMeta = NULL;
- int ret;
- int offset;
- char path[TSDB_FILENAME_LEN] = {0};
-
- *ppMeta = NULL;
+int32_t metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) {
+ SMeta *pMeta = NULL;
+ int32_t code = 0;
+ int32_t lino;
+ int32_t offset;
+ char path[TSDB_FILENAME_LEN] = {0};
+ char indexFullPath[128] = {0};
// create handle
vnodeGetPrimaryDir(pVnode->path, pVnode->diskPrimary, pVnode->pTfs, path, TSDB_FILENAME_LEN);
@@ -53,8 +53,7 @@ int metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) {
snprintf(path + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, VNODE_META_DIR);
if ((pMeta = taosMemoryCalloc(1, sizeof(*pMeta) + strlen(path) + 1)) == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return -1;
+ TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
}
metaInitLock(pMeta);
@@ -69,163 +68,104 @@ int metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) {
taosMkDir(pMeta->path);
// open env
- ret = tdbOpen(pMeta->path, pVnode->config.szPage, pVnode->config.szCache, &pMeta->pEnv, rollback,
- pVnode->config.tdbEncryptAlgorithm, pVnode->config.tdbEncryptKey);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta env since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbOpen(pMeta->path, pVnode->config.szPage, pVnode->config.szCache, &pMeta->pEnv, rollback,
+ pVnode->config.tdbEncryptAlgorithm, pVnode->config.tdbEncryptKey);
+ TSDB_CHECK_CODE(code, lino, _exit);
// open pTbDb
- ret = tdbTbOpen("table.db", sizeof(STbDbKey), -1, tbDbKeyCmpr, pMeta->pEnv, &pMeta->pTbDb, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta table db since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("table.db", sizeof(STbDbKey), -1, tbDbKeyCmpr, pMeta->pEnv, &pMeta->pTbDb, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
// open pSkmDb
- ret = tdbTbOpen("schema.db", sizeof(SSkmDbKey), -1, skmDbKeyCmpr, pMeta->pEnv, &pMeta->pSkmDb, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta schema db since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("schema.db", sizeof(SSkmDbKey), -1, skmDbKeyCmpr, pMeta->pEnv, &pMeta->pSkmDb, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
// open pUidIdx
- ret = tdbTbOpen("uid.idx", sizeof(tb_uid_t), sizeof(SUidIdxVal), uidIdxKeyCmpr, pMeta->pEnv, &pMeta->pUidIdx, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta uid idx since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("uid.idx", sizeof(tb_uid_t), sizeof(SUidIdxVal), uidIdxKeyCmpr, pMeta->pEnv, &pMeta->pUidIdx, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
// open pNameIdx
- ret = tdbTbOpen("name.idx", -1, sizeof(tb_uid_t), NULL, pMeta->pEnv, &pMeta->pNameIdx, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta name index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("name.idx", -1, sizeof(tb_uid_t), NULL, pMeta->pEnv, &pMeta->pNameIdx, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
// open pCtbIdx
- ret = tdbTbOpen("ctb.idx", sizeof(SCtbIdxKey), -1, ctbIdxKeyCmpr, pMeta->pEnv, &pMeta->pCtbIdx, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta child table index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("ctb.idx", sizeof(SCtbIdxKey), -1, ctbIdxKeyCmpr, pMeta->pEnv, &pMeta->pCtbIdx, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
// open pSuidIdx
- ret = tdbTbOpen("suid.idx", sizeof(tb_uid_t), 0, uidIdxKeyCmpr, pMeta->pEnv, &pMeta->pSuidIdx, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta super table index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("suid.idx", sizeof(tb_uid_t), 0, uidIdxKeyCmpr, pMeta->pEnv, &pMeta->pSuidIdx, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
- char indexFullPath[128] = {0};
sprintf(indexFullPath, "%s/%s", pMeta->path, "invert");
- taosMkDir(indexFullPath);
+ TAOS_UNUSED(taosMkDir(indexFullPath));
SIndexOpts opts = {.cacheSize = 8 * 1024 * 1024};
- ret = indexOpen(&opts, indexFullPath, (SIndex **)&pMeta->pTagIvtIdx);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta tag index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = indexOpen(&opts, indexFullPath, (SIndex **)&pMeta->pTagIvtIdx);
+ TSDB_CHECK_CODE(code, lino, _exit);
- ret = tdbTbOpen("tag.idx", -1, 0, tagIdxKeyCmpr, pMeta->pEnv, &pMeta->pTagIdx, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta tag index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("tag.idx", -1, 0, tagIdxKeyCmpr, pMeta->pEnv, &pMeta->pTagIdx, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
// open pTtlMgr ("ttlv1.idx")
char logPrefix[128] = {0};
sprintf(logPrefix, "vgId:%d", TD_VID(pVnode));
- ret = ttlMgrOpen(&pMeta->pTtlMgr, pMeta->pEnv, 0, logPrefix, tsTtlFlushThreshold);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta ttl index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = ttlMgrOpen(&pMeta->pTtlMgr, pMeta->pEnv, 0, logPrefix, tsTtlFlushThreshold);
+ TSDB_CHECK_CODE(code, lino, _exit);
// open pSmaIdx
- ret = tdbTbOpen("sma.idx", sizeof(SSmaIdxKey), 0, smaIdxKeyCmpr, pMeta->pEnv, &pMeta->pSmaIdx, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta sma index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("sma.idx", sizeof(SSmaIdxKey), 0, smaIdxKeyCmpr, pMeta->pEnv, &pMeta->pSmaIdx, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
// idx table create time
- ret = tdbTbOpen("ctime.idx", sizeof(SBtimeIdxKey), 0, btimeIdxCmpr, pMeta->pEnv, &pMeta->pBtimeIdx, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta ctime index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("ctime.idx", sizeof(SBtimeIdxKey), 0, btimeIdxCmpr, pMeta->pEnv, &pMeta->pBtimeIdx, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
// idx num of col, normal table only
- ret = tdbTbOpen("ncol.idx", sizeof(SNcolIdxKey), 0, ncolIdxCmpr, pMeta->pEnv, &pMeta->pNcolIdx, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta ncol index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("ncol.idx", sizeof(SNcolIdxKey), 0, ncolIdxCmpr, pMeta->pEnv, &pMeta->pNcolIdx, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
- ret = tdbTbOpen("stream.task.db", sizeof(int64_t), -1, taskIdxKeyCmpr, pMeta->pEnv, &pMeta->pStreamDb, 0);
- if (ret < 0) {
- metaError("vgId:%d, failed to open meta stream task index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = tdbTbOpen("stream.task.db", sizeof(int64_t), -1, taskIdxKeyCmpr, pMeta->pEnv, &pMeta->pStreamDb, 0);
+ TSDB_CHECK_CODE(code, lino, _exit);
- // open index
- if (metaOpenIdx(pMeta) < 0) {
- metaError("vgId:%d, failed to open meta index since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ code = metaCacheOpen(pMeta);
+ TSDB_CHECK_CODE(code, lino, _exit);
- int32_t code = metaCacheOpen(pMeta);
+ code = metaInitTbFilterCache(pMeta);
+ TSDB_CHECK_CODE(code, lino, _exit);
+
+_exit:
if (code) {
- terrno = code;
- metaError("vgId:%d, failed to open meta cache since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
+ metaError("vgId:%d %s failed at %s:%d since %s", TD_VID(pVnode), __func__, __FILE__, __LINE__, tstrerror(code));
+ metaCleanup(&pMeta);
+ *ppMeta = NULL;
+ } else {
+ metaDebug("vgId:%d %s success", TD_VID(pVnode), __func__);
+ *ppMeta = pMeta;
}
-
- if (metaInitTbFilterCache(pMeta) != 0) {
- goto _err;
- }
-
- metaDebug("vgId:%d, meta is opened", TD_VID(pVnode));
-
- *ppMeta = pMeta;
- return 0;
-
-_err:
- metaCleanup(&pMeta);
- return -1;
+ return code;
}
-int metaUpgrade(SVnode *pVnode, SMeta **ppMeta) {
- int code = TSDB_CODE_SUCCESS;
- SMeta *pMeta = *ppMeta;
+int32_t metaUpgrade(SVnode *pVnode, SMeta **ppMeta) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino;
+ SMeta *pMeta = *ppMeta;
if (ttlMgrNeedUpgrade(pMeta->pEnv)) {
code = metaBegin(pMeta, META_BEGIN_HEAP_OS);
- if (code < 0) {
- metaError("vgId:%d, failed to upgrade meta, meta begin failed since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ TSDB_CHECK_CODE(code, lino, _exit);
code = ttlMgrUpgrade(pMeta->pTtlMgr, pMeta);
- if (code < 0) {
- metaError("vgId:%d, failed to upgrade meta ttl since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ TSDB_CHECK_CODE(code, lino, _exit);
code = metaCommit(pMeta, pMeta->txn);
- if (code < 0) {
- metaError("vgId:%d, failed to upgrade meta ttl, meta commit failed since %s", TD_VID(pVnode), tstrerror(terrno));
- goto _err;
- }
+ TSDB_CHECK_CODE(code, lino, _exit);
}
- return TSDB_CODE_SUCCESS;
-
-_err:
- metaCleanup(ppMeta);
+_exit:
+ if (code) {
+ metaError("vgId:%d %s failed at %s:%d since %s", TD_VID(pVnode), __func__, __FILE__, __LINE__, tstrerror(code));
+ metaCleanup(ppMeta);
+ }
return code;
}
@@ -235,33 +175,42 @@ int metaClose(SMeta **ppMeta) {
}
int metaAlterCache(SMeta *pMeta, int32_t nPage) {
+ int32_t code = 0;
metaWLock(pMeta);
-
- if (tdbAlter(pMeta->pEnv, nPage) < 0) {
- metaULock(pMeta);
- return -1;
- }
-
+ code = tdbAlter(pMeta->pEnv, nPage);
metaULock(pMeta);
- return 0;
+
+ if (code) {
+ metaError("vgId:%d %s failed since %s", TD_VID(pMeta->pVnode), __func__, tstrerror(code));
+ }
+ return code;
}
int32_t metaRLock(SMeta *pMeta) {
metaTrace("meta rlock %p", &pMeta->lock);
- int32_t ret = taosThreadRwlockRdlock(&pMeta->lock);
- return ret;
+ int32_t code = taosThreadRwlockRdlock(&pMeta->lock);
+ if (code) {
+ return TAOS_SYSTEM_ERROR(code);
+ }
+ return 0;
}
int32_t metaWLock(SMeta *pMeta) {
metaTrace("meta wlock %p", &pMeta->lock);
- int32_t ret = taosThreadRwlockWrlock(&pMeta->lock);
- return ret;
+ int32_t code = taosThreadRwlockWrlock(&pMeta->lock);
+ if (code) {
+ return TAOS_SYSTEM_ERROR(code);
+ }
+ return 0;
}
int32_t metaULock(SMeta *pMeta) {
metaTrace("meta ulock %p", &pMeta->lock);
- int32_t ret = taosThreadRwlockUnlock(&pMeta->lock);
- return ret;
+ int32_t code = taosThreadRwlockUnlock(&pMeta->lock);
+ if (code) {
+ return TAOS_SYSTEM_ERROR(code);
+ }
+ return 0;
}
static void metaCleanup(SMeta **ppMeta) {
diff --git a/source/dnode/vnode/src/meta/metaQuery.c b/source/dnode/vnode/src/meta/metaQuery.c
index 88a551e47c..062c019d48 100644
--- a/source/dnode/vnode/src/meta/metaQuery.c
+++ b/source/dnode/vnode/src/meta/metaQuery.c
@@ -1542,9 +1542,14 @@ int32_t metaGetStbStats(void *pVnode, int64_t uid, int64_t *numOfTables, int32_t
// slow path: search TDB
int64_t ctbNum = 0;
int32_t colNum = 0;
- vnodeGetCtbNum(pVnode, uid, &ctbNum);
- vnodeGetStbColumnNum(pVnode, uid, &colNum);
+ code = vnodeGetCtbNum(pVnode, uid, &ctbNum);
+ if (TSDB_CODE_SUCCESS == code) {
+ code = vnodeGetStbColumnNum(pVnode, uid, &colNum);
+ }
metaULock(pVnodeObj->pMeta);
+ if (TSDB_CODE_SUCCESS != code) {
+ goto _exit;
+ }
if (numOfTables) *numOfTables = ctbNum;
if (numOfCols) *numOfCols = colNum;
diff --git a/source/dnode/vnode/src/meta/metaSnapshot.c b/source/dnode/vnode/src/meta/metaSnapshot.c
index 34d4f8e845..95c65e5e80 100644
--- a/source/dnode/vnode/src/meta/metaSnapshot.c
+++ b/source/dnode/vnode/src/meta/metaSnapshot.c
@@ -25,14 +25,14 @@ struct SMetaSnapReader {
int32_t metaSnapReaderOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapReader** ppReader) {
int32_t code = 0;
+ int32_t lino;
int32_t c = 0;
SMetaSnapReader* pReader = NULL;
// alloc
pReader = (SMetaSnapReader*)taosMemoryCalloc(1, sizeof(*pReader));
if (pReader == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err;
+ TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
}
pReader->pMeta = pMeta;
pReader->sver = sver;
@@ -40,36 +40,29 @@ int32_t metaSnapReaderOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapRe
// impl
code = tdbTbcOpen(pMeta->pTbDb, &pReader->pTbc, NULL);
- if (code) {
- taosMemoryFree(pReader);
- goto _err;
- }
+ TSDB_CHECK_CODE(code, lino, _exit);
code = tdbTbcMoveTo(pReader->pTbc, &(STbDbKey){.version = sver, .uid = INT64_MIN}, sizeof(STbDbKey), &c);
+ TSDB_CHECK_CODE(code, lino, _exit);
+
+_exit:
if (code) {
- taosMemoryFree(pReader);
- goto _err;
+ metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, lino, tstrerror(code));
+ metaSnapReaderClose(&pReader);
+ *ppReader = NULL;
+ } else {
+ metaInfo("vgId:%d, %s success", TD_VID(pMeta->pVnode), __func__);
+ *ppReader = pReader;
}
-
- metaInfo("vgId:%d, vnode snapshot meta reader opened", TD_VID(pMeta->pVnode));
-
- *ppReader = pReader;
- return code;
-
-_err:
- metaError("vgId:%d, vnode snapshot meta reader open failed since %s", TD_VID(pMeta->pVnode), tstrerror(code));
- *ppReader = NULL;
return code;
}
-int32_t metaSnapReaderClose(SMetaSnapReader** ppReader) {
- int32_t code = 0;
-
- tdbTbcClose((*ppReader)->pTbc);
- taosMemoryFree(*ppReader);
- *ppReader = NULL;
-
- return code;
+void metaSnapReaderClose(SMetaSnapReader** ppReader) {
+ if (ppReader && *ppReader) {
+ tdbTbcClose((*ppReader)->pTbc);
+ taosMemoryFree(*ppReader);
+ *ppReader = NULL;
+ }
}
int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) {
@@ -106,7 +99,7 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) {
*ppData = taosMemoryMalloc(sizeof(SSnapDataHdr) + nData);
if (*ppData == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err;
+ goto _exit;
}
SSnapDataHdr* pHdr = (SSnapDataHdr*)(*ppData);
@@ -122,10 +115,10 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) {
}
_exit:
- return code;
-
-_err:
- metaError("vgId:%d, vnode snapshot meta read data failed since %s", TD_VID(pReader->pMeta->pVnode), tstrerror(code));
+ if (code) {
+ metaError("vgId:%d, vnode snapshot meta read data failed since %s", TD_VID(pReader->pMeta->pVnode),
+ tstrerror(code));
+ }
return code;
}
@@ -138,26 +131,30 @@ struct SMetaSnapWriter {
int32_t metaSnapWriterOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapWriter** ppWriter) {
int32_t code = 0;
+ int32_t lino;
SMetaSnapWriter* pWriter;
// alloc
pWriter = (SMetaSnapWriter*)taosMemoryCalloc(1, sizeof(*pWriter));
if (pWriter == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- goto _err;
+ TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
}
pWriter->pMeta = pMeta;
pWriter->sver = sver;
pWriter->ever = ever;
- metaBegin(pMeta, META_BEGIN_HEAP_NIL);
+ code = metaBegin(pMeta, META_BEGIN_HEAP_NIL);
+ TSDB_CHECK_CODE(code, lino, _exit);
- *ppWriter = pWriter;
- return code;
-
-_err:
- metaError("vgId:%d, meta snapshot writer open failed since %s", TD_VID(pMeta->pVnode), tstrerror(code));
- *ppWriter = NULL;
+_exit:
+ if (code) {
+ metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, lino, tstrerror(code));
+ taosMemoryFree(pWriter);
+ *ppWriter = NULL;
+ } else {
+ metaDebug("vgId:%d, %s success", TD_VID(pMeta->pVnode), __func__);
+ *ppWriter = pWriter;
+ }
return code;
}
@@ -189,25 +186,24 @@ _err:
int32_t metaSnapWrite(SMetaSnapWriter* pWriter, uint8_t* pData, uint32_t nData) {
int32_t code = 0;
- int32_t line = 0;
+ int32_t lino = 0;
SMeta* pMeta = pWriter->pMeta;
SMetaEntry metaEntry = {0};
SDecoder* pDecoder = &(SDecoder){0};
tDecoderInit(pDecoder, pData + sizeof(SSnapDataHdr), nData - sizeof(SSnapDataHdr));
code = metaDecodeEntry(pDecoder, &metaEntry);
- VND_CHECK_CODE(code, line, _err);
+ TSDB_CHECK_CODE(code, lino, _exit);
code = metaHandleEntry(pMeta, &metaEntry);
- VND_CHECK_CODE(code, line, _err);
+ TSDB_CHECK_CODE(code, lino, _exit);
+_exit:
+ if (code) {
+ metaError("vgId:%d, %s failed at %s:%d since %s", TD_VID(pMeta->pVnode), __func__, __FILE__, lino, tstrerror(code));
+ }
tDecoderClear(pDecoder);
return code;
-
-_err:
- tDecoderClear(pDecoder);
- metaError("vgId:%d, vnode snapshot meta write failed since %s at line:%d", TD_VID(pMeta->pVnode), terrstr(), line);
- return code;
}
typedef struct STableInfoForChildTable {
@@ -468,19 +464,17 @@ int32_t setForSnapShot(SSnapContext* ctx, int64_t uid) {
return c;
}
-void taosXSetTablePrimaryKey(SSnapContext* ctx, int64_t uid){
- bool ret = false;
- SSchemaWrapper *schema = metaGetTableSchema(ctx->pMeta, uid, -1, 1);
- if (schema->nCols >= 2 && schema->pSchema[1].flags & COL_IS_KEY){
+void taosXSetTablePrimaryKey(SSnapContext* ctx, int64_t uid) {
+ bool ret = false;
+ SSchemaWrapper* schema = metaGetTableSchema(ctx->pMeta, uid, -1, 1);
+ if (schema->nCols >= 2 && schema->pSchema[1].flags & COL_IS_KEY) {
ret = true;
}
tDeleteSchemaWrapper(schema);
ctx->hasPrimaryKey = ret;
}
-bool taosXGetTablePrimaryKey(SSnapContext* ctx){
- return ctx->hasPrimaryKey;
-}
+bool taosXGetTablePrimaryKey(SSnapContext* ctx) { return ctx->hasPrimaryKey; }
int32_t getTableInfoFromSnapshot(SSnapContext* ctx, void** pBuf, int32_t* contLen, int16_t* type, int64_t* uid) {
int32_t ret = 0;
diff --git a/source/dnode/vnode/src/tq/tqMeta.c b/source/dnode/vnode/src/tq/tqMeta.c
index ca536c5bad..d0519ec5e7 100644
--- a/source/dnode/vnode/src/tq/tqMeta.c
+++ b/source/dnode/vnode/src/tq/tqMeta.c
@@ -37,7 +37,7 @@ int32_t tEncodeSTqHandle(SEncoder* pEncoder, const STqHandle* pHandle) {
}
} else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__TABLE) {
if (tEncodeI64(pEncoder, pHandle->execHandle.execTb.suid) < 0) return -1;
- if (pHandle->execHandle.execTb.qmsg != NULL){
+ if (pHandle->execHandle.execTb.qmsg != NULL) {
if (tEncodeCStr(pEncoder, pHandle->execHandle.execTb.qmsg) < 0) return -1;
}
}
@@ -67,7 +67,7 @@ int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle) {
}
} else if (pHandle->execHandle.subType == TOPIC_SUB_TYPE__TABLE) {
if (tDecodeI64(pDecoder, &pHandle->execHandle.execTb.suid) < 0) return -1;
- if (!tDecodeIsEnd(pDecoder)){
+ if (!tDecodeIsEnd(pDecoder)) {
if (tDecodeCStrAlloc(pDecoder, &pHandle->execHandle.execTb.qmsg) < 0) return -1;
}
}
@@ -75,8 +75,8 @@ int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle) {
return 0;
}
-int32_t tqMetaDecodeCheckInfo(STqCheckInfo *info, void *pVal, int32_t vLen){
- SDecoder decoder = {0};
+int32_t tqMetaDecodeCheckInfo(STqCheckInfo* info, void* pVal, int32_t vLen) {
+ SDecoder decoder = {0};
tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
int32_t code = tDecodeSTqCheckInfo(&decoder, info);
if (code != 0) {
@@ -87,8 +87,8 @@ int32_t tqMetaDecodeCheckInfo(STqCheckInfo *info, void *pVal, int32_t vLen){
return code;
}
-int32_t tqMetaDecodeOffsetInfo(STqOffset *info, void *pVal, int32_t vLen){
- SDecoder decoder = {0};
+int32_t tqMetaDecodeOffsetInfo(STqOffset* info, void* pVal, int32_t vLen) {
+ SDecoder decoder = {0};
tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
int32_t code = tDecodeSTqOffset(&decoder, info);
if (code != 0) {
@@ -101,7 +101,7 @@ int32_t tqMetaDecodeOffsetInfo(STqOffset *info, void *pVal, int32_t vLen){
int32_t tqMetaSaveInfo(STQ* pTq, TTB* ttb, const void* key, int32_t kLen, const void* value, int32_t vLen) {
int32_t code = TDB_CODE_SUCCESS;
- TXN* txn = NULL;
+ TXN* txn = NULL;
TQ_ERR_GO_TO_END(tdbBegin(pTq->pMetaDB, &txn, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED));
TQ_ERR_GO_TO_END(tdbTbUpsert(ttb, key, kLen, value, vLen, txn));
@@ -117,7 +117,7 @@ END:
int32_t tqMetaDeleteInfo(STQ* pTq, TTB* ttb, const void* key, int32_t kLen) {
int32_t code = TDB_CODE_SUCCESS;
- TXN* txn = NULL;
+ TXN* txn = NULL;
TQ_ERR_GO_TO_END(tdbBegin(pTq->pMetaDB, &txn, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED));
TQ_ERR_GO_TO_END(tdbTbDelete(ttb, key, kLen, txn));
@@ -131,10 +131,10 @@ END:
return code;
}
-void* tqMetaGetOffset(STQ* pTq, const char* subkey){
+void* tqMetaGetOffset(STQ* pTq, const char* subkey) {
void* data = taosHashGet(pTq->pOffset, subkey, strlen(subkey));
if (data == NULL) {
- int vLen = 0;
+ int vLen = 0;
if (tdbTbGet(pTq->pOffsetStore, subkey, strlen(subkey), &data, &vLen) < 0) {
tdbFree(data);
return NULL;
@@ -146,7 +146,7 @@ void* tqMetaGetOffset(STQ* pTq, const char* subkey){
return NULL;
}
- if(taosHashPut(pTq->pOffset, subkey, strlen(subkey), &offset, sizeof(STqOffset)) != 0){
+ if (taosHashPut(pTq->pOffset, subkey, strlen(subkey), &offset, sizeof(STqOffset)) != 0) {
tDeleteSTqOffset(&offset);
tdbFree(data);
return NULL;
@@ -160,9 +160,9 @@ void* tqMetaGetOffset(STQ* pTq, const char* subkey){
}
int32_t tqMetaSaveHandle(STQ* pTq, const char* key, const STqHandle* pHandle) {
- int32_t code = TDB_CODE_SUCCESS;
- int32_t vlen;
- void* buf = NULL;
+ int32_t code = TDB_CODE_SUCCESS;
+ int32_t vlen;
+ void* buf = NULL;
SEncoder encoder;
tEncodeSize(tEncodeSTqHandle, pHandle, vlen, code);
if (code < 0) {
@@ -192,14 +192,15 @@ END:
return code;
}
-static int tqMetaInitHandle(STQ* pTq, STqHandle* handle){
+static int tqMetaInitHandle(STQ* pTq, STqHandle* handle) {
int32_t code = TDB_CODE_SUCCESS;
+
SVnode* pVnode = pTq->pVnode;
int32_t vgId = TD_VID(pVnode);
handle->pRef = walOpenRef(pVnode->pWal);
if (handle->pRef == NULL) {
- return TSDB_CODE_OUT_OF_MEMORY;
+ TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
TQ_ERR_RETURN(walSetRefVer(handle->pRef, handle->snapshotVer));
@@ -213,8 +214,8 @@ static int tqMetaInitHandle(STQ* pTq, STqHandle* handle){
initStorageAPI(&reader.api);
if (handle->execHandle.subType == TOPIC_SUB_TYPE__COLUMN) {
- handle->execHandle.task =
- qCreateQueueExecTaskInfo(handle->execHandle.execCol.qmsg, &reader, vgId, &handle->execHandle.numOfCols, handle->consumerId);
+ handle->execHandle.task = qCreateQueueExecTaskInfo(handle->execHandle.execCol.qmsg, &reader, vgId,
+ &handle->execHandle.numOfCols, handle->consumerId);
if (handle->execHandle.task == NULL) {
tqError("cannot create exec task for %s", handle->subKey);
return TSDB_CODE_OUT_OF_MEMORY;
@@ -240,7 +241,7 @@ static int tqMetaInitHandle(STQ* pTq, STqHandle* handle){
} else if (handle->execHandle.subType == TOPIC_SUB_TYPE__TABLE) {
handle->pWalReader = walOpenReader(pVnode->pWal, NULL, 0);
- if(handle->execHandle.execTb.qmsg != NULL && strcmp(handle->execHandle.execTb.qmsg, "") != 0) {
+ if (handle->execHandle.execTb.qmsg != NULL && strcmp(handle->execHandle.execTb.qmsg, "") != 0) {
if (nodesStringToNode(handle->execHandle.execTb.qmsg, &handle->execHandle.execTb.node) != 0) {
tqError("nodesStringToNode error in sub stable, since %s", terrstr());
return TSDB_CODE_SCH_INTERNAL_ERROR;
@@ -251,13 +252,15 @@ static int tqMetaInitHandle(STQ* pTq, STqHandle* handle){
handle->execHandle.task = qCreateQueueExecTaskInfo(NULL, &reader, vgId, NULL, handle->consumerId);
SArray* tbUidList = NULL;
- int ret = qGetTableList(handle->execHandle.execTb.suid, pVnode, handle->execHandle.execTb.node, &tbUidList, handle->execHandle.task);
- if(ret != TDB_CODE_SUCCESS) {
+ int ret = qGetTableList(handle->execHandle.execTb.suid, pVnode, handle->execHandle.execTb.node, &tbUidList,
+ handle->execHandle.task);
+ if (ret != TDB_CODE_SUCCESS) {
tqError("qGetTableList error:%d handle %s consumer:0x%" PRIx64, ret, handle->subKey, handle->consumerId);
taosArrayDestroy(tbUidList);
return TSDB_CODE_SCH_INTERNAL_ERROR;
}
- tqInfo("vgId:%d, tq try to get ctb for stb subscribe, suid:%" PRId64, pVnode->config.vgId, handle->execHandle.execTb.suid);
+ tqInfo("vgId:%d, tq try to get ctb for stb subscribe, suid:%" PRId64, pVnode->config.vgId,
+ handle->execHandle.execTb.suid);
handle->execHandle.pTqReader = tqReaderOpen(pVnode);
tqReaderSetTbUidList(handle->execHandle.pTqReader, tbUidList, NULL);
taosArrayDestroy(tbUidList);
@@ -265,10 +268,10 @@ static int tqMetaInitHandle(STQ* pTq, STqHandle* handle){
return 0;
}
-static int32_t tqMetaRestoreHandle(STQ* pTq, void* pVal, int vLen, STqHandle* handle){
+static int32_t tqMetaRestoreHandle(STQ* pTq, void* pVal, int vLen, STqHandle* handle) {
int32_t vgId = TD_VID(pTq->pVnode);
SDecoder decoder = {0};
- int32_t code = TDB_CODE_SUCCESS;
+ int32_t code = TDB_CODE_SUCCESS;
tDecoderInit(&decoder, (uint8_t*)pVal, vLen);
TQ_ERR_GO_TO_END(tDecodeSTqHandle(&decoder, handle));
@@ -281,53 +284,55 @@ END:
return code;
}
-int32_t tqMetaCreateHandle(STQ* pTq, SMqRebVgReq* req, STqHandle* handle){
- int32_t vgId = TD_VID(pTq->pVnode);
+int32_t tqMetaCreateHandle(STQ* pTq, SMqRebVgReq* req, STqHandle* handle) {
+ int32_t vgId = TD_VID(pTq->pVnode);
memcpy(handle->subKey, req->subKey, TSDB_SUBSCRIBE_KEY_LEN);
handle->consumerId = req->newConsumerId;
handle->execHandle.subType = req->subType;
handle->fetchMeta = req->withMeta;
- if(req->subType == TOPIC_SUB_TYPE__COLUMN){
+ if (req->subType == TOPIC_SUB_TYPE__COLUMN) {
handle->execHandle.execCol.qmsg = taosStrdup(req->qmsg);
- }else if(req->subType == TOPIC_SUB_TYPE__DB){
+ } else if (req->subType == TOPIC_SUB_TYPE__DB) {
handle->execHandle.execDb.pFilterOutTbUid =
taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
- }else if(req->subType == TOPIC_SUB_TYPE__TABLE){
+ } else if (req->subType == TOPIC_SUB_TYPE__TABLE) {
handle->execHandle.execTb.suid = req->suid;
handle->execHandle.execTb.qmsg = taosStrdup(req->qmsg);
}
handle->snapshotVer = walGetCommittedVer(pTq->pVnode->pWal);
- if(tqMetaInitHandle(pTq, handle) < 0){
+ if (tqMetaInitHandle(pTq, handle) < 0) {
return -1;
}
- tqInfo("tqMetaCreateHandle %s consumer 0x%" PRIx64 " vgId:%d, snapshotVer:%" PRId64, handle->subKey, handle->consumerId, vgId, handle->snapshotVer);
+ tqInfo("tqMetaCreateHandle %s consumer 0x%" PRIx64 " vgId:%d, snapshotVer:%" PRId64, handle->subKey,
+ handle->consumerId, vgId, handle->snapshotVer);
return taosHashPut(pTq->pHandle, handle->subKey, strlen(handle->subKey), handle, sizeof(STqHandle));
}
-static int32_t tqMetaTransformInfo(TDB* pMetaDB, TTB* pOld, TTB* pNew){
- TBC* pCur = NULL;
- void* pKey = NULL;
- int kLen = 0;
- void* pVal = NULL;
- int vLen = 0;
- TXN* txn = NULL;
+static int32_t tqMetaTransformInfo(TDB* pMetaDB, TTB* pOld, TTB* pNew) {
+ TBC* pCur = NULL;
+ void* pKey = NULL;
+ int kLen = 0;
+ void* pVal = NULL;
+ int vLen = 0;
+ TXN* txn = NULL;
- int32_t code = TDB_CODE_SUCCESS;
+ int32_t code = TDB_CODE_SUCCESS;
TQ_ERR_GO_TO_END(tdbTbcOpen(pOld, &pCur, NULL));
- TQ_ERR_GO_TO_END(tdbBegin(pMetaDB, &txn, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED));
+ TQ_ERR_GO_TO_END(
+ tdbBegin(pMetaDB, &txn, tdbDefaultMalloc, tdbDefaultFree, NULL, TDB_TXN_WRITE | TDB_TXN_READ_UNCOMMITTED));
TQ_ERR_GO_TO_END(tdbTbcMoveToFirst(pCur));
while (tdbTbcNext(pCur, &pKey, &kLen, &pVal, &vLen) == 0) {
- TQ_ERR_GO_TO_END (tdbTbUpsert(pNew, pKey, kLen, pVal, vLen, txn));
+ TQ_ERR_GO_TO_END(tdbTbUpsert(pNew, pKey, kLen, pVal, vLen, txn));
}
- TQ_ERR_GO_TO_END (tdbCommit(pMetaDB, txn));
- TQ_ERR_GO_TO_END (tdbPostCommit(pMetaDB, txn));
+ TQ_ERR_GO_TO_END(tdbCommit(pMetaDB, txn));
+ TQ_ERR_GO_TO_END(tdbPostCommit(pMetaDB, txn));
END:
tdbFree(pKey);
@@ -338,24 +343,24 @@ END:
int32_t tqMetaGetHandle(STQ* pTq, const char* key, STqHandle** pHandle) {
void* data = taosHashGet(pTq->pHandle, key, strlen(key));
- if(data == NULL){
- int vLen = 0;
+ if (data == NULL) {
+ int vLen = 0;
if (tdbTbGet(pTq->pExecStore, key, (int)strlen(key), &data, &vLen) < 0) {
tdbFree(data);
return TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST;
}
STqHandle handle = {0};
- if (tqMetaRestoreHandle(pTq, data, vLen, &handle) != 0){
+ if (tqMetaRestoreHandle(pTq, data, vLen, &handle) != 0) {
tdbFree(data);
tqDestroyTqHandle(&handle);
return TSDB_CODE_OUT_OF_MEMORY;
}
tdbFree(data);
*pHandle = taosHashGet(pTq->pHandle, key, strlen(key));
- if(*pHandle == NULL){
+ if (*pHandle == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
- }else{
+ } else {
*pHandle = data;
}
return TDB_CODE_SUCCESS;
@@ -372,8 +377,8 @@ END:
return code;
}
-static int32_t replaceTqPath(char** path){
- char* tpath = NULL;
+static int32_t replaceTqPath(char** path) {
+ char* tpath = NULL;
int32_t code = TDB_CODE_SUCCESS;
TQ_ERR_RETURN(tqBuildFName(&tpath, *path, TQ_SUBSCRIBE_NAME));
taosMemoryFree(*path);
@@ -382,12 +387,12 @@ static int32_t replaceTqPath(char** path){
}
static int32_t tqMetaRestoreCheckInfo(STQ* pTq) {
- TBC* pCur = NULL;
- void* pKey = NULL;
- int kLen = 0;
- void* pVal = NULL;
- int vLen = 0;
- int32_t code = 0;
+ TBC* pCur = NULL;
+ void* pKey = NULL;
+ int kLen = 0;
+ void* pVal = NULL;
+ int vLen = 0;
+ int32_t code = 0;
STqCheckInfo info = {0};
TQ_ERR_GO_TO_END(tdbTbcOpen(pTq->pCheckStore, &pCur, NULL));
@@ -412,10 +417,10 @@ int32_t tqMetaOpen(STQ* pTq) {
char* offsetNew = NULL;
int32_t code = TDB_CODE_SUCCESS;
TQ_ERR_GO_TO_END(tqBuildFName(&maindb, pTq->path, TDB_MAINDB_NAME));
- if(!taosCheckExistFile(maindb)){
+ if (!taosCheckExistFile(maindb)) {
TQ_ERR_GO_TO_END(replaceTqPath(&pTq->path));
TQ_ERR_GO_TO_END(tqMetaOpenTdb(pTq));
- }else{
+ } else {
TQ_ERR_GO_TO_END(tqMetaTransform(pTq));
(void)taosRemoveFile(maindb);
}
@@ -435,12 +440,12 @@ END:
}
int32_t tqMetaTransform(STQ* pTq) {
- int32_t code = TDB_CODE_SUCCESS;
- TDB* pMetaDB = NULL;
- TTB* pExecStore = NULL;
- TTB* pCheckStore = NULL;
- char* offsetNew = NULL;
- char* offset = NULL;
+ int32_t code = TDB_CODE_SUCCESS;
+ TDB* pMetaDB = NULL;
+ TTB* pExecStore = NULL;
+ TTB* pCheckStore = NULL;
+ char* offsetNew = NULL;
+ char* offset = NULL;
TQ_ERR_GO_TO_END(tqBuildFName(&offset, pTq->path, TQ_OFFSET_NAME));
TQ_ERR_GO_TO_END(tdbOpen(pTq->path, 16 * 1024, 1, &pMetaDB, 0, 0, NULL));
@@ -454,6 +459,7 @@ int32_t tqMetaTransform(STQ* pTq) {
TQ_ERR_GO_TO_END(tqMetaTransformInfo(pTq->pMetaDB, pCheckStore, pTq->pCheckStore));
TQ_ERR_GO_TO_END(tqBuildFName(&offsetNew, pTq->path, TQ_OFFSET_NAME));
+
if(taosCheckExistFile(offset)) {
if (taosCopyFile(offset, offsetNew) < 0) {
tqError("copy offset file error");
@@ -466,7 +472,7 @@ END:
taosMemoryFree(offset);
taosMemoryFree(offsetNew);
- //return 0 always, so ignore
+ // return 0 always, so ignore
(void)tdbTbClose(pExecStore);
(void)tdbTbClose(pCheckStore);
(void)tdbClose(pMetaDB);
@@ -486,4 +492,4 @@ int32_t tqMetaClose(STQ* pTq) {
}
(void)tdbClose(pTq->pMetaDB);
return 0;
-}
\ No newline at end of file
+}
diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c
index b57af518b4..0cdfbdb50a 100644
--- a/source/dnode/vnode/src/tq/tqRead.c
+++ b/source/dnode/vnode/src/tq/tqRead.c
@@ -188,9 +188,9 @@ int32_t tqFetchLog(STQ* pTq, STqHandle* pHandle, int64_t* fetchOffset, uint64_t
int64_t committedVer = walGetCommittedVer(pHandle->pWalReader->pWal);
int64_t appliedVer = walGetAppliedVer(pHandle->pWalReader->pWal);
- wDebug("vgId:%d, start to fetch wal, index:%" PRId64 ", last:%" PRId64 " commit:%" PRId64 ", applied:%" PRId64
- ", 0x%" PRIx64,
- vgId, offset, lastVer, committedVer, appliedVer, id);
+ tqDebug("vgId:%d, start to fetch wal, index:%" PRId64 ", last:%" PRId64 " commit:%" PRId64 ", applied:%" PRId64
+ ", 0x%" PRIx64,
+ vgId, offset, lastVer, committedVer, appliedVer, id);
while (offset <= appliedVer) {
if (walFetchHead(pHandle->pWalReader, offset) < 0) {
@@ -240,14 +240,12 @@ END:
return code;
}
-bool tqGetTablePrimaryKey(STqReader* pReader){
- return pReader->hasPrimaryKey;
-}
+bool tqGetTablePrimaryKey(STqReader* pReader) { return pReader->hasPrimaryKey; }
-void tqSetTablePrimaryKey(STqReader* pReader, int64_t uid){
- bool ret = false;
- SSchemaWrapper *schema = metaGetTableSchema(pReader->pVnodeMeta, uid, -1, 1);
- if (schema->nCols >= 2 && schema->pSchema[1].flags & COL_IS_KEY){
+void tqSetTablePrimaryKey(STqReader* pReader, int64_t uid) {
+ bool ret = false;
+ SSchemaWrapper* schema = metaGetTableSchema(pReader->pVnodeMeta, uid, -1, 1);
+ if (schema->nCols >= 2 && schema->pSchema[1].flags & COL_IS_KEY) {
ret = true;
}
tDeleteSchemaWrapper(schema);
@@ -311,10 +309,7 @@ int32_t extractMsgFromWal(SWalReader* pReader, void** pItem, int64_t maxVer, con
int32_t code = 0;
while (1) {
- code = walNextValidMsg(pReader);
- if (code != TSDB_CODE_SUCCESS) {
- return code;
- }
+ TAOS_CHECK_RETURN(walNextValidMsg(pReader));
SWalCont* pCont = &pReader->pHead->head;
int64_t ver = pCont->version;
@@ -374,7 +369,7 @@ int32_t extractMsgFromWal(SWalReader* pReader, void** pItem, int64_t maxVer, con
}
bool tqNextBlockInWal(STqReader* pReader, const char* id, int sourceExcluded) {
- SWalReader* pWalReader = pReader->pWalReader;
+ SWalReader* pWalReader = pReader->pWalReader;
int64_t st = taosGetTimestampMs();
while (1) {
@@ -405,7 +400,7 @@ bool tqNextBlockInWal(STqReader* pReader, const char* id, int sourceExcluded) {
pReader->msg.msgStr = NULL;
int64_t elapsed = taosGetTimestampMs() - st;
- if(elapsed > 1000 || elapsed < 0){
+ if (elapsed > 1000 || elapsed < 0) {
return false;
}
@@ -681,10 +676,11 @@ int32_t tqRetrieveDataBlock(STqReader* pReader, SSDataBlock** pRes, const char*
continue;
}
- SColData* pCol = taosArrayGet(pCols, sourceIdx);
- SColVal colVal;
+ SColData* pCol = taosArrayGet(pCols, sourceIdx);
+ SColVal colVal;
- tqTrace("lostdata colActual:%d, sourceIdx:%d, targetIdx:%d, numOfCols:%d, source cid:%d, dst cid:%d", colActual, sourceIdx, targetIdx, numOfCols, pCol->cid, pColData->info.colId);
+ tqTrace("lostdata colActual:%d, sourceIdx:%d, targetIdx:%d, numOfCols:%d, source cid:%d, dst cid:%d", colActual,
+ sourceIdx, targetIdx, numOfCols, pCol->cid, pColData->info.colId);
if (pCol->cid < pColData->info.colId) {
sourceIdx++;
} else if (pCol->cid == pColData->info.colId) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
index eb4fee3024..28abed1ce7 100644
--- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
+++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
@@ -757,10 +757,9 @@ int32_t tsdbReadDataBlk(SDataFReader *pReader, SBlockIdx *pBlockIdx, SMapData *m
TSDB_CHECK_CODE(code, lino, _exit);
// decode
- int64_t n = tGetMapData(pReader->aBuf[0], mDataBlk);
- if (n < 0) {
- TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
- }
+ int32_t n;
+ code = tGetMapData(pReader->aBuf[0], mDataBlk, &n);
+ if (code) goto _exit;
ASSERT(n == size);
_exit:
diff --git a/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c b/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
index bc7bf5449e..f515cd5352 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
@@ -81,7 +81,7 @@ static int32_t tsdbFTypeToFRangeType(tsdb_ftype_t ftype) {
static int32_t tsdbTFileSetToFSetPartition(STFileSet* fset, STsdbFSetPartition** ppSP) {
STsdbFSetPartition* p = tsdbFSetPartitionCreate();
if (p == NULL) {
- goto _err;
+ return terrno;
}
p->fid = fset->fid;
@@ -134,10 +134,6 @@ static int32_t tsdbTFileSetToFSetPartition(STFileSet* fset, STsdbFSetPartition**
}
ppSP[0] = p;
return 0;
-
-_err:
- tsdbFSetPartitionClear(&p);
- return -1;
}
// fset partition list
@@ -160,9 +156,11 @@ void tsdbFSetPartListDestroy(STsdbFSetPartList** ppList) {
}
int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList* pList, TFileSetRangeArray** ppRanges) {
+ int32_t code = 0;
+
TFileSetRangeArray* pDiff = taosMemoryCalloc(1, sizeof(TFileSetRangeArray));
if (pDiff == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto _err;
}
TARRAY2_INIT(pDiff);
@@ -171,7 +169,7 @@ int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList* pList, TFileSetRangeArray
TARRAY2_FOREACH(pList, part) {
STFileSetRange* r = taosMemoryCalloc(1, sizeof(STFileSetRange));
if (r == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto _err;
}
int64_t maxVerValid = -1;
@@ -202,7 +200,7 @@ _err:
if (pDiff) {
tsdbTFileSetRangeArrayDestroy(&pDiff);
}
- return -1;
+ return code;
}
// serialization
@@ -235,96 +233,103 @@ int32_t tTsdbFSetPartListDataLenCalc(STsdbFSetPartList* pList) {
return datLen;
}
-int32_t tSerializeTsdbFSetPartList(void* buf, int32_t bufLen, STsdbFSetPartList* pList) {
+static int32_t tSerializeTsdbFSetPartList(void* buf, int32_t bufLen, STsdbFSetPartList* pList, int32_t* encodeSize) {
SEncoder encoder = {0};
+ int8_t reserved8 = 0;
+ int16_t reserved16 = 0;
+ int64_t reserved64 = 0;
+ int8_t msgVer = TSDB_SNAP_MSG_VER;
+ int32_t len = TARRAY2_SIZE(pList);
+ int32_t code = 0;
+
tEncoderInit(&encoder, buf, bufLen);
-
- int8_t reserved8 = 0;
- int16_t reserved16 = 0;
- int64_t reserved64 = 0;
-
- int8_t msgVer = TSDB_SNAP_MSG_VER;
- int32_t len = TARRAY2_SIZE(pList);
-
- if (tStartEncode(&encoder) < 0) goto _err;
- if (tEncodeI8(&encoder, msgVer) < 0) goto _err;
- if (tEncodeI32(&encoder, len) < 0) goto _err;
+ if ((code = tStartEncode(&encoder))) goto _exit;
+ if ((code = tEncodeI8(&encoder, msgVer))) goto _exit;
+ if ((code = tEncodeI32(&encoder, len))) goto _exit;
for (int32_t u = 0; u < len; u++) {
STsdbFSetPartition* p = TARRAY2_GET(pList, u);
- if (tEncodeI64(&encoder, p->fid) < 0) goto _err;
- if (tEncodeI8(&encoder, p->stat) < 0) goto _err;
- if (tEncodeI8(&encoder, reserved8) < 0) goto _err;
- if (tEncodeI16(&encoder, reserved16) < 0) goto _err;
+ if ((code = tEncodeI64(&encoder, p->fid))) goto _exit;
+ if ((code = tEncodeI8(&encoder, p->stat))) goto _exit;
+ if ((code = tEncodeI8(&encoder, reserved8))) goto _exit;
+ if ((code = tEncodeI16(&encoder, reserved16))) goto _exit;
int32_t typMax = TSDB_FSET_RANGE_TYP_MAX;
- if (tEncodeI32(&encoder, typMax) < 0) goto _err;
+ if ((code = tEncodeI32(&encoder, typMax))) goto _exit;
for (int32_t i = 0; i < typMax; i++) {
SVerRangeList* iList = &p->verRanges[i];
int32_t iLen = TARRAY2_SIZE(iList);
- if (tEncodeI32(&encoder, iLen) < 0) goto _err;
+ if ((code = tEncodeI32(&encoder, iLen))) goto _exit;
for (int32_t j = 0; j < iLen; j++) {
SVersionRange r = TARRAY2_GET(iList, j);
- if (tEncodeI64(&encoder, r.minVer) < 0) goto _err;
- if (tEncodeI64(&encoder, r.maxVer) < 0) goto _err;
- if (tEncodeI64(&encoder, reserved64) < 0) goto _err;
+ if ((code = tEncodeI64(&encoder, r.minVer))) goto _exit;
+ if ((code = tEncodeI64(&encoder, r.maxVer))) goto _exit;
+ if ((code = tEncodeI64(&encoder, reserved64))) goto _exit;
}
}
}
tEndEncode(&encoder);
- int32_t tlen = encoder.pos;
- tEncoderClear(&encoder);
- return tlen;
-_err:
+ if (encodeSize) {
+ encodeSize[0] = encoder.pos;
+ }
+
+_exit:
tEncoderClear(&encoder);
- return -1;
+ return code;
}
int32_t tDeserializeTsdbFSetPartList(void* buf, int32_t bufLen, STsdbFSetPartList* pList) {
SDecoder decoder = {0};
- tDecoderInit(&decoder, buf, bufLen);
-
- int8_t reserved8 = 0;
- int16_t reserved16 = 0;
- int64_t reserved64 = 0;
+ int8_t reserved8 = 0;
+ int16_t reserved16 = 0;
+ int64_t reserved64 = 0;
+ int32_t code = 0;
STsdbFSetPartition* p = NULL;
+ tDecoderInit(&decoder, buf, bufLen);
int8_t msgVer = 0;
int32_t len = 0;
- if (tStartDecode(&decoder) < 0) goto _err;
- if (tDecodeI8(&decoder, &msgVer) < 0) goto _err;
- if (msgVer != TSDB_SNAP_MSG_VER) goto _err;
- if (tDecodeI32(&decoder, &len) < 0) goto _err;
+ if ((code = tStartDecode(&decoder))) goto _err;
+ if ((code = tDecodeI8(&decoder, &msgVer))) goto _err;
+ if (msgVer != TSDB_SNAP_MSG_VER) {
+ code = TSDB_CODE_INVALID_MSG;
+ goto _err;
+ }
+ if ((code = tDecodeI32(&decoder, &len))) goto _err;
for (int32_t u = 0; u < len; u++) {
p = tsdbFSetPartitionCreate();
- if (p == NULL) goto _err;
- if (tDecodeI64(&decoder, &p->fid) < 0) goto _err;
- if (tDecodeI8(&decoder, &p->stat) < 0) goto _err;
- if (tDecodeI8(&decoder, &reserved8) < 0) goto _err;
- if (tDecodeI16(&decoder, &reserved16) < 0) goto _err;
+ if (p == NULL) {
+ code = terrno;
+ goto _err;
+ }
+
+ if ((code = tDecodeI64(&decoder, &p->fid))) goto _err;
+ if ((code = tDecodeI8(&decoder, &p->stat))) goto _err;
+ if ((code = tDecodeI8(&decoder, &reserved8))) goto _err;
+ if ((code = tDecodeI16(&decoder, &reserved16))) goto _err;
int32_t typMax = 0;
- if (tDecodeI32(&decoder, &typMax) < 0) goto _err;
+ if ((code = tDecodeI32(&decoder, &typMax))) goto _err;
for (int32_t i = 0; i < typMax; i++) {
SVerRangeList* iList = &p->verRanges[i];
int32_t iLen = 0;
- if (tDecodeI32(&decoder, &iLen) < 0) goto _err;
+ if ((code = tDecodeI32(&decoder, &iLen))) goto _err;
for (int32_t j = 0; j < iLen; j++) {
SVersionRange r = {0};
- if (tDecodeI64(&decoder, &r.minVer) < 0) goto _err;
- if (tDecodeI64(&decoder, &r.maxVer) < 0) goto _err;
- if (tDecodeI64(&decoder, &reserved64) < 0) goto _err;
- if (TARRAY2_APPEND(iList, r)) goto _err;
+ if ((code = tDecodeI64(&decoder, &r.minVer))) goto _err;
+ if ((code = tDecodeI64(&decoder, &r.maxVer))) goto _err;
+ if ((code = tDecodeI64(&decoder, &reserved64))) goto _err;
+ if ((code = TARRAY2_APPEND(iList, r))) goto _err;
}
}
- if (TARRAY2_APPEND(pList, p)) goto _err;
+ if ((code = TARRAY2_APPEND(pList, p))) goto _err;
p = NULL;
}
@@ -337,7 +342,7 @@ _err:
tsdbFSetPartitionClear(&p);
}
tDecoderClear(&decoder);
- return -1;
+ return code;
}
// fs state
@@ -352,8 +357,9 @@ static STsdbFSetPartList* tsdbSnapGetFSetPartList(STFileSystem* fs) {
STFileSet* fset;
TARRAY2_FOREACH(fs->fSetArr, fset) {
STsdbFSetPartition* pItem = NULL;
- if (tsdbTFileSetToFSetPartition(fset, &pItem) < 0) {
- code = -1;
+ code = tsdbTFileSetToFSetPartition(fset, &pItem);
+ if (code) {
+ terrno = code;
break;
}
ASSERT(pItem != NULL);
@@ -404,7 +410,9 @@ static int32_t tsdbPartitionInfoInit(SVnode* pVnode, STsdbPartitionInfo* pInfo)
for (int32_t j = 0; j < pInfo->tsdbMaxCnt; ++j) {
STsdb* pTsdb = SMA_RSMA_GET_TSDB(pVnode, j);
pInfo->pLists[j] = tsdbSnapGetFSetPartList(pTsdb->pFS);
- if (pInfo->pLists[j] == NULL) return -1;
+ if (pInfo->pLists[j] == NULL) {
+ return terrno;
+ }
}
return 0;
}
@@ -432,9 +440,10 @@ static int32_t tsdbPartitionInfoSerialize(STsdbPartitionInfo* pInfo, uint8_t* bu
SSyncTLV* pSubHead = (void*)((char*)buf + offset);
int32_t valOffset = offset + sizeof(*pSubHead);
ASSERT(pSubHead->val == (char*)buf + valOffset);
- if ((tlen = tSerializeTsdbFSetPartList(pSubHead->val, bufLen - valOffset, pInfo->pLists[j])) < 0) {
+ int32_t code = tSerializeTsdbFSetPartList(pSubHead->val, bufLen - valOffset, pInfo->pLists[j], &tlen);
+ if (code) {
tsdbError("vgId:%d, failed to serialize fset partition list of tsdb %d since %s", pInfo->vgId, j, terrstr());
- return -1;
+ return code;
}
pSubHead->typ = pInfo->subTyps[j];
pSubHead->len = tlen;
@@ -460,17 +469,18 @@ static int32_t tTsdbRepOptsDataLenCalc(STsdbRepOpts* pInfo) {
}
int32_t tSerializeTsdbRepOpts(void* buf, int32_t bufLen, STsdbRepOpts* pOpts) {
+ int32_t code = 0;
SEncoder encoder = {0};
+ int64_t reserved64 = 0;
+ int8_t msgVer = TSDB_SNAP_MSG_VER;
+
tEncoderInit(&encoder, buf, bufLen);
- int64_t reserved64 = 0;
- int8_t msgVer = TSDB_SNAP_MSG_VER;
-
- if (tStartEncode(&encoder) < 0) goto _err;
- if (tEncodeI8(&encoder, msgVer) < 0) goto _err;
+ if ((code = tStartEncode(&encoder))) goto _err;
+ if ((code = tEncodeI8(&encoder, msgVer))) goto _err;
int16_t format = pOpts->format;
- if (tEncodeI16(&encoder, format) < 0) goto _err;
- if (tEncodeI64(&encoder, reserved64) < 0) goto _err;
+ if ((code = tEncodeI16(&encoder, format))) goto _err;
+ if ((code = tEncodeI64(&encoder, reserved64))) goto _err;
tEndEncode(&encoder);
int32_t tlen = encoder.pos;
@@ -479,23 +489,24 @@ int32_t tSerializeTsdbRepOpts(void* buf, int32_t bufLen, STsdbRepOpts* pOpts) {
_err:
tEncoderClear(&encoder);
- return -1;
+ return code;
}
int32_t tDeserializeTsdbRepOpts(void* buf, int32_t bufLen, STsdbRepOpts* pOpts) {
+ int32_t code;
SDecoder decoder = {0};
+ int64_t reserved64 = 0;
+ int8_t msgVer = 0;
+
tDecoderInit(&decoder, buf, bufLen);
- int64_t reserved64 = 0;
- int8_t msgVer = 0;
-
- if (tStartDecode(&decoder) < 0) goto _err;
- if (tDecodeI8(&decoder, &msgVer) < 0) goto _err;
+ if ((code = tStartDecode(&decoder))) goto _err;
+ if ((code = tDecodeI8(&decoder, &msgVer))) goto _err;
if (msgVer != TSDB_SNAP_MSG_VER) goto _err;
int16_t format = 0;
- if (tDecodeI16(&decoder, &format) < 0) goto _err;
+ if ((code = tDecodeI16(&decoder, &format))) goto _err;
pOpts->format = format;
- if (tDecodeI64(&decoder, &reserved64) < 0) goto _err;
+ if ((code = tDecodeI64(&decoder, &reserved64))) goto _err;
tEndDecode(&decoder);
tDecoderClear(&decoder);
@@ -503,7 +514,7 @@ int32_t tDeserializeTsdbRepOpts(void* buf, int32_t bufLen, STsdbRepOpts* pOpts)
_err:
tDecoderClear(&decoder);
- return -1;
+ return code;
}
static int32_t tsdbRepOptsEstSize(STsdbRepOpts* pOpts) {
@@ -518,7 +529,7 @@ static int32_t tsdbRepOptsSerialize(STsdbRepOpts* pOpts, void* buf, int32_t bufL
int32_t offset = 0;
int32_t tlen = 0;
if ((tlen = tSerializeTsdbRepOpts(pSubHead->val, bufLen, pOpts)) < 0) {
- return -1;
+ return tlen;
}
pSubHead->typ = SNAP_DATA_RAW;
pSubHead->len = tlen;
@@ -528,8 +539,10 @@ static int32_t tsdbRepOptsSerialize(STsdbRepOpts* pOpts, void* buf, int32_t bufL
// snap info
static int32_t tsdbSnapPrepDealWithSnapInfo(SVnode* pVnode, SSnapshot* pSnap, STsdbRepOpts* pInfo) {
- if (!pSnap->data) return 0;
- int32_t code = -1;
+ if (!pSnap->data) {
+ return 0;
+ }
+ int32_t code = 0;
SSyncTLV* pHead = (void*)pSnap->data;
int32_t offset = 0;
@@ -546,30 +559,30 @@ static int32_t tsdbSnapPrepDealWithSnapInfo(SVnode* pVnode, SSnapshot* pSnap, ST
case SNAP_DATA_RSMA2: {
} break;
case SNAP_DATA_RAW: {
- if (tDeserializeTsdbRepOpts(buf, bufLen, pInfo) < 0) {
- terrno = TSDB_CODE_INVALID_DATA_FMT;
+ code = tDeserializeTsdbRepOpts(buf, bufLen, pInfo);
+ if (code < 0) {
tsdbError("vgId:%d, failed to deserialize tsdb rep opts since %s", TD_VID(pVnode), terrstr());
- goto _out;
+ return code;
}
} break;
default:
+ code = TSDB_CODE_INVALID_MSG;
tsdbError("vgId:%d, unexpected subfield type of snap info. typ:%d", TD_VID(pVnode), pField->typ);
- goto _out;
+ return code;
}
}
- code = 0;
-_out:
return code;
}
int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) {
ASSERT(pSnap->type == TDMT_SYNC_PREP_SNAPSHOT || pSnap->type == TDMT_SYNC_PREP_SNAPSHOT_REPLY);
STsdbPartitionInfo partitionInfo = {0};
- int code = -1;
+ int code = 0;
STsdbPartitionInfo* pInfo = &partitionInfo;
- if (tsdbPartitionInfoInit(pVnode, pInfo) != 0) {
+ code = tsdbPartitionInfoInit(pVnode, pInfo);
+ if (code) {
goto _out;
}
@@ -577,7 +590,7 @@ int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) {
STsdbRepOpts opts = {.format = TSDB_SNAP_REP_FMT_RAW};
if (pSnap->type == TDMT_SYNC_PREP_SNAPSHOT_REPLY) {
STsdbRepOpts leaderOpts = {0};
- if (tsdbSnapPrepDealWithSnapInfo(pVnode, pSnap, &leaderOpts) < 0) {
+ if ((code = tsdbSnapPrepDealWithSnapInfo(pVnode, pSnap, &leaderOpts)) < 0) {
tsdbError("vgId:%d, failed to deal with snap info for reply since %s", TD_VID(pVnode), terrstr());
goto _out;
}
@@ -589,7 +602,7 @@ int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) {
int32_t bufLen = headLen;
bufLen += tsdbPartitionInfoEstSize(pInfo);
bufLen += tsdbRepOptsEstSize(&opts);
- if (syncSnapInfoDataRealloc(pSnap, bufLen) != 0) {
+ if ((code = syncSnapInfoDataRealloc(pSnap, bufLen)) != 0) {
tsdbError("vgId:%d, failed to realloc memory for data of snap info. bytes:%d", TD_VID(pVnode), bufLen);
goto _out;
}
@@ -599,7 +612,8 @@ int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) {
int32_t offset = headLen;
int32_t tlen = 0;
- if ((tlen = tsdbPartitionInfoSerialize(pInfo, buf + offset, bufLen - offset)) < 0) {
+ if ((tlen = tsdbPartitionInfoSerialize(pInfo, (uint8_t*)(buf + offset), bufLen - offset)) < 0) {
+ code = tlen;
tsdbError("vgId:%d, failed to serialize tsdb partition info since %s", TD_VID(pVnode), terrstr());
goto _out;
}
@@ -607,6 +621,7 @@ int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) {
ASSERT(offset <= bufLen);
if ((tlen = tsdbRepOptsSerialize(&opts, buf + offset, bufLen - offset)) < 0) {
+ code = tlen;
tsdbError("vgId:%d, failed to serialize tsdb rep opts since %s", TD_VID(pVnode), terrstr());
goto _out;
}
@@ -620,7 +635,7 @@ int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) {
tsdbInfo("vgId:%d, tsdb snap info prepared. type:%s, val length:%d", TD_VID(pVnode), TMSG_INFO(pHead->typ),
pHead->len);
- code = 0;
+
_out:
tsdbPartitionInfoClear(pInfo);
return code;
diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c
index 58075cf0ac..66db7baab9 100644
--- a/source/dnode/vnode/src/tsdb/tsdbUtil.c
+++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c
@@ -152,7 +152,7 @@ int32_t tPutMapData(uint8_t *p, SMapData *pMapData) {
}
#endif
-int32_t tGetMapData(uint8_t *p, SMapData *pMapData) {
+int32_t tGetMapData(uint8_t *p, SMapData *pMapData, int32_t *decodedSize) {
int32_t n = 0;
int32_t offset;
@@ -160,7 +160,9 @@ int32_t tGetMapData(uint8_t *p, SMapData *pMapData) {
n += tGetI32v(p + n, &pMapData->nItem);
if (pMapData->nItem) {
- if (tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem)) return -1;
+ if (tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem)) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
int32_t lOffset = 0;
for (int32_t iItem = 0; iItem < pMapData->nItem; iItem++) {
@@ -170,12 +172,18 @@ int32_t tGetMapData(uint8_t *p, SMapData *pMapData) {
}
n += tGetI32v(p + n, &pMapData->nData);
- if (tRealloc(&pMapData->pData, pMapData->nData)) return -1;
+ if (tRealloc(&pMapData->pData, pMapData->nData)) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
memcpy(pMapData->pData, p + n, pMapData->nData);
n += pMapData->nData;
}
- return n;
+ if (decodedSize) {
+ *decodedSize = n;
+ }
+
+ return 0;
}
#ifdef BUILD_NO_CALL
@@ -680,20 +688,17 @@ int32_t tsdbRowCompareWithoutVersion(const void *p1, const void *p2) {
// STSDBRowIter ======================================================
int32_t tsdbRowIterOpen(STSDBRowIter *pIter, TSDBROW *pRow, STSchema *pTSchema) {
- int32_t code = 0;
-
pIter->pRow = pRow;
if (pRow->type == TSDBROW_ROW_FMT) {
- code = tRowIterOpen(pRow->pTSRow, pTSchema, &pIter->pIter);
- if (code) goto _exit;
+ int32_t code = tRowIterOpen(pRow->pTSRow, pTSchema, &pIter->pIter);
+ if (code) return code;
} else if (pRow->type == TSDBROW_COL_FMT) {
pIter->iColData = 0;
} else {
ASSERT(0);
}
-_exit:
- return code;
+ return 0;
}
void tsdbRowClose(STSDBRowIter *pIter) {
@@ -760,7 +765,9 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema)
--iCol;
continue;
} else if (pTSchema->columns[jCol].colId > pTColumn->colId) {
- taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type));
+ if (taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)) == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
continue;
}
@@ -780,14 +787,15 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema)
}
if (taosArrayPush(pMerger->pArray, pColVal) == NULL) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- return code;
+ return TSDB_CODE_OUT_OF_MEMORY;
}
}
for (; iCol < pMerger->pTSchema->numOfCols; ++iCol) {
pTColumn = &pMerger->pTSchema->columns[iCol];
- taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type));
+ if (taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)) == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
}
pMerger->version = key.version;
@@ -962,8 +970,7 @@ _exit:
*/
// delete skyline ======================================================
-static int32_t tsdbMergeSkyline(SArray *pSkyline1, SArray *pSkyline2, SArray *pSkyline) {
- int32_t code = 0;
+static void tsdbMergeSkyline(SArray *pSkyline1, SArray *pSkyline2, SArray *pSkyline) {
int32_t i1 = 0;
int32_t n1 = taosArrayGetSize(pSkyline1);
int32_t i2 = 0;
@@ -1017,7 +1024,6 @@ static int32_t tsdbMergeSkyline(SArray *pSkyline1, SArray *pSkyline2, SArray *pS
}
pSkyline->size = TARRAY_ELEM_IDX(pSkyline, pItem);
- return code;
}
int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx, SArray *pSkyline) {
@@ -1029,8 +1035,13 @@ int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx,
if (sidx == eidx) {
TSDBKEY *pItem1 = taosArrayGet(aSkyline, sidx * 2);
TSDBKEY *pItem2 = taosArrayGet(aSkyline, sidx * 2 + 1);
- taosArrayPush(pSkyline, &pItem1);
- taosArrayPush(pSkyline, &pItem2);
+ if (taosArrayPush(pSkyline, &pItem1) == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+
+ if (taosArrayPush(pSkyline, &pItem2) == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
} else {
SArray *pSkyline1 = NULL;
SArray *pSkyline2 = NULL;
@@ -1049,7 +1060,7 @@ int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx,
code = tsdbBuildDeleteSkylineImpl(aSkyline, midx + 1, eidx, pSkyline2);
if (code) goto _clear;
- code = tsdbMergeSkyline(pSkyline1, pSkyline2, pSkyline);
+ tsdbMergeSkyline(pSkyline1, pSkyline2, pSkyline);
_clear:
taosArrayDestroy(pSkyline1);
@@ -1064,13 +1075,28 @@ int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SAr
int32_t code = 0;
int32_t dataNum = eidx - sidx + 1;
SArray *aTmpSkyline = taosArrayInit(dataNum * 2, sizeof(TSDBKEY));
- SArray *pSkyline = taosArrayInit(dataNum * 2, POINTER_BYTES);
+ if (aTmpSkyline == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+
+ SArray *pSkyline = taosArrayInit(dataNum * 2, POINTER_BYTES);
+ if (pSkyline == NULL) {
+ taosArrayDestroy(aTmpSkyline);
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
taosArrayClear(aSkyline);
for (int32_t i = sidx; i <= eidx; ++i) {
pDelData = (SDelData *)taosArrayGet(aDelData, i);
- taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->sKey, .version = pDelData->version});
- taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0});
+ if (taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->sKey, .version = pDelData->version}) == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _clear;
+ }
+
+ if (taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0}) == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _clear;
+ }
}
code = tsdbBuildDeleteSkylineImpl(aTmpSkyline, sidx, eidx, pSkyline);
@@ -1079,7 +1105,10 @@ int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SAr
int32_t skylineNum = taosArrayGetSize(pSkyline);
for (int32_t i = 0; i < skylineNum; ++i) {
TSDBKEY *p = taosArrayGetP(pSkyline, i);
- taosArrayPush(aSkyline, p);
+ if (taosArrayPush(aSkyline, p) == NULL) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _clear;
+ }
}
_clear:
@@ -1519,8 +1548,8 @@ int32_t tBlockDataDecompress(SBufferReader *br, SBlockData *blockData, SBuffer *
SBlockCol blockCol;
code = tGetBlockCol(&br2, &blockCol, hdr.fmtVer, hdr.cmprAlg);
- if (blockCol.alg == 0) blockCol.alg = hdr.cmprAlg;
TSDB_CHECK_CODE(code, lino, _exit);
+ if (blockCol.alg == 0) blockCol.alg = hdr.cmprAlg;
code = tBlockDataDecompressColData(&hdr, &blockCol, br, blockData, assist);
TSDB_CHECK_CODE(code, lino, _exit);
}
@@ -1812,7 +1841,9 @@ int32_t tsdbGetColCmprAlgFromSet(SHashObj *set, int16_t colId, uint32_t *alg) {
if (set == NULL) return -1;
uint32_t *ret = taosHashGet(set, &colId, sizeof(colId));
- if (ret == NULL) return -1;
+ if (ret == NULL) {
+ return TSDB_CODE_NOT_FOUND;
+ }
*alg = *ret;
return 0;
diff --git a/source/dnode/vnode/src/vnd/vnodeQuery.c b/source/dnode/vnode/src/vnd/vnodeQuery.c
index 5b17e0f1da..f7b618d18b 100644
--- a/source/dnode/vnode/src/vnd/vnodeQuery.c
+++ b/source/dnode/vnode/src/vnd/vnodeQuery.c
@@ -47,7 +47,7 @@ int32_t fillTableColCmpr(SMetaReader *reader, SSchemaExt *pExt, int32_t numOfCol
return 0;
}
-int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
+int32_t vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
STableInfoReq infoReq = {0};
STableMetaRsp metaRsp = {0};
SMetaReader mer1 = {0};
@@ -62,15 +62,15 @@ int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
// decode req
if (tDeserializeSTableInfoReq(pMsg->pCont, pMsg->contLen, &infoReq) != 0) {
- code = TSDB_CODE_INVALID_MSG;
+ code = terrno;
goto _exit4;
}
metaRsp.dbId = pVnode->config.dbId;
- strcpy(metaRsp.tbName, infoReq.tbName);
- memcpy(metaRsp.dbFName, infoReq.dbFName, sizeof(metaRsp.dbFName));
+ (void)strcpy(metaRsp.tbName, infoReq.tbName);
+ (void)memcpy(metaRsp.dbFName, infoReq.dbFName, sizeof(metaRsp.dbFName));
- sprintf(tableFName, "%s.%s", infoReq.dbFName, infoReq.tbName);
+ (void)sprintf(tableFName, "%s.%s", infoReq.dbFName, infoReq.tbName);
code = vnodeValidateTableHash(pVnode, tableFName);
if (code) {
goto _exit4;
@@ -89,7 +89,7 @@ int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
metaRsp.tuid = mer1.me.uid;
if (mer1.me.type == TSDB_SUPER_TABLE) {
- strcpy(metaRsp.stbName, mer1.me.name);
+ (void)strcpy(metaRsp.stbName, mer1.me.name);
schema = mer1.me.stbEntry.schemaRow;
schemaTag = mer1.me.stbEntry.schemaTag;
metaRsp.suid = mer1.me.uid;
@@ -97,7 +97,7 @@ int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
metaReaderDoInit(&mer2, pVnode->pMeta, META_READER_NOLOCK);
if (metaReaderGetTableEntryByUid(&mer2, mer1.me.ctbEntry.suid) < 0) goto _exit2;
- strcpy(metaRsp.stbName, mer2.me.name);
+ (void)strcpy(metaRsp.stbName, mer2.me.name);
metaRsp.suid = mer2.me.uid;
schema = mer2.me.stbEntry.schemaRow;
schemaTag = mer2.me.stbEntry.schemaTag;
@@ -114,10 +114,13 @@ int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
metaRsp.tversion = schemaTag.version;
metaRsp.pSchemas = (SSchema *)taosMemoryMalloc(sizeof(SSchema) * (metaRsp.numOfColumns + metaRsp.numOfTags));
metaRsp.pSchemaExt = (SSchemaExt *)taosMemoryCalloc(metaRsp.numOfColumns, sizeof(SSchemaExt));
-
- memcpy(metaRsp.pSchemas, schema.pSchema, sizeof(SSchema) * schema.nCols);
+ if (NULL == metaRsp.pSchemas || NULL == metaRsp.pSchemaExt) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _exit;
+ }
+ (void)memcpy(metaRsp.pSchemas, schema.pSchema, sizeof(SSchema) * schema.nCols);
if (schemaTag.nCols) {
- memcpy(metaRsp.pSchemas + schema.nCols, schemaTag.pSchema, sizeof(SSchema) * schemaTag.nCols);
+ (void)memcpy(metaRsp.pSchemas + schema.nCols, schemaTag.pSchema, sizeof(SSchema) * schemaTag.nCols);
}
if (metaRsp.pSchemaExt) {
SMetaReader *pReader = mer1.me.type == TSDB_CHILD_TABLE ? &mer2 : &mer1;
@@ -134,7 +137,7 @@ int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
// encode and send response
rspLen = tSerializeSTableMetaRsp(NULL, 0, &metaRsp);
if (rspLen < 0) {
- code = TSDB_CODE_INVALID_MSG;
+ code = terrno;
goto _exit;
}
@@ -148,7 +151,12 @@ int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto _exit;
}
- tSerializeSTableMetaRsp(pRsp, rspLen, &metaRsp);
+
+ rspLen = tSerializeSTableMetaRsp(pRsp, rspLen, &metaRsp);
+ if (rspLen < 0) {
+ code = terrno;
+ goto _exit;
+ }
_exit:
taosMemoryFree(metaRsp.pSchemas);
@@ -174,10 +182,10 @@ _exit4:
*pMsg = rpcMsg;
}
- return TSDB_CODE_SUCCESS;
+ return code;
}
-int vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
+int32_t vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
STableCfgReq cfgReq = {0};
STableCfgRsp cfgRsp = {0};
SMetaReader mer1 = {0};
@@ -192,14 +200,14 @@ int vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
// decode req
if (tDeserializeSTableCfgReq(pMsg->pCont, pMsg->contLen, &cfgReq) != 0) {
- code = TSDB_CODE_INVALID_MSG;
+ code = terrno;
goto _exit;
}
- strcpy(cfgRsp.tbName, cfgReq.tbName);
- memcpy(cfgRsp.dbFName, cfgReq.dbFName, sizeof(cfgRsp.dbFName));
+ (void)strcpy(cfgRsp.tbName, cfgReq.tbName);
+ (void)memcpy(cfgRsp.dbFName, cfgReq.dbFName, sizeof(cfgRsp.dbFName));
- sprintf(tableFName, "%s.%s", cfgReq.dbFName, cfgReq.tbName);
+ (void)sprintf(tableFName, "%s.%s", cfgReq.dbFName, cfgReq.tbName);
code = vnodeValidateTableHash(pVnode, tableFName);
if (code) {
goto _exit;
@@ -222,24 +230,36 @@ int vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
metaReaderDoInit(&mer2, pVnode->pMeta, META_READER_LOCK);
if (metaReaderGetTableEntryByUid(&mer2, mer1.me.ctbEntry.suid) < 0) goto _exit;
- strcpy(cfgRsp.stbName, mer2.me.name);
+ (void)strcpy(cfgRsp.stbName, mer2.me.name);
schema = mer2.me.stbEntry.schemaRow;
schemaTag = mer2.me.stbEntry.schemaTag;
cfgRsp.ttl = mer1.me.ctbEntry.ttlDays;
cfgRsp.commentLen = mer1.me.ctbEntry.commentLen;
if (mer1.me.ctbEntry.commentLen > 0) {
cfgRsp.pComment = taosStrdup(mer1.me.ctbEntry.comment);
+ if (NULL == cfgRsp.pComment) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _exit;
+ }
}
STag *pTag = (STag *)mer1.me.ctbEntry.pTags;
cfgRsp.tagsLen = pTag->len;
cfgRsp.pTags = taosMemoryMalloc(cfgRsp.tagsLen);
- memcpy(cfgRsp.pTags, pTag, cfgRsp.tagsLen);
+ if (NULL == cfgRsp.pTags) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _exit;
+ }
+ (void)memcpy(cfgRsp.pTags, pTag, cfgRsp.tagsLen);
} else if (mer1.me.type == TSDB_NORMAL_TABLE) {
schema = mer1.me.ntbEntry.schemaRow;
cfgRsp.ttl = mer1.me.ntbEntry.ttlDays;
cfgRsp.commentLen = mer1.me.ntbEntry.commentLen;
if (mer1.me.ntbEntry.commentLen > 0) {
cfgRsp.pComment = taosStrdup(mer1.me.ntbEntry.comment);
+ if (NULL == cfgRsp.pComment) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _exit;
+ }
}
} else {
ASSERT(0);
@@ -250,9 +270,13 @@ int vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
cfgRsp.pSchemas = (SSchema *)taosMemoryMalloc(sizeof(SSchema) * (cfgRsp.numOfColumns + cfgRsp.numOfTags));
cfgRsp.pSchemaExt = (SSchemaExt *)taosMemoryMalloc(cfgRsp.numOfColumns * sizeof(SSchemaExt));
- memcpy(cfgRsp.pSchemas, schema.pSchema, sizeof(SSchema) * schema.nCols);
+ if (NULL == cfgRsp.pSchemas || NULL == cfgRsp.pSchemaExt) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _exit;
+ }
+ (void)memcpy(cfgRsp.pSchemas, schema.pSchema, sizeof(SSchema) * schema.nCols);
if (schemaTag.nCols) {
- memcpy(cfgRsp.pSchemas + schema.nCols, schemaTag.pSchema, sizeof(SSchema) * schemaTag.nCols);
+ (void)memcpy(cfgRsp.pSchemas + schema.nCols, schemaTag.pSchema, sizeof(SSchema) * schemaTag.nCols);
}
// if (useCompress(cfgRsp.tableType)) {
@@ -271,7 +295,7 @@ int vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
// encode and send response
rspLen = tSerializeSTableCfgRsp(NULL, 0, &cfgRsp);
if (rspLen < 0) {
- code = TSDB_CODE_INVALID_MSG;
+ code = terrno;
goto _exit;
}
@@ -285,7 +309,12 @@ int vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
code = TSDB_CODE_OUT_OF_MEMORY;
goto _exit;
}
- tSerializeSTableCfgRsp(pRsp, rspLen, &cfgRsp);
+
+ rspLen = tSerializeSTableCfgRsp(pRsp, rspLen, &cfgRsp);
+ if (rspLen < 0) {
+ code = terrno;
+ goto _exit;
+ }
_exit:
rpcMsg.info = pMsg->info;
@@ -307,7 +336,7 @@ _exit:
tFreeSTableCfgRsp(&cfgRsp);
metaReaderClear(&mer2);
metaReaderClear(&mer1);
- return TSDB_CODE_SUCCESS;
+ return code;
}
static FORCE_INLINE void vnodeFreeSBatchRspMsg(void *p) {
@@ -331,7 +360,7 @@ int32_t vnodeGetBatchMeta(SVnode *pVnode, SRpcMsg *pMsg) {
void *pRsp = NULL;
if (tDeserializeSBatchReq(pMsg->pCont, pMsg->contLen, &batchReq)) {
- code = TSDB_CODE_OUT_OF_MEMORY;
+ code = terrno;
qError("tDeserializeSBatchReq failed");
goto _exit;
}
@@ -352,6 +381,10 @@ int32_t vnodeGetBatchMeta(SVnode *pVnode, SRpcMsg *pMsg) {
for (int32_t i = 0; i < msgNum; ++i) {
req = taosArrayGet(batchReq.pMsgs, i);
+ if (req == NULL) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
reqMsg.msgType = req->msgType;
reqMsg.pCont = req->msg;
@@ -359,13 +392,16 @@ int32_t vnodeGetBatchMeta(SVnode *pVnode, SRpcMsg *pMsg) {
switch (req->msgType) {
case TDMT_VND_TABLE_META:
- vnodeGetTableMeta(pVnode, &reqMsg, false);
+ // error code has been set into reqMsg, no need to handle it here.
+ (void)vnodeGetTableMeta(pVnode, &reqMsg, false);
break;
case TDMT_VND_TABLE_CFG:
- vnodeGetTableCfg(pVnode, &reqMsg, false);
+ // error code has been set into reqMsg, no need to handle it here.
+ (void)vnodeGetTableCfg(pVnode, &reqMsg, false);
break;
case TDMT_VND_GET_STREAM_PROGRESS:
- vnodeGetStreamProgress(pVnode, &reqMsg, false);
+ // error code has been set into reqMsg, no need to handle it here.
+ (void)vnodeGetStreamProgress(pVnode, &reqMsg, false);
break;
default:
qError("invalid req msgType %d", req->msgType);
@@ -381,24 +417,28 @@ int32_t vnodeGetBatchMeta(SVnode *pVnode, SRpcMsg *pMsg) {
rsp.rspCode = reqMsg.code;
rsp.msg = reqMsg.pCont;
- taosArrayPush(batchRsp.pRsps, &rsp);
+ if (NULL == taosArrayPush(batchRsp.pRsps, &rsp)) {
+ qError("taosArrayPush failed");
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _exit;
+ }
}
rspSize = tSerializeSBatchRsp(NULL, 0, &batchRsp);
if (rspSize < 0) {
qError("tSerializeSBatchRsp failed");
- code = TSDB_CODE_OUT_OF_MEMORY;
+ code = terrno;
goto _exit;
}
pRsp = rpcMallocCont(rspSize);
if (pRsp == NULL) {
qError("rpcMallocCont %d failed", rspSize);
- code = TSDB_CODE_OUT_OF_MEMORY;
+ code = terrno;
goto _exit;
}
if (tSerializeSBatchRsp(pRsp, rspSize, &batchRsp) < 0) {
qError("tSerializeSBatchRsp %d failed", rspSize);
- code = TSDB_CODE_OUT_OF_MEMORY;
+ code = terrno;
goto _exit;
}
@@ -501,7 +541,12 @@ int32_t vnodeGetTableList(void *pVnode, int8_t type, SArray *pList) {
}
int32_t vnodeGetAllTableList(SVnode *pVnode, uint64_t uid, SArray *list) {
+ int32_t code = TSDB_CODE_SUCCESS;
SMCtbCursor *pCur = metaOpenCtbCursor(pVnode, uid, 1);
+ if (NULL == pCur) {
+ qError("vnode get all table list failed");
+ return TSDB_CODE_FAILED;
+ }
while (1) {
tb_uid_t id = metaCtbCursorNext(pCur);
@@ -510,11 +555,15 @@ int32_t vnodeGetAllTableList(SVnode *pVnode, uint64_t uid, SArray *list) {
}
STableKeyInfo info = {uid = id};
- taosArrayPush(list, &info);
+ if (NULL == taosArrayPush(list, &info)) {
+ qError("taosArrayPush failed");
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _exit;
+ }
}
-
+_exit:
metaCloseCtbCursor(pCur);
- return TSDB_CODE_SUCCESS;
+ return code;
}
int32_t vnodeGetCtbIdListByFilter(SVnode *pVnode, int64_t suid, SArray *list, bool (*filter)(void *arg), void *arg) {
@@ -522,8 +571,13 @@ int32_t vnodeGetCtbIdListByFilter(SVnode *pVnode, int64_t suid, SArray *list, bo
}
int32_t vnodeGetCtbIdList(void *pVnode, int64_t suid, SArray *list) {
+ int32_t code = TSDB_CODE_SUCCESS;
SVnode *pVnodeObj = pVnode;
SMCtbCursor *pCur = metaOpenCtbCursor(pVnodeObj, suid, 1);
+ if (NULL == pCur) {
+ qError("vnode get all table list failed");
+ return TSDB_CODE_FAILED;
+ }
while (1) {
tb_uid_t id = metaCtbCursorNext(pCur);
@@ -531,14 +585,20 @@ int32_t vnodeGetCtbIdList(void *pVnode, int64_t suid, SArray *list) {
break;
}
- taosArrayPush(list, &id);
+ if (NULL == taosArrayPush(list, &id)) {
+ qError("taosArrayPush failed");
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _exit;
+ }
}
+_exit:
metaCloseCtbCursor(pCur);
- return TSDB_CODE_SUCCESS;
+ return code;
}
int32_t vnodeGetStbIdList(SVnode *pVnode, int64_t suid, SArray *list) {
+ int32_t code = TSDB_CODE_SUCCESS;
SMStbCursor *pCur = metaOpenStbCursor(pVnode->pMeta, suid);
if (!pCur) {
return TSDB_CODE_FAILED;
@@ -550,15 +610,21 @@ int32_t vnodeGetStbIdList(SVnode *pVnode, int64_t suid, SArray *list) {
break;
}
- taosArrayPush(list, &id);
+ if (NULL == taosArrayPush(list, &id)) {
+ qError("taosArrayPush failed");
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _exit;
+ }
}
+_exit:
metaCloseStbCursor(pCur);
- return TSDB_CODE_SUCCESS;
+ return code;
}
int32_t vnodeGetStbIdListByFilter(SVnode *pVnode, int64_t suid, SArray *list, bool (*filter)(void *arg, void *arg1),
void *arg) {
+ int32_t code = TSDB_CODE_SUCCESS;
SMStbCursor *pCur = metaOpenStbCursor(pVnode->pMeta, suid);
if (!pCur) {
return TSDB_CODE_FAILED;
@@ -574,11 +640,16 @@ int32_t vnodeGetStbIdListByFilter(SVnode *pVnode, int64_t suid, SArray *list, bo
continue;
}
- taosArrayPush(list, &id);
+ if (NULL == taosArrayPush(list, &id)) {
+ qError("taosArrayPush failed");
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _exit;
+ }
}
+_exit:
metaCloseStbCursor(pCur);
- return TSDB_CODE_SUCCESS;
+ return code;
}
int32_t vnodeGetCtbNum(SVnode *pVnode, int64_t suid, int64_t *num) {
@@ -700,16 +771,20 @@ int32_t vnodeGetTimeSeriesNum(SVnode *pVnode, int64_t *num) {
*num = 0;
int64_t arrSize = taosArrayGetSize(suidList);
+ int32_t code = TSDB_CODE_SUCCESS;
for (int64_t i = 0; i < arrSize; ++i) {
tb_uid_t suid = *(tb_uid_t *)taosArrayGet(suidList, i);
int64_t ctbNum = 0;
int32_t numOfCols = 0;
- metaGetStbStats(pVnode, suid, &ctbNum, &numOfCols);
-
+ code = metaGetStbStats(pVnode, suid, &ctbNum, &numOfCols);
+ if (TSDB_CODE_SUCCESS != code) {
+ goto _exit;
+ }
*num += ctbNum * (numOfCols - 1);
}
+_exit:
taosArrayDestroy(suidList);
return TSDB_CODE_SUCCESS;
}
@@ -728,7 +803,11 @@ int32_t vnodeGetAllCtbNum(SVnode *pVnode, int64_t *num) {
}
int64_t ctbNum = 0;
- vnodeGetCtbNum(pVnode, id, &ctbNum);
+ int32_t code = vnodeGetCtbNum(pVnode, id, &ctbNum);
+ if (TSDB_CODE_SUCCESS != code) {
+ metaCloseStbCursor(pCur);
+ return code;
+ }
*num += ctbNum;
}
@@ -771,14 +850,17 @@ int32_t vnodeGetStreamProgress(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
rsp.vgId = req.vgId;
rsp.streamId = req.streamId;
rspLen = tSerializeStreamProgressRsp(0, 0, &rsp);
+ if (rspLen < 0) {
+ code = terrno;
+ goto _OVER;
+ }
if (direct) {
buf = rpcMallocCont(rspLen);
} else {
buf = taosMemoryCalloc(1, rspLen);
}
if (!buf) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- code = -1;
+ code = TSDB_CODE_OUT_OF_MEMORY;
goto _OVER;
}
}
@@ -787,7 +869,11 @@ int32_t vnodeGetStreamProgress(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
code = tqGetStreamExecInfo(pVnode, req.streamId, &rsp.progressDelay, &rsp.fillHisFinished);
}
if (code == TSDB_CODE_SUCCESS) {
- tSerializeStreamProgressRsp(buf, rspLen, &rsp);
+ rspLen = tSerializeStreamProgressRsp(buf, rspLen, &rsp);
+ if (rspLen < 0) {
+ code = terrno;
+ goto _OVER;
+ }
rpcMsg.pCont = buf;
buf = NULL;
rpcMsg.contLen = rspLen;
diff --git a/source/dnode/vnode/src/vnd/vnodeSnapshot.c b/source/dnode/vnode/src/vnd/vnodeSnapshot.c
index 75ba2be100..046f12f9e7 100644
--- a/source/dnode/vnode/src/vnd/vnodeSnapshot.c
+++ b/source/dnode/vnode/src/vnd/vnodeSnapshot.c
@@ -312,8 +312,7 @@ int32_t vnodeSnapRead(SVSnapReader *pReader, uint8_t **ppData, uint32_t *nData)
goto _exit;
} else {
pReader->metaDone = 1;
- code = metaSnapReaderClose(&pReader->pMetaReader);
- TSDB_CHECK_CODE(code, lino, _exit);
+ metaSnapReaderClose(&pReader->pMetaReader);
}
}
diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h
index d37599e0e3..7b27b41177 100644
--- a/source/libs/executor/inc/executil.h
+++ b/source/libs/executor/inc/executil.h
@@ -106,9 +106,9 @@ typedef struct STableListInfo {
int32_t numOfOuputGroups; // the data block will be generated one by one
int32_t* groupOffset; // keep the offset value for each group in the tableList
SArray* pTableList;
- SHashObj* map; // speedup acquire the tableQueryInfo by table uid
- SHashObj* remainGroups; // remaining group has not yet processed the empty group
- STableListIdInfo idInfo; // this maybe the super table or ordinary table
+ SHashObj* map; // speedup acquire the tableQueryInfo by table uid
+ SHashObj* remainGroups; // remaining group has not yet processed the empty group
+ STableListIdInfo idInfo; // this maybe the super table or ordinary table
} STableListInfo;
struct SqlFunctionCtx;
@@ -130,7 +130,7 @@ uint64_t tableListGetSize(const STableListInfo* pTableList);
uint64_t tableListGetSuid(const STableListInfo* pTableList);
STableKeyInfo* tableListGetInfo(const STableListInfo* pTableList, int32_t index);
int32_t tableListFind(const STableListInfo* pTableList, uint64_t uid, int32_t startIndex);
-void tableListGetSourceTableInfo(const STableListInfo* pTableList, uint64_t* psuid, uint64_t* uid, int32_t* type);
+void tableListGetSourceTableInfo(const STableListInfo* pTableList, uint64_t* psuid, uint64_t* uid, int32_t* type);
size_t getResultRowSize(struct SqlFunctionCtx* pCtx, int32_t numOfOutput);
void initResultRowInfo(SResultRowInfo* pResultRowInfo);
@@ -165,7 +165,8 @@ SSDataBlock* createDataBlockFromDescNode(SDataBlockDescNode* pNode);
int32_t prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo);
EDealRes doTranslateTagExpr(SNode** pNode, void* pContext);
-int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, char* keyBuf, uint64_t* pGroupId, SStorageAPI* pAPI);
+int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, char* keyBuf, uint64_t* pGroupId,
+ SStorageAPI* pAPI);
size_t getTableTagsBufLen(const SNodeList* pGroups);
SArray* createSortInfo(SNodeList* pNodeList);
@@ -173,18 +174,20 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList);
int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols,
int32_t type, SColMatchInfo* pMatchInfo);
-void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId);
-void createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode);
+int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId);
+int32_t createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode);
SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* numOfExprs);
-SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, SFunctionStateStore* pStore);
-void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn);
+SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset,
+ SFunctionStateStore* pStore);
+int32_t relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn);
int32_t initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow);
SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode);
SColumn extractColumnFromColumnNode(SColumnNode* pColNode);
-int32_t initQueryTableDataCond(SQueryTableDataCond* pCond, const STableScanPhysiNode* pTableScanNode, const SReadHandle* readHandle);
+int32_t initQueryTableDataCond(SQueryTableDataCond* pCond, const STableScanPhysiNode* pTableScanNode,
+ const SReadHandle* readHandle);
void cleanupQueryTableDataCond(SQueryTableDataCond* pCond);
int32_t convertFillType(int32_t mode);
@@ -198,7 +201,7 @@ void getNextTimeWindow(const SInterval* pInterval, STimeWindow* tw, int32_t orde
void getInitialStartTimeWindow(SInterval* pInterval, TSKEY ts, STimeWindow* w, bool ascQuery);
TSKEY getStartTsKey(STimeWindow* win, const TSKEY* tsCols);
-void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, int64_t delta);
+void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, int64_t delta);
SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList, void* pVnode,
SStorageAPI* pStorageAPI);
@@ -212,9 +215,9 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S
int32_t buildKeys(char* keyBuf, const SArray* pSortGroupCols, const SSDataBlock* pBlock, int32_t rowIndex);
int32_t compKeys(const SArray* pSortGroupCols, const char* oldkeyBuf, int32_t oldKeysLen, const SSDataBlock* pDataBlock,
- int32_t rowIndex);
+ int32_t rowIndex);
-uint64_t calcGroupId(char *pData, int32_t len);
+uint64_t calcGroupId(char* pData, int32_t len);
SNodeList* makeColsNodeArrFromSortKeys(SNodeList* pSortKeys);
diff --git a/source/libs/executor/inc/executorInt.h b/source/libs/executor/inc/executorInt.h
index f1a6d6434c..f3c314a8c1 100644
--- a/source/libs/executor/inc/executorInt.h
+++ b/source/libs/executor/inc/executorInt.h
@@ -903,7 +903,7 @@ int32_t appendDataToSpecialBlock(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pE
uint64_t calGroupIdByData(SPartitionBySupporter* pParSup, SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t rowId);
-int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup,
+void finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup,
SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo);
bool groupbyTbname(SNodeList* pGroupList);
diff --git a/source/libs/executor/inc/tfill.h b/source/libs/executor/inc/tfill.h
index 82d422302c..cd003ebd15 100644
--- a/source/libs/executor/inc/tfill.h
+++ b/source/libs/executor/inc/tfill.h
@@ -20,6 +20,7 @@
extern "C" {
#endif
+#include "executil.h"
#include "os.h"
#include "taosdef.h"
#include "tcommon.h"
@@ -77,6 +78,7 @@ typedef struct SFillInfo {
SFillColInfo* pFillCol; // column info for fill operations
SFillTagColInfo* pTags; // tags value for filling gap
const char* id;
+ SExecTaskInfo* pTaskInfo;
} SFillInfo;
typedef struct SResultCellData {
@@ -128,10 +130,10 @@ bool taosFillHasMoreResults(struct SFillInfo* pFillInfo);
SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t numOfNotFillCols, int32_t capacity,
SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, int32_t slotId,
- int32_t order, const char* id);
+ int32_t order, const char* id, SExecTaskInfo* pTaskInfo);
void* taosDestroyFillInfo(struct SFillInfo* pFillInfo);
-void taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity);
+int32_t taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity);
int64_t getFillInfoStart(struct SFillInfo* pFillInfo);
bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData,
diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c
index 8c1e021042..ead0f67bc9 100644
--- a/source/libs/executor/src/aggregateoperator.c
+++ b/source/libs/executor/src/aggregateoperator.c
@@ -199,7 +199,9 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) {
pBlock = getNextBlockFromDownstream(pOperator, 0);
if (pBlock == NULL) {
if (!pAggInfo->hasValidBlock) {
- createDataBlockForEmptyInput(pOperator, &pBlock);
+ code = createDataBlockForEmptyInput(pOperator, &pBlock);
+ QUERY_CHECK_CODE(code, lino, _end);
+
if (pBlock == NULL) {
break;
}
@@ -245,7 +247,7 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) {
}
initGroupedResultInfo(&pAggInfo->groupResInfo, pAggInfo->aggSup.pResultRowHashTable, 0);
-
+
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
@@ -256,6 +258,8 @@ _end:
}
SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SAggOperatorInfo* pAggInfo = pOperator->info;
SOptrBasicInfo* pInfo = &pAggInfo->binfo;
@@ -267,11 +271,13 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) {
bool hasNewGroups = false;
do {
hasNewGroups = nextGroupedResult(pOperator);
- blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _end);
while (1) {
doBuildResultDatablock(pOperator, pInfo, &pAggInfo->groupResInfo, pAggInfo->aggSup.pResultBuf);
- doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
if (!hasRemainResults(&pAggInfo->groupResInfo)) {
if (!hasNewGroups) setOperatorCompleted(pOperator);
@@ -287,6 +293,12 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) {
size_t rows = blockDataGetNumOfRows(pInfo->pRes);
pOperator->resultInfo.totalRows += rows;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
+
return (rows == 0) ? NULL : pInfo->pRes;
}
@@ -317,6 +329,8 @@ int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) {
}
static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBlock** ppBlock) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (!tsCountAlwaysReturnValue) {
return TSDB_CODE_SUCCESS;
}
@@ -357,9 +371,12 @@ static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBloc
int32_t slotId = pFuncParam->pCol->slotId;
int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
if (slotId >= numOfCols) {
- taosArrayEnsureCap(pBlock->pDataBlock, slotId + 1);
+ code = taosArrayEnsureCap(pBlock->pDataBlock, slotId + 1);
+ QUERY_CHECK_CODE(code, lino, _end);
+
for (int32_t k = numOfCols; k < slotId + 1; ++k) {
- taosArrayPush(pBlock->pDataBlock, &colInfo);
+ void* tmp = taosArrayPush(pBlock->pDataBlock, &colInfo);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
}
} else if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) {
@@ -368,14 +385,20 @@ static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBloc
}
}
- blockDataEnsureCapacity(pBlock, pBlock->info.rows);
+ code = blockDataEnsureCapacity(pBlock, pBlock->info.rows);
+ QUERY_CHECK_CODE(code, lino, _end);
+
for (int32_t i = 0; i < blockDataGetNumOfCols(pBlock); ++i) {
SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
colDataSetNULL(pColInfoData, 0);
}
*ppBlock = pBlock;
- return TSDB_CODE_SUCCESS;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ }
+ return code;
}
void destroyDataBlockForEmptyInput(bool blockAllocated, SSDataBlock** ppBlock) {
@@ -576,7 +599,12 @@ void applyAggFunctionOnPartialTuples(SExecTaskInfo* taskInfo, SqlFunctionCtx* pC
SScalarParam out = {.columnData = &idata};
SScalarParam tw = {.numOfRows = 5, .columnData = pTimeWindowData};
- pCtx[k].sfp.process(&tw, 1, &out);
+ int32_t code = pCtx[k].sfp.process(&tw, 1, &out);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ taskInfo->code = code;
+ T_LONG_JMP(taskInfo->env, code);
+ }
pEntryInfo->numOfRes = 1;
} else {
int32_t code = TSDB_CODE_SUCCESS;
diff --git a/source/libs/executor/src/cachescanoperator.c b/source/libs/executor/src/cachescanoperator.c
index 934e50650c..0485d609f9 100644
--- a/source/libs/executor/src/cachescanoperator.c
+++ b/source/libs/executor/src/cachescanoperator.c
@@ -13,8 +13,8 @@
* along with this program. If not, see .
*/
-#include "os.h"
#include "function.h"
+#include "os.h"
#include "tname.h"
#include "tdatablock.h"
@@ -63,7 +63,7 @@ static void setColIdForCacheReadBlock(SSDataBlock* pBlock, SLastRowScanPhysiNode
int32_t idx = 0;
FOREACH(pNode, pScan->pTargets) {
if (nodeType(pNode) == QUERY_NODE_COLUMN) {
- SColumnNode* pCol = (SColumnNode*)pNode;
+ SColumnNode* pCol = (SColumnNode*)pNode;
SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, idx);
pColInfo->info.colId = pCol->colId;
}
@@ -90,6 +90,7 @@ int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandl
QRY_OPTR_CHECK(pOptrInfo);
int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
int32_t numOfCols = 0;
SNodeList* pScanCols = pScanNode->scan.pScanCols;
SCacheRowsScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SCacheRowsScanInfo));
@@ -108,9 +109,7 @@ int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandl
pInfo->pRes = createDataBlockFromDescNode(pDescNode);
code = extractColMatchInfo(pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
// todo: the pk information should comes from the physical plan
// pk info may not in pScanCols, so extract primary key from pInfo->matchInfo may failed
@@ -124,7 +123,7 @@ int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandl
pInfo->pkCol.pk = 1;
}
} else {
- for(int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) {
+ for (int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) {
SColMatchItem* pItem = taosArrayGet(pInfo->matchInfo.pList, i);
if (pItem->isPk) {
pInfo->numOfPks += 1;
@@ -136,24 +135,31 @@ int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandl
}
SArray* pCidList = taosArrayInit(numOfCols, sizeof(int16_t));
+ QUERY_CHECK_NULL(pCidList, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
+
pInfo->pFuncTypeList = taosArrayInit(taosArrayGetSize(pScanNode->pFuncTypes), sizeof(int32_t));
- taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes);
+ QUERY_CHECK_NULL(pInfo->pFuncTypeList, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
+
+ void* tmp = taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes);
+ if (!tmp && taosArrayGetSize(pScanNode->pFuncTypes) > 0) {
+ QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
+ }
for (int i = 0; i < TARRAY_SIZE(pInfo->matchInfo.pList); ++i) {
SColMatchItem* pColInfo = taosArrayGet(pInfo->matchInfo.pList, i);
- taosArrayPush(pCidList, &pColInfo->colId);
+ void* tmp = taosArrayPush(pCidList, &pColInfo->colId);
+ QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
if (pInfo->pFuncTypeList != NULL && taosArrayGetSize(pInfo->pFuncTypeList) > i) {
pColInfo->funcType = *(int32_t*)taosArrayGet(pInfo->pFuncTypeList, i);
}
}
pInfo->pCidList = pCidList;
- removeRedundantTsCol(pScanNode, &pInfo->matchInfo);
+ code = removeRedundantTsCol(pScanNode, &pInfo->matchInfo);
+ QUERY_CHECK_CODE(code, lino, _error);
code = extractCacheScanSlotId(pInfo->matchInfo.pList, pTaskInfo, &pInfo->pSlotIds, &pInfo->pDstSlotIds);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
int32_t totalTables = tableListGetSize(pTableListInfo);
int32_t capacity = 0;
@@ -169,17 +175,16 @@ int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandl
uint64_t suid = tableListGetSuid(pTableListInfo);
code = pInfo->readHandle.api.cacheFn.openReader(pInfo->readHandle.vnode, pInfo->retrieveType, pList, totalTables,
taosArrayGetSize(pInfo->matchInfo.pList), pCidList, pInfo->pSlotIds,
- suid, &pInfo->pLastrowReader, pTaskInfo->id.str, pScanNode->pFuncTypes,
- &pInfo->pkCol, pInfo->numOfPks);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ suid, &pInfo->pLastrowReader, pTaskInfo->id.str,
+ pScanNode->pFuncTypes, &pInfo->pkCol, pInfo->numOfPks);
+ QUERY_CHECK_CODE(code, lino, _error);
capacity = TMIN(totalTables, 4096);
pInfo->pBufferedRes = createOneDataBlock(pInfo->pRes, false);
setColIdForCacheReadBlock(pInfo->pBufferedRes, pScanNode);
- blockDataEnsureCapacity(pInfo->pBufferedRes, capacity);
+ code = blockDataEnsureCapacity(pInfo->pBufferedRes, capacity);
+ QUERY_CHECK_CODE(code, lino, _error);
} else { // by tags
pInfo->retrieveType = CACHESCAN_RETRIEVE_TYPE_SINGLE | SCAN_ROW_TYPE(pScanNode->ignoreNull);
capacity = 1; // only one row output
@@ -187,20 +192,22 @@ int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandl
}
initResultSizeInfo(&pOperator->resultInfo, capacity);
- blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _error);
if (pScanNode->scan.pScanPseudoCols != NULL) {
SExprSupp* p = &pInfo->pseudoExprSup;
p->pExprInfo = createExprInfo(pScanNode->scan.pScanPseudoCols, NULL, &p->numOfExprs);
- p->pCtx = createSqlFunctionCtx(p->pExprInfo, p->numOfExprs, &p->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore);
+ p->pCtx =
+ createSqlFunctionCtx(p->pExprInfo, p->numOfExprs, &p->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore);
}
setOperatorInfo(pOperator, "CachedRowScanOperator", QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN, false, OP_NOT_OPENED,
pInfo, pTaskInfo);
pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);
- pOperator->fpSet =
- createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
+ pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn,
+ NULL, optrDefaultGetNextExtFn, NULL);
pOperator->cost.openCost = 0;
@@ -209,6 +216,9 @@ int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandl
_error:
pTaskInfo->code = code;
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
destroyCacheScanOperator(pInfo);
taosMemoryFree(pOperator);
return code;
@@ -264,7 +274,7 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
if (pInfo->indexOfBufferedRes < pBufRes->info.rows) {
for (int32_t i = 0; i < taosArrayGetSize(pBufRes->pDataBlock); ++i) {
SColumnInfoData* pCol = taosArrayGet(pRes->pDataBlock, i);
- int32_t slotId = pCol->info.slotId;
+ int32_t slotId = pCol->info.slotId;
SColumnInfoData* pSrc = taosArrayGet(pBufRes->pDataBlock, slotId);
SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, slotId);
@@ -273,8 +283,12 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
colDataSetNULL(pDst, 0);
} else {
if (pSrc->pData) {
- char* p = colDataGetData(pSrc, pInfo->indexOfBufferedRes);
- colDataSetVal(pDst, 0, p, false);
+ char* p = colDataGetData(pSrc, pInfo->indexOfBufferedRes);
+ int32_t code = colDataSetVal(pDst, 0, p, false);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
}
}
}
@@ -326,7 +340,11 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
continue;
}
} else {
- pReaderFn->reuseReader(pInfo->pLastrowReader, pList, num);
+ code = pReaderFn->reuseReader(pInfo->pLastrowReader, pList, num);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
}
taosArrayClear(pInfo->pUidList);
@@ -358,10 +376,10 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
}
}
- //pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
+ // pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
return pInfo->pRes;
} else {
- //pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
+ // pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
}
}
@@ -408,12 +426,12 @@ int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTask
return TSDB_CODE_OUT_OF_MEMORY;
}
- SSchemaInfo* pSchemaInfo = taosArrayGetLast(pTaskInfo->schemaInfos);
+ SSchemaInfo* pSchemaInfo = taosArrayGetLast(pTaskInfo->schemaInfos);
SSchemaWrapper* pWrapper = pSchemaInfo->sw;
for (int32_t i = 0; i < numOfCols; ++i) {
SColMatchItem* pColMatch = taosArrayGet(pColMatchInfo, i);
- bool found = false;
+ bool found = false;
for (int32_t j = 0; j < pWrapper->nCols; ++j) {
/* if (pColMatch->colId == pWrapper->pSchema[j].colId && pColMatch->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
(*pSlotIds)[pColMatch->dstSlotId] = -1;
@@ -437,12 +455,15 @@ int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTask
}
int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pColMatchInfo) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (!pScanNode->ignoreNull) { // retrieve cached last value
return TSDB_CODE_SUCCESS;
}
size_t size = taosArrayGetSize(pColMatchInfo->pList);
SArray* pMatchInfo = taosArrayInit(size, sizeof(SColMatchItem));
+ QUERY_CHECK_NULL(pMatchInfo, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
for (int32_t i = 0; i < size; ++i) {
SColMatchItem* pColInfo = taosArrayGet(pColMatchInfo->pList, i);
@@ -452,13 +473,20 @@ int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pC
SSlotDescNode* pDesc = (SSlotDescNode*)nodesListGetNode(pList, slotId);
if (pDesc->dataType.type != TSDB_DATA_TYPE_TIMESTAMP) {
- taosArrayPush(pMatchInfo, pColInfo);
- } else if (FUNCTION_TYPE_CACHE_LAST_ROW == pColInfo->funcType){
- taosArrayPush(pMatchInfo, pColInfo);
+ void* tmp = taosArrayPush(pMatchInfo, pColInfo);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+ } else if (FUNCTION_TYPE_CACHE_LAST_ROW == pColInfo->funcType) {
+ void* tmp = taosArrayPush(pMatchInfo, pColInfo);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
}
taosArrayDestroy(pColMatchInfo->pList);
pColMatchInfo->pList = pMatchInfo;
- return TSDB_CODE_SUCCESS;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
diff --git a/source/libs/executor/src/countwindowoperator.c b/source/libs/executor/src/countwindowoperator.c
index 7ea4cb0900..54a0ca7aa6 100644
--- a/source/libs/executor/src/countwindowoperator.c
+++ b/source/libs/executor/src/countwindowoperator.c
@@ -74,12 +74,15 @@ static SCountWindowResult* getCountWinStateInfo(SCountWindowSupp* pCountSup) {
return pBuffInfo;
}
-static SCountWindowResult* setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup,
- SResultRow** pResult) {
+static int32_t setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SResultRow** pResult,
+ SCountWindowResult** ppResBuff) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SCountWindowResult* pBuff = getCountWinStateInfo(pCountSup);
(*pResult) = &pBuff->row;
- setResultRowInitCtx(*pResult, pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset);
- return pBuff;
+ code = setResultRowInitCtx(*pResult, pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset);
+ (*ppResBuff) = pBuff;
+ return code;
}
static int32_t updateCountWindowInfo(int32_t start, int32_t blockRows, int32_t countWinRows, int32_t* pCurrentRows) {
@@ -88,20 +91,26 @@ static int32_t updateCountWindowInfo(int32_t start, int32_t blockRows, int32_t c
return rows;
}
-int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
+void doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
SExprSupp* pExprSup = &pOperator->exprSupp;
SCountWindowOperatorInfo* pInfo = pOperator->info;
SSDataBlock* pRes = pInfo->binfo.pRes;
SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pInfo->tsSlotId);
TSKEY* tsCols = (TSKEY*)pColInfoData->pData;
- int32_t code = TSDB_CODE_SUCCESS;
for (int32_t i = 0; i < pBlock->info.rows;) {
- SCountWindowResult* pBuffInfo = setCountWindowOutputBuff(pExprSup, &pInfo->countSup, &pInfo->pRow);
- int32_t prevRows = pBuffInfo->winRows;
- int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows);
- int32_t step = num;
+ SCountWindowResult* pBuffInfo = NULL;
+ code = setCountWindowOutputBuff(pExprSup, &pInfo->countSup, &pInfo->pRow, &pBuffInfo);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
+ int32_t prevRows = pBuffInfo->winRows;
+ int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows);
+ int32_t step = num;
if (prevRows == 0) {
pInfo->pRow->win.skey = tsCols[i];
}
@@ -131,15 +140,17 @@ int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
}
i += step;
}
-
- return code;
}
static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SExecTaskInfo* pTaskInfo,
SFilterInfo* pFilterInfo, SSDataBlock* pBlock) {
SResultRow* pResultRow = NULL;
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
for (int32_t i = 0; i < taosArrayGetSize(pCountSup->pWinStates); i++) {
- SCountWindowResult* pBuff = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow);
+ SCountWindowResult* pBuff = NULL;
+ code = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow, &pBuff);
+ QUERY_CHECK_CODE(code, lino, _end);
if (pBuff->winRows == 0) {
continue;
}
@@ -150,7 +161,14 @@ static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, S
clearWinStateBuff(pBuff);
clearResultRowInitFlag(pExprSup->pCtx, pExprSup->numOfExprs);
}
- doFilter(pBlock, pFilterInfo, NULL);
+ code = doFilter(pBlock, pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
}
static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) {
@@ -246,7 +264,8 @@ int32_t createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* phy
QUERY_CHECK_CODE(code, lino, _error);
SSDataBlock* pResBlock = createDataBlockFromDescNode(pCountWindowNode->window.node.pOutputDataBlockDesc);
- blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _error);
initBasicInfo(&pInfo->binfo, pResBlock);
initResultRowInfo(&pInfo->binfo.resultRowInfo);
diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c
index e3e709762c..0326121b0c 100644
--- a/source/libs/executor/src/eventwindowoperator.c
+++ b/source/libs/executor/src/eventwindowoperator.c
@@ -208,8 +208,12 @@ static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) {
}
}
- eventWindowAggImpl(pOperator, pInfo, pBlock);
- doFilter(pRes, pSup->pFilterInfo, NULL);
+ code = eventWindowAggImpl(pOperator, pInfo, pBlock);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = doFilter(pRes, pSup->pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
+
if (pRes->info.rows >= pOperator->resultInfo.threshold) {
return pRes;
}
@@ -257,6 +261,8 @@ static void doEventWindowAggImpl(SEventWindowOperatorInfo* pInfo, SExprSupp* pSu
}
int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* pInfo, SSDataBlock* pBlock) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
SExprSupp* pSup = &pOperator->exprSupp;
SSDataBlock* pRes = pInfo->binfo.pRes;
@@ -278,22 +284,20 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p
SFilterColumnParam param1 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock};
- int32_t code = filterSetDataFromSlotId(pInfo->pStartCondInfo, ¶m1);
- if (code != TSDB_CODE_SUCCESS) {
- return code;
- }
+ code = filterSetDataFromSlotId(pInfo->pStartCondInfo, ¶m1);
+ QUERY_CHECK_CODE(code, lino, _return);
int32_t status1 = 0;
- filterExecute(pInfo->pStartCondInfo, pBlock, &ps, NULL, param1.numOfCols, &status1);
+ code = filterExecute(pInfo->pStartCondInfo, pBlock, &ps, NULL, param1.numOfCols, &status1);
+ QUERY_CHECK_CODE(code, lino, _return);
SFilterColumnParam param2 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock};
code = filterSetDataFromSlotId(pInfo->pEndCondInfo, ¶m2);
- if (code != TSDB_CODE_SUCCESS) {
- goto _return;
- }
+ QUERY_CHECK_CODE(code, lino, _return);
int32_t status2 = 0;
- filterExecute(pInfo->pEndCondInfo, pBlock, &pe, NULL, param2.numOfCols, &status2);
+ code = filterExecute(pInfo->pEndCondInfo, pBlock, &pe, NULL, param2.numOfCols, &status2);
+ QUERY_CHECK_CODE(code, lino, _return);
int32_t startIndex = pInfo->inWindow ? 0 : -1;
while (rowIndex < pBlock->info.rows) {
@@ -311,7 +315,8 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p
// check buffer size
if (pRes->info.rows + pInfo->pRow->numOfRows >= pRes->info.capacity) {
int32_t newSize = pRes->info.rows + pInfo->pRow->numOfRows;
- blockDataEnsureCapacity(pRes, newSize);
+ code = blockDataEnsureCapacity(pRes, newSize);
+ QUERY_CHECK_CODE(code, lino, _return);
}
copyResultrowToDataBlock(pSup->pExprInfo, pSup->numOfExprs, pInfo->pRow, pSup->pCtx, pRes,
@@ -348,6 +353,9 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p
_return:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
colDataDestroy(ps);
taosMemoryFree(ps);
colDataDestroy(pe);
diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c
index d07516f0b9..3c9d7dd869 100644
--- a/source/libs/executor/src/exchangeoperator.c
+++ b/source/libs/executor/src/exchangeoperator.c
@@ -45,10 +45,10 @@ typedef struct SSourceDataInfo {
int32_t decompBufSize;
} SSourceDataInfo;
-static void destroyExchangeOperatorInfo(void* param);
-static void freeBlock(void* pParam);
-static void freeSourceDataInfo(void* param);
-static void* setAllSourcesCompleted(SOperatorInfo* pOperator);
+static void destroyExchangeOperatorInfo(void* param);
+static void freeBlock(void* pParam);
+static void freeSourceDataInfo(void* param);
+static void setAllSourcesCompleted(SOperatorInfo* pOperator);
static int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code);
static int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex);
@@ -171,6 +171,7 @@ _error:
}
static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) {
+ int32_t code = TSDB_CODE_SUCCESS;
SExchangeInfo* pExchangeInfo = pOperator->info;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
@@ -192,11 +193,22 @@ static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) {
}
if (p != NULL) {
- taosArrayPush(pExchangeInfo->pRecycledBlocks, &p);
+ void* tmp = taosArrayPush(pExchangeInfo->pRecycledBlocks, &p);
+ if (!tmp) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return p;
} else {
if (pExchangeInfo->seqLoadData) {
- seqLoadRemoteData(pOperator);
+ code = seqLoadRemoteData(pOperator);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
} else {
concurrentlyLoadRemoteDataImpl(pOperator, pExchangeInfo, pTaskInfo);
}
@@ -206,7 +218,13 @@ static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) {
} else {
p = taosArrayGetP(pExchangeInfo->pResultBlockList, 0);
taosArrayRemove(pExchangeInfo->pResultBlockList, 0);
- taosArrayPush(pExchangeInfo->pRecycledBlocks, &p);
+ void* tmp = taosArrayPush(pExchangeInfo->pRecycledBlocks, &p);
+ if (!tmp) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return p;
}
}
@@ -231,7 +249,11 @@ static SSDataBlock* loadRemoteData(SOperatorInfo* pOperator) {
return NULL;
}
- doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ pTaskInfo->code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ if (pTaskInfo->code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(pTaskInfo->code));
+ T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ }
if (blockDataGetNumOfRows(pBlock) == 0) {
continue;
}
@@ -293,21 +315,32 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo*
pInfo->pSources = taosArrayInit(numOfSources, sizeof(SDownstreamSourceNode));
if (pInfo->pSources == NULL) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
return TSDB_CODE_OUT_OF_MEMORY;
}
if (pExNode->node.dynamicOp) {
pInfo->pHashSources = tSimpleHashInit(numOfSources * 2, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT));
if (NULL == pInfo->pHashSources) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
return TSDB_CODE_OUT_OF_MEMORY;
}
}
for (int32_t i = 0; i < numOfSources; ++i) {
SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)nodesListGetNode((SNodeList*)pExNode->pSrcEndPoints, i);
- taosArrayPush(pInfo->pSources, pNode);
+ void* tmp = taosArrayPush(pInfo->pSources, pNode);
+ if (!tmp) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
SExchangeSrcIndex idx = {.srcIdx = i, .inUseIdx = -1};
- tSimpleHashPut(pInfo->pHashSources, &pNode->addr.nodeId, sizeof(pNode->addr.nodeId), &idx, sizeof(idx));
+ int32_t code =
+ tSimpleHashPut(pInfo->pHashSources, &pNode->addr.nodeId, sizeof(pNode->addr.nodeId), &idx, sizeof(idx));
+ if (pInfo->pHashSources && code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ return code;
+ }
}
initLimitInfo(pExNode->node.pLimit, pExNode->node.pSlimit, &pInfo->limitInfo);
@@ -321,6 +354,7 @@ int32_t createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNo
QRY_OPTR_CHECK(pOptrInfo);
int32_t code = 0;
+ int32_t lino = 0;
SExchangeInfo* pInfo = taosMemoryCalloc(1, sizeof(SExchangeInfo));
SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
if (pInfo == NULL || pOperator == NULL) {
@@ -330,17 +364,18 @@ int32_t createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNo
pInfo->dynamicOp = pExNode->node.dynamicOp;
code = initExchangeOperator(pExNode, pInfo, GET_TASKID(pTaskInfo));
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
+
+ code = tsem_init(&pInfo->ready, 0, 0);
+ QUERY_CHECK_CODE(code, lino, _error);
- tsem_init(&pInfo->ready, 0, 0);
pInfo->pDummyBlock = createDataBlockFromDescNode(pExNode->node.pOutputDataBlockDesc);
pInfo->pResultBlockList = taosArrayInit(64, POINTER_BYTES);
pInfo->pRecycledBlocks = taosArrayInit(64, POINTER_BYTES);
SExchangeOpStopInfo stopInfo = {QUERY_NODE_PHYSICAL_PLAN_EXCHANGE, pInfo->self};
- qAppendTaskStopInfo(pTaskInfo, &stopInfo);
+ code = qAppendTaskStopInfo(pTaskInfo, &stopInfo);
+ QUERY_CHECK_CODE(code, lino, _error);
pInfo->seqLoadData = pExNode->seqRecvData;
pInfo->pTransporter = pTransporter;
@@ -350,9 +385,7 @@ int32_t createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNo
pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pDummyBlock->pDataBlock);
code = filterInitFromNode((SNode*)pExNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
pOperator->fpSet = createOperatorFpSet(prepareLoadRemoteData, loadRemoteData, NULL, destroyExchangeOperatorInfo,
optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
@@ -360,6 +393,10 @@ int32_t createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNo
return code;
_error:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ }
if (pInfo != NULL) {
doDestroyExchangeOperatorInfo(pInfo);
}
@@ -371,7 +408,7 @@ _error:
void destroyExchangeOperatorInfo(void* param) {
SExchangeInfo* pExInfo = (SExchangeInfo*)param;
- taosRemoveRef(exchangeObjRefPool, pExInfo->self);
+ (void)taosRemoveRef(exchangeObjRefPool, pExInfo->self);
}
void freeBlock(void* pParam) {
@@ -399,7 +436,7 @@ void doDestroyExchangeOperatorInfo(void* param) {
blockDataDestroy(pExInfo->pDummyBlock);
tSimpleHashCleanup(pExInfo->pHashSources);
- tsem_destroy(&pExInfo->ready);
+ (void)tsem_destroy(&pExInfo->ready);
taosMemoryFreeClear(pExInfo->pTaskId);
taosMemoryFreeClear(param);
@@ -451,7 +488,7 @@ int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code) {
qError("failed to invoke post when fetch rsp is ready, code:%s, %p", tstrerror(code), pExchangeInfo);
}
- taosReleaseRef(exchangeObjRefPool, pWrapper->exchangeId);
+ (void)taosReleaseRef(exchangeObjRefPool, pWrapper->exchangeId);
return code;
}
@@ -484,6 +521,8 @@ int32_t buildTableScanOperatorParam(SOperatorParam** ppRes, SArray* pUidList, in
}
int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, sourceIndex);
if (EX_SOURCE_DATA_NOT_READY != pDataInfo->status) {
return TSDB_CODE_SUCCESS;
@@ -495,6 +534,7 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources);
SFetchRspHandleWrapper* pWrapper = taosMemoryCalloc(1, sizeof(SFetchRspHandleWrapper));
+ QUERY_CHECK_NULL(pWrapper, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
pWrapper->exchangeId = pExchangeInfo->self;
pWrapper->sourceIndex = sourceIndex;
@@ -503,7 +543,8 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
int32_t code =
(*pTaskInfo->localFetch.fp)(pTaskInfo->localFetch.handle, pSource->schedId, pTaskInfo->id.queryId,
pSource->taskId, 0, pSource->execId, &pBuf.pData, pTaskInfo->localFetch.explainRes);
- loadRemoteDataCallback(pWrapper, &pBuf, code);
+ code = loadRemoteDataCallback(pWrapper, &pBuf, code);
+ QUERY_CHECK_CODE(code, lino, _end);
taosMemoryFree(pWrapper);
} else {
SResFetchReq req = {0};
@@ -572,11 +613,15 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
pMsgSendInfo->fp = loadRemoteDataCallback;
int64_t transporterId = 0;
- int32_t code =
- asyncSendMsgToServer(pExchangeInfo->pTransporter, &pSource->addr.epSet, &transporterId, pMsgSendInfo);
+ code = asyncSendMsgToServer(pExchangeInfo->pTransporter, &pSource->addr.epSet, &transporterId, pMsgSendInfo);
+ QUERY_CHECK_CODE(code, lino, _end);
}
- return TSDB_CODE_SUCCESS;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
void updateLoadRemoteInfo(SLoadRemoteDataInfo* pInfo, int64_t numOfRows, int32_t dataLen, int64_t startTs,
@@ -588,6 +633,8 @@ void updateLoadRemoteInfo(SLoadRemoteDataInfo* pInfo, int64_t numOfRows, int32_t
}
int32_t extractDataBlockFromFetchRsp(SSDataBlock* pRes, char* pData, SArray* pColList, char** pNextStart) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (pColList == NULL) { // data from other sources
blockDataCleanup(pRes);
*pNextStart = (char*)blockDecode(pRes, pData);
@@ -610,24 +657,32 @@ int32_t extractDataBlockFromFetchRsp(SSDataBlock* pRes, char* pData, SArray* pCo
SSDataBlock* pBlock = createDataBlock();
for (int32_t i = 0; i < numOfCols; ++i) {
SColumnInfoData idata = createColumnInfoData(pSchema[i].type, pSchema[i].bytes, pSchema[i].colId);
- blockDataAppendColInfo(pBlock, &idata);
+ code = blockDataAppendColInfo(pBlock, &idata);
+ QUERY_CHECK_CODE(code, lino, _end);
}
- (void) blockDecode(pBlock, pStart);
- blockDataEnsureCapacity(pRes, pBlock->info.rows);
+ (void)blockDecode(pBlock, pStart);
+ code = blockDataEnsureCapacity(pRes, pBlock->info.rows);
+ QUERY_CHECK_CODE(code, lino, _end);
// data from mnode
pRes->info.dataLoad = 1;
pRes->info.rows = pBlock->info.rows;
pRes->info.scanFlag = MAIN_SCAN;
- relocateColumnData(pRes, pColList, pBlock->pDataBlock, false);
+ code = relocateColumnData(pRes, pColList, pBlock->pDataBlock, false);
+ QUERY_CHECK_CODE(code, lino, _end);
+
blockDataDestroy(pBlock);
}
- return TSDB_CODE_SUCCESS;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
-void* setAllSourcesCompleted(SOperatorInfo* pOperator) {
+void setAllSourcesCompleted(SOperatorInfo* pOperator) {
SExchangeInfo* pExchangeInfo = pOperator->info;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
@@ -638,7 +693,6 @@ void* setAllSourcesCompleted(SOperatorInfo* pOperator) {
pLoadInfo->totalElapsed / 1000.0);
setOperatorCompleted(pOperator);
- return NULL;
}
int32_t getCompletedSources(const SArray* pArray) {
@@ -685,21 +739,24 @@ int32_t prepareConcurrentlyLoad(SOperatorInfo* pOperator) {
}
int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDataInfo) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SRetrieveTableRsp* pRetrieveRsp = pDataInfo->pRsp;
- char* pNextStart = pRetrieveRsp->data;
- char* pStart = pNextStart;
+ char* pNextStart = pRetrieveRsp->data;
+ char* pStart = pNextStart;
int32_t index = 0;
- int32_t code = 0;
if (pRetrieveRsp->compressed) { // decompress the data
if (pDataInfo->decompBuf == NULL) {
pDataInfo->decompBuf = taosMemoryMalloc(pRetrieveRsp->payloadLen);
+ QUERY_CHECK_NULL(pDataInfo->decompBuf, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
pDataInfo->decompBufSize = pRetrieveRsp->payloadLen;
} else {
if (pDataInfo->decompBufSize < pRetrieveRsp->payloadLen) {
char* p = taosMemoryRealloc(pDataInfo->decompBuf, pRetrieveRsp->payloadLen);
+ QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
if (p != NULL) {
pDataInfo->decompBuf = p;
pDataInfo->decompBufSize = pRetrieveRsp->payloadLen;
@@ -708,7 +765,6 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa
}
}
-
while (index++ < pRetrieveRsp->numOfBlocks) {
SSDataBlock* pb = NULL;
pStart = pNextStart;
@@ -718,12 +774,13 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa
blockDataCleanup(pb);
} else {
pb = createOneDataBlock(pExchangeInfo->pDummyBlock, false);
+ QUERY_CHECK_NULL(pb, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
- int32_t compLen = *(int32_t*) pStart;
+ int32_t compLen = *(int32_t*)pStart;
pStart += sizeof(int32_t);
- int32_t rawLen = *(int32_t*) pStart;
+ int32_t rawLen = *(int32_t*)pStart;
pStart += sizeof(int32_t);
ASSERT(compLen <= rawLen && compLen != 0);
@@ -740,9 +797,14 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa
return code;
}
- taosArrayPush(pExchangeInfo->pResultBlockList, &pb);
+ void* tmp = taosArrayPush(pExchangeInfo->pResultBlockList, &pb);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
return code;
}
@@ -763,7 +825,13 @@ int32_t seqLoadRemoteData(SOperatorInfo* pOperator) {
SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pExchangeInfo->current);
pDataInfo->status = EX_SOURCE_DATA_NOT_READY;
- doSendFetchDataRequest(pExchangeInfo, pTaskInfo, pExchangeInfo->current);
+ code = doSendFetchDataRequest(pExchangeInfo, pTaskInfo, pExchangeInfo->current);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ }
+
code = exchangeWait(pOperator, pExchangeInfo);
if (code != TSDB_CODE_SUCCESS || isTaskKilled(pTaskInfo)) {
T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
@@ -844,7 +912,11 @@ int32_t addSingleExchangeSource(SOperatorInfo* pOperator, SExchangeOperatorBasic
dataInfo.srcOpType = pBasicParam->srcOpType;
dataInfo.tableSeq = pBasicParam->tableSeq;
- taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo);
+ void* tmp = taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo);
+ if (!tmp) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
pIdx->inUseIdx = taosArrayGetSize(pExchangeInfo->pSourceDataInfo) - 1;
} else {
SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pIdx->inUseIdx);
@@ -990,7 +1062,7 @@ static int32_t exchangeWait(SOperatorInfo* pOperator, SExchangeInfo* pExchangeIn
return pTask->code;
}
}
- tsem_wait(&pExchangeInfo->ready);
+ (void)tsem_wait(&pExchangeInfo->ready);
if (pTask->pWorkerCb) {
code = pTask->pWorkerCb->afterRecoverFromBlocking(pTask->pWorkerCb->pPool);
if (code != TSDB_CODE_SUCCESS) {
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 45edccb16d..5db27478fc 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -143,7 +143,7 @@ void initGroupedResultInfo(SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, in
// todo move away and record this during create window
while ((pData = tSimpleHashIterate(pHashmap, pData, &iter)) != NULL) {
- /*void* key = */ tSimpleHashGetKey(pData, &keyLen);
+ /*void* key = */ (void)tSimpleHashGetKey(pData, &keyLen);
bufLen += keyLen + sizeof(SResultRowPosition);
}
@@ -222,7 +222,13 @@ SArray* createSortInfo(SNodeList* pNodeList) {
SColumnNode* pColNode = (SColumnNode*)pSortKey->pExpr;
bi.slotId = pColNode->slotId;
- taosArrayPush(pList, &bi);
+ void* tmp = taosArrayPush(pList, &bi);
+ if (!tmp) {
+ taosArrayDestroy(pList);
+ pList = NULL;
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
+ break;
+ }
}
return pList;
@@ -245,7 +251,14 @@ SSDataBlock* createDataBlockFromDescNode(SDataBlockDescNode* pNode) {
idata.info.scale = pDescNode->dataType.scale;
idata.info.precision = pDescNode->dataType.precision;
- blockDataAppendColInfo(pBlock, &idata);
+ int32_t code = blockDataAppendColInfo(pBlock, &idata);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ blockDataDestroy(pBlock);
+ pBlock = NULL;
+ terrno = code;
+ break;
+ }
}
return pBlock;
@@ -288,7 +301,7 @@ int32_t prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo)
EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
SMetaReader* mr = (SMetaReader*)pContext;
- bool isTagCol = false, isTbname = false;
+ bool isTagCol = false, isTbname = false;
if (nodeType(*pNode) == QUERY_NODE_COLUMN) {
SColumnNode* pCol = (SColumnNode*)*pNode;
if (pCol->colType == COLUMN_TYPE_TBNAME)
@@ -297,8 +310,7 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
isTagCol = true;
} else if (nodeType(*pNode) == QUERY_NODE_FUNCTION) {
SFunctionNode* pFunc = (SFunctionNode*)*pNode;
- if (pFunc->funcType == FUNCTION_TYPE_TBNAME)
- isTbname = true;
+ if (pFunc->funcType == FUNCTION_TYPE_TBNAME) isTbname = true;
}
if (isTagCol) {
SColumnNode* pSColumnNode = *(SColumnNode**)pNode;
@@ -325,7 +337,10 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
memcpy(varDataVal(res->datum.p), tagVal.pData, tagVal.nData);
varDataSetLen(res->datum.p, tagVal.nData);
} else {
- nodesSetValueNodeValue(res, &(tagVal.i64));
+ int32_t code = nodesSetValueNodeValue(res, &(tagVal.i64));
+ if (code != TSDB_CODE_SUCCESS) {
+ return DEAL_RES_ERROR;
+ }
}
nodesDestroyNode(*pNode);
*pNode = (SNode*)res;
@@ -411,7 +426,11 @@ static EDealRes getColumn(SNode** pNode, void* pContext) {
tagFilterAssist* pData = (tagFilterAssist*)pContext;
void* data = taosHashGet(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));
if (!data) {
- taosHashPut(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));
+ int32_t tempRes =
+ taosHashPut(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));
+ if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+ return DEAL_RES_ERROR;
+ }
pSColumnNode->slotId = pData->index++;
SColumnInfo cInfo = {.colId = pSColumnNode->colId,
.type = pSColumnNode->node.resType.type,
@@ -420,7 +439,10 @@ static EDealRes getColumn(SNode** pNode, void* pContext) {
#if TAG_FILTER_DEBUG
qDebug("tagfilter build column info, slotId:%d, colId:%d, type:%d", pSColumnNode->slotId, cInfo.colId, cInfo.type);
#endif
- taosArrayPush(pData->cInfoList, &cInfo);
+ void* tmp = taosArrayPush(pData->cInfoList, &cInfo);
+ if (!tmp) {
+ return DEAL_RES_ERROR;
+ }
} else {
SColumnNode* col = *(SColumnNode**)data;
pSColumnNode->slotId = col->slotId;
@@ -468,28 +490,38 @@ void freeItem(void* p) {
}
}
-static void genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) {
+static int32_t genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) {
if (pTagCond == NULL) {
- return;
+ return TSDB_CODE_SUCCESS;
}
char* payload = NULL;
int32_t len = 0;
- nodesNodeToMsg(pTagCond, &payload, &len);
+ int32_t code = nodesNodeToMsg(pTagCond, &payload, &len);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ return code;
+ }
tMD5Init(pContext);
tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len);
tMD5Final(pContext);
taosMemoryFree(payload);
+ return TSDB_CODE_SUCCESS;
}
-static void genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_CTX* pContext) {
+static int32_t genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_CTX* pContext) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
char* payload = NULL;
int32_t len = 0;
- nodesNodeToMsg(pGroup, &payload, &len);
+ code = nodesNodeToMsg(pGroup, &payload, &len);
+ QUERY_CHECK_CODE(code, lino, _end);
+
if (filterDigest[0]) {
payload = taosMemoryRealloc(payload, len + tListLen(pContext->digest));
+ QUERY_CHECK_NULL(payload, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
memcpy(payload + len, filterDigest + 1, tListLen(pContext->digest));
len += tListLen(pContext->digest);
}
@@ -498,12 +530,18 @@ static void genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_C
tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len);
tMD5Final(pContext);
+_end:
taosMemoryFree(payload);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInfo* pTableListInfo, uint8_t* digest,
SStorageAPI* pAPI, bool initRemainGroups) {
int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SArray* pBlockList = NULL;
SSDataBlock* pResBlock = NULL;
void* keyBuf = NULL;
@@ -540,11 +578,15 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
if (tsTagFilterCache) {
SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST);
listNode->pNodeList = group;
- genTbGroupDigest((SNode*)listNode, digest, &context);
+ code = genTbGroupDigest((SNode*)listNode, digest, &context);
+ QUERY_CHECK_CODE(code, lino, end);
+
nodesFree(listNode);
- pAPI->metaFn.metaGetCachedTbGroup(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest),
- &tableList);
+ code = pAPI->metaFn.metaGetCachedTbGroup(pVnode, pTableListInfo->idInfo.suid, context.digest,
+ tListLen(context.digest), &tableList);
+ QUERY_CHECK_CODE(code, lino, end);
+
if (tableList) {
taosArrayDestroy(pTableListInfo->pTableList);
pTableListInfo->pTableList = tableList;
@@ -555,10 +597,13 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
}
pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo));
+ QUERY_CHECK_NULL(pUidTagList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
+
for (int32_t i = 0; i < rows; ++i) {
STableKeyInfo* pkeyInfo = taosArrayGet(pTableListInfo->pTableList, i);
STUidTagInfo info = {.uid = pkeyInfo->uid};
- taosArrayPush(pUidTagList, &info);
+ void* tmp = taosArrayPush(pUidTagList, &info);
+ QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
}
code = pAPI->metaFn.getTableTags(pVnode, pTableListInfo->idInfo.suid, pUidTagList);
@@ -577,9 +622,14 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
// qDebug("generate tag block rows:%d, cost:%ld us", rows, st1-st);
pBlockList = taosArrayInit(2, POINTER_BYTES);
- taosArrayPush(pBlockList, &pResBlock);
+ QUERY_CHECK_NULL(pBlockList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
+
+ void* tmp = taosArrayPush(pBlockList, &pResBlock);
+ QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
groupData = taosArrayInit(2, POINTER_BYTES);
+ QUERY_CHECK_NULL(groupData, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
+
FOREACH(pNode, group) {
SScalarParam output = {0};
@@ -617,7 +667,8 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
goto end;
}
- taosArrayPush(groupData, &output.columnData);
+ void* tmp = taosArrayPush(groupData, &output.columnData);
+ QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
}
int32_t keyLen = 0;
@@ -688,15 +739,21 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
info->groupId = calcGroupId(keyBuf, len);
if (initRemainGroups) {
// groupId ~ table uid
- taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid),
- sizeof(info->uid));
+ code = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid),
+ sizeof(info->uid));
+ if (code == TSDB_CODE_DUP_KEY) {
+ code = TSDB_CODE_SUCCESS;
+ }
+ QUERY_CHECK_CODE(code, lino, end);
}
}
if (tsTagFilterCache) {
tableList = taosArrayDup(pTableListInfo->pTableList, NULL);
- pAPI->metaFn.metaPutTbGroupToCache(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest),
- tableList, taosArrayGetSize(tableList) * sizeof(STableKeyInfo));
+ code = pAPI->metaFn.metaPutTbGroupToCache(pVnode, pTableListInfo->idInfo.suid, context.digest,
+ tListLen(context.digest), tableList,
+ taosArrayGetSize(tableList) * sizeof(STableKeyInfo));
+ QUERY_CHECK_CODE(code, lino, end);
}
// int64_t st2 = taosGetTimestampUs();
@@ -710,6 +767,9 @@ end:
taosArrayDestroy(pBlockList);
taosArrayDestroyEx(pUidTagList, freeItem);
taosArrayDestroyP(groupData, releaseColInfoData);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
return code;
}
@@ -726,10 +786,14 @@ static int32_t nameComparFn(const void* p1, const void* p2) {
}
static SArray* getTableNameList(const SNodeListNode* pList) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
int32_t len = LIST_LENGTH(pList->pNodeList);
SListCell* cell = pList->pNodeList->pHead;
SArray* pTbList = taosArrayInit(len, POINTER_BYTES);
+ QUERY_CHECK_NULL(pTbList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
for (int i = 0; i < pList->pNodeList->length; i++) {
SValueNode* valueNode = (SValueNode*)cell->pNode;
if (!IS_VAR_DATA_TYPE(valueNode->node.resType.type)) {
@@ -739,7 +803,8 @@ static SArray* getTableNameList(const SNodeListNode* pList) {
}
char* name = varDataVal(valueNode->datum.p);
- taosArrayPush(pTbList, &name);
+ void* tmp = taosArrayPush(pTbList, &name);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
cell = cell->pNext;
}
@@ -750,7 +815,8 @@ static SArray* getTableNameList(const SNodeListNode* pList) {
// remove the duplicates
SArray* pNewList = taosArrayInit(taosArrayGetSize(pTbList), sizeof(void*));
- taosArrayPush(pNewList, taosArrayGet(pTbList, 0));
+ void* tmp = taosArrayPush(pNewList, taosArrayGet(pTbList, 0));
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
for (int32_t i = 1; i < numOfTables; ++i) {
char** name = taosArrayGetLast(pNewList);
@@ -759,10 +825,16 @@ static SArray* getTableNameList(const SNodeListNode* pList) {
continue;
}
- taosArrayPush(pNewList, nameInOldList);
+ tmp = taosArrayPush(pNewList, nameInOldList);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
+_end:
taosArrayDestroy(pTbList);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ return NULL;
+ }
return pNewList;
}
@@ -868,9 +940,18 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S
size_t numOfExisted = taosArrayGetSize(pExistedUidList); // len > 0 means there already have uids
if (numOfExisted > 0) {
uHash = taosHashInit(numOfExisted / 0.7, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
+ if (!uHash) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+
for (int i = 0; i < numOfExisted; i++) {
STUidTagInfo* pTInfo = taosArrayGet(pExistedUidList, i);
- taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i));
+ int32_t tempRes = taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i));
+ if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));
+ return tempRes;
+ }
}
}
@@ -883,7 +964,10 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S
if (pStoreAPI->metaFn.getTableTypeByName(pVnode, name, &tbType) == 0 && tbType == TSDB_CHILD_TABLE) {
if (NULL == uHash || taosHashGet(uHash, &uid, sizeof(uid)) == NULL) {
STUidTagInfo s = {.uid = uid, .name = name, .pTagVal = NULL};
- taosArrayPush(pExistedUidList, &s);
+ void* tmp = taosArrayPush(pExistedUidList, &s);
+ if (!tmp) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
}
} else {
taosArrayDestroy(pTbList);
@@ -906,6 +990,8 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S
SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList, void* pVnode,
SStorageAPI* pStorageAPI) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SSDataBlock* pResBlock = createDataBlock();
if (pResBlock == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -915,10 +1001,11 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S
for (int32_t i = 0; i < taosArrayGetSize(pColList); ++i) {
SColumnInfoData colInfo = {0};
colInfo.info = *(SColumnInfo*)taosArrayGet(pColList, i);
- blockDataAppendColInfo(pResBlock, &colInfo);
+ code = blockDataAppendColInfo(pResBlock, &colInfo);
+ QUERY_CHECK_CODE(code, lino, _end);
}
- int32_t code = blockDataEnsureCapacity(pResBlock, numOfTables);
+ code = blockDataEnsureCapacity(pResBlock, numOfTables);
if (code != TSDB_CODE_SUCCESS) {
terrno = code;
taosMemoryFree(pResBlock);
@@ -940,10 +1027,12 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S
if (p1->name != NULL) {
STR_TO_VARSTR(str, p1->name);
} else { // name is not retrieved during filter
- pStorageAPI->metaFn.getTableNameByUid(pVnode, p1->uid, str);
+ code = pStorageAPI->metaFn.getTableNameByUid(pVnode, p1->uid, str);
+ QUERY_CHECK_CODE(code, lino, _end);
}
- colDataSetVal(pColInfo, i, str, false);
+ code = colDataSetVal(pColInfo, i, str, false);
+ QUERY_CHECK_CODE(code, lino, _end);
#if TAG_FILTER_DEBUG
qDebug("tagfilter uid:%ld, tbname:%s", *uid, str + 2);
#endif
@@ -958,18 +1047,22 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S
if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) {
colDataSetNULL(pColInfo, i);
} else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) {
- colDataSetVal(pColInfo, i, p, false);
+ code = colDataSetVal(pColInfo, i, p, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) {
char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
varDataSetLen(tmp, tagVal.nData);
memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData);
- colDataSetVal(pColInfo, i, tmp, false);
+ code = colDataSetVal(pColInfo, i, tmp, false);
+ QUERY_CHECK_CODE(code, lino, _end);
#if TAG_FILTER_DEBUG
qDebug("tagfilter varch:%s", tmp + 2);
#endif
taosMemoryFree(tmp);
} else {
- colDataSetVal(pColInfo, i, (const char*)&tagVal.i64, false);
+ code = colDataSetVal(pColInfo, i, (const char*)&tagVal.i64, false);
+ QUERY_CHECK_CODE(code, lino, _end);
#if TAG_FILTER_DEBUG
if (pColInfo->info.type == TSDB_DATA_TYPE_INT) {
qDebug("tagfilter int:%d", *(int*)(&tagVal.i64));
@@ -983,6 +1076,13 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S
}
}
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ taosMemoryFree(pResBlock);
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ terrno = code;
+ return NULL;
+ }
return pResBlock;
}
@@ -1004,7 +1104,10 @@ static int32_t doSetQualifiedUid(STableListInfo* pListInfo, SArray* pUidList, co
}
if (addUid) {
- taosArrayPush(pUidList, &uid);
+ void* tmp = taosArrayPush(pUidList, &uid);
+ if (tmp == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
}
}
}
@@ -1012,17 +1115,23 @@ static int32_t doSetQualifiedUid(STableListInfo* pListInfo, SArray* pUidList, co
return TSDB_CODE_SUCCESS;
}
-static void copyExistedUids(SArray* pUidTagList, const SArray* pUidList) {
+static int32_t copyExistedUids(SArray* pUidTagList, const SArray* pUidList) {
+ int32_t code = TSDB_CODE_SUCCESS;
int32_t numOfExisted = taosArrayGetSize(pUidList);
if (numOfExisted == 0) {
- return;
+ return code;
}
for (int32_t i = 0; i < numOfExisted; ++i) {
uint64_t* uid = taosArrayGet(pUidList, i);
STUidTagInfo info = {.uid = *uid};
- taosArrayPush(pUidTagList, &info);
+ void* tmp = taosArrayPush(pUidTagList, &info);
+ if (!tmp) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+ return code;
+ }
}
+ return code;
}
static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SNode* pTagCond, void* pVnode,
@@ -1034,6 +1143,7 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
terrno = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
int32_t code = TSDB_CODE_SUCCESS;
SArray* pBlockList = NULL;
SSDataBlock* pResBlock = NULL;
@@ -1044,13 +1154,15 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
ctx.colHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);
if (ctx.colHash == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
- goto end;
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ QUERY_CHECK_CODE(code, lino, end);
}
ctx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));
if (ctx.cInfoList == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
- goto end;
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ QUERY_CHECK_CODE(code, lino, end);
}
nodesRewriteExprPostOrder(&pTagCond, getColumn, (void*)&ctx);
@@ -1059,7 +1171,10 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
// int64_t stt = taosGetTimestampUs();
pUidTagList = taosArrayInit(10, sizeof(STUidTagInfo));
- copyExistedUids(pUidTagList, pUidList);
+ QUERY_CHECK_NULL(pUidTagList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
+
+ code = copyExistedUids(pUidTagList, pUidList);
+ QUERY_CHECK_CODE(code, lino, end);
FilterCondType condType = checkTagCond(pTagCond);
@@ -1068,10 +1183,13 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
taosArrayClear(pUidList);
int32_t numOfRows = taosArrayGetSize(pUidTagList);
- taosArrayEnsureCap(pUidList, numOfRows);
+ code = taosArrayEnsureCap(pUidList, numOfRows);
+ QUERY_CHECK_CODE(code, lino, end);
+
for (int32_t i = 0; i < numOfRows; ++i) {
STUidTagInfo* pInfo = taosArrayGet(pUidTagList, i);
- taosArrayPush(pUidList, &pInfo->uid);
+ void* tmp = taosArrayPush(pUidList, &pInfo->uid);
+ QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
}
terrno = 0;
} else {
@@ -1083,7 +1201,7 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
if (code != TSDB_CODE_SUCCESS) {
qError("failed to get table tags from meta, reason:%s, suid:%" PRIu64, tstrerror(code), pListInfo->idInfo.suid);
terrno = code;
- goto end;
+ QUERY_CHECK_CODE(code, lino, end);
}
}
@@ -1095,35 +1213,41 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
pResBlock = createTagValBlockForFilter(ctx.cInfoList, numOfTables, pUidTagList, pVnode, pAPI);
if (pResBlock == NULL) {
code = terrno;
- goto end;
+ QUERY_CHECK_CODE(code, lino, end);
}
// int64_t st1 = taosGetTimestampUs();
// qDebug("generate tag block rows:%d, cost:%ld us", rows, st1-st);
pBlockList = taosArrayInit(2, POINTER_BYTES);
- taosArrayPush(pBlockList, &pResBlock);
+ QUERY_CHECK_NULL(pBlockList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
+
+ void* tmp = taosArrayPush(pBlockList, &pResBlock);
+ QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
code = createResultData(&type, numOfTables, &output);
if (code != TSDB_CODE_SUCCESS) {
terrno = code;
- goto end;
+ QUERY_CHECK_CODE(code, lino, end);
}
code = scalarCalculate(pTagCond, pBlockList, &output);
if (code != TSDB_CODE_SUCCESS) {
qError("failed to calculate scalar, reason:%s", tstrerror(code));
terrno = code;
- goto end;
+ QUERY_CHECK_CODE(code, lino, end);
}
code = doSetQualifiedUid(pListInfo, pUidList, pUidTagList, (bool*)output.columnData->pData, addUid);
if (code != TSDB_CODE_SUCCESS) {
terrno = code;
- goto end;
+ QUERY_CHECK_CODE(code, lino, end);
}
*listAdded = true;
end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
taosHashCleanup(ctx.colHash);
taosArrayDestroy(ctx.cInfoList);
blockDataDestroy(pResBlock);
@@ -1138,6 +1262,7 @@ end:
int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, SNode* pTagIndexCond,
STableListInfo* pListInfo, uint8_t* digest, const char* idstr, SStorageAPI* pStorageAPI) {
int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
size_t numOfTables = 0;
bool listAdded = false;
@@ -1145,27 +1270,30 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
pListInfo->idInfo.tableType = pScanNode->tableType;
SArray* pUidList = taosArrayInit(8, sizeof(uint64_t));
+ QUERY_CHECK_NULL(pUidList, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
SIdxFltStatus status = SFLT_NOT_INDEX;
if (pScanNode->tableType != TSDB_SUPER_TABLE) {
pListInfo->idInfo.uid = pScanNode->uid;
if (pStorageAPI->metaFn.isTableExisted(pVnode, pScanNode->uid)) {
- taosArrayPush(pUidList, &pScanNode->uid);
+ void* tmp = taosArrayPush(pUidList, &pScanNode->uid);
+ QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
}
code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, false, &listAdded);
- if (code != TSDB_CODE_SUCCESS) {
- goto _end;
- }
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
T_MD5_CTX context = {0};
if (tsTagFilterCache) {
// try to retrieve the result from meta cache
- genTagFilterDigest(pTagCond, &context);
+ code = genTagFilterDigest(pTagCond, &context);
+ QUERY_CHECK_CODE(code, lino, _error);
bool acquired = false;
- pStorageAPI->metaFn.getCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest),
- pUidList, &acquired);
+ code = pStorageAPI->metaFn.getCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest),
+ pUidList, &acquired);
+ QUERY_CHECK_CODE(code, lino, _error);
+
if (acquired) {
digest[0] = 1;
memcpy(digest + 1, context.digest, tListLen(context.digest));
@@ -1175,7 +1303,8 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
}
if (!pTagCond) { // no tag filter condition exists, let's fetch all tables of this super table
- pStorageAPI->metaFn.getChildTableList(pVnode, pScanNode->suid, pUidList);
+ code = pStorageAPI->metaFn.getChildTableList(pVnode, pScanNode->suid, pUidList);
+ QUERY_CHECK_CODE(code, lino, _error);
} else {
// failed to find the result in the cache, let try to calculate the results
if (pTagIndexCond) {
@@ -1197,9 +1326,7 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
}
code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, tsTagFilterCache, &listAdded);
- if (code != TSDB_CODE_SUCCESS) {
- goto _end;
- }
+ QUERY_CHECK_CODE(code, lino, _end);
// let's add the filter results into meta-cache
numOfTables = taosArrayGetSize(pUidList);
@@ -1207,14 +1334,17 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
if (tsTagFilterCache) {
size_t size = numOfTables * sizeof(uint64_t) + sizeof(int32_t);
char* pPayload = taosMemoryMalloc(size);
+ QUERY_CHECK_NULL(pPayload, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
*(int32_t*)pPayload = numOfTables;
if (numOfTables > 0) {
memcpy(pPayload + sizeof(int32_t), taosArrayGet(pUidList, 0), numOfTables * sizeof(uint64_t));
}
- pStorageAPI->metaFn.putCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest),
- pPayload, size, 1);
+ code = pStorageAPI->metaFn.putCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest),
+ pPayload, size, 1);
+ QUERY_CHECK_CODE(code, lino, _error);
+
digest[0] = 1;
memcpy(digest + 1, context.digest, tListLen(context.digest));
}
@@ -1236,7 +1366,11 @@ _end:
}
}
+_error:
taosArrayDestroy(pUidList);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
return code;
}
@@ -1360,7 +1494,12 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList) {
c.precision = pColNode->node.resType.precision;
c.scale = pColNode->node.resType.scale;
- taosArrayPush(pList, &c);
+ void* tmp = taosArrayPush(pList, &c);
+ if (!tmp) {
+ taosArrayDestroy(pList);
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+ return NULL;
+ }
}
return pList;
@@ -1369,7 +1508,8 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList) {
int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols,
int32_t type, SColMatchInfo* pMatchInfo) {
size_t numOfCols = LIST_LENGTH(pNodeList);
- int32_t code = 0;
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
pMatchInfo->matchType = type;
@@ -1390,7 +1530,8 @@ int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNod
c.dstSlotId = pNode->slotId;
c.isPk = pColNode->isPk;
c.dataType = pColNode->node.resType;
- taosArrayPush(pList, &c);
+ void* tmp = taosArrayPush(pList, &c);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
}
@@ -1424,6 +1565,11 @@ int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNod
}
pMatchInfo->pList = pList;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
return code;
}
@@ -1458,8 +1604,12 @@ static SColumn* createColumn(int32_t blockId, int32_t slotId, int32_t colId, SDa
return pCol;
}
-void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
+int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
pExp->pExpr = taosMemoryCalloc(1, sizeof(tExprNode));
+ QUERY_CHECK_NULL(pExp->pExpr, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
pExp->pExpr->_function.num = 1;
pExp->pExpr->_function.functionId = -1;
@@ -1470,6 +1620,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
SColumnNode* pColNode = (SColumnNode*)pNode;
pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam));
+ QUERY_CHECK_NULL(pExp->base.pParam, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
pExp->base.numOfParams = 1;
SDataType* pType = &pColNode->node.resType;
@@ -1483,6 +1635,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
SValueNode* pValNode = (SValueNode*)pNode;
pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam));
+ QUERY_CHECK_NULL(pExp->base.pParam, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
pExp->base.numOfParams = 1;
SDataType* pType = &pValNode->node.resType;
@@ -1518,7 +1672,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
if (NULL == res) { // todo handle error
} else {
res->node.resType = (SDataType){.bytes = sizeof(int64_t), .type = TSDB_DATA_TYPE_BIGINT};
- nodesListAppend(pFuncNode->pParameterList, (SNode*)res);
+ code = nodesListAppend(pFuncNode->pParameterList, (SNode*)res);
+ QUERY_CHECK_CODE(code, lino, _end);
}
}
#endif
@@ -1567,10 +1722,16 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
} else {
ASSERT(0);
}
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
-void createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode) {
- createExprFromOneNode(pExp, pTargetNode->pExpr, pTargetNode->slotId);
+int32_t createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode) {
+ return createExprFromOneNode(pExp, pTargetNode->pExpr, pTargetNode->slotId);
}
SExprInfo* createExpr(SNodeList* pNodeList, int32_t* numOfExprs) {
@@ -1579,7 +1740,12 @@ SExprInfo* createExpr(SNodeList* pNodeList, int32_t* numOfExprs) {
for (int32_t i = 0; i < (*numOfExprs); ++i) {
SExprInfo* pExp = &pExprs[i];
- createExprFromOneNode(pExp, nodesListGetNode(pNodeList, i), i + UD_TAG_COLUMN_INDEX);
+ int32_t code = createExprFromOneNode(pExp, nodesListGetNode(pNodeList, i), i + UD_TAG_COLUMN_INDEX);
+ if (code != TSDB_CODE_SUCCESS) {
+ taosMemoryFreeClear(pExprs);
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ return NULL;
+ }
}
return pExprs;
@@ -1608,7 +1774,12 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t*
}
SExprInfo* pExp = &pExprs[i];
- createExprFromTargetNode(pExp, pTargetNode);
+ int32_t code = createExprFromTargetNode(pExp, pTargetNode);
+ if (code != TSDB_CODE_SUCCESS) {
+ taosMemoryFreeClear(pExprs);
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ return NULL;
+ }
}
return pExprs;
@@ -1627,8 +1798,8 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu
SHashObj* pSelectFuncs = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK);
for (int32_t i = 0; i < numOfOutput; ++i) {
const char* pName = pCtx[i].pExpr->pExpr->_function.functionName;
- if ((strcmp(pName, "_select_value") == 0) || (strcmp(pName, "_group_key") == 0)
- || (strcmp(pName, "_group_const_value") == 0)) {
+ if ((strcmp(pName, "_select_value") == 0) || (strcmp(pName, "_group_key") == 0) ||
+ (strcmp(pName, "_group_const_value") == 0)) {
pValCtx[num++] = &pCtx[i];
} else if (fmIsSelectFunc(pCtx[i].functionId)) {
void* data = taosHashGet(pSelectFuncs, pName, strlen(pName));
@@ -1636,7 +1807,11 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu
p = NULL;
break;
} else {
- taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num));
+ int32_t tempRes = taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num));
+ if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));
+ return tempRes;
+ }
p = &pCtx[i];
}
}
@@ -1655,6 +1830,8 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu
SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset,
SFunctionStateStore* pStore) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SqlFunctionCtx* pFuncCtx = (SqlFunctionCtx*)taosMemoryCalloc(numOfOutput, sizeof(SqlFunctionCtx));
if (pFuncCtx == NULL) {
return NULL;
@@ -1681,20 +1858,35 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput,
pCtx->isPseudoFunc = fmIsWindowPseudoColumnFunc(pCtx->functionId);
pCtx->isNotNullFunc = fmIsNotNullOutputFunc(pCtx->functionId);
+ bool isUdaf = fmIsUserDefinedFunc(pCtx->functionId);
if (fmIsAggFunc(pCtx->functionId) || fmIsIndefiniteRowsFunc(pCtx->functionId)) {
- bool isUdaf = fmIsUserDefinedFunc(pCtx->functionId);
if (!isUdaf) {
- fmGetFuncExecFuncs(pCtx->functionId, &pCtx->fpSet);
+ code = fmGetFuncExecFuncs(pCtx->functionId, &pCtx->fpSet);
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
char* udfName = pExpr->pExpr->_function.pFunctNode->functionName;
pCtx->udfName = taosStrdup(udfName);
- fmGetUdafExecFuncs(pCtx->functionId, &pCtx->fpSet);
+ code = fmGetUdafExecFuncs(pCtx->functionId, &pCtx->fpSet);
+ QUERY_CHECK_CODE(code, lino, _end);
+ }
+ bool tmp = pCtx->fpSet.getEnv(pExpr->pExpr->_function.pFunctNode, &env);
+ if (!tmp) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ QUERY_CHECK_CODE(code, lino, _end);
}
- pCtx->fpSet.getEnv(pExpr->pExpr->_function.pFunctNode, &env);
} else {
- fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp);
+ code = fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp);
+ if (code != TSDB_CODE_SUCCESS && isUdaf) {
+ code = TSDB_CODE_SUCCESS;
+ }
+ QUERY_CHECK_CODE(code, lino, _end);
+
if (pCtx->sfp.getEnv != NULL) {
- pCtx->sfp.getEnv(pExpr->pExpr->_function.pFunctNode, &env);
+ bool tmp = pCtx->sfp.getEnv(pExpr->pExpr->_function.pFunctNode, &env);
+ if (!tmp) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ QUERY_CHECK_CODE(code, lino, _end);
+ }
}
}
pCtx->resDataInfo.interBufSize = env.calcMemSize;
@@ -1706,7 +1898,9 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput,
pCtx->input.numOfInputCols = pFunct->numOfParams;
pCtx->input.pData = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES);
+ QUERY_CHECK_NULL(pCtx->input.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
pCtx->input.pColumnDataAgg = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES);
+ QUERY_CHECK_NULL(pCtx->input.pColumnDataAgg, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
pCtx->pTsOutput = NULL;
pCtx->resDataInfo.bytes = pFunct->resSchema.bytes;
@@ -1726,14 +1920,27 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput,
pFuncCtx[i - 1].resDataInfo.interBufSize);
}
- setSelectValueColumnInfo(pFuncCtx, numOfOutput);
+ code = setSelectValueColumnInfo(pFuncCtx, numOfOutput);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ for (int32_t i = 0; i < numOfOutput; ++i) {
+ taosMemoryFree(pFuncCtx[i].input.pData);
+ taosMemoryFree(pFuncCtx[i].input.pColumnDataAgg);
+ }
+ taosMemoryFreeClear(pFuncCtx);
+ return NULL;
+ }
return pFuncCtx;
}
// NOTE: sources columns are more than the destination SSDatablock columns.
// doFilter in table scan needs every column even its output is false
-void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn) {
- size_t numOfSrcCols = taosArrayGetSize(pCols);
+int32_t relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ size_t numOfSrcCols = taosArrayGetSize(pCols);
int32_t i = 0, j = 0;
while (i < numOfSrcCols && j < taosArrayGetSize(pColMatchInfo)) {
@@ -1742,7 +1949,11 @@ void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray
if (p->info.colId == pmInfo->colId) {
SColumnInfoData* pDst = taosArrayGet(pBlock->pDataBlock, pmInfo->dstSlotId);
- colDataAssign(pDst, p, pBlock->info.rows, &pBlock->info);
+ code = colDataAssign(pDst, p, pBlock->info.rows, &pBlock->info);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ return code;
+ }
i++;
j++;
} else if (p->info.colId < pmInfo->colId) {
@@ -1751,6 +1962,7 @@ void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray
ASSERT(0);
}
}
+ return code;
}
SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode) {
@@ -2022,20 +2234,22 @@ uint64_t tableListGetTableGroupId(const STableListInfo* pTableList, uint64_t tab
// TODO handle the group offset info, fix it, the rule of group output will be broken by this function
int32_t tableListAddTableInfo(STableListInfo* pTableList, uint64_t uid, uint64_t gid) {
- int32_t code = TSDB_CODE_SUCCESS;
- int32_t lino = 0;
-
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (pTableList->map == NULL) {
pTableList->map = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK);
QUERY_CHECK_NULL(pTableList->map, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
STableKeyInfo keyInfo = {.uid = uid, .groupId = gid};
- void* tmp = taosArrayPush(pTableList->pTableList, &keyInfo);
+ void* tmp = taosArrayPush(pTableList->pTableList, &keyInfo);
QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
int32_t slot = (int32_t)taosArrayGetSize(pTableList->pTableList) - 1;
code = taosHashPut(pTableList->map, &uid, sizeof(uid), &slot, sizeof(slot));
+ if (code == TSDB_CODE_DUP_KEY) {
+ code = TSDB_CODE_SUCCESS;
+ }
QUERY_CHECK_CODE(code, lino, _end);
_end:
@@ -2159,12 +2373,20 @@ static int32_t sortTableGroup(STableListInfo* pTableListInfo) {
uint64_t gid = pInfo->groupId;
int32_t start = 0;
- taosArrayPush(pList, &start);
+ void* tmp = taosArrayPush(pList, &start);
+ if (!tmp) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
for (int32_t i = 1; i < size; ++i) {
pInfo = taosArrayGet(pTableListInfo->pTableList, i);
if (pInfo->groupId != gid) {
- taosArrayPush(pList, &i);
+ tmp = taosArrayPush(pList, &i);
+ if (!tmp) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
gid = pInfo->groupId;
}
}
@@ -2191,19 +2413,24 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle*
return code;
}
if (group == NULL || groupByTbname) {
- if (tsCountAlwaysReturnValue && QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == nodeType(pScanNode) && ((STableScanPhysiNode*)pScanNode)->needCountEmptyTable) {
+ if (tsCountAlwaysReturnValue && QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == nodeType(pScanNode) &&
+ ((STableScanPhysiNode*)pScanNode)->needCountEmptyTable) {
pTableListInfo->remainGroups =
taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
if (pTableListInfo->remainGroups == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
}
-
+
for (int i = 0; i < numOfTables; i++) {
STableKeyInfo* info = taosArrayGet(pTableListInfo->pTableList, i);
info->groupId = groupByTbname ? info->uid : 0;
-
- taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid),
- sizeof(info->uid));
+
+ int32_t tempRes = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId),
+ &(info->uid), sizeof(info->uid));
+ if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));
+ return tempRes;
+ }
}
} else {
for (int32_t i = 0; i < numOfTables; i++) {
@@ -2251,7 +2478,11 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle*
size_t size = taosArrayGetSize(pTableListInfo->pTableList);
for (int32_t i = 0; i < size; ++i) {
STableKeyInfo* p = taosArrayGet(pTableListInfo->pTableList, i);
- taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t));
+ int32_t tempRes = taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t));
+ if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));
+ return tempRes;
+ }
}
return code;
@@ -2457,7 +2688,11 @@ SNodeList* makeColsNodeArrFromSortKeys(SNodeList* pSortKeys) {
SNodeList* ret = NULL;
FOREACH(node, pSortKeys) {
SOrderByExprNode* pSortKey = (SOrderByExprNode*)node;
- nodesListMakeAppend(&ret, pSortKey->pExpr);
+ int32_t code = nodesListMakeAppend(&ret, pSortKey->pExpr);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ return NULL;
+ }
}
return ret;
}
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index 95a24ab27a..35a1db8ade 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -97,7 +97,7 @@ static int32_t doSetSMABlock(SOperatorInfo* pOperator, void* input, size_t numOf
_end:
if (code != TSDB_CODE_SUCCESS) {
- qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
}
return code;
}
diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c
index b38347e56e..c71df486b5 100644
--- a/source/libs/executor/src/executorInt.c
+++ b/source/libs/executor/src/executorInt.c
@@ -521,8 +521,8 @@ int32_t setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t n
if (!pResInfo->initialized) {
if (pCtx[i].functionId != -1) {
- bool ini = pCtx[i].fpSet.init(&pCtx[i], pResInfo);
- if (!ini && fmIsUserDefinedFunc(pCtx[i].functionId)) {
+ int32_t code = pCtx[i].fpSet.init(&pCtx[i], pResInfo);
+ if (code != TSDB_CODE_SUCCESS && fmIsUserDefinedFunc(pCtx[i].functionId)){
pResInfo->initialized = false;
return TSDB_CODE_UDF_FUNC_EXEC_FAILURE;
}
@@ -677,7 +677,7 @@ _end:
}
// todo refactor. SResultRow has direct pointer in miainfo
-int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup,
+void finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup,
SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) {
SFilePage* page = getBufPage(pBuf, resultRowPosition->pageId);
if (page == NULL) {
@@ -694,7 +694,7 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos
doUpdateNumOfRows(pCtx, pRow, pSup->numOfExprs, rowEntryOffset);
if (pRow->numOfRows == 0) {
releaseBufPage(pBuf, page);
- return 0;
+ return ;
}
int32_t size = pBlock->info.capacity;
@@ -713,7 +713,6 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos
releaseBufPage(pBuf, page);
pBlock->info.rows += pRow->numOfRows;
- return 0;
}
void doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf,
diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c
index a04e7db9f2..093f6972c5 100644
--- a/source/libs/executor/src/filloperator.c
+++ b/source/libs/executor/src/filloperator.c
@@ -63,7 +63,8 @@ static void fillResetPrevForNewGroup(SFillInfo* pFillInfo);
static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOperatorInfo* pInfo,
SResultInfo* pResultInfo, int32_t order) {
pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
- SSDataBlock* pResBlock = pInfo->pFinalRes;
+ SSDataBlock* pResBlock = pInfo->pFinalRes;
+ SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
// int32_t order = TSDB_ORDER_ASC;
int32_t scanFlag = MAIN_SCAN;
@@ -85,7 +86,11 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp
}
int32_t numOfResultRows = pResultInfo->capacity - pResBlock->info.rows;
- taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
+ int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
pInfo->curGroupId = pInfo->existNewGroupBlock->info.id.groupId;
pInfo->existNewGroupBlock = NULL;
@@ -96,7 +101,11 @@ static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOpera
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
if (taosFillHasMoreResults(pInfo->pFillInfo)) {
int32_t numOfResultRows = pResultInfo->capacity - pInfo->pFinalRes->info.rows;
- taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows);
+ int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
pInfo->pRes->info.id.groupId = pInfo->curGroupId;
return;
}
@@ -269,7 +278,8 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
}
int32_t numOfResultRows = pOperator->resultInfo.capacity - pResBlock->info.rows;
- taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
+ code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
+ QUERY_CHECK_CODE(code, lino, _end);
// current group has no more result to return
if (pResBlock->info.rows > 0) {
@@ -356,7 +366,8 @@ void destroyFillOperatorInfo(void* param) {
static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t numOfCols, SExprInfo* pNotFillExpr,
int32_t numOfNotFillCols, SNodeListNode* pValNode, STimeWindow win, int32_t capacity,
- const char* id, SInterval* pInterval, int32_t fillType, int32_t order) {
+ const char* id, SInterval* pInterval, int32_t fillType, int32_t order,
+ SExecTaskInfo* pTaskInfo) {
SFillColInfo* pColInfo = createFillColInfo(pExpr, numOfCols, pNotFillExpr, numOfNotFillCols, pValNode);
int64_t startKey = (order == TSDB_ORDER_ASC) ? win.skey : win.ekey;
@@ -364,7 +375,7 @@ static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t
// STimeWindow w = {0};
// getInitialStartTimeWindow(pInterval, startKey, &w, order == TSDB_ORDER_ASC);
pInfo->pFillInfo = taosCreateFillInfo(startKey, numOfCols, numOfNotFillCols, capacity, pInterval, fillType, pColInfo,
- pInfo->primaryTsCol, order, id);
+ pInfo->primaryTsCol, order, id, pTaskInfo);
if (order == TSDB_ORDER_ASC) {
pInfo->win.skey = win.skey;
@@ -414,7 +425,13 @@ static int32_t createPrimaryTsExprIfNeeded(SFillOperatorInfo* pInfo, SFillPhysiN
return TSDB_CODE_OUT_OF_MEMORY;
}
- createExprFromTargetNode(&pExpr[pExprSupp->numOfExprs], (STargetNode*)pPhyFillNode->pWStartTs);
+ int32_t code = createExprFromTargetNode(&pExpr[pExprSupp->numOfExprs], (STargetNode*)pPhyFillNode->pWStartTs);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ taosMemoryFreeClear(pExpr);
+ return code;
+ }
+
pExprSupp->numOfExprs += 1;
pExprSupp->pExprInfo = pExpr;
}
@@ -480,7 +497,7 @@ int32_t createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFi
code = initFillInfo(pInfo, pExprInfo, pInfo->numOfExpr, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs,
(SNodeListNode*)pPhyFillNode->pValues, pPhyFillNode->timeRange, pResultInfo->capacity,
- pTaskInfo->id.str, pInterval, type, order);
+ pTaskInfo->id.str, pInterval, type, order, pTaskInfo);
if (code != TSDB_CODE_SUCCESS) {
goto _error;
}
diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c
index 453444efa5..a5ad48ea4e 100644
--- a/source/libs/executor/src/groupoperator.c
+++ b/source/libs/executor/src/groupoperator.c
@@ -778,6 +778,9 @@ void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDataGroupInf
QUERY_CHECK_NULL(gi.pPageList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
code = taosHashPut(pInfo->pGroupSet, pInfo->keyBuf, len, &gi, sizeof(SDataGroupInfo));
+ if (code == TSDB_CODE_DUP_KEY) {
+ code = TSDB_CODE_SUCCESS;
+ }
QUERY_CHECK_CODE(code, lino, _end);
p = taosHashGet(pInfo->pGroupSet, pInfo->keyBuf, len);
@@ -1403,6 +1406,9 @@ static void doStreamHashPartitionImpl(SStreamPartitionOperatorInfo* pInfo, SSDat
code =
taosHashPut(pInfo->pPartitions, pInfo->partitionSup.keyBuf, keyLen, &newParData, sizeof(SPartitionDataInfo));
+ if (code == TSDB_CODE_DUP_KEY) {
+ code = TSDB_CODE_SUCCESS;
+ }
QUERY_CHECK_CODE(code, lino, _end);
}
}
@@ -1622,7 +1628,9 @@ int32_t createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStreamPart
QUERY_CHECK_NULL(pSubTableExpr, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;
- createExprFromOneNode(pSubTableExpr, pPartNode->pSubtable, 0);
+ code = createExprFromOneNode(pSubTableExpr, pPartNode->pSubtable, 0);
+ QUERY_CHECK_CODE(code, lino, _error);
+
code = initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore);
QUERY_CHECK_CODE(code, lino, _error);
}
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index 5de1fc1439..7bb8ccce0a 100644
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@@ -175,8 +175,13 @@ static int32_t insertTableToScanIgnoreList(STableScanInfo* pTableScanInfo, uint6
}
}
- return taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes,
- sizeof(pTableScanInfo->scanTimes));
+ int32_t tempRes = taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes,
+ sizeof(pTableScanInfo->scanTimes));
+ if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));
+ return tempRes;
+ }
+ return TSDB_CODE_SUCCESS;
}
static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo* pBlockInfo, uint32_t* status) {
@@ -202,8 +207,9 @@ static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo*
SResultRowEntryInfo* pEntry = getResultEntryInfo(pRow, i, pTableScanInfo->base.pdInfo.pExprSup->rowEntryInfoOffset);
- int32_t reqStatus = fmFuncDynDataRequired(functionId, pEntry, pBlockInfo);
- if (reqStatus != FUNC_DATA_REQUIRED_NOT_LOAD) {
+ int32_t reqStatus;
+ code = fmFuncDynDataRequired(functionId, pEntry, pBlockInfo, &reqStatus);
+ if (code != TSDB_CODE_SUCCESS || reqStatus != FUNC_DATA_REQUIRED_NOT_LOAD) {
notLoadBlock = false;
break;
}
@@ -278,7 +284,8 @@ bool applyLimitOffset(SLimitInfo* pLimitInfo, SSDataBlock* pBlock, SExecTaskInfo
int32_t code = blockDataTrimFirstRows(pBlock, pLimitInfo->remainOffset);
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
pLimitInfo->remainOffset = 0;
}
@@ -357,13 +364,11 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca
if (pOperator->exprSupp.pFilterInfo != NULL && (!loadSMA)) {
bool success = doLoadBlockSMA(pTableScanInfo, pBlock, pTaskInfo);
if (success) {
- size_t size = taosArrayGetSize(pBlock->pDataBlock);
- bool keep = false;
- int32_t code =
- doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep);
- if (TSDB_CODE_SUCCESS != code) {
- return code;
- }
+ size_t size = taosArrayGetSize(pBlock->pDataBlock);
+ bool keep = false;
+ code = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep);
+ QUERY_CHECK_CODE(code, lino, _end);
+
if (!keep) {
qDebug("%s data block filter out by block SMA, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64,
GET_TASKID(pTaskInfo), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
@@ -1001,7 +1006,8 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) {
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
return NULL;
}
@@ -1102,7 +1108,8 @@ static SSDataBlock* startNextGroupScan(SOperatorInfo* pOperator) {
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
return NULL;
}
@@ -1125,14 +1132,19 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) {
taosRLockLatch(&pTaskInfo->lock);
code = initNextGroupScan(pInfo, &pList, &num);
- QUERY_CHECK_CODE(code, lino, _end);
taosRUnLockLatch(&pTaskInfo->lock);
+ QUERY_CHECK_CODE(code, lino, _end);
ASSERT(pInfo->base.dataReader == NULL);
- pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock,
+ code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock,
(void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->pIgnoreTables);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
+
if (pInfo->filesetDelimited) {
pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);
}
@@ -1159,7 +1171,8 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) {
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
return result;
}
@@ -1236,7 +1249,8 @@ static SSDataBlock* doTableScan(SOperatorInfo* pOperator) {
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
return NULL;
}
@@ -3486,7 +3500,8 @@ static SSDataBlock* doRawScan(SOperatorInfo* pOperator) {
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
return NULL;
}
@@ -3642,6 +3657,9 @@ void streamScanReloadState(SOperatorInfo* pOperator) {
size_t keySize = 0;
int64_t* pUid = taosHashGetKey(pIte, &keySize);
code = taosHashPut(pUpInfo->pMap, pUid, sizeof(int64_t), pIte, sizeof(TSKEY));
+ if (code == TSDB_CODE_DUP_KEY) {
+ code = TSDB_CODE_SUCCESS;
+ }
QUERY_CHECK_CODE(code, lino, _end);
pIte = taosHashIterate(curMap, pIte);
@@ -3739,7 +3757,9 @@ int32_t createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode*
}
pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;
- createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0);
+ code = createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0);
+ QUERY_CHECK_CODE(code, lino, _error);
+
if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) {
tableListDestroy(pTableListInfo);
goto _error;
@@ -3968,7 +3988,8 @@ static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes,
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
}
@@ -4033,6 +4054,9 @@ static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {
void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));
if (!data) {
code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));
+ if (code == TSDB_CODE_DUP_KEY) {
+ code = TSDB_CODE_SUCCESS;
+ }
QUERY_CHECK_CODE(code, lino, _end);
pSColumnNode->slotId = pCtx->index++;
SColumnInfo cInfo = {.colId = pSColumnNode->colId,
@@ -4271,7 +4295,8 @@ static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) {
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
pOperator->resultInfo.totalRows += pRes->info.rows;
return (pRes->info.rows == 0) ? NULL : pInfo->pRes;
@@ -4706,7 +4731,8 @@ static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTabl
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
}
@@ -4806,7 +4832,8 @@ static SSDataBlock* getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBloc
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
return (pResBlock->info.rows > 0) ? pResBlock : NULL;
}
@@ -4924,7 +4951,8 @@ SSDataBlock* doTableMergeScanParaSubTables(SOperatorInfo* pOperator) {
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
return pBlock;
}
@@ -4944,13 +4972,17 @@ static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {
int bSkip = 1;
if (pInfo->mSkipTables != NULL) {
code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));
+ if (code == TSDB_CODE_DUP_KEY) {
+ code = TSDB_CODE_SUCCESS;
+ }
QUERY_CHECK_CODE(code, lino, _end);
}
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
}
@@ -5247,7 +5279,8 @@ void startGroupTableMergeScan(SOperatorInfo* pOperator) {
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
}
@@ -5383,7 +5416,6 @@ SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) {
}
pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;
- ;
return pBlock;
}
@@ -5805,7 +5837,8 @@ static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScan
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
setOperatorCompleted(pOperator);
}
@@ -5846,7 +5879,8 @@ static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountSca
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
}
@@ -5894,7 +5928,8 @@ static SSDataBlock* buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCount
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
return pRes->info.rows > 0 ? pRes : NULL;
}
@@ -5941,7 +5976,8 @@ static void buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountSca
_end:
if (code != TSDB_CODE_SUCCESS) {
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
}
}
@@ -5979,7 +6015,8 @@ static void buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanO
_end:
if (code != TSDB_CODE_SUCCESS) {
- T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
}
setOperatorCompleted(pOperator);
diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c
index 46b069a59a..cd849b18dd 100644
--- a/source/libs/executor/src/streamtimewindowoperator.c
+++ b/source/libs/executor/src/streamtimewindowoperator.c
@@ -1600,7 +1600,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
if (pBlock->info.type != STREAM_CLEAR) {
void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins);
- if (!tmp) {
+ if (!tmp && taosArrayGetSize(delWins) > 0) {
code = TSDB_CODE_OUT_OF_MEMORY;
QUERY_CHECK_CODE(code, lino, _end);
}
@@ -1610,7 +1610,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
}
removeResults(delWins, pInfo->pUpdatedMap);
void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins);
- if (!tmp) {
+ if (!tmp && taosArrayGetSize(delWins) > 0) {
code = TSDB_CODE_OUT_OF_MEMORY;
QUERY_CHECK_CODE(code, lino, _end);
}
@@ -5333,7 +5333,7 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) {
removeResults(delWins, pInfo->pUpdatedMap);
void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins);
- if (!tmp) {
+ if (!tmp && taosArrayGetSize(delWins) > 0) {
code = TSDB_CODE_OUT_OF_MEMORY;
QUERY_CHECK_CODE(code, lino, _end);
}
diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c
index ff818cbf20..becdeab099 100644
--- a/source/libs/executor/src/sysscanoperator.c
+++ b/source/libs/executor/src/sysscanoperator.c
@@ -14,9 +14,9 @@
*/
#include "executorInt.h"
-#include "geosWrapper.h"
#include "filter.h"
#include "functionMgt.h"
+#include "geosWrapper.h"
#include "querynodes.h"
#include "systable.h"
#include "tname.h"
@@ -129,7 +129,7 @@ const SSTabFltFuncDef filterDict[] = {
#define SYSTAB_FILTER_DICT_SIZE (sizeof(filterDict) / sizeof(filterDict[0]))
static int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTableMeta* pSysDbTableMeta,
- size_t size, const char* dbName);
+ size_t size, const char* dbName, int64_t* pRows);
static char* SYSTABLE_IDX_COLUMN[] = {"table_name", "db_name", "create_time", "columns",
"ttl", "stable_name", "vgroup_id', 'uid", "type"};
@@ -151,7 +151,7 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo,
char* tableType);
static void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock,
- SFilterInfo* pFilterInfo);
+ SFilterInfo* pFilterInfo, SExecTaskInfo* pTaskInfo);
int32_t sysFilte__DbName(void* arg, SNode* pNode, SArray* result) {
SSTabFltArg* pArg = arg;
@@ -160,11 +160,19 @@ int32_t sysFilte__DbName(void* arg, SNode* pNode, SArray* result) {
const char* db = NULL;
pArg->pAPI->metaFn.getBasicInfo(pVnode, &db, NULL, NULL, NULL);
- SName sn = {0};
- char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
- tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+ SName sn = {0};
+ char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+ int32_t code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ return code;
+ }
- tNameGetDbName(&sn, varDataVal(dbname));
+ code = tNameGetDbName(&sn, varDataVal(dbname));
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ return code;
+ }
varDataSetLen(dbname, strlen(varDataVal(dbname)));
SOperatorNode* pOper = (SOperatorNode*)pNode;
@@ -481,11 +489,18 @@ static SSDataBlock* doOptimizeTableNameFilter(SOperatorInfo* pOperator, SSDataBl
STR_TO_VARSTR(typeName, "NORMAL_TABLE");
}
- sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, dataBlock, tableName, schemaRow, typeName);
+ code = sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, dataBlock, tableName, schemaRow, typeName);
+ if (code != TSDB_CODE_SUCCESS) {
+ pAPI->metaReaderFn.clearReader(&smrTable);
+ pInfo->loadInfo.totalRows = 0;
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
pAPI->metaReaderFn.clearReader(&smrTable);
if (numOfRows > 0) {
- relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo);
+ relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo);
numOfRows = 0;
}
@@ -498,19 +513,30 @@ static SSDataBlock* doOptimizeTableNameFilter(SOperatorInfo* pOperator, SSDataBl
}
int32_t doExtractDbName(char* dbname, SSysTableScanInfo* pInfo, SStorageAPI* pAPI) {
- SName sn = {0};
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ SName sn = {0};
const char* db = NULL;
int32_t vgId = 0;
pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL);
- tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+ code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = tNameGetDbName(&sn, varDataVal(dbname));
+ QUERY_CHECK_CODE(code, lino, _end);
- tNameGetDbName(&sn, varDataVal(dbname));
varDataSetLen(dbname, strlen(varDataVal(dbname)));
- return TSDB_CODE_SUCCESS;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
SStorageAPI* pAPI = &pTaskInfo->storageAPI;
SSysTableScanInfo* pInfo = pOperator->info;
@@ -526,8 +552,11 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
blockDataCleanup(pInfo->pRes);
pDataBlock = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_COLS);
- blockDataEnsureCapacity(pDataBlock, pOperator->resultInfo.capacity);
- doExtractDbName(dbname, pInfo, pAPI);
+ code = blockDataEnsureCapacity(pDataBlock, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = doExtractDbName(dbname, pInfo, pAPI);
+ QUERY_CHECK_CODE(code, lino, _end);
// optimize when sql like where table_name='tablename' and xxx.
if (pInfo->req.filterTb[0]) {
@@ -555,7 +584,6 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
return NULL;
}
-
while (((ret = pAPI->metaFn.cursorNext(pInfo->pCur, TSDB_TABLE_MAX)) == 0)) {
char typeName[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
char tableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
@@ -567,7 +595,11 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
void* schema = taosHashGet(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t));
if (schema == NULL) {
SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&pInfo->pCur->mr.me.stbEntry.schemaRow);
- taosHashPut(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES);
+ code = taosHashPut(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES);
+ if (code == TSDB_CODE_DUP_KEY) {
+ code = TSDB_CODE_SUCCESS;
+ }
+ QUERY_CHECK_CODE(code, lino, _end);
}
continue;
} else if (pInfo->pCur->mr.me.type == TSDB_CHILD_TABLE) {
@@ -582,10 +614,11 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
} else {
SMetaReader smrSuperTable = {0};
pAPI->metaReaderFn.initReader(&smrSuperTable, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn);
- int code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid);
+ code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid);
if (code != TSDB_CODE_SUCCESS) {
// terrno has been set by pAPI->metaReaderFn.getTableEntryByName, therefore, return directly
- qError("sysTableScanUserCols get meta by suid:%" PRId64 " error, code:%d, %s", suid, code, GET_TASKID(pTaskInfo));
+ qError("sysTableScanUserCols get meta by suid:%" PRId64 " error, code:%d, %s", suid, code,
+ GET_TASKID(pTaskInfo));
pAPI->metaReaderFn.clearReader(&smrSuperTable);
blockDataDestroy(pDataBlock);
@@ -593,7 +626,12 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
return NULL;
}
SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&smrSuperTable.me.stbEntry.schemaRow);
- taosHashPut(pInfo->pSchema, &suid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES);
+ code = taosHashPut(pInfo->pSchema, &suid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES);
+ if (code == TSDB_CODE_DUP_KEY) {
+ code = TSDB_CODE_SUCCESS;
+ }
+ QUERY_CHECK_CODE(code, lino, _end);
+
schemaRow = schemaWrapper;
pAPI->metaReaderFn.clearReader(&smrSuperTable);
}
@@ -608,7 +646,7 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
}
if ((numOfRows + schemaRow->nCols) > pOperator->resultInfo.capacity) {
- relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo);
+ relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo);
numOfRows = 0;
if (pInfo->pRes->info.rows > 0) {
@@ -616,13 +654,14 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
break;
}
} else {
- sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, pDataBlock, tableName, schemaRow, typeName);
+ code = sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, pDataBlock, tableName, schemaRow, typeName);
+ QUERY_CHECK_CODE(code, lino, _end);
}
}
if (numOfRows > 0) {
pAPI->metaFn.pauseTableMetaCursor(pInfo->pCur);
- relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo);
+ relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo);
numOfRows = 0;
}
@@ -635,10 +674,19 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
pInfo->loadInfo.totalRows += pInfo->pRes->info.rows;
qDebug("get cols success, rows:%" PRIu64 " %s", pInfo->loadInfo.totalRows, GET_TASKID(pTaskInfo));
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes;
}
static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
SStorageAPI* pAPI = &pTaskInfo->storageAPI;
@@ -651,7 +699,8 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
int32_t numOfRows = 0;
SSDataBlock* dataBlock = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TAGS);
- blockDataEnsureCapacity(dataBlock, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(dataBlock, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _end);
const char* db = NULL;
int32_t vgId = 0;
@@ -659,9 +708,12 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
SName sn = {0};
char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
- tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+ code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = tNameGetDbName(&sn, varDataVal(dbname));
+ QUERY_CHECK_CODE(code, lino, _end);
- tNameGetDbName(&sn, varDataVal(dbname));
varDataSetLen(dbname, strlen(varDataVal(dbname)));
char condTableName[TSDB_TABLE_NAME_LEN] = {0};
@@ -699,12 +751,15 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
return NULL;
}
- sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &smrChildTable, dbname, tableName, &numOfRows, dataBlock);
+ code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &smrChildTable, dbname, tableName, &numOfRows,
+ dataBlock);
+ QUERY_CHECK_CODE(code, lino, _end);
+
pAPI->metaReaderFn.clearReader(&smrSuperTable);
pAPI->metaReaderFn.clearReader(&smrChildTable);
if (numOfRows > 0) {
- relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo);
+ relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo);
numOfRows = 0;
}
blockDataDestroy(dataBlock);
@@ -731,7 +786,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
SMetaReader smrSuperTable = {0};
pAPI->metaReaderFn.initReader(&smrSuperTable, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn);
uint64_t suid = pInfo->pCur->mr.me.ctbEntry.suid;
- int32_t code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid);
+ code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid);
if (code != TSDB_CODE_SUCCESS) {
qError("failed to get super table meta, uid:0x%" PRIx64 ", code:%s, %s", suid, tstrerror(terrno),
GET_TASKID(pTaskInfo));
@@ -742,7 +797,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
}
if ((smrSuperTable.me.stbEntry.schemaTag.nCols + numOfRows) > pOperator->resultInfo.capacity) {
- relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo);
+ relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo);
numOfRows = 0;
if (pInfo->pRes->info.rows > 0) {
@@ -751,15 +806,16 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
break;
}
} else {
- sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &pInfo->pCur->mr, dbname, tableName, &numOfRows,
- dataBlock);
+ code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &pInfo->pCur->mr, dbname, tableName, &numOfRows,
+ dataBlock);
+ QUERY_CHECK_CODE(code, lino, _end);
}
pAPI->metaReaderFn.clearReader(&smrSuperTable);
}
if (numOfRows > 0) {
pAPI->metaFn.pauseTableMetaCursor(pInfo->pCur);
- relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo);
+ relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo);
numOfRows = 0;
}
@@ -771,17 +827,39 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
}
pInfo->loadInfo.totalRows += pInfo->pRes->info.rows;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pAPI->metaFn.closeTableMetaCursor(pInfo->pCur);
+ pInfo->pCur = NULL;
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes;
}
void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock,
- SFilterInfo* pFilterInfo) {
+ SFilterInfo* pFilterInfo, SExecTaskInfo* pTaskInfo) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
dataBlock->info.rows = numOfRows;
pInfo->pRes->info.rows = numOfRows;
- relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, dataBlock->pDataBlock, false);
- doFilter(pInfo->pRes, pFilterInfo, NULL);
+ code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, dataBlock->pDataBlock, false);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = doFilter(pInfo->pRes, pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
+
blockDataCleanup(dataBlock);
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
}
int32_t convertTagDataToStr(char* str, int type, void* buf, int32_t bufSize, int32_t* len) {
@@ -894,7 +972,9 @@ static int32_t sysTableGetGeomText(char* iGeom, int32_t nGeom, char** output, in
static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, SMetaReader* smrSuperTable,
SMetaReader* smrChildTable, const char* dbname, const char* tableName,
int32_t* pNumOfRows, const SSDataBlock* dataBlock) {
- char stableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ char stableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(stableName, (*smrSuperTable).me.name);
int32_t numOfRows = *pNumOfRows;
@@ -905,21 +985,25 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo,
// table name
pColInfoData = taosArrayGet(dataBlock->pDataBlock, 0);
- colDataSetVal(pColInfoData, numOfRows, tableName, false);
+ code = colDataSetVal(pColInfoData, numOfRows, tableName, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// database name
pColInfoData = taosArrayGet(dataBlock->pDataBlock, 1);
- colDataSetVal(pColInfoData, numOfRows, dbname, false);
+ code = colDataSetVal(pColInfoData, numOfRows, dbname, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// super table name
pColInfoData = taosArrayGet(dataBlock->pDataBlock, 2);
- colDataSetVal(pColInfoData, numOfRows, stableName, false);
+ code = colDataSetVal(pColInfoData, numOfRows, stableName, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// tag name
char tagName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(tagName, (*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].name);
pColInfoData = taosArrayGet(dataBlock->pDataBlock, 3);
- colDataSetVal(pColInfoData, numOfRows, tagName, false);
+ code = colDataSetVal(pColInfoData, numOfRows, tagName, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// tag type
int8_t tagType = (*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].type;
@@ -935,7 +1019,8 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo,
(int32_t)((*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].bytes - VARSTR_HEADER_SIZE));
}
varDataSetLen(tagTypeStr, tagTypeLen);
- colDataSetVal(pColInfoData, numOfRows, (char*)tagTypeStr, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)tagTypeStr, false);
+ QUERY_CHECK_CODE(code, lino, _end);
STagVal tagVal = {0};
tagVal.cid = (*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].colId;
@@ -948,7 +1033,8 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo,
bool exist = tTagGet((STag*)smrChildTable->me.ctbEntry.pTags, &tagVal);
if (exist) {
if (tagType == TSDB_DATA_TYPE_GEOMETRY) {
- sysTableGetGeomText(tagVal.pData, tagVal.nData, &tagData, &tagLen);
+ code = sysTableGetGeomText(tagVal.pData, tagVal.nData, &tagData, &tagLen);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (tagType == TSDB_DATA_TYPE_VARBINARY) {
if (taosAscii2Hex(tagVal.pData, tagVal.nData, (void**)&tagData, &tagLen) < 0) {
qError("varbinary for systable failed since %s", tstrerror(TSDB_CODE_OUT_OF_MEMORY));
@@ -969,6 +1055,7 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo,
char* tagJson = NULL;
parseTagDatatoJson(tagData, &tagJson);
tagVarChar = taosMemoryMalloc(strlen(tagJson) + VARSTR_HEADER_SIZE);
+ QUERY_CHECK_NULL(tagVarChar, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
memcpy(varDataVal(tagVarChar), tagJson, strlen(tagJson));
varDataSetLen(tagVarChar, strlen(tagJson));
taosMemoryFree(tagJson);
@@ -976,6 +1063,7 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo,
int32_t bufSize = IS_VAR_DATA_TYPE(tagType) ? (tagLen + VARSTR_HEADER_SIZE)
: (3 + DBL_MANT_DIG - DBL_MIN_EXP + VARSTR_HEADER_SIZE);
tagVarChar = taosMemoryCalloc(1, bufSize + 1);
+ QUERY_CHECK_NULL(tagVarChar, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
int32_t len = -1;
if (tagLen > 0)
convertTagDataToStr(varDataVal(tagVarChar), tagType, tagData, tagLen, &len);
@@ -985,8 +1073,10 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo,
}
}
pColInfoData = taosArrayGet(dataBlock->pDataBlock, 5);
- colDataSetVal(pColInfoData, numOfRows, tagVarChar,
- (tagData == NULL) || (tagType == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(tagData)));
+ code = colDataSetVal(pColInfoData, numOfRows, tagVarChar,
+ (tagData == NULL) || (tagType == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(tagData)));
+ QUERY_CHECK_CODE(code, lino, _end);
+
if (tagType == TSDB_DATA_TYPE_GEOMETRY || tagType == TSDB_DATA_TYPE_VARBINARY) taosMemoryFreeClear(tagData);
taosMemoryFree(tagVarChar);
++numOfRows;
@@ -994,12 +1084,18 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo,
*pNumOfRows = numOfRows;
- return TSDB_CODE_SUCCESS;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, const char* dbname, int32_t* pNumOfRows,
const SSDataBlock* dataBlock, char* tName, SSchemaWrapper* schemaRow,
char* tableType) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (schemaRow == NULL) {
qError("sysTableUserColsFillOneTableCols schemaRow is NULL");
return TSDB_CODE_SUCCESS;
@@ -1012,20 +1108,24 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo,
// table name
pColInfoData = taosArrayGet(dataBlock->pDataBlock, 0);
- colDataSetVal(pColInfoData, numOfRows, tName, false);
+ code = colDataSetVal(pColInfoData, numOfRows, tName, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// database name
pColInfoData = taosArrayGet(dataBlock->pDataBlock, 1);
- colDataSetVal(pColInfoData, numOfRows, dbname, false);
+ code = colDataSetVal(pColInfoData, numOfRows, dbname, false);
+ QUERY_CHECK_CODE(code, lino, _end);
pColInfoData = taosArrayGet(dataBlock->pDataBlock, 2);
- colDataSetVal(pColInfoData, numOfRows, tableType, false);
+ code = colDataSetVal(pColInfoData, numOfRows, tableType, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// col name
char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(colName, schemaRow->pSchema[i].name);
pColInfoData = taosArrayGet(dataBlock->pDataBlock, 3);
- colDataSetVal(pColInfoData, numOfRows, colName, false);
+ code = colDataSetVal(pColInfoData, numOfRows, colName, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// col type
int8_t colType = schemaRow->pSchema[i].type;
@@ -1040,10 +1140,12 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo,
(int32_t)((schemaRow->pSchema[i].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));
}
varDataSetLen(colTypeStr, colTypeLen);
- colDataSetVal(pColInfoData, numOfRows, (char*)colTypeStr, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)colTypeStr, false);
+ QUERY_CHECK_CODE(code, lino, _end);
pColInfoData = taosArrayGet(dataBlock->pDataBlock, 5);
- colDataSetVal(pColInfoData, numOfRows, (const char*)&schemaRow->pSchema[i].bytes, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (const char*)&schemaRow->pSchema[i].bytes, false);
+ QUERY_CHECK_CODE(code, lino, _end);
for (int32_t j = 6; j <= 8; ++j) {
pColInfoData = taosArrayGet(dataBlock->pDataBlock, j);
@@ -1054,7 +1156,11 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo,
*pNumOfRows = numOfRows;
- return TSDB_CODE_SUCCESS;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static SSDataBlock* buildInfoSchemaTableMetaBlock(char* tableName) {
@@ -1074,14 +1180,23 @@ static SSDataBlock* buildInfoSchemaTableMetaBlock(char* tableName) {
for (int32_t i = 0; i < pMeta[index].colNum; ++i) {
SColumnInfoData colInfoData =
createColumnInfoData(pMeta[index].schema[i].type, pMeta[index].schema[i].bytes, i + 1);
- blockDataAppendColInfo(pBlock, &colInfoData);
+ int32_t code = blockDataAppendColInfo(pBlock, &colInfoData);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ blockDataDestroy(pBlock);
+ pBlock = NULL;
+ terrno = code;
+ break;
+ }
}
return pBlock;
}
int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTableMeta* pSysDbTableMeta, size_t size,
- const char* dbName) {
+ const char* dbName, int64_t* pRows) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
char n[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
int32_t numOfRows = p->info.rows;
@@ -1091,19 +1206,21 @@ int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTabl
continue;
}
- if(strcmp(pm->name, TSDB_INS_TABLE_USERS_FULL) == 0){
+ if (strcmp(pm->name, TSDB_INS_TABLE_USERS_FULL) == 0) {
continue;
}
SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0);
STR_TO_VARSTR(n, pm->name);
- colDataSetVal(pColInfoData, numOfRows, n, false);
+ code = colDataSetVal(pColInfoData, numOfRows, n, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// database name
STR_TO_VARSTR(n, dbName);
pColInfoData = taosArrayGet(p->pDataBlock, 1);
- colDataSetVal(pColInfoData, numOfRows, n, false);
+ code = colDataSetVal(pColInfoData, numOfRows, n, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// create time
pColInfoData = taosArrayGet(p->pDataBlock, 2);
@@ -1111,7 +1228,8 @@ int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTabl
// number of columns
pColInfoData = taosArrayGet(p->pDataBlock, 3);
- colDataSetVal(pColInfoData, numOfRows, (char*)&pm->colNum, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&pm->colNum, false);
+ QUERY_CHECK_CODE(code, lino, _end);
for (int32_t j = 4; j <= 8; ++j) {
pColInfoData = taosArrayGet(p->pDataBlock, j);
@@ -1121,41 +1239,61 @@ int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTabl
STR_TO_VARSTR(n, "SYSTEM_TABLE");
pColInfoData = taosArrayGet(p->pDataBlock, 9);
- colDataSetVal(pColInfoData, numOfRows, n, false);
+ code = colDataSetVal(pColInfoData, numOfRows, n, false);
+ QUERY_CHECK_CODE(code, lino, _end);
numOfRows += 1;
}
- return numOfRows;
+ *pRows = numOfRows;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
int32_t buildSysDbTableInfo(const SSysTableScanInfo* pInfo, int32_t capacity) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TABLES);
- blockDataEnsureCapacity(p, capacity);
+ QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+ code = blockDataEnsureCapacity(p, capacity);
+ QUERY_CHECK_CODE(code, lino, _end);
size_t size = 0;
const SSysTableMeta* pSysDbTableMeta = NULL;
getInfosDbMeta(&pSysDbTableMeta, &size);
- p->info.rows = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_INFORMATION_SCHEMA_DB);
+ code = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_INFORMATION_SCHEMA_DB, &p->info.rows);
+ QUERY_CHECK_CODE(code, lino, _end);
getPerfDbMeta(&pSysDbTableMeta, &size);
- p->info.rows = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_PERFORMANCE_SCHEMA_DB);
+ code = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_PERFORMANCE_SCHEMA_DB, &p->info.rows);
+ QUERY_CHECK_CODE(code, lino, _end);
pInfo->pRes->info.rows = p->info.rows;
- relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
+ code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
+ QUERY_CHECK_CODE(code, lino, _end);
+
blockDataDestroy(p);
- return pInfo->pRes->info.rows;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
- SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
- SStorageAPI* pAPI = &pTaskInfo->storageAPI;
-
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+ SStorageAPI* pAPI = &pTaskInfo->storageAPI;
SSysTableScanInfo* pInfo = pOperator->info;
-
- SSysTableIndex* pIdx = pInfo->pIdx;
+ SSysTableIndex* pIdx = pInfo->pIdx;
blockDataCleanup(pInfo->pRes);
int32_t numOfRows = 0;
@@ -1167,13 +1305,17 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
SName sn = {0};
char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
- tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+ code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = tNameGetDbName(&sn, varDataVal(dbname));
+ QUERY_CHECK_CODE(code, lino, _end);
- tNameGetDbName(&sn, varDataVal(dbname));
varDataSetLen(dbname, strlen(varDataVal(dbname)));
SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TABLES);
- blockDataEnsureCapacity(p, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(p, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _end);
char n[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
int32_t i = pIdx->lastIdx;
@@ -1191,28 +1333,32 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
// table name
SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0);
- colDataSetVal(pColInfoData, numOfRows, n, false);
+ code = colDataSetVal(pColInfoData, numOfRows, n, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// database name
pColInfoData = taosArrayGet(p->pDataBlock, 1);
- colDataSetVal(pColInfoData, numOfRows, dbname, false);
+ code = colDataSetVal(pColInfoData, numOfRows, dbname, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// vgId
pColInfoData = taosArrayGet(p->pDataBlock, 6);
- colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false);
+ QUERY_CHECK_CODE(code, lino, _end);
int32_t tableType = mr.me.type;
if (tableType == TSDB_CHILD_TABLE) {
// create time
int64_t ts = mr.me.ctbEntry.btime;
pColInfoData = taosArrayGet(p->pDataBlock, 2);
- colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false);
+ QUERY_CHECK_CODE(code, lino, _end);
SMetaReader mr1 = {0};
pAPI->metaReaderFn.initReader(&mr1, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn);
int64_t suid = mr.me.ctbEntry.suid;
- int32_t code = pAPI->metaReaderFn.getTableEntryByUid(&mr1, suid);
+ code = pAPI->metaReaderFn.getTableEntryByUid(&mr1, suid);
if (code != TSDB_CODE_SUCCESS) {
qError("failed to get super table meta, cname:%s, suid:0x%" PRIx64 ", code:%s, %s", pInfo->pCur->mr.me.name,
suid, tstrerror(terrno), GET_TASKID(pTaskInfo));
@@ -1221,12 +1367,14 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
T_LONG_JMP(pTaskInfo->env, terrno);
}
pColInfoData = taosArrayGet(p->pDataBlock, 3);
- colDataSetVal(pColInfoData, numOfRows, (char*)&mr1.me.stbEntry.schemaRow.nCols, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr1.me.stbEntry.schemaRow.nCols, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// super table name
STR_TO_VARSTR(n, mr1.me.name);
pColInfoData = taosArrayGet(p->pDataBlock, 4);
- colDataSetVal(pColInfoData, numOfRows, n, false);
+ code = colDataSetVal(pColInfoData, numOfRows, n, false);
+ QUERY_CHECK_CODE(code, lino, _end);
pAPI->metaReaderFn.clearReader(&mr1);
// table comment
@@ -1234,33 +1382,39 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
if (mr.me.ctbEntry.commentLen > 0) {
char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(comment, mr.me.ctbEntry.comment);
- colDataSetVal(pColInfoData, numOfRows, comment, false);
+ code = colDataSetVal(pColInfoData, numOfRows, comment, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (mr.me.ctbEntry.commentLen == 0) {
char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(comment, "");
- colDataSetVal(pColInfoData, numOfRows, comment, false);
+ code = colDataSetVal(pColInfoData, numOfRows, comment, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
colDataSetNULL(pColInfoData, numOfRows);
}
// uid
pColInfoData = taosArrayGet(p->pDataBlock, 5);
- colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// ttl
pColInfoData = taosArrayGet(p->pDataBlock, 7);
- colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ctbEntry.ttlDays, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ctbEntry.ttlDays, false);
+ QUERY_CHECK_CODE(code, lino, _end);
STR_TO_VARSTR(n, "CHILD_TABLE");
} else if (tableType == TSDB_NORMAL_TABLE) {
// create time
pColInfoData = taosArrayGet(p->pDataBlock, 2);
- colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// number of columns
pColInfoData = taosArrayGet(p->pDataBlock, 3);
- colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// super table name
pColInfoData = taosArrayGet(p->pDataBlock, 4);
@@ -1271,22 +1425,26 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
if (mr.me.ntbEntry.commentLen > 0) {
char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(comment, mr.me.ntbEntry.comment);
- colDataSetVal(pColInfoData, numOfRows, comment, false);
+ code = colDataSetVal(pColInfoData, numOfRows, comment, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (mr.me.ntbEntry.commentLen == 0) {
char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(comment, "");
- colDataSetVal(pColInfoData, numOfRows, comment, false);
+ code = colDataSetVal(pColInfoData, numOfRows, comment, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
colDataSetNULL(pColInfoData, numOfRows);
}
// uid
pColInfoData = taosArrayGet(p->pDataBlock, 5);
- colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// ttl
pColInfoData = taosArrayGet(p->pDataBlock, 7);
- colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ntbEntry.ttlDays, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ntbEntry.ttlDays, false);
+ QUERY_CHECK_CODE(code, lino, _end);
STR_TO_VARSTR(n, "NORMAL_TABLE");
// impl later
@@ -1295,14 +1453,18 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
pAPI->metaReaderFn.clearReader(&mr);
pColInfoData = taosArrayGet(p->pDataBlock, 9);
- colDataSetVal(pColInfoData, numOfRows, n, false);
+ code = colDataSetVal(pColInfoData, numOfRows, n, false);
+ QUERY_CHECK_CODE(code, lino, _end);
if (++numOfRows >= pOperator->resultInfo.capacity) {
p->info.rows = numOfRows;
pInfo->pRes->info.rows = numOfRows;
- relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
- doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
blockDataCleanup(p);
numOfRows = 0;
@@ -1317,8 +1479,11 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
p->info.rows = numOfRows;
pInfo->pRes->info.rows = numOfRows;
- relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
- doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
blockDataCleanup(p);
numOfRows = 0;
@@ -1333,10 +1498,19 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
blockDataDestroy(p);
pInfo->loadInfo.totalRows += pInfo->pRes->info.rows;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes;
}
static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
SStorageAPI* pAPI = &pTaskInfo->storageAPI;
int8_t firstMetaCursor = 0;
@@ -1359,13 +1533,19 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
SName sn = {0};
char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
- tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+ code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = tNameGetDbName(&sn, varDataVal(dbname));
+ QUERY_CHECK_CODE(code, lino, _end);
- tNameGetDbName(&sn, varDataVal(dbname));
varDataSetLen(dbname, strlen(varDataVal(dbname)));
SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TABLES);
- blockDataEnsureCapacity(p, pOperator->resultInfo.capacity);
+ QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+ code = blockDataEnsureCapacity(p, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _end);
char n[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
@@ -1375,28 +1555,32 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
// table name
SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0);
- colDataSetVal(pColInfoData, numOfRows, n, false);
+ code = colDataSetVal(pColInfoData, numOfRows, n, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// database name
pColInfoData = taosArrayGet(p->pDataBlock, 1);
- colDataSetVal(pColInfoData, numOfRows, dbname, false);
+ code = colDataSetVal(pColInfoData, numOfRows, dbname, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// vgId
pColInfoData = taosArrayGet(p->pDataBlock, 6);
- colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false);
+ QUERY_CHECK_CODE(code, lino, _end);
int32_t tableType = pInfo->pCur->mr.me.type;
if (tableType == TSDB_CHILD_TABLE) {
// create time
int64_t ts = pInfo->pCur->mr.me.ctbEntry.btime;
pColInfoData = taosArrayGet(p->pDataBlock, 2);
- colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false);
+ QUERY_CHECK_CODE(code, lino, _end);
SMetaReader mr = {0};
pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn);
uint64_t suid = pInfo->pCur->mr.me.ctbEntry.suid;
- int32_t code = pAPI->metaReaderFn.getTableEntryByUid(&mr, suid);
+ code = pAPI->metaReaderFn.getTableEntryByUid(&mr, suid);
if (code != TSDB_CODE_SUCCESS) {
qError("failed to get super table meta, cname:%s, suid:0x%" PRIx64 ", code:%s, %s", pInfo->pCur->mr.me.name,
suid, tstrerror(terrno), GET_TASKID(pTaskInfo));
@@ -1413,12 +1597,14 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
// number of columns
pColInfoData = taosArrayGet(p->pDataBlock, 3);
- colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.stbEntry.schemaRow.nCols, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.stbEntry.schemaRow.nCols, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// super table name
STR_TO_VARSTR(n, mr.me.name);
pColInfoData = taosArrayGet(p->pDataBlock, 4);
- colDataSetVal(pColInfoData, numOfRows, n, false);
+ code = colDataSetVal(pColInfoData, numOfRows, n, false);
+ QUERY_CHECK_CODE(code, lino, _end);
pAPI->metaReaderFn.clearReader(&mr);
// table comment
@@ -1426,32 +1612,38 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
if (pInfo->pCur->mr.me.ctbEntry.commentLen > 0) {
char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(comment, pInfo->pCur->mr.me.ctbEntry.comment);
- colDataSetVal(pColInfoData, numOfRows, comment, false);
+ code = colDataSetVal(pColInfoData, numOfRows, comment, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (pInfo->pCur->mr.me.ctbEntry.commentLen == 0) {
char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(comment, "");
- colDataSetVal(pColInfoData, numOfRows, comment, false);
+ code = colDataSetVal(pColInfoData, numOfRows, comment, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
colDataSetNULL(pColInfoData, numOfRows);
}
// uid
pColInfoData = taosArrayGet(p->pDataBlock, 5);
- colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// ttl
pColInfoData = taosArrayGet(p->pDataBlock, 7);
- colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ctbEntry.ttlDays, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ctbEntry.ttlDays, false);
+ QUERY_CHECK_CODE(code, lino, _end);
STR_TO_VARSTR(n, "CHILD_TABLE");
} else if (tableType == TSDB_NORMAL_TABLE) {
// create time
pColInfoData = taosArrayGet(p->pDataBlock, 2);
- colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// number of columns
pColInfoData = taosArrayGet(p->pDataBlock, 3);
- colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// super table name
pColInfoData = taosArrayGet(p->pDataBlock, 4);
@@ -1462,35 +1654,43 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
if (pInfo->pCur->mr.me.ntbEntry.commentLen > 0) {
char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(comment, pInfo->pCur->mr.me.ntbEntry.comment);
- colDataSetVal(pColInfoData, numOfRows, comment, false);
+ code = colDataSetVal(pColInfoData, numOfRows, comment, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (pInfo->pCur->mr.me.ntbEntry.commentLen == 0) {
char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(comment, "");
- colDataSetVal(pColInfoData, numOfRows, comment, false);
+ code = colDataSetVal(pColInfoData, numOfRows, comment, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
colDataSetNULL(pColInfoData, numOfRows);
}
// uid
pColInfoData = taosArrayGet(p->pDataBlock, 5);
- colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false);
+ QUERY_CHECK_CODE(code, lino, _end);
// ttl
pColInfoData = taosArrayGet(p->pDataBlock, 7);
- colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.ttlDays, false);
+ code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.ttlDays, false);
+ QUERY_CHECK_CODE(code, lino, _end);
STR_TO_VARSTR(n, "NORMAL_TABLE");
}
pColInfoData = taosArrayGet(p->pDataBlock, 9);
- colDataSetVal(pColInfoData, numOfRows, n, false);
+ code = colDataSetVal(pColInfoData, numOfRows, n, false);
+ QUERY_CHECK_CODE(code, lino, _end);
if (++numOfRows >= pOperator->resultInfo.capacity) {
p->info.rows = numOfRows;
pInfo->pRes->info.rows = numOfRows;
- relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
- doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
blockDataCleanup(p);
numOfRows = 0;
@@ -1507,8 +1707,11 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
p->info.rows = numOfRows;
pInfo->pRes->info.rows = numOfRows;
- relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
- doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
blockDataCleanup(p);
numOfRows = 0;
@@ -1524,10 +1727,19 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
}
pInfo->loadInfo.totalRows += pInfo->pRes->info.rows;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes;
}
static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
SSysTableScanInfo* pInfo = pOperator->info;
@@ -1538,8 +1750,11 @@ static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) {
// the retrieve is executed on the mnode, so return tables that belongs to the information schema database.
if (pInfo->readHandle.mnd != NULL) {
- buildSysDbTableInfo(pInfo, pOperator->resultInfo.capacity);
- doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = buildSysDbTableInfo(pInfo, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
pInfo->loadInfo.totalRows += pInfo->pRes->info.rows;
setOperatorCompleted(pOperator);
@@ -1573,6 +1788,13 @@ static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) {
return sysTableBuildUserTables(pOperator);
}
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return NULL;
}
@@ -1657,7 +1879,6 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) {
char dbName[TSDB_DB_NAME_LEN] = {0};
while (1) {
-
if (isTaskKilled(pOperator->pTaskInfo)) {
setOperatorCompleted(pOperator);
return NULL;
@@ -1675,7 +1896,7 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) {
} else if (strncasecmp(name, TSDB_INS_TABLE_COLS, TSDB_TABLE_FNAME_LEN) == 0) {
getDBNameFromCondition(pInfo->pCondition, dbName);
if (dbName[0]) sprintf(pInfo->req.db, "%d.%s", pInfo->accountId, dbName);
- sysTableIsCondOnOneTable(pInfo->pCondition, pInfo->req.filterTb);
+ (void)sysTableIsCondOnOneTable(pInfo->pCondition, pInfo->req.filterTb);
}
SSDataBlock* pBlock = NULL;
@@ -1686,7 +1907,7 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) {
} else if (strncasecmp(name, TSDB_INS_TABLE_COLS, TSDB_TABLE_FNAME_LEN) == 0 && pInfo->readHandle.mnd == NULL) {
pBlock = sysTableScanUserCols(pOperator);
} else if (strncasecmp(name, TSDB_INS_TABLE_STABLES, TSDB_TABLE_FNAME_LEN) == 0 && pInfo->showRewrite &&
- IS_SYS_DBNAME(dbName)) {
+ IS_SYS_DBNAME(dbName)) {
pBlock = sysTableScanUserSTables(pOperator);
} else { // load the meta from mnode of the given epset
pBlock = sysTableScanFromMNode(pOperator, pInfo, name, pTaskInfo);
@@ -1711,6 +1932,9 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) {
static void sysTableScanFillTbName(SOperatorInfo* pOperator, const SSysTableScanInfo* pInfo, const char* name,
SSDataBlock* pBlock) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
if (pBlock == NULL) {
return;
}
@@ -1720,14 +1944,25 @@ static void sysTableScanFillTbName(SOperatorInfo* pOperator, const SSysTableScan
char varTbName[TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE] = {0};
STR_TO_VARSTR(varTbName, name);
- colDataSetNItems(pColumnInfoData, 0, varTbName, pBlock->info.rows, true);
+ code = colDataSetNItems(pColumnInfoData, 0, varTbName, pBlock->info.rows, true);
+ QUERY_CHECK_CODE(code, lino, _end);
}
- doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
}
static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableScanInfo* pInfo, const char* name,
SExecTaskInfo* pTaskInfo) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (pOperator->status == OP_EXEC_DONE) {
return NULL;
}
@@ -1739,7 +1974,7 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca
int32_t contLen = tSerializeSRetrieveTableReq(NULL, 0, &pInfo->req);
char* buf1 = taosMemoryCalloc(1, contLen);
- tSerializeSRetrieveTableReq(buf1, contLen, &pInfo->req);
+ (void)tSerializeSRetrieveTableReq(buf1, contLen, &pInfo->req);
// send the fetch remote task result reques
SMsgSendInfo* pMsgSendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
@@ -1760,9 +1995,14 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca
pMsgSendInfo->requestId = pTaskInfo->id.queryId;
int64_t transporterId = 0;
- int32_t code =
- asyncSendMsgToServer(pInfo->readHandle.pMsgCb->clientRpc, &pInfo->epSet, &transporterId, pMsgSendInfo);
- tsem_wait(&pInfo->ready);
+ code = asyncSendMsgToServer(pInfo->readHandle.pMsgCb->clientRpc, &pInfo->epSet, &transporterId, pMsgSendInfo);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
+
+ (void)tsem_wait(&pInfo->ready);
if (pTaskInfo->code) {
qError("%s load meta data from mnode failed, totalRows:%" PRIu64 ", code:%s", GET_TASKID(pTaskInfo),
@@ -1785,11 +2025,23 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca
}
char* pStart = pRsp->data;
- extractDataBlockFromFetchRsp(pInfo->pRes, pRsp->data, pInfo->matchInfo.pList, &pStart);
+ code = extractDataBlockFromFetchRsp(pInfo->pRes, pRsp->data, pInfo->matchInfo.pList, &pStart);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ taosMemoryFreeClear(pRsp);
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
updateLoadRemoteInfo(&pInfo->loadInfo, pRsp->numOfRows, pRsp->compLen, startTs, pOperator);
// todo log the filter info
- doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ taosMemoryFreeClear(pRsp);
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
taosMemoryFree(pRsp);
if (pInfo->pRes->info.rows > 0) {
return pInfo->pRes;
@@ -1804,6 +2056,7 @@ int32_t createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNo
QRY_OPTR_CHECK(pOptrInfo);
int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SSysTableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SSysTableScanInfo));
SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
if (pInfo == NULL || pOperator == NULL) {
@@ -1831,13 +2084,12 @@ int32_t createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNo
pInfo->pRes = createDataBlockFromDescNode(pDescNode);
pInfo->pCondition = pScanNode->node.pConditions;
code = filterInitFromNode(pScanNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
initLimitInfo(pScanPhyNode->scan.node.pLimit, pScanPhyNode->scan.node.pSlimit, &pInfo->limitInfo);
initResultSizeInfo(&pOperator->resultInfo, 4096);
- blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _error);
tNameAssign(&pInfo->name, &pScanNode->tableName);
const char* name = tNameGetTableName(&pInfo->name);
@@ -1846,7 +2098,10 @@ int32_t createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNo
strncasecmp(name, TSDB_INS_TABLE_TAGS, TSDB_TABLE_FNAME_LEN) == 0) {
pInfo->readHandle = *(SReadHandle*)readHandle;
} else {
- tsem_init(&pInfo->ready, 0, 0);
+ if (tsem_init(&pInfo->ready, 0, 0) != TSDB_CODE_SUCCESS) {
+ code = TSDB_CODE_FAILED;
+ goto _error;
+ }
pInfo->epSet = pScanPhyNode->mgmtEpSet;
pInfo->readHandle = *(SReadHandle*)readHandle;
}
@@ -1863,6 +2118,9 @@ _error:
if (pInfo != NULL) {
destroySysScanOperator(pInfo);
}
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
taosMemoryFreeClear(pOperator);
pTaskInfo->code = code;
return code;
@@ -1890,7 +2148,7 @@ void extractTbnameSlotId(SSysTableScanInfo* pInfo, const SScanPhysiNode* pScanNo
void destroySysScanOperator(void* param) {
SSysTableScanInfo* pInfo = (SSysTableScanInfo*)param;
- tsem_destroy(&pInfo->ready);
+ (void)tsem_destroy(&pInfo->ready);
blockDataDestroy(pInfo->pRes);
const char* name = tNameGetTableName(&pInfo->name);
@@ -1942,7 +2200,7 @@ int32_t loadSysTableCallback(void* param, SDataBuf* pMsg, int32_t code) {
}
}
- tsem_post(&pScanResInfo->ready);
+ (void)tsem_post(&pScanResInfo->ready);
return TSDB_CODE_SUCCESS;
}
@@ -2086,12 +2344,15 @@ static FORCE_INLINE int optSysBinarySearch(SArray* arr, int s, int e, uint64_t k
return s;
}
-void optSysIntersection(SArray* in, SArray* out) {
+int32_t optSysIntersection(SArray* in, SArray* out) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
int32_t sz = (int32_t)taosArrayGetSize(in);
if (sz <= 0) {
- return;
+ goto _end;
}
MergeIndex* mi = taosMemoryCalloc(sz, sizeof(MergeIndex));
+ QUERY_CHECK_NULL(mi, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
for (int i = 0; i < sz; i++) {
SArray* t = taosArrayGetP(in, i);
mi[i].len = (int32_t)taosArrayGetSize(t);
@@ -2114,10 +2375,20 @@ void optSysIntersection(SArray* in, SArray* out) {
}
}
if (has == true) {
- taosArrayPush(out, &tgt);
+ void* tmp = taosArrayPush(out, &tgt);
+ if (!tmp) {
+ code = TSDB_CODE_OUT_OF_MEMORY;
+ goto _end;
+ }
}
}
+
+_end:
taosMemoryFreeClear(mi);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static int tableUidCompare(const void* a, const void* b) {
@@ -2135,8 +2406,7 @@ static int32_t optSysMergeRslt(SArray* mRslt, SArray* rslt) {
SArray* arslt = taosArrayGetP(mRslt, i);
taosArraySort(arslt, tableUidCompare);
}
- optSysIntersection(mRslt, rslt);
- return 0;
+ return optSysIntersection(mRslt, rslt);
}
static int32_t optSysSpecialColumn(SNode* cond) {
@@ -2151,7 +2421,7 @@ static int32_t optSysSpecialColumn(SNode* cond) {
}
static int32_t optSysTabFilte(void* arg, SNode* cond, SArray* result) {
- int ret = -1;
+ int ret = TSDB_CODE_FAILED;
if (nodeType(cond) == QUERY_NODE_OPERATOR) {
ret = optSysTabFilteImpl(arg, cond, result);
if (ret == 0) {
@@ -2189,7 +2459,10 @@ static int32_t optSysTabFilte(void* arg, SNode* cond, SArray* result) {
// has index
hasIdx = true;
if (optSysSpecialColumn(cell->pNode) == 0) {
- taosArrayPush(mRslt, &aRslt);
+ void* tmp = taosArrayPush(mRslt, &aRslt);
+ if (!tmp) {
+ return TSDB_CODE_FAILED;
+ }
} else {
// db_name/vgroup not result
taosArrayDestroy(aRslt);
@@ -2206,7 +2479,10 @@ static int32_t optSysTabFilte(void* arg, SNode* cond, SArray* result) {
cell = cell->pNext;
}
if (hasRslt && hasIdx) {
- optSysMergeRslt(mRslt, result);
+ int32_t code = optSysMergeRslt(mRslt, result);
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
+ }
}
for (int i = 0; i < taosArrayGetSize(mRslt); i++) {
@@ -2277,6 +2553,8 @@ static int32_t doGetTableRowSize(SReadHandle* pHandle, uint64_t uid, int32_t* ro
}
static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (pOperator->status == OP_EXEC_DONE) {
return NULL;
}
@@ -2286,13 +2564,13 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) {
SStorageAPI* pAPI = &pTaskInfo->storageAPI;
STableBlockDistInfo blockDistInfo = {.minRows = INT_MAX, .maxRows = INT_MIN};
- int32_t code = doGetTableRowSize(&pBlockScanInfo->readHandle, pBlockScanInfo->uid, (int32_t*)&blockDistInfo.rowSize,
- GET_TASKID(pTaskInfo));
- if (code != TSDB_CODE_SUCCESS) {
- T_LONG_JMP(pTaskInfo->env, code);
- }
+ code = doGetTableRowSize(&pBlockScanInfo->readHandle, pBlockScanInfo->uid, (int32_t*)&blockDistInfo.rowSize,
+ GET_TASKID(pTaskInfo));
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = pAPI->tsdReader.tsdReaderGetDataBlockDistInfo(pBlockScanInfo->pHandle, &blockDistInfo);
+ QUERY_CHECK_CODE(code, lino, _end);
- pAPI->tsdReader.tsdReaderGetDataBlockDistInfo(pBlockScanInfo->pHandle, &blockDistInfo);
blockDistInfo.numOfInmemRows = (int32_t)pAPI->tsdReader.tsdReaderGetNumOfInMemRows(pBlockScanInfo->pHandle);
SSDataBlock* pBlock = pBlockScanInfo->pResBlock;
@@ -2302,10 +2580,14 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) {
int32_t len = tSerializeBlockDistInfo(NULL, 0, &blockDistInfo);
char* p = taosMemoryCalloc(1, len + VARSTR_HEADER_SIZE);
- tSerializeBlockDistInfo(varDataVal(p), len, &blockDistInfo);
+ QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+ (void)tSerializeBlockDistInfo(varDataVal(p), len, &blockDistInfo);
varDataSetLen(p, len);
- colDataSetVal(pColInfo, 0, p, false);
+ code = colDataSetVal(pColInfo, 0, p, false);
+ QUERY_CHECK_CODE(code, lino, _end);
+
taosMemoryFree(p);
// make the valgrind happy that all memory buffer has been initialized already.
@@ -2317,6 +2599,13 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) {
pBlock->info.rows = 1;
pOperator->status = OP_EXEC_DONE;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return pBlock;
}
@@ -2361,6 +2650,7 @@ int32_t createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanP
QRY_OPTR_CHECK(pOptrInfo);
int32_t code = 0;
+ int32_t lino = 0;
SBlockDistInfo* pInfo = taosMemoryCalloc(1, sizeof(SBlockDistInfo));
SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
if (pInfo == NULL || pOperator == NULL) {
@@ -2369,14 +2659,13 @@ int32_t createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanP
}
pInfo->pResBlock = createDataBlockFromDescNode(pBlockScanNode->node.pOutputDataBlockDesc);
- blockDataEnsureCapacity(pInfo->pResBlock, 1);
+ code = blockDataEnsureCapacity(pInfo->pResBlock, 1);
+ QUERY_CHECK_CODE(code, lino, _error);
{
SQueryTableDataCond cond = {0};
code = initTableblockDistQueryCond(pBlockScanNode->suid, &cond);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
pInfo->pTableListInfo = pTableListInfo;
size_t num = tableListGetSize(pTableListInfo);
@@ -2385,9 +2674,7 @@ int32_t createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanP
code = readHandle->api.tsdReader.tsdReaderOpen(readHandle->vnode, &cond, pList, num, pInfo->pResBlock,
(void**)&pInfo->pHandle, pTaskInfo->id.str, NULL);
cleanupQueryTableDataCond(&cond);
- if (code != 0) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
}
pInfo->readHandle = *readHandle;
@@ -2396,9 +2683,7 @@ int32_t createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanP
int32_t numOfCols = 0;
SExprInfo* pExprInfo = createExprInfo(pBlockScanNode->pScanPseudoCols, NULL, &numOfCols);
code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfCols, &pTaskInfo->storageAPI.functionStore);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
setOperatorInfo(pOperator, "DataBlockDistScanOperator", QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN, false,
OP_NOT_OPENED, pInfo, pTaskInfo);
diff --git a/source/libs/executor/src/tfill.c b/source/libs/executor/src/tfill.c
index 5a8697d7b8..3a024bc22d 100644
--- a/source/libs/executor/src/tfill.c
+++ b/source/libs/executor/src/tfill.c
@@ -28,6 +28,7 @@
#include "executorInt.h"
#include "function.h"
#include "querynodes.h"
+#include "querytask.h"
#include "tdatablock.h"
#include "tfill.h"
@@ -35,7 +36,7 @@
#define DO_INTERPOLATION(_v1, _v2, _k1, _k2, _k) \
((_v1) + ((_v2) - (_v1)) * (((double)(_k)) - ((double)(_k1))) / (((double)(_k2)) - ((double)(_k1))))
-static void doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey);
+static int32_t doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey);
static void setNotFillColumn(SFillInfo* pFillInfo, SColumnInfoData* pDstColInfo, int32_t rowIndex, int32_t colIdx) {
SRowVal* p = NULL;
@@ -46,7 +47,11 @@ static void setNotFillColumn(SFillInfo* pFillInfo, SColumnInfoData* pDstColInfo,
}
SGroupKeys* pKey = taosArrayGet(p->pRowVal, colIdx);
- doSetVal(pDstColInfo, rowIndex, pKey);
+ int32_t code = doSetVal(pDstColInfo, rowIndex, pKey);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ T_LONG_JMP(pFillInfo->pTaskInfo->env, code);
+ }
}
static void setNullRow(SSDataBlock* pBlock, SFillInfo* pFillInfo, int32_t rowIndex) {
@@ -65,39 +70,55 @@ static void setNullRow(SSDataBlock* pBlock, SFillInfo* pFillInfo, int32_t rowInd
}
}
-static void doSetUserSpecifiedValue(SColumnInfoData* pDst, SVariant* pVar, int32_t rowIndex, int64_t currentKey) {
- bool isNull = (TSDB_DATA_TYPE_NULL == pVar->nType) ? true : false;
+static int32_t doSetUserSpecifiedValue(SColumnInfoData* pDst, SVariant* pVar, int32_t rowIndex, int64_t currentKey) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ bool isNull = (TSDB_DATA_TYPE_NULL == pVar->nType) ? true : false;
if (pDst->info.type == TSDB_DATA_TYPE_FLOAT) {
float v = 0;
GET_TYPED_DATA(v, float, pVar->nType, &pVar->f);
- colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+ code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (pDst->info.type == TSDB_DATA_TYPE_DOUBLE) {
double v = 0;
GET_TYPED_DATA(v, double, pVar->nType, &pVar->d);
- colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+ code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (IS_SIGNED_NUMERIC_TYPE(pDst->info.type) || pDst->info.type == TSDB_DATA_TYPE_BOOL) {
int64_t v = 0;
GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->i);
- colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+ code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (IS_UNSIGNED_NUMERIC_TYPE(pDst->info.type)) {
uint64_t v = 0;
GET_TYPED_DATA(v, uint64_t, pVar->nType, &pVar->u);
- colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+ code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
int64_t v = 0;
GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->u);
- colDataSetVal(pDst, rowIndex, (const char*)&v, isNull);
+ code = colDataSetVal(pDst, rowIndex, (const char*)&v, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (pDst->info.type == TSDB_DATA_TYPE_NCHAR || pDst->info.type == TSDB_DATA_TYPE_VARCHAR ||
pDst->info.type == TSDB_DATA_TYPE_VARBINARY) {
- colDataSetVal(pDst, rowIndex, pVar->pz, isNull);
+ code = colDataSetVal(pDst, rowIndex, pVar->pz, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
} else { // others data
colDataSetNULL(pDst, rowIndex);
}
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
// fill windows pseudo column, _wstart, _wend, _wduration and return true, otherwise return false
bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData,
int32_t rowIndex) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (!pCol->notFillCol) {
return false;
}
@@ -106,26 +127,37 @@ bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnI
return false;
}
if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_START) {
- colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->currentKey, false);
+ code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->currentKey, false);
+ QUERY_CHECK_CODE(code, lino, _end);
return true;
} else if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_END) {
// TODO: include endpoint
SInterval* pInterval = &pFillInfo->interval;
int64_t windowEnd =
taosTimeAdd(pFillInfo->currentKey, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
- colDataSetVal(pDstColInfoData, rowIndex, (const char*)&windowEnd, false);
+ code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&windowEnd, false);
+ QUERY_CHECK_CODE(code, lino, _end);
return true;
} else if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_DURATION) {
// TODO: include endpoint
- colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->interval.sliding, false);
+ code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->interval.sliding, false);
+ QUERY_CHECK_CODE(code, lino, _end);
return true;
}
}
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ T_LONG_JMP(pFillInfo->pTaskInfo->env, code);
+ }
return false;
}
static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* pSrcBlock, int64_t ts,
bool outOfBound) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SPoint point1, point2, point;
int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order);
@@ -171,7 +203,7 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
setNotFillColumn(pFillInfo, pDstCol, index, i);
}
} else {
- SRowVal* pRVal = FILL_IS_ASC_FILL(pFillInfo) ? &pFillInfo->prev : &pFillInfo->next;
+ SRowVal* pRVal = FILL_IS_ASC_FILL(pFillInfo) ? &pFillInfo->prev : &pFillInfo->next;
SGroupKeys* pKey = taosArrayGet(pRVal->pRowVal, i);
if (IS_VAR_DATA_TYPE(type) || type == TSDB_DATA_TYPE_BOOL || pKey->isNull) {
colDataSetNULL(pDstCol, index);
@@ -193,7 +225,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
point = (SPoint){.key = pFillInfo->currentKey, .val = &out};
taosGetLinearInterpolationVal(&point, type, &point1, &point2, type);
- colDataSetVal(pDstCol, index, (const char*)&out, false);
+ code = colDataSetVal(pDstCol, index, (const char*)&out, false);
+ QUERY_CHECK_CODE(code, lino, _end);
}
}
}
@@ -213,7 +246,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
}
} else {
SVariant* pVar = &pFillInfo->pFillCol[i].fillVal;
- doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey);
+ code = doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey);
+ QUERY_CHECK_CODE(code, lino, _end);
}
}
}
@@ -224,19 +258,36 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
taosTimeAdd(pFillInfo->currentKey, pInterval->sliding * step, pInterval->slidingUnit, pInterval->precision);
pBlock->info.rows += 1;
pFillInfo->numOfCurrent++;
-}
-void doSetVal(SColumnInfoData* pDstCol, int32_t rowIndex, const SGroupKeys* pKey) {
- if (pKey->isNull) {
- colDataSetNULL(pDstCol, rowIndex);
- } else {
- colDataSetVal(pDstCol, rowIndex, pKey->pData, false);
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ T_LONG_JMP(pFillInfo->pTaskInfo->env, code);
}
}
-static void initBeforeAfterDataBuf(SFillInfo* pFillInfo) {
+int32_t doSetVal(SColumnInfoData* pDstCol, int32_t rowIndex, const SGroupKeys* pKey) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ if (pKey->isNull) {
+ colDataSetNULL(pDstCol, rowIndex);
+ } else {
+ code = colDataSetVal(pDstCol, rowIndex, pKey->pData, false);
+ QUERY_CHECK_CODE(code, lino, _end);
+ }
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
+}
+
+static int32_t initBeforeAfterDataBuf(SFillInfo* pFillInfo) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (taosArrayGetSize(pFillInfo->next.pRowVal) > 0) {
- return;
+ goto _end;
}
for (int i = 0; i < pFillInfo->numOfCols; i++) {
@@ -245,15 +296,26 @@ static void initBeforeAfterDataBuf(SFillInfo* pFillInfo) {
SGroupKeys key = {0};
SResSchema* pSchema = &pCol->pExpr->base.resSchema;
key.pData = taosMemoryMalloc(pSchema->bytes);
+ QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
key.isNull = true;
key.bytes = pSchema->bytes;
key.type = pSchema->type;
- taosArrayPush(pFillInfo->next.pRowVal, &key);
+ void* tmp = taosArrayPush(pFillInfo->next.pRowVal, &key);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
key.pData = taosMemoryMalloc(pSchema->bytes);
- taosArrayPush(pFillInfo->prev.pRowVal, &key);
+ QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+ tmp = taosArrayPush(pFillInfo->prev.pRowVal, &key);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bool isNull);
@@ -264,7 +326,7 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, int32_t rowIndex, SRowVa
for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
int32_t type = pFillInfo->pFillCol[i].pExpr->pExpr->nodeType;
- if ( type == QUERY_NODE_COLUMN || type == QUERY_NODE_OPERATOR || type == QUERY_NODE_FUNCTION) {
+ if (type == QUERY_NODE_COLUMN || type == QUERY_NODE_OPERATOR || type == QUERY_NODE_FUNCTION) {
if (!pFillInfo->pFillCol[i].notFillCol && pFillInfo->type != TSDB_FILL_NEXT) {
continue;
}
@@ -288,7 +350,8 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, int32_t rowIndex, SRowVa
static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t outputRows) {
pFillInfo->numOfCurrent = 0;
-
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SColumnInfoData* pTsCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId);
int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order);
@@ -321,7 +384,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
// output buffer is full, abort
if (pFillInfo->numOfCurrent == outputRows) {
pFillInfo->numOfTotal += pFillInfo->numOfCurrent;
- return outputRows;
+ goto _end;
}
} else {
ASSERT(pFillInfo->currentKey == ts);
@@ -348,7 +411,8 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
char* src = colDataGetData(pSrc, pFillInfo->index);
if (!colDataIsNull_s(pSrc, pFillInfo->index)) {
- colDataSetVal(pDst, index, src, false);
+ code = colDataSetVal(pDst, index, src, false);
+ QUERY_CHECK_CODE(code, lino, _end);
SRowVal* pRVal = FILL_IS_ASC_FILL(pFillInfo) ? &pFillInfo->prev : &pFillInfo->next;
saveColData(pRVal->pRowVal, i, src, false);
if (pFillInfo->srcTsSlotId == dstSlotId) {
@@ -356,15 +420,19 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
}
} else { // the value is null
if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
- colDataSetVal(pDst, index, (const char*)&pFillInfo->currentKey, false);
+ code = colDataSetVal(pDst, index, (const char*)&pFillInfo->currentKey, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else { // i > 0 and data is null , do interpolation
if (pFillInfo->type == TSDB_FILL_PREV) {
SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->prev.pRowVal : pFillInfo->next.pRowVal;
SGroupKeys* pKey = taosArrayGet(p, i);
- doSetVal(pDst, index, pKey);
+ code = doSetVal(pDst, index, pKey);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (pFillInfo->type == TSDB_FILL_LINEAR) {
bool isNull = colDataIsNull_s(pSrc, pFillInfo->index);
- colDataSetVal(pDst, index, src, isNull);
+ code = colDataSetVal(pDst, index, src, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
+
SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->prev.pRowVal : pFillInfo->next.pRowVal;
saveColData(p, i, src, isNull); // todo:
} else if (pFillInfo->type == TSDB_FILL_NULL || pFillInfo->type == TSDB_FILL_NULL_F) {
@@ -372,10 +440,12 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
} else if (pFillInfo->type == TSDB_FILL_NEXT) {
SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->next.pRowVal : pFillInfo->prev.pRowVal;
SGroupKeys* pKey = taosArrayGet(p, i);
- doSetVal(pDst, index, pKey);
+ code = doSetVal(pDst, index, pKey);
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
SVariant* pVar = &pFillInfo->pFillCol[i].fillVal;
- doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey);
+ code = doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey);
+ QUERY_CHECK_CODE(code, lino, _end);
}
}
}
@@ -393,11 +463,15 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
if (pFillInfo->index >= pFillInfo->numOfRows || pFillInfo->numOfCurrent >= outputRows) {
pFillInfo->numOfTotal += pFillInfo->numOfCurrent;
- return pFillInfo->numOfCurrent;
+ goto _end;
}
}
- return pFillInfo->numOfCurrent;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bool isNull) {
@@ -414,7 +488,7 @@ static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bo
}
}
-static int64_t appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int64_t resultCapacity) {
+static void appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int64_t resultCapacity) {
/*
* These data are generated according to fill strategy, since the current timestamp is out of the time window of
* real result set. Note that we need to keep the direct previous result rows, to generated the filled data.
@@ -427,7 +501,6 @@ static int64_t appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int
pFillInfo->numOfTotal += pFillInfo->numOfCurrent;
ASSERT(pFillInfo->numOfCurrent == resultCapacity);
- return resultCapacity;
}
static int32_t taosNumOfRemainRows(SFillInfo* pFillInfo) {
@@ -440,7 +513,9 @@ static int32_t taosNumOfRemainRows(SFillInfo* pFillInfo) {
struct SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t numOfNotFillCols, int32_t capacity,
SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol,
- int32_t primaryTsSlotId, int32_t order, const char* id) {
+ int32_t primaryTsSlotId, int32_t order, const char* id, SExecTaskInfo* pTaskInfo) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (fillType == TSDB_FILL_NONE) {
return NULL;
}
@@ -473,9 +548,23 @@ struct SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t
pFillInfo->interval = *pInterval;
pFillInfo->next.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys));
- pFillInfo->prev.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys));
+ QUERY_CHECK_NULL(pFillInfo->next.pRowVal, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
- initBeforeAfterDataBuf(pFillInfo);
+ pFillInfo->prev.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys));
+ QUERY_CHECK_NULL(pFillInfo->prev.pRowVal, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+ code = initBeforeAfterDataBuf(pFillInfo);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ pFillInfo->pTaskInfo = pTaskInfo;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ taosArrayDestroy(pFillInfo->next.pRowVal);
+ taosArrayDestroy(pFillInfo->prev.pRowVal);
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
+ return NULL;
+ }
return pFillInfo;
}
@@ -559,7 +648,7 @@ void taosFillUpdateStartTimestampInfo(SFillInfo* pFillInfo, int64_t ts) {
pFillInfo->currentKey = ts;
}
-bool taosFillNotStarted(const SFillInfo* pFillInfo) {return pFillInfo->start == pFillInfo->currentKey;}
+bool taosFillNotStarted(const SFillInfo* pFillInfo) { return pFillInfo->start == pFillInfo->currentKey; }
bool taosFillHasMoreResults(SFillInfo* pFillInfo) {
int32_t remain = taosNumOfRemainRows(pFillInfo);
@@ -577,16 +666,17 @@ bool taosFillHasMoreResults(SFillInfo* pFillInfo) {
}
int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t maxNumOfRows) {
- int32_t numOfRows = taosNumOfRemainRows(pFillInfo);
+ int32_t numOfRows = taosNumOfRemainRows(pFillInfo);
TSKEY ekey1 = ekey;
int64_t numOfRes = -1;
if (numOfRows > 0) { // still fill gap within current data block, not generating data after the result set.
- SColumnInfoData* pCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId);
- int64_t* tsList = (int64_t*)pCol->pData;
- TSKEY lastKey = tsList[pFillInfo->numOfRows - 1];
- numOfRes = taosTimeCountIntervalForFill(lastKey, pFillInfo->currentKey, pFillInfo->interval.sliding,
+ SColumnInfoData* pCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId);
+ int64_t* tsList = (int64_t*)pCol->pData;
+ TSKEY lastKey = tsList[pFillInfo->numOfRows - 1];
+ numOfRes =
+ taosTimeCountIntervalForFill(lastKey, pFillInfo->currentKey, pFillInfo->interval.sliding,
pFillInfo->interval.slidingUnit, pFillInfo->interval.precision, pFillInfo->order);
ASSERT(numOfRes >= numOfRows);
} else { // reach the end of data
@@ -595,7 +685,8 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma
return 0;
}
- numOfRes = taosTimeCountIntervalForFill(ekey1, pFillInfo->currentKey, pFillInfo->interval.sliding,
+ numOfRes =
+ taosTimeCountIntervalForFill(ekey1, pFillInfo->currentKey, pFillInfo->interval.sliding,
pFillInfo->interval.slidingUnit, pFillInfo->interval.precision, pFillInfo->order);
}
@@ -603,7 +694,7 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma
}
void taosGetLinearInterpolationVal(SPoint* point, int32_t outputType, SPoint* point1, SPoint* point2,
- int32_t inputType) {
+ int32_t inputType) {
double v1 = -1, v2 = -1;
GET_TYPED_DATA(v1, double, inputType, point1->val);
GET_TYPED_DATA(v2, double, inputType, point2->val);
@@ -617,7 +708,8 @@ void taosGetLinearInterpolationVal(SPoint* point, int32_t outputType, SPoint* po
SET_TYPED_DATA(point->val, outputType, r);
}
-void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity) {
+int32_t taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity) {
+ int32_t code = TSDB_CODE_SUCCESS;
int32_t remain = taosNumOfRemainRows(pFillInfo);
int64_t numOfRes = getNumOfResultsAfterFillGap(pFillInfo, pFillInfo->end, capacity);
@@ -627,7 +719,7 @@ void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capac
if (remain == 0) {
appendFilledResult(pFillInfo, p, numOfRes);
} else {
- fillResultImpl(pFillInfo, p, (int32_t)numOfRes);
+ code = fillResultImpl(pFillInfo, p, (int32_t)numOfRes);
ASSERT(numOfRes == pFillInfo->numOfCurrent);
}
@@ -635,6 +727,7 @@ void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capac
", current : % d, total : % d, %s",
pFillInfo, pFillInfo->numOfRows, pFillInfo->index, pFillInfo->start, pFillInfo->end, pFillInfo->currentKey,
pFillInfo->numOfCurrent, pFillInfo->numOfTotal, pFillInfo->id);
+ return code;
}
int64_t getFillInfoStart(struct SFillInfo* pFillInfo) { return pFillInfo->start; }
diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c
index f095a471bc..7e45ddaf52 100644
--- a/source/libs/executor/src/timesliceoperator.c
+++ b/source/libs/executor/src/timesliceoperator.c
@@ -44,8 +44,8 @@ typedef struct STimeSliceOperatorInfo {
uint64_t groupId;
SGroupKeys* pPrevGroupKey;
SSDataBlock* pNextGroupRes;
- SSDataBlock* pRemainRes; // save block unfinished processing
- int32_t remainIndex; // the remaining index in the block to be processed
+ SSDataBlock* pRemainRes; // save block unfinished processing
+ int32_t remainIndex; // the remaining index in the block to be processed
bool hasPk;
SColumn pkCol;
} STimeSliceOperatorInfo;
@@ -163,18 +163,22 @@ static FORCE_INLINE int32_t timeSliceEnsureBlockCapacity(STimeSliceOperatorInfo*
uint32_t winNum = (pSliceInfo->win.ekey - pSliceInfo->win.skey) / pSliceInfo->interval.interval;
uint32_t newRowsNum = pBlock->info.rows + TMIN(winNum / 4 + 1, 1048576);
- blockDataEnsureCapacity(pBlock, newRowsNum);
+ int32_t code = blockDataEnsureCapacity(pBlock, newRowsNum);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ return code;
+ }
return TSDB_CODE_SUCCESS;
}
static bool isIrowtsPseudoColumn(SExprInfo* pExprInfo) {
- char *name = pExprInfo->pExpr->_function.functionName;
+ char* name = pExprInfo->pExpr->_function.functionName;
return (IS_TIMESTAMP_TYPE(pExprInfo->base.resSchema.type) && strcasecmp(name, "_irowts") == 0);
}
static bool isIsfilledPseudoColumn(SExprInfo* pExprInfo) {
- char *name = pExprInfo->pExpr->_function.functionName;
+ char* name = pExprInfo->pExpr->_function.functionName;
return (IS_BOOLEAN_TYPE(pExprInfo->base.resSchema.type) && strcasecmp(name, "_isfilled") == 0);
}
@@ -202,7 +206,7 @@ static bool checkDuplicateTimestamps(STimeSliceOperatorInfo* pSliceInfo, SColumn
return false;
}
- SRowKey cur = {.ts = currentTs, .numOfPKs = (pPkCol != NULL)? 1:0};
+ SRowKey cur = {.ts = currentTs, .numOfPKs = (pPkCol != NULL) ? 1 : 0};
if (pPkCol != NULL) {
cur.pks[0].type = pPkCol->info.type;
if (IS_VAR_DATA_TYPE(pPkCol->info.type)) {
@@ -244,7 +248,7 @@ static bool getIgoreNullRes(SExprSupp* pExprSup) {
if (isInterpFunc(pExprInfo)) {
for (int32_t j = 0; j < pExprInfo->base.numOfParams; ++j) {
- SFunctParam *pFuncParam = &pExprInfo->base.pParam[j];
+ SFunctParam* pFuncParam = &pExprInfo->base.pParam[j];
if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) {
return pFuncParam->param.i ? true : false;
}
@@ -264,7 +268,7 @@ static bool checkNullRow(SExprSupp* pExprSup, SSDataBlock* pSrcBlock, int32_t in
SExprInfo* pExprInfo = &pExprSup->pExprInfo[j];
if (isInterpFunc(pExprInfo)) {
- int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId;
+ int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId;
SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot);
if (colDataIsNull_s(pSrc, index)) {
@@ -276,34 +280,37 @@ static bool checkNullRow(SExprSupp* pExprSup, SSDataBlock* pSrcBlock, int32_t in
return false;
}
-
static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock,
- SSDataBlock* pSrcBlock, int32_t index, bool beforeTs) {
+ SSDataBlock* pSrcBlock, int32_t index, bool beforeTs, SExecTaskInfo* pTaskInfo) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
int32_t rows = pResBlock->info.rows;
- timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock);
+ code = timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock);
+ QUERY_CHECK_CODE(code, lino, _end);
// todo set the correct primary timestamp column
-
// output the result
int32_t fillColIndex = 0;
- bool hasInterp = true;
+ bool hasInterp = true;
for (int32_t j = 0; j < pExprSup->numOfExprs; ++j) {
SExprInfo* pExprInfo = &pExprSup->pExprInfo[j];
- int32_t dstSlot = pExprInfo->base.resSchema.slotId;
+ int32_t dstSlot = pExprInfo->base.resSchema.slotId;
SColumnInfoData* pDst = taosArrayGet(pResBlock->pDataBlock, dstSlot);
if (isIrowtsPseudoColumn(pExprInfo)) {
- colDataSetVal(pDst, rows, (char*)&pSliceInfo->current, false);
+ code = colDataSetVal(pDst, rows, (char*)&pSliceInfo->current, false);
+ QUERY_CHECK_CODE(code, lino, _end);
continue;
} else if (isIsfilledPseudoColumn(pExprInfo)) {
bool isFilled = true;
- colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false);
+ code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false);
+ QUERY_CHECK_CODE(code, lino, _end);
continue;
} else if (!isInterpFunc(pExprInfo)) {
if (isGroupKeyFunc(pExprInfo) || isSelectGroupConstValueFunc(pExprInfo)) {
if (pSrcBlock != NULL) {
- int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId;
+ int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId;
SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot);
if (colDataIsNull_s(pSrc, index)) {
@@ -312,12 +319,14 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
}
char* v = colDataGetData(pSrc, index);
- colDataSetVal(pDst, pResBlock->info.rows, v, false);
+ code = colDataSetVal(pDst, pResBlock->info.rows, v, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if(!isSelectGroupConstValueFunc(pExprInfo)){
// use stored group key
SGroupKeys* pkey = pSliceInfo->pPrevGroupKey;
if (pkey->isNull == false) {
- colDataSetVal(pDst, rows, pkey->pData, false);
+ code = colDataSetVal(pDst, rows, pkey->pData, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
colDataSetNULL(pDst, rows);
}
@@ -354,7 +363,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
} else {
v = taosStr2Float(varDataVal(pVar->pz), NULL);
}
- colDataSetVal(pDst, rows, (char*)&v, isNull);
+ code = colDataSetVal(pDst, rows, (char*)&v, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (pDst->info.type == TSDB_DATA_TYPE_DOUBLE) {
double v = 0;
if (!IS_VAR_DATA_TYPE(pVar->nType)) {
@@ -362,7 +372,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
} else {
v = taosStr2Double(varDataVal(pVar->pz), NULL);
}
- colDataSetVal(pDst, rows, (char*)&v, isNull);
+ code = colDataSetVal(pDst, rows, (char*)&v, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (IS_SIGNED_NUMERIC_TYPE(pDst->info.type)) {
int64_t v = 0;
if (!IS_VAR_DATA_TYPE(pVar->nType)) {
@@ -370,7 +381,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
} else {
v = taosStr2Int64(varDataVal(pVar->pz), NULL, 10);
}
- colDataSetVal(pDst, rows, (char*)&v, isNull);
+ code = colDataSetVal(pDst, rows, (char*)&v, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (IS_UNSIGNED_NUMERIC_TYPE(pDst->info.type)) {
uint64_t v = 0;
if (!IS_VAR_DATA_TYPE(pVar->nType)) {
@@ -378,7 +390,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
} else {
v = taosStr2UInt64(varDataVal(pVar->pz), NULL, 10);
}
- colDataSetVal(pDst, rows, (char*)&v, isNull);
+ code = colDataSetVal(pDst, rows, (char*)&v, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (IS_BOOLEAN_TYPE(pDst->info.type)) {
bool v = false;
if (!IS_VAR_DATA_TYPE(pVar->nType)) {
@@ -386,7 +399,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
} else {
v = taosStr2Int8(varDataVal(pVar->pz), NULL, 10);
}
- colDataSetVal(pDst, rows, (char*)&v, isNull);
+ code = colDataSetVal(pDst, rows, (char*)&v, isNull);
+ QUERY_CHECK_CODE(code, lino, _end);
}
++fillColIndex;
@@ -421,8 +435,10 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
}
current.val = taosMemoryCalloc(pLinearInfo->bytes, 1);
+ QUERY_CHECK_NULL(current.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
taosGetLinearInterpolationVal(¤t, pLinearInfo->type, &start, &end, pLinearInfo->type);
- colDataSetVal(pDst, rows, (char*)current.val, false);
+ code = colDataSetVal(pDst, rows, (char*)current.val, false);
+ QUERY_CHECK_CODE(code, lino, _end);
taosMemoryFree(current.val);
break;
@@ -435,7 +451,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
SGroupKeys* pkey = taosArrayGet(pSliceInfo->pPrevRow, srcSlot);
if (pkey->isNull == false) {
- colDataSetVal(pDst, rows, pkey->pData, false);
+ code = colDataSetVal(pDst, rows, pkey->pData, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
colDataSetNULL(pDst, rows);
}
@@ -450,7 +467,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
SGroupKeys* pkey = taosArrayGet(pSliceInfo->pNextRow, srcSlot);
if (pkey->isNull == false) {
- colDataSetVal(pDst, rows, pkey->pData, false);
+ code = colDataSetVal(pDst, rows, pkey->pData, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
colDataSetNULL(pDst, rows);
}
@@ -467,12 +485,21 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
pResBlock->info.rows += 1;
}
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return hasInterp;
}
-static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock,
- SSDataBlock* pSrcBlock, int32_t index) {
- timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock);
+static int32_t addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock,
+ SSDataBlock* pSrcBlock, int32_t index) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ code = timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock);
+ QUERY_CHECK_CODE(code, lino, _end);
for (int32_t j = 0; j < pExprSup->numOfExprs; ++j) {
SExprInfo* pExprInfo = &pExprSup->pExprInfo[j];
@@ -480,12 +507,14 @@ static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp*
SColumnInfoData* pDst = taosArrayGet(pResBlock->pDataBlock, dstSlot);
if (isIrowtsPseudoColumn(pExprInfo)) {
- colDataSetVal(pDst, pResBlock->info.rows, (char*)&pSliceInfo->current, false);
+ code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&pSliceInfo->current, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else if (isIsfilledPseudoColumn(pExprInfo)) {
bool isFilled = false;
- colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false);
+ code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false);
+ QUERY_CHECK_CODE(code, lino, _end);
} else {
- int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId;
+ int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId;
SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot);
if (colDataIsNull_s(pSrc, index)) {
@@ -494,15 +523,23 @@ static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp*
}
char* v = colDataGetData(pSrc, index);
- colDataSetVal(pDst, pResBlock->info.rows, v, false);
+ code = colDataSetVal(pDst, pResBlock->info.rows, v, false);
+ QUERY_CHECK_CODE(code, lino, _end);
}
}
pResBlock->info.rows += 1;
- return;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static int32_t initPrevRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (pInfo->pPrevRow != NULL) {
return TSDB_CODE_SUCCESS;
}
@@ -521,14 +558,23 @@ static int32_t initPrevRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB
key.type = pColInfo->info.type;
key.isNull = false;
key.pData = taosMemoryCalloc(1, pColInfo->info.bytes);
- taosArrayPush(pInfo->pPrevRow, &key);
+ QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+ void* tmp = taosArrayPush(pInfo->pPrevRow, &key);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
pInfo->isPrevRowSet = false;
- return TSDB_CODE_SUCCESS;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static int32_t initNextRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (pInfo->pNextRow != NULL) {
return TSDB_CODE_SUCCESS;
}
@@ -547,15 +593,24 @@ static int32_t initNextRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB
key.type = pColInfo->info.type;
key.isNull = false;
key.pData = taosMemoryCalloc(1, pColInfo->info.bytes);
- taosArrayPush(pInfo->pNextRow, &key);
+ QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+ void* tmp = taosArrayPush(pInfo->pNextRow, &key);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
pInfo->isNextRowSet = false;
- return TSDB_CODE_SUCCESS;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static int32_t initFillLinearInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
if (pInfo->pLinearInfo != NULL) {
return TSDB_CODE_SUCCESS;
}
@@ -573,15 +628,23 @@ static int32_t initFillLinearInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB
linearInfo.start.key = INT64_MIN;
linearInfo.end.key = INT64_MIN;
linearInfo.start.val = taosMemoryCalloc(1, pColInfo->info.bytes);
+ QUERY_CHECK_NULL(linearInfo.start.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
linearInfo.end.val = taosMemoryCalloc(1, pColInfo->info.bytes);
+ QUERY_CHECK_NULL(linearInfo.end.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
linearInfo.isStartSet = false;
linearInfo.isEndSet = false;
linearInfo.type = pColInfo->info.type;
linearInfo.bytes = pColInfo->info.bytes;
- taosArrayPush(pInfo->pLinearInfo, &linearInfo);
+ void* tmp = taosArrayPush(pInfo->pLinearInfo, &linearInfo);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
- return TSDB_CODE_SUCCESS;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
+ return code;
}
static int32_t initGroupKeyKeeper(STimeSliceOperatorInfo* pInfo, SExprSupp* pExprSup) {
@@ -630,62 +693,59 @@ static int32_t initKeeperInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock
return TSDB_CODE_FAILED;
}
-
return TSDB_CODE_SUCCESS;
}
-static int32_t resetPrevRowsKeeper(STimeSliceOperatorInfo* pInfo) {
+static void resetPrevRowsKeeper(STimeSliceOperatorInfo* pInfo) {
if (pInfo->pPrevRow == NULL) {
- return TSDB_CODE_SUCCESS;
+ return;
}
for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) {
- SGroupKeys *pKey = taosArrayGet(pInfo->pPrevRow, i);
+ SGroupKeys* pKey = taosArrayGet(pInfo->pPrevRow, i);
pKey->isNull = false;
}
pInfo->isPrevRowSet = false;
- return TSDB_CODE_SUCCESS;
+ return;
}
-static int32_t resetNextRowsKeeper(STimeSliceOperatorInfo* pInfo) {
+static void resetNextRowsKeeper(STimeSliceOperatorInfo* pInfo) {
if (pInfo->pNextRow == NULL) {
- return TSDB_CODE_SUCCESS;
+ return;
}
for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) {
- SGroupKeys *pKey = taosArrayGet(pInfo->pPrevRow, i);
+ SGroupKeys* pKey = taosArrayGet(pInfo->pPrevRow, i);
pKey->isNull = false;
}
pInfo->isNextRowSet = false;
- return TSDB_CODE_SUCCESS;
+ return;
}
-static int32_t resetFillLinearInfo(STimeSliceOperatorInfo* pInfo) {
+static void resetFillLinearInfo(STimeSliceOperatorInfo* pInfo) {
if (pInfo->pLinearInfo == NULL) {
- return TSDB_CODE_SUCCESS;
+ return;
}
for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) {
- SFillLinearInfo *pLinearInfo = taosArrayGet(pInfo->pLinearInfo, i);
+ SFillLinearInfo* pLinearInfo = taosArrayGet(pInfo->pLinearInfo, i);
pLinearInfo->start.key = INT64_MIN;
pLinearInfo->end.key = INT64_MIN;
pLinearInfo->isStartSet = false;
pLinearInfo->isEndSet = false;
}
- return TSDB_CODE_SUCCESS;
+ return;
}
-static int32_t resetKeeperInfo(STimeSliceOperatorInfo* pInfo) {
+static void resetKeeperInfo(STimeSliceOperatorInfo* pInfo) {
resetPrevRowsKeeper(pInfo);
resetNextRowsKeeper(pInfo);
resetFillLinearInfo(pInfo);
-
- return TSDB_CODE_SUCCESS;
}
static bool checkThresholdReached(STimeSliceOperatorInfo* pSliceInfo, int32_t threshold) {
@@ -717,13 +777,14 @@ static void saveBlockStatus(STimeSliceOperatorInfo* pSliceInfo, SSDataBlock* pBl
// all data in remaining block processed
pSliceInfo->pRemainRes = NULL;
-
}
static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pSliceInfo, SSDataBlock* pBlock,
SExecTaskInfo* pTaskInfo, bool ignoreNull) {
- SSDataBlock* pResBlock = pSliceInfo->pRes;
- SInterval* pInterval = &pSliceInfo->interval;
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ SSDataBlock* pResBlock = pSliceInfo->pRes;
+ SInterval* pInterval = &pSliceInfo->interval;
SColumnInfoData* pTsCol = taosArrayGet(pBlock->pDataBlock, pSliceInfo->tsCol.slotId);
SColumnInfoData* pPkCol = NULL;
@@ -746,7 +807,8 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS
}
if (ts == pSliceInfo->current) {
- addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i);
+ code = addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i);
+ QUERY_CHECK_CODE(code, lino, _end);
doKeepPrevRows(pSliceInfo, pBlock, i);
doKeepLinearInfo(pSliceInfo, pBlock, i);
@@ -773,12 +835,12 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS
int64_t nextTs = *(int64_t*)colDataGetData(pTsCol, i + 1);
if (nextTs > pSliceInfo->current) {
while (pSliceInfo->current < nextTs && pSliceInfo->current <= pSliceInfo->win.ekey) {
- if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, false) &&
+ if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, false, pTaskInfo) &&
pSliceInfo->fillType == TSDB_FILL_LINEAR) {
break;
} else {
- pSliceInfo->current = taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit,
- pInterval->precision);
+ pSliceInfo->current =
+ taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
}
}
@@ -801,7 +863,7 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS
doKeepLinearInfo(pSliceInfo, pBlock, i);
while (pSliceInfo->current < ts && pSliceInfo->current <= pSliceInfo->win.ekey) {
- if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, true) &&
+ if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, true, pTaskInfo) &&
pSliceInfo->fillType == TSDB_FILL_LINEAR) {
break;
} else {
@@ -812,7 +874,8 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS
// add current row if timestamp match
if (ts == pSliceInfo->current && pSliceInfo->current <= pSliceInfo->win.ekey) {
- addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i);
+ code = addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i);
+ QUERY_CHECK_CODE(code, lino, _end);
pSliceInfo->current =
taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
@@ -832,6 +895,13 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS
// if reached here, meaning block processing finished naturally,
// or interpolation reach window upper bound
pSliceInfo->pRemainRes = NULL;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
}
static void genInterpAfterDataBlock(STimeSliceOperatorInfo* pSliceInfo, SOperatorInfo* pOperator, int32_t index) {
@@ -844,7 +914,7 @@ static void genInterpAfterDataBlock(STimeSliceOperatorInfo* pSliceInfo, SOperato
}
while (pSliceInfo->current <= pSliceInfo->win.ekey) {
- genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, NULL, index, false);
+ (void)genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, NULL, index, false, pOperator->pTaskInfo);
pSliceInfo->current =
taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
}
@@ -855,7 +925,7 @@ static void copyPrevGroupKey(SExprSupp* pExprSup, SGroupKeys* pGroupKey, SSDataB
SExprInfo* pExprInfo = &pExprSup->pExprInfo[j];
if (isGroupKeyFunc(pExprInfo)) {
- int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId;
+ int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId;
SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot);
if (colDataIsNull_s(pSrc, 0)) {
@@ -901,16 +971,27 @@ static void doHandleTimeslice(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
if (pSliceInfo->scalarSup.pExprInfo != NULL) {
SExprSupp* pExprSup = &pSliceInfo->scalarSup;
- projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+ code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
}
// the pDataBlock are always the same one, no need to call this again
- setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
+ code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
doTimesliceImpl(pOperator, pSliceInfo, pBlock, pTaskInfo, ignoreNull);
copyPrevGroupKey(&pOperator->exprSupp, pSliceInfo->pPrevGroupKey, pBlock);
}
static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
if (pOperator->status == OP_EXEC_DONE) {
return NULL;
}
@@ -924,7 +1005,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
if (pSliceInfo->pNextGroupRes != NULL) {
doHandleTimeslice(pOperator, pSliceInfo->pNextGroupRes);
if (checkWindowBoundReached(pSliceInfo) || checkThresholdReached(pSliceInfo, pOperator->resultInfo.threshold)) {
- doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _finished);
if (pSliceInfo->pRemainRes == NULL) {
pSliceInfo->pNextGroupRes = NULL;
}
@@ -959,7 +1041,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
doHandleTimeslice(pOperator, pBlock);
if (checkWindowBoundReached(pSliceInfo) || checkThresholdReached(pSliceInfo, pOperator->resultInfo.threshold)) {
- doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _finished);
if (pResBlock->info.rows != 0) {
goto _finished;
}
@@ -971,7 +1054,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
// except for fill(next), fill(linear)
genInterpAfterDataBlock(pSliceInfo, pOperator, 0);
- doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _finished);
if (pOperator->status == OP_EXEC_DONE) {
break;
}
@@ -989,6 +1073,11 @@ _finished:
if (pResBlock->info.rows == 0) {
pOperator->status = OP_EXEC_DONE;
}
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return pResBlock->info.rows == 0 ? NULL : pResBlock;
}
@@ -996,17 +1085,16 @@ _finished:
static int32_t extractPkColumnFromFuncs(SNodeList* pFuncs, bool* pHasPk, SColumn* pPkColumn) {
SNode* pNode;
FOREACH(pNode, pFuncs) {
- if ((nodeType(pNode) == QUERY_NODE_TARGET) &&
- (nodeType(((STargetNode*)pNode)->pExpr) == QUERY_NODE_FUNCTION)) {
- SFunctionNode* pFunc = (SFunctionNode*)((STargetNode*)pNode)->pExpr;
- if (fmIsInterpFunc(pFunc->funcId) && pFunc->hasPk) {
- SNode* pNode2 = (pFunc->pParameterList->pTail->pNode);
- if ((nodeType(pNode2) == QUERY_NODE_COLUMN) && ((SColumnNode*)pNode2)->isPk) {
- *pHasPk = true;
- *pPkColumn = extractColumnFromColumnNode((SColumnNode*)pNode2);
- break;
- }
+ if ((nodeType(pNode) == QUERY_NODE_TARGET) && (nodeType(((STargetNode*)pNode)->pExpr) == QUERY_NODE_FUNCTION)) {
+ SFunctionNode* pFunc = (SFunctionNode*)((STargetNode*)pNode)->pExpr;
+ if (fmIsInterpFunc(pFunc->funcId) && pFunc->hasPk) {
+ SNode* pNode2 = (pFunc->pParameterList->pTail->pNode);
+ if ((nodeType(pNode2) == QUERY_NODE_COLUMN) && ((SColumnNode*)pNode2)->isPk) {
+ *pHasPk = true;
+ *pPkColumn = extractColumnFromColumnNode((SColumnNode*)pNode2);
+ break;
}
+ }
}
}
return TSDB_CODE_SUCCESS;
@@ -1016,6 +1104,7 @@ int32_t createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyN
QRY_OPTR_CHECK(pOptrInfo);
int32_t code = 0;
+ int32_t lino = 0;
STimeSliceOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STimeSliceOperatorInfo));
SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
@@ -1030,26 +1119,22 @@ int32_t createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyN
int32_t numOfExprs = 0;
SExprInfo* pExprInfo = createExprInfo(pInterpPhyNode->pFuncs, NULL, &numOfExprs);
code = initExprSupp(pSup, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
if (pInterpPhyNode->pExprs != NULL) {
int32_t num = 0;
SExprInfo* pScalarExprInfo = createExprInfo(pInterpPhyNode->pExprs, NULL, &num);
code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, num, &pTaskInfo->storageAPI.functionStore);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
}
code = filterInitFromNode((SNode*)pInterpPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
pInfo->tsCol = extractColumnFromColumnNode((SColumnNode*)pInterpPhyNode->pTimeSeries);
- extractPkColumnFromFuncs(pInterpPhyNode->pFuncs, &pInfo->hasPk, &pInfo->pkCol);
+ code = extractPkColumnFromFuncs(pInterpPhyNode->pFuncs, &pInfo->hasPk, &pInfo->pkCol);
+ QUERY_CHECK_CODE(code, lino, _error);
+
pInfo->fillType = convertFillType(pInterpPhyNode->fillMode);
initResultSizeInfo(&pOperator->resultInfo, 4096);
@@ -1085,12 +1170,13 @@ int32_t createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyN
setOperatorInfo(pOperator, "TimeSliceOperator", QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC, false, OP_NOT_OPENED, pInfo,
pTaskInfo);
- pOperator->fpSet =
- createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
+ pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo,
+ optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
- blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _error);
-// int32_t code = initKeeperInfo(pSliceInfo, pBlock, &pOperator->exprSupp);
+ // int32_t code = initKeeperInfo(pSliceInfo, pBlock, &pOperator->exprSupp);
code = appendDownstream(pOperator, &downstream, 1);
@@ -1098,6 +1184,9 @@ int32_t createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyN
return code;
_error:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ }
taosMemoryFree(pInfo);
taosMemoryFree(pOperator);
pTaskInfo->code = code;
diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c
index b96447953c..9ee5b1c537 100644
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
@@ -62,10 +62,10 @@ typedef struct SOpenWindowInfo {
uint64_t groupId;
} SOpenWindowInfo;
-static int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo);
+static int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo, SExecTaskInfo* pTaskInfo);
static SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult,
- uint64_t groupId);
+ uint64_t groupId, SExecTaskInfo* pTaskInfo);
static void doCloseWindow(SResultRowInfo* pResultRowInfo, const SIntervalAggOperatorInfo* pInfo, SResultRow* pResult);
static int32_t setTimeWindowOutputBuf(SResultRowInfo* pResultRowInfo, STimeWindow* win, bool masterscan,
@@ -707,7 +707,7 @@ static bool hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul
int32_t startPos = 0;
int32_t numOfOutput = pSup->numOfExprs;
- int64_t* tsCols = extractTsCol(pBlock, pInfo);
+ int64_t* tsCols = extractTsCol(pBlock, pInfo, pTaskInfo);
uint64_t tableGroupId = pBlock->info.id.groupId;
bool ascScan = (pInfo->binfo.inputTsOrder == TSDB_ORDER_ASC);
TSKEY ts = getStartTsKey(&pBlock->info.window, tsCols);
@@ -740,7 +740,7 @@ static bool hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul
// prev time window not interpolation yet.
if (pInfo->timeWindowInterpo) {
- SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId);
+ SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId, pTaskInfo);
doInterpUnclosedTimeWindow(pOperatorInfo, numOfOutput, pResultRowInfo, pBlock, scanFlag, tsCols, &pos);
// restore current time window
@@ -811,26 +811,36 @@ void doCloseWindow(SResultRowInfo* pResultRowInfo, const SIntervalAggOperatorInf
}
}
-SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult, uint64_t groupId) {
+SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult, uint64_t groupId, SExecTaskInfo* pTaskInfo) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SOpenWindowInfo openWin = {0};
openWin.pos.pageId = pResult->pageId;
openWin.pos.offset = pResult->offset;
openWin.groupId = groupId;
SListNode* pn = tdListGetTail(pResultRowInfo->openWindow);
if (pn == NULL) {
- tdListAppend(pResultRowInfo->openWindow, &openWin);
+ code = tdListAppend(pResultRowInfo->openWindow, &openWin);
+ QUERY_CHECK_CODE(code, lino, _end);
return openWin.pos;
}
SOpenWindowInfo* px = (SOpenWindowInfo*)pn->data;
if (px->pos.pageId != openWin.pos.pageId || px->pos.offset != openWin.pos.offset || px->groupId != openWin.groupId) {
- tdListAppend(pResultRowInfo->openWindow, &openWin);
+ code = tdListAppend(pResultRowInfo->openWindow, &openWin);
+ QUERY_CHECK_CODE(code, lino, _end);
}
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return openWin.pos;
}
-int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo) {
+int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo, SExecTaskInfo* pTaskInfo) {
TSKEY* tsCols = NULL;
if (pBlock->pDataBlock != NULL && pBlock->info.dataLoad) {
@@ -844,7 +854,12 @@ int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo
}
if (tsCols[0] != 0 && (pBlock->info.window.skey == 0 && pBlock->info.window.ekey == 0)) {
- blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex);
+ int32_t code = blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
}
}
@@ -856,6 +871,8 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) {
return TSDB_CODE_SUCCESS;
}
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
SOperatorInfo* downstream = pOperator->pDownstream[0];
@@ -875,11 +892,13 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) {
if (pInfo->scalarSupp.pExprInfo != NULL) {
SExprSupp* pExprSup = &pInfo->scalarSupp;
- projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+ code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
}
// the pDataBlock are always the same one, no need to call this again
- setInputDataBlock(pSup, pBlock, pInfo->binfo.inputTsOrder, scanFlag, true);
+ code = setInputDataBlock(pSup, pBlock, pInfo->binfo.inputTsOrder, scanFlag, true);
+ QUERY_CHECK_CODE(code, lino, _end);
if (hashIntervalAgg(pOperator, &pInfo->binfo.resultRowInfo, pBlock, scanFlag)) break;
}
@@ -887,7 +906,14 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) {
OPTR_SET_OPENED(pOperator);
pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0;
- return TSDB_CODE_SUCCESS;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
+ return code;
}
static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorInfo* pInfo, SSDataBlock* pBlock) {
@@ -979,6 +1005,8 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) {
return TSDB_CODE_SUCCESS;
}
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SStateWindowOperatorInfo* pInfo = pOperator->info;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
@@ -994,8 +1022,11 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) {
}
pInfo->binfo.pRes->info.scanFlag = pBlock->info.scanFlag;
- setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
- blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId);
+ code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId);
+ QUERY_CHECK_CODE(code, lino, _end);
// there is an scalar expression that needs to be calculated right before apply the group aggregation.
if (pInfo->scalarSup.pExprInfo != NULL) {
@@ -1013,7 +1044,13 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) {
initGroupedResultInfo(&pInfo->groupResInfo, pInfo->aggSup.pResultRowHashTable, TSDB_ORDER_ASC);
pOperator->status = OP_RES_TO_RETURN;
- return TSDB_CODE_SUCCESS;
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
+ return code;
}
static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator) {
@@ -1031,10 +1068,21 @@ static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator) {
return NULL;
}
- blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
+ int32_t code = blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
+
while (1) {
doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
- doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
if (!hasRemain) {
@@ -1067,7 +1115,12 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) {
while (1) {
doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
- doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ int32_t code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
if (!hasRemain) {
@@ -1086,32 +1139,6 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) {
return (rows == 0) ? NULL : pBlock;
}
-static void doClearWindowImpl(SResultRowPosition* p1, SDiskbasedBuf* pResultBuf, SExprSupp* pSup, int32_t numOfOutput) {
- SResultRow* pResult = getResultRowByPos(pResultBuf, p1, false);
- if (NULL == pResult) {
- return;
- }
-
- SqlFunctionCtx* pCtx = pSup->pCtx;
- for (int32_t i = 0; i < numOfOutput; ++i) {
- pCtx[i].resultInfo = getResultEntryInfo(pResult, i, pSup->rowEntryInfoOffset);
- struct SResultRowEntryInfo* pResInfo = pCtx[i].resultInfo;
- if (fmIsWindowPseudoColumnFunc(pCtx[i].functionId)) {
- continue;
- }
- pResInfo->initialized = false;
- if (pCtx[i].functionId != -1) {
- pCtx[i].fpSet.init(&pCtx[i], pResInfo);
- }
- }
- SFilePage* bufPage = getBufPage(pResultBuf, p1->pageId);
- if (NULL == bufPage) {
- return;
- }
- setBufPageDirty(bufPage, true);
- releaseBufPage(pResultBuf, bufPage);
-}
-
static void destroyStateWindowOperatorInfo(void* param) {
SStateWindowOperatorInfo* pInfo = (SStateWindowOperatorInfo*)param;
cleanupBasicInfo(&pInfo->binfo);
@@ -1135,7 +1162,7 @@ void destroyIntervalOperatorInfo(void* param) {
cleanupAggSup(&pInfo->aggSup);
cleanupExprSupp(&pInfo->scalarSupp);
- tdListFree(pInfo->binfo.resultRowInfo.openWindow);
+ (void)tdListFree(pInfo->binfo.resultRowInfo.openWindow);
taosArrayDestroy(pInfo->pInterpCols);
pInfo->pInterpCols = NULL;
@@ -1148,9 +1175,13 @@ void destroyIntervalOperatorInfo(void* param) {
taosMemoryFreeClear(param);
}
-static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SIntervalAggOperatorInfo* pInfo) {
+static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SIntervalAggOperatorInfo* pInfo,
+ SExecTaskInfo* pTaskInfo) {
// the primary timestamp column
- bool needed = false;
+ bool needed = false;
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ void* tmp = NULL;
for (int32_t i = 0; i < numOfCols; ++i) {
SExprInfo* pExpr = pCtx[i].pExpr;
@@ -1162,7 +1193,10 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt
if (needed) {
pInfo->pInterpCols = taosArrayInit(4, sizeof(SColumn));
+ QUERY_CHECK_NULL(pInfo->pInterpCols, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
pInfo->pPrevValues = taosArrayInit(4, sizeof(SGroupKeys));
+ QUERY_CHECK_NULL(pInfo->pPrevValues, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
{ // ts column
SColumn c = {0};
@@ -1170,14 +1204,18 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt
c.slotId = pInfo->primaryTsIndex;
c.type = TSDB_DATA_TYPE_TIMESTAMP;
c.bytes = sizeof(int64_t);
- taosArrayPush(pInfo->pInterpCols, &c);
+ tmp = taosArrayPush(pInfo->pInterpCols, &c);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
SGroupKeys key;
key.bytes = c.bytes;
key.type = c.type;
key.isNull = true; // to denote no value is assigned yet
key.pData = taosMemoryCalloc(1, c.bytes);
- taosArrayPush(pInfo->pPrevValues, &key);
+ QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+ tmp = taosArrayPush(pInfo->pPrevValues, &key);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
}
@@ -1188,17 +1226,27 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt
SFunctParam* pParam = &pExpr->base.pParam[0];
SColumn c = *pParam->pCol;
- taosArrayPush(pInfo->pInterpCols, &c);
+ tmp = taosArrayPush(pInfo->pInterpCols, &c);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
SGroupKeys key = {0};
key.bytes = c.bytes;
key.type = c.type;
key.isNull = false;
key.pData = taosMemoryCalloc(1, c.bytes);
- taosArrayPush(pInfo->pPrevValues, &key);
+ QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+ tmp = taosArrayPush(pInfo->pPrevValues, &key);
+ QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
}
}
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return needed;
}
@@ -1225,15 +1273,14 @@ int32_t createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode
size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
initResultSizeInfo(&pOperator->resultInfo, 512);
- blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _error);
int32_t num = 0;
SExprInfo* pExprInfo = createExprInfo(pPhyNode->window.pFuncs, NULL, &num);
code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState,
&pTaskInfo->storageAPI.functionStore);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
SInterval interval = {.interval = pPhyNode->interval,
.sliding = pPhyNode->sliding,
@@ -1282,7 +1329,7 @@ int32_t createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode
code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pInfo->win);
QUERY_CHECK_CODE(code, lino, _error);
- pInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, pInfo);
+ pInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, pInfo, pTaskInfo);
if (pInfo->timeWindowInterpo) {
pInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo));
if (pInfo->binfo.resultRowInfo.openWindow == NULL) {
@@ -1391,6 +1438,9 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
return NULL;
}
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
+ SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
SSessionAggOperatorInfo* pInfo = pOperator->info;
SOptrBasicInfo* pBInfo = &pInfo->binfo;
SExprSupp* pSup = &pOperator->exprSupp;
@@ -1398,7 +1448,8 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
if (pOperator->status == OP_RES_TO_RETURN) {
while (1) {
doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
- doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
if (!hasRemain) {
@@ -1428,11 +1479,15 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
pBInfo->pRes->info.scanFlag = pBlock->info.scanFlag;
if (pInfo->scalarSupp.pExprInfo != NULL) {
SExprSupp* pExprSup = &pInfo->scalarSupp;
- projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+ code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
}
// the pDataBlock are always the same one, no need to call this again
- setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
- blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId);
+ code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
+ QUERY_CHECK_CODE(code, lino, _end);
+
+ code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId);
+ QUERY_CHECK_CODE(code, lino, _end);
doSessionWindowAggImpl(pOperator, pInfo, pBlock);
}
@@ -1443,10 +1498,12 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
pOperator->status = OP_RES_TO_RETURN;
initGroupedResultInfo(&pInfo->groupResInfo, pInfo->aggSup.pResultRowHashTable, TSDB_ORDER_ASC);
- blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _end);
while (1) {
doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
- doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
if (!hasRemain) {
@@ -1459,6 +1516,13 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
}
}
pOperator->resultInfo.totalRows += pBInfo->pRes->info.rows;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return (pBInfo->pRes->info.rows == 0) ? NULL : pBInfo->pRes;
}
@@ -1591,7 +1655,7 @@ int32_t createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPh
initBasicInfo(&pInfo->binfo, pResBlock);
code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str,
- pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore);
+ pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore);
if (code != TSDB_CODE_SUCCESS) {
goto _error;
}
@@ -1684,7 +1748,7 @@ static void doMergeAlignedIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultR
SInterval* pInterval = &iaInfo->interval;
int32_t startPos = 0;
- int64_t* tsCols = extractTsCol(pBlock, iaInfo);
+ int64_t* tsCols = extractTsCol(pBlock, iaInfo, pTaskInfo);
TSKEY ts = getStartTsKey(&pBlock->info.window, tsCols);
@@ -1748,8 +1812,9 @@ static void cleanupAfterGroupResultGen(SMergeAlignedIntervalAggOperatorInfo* pMi
}
static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
- SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
-
+ SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SMergeAlignedIntervalAggOperatorInfo* pMiaInfo = pOperator->info;
SIntervalAggOperatorInfo* pIaInfo = pMiaInfo->intervalAggOperatorInfo;
@@ -1776,7 +1841,8 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo);
resetResultRow(pMiaInfo->pResultRow, pIaInfo->aggSup.resultRowSize - sizeof(SResultRow));
cleanupAfterGroupResultGen(pMiaInfo, pRes);
- doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
}
setOperatorCompleted(pOperator);
@@ -1797,7 +1863,8 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
pMiaInfo->prefetchedBlock = pBlock;
cleanupAfterGroupResultGen(pMiaInfo, pRes);
- doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
break;
} else {
// continue
@@ -1806,14 +1873,25 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
}
pRes->info.scanFlag = pBlock->info.scanFlag;
- setInputDataBlock(pSup, pBlock, pIaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true);
+ code = setInputDataBlock(pSup, pBlock, pIaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true);
+ QUERY_CHECK_CODE(code, lino, _end);
+
doMergeAlignedIntervalAggImpl(pOperator, &pIaInfo->binfo.resultRowInfo, pBlock, pRes);
- doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+ QUERY_CHECK_CODE(code, lino, _end);
+
if (pRes->info.rows >= pOperator->resultInfo.capacity) {
break;
}
}
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
}
static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
@@ -1880,9 +1958,7 @@ int32_t createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMerge
pSup->hasWindowOrGroup = true;
code = filterInitFromNode((SNode*)pNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
miaInfo->curTs = INT64_MIN;
iaInfo->win = pTaskInfo->window;
@@ -1900,22 +1976,21 @@ int32_t createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMerge
code = initAggSup(&pOperator->exprSupp, &iaInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str,
pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
SSDataBlock* pResBlock = createDataBlockFromDescNode(pNode->window.node.pOutputDataBlockDesc);
initBasicInfo(&iaInfo->binfo, pResBlock);
code = initExecTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &iaInfo->win);
QUERY_CHECK_CODE(code, lino, _error);
- iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo);
+ iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo, pTaskInfo);
if (iaInfo->timeWindowInterpo) {
iaInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo));
}
initResultRowInfo(&iaInfo->binfo.resultRowInfo);
- blockDataEnsureCapacity(iaInfo->binfo.pRes, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(iaInfo->binfo.pRes, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _error);
setOperatorInfo(pOperator, "TimeMergeAlignedIntervalAggOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL,
false, OP_NOT_OPENED, miaInfo, pTaskInfo);
@@ -1923,9 +1998,7 @@ int32_t createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMerge
optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
code = appendDownstream(pOperator, &downstream, 1);
- if (code != TSDB_CODE_SUCCESS) {
- goto _error;
- }
+ QUERY_CHECK_CODE(code, lino, _error);
*pOptrInfo = pOperator;
return code;
@@ -1956,7 +2029,7 @@ typedef struct SGroupTimeWindow {
void destroyMergeIntervalOperatorInfo(void* param) {
SMergeIntervalAggOperatorInfo* miaInfo = (SMergeIntervalAggOperatorInfo*)param;
- tdListFree(miaInfo->groupIntervals);
+ (void)tdListFree(miaInfo->groupIntervals);
destroyIntervalOperatorInfo(&miaInfo->intervalAggOperatorInfo);
taosMemoryFreeClear(param);
@@ -1969,7 +2042,11 @@ static int32_t outputPrevIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t t
bool ascScan = (iaInfo->binfo.inputTsOrder == TSDB_ORDER_ASC);
SGroupTimeWindow groupTimeWindow = {.groupId = tableGroupId, .window = *newWin};
- tdListAppend(miaInfo->groupIntervals, &groupTimeWindow);
+ int32_t code = tdListAppend(miaInfo->groupIntervals, &groupTimeWindow);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ return code;
+ }
SListIter iter = {0};
tdListInitIter(miaInfo->groupIntervals, &iter, TD_LIST_FORWARD);
@@ -1982,11 +2059,11 @@ static int32_t outputPrevIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t t
STimeWindow* prevWin = &prevGrpWin->window;
if ((ascScan && newWin->skey > prevWin->ekey) || ((!ascScan) && newWin->skey < prevWin->ekey)) {
- tdListPopNode(miaInfo->groupIntervals, listNode);
+ (void)tdListPopNode(miaInfo->groupIntervals, listNode);
}
}
- return 0;
+ return TSDB_CODE_SUCCESS;
}
static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResultRowInfo, SSDataBlock* pBlock,
@@ -1999,7 +2076,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
int32_t startPos = 0;
int32_t numOfOutput = pExprSup->numOfExprs;
- int64_t* tsCols = extractTsCol(pBlock, iaInfo);
+ int64_t* tsCols = extractTsCol(pBlock, iaInfo, pTaskInfo);
uint64_t tableGroupId = pBlock->info.id.groupId;
bool ascScan = (iaInfo->binfo.inputTsOrder == TSDB_ORDER_ASC);
TSKEY blockStartTs = getStartTsKey(&pBlock->info.window, tsCols);
@@ -2022,7 +2099,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
// prev time window not interpolation yet.
if (iaInfo->timeWindowInterpo) {
- SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId);
+ SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId, pTaskInfo);
doInterpUnclosedTimeWindow(pOperatorInfo, numOfOutput, pResultRowInfo, pBlock, scanFlag, tsCols, &pos);
// restore current time window
@@ -2042,7 +2119,11 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
doCloseWindow(pResultRowInfo, iaInfo, pResult);
// output previous interval results after this interval (&win) is closed
- outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &win);
+ int32_t code = outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &win);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+ }
STimeWindow nextWin = win;
while (1) {
@@ -2054,7 +2135,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
}
// null data, failed to allocate more memory buffer
- int32_t code =
+ code =
setTimeWindowOutputBuf(pResultRowInfo, &nextWin, (scanFlag == MAIN_SCAN), &pResult, tableGroupId,
pExprSup->pCtx, numOfOutput, pExprSup->rowEntryInfoOffset, &iaInfo->aggSup, pTaskInfo);
if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
@@ -2074,7 +2155,11 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
doCloseWindow(pResultRowInfo, iaInfo, pResult);
// output previous interval results after this interval (&nextWin) is closed
- outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &nextWin);
+ code = outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &nextWin);
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+ T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+ }
}
if (iaInfo->timeWindowInterpo) {
@@ -2083,6 +2168,8 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
}
static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
+ int32_t code = TSDB_CODE_SUCCESS;
+ int32_t lino = 0;
SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
SMergeIntervalAggOperatorInfo* miaInfo = pOperator->info;
@@ -2095,7 +2182,8 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
SSDataBlock* pRes = iaInfo->binfo.pRes;
blockDataCleanup(pRes);
- blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity);
+ code = blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity);
+ QUERY_CHECK_CODE(code, lino, _end);
if (!miaInfo->inputBlocksFinished) {
SOperatorInfo* downstream = pOperator->pDownstream[0];
@@ -2124,7 +2212,9 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
}
pRes->info.scanFlag = pBlock->info.scanFlag;
- setInputDataBlock(pExpSupp, pBlock, iaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true);
+ code = setInputDataBlock(pExpSupp, pBlock, iaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true);
+ QUERY_CHECK_CODE(code, lino, _end);
+
doMergeIntervalAggImpl(pOperator, &iaInfo->binfo.resultRowInfo, pBlock, pBlock->info.scanFlag, pRes);
if (pRes->info.rows >= pOperator->resultInfo.threshold) {
@@ -2150,6 +2240,13 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
size_t rows = pRes->info.rows;
pOperator->resultInfo.totalRows += rows;
+
+_end:
+ if (code != TSDB_CODE_SUCCESS) {
+ qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+ pTaskInfo->code = code;
+ T_LONG_JMP(pTaskInfo->env, code);
+ }
return (rows == 0) ? NULL : pRes;
}
@@ -2203,7 +2300,7 @@ int32_t createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeInterva
code = initExecTimeWindowInfo(&pIntervalInfo->twAggSup.timeWindowData, &pIntervalInfo->win);
QUERY_CHECK_CODE(code, lino, _error);
- pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo);
+ pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo, pTaskInfo);
if (pIntervalInfo->timeWindowInterpo) {
pIntervalInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo));
if (pIntervalInfo->binfo.resultRowInfo.openWindow == NULL) {
diff --git a/source/libs/executor/test/timewindowTest.cpp b/source/libs/executor/test/timewindowTest.cpp
index 7ccbf0b10f..211dce606e 100644
--- a/source/libs/executor/test/timewindowTest.cpp
+++ b/source/libs/executor/test/timewindowTest.cpp
@@ -52,7 +52,7 @@ void printTimeWindow(STimeWindow* pWindow, int8_t precision, int64_t ts) {
taosFormatUtcTime(bufs, tListLen(bufs), pWindow->skey, precision);
taosFormatUtcTime(bufe, tListLen(bufe), pWindow->ekey, precision);
- printf("%s [%s - %s]\n", buf, bufs, bufe);
+ (void)printf("%s [%s - %s]\n", buf, bufs, bufe);
}
} // namespace
@@ -71,26 +71,26 @@ TEST(testCase, timewindow_gen) {
printTimeWindow(&w, precision, key);
getNextTimeWindow(&interval, &w, TSDB_ORDER_ASC);
- printf("next\n");
+ (void)printf("next\n");
printTimeWindow(&w, precision, key);
- printf("---------------------------------------------------\n");
+ (void)printf("---------------------------------------------------\n");
SInterval monthInterval =
createInterval(1, 1, 0, 'n', 'n', 'd', TSDB_TIME_PRECISION_MILLI);
getInitialStartTimeWindow(&monthInterval, key, &w, true);
printTimeWindow(&w, precision, key);
getNextTimeWindow(&monthInterval, &w, TSDB_ORDER_ASC);
- printf("next\n");
+ (void)printf("next\n");
printTimeWindow(&w, precision, key);
- printf("----------------------------------------------------------\n");
+ (void)printf("----------------------------------------------------------\n");
SInterval slidingInterval = createInterval(1, 10*86400*1000, 0, 'n', 'd', 'd', TSDB_TIME_PRECISION_MILLI);
getInitialStartTimeWindow(&slidingInterval, key, &w, true);
printTimeWindow(&w, precision, key);
getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC);
- printf("next\n");
+ (void)printf("next\n");
printTimeWindow(&w, precision, key);
getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC);
@@ -114,13 +114,13 @@ TEST(testCase, timewindow_gen) {
getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC);
printTimeWindow(&w, precision, key);
- printf("-----------------calendar_interval_1n_sliding_1d-------\n");
+ (void)printf("-----------------calendar_interval_1n_sliding_1d-------\n");
SInterval calendar_interval_1n = createInterval(1, 1*86400*1000, 0, 'n', 'd', 'd', TSDB_TIME_PRECISION_MILLI);
int64_t k1 = 1664409600 * 1000L;
getInitialStartTimeWindow(&calendar_interval_1n, k1, &w, true);
printTimeWindow(&w, precision, k1);
- printf("next\n");
+ (void)printf("next\n");
getNextTimeWindow(&calendar_interval_1n, &w, TSDB_ORDER_ASC);
printTimeWindow(&w, precision, key);
@@ -134,14 +134,14 @@ TEST(testCase, timewindow_gen) {
getNextTimeWindow(&calendar_interval_1n, &w, TSDB_ORDER_ASC);
printTimeWindow(&w, precision, key);
- printf("----------------interval_1d_clendar_sliding_1n---------\n");
+ (void)printf("----------------interval_1d_clendar_sliding_1n---------\n");
SInterval interval_1d_calendar_sliding_1n = createInterval(1*86400*1000L, 1, 0, 'd', 'n', 'd', TSDB_TIME_PRECISION_MILLI);
k1 = 1664409600 * 1000L;
getInitialStartTimeWindow(&interval_1d_calendar_sliding_1n, k1, &w, true);
printTimeWindow(&w, precision, k1);
- printf("next time window:\n");
+ (void)printf("next time window:\n");
getNextTimeWindow(&interval_1d_calendar_sliding_1n, &w, TSDB_ORDER_ASC);
printTimeWindow(&w, precision, k1);
@@ -151,7 +151,7 @@ TEST(testCase, timewindow_gen) {
getNextTimeWindow(&interval_1d_calendar_sliding_1n, &w, TSDB_ORDER_ASC);
printTimeWindow(&w, precision, k1);
- printf("----------------interval_1d_sliding_1d_calendar_offset_1n---------\n");
+ (void)printf("----------------interval_1d_sliding_1d_calendar_offset_1n---------\n");
SInterval offset_1n = createInterval(10*86400*1000L, 10*86400*1000L, 1, 'd', 'd', 'n', TSDB_TIME_PRECISION_MILLI);
getInitialStartTimeWindow(&offset_1n, k1, &w, true);
printTimeWindow(&w, precision, k1);
@@ -175,14 +175,14 @@ TEST(testCase, timewindow_natural) {
getInitialStartTimeWindow(&interval2, key1, &w1, true);
printTimeWindow(&w1, precision, key1);
STimeWindow w3 = getAlignQueryTimeWindow(&interval2, key1);
- printf("%ld win %ld, %ld\n", key1, w3.skey, w3.ekey);
+ (void)printf("%ld win %ld, %ld\n", key1, w3.skey, w3.ekey);
int64_t key2 = 1648758398208;
STimeWindow w2 = {0};
getInitialStartTimeWindow(&interval2, key2, &w2, true);
printTimeWindow(&w2, precision, key2);
STimeWindow w4 = getAlignQueryTimeWindow(&interval2, key2);
- printf("%ld win %ld, %ld\n", key2, w3.skey, w3.ekey);
+ (void)printf("%ld win %ld, %ld\n", key2, w3.skey, w3.ekey);
ASSERT_EQ(w3.skey, w4.skey);
ASSERT_EQ(w3.ekey, w4.ekey);
@@ -199,7 +199,7 @@ TEST(testCase, timewindow_active) {
int64_t key = (int64_t)1609430400*1000; // 2021-01-01
STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, key, &interval, TSDB_ORDER_ASC);
printTimeWindow(&win, precision, key);
- printf("%ld win %ld, %ld\n", key, win.skey, win.ekey);
+ (void)printf("%ld win %ld, %ld\n", key, win.skey, win.ekey);
ASSERT_EQ(win.skey, 1325376000000);
ASSERT_EQ(win.ekey, 1640908799999);
}
diff --git a/source/libs/function/inc/builtinsimpl.h b/source/libs/function/inc/builtinsimpl.h
index b48a617b9c..274ef61feb 100644
--- a/source/libs/function/inc/builtinsimpl.h
+++ b/source/libs/function/inc/builtinsimpl.h
@@ -49,9 +49,9 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc, int32_t* nElems)
int32_t saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos);
int32_t updateTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos);
-const char* loadTupleData(SqlFunctionCtx* pCtx, const STuplePos* pPos);
+int32_t loadTupleData(SqlFunctionCtx* pCtx, const STuplePos* pPos, char** value);
-bool functionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t functionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t functionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
int32_t functionFinalizeWithResultBuf(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, char* finalResult);
int32_t combineFunction(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
@@ -74,7 +74,7 @@ int32_t sumInvertFunction(SqlFunctionCtx* pCtx);
int32_t sumCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
-bool minmaxFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t minmaxFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
bool getMinmaxFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
int32_t minFunction(SqlFunctionCtx* pCtx);
int32_t maxFunction(SqlFunctionCtx* pCtx);
@@ -83,7 +83,7 @@ int32_t minCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
int32_t maxCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
bool getAvgFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool avgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t avgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t avgFunction(SqlFunctionCtx* pCtx);
int32_t avgFunctionMerge(SqlFunctionCtx* pCtx);
int32_t avgFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -97,7 +97,7 @@ int32_t avgCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
int32_t getAvgInfoSize();
bool getStddevFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool stddevFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t stddevFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t stddevFunction(SqlFunctionCtx* pCtx);
int32_t stddevFunctionMerge(SqlFunctionCtx* pCtx);
int32_t stddevFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -111,18 +111,18 @@ int32_t stddevCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
int32_t getStddevInfoSize();
bool getLeastSQRFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool leastSQRFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t leastSQRFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t leastSQRFunction(SqlFunctionCtx* pCtx);
int32_t leastSQRFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
int32_t leastSQRCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
bool getPercentileFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool percentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t percentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t percentileFunction(SqlFunctionCtx* pCtx);
int32_t percentileFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
bool getApercentileFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t apercentileFunction(SqlFunctionCtx* pCtx);
int32_t apercentileFunctionMerge(SqlFunctionCtx* pCtx);
int32_t apercentileFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -131,16 +131,16 @@ int32_t apercentileCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx)
int32_t getApercentileMaxSize();
bool getDiffFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool diffFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo);
+int32_t diffFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo);
int32_t diffFunction(SqlFunctionCtx* pCtx);
int32_t diffFunctionByRow(SArray* pCtx);
bool getDerivativeFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool derivativeFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo);
+int32_t derivativeFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo);
int32_t derivativeFunction(SqlFunctionCtx* pCtx);
bool getIrateFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool irateFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo);
+int32_t irateFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo);
int32_t irateFunction(SqlFunctionCtx* pCtx);
int32_t irateFunctionMerge(SqlFunctionCtx* pCtx);
int32_t irateFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -165,7 +165,7 @@ EFuncDataRequired lastDynDataReq(void* pRes, SDataBlockInfo* pBlockInfo);
int32_t lastRowFunction(SqlFunctionCtx* pCtx);
bool getTopBotFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv);
-bool topBotFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t topBotFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t topFunction(SqlFunctionCtx* pCtx);
int32_t bottomFunction(SqlFunctionCtx* pCtx);
int32_t topBotFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -174,7 +174,7 @@ int32_t bottomCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
int32_t getTopBotInfoSize(int64_t numOfItems);
bool getSpreadFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool spreadFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t spreadFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t spreadFunction(SqlFunctionCtx* pCtx);
int32_t spreadFunctionMerge(SqlFunctionCtx* pCtx);
int32_t spreadFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -183,7 +183,7 @@ int32_t getSpreadInfoSize();
int32_t spreadCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
bool getElapsedFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool elapsedFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t elapsedFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t elapsedFunction(SqlFunctionCtx* pCtx);
int32_t elapsedFunctionMerge(SqlFunctionCtx* pCtx);
int32_t elapsedFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
@@ -192,7 +192,7 @@ int32_t getElapsedInfoSize();
int32_t elapsedCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
bool getHistogramFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool histogramFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t histogramFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t histogramFunction(SqlFunctionCtx* pCtx);
int32_t histogramFunctionPartial(SqlFunctionCtx* pCtx);
int32_t histogramFunctionMerge(SqlFunctionCtx* pCtx);
@@ -210,7 +210,7 @@ int32_t getHLLInfoSize();
int32_t hllCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx);
bool getStateFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool stateFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t stateFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t stateCountFunction(SqlFunctionCtx* pCtx);
int32_t stateDurationFunction(SqlFunctionCtx* pCtx);
@@ -218,35 +218,35 @@ bool getCsumFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
int32_t csumFunction(SqlFunctionCtx* pCtx);
bool getMavgFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool mavgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t mavgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t mavgFunction(SqlFunctionCtx* pCtx);
bool getSampleFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool sampleFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t sampleFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t sampleFunction(SqlFunctionCtx* pCtx);
int32_t sampleFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
bool getTailFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool tailFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t tailFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t tailFunction(SqlFunctionCtx* pCtx);
bool getUniqueFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool uniqueFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t uniqueFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t uniqueFunction(SqlFunctionCtx* pCtx);
bool getModeFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool modeFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t modeFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t modeFunction(SqlFunctionCtx* pCtx);
int32_t modeFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
bool getTwaFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool twaFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t twaFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t twaFunction(SqlFunctionCtx* pCtx);
int32_t twaFinalize(struct SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
bool getSelectivityFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv);
-bool blockDistSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
+int32_t blockDistSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo);
int32_t blockDistFunction(SqlFunctionCtx* pCtx);
int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock);
diff --git a/source/libs/function/inc/tfunctionInt.h b/source/libs/function/inc/tfunctionInt.h
index b4c48abf37..8d9e42576d 100644
--- a/source/libs/function/inc/tfunctionInt.h
+++ b/source/libs/function/inc/tfunctionInt.h
@@ -37,7 +37,7 @@ static FORCE_INLINE void initResultRowEntry(SResultRowEntryInfo *pResInfo, int32
pResInfo->complete = false;
pResInfo->numOfRes = 0;
- memset(GET_ROWCELL_INTERBUF(pResInfo), 0, bufLen);
+ (void)memset(GET_ROWCELL_INTERBUF(pResInfo), 0, bufLen);
}
#ifdef __cplusplus
diff --git a/source/libs/function/inc/thistogram.h b/source/libs/function/inc/thistogram.h
index 20111086cd..5bc6a87c70 100644
--- a/source/libs/function/inc/thistogram.h
+++ b/source/libs/function/inc/thistogram.h
@@ -55,14 +55,15 @@ typedef struct SHistogramInfo {
#endif
} SHistogramInfo;
-SHistogramInfo* tHistogramCreate(int32_t numOfBins);
+int32_t tHistogramCreate(int32_t numOfEntries, SHistogramInfo** pHisto);
SHistogramInfo* tHistogramCreateFrom(void* pBuf, int32_t numOfBins);
int32_t tHistogramAdd(SHistogramInfo** pHisto, double val);
int64_t tHistogramSum(SHistogramInfo* pHisto, double v);
-double* tHistogramUniform(SHistogramInfo* pHisto, double* ratio, int32_t num);
-SHistogramInfo* tHistogramMerge(SHistogramInfo* pHisto1, SHistogramInfo* pHisto2, int32_t numOfEntries);
+int32_t tHistogramUniform(SHistogramInfo* pHisto, double* ratio, int32_t num, double** pVal);
+int32_t tHistogramMerge(SHistogramInfo* pHisto1, SHistogramInfo* pHisto2, int32_t numOfEntries,
+ SHistogramInfo** pResHistogram);
void tHistogramDestroy(SHistogramInfo** pHisto);
void tHistogramPrint(SHistogramInfo* pHisto);
diff --git a/source/libs/function/inc/tpercentile.h b/source/libs/function/inc/tpercentile.h
index 34815a34ad..90fb279259 100644
--- a/source/libs/function/inc/tpercentile.h
+++ b/source/libs/function/inc/tpercentile.h
@@ -67,7 +67,8 @@ typedef struct tMemBucket {
SHashObj *groupPagesMap; // disk page map for different groups;
} tMemBucket;
-tMemBucket *tMemBucketCreate(int32_t nElemSize, int16_t dataType, double minval, double maxval, bool hasWindowOrGroup);
+int32_t tMemBucketCreate(int32_t nElemSize, int16_t dataType, double minval, double maxval, bool hasWindowOrGroup,
+ tMemBucket **pBucket);
void tMemBucketDestroy(tMemBucket *pBucket);
diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c
index f5c98933fd..9c57c682cf 100644
--- a/source/libs/function/src/builtins.c
+++ b/source/libs/function/src/builtins.c
@@ -25,7 +25,7 @@
static int32_t buildFuncErrMsg(char* pErrBuf, int32_t len, int32_t errCode, const char* pFormat, ...) {
va_list vArgList;
va_start(vArgList, pFormat);
- vsnprintf(pErrBuf, len, pFormat, vArgList);
+ (void)vsnprintf(pErrBuf, len, pFormat, vArgList);
va_end(vArgList);
return errCode;
}
@@ -42,27 +42,24 @@ static int32_t invaildFuncParaValueErrMsg(char* pErrBuf, int32_t len, const char
return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_PARA_VALUE, "Invalid parameter value : %s", pFuncName);
}
-#define TIME_UNIT_INVALID 1
-#define TIME_UNIT_TOO_SMALL 2
-
static int32_t validateTimeUnitParam(uint8_t dbPrec, const SValueNode* pVal) {
if (!IS_DURATION_VAL(pVal->flag)) {
- return TIME_UNIT_INVALID;
+ return TSDB_CODE_FUNC_TIME_UNIT_INVALID;
}
if (TSDB_TIME_PRECISION_MILLI == dbPrec &&
(0 == strcasecmp(pVal->literal, "1u") || 0 == strcasecmp(pVal->literal, "1b"))) {
- return TIME_UNIT_TOO_SMALL;
+ return TSDB_CODE_FUNC_TIME_UNIT_TOO_SMALL;
}
if (TSDB_TIME_PRECISION_MICRO == dbPrec && 0 == strcasecmp(pVal->literal, "1b")) {
- return TIME_UNIT_TOO_SMALL;
+ return TSDB_CODE_FUNC_TIME_UNIT_TOO_SMALL;
}
if (pVal->literal[0] != '1' ||
(pVal->literal[1] != 'u' && pVal->literal[1] != 'a' && pVal->literal[1] != 's' && pVal->literal[1] != 'm' &&
pVal->literal[1] != 'h' && pVal->literal[1] != 'd' && pVal->literal[1] != 'w' && pVal->literal[1] != 'b')) {
- return TIME_UNIT_INVALID;
+ return TSDB_CODE_FUNC_TIME_UNIT_INVALID;
}
return TSDB_CODE_SUCCESS;
@@ -138,13 +135,13 @@ static bool validateTimezoneFormat(const SValueNode* pVal) {
}
if (i == 2) {
- memcpy(buf, &tz[i - 1], 2);
+ (void)memcpy(buf, &tz[i - 1], 2);
hour = taosStr2Int8(buf, NULL, 10);
if (!validateHourRange(hour)) {
return false;
}
} else if (i == 4) {
- memcpy(buf, &tz[i - 1], 2);
+ (void)memcpy(buf, &tz[i - 1], 2);
minute = taosStr2Int8(buf, NULL, 10);
if (!validateMinuteRange(hour, minute, tz[0])) {
return false;
@@ -167,13 +164,13 @@ static bool validateTimezoneFormat(const SValueNode* pVal) {
}
if (i == 2) {
- memcpy(buf, &tz[i - 1], 2);
+ (void)memcpy(buf, &tz[i - 1], 2);
hour = taosStr2Int8(buf, NULL, 10);
if (!validateHourRange(hour)) {
return false;
}
} else if (i == 5) {
- memcpy(buf, &tz[i - 1], 2);
+ (void)memcpy(buf, &tz[i - 1], 2);
minute = taosStr2Int8(buf, NULL, 10);
if (!validateMinuteRange(hour, minute, tz[0])) {
return false;
@@ -215,7 +212,7 @@ static int32_t addTimezoneParam(SNodeList* pList) {
time_t t = taosTime(NULL);
struct tm tmInfo;
if (taosLocalTime(&t, &tmInfo, buf) != NULL) {
- strftime(buf, sizeof(buf), "%z", &tmInfo);
+ (void)strftime(buf, sizeof(buf), "%z", &tmInfo);
}
int32_t len = (int32_t)strlen(buf);
@@ -225,15 +222,27 @@ static int32_t addTimezoneParam(SNodeList* pList) {
}
pVal->literal = strndup(buf, len);
+ if (pVal->literal == NULL) {
+ nodesDestroyNode((SNode*)pVal);
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
pVal->translate = true;
pVal->node.resType.type = TSDB_DATA_TYPE_BINARY;
pVal->node.resType.bytes = len + VARSTR_HEADER_SIZE;
pVal->node.resType.precision = TSDB_TIME_PRECISION_MILLI;
pVal->datum.p = taosMemoryCalloc(1, len + VARSTR_HEADER_SIZE + 1);
+ if (pVal->datum.p == NULL) {
+ nodesDestroyNode((SNode*)pVal);
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
varDataSetLen(pVal->datum.p, len);
- strncpy(varDataVal(pVal->datum.p), pVal->literal, len);
+ (void)strncpy(varDataVal(pVal->datum.p), pVal->literal, len);
- nodesListAppend(pList, (SNode*)pVal);
+ int32_t code = nodesListAppend(pList, (SNode*)pVal);
+ if (TSDB_CODE_SUCCESS != code) {
+ nodesDestroyNode((SNode*)pVal);
+ return code;
+ }
return TSDB_CODE_SUCCESS;
}
@@ -252,7 +261,11 @@ static int32_t addDbPrecisonParam(SNodeList** pList, uint8_t precision) {
pVal->datum.i = (int64_t)precision;
pVal->typeData = (int64_t)precision;
- nodesListMakeAppend(pList, (SNode*)pVal);
+ int32_t code = nodesListMakeAppend(pList, (SNode*)pVal);
+ if (TSDB_CODE_SUCCESS != code) {
+ nodesDestroyNode((SNode*)pVal);
+ return code;
+ }
return TSDB_CODE_SUCCESS;
}
@@ -936,13 +949,13 @@ static int32_t translateElapsed(SFunctionNode* pFunc, char* pErrBuf, int32_t len
uint8_t dbPrec = pFunc->node.resType.precision;
- int32_t ret = validateTimeUnitParam(dbPrec, (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1));
- if (ret == TIME_UNIT_TOO_SMALL) {
- return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
+ int32_t code = validateTimeUnitParam(dbPrec, (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1));
+ if (code == TSDB_CODE_FUNC_TIME_UNIT_TOO_SMALL) {
+ return buildFuncErrMsg(pErrBuf, len, code,
"ELAPSED function time unit parameter should be greater than db precision");
- } else if (ret == TIME_UNIT_INVALID) {
+ } else if (code == TSDB_CODE_FUNC_TIME_UNIT_INVALID) {
return buildFuncErrMsg(
- pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
+ pErrBuf, len, code,
"ELAPSED function time unit parameter should be one of the following: [1b, 1u, 1a, 1s, 1m, 1h, 1d, 1w]");
}
}
@@ -1062,7 +1075,7 @@ static int8_t validateHistogramBinType(char* binTypeStr) {
return binType;
}
-static bool validateHistogramBinDesc(char* binDescStr, int8_t binType, char* errMsg, int32_t msgLen) {
+static int32_t validateHistogramBinDesc(char* binDescStr, int8_t binType, char* errMsg, int32_t msgLen) {
const char* msg1 = "HISTOGRAM function requires four parameters";
const char* msg3 = "HISTOGRAM function invalid format for binDesc parameter";
const char* msg4 = "HISTOGRAM function binDesc parameter \"count\" should be in range [1, 1000]";
@@ -1070,6 +1083,7 @@ static bool validateHistogramBinDesc(char* binDescStr, int8_t binType, char* err
const char* msg6 = "HISTOGRAM function binDesc parameter \"width\" cannot be 0";
const char* msg7 = "HISTOGRAM function binDesc parameter \"start\" cannot be 0 with \"log_bin\" type";
const char* msg8 = "HISTOGRAM function binDesc parameter \"factor\" cannot be negative or equal to 0/1";
+ const char* msg9 = "HISTOGRAM function out of memory";
cJSON* binDesc = cJSON_Parse(binDescStr);
int32_t numOfBins;
@@ -1078,9 +1092,9 @@ static bool validateHistogramBinDesc(char* binDescStr, int8_t binType, char* err
int32_t numOfParams = cJSON_GetArraySize(binDesc);
int32_t startIndex;
if (numOfParams != 4) {
- snprintf(errMsg, msgLen, "%s", msg1);
+ (void)snprintf(errMsg, msgLen, "%s", msg1);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
cJSON* start = cJSON_GetObjectItem(binDesc, "start");
@@ -1090,22 +1104,22 @@ static bool validateHistogramBinDesc(char* binDescStr, int8_t binType, char* err
cJSON* infinity = cJSON_GetObjectItem(binDesc, "infinity");
if (!cJSON_IsNumber(start) || !cJSON_IsNumber(count) || !cJSON_IsBool(infinity)) {
- snprintf(errMsg, msgLen, "%s", msg3);
+ (void)snprintf(errMsg, msgLen, "%s", msg3);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
if (count->valueint <= 0 || count->valueint > 1000) { // limit count to 1000
- snprintf(errMsg, msgLen, "%s", msg4);
+ (void)snprintf(errMsg, msgLen, "%s", msg4);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
if (isinf(start->valuedouble) || (width != NULL && isinf(width->valuedouble)) ||
(factor != NULL && isinf(factor->valuedouble)) || (count != NULL && isinf(count->valuedouble))) {
- snprintf(errMsg, msgLen, "%s", msg5);
+ (void)snprintf(errMsg, msgLen, "%s", msg5);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
int32_t counter = (int32_t)count->valueint;
@@ -1118,53 +1132,58 @@ static bool validateHistogramBinDesc(char* binDescStr, int8_t binType, char* err
}
intervals = taosMemoryCalloc(numOfBins, sizeof(double));
+ if (intervals == NULL) {
+ (void)snprintf(errMsg, msgLen, "%s", msg9);
+ cJSON_Delete(binDesc);
+ return TSDB_CODE_FAILED;
+ }
if (cJSON_IsNumber(width) && factor == NULL && binType == LINEAR_BIN) {
// linear bin process
if (width->valuedouble == 0) {
- snprintf(errMsg, msgLen, "%s", msg6);
+ (void)snprintf(errMsg, msgLen, "%s", msg6);
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
for (int i = 0; i < counter + 1; ++i) {
intervals[startIndex] = start->valuedouble + i * width->valuedouble;
if (isinf(intervals[startIndex])) {
- snprintf(errMsg, msgLen, "%s", msg5);
+ (void)snprintf(errMsg, msgLen, "%s", msg5);
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
startIndex++;
}
} else if (cJSON_IsNumber(factor) && width == NULL && binType == LOG_BIN) {
// log bin process
if (start->valuedouble == 0) {
- snprintf(errMsg, msgLen, "%s", msg7);
+ (void)snprintf(errMsg, msgLen, "%s", msg7);
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
if (factor->valuedouble < 0 || factor->valuedouble == 0 || factor->valuedouble == 1) {
- snprintf(errMsg, msgLen, "%s", msg8);
+ (void)snprintf(errMsg, msgLen, "%s", msg8);
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
for (int i = 0; i < counter + 1; ++i) {
intervals[startIndex] = start->valuedouble * pow(factor->valuedouble, i * 1.0);
if (isinf(intervals[startIndex])) {
- snprintf(errMsg, msgLen, "%s", msg5);
+ (void)snprintf(errMsg, msgLen, "%s", msg5);
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
startIndex++;
}
} else {
- snprintf(errMsg, msgLen, "%s", msg3);
+ (void)snprintf(errMsg, msgLen, "%s", msg3);
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
if (infinity->valueint == true) {
@@ -1172,7 +1191,7 @@ static bool validateHistogramBinDesc(char* binDescStr, int8_t binType, char* err
intervals[numOfBins - 1] = INFINITY;
// in case of desc bin orders, -inf/inf should be swapped
if (numOfBins < 4) {
- return false;
+ return TSDB_CODE_FAILED;
}
if (intervals[1] > intervals[numOfBins - 2]) {
@@ -1181,46 +1200,51 @@ static bool validateHistogramBinDesc(char* binDescStr, int8_t binType, char* err
}
} else if (cJSON_IsArray(binDesc)) { /* user input bins */
if (binType != USER_INPUT_BIN) {
- snprintf(errMsg, msgLen, "%s", msg3);
+ (void)snprintf(errMsg, msgLen, "%s", msg3);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
numOfBins = cJSON_GetArraySize(binDesc);
intervals = taosMemoryCalloc(numOfBins, sizeof(double));
+ if (intervals == NULL) {
+ (void)snprintf(errMsg, msgLen, "%s", msg9);
+ cJSON_Delete(binDesc);
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
cJSON* bin = binDesc->child;
if (bin == NULL) {
- snprintf(errMsg, msgLen, "%s", msg3);
+ (void)snprintf(errMsg, msgLen, "%s", msg3);
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
int i = 0;
while (bin) {
intervals[i] = bin->valuedouble;
if (!cJSON_IsNumber(bin)) {
- snprintf(errMsg, msgLen, "%s", msg3);
+ (void)snprintf(errMsg, msgLen, "%s", msg3);
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
if (i != 0 && intervals[i] <= intervals[i - 1]) {
- snprintf(errMsg, msgLen, "%s", msg3);
+ (void)snprintf(errMsg, msgLen, "%s", msg3);
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
bin = bin->next;
i++;
}
} else {
- snprintf(errMsg, msgLen, "%s", msg3);
+ (void)snprintf(errMsg, msgLen, "%s", msg3);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
cJSON_Delete(binDesc);
taosMemoryFree(intervals);
- return true;
+ return TSDB_CODE_SUCCESS;
}
static int32_t translateHistogram(SFunctionNode* pFunc, char* pErrBuf, int32_t len) {
@@ -1265,7 +1289,7 @@ static int32_t translateHistogram(SFunctionNode* pFunc, char* pErrBuf, int32_t l
if (i == 2) {
char errMsg[128] = {0};
binDesc = varDataVal(pValue->datum.p);
- if (!validateHistogramBinDesc(binDesc, binType, errMsg, (int32_t)sizeof(errMsg))) {
+ if (TSDB_CODE_SUCCESS != validateHistogramBinDesc(binDesc, binType, errMsg, (int32_t)sizeof(errMsg))) {
return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, errMsg);
}
}
@@ -1323,7 +1347,7 @@ static int32_t translateHistogramImpl(SFunctionNode* pFunc, char* pErrBuf, int32
if (i == 2) {
char errMsg[128] = {0};
binDesc = varDataVal(pValue->datum.p);
- if (!validateHistogramBinDesc(binDesc, binType, errMsg, (int32_t)sizeof(errMsg))) {
+ if (TSDB_CODE_SUCCESS != validateHistogramBinDesc(binDesc, binType, errMsg, (int32_t)sizeof(errMsg))) {
return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, errMsg);
}
}
@@ -1507,12 +1531,12 @@ static int32_t translateStateDuration(SFunctionNode* pFunc, char* pErrBuf, int32
if (numOfParams == 4) {
uint8_t dbPrec = pFunc->node.resType.precision;
- int32_t ret = validateTimeUnitParam(dbPrec, (SValueNode*)nodesListGetNode(pFunc->pParameterList, 3));
- if (ret == TIME_UNIT_TOO_SMALL) {
- return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
+ int32_t code = validateTimeUnitParam(dbPrec, (SValueNode*)nodesListGetNode(pFunc->pParameterList, 3));
+ if (code == TSDB_CODE_FUNC_TIME_UNIT_TOO_SMALL) {
+ return buildFuncErrMsg(pErrBuf, len, code,
"STATEDURATION function time unit parameter should be greater than db precision");
- } else if (ret == TIME_UNIT_INVALID) {
- return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
+ } else if (code == TSDB_CODE_FUNC_TIME_UNIT_INVALID) {
+ return buildFuncErrMsg(pErrBuf, len, code,
"STATEDURATION function time unit parameter should be one of the following: [1b, 1u, 1a, "
"1s, 1m, 1h, 1d, 1w]");
}
@@ -2268,13 +2292,13 @@ static int32_t translateTimeTruncate(SFunctionNode* pFunc, char* pErrBuf, int32_
}
uint8_t dbPrec = pFunc->node.resType.precision;
- int32_t ret = validateTimeUnitParam(dbPrec, (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1));
- if (ret == TIME_UNIT_TOO_SMALL) {
- return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
+ int32_t code = validateTimeUnitParam(dbPrec, (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1));
+ if (code == TSDB_CODE_FUNC_TIME_UNIT_TOO_SMALL) {
+ return buildFuncErrMsg(pErrBuf, len, code,
"TIMETRUNCATE function time unit parameter should be greater than db precision");
- } else if (ret == TIME_UNIT_INVALID) {
+ } else if (code == TSDB_CODE_FUNC_TIME_UNIT_INVALID) {
return buildFuncErrMsg(
- pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
+ pErrBuf, len, code,
"TIMETRUNCATE function time unit parameter should be one of the following: [1b, 1u, 1a, 1s, 1m, 1h, 1d, 1w]");
}
@@ -2291,7 +2315,7 @@ static int32_t translateTimeTruncate(SFunctionNode* pFunc, char* pErrBuf, int32_
// add database precision as param
- int32_t code = addDbPrecisonParam(&pFunc->pParameterList, dbPrec);
+ code = addDbPrecisonParam(&pFunc->pParameterList, dbPrec);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
@@ -2330,13 +2354,13 @@ static int32_t translateTimeDiff(SFunctionNode* pFunc, char* pErrBuf, int32_t le
uint8_t dbPrec = pFunc->node.resType.precision;
if (3 == numOfParams) {
- int32_t ret = validateTimeUnitParam(dbPrec, (SValueNode*)nodesListGetNode(pFunc->pParameterList, 2));
- if (ret == TIME_UNIT_TOO_SMALL) {
- return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
+ int32_t code = validateTimeUnitParam(dbPrec, (SValueNode*)nodesListGetNode(pFunc->pParameterList, 2));
+ if (code == TSDB_CODE_FUNC_TIME_UNIT_TOO_SMALL) {
+ return buildFuncErrMsg(pErrBuf, len, code,
"TIMEDIFF function time unit parameter should be greater than db precision");
- } else if (ret == TIME_UNIT_INVALID) {
+ } else if (code == TSDB_CODE_FUNC_TIME_UNIT_INVALID) {
return buildFuncErrMsg(
- pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR,
+ pErrBuf, len, code,
"TIMEDIFF function time unit parameter should be one of the following: [1b, 1u, 1a, 1s, 1m, 1h, 1d, 1w]");
}
}
diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c
index 5f6565be1f..1197891cab 100644
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@@ -429,7 +429,7 @@ typedef struct SGroupKeyInfo {
(_p).val = (_v); \
} while (0)
-int32_t funcInputUpdate(SqlFunctionCtx* pCtx) {
+void funcInputUpdate(SqlFunctionCtx* pCtx) {
SFuncInputRowIter* pIter = &pCtx->rowIter;
if (!pCtx->bInputFinished) {
@@ -448,11 +448,9 @@ int32_t funcInputUpdate(SqlFunctionCtx* pCtx) {
} else {
pIter->finalRow = true;
}
-
- return TSDB_CODE_SUCCESS;
}
-bool funcInputGetNextRowDescPk(SFuncInputRowIter* pIter, SFuncInputRow* pRow) {
+int32_t funcInputGetNextRowDescPk(SFuncInputRowIter* pIter, SFuncInputRow* pRow, bool *res) {
if (pIter->finalRow) {
if (pIter->hasPrev) {
pRow->ts = pIter->prevBlockTsEnd;
@@ -462,29 +460,41 @@ bool funcInputGetNextRowDescPk(SFuncInputRowIter* pIter, SFuncInputRow* pRow) {
pRow->rowIndex = 0;
pIter->hasPrev = false;
- return true;
+ *res = true;
+ return TSDB_CODE_SUCCESS;
} else {
- return false;
+ *res = false;
+ return TSDB_CODE_SUCCESS;
}
}
if (pIter->hasPrev) {
if (pIter->prevBlockTsEnd == pIter->tsList[pIter->inputEndIndex]) {
- blockDataDestroy(pIter->pPrevRowBlock);
+ (void)blockDataDestroy(pIter->pPrevRowBlock);
pIter->pPrevRowBlock = blockDataExtractBlock(pIter->pSrcBlock, pIter->inputEndIndex, 1);
pIter->prevIsDataNull = colDataIsNull_f(pIter->pDataCol->nullbitmap, pIter->inputEndIndex);
pIter->pPrevData = taosMemoryMalloc(pIter->pDataCol->info.bytes);
+ if (NULL == pIter->pPrevData) {
+ qError("out of memory when function get input row.");
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
char* srcData = colDataGetData(pIter->pDataCol, pIter->inputEndIndex);
- memcpy(pIter->pPrevData, srcData, pIter->pDataCol->info.bytes);
+ (void)memcpy(pIter->pPrevData, srcData, pIter->pDataCol->info.bytes);
pIter->pPrevPk = taosMemoryMalloc(pIter->pPkCol->info.bytes);
+ if (NULL == pIter->pPrevPk) {
+ qError("out of memory when function get input row.");
+ taosMemoryFree(pIter->pPrevData);
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
char* pkData = colDataGetData(pIter->pPkCol, pIter->inputEndIndex);
- memcpy(pIter->pPrevPk, pkData, pIter->pPkCol->info.bytes);
+ (void)memcpy(pIter->pPrevPk, pkData, pIter->pPkCol->info.bytes);
pIter->pPrevRowBlock = blockDataExtractBlock(pIter->pSrcBlock, pIter->inputEndIndex, 1);
pIter->hasPrev = true;
- return false;
+ *res = false;
+ return TSDB_CODE_SUCCESS;
} else {
int32_t idx = pIter->rowIndex;
while (pIter->tsList[idx] == pIter->prevBlockTsEnd) {
@@ -506,7 +516,8 @@ bool funcInputGetNextRowDescPk(SFuncInputRowIter* pIter, SFuncInputRow* pRow) {
}
pIter->hasPrev = false;
pIter->rowIndex = idx;
- return true;
+ *res = true;
+ return TSDB_CODE_SUCCESS;
}
} else {
TSKEY tsEnd = pIter->tsList[pIter->inputEndIndex];
@@ -522,18 +533,29 @@ bool funcInputGetNextRowDescPk(SFuncInputRowIter* pIter, SFuncInputRow* pRow) {
pRow->block = pIter->pSrcBlock;
pIter->rowIndex = idx + 1;
- return true;
+ *res = true;
+ return TSDB_CODE_SUCCESS;
} else {
pIter->hasPrev = true;
pIter->prevBlockTsEnd = tsEnd;
pIter->prevIsDataNull = colDataIsNull_f(pIter->pDataCol->nullbitmap, pIter->inputEndIndex);
pIter->pPrevData = taosMemoryMalloc(pIter->pDataCol->info.bytes);
- memcpy(pIter->pPrevData, colDataGetData(pIter->pDataCol, pIter->inputEndIndex), pIter->pDataCol->info.bytes);
+ if (NULL == pIter->pPrevData) {
+ qError("out of memory when function get input row.");
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(pIter->pPrevData, colDataGetData(pIter->pDataCol, pIter->inputEndIndex), pIter->pDataCol->info.bytes);
pIter->pPrevPk = taosMemoryMalloc(pIter->pPkCol->info.bytes);
- memcpy(pIter->pPrevPk, colDataGetData(pIter->pPkCol, pIter->inputEndIndex), pIter->pPkCol->info.bytes);
+ if (NULL == pIter->pPrevPk) {
+ qError("out of memory when function get input row.");
+ taosMemoryFree(pIter->pPrevData);
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(pIter->pPrevPk, colDataGetData(pIter->pPkCol, pIter->inputEndIndex), pIter->pPkCol->info.bytes);
pIter->pPrevRowBlock = blockDataExtractBlock(pIter->pSrcBlock, pIter->inputEndIndex, 1);
- return false;
+ *res = false;
+ return TSDB_CODE_SUCCESS;
}
}
}
@@ -602,24 +624,27 @@ bool funcInputGetNextRowNoPk(SFuncInputRowIter *pIter, SFuncInputRow* pRow) {
}
}
-bool funcInputGetNextRow(SqlFunctionCtx* pCtx, SFuncInputRow* pRow) {
+int32_t funcInputGetNextRow(SqlFunctionCtx* pCtx, SFuncInputRow* pRow, bool *res) {
SFuncInputRowIter* pIter = &pCtx->rowIter;
if (pCtx->hasPrimaryKey) {
if (pCtx->order == TSDB_ORDER_ASC) {
- return funcInputGetNextRowAscPk(pIter, pRow);
+ *res = funcInputGetNextRowAscPk(pIter, pRow);
+ return TSDB_CODE_SUCCESS;
} else {
- return funcInputGetNextRowDescPk(pIter, pRow);
+ return funcInputGetNextRowDescPk(pIter, pRow, res);
}
} else {
- return funcInputGetNextRowNoPk(pIter, pRow);
+ *res = funcInputGetNextRowNoPk(pIter, pRow);
+ return TSDB_CODE_SUCCESS;
}
+ return TSDB_CODE_SUCCESS;
}
// This function append the selectivity to subsidiaries function context directly, without fetching data
// from intermediate disk based buf page
-void appendSelectivityCols(SqlFunctionCtx* pCtx, SSDataBlock* pSrcBlock, int32_t rowIndex, int32_t pos) {
+int32_t appendSelectivityCols(SqlFunctionCtx* pCtx, SSDataBlock* pSrcBlock, int32_t rowIndex, int32_t pos) {
if (pCtx->subsidiaries.num <= 0) {
- return;
+ return TSDB_CODE_SUCCESS;
}
for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
@@ -630,6 +655,9 @@ void appendSelectivityCols(SqlFunctionCtx* pCtx, SSDataBlock* pSrcBlock, int32_t
int32_t srcSlotId = pFuncParam->pCol->slotId;
SColumnInfoData* pSrcCol = taosArrayGet(pSrcBlock->pDataBlock, srcSlotId);
+ if (NULL == pSrcCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
char* pData = colDataGetData(pSrcCol, rowIndex);
@@ -637,43 +665,52 @@ void appendSelectivityCols(SqlFunctionCtx* pCtx, SSDataBlock* pSrcBlock, int32_t
int32_t dstSlotId = pc->pExpr->base.resSchema.slotId;
SColumnInfoData* pDstCol = taosArrayGet(pCtx->pDstBlock->pDataBlock, dstSlotId);
-
+ if (NULL == pDstCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
if (colDataIsNull_s(pSrcCol, rowIndex) == true) {
colDataSetNULL(pDstCol, pos);
} else {
- colDataSetVal(pDstCol, pos, pData, false);
+ int32_t code = colDataSetVal(pDstCol, pos, pData, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
}
+ return TSDB_CODE_SUCCESS;
}
bool funcInputGetNextRowIndex(SInputColumnInfoData* pInput, int32_t from, bool firstOccur, int32_t* pRowIndex, int32_t* nextFrom);
-static int32_t firstLastTransferInfoImpl(SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst);
+static bool firstLastTransferInfoImpl(SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst);
-bool functionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+int32_t functionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
if (pResultInfo->initialized) {
- return false;
+ return TSDB_CODE_SUCCESS; // already initialized
}
if (pCtx->pOutput != NULL) {
- memset(pCtx->pOutput, 0, (size_t)pCtx->resDataInfo.bytes);
+ (void)memset(pCtx->pOutput, 0, (size_t)pCtx->resDataInfo.bytes);
}
initResultRowEntry(pResultInfo, pCtx->resDataInfo.interBufSize);
- return true;
+ return TSDB_CODE_SUCCESS;
}
int32_t functionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
+ int32_t code = TSDB_CODE_SUCCESS;
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
-
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;
char* in = GET_ROWCELL_INTERBUF(pResInfo);
- colDataSetVal(pCol, pBlock->info.rows, in, pResInfo->isNullRes);
+ code = colDataSetVal(pCol, pBlock->info.rows, in, pResInfo->isNullRes);
- return pResInfo->numOfRes;
+ return code;
}
int32_t firstCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
@@ -684,9 +721,7 @@ int32_t firstCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
SFirstLastRes* pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
- if (TSDB_CODE_SUCCESS == firstLastTransferInfoImpl(pSBuf, pDBuf, true)) {
- pDBuf->hasResult = true;
- }
+ pDBuf->hasResult = firstLastTransferInfoImpl(pSBuf, pDBuf, true);
pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
pDResInfo->isNullRes &= pSResInfo->isNullRes;
@@ -696,14 +731,16 @@ int32_t firstCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
int32_t functionFinalizeWithResultBuf(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, char* finalResult) {
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
-
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;
char* in = finalResult;
- colDataSetVal(pCol, pBlock->info.rows, in, pResInfo->isNullRes);
+ int32_t code = colDataSetVal(pCol, pBlock->info.rows, in, pResInfo->isNullRes);
- return pResInfo->numOfRes;
+ return code;
}
EFuncDataRequired countDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow) {
@@ -972,9 +1009,12 @@ EFuncDataRequired statisDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWin
return FUNC_DATA_REQUIRED_SMA_LOAD;
}
-bool minmaxFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false; // not initialized since it has been initialized
+int32_t minmaxFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR; // not initialized since it has been initialized
}
SMinmaxResInfo* buf = GET_ROWCELL_INTERBUF(pResultInfo);
@@ -983,7 +1023,7 @@ bool minmaxFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo)
buf->nullTupleSaved = false;
buf->nullTuplePos.pageId = -1;
- return true;
+ return TSDB_CODE_SUCCESS;
}
bool getMinmaxFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
@@ -1025,6 +1065,9 @@ int32_t minmaxFunctionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t currentRow = pBlock->info.rows;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
pEntryInfo->isNullRes = (pEntryInfo->numOfRes == 0) ? 1 : 0;
// NOTE: do nothing change it, for performance issue
@@ -1097,12 +1140,12 @@ int32_t setSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const STu
if ((pCtx->saveHandle.pBuf != NULL && pTuplePos->pageId != -1) ||
(pCtx->saveHandle.pState && pTuplePos->streamTupleKey.ts > 0)) {
int32_t numOfCols = pCtx->subsidiaries.num;
- const char* p = loadTupleData(pCtx, pTuplePos);
- if (p == NULL) {
- terrno = TSDB_CODE_NOT_FOUND;
+ char* p = NULL;
+ int32_t code = loadTupleData(pCtx, pTuplePos, &p);
+ if (p == NULL || TSDB_CODE_SUCCESS != code) {
qError("Load tuple data failed since %s, groupId:%" PRIu64 ", ts:%" PRId64, terrstr(),
pTuplePos->streamTupleKey.groupId, pTuplePos->streamTupleKey.ts);
- return terrno;
+ return TSDB_CODE_NOT_FOUND;
}
bool* nullList = (bool*)p;
@@ -1120,10 +1163,16 @@ int32_t setSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const STu
}
SColumnInfoData* pDstCol = taosArrayGet(pBlock->pDataBlock, dstSlotId);
+ if (NULL == pDstCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
if (nullList[j]) {
colDataSetNULL(pDstCol, rowIndex);
} else {
- colDataSetVal(pDstCol, rowIndex, pStart, false);
+ code = colDataSetVal(pDstCol, rowIndex, pStart, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
pStart += pDstCol->info.bytes;
}
@@ -1134,11 +1183,12 @@ int32_t setSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const STu
// This function append the selectivity to subsidiaries function context directly, without fetching data
// from intermediate disk based buf page
-void appendSelectivityValue(SqlFunctionCtx* pCtx, int32_t rowIndex, int32_t pos) {
+int32_t appendSelectivityValue(SqlFunctionCtx* pCtx, int32_t rowIndex, int32_t pos) {
if (pCtx->subsidiaries.num <= 0) {
- return;
+ return TSDB_CODE_SUCCESS;
}
+ int32_t code = TSDB_CODE_SUCCESS;
for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
SqlFunctionCtx* pc = pCtx->subsidiaries.pCtx[j];
@@ -1147,6 +1197,9 @@ void appendSelectivityValue(SqlFunctionCtx* pCtx, int32_t rowIndex, int32_t pos)
int32_t srcSlotId = pFuncParam->pCol->slotId;
SColumnInfoData* pSrcCol = taosArrayGet(pCtx->pSrcBlock->pDataBlock, srcSlotId);
+ if (NULL == pSrcCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
char* pData = colDataGetData(pSrcCol, rowIndex);
@@ -1154,13 +1207,20 @@ void appendSelectivityValue(SqlFunctionCtx* pCtx, int32_t rowIndex, int32_t pos)
int32_t dstSlotId = pc->pExpr->base.resSchema.slotId;
SColumnInfoData* pDstCol = taosArrayGet(pCtx->pDstBlock->pDataBlock, dstSlotId);
+ if (NULL == pDstCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
if (colDataIsNull_s(pSrcCol, rowIndex) == true) {
colDataSetNULL(pDstCol, pos);
} else {
- colDataSetVal(pDstCol, pos, pData, false);
+ code = colDataSetVal(pDstCol, pos, pData, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
}
+ return code;
}
void replaceTupleData(STuplePos* pDestPos, STuplePos* pSourcePos) { *pDestPos = *pSourcePos; }
@@ -1244,14 +1304,17 @@ bool getStddevFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool stddevFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t stddevFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SStddevRes* pRes = GET_ROWCELL_INTERBUF(pResultInfo);
- memset(pRes, 0, sizeof(SStddevRes));
- return true;
+ (void)memset(pRes, 0, sizeof(SStddevRes));
+ return TSDB_CODE_SUCCESS;
}
int32_t stddevFunction(SqlFunctionCtx* pCtx) {
@@ -1588,16 +1651,23 @@ int32_t stddevPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t resultBytes = getStddevInfoSize();
char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
- memcpy(varDataVal(res), pInfo, resultBytes);
+ if (NULL == res) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(varDataVal(res), pInfo, resultBytes);
varDataSetLen(res, resultBytes);
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ taosMemoryFree(res);
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
- colDataSetVal(pCol, pBlock->info.rows, res, false);
+ int32_t code = colDataSetVal(pCol, pBlock->info.rows, res, false);
taosMemoryFree(res);
- return pResInfo->numOfRes;
+ return code;
}
int32_t stddevCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
@@ -1620,16 +1690,19 @@ bool getLeastSQRFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool leastSQRFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t leastSQRFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SLeastSQRInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
GET_TYPED_DATA(pInfo->startVal, double, pCtx->param[1].param.nType, &pCtx->param[1].param.i);
GET_TYPED_DATA(pInfo->stepVal, double, pCtx->param[2].param.nType, &pCtx->param[2].param.i);
- return true;
+ return TSDB_CODE_SUCCESS;
}
int32_t leastSQRFunction(SqlFunctionCtx* pCtx) {
@@ -1798,11 +1871,14 @@ int32_t leastSQRFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
int32_t currentRow = pBlock->info.rows;
if (0 == pInfo->num) {
colDataSetNULL(pCol, currentRow);
- return 0;
+ return TSDB_CODE_SUCCESS;
}
double(*param)[3] = pInfo->matrix;
@@ -1815,7 +1891,7 @@ int32_t leastSQRFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
if (0 == param00) {
colDataSetNULL(pCol, currentRow);
- return 0;
+ return TSDB_CODE_SUCCESS;
}
// param[0][1] = 0;
@@ -1830,19 +1906,19 @@ int32_t leastSQRFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
char interceptBuf[64] = {0};
int n = snprintf(slopBuf, 64, "%.6lf", param02);
if (n > LEASTSQUARES_DOUBLE_ITEM_LENGTH) {
- snprintf(slopBuf, 64, "%." DOUBLE_PRECISION_DIGITS, param02);
+ (void)snprintf(slopBuf, 64, "%." DOUBLE_PRECISION_DIGITS, param02);
}
n = snprintf(interceptBuf, 64, "%.6lf", param12);
if (n > LEASTSQUARES_DOUBLE_ITEM_LENGTH) {
- snprintf(interceptBuf, 64, "%." DOUBLE_PRECISION_DIGITS, param12);
+ (void)snprintf(interceptBuf, 64, "%." DOUBLE_PRECISION_DIGITS, param12);
}
size_t len =
snprintf(varDataVal(buf), sizeof(buf) - VARSTR_HEADER_SIZE, "{slop:%s, intercept:%s}", slopBuf, interceptBuf);
varDataSetLen(buf, len);
- colDataSetVal(pCol, currentRow, buf, pResInfo->isNullRes);
+ int32_t code = colDataSetVal(pCol, currentRow, buf, pResInfo->isNullRes);
- return pResInfo->numOfRes;
+ return code;
}
int32_t leastSQRCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
@@ -1872,9 +1948,12 @@ bool getPercentileFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool percentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t percentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
// in the first round, get the min-max value of all involved data
@@ -1883,10 +1962,11 @@ bool percentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultI
SET_DOUBLE_VAL(&pInfo->maxval, -DBL_MAX);
pInfo->numOfElems = 0;
- return true;
+ return TSDB_CODE_SUCCESS;
}
int32_t percentileFunction(SqlFunctionCtx* pCtx) {
+ int32_t code = TSDB_CODE_SUCCESS;
int32_t numOfElems = 0;
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
@@ -1905,7 +1985,10 @@ int32_t percentileFunction(SqlFunctionCtx* pCtx) {
pResInfo->complete = true;
return TSDB_CODE_SUCCESS;
} else {
- pInfo->pMemBucket = tMemBucketCreate(pCol->info.bytes, type, pInfo->minval, pInfo->maxval, pCtx->hasWindowOrGroup);
+ code = tMemBucketCreate(pCol->info.bytes, type, pInfo->minval, pInfo->maxval, pCtx->hasWindowOrGroup, &pInfo->pMemBucket);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
}
@@ -1966,7 +2049,7 @@ int32_t percentileFunction(SqlFunctionCtx* pCtx) {
char* data = colDataGetData(pCol, i);
numOfElems += 1;
- int32_t code = tMemBucketPut(pInfo->pMemBucket, data, 1);
+ code = tMemBucketPut(pInfo->pMemBucket, data, 1);
if (code != TSDB_CODE_SUCCESS) {
tMemBucketDestroy(pInfo->pMemBucket);
return code;
@@ -2012,12 +2095,19 @@ int32_t percentileFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _fin_error;
+ }
varDataSetLen(buf, len);
- colDataSetVal(pCol, pBlock->info.rows, buf, false);
+ code = colDataSetVal(pCol, pBlock->info.rows, buf, false);
+ if (code != TSDB_CODE_SUCCESS) {
+ goto _fin_error;
+ }
tMemBucketDestroy(pMemBucket);
- return pResInfo->numOfRes;
+ return TSDB_CODE_SUCCESS;
} else {
SVariant* pVal = &pCtx->param[1].param;
@@ -2076,9 +2166,12 @@ static void buildTDigestInfo(SAPercentileInfo* pInfo) {
pInfo->pTDigest = (TDigest*)((char*)pInfo + sizeof(SAPercentileInfo));
}
-bool apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SAPercentileInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
@@ -2092,7 +2185,7 @@ bool apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResult
} else if (pCtx->numOfParams == 3) {
pInfo->algo = getApercentileAlgo(varDataVal(pCtx->param[2].param.pz));
if (pInfo->algo == APERCT_ALGO_UNKNOWN) {
- return false;
+ return TSDB_CODE_FUNC_FUNTION_PARA_VALUE;
}
}
@@ -2106,7 +2199,7 @@ bool apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResult
pInfo->pHisto->numOfElems, pInfo->pHisto->numOfEntries, pInfo->pHisto, pInfo->pHisto->elems);
}
- return true;
+ return TSDB_CODE_SUCCESS;
}
int32_t apercentileFunction(SqlFunctionCtx* pCtx) {
@@ -2152,8 +2245,8 @@ int32_t apercentileFunction(SqlFunctionCtx* pCtx) {
double v = 0;
GET_TYPED_DATA(v, double, type, data);
int32_t code = tHistogramAdd(&pInfo->pHisto, v);
- if (code != 0) {
- return TSDB_CODE_FAILED;
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
}
}
@@ -2166,7 +2259,7 @@ int32_t apercentileFunction(SqlFunctionCtx* pCtx) {
return TSDB_CODE_SUCCESS;
}
-static void apercentileTransferInfo(SAPercentileInfo* pInput, SAPercentileInfo* pOutput, bool* hasRes) {
+static int32_t apercentileTransferInfo(SAPercentileInfo* pInput, SAPercentileInfo* pOutput, bool* hasRes) {
pOutput->percent = pInput->percent;
pOutput->algo = pInput->algo;
if (pOutput->algo == APERCT_ALGO_TDIGEST) {
@@ -2174,7 +2267,7 @@ static void apercentileTransferInfo(SAPercentileInfo* pInput, SAPercentileInfo*
tdigestAutoFill(pInput->pTDigest, COMPRESSION);
if (pInput->pTDigest->num_centroids == 0 && pInput->pTDigest->num_buffered_pts == 0) {
- return;
+ return TSDB_CODE_SUCCESS;
}
if (hasRes) {
@@ -2186,7 +2279,7 @@ static void apercentileTransferInfo(SAPercentileInfo* pInput, SAPercentileInfo*
tdigestAutoFill(pTDigest, COMPRESSION);
if (pTDigest->num_centroids <= 0 && pTDigest->num_buffered_pts == 0) {
- memcpy(pTDigest, pInput->pTDigest, (size_t)TDIGEST_SIZE(COMPRESSION));
+ (void)memcpy(pTDigest, pInput->pTDigest, (size_t)TDIGEST_SIZE(COMPRESSION));
tdigestAutoFill(pTDigest, COMPRESSION);
} else {
tdigestMerge(pTDigest, pInput->pTDigest);
@@ -2194,7 +2287,7 @@ static void apercentileTransferInfo(SAPercentileInfo* pInput, SAPercentileInfo*
} else {
buildHistogramInfo(pInput);
if (pInput->pHisto->numOfElems <= 0) {
- return;
+ return TSDB_CODE_SUCCESS;
}
if (hasRes) {
@@ -2205,7 +2298,7 @@ static void apercentileTransferInfo(SAPercentileInfo* pInput, SAPercentileInfo*
SHistogramInfo* pHisto = pOutput->pHisto;
if (pHisto->numOfElems <= 0) {
- memcpy(pHisto, pInput->pHisto, sizeof(SHistogramInfo) + sizeof(SHistBin) * (MAX_HISTOGRAM_BIN + 1));
+ (void)memcpy(pHisto, pInput->pHisto, sizeof(SHistogramInfo) + sizeof(SHistBin) * (MAX_HISTOGRAM_BIN + 1));
pHisto->elems = (SHistBin*)((char*)pHisto + sizeof(SHistogramInfo));
qDebug("%s merge histo, total:%" PRId64 ", entry:%d, %p", __FUNCTION__, pHisto->numOfElems, pHisto->numOfEntries,
@@ -2215,8 +2308,13 @@ static void apercentileTransferInfo(SAPercentileInfo* pInput, SAPercentileInfo*
qDebug("%s input histogram, elem:%" PRId64 ", entry:%d, %p", __FUNCTION__, pHisto->numOfElems,
pHisto->numOfEntries, pInput->pHisto);
- SHistogramInfo* pRes = tHistogramMerge(pHisto, pInput->pHisto, MAX_HISTOGRAM_BIN);
- memcpy(pHisto, pRes, sizeof(SHistogramInfo) + sizeof(SHistBin) * MAX_HISTOGRAM_BIN);
+ SHistogramInfo* pRes = NULL;
+ int32_t code = tHistogramMerge(pHisto, pInput->pHisto, MAX_HISTOGRAM_BIN, &pRes);
+ if (TSDB_CODE_SUCCESS != code) {
+ tHistogramDestroy(&pRes);
+ return code;
+ }
+ (void)memcpy(pHisto, pRes, sizeof(SHistogramInfo) + sizeof(SHistBin) * MAX_HISTOGRAM_BIN);
pHisto->elems = (SHistBin*)((char*)pHisto + sizeof(SHistogramInfo));
qDebug("%s merge histo, total:%" PRId64 ", entry:%d, %p", __FUNCTION__, pHisto->numOfElems, pHisto->numOfEntries,
@@ -2224,6 +2322,7 @@ static void apercentileTransferInfo(SAPercentileInfo* pInput, SAPercentileInfo*
tHistogramDestroy(&pRes);
}
}
+ return TSDB_CODE_SUCCESS;
}
int32_t apercentileFunctionMerge(SqlFunctionCtx* pCtx) {
@@ -2246,7 +2345,10 @@ int32_t apercentileFunctionMerge(SqlFunctionCtx* pCtx) {
char* data = colDataGetData(pCol, i);
SAPercentileInfo* pInputInfo = (SAPercentileInfo*)varDataVal(data);
- apercentileTransferInfo(pInputInfo, pInfo, &hasRes);
+ int32_t code = apercentileTransferInfo(pInputInfo, pInfo, &hasRes);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
if (pInfo->algo != APERCT_ALGO_TDIGEST) {
@@ -2279,7 +2381,12 @@ int32_t apercentileFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
pInfo->pHisto->numOfElems, pInfo->pHisto->numOfEntries, pInfo->pHisto, pInfo->pHisto->elems);
double ratio[] = {pInfo->percent};
- double* res = tHistogramUniform(pInfo->pHisto, ratio, 1);
+ double* res = NULL;
+ int32_t code = tHistogramUniform(pInfo->pHisto, ratio, 1, &res);
+ if (TSDB_CODE_SUCCESS != code) {
+ taosMemoryFree(res);
+ return code;
+ }
pInfo->result = *res;
// memcpy(pCtx->pOutput, res, sizeof(double));
taosMemoryFree(res);
@@ -2300,22 +2407,29 @@ int32_t apercentilePartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t resultBytes = getApercentileMaxSize();
char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
+ if (NULL == res) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
if (pInfo->algo == APERCT_ALGO_TDIGEST) {
- memcpy(varDataVal(res), pInfo, resultBytes);
+ (void)memcpy(varDataVal(res), pInfo, resultBytes);
varDataSetLen(res, resultBytes);
} else {
- memcpy(varDataVal(res), pInfo, resultBytes);
+ (void)memcpy(varDataVal(res), pInfo, resultBytes);
varDataSetLen(res, resultBytes);
}
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ taosMemoryFree(res);
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
- colDataSetVal(pCol, pBlock->info.rows, res, false);
+ int32_t code = colDataSetVal(pCol, pBlock->info.rows, res, false);
taosMemoryFree(res);
- return pResInfo->numOfRes;
+ return code;
}
int32_t apercentileCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
@@ -2327,7 +2441,10 @@ int32_t apercentileCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx)
qDebug("%s start to combine apercentile, %p", __FUNCTION__, pDBuf->pHisto);
- apercentileTransferInfo(pSBuf, pDBuf, NULL);
+ int32_t code = apercentileTransferInfo(pSBuf, pDBuf, NULL);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
pDResInfo->isNullRes &= pSResInfo->isNullRes;
return TSDB_CODE_SUCCESS;
@@ -2447,7 +2564,7 @@ static FORCE_INLINE TSKEY getRowPTs(SColumnInfoData* pTsColInfo, int32_t rowInde
return *(TSKEY*)colDataGetData(pTsColInfo, rowIndex);
}
-static void prepareBuf(SqlFunctionCtx* pCtx) {
+static int32_t prepareBuf(SqlFunctionCtx* pCtx) {
if (pCtx->subsidiaries.rowLen == 0) {
int32_t rowLen = 0;
for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
@@ -2457,7 +2574,11 @@ static void prepareBuf(SqlFunctionCtx* pCtx) {
pCtx->subsidiaries.rowLen = rowLen + pCtx->subsidiaries.num * sizeof(bool);
pCtx->subsidiaries.buf = taosMemoryMalloc(pCtx->subsidiaries.rowLen);
+ if (NULL == pCtx->subsidiaries.buf) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
}
+ return TSDB_CODE_SUCCESS;
}
static int32_t firstlastSaveTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SqlFunctionCtx* pCtx,
@@ -2485,12 +2606,12 @@ static int32_t doSaveCurrentVal(SqlFunctionCtx* pCtx, int32_t rowIndex, int64_t
pInfo->bytes = varDataTLen(pData);
}
- memcpy(pInfo->buf, pData, pInfo->bytes);
+ (void)memcpy(pInfo->buf, pData, pInfo->bytes);
if (pkData != NULL) {
if (IS_VAR_DATA_TYPE(pInfo->pkType)) {
pInfo->pkBytes = varDataTLen(pkData);
}
- memcpy(pInfo->buf + pInfo->bytes, pkData, pInfo->pkBytes);
+ (void)memcpy(pInfo->buf + pInfo->bytes, pkData, pInfo->pkBytes);
pInfo->pkData = pInfo->buf + pInfo->bytes;
}
@@ -2818,9 +2939,9 @@ int32_t lastFunction(SqlFunctionCtx* pCtx) {
return TSDB_CODE_SUCCESS;
}
-static int32_t firstLastTransferInfoImpl(SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst) {
+static bool firstLastTransferInfoImpl(SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst) {
if (!pInput->hasResult) {
- return TSDB_CODE_FAILED;
+ return false;
}
__compar_fn_t pkCompareFn = NULL;
if (pInput->pkData) {
@@ -2830,12 +2951,12 @@ static int32_t firstLastTransferInfoImpl(SFirstLastRes* pInput, SFirstLastRes* p
if (isFirst) {
if (pInput->ts > pOutput->ts ||
(pInput->ts == pOutput->ts && pkCompareFn && pkCompareFn(pInput->pkData, pOutput->pkData) > 0)) {
- return TSDB_CODE_FAILED;
+ return false;
}
} else {
if (pInput->ts < pOutput->ts ||
(pInput->ts == pOutput->ts && pkCompareFn && pkCompareFn(pInput->pkData, pOutput->pkData) > 0)) {
- return TSDB_CODE_FAILED;
+ return false;
}
}
}
@@ -2845,25 +2966,24 @@ static int32_t firstLastTransferInfoImpl(SFirstLastRes* pInput, SFirstLastRes* p
pOutput->bytes = pInput->bytes;
pOutput->pkType = pInput->pkType;
- memcpy(pOutput->buf, pInput->buf, pOutput->bytes);
+ (void)memcpy(pOutput->buf, pInput->buf, pOutput->bytes);
if (pInput->pkData) {
pOutput->pkBytes = pInput->pkBytes;
- memcpy(pOutput->buf + pOutput->bytes, pInput->pkData, pOutput->pkBytes);
+ (void)memcpy(pOutput->buf + pOutput->bytes, pInput->pkData, pOutput->pkBytes);
pOutput->pkData = pOutput->buf + pOutput->bytes;
}
- return TSDB_CODE_SUCCESS;
+ return true;
}
static int32_t firstLastTransferInfo(SqlFunctionCtx* pCtx, SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst,
int32_t rowIndex) {
- if (TSDB_CODE_SUCCESS == firstLastTransferInfoImpl(pInput, pOutput, isFirst)) {
+ if (firstLastTransferInfoImpl(pInput, pOutput, isFirst)) {
int32_t code = firstlastSaveTupleData(pCtx->pSrcBlock, rowIndex, pCtx, pOutput);
- if (code != TSDB_CODE_SUCCESS) {
+ if (TSDB_CODE_SUCCESS != code) {
return code;
}
pOutput->hasResult = true;
}
-
return TSDB_CODE_SUCCESS;
}
@@ -2918,12 +3038,18 @@ int32_t firstLastFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t code = TSDB_CODE_SUCCESS;
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;
SFirstLastRes* pRes = GET_ROWCELL_INTERBUF(pResInfo);
- colDataSetVal(pCol, pBlock->info.rows, pRes->buf, pRes->isNull || pResInfo->isNullRes);
+ code = colDataSetVal(pCol, pBlock->info.rows, pRes->buf, pRes->isNull || pResInfo->isNullRes);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
// handle selectivity
code = setSelectivityValue(pCtx, pBlock, &pRes->pos, pBlock->info.rows);
@@ -2941,14 +3067,24 @@ int32_t firstLastPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
// todo check for failure
char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
- memcpy(varDataVal(res), pRes, resultBytes);
+ if (NULL == res) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(varDataVal(res), pRes, resultBytes);
varDataSetLen(res, resultBytes);
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ taosMemoryFree(res);
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
- colDataSetVal(pCol, pBlock->info.rows, res, false);
+ code = colDataSetVal(pCol, pBlock->info.rows, res, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
code = setSelectivityValue(pCtx, pBlock, &pRes->pos, pBlock->info.rows);
taosMemoryFree(res);
@@ -2963,10 +3099,7 @@ int32_t lastCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
SFirstLastRes* pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
- if (TSDB_CODE_SUCCESS == firstLastTransferInfoImpl(pSBuf, pDBuf, false)) {
- pDBuf->hasResult = true;
- }
-
+ pDBuf->hasResult = firstLastTransferInfoImpl(pSBuf, pDBuf, false);
pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
pDResInfo->isNullRes &= pSResInfo->isNullRes;
return TSDB_CODE_SUCCESS;
@@ -2987,7 +3120,7 @@ static int32_t doSaveLastrow(SqlFunctionCtx* pCtx, char* pData, int32_t rowIndex
pInfo->bytes = varDataTLen(pData);
}
- memcpy(pInfo->buf, pData, pInfo->bytes);
+ (void)memcpy(pInfo->buf, pData, pInfo->bytes);
}
if (pCtx->hasPrimaryKey) {
@@ -2995,7 +3128,7 @@ static int32_t doSaveLastrow(SqlFunctionCtx* pCtx, char* pData, int32_t rowIndex
if (IS_VAR_DATA_TYPE(pInfo->pkType)) {
pInfo->pkBytes = varDataTLen(pkData);
}
- memcpy(pInfo->buf + pInfo->bytes, pkData, pInfo->pkBytes);
+ (void)memcpy(pInfo->buf + pInfo->bytes, pkData, pInfo->pkBytes);
pInfo->pkData = pInfo->buf + pInfo->bytes;
}
pInfo->ts = cts;
@@ -3101,11 +3234,13 @@ bool getDiffFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
return true;
}
-bool diffFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
- if (!functionSetup(pCtx, pResInfo)) {
- return false;
+int32_t diffFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
+ if (pResInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
-
SDiffInfo* pDiffInfo = GET_ROWCELL_INTERBUF(pResInfo);
pDiffInfo->hasPrev = false;
pDiffInfo->isFirstRow = true;
@@ -3116,7 +3251,7 @@ bool diffFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
} else {
pDiffInfo->ignoreOption = 0;
}
- return true;
+ return TSDB_CODE_SUCCESS;
}
static int32_t doSetPrevVal(SDiffInfo* pDiffInfo, int32_t type, const char* pv, int64_t ts) {
@@ -3155,7 +3290,7 @@ static int32_t doSetPrevVal(SDiffInfo* pDiffInfo, int32_t type, const char* pv,
return TSDB_CODE_SUCCESS;
}
-static int32_t diffIsNegtive(SDiffInfo* pDiffInfo, int32_t type, const char* pv) {
+static bool diffIsNegtive(SDiffInfo* pDiffInfo, int32_t type, const char* pv) {
switch (type) {
case TSDB_DATA_TYPE_UINT: {
int64_t v = *(uint32_t*)pv;
@@ -3382,14 +3517,17 @@ int32_t setDoDiffResult(SqlFunctionCtx* pCtx, SFuncInputRow* pRow, int32_t pos)
SColumnInfoData* pInputCol = pInput->pData[0];
int8_t inputType = pInputCol->info.type;
SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;
-
+ int32_t code = TSDB_CODE_SUCCESS;
if (pRow->isDataNull) {
colDataSetNull_f_s(pOutput, pos);
pOutput->hasNull = true;
// handle selectivity
if (pCtx->subsidiaries.num > 0) {
- appendSelectivityCols(pCtx, pRow->block, pRow->rowIndex, pos);
+ code = appendSelectivityCols(pCtx, pRow->block, pRow->rowIndex, pos);
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
+ }
}
return TSDB_CODE_SUCCESS;
}
@@ -3399,13 +3537,16 @@ int32_t setDoDiffResult(SqlFunctionCtx* pCtx, SFuncInputRow* pRow, int32_t pos)
if (pRow->ts == pDiffInfo->prevTs) {
return TSDB_CODE_FUNC_DUP_TIMESTAMP;
}
- int32_t code = doHandleDiff(pDiffInfo, inputType, pv, pOutput, pos, pRow->ts);
+ code = doHandleDiff(pDiffInfo, inputType, pv, pOutput, pos, pRow->ts);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
// handle selectivity
if (pCtx->subsidiaries.num > 0) {
- appendSelectivityCols(pCtx, pRow->block, pRow->rowIndex, pos);
+ code = appendSelectivityCols(pCtx, pRow->block, pRow->rowIndex, pos);
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
+ }
}
return TSDB_CODE_SUCCESS;
@@ -3424,10 +3565,17 @@ int32_t diffFunctionByRow(SArray* pCtxArray) {
int32_t numOfElems = 0;
SArray* pRows = taosArrayInit_s(sizeof(SFuncInputRow), diffColNum);
+ if (NULL == pRows) {
+ return terrno;
+ }
bool keepNull = false;
for (int i = 0; i < diffColNum; ++i) {
SqlFunctionCtx* pCtx = *(SqlFunctionCtx**)taosArrayGet(pCtxArray, i);
+ if (NULL == pCtx) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
funcInputUpdate(pCtx);
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
SDiffInfo* pDiffInfo = GET_ROWCELL_INTERBUF(pResInfo);
@@ -3438,13 +3586,33 @@ int32_t diffFunctionByRow(SArray* pCtxArray) {
SqlFunctionCtx* pCtx0 = *(SqlFunctionCtx**)taosArrayGet(pCtxArray, 0);
SFuncInputRow* pRow0 = (SFuncInputRow*)taosArrayGet(pRows, 0);
+ if (NULL == pCtx0 || NULL == pRow0) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
int32_t startOffset = pCtx0->offset;
- while (funcInputGetNextRow(pCtx0, pRow0)) {
+ bool result = false;
+ while (1) {
+ code = funcInputGetNextRow(pCtx0, pRow0, &result);
+ if (TSDB_CODE_SUCCESS != code) {
+ goto _exit;
+ }
+ if (!result) {
+ break;
+ }
bool hasNotNullValue = !diffResultIsNull(pCtx0, pRow0);
for (int i = 1; i < diffColNum; ++i) {
SqlFunctionCtx* pCtx = *(SqlFunctionCtx**)taosArrayGet(pCtxArray, i);
SFuncInputRow* pRow = (SFuncInputRow*)taosArrayGet(pRows, i);
- if(!funcInputGetNextRow(pCtx, pRow)) {
+ if (NULL == pCtx || NULL == pRow) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
+ code = funcInputGetNextRow(pCtx, pRow, &result);
+ if (TSDB_CODE_SUCCESS != code) {
+ goto _exit;
+ }
+ if (!result) {
// rows are not equal
code = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;
goto _exit;
@@ -3459,6 +3627,10 @@ int32_t diffFunctionByRow(SArray* pCtxArray) {
for (int i = 0; i < diffColNum; ++i) {
SqlFunctionCtx* pCtx = *(SqlFunctionCtx**)taosArrayGet(pCtxArray, i);
SFuncInputRow* pRow = (SFuncInputRow*)taosArrayGet(pRows, i);
+ if (NULL == pCtx || NULL == pRow) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
if ((keepNull || hasNotNullValue) && !isFirstRow(pCtx, pRow)){
code = setDoDiffResult(pCtx, pRow, pos);
if (code != TSDB_CODE_SUCCESS) {
@@ -3477,6 +3649,10 @@ int32_t diffFunctionByRow(SArray* pCtxArray) {
for (int i = 0; i < diffColNum; ++i) {
SqlFunctionCtx* pCtx = *(SqlFunctionCtx**)taosArrayGet(pCtxArray, i);
+ if (NULL == pCtx) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
pResInfo->numOfRes = numOfElems;
}
@@ -3497,9 +3673,12 @@ bool getTopBotFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool topBotFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
- if (!functionSetup(pCtx, pResInfo)) {
- return false;
+int32_t topBotFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
+ if (pResInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
STopBotRes* pRes = GET_ROWCELL_INTERBUF(pResInfo);
@@ -3509,7 +3688,7 @@ bool topBotFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
pRes->nullTupleSaved = false;
pRes->nullTuplePos.pageId = -1;
- return true;
+ return TSDB_CODE_SUCCESS;
}
static STopBotRes* getTopBotOutputInfo(SqlFunctionCtx* pCtx) {
@@ -3523,7 +3702,7 @@ static STopBotRes* getTopBotOutputInfo(SqlFunctionCtx* pCtx) {
static int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock,
uint16_t type, uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery);
-static void addResult(SqlFunctionCtx* pCtx, STopBotResItem* pSourceItem, int16_t type, bool isTopQuery);
+static int32_t addResult(SqlFunctionCtx* pCtx, STopBotResItem* pSourceItem, int16_t type, bool isTopQuery);
int32_t topFunction(SqlFunctionCtx* pCtx) {
int32_t numOfElems = 0;
@@ -3630,8 +3809,10 @@ static int32_t topBotResComparFn(const void* p1, const void* p2, const void* par
int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock, uint16_t type,
uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery) {
STopBotRes* pRes = getTopBotOutputInfo(pCtx);
+ int32_t code = TSDB_CODE_SUCCESS;
SVariant val = {0};
+ // TODO(smj) : this func need err code
taosVariantCreateFromBinary(&val, pData, tDataTypes[type].bytes, type);
STopBotResItem* pItems = pRes->pItems;
@@ -3644,7 +3825,7 @@ int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSD
// save the data of this tuple
if (pCtx->subsidiaries.num > 0) {
- int32_t code = saveTupleData(pCtx, rowIndex, pSrcBlock, &pItem->tuplePos);
+ code = saveTupleData(pCtx, rowIndex, pSrcBlock, &pItem->tuplePos);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
@@ -3655,8 +3836,11 @@ int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSD
#endif
// allocate the buffer and keep the data of this row into the new allocated buffer
pEntryInfo->numOfRes++;
- taosheapsort((void*)pItems, sizeof(STopBotResItem), pEntryInfo->numOfRes, (const void*)&type, topBotResComparFn,
- !isTopQuery);
+ code = taosheapsort((void*)pItems, sizeof(STopBotResItem), pEntryInfo->numOfRes, (const void*)&type,
+ topBotResComparFn, !isTopQuery);
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
+ }
} else { // replace the minimum value in the result
if ((isTopQuery && ((IS_SIGNED_NUMERIC_TYPE(type) && val.i > pItems[0].v.i) ||
(IS_UNSIGNED_NUMERIC_TYPE(type) && val.u > pItems[0].v.u) ||
@@ -3673,7 +3857,7 @@ int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSD
// save the data of this tuple by over writing the old data
if (pCtx->subsidiaries.num > 0) {
- int32_t code = updateTupleData(pCtx, rowIndex, pSrcBlock, &pItem->tuplePos);
+ code = updateTupleData(pCtx, rowIndex, pSrcBlock, &pItem->tuplePos);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
@@ -3681,8 +3865,11 @@ int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSD
#ifdef BUF_PAGE_DEBUG
qDebug("page_copyTuple pageId:%d, offset:%d", pItem->tuplePos.pageId, pItem->tuplePos.offset);
#endif
- taosheapadjust((void*)pItems, sizeof(STopBotResItem), 0, pEntryInfo->numOfRes - 1, (const void*)&type,
+ code = taosheapadjust((void*)pItems, sizeof(STopBotResItem), 0, pEntryInfo->numOfRes - 1, (const void*)&type,
topBotResComparFn, NULL, !isTopQuery);
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
+ }
}
}
@@ -3695,8 +3882,8 @@ int32_t doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSD
* |(n columns, one bit for each column)| src column #1| src column #2|
* +------------------------------------+--------------+--------------+
*/
-void* serializeTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SSubsidiaryResInfo* pSubsidiaryies,
- char* buf) {
+int32_t serializeTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SSubsidiaryResInfo* pSubsidiaryies,
+ char* buf, char** res) {
char* nullList = buf;
char* pStart = (char*)(nullList + sizeof(bool) * pSubsidiaryies->num);
@@ -3714,6 +3901,9 @@ void* serializeTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SSubsid
int32_t srcSlotId = pFuncParam->pCol->slotId;
SColumnInfoData* pCol = taosArrayGet(pSrcBlock->pDataBlock, srcSlotId);
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
if ((nullList[i] = colDataIsNull_s(pCol, rowIndex)) == true) {
offset += pCol->info.bytes;
continue;
@@ -3721,15 +3911,16 @@ void* serializeTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SSubsid
char* p = colDataGetData(pCol, rowIndex);
if (IS_VAR_DATA_TYPE(pCol->info.type)) {
- memcpy(pStart + offset, p, (pCol->info.type == TSDB_DATA_TYPE_JSON) ? getJsonValueLen(p) : varDataTLen(p));
+ (void)memcpy(pStart + offset, p, (pCol->info.type == TSDB_DATA_TYPE_JSON) ? getJsonValueLen(p) : varDataTLen(p));
} else {
- memcpy(pStart + offset, p, pCol->info.bytes);
+ (void)memcpy(pStart + offset, p, pCol->info.bytes);
}
offset += pCol->info.bytes;
}
- return buf;
+ *res = buf;
+ return TSDB_CODE_SUCCESS;
}
static int32_t doSaveTupleData(SSerializeDataHandle* pHandle, const void* pBuf, size_t length, SWinKey* key,
@@ -3761,7 +3952,7 @@ static int32_t doSaveTupleData(SSerializeDataHandle* pHandle, const void* pBuf,
}
p = (STuplePos){.pageId = pHandle->currentPage, .offset = pPage->num};
- memcpy(pPage->data + pPage->num, pBuf, length);
+ (void)memcpy(pPage->data + pPage->num, pBuf, length);
pPage->num += length;
setBufPageDirty(pPage, true);
@@ -3777,17 +3968,27 @@ static int32_t doSaveTupleData(SSerializeDataHandle* pHandle, const void* pBuf,
}
int32_t saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos) {
- prepareBuf(pCtx);
+ int32_t code = prepareBuf(pCtx);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
SWinKey key = {0};
if (pCtx->saveHandle.pBuf == NULL) {
SColumnInfoData* pColInfo = taosArrayGet(pSrcBlock->pDataBlock, pCtx->saveHandle.pState->tsIndex);
+ if (NULL == pColInfo) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
ASSERT(pColInfo->info.type == TSDB_DATA_TYPE_TIMESTAMP);
key.groupId = pSrcBlock->info.id.groupId;
key.ts = *(int64_t*)colDataGetData(pColInfo, rowIndex);
}
- char* buf = serializeTupleData(pSrcBlock, rowIndex, &pCtx->subsidiaries, pCtx->subsidiaries.buf);
+ char* buf = NULL;
+ code = serializeTupleData(pSrcBlock, rowIndex, &pCtx->subsidiaries, pCtx->subsidiaries.buf, &buf);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
return doSaveTupleData(&pCtx->saveHandle, buf, pCtx->subsidiaries.rowLen, &key, pPos, pCtx->pStore);
}
@@ -3797,42 +3998,56 @@ static int32_t doUpdateTupleData(SSerializeDataHandle* pHandle, const void* pBuf
if (pPage == NULL) {
return terrno;
}
- memcpy(pPage->data + pPos->offset, pBuf, length);
+ (void)memcpy(pPage->data + pPos->offset, pBuf, length);
setBufPageDirty(pPage, true);
releaseBufPage(pHandle->pBuf, pPage);
} else {
- pStore->streamStateFuncPut(pHandle->pState, &pPos->streamTupleKey, pBuf, length);
+ int32_t code = pStore->streamStateFuncPut(pHandle->pState, &pPos->streamTupleKey, pBuf, length);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
return TSDB_CODE_SUCCESS;
}
int32_t updateTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos) {
- prepareBuf(pCtx);
+ int32_t code = prepareBuf(pCtx);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
- char* buf = serializeTupleData(pSrcBlock, rowIndex, &pCtx->subsidiaries, pCtx->subsidiaries.buf);
+ char* buf = NULL;
+ code = serializeTupleData(pSrcBlock, rowIndex, &pCtx->subsidiaries, pCtx->subsidiaries.buf, &buf);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
return doUpdateTupleData(&pCtx->saveHandle, buf, pCtx->subsidiaries.rowLen, pPos, pCtx->pStore);
}
-static char* doLoadTupleData(SSerializeDataHandle* pHandle, const STuplePos* pPos, SFunctionStateStore* pStore) {
+static int32_t doLoadTupleData(SSerializeDataHandle* pHandle, const STuplePos* pPos, SFunctionStateStore* pStore, char** value) {
if (pHandle->pBuf != NULL) {
SFilePage* pPage = getBufPage(pHandle->pBuf, pPos->pageId);
if (pPage == NULL) {
- return NULL;
+ *value = NULL;
+ return terrno;
}
- char* p = pPage->data + pPos->offset;
+ *value = pPage->data + pPos->offset;
releaseBufPage(pHandle->pBuf, pPage);
- return p;
+ return TSDB_CODE_SUCCESS;
} else {
- void* value = NULL;
+ *value = NULL;
int32_t vLen;
- pStore->streamStateFuncGet(pHandle->pState, &pPos->streamTupleKey, &value, &vLen);
- return (char*)value;
+ int32_t code = pStore->streamStateFuncGet(pHandle->pState, &pPos->streamTupleKey, (void **)(value), &vLen);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
+ return TSDB_CODE_SUCCESS;
}
}
-const char* loadTupleData(SqlFunctionCtx* pCtx, const STuplePos* pPos) {
- return doLoadTupleData(&pCtx->saveHandle, pPos, pCtx->pStore);
+int32_t loadTupleData(SqlFunctionCtx* pCtx, const STuplePos* pPos, char** value) {
+ return doLoadTupleData(&pCtx->saveHandle, pPos, pCtx->pStore, value);
}
int32_t topBotFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
@@ -3845,6 +4060,9 @@ int32_t topBotFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
// todo assign the tag value and the corresponding row data
int32_t currentRow = pBlock->info.rows;
@@ -3855,22 +4073,29 @@ int32_t topBotFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
}
for (int32_t i = 0; i < pEntryInfo->numOfRes; ++i) {
STopBotResItem* pItem = &pRes->pItems[i];
- colDataSetVal(pCol, currentRow, (const char*)&pItem->v.i, false);
+ code = colDataSetVal(pCol, currentRow, (const char*)&pItem->v.i, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
#ifdef BUF_PAGE_DEBUG
qDebug("page_finalize i:%d,item:%p,pageId:%d, offset:%d\n", i, pItem, pItem->tuplePos.pageId,
pItem->tuplePos.offset);
#endif
code = setSelectivityValue(pCtx, pBlock, &pRes->pItems[i].tuplePos, currentRow);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
currentRow += 1;
}
return code;
}
-void addResult(SqlFunctionCtx* pCtx, STopBotResItem* pSourceItem, int16_t type, bool isTopQuery) {
+int32_t addResult(SqlFunctionCtx* pCtx, STopBotResItem* pSourceItem, int16_t type, bool isTopQuery) {
SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
STopBotRes* pRes = getTopBotOutputInfo(pCtx);
STopBotResItem* pItems = pRes->pItems;
+ int32_t code = TSDB_CODE_SUCCESS;
// not full yet
if (pEntryInfo->numOfRes < pRes->maxSize) {
@@ -3880,8 +4105,11 @@ void addResult(SqlFunctionCtx* pCtx, STopBotResItem* pSourceItem, int16_t type,
pItem->tuplePos.pageId = -1;
replaceTupleData(&pItem->tuplePos, &pSourceItem->tuplePos);
pEntryInfo->numOfRes++;
- taosheapsort((void*)pItems, sizeof(STopBotResItem), pEntryInfo->numOfRes, (const void*)&type, topBotResComparFn,
- !isTopQuery);
+ code = taosheapsort((void*)pItems, sizeof(STopBotResItem), pEntryInfo->numOfRes, (const void*)&type,
+ topBotResComparFn, !isTopQuery);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
} else { // replace the minimum value in the result
if ((isTopQuery && ((IS_SIGNED_NUMERIC_TYPE(type) && pSourceItem->v.i > pItems[0].v.i) ||
(IS_UNSIGNED_NUMERIC_TYPE(type) && pSourceItem->v.u > pItems[0].v.u) ||
@@ -3898,18 +4126,26 @@ void addResult(SqlFunctionCtx* pCtx, STopBotResItem* pSourceItem, int16_t type,
// save the data of this tuple by over writing the old data
replaceTupleData(&pItem->tuplePos, &pSourceItem->tuplePos);
- taosheapadjust((void*)pItems, sizeof(STopBotResItem), 0, pEntryInfo->numOfRes - 1, (const void*)&type,
- topBotResComparFn, NULL, !isTopQuery);
+ code = taosheapadjust((void*)pItems, sizeof(STopBotResItem), 0, pEntryInfo->numOfRes - 1, (const void*)&type,
+ topBotResComparFn, NULL, !isTopQuery);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
}
+ return code;
}
int32_t topCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
STopBotRes* pSBuf = getTopBotOutputInfo(pSourceCtx);
int16_t type = pSBuf->type;
+ int32_t code = TSDB_CODE_SUCCESS;
for (int32_t i = 0; i < pSResInfo->numOfRes; i++) {
- addResult(pDestCtx, pSBuf->pItems + i, type, true);
+ code = addResult(pDestCtx, pSBuf->pItems + i, type, true);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
return TSDB_CODE_SUCCESS;
}
@@ -3918,8 +4154,12 @@ int32_t bottomCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
STopBotRes* pSBuf = getTopBotOutputInfo(pSourceCtx);
int16_t type = pSBuf->type;
+ int32_t code = TSDB_CODE_SUCCESS;
for (int32_t i = 0; i < pSResInfo->numOfRes; i++) {
- addResult(pDestCtx, pSBuf->pItems + i, type, false);
+ code = addResult(pDestCtx, pSBuf->pItems + i, type, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
return TSDB_CODE_SUCCESS;
}
@@ -3931,16 +4171,19 @@ bool getSpreadFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
return true;
}
-bool spreadFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t spreadFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SSpreadInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
SET_DOUBLE_VAL(&pInfo->min, DBL_MAX);
SET_DOUBLE_VAL(&pInfo->max, -DBL_MAX);
pInfo->hasResult = false;
- return true;
+ return TSDB_CODE_SUCCESS;
}
int32_t spreadFunction(SqlFunctionCtx* pCtx) {
@@ -4073,16 +4316,28 @@ int32_t spreadPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t resultBytes = getSpreadInfoSize();
char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
- memcpy(varDataVal(res), pInfo, resultBytes);
+ if (NULL == res) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(varDataVal(res), pInfo, resultBytes);
varDataSetLen(res, resultBytes);
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
+ int32_t code = TSDB_CODE_SUCCESS;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
- colDataSetVal(pCol, pBlock->info.rows, res, false);
+ code = colDataSetVal(pCol, pBlock->info.rows, res, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ goto _exit;
+ }
+_exit:
taosMemoryFree(res);
- return pResInfo->numOfRes;
+ return TSDB_CODE_SUCCESS;
}
int32_t spreadCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
@@ -4104,9 +4359,12 @@ bool getElapsedFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
return true;
}
-bool elapsedFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t elapsedFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SElapsedInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
@@ -4120,7 +4378,7 @@ bool elapsedFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo
pInfo->timeUnit = 1;
}
- return true;
+ return TSDB_CODE_SUCCESS;
}
int32_t elapsedFunction(SqlFunctionCtx* pCtx) {
@@ -4248,16 +4506,27 @@ int32_t elapsedPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t resultBytes = getElapsedInfoSize();
char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
- memcpy(varDataVal(res), pInfo, resultBytes);
+ if (NULL == res) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(varDataVal(res), pInfo, resultBytes);
varDataSetLen(res, resultBytes);
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
+ int32_t code = TSDB_CODE_SUCCESS;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
- colDataSetVal(pCol, pBlock->info.rows, res, false);
-
+ code = colDataSetVal(pCol, pBlock->info.rows, res, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ goto _exit;
+ }
+_exit:
taosMemoryFree(res);
- return pResInfo->numOfRes;
+ return code;
}
int32_t elapsedCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
@@ -4297,7 +4566,7 @@ static int8_t getHistogramBinType(char* binTypeStr) {
return binType;
}
-static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t binType, bool normalized) {
+static int32_t getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t binType, bool normalized) {
cJSON* binDesc = cJSON_Parse(binDescStr);
int32_t numOfBins;
double* intervals;
@@ -4306,7 +4575,7 @@ static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t
int32_t startIndex;
if (numOfParams != 4) {
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
cJSON* start = cJSON_GetObjectItem(binDesc, "start");
@@ -4317,18 +4586,18 @@ static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t
if (!cJSON_IsNumber(start) || !cJSON_IsNumber(count) || !cJSON_IsBool(infinity)) {
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
if (count->valueint <= 0 || count->valueint > 1000) { // limit count to 1000
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
if (isinf(start->valuedouble) || (width != NULL && isinf(width->valuedouble)) ||
(factor != NULL && isinf(factor->valuedouble)) || (count != NULL && isinf(count->valuedouble))) {
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
int32_t counter = (int32_t)count->valueint;
@@ -4341,19 +4610,24 @@ static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t
}
intervals = taosMemoryCalloc(numOfBins, sizeof(double));
+ if (NULL == intervals) {
+ cJSON_Delete(binDesc);
+ qError("histogram function out of memory");
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
if (cJSON_IsNumber(width) && factor == NULL && binType == LINEAR_BIN) {
// linear bin process
if (width->valuedouble == 0) {
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
for (int i = 0; i < counter + 1; ++i) {
intervals[startIndex] = start->valuedouble + i * width->valuedouble;
if (isinf(intervals[startIndex])) {
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
startIndex++;
}
@@ -4362,26 +4636,26 @@ static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t
if (start->valuedouble == 0) {
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
if (factor->valuedouble < 0 || factor->valuedouble == 0 || factor->valuedouble == 1) {
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
for (int i = 0; i < counter + 1; ++i) {
intervals[startIndex] = start->valuedouble * pow(factor->valuedouble, i * 1.0);
if (isinf(intervals[startIndex])) {
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
startIndex++;
}
} else {
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
if (infinity->valueint == true) {
@@ -4389,7 +4663,7 @@ static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t
intervals[numOfBins - 1] = INFINITY;
// in case of desc bin orders, -inf/inf should be swapped
if (numOfBins < 4) {
- return false;
+ return TSDB_CODE_FAILED;
}
if (intervals[1] > intervals[numOfBins - 2]) {
TSWAP(intervals[0], intervals[numOfBins - 1]);
@@ -4398,15 +4672,20 @@ static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t
} else if (cJSON_IsArray(binDesc)) { /* user input bins */
if (binType != USER_INPUT_BIN) {
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
numOfBins = cJSON_GetArraySize(binDesc);
intervals = taosMemoryCalloc(numOfBins, sizeof(double));
+ if (NULL == intervals) {
+ cJSON_Delete(binDesc);
+ qError("histogram function out of memory");
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
cJSON* bin = binDesc->child;
if (bin == NULL) {
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
int i = 0;
while (bin) {
@@ -4414,19 +4693,19 @@ static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t
if (!cJSON_IsNumber(bin)) {
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
if (i != 0 && intervals[i] <= intervals[i - 1]) {
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
bin = bin->next;
i++;
}
} else {
cJSON_Delete(binDesc);
- return false;
+ return TSDB_CODE_FAILED;
}
pInfo->numOfBins = numOfBins - 1;
@@ -4440,12 +4719,15 @@ static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t
taosMemoryFree(intervals);
cJSON_Delete(binDesc);
- return true;
+ return TSDB_CODE_SUCCESS;
}
-bool histogramFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t histogramFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SHistoFuncInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
@@ -4458,21 +4740,22 @@ bool histogramFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultIn
taosMemoryFree(binTypeStr);
if (binType == UNKNOWN_BIN) {
- return false;
+ return TSDB_CODE_FUNC_FUNTION_PARA_VALUE;
}
char* binDesc = strndup(varDataVal(pCtx->param[2].param.pz), varDataLen(pCtx->param[2].param.pz));
int64_t normalized = pCtx->param[3].param.i;
if (normalized != 0 && normalized != 1) {
taosMemoryFree(binDesc);
- return false;
+ return TSDB_CODE_FUNC_FUNTION_PARA_VALUE;
}
- if (!getHistogramBinDesc(pInfo, binDesc, binType, (bool)normalized)) {
+ int32_t code = getHistogramBinDesc(pInfo, binDesc, binType, (bool)normalized);
+ if (TSDB_CODE_SUCCESS != code) {
taosMemoryFree(binDesc);
- return false;
+ return code;
}
taosMemoryFree(binDesc);
- return true;
+ return TSDB_CODE_SUCCESS;
}
static int32_t histogramFunctionImpl(SqlFunctionCtx* pCtx, bool isPartial) {
@@ -4556,8 +4839,12 @@ int32_t histogramFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
SHistoFuncInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ int32_t code = TSDB_CODE_SUCCESS;
int32_t currentRow = pBlock->info.rows;
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
if (pInfo->normalized) {
for (int32_t k = 0; k < pResInfo->numOfRes; ++k) {
@@ -4580,11 +4867,14 @@ int32_t histogramFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
pInfo->bins[i].upper, pInfo->bins[i].percentage);
}
varDataSetLen(buf, len);
- colDataSetVal(pCol, currentRow, buf, false);
+ code = colDataSetVal(pCol, currentRow, buf, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
currentRow++;
}
- return pResInfo->numOfRes;
+ return code;
}
int32_t histogramPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
@@ -4593,16 +4883,24 @@ int32_t histogramPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t resultBytes = getHistogramInfoSize();
char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
- memcpy(varDataVal(res), pInfo, resultBytes);
+ if (NULL == res) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(varDataVal(res), pInfo, resultBytes);
varDataSetLen(res, resultBytes);
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
+ int32_t code = TSDB_CODE_SUCCESS;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
+ code = colDataSetVal(pCol, pBlock->info.rows, res, false);
- colDataSetVal(pCol, pBlock->info.rows, res, false);
-
+_exit:
taosMemoryFree(res);
- return pResInfo->numOfRes;
+ return code;
}
int32_t histogramCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
@@ -4818,16 +5116,25 @@ int32_t hllPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t resultBytes = getHLLInfoSize();
char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
- memcpy(varDataVal(res), pInfo, resultBytes);
+ if (NULL == res) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(varDataVal(res), pInfo, resultBytes);
varDataSetLen(res, resultBytes);
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
+ int32_t code = TSDB_CODE_SUCCESS;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
- colDataSetVal(pCol, pBlock->info.rows, res, false);
+ code = colDataSetVal(pCol, pBlock->info.rows, res, false);
+_exit:
taosMemoryFree(res);
- return pResInfo->numOfRes;
+ return code;
}
int32_t hllCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
@@ -4930,6 +5237,7 @@ static bool checkStateOp(int8_t op, SColumnInfoData* pCol, int32_t index, SVaria
}
int32_t stateCountFunction(SqlFunctionCtx* pCtx) {
+ int32_t code = TSDB_CODE_SUCCESS;
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
SStateInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
@@ -4960,7 +5268,10 @@ int32_t stateCountFunction(SqlFunctionCtx* pCtx) {
colDataSetNULL(pOutput, i);
// handle selectivity
if (pCtx->subsidiaries.num > 0) {
- appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
+ code = appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
continue;
}
@@ -4973,11 +5284,17 @@ int32_t stateCountFunction(SqlFunctionCtx* pCtx) {
} else {
pInfo->count = 0;
}
- colDataSetVal(pOutput, pCtx->offset + numOfElems - 1, (char*)&output, false);
+ code = colDataSetVal(pOutput, pCtx->offset + numOfElems - 1, (char*)&output, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
// handle selectivity
if (pCtx->subsidiaries.num > 0) {
- appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
+ code = appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
}
@@ -4986,6 +5303,7 @@ int32_t stateCountFunction(SqlFunctionCtx* pCtx) {
}
int32_t stateDurationFunction(SqlFunctionCtx* pCtx) {
+ int32_t code = TSDB_CODE_SUCCESS;
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
SStateInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
@@ -5022,7 +5340,10 @@ int32_t stateDurationFunction(SqlFunctionCtx* pCtx) {
colDataSetNULL(pOutput, i);
// handle selectivity
if (pCtx->subsidiaries.num > 0) {
- appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
+ code = appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
continue;
}
@@ -5039,11 +5360,17 @@ int32_t stateDurationFunction(SqlFunctionCtx* pCtx) {
} else {
pInfo->durationStart = 0;
}
- colDataSetVal(pOutput, pCtx->offset + numOfElems - 1, (char*)&output, false);
+ code = colDataSetVal(pOutput, pCtx->offset + numOfElems - 1, (char*)&output, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
// handle selectivity
if (pCtx->subsidiaries.num > 0) {
- appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
+ code = appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
}
@@ -5057,6 +5384,7 @@ bool getCsumFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
}
int32_t csumFunction(SqlFunctionCtx* pCtx) {
+ int32_t code = TSDB_CODE_SUCCESS;
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
SSumRes* pSumRes = GET_ROWCELL_INTERBUF(pResInfo);
@@ -5088,12 +5416,18 @@ int32_t csumFunction(SqlFunctionCtx* pCtx) {
int64_t v;
GET_TYPED_DATA(v, int64_t, type, data);
pSumRes->isum += v;
- colDataSetVal(pOutput, pos, (char*)&pSumRes->isum, false);
+ code = colDataSetVal(pOutput, pos, (char*)&pSumRes->isum, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
} else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
uint64_t v;
GET_TYPED_DATA(v, uint64_t, type, data);
pSumRes->usum += v;
- colDataSetVal(pOutput, pos, (char*)&pSumRes->usum, false);
+ code = colDataSetVal(pOutput, pos, (char*)&pSumRes->usum, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
} else if (IS_FLOAT_TYPE(type)) {
double v;
GET_TYPED_DATA(v, double, type, data);
@@ -5102,13 +5436,19 @@ int32_t csumFunction(SqlFunctionCtx* pCtx) {
if (isinf(pSumRes->dsum) || isnan(pSumRes->dsum)) {
colDataSetNULL(pOutput, pos);
} else {
- colDataSetVal(pOutput, pos, (char*)&pSumRes->dsum, false);
+ code = colDataSetVal(pOutput, pos, (char*)&pSumRes->dsum, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
}
// handle selectivity
if (pCtx->subsidiaries.num > 0) {
- appendSelectivityValue(pCtx, i, pos);
+ code = appendSelectivityValue(pCtx, i, pos);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
numOfElems++;
@@ -5123,9 +5463,12 @@ bool getMavgFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
return true;
}
-bool mavgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t mavgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SMavgInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
@@ -5135,14 +5478,15 @@ bool mavgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
pInfo->isPrevTsSet = false;
pInfo->numOfPoints = pCtx->param[1].param.i;
if (pInfo->numOfPoints < 1 || pInfo->numOfPoints > MAVG_MAX_POINTS_NUM) {
- return false;
+ return TSDB_CODE_FUNC_FUNTION_PARA_VALUE;
}
pInfo->pointsMeet = false;
- return true;
+ return TSDB_CODE_SUCCESS;
}
int32_t mavgFunction(SqlFunctionCtx* pCtx) {
+ int32_t code = TSDB_CODE_SUCCESS;
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
SMavgInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
@@ -5191,12 +5535,18 @@ int32_t mavgFunction(SqlFunctionCtx* pCtx) {
if (isinf(result) || isnan(result)) {
colDataSetNULL(pOutput, pos);
} else {
- colDataSetVal(pOutput, pos, (char*)&result, false);
+ code = colDataSetVal(pOutput, pos, (char*)&result, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
// handle selectivity
if (pCtx->subsidiaries.num > 0) {
- appendSelectivityValue(pCtx, i, pos);
+ code = appendSelectivityValue(pCtx, i, pos);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
numOfElems++;
@@ -5230,9 +5580,12 @@ bool getSampleFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool sampleFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t sampleFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
taosSeedRand(taosSafeRand());
@@ -5248,7 +5601,7 @@ bool sampleFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo)
pInfo->data = (char*)pInfo + sizeof(SSampleInfo);
pInfo->tuplePos = (STuplePos*)((char*)pInfo + sizeof(SSampleInfo) + pInfo->samples * pInfo->colBytes);
- return true;
+ return TSDB_CODE_SUCCESS;
}
static void sampleAssignResult(SSampleInfo* pInfo, char* data, int32_t index) {
@@ -5322,6 +5675,9 @@ int32_t sampleFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
int32_t currentRow = pBlock->info.rows;
if (pInfo->numSampled == 0) {
@@ -5330,8 +5686,14 @@ int32_t sampleFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
return code;
}
for (int32_t i = 0; i < pInfo->numSampled; ++i) {
- colDataSetVal(pCol, currentRow + i, pInfo->data + i * pInfo->colBytes, false);
+ code = colDataSetVal(pCol, currentRow + i, pInfo->data + i * pInfo->colBytes, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
code = setSelectivityValue(pCtx, pBlock, &pInfo->tuplePos[i], currentRow + i);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
return code;
@@ -5347,7 +5709,7 @@ bool getTailFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool tailFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+int32_t tailFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
#if 0
if (!functionSetup(pCtx, pResultInfo)) {
return false;
@@ -5378,7 +5740,7 @@ bool tailFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
}
#endif
- return true;
+ return TSDB_CODE_SUCCESS;
}
static void tailAssignResult(STailItem* pItem, char* data, int32_t colBytes, TSKEY ts, bool isNull) {
@@ -5483,7 +5845,7 @@ bool getUniqueFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool uniqueFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
+int32_t uniqueFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
#if 0
if (!functionSetup(pCtx, pResInfo)) {
return false;
@@ -5499,7 +5861,7 @@ bool uniqueFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
pInfo->pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
}
#endif
- return true;
+ return TSDB_CODE_SUCCESS;
}
#if 0
@@ -5580,9 +5942,12 @@ bool getModeFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool modeFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
- if (!functionSetup(pCtx, pResInfo)) {
- return false;
+int32_t modeFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
+ if (pResInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SModeInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
@@ -5592,13 +5957,19 @@ bool modeFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
taosHashClear(pInfo->pHash);
} else {
pInfo->pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+ if (NULL == pInfo->pHash) {
+ return terrno;
+ }
}
pInfo->nullTupleSaved = false;
pInfo->nullTuplePos.pageId = -1;
pInfo->buf = taosMemoryMalloc(pInfo->colBytes);
+ if (NULL == pInfo->buf) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
- return true;
+ return TSDB_CODE_SUCCESS;
}
static void modeFunctionCleanup(SModeInfo * pInfo) {
@@ -5608,9 +5979,9 @@ static void modeFunctionCleanup(SModeInfo * pInfo) {
static int32_t saveModeTupleData(SqlFunctionCtx* pCtx, char* data, SModeInfo *pInfo, STuplePos* pPos) {
if (IS_VAR_DATA_TYPE(pInfo->colType)) {
- memcpy(pInfo->buf, data, varDataTLen(data));
+ (void)memcpy(pInfo->buf, data, varDataTLen(data));
} else {
- memcpy(pInfo->buf, data, pInfo->colBytes);
+ (void)memcpy(pInfo->buf, data, pInfo->colBytes);
}
return doSaveTupleData(&pCtx->saveHandle, pInfo->buf, pInfo->colBytes, NULL, pPos, pCtx->pStore);
@@ -5638,7 +6009,10 @@ static int32_t doModeAdd(SModeInfo* pInfo, int32_t rowIndex, SqlFunctionCtx* pCt
}
}
- taosHashPut(pInfo->pHash, data, hashKeyBytes, &item, sizeof(SModeItem));
+ code = taosHashPut(pInfo->pHash, data, hashKeyBytes, &item, sizeof(SModeItem));
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
+ }
} else {
pHashItem->count += 1;
if (pCtx->subsidiaries.num > 0) {
@@ -5698,6 +6072,9 @@ int32_t modeFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
int32_t currentRow = pBlock->info.rows;
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
STuplePos resDataPos, resTuplePos;
int32_t maxCount = 0;
@@ -5715,8 +6092,9 @@ int32_t modeFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
}
if (maxCount != 0) {
- const char* pData = loadTupleData(pCtx, &resDataPos);
- if (pData == NULL) {
+ char* pData = NULL;
+ code = loadTupleData(pCtx, &resDataPos, &pData);
+ if (pData == NULL || TSDB_CODE_SUCCESS != code) {
code = terrno = TSDB_CODE_NOT_FOUND;
qError("Load tuple data failed since %s, groupId:%" PRIu64 ", ts:%" PRId64, terrstr(),
resDataPos.streamTupleKey.groupId, resDataPos.streamTupleKey.ts);
@@ -5724,7 +6102,10 @@ int32_t modeFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
return code;
}
- colDataSetVal(pCol, currentRow, pData, false);
+ code = colDataSetVal(pCol, currentRow, pData, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
code = setSelectivityValue(pCtx, pBlock, &resTuplePos, currentRow);
} else {
colDataSetNULL(pCol, currentRow);
@@ -5741,16 +6122,19 @@ bool getTwaFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool twaFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t twaFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
STwaInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
pInfo->numOfElems = 0;
pInfo->p.key = INT64_MIN;
pInfo->win = TSWINDOW_INITIALIZER;
- return true;
+ return TSDB_CODE_SUCCESS;
}
static double twa_get_area(SPoint1 s, SPoint1 e) {
@@ -5768,6 +6152,7 @@ static double twa_get_area(SPoint1 s, SPoint1 e) {
}
int32_t twaFunction(SqlFunctionCtx* pCtx) {
+ int32_t code = TSDB_CODE_SUCCESS;
SInputColumnInfoData* pInput = &pCtx->input;
SColumnInfoData* pInputCol = pInput->pData[0];
@@ -5782,8 +6167,16 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) {
funcInputUpdate(pCtx);
SFuncInputRow row = {0};
+ bool result = false;
if (pCtx->start.key != INT64_MIN && last->key == INT64_MIN) {
- while (funcInputGetNextRow(pCtx, &row)) {
+ while (1) {
+ code = funcInputGetNextRow(pCtx, &row, &result);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
+ if (!result) {
+ break;
+ }
if (row.isDataNull) {
continue;
}
@@ -5798,7 +6191,14 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) {
break;
}
} else if (pInfo->p.key == INT64_MIN) {
- while (funcInputGetNextRow(pCtx, &row)) {
+ while (1) {
+ code = funcInputGetNextRow(pCtx, &row, &result);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
+ if (!result) {
+ break;
+ }
if (row.isDataNull) {
continue;
}
@@ -5816,181 +6216,69 @@ int32_t twaFunction(SqlFunctionCtx* pCtx) {
SPoint1 st = {0};
// calculate the value of
- switch (pInputCol->info.type) {
- case TSDB_DATA_TYPE_TINYINT: {
- while (funcInputGetNextRow(pCtx, &row)) {
- if (row.isDataNull) {
- continue;
- }
- pInfo->numOfElems++;
-
+ while (1) {
+ code = funcInputGetNextRow(pCtx, &row, &result);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
+ if (!result) {
+ break;
+ }
+ if (row.isDataNull) {
+ continue;
+ }
+ pInfo->numOfElems++;
+ switch (pInputCol->info.type) {
+ case TSDB_DATA_TYPE_TINYINT: {
INIT_INTP_POINT(st, row.ts, *(int8_t*)row.pData);
- if (pInfo->p.key == st.key) {
- return TSDB_CODE_FUNC_DUP_TIMESTAMP;
- }
-
- pInfo->dOutput += twa_get_area(pInfo->p, st);
- pInfo->p = st;
+ break;
}
- break;
- }
-
- case TSDB_DATA_TYPE_SMALLINT: {
- while (funcInputGetNextRow(pCtx, &row)) {
- if (row.isDataNull) {
- continue;
- }
- pInfo->numOfElems++;
-
+ case TSDB_DATA_TYPE_SMALLINT: {
INIT_INTP_POINT(st, row.ts, *(int16_t*)row.pData);
- if (pInfo->p.key == st.key) {
- return TSDB_CODE_FUNC_DUP_TIMESTAMP;
- }
-
- pInfo->dOutput += twa_get_area(pInfo->p, st);
- pInfo->p = st;
+ break;
}
- break;
- }
- case TSDB_DATA_TYPE_INT: {
- while (funcInputGetNextRow(pCtx, &row)) {
- if (row.isDataNull) {
- continue;
- }
- pInfo->numOfElems++;
-
+ case TSDB_DATA_TYPE_INT: {
INIT_INTP_POINT(st, row.ts, *(int32_t*)row.pData);
- if (pInfo->p.key == st.key) {
- return TSDB_CODE_FUNC_DUP_TIMESTAMP;
- }
-
- pInfo->dOutput += twa_get_area(pInfo->p, st);
- pInfo->p = st;
+ break;
}
- break;
- }
- case TSDB_DATA_TYPE_BIGINT: {
- while (funcInputGetNextRow(pCtx, &row)) {
- if (row.isDataNull) {
- continue;
- }
- pInfo->numOfElems++;
-
+ case TSDB_DATA_TYPE_BIGINT: {
INIT_INTP_POINT(st, row.ts, *(int64_t*)row.pData);
- if (pInfo->p.key == st.key) {
- return TSDB_CODE_FUNC_DUP_TIMESTAMP;
- }
-
- pInfo->dOutput += twa_get_area(pInfo->p, st);
- pInfo->p = st;
+ break;
}
- break;
- }
- case TSDB_DATA_TYPE_FLOAT: {
- while (funcInputGetNextRow(pCtx, &row)) {
- if (row.isDataNull) {
- continue;
- }
- pInfo->numOfElems++;
-
+ case TSDB_DATA_TYPE_FLOAT: {
INIT_INTP_POINT(st, row.ts, *(float_t*)row.pData);
- if (pInfo->p.key == st.key) {
- return TSDB_CODE_FUNC_DUP_TIMESTAMP;
- }
-
- pInfo->dOutput += twa_get_area(pInfo->p, st);
- pInfo->p = st;
+ break;
}
- break;
- }
- case TSDB_DATA_TYPE_DOUBLE: {
- while (funcInputGetNextRow(pCtx, &row)) {
- if (row.isDataNull) {
- continue;
- }
- pInfo->numOfElems++;
-
+ case TSDB_DATA_TYPE_DOUBLE: {
INIT_INTP_POINT(st, row.ts, *(double*)row.pData);
- if (pInfo->p.key == st.key) {
- return TSDB_CODE_FUNC_DUP_TIMESTAMP;
- }
-
- pInfo->dOutput += twa_get_area(pInfo->p, st);
- pInfo->p = st;
+ break;
}
- break;
- }
- case TSDB_DATA_TYPE_UTINYINT: {
- while (funcInputGetNextRow(pCtx, &row)) {
- if (row.isDataNull) {
- continue;
- }
- pInfo->numOfElems++;
-
+ case TSDB_DATA_TYPE_UTINYINT: {
INIT_INTP_POINT(st, row.ts, *(uint8_t*)row.pData);
- if (pInfo->p.key == st.key) {
- return TSDB_CODE_FUNC_DUP_TIMESTAMP;
- }
-
- pInfo->dOutput += twa_get_area(pInfo->p, st);
- pInfo->p = st;
+ break;
}
- break;
- }
- case TSDB_DATA_TYPE_USMALLINT: {
- while (funcInputGetNextRow(pCtx, &row)) {
- if (row.isDataNull) {
- continue;
- }
- pInfo->numOfElems++;
-
+ case TSDB_DATA_TYPE_USMALLINT: {
INIT_INTP_POINT(st, row.ts, *(uint16_t*)row.pData);
- if (pInfo->p.key == st.key) {
- return TSDB_CODE_FUNC_DUP_TIMESTAMP;
- }
-
- pInfo->dOutput += twa_get_area(pInfo->p, st);
- pInfo->p = st;
+ break;
}
- break;
- }
- case TSDB_DATA_TYPE_UINT: {
- while (funcInputGetNextRow(pCtx, &row)) {
- if (row.isDataNull) {
- continue;
- }
- pInfo->numOfElems++;
-
+ case TSDB_DATA_TYPE_UINT: {
INIT_INTP_POINT(st, row.ts, *(uint32_t*)row.pData);
- if (pInfo->p.key == st.key) {
- return TSDB_CODE_FUNC_DUP_TIMESTAMP;
- }
-
- pInfo->dOutput += twa_get_area(pInfo->p, st);
- pInfo->p = st;
+ break;
}
- break;
- }
- case TSDB_DATA_TYPE_UBIGINT: {
- while (funcInputGetNextRow(pCtx, &row)) {
- if (row.isDataNull) {
- continue;
- }
- pInfo->numOfElems++;
-
+ case TSDB_DATA_TYPE_UBIGINT: {
INIT_INTP_POINT(st, row.ts, *(uint64_t*)row.pData);
- if (pInfo->p.key == st.key) {
- return TSDB_CODE_FUNC_DUP_TIMESTAMP;
- }
-
- pInfo->dOutput += twa_get_area(pInfo->p, st);
- pInfo->p = st;
+ break;
}
- break;
+ default: {
+ return TSDB_CODE_FUNC_FUNTION_PARA_TYPE;
+ }
+ }
+ if (pInfo->p.key == st.key) {
+ return TSDB_CODE_FUNC_DUP_TIMESTAMP;
}
- default:
- return TSDB_CODE_FUNC_FUNTION_PARA_TYPE;
+ pInfo->dOutput += twa_get_area(pInfo->p, st);
+ pInfo->p = st;
}
// the last interpolated time window value
@@ -6040,14 +6328,17 @@ int32_t twaFinalize(struct SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
return functionFinalize(pCtx, pBlock);
}
-bool blockDistSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t blockDistSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
STableBlockDistInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
pInfo->minRows = INT32_MAX;
- return true;
+ return TSDB_CODE_SUCCESS;
}
int32_t blockDistFunction(SqlFunctionCtx* pCtx) {
@@ -6059,7 +6350,10 @@ int32_t blockDistFunction(SqlFunctionCtx* pCtx) {
STableBlockDistInfo* pDistInfo = GET_ROWCELL_INTERBUF(pResInfo);
STableBlockDistInfo p1 = {0};
- tDeserializeBlockDistInfo(varDataVal(pInputCol->pData), varDataLen(pInputCol->pData), &p1);
+ if (tDeserializeBlockDistInfo(varDataVal(pInputCol->pData), varDataLen(pInputCol->pData), &p1) < 0) {
+ qError("failed to deserialize block dist info");
+ return TSDB_CODE_FAILED;
+ }
pDistInfo->numOfBlocks += p1.numOfBlocks;
pDistInfo->numOfTables += p1.numOfTables;
@@ -6154,6 +6448,9 @@ int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
STableBlockDistInfo* pData = GET_ROWCELL_INTERBUF(pResInfo);
SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, 0);
+ if (NULL == pColInfo) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
if (pData->totalRows == 0) {
pData->minRows = 0;
@@ -6176,7 +6473,10 @@ int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
pData->numOfBlocks, pData->totalSize / 1024.0, averageSize / 1024.0, compRatio, '%');
varDataSetLen(st, len);
- colDataSetVal(pColInfo, row++, st, false);
+ int32_t code = colDataSetVal(pColInfo, row++, st, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
int64_t avgRows = 0;
if (pData->numOfBlocks > 0) {
@@ -6186,22 +6486,34 @@ int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
len = sprintf(st + VARSTR_HEADER_SIZE, "Block_Rows=[%" PRId64 "] MinRows=[%d] MaxRows=[%d] AvgRows=[%" PRId64 "]",
pData->totalRows, pData->minRows, pData->maxRows, avgRows);
varDataSetLen(st, len);
- colDataSetVal(pColInfo, row++, st, false);
+ code = colDataSetVal(pColInfo, row++, st, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
len = sprintf(st + VARSTR_HEADER_SIZE, "Inmem_Rows=[%d] Stt_Rows=[%d] ", pData->numOfInmemRows, pData->numOfSttRows);
varDataSetLen(st, len);
- colDataSetVal(pColInfo, row++, st, false);
+ code = colDataSetVal(pColInfo, row++, st, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
len = sprintf(st + VARSTR_HEADER_SIZE, "Total_Tables=[%d] Total_Filesets=[%d] Total_Vgroups=[%d]", pData->numOfTables,
pData->numOfFiles, pData->numOfVgroups);
varDataSetLen(st, len);
- colDataSetVal(pColInfo, row++, st, false);
+ code = colDataSetVal(pColInfo, row++, st, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
len = sprintf(st + VARSTR_HEADER_SIZE,
"--------------------------------------------------------------------------------");
varDataSetLen(st, len);
- colDataSetVal(pColInfo, row++, st, false);
+ code = colDataSetVal(pColInfo, row++, st, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
int32_t maxVal = 0;
int32_t minVal = INT32_MAX;
@@ -6240,7 +6552,10 @@ int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
}
varDataSetLen(st, len);
- colDataSetVal(pColInfo, row++, st, false);
+ code = colDataSetVal(pColInfo, row++, st, false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
return TSDB_CODE_SUCCESS;
@@ -6251,9 +6566,12 @@ bool getDerivativeFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool derivativeFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
- if (!functionSetup(pCtx, pResInfo)) {
- return false; // not initialized since it has been initialized
+int32_t derivativeFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
+ if (pResInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SDerivInfo* pDerivInfo = GET_ROWCELL_INTERBUF(pResInfo);
@@ -6262,7 +6580,7 @@ bool derivativeFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
pDerivInfo->prevTs = -1;
pDerivInfo->tsWindow = pCtx->param[1].param.i;
pDerivInfo->valueSet = false;
- return true;
+ return TSDB_CODE_SUCCESS;
}
int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
@@ -6275,13 +6593,22 @@ int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
int32_t numOfElems = 0;
SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;
SColumnInfoData* pTsOutput = pCtx->pTsOutput;
+ int32_t code = TSDB_CODE_SUCCESS;
funcInputUpdate(pCtx);
double v = 0;
if (pCtx->order == TSDB_ORDER_ASC) {
SFuncInputRow row = {0};
- while (funcInputGetNextRow(pCtx, &row)) {
+ bool result = false;
+ while (1) {
+ code = funcInputGetNextRow(pCtx, &row, &result);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
+ if (!result) {
+ break;
+ }
if (row.isDataNull) {
continue;
}
@@ -6302,7 +6629,10 @@ int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
if (isinf(r) || isnan(r)) {
colDataSetNULL(pOutput, pos);
} else {
- colDataSetVal(pOutput, pos, (const char*)&r, false);
+ code = colDataSetVal(pOutput, pos, (const char*)&r, false);
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
+ }
}
if (pTsOutput != NULL) {
@@ -6311,7 +6641,10 @@ int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
// handle selectivity
if (pCtx->subsidiaries.num > 0) {
- appendSelectivityCols(pCtx, row.block, row.rowIndex, pos);
+ code = appendSelectivityCols(pCtx, row.block, row.rowIndex, pos);
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
+ }
}
numOfElems++;
@@ -6323,7 +6656,15 @@ int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
}
} else {
SFuncInputRow row = {0};
- while (funcInputGetNextRow(pCtx, &row)) {
+ bool result = false;
+ while (1) {
+ code = funcInputGetNextRow(pCtx, &row, &result);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
+ if (!result) {
+ break;
+ }
if (row.isDataNull) {
continue;
}
@@ -6344,7 +6685,10 @@ int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
if (isinf(r) || isnan(r)) {
colDataSetNULL(pOutput, pos);
} else {
- colDataSetVal(pOutput, pos, (const char*)&r, false);
+ code = colDataSetVal(pOutput, pos, (const char*)&r, false);
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
+ }
}
if (pTsOutput != NULL) {
@@ -6353,7 +6697,10 @@ int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
// handle selectivity
if (pCtx->subsidiaries.num > 0) {
- appendSelectivityCols(pCtx, row.block, row.rowIndex, pos);
+ code = appendSelectivityCols(pCtx, row.block, row.rowIndex, pos);
+ if (code != TSDB_CODE_SUCCESS) {
+ return code;
+ }
}
numOfElems++;
}
@@ -6377,9 +6724,12 @@ bool getIrateFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
return true;
}
-bool irateFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
- if (!functionSetup(pCtx, pResInfo)) {
- return false; // not initialized since it has been initialized
+int32_t irateFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
+ if (pResInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SRateInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
@@ -6390,7 +6740,7 @@ bool irateFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
pInfo->lastValue = (double)INT64_MIN;
pInfo->hasResult = 0;
- return true;
+ return TSDB_CODE_SUCCESS;
}
static void doSaveRateInfo(SRateInfo* pRateInfo, bool isFirst, int64_t ts, char* pk, double v) {
@@ -6399,14 +6749,14 @@ static void doSaveRateInfo(SRateInfo* pRateInfo, bool isFirst, int64_t ts, char*
pRateInfo->firstKey = ts;
if (pRateInfo->firstPk) {
int32_t pkBytes = IS_VAR_DATA_TYPE(pRateInfo->pkType) ? varDataTLen(pk) : pRateInfo->pkBytes;
- memcpy(pRateInfo->firstPk, pk, pkBytes);
+ (void)memcpy(pRateInfo->firstPk, pk, pkBytes);
}
} else {
pRateInfo->lastValue = v;
pRateInfo->lastKey = ts;
if (pRateInfo->lastPk) {
int32_t pkBytes = IS_VAR_DATA_TYPE(pRateInfo->pkType) ? varDataTLen(pk) : pRateInfo->pkBytes;
- memcpy(pRateInfo->lastPk, pk, pkBytes);
+ (void)memcpy(pRateInfo->lastPk, pk, pkBytes);
}
}
}
@@ -6429,6 +6779,7 @@ static void initializeRateInfo(SqlFunctionCtx* pCtx, SRateInfo* pRateInfo, bool
}
int32_t irateFunction(SqlFunctionCtx* pCtx) {
+ int32_t code = TSDB_CODE_SUCCESS;
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
SRateInfo* pRateInfo = GET_ROWCELL_INTERBUF(pResInfo);
@@ -6444,7 +6795,15 @@ int32_t irateFunction(SqlFunctionCtx* pCtx) {
int32_t numOfElems = 0;
int32_t type = pInputCol->info.type;
SFuncInputRow row = {0};
- while (funcInputGetNextRow(pCtx, &row)) {
+ bool result = false;
+ while (1) {
+ code = funcInputGetNextRow(pCtx, &row, &result);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
+ if (!result) {
+ break;
+ }
if (row.isDataNull) {
continue;
}
@@ -6589,30 +6948,40 @@ int32_t iratePartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t resultBytes = getIrateInfoSize(pInfo->pkBytes);
char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
- memcpy(varDataVal(res), pInfo, resultBytes);
+ if (NULL == res) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(varDataVal(res), pInfo, resultBytes);
varDataSetLen(res, resultBytes);
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ taosMemoryFree(res);
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
- colDataSetVal(pCol, pBlock->info.rows, res, false);
+ int32_t code = colDataSetVal(pCol, pBlock->info.rows, res, false);
taosMemoryFree(res);
- return pResInfo->numOfRes;
+ return code;
}
int32_t irateFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;
SRateInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
double result = doCalcRate(pInfo, (double)TSDB_TICK_PER_SECOND(pCtx->param[1].param.i));
- colDataSetVal(pCol, pBlock->info.rows, (const char*)&result, pResInfo->isNullRes);
+ int32_t code = colDataSetVal(pCol, pBlock->info.rows, (const char*)&result, pResInfo->isNullRes);
- return pResInfo->numOfRes;
+ return code;
}
int32_t groupConstValueFunction(SqlFunctionCtx* pCtx) {
@@ -6637,10 +7006,10 @@ int32_t groupConstValueFunction(SqlFunctionCtx* pCtx) {
char* data = colDataGetData(pInputCol, startIndex);
if (IS_VAR_DATA_TYPE(pInputCol->info.type)) {
- memcpy(pInfo->data, data,
- (pInputCol->info.type == TSDB_DATA_TYPE_JSON) ? getJsonValueLen(data) : varDataTLen(data));
+ (void)memcpy(pInfo->data, data,
+ (pInputCol->info.type == TSDB_DATA_TYPE_JSON) ? getJsonValueLen(data) : varDataTLen(data));
} else {
- memcpy(pInfo->data, data, pInputCol->info.bytes);
+ (void)memcpy(pInfo->data, data, pInputCol->info.bytes);
}
pInfo->hasResult = true;
@@ -6656,7 +7025,11 @@ int32_t groupKeyFunction(SqlFunctionCtx* pCtx) {
int32_t groupConstValueFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
+ int32_t code = TSDB_CODE_SUCCESS;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if (NULL == pCol) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
@@ -6665,13 +7038,16 @@ int32_t groupConstValueFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
if (pInfo->hasResult) {
int32_t currentRow = pBlock->info.rows;
for (; currentRow < pBlock->info.rows + pResInfo->numOfRes; ++currentRow) {
- colDataSetVal(pCol, currentRow, pInfo->data, pInfo->isNull ? true : false);
+ code = colDataSetVal(pCol, currentRow, pInfo->data, pInfo->isNull ? true : false);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
} else {
pResInfo->numOfRes = 0;
}
- return pResInfo->numOfRes;
+ return code;
}
int32_t groupKeyFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock){
@@ -6697,10 +7073,10 @@ int32_t groupKeyCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
}
if (IS_VAR_DATA_TYPE(pSourceCtx->resDataInfo.type)) {
- memcpy(pDBuf->data, pSBuf->data,
+ (void)memcpy(pDBuf->data, pSBuf->data,
(pSourceCtx->resDataInfo.type == TSDB_DATA_TYPE_JSON) ? getJsonValueLen(pSBuf->data) : varDataTLen(pSBuf->data));
} else {
- memcpy(pDBuf->data, pSBuf->data, pSourceCtx->resDataInfo.bytes);
+ (void)memcpy(pDBuf->data, pSBuf->data, pSourceCtx->resDataInfo.bytes);
}
pDBuf->hasResult = true;
diff --git a/source/libs/function/src/detail/tavgfunction.c b/source/libs/function/src/detail/tavgfunction.c
index 3d51f0cd16..df9edb9948 100644
--- a/source/libs/function/src/detail/tavgfunction.c
+++ b/source/libs/function/src/detail/tavgfunction.c
@@ -354,14 +354,17 @@ bool getAvgFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
return true;
}
-bool avgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
- if (!functionSetup(pCtx, pResultInfo)) {
- return false;
+int32_t avgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
+ if (pResultInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SAvgRes* pRes = GET_ROWCELL_INTERBUF(pResultInfo);
- memset(pRes, 0, sizeof(SAvgRes));
- return true;
+ (void)memset(pRes, 0, sizeof(SAvgRes));
+ return TSDB_CODE_SUCCESS;
}
static int32_t calculateAvgBySMAInfo(SAvgRes* pRes, int32_t numOfRows, int32_t type, const SColumnDataAgg* pAgg) {
@@ -849,15 +852,23 @@ int32_t avgPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
SAvgRes* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
int32_t resultBytes = getAvgInfoSize();
char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
-
- memcpy(varDataVal(res), pInfo, resultBytes);
+ int32_t code = TSDB_CODE_SUCCESS;
+ if (NULL == res) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
+ (void)memcpy(varDataVal(res), pInfo, resultBytes);
varDataSetLen(res, resultBytes);
int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
+ if(NULL == pCol) {
+ code = TSDB_CODE_OUT_OF_RANGE;
+ goto _exit;
+ }
- colDataSetVal(pCol, pBlock->info.rows, res, false);
+ code = colDataSetVal(pCol, pBlock->info.rows, res, false);
+_exit:
taosMemoryFree(res);
- return pResInfo->numOfRes;
+ return code;
}
diff --git a/source/libs/function/src/detail/tminmax.c b/source/libs/function/src/detail/tminmax.c
index 590a15c753..b316b7a512 100644
--- a/source/libs/function/src/detail/tminmax.c
+++ b/source/libs/function/src/detail/tminmax.c
@@ -20,6 +20,7 @@
#include "tglobal.h"
#define __COMPARE_ACQUIRED_MAX(i, end, bm, _data, ctx, val, pos) \
+ int32_t code = TSDB_CODE_SUCCESS; \
for (; i < (end); ++i) { \
if (colDataIsNull_f(bm, i)) { \
continue; \
@@ -28,12 +29,16 @@
if ((val) < (_data)[i]) { \
(val) = (_data)[i]; \
if ((ctx)->subsidiaries.num > 0) { \
- updateTupleData((ctx), i, (ctx)->pSrcBlock, pos); \
+ code = updateTupleData((ctx), i, (ctx)->pSrcBlock, pos); \
+ if (TSDB_CODE_SUCCESS != code) { \
+ return code; \
+ } \
} \
} \
}
#define __COMPARE_ACQUIRED_MIN(i, end, bm, _data, ctx, val, pos) \
+ int32_t code = TSDB_CODE_SUCCESS; \
for (; i < (end); ++i) { \
if (colDataIsNull_f(bm, i)) { \
continue; \
@@ -42,7 +47,10 @@
if ((val) > (_data)[i]) { \
(val) = (_data)[i]; \
if ((ctx)->subsidiaries.num > 0) { \
- updateTupleData((ctx), i, (ctx)->pSrcBlock, pos); \
+ code = updateTupleData((ctx), i, (ctx)->pSrcBlock, pos); \
+ if (TSDB_CODE_SUCCESS != code) { \
+ return code; \
+ } \
} \
} \
}
@@ -571,7 +579,7 @@ static int32_t findRowIndex(int32_t start, int32_t num, SColumnInfoData* pCol, c
return -1;
}
-static void doExtractVal(SColumnInfoData* pCol, int32_t i, int32_t end, SqlFunctionCtx* pCtx, SMinmaxResInfo* pBuf,
+static int32_t doExtractVal(SColumnInfoData* pCol, int32_t i, int32_t end, SqlFunctionCtx* pCtx, SMinmaxResInfo* pBuf,
bool isMinFunc) {
if (isMinFunc) {
switch (pCol->info.type) {
@@ -700,6 +708,7 @@ static void doExtractVal(SColumnInfoData* pCol, int32_t i, int32_t end, SqlFunct
}
}
}
+ return TSDB_CODE_SUCCESS;
}
static int32_t saveRelatedTupleTag(SqlFunctionCtx* pCtx, SInputColumnInfoData* pInput, void* tval) {
@@ -840,7 +849,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc, int32_t* nElems)
break;
}
default:
- memcpy(&pBuf->v, p, pCol->info.bytes);
+ (void)memcpy(&pBuf->v, p, pCol->info.bytes);
break;
}
@@ -858,7 +867,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc, int32_t* nElems)
goto _over;
}
- doExtractVal(pCol, i, end, pCtx, pBuf, isMinFunc);
+ code = doExtractVal(pCol, i, end, pCtx, pBuf, isMinFunc);
} else {
numOfElems = numOfRows;
diff --git a/source/libs/function/src/functionMgt.c b/source/libs/function/src/functionMgt.c
index 8255997836..0424b2f179 100644
--- a/source/libs/function/src/functionMgt.c
+++ b/source/libs/function/src/functionMgt.c
@@ -35,14 +35,14 @@ static void doInitFunctionTable() {
gFunMgtService.pFuncNameHashTable =
taosHashInit(funcMgtBuiltinsNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
if (NULL == gFunMgtService.pFuncNameHashTable) {
- initFunctionCode = TSDB_CODE_FAILED;
+ initFunctionCode = terrno;
return;
}
for (int32_t i = 0; i < funcMgtBuiltinsNum; ++i) {
if (TSDB_CODE_SUCCESS != taosHashPut(gFunMgtService.pFuncNameHashTable, funcMgtBuiltins[i].name,
strlen(funcMgtBuiltins[i].name), &i, sizeof(int32_t))) {
- initFunctionCode = TSDB_CODE_FAILED;
+ initFunctionCode = terrno;
return;
}
}
@@ -61,7 +61,7 @@ static bool isSpecificClassifyFunc(int32_t funcId, uint64_t classification) {
}
int32_t fmFuncMgtInit() {
- taosThreadOnce(&functionHashTableInit, doInitFunctionTable);
+ (void)taosThreadOnce(&functionHashTableInit, doInitFunctionTable);
return initFunctionCode;
}
@@ -115,20 +115,24 @@ EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWin
return funcMgtBuiltins[pFunc->funcId].dataRequiredFunc(pFunc, pTimeWindow);
}
-EFuncDataRequired fmFuncDynDataRequired(int32_t funcId, void* pRes, SDataBlockInfo* pBlockInfo) {
+int32_t fmFuncDynDataRequired(int32_t funcId, void* pRes, SDataBlockInfo* pBlockInfo, int32_t *reqStatus) {
if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {
+ *reqStatus = -1;
return TSDB_CODE_FAILED;
}
const char* name = funcMgtBuiltins[funcId].name;
if ((strcmp(name, "_group_key") == 0) || (strcmp(name, "_select_value") == 0)) {
- return FUNC_DATA_REQUIRED_NOT_LOAD;
+ *reqStatus = FUNC_DATA_REQUIRED_NOT_LOAD;
+ return TSDB_CODE_SUCCESS;;
}
if (funcMgtBuiltins[funcId].dynDataRequiredFunc == NULL) {
- return FUNC_DATA_REQUIRED_DATA_LOAD;
+ *reqStatus = FUNC_DATA_REQUIRED_DATA_LOAD;
+ return TSDB_CODE_SUCCESS;
} else {
- return funcMgtBuiltins[funcId].dynDataRequiredFunc(pRes, pBlockInfo);
+ *reqStatus = funcMgtBuiltins[funcId].dynDataRequiredFunc(pRes, pBlockInfo);
+ return TSDB_CODE_SUCCESS;
}
}
@@ -378,29 +382,30 @@ static int32_t getFuncInfo(SFunctionNode* pFunc) {
return fmGetFuncInfo(pFunc, msg, sizeof(msg));
}
-SFunctionNode* createFunction(const char* pName, SNodeList* pParameterList) {
- SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
- if (NULL == pFunc) {
- return NULL;
+int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** pFunc) {
+ *pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION);
+ if (NULL == *pFunc) {
+ return TSDB_CODE_OUT_OF_MEMORY;
}
- snprintf(pFunc->functionName, sizeof(pFunc->functionName), "%s", pName);
- pFunc->pParameterList = pParameterList;
- if (TSDB_CODE_SUCCESS != getFuncInfo(pFunc)) {
- pFunc->pParameterList = NULL;
- nodesDestroyNode((SNode*)pFunc);
- return NULL;
+ (void)snprintf((*pFunc)->functionName, sizeof((*pFunc)->functionName), "%s", pName);
+ (*pFunc)->pParameterList = pParameterList;
+ int32_t code = getFuncInfo((*pFunc));
+ if (TSDB_CODE_SUCCESS != code) {
+ (*pFunc)->pParameterList = NULL;
+ nodesDestroyNode((SNode*)*pFunc);
+ return code;
}
- return pFunc;
+ return code;
}
-static SNode* createColumnByFunc(const SFunctionNode* pFunc) {
- SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
- if (NULL == pCol) {
- return NULL;
+static int32_t createColumnByFunc(const SFunctionNode* pFunc, SColumnNode** pCol) {
+ *pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN);
+ if (NULL == *pCol) {
+ return TSDB_CODE_OUT_OF_MEMORY;
}
- strcpy(pCol->colName, pFunc->node.aliasName);
- pCol->node.resType = pFunc->node.resType;
- return (SNode*)pCol;
+ (void)strcpy((*pCol)->colName, pFunc->node.aliasName);
+ (*pCol)->node.resType = pFunc->node.resType;
+ return TSDB_CODE_SUCCESS;
}
bool fmIsDistExecFunc(int32_t funcId) {
@@ -418,17 +423,17 @@ static int32_t createPartialFunction(const SFunctionNode* pSrcFunc, SFunctionNod
if (NULL == pParameterList) {
return TSDB_CODE_OUT_OF_MEMORY;
}
- *pPartialFunc = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pPartialFunc, pParameterList);
- if (NULL == *pPartialFunc) {
+ int32_t code = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pPartialFunc, pParameterList,pPartialFunc );
+ if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pParameterList);
- return TSDB_CODE_OUT_OF_MEMORY;
+ return code;
}
(*pPartialFunc)->hasOriginalFunc = true;
(*pPartialFunc)->originalFuncId = pSrcFunc->hasOriginalFunc ? pSrcFunc->originalFuncId : pSrcFunc->funcId;
char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0};
int32_t len = snprintf(name, sizeof(name) - 1, "%s.%p", (*pPartialFunc)->functionName, pSrcFunc);
- taosCreateMD5Hash(name, len);
- strncpy((*pPartialFunc)->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
+ (void)taosCreateMD5Hash(name, len);
+ (void)strncpy((*pPartialFunc)->node.aliasName, name, TSDB_COL_NAME_LEN - 1);
(*pPartialFunc)->hasPk = pSrcFunc->hasPk;
(*pPartialFunc)->pkBytes = pSrcFunc->pkBytes;
return TSDB_CODE_SUCCESS;
@@ -436,7 +441,11 @@ static int32_t createPartialFunction(const SFunctionNode* pSrcFunc, SFunctionNod
static int32_t createMergeFuncPara(const SFunctionNode* pSrcFunc, const SFunctionNode* pPartialFunc,
SNodeList** pParameterList) {
- SNode* pRes = createColumnByFunc(pPartialFunc);
+ SNode *pRes = NULL;
+ int32_t code = createColumnByFunc(pPartialFunc, (SColumnNode**)&pRes);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
if (NULL != funcMgtBuiltins[pSrcFunc->funcId].createMergeParaFuc) {
return funcMgtBuiltins[pSrcFunc->funcId].createMergeParaFuc(pSrcFunc->pParameterList, pRes, pParameterList);
} else {
@@ -452,16 +461,13 @@ static int32_t createMidFunction(const SFunctionNode* pSrcFunc, const SFunctionN
int32_t code = createMergeFuncPara(pSrcFunc, pPartialFunc, &pParameterList);
if (TSDB_CODE_SUCCESS == code) {
if(funcMgtBuiltins[pSrcFunc->funcId].pMiddleFunc != NULL){
- pFunc = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pMiddleFunc, pParameterList);
+ code = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pMiddleFunc, pParameterList, &pFunc);
}else{
- pFunc = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pParameterList);
- }
- if (NULL == pFunc) {
- code = TSDB_CODE_OUT_OF_MEMORY;
+ code = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pParameterList, &pFunc);
}
}
if (TSDB_CODE_SUCCESS == code) {
- strcpy(pFunc->node.aliasName, pPartialFunc->node.aliasName);
+ (void)strcpy(pFunc->node.aliasName, pPartialFunc->node.aliasName);
}
if (TSDB_CODE_SUCCESS == code) {
@@ -481,10 +487,7 @@ static int32_t createMergeFunction(const SFunctionNode* pSrcFunc, const SFunctio
int32_t code = createMergeFuncPara(pSrcFunc, pPartialFunc, &pParameterList);
if (TSDB_CODE_SUCCESS == code) {
- pFunc = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pParameterList);
- if (NULL == pFunc) {
- code = TSDB_CODE_OUT_OF_MEMORY;
- }
+ code = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pMergeFunc, pParameterList, &pFunc);
}
if (TSDB_CODE_SUCCESS == code) {
pFunc->hasOriginalFunc = true;
@@ -493,7 +496,7 @@ static int32_t createMergeFunction(const SFunctionNode* pSrcFunc, const SFunctio
if (fmIsSameInOutType(pSrcFunc->funcId)) {
pFunc->node.resType = pSrcFunc->node.resType;
}
- strcpy(pFunc->node.aliasName, pSrcFunc->node.aliasName);
+ (void)strcpy(pFunc->node.aliasName, pSrcFunc->node.aliasName);
}
if (TSDB_CODE_SUCCESS == code) {
@@ -541,13 +544,13 @@ static int32_t fmCreateStateFunc(const SFunctionNode* pFunc, SFunctionNode** pSt
if (funcMgtBuiltins[pFunc->funcId].pStateFunc) {
SNodeList* pParams = nodesCloneList(pFunc->pParameterList);
if (!pParams) return TSDB_CODE_OUT_OF_MEMORY;
- *pStateFunc = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams);
- if (!*pStateFunc) {
+ int32_t code = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams, pStateFunc);
+ if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pParams);
return TSDB_CODE_FUNC_FUNTION_ERROR;
}
- strcpy((*pStateFunc)->node.aliasName, pFunc->node.aliasName);
- strcpy((*pStateFunc)->node.userAlias, pFunc->node.userAlias);
+ (void)strcpy((*pStateFunc)->node.aliasName, pFunc->node.aliasName);
+ (void)strcpy((*pStateFunc)->node.userAlias, pFunc->node.userAlias);
}
return TSDB_CODE_SUCCESS;
}
@@ -587,13 +590,13 @@ static int32_t fmCreateStateMergeFunc(SFunctionNode* pFunc, SFunctionNode** pSta
if (funcMgtBuiltins[pFunc->funcId].pMergeFunc) {
SNodeList* pParams = nodesCloneList(pFunc->pParameterList);
if (!pParams) return TSDB_CODE_OUT_OF_MEMORY;
- *pStateMergeFunc = createFunction(funcMgtBuiltins[pFunc->funcId].pMergeFunc, pParams);
- if (!*pStateMergeFunc) {
+ int32_t code = createFunction(funcMgtBuiltins[pFunc->funcId].pMergeFunc, pParams, pStateMergeFunc);
+ if (TSDB_CODE_SUCCESS != code) {
nodesDestroyList(pParams);
- return TSDB_CODE_FUNC_FUNTION_ERROR;
+ return code;
}
- strcpy((*pStateMergeFunc)->node.aliasName, pFunc->node.aliasName);
- strcpy((*pStateMergeFunc)->node.userAlias, pFunc->node.userAlias);
+ (void)strcpy((*pStateMergeFunc)->node.aliasName, pFunc->node.aliasName);
+ (void)strcpy((*pStateMergeFunc)->node.userAlias, pFunc->node.userAlias);
}
return TSDB_CODE_SUCCESS;
}
@@ -646,6 +649,9 @@ bool fmIsMyStateFunc(int32_t funcId, int32_t stateFuncId) {
}
if (strcmp(pFunc->pStateFunc, pStateFunc->name) == 0) return true;
int32_t stateMergeFuncId = fmGetFuncId(pFunc->pStateFunc);
+ if (stateMergeFuncId == -1) {
+ return false;
+ }
const SBuiltinFuncDefinition* pStateMergeFunc = &funcMgtBuiltins[stateMergeFuncId];
return strcmp(pStateFunc->name, pStateMergeFunc->pMergeFunc) == 0;
}
diff --git a/source/libs/function/src/thistogram.c b/source/libs/function/src/thistogram.c
index b56691f35d..f57f6aa118 100644
--- a/source/libs/function/src/thistogram.c
+++ b/source/libs/function/src/thistogram.c
@@ -32,9 +32,12 @@
*/
static int32_t histogramCreateBin(SHistogramInfo* pHisto, int32_t index, double val);
-SHistogramInfo* tHistogramCreate(int32_t numOfEntries) {
+int32_t tHistogramCreate(int32_t numOfEntries, SHistogramInfo** pHisto) {
/* need one redundant slot */
- SHistogramInfo* pHisto = taosMemoryMalloc(sizeof(SHistogramInfo) + sizeof(SHistBin) * (numOfEntries + 1));
+ *pHisto = taosMemoryMalloc(sizeof(SHistogramInfo) + sizeof(SHistBin) * (numOfEntries + 1));
+ if (NULL == *pHisto) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
#if !defined(USE_ARRAYLIST)
pHisto->pList = SSkipListCreate(MAX_SKIP_LIST_LEVEL, TSDB_DATA_TYPE_DOUBLE, sizeof(double));
@@ -46,11 +49,12 @@ SHistogramInfo* tHistogramCreate(int32_t numOfEntries) {
pss->pTree = pHisto->pLoserTree;
#endif
- return tHistogramCreateFrom(pHisto, numOfEntries);
+ *pHisto = tHistogramCreateFrom(*pHisto, numOfEntries);
+ return TSDB_CODE_SUCCESS;
}
SHistogramInfo* tHistogramCreateFrom(void* pBuf, int32_t numOfBins) {
- memset(pBuf, 0, sizeof(SHistogramInfo) + sizeof(SHistBin) * (numOfBins + 1));
+ (void)memset(pBuf, 0, sizeof(SHistogramInfo) + sizeof(SHistBin) * (numOfBins + 1));
SHistogramInfo* pHisto = (SHistogramInfo*)pBuf;
pHisto->elems = (SHistBin*)((char*)pBuf + sizeof(SHistogramInfo));
@@ -67,15 +71,19 @@ SHistogramInfo* tHistogramCreateFrom(void* pBuf, int32_t numOfBins) {
}
int32_t tHistogramAdd(SHistogramInfo** pHisto, double val) {
+ int32_t code = TSDB_CODE_SUCCESS;
if (*pHisto == NULL) {
- *pHisto = tHistogramCreate(MAX_HISTOGRAM_BIN);
+ code = tHistogramCreate(MAX_HISTOGRAM_BIN, pHisto);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
}
#if defined(USE_ARRAYLIST)
int32_t idx = histoBinarySearch((*pHisto)->elems, (*pHisto)->numOfEntries, val);
if (ASSERTS(idx >= 0 && idx <= (*pHisto)->maxEntries && (*pHisto)->elems != NULL, "tHistogramAdd Error, idx:%d, maxEntries:%d, elems:%p",
idx, (*pHisto)->maxEntries, (*pHisto)->elems)) {
- return -1;
+ return TSDB_CODE_FAILED;
}
if ((*pHisto)->elems[idx].val == val && idx >= 0) {
@@ -89,23 +97,23 @@ int32_t tHistogramAdd(SHistogramInfo** pHisto, double val) {
if (idx > 0) {
if (ASSERTS((*pHisto)->elems[idx - 1].val <= val, "tHistogramAdd Error, elems[%d].val:%lf, val:%lf",
idx - 1, (*pHisto)->elems[idx - 1].val, val)) {
- return -1;
+ return TSDB_CODE_FAILED;
}
} else {
if (ASSERTS((*pHisto)->elems[idx].val > val, "tHistogramAdd Error, elems[%d].val:%lf, val:%lf",
idx, (*pHisto)->elems[idx].val, val)) {
- return -1;
+ return TSDB_CODE_FAILED;
}
}
} else if ((*pHisto)->numOfElems > 0) {
if (ASSERTS((*pHisto)->elems[(*pHisto)->numOfEntries].val <= val, "tHistogramAdd Error, elems[%d].val:%lf, val:%lf",
(*pHisto)->numOfEntries, (*pHisto)->elems[idx].val, val)) {
- return -1;
+ return TSDB_CODE_FAILED;
}
}
- int32_t code = histogramCreateBin(*pHisto, idx, val);
- if (code != 0) {
+ code = histogramCreateBin(*pHisto, idx, val);
+ if (code != TSDB_CODE_SUCCESS) {
return code;
}
}
@@ -286,7 +294,7 @@ int32_t tHistogramAdd(SHistogramInfo** pHisto, double val) {
}
(*pHisto)->numOfElems += 1;
- return 0;
+ return code;
}
int32_t histoBinarySearch(SHistBin* pEntry, int32_t len, double val) {
@@ -335,7 +343,7 @@ static void histogramMergeImpl(SHistBin* pHistBin, int32_t* size) {
s1->val = newVal;
s1->num = s1->num + s2->num;
- memmove(&pHistBin[index + 1], &pHistBin[index + 2], (oldSize - index - 2) * sizeof(SHistBin));
+ (void)memmove(&pHistBin[index + 1], &pHistBin[index + 2], (oldSize - index - 2) * sizeof(SHistBin));
(*size) -= 1;
#endif
}
@@ -345,12 +353,12 @@ int32_t histogramCreateBin(SHistogramInfo* pHisto, int32_t index, double val) {
#if defined(USE_ARRAYLIST)
int32_t remain = pHisto->numOfEntries - index;
if (remain > 0) {
- memmove(&pHisto->elems[index + 1], &pHisto->elems[index], sizeof(SHistBin) * remain);
+ (void)memmove(&pHisto->elems[index + 1], &pHisto->elems[index], sizeof(SHistBin) * remain);
}
if (ASSERTS(index >= 0 && index <= pHisto->maxEntries, "histogramCreateBin Error, index:%d, maxEntries:%d",
index, pHisto->maxEntries)) {
- return -1;
+ return TSDB_CODE_FAILED;
}
pHisto->elems[index].num = 1;
@@ -367,10 +375,10 @@ int32_t histogramCreateBin(SHistogramInfo* pHisto, int32_t index, double val) {
#endif
if (ASSERTS(pHisto->numOfEntries <= pHisto->maxEntries, "histogramCreateBin Error, numOfEntries:%d, maxEntries:%d",
pHisto->numOfEntries, pHisto->maxEntries)) {
- return -1;
+ return TSDB_CODE_FAILED;
}
- return 0;
+ return TSDB_CODE_SUCCESS;
}
void tHistogramDestroy(SHistogramInfo** pHisto) {
@@ -383,17 +391,17 @@ void tHistogramDestroy(SHistogramInfo** pHisto) {
}
void tHistogramPrint(SHistogramInfo* pHisto) {
- printf("total entries: %d, elements: %" PRId64 "\n", pHisto->numOfEntries, pHisto->numOfElems);
+ (void)printf("total entries: %d, elements: %" PRId64 "\n", pHisto->numOfEntries, pHisto->numOfElems);
#if defined(USE_ARRAYLIST)
for (int32_t i = 0; i < pHisto->numOfEntries; ++i) {
- printf("%d: (%f, %" PRId64 ")\n", i + 1, pHisto->elems[i].val, pHisto->elems[i].num);
+ (void)printf("%d: (%f, %" PRId64 ")\n", i + 1, pHisto->elems[i].val, pHisto->elems[i].num);
}
#else
tSkipListNode* pNode = pHisto->pList->pHead.pForward[0];
for (int32_t i = 0; i < pHisto->numOfEntries; ++i) {
SHistBin* pEntry = (SHistBin*)pNode->pData;
- printf("%d: (%f, %" PRId64 ")\n", i + 1, pEntry->val, pEntry->num);
+ (void)printf("%d: (%f, %" PRId64 ")\n", i + 1, pEntry->val, pEntry->num);
pNode = pNode->pForward[0];
}
#endif
@@ -443,21 +451,24 @@ int64_t tHistogramSum(SHistogramInfo* pHisto, double v) {
#endif
}
-double* tHistogramUniform(SHistogramInfo* pHisto, double* ratio, int32_t num) {
+int32_t tHistogramUniform(SHistogramInfo* pHisto, double* ratio, int32_t num, double** pVal) {
#if defined(USE_ARRAYLIST)
- double* pVal = taosMemoryMalloc(num * sizeof(double));
+ *pVal = taosMemoryMalloc(num * sizeof(double));
+ if (NULL == *pVal) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
for (int32_t i = 0; i < num; ++i) {
double numOfElem = (ratio[i] / 100) * pHisto->numOfElems;
if (numOfElem == 0) {
- pVal[i] = pHisto->min;
+ (*pVal)[i] = pHisto->min;
continue;
} else if (numOfElem <= pHisto->elems[0].num) {
- pVal[i] = pHisto->elems[0].val;
+ (*pVal)[i] = pHisto->elems[0].val;
continue;
} else if (numOfElem == pHisto->numOfElems) {
- pVal[i] = pHisto->max;
+ (*pVal)[i] = pHisto->max;
continue;
}
@@ -479,37 +490,39 @@ double* tHistogramUniform(SHistogramInfo* pHisto, double* ratio, int32_t num) {
double delta = numOfElem - total;
if (fabs(delta) < FLT_EPSILON) {
- pVal[i] = pHisto->elems[j].val;
+ (*pVal)[i] = pHisto->elems[j].val;
}
double start = (double)pHisto->elems[j].num;
double range = pHisto->elems[j + 1].num - start;
if (range == 0) {
- pVal[i] = (pHisto->elems[j + 1].val - pHisto->elems[j].val) * delta / start + pHisto->elems[j].val;
+ (*pVal)[i] = (pHisto->elems[j + 1].val - pHisto->elems[j].val) * delta / start + pHisto->elems[j].val;
} else {
double factor = (-2 * start + sqrt(4 * start * start - 4 * range * (-2 * delta))) / (2 * range);
- pVal[i] = pHisto->elems[j].val + (pHisto->elems[j + 1].val - pHisto->elems[j].val) * factor;
+ (*pVal)[i] = pHisto->elems[j].val + (pHisto->elems[j + 1].val - pHisto->elems[j].val) * factor;
}
}
#else
double* pVal = taosMemoryMalloc(num * sizeof(double));
-
+ if (NULL == *pVal) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
for (int32_t i = 0; i < num; ++i) {
double numOfElem = ratio[i] * pHisto->numOfElems;
tSkipListNode* pFirst = pHisto->pList->pHead.pForward[0];
SHistBin* pEntry = (SHistBin*)pFirst->pData;
if (numOfElem == 0) {
- pVal[i] = pHisto->min;
+ (*pVal)[i] = pHisto->min;
printf("i/numofSlot: %f, v:%f, %f\n", ratio[i], numOfElem, pVal[i]);
continue;
} else if (numOfElem <= pEntry->num) {
- pVal[i] = pEntry->val;
+ (*pVal)[i] = pEntry->val;
printf("i/numofSlot: %f, v:%f, %f\n", ratio[i], numOfElem, pVal[i]);
continue;
} else if (numOfElem == pHisto->numOfElems) {
- pVal[i] = pHisto->max;
+ (*pVal)[i] = pHisto->max;
printf("i/numofSlot: %f, v:%f, %f\n", ratio[i], numOfElem, pVal[i]);
continue;
}
@@ -540,34 +553,40 @@ double* tHistogramUniform(SHistogramInfo* pHisto, double* ratio, int32_t num) {
if (fabs(delta) < FLT_EPSILON) {
// printf("i/numofSlot: %f, v:%f, %f\n",
// (double)i/numOfSlots, numOfElem, pHisto->elems[j].val);
- pVal[i] = pPrev->val;
+ (*pVal)[i] = pPrev->val;
}
double start = pPrev->num;
double range = pEntry->num - start;
if (range == 0) {
- pVal[i] = (pEntry->val - pPrev->val) * delta / start + pPrev->val;
+ (*pVal)[i] = (pEntry->val - pPrev->val) * delta / start + pPrev->val;
} else {
double factor = (-2 * start + sqrt(4 * start * start - 4 * range * (-2 * delta))) / (2 * range);
- pVal[i] = pPrev->val + (pEntry->val - pPrev->val) * factor;
+ (*pVal)[i] = pPrev->val + (pEntry->val - pPrev->val) * factor;
}
// printf("i/numofSlot: %f, v:%f, %f\n", (double)i/numOfSlots,
// numOfElem, val);
}
#endif
- return pVal;
+ return TSDB_CODE_SUCCESS;
}
-SHistogramInfo* tHistogramMerge(SHistogramInfo* pHisto1, SHistogramInfo* pHisto2, int32_t numOfEntries) {
- SHistogramInfo* pResHistogram = tHistogramCreate(numOfEntries);
+int32_t tHistogramMerge(SHistogramInfo* pHisto1, SHistogramInfo* pHisto2, int32_t numOfEntries, SHistogramInfo** pResHistogram) {
+ int32_t code = tHistogramCreate(numOfEntries, pResHistogram);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
// error in histogram info
if (pHisto1->numOfEntries > MAX_HISTOGRAM_BIN || pHisto2->numOfEntries > MAX_HISTOGRAM_BIN) {
- return pResHistogram;
+ return code;
}
SHistBin* pHistoBins = taosMemoryCalloc(1, sizeof(SHistBin) * (pHisto1->numOfEntries + pHisto2->numOfEntries));
+ if (NULL == pHistoBins) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
int32_t i = 0, j = 0, k = 0;
while (i < pHisto1->numOfEntries && j < pHisto2->numOfEntries) {
@@ -583,28 +602,28 @@ SHistogramInfo* tHistogramMerge(SHistogramInfo* pHisto1, SHistogramInfo* pHisto2
if (i < pHisto1->numOfEntries) {
int32_t remain = pHisto1->numOfEntries - i;
- memcpy(&pHistoBins[k], &pHisto1->elems[i], sizeof(SHistBin) * remain);
+ (void)memcpy(&pHistoBins[k], &pHisto1->elems[i], sizeof(SHistBin) * remain);
k += remain;
}
if (j < pHisto2->numOfEntries) {
int32_t remain = pHisto2->numOfEntries - j;
- memcpy(&pHistoBins[k], &pHisto2->elems[j], sizeof(SHistBin) * remain);
+ (void)memcpy(&pHistoBins[k], &pHisto2->elems[j], sizeof(SHistBin) * remain);
k += remain;
}
/* update other information */
- pResHistogram->numOfElems = pHisto1->numOfElems + pHisto2->numOfElems;
- pResHistogram->min = (pHisto1->min < pHisto2->min) ? pHisto1->min : pHisto2->min;
- pResHistogram->max = (pHisto1->max > pHisto2->max) ? pHisto1->max : pHisto2->max;
+ (*pResHistogram)->numOfElems = pHisto1->numOfElems + pHisto2->numOfElems;
+ (*pResHistogram)->min = (pHisto1->min < pHisto2->min) ? pHisto1->min : pHisto2->min;
+ (*pResHistogram)->max = (pHisto1->max > pHisto2->max) ? pHisto1->max : pHisto2->max;
while (k > numOfEntries) {
histogramMergeImpl(pHistoBins, &k);
}
- pResHistogram->numOfEntries = k;
- memcpy(pResHistogram->elems, pHistoBins, sizeof(SHistBin) * k);
+ (*pResHistogram)->numOfEntries = k;
+ (void)memcpy((*pResHistogram)->elems, pHistoBins, sizeof(SHistBin) * k);
taosMemoryFree(pHistoBins);
- return pResHistogram;
+ return TSDB_CODE_SUCCESS;
}
diff --git a/source/libs/function/src/tpercentile.c b/source/libs/function/src/tpercentile.c
index a068186992..40e0407a54 100644
--- a/source/libs/function/src/tpercentile.c
+++ b/source/libs/function/src/tpercentile.c
@@ -28,9 +28,12 @@
int32_t getGroupId(int32_t numOfSlots, int32_t slotIndex, int32_t times) { return (times * numOfSlots) + slotIndex; }
-static SFilePage *loadDataFromFilePage(tMemBucket *pMemBucket, int32_t slotIdx) {
- SFilePage *buffer =
+static int32_t loadDataFromFilePage(tMemBucket *pMemBucket, int32_t slotIdx, SFilePage ** buffer) {
+ *buffer =
(SFilePage *)taosMemoryCalloc(1, pMemBucket->bytes * pMemBucket->pSlots[slotIdx].info.size + sizeof(SFilePage));
+ if (NULL == *buffer) {
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
int32_t groupId = getGroupId(pMemBucket->numOfSlots, slotIdx, pMemBucket->times);
@@ -39,26 +42,30 @@ static SFilePage *loadDataFromFilePage(tMemBucket *pMemBucket, int32_t slotIdx)
if (p != NULL) {
pIdList = *(SArray **)p;
} else {
- taosMemoryFree(buffer);
- return NULL;
+ taosMemoryFree(*buffer);
+ return TSDB_CODE_OUT_OF_MEMORY;
}
int32_t offset = 0;
for (int32_t i = 0; i < taosArrayGetSize(pIdList); ++i) {
int32_t *pageId = taosArrayGet(pIdList, i);
+ if (pageId == NULL) {
+ taosMemoryFree(*buffer);
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
SFilePage *pg = getBufPage(pMemBucket->pBuffer, *pageId);
if (pg == NULL) {
- taosMemoryFree(buffer);
- return NULL;
+ taosMemoryFree(*buffer);
+ return terrno;
}
- memcpy(buffer->data + offset, pg->data, (size_t)(pg->num * pMemBucket->bytes));
+ (void)memcpy((*buffer)->data + offset, pg->data, (size_t)(pg->num * pMemBucket->bytes));
offset += (int32_t)(pg->num * pMemBucket->bytes);
}
- taosSort(buffer->data, pMemBucket->pSlots[slotIdx].info.size, pMemBucket->bytes, pMemBucket->comparFn);
- return buffer;
+ taosSort((*buffer)->data, pMemBucket->pSlots[slotIdx].info.size, pMemBucket->bytes, pMemBucket->comparFn);
+ return TSDB_CODE_SUCCESS;
}
static void resetBoundingBox(MinMaxEntry *range, int32_t type) {
@@ -116,6 +123,9 @@ int32_t findOnlyResult(tMemBucket *pMemBucket, double *result) {
ASSERT(list->size == 1);
int32_t *pageId = taosArrayGet(list, 0);
+ if (NULL == pageId) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
SFilePage *pPage = getBufPage(pMemBucket->pBuffer, *pageId);
if (pPage == NULL) {
return terrno;
@@ -238,67 +248,71 @@ static void resetSlotInfo(tMemBucket *pBucket) {
}
}
-tMemBucket *tMemBucketCreate(int32_t nElemSize, int16_t dataType, double minval, double maxval, bool hasWindowOrGroup) {
- tMemBucket *pBucket = (tMemBucket *)taosMemoryCalloc(1, sizeof(tMemBucket));
- if (pBucket == NULL) {
- return NULL;
+int32_t tMemBucketCreate(int32_t nElemSize, int16_t dataType, double minval, double maxval, bool hasWindowOrGroup,
+ tMemBucket **pBucket) {
+ *pBucket = (tMemBucket *)taosMemoryCalloc(1, sizeof(tMemBucket));
+ if (*pBucket == NULL) {
+ return TSDB_CODE_OUT_OF_MEMORY;
}
if (hasWindowOrGroup) {
// With window or group by, we need to shrink page size and reduce page num to save memory.
- pBucket->numOfSlots = DEFAULT_NUM_OF_SLOT / 8 ; // 128 bucket
- pBucket->bufPageSize = 4096; // 4k per page
+ (*pBucket)->numOfSlots = DEFAULT_NUM_OF_SLOT / 8 ; // 128 bucket
+ (*pBucket)->bufPageSize = 4096; // 4k per page
} else {
- pBucket->numOfSlots = DEFAULT_NUM_OF_SLOT;
- pBucket->bufPageSize = 16384 * 4; // 16k per page
+ (*pBucket)->numOfSlots = DEFAULT_NUM_OF_SLOT;
+ (*pBucket)->bufPageSize = 16384 * 4; // 16k per page
}
- pBucket->type = dataType;
- pBucket->bytes = nElemSize;
- pBucket->total = 0;
- pBucket->times = 1;
+ (*pBucket)->type = dataType;
+ (*pBucket)->bytes = nElemSize;
+ (*pBucket)->total = 0;
+ (*pBucket)->times = 1;
- pBucket->maxCapacity = 200000;
- pBucket->groupPagesMap = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
- if (setBoundingBox(&pBucket->range, pBucket->type, minval, maxval) != 0) {
+ (*pBucket)->maxCapacity = 200000;
+ (*pBucket)->groupPagesMap = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK);
+ if ((*pBucket)->groupPagesMap == NULL) {
+ tMemBucketDestroy(*pBucket);
+ return terrno;
+ }
+ if (setBoundingBox(&(*pBucket)->range, (*pBucket)->type, minval, maxval) != 0) {
// qError("MemBucket:%p, invalid value range: %f-%f", pBucket, minval, maxval);
- taosMemoryFree(pBucket);
- return NULL;
+ tMemBucketDestroy(*pBucket);
+ return TSDB_CODE_FUNC_INVALID_VALUE_RANGE;
}
- pBucket->elemPerPage = (pBucket->bufPageSize - sizeof(SFilePage)) / pBucket->bytes;
- pBucket->comparFn = getKeyComparFunc(pBucket->type, TSDB_ORDER_ASC);
+ (*pBucket)->elemPerPage = ((*pBucket)->bufPageSize - sizeof(SFilePage)) / (*pBucket)->bytes;
+ (*pBucket)->comparFn = getKeyComparFunc((*pBucket)->type, TSDB_ORDER_ASC);
- pBucket->hashFunc = getHashFunc(pBucket->type);
- if (pBucket->hashFunc == NULL) {
+ (*pBucket)->hashFunc = getHashFunc((*pBucket)->type);
+ if ((*pBucket)->hashFunc == NULL) {
// qError("MemBucket:%p, not support data type %d, failed", pBucket, pBucket->type);
- taosMemoryFree(pBucket);
- return NULL;
+ tMemBucketDestroy(*pBucket);
+ return TSDB_CODE_FUNC_FUNTION_PARA_TYPE;
}
- pBucket->pSlots = (tMemBucketSlot *)taosMemoryCalloc(pBucket->numOfSlots, sizeof(tMemBucketSlot));
- if (pBucket->pSlots == NULL) {
- taosMemoryFree(pBucket);
- return NULL;
+ (*pBucket)->pSlots = (tMemBucketSlot *)taosMemoryCalloc((*pBucket)->numOfSlots, sizeof(tMemBucketSlot));
+ if ((*pBucket)->pSlots == NULL) {
+ tMemBucketDestroy(*pBucket);
+ return TSDB_CODE_OUT_OF_MEMORY;
}
- resetSlotInfo(pBucket);
+ resetSlotInfo((*pBucket));
if (!osTempSpaceAvailable()) {
- terrno = TSDB_CODE_NO_DISKSPACE;
// qError("MemBucket create disk based Buf failed since %s", terrstr(terrno));
- tMemBucketDestroy(pBucket);
- return NULL;
+ tMemBucketDestroy(*pBucket);
+ return TSDB_CODE_NO_DISKSPACE;
}
- int32_t ret = createDiskbasedBuf(&pBucket->pBuffer, pBucket->bufPageSize, pBucket->bufPageSize * 1024, "1", tsTempDir);
+ int32_t ret = createDiskbasedBuf(&(*pBucket)->pBuffer, (*pBucket)->bufPageSize, (*pBucket)->bufPageSize * 1024, "1", tsTempDir);
if (ret != 0) {
- tMemBucketDestroy(pBucket);
- return NULL;
+ tMemBucketDestroy(*pBucket);
+ return ret;
}
// qDebug("MemBucket:%p, elem size:%d", pBucket, pBucket->bytes);
- return pBucket;
+ return TSDB_CODE_SUCCESS;
}
void tMemBucketDestroy(tMemBucket *pBucket) {
@@ -394,7 +408,14 @@ int32_t tMemBucketPut(tMemBucket *pBucket, const void *data, size_t size) {
void *p = taosHashGet(pBucket->groupPagesMap, &groupId, sizeof(groupId));
if (p == NULL) {
pPageIdList = taosArrayInit(4, sizeof(int32_t));
- taosHashPut(pBucket->groupPagesMap, &groupId, sizeof(groupId), &pPageIdList, POINTER_BYTES);
+ if (NULL == pPageIdList) {
+ return terrno;
+ }
+ int32_t code = taosHashPut(pBucket->groupPagesMap, &groupId, sizeof(groupId), &pPageIdList, POINTER_BYTES);
+ if (TSDB_CODE_SUCCESS != code) {
+ taosArrayDestroy(pPageIdList);
+ return code;
+ }
} else {
pPageIdList = *(SArray **)p;
}
@@ -404,10 +425,13 @@ int32_t tMemBucketPut(tMemBucket *pBucket, const void *data, size_t size) {
return terrno;
}
pSlot->info.pageId = pageId;
- taosArrayPush(pPageIdList, &pageId);
+ if (taosArrayPush(pPageIdList, &pageId) == NULL) {
+ taosArrayDestroy(pPageIdList);
+ return TSDB_CODE_OUT_OF_MEMORY;
+ }
}
- memcpy(pSlot->info.data->data + pSlot->info.data->num * pBucket->bytes, d, pBucket->bytes);
+ (void)memcpy(pSlot->info.data->data + pSlot->info.data->num * pBucket->bytes, d, pBucket->bytes);
pSlot->info.data->num += 1;
pSlot->info.size += 1;
@@ -493,9 +517,10 @@ int32_t getPercentileImpl(tMemBucket *pMemBucket, int32_t count, double fraction
if (pSlot->info.size <= pMemBucket->maxCapacity) {
// data in buffer and file are merged together to be processed.
- SFilePage *buffer = loadDataFromFilePage(pMemBucket, i);
- if (buffer == NULL) {
- return terrno;
+ SFilePage *buffer = NULL;
+ int32_t code = loadDataFromFilePage(pMemBucket, i, &buffer);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
}
int32_t currentIdx = count - num;
@@ -541,6 +566,9 @@ int32_t getPercentileImpl(tMemBucket *pMemBucket, int32_t count, double fraction
for (int32_t f = 0; f < list->size; ++f) {
int32_t *pageId = taosArrayGet(list, f);
+ if (NULL == pageId) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
SFilePage *pg = getBufPage(pMemBucket->pBuffer, *pageId);
if (pg == NULL) {
return terrno;
diff --git a/source/libs/function/src/tudf.c b/source/libs/function/src/tudf.c
index 3c5e4014b3..c9b8a1e08b 100644
--- a/source/libs/function/src/tudf.c
+++ b/source/libs/function/src/tudf.c
@@ -1011,7 +1011,7 @@ void releaseUdfFuncHandle(char *udfName, UdfcFuncHandle handle);
int32_t cleanUpUdfs();
bool udfAggGetEnv(struct SFunctionNode *pFunc, SFuncExecEnv *pEnv);
-bool udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo);
+int32_t udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo);
int32_t udfAggProcess(struct SqlFunctionCtx *pCtx);
int32_t udfAggFinalize(struct SqlFunctionCtx *pCtx, SSDataBlock *pBlock);
@@ -1196,15 +1196,18 @@ bool udfAggGetEnv(struct SFunctionNode *pFunc, SFuncExecEnv *pEnv) {
return true;
}
-bool udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo) {
- if (functionSetup(pCtx, pResultCellInfo) != true) {
- return false;
+int32_t udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo) {
+ if (pResultCellInfo->initialized) {
+ return TSDB_CODE_SUCCESS;
+ }
+ if (functionSetup(pCtx, pResultCellInfo) != TSDB_CODE_SUCCESS) {
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
UdfcFuncHandle handle;
int32_t udfCode = 0;
if ((udfCode = acquireUdfFuncHandle((char *)pCtx->udfName, &handle)) != 0) {
fnError("udfAggInit error. step doSetupUdf. udf code: %d", udfCode);
- return false;
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
SUdfcUvSession *session = (SUdfcUvSession *)handle;
SUdfAggRes *udfRes = (SUdfAggRes *)GET_ROWCELL_INTERBUF(pResultCellInfo);
@@ -1218,7 +1221,7 @@ bool udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResult
if ((udfCode = doCallUdfAggInit(handle, &buf)) != 0) {
fnError("udfAggInit error. step doCallUdfAggInit. udf code: %d", udfCode);
releaseUdfFuncHandle(pCtx->udfName, handle);
- return false;
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
if (buf.bufLen <= session->bufSize) {
memcpy(udfRes->interResBuf, buf.buf, buf.bufLen);
@@ -1227,11 +1230,11 @@ bool udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResult
} else {
fnError("udfc inter buf size %d is greater than function bufSize %d", buf.bufLen, session->bufSize);
releaseUdfFuncHandle(pCtx->udfName, handle);
- return false;
+ return TSDB_CODE_FUNC_SETUP_ERROR;
}
releaseUdfFuncHandle(pCtx->udfName, handle);
freeUdfInterBuf(&buf);
- return true;
+ return TSDB_CODE_SUCCESS;
}
int32_t udfAggProcess(struct SqlFunctionCtx *pCtx) {
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 844a608456..e67001889e 100644
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -10420,8 +10420,9 @@ static int32_t createLastTsSelectStmt(char* pDb, const char* pTable, const char*
return code;
}
- SNode* pFunc = (SNode*)createFunction("last", pParameterList);
- if (NULL == pFunc) {
+ SNode* pFunc = NULL;
+ code = createFunction("last", pParameterList, (SFunctionNode**)&pFunc);
+ if (code) {
nodesDestroyList(pParameterList);
return TSDB_CODE_OUT_OF_MEMORY;
}
@@ -10438,8 +10439,9 @@ static int32_t createLastTsSelectStmt(char* pDb, const char* pTable, const char*
return code;
}
- SFunctionNode* pFunc1 = createFunction("_vgid", NULL);
- if (NULL == pFunc1) {
+ SFunctionNode* pFunc1 = NULL;
+ code = createFunction("_vgid", NULL, &pFunc1);
+ if (code) {
nodesDestroyList(pProjectionList);
return TSDB_CODE_OUT_OF_MEMORY;
}
@@ -10451,8 +10453,9 @@ static int32_t createLastTsSelectStmt(char* pDb, const char* pTable, const char*
return code;
}
- SFunctionNode* pFunc2 = createFunction("_vgver", NULL);
- if (NULL == pFunc2) {
+ SFunctionNode* pFunc2 = NULL;
+ code = createFunction("_vgver", NULL, &pFunc2);
+ if (code) {
nodesDestroyList(pProjectionList);
return TSDB_CODE_OUT_OF_MEMORY;
}
diff --git a/source/libs/parser/test/parTestMain.cpp b/source/libs/parser/test/parTestMain.cpp
index 8d13d7cf0e..c8925b3df7 100644
--- a/source/libs/parser/test/parTestMain.cpp
+++ b/source/libs/parser/test/parTestMain.cpp
@@ -35,7 +35,8 @@ namespace ParserTest {
class ParserEnv : public testing::Environment {
public:
virtual void SetUp() {
- fmFuncMgtInit();
+ // TODO(smj) : How to handle return value of fmFuncMgtInit
+ (void)fmFuncMgtInit();
initMetaDataEnv();
generateMetaData();
initLog(TD_TMP_DIR_PATH "td");
diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c
index b1db171875..b72cad012d 100644
--- a/source/libs/planner/src/planOptimizer.c
+++ b/source/libs/planner/src/planOptimizer.c
@@ -5336,9 +5336,13 @@ static bool stbJoinOptShouldBeOptimized(SLogicNode* pNode) {
}
int32_t stbJoinOptAddFuncToScanNode(char* funcName, SScanLogicNode* pScan) {
- SFunctionNode* pUidFunc = createFunction(funcName, NULL);
+ SFunctionNode* pUidFunc = NULL;
+ int32_t code = createFunction(funcName, NULL, &pUidFunc);
+ if (TSDB_CODE_SUCCESS != code) {
+ return code;
+ }
snprintf(pUidFunc->node.aliasName, sizeof(pUidFunc->node.aliasName), "%s.%p", pUidFunc->functionName, pUidFunc);
- int32_t code = nodesListStrictAppend(pScan->pScanPseudoCols, (SNode*)pUidFunc);
+ code = nodesListStrictAppend(pScan->pScanPseudoCols, (SNode*)pUidFunc);
if (TSDB_CODE_SUCCESS == code) {
code = createColumnByRewriteExpr((SNode*)pUidFunc, &pScan->node.pTargets);
}
diff --git a/source/libs/planner/test/planTestMain.cpp b/source/libs/planner/test/planTestMain.cpp
index 4e013c44b8..e05fa27c1e 100644
--- a/source/libs/planner/test/planTestMain.cpp
+++ b/source/libs/planner/test/planTestMain.cpp
@@ -27,7 +27,8 @@
class PlannerEnv : public testing::Environment {
public:
virtual void SetUp() {
- fmFuncMgtInit();
+ // TODO(smj) : How to handle return value of fmFuncMgtInit
+ (void)fmFuncMgtInit();
initMetaDataEnv();
generateMetaData();
initLog(TD_TMP_DIR_PATH "td");
diff --git a/source/libs/scalar/src/filter.c b/source/libs/scalar/src/filter.c
index 105243608e..19b4c521a4 100644
--- a/source/libs/scalar/src/filter.c
+++ b/source/libs/scalar/src/filter.c
@@ -997,9 +997,15 @@ int32_t filterDetachCnfGroups(SArray *group, SArray *left, SArray *right) {
for (int32_t l = 0; l < leftSize; ++l) {
SFilterGroup *gp1 = taosArrayGet(left, l);
+ if (NULL == gp1) {
+ FLT_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
for (int32_t r = 0; r < rightSize; ++r) {
SFilterGroup *gp2 = taosArrayGet(right, r);
+ if (NULL == gp2) {
+ FLT_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
FLT_ERR_RET(filterDetachCnfGroup(gp1, gp2, group));
}
@@ -1212,7 +1218,7 @@ int32_t filterAddUnitImpl(SFilterInfo *info, uint8_t optr, SFilterFieldId *left,
FLT_PACKAGE_UNIT_HASH_KEY(&v, optr, optr2, left->idx, (right ? right->idx : -1), (right2 ? right2->idx : -1));
if (taosHashPut(info->pctx.unitHash, v, sizeof(v), uidx, sizeof(*uidx))) {
fltError("taosHashPut to set failed");
- FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+ FLT_ERR_RET(terrno);
}
}
@@ -2157,7 +2163,7 @@ int32_t fltInitValFieldData(SFilterInfo *info) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(fi->data), varDataLen(fi->data), varDataVal(newValData));
if (len < 0) {
qError("filterInitValFieldData taosUcs4ToMbs error 1");
- return TSDB_CODE_APP_ERROR;
+ return TSDB_CODE_SCALAR_CONVERT_ERROR;
}
varDataSetLen(newValData, len);
(void)varDataCopy(fi->data, newValData);
@@ -2307,6 +2313,9 @@ int32_t filterMergeUnits(SFilterInfo *info, SFilterGroupCtx *gRes, uint32_t colI
for (uint32_t i = 0; i < size; ++i) {
SFilterUnit *u = taosArrayGetP(colArray, i);
+ if (NULL == u) {
+ FLT_ERR_JRET(TSDB_CODE_OUT_OF_RANGE);
+ }
uint8_t optr = FILTER_UNIT_OPTR(u);
FLT_ERR_RET(filterAddRangeOptr(ctx, optr, LOGIC_COND_TYPE_AND, empty, NULL));
@@ -2637,6 +2646,9 @@ int32_t filterMergeTwoGroups(SFilterInfo *info, SFilterGroupCtx **gRes1, SFilter
for (int32_t i = 0; i < ctxSize; ++i) {
pctx = taosArrayGet(colCtxs, i);
+ if (NULL == pctx) {
+ FLT_ERR_JRET(TSDB_CODE_OUT_OF_RANGE);
+ }
colInfo = &(*gRes1)->colInfo[pctx->colIdx];
filterFreeColInfo(colInfo);
@@ -2763,6 +2775,9 @@ int32_t filterConvertGroupFromArray(SFilterInfo *info, SArray *group) {
for (size_t i = 0; i < groupSize; ++i) {
SFilterGroup *pg = taosArrayGet(group, i);
+ if (NULL == pg) {
+ FLT_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
pg->unitFlags = taosMemoryCalloc(pg->unitNum, sizeof(*pg->unitFlags));
if (pg->unitFlags == NULL) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
@@ -2819,7 +2834,9 @@ int32_t filterRewrite(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t gResNum
for (int32_t n = 0; n < usize; ++n) {
SFilterUnit *u = (SFilterUnit *)taosArrayGetP((SArray *)colInfo->info, n);
-
+ if (NULL == u) {
+ FLT_ERR_JRET(TSDB_CODE_OUT_OF_RANGE);
+ }
FLT_ERR_JRET(filterAddUnitFromUnit(info, &oinfo, u, &uidx));
FLT_ERR_JRET(filterAddUnitToGroup(&ng, uidx));
}
@@ -3425,7 +3442,7 @@ int32_t filterExecuteImplMisc(void *pinfo, int32_t numOfRows, SColumnInfoData *p
if (len < 0) {
qError("castConvert1 taosUcs4ToMbs error");
taosMemoryFreeClear(newColData);
- FLT_ERR_RET(TSDB_CODE_APP_ERROR);
+ FLT_ERR_RET(TSDB_CODE_SCALAR_CONVERT_ERROR);
} else {
varDataSetLen(newColData, len);
p[i] = filterDoCompare(gDataCompare[info->cunits[uidx].func], info->cunits[uidx].optr, newColData,
@@ -3500,7 +3517,7 @@ int32_t filterExecuteImpl(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes,
if (len < 0) {
qError("castConvert1 taosUcs4ToMbs error");
taosMemoryFreeClear(newColData);
- FLT_ERR_RET(TSDB_CODE_APP_ERROR);
+ FLT_ERR_RET(TSDB_CODE_SCALAR_CONVERT_ERROR);
} else {
varDataSetLen(newColData, len);
p[i] = filterDoCompare(gDataCompare[cunit->func], cunit->optr, newColData, cunit->valData);
@@ -3814,6 +3831,9 @@ int32_t fltSclMergeSort(SArray *pts1, SArray *pts2, SArray *result) {
while (i < len1 && j < len2) {
SFltSclPoint *pt1 = taosArrayGet(pts1, i);
SFltSclPoint *pt2 = taosArrayGet(pts2, j);
+ if (NULL == pt1 || NULL == pt2) {
+ FLT_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
bool less = fltSclLessPoint(pt1, pt2);
if (less) {
if (NULL == taosArrayPush(result, pt1)) {
@@ -3830,6 +3850,9 @@ int32_t fltSclMergeSort(SArray *pts1, SArray *pts2, SArray *result) {
if (i < len1) {
for (; i < len1; ++i) {
SFltSclPoint *pt1 = taosArrayGet(pts1, i);
+ if (NULL == pt1) {
+ FLT_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
if (NULL == taosArrayPush(result, pt1)) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
@@ -3838,6 +3861,9 @@ int32_t fltSclMergeSort(SArray *pts1, SArray *pts2, SArray *result) {
if (j < len2) {
for (; j < len2; ++j) {
SFltSclPoint *pt2 = taosArrayGet(pts2, j);
+ if (NULL == pt2) {
+ FLT_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
if (NULL == taosArrayPush(result, pt2)) {
FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
}
@@ -3859,6 +3885,9 @@ int32_t fltSclMerge(SArray *pts1, SArray *pts2, bool isUnion, SArray *merged) {
int32_t count = 0;
for (int32_t i = 0; i < taosArrayGetSize(all); ++i) {
SFltSclPoint *pt = taosArrayGet(all, i);
+ if (NULL == pt) {
+ FLT_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
if (pt->start) {
++count;
if (count == countRequired) {
@@ -3893,6 +3922,9 @@ typedef struct {
int32_t fltSclGetOrCreateColumnRange(SColumnNode *colNode, SArray *colRangeList, SFltSclColumnRange **colRange) {
for (int32_t i = 0; i < taosArrayGetSize(colRangeList); ++i) {
*colRange = taosArrayGet(colRangeList, i);
+ if (NULL == colRange) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
if (nodesEqualNode((SNode *)(*colRange)->colNode, (SNode *)colNode)) {
return TSDB_CODE_SUCCESS;
}
@@ -4044,6 +4076,9 @@ int32_t filterRangeExecute(SFilterInfo *info, SColumnDataAgg *pDataStatis, int32
SArray *colRanges = info->sclCtx.fltSclRange;
for (int32_t i = 0; i < taosArrayGetSize(colRanges); ++i) {
SFltSclColumnRange *colRange = taosArrayGet(colRanges, i);
+ if (NULL == colRange) {
+ FLT_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
bool foundCol = false;
int32_t j = 0;
for (; j < numOfCols; ++j) {
@@ -4332,11 +4367,17 @@ int32_t filterGetTimeRange(SNode *pNode, STimeWindow *win, bool *isStrict) {
SArray *colRanges = info->sclCtx.fltSclRange;
if (taosArrayGetSize(colRanges) == 1) {
SFltSclColumnRange *colRange = taosArrayGet(colRanges, 0);
+ if (NULL == colRange) {
+ FLT_ERR_JRET(TSDB_CODE_OUT_OF_RANGE);
+ }
SArray *points = colRange->points;
if (taosArrayGetSize(points) == 2) {
*win = TSWINDOW_DESC_INITIALIZER;
SFltSclPoint *startPt = taosArrayGet(points, 0);
SFltSclPoint *endPt = taosArrayGet(points, 1);
+ if (NULL == startPt || NULL == endPt) {
+ FLT_ERR_JRET(TSDB_CODE_OUT_OF_RANGE);
+ }
SFltSclDatum start;
SFltSclDatum end;
FLT_ERR_JRET(fltSclGetTimeStampDatum(startPt, &start));
@@ -4398,7 +4439,7 @@ int32_t filterConverNcharColumns(SFilterInfo *info, int32_t rows, bool *gotNchar
bool ret = taosMbsToUcs4(varDataVal(src), varDataLen(src), (TdUcs4 *)varDataVal(dst), bufSize, &len);
if (!ret) {
qError("filterConverNcharColumns taosMbsToUcs4 error");
- return TSDB_CODE_FAILED;
+ return TSDB_CODE_SCALAR_CONVERT_ERROR;
}
varDataLen(dst) = len;
}
@@ -4432,7 +4473,7 @@ int32_t fltAddValueNodeToConverList(SFltTreeStat *stat, SValueNode *pNode) {
if (NULL == stat->nodeList) {
stat->nodeList = taosArrayInit(10, POINTER_BYTES);
if (NULL == stat->nodeList) {
- FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+ FLT_ERR_RET(terrno);
}
}
@@ -4816,6 +4857,9 @@ int32_t fltSclProcessCNF(SArray *sclOpListCNF, SArray *colRangeList) {
size_t sz = taosArrayGetSize(sclOpListCNF);
for (int32_t i = 0; i < sz; ++i) {
SFltSclOperator *sclOper = taosArrayGet(sclOpListCNF, i);
+ if (NULL == sclOper) {
+ FLT_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
SFltSclColumnRange *colRange = NULL;
FLT_ERR_RET(fltSclGetOrCreateColumnRange(sclOper->colNode, colRangeList, &colRange));
SArray *points = taosArrayInit(4, sizeof(SFltSclPoint));
@@ -4920,22 +4964,27 @@ static int32_t fltSclCollectOperators(SNode *pNode, SArray *sclOpList) {
int32_t fltOptimizeNodes(SFilterInfo *pInfo, SNode **pNode, SFltTreeStat *pStat) {
SArray *sclOpList = taosArrayInit(16, sizeof(SFltSclOperator));
+ int32_t code = TSDB_CODE_SUCCESS;
if (NULL == sclOpList) {
FLT_ERR_RET(terrno);
}
- FLT_ERR_RET(fltSclCollectOperators(*pNode, sclOpList));
+ FLT_ERR_JRET(fltSclCollectOperators(*pNode, sclOpList));
SArray *colRangeList = taosArrayInit(16, sizeof(SFltSclColumnRange));
if (NULL == colRangeList) {
FLT_ERR_RET(terrno);
}
- FLT_ERR_RET(fltSclProcessCNF(sclOpList, colRangeList));
+ FLT_ERR_JRET(fltSclProcessCNF(sclOpList, colRangeList));
pInfo->sclCtx.fltSclRange = colRangeList;
for (int32_t i = 0; i < taosArrayGetSize(sclOpList); ++i) {
SFltSclOperator *sclOp = taosArrayGet(sclOpList, i);
+ if (NULL == sclOp) {
+ FLT_ERR_JRET(TSDB_CODE_OUT_OF_RANGE);
+ }
nodesDestroyNode((SNode *)sclOp->colNode);
nodesDestroyNode((SNode *)sclOp->valNode);
}
+_return:
taosArrayDestroy(sclOpList);
return TSDB_CODE_SUCCESS;
}
@@ -4946,6 +4995,9 @@ int32_t fltGetDataFromColId(void *param, int32_t id, void **data) {
for (int32_t j = 0; j < numOfCols; ++j) {
SColumnInfoData *pColInfo = taosArrayGet(pDataBlock, j);
+ if (NULL == pColInfo) {
+ FLT_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
if (id == pColInfo->info.colId) {
*data = pColInfo;
break;
@@ -4965,6 +5017,9 @@ int32_t fltGetDataFromSlotId(void *param, int32_t id, void **data) {
}
SColumnInfoData *pColInfo = taosArrayGet(pDataBlock, id);
+ if (NULL == pColInfo) {
+ return TSDB_CODE_OUT_OF_RANGE;
+ }
*data = pColInfo;
return TSDB_CODE_SUCCESS;
diff --git a/source/libs/scalar/src/scalar.c b/source/libs/scalar/src/scalar.c
index 346bbb2811..040e090661 100644
--- a/source/libs/scalar/src/scalar.c
+++ b/source/libs/scalar/src/scalar.c
@@ -90,6 +90,9 @@ int32_t sclConvertValueToSclParam(SValueNode *pValueNode, SScalarParam *out, int
int32_t sclExtendResRows(SScalarParam *pDst, SScalarParam *pSrc, SArray *pBlockList) {
SSDataBlock *pb = taosArrayGetP(pBlockList, 0);
+ if (NULL == pb) {
+ SCL_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
SScalarParam *pLeft = taosMemoryCalloc(1, sizeof(SScalarParam));
int32_t code = TSDB_CODE_SUCCESS;
if (NULL == pLeft) {
@@ -116,7 +119,7 @@ int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type) {
SHashObj *pObj = taosHashInit(256, taosGetDefaultHashFunction(type), true, false);
if (NULL == pObj) {
sclError("taosHashInit failed, size:%d", 256);
- SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+ SCL_ERR_RET(terrno);
}
taosHashSetEqualFp(pObj, taosGetDefaultEqualFunction(type));
@@ -176,7 +179,7 @@ int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type) {
if (taosHashPut(pObj, buf, (size_t)len, NULL, 0)) {
sclError("taosHashPut to set failed");
- SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
+ SCL_ERR_JRET(terrno);
}
colInfoDataCleanup(out.columnData, out.numOfRows);
@@ -336,6 +339,9 @@ int32_t sclInitParam(SNode *node, SScalarParam *param, SScalarCtx *ctx, int32_t
switch (nodeType(node)) {
case QUERY_NODE_LEFT_VALUE: {
SSDataBlock *pb = taosArrayGetP(ctx->pBlockList, 0);
+ if (NULL == pb) {
+ SCL_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
param->numOfRows = pb->info.rows;
break;
}
@@ -347,10 +353,7 @@ int32_t sclInitParam(SNode *node, SScalarParam *param, SScalarCtx *ctx, int32_t
SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
}
param->numOfRows = 1;
- int32_t code = sclCreateColumnInfoData(&valueNode->node.resType, 1, param);
- if (code != TSDB_CODE_SUCCESS) {
- SCL_RET(TSDB_CODE_OUT_OF_MEMORY);
- }
+ SCL_ERR_RET(sclCreateColumnInfoData(&valueNode->node.resType, 1, param));
if (TSDB_DATA_TYPE_NULL == valueNode->node.resType.type || valueNode->isNull) {
colDataSetNULL(param->columnData, 0);
} else {
@@ -377,7 +380,7 @@ int32_t sclInitParam(SNode *node, SScalarParam *param, SScalarCtx *ctx, int32_t
taosHashCleanup(param->pHashFilter);
param->pHashFilter = NULL;
sclError("taosHashPut nodeList failed, size:%d", (int32_t)sizeof(*param));
- return TSDB_CODE_OUT_OF_MEMORY;
+ return terrno;
}
param->colAlloced = false;
break;
@@ -393,6 +396,9 @@ int32_t sclInitParam(SNode *node, SScalarParam *param, SScalarCtx *ctx, int32_t
int32_t index = -1;
for (int32_t i = 0; i < taosArrayGetSize(ctx->pBlockList); ++i) {
SSDataBlock *pb = taosArrayGetP(ctx->pBlockList, i);
+ if (NULL == pb) {
+ SCL_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
if (pb->info.id.blockId == ref->dataBlockId) {
index = i;
break;
@@ -461,6 +467,9 @@ int32_t sclInitParamList(SScalarParam **pParams, SNodeList *pParamList, SScalarC
if (NULL == pParamList) {
if (ctx->pBlockList) {
SSDataBlock *pBlock = taosArrayGetP(ctx->pBlockList, 0);
+ if (NULL == pBlock) {
+ SCL_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
*rowNum = pBlock->info.rows;
} else {
*rowNum = 1;
@@ -919,6 +928,9 @@ int32_t sclExecCaseWhen(SCaseWhenNode *node, SScalarCtx *ctx, SScalarParam *outp
if (ctx->pBlockList) {
SSDataBlock *pb = taosArrayGetP(ctx->pBlockList, 0);
+ if (NULL == pb) {
+ SCL_ERR_RET(TSDB_CODE_OUT_OF_RANGE);
+ }
rowNum = pb->info.rows;
output->numOfRows = pb->info.rows;
}
@@ -1532,6 +1544,10 @@ EDealRes sclWalkTarget(SNode *pNode, SScalarCtx *ctx) {
int32_t index = -1;
for (int32_t i = 0; i < taosArrayGetSize(ctx->pBlockList); ++i) {
SSDataBlock *pb = taosArrayGetP(ctx->pBlockList, i);
+ if (NULL == pb) {
+ ctx->code = TSDB_CODE_OUT_OF_RANGE;
+ return DEAL_RES_ERROR;
+ }
if (pb->info.id.blockId == target->dataBlockId) {
index = i;
break;
@@ -1636,7 +1652,7 @@ int32_t sclCalcConstants(SNode *pNode, bool dual, SNode **pRes) {
ctx.pRes = taosHashInit(SCL_DEFAULT_OP_NUM, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
if (NULL == ctx.pRes) {
sclError("taosHashInit failed, num:%d", SCL_DEFAULT_OP_NUM);
- SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+ SCL_ERR_RET(terrno);
}
nodesRewriteExprPostOrder(&pNode, sclConstantsRewriter, (void *)&ctx);
@@ -1770,7 +1786,7 @@ int32_t scalarCalculate(SNode *pNode, SArray *pBlockList, SScalarParam *pDst) {
ctx.pRes = taosHashInit(SCL_DEFAULT_OP_NUM, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
if (NULL == ctx.pRes) {
sclError("taosHashInit failed, num:%d", SCL_DEFAULT_OP_NUM);
- SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+ SCL_ERR_RET(terrno);
}
nodesWalkExprPostOrder(pNode, sclCalcWalker, (void *)&ctx);
@@ -1784,6 +1800,9 @@ int32_t scalarCalculate(SNode *pNode, SArray *pBlockList, SScalarParam *pDst) {
}
SSDataBlock *pb = taosArrayGetP(pBlockList, 0);
+ if (NULL == pb) {
+ SCL_ERR_JRET(TSDB_CODE_OUT_OF_RANGE);
+ }
if (1 == res->numOfRows && pb->info.rows > 0) {
SCL_ERR_JRET(sclExtendResRows(pDst, res, pBlockList));
} else {
diff --git a/source/libs/scalar/src/sclfunc.c b/source/libs/scalar/src/sclfunc.c
index 5baaa57b1d..fd747ce78a 100644
--- a/source/libs/scalar/src/sclfunc.c
+++ b/source/libs/scalar/src/sclfunc.c
@@ -399,7 +399,7 @@ static int32_t concatCopyHelper(const char *input, char *output, bool hasNchar,
bool ret = taosMbsToUcs4(varDataVal(input), len, newBuf, (varDataLen(input) + 1) * TSDB_NCHAR_SIZE, &len);
if (!ret) {
taosMemoryFree(newBuf);
- return TSDB_CODE_FAILED;
+ return TSDB_CODE_SCALAR_CONVERT_ERROR;
}
memcpy(varDataVal(output) + *dataLen, newBuf, varDataLen(input) * TSDB_NCHAR_SIZE);
*dataLen += varDataLen(input) * TSDB_NCHAR_SIZE;
@@ -818,7 +818,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
@@ -837,7 +837,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
convBuf[len] = 0;
@@ -855,7 +855,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
@@ -874,7 +874,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
convBuf[len] = 0;
@@ -892,7 +892,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
convBuf[len] = 0;
@@ -910,7 +910,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
convBuf[len] = 0;
@@ -928,7 +928,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
convBuf[len] = 0;
@@ -946,7 +946,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
@@ -965,7 +965,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
convBuf[len] = 0;
@@ -983,7 +983,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
convBuf[len] = 0;
@@ -1001,7 +1001,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
convBuf[len] = 0;
@@ -1041,7 +1041,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
} else if (inputType == TSDB_DATA_TYPE_NCHAR) {
int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(input), varDataLen(input), convBuf);
if (len < 0) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
len = TMIN(len, outputLen - VARSTR_HEADER_SIZE);
@@ -1075,7 +1075,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
len = sprintf(tmp, "%.*s", outputCharLen, *(int8_t *)input ? "true" : "false");
bool ret = taosMbsToUcs4(tmp, len, (TdUcs4 *)varDataVal(output), outputLen - VARSTR_HEADER_SIZE, &len);
if (!ret) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
@@ -1085,7 +1085,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
bool ret = taosMbsToUcs4(input + VARSTR_HEADER_SIZE, len, (TdUcs4 *)varDataVal(output),
outputLen - VARSTR_HEADER_SIZE, &len);
if (!ret) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
varDataSetLen(output, len);
@@ -1099,7 +1099,7 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp
len = outputCharLen > len ? len : outputCharLen;
bool ret = taosMbsToUcs4(buf, len, (TdUcs4 *)varDataVal(output), outputLen - VARSTR_HEADER_SIZE, &len);
if (!ret) {
- code = TSDB_CODE_FAILED;
+ code = TSDB_CODE_SCALAR_CONVERT_ERROR;
goto _end;
}
varDataSetLen(output, len);
diff --git a/source/libs/scalar/src/sclvector.c b/source/libs/scalar/src/sclvector.c
index f841ec6618..cbc671a73a 100644
--- a/source/libs/scalar/src/sclvector.c
+++ b/source/libs/scalar/src/sclvector.c
@@ -105,7 +105,7 @@ int32_t convertNcharToDouble(const void *inData, void *outData) {
int len = taosUcs4ToMbs((TdUcs4 *)varDataVal(inData), varDataLen(inData), tmp);
if (len < 0) {
sclError("castConvert taosUcs4ToMbs error 1");
- SCL_ERR_JRET(TSDB_CODE_FAILED);
+ SCL_ERR_JRET(TSDB_CODE_SCALAR_CONVERT_ERROR);
}
tmp[len] = 0;
@@ -596,7 +596,7 @@ int32_t ncharTobinary(void *buf, void **out) { // todo need to remove , if tobi
sclError("charset:%s to %s. val:%s convert ncharTobinary failed.", DEFAULT_UNICODE_ENCODEC, tsCharset,
(char *)varDataVal(buf));
taosMemoryFree(*out);
- SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+ SCL_ERR_RET(TSDB_CODE_SCALAR_CONVERT_ERROR);
}
varDataSetLen(*out, len);
SCL_RET(TSDB_CODE_SUCCESS);
diff --git a/source/libs/stream/src/streamMsg.c b/source/libs/stream/src/streamMsg.c
index b08280f9ed..bc0faacb32 100644
--- a/source/libs/stream/src/streamMsg.c
+++ b/source/libs/stream/src/streamMsg.c
@@ -549,7 +549,7 @@ int32_t tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask) {
if (tEncodeCStrWithLen(pEncoder, pTask->reserve, sizeof(pTask->reserve) - 1) < 0) return -1;
tEndEncode(pEncoder);
- return pEncoder->pos;
+ return 0;
}
int32_t tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask) {
diff --git a/source/libs/sync/src/syncRaftLog.c b/source/libs/sync/src/syncRaftLog.c
index b9c6838fda..19c8837d83 100644
--- a/source/libs/sync/src/syncRaftLog.c
+++ b/source/libs/sync/src/syncRaftLog.c
@@ -206,17 +206,17 @@ static int32_t raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntr
SSyncLogStoreData* pData = pLogStore->data;
SWal* pWal = pData->pWal;
- SyncIndex index = 0;
SWalSyncInfo syncMeta = {0};
syncMeta.isWeek = pEntry->isWeak;
syncMeta.seqNum = pEntry->seqNum;
syncMeta.term = pEntry->term;
+
int64_t tsWriteBegin = taosGetTimestampNs();
- index = walAppendLog(pWal, pEntry->index, pEntry->originalRpcType, syncMeta, pEntry->data, pEntry->dataLen);
+ int32_t code = walAppendLog(pWal, pEntry->index, pEntry->originalRpcType, syncMeta, pEntry->data, pEntry->dataLen);
int64_t tsWriteEnd = taosGetTimestampNs();
int64_t tsElapsed = tsWriteEnd - tsWriteBegin;
- if (index < 0) {
+ if (TSDB_CODE_SUCCESS != code) {
int32_t err = terrno;
const char* errStr = tstrerror(err);
int32_t sysErr = errno;
@@ -227,9 +227,11 @@ static int32_t raftLogAppendEntry(struct SSyncLogStore* pLogStore, SSyncRaftEntr
return -1;
}
- ASSERT(pEntry->index == index);
-
- walFsync(pWal, forceSync);
+ code = walFsync(pWal, forceSync);
+ if (TSDB_CODE_SUCCESS != code) {
+ sNError(pData->pSyncNode, "wal fsync failed since %s", tstrerror(code));
+ TAOS_RETURN(code);
+ }
sNTrace(pData->pSyncNode, "write index:%" PRId64 ", type:%s, origin type:%s, elapsed:%" PRId64, pEntry->index,
TMSG_INFO(pEntry->msgType), TMSG_INFO(pEntry->originalRpcType), tsElapsed);
diff --git a/source/libs/sync/src/syncUtil.c b/source/libs/sync/src/syncUtil.c
index 93a06ddf30..66b7938440 100644
--- a/source/libs/sync/src/syncUtil.c
+++ b/source/libs/sync/src/syncUtil.c
@@ -43,17 +43,16 @@ void syncUtilNodeInfo2EpSet(const SNodeInfo* pInfo, SEpSet* pEpSet) {
bool syncUtilNodeInfo2RaftId(const SNodeInfo* pInfo, SyncGroupId vgId, SRaftId* raftId) {
uint32_t ipv4 = 0xFFFFFFFF;
- sDebug("vgId:%d, start to resolve sync addr fqdn in %d seconds, "
- "dnode:%d cluster:%" PRId64 " fqdn:%s port:%u ",
- vgId, tsResolveFQDNRetryTime,
- pInfo->nodeId, pInfo->clusterId, pInfo->nodeFqdn, pInfo->nodePort);
- for(int i = 0; i < tsResolveFQDNRetryTime; i++){
+ sDebug(
+ "vgId:%d, start to resolve sync addr fqdn in %d seconds, "
+ "dnode:%d cluster:%" PRId64 " fqdn:%s port:%u ",
+ vgId, tsResolveFQDNRetryTime, pInfo->nodeId, pInfo->clusterId, pInfo->nodeFqdn, pInfo->nodePort);
+ for (int i = 0; i < tsResolveFQDNRetryTime; i++) {
ipv4 = taosGetIpv4FromFqdn(pInfo->nodeFqdn);
if (ipv4 == 0xFFFFFFFF || ipv4 == 1) {
sError("failed to resolve ipv4 addr, fqdn:%s, wait one second", pInfo->nodeFqdn);
taosSsleep(1);
- }
- else{
+ } else {
break;
}
}
@@ -501,8 +500,7 @@ void syncLogSendRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteRepl
int32_t syncSnapInfoDataRealloc(SSnapshot* pSnap, int32_t size) {
void* data = taosMemoryRealloc(pSnap->data, size);
if (data == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return -1;
+ return terrno = TSDB_CODE_OUT_OF_MEMORY;
}
pSnap->data = data;
return 0;
diff --git a/source/libs/sync/test/syncRaftLogTest.cpp b/source/libs/sync/test/syncRaftLogTest.cpp
index e309a2e432..883f80dd13 100644
--- a/source/libs/sync/test/syncRaftLogTest.cpp
+++ b/source/libs/sync/test/syncRaftLogTest.cpp
@@ -51,8 +51,14 @@ void test2() {
SWal *pWal = walOpen(gWalPath, &walCfg);
assert(pWal != NULL);
+ SWalSyncInfo syncMeta = {
+ .isWeek = -1,
+ .seqNum = UINT64_MAX,
+ .term = UINT64_MAX,
+ };
+
for (int i = 0; i < 5; ++i) {
- int code = walWrite(pWal, i, 100, "aa", 3);
+ int code = walAppendLog(pWal, i, 100, syncMeta, "aa", 3);
if (code != 0) {
printf("code:%d terror:%d msg:%s i:%d \n", code, terrno, tstrerror(terrno), i);
assert(0);
@@ -105,10 +111,16 @@ void test4() {
SWal *pWal = walOpen(gWalPath, &walCfg);
assert(pWal != NULL);
+ SWalSyncInfo syncMeta = {
+ .isWeek = -1,
+ .seqNum = UINT64_MAX,
+ .term = UINT64_MAX,
+ };
+
walRestoreFromSnapshot(pWal, 5);
for (int i = 6; i < 10; ++i) {
- int code = walWrite(pWal, i, 100, "aa", 3);
+ int code = walAppendLog(pWal, i, 100, syncMeta, "aa", 3);
if (code != 0) {
printf("code:%d terror:%d msg:%s i:%d \n", code, terrno, tstrerror(terrno), i);
assert(0);
diff --git a/source/libs/tdb/src/db/tdbDb.c b/source/libs/tdb/src/db/tdbDb.c
index b9ba9de51f..ca08231d97 100644
--- a/source/libs/tdb/src/db/tdbDb.c
+++ b/source/libs/tdb/src/db/tdbDb.c
@@ -70,7 +70,7 @@ int32_t tdbOpen(const char *dbname, int32_t szPage, int32_t pages, TDB **ppDb, i
ret = taosMulModeMkDir(dbname, 0755, false);
if (ret < 0) {
- return TAOS_SYSTEM_ERROR(ret);
+ return terrno;
}
#ifdef USE_MAINDB
diff --git a/source/libs/tdb/src/db/tdbPager.c b/source/libs/tdb/src/db/tdbPager.c
index 14165045ca..5d8b05ffcf 100644
--- a/source/libs/tdb/src/db/tdbPager.c
+++ b/source/libs/tdb/src/db/tdbPager.c
@@ -957,6 +957,8 @@ static int tdbPagerInitPage(SPager *pPager, SPage *pPage, int (*initPage)(SPage
return -1;
}
+ tmemory_barrier();
+
pPage->pPager = pPager;
TDB_UNLOCK_PAGE(pPage);
diff --git a/source/libs/wal/inc/walInt.h b/source/libs/wal/inc/walInt.h
index 6dc9922981..d493061bdc 100644
--- a/source/libs/wal/inc/walInt.h
+++ b/source/libs/wal/inc/walInt.h
@@ -27,6 +27,15 @@
extern "C" {
#endif
+// clang-format off
+#define wFatal(...) { if (wDebugFlag & DEBUG_FATAL) { taosPrintLog("WAL FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); }}
+#define wError(...) { if (wDebugFlag & DEBUG_ERROR) { taosPrintLog("WAL ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }}
+#define wWarn(...) { if (wDebugFlag & DEBUG_WARN) { taosPrintLog("WAL WARN ", DEBUG_WARN, 255, __VA_ARGS__); }}
+#define wInfo(...) { if (wDebugFlag & DEBUG_INFO) { taosPrintLog("WAL ", DEBUG_INFO, 255, __VA_ARGS__); }}
+#define wDebug(...) { if (wDebugFlag & DEBUG_DEBUG) { taosPrintLog("WAL ", DEBUG_DEBUG, wDebugFlag, __VA_ARGS__); }}
+#define wTrace(...) { if (wDebugFlag & DEBUG_TRACE) { taosPrintLog("WAL ", DEBUG_TRACE, wDebugFlag, __VA_ARGS__); }}
+// clang-format on
+
// meta section begin
typedef struct {
int64_t firstVer;
@@ -144,27 +153,22 @@ static inline void walResetVer(SWalVer* pVer) {
pVer->lastVer = -1;
}
-int walLoadMeta(SWal* pWal);
-int walSaveMeta(SWal* pWal);
-int walRemoveMeta(SWal* pWal);
-int walRollFileInfo(SWal* pWal);
+int32_t walLoadMeta(SWal* pWal);
+int32_t walSaveMeta(SWal* pWal);
+int32_t walRemoveMeta(SWal* pWal);
+int32_t walRollFileInfo(SWal* pWal);
-int walCheckAndRepairMeta(SWal* pWal);
+int32_t walCheckAndRepairMeta(SWal* pWal);
-int walCheckAndRepairIdx(SWal* pWal);
+int32_t walCheckAndRepairIdx(SWal* pWal);
-char* walMetaSerialize(SWal* pWal);
-int walMetaDeserialize(SWal* pWal, const char* bytes);
+int32_t walMetaSerialize(SWal* pWal, char** serialized);
+int32_t walMetaDeserialize(SWal* pWal, const char* bytes);
// meta section end
-// seek section
-int64_t walChangeWrite(SWal* pWal, int64_t ver);
-int walInitWriteFile(SWal* pWal);
-// seek section end
+int32_t decryptBody(SWalCfg* cfg, SWalCkHead* pHead, int32_t plainBodyLen, const char* func);
int64_t walGetSeq();
-int walSeekWriteVer(SWal* pWal, int64_t ver);
-int32_t walRollImpl(SWal* pWal);
#ifdef __cplusplus
}
diff --git a/source/libs/wal/src/walMeta.c b/source/libs/wal/src/walMeta.c
index ac33b1d6b7..df9ef041c6 100644
--- a/source/libs/wal/src/walMeta.c
+++ b/source/libs/wal/src/walMeta.c
@@ -46,10 +46,14 @@ static FORCE_INLINE int walBuildTmpMetaName(SWal* pWal, char* buf) {
return sprintf(buf, "%s/meta-ver.tmp", pWal->path);
}
-static FORCE_INLINE int64_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx) {
+static FORCE_INLINE int32_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx, int64_t* lastVer) {
+ int32_t code = 0, lino = 0;
int32_t sz = taosArrayGetSize(pWal->fileInfoSet);
+ int64_t retVer = -1;
+ void* ptr = NULL;
SWalFileInfo* pFileInfo = taosArrayGet(pWal->fileInfoSet, fileIdx);
- char fnameStr[WAL_FILE_LEN];
+
+ char fnameStr[WAL_FILE_LEN];
walBuildLogName(pWal, pFileInfo->firstVer, fnameStr);
int64_t fileSize = 0;
@@ -58,8 +62,8 @@ static FORCE_INLINE int64_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx) {
TdFilePtr pFile = taosOpenFile(fnameStr, TD_FILE_READ | TD_FILE_WRITE);
if (pFile == NULL) {
wError("vgId:%d, failed to open file due to %s. file:%s", pWal->cfg.vgId, strerror(errno), fnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+ *lastVer = retVer;
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
// ensure size as non-negative
@@ -73,7 +77,6 @@ static FORCE_INLINE int64_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx) {
int64_t readSize = 0;
char* buf = NULL;
int64_t offset = TMIN(pFileInfo->fileSize, fileSize);
- int64_t retVer = -1;
int64_t lastEntryBeginOffset = 0;
int64_t lastEntryEndOffset = 0;
int64_t recordLen = 0;
@@ -94,25 +97,22 @@ static FORCE_INLINE int64_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx) {
readSize = end - offset;
capacity = readSize + sizeof(magic);
- void* ptr = taosMemoryRealloc(buf, capacity);
+ ptr = taosMemoryRealloc(buf, capacity);
if (ptr == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- goto _err;
+ TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err);
}
buf = ptr;
int64_t ret = taosLSeekFile(pFile, offset, SEEK_SET);
if (ret < 0) {
wError("vgId:%d, failed to lseek file due to %s. offset:%" PRId64 "", pWal->cfg.vgId, strerror(errno), offset);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
if (readSize != taosReadFile(pFile, buf, readSize)) {
wError("vgId:%d, failed to read file due to %s. readSize:%" PRId64 ", file:%s", pWal->cfg.vgId, strerror(errno),
readSize, fnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
char* candidate = NULL;
@@ -140,7 +140,7 @@ static FORCE_INLINE int64_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx) {
logContent = (SWalCkHead*)(buf + pos);
if (walValidHeadCksum(logContent) != 0) {
- terrno = TSDB_CODE_WAL_CHKSUM_MISMATCH;
+ code = TSDB_CODE_WAL_CHKSUM_MISMATCH;
wWarn("vgId:%d, failed to validate checksum of wal entry header. offset:%" PRId64 ", file:%s", pWal->cfg.vgId,
offset + pos, fnameStr);
haystack = buf + pos + 1;
@@ -163,8 +163,7 @@ static FORCE_INLINE int64_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx) {
capacity += extraSize;
void* ptr = taosMemoryRealloc(buf, capacity);
if (ptr == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- goto _err;
+ TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _err);
}
buf = ptr;
}
@@ -172,21 +171,25 @@ static FORCE_INLINE int64_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx) {
if (ret < 0) {
wError("vgId:%d, failed to lseek file due to %s. offset:%" PRId64 "", pWal->cfg.vgId, strerror(errno),
offset);
- terrno = TAOS_SYSTEM_ERROR(errno);
+ code = TAOS_SYSTEM_ERROR(errno);
break;
}
if (extraSize != taosReadFile(pFile, buf + readSize, extraSize)) {
wError("vgId:%d, failed to read file due to %s. offset:%" PRId64 ", extraSize:%" PRId64 ", file:%s",
pWal->cfg.vgId, strerror(errno), offset + readSize, extraSize, fnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
+ code = TAOS_SYSTEM_ERROR(errno);
break;
}
}
logContent = (SWalCkHead*)(buf + pos);
- decryptBody(&pWal->cfg, logContent, logContent->head.bodyLen, __FUNCTION__);
+ code = decryptBody(&pWal->cfg, logContent, logContent->head.bodyLen, __FUNCTION__);
+ if (code) {
+ break;
+ }
+
if (walValidBodyCksum(logContent) != 0) {
- terrno = TSDB_CODE_WAL_CHKSUM_MISMATCH;
+ code = TSDB_CODE_WAL_CHKSUM_MISMATCH;
wWarn("vgId:%d, failed to validate checksum of wal entry body. offset:%" PRId64 ", file:%s", pWal->cfg.vgId,
offset + pos, fnameStr);
haystack = buf + pos + 1;
@@ -211,7 +214,7 @@ static FORCE_INLINE int64_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx) {
}
if (retVer < 0) {
- terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
+ code = TSDB_CODE_WAL_LOG_NOT_EXIST;
}
// truncate file
@@ -221,30 +224,26 @@ static FORCE_INLINE int64_t walScanLogGetLastVer(SWal* pWal, int32_t fileIdx) {
if (taosFtruncateFile(pFile, lastEntryEndOffset) < 0) {
wError("failed to truncate file due to %s. file:%s", strerror(errno), fnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
if (pWal->cfg.level != TAOS_WAL_SKIP && taosFsyncFile(pFile) < 0) {
wError("failed to fsync file due to %s. file:%s", strerror(errno), fnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
}
pFileInfo->fileSize = lastEntryEndOffset;
- taosCloseFile(&pFile);
- taosMemoryFree(buf);
- return retVer;
-
_err:
taosCloseFile(&pFile);
taosMemoryFree(buf);
- return -1;
+ *lastVer = retVer;
+
+ TAOS_RETURN(code);
}
-static void walRebuildFileInfoSet(SArray* metaLogList, SArray* actualLogList) {
+static int32_t walRebuildFileInfoSet(SArray* metaLogList, SArray* actualLogList) {
int metaFileNum = taosArrayGetSize(metaLogList);
int actualFileNum = taosArrayGetSize(actualLogList);
int j = 0;
@@ -270,11 +269,15 @@ static void walRebuildFileInfoSet(SArray* metaLogList, SArray* actualLogList) {
for (int i = 0; i < actualFileNum; i++) {
SWalFileInfo* pFileInfo = taosArrayGet(actualLogList, i);
- taosArrayPush(metaLogList, pFileInfo);
+ if (NULL == taosArrayPush(metaLogList, pFileInfo)) {
+ TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+ }
}
+
+ return TSDB_CODE_SUCCESS;
}
-void walAlignVersions(SWal* pWal) {
+static void walAlignVersions(SWal* pWal) {
if (pWal->vers.firstVer > pWal->vers.snapshotVer + 1) {
wWarn("vgId:%d, firstVer:%" PRId64 " is larger than snapshotVer:%" PRId64 " + 1. align with it.", pWal->cfg.vgId,
pWal->vers.firstVer, pWal->vers.snapshotVer);
@@ -294,7 +297,7 @@ void walAlignVersions(SWal* pWal) {
wInfo("vgId:%d, reset commitVer to %" PRId64, pWal->cfg.vgId, pWal->vers.commitVer);
}
-int walRepairLogFileTs(SWal* pWal, bool* updateMeta) {
+static int32_t walRepairLogFileTs(SWal* pWal, bool* updateMeta) {
int32_t sz = taosArrayGetSize(pWal->fileInfoSet);
int32_t fileIdx = -1;
int32_t lastCloseTs = 0;
@@ -310,9 +313,9 @@ int walRepairLogFileTs(SWal* pWal, bool* updateMeta) {
walBuildLogName(pWal, pFileInfo->firstVer, fnameStr);
int32_t mtime = 0;
if (taosStatFile(fnameStr, NULL, &mtime, NULL) < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, failed to stat file due to %s, file:%s", pWal->cfg.vgId, strerror(errno), fnameStr);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
if (updateMeta != NULL) *updateMeta = true;
@@ -321,10 +324,10 @@ int walRepairLogFileTs(SWal* pWal, bool* updateMeta) {
lastCloseTs = pFileInfo->closeTs;
}
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
-bool walLogEntriesComplete(const SWal* pWal) {
+static int32_t walLogEntriesComplete(const SWal* pWal) {
int32_t sz = taosArrayGetSize(pWal->fileInfoSet);
bool complete = true;
int32_t fileIdx = -1;
@@ -346,13 +349,13 @@ bool walLogEntriesComplete(const SWal* pWal) {
wError("vgId:%d, WAL log entries incomplete in range [%" PRId64 ", %" PRId64 "], index:%" PRId64
", snaphotVer:%" PRId64,
pWal->cfg.vgId, pWal->vers.firstVer, pWal->vers.lastVer, index, pWal->vers.snapshotVer);
- terrno = TSDB_CODE_WAL_LOG_INCOMPLETE;
+ TAOS_RETURN(TSDB_CODE_WAL_LOG_INCOMPLETE);
+ } else {
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
-
- return complete;
}
-int walTrimIdxFile(SWal* pWal, int32_t fileIdx) {
+static int32_t walTrimIdxFile(SWal* pWal, int32_t fileIdx) {
SWalFileInfo* pFileInfo = taosArrayGet(pWal->fileInfoSet, fileIdx);
ASSERT(pFileInfo != NULL);
char fnameStr[WAL_FILE_LEN];
@@ -364,13 +367,12 @@ int walTrimIdxFile(SWal* pWal, int32_t fileIdx) {
int64_t lastEndOffset = records * sizeof(SWalIdxEntry);
if (fileSize <= lastEndOffset) {
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
TdFilePtr pFile = taosOpenFile(fnameStr, TD_FILE_READ | TD_FILE_WRITE);
if (pFile == NULL) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
wInfo("vgId:%d, trim idx file. file: %s, size: %" PRId64 ", offset: %" PRId64, pWal->cfg.vgId, fnameStr, fileSize,
@@ -378,11 +380,13 @@ int walTrimIdxFile(SWal* pWal, int32_t fileIdx) {
taosFtruncateFile(pFile, lastEndOffset);
taosCloseFile(&pFile);
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
-int walCheckAndRepairMeta(SWal* pWal) {
+int32_t walCheckAndRepairMeta(SWal* pWal) {
// load log files, get first/snapshot/last version info
+ int32_t code = 0;
const char* logPattern = "^[0-9]+.log$";
const char* idxPattern = "^[0-9]+.idx$";
regex_t logRegPattern;
@@ -396,7 +400,7 @@ int walCheckAndRepairMeta(SWal* pWal) {
regfree(&logRegPattern);
regfree(&idxRegPattern);
wError("vgId:%d, path:%s, failed to open since %s", pWal->cfg.vgId, pWal->path, strerror(errno));
- return -1;
+ TAOS_RETURN(TSDB_CODE_FAILED);
}
SArray* actualLog = taosArrayInit(8, sizeof(SWalFileInfo));
@@ -428,8 +432,11 @@ int walCheckAndRepairMeta(SWal* pWal) {
bool updateMeta = (metaFileNum != actualFileNum);
// rebuild meta of file info
- walRebuildFileInfoSet(pWal->fileInfoSet, actualLog);
+ code = walRebuildFileInfoSet(pWal->fileInfoSet, actualLog);
taosArrayDestroy(actualLog);
+ if (code) {
+ TAOS_RETURN(code);
+ }
int32_t sz = taosArrayGetSize(pWal->fileInfoSet);
@@ -444,9 +451,9 @@ int walCheckAndRepairMeta(SWal* pWal) {
walBuildLogName(pWal, pFileInfo->firstVer, fnameStr);
int32_t code = taosStatFile(fnameStr, &fileSize, NULL, NULL);
if (code < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("failed to stat file since %s. file:%s", terrstr(), fnameStr);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
if (pFileInfo->lastVer >= pFileInfo->firstVer && fileSize == pFileInfo->fileSize) {
@@ -455,16 +462,20 @@ int walCheckAndRepairMeta(SWal* pWal) {
}
updateMeta = true;
- (void)walTrimIdxFile(pWal, fileIdx);
+ TAOS_CHECK_RETURN(walTrimIdxFile(pWal, fileIdx));
- int64_t lastVer = walScanLogGetLastVer(pWal, fileIdx);
+ int64_t lastVer = -1;
+ code = walScanLogGetLastVer(pWal, fileIdx, &lastVer);
if (lastVer < 0) {
- if (terrno != TSDB_CODE_WAL_LOG_NOT_EXIST) {
+ if (code != TSDB_CODE_WAL_LOG_NOT_EXIST) {
wError("failed to scan wal last ver since %s", terrstr());
- return -1;
+
+ TAOS_RETURN(code);
}
// empty log file
lastVer = pFileInfo->firstVer - 1;
+
+ code = TSDB_CODE_SUCCESS;
}
// update lastVer
@@ -481,45 +492,39 @@ int walCheckAndRepairMeta(SWal* pWal) {
pWal->vers.firstVer = ((SWalFileInfo*)taosArrayGet(pWal->fileInfoSet, 0))->firstVer;
pWal->vers.lastVer = ((SWalFileInfo*)taosArrayGetLast(pWal->fileInfoSet))->lastVer;
}
- (void)walAlignVersions(pWal);
+ walAlignVersions(pWal);
// repair ts of files
- if (walRepairLogFileTs(pWal, &updateMeta) < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walRepairLogFileTs(pWal, &updateMeta));
// update meta file
if (updateMeta) {
- (void)walSaveMeta(pWal);
+ TAOS_CHECK_RETURN(walSaveMeta(pWal));
}
- if (!walLogEntriesComplete(pWal)) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walLogEntriesComplete(pWal));
- return 0;
+ return code;
}
-int walReadLogHead(TdFilePtr pLogFile, int64_t offset, SWalCkHead* pCkHead) {
+static int32_t walReadLogHead(TdFilePtr pLogFile, int64_t offset, SWalCkHead* pCkHead) {
if (taosLSeekFile(pLogFile, offset, SEEK_SET) < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
if (taosReadFile(pLogFile, pCkHead, sizeof(SWalCkHead)) != sizeof(SWalCkHead)) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
if (walValidHeadCksum(pCkHead) != 0) {
- terrno = TSDB_CODE_WAL_CHKSUM_MISMATCH;
- return -1;
+ TAOS_RETURN(TSDB_CODE_WAL_CHKSUM_MISMATCH);
}
- return 0;
+ return TSDB_CODE_SUCCESS;
}
-int walCheckAndRepairIdxFile(SWal* pWal, int32_t fileIdx) {
+static int32_t walCheckAndRepairIdxFile(SWal* pWal, int32_t fileIdx) {
+ int32_t code = 0, lino = 0;
int32_t sz = taosArrayGetSize(pWal->fileInfoSet);
SWalFileInfo* pFileInfo = taosArrayGet(pWal->fileInfoSet, fileIdx);
char fnameStr[WAL_FILE_LEN];
@@ -530,12 +535,12 @@ int walCheckAndRepairIdxFile(SWal* pWal, int32_t fileIdx) {
if (taosStatFile(fnameStr, &fileSize, NULL, NULL) < 0 && errno != ENOENT) {
wError("vgId:%d, failed to stat file due to %s. file:%s", pWal->cfg.vgId, strerror(errno), fnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
if (fileSize == (pFileInfo->lastVer - pFileInfo->firstVer + 1) * sizeof(SWalIdxEntry)) {
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
// start to repair
@@ -550,15 +555,15 @@ int walCheckAndRepairIdxFile(SWal* pWal, int32_t fileIdx) {
pIdxFile = taosOpenFile(fnameStr, TD_FILE_READ | TD_FILE_WRITE | TD_FILE_CREATE);
if (pIdxFile == NULL) {
wError("vgId:%d, failed to open file due to %s. file:%s", pWal->cfg.vgId, strerror(errno), fnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
pLogFile = taosOpenFile(fLogNameStr, TD_FILE_READ);
if (pLogFile == NULL) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, cannot open file %s, since %s", pWal->cfg.vgId, fLogNameStr, terrstr());
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
// determine the last valid entry end, i.e. offset
@@ -566,15 +571,15 @@ int walCheckAndRepairIdxFile(SWal* pWal, int32_t fileIdx) {
if (taosLSeekFile(pIdxFile, offset, SEEK_SET) < 0) {
wError("vgId:%d, failed to seek file due to %s. offset:%" PRId64 ", file:%s", pWal->cfg.vgId, strerror(errno),
offset, fnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
if (taosReadFile(pIdxFile, &idxEntry, sizeof(SWalIdxEntry)) != sizeof(SWalIdxEntry)) {
wError("vgId:%d, failed to read file due to %s. offset:%" PRId64 ", file:%s", pWal->cfg.vgId, strerror(errno),
offset, fnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
if (idxEntry.ver > pFileInfo->lastVer) {
@@ -602,19 +607,19 @@ int walCheckAndRepairIdxFile(SWal* pWal, int32_t fileIdx) {
// ftruncate idx file
if (offset < fileSize) {
if (taosFtruncateFile(pIdxFile, offset) < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, failed to ftruncate file since %s. offset:%" PRId64 ", file:%s", pWal->cfg.vgId, terrstr(),
offset, fnameStr);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
}
// rebuild idx file
if (taosLSeekFile(pIdxFile, 0, SEEK_END) < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, failed to seek file since %s. offset:%" PRId64 ", file:%s", pWal->cfg.vgId, terrstr(), offset,
fnameStr);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
int64_t count = 0;
@@ -630,23 +635,25 @@ int walCheckAndRepairIdxFile(SWal* pWal, int32_t fileIdx) {
}
idxEntry.offset += sizeof(SWalCkHead) + cryptedBodyLen;
- if (walReadLogHead(pLogFile, idxEntry.offset, &ckHead) < 0) {
+ code = walReadLogHead(pLogFile, idxEntry.offset, &ckHead);
+ if (code) {
wError("vgId:%d, failed to read wal log head since %s. index:%" PRId64 ", offset:%" PRId64 ", file:%s",
pWal->cfg.vgId, terrstr(), idxEntry.ver, idxEntry.offset, fLogNameStr);
- goto _err;
+
+ TAOS_CHECK_GOTO(code, &lino, _err);
}
if (pWal->cfg.level != TAOS_WAL_SKIP && taosWriteFile(pIdxFile, &idxEntry, sizeof(SWalIdxEntry)) < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, failed to append file since %s. file:%s", pWal->cfg.vgId, terrstr(), fnameStr);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
count++;
}
if (pWal->cfg.level != TAOS_WAL_SKIP && taosFsyncFile(pIdxFile) < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, faild to fsync file since %s. file:%s", pWal->cfg.vgId, terrstr(), fnameStr);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
if (count > 0) {
@@ -654,14 +661,15 @@ int walCheckAndRepairIdxFile(SWal* pWal, int32_t fileIdx) {
pFileInfo->lastVer);
}
- (void)taosCloseFile(&pLogFile);
- (void)taosCloseFile(&pIdxFile);
- return 0;
-
_err:
+ if (code) {
+ wError("vgId:%d, %s failed at line %d since %s", pWal->cfg.vgId, __func__, lino, tstrerror(code));
+ }
+
(void)taosCloseFile(&pLogFile);
(void)taosCloseFile(&pIdxFile);
- return -1;
+
+ TAOS_RETURN(code);
}
int64_t walGetVerRetention(SWal* pWal, int64_t bytes) {
@@ -681,19 +689,24 @@ int64_t walGetVerRetention(SWal* pWal, int64_t bytes) {
return ver + 1;
}
-int walCheckAndRepairIdx(SWal* pWal) {
+int32_t walCheckAndRepairIdx(SWal* pWal) {
+ int32_t code = 0;
int32_t sz = taosArrayGetSize(pWal->fileInfoSet);
int32_t fileIdx = sz;
+
while (--fileIdx >= 0) {
- if (walCheckAndRepairIdxFile(pWal, fileIdx) < 0) {
+ code = walCheckAndRepairIdxFile(pWal, fileIdx);
+ if (code) {
wError("vgId:%d, failed to repair idx file since %s. fileIdx:%d", pWal->cfg.vgId, terrstr(), fileIdx);
- return -1;
+
+ TAOS_RETURN(code);
}
}
- return 0;
+
+ TAOS_RETURN(code);
}
-int walRollFileInfo(SWal* pWal) {
+int32_t walRollFileInfo(SWal* pWal) {
int64_t ts = taosGetTimestampSec();
SArray* pArray = pWal->fileInfoSet;
@@ -706,8 +719,7 @@ int walRollFileInfo(SWal* pWal) {
// TODO: change to emplace back
SWalFileInfo* pNewInfo = taosMemoryMalloc(sizeof(SWalFileInfo));
if (pNewInfo == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return -1;
+ TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
pNewInfo->firstVer = pWal->vers.lastVer + 1;
pNewInfo->lastVer = -1;
@@ -717,10 +729,11 @@ int walRollFileInfo(SWal* pWal) {
pNewInfo->syncedOffset = 0;
taosArrayPush(pArray, pNewInfo);
taosMemoryFree(pNewInfo);
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
-char* walMetaSerialize(SWal* pWal) {
+int32_t walMetaSerialize(SWal* pWal, char** serialized) {
char buf[30];
int sz = taosArrayGetSize(pWal->fileInfoSet);
cJSON* pRoot = cJSON_CreateObject();
@@ -737,8 +750,8 @@ char* walMetaSerialize(SWal* pWal) {
if (pFiles) {
cJSON_Delete(pFiles);
}
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return NULL;
+
+ TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
cJSON_AddItemToObject(pRoot, "meta", pMeta);
sprintf(buf, "%" PRId64, pWal->vers.firstVer);
@@ -757,7 +770,8 @@ char* walMetaSerialize(SWal* pWal) {
cJSON_AddItemToArray(pFiles, pField = cJSON_CreateObject());
if (pField == NULL) {
cJSON_Delete(pRoot);
- return NULL;
+
+ TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
// cjson only support int32_t or double
// string are used to prohibit the loss of precision
@@ -772,12 +786,15 @@ char* walMetaSerialize(SWal* pWal) {
sprintf(buf, "%" PRId64, pInfo->fileSize);
cJSON_AddStringToObject(pField, "fileSize", buf);
}
- char* serialized = cJSON_Print(pRoot);
+ char* pSerialized = cJSON_Print(pRoot);
cJSON_Delete(pRoot);
- return serialized;
+
+ *serialized = pSerialized;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
-int walMetaDeserialize(SWal* pWal, const char* bytes) {
+int32_t walMetaDeserialize(SWal* pWal, const char* bytes) {
/*A(taosArrayGetSize(pWal->fileInfoSet) == 0);*/
cJSON *pRoot, *pMeta, *pFiles, *pInfoJson, *pField;
pRoot = cJSON_Parse(bytes);
@@ -829,11 +846,11 @@ int walMetaDeserialize(SWal* pWal, const char* bytes) {
pWal->fileInfoSet = pArray;
pWal->writeCur = sz - 1;
cJSON_Delete(pRoot);
- return 0;
+ return TSDB_CODE_SUCCESS;
_err:
cJSON_Delete(pRoot);
- return -1;
+ return TSDB_CODE_FAILED;
}
static int walFindCurMetaVer(SWal* pWal) {
@@ -866,13 +883,14 @@ static int walFindCurMetaVer(SWal* pWal) {
return metaVer;
}
-void walUpdateSyncedOffset(SWal* pWal) {
+static void walUpdateSyncedOffset(SWal* pWal) {
SWalFileInfo* pFileInfo = walGetCurFileInfo(pWal);
if (pFileInfo == NULL) return;
pFileInfo->syncedOffset = pFileInfo->fileSize;
}
-int walSaveMeta(SWal* pWal) {
+int32_t walSaveMeta(SWal* pWal) {
+ int code = 0, lino = 0;
int metaVer = walFindCurMetaVer(pWal);
char fnameStr[WAL_FILE_LEN];
char tmpFnameStr[WAL_FILE_LEN];
@@ -881,63 +899,64 @@ int walSaveMeta(SWal* pWal) {
// fsync the idx and log file at first to ensure validity of meta
if (pWal->cfg.level != TAOS_WAL_SKIP && taosFsyncFile(pWal->pIdxFile) < 0) {
wError("vgId:%d, failed to sync idx file due to %s", pWal->cfg.vgId, strerror(errno));
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
if (pWal->cfg.level != TAOS_WAL_SKIP && taosFsyncFile(pWal->pLogFile) < 0) {
wError("vgId:%d, failed to sync log file due to %s", pWal->cfg.vgId, strerror(errno));
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
// update synced offset
- (void)walUpdateSyncedOffset(pWal);
+ walUpdateSyncedOffset(pWal);
// flush to a tmpfile
n = walBuildTmpMetaName(pWal, tmpFnameStr);
if (n >= sizeof(tmpFnameStr)) {
- return -1;
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
TdFilePtr pMetaFile =
taosOpenFile(tmpFnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH);
if (pMetaFile == NULL) {
wError("vgId:%d, failed to open file due to %s. file:%s", pWal->cfg.vgId, strerror(errno), tmpFnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
- char* serialized = walMetaSerialize(pWal);
- int len = strlen(serialized);
+ char* serialized = NULL;
+ TAOS_CHECK_RETURN(walMetaSerialize(pWal, &serialized));
+ int len = strlen(serialized);
if (pWal->cfg.level != TAOS_WAL_SKIP && len != taosWriteFile(pMetaFile, serialized, len)) {
wError("vgId:%d, failed to write file due to %s. file:%s", pWal->cfg.vgId, strerror(errno), tmpFnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
if (pWal->cfg.level != TAOS_WAL_SKIP && taosFsyncFile(pMetaFile) < 0) {
wError("vgId:%d, failed to sync file due to %s. file:%s", pWal->cfg.vgId, strerror(errno), tmpFnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
if (taosCloseFile(&pMetaFile) < 0) {
wError("vgId:%d, failed to close file due to %s. file:%s", pWal->cfg.vgId, strerror(errno), tmpFnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
// rename it
n = walBuildMetaName(pWal, metaVer + 1, fnameStr);
if (n >= sizeof(fnameStr)) {
- goto _err;
+ TAOS_CHECK_GOTO(TSDB_CODE_FAILED, &lino, _err);
}
if (taosRenameFile(tmpFnameStr, fnameStr) < 0) {
wError("failed to rename file due to %s. dest:%s", strerror(errno), fnameStr);
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto _err;
+
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
}
// delete old file
@@ -945,21 +964,24 @@ int walSaveMeta(SWal* pWal) {
walBuildMetaName(pWal, metaVer, fnameStr);
taosRemoveFile(fnameStr);
}
+
taosMemoryFree(serialized);
- return 0;
+ return code;
_err:
taosCloseFile(&pMetaFile);
taosMemoryFree(serialized);
- return -1;
+ return code;
}
-int walLoadMeta(SWal* pWal) {
+int32_t walLoadMeta(SWal* pWal) {
+ int32_t code = 0;
// find existing meta file
int metaVer = walFindCurMetaVer(pWal);
if (metaVer == -1) {
wDebug("vgId:%d, wal find meta ver %d", pWal->cfg.vgId, metaVer);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_FAILED);
}
char fnameStr[WAL_FILE_LEN];
walBuildMetaName(pWal, metaVer, fnameStr);
@@ -969,39 +991,40 @@ int walLoadMeta(SWal* pWal) {
if (fileSize == 0) {
(void)taosRemoveFile(fnameStr);
wDebug("vgId:%d, wal find empty meta ver %d", pWal->cfg.vgId, metaVer);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_FAILED);
}
int size = (int)fileSize;
char* buf = taosMemoryMalloc(size + 5);
if (buf == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return -1;
+ TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
memset(buf, 0, size + 5);
TdFilePtr pFile = taosOpenFile(fnameStr, TD_FILE_READ);
if (pFile == NULL) {
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
taosMemoryFree(buf);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
if (taosReadFile(pFile, buf, size) != size) {
- terrno = TAOS_SYSTEM_ERROR(errno);
taosCloseFile(&pFile);
taosMemoryFree(buf);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
// load into fileInfoSet
- int code = walMetaDeserialize(pWal, buf);
+ code = walMetaDeserialize(pWal, buf);
if (code < 0) {
wError("failed to deserialize wal meta. file:%s", fnameStr);
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
+ code = TSDB_CODE_WAL_FILE_CORRUPTED;
}
taosCloseFile(&pFile);
taosMemoryFree(buf);
- return code;
+
+ TAOS_RETURN(code);
}
-int walRemoveMeta(SWal* pWal) {
+int32_t walRemoveMeta(SWal* pWal) {
int metaVer = walFindCurMetaVer(pWal);
if (metaVer == -1) return 0;
char fnameStr[WAL_FILE_LEN];
diff --git a/source/libs/wal/src/walMgmt.c b/source/libs/wal/src/walMgmt.c
index 3dbaed1bc7..bf875b4e09 100644
--- a/source/libs/wal/src/walMgmt.c
+++ b/source/libs/wal/src/walMgmt.c
@@ -46,10 +46,11 @@ int32_t walInit() {
tsWal.refSetId = taosOpenRef(TSDB_MIN_VNODES, walFreeObj);
int32_t code = walCreateThread();
- if (code != 0) {
+ if (TSDB_CODE_SUCCESS != code) {
wError("failed to init wal module since %s", tstrerror(code));
atomic_store_8(&tsWal.inited, 0);
- return code;
+
+ TAOS_RETURN(code);
}
wInfo("wal module is initialized, rsetId:%d", tsWal.refSetId);
@@ -103,7 +104,7 @@ SWal *walOpen(const char *path, SWalCfg *pCfg) {
tstrncpy(pWal->path, path, sizeof(pWal->path));
if (taosMkDir(pWal->path) != 0) {
- wError("vgId:%d, path:%s, failed to create directory since %s", pWal->cfg.vgId, pWal->path, strerror(errno));
+ wError("vgId:%d, path:%s, failed to create directory since %s", pWal->cfg.vgId, pWal->path, tstrerror(terrno));
goto _err;
}
@@ -171,19 +172,20 @@ _err:
taosArrayDestroy(pWal->fileInfoSet);
taosHashCleanup(pWal->pRefHash);
taosThreadMutexDestroy(&pWal->mutex);
- taosMemoryFree(pWal);
- pWal = NULL;
+ taosMemoryFreeClear(pWal);
+
return NULL;
}
int32_t walAlter(SWal *pWal, SWalCfg *pCfg) {
- if (pWal == NULL) return TSDB_CODE_APP_ERROR;
+ if (pWal == NULL) TAOS_RETURN(TSDB_CODE_APP_ERROR);
if (pWal->cfg.level == pCfg->level && pWal->cfg.fsyncPeriod == pCfg->fsyncPeriod &&
pWal->cfg.retentionPeriod == pCfg->retentionPeriod && pWal->cfg.retentionSize == pCfg->retentionSize) {
wDebug("vgId:%d, walLevel:%d fsync:%d walRetentionPeriod:%d walRetentionSize:%" PRId64 " not change",
pWal->cfg.vgId, pWal->cfg.level, pWal->cfg.fsyncPeriod, pWal->cfg.retentionPeriod, pWal->cfg.retentionSize);
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
wInfo("vgId:%d, change old walLevel:%d fsync:%d walRetentionPeriod:%d walRetentionSize:%" PRId64
@@ -199,14 +201,17 @@ int32_t walAlter(SWal *pWal, SWalCfg *pCfg) {
pWal->fsyncSeq = pCfg->fsyncPeriod / 1000;
if (pWal->fsyncSeq <= 0) pWal->fsyncSeq = 1;
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
int32_t walPersist(SWal *pWal) {
+ int32_t code = 0;
+
taosThreadMutexLock(&pWal->mutex);
- int32_t ret = walSaveMeta(pWal);
+ code = walSaveMeta(pWal);
taosThreadMutexUnlock(&pWal->mutex);
- return ret;
+
+ TAOS_RETURN(code);
}
void walClose(SWal *pWal) {
@@ -301,14 +306,14 @@ static int32_t walCreateThread() {
if (taosThreadCreate(&tsWal.thread, &thAttr, walThreadFunc, NULL) != 0) {
wError("failed to create wal thread since %s", strerror(errno));
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
taosThreadAttrDestroy(&thAttr);
wDebug("wal thread is launched, thread:0x%08" PRIx64, taosGetPthreadId(tsWal.thread));
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
static void walStopThread() {
diff --git a/source/libs/wal/src/walRead.c b/source/libs/wal/src/walRead.c
index c164940f9b..23e3991d8f 100644
--- a/source/libs/wal/src/walRead.c
+++ b/source/libs/wal/src/walRead.c
@@ -26,7 +26,7 @@ SWalReader *walOpenReader(SWal *pWal, SWalFilterCond *cond, int64_t id) {
}
pReader->pWal = pWal;
- pReader->readerId = (id != 0)? id:tGenIdPI64();
+ pReader->readerId = (id != 0) ? id : tGenIdPI64();
pReader->pIdxFile = NULL;
pReader->pLogFile = NULL;
pReader->curVersion = -1;
@@ -35,7 +35,7 @@ SWalReader *walOpenReader(SWal *pWal, SWalFilterCond *cond, int64_t id) {
if (cond) {
pReader->cond = *cond;
} else {
-// pReader->cond.scanUncommited = 0;
+ // pReader->cond.scanUncommited = 0;
pReader->cond.scanNotApplied = 0;
pReader->cond.scanMeta = 0;
pReader->cond.enableRef = 0;
@@ -58,7 +58,7 @@ SWalReader *walOpenReader(SWal *pWal, SWalFilterCond *cond, int64_t id) {
}
void walCloseReader(SWalReader *pReader) {
- if(pReader == NULL) return;
+ if (pReader == NULL) return;
taosCloseFile(&pReader->pIdxFile);
taosCloseFile(&pReader->pLogFile);
@@ -75,30 +75,24 @@ int32_t walNextValidMsg(SWalReader *pReader) {
wDebug("vgId:%d, wal start to fetch, index:%" PRId64 ", last:%" PRId64 " commit:%" PRId64 ", applied:%" PRId64,
pReader->pWal->cfg.vgId, fetchVer, lastVer, committedVer, appliedVer);
if (fetchVer > appliedVer) {
- terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
- return -1;
+ TAOS_RETURN(TSDB_CODE_WAL_LOG_NOT_EXIST);
}
while (fetchVer <= appliedVer) {
- if (walFetchHead(pReader, fetchVer) < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walFetchHead(pReader, fetchVer));
int32_t type = pReader->pHead->head.msgType;
if (type == TDMT_VND_SUBMIT || ((type == TDMT_VND_DELETE) && (pReader->cond.deleteMsg == 1)) ||
(IS_META_MSG(type) && pReader->cond.scanMeta)) {
- int32_t code = walFetchBody(pReader);
- return (code == TSDB_CODE_SUCCESS)? 0:-1;
+ TAOS_RETURN(walFetchBody(pReader));
} else {
- if (walSkipFetchBody(pReader) < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walSkipFetchBody(pReader));
fetchVer = pReader->curVersion;
}
}
- return -1;
+ TAOS_RETURN(TSDB_CODE_FAILED);
}
int64_t walReaderGetCurrentVer(const SWalReader *pReader) { return pReader->curVersion; }
@@ -119,18 +113,18 @@ void walReaderValidVersionRange(SWalReader *pReader, int64_t *sver, int64_t *eve
*ever = pReader->cond.scanUncommited ? lastVer : committedVer;
}
-void walReaderVerifyOffset(SWalReader *pWalReader, STqOffsetVal* pOffset){
+void walReaderVerifyOffset(SWalReader *pWalReader, STqOffsetVal *pOffset) {
// if offset version is small than first version , let's seek to first version
taosThreadMutexLock(&pWalReader->pWal->mutex);
int64_t firstVer = walGetFirstVer((pWalReader)->pWal);
taosThreadMutexUnlock(&pWalReader->pWal->mutex);
- if (pOffset->version < firstVer){
+ if (pOffset->version < firstVer) {
pOffset->version = firstVer;
}
}
-static int64_t walReadSeekFilePos(SWalReader *pReader, int64_t fileFirstVer, int64_t ver) {
+static int32_t walReadSeekFilePos(SWalReader *pReader, int64_t fileFirstVer, int64_t ver) {
int64_t ret = 0;
TdFilePtr pIdxTFile = pReader->pIdxFile;
@@ -140,32 +134,34 @@ static int64_t walReadSeekFilePos(SWalReader *pReader, int64_t fileFirstVer, int
int64_t offset = (ver - fileFirstVer) * sizeof(SWalIdxEntry);
ret = taosLSeekFile(pIdxTFile, offset, SEEK_SET);
if (ret < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, failed to seek idx file, index:%" PRId64 ", pos:%" PRId64 ", since %s", pReader->pWal->cfg.vgId,
ver, offset, terrstr());
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
SWalIdxEntry entry = {0};
if ((ret = taosReadFile(pIdxTFile, &entry, sizeof(SWalIdxEntry))) != sizeof(SWalIdxEntry)) {
if (ret < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, failed to read idx file, since %s", pReader->pWal->cfg.vgId, terrstr());
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
} else {
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
wError("vgId:%d, read idx file incompletely, read bytes %" PRId64 ", bytes should be %ld",
pReader->pWal->cfg.vgId, ret, sizeof(SWalIdxEntry));
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
- return -1;
}
ret = taosLSeekFile(pLogTFile, entry.offset, SEEK_SET);
if (ret < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, failed to seek log file, index:%" PRId64 ", pos:%" PRId64 ", since %s", pReader->pWal->cfg.vgId,
ver, entry.offset, terrstr());
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
- return ret;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
static int32_t walReadChangeFile(SWalReader *pReader, int64_t fileFirstVer) {
@@ -177,9 +173,9 @@ static int32_t walReadChangeFile(SWalReader *pReader, int64_t fileFirstVer) {
walBuildLogName(pReader->pWal, fileFirstVer, fnameStr);
TdFilePtr pLogFile = taosOpenFile(fnameStr, TD_FILE_READ);
if (pLogFile == NULL) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, cannot open file %s, since %s", pReader->pWal->cfg.vgId, fnameStr, terrstr());
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
pReader->pLogFile = pLogFile;
@@ -187,19 +183,19 @@ static int32_t walReadChangeFile(SWalReader *pReader, int64_t fileFirstVer) {
walBuildIdxName(pReader->pWal, fileFirstVer, fnameStr);
TdFilePtr pIdxFile = taosOpenFile(fnameStr, TD_FILE_READ);
if (pIdxFile == NULL) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, cannot open file %s, since %s", pReader->pWal->cfg.vgId, fnameStr, terrstr());
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
pReader->pIdxFile = pIdxFile;
pReader->curFileFirstVer = fileFirstVer;
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
-int32_t walReadSeekVerImpl(SWalReader *pReader, int64_t ver) {
+static int32_t walReadSeekVerImpl(SWalReader *pReader, int64_t ver) {
SWal *pWal = pReader->pWal;
// bsearch in fileSet
@@ -208,51 +204,45 @@ int32_t walReadSeekVerImpl(SWalReader *pReader, int64_t ver) {
SWalFileInfo *pRet = taosArraySearch(pWal->fileInfoSet, &tmpInfo, compareWalFileInfo, TD_LE);
if (pRet == NULL) {
wError("failed to find WAL log file with ver:%" PRId64, ver);
- terrno = TSDB_CODE_WAL_INVALID_VER;
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_WAL_INVALID_VER);
}
if (pReader->curFileFirstVer != pRet->firstVer) {
// error code was set inner
- if (walReadChangeFile(pReader, pRet->firstVer) < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walReadChangeFile(pReader, pRet->firstVer));
}
// error code was set inner
- if (walReadSeekFilePos(pReader, pRet->firstVer, ver) < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walReadSeekFilePos(pReader, pRet->firstVer, ver));
- wDebug("vgId:%d, wal version reset from %" PRId64 " to %" PRId64, pReader->pWal->cfg.vgId,
- pReader->curVersion, ver);
+ wDebug("vgId:%d, wal version reset from %" PRId64 " to %" PRId64, pReader->pWal->cfg.vgId, pReader->curVersion, ver);
pReader->curVersion = ver;
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
int32_t walReaderSeekVer(SWalReader *pReader, int64_t ver) {
SWal *pWal = pReader->pWal;
if (ver == pReader->curVersion) {
wDebug("vgId:%d, wal index:%" PRId64 " match, no need to reset", pReader->pWal->cfg.vgId, ver);
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
if (ver > pWal->vers.lastVer || ver < pWal->vers.firstVer) {
wInfo("vgId:%d, invalid index:%" PRId64 ", first index:%" PRId64 ", last index:%" PRId64, pReader->pWal->cfg.vgId,
- ver, pWal->vers.firstVer, pWal->vers.lastVer);
- terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
- return -1;
+ ver, pWal->vers.firstVer, pWal->vers.lastVer);
+
+ TAOS_RETURN(TSDB_CODE_WAL_LOG_NOT_EXIST);
}
- if (walReadSeekVerImpl(pReader, ver) < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walReadSeekVerImpl(pReader, ver));
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
-
int32_t walFetchHead(SWalReader *pRead, int64_t ver) {
int64_t code;
int64_t contLen;
@@ -260,14 +250,12 @@ int32_t walFetchHead(SWalReader *pRead, int64_t ver) {
// TODO: valid ver
if (ver > pRead->pWal->vers.commitVer) {
- return -1;
+ TAOS_RETURN(TSDB_CODE_FAILED);
}
if (pRead->curVersion != ver) {
- code = walReaderSeekVer(pRead, ver);
- if (code < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walReaderSeekVer(pRead, ver));
+
seeked = true;
}
@@ -276,53 +264,51 @@ int32_t walFetchHead(SWalReader *pRead, int64_t ver) {
if (contLen == sizeof(SWalCkHead)) {
break;
} else if (contLen == 0 && !seeked) {
- if(walReadSeekVerImpl(pRead, ver) < 0){
- return -1;
- }
+ TAOS_CHECK_RETURN(walReadSeekVerImpl(pRead, ver));
+
seeked = true;
continue;
} else {
if (contLen < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
} else {
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
- return -1;
}
}
code = walValidHeadCksum(pRead->pHead);
if (code != 0) {
- wError("vgId:%d, unexpected wal log index:%" PRId64 ", since head checksum not passed, 0x%"PRIx64, pRead->pWal->cfg.vgId, ver,
- pRead->readerId);
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
- return -1;
+ wError("vgId:%d, unexpected wal log index:%" PRId64 ", since head checksum not passed, 0x%" PRIx64,
+ pRead->pWal->cfg.vgId, ver, pRead->readerId);
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
int32_t walSkipFetchBody(SWalReader *pRead) {
- wDebug("vgId:%d, skip:%" PRId64 ", first:%" PRId64 ", commit:%" PRId64 ", last:%" PRId64
- ", applied:%" PRId64 ", 0x%" PRIx64,
+ wDebug("vgId:%d, skip:%" PRId64 ", first:%" PRId64 ", commit:%" PRId64 ", last:%" PRId64 ", applied:%" PRId64
+ ", 0x%" PRIx64,
pRead->pWal->cfg.vgId, pRead->pHead->head.version, pRead->pWal->vers.firstVer, pRead->pWal->vers.commitVer,
pRead->pWal->vers.lastVer, pRead->pWal->vers.appliedVer, pRead->readerId);
int32_t plainBodyLen = pRead->pHead->head.bodyLen;
int32_t cryptedBodyLen = plainBodyLen;
- //TODO: dmchen emun
- if(pRead->pWal->cfg.encryptAlgorithm == 1){
+ // TODO: dmchen emun
+ if (pRead->pWal->cfg.encryptAlgorithm == 1) {
cryptedBodyLen = ENCRYPTED_LEN(cryptedBodyLen);
}
int64_t code = taosLSeekFile(pRead->pLogFile, cryptedBodyLen, SEEK_CUR);
if (code < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
pRead->curVersion++;
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
int32_t walFetchBody(SWalReader *pRead) {
@@ -339,16 +325,15 @@ int32_t walFetchBody(SWalReader *pRead) {
int32_t plainBodyLen = pReadHead->bodyLen;
int32_t cryptedBodyLen = plainBodyLen;
- //TODO: dmchen emun
- if(pRead->pWal->cfg.encryptAlgorithm == 1){
+ // TODO: dmchen emun
+ if (pRead->pWal->cfg.encryptAlgorithm == 1) {
cryptedBodyLen = ENCRYPTED_LEN(cryptedBodyLen);
}
if (pRead->capacity < cryptedBodyLen) {
SWalCkHead *ptr = (SWalCkHead *)taosMemoryRealloc(pRead->pHead, sizeof(SWalCkHead) + cryptedBodyLen);
if (ptr == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return -1;
+ TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
pRead->pHead = ptr;
pReadHead = &pRead->pHead->head;
@@ -357,62 +342,68 @@ int32_t walFetchBody(SWalReader *pRead) {
if (cryptedBodyLen != taosReadFile(pRead->pLogFile, pReadHead->body, cryptedBodyLen)) {
if (plainBodyLen < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- wError("vgId:%d, wal fetch body error:%" PRId64 ", read request index:%" PRId64 ", since %s, 0x%"PRIx64,
- vgId, pReadHead->version, ver, tstrerror(terrno), id);
+ wError("vgId:%d, wal fetch body error:%" PRId64 ", read request index:%" PRId64 ", since %s, 0x%" PRIx64, vgId,
+ pReadHead->version, ver, tstrerror(terrno), id);
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
} else {
- wError("vgId:%d, wal fetch body error:%" PRId64 ", read request index:%" PRId64 ", since file corrupted, 0x%"PRIx64,
+ wError("vgId:%d, wal fetch body error:%" PRId64 ", read request index:%" PRId64
+ ", since file corrupted, 0x%" PRIx64,
vgId, pReadHead->version, ver, id);
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
- return -1;
}
if (pReadHead->version != ver) {
- wError("vgId:%d, wal fetch body error, index:%" PRId64 ", read request index:%" PRId64", 0x%"PRIx64, vgId,
+ wError("vgId:%d, wal fetch body error, index:%" PRId64 ", read request index:%" PRId64 ", 0x%" PRIx64, vgId,
pReadHead->version, ver, id);
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
- decryptBody(&pRead->pWal->cfg, pRead->pHead, plainBodyLen, __FUNCTION__);
+ TAOS_CHECK_RETURN(decryptBody(&pRead->pWal->cfg, pRead->pHead, plainBodyLen, __FUNCTION__));
if (walValidBodyCksum(pRead->pHead) != 0) {
- wError("vgId:%d, wal fetch body error, index:%" PRId64 ", since body checksum not passed, 0x%" PRIx64, vgId, ver, id);
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
- return -1;
+ wError("vgId:%d, wal fetch body error, index:%" PRId64 ", since body checksum not passed, 0x%" PRIx64, vgId, ver,
+ id);
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
pRead->curVersion++;
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
int32_t walReadVer(SWalReader *pReader, int64_t ver) {
wDebug("vgId:%d, wal start to read index:%" PRId64, pReader->pWal->cfg.vgId, ver);
int64_t contLen;
- int32_t code;
+ int32_t code = 0;
bool seeked = false;
if (walIsEmpty(pReader->pWal)) {
- terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
- return -1;
+ TAOS_RETURN(TSDB_CODE_WAL_LOG_NOT_EXIST);
}
if (ver > pReader->pWal->vers.lastVer || ver < pReader->pWal->vers.firstVer) {
wDebug("vgId:%d, invalid index:%" PRId64 ", first index:%" PRId64 ", last index:%" PRId64, pReader->pWal->cfg.vgId,
ver, pReader->pWal->vers.firstVer, pReader->pWal->vers.lastVer);
- terrno = TSDB_CODE_WAL_LOG_NOT_EXIST;
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_WAL_LOG_NOT_EXIST);
}
taosThreadMutexLock(&pReader->mutex);
if (pReader->curVersion != ver) {
- if (walReaderSeekVer(pReader, ver) < 0) {
+ code = walReaderSeekVer(pReader, ver);
+ if (code) {
wError("vgId:%d, unexpected wal log, index:%" PRId64 ", since %s", pReader->pWal->cfg.vgId, ver, terrstr());
taosThreadMutexUnlock(&pReader->mutex);
- return -1;
+
+ TAOS_RETURN(code);
}
+
seeked = true;
}
@@ -421,22 +412,24 @@ int32_t walReadVer(SWalReader *pReader, int64_t ver) {
if (contLen == sizeof(SWalCkHead)) {
break;
} else if (contLen == 0 && !seeked) {
- if(walReadSeekVerImpl(pReader, ver) < 0){
+ code = walReadSeekVerImpl(pReader, ver);
+ if (code) {
taosThreadMutexUnlock(&pReader->mutex);
- return -1;
+
+ TAOS_RETURN(code);
}
seeked = true;
continue;
} else {
- if (contLen < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- } else {
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
- }
wError("vgId:%d, failed to read WAL record head, index:%" PRId64 ", from log file since %s",
pReader->pWal->cfg.vgId, ver, terrstr());
taosThreadMutexUnlock(&pReader->mutex);
- return -1;
+
+ if (contLen < 0) {
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+ } else {
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
+ }
}
}
@@ -444,54 +437,57 @@ int32_t walReadVer(SWalReader *pReader, int64_t ver) {
if (code != 0) {
wError("vgId:%d, unexpected wal log, index:%" PRId64 ", since head checksum not passed", pReader->pWal->cfg.vgId,
ver);
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
taosThreadMutexUnlock(&pReader->mutex);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
int32_t plainBodyLen = pReader->pHead->head.bodyLen;
int32_t cryptedBodyLen = plainBodyLen;
-
- //TODO: dmchen emun
- if(pReader->pWal->cfg.encryptAlgorithm == 1){
+
+ // TODO: dmchen emun
+ if (pReader->pWal->cfg.encryptAlgorithm == 1) {
cryptedBodyLen = ENCRYPTED_LEN(cryptedBodyLen);
}
if (pReader->capacity < cryptedBodyLen) {
- SWalCkHead *ptr =
- (SWalCkHead *)taosMemoryRealloc(pReader->pHead, sizeof(SWalCkHead) + cryptedBodyLen);
+ SWalCkHead *ptr = (SWalCkHead *)taosMemoryRealloc(pReader->pHead, sizeof(SWalCkHead) + cryptedBodyLen);
if (ptr == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
taosThreadMutexUnlock(&pReader->mutex);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
}
pReader->pHead = ptr;
pReader->capacity = cryptedBodyLen;
}
- if ((contLen = taosReadFile(pReader->pLogFile, pReader->pHead->head.body, cryptedBodyLen)) !=
- cryptedBodyLen) {
- if (contLen < 0)
- terrno = TAOS_SYSTEM_ERROR(errno);
- else {
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
- }
+ if ((contLen = taosReadFile(pReader->pLogFile, pReader->pHead->head.body, cryptedBodyLen)) != cryptedBodyLen) {
wError("vgId:%d, failed to read WAL record body, index:%" PRId64 ", from log file since %s",
pReader->pWal->cfg.vgId, ver, terrstr());
taosThreadMutexUnlock(&pReader->mutex);
- return -1;
+
+ if (contLen < 0) {
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+ } else {
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
+ }
}
if (pReader->pHead->head.version != ver) {
wError("vgId:%d, unexpected wal log, index:%" PRId64 ", read request index:%" PRId64, pReader->pWal->cfg.vgId,
pReader->pHead->head.version, ver);
-// pReader->curInvalid = 1;
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
+ // pReader->curInvalid = 1;
taosThreadMutexUnlock(&pReader->mutex);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
- decryptBody(&pReader->pWal->cfg, pReader->pHead, plainBodyLen, __FUNCTION__);
+ code = decryptBody(&pReader->pWal->cfg, pReader->pHead, plainBodyLen, __FUNCTION__);
+ if (code) {
+ taosThreadMutexUnlock(&pReader->mutex);
+
+ TAOS_RETURN(code);
+ }
code = walValidBodyCksum(pReader->pHead);
if (code != 0) {
@@ -500,23 +496,27 @@ int32_t walReadVer(SWalReader *pReader, int64_t ver) {
uint32_t readCkSum = walCalcBodyCksum(pReader->pHead->head.body, plainBodyLen);
uint32_t logCkSum = pReader->pHead->cksumBody;
wError("checksum written into log:%u, checksum calculated:%u", logCkSum, readCkSum);
-// pReader->curInvalid = 1;
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
+ // pReader->curInvalid = 1;
+
taosThreadMutexUnlock(&pReader->mutex);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
pReader->curVersion++;
taosThreadMutexUnlock(&pReader->mutex);
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
-void decryptBody(SWalCfg* cfg, SWalCkHead* pHead, int32_t plainBodyLen, const char* func) {
- //TODO: dmchen emun
+int32_t decryptBody(SWalCfg *cfg, SWalCkHead *pHead, int32_t plainBodyLen, const char *func) {
+ // TODO: dmchen emun
if (cfg->encryptAlgorithm == 1) {
int32_t cryptedBodyLen = ENCRYPTED_LEN(plainBodyLen);
char *newBody = taosMemoryMalloc(cryptedBodyLen);
+ if (!newBody) {
+ TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+ }
SCryptOpts opts;
opts.len = cryptedBodyLen;
@@ -527,12 +527,14 @@ void decryptBody(SWalCfg* cfg, SWalCkHead* pHead, int32_t plainBodyLen, const ch
int32_t count = CBC_Decrypt(&opts);
- //wDebug("CBC_Decrypt cryptedBodyLen:%d, plainBodyLen:%d, %s", count, plainBodyLen, func);
+ // wDebug("CBC_Decrypt cryptedBodyLen:%d, plainBodyLen:%d, %s", count, plainBodyLen, func);
memcpy(pHead->head.body, newBody, plainBodyLen);
taosMemoryFree(newBody);
}
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
void walReadReset(SWalReader *pReader) {
diff --git a/source/libs/wal/src/walRef.c b/source/libs/wal/src/walRef.c
index 7f47517257..ecca876c0d 100644
--- a/source/libs/wal/src/walRef.c
+++ b/source/libs/wal/src/walRef.c
@@ -22,27 +22,39 @@
SWalRef *walOpenRef(SWal *pWal) {
SWalRef *pRef = taosMemoryCalloc(1, sizeof(SWalRef));
if (pRef == NULL) {
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
+
pRef->refId = tGenIdPI64();
+
+ if (taosHashPut(pWal->pRefHash, &pRef->refId, sizeof(int64_t), &pRef, sizeof(void *))) {
+ taosMemoryFree(pRef);
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
+ return NULL;
+ }
+
pRef->refVer = -1;
- // pRef->refFile = -1;
pRef->pWal = pWal;
- taosHashPut(pWal->pRefHash, &pRef->refId, sizeof(int64_t), &pRef, sizeof(void *));
+
return pRef;
}
void walCloseRef(SWal *pWal, int64_t refId) {
SWalRef **ppRef = taosHashGet(pWal->pRefHash, &refId, sizeof(int64_t));
- if (ppRef == NULL) return;
- SWalRef *pRef = *ppRef;
- if (pRef) {
- wDebug("vgId:%d, wal close ref %" PRId64 ", refId %" PRId64, pWal->cfg.vgId, pRef->refVer, pRef->refId);
- } else {
- wDebug("vgId:%d, wal close ref null, refId %" PRId64, pWal->cfg.vgId, refId);
+ if (ppRef) {
+ SWalRef *pRef = *ppRef;
+
+ if (pRef) {
+ wDebug("vgId:%d, wal close ref %" PRId64 ", refId %" PRId64, pWal->cfg.vgId, pRef->refVer, pRef->refId);
+
+ taosMemoryFree(pRef);
+ } else {
+ wDebug("vgId:%d, wal close ref null, refId %" PRId64, pWal->cfg.vgId, refId);
+ }
+
+ (void)taosHashRemove(pWal->pRefHash, &refId, sizeof(int64_t));
}
- taosHashRemove(pWal->pRefHash, &refId, sizeof(int64_t));
- taosMemoryFree(pRef);
}
int32_t walSetRefVer(SWalRef *pRef, int64_t ver) {
@@ -52,30 +64,31 @@ int32_t walSetRefVer(SWalRef *pRef, int64_t ver) {
taosThreadMutexLock(&pWal->mutex);
if (ver < pWal->vers.firstVer || ver > pWal->vers.lastVer) {
taosThreadMutexUnlock(&pWal->mutex);
- return TSDB_CODE_WAL_INVALID_VER;
+
+ TAOS_RETURN(TSDB_CODE_WAL_INVALID_VER);
}
pRef->refVer = ver;
taosThreadMutexUnlock(&pWal->mutex);
}
- return TSDB_CODE_SUCCESS;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
void walRefFirstVer(SWal *pWal, SWalRef *pRef) {
taosThreadMutexLock(&pWal->mutex);
- int64_t ver = walGetFirstVer(pWal);
- pRef->refVer = ver;
+
+ pRef->refVer = pWal->vers.firstVer;
taosThreadMutexUnlock(&pWal->mutex);
- wDebug("vgId:%d, wal ref version %" PRId64 " for first", pWal->cfg.vgId, ver);
+ wDebug("vgId:%d, wal ref version %" PRId64 " for first", pWal->cfg.vgId, pRef->refVer);
}
void walRefLastVer(SWal *pWal, SWalRef *pRef) {
taosThreadMutexLock(&pWal->mutex);
- int64_t ver = walGetLastVer(pWal);
- pRef->refVer = ver;
+
+ pRef->refVer = pWal->vers.lastVer;
taosThreadMutexUnlock(&pWal->mutex);
- wDebug("vgId:%d, wal ref version %" PRId64 " for last", pWal->cfg.vgId, ver);
+ wDebug("vgId:%d, wal ref version %" PRId64 " for last", pWal->cfg.vgId, pRef->refVer);
}
diff --git a/source/libs/wal/src/walSeek.c b/source/libs/wal/src/walSeek.c
deleted file mode 100644
index 0e452a937b..0000000000
--- a/source/libs/wal/src/walSeek.c
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc.
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see .
- */
-
-#define _DEFAULT_SOURCE
-#include "os.h"
-#include "taoserror.h"
-#include "tref.h"
-#include "walInt.h"
-
-#if 0
-static int64_t walSeekWritePos(SWal* pWal, int64_t ver) {
- int64_t code = 0;
-
- TdFilePtr pIdxTFile = pWal->pIdxFile;
- TdFilePtr pLogTFile = pWal->pLogFile;
-
- // seek position
- int64_t idxOff = walGetVerIdxOffset(pWal, ver);
- code = taosLSeekFile(pIdxTFile, idxOff, SEEK_SET);
- if (code != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
- }
- SWalIdxEntry entry;
- // TODO:deserialize
- code = taosReadFile(pIdxTFile, &entry, sizeof(SWalIdxEntry));
- if (code != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
- }
- code = taosLSeekFile(pLogTFile, entry.offset, SEEK_SET);
- if (code < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
- }
- return 0;
-}
-#endif
-
-int walInitWriteFile(SWal* pWal) {
- TdFilePtr pIdxTFile, pLogTFile;
- SWalFileInfo* pRet = taosArrayGetLast(pWal->fileInfoSet);
- int64_t fileFirstVer = pRet->firstVer;
-
- char fnameStr[WAL_FILE_LEN];
- walBuildIdxName(pWal, fileFirstVer, fnameStr);
- pIdxTFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
- if (pIdxTFile == NULL) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
- }
- walBuildLogName(pWal, fileFirstVer, fnameStr);
- pLogTFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
- if (pLogTFile == NULL) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
- }
- // switch file
- pWal->pIdxFile = pIdxTFile;
- pWal->pLogFile = pLogTFile;
- pWal->writeCur = taosArrayGetSize(pWal->fileInfoSet) - 1;
- return 0;
-}
-
-int64_t walChangeWrite(SWal* pWal, int64_t ver) {
- int code;
- TdFilePtr pIdxTFile, pLogTFile;
- char fnameStr[WAL_FILE_LEN];
- if (pWal->pLogFile != NULL) {
- if (pWal->cfg.level != TAOS_WAL_SKIP && (code = taosFsyncFile(pWal->pLogFile)) != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
- }
- code = taosCloseFile(&pWal->pLogFile);
- if (code != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
- }
- }
- if (pWal->pIdxFile != NULL) {
- if (pWal->cfg.level != TAOS_WAL_SKIP && (code = taosFsyncFile(pWal->pIdxFile)) != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
- }
- code = taosCloseFile(&pWal->pIdxFile);
- if (code != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
- }
- }
-
- SWalFileInfo tmpInfo;
- tmpInfo.firstVer = ver;
- // bsearch in fileSet
- int32_t idx = taosArraySearchIdx(pWal->fileInfoSet, &tmpInfo, compareWalFileInfo, TD_LE);
- /*A(idx != -1);*/
- SWalFileInfo* pFileInfo = taosArrayGet(pWal->fileInfoSet, idx);
-
- int64_t fileFirstVer = pFileInfo->firstVer;
- walBuildIdxName(pWal, fileFirstVer, fnameStr);
- pIdxTFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
- if (pIdxTFile == NULL) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- pWal->pIdxFile = NULL;
- return -1;
- }
- walBuildLogName(pWal, fileFirstVer, fnameStr);
- pLogTFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
- if (pLogTFile == NULL) {
- taosCloseFile(&pIdxTFile);
- terrno = TAOS_SYSTEM_ERROR(errno);
- pWal->pLogFile = NULL;
- return -1;
- }
-
- pWal->pLogFile = pLogTFile;
- pWal->pIdxFile = pIdxTFile;
- pWal->writeCur = idx;
- return fileFirstVer;
-}
-
-#if 0
-int walSeekWriteVer(SWal* pWal, int64_t ver) {
- int64_t code;
- if (ver == pWal->vers.lastVer) {
- return 0;
- }
- if (ver > pWal->vers.lastVer || ver < pWal->vers.firstVer) {
- terrno = TSDB_CODE_WAL_INVALID_VER;
- return -1;
- }
- if (ver < pWal->vers.snapshotVer) {
- }
- if (ver < walGetCurFileFirstVer(pWal) || (ver > walGetCurFileLastVer(pWal))) {
- code = walChangeWrite(pWal, ver);
- if (code != 0) {
- return -1;
- }
- }
- code = walSeekWritePos(pWal, ver);
- if (code != 0) {
- return -1;
- }
-
- return 0;
-}
-#endif
diff --git a/source/libs/wal/src/walWrite.c b/source/libs/wal/src/walWrite.c
index 19345e0644..1053b7a273 100644
--- a/source/libs/wal/src/walWrite.c
+++ b/source/libs/wal/src/walWrite.c
@@ -21,6 +21,8 @@
#include "walInt.h"
int32_t walRestoreFromSnapshot(SWal *pWal, int64_t ver) {
+ int32_t code = 0;
+
taosThreadMutexLock(&pWal->mutex);
wInfo("vgId:%d, restore from snapshot, version %" PRId64, pWal->cfg.vgId, ver);
@@ -33,7 +35,8 @@ int32_t walRestoreFromSnapshot(SWal *pWal, int64_t ver) {
if (pRef->refVer != -1 && pRef->refVer <= ver) {
taosHashCancelIterate(pWal->pRefHash, pIter);
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_FAILED);
}
}
@@ -47,24 +50,25 @@ int32_t walRestoreFromSnapshot(SWal *pWal, int64_t ver) {
char fnameStr[WAL_FILE_LEN];
walBuildLogName(pWal, pFileInfo->firstVer, fnameStr);
if (taosRemoveFile(fnameStr) < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, restore from snapshot, cannot remove file %s since %s", pWal->cfg.vgId, fnameStr, terrstr());
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
wInfo("vgId:%d, restore from snapshot, remove file %s", pWal->cfg.vgId, fnameStr);
walBuildIdxName(pWal, pFileInfo->firstVer, fnameStr);
if (taosRemoveFile(fnameStr) < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, cannot remove file %s since %s", pWal->cfg.vgId, fnameStr, terrstr());
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
wInfo("vgId:%d, restore from snapshot, remove file %s", pWal->cfg.vgId, fnameStr);
}
}
- (void)walRemoveMeta(pWal);
+
+ TAOS_CHECK_RETURN(walRemoveMeta(pWal));
pWal->writeCur = -1;
pWal->totSize = 0;
@@ -78,25 +82,81 @@ int32_t walRestoreFromSnapshot(SWal *pWal, int64_t ver) {
pWal->vers.verInSnapshotting = -1;
taosThreadMutexUnlock(&pWal->mutex);
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
int32_t walApplyVer(SWal *pWal, int64_t ver) {
// TODO: error check
pWal->vers.appliedVer = ver;
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
int32_t walCommit(SWal *pWal, int64_t ver) {
if (ver < pWal->vers.commitVer) {
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
if (ver > pWal->vers.lastVer || pWal->vers.commitVer < pWal->vers.snapshotVer) {
- terrno = TSDB_CODE_WAL_INVALID_VER;
- return -1;
+ TAOS_RETURN(TSDB_CODE_WAL_INVALID_VER);
}
pWal->vers.commitVer = ver;
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
+}
+
+static int64_t walChangeWrite(SWal *pWal, int64_t ver) {
+ int code;
+ TdFilePtr pIdxTFile, pLogTFile;
+ char fnameStr[WAL_FILE_LEN];
+ if (pWal->pLogFile != NULL) {
+ if (pWal->cfg.level != TAOS_WAL_SKIP && (code = taosFsyncFile(pWal->pLogFile)) != 0) {
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+ }
+ code = taosCloseFile(&pWal->pLogFile);
+ if (code != 0) {
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+ }
+ }
+ if (pWal->pIdxFile != NULL) {
+ if (pWal->cfg.level != TAOS_WAL_SKIP && (code = taosFsyncFile(pWal->pIdxFile)) != 0) {
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+ }
+ code = taosCloseFile(&pWal->pIdxFile);
+ if (code != 0) {
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+ }
+ }
+
+ SWalFileInfo tmpInfo;
+ tmpInfo.firstVer = ver;
+ // bsearch in fileSet
+ int32_t idx = taosArraySearchIdx(pWal->fileInfoSet, &tmpInfo, compareWalFileInfo, TD_LE);
+ /*A(idx != -1);*/
+ SWalFileInfo *pFileInfo = taosArrayGet(pWal->fileInfoSet, idx);
+
+ int64_t fileFirstVer = pFileInfo->firstVer;
+ walBuildIdxName(pWal, fileFirstVer, fnameStr);
+ pIdxTFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
+ if (pIdxTFile == NULL) {
+ pWal->pIdxFile = NULL;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+ }
+ walBuildLogName(pWal, fileFirstVer, fnameStr);
+ pLogTFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
+ if (pLogTFile == NULL) {
+ taosCloseFile(&pIdxTFile);
+ pWal->pLogFile = NULL;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+ }
+
+ pWal->pLogFile = pLogTFile;
+ pWal->pIdxFile = pIdxTFile;
+ pWal->writeCur = idx;
+
+ return fileFirstVer;
}
int32_t walRollback(SWal *pWal, int64_t ver) {
@@ -105,9 +165,9 @@ int32_t walRollback(SWal *pWal, int64_t ver) {
int64_t code;
char fnameStr[WAL_FILE_LEN];
if (ver > pWal->vers.lastVer || ver <= pWal->vers.commitVer || ver <= pWal->vers.snapshotVer) {
- terrno = TSDB_CODE_WAL_INVALID_VER;
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_WAL_INVALID_VER);
}
// find correct file
@@ -116,7 +176,8 @@ int32_t walRollback(SWal *pWal, int64_t ver) {
code = walChangeWrite(pWal, ver);
if (code < 0) {
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(code);
}
// delete files in descending order
@@ -136,22 +197,24 @@ int32_t walRollback(SWal *pWal, int64_t ver) {
walBuildIdxName(pWal, walGetCurFileFirstVer(pWal), fnameStr);
taosCloseFile(&pWal->pIdxFile);
TdFilePtr pIdxFile = taosOpenFile(fnameStr, TD_FILE_WRITE | TD_FILE_READ | TD_FILE_APPEND);
-
if (pIdxFile == NULL) {
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
int64_t idxOff = walGetVerIdxOffset(pWal, ver);
code = taosLSeekFile(pIdxFile, idxOff, SEEK_SET);
if (code < 0) {
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
// read idx file and get log file pos
SWalIdxEntry entry;
if (taosReadFile(pIdxFile, &entry, sizeof(SWalIdxEntry)) != sizeof(SWalIdxEntry)) {
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
walBuildLogName(pWal, walGetCurFileFirstVer(pWal), fnameStr);
@@ -160,49 +223,50 @@ int32_t walRollback(SWal *pWal, int64_t ver) {
wDebug("vgId:%d, wal truncate file %s", pWal->cfg.vgId, fnameStr);
if (pLogFile == NULL) {
// TODO
- terrno = TAOS_SYSTEM_ERROR(errno);
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
code = taosLSeekFile(pLogFile, entry.offset, SEEK_SET);
if (code < 0) {
// TODO
- terrno = TAOS_SYSTEM_ERROR(errno);
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
// validate offset
SWalCkHead head;
int64_t size = taosReadFile(pLogFile, &head, sizeof(SWalCkHead));
if (size != sizeof(SWalCkHead)) {
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
code = walValidHeadCksum(&head);
if (code != 0) {
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
if (head.head.version != ver) {
- terrno = TSDB_CODE_WAL_FILE_CORRUPTED;
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_WAL_FILE_CORRUPTED);
}
// truncate old files
code = taosFtruncateFile(pLogFile, entry.offset);
if (code < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
code = taosFtruncateFile(pIdxFile, idxOff);
if (code < 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
pWal->vers.lastVer = ver - 1;
((SWalFileInfo *)taosArrayGetLast(pWal->fileInfoSet))->lastVer = ver - 1;
@@ -215,43 +279,98 @@ int32_t walRollback(SWal *pWal, int64_t ver) {
if (code < 0) {
wError("vgId:%d, failed to save meta since %s", pWal->cfg.vgId, terrstr());
taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+
+ TAOS_RETURN(code);
}
// unlock
taosThreadMutexUnlock(&pWal->mutex);
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
+}
+
+static int32_t walRollImpl(SWal *pWal) {
+ int32_t code = 0, lino = 0;
+
+ if (pWal->pIdxFile != NULL) {
+ if (pWal->cfg.level != TAOS_WAL_SKIP && (code = taosFsyncFile(pWal->pIdxFile)) != 0) {
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _exit);
+ }
+ code = taosCloseFile(&pWal->pIdxFile);
+ if (code != 0) {
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _exit);
+ }
+ }
+
+ if (pWal->pLogFile != NULL) {
+ if (pWal->cfg.level != TAOS_WAL_SKIP && (code = taosFsyncFile(pWal->pLogFile)) != 0) {
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _exit);
+ }
+ code = taosCloseFile(&pWal->pLogFile);
+ if (code != 0) {
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _exit);
+ }
+ }
+
+ TdFilePtr pIdxFile, pLogFile;
+ // create new file
+ int64_t newFileFirstVer = pWal->vers.lastVer + 1;
+ char fnameStr[WAL_FILE_LEN];
+ walBuildIdxName(pWal, newFileFirstVer, fnameStr);
+ pIdxFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
+ if (pIdxFile == NULL) {
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _exit);
+ }
+ walBuildLogName(pWal, newFileFirstVer, fnameStr);
+ pLogFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
+ wDebug("vgId:%d, wal create new file for write:%s", pWal->cfg.vgId, fnameStr);
+ if (pLogFile == NULL) {
+ TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _exit);
+ }
+
+ TAOS_CHECK_GOTO(walRollFileInfo(pWal), &lino, _exit);
+
+ // switch file
+ pWal->pIdxFile = pIdxFile;
+ pWal->pLogFile = pLogFile;
+ pWal->writeCur = taosArrayGetSize(pWal->fileInfoSet) - 1;
+
+ pWal->lastRollSeq = walGetSeq();
+
+ TAOS_CHECK_GOTO(walSaveMeta(pWal), &lino, _exit);
+
+_exit:
+ if (code) {
+ wError("vgId:%d, %s failed at line %d since %s", pWal->cfg.vgId, __func__, lino, tstrerror(code));
+ }
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
static FORCE_INLINE int32_t walCheckAndRoll(SWal *pWal) {
if (taosArrayGetSize(pWal->fileInfoSet) == 0) {
- if (walRollImpl(pWal) < 0) {
- return -1;
- }
- return 0;
+ TAOS_CHECK_RETURN(walRollImpl(pWal));
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
int64_t passed = walGetSeq() - pWal->lastRollSeq;
if (pWal->cfg.rollPeriod != -1 && pWal->cfg.rollPeriod != 0 && passed > pWal->cfg.rollPeriod) {
- if (walRollImpl(pWal) < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walRollImpl(pWal));
} else if (pWal->cfg.segSize != -1 && pWal->cfg.segSize != 0 && walGetLastFileSize(pWal) > pWal->cfg.segSize) {
- if (walRollImpl(pWal) < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walRollImpl(pWal));
}
if (walGetLastFileCachedSize(pWal) > tsWalFsyncDataSizeLimit) {
- if (walSaveMeta(pWal) < 0) {
- return -1;
- }
+ TAOS_CHECK_RETURN(walSaveMeta(pWal));
}
- return 0;
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
int32_t walBeginSnapshot(SWal *pWal, int64_t ver, int64_t logRetention) {
+ int32_t code = 0;
+
taosThreadMutexLock(&pWal->mutex);
ASSERT(logRetention >= 0);
pWal->vers.verInSnapshotting = ver;
@@ -262,22 +381,21 @@ int32_t walBeginSnapshot(SWal *pWal, int64_t ver, int64_t logRetention) {
pWal->cfg.vgId, ver, pWal->vers.logRetention, pWal->vers.firstVer, pWal->vers.lastVer);
// check file rolling
if (walGetLastFileSize(pWal) != 0) {
- if (walRollImpl(pWal) < 0) {
+ if ((code = walRollImpl(pWal)) < 0) {
wError("vgId:%d, failed to roll wal files since %s", pWal->cfg.vgId, terrstr());
- goto _err;
+ goto _exit;
}
}
+_exit:
taosThreadMutexUnlock(&pWal->mutex);
- return 0;
-_err:
- taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+ TAOS_RETURN(code);
}
int32_t walEndSnapshot(SWal *pWal) {
- int32_t code = 0;
+ int32_t code = 0, lino = 0;
+
taosThreadMutexLock(&pWal->mutex);
int64_t ver = pWal->vers.verInSnapshotting;
@@ -286,8 +404,7 @@ int32_t walEndSnapshot(SWal *pWal) {
pWal->cfg.vgId, ver, pWal->vers.logRetention, pWal->vers.firstVer, pWal->vers.lastVer);
if (ver == -1) {
- code = -1;
- goto END;
+ TAOS_CHECK_GOTO(TSDB_CODE_FAILED, &lino, _exit);
}
pWal->vers.snapshotVer = ver;
@@ -357,10 +474,7 @@ int32_t walEndSnapshot(SWal *pWal) {
pWal->totSize = newTotSize;
pWal->vers.verInSnapshotting = -1;
- code = walSaveMeta(pWal);
- if (code < 0) {
- goto END;
- }
+ TAOS_CHECK_GOTO(walSaveMeta(pWal), &lino, _exit);
// delete files
deleteCnt = taosArrayGetSize(pWal->toDeleteFiles);
@@ -373,12 +487,12 @@ int32_t walEndSnapshot(SWal *pWal) {
walBuildLogName(pWal, pInfo->firstVer, fnameStr);
if (taosRemoveFile(fnameStr) < 0 && errno != ENOENT) {
wError("vgId:%d, failed to remove log file %s due to %s", pWal->cfg.vgId, fnameStr, strerror(errno));
- goto END;
+ goto _exit;
}
walBuildIdxName(pWal, pInfo->firstVer, fnameStr);
if (taosRemoveFile(fnameStr) < 0 && errno != ENOENT) {
wError("vgId:%d, failed to remove idx file %s due to %s", pWal->cfg.vgId, fnameStr, strerror(errno));
- goto END;
+ goto _exit;
}
}
if (pInfo != NULL) {
@@ -387,81 +501,19 @@ int32_t walEndSnapshot(SWal *pWal) {
}
taosArrayClear(pWal->toDeleteFiles);
-END:
+_exit:
taosThreadMutexUnlock(&pWal->mutex);
- return code;
-}
-int32_t walRollImpl(SWal *pWal) {
- int32_t code = 0;
-
- if (pWal->pIdxFile != NULL) {
- if (pWal->cfg.level != TAOS_WAL_SKIP && (code = taosFsyncFile(pWal->pIdxFile)) != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto END;
- }
- code = taosCloseFile(&pWal->pIdxFile);
- if (code != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto END;
- }
+ if (code) {
+ wError("vgId:%d, %s failed at line %d since %s", pWal->cfg.vgId, __func__, lino, tstrerror(code));
}
- if (pWal->pLogFile != NULL) {
- if (pWal->cfg.level != TAOS_WAL_SKIP && (code = taosFsyncFile(pWal->pLogFile)) != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto END;
- }
- code = taosCloseFile(&pWal->pLogFile);
- if (code != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- goto END;
- }
- }
-
- TdFilePtr pIdxFile, pLogFile;
- // create new file
- int64_t newFileFirstVer = pWal->vers.lastVer + 1;
- char fnameStr[WAL_FILE_LEN];
- walBuildIdxName(pWal, newFileFirstVer, fnameStr);
- pIdxFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
- if (pIdxFile == NULL) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- code = -1;
- goto END;
- }
- walBuildLogName(pWal, newFileFirstVer, fnameStr);
- pLogFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
- wDebug("vgId:%d, wal create new file for write:%s", pWal->cfg.vgId, fnameStr);
- if (pLogFile == NULL) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- code = -1;
- goto END;
- }
- // error code was set inner
- code = walRollFileInfo(pWal);
- if (code != 0) {
- goto END;
- }
-
- // switch file
- pWal->pIdxFile = pIdxFile;
- pWal->pLogFile = pLogFile;
- pWal->writeCur = taosArrayGetSize(pWal->fileInfoSet) - 1;
-
- pWal->lastRollSeq = walGetSeq();
-
- code = walSaveMeta(pWal);
- if (code < 0) {
- wError("vgId:%d, failed to save meta since %s", pWal->cfg.vgId, terrstr());
- goto END;
- }
-
-END:
return code;
}
static int32_t walWriteIndex(SWal *pWal, int64_t ver, int64_t offset) {
+ int32_t code = 0;
+
SWalIdxEntry entry = {.ver = ver, .offset = offset};
SWalFileInfo *pFileInfo = walGetCurFileInfo(pWal);
@@ -472,8 +524,8 @@ static int32_t walWriteIndex(SWal *pWal, int64_t ver, int64_t offset) {
int64_t size = taosWriteFile(pWal->pIdxFile, &entry, sizeof(SWalIdxEntry));
if (size != sizeof(SWalIdxEntry)) {
wError("vgId:%d, failed to write idx entry due to %s. ver:%" PRId64, pWal->cfg.vgId, strerror(errno), ver);
- terrno = TAOS_SYSTEM_ERROR(errno);
- return -1;
+
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
}
// check alignment of idx entries
@@ -484,12 +536,13 @@ static int32_t walWriteIndex(SWal *pWal, int64_t ver, int64_t offset) {
taosMsleep(100);
exit(EXIT_FAILURE);
}
- return 0;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
}
static FORCE_INLINE int32_t walWriteImpl(SWal *pWal, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta,
const void *body, int32_t bodyLen) {
- int64_t code = 0;
+ int32_t code = 0, lino = 0;
int32_t plainBodyLen = bodyLen;
int64_t offset = walGetCurFileOffset(pWal);
@@ -509,19 +562,16 @@ static FORCE_INLINE int32_t walWriteImpl(SWal *pWal, int64_t index, tmsg_t msgTy
TMSG_INFO(msgType), pWal->writeHead.cksumHead, pWal->writeHead.cksumBody);
if (pWal->cfg.level != TAOS_WAL_SKIP) {
- code = walWriteIndex(pWal, index, offset);
- if (code < 0) {
- goto END;
- }
+ TAOS_CHECK_GOTO(walWriteIndex(pWal, index, offset), &lino, _exit);
}
if (pWal->cfg.level != TAOS_WAL_SKIP &&
taosWriteFile(pWal->pLogFile, &pWal->writeHead, sizeof(SWalCkHead)) != sizeof(SWalCkHead)) {
- terrno = TAOS_SYSTEM_ERROR(errno);
+ code = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, file:%" PRId64 ".log, failed to write since %s", pWal->cfg.vgId, walGetLastFileFirstVer(pWal),
strerror(errno));
- code = -1;
- goto END;
+
+ TAOS_CHECK_GOTO(code, &lino, _exit);
}
int32_t cyptedBodyLen = plainBodyLen;
@@ -536,8 +586,8 @@ static FORCE_INLINE int32_t walWriteImpl(SWal *pWal, int64_t index, tmsg_t msgTy
if (newBody == NULL) {
wError("vgId:%d, file:%" PRId64 ".log, failed to malloc since %s", pWal->cfg.vgId, walGetLastFileFirstVer(pWal),
strerror(errno));
- code = -1;
- goto END;
+
+ TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
}
memset(newBody, 0, cyptedBodyLen);
memcpy(newBody, body, plainBodyLen);
@@ -546,9 +596,10 @@ static FORCE_INLINE int32_t walWriteImpl(SWal *pWal, int64_t index, tmsg_t msgTy
if (newBodyEncrypted == NULL) {
wError("vgId:%d, file:%" PRId64 ".log, failed to malloc since %s", pWal->cfg.vgId, walGetLastFileFirstVer(pWal),
strerror(errno));
- code = -1;
+
if (newBody != NULL) taosMemoryFreeClear(newBody);
- goto END;
+
+ TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
}
SCryptOpts opts;
@@ -567,15 +618,16 @@ static FORCE_INLINE int32_t walWriteImpl(SWal *pWal, int64_t index, tmsg_t msgTy
}
if (pWal->cfg.level != TAOS_WAL_SKIP && taosWriteFile(pWal->pLogFile, (char *)buf, cyptedBodyLen) != cyptedBodyLen) {
- terrno = TAOS_SYSTEM_ERROR(errno);
+ code = TAOS_SYSTEM_ERROR(errno);
wError("vgId:%d, file:%" PRId64 ".log, failed to write since %s", pWal->cfg.vgId, walGetLastFileFirstVer(pWal),
strerror(errno));
- code = -1;
+
if (pWal->cfg.encryptAlgorithm == DND_CA_SM4) {
taosMemoryFreeClear(newBody);
taosMemoryFreeClear(newBodyEncrypted);
}
- goto END;
+
+ TAOS_CHECK_GOTO(code, &lino, _exit);
}
if (pWal->cfg.encryptAlgorithm == DND_CA_SM4) {
@@ -596,7 +648,7 @@ static FORCE_INLINE int32_t walWriteImpl(SWal *pWal, int64_t index, tmsg_t msgTy
return 0;
-END:
+_exit:
// recover in a reverse order
if (taosFtruncateFile(pWal->pLogFile, offset) < 0) {
terrno = TAOS_SYSTEM_ERROR(errno);
@@ -614,88 +666,66 @@ END:
taosMsleep(100);
exit(EXIT_FAILURE);
}
- return -1;
+
+ TAOS_RETURN(TSDB_CODE_FAILED);
}
-int64_t walAppendLog(SWal *pWal, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body,
+static int32_t walInitWriteFile(SWal *pWal) {
+ TdFilePtr pIdxTFile, pLogTFile;
+ SWalFileInfo *pRet = taosArrayGetLast(pWal->fileInfoSet);
+ int64_t fileFirstVer = pRet->firstVer;
+
+ char fnameStr[WAL_FILE_LEN];
+ walBuildIdxName(pWal, fileFirstVer, fnameStr);
+ pIdxTFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
+ if (pIdxTFile == NULL) {
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+ }
+ walBuildLogName(pWal, fileFirstVer, fnameStr);
+ pLogTFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
+ if (pLogTFile == NULL) {
+ TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+ }
+ // switch file
+ pWal->pIdxFile = pIdxTFile;
+ pWal->pLogFile = pLogTFile;
+ pWal->writeCur = taosArrayGetSize(pWal->fileInfoSet) - 1;
+
+ TAOS_RETURN(TSDB_CODE_SUCCESS);
+}
+
+int32_t walAppendLog(SWal *pWal, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body,
int32_t bodyLen) {
+ int32_t code = 0, lino = 0;
+
taosThreadMutexLock(&pWal->mutex);
if (index != pWal->vers.lastVer + 1) {
- terrno = TSDB_CODE_WAL_INVALID_VER;
- taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+ TAOS_CHECK_GOTO(TSDB_CODE_WAL_INVALID_VER, &lino, _exit);
}
- if (walCheckAndRoll(pWal) < 0) {
- taosThreadMutexUnlock(&pWal->mutex);
- return -1;
- }
+ TAOS_CHECK_GOTO(walCheckAndRoll(pWal), &lino, _exit);
if (pWal->pLogFile == NULL || pWal->pIdxFile == NULL || pWal->writeCur < 0) {
- if (walInitWriteFile(pWal) < 0) {
- taosThreadMutexUnlock(&pWal->mutex);
- return -1;
- }
+ TAOS_CHECK_GOTO(walInitWriteFile(pWal), &lino, _exit);
}
- if (walWriteImpl(pWal, index, msgType, syncMeta, body, bodyLen) < 0) {
- taosThreadMutexUnlock(&pWal->mutex);
- return -1;
- }
+ TAOS_CHECK_GOTO(walWriteImpl(pWal, index, msgType, syncMeta, body, bodyLen), &lino, _exit);
- taosThreadMutexUnlock(&pWal->mutex);
- return index;
-}
-
-int32_t walWriteWithSyncInfo(SWal *pWal, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body,
- int32_t bodyLen) {
- int32_t code = 0;
-
- taosThreadMutexLock(&pWal->mutex);
-
- // concurrency control:
- // if logs are write with assigned index,
- // smaller index must be write before larger one
- if (index != pWal->vers.lastVer + 1) {
- terrno = TSDB_CODE_WAL_INVALID_VER;
- taosThreadMutexUnlock(&pWal->mutex);
- return -1;
- }
-
- if (walCheckAndRoll(pWal) < 0) {
- taosThreadMutexUnlock(&pWal->mutex);
- return -1;
- }
-
- if (pWal->pIdxFile == NULL || pWal->pLogFile == NULL || pWal->writeCur < 0) {
- if (walInitWriteFile(pWal) < 0) {
- taosThreadMutexUnlock(&pWal->mutex);
- return -1;
- }
- }
-
- if (walWriteImpl(pWal, index, msgType, syncMeta, body, bodyLen) < 0) {
- taosThreadMutexUnlock(&pWal->mutex);
- return -1;
+_exit:
+ if (code) {
+ wError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
}
taosThreadMutexUnlock(&pWal->mutex);
return code;
}
-int32_t walWrite(SWal *pWal, int64_t index, tmsg_t msgType, const void *body, int32_t bodyLen) {
- SWalSyncInfo syncMeta = {
- .isWeek = -1,
- .seqNum = UINT64_MAX,
- .term = UINT64_MAX,
- };
- return walWriteWithSyncInfo(pWal, index, msgType, syncMeta, body, bodyLen);
-}
+int32_t walFsync(SWal *pWal, bool forceFsync) {
+ int32_t code = 0;
-void walFsync(SWal *pWal, bool forceFsync) {
if (pWal->cfg.level == TAOS_WAL_SKIP) {
- return;
+ return code;
}
taosThreadMutexLock(&pWal->mutex);
@@ -704,7 +734,10 @@ void walFsync(SWal *pWal, bool forceFsync) {
if (taosFsyncFile(pWal->pLogFile) < 0) {
wError("vgId:%d, file:%" PRId64 ".log, fsync failed since %s", pWal->cfg.vgId, walGetCurFileFirstVer(pWal),
strerror(errno));
+ code = TAOS_SYSTEM_ERROR(errno);
}
}
taosThreadMutexUnlock(&pWal->mutex);
+
+ return code;
}
diff --git a/source/libs/wal/test/walMetaTest.cpp b/source/libs/wal/test/walMetaTest.cpp
index fb64bec722..c7e83e7c86 100644
--- a/source/libs/wal/test/walMetaTest.cpp
+++ b/source/libs/wal/test/walMetaTest.cpp
@@ -5,8 +5,9 @@
#include "walInt.h"
-const char* ranStr = "tvapq02tcp";
-const int ranStrLen = strlen(ranStr);
+const char* ranStr = "tvapq02tcp";
+const int ranStrLen = strlen(ranStr);
+SWalSyncInfo syncMeta = {0};
class WalCleanEnv : public ::testing::Test {
protected:
@@ -170,7 +171,9 @@ TEST_F(WalCleanEnv, serialize) {
ASSERT(code == 0);
code = walRollFileInfo(pWal);
ASSERT(code == 0);
- char* ss = walMetaSerialize(pWal);
+ char* ss = NULL;
+ code = walMetaSerialize(pWal, &ss);
+ ASSERT(code == 0);
printf("%s\n", ss);
taosMemoryFree(ss);
code = walSaveMeta(pWal);
@@ -193,15 +196,21 @@ TEST_F(WalKeepEnv, readOldMeta) {
walResetEnv();
int code;
+ syncMeta.isWeek = -1;
+ syncMeta.seqNum = UINT64_MAX;
+ syncMeta.term = UINT64_MAX;
+
for (int i = 0; i < 10; i++) {
- code = walWrite(pWal, i, i + 1, (void*)ranStr, ranStrLen);
+ code = walAppendLog(pWal, i, i + 1, syncMeta, (void*)ranStr, ranStrLen);
ASSERT_EQ(code, 0);
ASSERT_EQ(pWal->vers.lastVer, i);
- code = walWrite(pWal, i + 2, i, (void*)ranStr, ranStrLen);
- ASSERT_EQ(code, -1);
+ code = walAppendLog(pWal, i + 2, i, syncMeta, (void*)ranStr, ranStrLen);
+ ASSERT_EQ(code, TSDB_CODE_WAL_INVALID_VER);
ASSERT_EQ(pWal->vers.lastVer, i);
}
- char* oldss = walMetaSerialize(pWal);
+ char* oldss = NULL;
+ code = walMetaSerialize(pWal, &oldss);
+ ASSERT(code == 0);
TearDown();
SetUp();
@@ -209,7 +218,9 @@ TEST_F(WalKeepEnv, readOldMeta) {
ASSERT_EQ(pWal->vers.firstVer, 0);
ASSERT_EQ(pWal->vers.lastVer, 9);
- char* newss = walMetaSerialize(pWal);
+ char* newss = NULL;
+ code = walMetaSerialize(pWal, &newss);
+ ASSERT(code == 0);
int len = strlen(oldss);
ASSERT_EQ(len, strlen(newss));
@@ -223,11 +234,11 @@ TEST_F(WalKeepEnv, readOldMeta) {
TEST_F(WalCleanEnv, write) {
int code;
for (int i = 0; i < 10; i++) {
- code = walWrite(pWal, i, i + 1, (void*)ranStr, ranStrLen);
+ code = walAppendLog(pWal, i, i + 1, syncMeta, (void*)ranStr, ranStrLen);
ASSERT_EQ(code, 0);
ASSERT_EQ(pWal->vers.lastVer, i);
- code = walWrite(pWal, i + 2, i, (void*)ranStr, ranStrLen);
- ASSERT_EQ(code, -1);
+ code = walAppendLog(pWal, i + 2, i, syncMeta, (void*)ranStr, ranStrLen);
+ ASSERT_EQ(code, TSDB_CODE_WAL_INVALID_VER);
ASSERT_EQ(pWal->vers.lastVer, i);
}
code = walSaveMeta(pWal);
@@ -237,7 +248,7 @@ TEST_F(WalCleanEnv, write) {
TEST_F(WalCleanEnv, rollback) {
int code;
for (int i = 0; i < 10; i++) {
- code = walWrite(pWal, i, i + 1, (void*)ranStr, ranStrLen);
+ code = walAppendLog(pWal, i, i + 1, syncMeta, (void*)ranStr, ranStrLen);
ASSERT_EQ(code, 0);
ASSERT_EQ(pWal->vers.lastVer, i);
}
@@ -260,7 +271,7 @@ TEST_F(WalCleanEnv, rollback) {
TEST_F(WalCleanEnv, rollbackMultiFile) {
int code;
for (int i = 0; i < 10; i++) {
- code = walWrite(pWal, i, i + 1, (void*)ranStr, ranStrLen);
+ code = walAppendLog(pWal, i, i + 1, syncMeta, (void*)ranStr, ranStrLen);
ASSERT_EQ(code, 0);
ASSERT_EQ(pWal->vers.lastVer, i);
if (i == 5) {
@@ -278,11 +289,11 @@ TEST_F(WalCleanEnv, rollbackMultiFile) {
ASSERT_EQ(code, 0);
ASSERT_EQ(pWal->vers.lastVer, 5);
code = walRollback(pWal, 5);
- ASSERT_EQ(code, -1);
+ ASSERT_NE(code, 0);
ASSERT_EQ(pWal->vers.lastVer, 5);
- code = walWrite(pWal, 6, 6, (void*)ranStr, ranStrLen);
+ code = walAppendLog(pWal, 6, 6, syncMeta, (void*)ranStr, ranStrLen);
ASSERT_EQ(code, 0);
ASSERT_EQ(pWal->vers.lastVer, 6);
@@ -294,7 +305,7 @@ TEST_F(WalCleanDeleteEnv, roll) {
int code;
int i;
for (i = 0; i < 100; i++) {
- code = walWrite(pWal, i, 0, (void*)ranStr, ranStrLen);
+ code = walAppendLog(pWal, i, 0, syncMeta, (void*)ranStr, ranStrLen);
ASSERT_EQ(code, 0);
ASSERT_EQ(pWal->vers.lastVer, i);
code = walCommit(pWal, i);
@@ -307,11 +318,11 @@ TEST_F(WalCleanDeleteEnv, roll) {
ASSERT_EQ(pWal->vers.snapshotVer, i - 1);
ASSERT_EQ(pWal->vers.verInSnapshotting, -1);
- code = walWrite(pWal, 5, 0, (void*)ranStr, ranStrLen);
+ code = walAppendLog(pWal, 5, 0, syncMeta, (void*)ranStr, ranStrLen);
ASSERT_NE(code, 0);
for (; i < 200; i++) {
- code = walWrite(pWal, i, 0, (void*)ranStr, ranStrLen);
+ code = walAppendLog(pWal, i, 0, syncMeta, (void*)ranStr, ranStrLen);
ASSERT_EQ(code, 0);
code = walCommit(pWal, i);
ASSERT_EQ(pWal->vers.commitVer, i);
@@ -334,7 +345,7 @@ TEST_F(WalKeepEnv, readHandleRead) {
char newStr[100];
sprintf(newStr, "%s-%d", ranStr, i);
int len = strlen(newStr);
- code = walWrite(pWal, i, 0, newStr, len);
+ code = walAppendLog(pWal, i, 0, syncMeta, newStr, len);
ASSERT_EQ(code, 0);
}
for (int i = 0; i < 1000; i++) {
@@ -370,7 +381,7 @@ TEST_F(WalRetentionEnv, repairMeta1) {
char newStr[100];
sprintf(newStr, "%s-%d", ranStr, i);
int len = strlen(newStr);
- code = walWrite(pWal, i, 0, newStr, len);
+ code = walAppendLog(pWal, i, 0, syncMeta, newStr, len);
ASSERT_EQ(code, 0);
}
@@ -416,7 +427,7 @@ TEST_F(WalRetentionEnv, repairMeta1) {
char newStr[100];
sprintf(newStr, "%s-%d", ranStr, i);
int len = strlen(newStr);
- code = walWrite(pWal, i, 0, newStr, len);
+ code = walAppendLog(pWal, i, 0, syncMeta, newStr, len);
ASSERT_EQ(code, 0);
}
diff --git a/source/os/src/osDir.c b/source/os/src/osDir.c
index 667c3c146a..c04add2f42 100644
--- a/source/os/src/osDir.c
+++ b/source/os/src/osDir.c
@@ -44,7 +44,7 @@ int wordexp(char *words, wordexp_t *pwordexp, int flags) {
pwordexp->we_wordc = 1;
pwordexp->we_wordv[0] = pwordexp->wordPos;
- memset(pwordexp->wordPos, 0, 1025);
+ (void)memset(pwordexp->wordPos, 0, 1025);
if (_fullpath(pwordexp->wordPos, words, 1024) == NULL) {
pwordexp->we_wordv[0] = words;
printf("failed to parse relative path:%s to abs path\n", words);
@@ -100,7 +100,7 @@ void taosRemoveDir(const char *dirname) {
if (strcmp(taosGetDirEntryName(de), ".") == 0 || strcmp(taosGetDirEntryName(de), "..") == 0) continue;
char filename[1024] = {0};
- snprintf(filename, sizeof(filename), "%s%s%s", dirname, TD_DIRSEP, taosGetDirEntryName(de));
+ (void)snprintf(filename, sizeof(filename), "%s%s%s", dirname, TD_DIRSEP, taosGetDirEntryName(de));
if (taosDirEntryIsDir(de)) {
taosRemoveDir(filename);
} else {
@@ -109,8 +109,8 @@ void taosRemoveDir(const char *dirname) {
}
}
- taosCloseDir(&pDir);
- rmdir(dirname);
+ (void)taosCloseDir(&pDir);
+ (void)rmdir(dirname);
// printf("dir:%s is removed\n", dirname);
return;
@@ -127,8 +127,13 @@ int32_t taosMkDir(const char *dirname) {
#else
int32_t code = mkdir(dirname, 0755);
#endif
- if (code < 0 && errno == EEXIST) {
- return 0;
+ if (-1 == code) {
+ if (errno == EEXIST) {
+ return 0;
+ } else {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ code = terrno;
+ }
}
return code;
@@ -143,7 +148,7 @@ int32_t taosMulMkDir(const char *dirname) {
taosRealPath(dirname, temp, sizeof(temp));
if (temp[1] == ':') pos += 3;
#else
- strcpy(temp, dirname);
+ (void)strcpy(temp, dirname);
#endif
if (taosDirExist(temp)) return code;
@@ -165,7 +170,7 @@ int32_t taosMulMkDir(const char *dirname) {
code = mkdir(temp, 0755);
#endif
if (code < 0 && errno != EEXIST) {
- // terrno = TAOS_SYSTEM_ERROR(errno);
+ terrno = TAOS_SYSTEM_ERROR(errno);
return code;
}
*pos = TD_DIRSEP[0];
@@ -181,7 +186,7 @@ int32_t taosMulMkDir(const char *dirname) {
code = mkdir(temp, 0755);
#endif
if (code < 0 && errno != EEXIST) {
- // terrno = TAOS_SYSTEM_ERROR(errno);
+ terrno = TAOS_SYSTEM_ERROR(errno);
return code;
}
}
@@ -194,7 +199,10 @@ int32_t taosMulMkDir(const char *dirname) {
}
int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) {
- if (dirname == NULL || strlen(dirname) >= TDDIRMAXLEN) return -1;
+ if (dirname == NULL || strlen(dirname) >= TDDIRMAXLEN) {
+ terrno = TSDB_CODE_INVALID_PARA;
+ return terrno;
+ }
char temp[TDDIRMAXLEN];
char *pos = temp;
int32_t code = 0;
@@ -202,14 +210,18 @@ int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) {
taosRealPath(dirname, temp, sizeof(temp));
if (temp[1] == ':') pos += 3;
#else
- strcpy(temp, dirname);
+ (void)strcpy(temp, dirname);
#endif
if (taosDirExist(temp)) {
if (checkAccess && taosCheckAccessFile(temp, TD_FILE_ACCESS_EXIST_OK | TD_FILE_ACCESS_READ_OK | TD_FILE_ACCESS_WRITE_OK)) {
return 0;
}
- return chmod(temp, mode);
+ code = chmod(temp, mode);
+ if (-1 == code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
+ }
}
if (strncmp(temp, TD_DIRSEP, 1) == 0) {
@@ -229,8 +241,8 @@ int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) {
code = mkdir(temp, mode);
#endif
if (code < 0 && errno != EEXIST) {
- // terrno = TAOS_SYSTEM_ERROR(errno);
- return code;
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
}
*pos = TD_DIRSEP[0];
}
@@ -245,8 +257,8 @@ int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) {
code = mkdir(temp, mode);
#endif
if (code < 0 && errno != EEXIST) {
- // terrno = TAOS_SYSTEM_ERROR(errno);
- return code;
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
}
}
@@ -254,10 +266,14 @@ int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) {
if (checkAccess && taosCheckAccessFile(temp, TD_FILE_ACCESS_EXIST_OK | TD_FILE_ACCESS_READ_OK | TD_FILE_ACCESS_WRITE_OK)) {
return 0;
}
- return chmod(temp, mode);
}
- return chmod(temp, mode);
+ code = chmod(temp, mode);
+ if (-1 == code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
+ }
+ return code;
}
void taosRemoveOldFiles(const char *dirname, int32_t keepDays) {
@@ -271,7 +287,7 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) {
if (strcmp(taosGetDirEntryName(de), ".") == 0 || strcmp(taosGetDirEntryName(de), "..") == 0) continue;
char filename[1024];
- snprintf(filename, sizeof(filename), "%s/%s", dirname, taosGetDirEntryName(de));
+ (void)snprintf(filename, sizeof(filename), "%s/%s", dirname, taosGetDirEntryName(de));
if (taosDirEntryIsDir(de)) {
continue;
} else {
@@ -299,34 +315,25 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) {
}
}
- taosCloseDir(&pDir);
- rmdir(dirname);
+ (void)taosCloseDir(&pDir);
+ (void)rmdir(dirname);
}
int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen) {
wordexp_t full_path;
- switch (wordexp(dirname, &full_path, 0)) {
+ int32_t code = wordexp(dirname, &full_path, 0);
+ switch (code) {
case 0:
break;
case WRDE_NOSPACE:
wordfree(&full_path);
- // printf("failed to expand path:%s since Out of memory\n", dirname);
- return -1;
- case WRDE_BADCHAR:
- // printf("failed to expand path:%s since illegal occurrence of newline or one of |, &, ;, <, >, (, ), {, }\n",
- // dirname);
- return -1;
- case WRDE_SYNTAX:
- // printf("failed to expand path:%s since Shell syntax error, such as unbalanced parentheses or unmatched
- // quotes\n", dirname);
- return -1;
+ // FALL THROUGH
default:
- // printf("failed to expand path:%s since %s\n", dirname, strerror(errno));
- return -1;
+ return code;
}
if (full_path.we_wordv != NULL && full_path.we_wordv[0] != NULL) {
- strncpy(outname, full_path.we_wordv[0], maxlen);
+ (void)strncpy(outname, full_path.we_wordv[0], maxlen);
}
wordfree(&full_path);
@@ -343,21 +350,23 @@ int32_t taosRealPath(char *dirname, char *realPath, int32_t maxlen) {
#endif
if (strlen(tmp) < maxlen) {
if (realPath == NULL) {
- strncpy(dirname, tmp, maxlen);
+ (void)strncpy(dirname, tmp, maxlen);
} else {
- strncpy(realPath, tmp, maxlen);
+ (void)strncpy(realPath, tmp, maxlen);
}
return 0;
}
}
- return -1;
+ terrno = TAOS_SYSTEM_ERROR(errno);
+
+ return terrno;
}
bool taosIsDir(const char *dirname) {
TdDirPtr pDir = taosOpenDir(dirname);
if (pDir != NULL) {
- taosCloseDir(&pDir);
+ (void)taosCloseDir(&pDir);
return true;
}
return false;
@@ -410,6 +419,7 @@ char *taosDirEntryBaseName(char *name) {
TdDirPtr taosOpenDir(const char *dirname) {
if (dirname == NULL) {
+ terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
@@ -436,12 +446,17 @@ TdDirPtr taosOpenDir(const char *dirname) {
dirPtr->pDir = pDir;
return dirPtr;
#else
- return (TdDirPtr)opendir(dirname);
+ TdDirPtr ptr = (TdDirPtr)opendir(dirname);
+ if (NULL == ptr) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ }
+ return ptr;
#endif
}
TdDirEntryPtr taosReadDir(TdDirPtr pDir) {
if (pDir == NULL) {
+ terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
#ifdef WINDOWS
@@ -456,7 +471,13 @@ TdDirEntryPtr taosReadDir(TdDirPtr pDir) {
return NULL;
}
#else
- return (TdDirEntryPtr)readdir((DIR *)pDir);
+ errno = 0;
+ terrno = 0;
+ TdDirEntryPtr p = (TdDirEntryPtr)readdir((DIR *)pDir);
+ if (NULL == p && errno) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ }
+ return p;
#endif
}
@@ -484,7 +505,8 @@ char *taosGetDirEntryName(TdDirEntryPtr pDirEntry) {
int32_t taosCloseDir(TdDirPtr *ppDir) {
if (ppDir == NULL || *ppDir == NULL) {
- return -1;
+ terrno = TSDB_CODE_INVALID_PARA;
+ return terrno;
}
#ifdef WINDOWS
FindClose((*ppDir)->hFind);
@@ -497,8 +519,12 @@ int32_t taosCloseDir(TdDirPtr *ppDir) {
*ppDir = NULL;
return 0;
#else
- closedir((DIR *)*ppDir);
+ int32_t code = closedir((DIR *)*ppDir);
*ppDir = NULL;
+ if (-1 == code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
+ }
return 0;
#endif
}
diff --git a/source/os/src/osEnv.c b/source/os/src/osEnv.c
index 948040ac76..72f0a41710 100644
--- a/source/os/src/osEnv.c
+++ b/source/os/src/osEnv.c
@@ -45,11 +45,16 @@ char tsAVX2Supported = 0;
char tsFMASupported = 0;
char tsAVX512Supported = 0;
-void osDefaultInit() {
+int32_t osDefaultInit() {
+ int32_t code = TSDB_CODE_SUCCESS;
+
taosSeedRand(taosSafeRand());
taosGetSystemLocale(tsLocale, tsCharset);
taosGetSystemTimezone(tsTimezoneStr, &tsTimezone);
- taosSetSystemTimezone(tsTimezoneStr, tsTimezoneStr, &tsDaylight, &tsTimezone);
+ code = taosSetSystemTimezone(tsTimezoneStr, tsTimezoneStr, &tsDaylight, &tsTimezone);
+ if (code) {
+ return code;
+ }
taosGetSystemInfo();
// deadlock in query
@@ -65,33 +70,35 @@ void osDefaultInit() {
tmpDir = getenv("temp");
}
if (tmpDir != NULL) {
- strcpy(tsTempDir, tmpDir);
+ (void)strcpy(tsTempDir, tmpDir);
}
- strcpy(tsOsName, "Windows");
+ (void)strcpy(tsOsName, "Windows");
#elif defined(_TD_DARWIN_64)
- strcpy(tsOsName, "Darwin");
+ (void)strcpy(tsOsName, "Darwin");
#else
- strcpy(tsOsName, "Linux");
+ (void)strcpy(tsOsName, "Linux");
#endif
if (configDir[0] == 0) {
- strcpy(configDir, TD_CFG_DIR_PATH);
+ (void)strcpy(configDir, TD_CFG_DIR_PATH);
}
- strcpy(tsDataDir, TD_DATA_DIR_PATH);
- strcpy(tsLogDir, TD_LOG_DIR_PATH);
+ (void)strcpy(tsDataDir, TD_DATA_DIR_PATH);
+ (void)strcpy(tsLogDir, TD_LOG_DIR_PATH);
if(strlen(tsTempDir) == 0){
- strcpy(tsTempDir, TD_TMP_DIR_PATH);
+ (void)strcpy(tsTempDir, TD_TMP_DIR_PATH);
}
+
+ return code;
}
void osUpdate() {
if (tsLogDir[0] != 0) {
- taosGetDiskSize(tsLogDir, &tsLogSpace.size);
+ (void)taosGetDiskSize(tsLogDir, &tsLogSpace.size);
}
if (tsDataDir[0] != 0) {
- taosGetDiskSize(tsDataDir, &tsDataSpace.size);
+ (void)taosGetDiskSize(tsDataDir, &tsDataSpace.size);
}
if (tsTempDir[0] != 0) {
- taosGetDiskSize(tsTempDir, &tsTempSpace.size);
+ (void)taosGetDiskSize(tsTempDir, &tsTempSpace.size);
}
}
@@ -109,11 +116,11 @@ bool osDataSpaceSufficient() { return tsDataSpace.size.avail > tsDataSpace.reser
bool osTempSpaceSufficient() { return tsTempSpace.size.avail > tsTempSpace.reserved; }
-void osSetTimezone(const char *tz) { taosSetSystemTimezone(tz, tsTimezoneStr, &tsDaylight, &tsTimezone); }
+int32_t osSetTimezone(const char *tz) { return taosSetSystemTimezone(tz, tsTimezoneStr, &tsDaylight, &tsTimezone); }
void osSetSystemLocale(const char *inLocale, const char *inCharSet) {
- memcpy(tsLocale, inLocale, strlen(inLocale) + 1);
- memcpy(tsCharset, inCharSet, strlen(inCharSet) + 1);
+ (void)memcpy(tsLocale, inLocale, strlen(inLocale) + 1);
+ (void)memcpy(tsCharset, inCharSet, strlen(inCharSet) + 1);
}
void osSetProcPath(int32_t argc, char **argv) { tsProcPath = argv[0]; }
diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c
index 79acec1211..ef1c2dcdc8 100644
--- a/source/os/src/osFile.c
+++ b/source/os/src/osFile.c
@@ -90,24 +90,24 @@ void taosGetTmpfilePath(const char *inputTmpDir, const char *fileNamePrefix, cha
char tmpPath[PATH_MAX];
int32_t len = strlen(inputTmpDir);
- memcpy(tmpPath, inputTmpDir, len);
+ (void)memcpy(tmpPath, inputTmpDir, len);
static uint64_t seqId = 0;
if (tmpPath[len - 1] != '/') {
tmpPath[len++] = '/';
}
- strcpy(tmpPath + len, TD_TMP_FILE_PREFIX);
+ (void)strcpy(tmpPath + len, TD_TMP_FILE_PREFIX);
if (strlen(tmpPath) + strlen(fileNamePrefix) + strlen("-%d-%s") < PATH_MAX) {
- strcat(tmpPath, fileNamePrefix);
- strcat(tmpPath, "-%d-%s");
+ (void)strcat(tmpPath, fileNamePrefix);
+ (void)strcat(tmpPath, "-%d-%s");
}
char rand[32] = {0};
- sprintf(rand, "%" PRIu64, atomic_add_fetch_64(&seqId, 1));
+ (void)sprintf(rand, "%" PRIu64, atomic_add_fetch_64(&seqId, 1));
- snprintf(dstPath, PATH_MAX, tmpPath, getpid(), rand);
+ (void)snprintf(dstPath, PATH_MAX, tmpPath, getpid(), rand);
#endif
}
@@ -123,41 +123,60 @@ int64_t taosCopyFile(const char *from, const char *to) {
char buffer[4096];
int64_t size = 0;
int64_t bytes;
+ int32_t code = TSDB_CODE_SUCCESS;
// fidfrom = open(from, O_RDONLY);
TdFilePtr pFileFrom = taosOpenFile(from, TD_FILE_READ);
- if (pFileFrom == NULL) goto _err;
+ if (pFileFrom == NULL) {
+ code = terrno;
+ goto _err;
+ }
// fidto = open(to, O_WRONLY | O_CREAT | O_EXCL, 0755);
TdFilePtr pFileTo = taosOpenFile(to, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_EXCL);
- if (pFileTo == NULL) goto _err;
+ if (pFileTo == NULL) {
+ code = terrno;
+ goto _err;
+ }
while (true) {
bytes = taosReadFile(pFileFrom, buffer, sizeof(buffer));
- if (bytes < 0) goto _err;
+ if (bytes < 0) {
+ code = terrno;
+ goto _err;
+ }
+
if (bytes == 0) break;
size += bytes;
- if (taosWriteFile(pFileTo, (void *)buffer, bytes) < bytes) goto _err;
+ if (taosWriteFile(pFileTo, (void *)buffer, bytes) < bytes) {
+ code = terrno;
+ goto _err;
+ }
if (bytes < sizeof(buffer)) break;
}
- int code = taosFsyncFile(pFileTo);
+ code = taosFsyncFile(pFileTo);
- taosCloseFile(&pFileFrom);
- taosCloseFile(&pFileTo);
+ (void)taosCloseFile(&pFileFrom);
+ (void)taosCloseFile(&pFileTo);
if (code != 0) {
+ terrno = code;
return -1;
}
+
return size;
_err:
- if (pFileFrom != NULL) taosCloseFile(&pFileFrom);
- if (pFileTo != NULL) taosCloseFile(&pFileTo);
+
+ if (pFileFrom != NULL) (void)taosCloseFile(&pFileFrom);
+ if (pFileTo != NULL) (void)taosCloseFile(&pFileTo);
/* coverity[+retval] */
- taosRemoveFile(to);
+ (void)taosRemoveFile(to);
+
+ terrno = code;
return -1;
#endif
}
@@ -165,24 +184,31 @@ _err:
TdFilePtr taosCreateFile(const char *path, int32_t tdFileOptions) {
TdFilePtr fp = taosOpenFile(path, tdFileOptions);
if (!fp) {
- if (errno == ENOENT) {
+ if (terrno == TAOS_SYSTEM_ERROR(ENOENT)) {
// Try to create directory recursively
- char *s = taosStrdup(path);
+ char s[PATH_MAX];
+ tstrncpy(s, path, sizeof(s));
if (taosMulMkDir(taosDirName(s)) != 0) {
- taosMemoryFree(s);
return NULL;
}
- taosMemoryFree(s);
fp = taosOpenFile(path, tdFileOptions);
if (!fp) {
return NULL;
}
}
}
+
return fp;
}
-int32_t taosRemoveFile(const char *path) { return remove(path); }
+int32_t taosRemoveFile(const char *path) {
+ int32_t code = remove(path);
+ if (-1 == code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
+ }
+ return code;
+}
int32_t taosRenameFile(const char *oldName, const char *newName) {
#ifdef WINDOWS
@@ -214,8 +240,9 @@ int32_t taosRenameFile(const char *oldName, const char *newName) {
return finished ? 0 : -1;
#else
int32_t code = rename(oldName, newName);
- if (code < 0) {
- printf("failed to rename file %s to %s, reason:%s\n", oldName, newName, strerror(errno));
+ if (-1 == code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
}
return code;
@@ -230,8 +257,9 @@ int32_t taosStatFile(const char *path, int64_t *size, int32_t *mtime, int32_t *a
struct stat fileStat;
int32_t code = stat(path, &fileStat);
#endif
- if (code < 0) {
- return code;
+ if (-1 == code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
}
if (size != NULL) {
@@ -269,13 +297,15 @@ int32_t taosDevInoFile(TdFilePtr pFile, int64_t *stDev, int64_t *stIno) {
#else
if (pFile == NULL || pFile->fd < 0) {
- return TSDB_CODE_INVALID_PARA;
+ terrno = TSDB_CODE_INVALID_PARA;
+ return terrno;
}
+
struct stat fileStat;
int32_t code = fstat(pFile->fd, &fileStat);
- if (code < 0) {
- printf("taosFStatFile run fstat fail.");
- return TAOS_SYSTEM_ERROR(errno);
+ if (-1 == code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
}
if (stDev != NULL) {
@@ -301,11 +331,15 @@ FILE *taosOpenFileForStream(const char *path, int32_t tdFileOptions) {
} else {
mode = (tdFileOptions & TD_FILE_TEXT) ? "rt+" : "rb+";
}
- ASSERT(!(tdFileOptions & TD_FILE_EXCL));
if (tdFileOptions & TD_FILE_EXCL) {
+ terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
- return fopen(path, mode);
+ FILE* f = fopen(path, mode);
+ if (NULL == f) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ }
+ return f;
}
#ifdef WINDOWS
@@ -653,6 +687,9 @@ int taosOpenFileNotStream(const char *path, int32_t tdFileOptions) {
access |= (tdFileOptions & TD_FILE_CLOEXEC) ? O_CLOEXEC : 0;
int fd = open(path, access, S_IRWXU | S_IRWXG | S_IRWXO);
+ if (-1 == fd) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ }
return fd;
}
@@ -1060,14 +1097,14 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
#ifdef WINDOWS
if (hFile != NULL) CloseHandle(hFile);
#else
- if (fd >= 0) close(fd);
+ if (fd >= 0) (void)close(fd);
#endif
- if (fp != NULL) fclose(fp);
+ if (fp != NULL) (void)fclose(fp);
return NULL;
}
#if FILE_WITH_LOCK
- taosThreadRwlockInit(&(pFile->rwlock), NULL);
+ (void)taosThreadRwlockInit(&(pFile->rwlock), NULL);
#endif
pFile->fp = fp;
pFile->refId = 0;
@@ -1082,9 +1119,15 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
// Remove it instantly, so when the program exits normally/abnormally, the file
// will be automatically remove by OS.
if (tdFileOptions & TD_FILE_AUTO_DEL) {
- unlink(path);
+ if (-1 == unlink(path)) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ (void)close(fd);
+ taosMemoryFree(pFile);
+ return NULL;
+ }
}
#endif
+
return pFile;
}
@@ -1094,11 +1137,11 @@ int32_t taosCloseFile(TdFilePtr *ppFile) {
return 0;
}
#if FILE_WITH_LOCK
- taosThreadRwlockWrlock(&((*ppFile)->rwlock));
+ (void)taosThreadRwlockWrlock(&((*ppFile)->rwlock));
#endif
if ((*ppFile)->fp != NULL) {
- fflush((*ppFile)->fp);
- fclose((*ppFile)->fp);
+ (void)fflush((*ppFile)->fp);
+ (void)fclose((*ppFile)->fp);
(*ppFile)->fp = NULL;
}
#ifdef WINDOWS
@@ -1113,16 +1156,20 @@ int32_t taosCloseFile(TdFilePtr *ppFile) {
// warning: never fsync silently in base lib
/*fsync((*ppFile)->fd);*/
code = close((*ppFile)->fd);
+ if (-1 == code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ }
(*ppFile)->fd = -1;
#endif
}
(*ppFile)->refId = 0;
#if FILE_WITH_LOCK
- taosThreadRwlockUnlock(&((*ppFile)->rwlock));
- taosThreadRwlockDestroy(&((*ppFile)->rwlock));
+ (void)taosThreadRwlockUnlock(&((*ppFile)->rwlock));
+ (void)taosThreadRwlockDestroy(&((*ppFile)->rwlock));
#endif
taosMemoryFree(*ppFile);
*ppFile = NULL;
+
return code;
}
@@ -1130,6 +1177,8 @@ int64_t taosPReadFile(TdFilePtr pFile, void *buf, int64_t count, int64_t offset)
if (pFile == NULL) {
return 0;
}
+
+ int32_t code = 0;
#ifdef WINDOWS
#if FILE_WITH_LOCK
@@ -1155,20 +1204,27 @@ int64_t taosPReadFile(TdFilePtr pFile, void *buf, int64_t count, int64_t offset)
}
#else
#if FILE_WITH_LOCK
- taosThreadRwlockRdlock(&(pFile->rwlock));
+ (void)taosThreadRwlockRdlock(&(pFile->rwlock));
#endif
ASSERT(pFile->fd >= 0); // Please check if you have closed the file.
if (pFile->fd < 0) {
#if FILE_WITH_LOCK
- taosThreadRwlockUnlock(&(pFile->rwlock));
+ (void)taosThreadRwlockUnlock(&(pFile->rwlock));
#endif
+ terrno = TSDB_CODE_INVALID_PARA;
return -1;
}
int64_t ret = pread(pFile->fd, buf, count, offset);
+ if (-1 == ret) {
+ code = TAOS_SYSTEM_ERROR(errno);
+ }
#endif
#if FILE_WITH_LOCK
- taosThreadRwlockUnlock(&(pFile->rwlock));
+ (void)taosThreadRwlockUnlock(&(pFile->rwlock));
#endif
+
+ terrno = code;
+
return ret;
}
@@ -1177,20 +1233,36 @@ int32_t taosFsyncFile(TdFilePtr pFile) {
return 0;
}
+ int32_t code = 0;
// this implementation is WRONG
// fflush is not a replacement of fsync
- if (pFile->fp != NULL) return fflush(pFile->fp);
+ if (pFile->fp != NULL) {
+ code = fflush(pFile->fp);
+ if (0 != code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
+ }
+
+ return code;
+ }
+
#ifdef WINDOWS
if (pFile->hFile != NULL) {
if (pFile->tdFileOptions & TD_FILE_WRITE_THROUGH) {
return 0;
}
return !FlushFileBuffers(pFile->hFile);
+ }
#else
if (pFile->fd >= 0) {
- return fsync(pFile->fd);
-#endif
+ code = fsync(pFile->fd);
+ if (-1 == code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
+ }
}
+#endif
+
return 0;
}
@@ -1438,5 +1510,5 @@ int taosSetAutoDelFile(char *path) {
return SetFileAttributes(path, FILE_ATTRIBUTE_TEMPORARY);
#else
return unlink(path);
-#endif
-}
\ No newline at end of file
+#endif
+}
diff --git a/source/os/src/osMemory.c b/source/os/src/osMemory.c
index d130ebe469..25567dfde0 100644
--- a/source/os/src/osMemory.c
+++ b/source/os/src/osMemory.c
@@ -186,7 +186,7 @@ static void print_line(Dwarf_Debug dbg, Dwarf_Line line, Dwarf_Addr pc) {
dwarf_linesrc(line, &linesrc, NULL);
dwarf_lineno(line, &lineno, NULL);
}
- printf("BackTrace %08" PRId64 " %s:%" DW_PR_DUu "\n", taosGetSelfPthreadId(), linesrc, lineno);
+ (void)printf("BackTrace %08" PRId64 " %s:%" DW_PR_DUu "\n", taosGetSelfPthreadId(), linesrc, lineno);
if (line) dwarf_dealloc(dbg, linesrc, DW_DLA_STRING);
}
void taosPrintBackTrace() {
@@ -266,7 +266,11 @@ void *taosMemoryMalloc(int64_t size) {
return (char *)tmp + sizeof(TdMemoryInfo);
#else
- return malloc(size);
+ void *p = malloc(size);
+ if (NULL == p) {
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
+ }
+ return p;
#endif
}
@@ -283,7 +287,11 @@ void *taosMemoryCalloc(int64_t num, int64_t size) {
return (char *)tmp + sizeof(TdMemoryInfo);
#else
- return calloc(num, size);
+ void *p = calloc(num, size);
+ if (NULL == p) {
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
+ }
+ return p;
#endif
}
@@ -309,7 +317,11 @@ void *taosMemoryRealloc(void *ptr, int64_t size) {
return (char *)tmp + sizeof(TdMemoryInfo);
#else
- return realloc(ptr, size);
+ void *p = realloc(ptr, size);
+ if (size > 0 && NULL == p) {
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
+ }
+ return p;
#endif
}
@@ -330,7 +342,12 @@ char *taosStrdup(const char *ptr) {
return (char *)tmp + sizeof(TdMemoryInfo);
#else
- return tstrdup(ptr);
+ char *p = tstrdup(ptr);
+ if (ptr != NULL && NULL == p) {
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
+ }
+ return p;
+
#endif
}
@@ -357,8 +374,7 @@ int64_t taosMemorySize(void *ptr) {
TdMemoryInfoPtr pTdMemoryInfo = (TdMemoryInfoPtr)((char *)ptr - sizeof(TdMemoryInfo));
ASSERT(pTdMemoryInfo->symbol == TD_MEMORY_SYMBOL);
if (pTdMemoryInfo->symbol != TD_MEMORY_SYMBOL) {
- +return NULL;
- +
+ return NULL;
}
return pTdMemoryInfo->memorySize;
@@ -378,7 +394,7 @@ void taosMemoryTrim(int32_t size) {
// do nothing
return;
#else
- malloc_trim(size);
+ (void)malloc_trim(size);
#endif
}
@@ -388,6 +404,13 @@ void *taosMemoryMallocAlign(uint32_t alignment, int64_t size) {
#else
#if defined(LINUX)
void *p = memalign(alignment, size);
+ if (NULL == p) {
+ if (ENOMEM == errno) {
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
+ } else {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ }
+ }
return p;
#else
return taosMemoryMalloc(size);
diff --git a/source/os/src/osRand.c b/source/os/src/osRand.c
index 0e58b7a8ec..da4e8dfb9d 100644
--- a/source/os/src/osRand.c
+++ b/source/os/src/osRand.c
@@ -69,7 +69,7 @@ uint32_t taosSafeRand(void) {
if (len < 0) {
seed = (int)taosGetTimestampSec();
}
- taosCloseFile(&pFile);
+ (void)taosCloseFile(&pFile);
}
return (uint32_t)seed;
diff --git a/source/os/src/osSleep.c b/source/os/src/osSleep.c
index f6cc7d608d..f72805b15d 100644
--- a/source/os/src/osSleep.c
+++ b/source/os/src/osSleep.c
@@ -26,7 +26,9 @@ void taosSsleep(int32_t s) {
#ifdef WINDOWS
Sleep(1000 * s);
#else
- sleep(s);
+ while (s > 0) {
+ s = sleep(s);
+ }
#endif
}
@@ -35,7 +37,7 @@ void taosMsleep(int32_t ms) {
#ifdef WINDOWS
Sleep(ms);
#else
- usleep(ms * 1000);
+ (void)usleep(ms * 1000);
#endif
}
@@ -51,6 +53,6 @@ void taosUsleep(int32_t us) {
WaitForSingleObject(timer, INFINITE);
CloseHandle(timer);
#else
- usleep(us);
+ (void)usleep(us);
#endif
}
diff --git a/source/os/src/osTime.c b/source/os/src/osTime.c
index 9cad1dd6ef..c650ac989d 100644
--- a/source/os/src/osTime.c
+++ b/source/os/src/osTime.c
@@ -345,6 +345,7 @@ char *taosStrpTime(const char *buf, const char *fmt, struct tm *tm) {
}
int32_t taosGetTimeOfDay(struct timeval *tv) {
+ int32_t code = 0;
#ifdef WINDOWS
LARGE_INTEGER t;
FILETIME f;
@@ -359,11 +360,18 @@ int32_t taosGetTimeOfDay(struct timeval *tv) {
tv->tv_usec = (t.QuadPart % 10000000) / 10;
return 0;
#else
- return gettimeofday(tv, NULL);
+ code = gettimeofday(tv, NULL);
+ return (-1 == code) ? (terrno = TAOS_SYSTEM_ERROR(errno)) : 0;
#endif
}
-time_t taosTime(time_t *t) { return time(t); }
+time_t taosTime(time_t *t) {
+ time_t r = time(t);
+ if (r == (time_t)-1) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ }
+ return r;
+}
/*
* mktime64 - Converts date to seconds.
@@ -458,7 +466,11 @@ time_t taosMktime(struct tm *timep) {
timep->tm_sec, tz);
#endif
#else
- return mktime(timep);
+ time_t r = mktime(timep);
+ if (r == (time_t)-1) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ }
+ return r;
#endif
}
@@ -470,7 +482,7 @@ struct tm *taosLocalTime(const time_t *timep, struct tm *result, char *buf) {
if (result == NULL) {
res = localtime(timep);
if (res == NULL && buf != NULL) {
- sprintf(buf, "NaN");
+ (void)sprintf(buf, "NaN");
}
return res;
}
@@ -528,7 +540,7 @@ struct tm *taosLocalTime(const time_t *timep, struct tm *result, char *buf) {
#else
res = localtime_r(timep, result);
if (res == NULL && buf != NULL) {
- sprintf(buf, "NaN");
+ (void)sprintf(buf, "NaN");
}
#endif
return result;
@@ -642,6 +654,7 @@ struct tm *taosLocalTimeNolock(struct tm *result, const time_t *timep, int dst)
int32_t taosGetTimestampSec() { return (int32_t)time(NULL); }
int32_t taosClockGetTime(int clock_id, struct timespec *pTS) {
+ int32_t code = 0;
#ifdef WINDOWS
LARGE_INTEGER t;
FILETIME f;
@@ -656,6 +669,7 @@ int32_t taosClockGetTime(int clock_id, struct timespec *pTS) {
pTS->tv_nsec = (t.QuadPart % 10000000) * 100;
return (0);
#else
- return clock_gettime(clock_id, pTS);
+ code = clock_gettime(clock_id, pTS);
+ return (-1 == code) ? (terrno = TAOS_SYSTEM_ERROR(errno)) : 0;
#endif
}
diff --git a/source/os/src/osTimer.c b/source/os/src/osTimer.c
index 36d364382a..6e5d9844a9 100644
--- a/source/os/src/osTimer.c
+++ b/source/os/src/osTimer.c
@@ -80,7 +80,7 @@ void taos_block_sigalrm(void) {
static void taosDeleteTimer(void *tharg) {
timer_t *pTimer = tharg;
- timer_delete(*pTimer);
+ (void)timer_delete(*pTimer);
}
static TdThread timerThread;
@@ -90,9 +90,9 @@ static volatile bool stopTimer = false;
static void *taosProcessAlarmSignal(void *tharg) {
// Block the signal
sigset_t sigset;
- sigemptyset(&sigset);
- sigaddset(&sigset, SIGALRM);
- sigprocmask(SIG_BLOCK, &sigset, NULL);
+ (void)sigemptyset(&sigset);
+ (void)sigaddset(&sigset, SIGALRM);
+ (void)sigprocmask(SIG_BLOCK, &sigset, NULL);
void (*callback)(int) = tharg;
struct sigevent sevent = {{0}};
@@ -110,7 +110,8 @@ static void *taosProcessAlarmSignal(void *tharg) {
sevent.sigev_signo = SIGALRM;
if (timer_create(CLOCK_REALTIME, &sevent, &timerId) == -1) {
- // printf("Failed to create timer");
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return NULL;
}
taosThreadCleanupPush(taosDeleteTimer, &timerId);
@@ -122,15 +123,17 @@ static void *taosProcessAlarmSignal(void *tharg) {
ts.it_interval.tv_sec = 0;
ts.it_interval.tv_nsec = 1000000 * MSECONDS_PER_TICK;
- if (timer_settime(timerId, 0, &ts, NULL)) {
- // printf("Failed to init timer");
+ if (-1 == timer_settime(timerId, 0, &ts, NULL)) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
break;
}
int signo;
+ int32_t code = 0;
while (!stopTimer) {
- if (sigwait(&sigset, &signo)) {
- // printf("Failed to wait signal: number %d", signo);
+ code = sigwait(&sigset, &signo);
+ if (code) {
+ terrno = TAOS_SYSTEM_ERROR(code);
continue;
}
/* //printf("Signal handling: number %d ......\n", signo); */
@@ -178,14 +181,12 @@ int taosInitTimer(void (*callback)(int), int ms) {
#else
stopTimer = false;
TdThreadAttr tattr;
- taosThreadAttrInit(&tattr);
+ (void)taosThreadAttrInit(&tattr);
int code = taosThreadCreate(&timerThread, &tattr, taosProcessAlarmSignal, callback);
- taosThreadAttrDestroy(&tattr);
+ (void)taosThreadAttrDestroy(&tattr);
if (code != 0) {
// printf("failed to create timer thread");
- return -1;
- } else {
- // printf("timer thread:0x%08" PRIx64 " is created", taosGetPthreadId(timerThread));
+ return TAOS_SYSTEM_ERROR(code);
}
return 0;
@@ -210,7 +211,7 @@ void taosUninitTimer() {
stopTimer = true;
// printf("join timer thread:0x%08" PRIx64, taosGetPthreadId(timerThread));
- taosThreadJoin(timerThread, NULL);
+ (void)taosThreadJoin(timerThread, NULL);
#endif
}
diff --git a/source/os/src/osTimezone.c b/source/os/src/osTimezone.c
index 72f7dda41c..8780fb2bc2 100644
--- a/source/os/src/osTimezone.c
+++ b/source/os/src/osTimezone.c
@@ -742,12 +742,20 @@ char *tz_win[554][2] = {{"Asia/Shanghai", "China Standard Time"},
static int isdst_now = 0;
-void taosSetSystemTimezone(const char *inTimezoneStr, char *outTimezoneStr, int8_t *outDaylight,
+int32_t taosSetSystemTimezone(const char *inTimezoneStr, char *outTimezoneStr, int8_t *outDaylight,
enum TdTimezone *tsTimezone) {
- if (inTimezoneStr == NULL || inTimezoneStr[0] == 0) return;
+ if (inTimezoneStr == NULL || inTimezoneStr[0] == 0) {
+ terrno = TSDB_CODE_INVALID_PARA;
+ return terrno;
+ }
+ int32_t code = TSDB_CODE_SUCCESS;
size_t len = strlen(inTimezoneStr);
- char *buf = taosMemoryCalloc(len + 1, 1);
+ if (len >= TD_TIMEZONE_LEN) {
+ terrno = TSDB_CODE_INVALID_PARA;
+ return terrno;
+ }
+ char buf[TD_TIMEZONE_LEN] = {0};
for (int32_t i = 0; i < len; i++) {
if (inTimezoneStr[i] == ' ' || inTimezoneStr[i] == '(') {
buf[i] = 0;
@@ -813,17 +821,22 @@ void taosSetSystemTimezone(const char *inTimezoneStr, char *outTimezoneStr, int8
*outDaylight = isdst_now;
#else
- setenv("TZ", buf, 1);
+ code = setenv("TZ", buf, 1);
+ if (-1 == code) {
+ terrno = TAOS_SYSTEM_ERROR(errno);
+ return terrno;
+ }
+
tzset();
int32_t tz = (int32_t)((-timezone * MILLISECOND_PER_SECOND) / MILLISECOND_PER_HOUR);
*tsTimezone = tz;
tz += isdst_now;
- sprintf(outTimezoneStr, "%s (%s, %s%02d00)", buf, tzname[isdst_now], tz >= 0 ? "+" : "-", abs(tz));
+ (void)sprintf(outTimezoneStr, "%s (%s, %s%02d00)", buf, tzname[isdst_now], tz >= 0 ? "+" : "-", abs(tz));
*outDaylight = isdst_now;
#endif
- taosMemoryFree(buf);
+ return code;
}
void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) {
@@ -914,7 +927,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) {
{
int n = readlink("/etc/localtime", buf, sizeof(buf)-1);
if (n < 0) {
- printf("read /etc/localtime error, reason:%s", strerror(errno));
+ (void)printf("read /etc/localtime error, reason:%s", strerror(errno));
if (taosCheckExistFile("/etc/timezone")) {
/*
@@ -924,7 +937,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) {
*/
time_t tx1 = taosGetTimestampSec();
struct tm tm1;
- taosLocalTime(&tx1, &tm1, NULL);
+ (void)taosLocalTime(&tx1, &tm1, NULL);
/* load time zone string from /etc/timezone */
// FILE *f = fopen("/etc/timezone", "r");
errno = 0;
@@ -933,12 +946,12 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) {
if (pFile != NULL) {
int len = taosReadFile(pFile, buf, 64);
if (len < 64 && taosGetErrorFile(pFile)) {
- taosCloseFile(&pFile);
- printf("read /etc/timezone error, reason:%s", strerror(errno));
+ (void)taosCloseFile(&pFile);
+ (void)printf("read /etc/timezone error, reason:%s", strerror(errno));
return;
}
- taosCloseFile(&pFile);
+ (void)taosCloseFile(&pFile);
buf[sizeof(buf) - 1] = 0;
char *lineEnd = strstr(buf, "\n");
@@ -948,7 +961,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) {
// for CentOS system, /etc/timezone does not exist. Ignore the TZ environment variables
if (strlen(buf) > 0) {
- setenv("TZ", buf, 1);
+ (void)setenv("TZ", buf, 1);
}
}
// get and set default timezone
@@ -970,10 +983,10 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) {
* Asia/Shanghai (CST, +0800)
* Europe/London (BST, +0100)
*/
- snprintf(outTimezoneStr, TD_TIMEZONE_LEN, "%s (%s, %s%02d00)", buf, tzname[daylight], tz >= 0 ? "+" : "-",
+ (void)snprintf(outTimezoneStr, TD_TIMEZONE_LEN, "%s (%s, %s%02d00)", buf, tzname[daylight], tz >= 0 ? "+" : "-",
abs(tz));
} else {
- printf("There is not /etc/timezone.\n");
+ (void)printf("There is not /etc/timezone.\n");
}
return;
}
@@ -981,7 +994,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) {
char *zi = strstr(buf, "zoneinfo");
if (!zi) {
- printf("parsing /etc/localtime failed");
+ (void)printf("parsing /etc/localtime failed");
return;
}
tz = zi + strlen("zoneinfo") + 1;
@@ -1000,7 +1013,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) {
// return;
// }
- setenv("TZ", tz, 1);
+ (void)setenv("TZ", tz, 1);
tzset();
}
@@ -1011,7 +1024,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) {
*/
time_t tx1 = taosGetTimestampSec();
struct tm tm1;
- taosLocalTime(&tx1, &tm1, NULL);
+ (void)taosLocalTime(&tx1, &tm1, NULL);
isdst_now = tm1.tm_isdst;
/*
@@ -1020,7 +1033,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) {
* Asia/Shanghai (CST, +0800)
* Europe/London (BST, +0100)
*/
- snprintf(outTimezoneStr, TD_TIMEZONE_LEN, "%s (%s, %+03ld00)", tz, tm1.tm_isdst ? tzname[daylight] : tzname[0],
+ (void)snprintf(outTimezoneStr, TD_TIMEZONE_LEN, "%s (%s, %+03ld00)", tz, tm1.tm_isdst ? tzname[daylight] : tzname[0],
-timezone / 3600);
#endif
}
diff --git a/source/util/src/tarray.c b/source/util/src/tarray.c
index ec5e41f256..75fe5d254d 100644
--- a/source/util/src/tarray.c
+++ b/source/util/src/tarray.c
@@ -18,9 +18,9 @@
#include "tcoding.h"
// todo refactor API
-#define BOUNDARY_SIZE 1024*1024*1024 // 1G
+#define BOUNDARY_SIZE 1024 * 1024 * 1024 // 1G
#define BOUNDARY_SMALL_FACTOR 1.2
-#define BOUNDARY_BIG_FACTOR 2
+#define BOUNDARY_BIG_FACTOR 2
SArray* taosArrayInit(size_t size, size_t elemSize) {
if (elemSize == 0) {
@@ -52,14 +52,12 @@ SArray* taosArrayInit(size_t size, size_t elemSize) {
SArray* taosArrayInit_s(size_t elemSize, size_t initialSize) {
SArray* pArray = taosMemoryMalloc(sizeof(SArray));
if (pArray == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
pArray->size = initialSize;
pArray->pData = taosMemoryCalloc(initialSize, elemSize);
if (pArray->pData == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
taosMemoryFree(pArray);
return NULL;
}
@@ -75,7 +73,7 @@ static int32_t taosArrayResize(SArray* pArray) {
void* tmp = taosMemoryRealloc(pArray->pData, size * pArray->elemSize);
if (tmp == NULL) { // reallocate failed, the original buffer remains
- return -1;
+ return terrno;
}
pArray->pData = tmp;
@@ -99,7 +97,7 @@ int32_t taosArrayEnsureCap(SArray* pArray, size_t newCap) {
pArray->pData = taosMemoryRealloc(pArray->pData, tsize * pArray->elemSize);
if (pArray->pData == NULL) {
- return -1;
+ return terrno;
}
pArray->capacity = tsize;
@@ -109,10 +107,13 @@ int32_t taosArrayEnsureCap(SArray* pArray, size_t newCap) {
void* taosArrayAddBatch(SArray* pArray, const void* pData, int32_t nEles) {
if (pData == NULL) {
+ terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
- if (taosArrayEnsureCap(pArray, pArray->size + nEles) != 0) {
+ int32_t code = taosArrayEnsureCap(pArray, pArray->size + nEles);
+ if (code) {
+ terrno = code;
return NULL;
}
@@ -171,7 +172,9 @@ void* taosArrayAddAll(SArray* pArray, const SArray* pInput) {
}
void* taosArrayReserve(SArray* pArray, int32_t num) {
- if (taosArrayEnsureCap(pArray, pArray->size + num) != 0) {
+ int32_t code = taosArrayEnsureCap(pArray, pArray->size + num);
+ if (code) {
+ terrno = code;
return NULL;
}
@@ -198,7 +201,7 @@ void* taosArrayGet(const SArray* pArray, size_t index) {
}
if (index >= pArray->size) {
- uError("index is out of range, current:%" PRIzu " max:%"PRIzu, index, pArray->size);
+ uError("index is out of range, current:%" PRIzu " max:%" PRIzu, index, pArray->size);
return NULL;
}
@@ -230,6 +233,7 @@ size_t taosArrayGetSize(const SArray* pArray) {
void* taosArrayInsert(SArray* pArray, size_t index, const void* pData) {
if (pArray == NULL || pData == NULL) {
+ terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
@@ -239,7 +243,6 @@ void* taosArrayInsert(SArray* pArray, size_t index, const void* pData) {
if (pArray->size >= pArray->capacity) {
int32_t ret = taosArrayResize(pArray);
-
if (ret < 0) {
return NULL;
}
@@ -316,8 +319,10 @@ SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize) {
}
SArray* pDst = taosArrayInit(size, elemSize);
- memcpy(pDst->pData, src, elemSize * size);
- pDst->size = size;
+ if (pDst) {
+ memcpy(pDst->pData, src, elemSize * size);
+ pDst->size = size;
+ }
return pDst;
}
@@ -333,18 +338,20 @@ SArray* taosArrayDup(const SArray* pSrc, __array_item_dup_fn_t fn) {
SArray* dst = taosArrayInit(pSrc->size, pSrc->elemSize);
- if (fn == NULL) {
- memcpy(dst->pData, pSrc->pData, pSrc->elemSize * pSrc->size);
- } else {
- ASSERT(pSrc->elemSize == sizeof(void*));
+ if (dst) {
+ if (fn == NULL) {
+ memcpy(dst->pData, pSrc->pData, pSrc->elemSize * pSrc->size);
+ } else {
+ ASSERT(pSrc->elemSize == sizeof(void*));
- for (int32_t i = 0; i < pSrc->size; ++i) {
- void* p = fn(taosArrayGetP(pSrc, i));
- memcpy(((char*)dst->pData) + i * dst->elemSize, &p, dst->elemSize);
+ for (int32_t i = 0; i < pSrc->size; ++i) {
+ void* p = fn(taosArrayGetP(pSrc, i));
+ memcpy(((char*)dst->pData) + i * dst->elemSize, &p, dst->elemSize);
+ }
}
- }
- dst->size = pSrc->size;
+ dst->size = pSrc->size;
+ }
return dst;
}
@@ -508,10 +515,21 @@ void* taosDecodeArray(const void* buf, SArray** pArray, FDecode decode, int32_t
int32_t sz;
buf = taosDecodeFixedI32(buf, &sz);
*pArray = taosArrayInit(sz, sizeof(void*));
+ if (*pArray == NULL) {
+ return NULL;
+ }
for (int32_t i = 0; i < sz; i++) {
void* data = taosMemoryCalloc(1, dataSz);
+ if (data == NULL) {
+ return NULL;
+ }
+
buf = decode(buf, data, sver);
- taosArrayPush(*pArray, &data);
+
+ if (taosArrayPush(*pArray, &data) == NULL) {
+ taosMemoryFree(data);
+ return NULL;
+ }
}
return (void*)buf;
}
diff --git a/source/util/src/tcache.c b/source/util/src/tcache.c
index 0a7842194e..c0ed0b98d0 100644
--- a/source/util/src/tcache.c
+++ b/source/util/src/tcache.c
@@ -230,6 +230,7 @@ static FORCE_INLINE void taosCacheReleaseNode(SCacheObj *pCacheObj, SCacheNode *
static FORCE_INLINE STrashElem *doRemoveElemInTrashcan(SCacheObj *pCacheObj, STrashElem *pElem) {
if (pElem->pData->signature != pElem->pData) {
uWarn("key:sig:0x%" PRIx64 " %p data has been released, ignore", (int64_t)pElem->pData->signature, pElem->pData);
+ terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
@@ -358,6 +359,7 @@ SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInMs, bool extendLi
SCacheObj *pCacheObj = (SCacheObj *)taosMemoryCalloc(1, sizeof(SCacheObj));
if (pCacheObj == NULL) {
uError("failed to allocate memory, reason:%s", strerror(errno));
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
@@ -393,6 +395,7 @@ SCacheObj *taosCacheInit(int32_t keyType, int64_t refreshTimeInMs, bool extendLi
void *taosCachePut(SCacheObj *pCacheObj, const void *key, size_t keyLen, const void *pData, size_t dataSize,
int32_t durationMS) {
if (pCacheObj == NULL || pCacheObj->pEntryList == NULL || pCacheObj->deleting == 1) {
+ terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
@@ -501,11 +504,15 @@ void *taosCacheAcquireByData(SCacheObj *pCacheObj, void *data) {
}
void *taosCacheTransferData(SCacheObj *pCacheObj, void **data) {
- if (pCacheObj == NULL || data == NULL || (*data) == NULL) return NULL;
+ if (pCacheObj == NULL || data == NULL || (*data) == NULL) {
+ terrno = TSDB_CODE_INVALID_PARA;
+ return NULL;
+ }
SCacheNode *ptNode = (SCacheNode *)((char *)(*data) - sizeof(SCacheNode));
if (ptNode->signature != ptNode) {
uError("cache:%s, key: %p the data from cache is invalid", pCacheObj->name, ptNode);
+ terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
@@ -702,8 +709,8 @@ SCacheNode *taosCreateCacheNode(const char *key, size_t keyLen, const char *pDat
SCacheNode *pNewNode = taosMemoryCalloc(1, sizeInBytes);
if (pNewNode == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
uError("failed to allocate memory, reason:%s", strerror(errno));
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c
index 3ab0f83238..268b0b8497 100644
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
@@ -136,8 +136,7 @@ static int32_t cfgCheckAndSetConf(SConfigItem *pItem, const char *conf) {
static int32_t cfgCheckAndSetDir(SConfigItem *pItem, const char *inputDir) {
char fullDir[PATH_MAX] = {0};
if (taosExpandDir(inputDir, fullDir, PATH_MAX) != 0) {
- terrno = TAOS_SYSTEM_ERROR(errno);
- uError("failed to expand dir:%s since %s", inputDir, terrstr());
+ uError("failed to expand dir:%s", inputDir);
return -1;
}
diff --git a/source/util/src/tdes.c b/source/util/src/tdes.c
index a4da08630e..2da8cd9b55 100644
--- a/source/util/src/tdes.c
+++ b/source/util/src/tdes.c
@@ -76,6 +76,12 @@ char* taosDesEncode(int64_t key, char* src, int32_t len) {
char* taosDesDecode(int64_t key, char* src, int32_t len) {
uint8_t* keyStr = (uint8_t*)(&key);
char* temp = taosMemoryCalloc(len + 8, 1);
+
+ if (!temp) {
+ terrno = TSDB_CODE_OUT_OF_MEMORY;
+ return NULL;
+ }
+
memcpy(temp, src, len);
len += 8;
diff --git a/source/util/src/tdigest.c b/source/util/src/tdigest.c
index b46a50b2dc..588c53537a 100644
--- a/source/util/src/tdigest.c
+++ b/source/util/src/tdigest.c
@@ -30,7 +30,7 @@
#include "tlog.h"
#define INTERPOLATE(x, x0, x1) (((x) - (x0)) / ((x1) - (x0)))
-//#define INTEGRATED_LOCATION(compression, q) ((compression) * (asin(2 * (q) - 1) + M_PI / 2) / M_PI)
+// #define INTEGRATED_LOCATION(compression, q) ((compression) * (asin(2 * (q) - 1) + M_PI / 2) / M_PI)
#define INTEGRATED_LOCATION(compression, q) ((compression) * (asin(2 * (double)(q)-1) / M_PI + (double)1 / 2))
#define FLOAT_EQ(f1, f2) (fabs((f1) - (f2)) <= FLT_EPSILON)
@@ -99,16 +99,19 @@ static void mergeCentroid(SMergeArgs *args, SCentroid *merge) {
}
}
-void tdigestCompress(TDigest *t) {
+int32_t tdigestCompress(TDigest *t) {
SCentroid *unmerged_centroids;
int64_t unmerged_weight = 0;
int32_t num_unmerged = t->num_buffered_pts;
int32_t i, j;
SMergeArgs args;
- if (t->num_buffered_pts <= 0) return;
+ if (t->num_buffered_pts <= 0) return 0;
unmerged_centroids = (SCentroid *)taosMemoryMalloc(sizeof(SCentroid) * t->num_buffered_pts);
+ if (unmerged_centroids == NULL) {
+ return terrno;
+ }
for (i = 0; i < num_unmerged; i++) {
SPt *p = t->buffered_pts + i;
SCentroid *c = &unmerged_centroids[i];
@@ -122,6 +125,10 @@ void tdigestCompress(TDigest *t) {
taosSort(unmerged_centroids, num_unmerged, sizeof(SCentroid), cmpCentroid);
memset(&args, 0, sizeof(SMergeArgs));
args.centroids = (SCentroid *)taosMemoryMalloc((size_t)(sizeof(SCentroid) * t->size));
+ if (args.centroids == NULL) {
+ taosMemoryFree((void *)unmerged_centroids);
+ return terrno;
+ }
memset(args.centroids, 0, (size_t)(sizeof(SCentroid) * t->size));
args.t = t;
@@ -167,10 +174,11 @@ void tdigestCompress(TDigest *t) {
memcpy(t->centroids, args.centroids, sizeof(SCentroid) * t->num_centroids);
taosMemoryFree((void *)args.centroids);
+ return 0;
}
-void tdigestAdd(TDigest *t, double x, int64_t w) {
- if (w == 0) return;
+int32_t tdigestAdd(TDigest *t, double x, int64_t w) {
+ if (w == 0) return 0;
int32_t i = t->num_buffered_pts;
if (i > 0 && t->buffered_pts[i - 1].value == x) {
@@ -181,7 +189,10 @@ void tdigestAdd(TDigest *t, double x, int64_t w) {
t->num_buffered_pts++;
}
- if (t->num_buffered_pts >= t->threshold) tdigestCompress(t);
+ if (t->num_buffered_pts >= t->threshold) {
+ return tdigestCompress(t);
+ }
+ return 0;
}
#if 0
@@ -284,16 +295,21 @@ double tdigestQuantile(TDigest *t, double q) {
return t->max;
}
-void tdigestMerge(TDigest *t1, TDigest *t2) {
+int32_t tdigestMerge(TDigest *t1, TDigest *t2) {
+ int32_t code = 0;
// SPoints
int32_t num_pts = t2->num_buffered_pts;
for (int32_t i = num_pts - 1; i >= 0; i--) {
SPt *p = t2->buffered_pts + i;
- tdigestAdd(t1, p->value, p->weight);
+ code = tdigestAdd(t1, p->value, p->weight);
+ if (code) return code;
t2->num_buffered_pts--;
}
// centroids
for (int32_t i = 0; i < t2->num_centroids; i++) {
- tdigestAdd(t1, t2->centroids[i].mean, t2->centroids[i].weight);
+ code = tdigestAdd(t1, t2->centroids[i].mean, t2->centroids[i].weight);
+ if (code) return code;
}
+
+ return 0;
}
diff --git a/source/util/src/tenv.c b/source/util/src/tenv.c
index 7fe079ada4..539687878b 100644
--- a/source/util/src/tenv.c
+++ b/source/util/src/tenv.c
@@ -28,7 +28,7 @@ int32_t taosEnvNameToCfgName(const char *envNameStr, char *cfgNameStr, int32_t c
// p[cfgNameMaxLen - 1] = '\0';
// return strlen(cfgNameStr);
cfgNameStr[0] = '\0';
- return -1;
+ return TSDB_CODE_INVALID_PARA;
}
envNameStr += 5;
if (*envNameStr != '\0') {
@@ -55,7 +55,7 @@ int32_t taosEnvNameToCfgName(const char *envNameStr, char *cfgNameStr, int32_t c
int32_t taosEnvToCfg(const char *envStr, char *cfgStr) {
if (envStr == NULL || cfgStr == NULL) {
- return -1;
+ return TSDB_CODE_INVALID_PARA;
}
if (cfgStr != envStr) strcpy(cfgStr, envStr);
char *p = strchr(cfgStr, '=');
@@ -74,7 +74,7 @@ int32_t taosEnvToCfg(const char *envStr, char *cfgStr) {
memset(&cfgStr[cfgNameLen], ' ', p - cfgStr - cfgNameLen + 1);
} else {
*cfgStr = '\0';
- return -1;
+ return TSDB_CODE_INVALID_PARA;
}
}
return strlen(cfgStr);
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index 4db1475fa9..09c7224c1e 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -707,6 +707,10 @@ TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_TO_TIMESTAMP_FAILED_FORMAT_ERR, "Func to_timest
TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_TO_TIMESTAMP_FAILED_TS_ERR, "Func to_timestamp failed for wrong timestamp")
TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_TO_TIMESTAMP_FAILED_NOT_SUPPORTED, "Func to_timestamp failed for unsupported timestamp format")
TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_TO_CHAR_NOT_SUPPORTED, "Func to_char failed for unsupported format")
+TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_TIME_UNIT_INVALID, "Invalid function time unit")
+TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_TIME_UNIT_TOO_SMALL, "Function time unit cannot be smaller than db precision")
+TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_INVALID_VALUE_RANGE, "Function got invalid value range")
+TAOS_DEFINE_ERROR(TSDB_CODE_FUNC_SETUP_ERROR, "Function set up failed")
//udf
TAOS_DEFINE_ERROR(TSDB_CODE_UDF_STOPPING, "udf is stopping")
diff --git a/source/util/src/tgeosctx.c b/source/util/src/tgeosctx.c
index b60e9ee8ac..a05734c911 100644
--- a/source/util/src/tgeosctx.c
+++ b/source/util/src/tgeosctx.c
@@ -13,14 +13,12 @@
* along with this program. If not, see .
*/
-#include "tdef.h"
#include "tgeosctx.h"
+#include "tdef.h"
static threadlocal SGeosContext tlGeosCtx = {0};
-SGeosContext* getThreadLocalGeosCtx() {
- return &tlGeosCtx;
-}
+SGeosContext* getThreadLocalGeosCtx() { return &tlGeosCtx; }
void destroyThreadLocalGeosCtx() {
if (tlGeosCtx.WKTReader) {
@@ -47,7 +45,7 @@ void destroyThreadLocalGeosCtx() {
destroyRegexes(tlGeosCtx.WKTRegex, tlGeosCtx.WKTMatchData);
}
- if(tlGeosCtx.handle) {
+ if (tlGeosCtx.handle) {
GEOS_finish_r(tlGeosCtx.handle);
tlGeosCtx.handle = NULL;
}
diff --git a/source/util/src/thash.c b/source/util/src/thash.c
index b509aaebc3..62a73cb38c 100644
--- a/source/util/src/thash.c
+++ b/source/util/src/thash.c
@@ -67,7 +67,7 @@ struct SHashObj {
bool enableUpdate; // enable update
SArray *pMemBlock; // memory block allocated for SHashEntry
_hash_before_fn_t callbackFp; // function invoked before return the value to caller
-// int64_t compTimes;
+ // int64_t compTimes;
};
/*
@@ -147,7 +147,7 @@ static FORCE_INLINE SHashNode *doSearchInEntryList(SHashObj *pHashObj, SHashEntr
uint32_t hashVal) {
SHashNode *pNode = pe->next;
while (pNode) {
- //atomic_add_fetch_64(&pHashObj->compTimes, 1);
+ // atomic_add_fetch_64(&pHashObj->compTimes, 1);
if ((pNode->keyLen == keyLen) && ((*(pHashObj->equalFp))(GET_HASH_NODE_KEY(pNode), key, keyLen) == 0) &&
pNode->removed == 0) {
break;
@@ -243,7 +243,6 @@ SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool update, SHashLockTyp
SHashObj *pHashObj = (SHashObj *)taosMemoryMalloc(sizeof(SHashObj));
if (pHashObj == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
@@ -262,7 +261,6 @@ SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool update, SHashLockTyp
pHashObj->hashList = (SHashEntry **)taosMemoryMalloc(pHashObj->capacity * sizeof(void *));
if (pHashObj->hashList == NULL) {
taosMemoryFree(pHashObj);
- terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
@@ -270,7 +268,6 @@ SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool update, SHashLockTyp
if (pHashObj->pMemBlock == NULL) {
taosMemoryFree(pHashObj->hashList);
taosMemoryFree(pHashObj);
- terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
@@ -279,7 +276,6 @@ SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool update, SHashLockTyp
taosArrayDestroy(pHashObj->pMemBlock);
taosMemoryFree(pHashObj->hashList);
taosMemoryFree(pHashObj);
- terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
@@ -290,7 +286,12 @@ SHashObj *taosHashInit(size_t capacity, _hash_fn_t fn, bool update, SHashLockTyp
pHashObj->hashList[i]->next = NULL;
}
- taosArrayPush(pHashObj->pMemBlock, &p);
+ if (taosArrayPush(pHashObj->pMemBlock, &p) == NULL) {
+ taosArrayDestroy(pHashObj->pMemBlock);
+ taosMemoryFree(pHashObj->hashList);
+ taosMemoryFree(pHashObj);
+ return NULL;
+ }
return pHashObj;
}
@@ -315,8 +316,7 @@ int32_t taosHashGetSize(const SHashObj *pHashObj) {
int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, const void *data, size_t size) {
if (pHashObj == NULL || key == NULL || keyLen == 0) {
- terrno = TSDB_CODE_INVALID_PTR;
- return TSDB_CODE_INVALID_PTR;
+ return terrno = TSDB_CODE_INVALID_PTR;
}
uint32_t hashVal = (*pHashObj->hashFp)(key, (uint32_t)keyLen);
@@ -331,7 +331,7 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, const vo
// disable resize
taosHashRLock(pHashObj);
- int32_t code = TSDB_CODE_SUCCESS;
+ int32_t code = TSDB_CODE_SUCCESS;
uint32_t slot = HASH_INDEX(hashVal, pHashObj->capacity);
SHashEntry *pe = pHashObj->hashList[slot];
@@ -440,14 +440,12 @@ void *taosHashGetImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void *
*size = pNode->dataLen;
*d = taosMemoryCalloc(1, *size);
if (*d == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
} else if (*size < pNode->dataLen) {
*size = pNode->dataLen;
char *tmp = taosMemoryRealloc(*d, *size);
if (tmp == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
@@ -474,7 +472,7 @@ void *taosHashGetImpl(SHashObj *pHashObj, const void *key, size_t keyLen, void *
int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen) {
if (pHashObj == NULL || taosHashTableEmpty(pHashObj) || key == NULL || keyLen == 0) {
- return -1;
+ return TSDB_CODE_INVALID_PARA;
}
uint32_t hashVal = (*pHashObj->hashFp)(key, (uint32_t)keyLen);
@@ -615,7 +613,7 @@ void taosHashTableResize(SHashObj *pHashObj) {
return;
}
- int64_t st = taosGetTimestampUs();
+ int64_t st = taosGetTimestampUs();
SHashEntry **pNewEntryList = taosMemoryRealloc(pHashObj->hashList, sizeof(SHashEntry *) * newCapacity);
if (pNewEntryList == NULL) {
// uDebug("cache resize failed due to out of memory, capacity remain:%zu", pHashObj->capacity);
@@ -631,7 +629,10 @@ void taosHashTableResize(SHashObj *pHashObj) {
pHashObj->hashList[i + pHashObj->capacity] = (void *)((char *)p + i * sizeof(SHashEntry));
}
- taosArrayPush(pHashObj->pMemBlock, &p);
+ if (taosArrayPush(pHashObj->pMemBlock, &p) == NULL) {
+ taosMemoryFree(p);
+ return;
+ }
pHashObj->capacity = newCapacity;
for (int32_t idx = 0; idx < pHashObj->capacity; ++idx) {
@@ -681,7 +682,6 @@ SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *pData, s
#endif
if (pNewNode == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
diff --git a/source/util/src/theap.c b/source/util/src/theap.c
index 315ddf9367..40fe63b004 100644
--- a/source/util/src/theap.c
+++ b/source/util/src/theap.c
@@ -188,7 +188,6 @@ void heapRemove(Heap* heap, HeapNode* node) {
void heapDequeue(Heap* heap) { heapRemove(heap, heap->min); }
-
struct PriorityQueue {
SArray* container;
pq_comp_fn fn;
@@ -197,16 +196,23 @@ struct PriorityQueue {
};
PriorityQueue* createPriorityQueue(pq_comp_fn fn, FDelete deleteFn, void* param) {
PriorityQueue* pq = (PriorityQueue*)taosMemoryCalloc(1, sizeof(PriorityQueue));
+ if (pq == NULL) {
+ return NULL;
+ }
+
pq->container = taosArrayInit(1, sizeof(PriorityQueueNode));
+ if (pq->container == NULL) {
+ taosMemoryFree(pq);
+ return NULL;
+ }
+
pq->fn = fn;
pq->deleteFn = deleteFn;
pq->param = param;
return pq;
}
-void taosPQSetFn(PriorityQueue* pq, pq_comp_fn fn) {
- pq->fn = fn;
-}
+void taosPQSetFn(PriorityQueue* pq, pq_comp_fn fn) { pq->fn = fn; }
void destroyPriorityQueue(PriorityQueue* pq) {
if (pq->deleteFn)
@@ -218,15 +224,15 @@ void destroyPriorityQueue(PriorityQueue* pq) {
static size_t pqParent(size_t i) { return (--i) >> 1; /* (i - 1) / 2 */ }
static size_t pqLeft(size_t i) { return (i << 1) | 1; /* i * 2 + 1 */ }
-static size_t pqRight(size_t i) { return (++i) << 1; /* (i + 1) * 2 */}
-static void pqSwapPQNode(PriorityQueueNode* a, PriorityQueueNode* b) {
- void * tmp = a->data;
+static size_t pqRight(size_t i) { return (++i) << 1; /* (i + 1) * 2 */ }
+static void pqSwapPQNode(PriorityQueueNode* a, PriorityQueueNode* b) {
+ void* tmp = a->data;
a->data = b->data;
b->data = tmp;
}
#define pqContainerGetEle(pq, i) ((PriorityQueueNode*)taosArrayGet((pq)->container, (i)))
-#define pqContainerSize(pq) (taosArrayGetSize((pq)->container))
+#define pqContainerSize(pq) (taosArrayGetSize((pq)->container))
size_t taosPQSize(PriorityQueue* pq) { return pqContainerSize(pq); }
@@ -288,12 +294,12 @@ static void pqRemove(PriorityQueue* pq, size_t i) {
pqUpdate(pq, i);
}
-PriorityQueueNode* taosPQTop(PriorityQueue* pq) {
- return pqContainerGetEle(pq, 0);
-}
+PriorityQueueNode* taosPQTop(PriorityQueue* pq) { return pqContainerGetEle(pq, 0); }
PriorityQueueNode* taosPQPush(PriorityQueue* pq, const PriorityQueueNode* node) {
- taosArrayPush(pq->container, node);
+ if (taosArrayPush(pq->container, node) == NULL) {
+ return NULL;
+ }
return pqReverseHeapify(pq, pqContainerSize(pq) - 1);
}
@@ -310,15 +316,28 @@ struct BoundedQueue {
BoundedQueue* createBoundedQueue(uint32_t maxSize, pq_comp_fn fn, FDelete deleteFn, void* param) {
BoundedQueue* q = (BoundedQueue*)taosMemoryCalloc(1, sizeof(BoundedQueue));
+ if (q == NULL) {
+ return NULL;
+ }
+
q->queue = createPriorityQueue(fn, deleteFn, param);
- taosArrayEnsureCap(q->queue->container, maxSize + 1);
+ if (q->queue == NULL) {
+ taosMemoryFree(q);
+ return NULL;
+ }
+
+ int32_t code = taosArrayEnsureCap(q->queue->container, maxSize + 1);
+ if (code) {
+ destroyPriorityQueue(q->queue);
+ taosMemoryFree(q);
+ terrno = code;
+ return NULL;
+ }
q->maxSize = maxSize;
return q;
}
-void taosBQSetFn(BoundedQueue* q, pq_comp_fn fn) {
- taosPQSetFn(q->queue, fn);
-}
+void taosBQSetFn(BoundedQueue* q, pq_comp_fn fn) { taosPQSetFn(q->queue, fn); }
void destroyBoundedQueue(BoundedQueue* q) {
if (!q) return;
@@ -343,22 +362,12 @@ PriorityQueueNode* taosBQPush(BoundedQueue* q, PriorityQueueNode* n) {
}
}
-PriorityQueueNode* taosBQTop(BoundedQueue* q) {
- return taosPQTop(q->queue);
-}
+PriorityQueueNode* taosBQTop(BoundedQueue* q) { return taosPQTop(q->queue); }
-void taosBQBuildHeap(BoundedQueue *q) {
- pqBuildHeap(q->queue);
-}
+void taosBQBuildHeap(BoundedQueue* q) { pqBuildHeap(q->queue); }
-size_t taosBQMaxSize(BoundedQueue* q) {
- return q->maxSize;
-}
+size_t taosBQMaxSize(BoundedQueue* q) { return q->maxSize; }
-size_t taosBQSize(BoundedQueue* q) {
- return taosPQSize(q->queue);
-}
+size_t taosBQSize(BoundedQueue* q) { return taosPQSize(q->queue); }
-void taosBQPop(BoundedQueue* q) {
- taosPQPop(q->queue);
-}
+void taosBQPop(BoundedQueue* q) { taosPQPop(q->queue); }
diff --git a/source/util/src/tidpool.c b/source/util/src/tidpool.c
index b45113942c..cfb2be5f02 100644
--- a/source/util/src/tidpool.c
+++ b/source/util/src/tidpool.c
@@ -19,7 +19,9 @@
void *taosInitIdPool(int32_t maxId) {
id_pool_t *pIdPool = taosMemoryCalloc(1, sizeof(id_pool_t));
- if (pIdPool == NULL) return NULL;
+ if (pIdPool == NULL) {
+ return NULL;
+ }
pIdPool->freeList = taosMemoryCalloc(maxId, sizeof(bool));
if (pIdPool->freeList == NULL) {
@@ -120,7 +122,7 @@ int32_t taosUpdateIdPool(id_pool_t *pIdPool, int32_t maxId) {
bool *idList = taosMemoryCalloc(maxId, sizeof(bool));
if (idList == NULL) {
- return -1;
+ return terrno;
}
taosThreadMutexLock(&pIdPool->mutex);
diff --git a/source/util/src/tref.c b/source/util/src/tref.c
index 1bd3099b2d..5583286280 100644
--- a/source/util/src/tref.c
+++ b/source/util/src/tref.c
@@ -67,15 +67,13 @@ int32_t taosOpenRef(int32_t max, RefFp fp) {
nodeList = taosMemoryCalloc(sizeof(SRefNode *), (size_t)max);
if (nodeList == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return -1;
+ return terrno = TSDB_CODE_OUT_OF_MEMORY;
}
lockedBy = taosMemoryCalloc(sizeof(int64_t), (size_t)max);
if (lockedBy == NULL) {
taosMemoryFree(nodeList);
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return -1;
+ return terrno = TSDB_CODE_OUT_OF_MEMORY;
}
taosThreadMutexLock(&tsRefMutex);
@@ -118,8 +116,7 @@ int32_t taosCloseRef(int32_t rsetId) {
if (rsetId < 0 || rsetId >= TSDB_REF_OBJECTS) {
uTrace("rsetId:%d is invalid, out of range", rsetId);
- terrno = TSDB_CODE_REF_INVALID_ID;
- return -1;
+ return terrno = TSDB_CODE_REF_INVALID_ID;
}
pSet = tsRefSetList + rsetId;
@@ -149,8 +146,7 @@ int64_t taosAddRef(int32_t rsetId, void *p) {
if (rsetId < 0 || rsetId >= TSDB_REF_OBJECTS) {
uTrace("rsetId:%d p:%p failed to add, rsetId not valid", rsetId, p);
- terrno = TSDB_CODE_REF_INVALID_ID;
- return -1;
+ return terrno = TSDB_CODE_REF_INVALID_ID;
}
pSet = tsRefSetList + rsetId;
@@ -158,14 +154,12 @@ int64_t taosAddRef(int32_t rsetId, void *p) {
if (pSet->state != TSDB_REF_STATE_ACTIVE) {
taosDecRsetCount(pSet);
uTrace("rsetId:%d p:%p failed to add, not active", rsetId, p);
- terrno = TSDB_CODE_REF_ID_REMOVED;
- return -1;
+ return terrno = TSDB_CODE_REF_ID_REMOVED;
}
pNode = taosMemoryCalloc(sizeof(SRefNode), 1);
if (pNode == NULL) {
- terrno = TSDB_CODE_OUT_OF_MEMORY;
- return -1;
+ return terrno = TSDB_CODE_OUT_OF_MEMORY;
}
rid = atomic_add_fetch_64(&pSet->rid, 1);
@@ -389,21 +383,18 @@ static int32_t taosDecRefCount(int32_t rsetId, int64_t rid, int32_t remove) {
if (rsetId < 0 || rsetId >= TSDB_REF_OBJECTS) {
uTrace("rsetId:%d rid:%" PRId64 " failed to remove, rsetId not valid", rsetId, rid);
- terrno = TSDB_CODE_REF_INVALID_ID;
- return -1;
+ return terrno = TSDB_CODE_REF_INVALID_ID;
}
if (rid <= 0) {
uTrace("rsetId:%d rid:%" PRId64 " failed to remove, rid not valid", rsetId, rid);
- terrno = TSDB_CODE_REF_NOT_EXIST;
- return -1;
+ return terrno = TSDB_CODE_REF_NOT_EXIST;
}
pSet = tsRefSetList + rsetId;
if (pSet->state == TSDB_REF_STATE_EMPTY) {
uTrace("rsetId:%d rid:%" PRId64 " failed to remove, cleaned", rsetId, rid);
- terrno = TSDB_CODE_REF_ID_REMOVED;
- return -1;
+ return terrno = TSDB_CODE_REF_ID_REMOVED;
}
hash = rid % pSet->max;
diff --git a/tests/ci/ci_deploy_dependency_file_list.txt b/tests/ci/ci_deploy_dependency_file_list.txt
new file mode 100644
index 0000000000..1e7afdd7db
--- /dev/null
+++ b/tests/ci/ci_deploy_dependency_file_list.txt
@@ -0,0 +1,8 @@
+/home/m.json
+/home/log_server.json
+/var/lib/jenkins/workspace/restore.sh
+/var/lib/jenkins/workspace/start_http.sh
+/var/lib/jenkins/workspace/TDinternal
+/var/lib/jenkins/workspace/remove_corefile.sh
+/var/lib/jenkins/workspace/CI_disk_Monitor.py
+/var/lib/jenkins/workspace/start_CI_Monitor.sh
diff --git a/tests/ci/container_build_newmachine.sh b/tests/ci/container_build_newmachine.sh
new file mode 100755
index 0000000000..3c87cf156f
--- /dev/null
+++ b/tests/ci/container_build_newmachine.sh
@@ -0,0 +1,88 @@
+#!/bin/bash
+set -e
+
+function usage() {
+ echo "$0"
+ echo -e "\t -w work dir"
+ echo -e "\t -e enterprise edition"
+ echo -e "\t -t make thread count"
+ echo -e "\t -h help"
+}
+
+ent=0
+while getopts "w:t:eh" opt; do
+ case $opt in
+ w)
+ WORKDIR=$OPTARG
+ ;;
+ e)
+ ent=1
+ ;;
+ t)
+ THREAD_COUNT=$OPTARG
+ ;;
+ h)
+ usage
+ exit 0
+ ;;
+ \?)
+ echo "Invalid option: -$OPTARG"
+ usage
+ exit 0
+ ;;
+ esac
+done
+
+if [ -z "$WORKDIR" ]; then
+ usage
+ exit 1
+fi
+# if [ -z "$THREAD_COUNT" ]; then
+# THREAD_COUNT=1
+# fi
+
+ulimit -c unlimited
+
+if [ $ent -eq 0 ]; then
+ REP_DIR=/home/TDengine
+ REP_REAL_PATH=$WORKDIR/TDengine
+ REP_MOUNT_PARAM=$REP_REAL_PATH:/home/TDengine
+else
+ REP_DIR=/home/TDinternal
+ REP_REAL_PATH=$WORKDIR/TDinternal
+ REP_MOUNT_PARAM=$REP_REAL_PATH:/home/TDinternal
+
+fi
+date
+docker run \
+ -v $REP_MOUNT_PARAM \
+ -v /root/.cargo/registry:/root/.cargo/registry \
+ -v /root/.cargo/git:/root/.cargo/git \
+ -v /root/go/pkg/mod:/root/go/pkg/mod \
+ -v /root/.cache/go-build:/root/.cache/go-build \
+ -v /root/.cos-local.1:/root/.cos-local.2 \
+ --rm --ulimit core=-1 taos_test:v1.0 sh -c "pip uninstall taospy -y;pip3 install taospy==2.7.2;cd $REP_DIR;rm -rf debug;mkdir -p debug;cd debug;cmake .. -DBUILD_HTTP=false -DBUILD_TOOLS=true -DBUILD_TEST=true -DWEBSOCKET=true -DBUILD_SANITIZER=1 -DTOOLS_SANITIZE=true $CMAKE_BUILD_TYPE -DTOOLS_BUILD_TYPE=Debug -DBUILD_TAOSX=false -DJEMALLOC_ENABLED=0;make -j 10|| exit 1 "
+ # -v ${REP_REAL_PATH}/community/contrib/jemalloc/:${REP_DIR}/community/contrib/jemalloc \
+
+if [[ -d ${WORKDIR}/debugNoSan ]] ;then
+ echo "delete ${WORKDIR}/debugNoSan"
+ rm -rf ${WORKDIR}/debugNoSan
+fi
+if [[ -d ${WORKDIR}/debugSan ]] ;then
+ echo "delete ${WORKDIR}/debugSan"
+ rm -rf ${WORKDIR}/debugSan
+fi
+
+if [ "$(uname -m)" = "aarch64" ] ;then
+ CMAKE_BUILD_TYPE="-DCMAKE_BUILD_TYPE=Debug"
+else
+ CMAKE_BUILD_TYPE="-DCMAKE_BUILD_TYPE=Release"
+fi
+
+
+mv ${REP_REAL_PATH}/debug ${WORKDIR}/debugSan
+date
+
+ret=$?
+exit $ret
+
diff --git a/tests/ci/deploy_ci_machines.sh b/tests/ci/deploy_ci_machines.sh
new file mode 100644
index 0000000000..e34ec1d6e5
--- /dev/null
+++ b/tests/ci/deploy_ci_machines.sh
@@ -0,0 +1,69 @@
+#!/bin/bash
+
+function scp_file_from_host {
+ # check at least three parameters
+ if [ "$#" -lt 3 ]; then
+ echo "Usage: $0 host passwd source_filename [dest_filename]"
+ exit 1
+ fi
+
+ host=$1
+ passwd=$2
+ source_filename=$3
+ # If the fourth parameter is not provided, use the third parameter as the default value
+ dest_filename=${4:-$3}
+
+ # use sshpass and scp for secure file transfer
+ sshpass -p "$passwd" scp -o StrictHostKeyChecking=no -r "$host":"$source_filename" "$dest_filename"
+}
+
+
+# install docker and sshpass
+curl -fsSL https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
+sudo add-apt-repository "deb [arch=amd64] https://mirrors.ustc.edu.cn/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
+sudo apt-get update
+sudo apt-get install -y docker-ce sshpass jq
+sudo systemctl enable docker
+sudo systemctl start docker
+
+# create a log directory
+mkdir -p /var/lib/jenkins/workspace/log
+
+# Assuming you have a file called 'file_list.txt' with one filename per line
+file_list="ci_deploy_dependency_file_list.txt"
+monitorip="192.168.1.59"
+passwd_all="abcdefg"
+
+# Read the file list and call scp_file_from_host for each file
+while IFS= read -r source_filename; do
+ scp_file_from_host "$monitorip" "$passwd_all" "$source_filename"
+done < "$file_list"
+
+# modify the configuration file
+ip=$(ifconfig |grep inet|grep 192 |awk '{print $2}')
+sed -i "s/${monitorip}/$ip/" /home/log_server.json
+sed -i "s/${monitorip}/$ip/" /home/m.json
+
+#mkdir corefile dir and configure the system to automatically set corefile dir at startup
+mkdir -p /home/coredump/ && echo "echo '/home/coredump/core_%e-%p' | sudo tee /proc/sys/kernel/core_pattern " >> /root/.bashrc
+
+
+# get image from 0.212
+image_ip="192.168.0.212"
+scp_file_from_host $image_ip $passwd_all "/home/tang/work/image/taos_image.tar " "/home/taos_image.tar"
+docker load -i /home/taos_image.tar
+
+#start http server
+nohup /var/lib/jenkins/workspace/log/start_http.sh &
+
+# start CI monitor and remove corefile in crontable
+(crontab -l;echo "0 1 * * * /usr/bin/bash /var/lib/jenkins/workspace/remove_corefile.sh") | crontab
+(crontab -l;echo "@reboot /usr/bin/bash /var/lib/jenkins/workspace/start_CI_Monitor.sh") | crontab
+
+
+# generate cache dir
+cd /var/lib/jenkins/workspace/TDinternal/community/tests/parallel_test || exit
+time ./container_build_newmachine.sh -w /var/lib/jenkins/workspace -e
+
+# test if the CI machine compilation is successful
+time ./container_build.sh -w /var/lib/jenkins/workspace -e
\ No newline at end of file
diff --git a/tests/ci/remove_corefile.sh b/tests/ci/remove_corefile.sh
new file mode 100644
index 0000000000..7374101547
--- /dev/null
+++ b/tests/ci/remove_corefile.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+date_str=$(date -d "4 day ago" +%Y%m%d)
+if [ ! -z "$1" ]; then
+ date_str="$1"
+fi
+script_dir=$(dirname $0)
+cd "${script_dir}"/log || exit
+# date >>core.list
+# find . -name "core.*" | grep "$date_str" >>core.list
+# find . -name "core.*" | grep "$date_str" | xargs rm -rf
+# find . -name "build_*" | grep "$date_str" | xargs rm -rf
+for file in *; do
+ if [[ $file == *"$date_str"* ]]; then
+ rm -rf "$file"
+ fi
+done
diff --git a/tests/ci/restore.sh b/tests/ci/restore.sh
new file mode 100644
index 0000000000..4c9daf73fe
--- /dev/null
+++ b/tests/ci/restore.sh
@@ -0,0 +1,159 @@
+#!/bin/bash
+ set -x
+JENKINS_LOG=jenkins.log
+# pr_num=14228
+# n=1
+function usage() {
+ echo "$0"
+ echo -e "\t -p PR number"
+ echo -e "\t -n build number"
+ echo -e "\t -c container name"
+ echo -e "\t -h help"
+}
+while getopts "p:n:c:h" opt; do
+ case $opt in
+ p)
+ pr_num=$OPTARG
+ ;;
+ n)
+ n=$OPTARG
+ ;;
+ c)
+ container_name=$OPTARG
+ ;;
+ h)
+ usage
+ exit 0
+ ;;
+ \?)
+ echo "Invalid option: -$OPTARG"
+ usage
+ exit 1
+ ;;
+ esac
+done
+if [ -z "$container_name" ]; then
+ echo "container name not specified"
+ usage
+ exit 1
+fi
+if [ -z "$pr_num" ]; then
+ echo "PR number not specified"
+ usage
+ exit 1
+fi
+if [ -z "$n" ]; then
+ echo "build number not specified"
+ usage
+ exit 1
+fi
+pr_num=`echo "$pr_num"|sed "s/PR-//"`
+container_count=`docker ps -a -f name=$container_name|wc -l`
+if [ $container_count -gt 1 ]; then
+ docker ps -a -f name=$container_name
+ echo "container $container_name exists"
+ exit 1
+fi
+cd $(dirname $0)
+info=`grep -n "^[0-9]\{8\}-[0-9]\{6\}" jenkins.log | grep -A 1 "PR-${pr_num}:${n}:"`
+# 22131:20220625-113105 NewTest/PR-14228:PR-14228:1:3.0
+# 22270:20220625-121154 NewTest/PR-14221:PR-14221:2:3.0
+ci_hosts="\
+192.168.0.212 \
+192.168.0.215 \
+192.168.0.217 \
+192.168.0.219 \
+"
+if [ -z "$info" ]; then
+ echo "PR-${pr_num}:${n} not found"
+ for host in $ci_hosts; do
+ ssh root@$host "sh -c \"grep -n \\\"^[0-9]\\\\\{8\\\\\}-[0-9]\\\\\{6\\\\\}\\\" /var/lib/jenkins/workspace/jenkins.log | grep \\\"PR-${pr_num}:${n}:\\\"\""
+ if [ $? -eq 0 ]; then
+ echo "this PR is possibly on host $host"
+ break
+ fi
+ done
+ exit 1
+fi
+line_num=`echo "$info"|wc -l`
+curr=`echo "$info"|head -n1`
+if [ "$line_num" == "2" ]; then
+ next=`echo "$info"|tail -n1`
+fi
+
+# check if it is TDinternal CI
+internal=0
+commit_prefix=community
+echo "$curr"|grep -q TDinternalCI
+if [ $? -eq 0 ]; then
+ internal=1
+ commit_prefix=tdinternal
+fi
+
+curr_line=`echo "$curr"|cut -d: -f1`
+next_line='$'
+if [ ! -z "$next" ]; then
+ next_line=`echo "$next"|cut -d: -f1`
+ next_line=$(( next_line - 1 ))
+fi
+# echo "$curr_line, $next_line"
+
+details=`sed -n "${curr_line},${next_line}p" $JENKINS_LOG`
+merge_line=`echo "$details"|grep -A 10 "$commit_prefix log merged: "|grep "Merge .* into"|head -n1`
+if [ -z "$merge_line" ]; then
+ echo "merge commit not found"
+ exit 1
+fi
+echo "$merge_line"
+branch=`echo "$merge_line"|awk '{print $2}'`
+commit_id=`echo "$merge_line"|awk '{print $4}'`
+# echo "$details"
+community_id=`echo "$details"|grep "community log: commit"|awk '{print $NF}'`
+internal_id=`echo "$details"|grep "tdinternal log: commit"|awk '{print $NF}'`
+python_connector_id=`echo "$details"|grep "python connector log: commit"|awk '{print $NF}'`
+# change_branch=`echo "$details"|grep "CHANGE_BRANCH"|sed "s/CHANGE_BRANCH://"`
+
+# if [ -z "${branch}" ]; then
+# branch="$change_branch"
+# fi
+
+PWD=`pwd`
+log_dir=`ls log|grep "PR-${pr_num}_${n}_"`
+if [ -z "$log_dir" ]; then
+ echo "no log dir found"
+else
+ mount_dir="-v ${PWD}/log/$log_dir:/home/log"
+ build_dir=`ls log/$log_dir | grep "build_"`
+ if [ ! -z "$build_dir" ]; then
+ mount_dir="$mount_dir -v ${PWD}/log/$log_dir/$build_dir:/home/TDinternal/debug/build"
+ fi
+fi
+
+docker run -d --privileged -it --name $container_name \
+ $mount_dir \
+ taos_test:v1.0 bash
+
+if [ $internal -eq 0 ]; then
+ docker exec $container_name /home/setup.sh -c $commit_id -m $branch -n
+ echo "TDinternal checkout: $internal_id"
+ docker exec $container_name sh -c "cd /home/TDinternal; git checkout $internal_id"
+else
+ docker exec $container_name /home/setup.sh -e -c $commit_id -m $branch -n
+ echo "community checkout: $community_id"
+ docker exec $container_name sh -c "cd /home/TDinternal/community; git checkout $community_id"
+fi
+echo
+echo "* run the following command to enter the container:"
+echo " docker exec -it $container_name bash"
+if [ -z "$log_dir" ]; then
+ echo "* no log dir found"
+else
+ echo "* log and coredump files are located in /home/log"
+fi
+if [ -z "$build_dir" ]; then
+ echo "* no build dir found"
+else
+ echo "* build files are located in /home/TDinternal/debug/build"
+fi
+echo "* source files are located in /home/TDinternal"
+
diff --git a/tests/ci/start_http.sh b/tests/ci/start_http.sh
new file mode 100644
index 0000000000..f73ffc85c8
--- /dev/null
+++ b/tests/ci/start_http.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+script_dir=$(dirname $0)
+cd $script_dir || exit
+script_name=$(basename $0)
+ps -ef|grep -v grep|grep -v $$|grep -q "$script_name"
+if [ $? -eq 0 ]; then
+ exit 0
+fi
+while [ 1 ]; do
+ ps -ef|grep python|grep -q 8081
+ if [ $? -ne 0 ]; then
+ python3 -m http.server 8081
+ fi
+ sleep 60
+done
\ No newline at end of file
diff --git a/tests/parallel_test/container_build.sh b/tests/parallel_test/container_build.sh
index 3d3069f05f..85e3d2ab73 100755
--- a/tests/parallel_test/container_build.sh
+++ b/tests/parallel_test/container_build.sh
@@ -61,14 +61,28 @@ docker run \
-v /root/go/pkg/mod:/root/go/pkg/mod \
-v /root/.cache/go-build:/root/.cache/go-build \
-v /root/.cos-local.1:/root/.cos-local.2 \
- -v ${REP_REAL_PATH}/enterprise/src/plugins/taosx/target:${REP_DIR}/enterprise/src/plugins/taosx/target \
- -v ${REP_REAL_PATH}/community/tools/taosws-rs/target:${REP_DIR}/community/tools/taosws-rs/target \
+ -v ${REP_REAL_PATH}/enterprise/contrib/grant-lib:${REP_DIR}/enterprise/contrib/grant-lib \
+ -v ${REP_REAL_PATH}/community/tools/taosadapter:${REP_DIR}/community/tools/taosadapter \
+ -v ${REP_REAL_PATH}/community/tools/taos-tools:${REP_DIR}/community/tools/taos-tools \
+ -v ${REP_REAL_PATH}/community/tools/taosws-rs:${REP_DIR}/community/tools/taosws-rs \
+ -v ${REP_REAL_PATH}/community/contrib/apr/:${REP_DIR}/community/contrib/apr \
+ -v ${REP_REAL_PATH}/community/contrib/apr-util/:${REP_DIR}/community/contrib/apr-util \
-v ${REP_REAL_PATH}/community/contrib/cJson/:${REP_DIR}/community/contrib/cJson \
- -v ${REP_REAL_PATH}/community/contrib/googletest/:${REP_DIR}/community/contrib/googletest \
-v ${REP_REAL_PATH}/community/contrib/cpp-stub/:${REP_DIR}/community/contrib/cpp-stub \
+ -v ${REP_REAL_PATH}/community/contrib/curl/:${REP_DIR}/community/contrib/curl \
+ -v ${REP_REAL_PATH}/community/contrib/curl2/:${REP_DIR}/community/contrib/curl2 \
+ -v ${REP_REAL_PATH}/community/contrib/geos/:${REP_DIR}/community/contrib/geos \
+ -v ${REP_REAL_PATH}/community/contrib/googletest/:${REP_DIR}/community/contrib/googletest \
+ -v ${REP_REAL_PATH}/community/contrib/libs3/:${REP_DIR}/community/contrib/libs3 \
-v ${REP_REAL_PATH}/community/contrib/libuv/:${REP_DIR}/community/contrib/libuv \
-v ${REP_REAL_PATH}/community/contrib/lz4/:${REP_DIR}/community/contrib/lz4 \
+ -v ${REP_REAL_PATH}/community/contrib/lzma2/:${REP_DIR}/community/contrib/lzma2 \
+ -v ${REP_REAL_PATH}/community/contrib/mxml/:${REP_DIR}/community/contrib/mxml \
+ -v ${REP_REAL_PATH}/community/contrib/openssl/:${REP_DIR}/community/contrib/openssl \
+ -v ${REP_REAL_PATH}/community/contrib/pcre2/:${REP_DIR}/community/contrib/pcre2 \
+ -v ${REP_REAL_PATH}/community/contrib/xml2/:${REP_DIR}/community/contrib/xml2 \
-v ${REP_REAL_PATH}/community/contrib/zlib/:${REP_DIR}/community/contrib/zlib \
+ -v ${REP_REAL_PATH}/community/contrib/zstd/:${REP_DIR}/community/contrib/zstd \
--rm --ulimit core=-1 taos_test:v1.0 sh -c "pip uninstall taospy -y;pip3 install taospy==2.7.2;cd $REP_DIR;rm -rf debug;mkdir -p debug;cd debug;cmake .. -DBUILD_HTTP=false -DBUILD_TOOLS=true -DBUILD_TEST=true -DWEBSOCKET=true -DBUILD_TAOSX=false -DJEMALLOC_ENABLED=0;make -j 10|| exit 1"
# -v ${REP_REAL_PATH}/community/contrib/jemalloc/:${REP_DIR}/community/contrib/jemalloc \
@@ -96,15 +110,29 @@ docker run \
-v /root/go/pkg/mod:/root/go/pkg/mod \
-v /root/.cache/go-build:/root/.cache/go-build \
-v /root/.cos-local.1:/root/.cos-local.2 \
- -v ${REP_REAL_PATH}/enterprise/src/plugins/taosx/target:${REP_DIR}/enterprise/src/plugins/taosx/target \
+ -v ${REP_REAL_PATH}/enterprise/contrib/grant-lib:${REP_DIR}/enterprise/contrib/grant-lib \
+ -v ${REP_REAL_PATH}/community/tools/taosadapter:${REP_DIR}/community/tools/taosadapter \
+ -v ${REP_REAL_PATH}/community/tools/taos-tools:${REP_DIR}/community/tools/taos-tools \
+ -v ${REP_REAL_PATH}/community/tools/taosws-rs:${REP_DIR}/community/tools/taosws-rs \
-v ${REP_REAL_PATH}/community/tools/taosws-rs/target:${REP_DIR}/community/tools/taosws-rs/target \
+ -v ${REP_REAL_PATH}/community/contrib/apr/:${REP_DIR}/community/contrib/apr \
+ -v ${REP_REAL_PATH}/community/contrib/apr-util/:${REP_DIR}/community/contrib/apr-util \
-v ${REP_REAL_PATH}/community/contrib/cJson/:${REP_DIR}/community/contrib/cJson \
- -v ${REP_REAL_PATH}/community/contrib/googletest/:${REP_DIR}/community/contrib/googletest \
-v ${REP_REAL_PATH}/community/contrib/cpp-stub/:${REP_DIR}/community/contrib/cpp-stub \
+ -v ${REP_REAL_PATH}/community/contrib/curl/:${REP_DIR}/community/contrib/curl \
+ -v ${REP_REAL_PATH}/community/contrib/curl2/:${REP_DIR}/community/contrib/curl2 \
+ -v ${REP_REAL_PATH}/community/contrib/geos/:${REP_DIR}/community/contrib/geos \
+ -v ${REP_REAL_PATH}/community/contrib/googletest/:${REP_DIR}/community/contrib/googletest \
+ -v ${REP_REAL_PATH}/community/contrib/libs3/:${REP_DIR}/community/contrib/libs3 \
-v ${REP_REAL_PATH}/community/contrib/libuv/:${REP_DIR}/community/contrib/libuv \
-v ${REP_REAL_PATH}/community/contrib/lz4/:${REP_DIR}/community/contrib/lz4 \
+ -v ${REP_REAL_PATH}/community/contrib/lzma2/:${REP_DIR}/community/contrib/lzma2 \
+ -v ${REP_REAL_PATH}/community/contrib/mxml/:${REP_DIR}/community/contrib/mxml \
+ -v ${REP_REAL_PATH}/community/contrib/openssl/:${REP_DIR}/community/contrib/openssl \
+ -v ${REP_REAL_PATH}/community/contrib/pcre2/:${REP_DIR}/community/contrib/pcre2 \
+ -v ${REP_REAL_PATH}/community/contrib/xml2/:${REP_DIR}/community/contrib/xml2 \
-v ${REP_REAL_PATH}/community/contrib/zlib/:${REP_DIR}/community/contrib/zlib \
- -v ${REP_REAL_PATH}/community/contrib/jemalloc/:${REP_DIR}/community/contrib/jemalloc \
+ -v ${REP_REAL_PATH}/community/contrib/zstd/:${REP_DIR}/community/contrib/zstd \
--rm --ulimit core=-1 taos_test:v1.0 sh -c "pip uninstall taospy -y;pip3 install taospy==2.7.2;cd $REP_DIR;rm -rf debug;mkdir -p debug;cd debug;cmake .. -DBUILD_HTTP=false -DBUILD_TOOLS=true -DBUILD_TEST=false -DWEBSOCKET=true -DBUILD_SANITIZER=1 -DTOOLS_SANITIZE=true $CMAKE_BUILD_TYPE -DTOOLS_BUILD_TYPE=Debug -DBUILD_TAOSX=false -DJEMALLOC_ENABLED=0;make -j 10|| exit 1 "
mv ${REP_REAL_PATH}/debug ${WORKDIR}/debugSan
diff --git a/tests/system-test/8-stream/stream_basic.py b/tests/system-test/8-stream/stream_basic.py
index 2067c2395e..95f4f1addc 100644
--- a/tests/system-test/8-stream/stream_basic.py
+++ b/tests/system-test/8-stream/stream_basic.py
@@ -93,9 +93,8 @@ class TDTestCase:
tdSql.execute("create stream stream2 fill_history 1 into stb subtable(concat('new-', tname)) AS SELECT "
"_wstart, count(*), avg(i) FROM st PARTITION BY tbname tname INTERVAL(1m)", show=True)
- time.sleep(2)
- tdSql.query("select * from sta")
- tdSql.checkRows(3)
+ sql= "select * from sta"
+ tdSql.check_rows_loop(3, sql, loopCount=100, waitTime=0.5)
tdSql.query("select tbname from sta order by tbname")
if not tdSql.getData(0, 0).startswith('nee_w-t1_sta_'):
tdLog.exit("error1")
@@ -106,8 +105,8 @@ class TDTestCase:
if not tdSql.getData(2, 0).startswith('nee_w-t3_sta_'):
tdLog.exit("error3")
- tdSql.query("select * from stb")
- tdSql.checkRows(3)
+ sql= "select * from stb"
+ tdSql.check_rows_loop(3, sql, loopCount=100, waitTime=0.5)
tdSql.query("select tbname from stb order by tbname")
if not tdSql.getData(0, 0).startswith('new-t1_stb_'):
tdLog.exit("error4")