From 64363627fe2a406fad94b26e73cf099f10b4ea38 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 16 Jul 2024 17:30:32 +0800 Subject: [PATCH 01/12] enh: refact tqueue code --- include/util/tqueue.h | 56 +-- source/client/src/clientMonitor.c | 350 +++++++++--------- source/client/src/clientTmq.c | 102 +++-- source/dnode/mgmt/mgmt_mnode/src/mmWorker.c | 12 +- source/dnode/mgmt/mgmt_qnode/src/qmWorker.c | 7 +- source/dnode/mgmt/mgmt_snode/src/smWorker.c | 7 +- source/dnode/mgmt/mgmt_vnode/src/vmWorker.c | 8 +- source/dnode/mgmt/node_mgmt/src/dmTransport.c | 4 +- source/dnode/vnode/src/sma/smaRollup.c | 75 ++-- source/dnode/vnode/src/tq/tqUtil.c | 66 ++-- source/libs/executor/src/dataDeleter.c | 17 +- source/libs/executor/src/dataDispatcher.c | 20 +- source/libs/qcom/src/queryUtil.c | 4 +- source/libs/stream/src/streamCheckpoint.c | 10 +- source/libs/stream/src/streamData.c | 44 ++- source/libs/stream/src/streamQueue.c | 66 ++-- source/libs/stream/src/streamSched.c | 9 +- source/libs/stream/src/streamTask.c | 11 +- source/util/src/tqueue.c | 81 ++-- source/util/src/tworker.c | 156 ++++---- 20 files changed, 627 insertions(+), 478 deletions(-) diff --git a/include/util/tqueue.h b/include/util/tqueue.h index bed218ac1b..f7eaf794b0 100644 --- a/include/util/tqueue.h +++ b/include/util/tqueue.h @@ -73,36 +73,36 @@ struct STaosQnode { char item[]; }; -STaosQueue *taosOpenQueue(); -void taosCloseQueue(STaosQueue *queue); -void taosSetQueueFp(STaosQueue *queue, FItem itemFp, FItems itemsFp); -void *taosAllocateQitem(int32_t size, EQItype itype, int64_t dataSize); -void taosFreeQitem(void *pItem); -int32_t taosWriteQitem(STaosQueue *queue, void *pItem); -int32_t taosReadQitem(STaosQueue *queue, void **ppItem); -bool taosQueueEmpty(STaosQueue *queue); -void taosUpdateItemSize(STaosQueue *queue, int32_t items); -int32_t taosQueueItemSize(STaosQueue *queue); -int64_t taosQueueMemorySize(STaosQueue *queue); -void taosSetQueueCapacity(STaosQueue *queue, int64_t size); -void taosSetQueueMemoryCapacity(STaosQueue *queue, int64_t mem); +int32_t taosOpenQueue(STaosQueue **queue); +void taosCloseQueue(STaosQueue *queue); +void taosSetQueueFp(STaosQueue *queue, FItem itemFp, FItems itemsFp); +int32_t taosAllocateQitem(int32_t size, EQItype itype, int64_t dataSize, void **item); +void taosFreeQitem(void *pItem); +int32_t taosWriteQitem(STaosQueue *queue, void *pItem); +int32_t taosReadQitem(STaosQueue *queue, void **ppItem); +bool taosQueueEmpty(STaosQueue *queue); +void taosUpdateItemSize(STaosQueue *queue, int32_t items); +int32_t taosQueueItemSize(STaosQueue *queue); +int64_t taosQueueMemorySize(STaosQueue *queue); +void taosSetQueueCapacity(STaosQueue *queue, int64_t size); +void taosSetQueueMemoryCapacity(STaosQueue *queue, int64_t mem); -STaosQall *taosAllocateQall(); -void taosFreeQall(STaosQall *qall); -int32_t taosReadAllQitems(STaosQueue *queue, STaosQall *qall); -int32_t taosGetQitem(STaosQall *qall, void **ppItem); -void taosResetQitems(STaosQall *qall); -int32_t taosQallItemSize(STaosQall *qall); -int64_t taosQallMemSize(STaosQall *qll); -int64_t taosQallUnAccessedItemSize(STaosQall *qall); -int64_t taosQallUnAccessedMemSize(STaosQall *qall); +int32_t taosAllocateQall(STaosQall **qall); +void taosFreeQall(STaosQall *qall); +int32_t taosReadAllQitems(STaosQueue *queue, STaosQall *qall); +int32_t taosGetQitem(STaosQall *qall, void **ppItem); +void taosResetQitems(STaosQall *qall); +int32_t taosQallItemSize(STaosQall *qall); +int64_t taosQallMemSize(STaosQall *qll); +int64_t taosQallUnAccessedItemSize(STaosQall *qall); +int64_t taosQallUnAccessedMemSize(STaosQall *qall); -STaosQset *taosOpenQset(); -void taosCloseQset(STaosQset *qset); -void taosQsetThreadResume(STaosQset *qset); -int32_t taosAddIntoQset(STaosQset *qset, STaosQueue *queue, void *ahandle); -void taosRemoveFromQset(STaosQset *qset, STaosQueue *queue); -int32_t taosGetQueueNumber(STaosQset *qset); +int32_t taosOpenQset(STaosQset **qset); +void taosCloseQset(STaosQset *qset); +void taosQsetThreadResume(STaosQset *qset); +int32_t taosAddIntoQset(STaosQset *qset, STaosQueue *queue, void *ahandle); +void taosRemoveFromQset(STaosQset *qset, STaosQueue *queue); +int32_t taosGetQueueNumber(STaosQset *qset); int32_t taosReadQitemFromQset(STaosQset *qset, void **ppItem, SQueueInfo *qinfo); int32_t taosReadAllQitemsFromQset(STaosQset *qset, STaosQall *qall, SQueueInfo *qinfo); diff --git a/source/client/src/clientMonitor.c b/source/client/src/clientMonitor.c index ae2a57ba97..304f18cd68 100644 --- a/source/client/src/clientMonitor.c +++ b/source/client/src/clientMonitor.c @@ -1,13 +1,13 @@ #include "clientMonitor.h" -#include "clientLog.h" -#include "os.h" -#include "tmisce.h" -#include "ttime.h" -#include "ttimer.h" -#include "tglobal.h" -#include "tqueue.h" #include "cJSON.h" #include "clientInt.h" +#include "clientLog.h" +#include "os.h" +#include "tglobal.h" +#include "tmisce.h" +#include "tqueue.h" +#include "ttime.h" +#include "ttimer.h" SRWLatch monitorLock; void* monitorTimer; @@ -20,41 +20,41 @@ STaosQueue* monitorQueue; SHashObj* monitorSlowLogHash; char tmpSlowLogPath[PATH_MAX] = {0}; -static int32_t getSlowLogTmpDir(char* tmpPath, int32_t size){ +static int32_t getSlowLogTmpDir(char* tmpPath, int32_t size) { if (tsTempDir == NULL) { return -1; } int ret = snprintf(tmpPath, size, "%s/tdengine_slow_log/", tsTempDir); - if (ret < 0){ + if (ret < 0) { tscError("failed to get tmp path ret:%d", ret); return ret; } return 0; } -static void processFileInTheEnd(TdFilePtr pFile, char* path){ - if(pFile == NULL){ +static void processFileInTheEnd(TdFilePtr pFile, char* path) { + if (pFile == NULL) { return; } - if(taosFtruncateFile(pFile, 0) != 0){ + if (taosFtruncateFile(pFile, 0) != 0) { tscError("failed to truncate file:%s, errno:%d", path, errno); return; } - if(taosUnLockFile(pFile) != 0){ + if (taosUnLockFile(pFile) != 0) { tscError("failed to unlock file:%s, errno:%d", path, errno); return; } - if(taosCloseFile(&(pFile)) != 0){ + if (taosCloseFile(&(pFile)) != 0) { tscError("failed to close file:%s, errno:%d", path, errno); return; } - if(taosRemoveFile(path) != 0){ + if (taosRemoveFile(path) != 0) { tscError("failed to remove file:%s, errno:%d", path, errno); return; } } -static void destroySlowLogClient(void* data){ +static void destroySlowLogClient(void* data) { if (data == NULL) { return; } @@ -63,40 +63,40 @@ static void destroySlowLogClient(void* data){ taosMemoryFree(slowLogClient); } -static void destroyMonitorClient(void* data){ +static void destroyMonitorClient(void* data) { if (data == NULL) { return; } MonitorClient* pMonitor = *(MonitorClient**)data; - if(pMonitor == NULL){ + if (pMonitor == NULL) { return; } taosTmrStopA(&pMonitor->timer); taosHashCleanup(pMonitor->counters); taos_collector_registry_destroy(pMonitor->registry); -// taos_collector_destroy(pMonitor->colector); + // taos_collector_destroy(pMonitor->colector); taosMemoryFree(pMonitor); } -static void monitorFreeSlowLogData(void *paras) { +static void monitorFreeSlowLogData(void* paras) { MonitorSlowLogData* pData = (MonitorSlowLogData*)paras; if (pData == NULL) { return; } taosMemoryFreeClear(pData->data); - if (pData->type == SLOW_LOG_READ_BEGINNIG){ + if (pData->type == SLOW_LOG_READ_BEGINNIG) { taosMemoryFree(pData->fileName); } } -static void monitorFreeSlowLogDataEx(void *paras) { +static void monitorFreeSlowLogDataEx(void* paras) { monitorFreeSlowLogData(paras); taosMemoryFree(paras); } static SAppInstInfo* getAppInstByClusterId(int64_t clusterId) { - void *p = taosHashGet(appInfo.pInstMapByClusterId, &clusterId, LONG_BYTES); - if(p == NULL){ + void* p = taosHashGet(appInfo.pInstMapByClusterId, &clusterId, LONG_BYTES); + if (p == NULL) { tscError("failed to get app inst, clusterId:%" PRIx64, clusterId); return NULL; } @@ -111,21 +111,25 @@ static int32_t monitorReportAsyncCB(void* param, SDataBuf* pMsg, int32_t code) { taosMemoryFree(pMsg->pData); taosMemoryFree(pMsg->pEpSet); } - if(param != NULL){ + if (param != NULL) { MonitorSlowLogData* p = (MonitorSlowLogData*)param; - if(code != 0){ + if (code != 0) { tscError("failed to send slow log:%s, clusterId:%" PRIx64, p->data, p->clusterId); } - MonitorSlowLogData tmp = {.clusterId = p->clusterId, .type = p->type, .fileName = p->fileName, - .pFile= p->pFile, .offset = p->offset, .data = NULL}; - if(monitorPutData2MonitorQueue(tmp) == 0){ + MonitorSlowLogData tmp = {.clusterId = p->clusterId, + .type = p->type, + .fileName = p->fileName, + .pFile = p->pFile, + .offset = p->offset, + .data = NULL}; + if (monitorPutData2MonitorQueue(tmp) == 0) { p->fileName = NULL; } } return code; } -static int32_t sendReport(void* pTransporter, SEpSet *epSet, char* pCont, MONITOR_TYPE type, void* param) { +static int32_t sendReport(void* pTransporter, SEpSet* epSet, char* pCont, MONITOR_TYPE type, void* param) { SStatisReq sStatisReq; sStatisReq.pCont = pCont; sStatisReq.contLen = strlen(pCont); @@ -167,11 +171,11 @@ FAILED: return -1; } -static void generateClusterReport(taos_collector_registry_t* registry, void* pTransporter, SEpSet *epSet) { +static void generateClusterReport(taos_collector_registry_t* registry, void* pTransporter, SEpSet* epSet) { char ts[50] = {0}; sprintf(ts, "%" PRId64, taosGetTimestamp(TSDB_TIME_PRECISION_MILLI)); char* pCont = (char*)taos_collector_registry_bridge_new(registry, ts, "%" PRId64, NULL); - if(NULL == pCont) { + if (NULL == pCont) { tscError("generateClusterReport failed, get null content."); return; } @@ -190,8 +194,8 @@ static void reportSendProcess(void* param, void* tmrId) { } MonitorClient* pMonitor = (MonitorClient*)param; - SAppInstInfo* pInst = getAppInstByClusterId(pMonitor->clusterId); - if(pInst == NULL){ + SAppInstInfo* pInst = getAppInstByClusterId(pMonitor->clusterId); + if (pInst == NULL) { taosRUnLockLatch(&monitorLock); return; } @@ -202,15 +206,15 @@ static void reportSendProcess(void* param, void* tmrId) { taosRUnLockLatch(&monitorLock); } -static void sendAllCounter(){ +static void sendAllCounter() { MonitorClient** ppMonitor = NULL; while ((ppMonitor = taosHashIterate(monitorSlowLogHash, ppMonitor))) { MonitorClient* pMonitor = *ppMonitor; - if (pMonitor == NULL){ + if (pMonitor == NULL) { continue; } SAppInstInfo* pInst = getAppInstByClusterId(pMonitor->clusterId); - if(pInst == NULL){ + if (pInst == NULL) { taosHashCancelIterate(monitorCounterHash, ppMonitor); break; } @@ -231,46 +235,48 @@ void monitorCreateClient(int64_t clusterId) { } pMonitor->clusterId = clusterId; char clusterKey[32] = {0}; - if(snprintf(clusterKey, sizeof(clusterKey), "%"PRId64, clusterId) < 0){ + if (snprintf(clusterKey, sizeof(clusterKey), "%" PRId64, clusterId) < 0) { tscError("failed to create cluster key"); goto fail; } pMonitor->registry = taos_collector_registry_new(clusterKey); - if(pMonitor->registry == NULL){ + if (pMonitor->registry == NULL) { tscError("failed to create registry"); goto fail; } pMonitor->colector = taos_collector_new(clusterKey); - if(pMonitor->colector == NULL){ + if (pMonitor->colector == NULL) { tscError("failed to create collector"); goto fail; } taos_collector_registry_register_collector(pMonitor->registry, pMonitor->colector); - pMonitor->counters = (SHashObj*)taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK); + pMonitor->counters = + (SHashObj*)taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK); if (pMonitor->counters == NULL) { tscError("failed to create monitor counters"); goto fail; } -// taosHashSetFreeFp(pMonitor->counters, destroyCounter); + // taosHashSetFreeFp(pMonitor->counters, destroyCounter); - if(taosHashPut(monitorCounterHash, &clusterId, LONG_BYTES, &pMonitor, POINTER_BYTES) != 0){ + if (taosHashPut(monitorCounterHash, &clusterId, LONG_BYTES, &pMonitor, POINTER_BYTES) != 0) { tscError("failed to put monitor client to hash"); goto fail; } SAppInstInfo* pInst = getAppInstByClusterId(clusterId); - if(pInst == NULL){ + if (pInst == NULL) { tscError("failed to get app instance by cluster id"); pMonitor = NULL; goto fail; } - pMonitor->timer = taosTmrStart(reportSendProcess, pInst->monitorParas.tsMonitorInterval * 1000, (void*)pMonitor, monitorTimer); - if(pMonitor->timer == NULL){ + pMonitor->timer = + taosTmrStart(reportSendProcess, pInst->monitorParas.tsMonitorInterval * 1000, (void*)pMonitor, monitorTimer); + if (pMonitor->timer == NULL) { tscError("failed to start timer"); goto fail; } - tscInfo("[monitor] monitorCreateClient for %"PRIx64 "finished %p.", clusterId, pMonitor); + tscInfo("[monitor] monitorCreateClient for %" PRIx64 "finished %p.", clusterId, pMonitor); } taosWUnLockLatch(&monitorLock); if (-1 != atomic_val_compare_exchange_32(&monitorFlag, -1, 0)) { @@ -283,7 +289,8 @@ fail: taosWUnLockLatch(&monitorLock); } -void monitorCreateClientCounter(int64_t clusterId, const char* name, const char* help, size_t label_key_count, const char** label_keys) { +void monitorCreateClientCounter(int64_t clusterId, const char* name, const char* help, size_t label_key_count, + const char** label_keys) { taosWLockLatch(&monitorLock); MonitorClient** ppMonitor = (MonitorClient**)taosHashGet(monitorCounterHash, &clusterId, LONG_BYTES); if (ppMonitor == NULL || *ppMonitor == NULL) { @@ -291,16 +298,16 @@ void monitorCreateClientCounter(int64_t clusterId, const char* name, const char* goto end; } taos_counter_t* newCounter = taos_counter_new(name, help, label_key_count, label_keys); - if (newCounter == NULL) - return; - MonitorClient* pMonitor = *ppMonitor; + if (newCounter == NULL) return; + MonitorClient* pMonitor = *ppMonitor; taos_collector_add_metric(pMonitor->colector, newCounter); - if(taosHashPut(pMonitor->counters, name, strlen(name), &newCounter, POINTER_BYTES) != 0){ + if (taosHashPut(pMonitor->counters, name, strlen(name), &newCounter, POINTER_BYTES) != 0) { tscError("failed to put counter to monitor"); taos_counter_destroy(newCounter); goto end; } - tscInfo("[monitor] monitorCreateClientCounter %"PRIx64"(%p):%s : %p.", pMonitor->clusterId, pMonitor, name, newCounter); + tscInfo("[monitor] monitorCreateClientCounter %" PRIx64 "(%p):%s : %p.", pMonitor->clusterId, pMonitor, name, + newCounter); end: taosWUnLockLatch(&monitorLock); @@ -315,18 +322,18 @@ void monitorCounterInc(int64_t clusterId, const char* counterName, const char** MonitorClient** ppMonitor = (MonitorClient**)taosHashGet(monitorCounterHash, &clusterId, LONG_BYTES); if (ppMonitor == NULL || *ppMonitor == NULL) { - tscError("monitorCounterInc not found pMonitor %"PRId64, clusterId); + tscError("monitorCounterInc not found pMonitor %" PRId64, clusterId); goto end; } MonitorClient* pMonitor = *ppMonitor; taos_counter_t** ppCounter = (taos_counter_t**)taosHashGet(pMonitor->counters, counterName, strlen(counterName)); if (ppCounter == NULL || *ppCounter == NULL) { - tscError("monitorCounterInc not found pCounter %"PRIx64":%s.", clusterId, counterName); + tscError("monitorCounterInc not found pCounter %" PRIx64 ":%s.", clusterId, counterName); goto end; } taos_counter_inc(*ppCounter, label_values); - tscDebug("[monitor] monitorCounterInc %"PRIx64"(%p):%s", pMonitor->clusterId, pMonitor, counterName); + tscDebug("[monitor] monitorCounterInc %" PRIx64 "(%p):%s", pMonitor->clusterId, pMonitor, counterName); end: taosWUnLockLatch(&monitorLock); @@ -339,13 +346,13 @@ const char* monitorResultStr(SQL_RESULT_CODE code) { static void monitorThreadFuncUnexpectedStopped(void) { atomic_store_32(&slowLogFlag, -1); } -static void monitorWriteSlowLog2File(MonitorSlowLogData* slowLogData, char *tmpPath){ +static void monitorWriteSlowLog2File(MonitorSlowLogData* slowLogData, char* tmpPath) { TdFilePtr pFile = NULL; - void* tmp = taosHashGet(monitorSlowLogHash, &slowLogData->clusterId, LONG_BYTES); - if (tmp == NULL){ + void* tmp = taosHashGet(monitorSlowLogHash, &slowLogData->clusterId, LONG_BYTES); + if (tmp == NULL) { char path[PATH_MAX] = {0}; char clusterId[32] = {0}; - if (snprintf(clusterId, sizeof(clusterId), "%" PRIx64, slowLogData->clusterId) < 0){ + if (snprintf(clusterId, sizeof(clusterId), "%" PRIx64, slowLogData->clusterId) < 0) { tscError("failed to generate clusterId:%" PRIx64, slowLogData->clusterId); return; } @@ -358,8 +365,8 @@ static void monitorWriteSlowLog2File(MonitorSlowLogData* slowLogData, char *tmpP return; } - SlowLogClient *pClient = taosMemoryCalloc(1, sizeof(SlowLogClient)); - if (pClient == NULL){ + SlowLogClient* pClient = taosMemoryCalloc(1, sizeof(SlowLogClient)); + if (pClient == NULL) { tscError("failed to allocate memory for slow log client"); taosCloseFile(&pFile); return; @@ -368,58 +375,58 @@ static void monitorWriteSlowLog2File(MonitorSlowLogData* slowLogData, char *tmpP strcpy(pClient->path, path); pClient->offset = 0; pClient->pFile = pFile; - if (taosHashPut(monitorSlowLogHash, &slowLogData->clusterId, LONG_BYTES, &pClient, POINTER_BYTES) != 0){ + if (taosHashPut(monitorSlowLogHash, &slowLogData->clusterId, LONG_BYTES, &pClient, POINTER_BYTES) != 0) { tscError("failed to put clusterId:%" PRId64 " to hash table", slowLogData->clusterId); taosCloseFile(&pFile); taosMemoryFree(pClient); return; } - if(taosLockFile(pFile) < 0){ + if (taosLockFile(pFile) < 0) { tscError("failed to lock file:%p since %s", pFile, terrstr()); return; } - }else{ + } else { pFile = (*(SlowLogClient**)tmp)->pFile; } - if(taosLSeekFile(pFile, 0, SEEK_END) < 0){ + if (taosLSeekFile(pFile, 0, SEEK_END) < 0) { tscError("failed to seek file:%p code: %d", pFile, errno); return; } - if (taosWriteFile(pFile, slowLogData->data, strlen(slowLogData->data) + 1) < 0){ + if (taosWriteFile(pFile, slowLogData->data, strlen(slowLogData->data) + 1) < 0) { tscError("failed to write len to file:%p since %s", pFile, terrstr()); } - tscDebug("[monitor] write slow log to file:%p, clusterId:%"PRIx64, pFile, slowLogData->clusterId); + tscDebug("[monitor] write slow log to file:%p, clusterId:%" PRIx64, pFile, slowLogData->clusterId); } -static char* readFile(TdFilePtr pFile, int64_t *offset, int64_t size){ - tscDebug("[monitor] readFile slow begin pFile:%p, offset:%"PRId64 ", size:%"PRId64, pFile, *offset, size); - if(taosLSeekFile(pFile, *offset, SEEK_SET) < 0){ +static char* readFile(TdFilePtr pFile, int64_t* offset, int64_t size) { + tscDebug("[monitor] readFile slow begin pFile:%p, offset:%" PRId64 ", size:%" PRId64, pFile, *offset, size); + if (taosLSeekFile(pFile, *offset, SEEK_SET) < 0) { tscError("failed to seek file:%p code: %d", pFile, errno); return NULL; } ASSERT(size > *offset); - char* pCont = NULL; + char* pCont = NULL; int64_t totalSize = 0; if (size - *offset >= SLOW_LOG_SEND_SIZE_MAX) { - pCont = taosMemoryCalloc(1, 4 + SLOW_LOG_SEND_SIZE_MAX); //4 reserved for [] + pCont = taosMemoryCalloc(1, 4 + SLOW_LOG_SEND_SIZE_MAX); // 4 reserved for [] totalSize = 4 + SLOW_LOG_SEND_SIZE_MAX; - }else{ + } else { pCont = taosMemoryCalloc(1, 4 + (size - *offset)); totalSize = 4 + (size - *offset); } - if(pCont == NULL){ + if (pCont == NULL) { tscError("failed to allocate memory for slow log, size:%" PRId64, totalSize); return NULL; } - char* buf = pCont; + char* buf = pCont; strcat(buf++, "["); int64_t readSize = taosReadFile(pFile, buf, SLOW_LOG_SEND_SIZE_MAX); if (readSize <= 0) { - if (readSize < 0){ + if (readSize < 0) { tscError("failed to read len from file:%p since %s", pFile, terrstr()); } taosMemoryFree(pCont); @@ -427,24 +434,24 @@ static char* readFile(TdFilePtr pFile, int64_t *offset, int64_t size){ } totalSize = 0; - while(1){ + while (1) { size_t len = strlen(buf); - totalSize += (len+1); + totalSize += (len + 1); if (totalSize > readSize || len == 0) { - *(buf-1) = ']'; + *(buf - 1) = ']'; *buf = '\0'; break; } - buf[len] = ','; // replace '\0' with ',' + buf[len] = ','; // replace '\0' with ',' buf += (len + 1); - *offset += (len+1); + *offset += (len + 1); } - tscDebug("[monitor] readFile slow log end, data:%s, offset:%"PRId64, pCont, *offset); + tscDebug("[monitor] readFile slow log end, data:%s, offset:%" PRId64, pCont, *offset); return pCont; } -static int64_t getFileSize(char* path){ +static int64_t getFileSize(char* path) { int64_t fileSize = 0; if (taosStatFile(path, &fileSize, NULL, NULL) < 0) { return -1; @@ -453,13 +460,14 @@ static int64_t getFileSize(char* path){ return fileSize; } -static int32_t sendSlowLog(int64_t clusterId, char* data, TdFilePtr pFile, int64_t offset, SLOW_LOG_QUEUE_TYPE type, char* fileName, void* pTransporter, SEpSet *epSet){ - if (data == NULL){ +static int32_t sendSlowLog(int64_t clusterId, char* data, TdFilePtr pFile, int64_t offset, SLOW_LOG_QUEUE_TYPE type, + char* fileName, void* pTransporter, SEpSet* epSet) { + if (data == NULL) { taosMemoryFree(fileName); return -1; } MonitorSlowLogData* pParam = taosMemoryMalloc(sizeof(MonitorSlowLogData)); - if(pParam == NULL){ + if (pParam == NULL) { taosMemoryFree(data); taosMemoryFree(fileName); return -1; @@ -473,121 +481,124 @@ static int32_t sendSlowLog(int64_t clusterId, char* data, TdFilePtr pFile, int64 return sendReport(pTransporter, epSet, data, MONITOR_TYPE_SLOW_LOG, pParam); } -static int32_t monitorReadSend(int64_t clusterId, TdFilePtr pFile, int64_t* offset, int64_t size, SLOW_LOG_QUEUE_TYPE type, char* fileName){ +static int32_t monitorReadSend(int64_t clusterId, TdFilePtr pFile, int64_t* offset, int64_t size, + SLOW_LOG_QUEUE_TYPE type, char* fileName) { SAppInstInfo* pInst = getAppInstByClusterId(clusterId); - if(pInst == NULL){ + if (pInst == NULL) { tscError("failed to get app instance by clusterId:%" PRId64, clusterId); return -1; } SEpSet ep = getEpSet_s(&pInst->mgmtEp); - char* data = readFile(pFile, offset, size); - return sendSlowLog(clusterId, data, (type == SLOW_LOG_READ_BEGINNIG ? pFile : NULL), *offset, type, fileName, pInst->pTransporter, &ep); + char* data = readFile(pFile, offset, size); + return sendSlowLog(clusterId, data, (type == SLOW_LOG_READ_BEGINNIG ? pFile : NULL), *offset, type, fileName, + pInst->pTransporter, &ep); } -static void monitorSendSlowLogAtBeginning(int64_t clusterId, char** fileName, TdFilePtr pFile, int64_t offset){ - int64_t size = getFileSize(*fileName); - if(size <= offset){ +static void monitorSendSlowLogAtBeginning(int64_t clusterId, char** fileName, TdFilePtr pFile, int64_t offset) { + int64_t size = getFileSize(*fileName); + if (size <= offset) { processFileInTheEnd(pFile, *fileName); tscDebug("[monitor] monitorSendSlowLogAtBeginning delete file:%s", *fileName); - }else{ + } else { int32_t code = monitorReadSend(clusterId, pFile, &offset, size, SLOW_LOG_READ_BEGINNIG, *fileName); - tscDebug("[monitor] monitorSendSlowLogAtBeginning send slow log clusterId:%"PRId64",ret:%d", clusterId, code); + tscDebug("[monitor] monitorSendSlowLogAtBeginning send slow log clusterId:%" PRId64 ",ret:%d", clusterId, code); *fileName = NULL; } } -static void monitorSendSlowLogAtRunning(int64_t clusterId){ +static void monitorSendSlowLogAtRunning(int64_t clusterId) { void* tmp = taosHashGet(monitorSlowLogHash, &clusterId, LONG_BYTES); - if (tmp == NULL){ + if (tmp == NULL) { return; } SlowLogClient* pClient = (*(SlowLogClient**)tmp); - if (pClient == NULL){ + if (pClient == NULL) { return; } - int64_t size = getFileSize(pClient->path); - if(size <= pClient->offset){ - if(taosFtruncateFile(pClient->pFile, 0) < 0){ + int64_t size = getFileSize(pClient->path); + if (size <= pClient->offset) { + if (taosFtruncateFile(pClient->pFile, 0) < 0) { tscError("failed to truncate file:%p code: %d", pClient->pFile, errno); } tscDebug("[monitor] monitorSendSlowLogAtRunning truncate file to 0 file:%p", pClient->pFile); pClient->offset = 0; - }else{ + } else { int32_t code = monitorReadSend(clusterId, pClient->pFile, &pClient->offset, size, SLOW_LOG_READ_RUNNING, NULL); - tscDebug("[monitor] monitorSendSlowLogAtRunning send slow log clusterId:%"PRId64",ret:%d", clusterId, code); + tscDebug("[monitor] monitorSendSlowLogAtRunning send slow log clusterId:%" PRId64 ",ret:%d", clusterId, code); } } static bool monitorSendSlowLogAtQuit(int64_t clusterId) { void* tmp = taosHashGet(monitorSlowLogHash, &clusterId, LONG_BYTES); - if (tmp == NULL){ + if (tmp == NULL) { return true; } SlowLogClient* pClient = (*(SlowLogClient**)tmp); - if (pClient == NULL){ + if (pClient == NULL) { return true; } int64_t size = getFileSize(pClient->path); - if(size <= pClient->offset){ + if (size <= pClient->offset) { processFileInTheEnd(pClient->pFile, pClient->path); pClient->pFile = NULL; tscInfo("[monitor] monitorSendSlowLogAtQuit remove file:%s", pClient->path); - if((--quitCnt) == 0){ + if ((--quitCnt) == 0) { return true; } - }else{ + } else { int32_t code = monitorReadSend(clusterId, pClient->pFile, &pClient->offset, size, SLOW_LOG_READ_QUIT, NULL); - tscDebug("[monitor] monitorSendSlowLogAtQuit send slow log clusterId:%"PRId64",ret:%d", clusterId, code); + tscDebug("[monitor] monitorSendSlowLogAtQuit send slow log clusterId:%" PRId64 ",ret:%d", clusterId, code); } return false; } -static void monitorSendAllSlowLogAtQuit(){ +static void monitorSendAllSlowLogAtQuit() { void* pIter = NULL; while ((pIter = taosHashIterate(monitorSlowLogHash, pIter))) { SlowLogClient* pClient = (*(SlowLogClient**)pIter); - if(pClient == NULL) { + if (pClient == NULL) { continue; } int64_t size = getFileSize(pClient->path); - if(size <= pClient->offset){ + if (size <= pClient->offset) { processFileInTheEnd(pClient->pFile, pClient->path); pClient->pFile = NULL; - }else if(pClient->offset == 0){ + } else if (pClient->offset == 0) { int64_t* clusterId = (int64_t*)taosHashGetKey(pIter, NULL); - int32_t code = monitorReadSend(*clusterId, pClient->pFile, &pClient->offset, size, SLOW_LOG_READ_QUIT, NULL); - tscDebug("[monitor] monitorSendAllSlowLogAtQuit send slow log clusterId:%"PRId64",ret:%d", *clusterId, code); - if (code == 0){ - quitCnt ++; + int32_t code = monitorReadSend(*clusterId, pClient->pFile, &pClient->offset, size, SLOW_LOG_READ_QUIT, NULL); + tscDebug("[monitor] monitorSendAllSlowLogAtQuit send slow log clusterId:%" PRId64 ",ret:%d", *clusterId, code); + if (code == 0) { + quitCnt++; } } } } -static void processFileRemoved(SlowLogClient* pClient){ +static void processFileRemoved(SlowLogClient* pClient) { taosUnLockFile(pClient->pFile); taosCloseFile(&(pClient->pFile)); - TdFilePtr pFile = taosOpenFile(pClient->path, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND | TD_FILE_READ | TD_FILE_TRUNC); + TdFilePtr pFile = + taosOpenFile(pClient->path, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND | TD_FILE_READ | TD_FILE_TRUNC); if (pFile == NULL) { terrno = TAOS_SYSTEM_ERROR(errno); tscError("failed to open file:%s since %s", pClient->path, terrstr()); - }else{ + } else { pClient->pFile = pFile; } } -static void monitorSendAllSlowLog(){ +static void monitorSendAllSlowLog() { int64_t t = taosGetMonoTimestampMs(); - void* pIter = NULL; + void* pIter = NULL; while ((pIter = taosHashIterate(monitorSlowLogHash, pIter))) { int64_t* clusterId = (int64_t*)taosHashGetKey(pIter, NULL); SAppInstInfo* pInst = getAppInstByClusterId(*clusterId); SlowLogClient* pClient = (*(SlowLogClient**)pIter); - if (pClient == NULL){ + if (pClient == NULL) { taosHashCancelIterate(monitorSlowLogHash, pIter); return; } - if (t - pClient->lastCheckTime > pInst->monitorParas.tsMonitorInterval * 1000){ + if (t - pClient->lastCheckTime > pInst->monitorParas.tsMonitorInterval * 1000) { pClient->lastCheckTime = t; } else { continue; @@ -595,35 +606,35 @@ static void monitorSendAllSlowLog(){ if (pInst != NULL && pClient->offset == 0) { int64_t size = getFileSize(pClient->path); - if(size <= 0){ - if(size < 0){ + if (size <= 0) { + if (size < 0) { tscError("[monitor] monitorSendAllSlowLog failed to get file size:%s, err:%d", pClient->path, errno); - if(errno == ENOENT){ + if (errno == ENOENT) { processFileRemoved(pClient); } } continue; } int32_t code = monitorReadSend(*clusterId, pClient->pFile, &pClient->offset, size, SLOW_LOG_READ_RUNNING, NULL); - tscDebug("[monitor] monitorSendAllSlowLog send slow log clusterId:%"PRId64",ret:%d", *clusterId, code); + tscDebug("[monitor] monitorSendAllSlowLog send slow log clusterId:%" PRId64 ",ret:%d", *clusterId, code); } } } -static void monitorSendAllSlowLogFromTempDir(int64_t clusterId){ +static void monitorSendAllSlowLogFromTempDir(int64_t clusterId) { SAppInstInfo* pInst = getAppInstByClusterId((int64_t)clusterId); - if(pInst == NULL || !pInst->monitorParas.tsEnableMonitor){ + if (pInst == NULL || !pInst->monitorParas.tsEnableMonitor) { tscInfo("[monitor] monitor is disabled, skip send slow log"); return; } char namePrefix[PATH_MAX] = {0}; - if (snprintf(namePrefix, sizeof(namePrefix), "%s%"PRIx64, TD_TMP_FILE_PREFIX, clusterId) < 0) { + if (snprintf(namePrefix, sizeof(namePrefix), "%s%" PRIx64, TD_TMP_FILE_PREFIX, clusterId) < 0) { tscError("failed to generate slow log file name prefix"); return; } - char tmpPath[PATH_MAX] = {0}; + char tmpPath[PATH_MAX] = {0}; if (getSlowLogTmpDir(tmpPath, sizeof(tmpPath)) < 0) { return; } @@ -639,11 +650,9 @@ static void monitorSendAllSlowLogFromTempDir(int64_t clusterId){ continue; } - char *name = taosGetDirEntryName(de); - if (strcmp(name, ".") == 0 || - strcmp(name, "..") == 0 || - strstr(name, namePrefix) == NULL) { - tscInfo("skip file:%s, for cluster id:%"PRIx64, name, clusterId); + char* name = taosGetDirEntryName(de); + if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0 || strstr(name, namePrefix) == NULL) { + tscInfo("skip file:%s, for cluster id:%" PRIx64, name, clusterId); continue; } @@ -659,7 +668,7 @@ static void monitorSendAllSlowLogFromTempDir(int64_t clusterId){ taosCloseFile(&pFile); continue; } - char *tmp = taosStrdup(filename); + char* tmp = taosStrdup(filename); monitorSendSlowLogAtBeginning(clusterId, &tmp, pFile, 0); taosMemoryFree(tmp); } @@ -667,7 +676,7 @@ static void monitorSendAllSlowLogFromTempDir(int64_t clusterId){ taosCloseDir(&pDir); } -static void* monitorThreadFunc(void *param){ +static void* monitorThreadFunc(void* param) { setThreadName("client-monitor-slowlog"); #ifdef WINDOWS @@ -680,18 +689,18 @@ static void* monitorThreadFunc(void *param){ return NULL; } tscDebug("monitorThreadFunc start"); - int64_t quitTime = 0; + int64_t quitTime = 0; while (1) { if (atomic_load_32(&slowLogFlag) > 0 > 0) { - if(quitCnt == 0){ + if (quitCnt == 0) { monitorSendAllSlowLogAtQuit(); - if(quitCnt == 0){ + if (quitCnt == 0) { tscInfo("monitorThreadFunc quit since no slow log to send"); break; } quitTime = taosGetMonoTimestampMs(); } - if(taosGetMonoTimestampMs() - quitTime > 500){ //quit at most 500ms + if (taosGetMonoTimestampMs() - quitTime > 500) { // quit at most 500ms tscInfo("monitorThreadFunc quit since timeout"); break; } @@ -700,18 +709,19 @@ static void* monitorThreadFunc(void *param){ MonitorSlowLogData* slowLogData = NULL; taosReadQitem(monitorQueue, (void**)&slowLogData); if (slowLogData != NULL) { - if (slowLogData->type == SLOW_LOG_READ_BEGINNIG){ - if(slowLogData->pFile != NULL){ - monitorSendSlowLogAtBeginning(slowLogData->clusterId, &(slowLogData->fileName), slowLogData->pFile, slowLogData->offset); - }else{ + if (slowLogData->type == SLOW_LOG_READ_BEGINNIG) { + if (slowLogData->pFile != NULL) { + monitorSendSlowLogAtBeginning(slowLogData->clusterId, &(slowLogData->fileName), slowLogData->pFile, + slowLogData->offset); + } else { monitorSendAllSlowLogFromTempDir(slowLogData->clusterId); } - } else if(slowLogData->type == SLOW_LOG_WRITE){ + } else if (slowLogData->type == SLOW_LOG_WRITE) { monitorWriteSlowLog2File(slowLogData, tmpSlowLogPath); - } else if(slowLogData->type == SLOW_LOG_READ_RUNNING){ + } else if (slowLogData->type == SLOW_LOG_READ_RUNNING) { monitorSendSlowLogAtRunning(slowLogData->clusterId); - } else if(slowLogData->type == SLOW_LOG_READ_QUIT){ - if(monitorSendSlowLogAtQuit(slowLogData->clusterId)){ + } else if (slowLogData->type == SLOW_LOG_READ_QUIT) { + if (monitorSendSlowLogAtQuit(slowLogData->clusterId)) { tscInfo("monitorThreadFunc quit since all slow log sended"); monitorFreeSlowLogData(slowLogData); taosFreeQitem(slowLogData); @@ -757,8 +767,11 @@ static void tscMonitorStop() { } int32_t monitorInit() { + int32_t code; + tscInfo("[monitor] tscMonitor init"); - monitorCounterHash = (SHashObj*)taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); + monitorCounterHash = + (SHashObj*)taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); if (monitorCounterHash == NULL) { tscError("failed to create monitorCounterHash"); terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -766,7 +779,8 @@ int32_t monitorInit() { } taosHashSetFreeFp(monitorCounterHash, destroyMonitorClient); - monitorSlowLogHash = (SHashObj*)taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); + monitorSlowLogHash = + (SHashObj*)taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); if (monitorSlowLogHash == NULL) { tscError("failed to create monitorSlowLogHash"); terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -781,7 +795,7 @@ int32_t monitorInit() { return -1; } - if (getSlowLogTmpDir(tmpSlowLogPath, sizeof(tmpSlowLogPath)) < 0){ + if (getSlowLogTmpDir(tmpSlowLogPath, sizeof(tmpSlowLogPath)) < 0) { terrno = TSDB_CODE_TSC_INTERNAL_ERROR; return -1; } @@ -798,14 +812,15 @@ int32_t monitorInit() { return -1; } - monitorQueue = taosOpenQueue(); - if(monitorQueue == NULL){ + code = taosOpenQueue(&monitorQueue); + if (code) { + terrno = code; tscError("open queue error since %s", terrstr()); return -1; } taosInitRWLatch(&monitorLock); - if (tscMonitortInit() != 0){ + if (tscMonitortInit() != 0) { return -1; } return 0; @@ -828,21 +843,26 @@ void monitorClose() { taosWUnLockLatch(&monitorLock); } -int32_t monitorPutData2MonitorQueue(MonitorSlowLogData data){ +int32_t monitorPutData2MonitorQueue(MonitorSlowLogData data) { + int32_t code; + MonitorSlowLogData* slowLogData; + if (atomic_load_32(&slowLogFlag) == -2) { tscError("[monitor] slow log thread is exiting"); return -1; } - MonitorSlowLogData* slowLogData = taosAllocateQitem(sizeof(MonitorSlowLogData), DEF_QITEM, 0); - if (slowLogData == NULL) { + + code = taosAllocateQitem(sizeof(MonitorSlowLogData), DEF_QITEM, 0, (void**)&slowLogData); + if (code) { tscError("[monitor] failed to allocate slow log data"); - return -1; + return terrno = code; } *slowLogData = data; - tscDebug("[monitor] write slow log to queue, clusterId:%"PRIx64 " type:%s, data:%s", slowLogData->clusterId, queueTypeStr[slowLogData->type], slowLogData->data); - if (taosWriteQitem(monitorQueue, slowLogData) == 0){ + tscDebug("[monitor] write slow log to queue, clusterId:%" PRIx64 " type:%s, data:%s", slowLogData->clusterId, + queueTypeStr[slowLogData->type], slowLogData->data); + if (taosWriteQitem(monitorQueue, slowLogData) == 0) { tsem2_post(&monitorSem); - }else{ + } else { monitorFreeSlowLogData(slowLogData); taosFreeQitem(slowLogData); } diff --git a/source/client/src/clientTmq.c b/source/client/src/clientTmq.c index 3c6ef00bf4..1ea03e15a6 100644 --- a/source/client/src/clientTmq.c +++ b/source/client/src/clientTmq.c @@ -733,13 +733,17 @@ end: } static void generateTimedTask(int64_t refId, int32_t type) { - tmq_t* tmq = taosAcquireRef(tmqMgmt.rsetId, refId); + tmq_t* tmq; + int8_t* pTaskType; + int32_t code; + + tmq = taosAcquireRef(tmqMgmt.rsetId, refId); if (tmq == NULL) return; - int8_t* pTaskType = taosAllocateQitem(sizeof(int8_t), DEF_QITEM, 0); - if (pTaskType != NULL){ + code = taosAllocateQitem(sizeof(int8_t), DEF_QITEM, 0, (void**)&pTaskType); + if (code) { *pTaskType = type; - if (taosWriteQitem(tmq->delayedTask, pTaskType) == 0){ + if (taosWriteQitem(tmq->delayedTask, pTaskType) == 0) { tsem2_post(&tmq->rspSem); } } @@ -877,7 +881,7 @@ void tmqSendHbReq(void* param, void* tmrId) { OVER: tDestroySMqHbReq(&req); - if(tmrId != NULL){ + if (tmrId != NULL) { taosTmrReset(tmqSendHbReq, DEFAULT_HEARTBEAT_INTERVAL, param, tmqMgmt.timer, &tmq->hbLiveTimer); } taosReleaseRef(tmqMgmt.rsetId, refId); @@ -890,7 +894,12 @@ static void defaultCommitCbFn(tmq_t* pTmq, int32_t code, void* param) { } int32_t tmqHandleAllDelayedTask(tmq_t* pTmq) { - STaosQall* qall = taosAllocateQall(); + STaosQall* qall; + int32_t code; + + code = taosAllocateQall(&qall); + if (code) return code; + taosReadAllQitems(pTmq->delayedTask, qall); int32_t numOfItems = taosQallItemSize(qall); @@ -914,7 +923,8 @@ int32_t tmqHandleAllDelayedTask(tmq_t* pTmq) { asyncCommitAllOffsets(pTmq, pCallbackFn, pTmq->commitCbUserParam); tscDebug("consumer:0x%" PRIx64 " next commit to vnode(s) in %.2fs", pTmq->consumerId, pTmq->autoCommitInterval / 1000.0); - taosTmrReset(tmqAssignDelayedCommitTask, pTmq->autoCommitInterval, (void*)(pTmq->refId), tmqMgmt.timer, &pTmq->commitTimer); + taosTmrReset(tmqAssignDelayedCommitTask, pTmq->autoCommitInterval, (void*)(pTmq->refId), tmqMgmt.timer, + &pTmq->commitTimer); } else { tscError("consumer:0x%" PRIx64 " invalid task type:%d", pTmq->consumerId, *pTaskType); } @@ -977,14 +987,14 @@ void tmqClearUnhandleMsg(tmq_t* tmq) { } int32_t tmqSubscribeCb(void* param, SDataBuf* pMsg, int32_t code) { - if(param == NULL) { + if (param == NULL) { return code; } SMqSubscribeCbParam* pParam = (SMqSubscribeCbParam*)param; pParam->rspErr = code; - if(pMsg){ + if (pMsg) { taosMemoryFree(pMsg->pEpSet); } tsem_post(&pParam->rspSem); @@ -1057,13 +1067,13 @@ void tmqFreeImpl(void* handle) { taosArrayDestroyEx(tmq->clientTopics, freeClientVgImpl); taos_close_internal(tmq->pTscObj); - if(tmq->commitTimer) { + if (tmq->commitTimer) { taosTmrStopA(&tmq->commitTimer); } - if(tmq->epTimer) { + if (tmq->epTimer) { taosTmrStopA(&tmq->epTimer); } - if(tmq->hbLiveTimer) { + if (tmq->hbLiveTimer) { taosTmrStopA(&tmq->hbLiveTimer); } taosMemoryFree(tmq); @@ -1101,6 +1111,8 @@ void tmqMgmtClose(void) { if (errstr != NULL) snprintf(errstr, errstrLen, MSG); tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) { + int32_t code; + if (conf == NULL) { SET_ERROR_MSG_TMQ("configure is null") return NULL; @@ -1124,12 +1136,31 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) { const char* pass = conf->pass == NULL ? TSDB_DEFAULT_PASS : conf->pass; pTmq->clientTopics = taosArrayInit(0, sizeof(SMqClientTopic)); - pTmq->mqueue = taosOpenQueue(); - pTmq->delayedTask = taosOpenQueue(); - pTmq->qall = taosAllocateQall(); + code = taosOpenQueue(&pTmq->mqueue); + if (code) { + terrno = code; + tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, terrstr(), pTmq->groupId); + SET_ERROR_MSG_TMQ("open queue failed") + goto _failed; + } - if (pTmq->clientTopics == NULL || pTmq->mqueue == NULL || pTmq->qall == NULL || pTmq->delayedTask == NULL || - conf->groupId[0] == 0) { + code = taosOpenQueue(&pTmq->delayedTask); + if (code) { + terrno = code; + tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, terrstr(), pTmq->groupId); + SET_ERROR_MSG_TMQ("open delayed task queue failed") + goto _failed; + } + + code = taosAllocateQall(&pTmq->qall); + if (code) { + terrno = code; + tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, terrstr(), pTmq->groupId); + SET_ERROR_MSG_TMQ("allocate qall failed") + goto _failed; + } + + if (conf->groupId[0] == 0) { terrno = TSDB_CODE_OUT_OF_MEMORY; tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, terrstr(), pTmq->groupId); SET_ERROR_MSG_TMQ("malloc tmq element failed or group is empty") @@ -1315,7 +1346,8 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) { // init ep timer tmq->epTimer = taosTmrStart(tmqAssignAskEpTask, DEFAULT_ASKEP_INTERVAL, (void*)(tmq->refId), tmqMgmt.timer); // init auto commit timer - tmq->commitTimer = taosTmrStart(tmqAssignDelayedCommitTask, tmq->autoCommitInterval, (void*)(tmq->refId), tmqMgmt.timer); + tmq->commitTimer = + taosTmrStart(tmqAssignDelayedCommitTask, tmq->autoCommitInterval, (void*)(tmq->refId), tmqMgmt.timer); FAIL: taosArrayDestroyP(req.topicNames, taosMemoryFree); @@ -1372,20 +1404,20 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) { if (pParam == NULL || pMsg == NULL) { goto FAIL; } - int64_t refId = pParam->refId; - int32_t vgId = pParam->vgId; - uint64_t requestId = pParam->requestId; + int64_t refId = pParam->refId; + int32_t vgId = pParam->vgId; + uint64_t requestId = pParam->requestId; tmq = taosAcquireRef(tmqMgmt.rsetId, refId); if (tmq == NULL) { code = TSDB_CODE_TMQ_CONSUMER_CLOSED; goto FAIL; } - SMqPollRspWrapper* pRspWrapper = taosAllocateQitem(sizeof(SMqPollRspWrapper), DEF_QITEM, 0); - if (pRspWrapper == NULL) { + SMqPollRspWrapper* pRspWrapper; + code = taosAllocateQitem(sizeof(SMqPollRspWrapper), DEF_QITEM, 0, (void**)&pRspWrapper); + if (code) { tscWarn("consumer:0x%" PRIx64 " msg discard from vgId:%d, since out of memory", tmq->consumerId, vgId); taosReleaseRef(tmqMgmt.rsetId, refId); - code = TSDB_CODE_OUT_OF_MEMORY; goto FAIL; } @@ -2575,7 +2607,7 @@ end: } int32_t askEpCb(void* param, SDataBuf* pMsg, int32_t code) { - if(param == NULL) return code; + if (param == NULL) return code; SMqAskEpCbParam* pParam = (SMqAskEpCbParam*)param; tmq_t* tmq = taosAcquireRef(tmqMgmt.rsetId, pParam->refId); if (tmq == NULL) { @@ -2600,9 +2632,9 @@ int32_t askEpCb(void* param, SDataBuf* pMsg, int32_t code) { doUpdateLocalEp(tmq, head->epoch, &rsp); tDeleteSMqAskEpRsp(&rsp); } else { - SMqAskEpRspWrapper* pWrapper = taosAllocateQitem(sizeof(SMqAskEpRspWrapper), DEF_QITEM, 0); - if (pWrapper == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + SMqAskEpRspWrapper* pWrapper; + code = taosAllocateQitem(sizeof(SMqAskEpRspWrapper), DEF_QITEM, 0, (void**)&pWrapper); + if (code) { goto END; } @@ -2620,13 +2652,13 @@ END: FAIL: if (pParam->sync) { SAskEpInfo* pInfo = pParam->pParam; - if(pInfo) { + if (pInfo) { pInfo->code = code; tsem_post(&pInfo->sem); } } - if(pMsg){ + if (pMsg) { taosMemoryFree(pMsg->pEpSet); taosMemoryFree(pMsg->pData); } @@ -2636,11 +2668,11 @@ FAIL: int32_t syncAskEp(tmq_t* pTmq) { SAskEpInfo* pInfo = taosMemoryMalloc(sizeof(SAskEpInfo)); - if(pInfo == NULL) return TSDB_CODE_OUT_OF_MEMORY; + if (pInfo == NULL) return TSDB_CODE_OUT_OF_MEMORY; tsem_init(&pInfo->sem, 0, 0); int32_t code = askEp(pTmq, pInfo, true, false); - if(code == 0){ + if (code == 0) { tsem_wait(&pInfo->sem); code = pInfo->code; } @@ -2778,7 +2810,7 @@ SReqResultInfo* tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4) { } static int32_t tmqGetWalInfoCb(void* param, SDataBuf* pMsg, int32_t code) { - if(param == NULL) { + if (param == NULL) { return code; } SMqVgWalInfoParam* pParam = param; @@ -2812,7 +2844,7 @@ static int32_t tmqGetWalInfoCb(void* param, SDataBuf* pMsg, int32_t code) { tsem_post(&pCommon->rsp); } - if(pMsg){ + if (pMsg) { taosMemoryFree(pMsg->pData); taosMemoryFree(pMsg->pEpSet); } @@ -3248,7 +3280,7 @@ static int32_t tmqSeekCb(void* param, SDataBuf* pMsg, int32_t code) { taosMemoryFree(pMsg->pData); taosMemoryFree(pMsg->pEpSet); } - if(param == NULL) { + if (param == NULL) { return code; } SMqSeekParam* pParam = param; diff --git a/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c b/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c index e5c32f9a43..f28de4695c 100644 --- a/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c +++ b/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c @@ -153,6 +153,8 @@ int32_t mmPutMsgToFetchQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) { } int32_t mmPutMsgToQueue(SMnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) { + int32_t code; + SSingleWorker *pWorker = NULL; switch (qtype) { case WRITE_QUEUE: @@ -181,13 +183,15 @@ int32_t mmPutMsgToQueue(SMnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) { } if (pWorker == NULL) return -1; - SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen); - if (pMsg == NULL) return -1; + SRpcMsg *pMsg; + code = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen, (void **)&pMsg); + if (code) return code; memcpy(pMsg, pRpc, sizeof(SRpcMsg)); pRpc->pCont = NULL; - dTrace("msg:%p, is created and will put into %s queue, type:%s len:%d", pMsg, pWorker->name, TMSG_INFO(pRpc->msgType), pRpc->contLen); - int32_t code = mmPutMsgToWorker(pMgmt, pWorker, pMsg); + dTrace("msg:%p, is created and will put into %s queue, type:%s len:%d", pMsg, pWorker->name, TMSG_INFO(pRpc->msgType), + pRpc->contLen); + code = mmPutMsgToWorker(pMgmt, pWorker, pMsg); if (code != 0) { dTrace("msg:%p, is freed", pMsg); rpcFreeCont(pMsg->pCont); diff --git a/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c b/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c index 5c635ff5ea..b443cbc351 100644 --- a/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c +++ b/source/dnode/mgmt/mgmt_qnode/src/qmWorker.c @@ -58,8 +58,11 @@ int32_t qmPutNodeMsgToFetchQueue(SQnodeMgmt *pMgmt, SRpcMsg *pMsg) { } int32_t qmPutRpcMsgToQueue(SQnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) { - SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen); - if (pMsg == NULL) return -1; + int32_t code; + SRpcMsg *pMsg; + + code = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen, (void **)&pMsg); + if (code) return code; memcpy(pMsg, pRpc, sizeof(SRpcMsg)); pRpc->pCont = NULL; diff --git a/source/dnode/mgmt/mgmt_snode/src/smWorker.c b/source/dnode/mgmt/mgmt_snode/src/smWorker.c index 1c57685414..e356380039 100644 --- a/source/dnode/mgmt/mgmt_snode/src/smWorker.c +++ b/source/dnode/mgmt/mgmt_snode/src/smWorker.c @@ -126,8 +126,11 @@ void smStopWorker(SSnodeMgmt *pMgmt) { } int32_t smPutMsgToQueue(SSnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) { - SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen); - if (pMsg == NULL) { + int32_t code; + SRpcMsg *pMsg; + + code = taosAllocateQitem(sizeof(SRpcMsg), RPC_QITEM, pRpc->contLen, (void **)&pMsg); + if (code) { rpcFreeCont(pRpc->pCont); pRpc->pCont = NULL; return -1; diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c b/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c index 0415340be9..b7d35030b8 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmWorker.c @@ -311,6 +311,7 @@ int32_t vmPutMsgToMgmtQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { } int32_t vmPutRpcMsgToQueue(SVnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) { + int32_t code; if (pRpc->contLen < sizeof(SMsgHead)) { dError("invalid rpc msg with no msg head at pCont. pRpc:%p, type:%s, len:%d", pRpc, TMSG_INFO(pRpc->msgType), pRpc->contLen); @@ -320,8 +321,9 @@ int32_t vmPutRpcMsgToQueue(SVnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) { } EQItype itype = APPLY_QUEUE == qtype ? DEF_QITEM : RPC_QITEM; - SRpcMsg *pMsg = taosAllocateQitem(sizeof(SRpcMsg), itype, pRpc->contLen); - if (pMsg == NULL) { + SRpcMsg *pMsg; + code = taosAllocateQitem(sizeof(SRpcMsg), itype, pRpc->contLen, (void **)&pMsg); + if (code) { rpcFreeCont(pRpc->pCont); pRpc->pCont = NULL; return -1; @@ -335,7 +337,7 @@ int32_t vmPutRpcMsgToQueue(SVnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) { memcpy(pMsg, pRpc, sizeof(SRpcMsg)); pRpc->pCont = NULL; - int32_t code = vmPutMsgToQueue(pMgmt, pMsg, qtype); + code = vmPutMsgToQueue(pMgmt, pMsg, qtype); if (code != 0) { dTrace("msg:%p, is freed", pMsg); rpcFreeCont(pMsg->pCont); diff --git a/source/dnode/mgmt/node_mgmt/src/dmTransport.c b/source/dnode/mgmt/node_mgmt/src/dmTransport.c index 99d641ff3f..bf35319fae 100644 --- a/source/dnode/mgmt/node_mgmt/src/dmTransport.c +++ b/source/dnode/mgmt/node_mgmt/src/dmTransport.c @@ -210,8 +210,8 @@ static void dmProcessRpcMsg(SDnode *pDnode, SRpcMsg *pRpc, SEpSet *pEpSet) { pRpc->info.wrapper = pWrapper; EQItype itype = IsReq(pRpc) ? RPC_QITEM : DEF_QITEM; // rsp msg is not restricted by tsRpcQueueMemoryUsed - pMsg = taosAllocateQitem(sizeof(SRpcMsg), itype, pRpc->contLen); - if (pMsg == NULL) goto _OVER; + code = taosAllocateQitem(sizeof(SRpcMsg), itype, pRpc->contLen, (void **)&pMsg); + if (code) goto _OVER; memcpy(pMsg, pRpc, sizeof(SRpcMsg)); dGTrace("msg:%p, is created, type:%s handle:%p len:%d", pMsg, TMSG_INFO(pRpc->msgType), pMsg->info.handle, diff --git a/source/dnode/vnode/src/sma/smaRollup.c b/source/dnode/vnode/src/sma/smaRollup.c index a48188430f..214d0300e1 100644 --- a/source/dnode/vnode/src/sma/smaRollup.c +++ b/source/dnode/vnode/src/sma/smaRollup.c @@ -61,7 +61,7 @@ struct SRSmaQTaskInfoItem { int32_t len; int8_t type; int64_t suid; - void * qTaskInfo; + void *qTaskInfo; }; static void tdRSmaQTaskInfoFree(qTaskInfo_t *taskHandle, int32_t vgId, int32_t level) { @@ -185,7 +185,7 @@ int32_t tdUpdateTbUidList(SSma *pSma, STbUidStore *pStore, bool isAdd) { void *pIter = NULL; while ((pIter = taosHashIterate(pStore->uidHash, pIter))) { tb_uid_t *pTbSuid = (tb_uid_t *)taosHashGetKey(pIter, NULL); - SArray * pTbUids = *(SArray **)pIter; + SArray *pTbUids = *(SArray **)pIter; if (tdUpdateTbUidListImpl(pSma, pTbSuid, pTbUids, isAdd) != TSDB_CODE_SUCCESS) { taosHashCancelIterate(pStore->uidHash, pIter); @@ -213,7 +213,7 @@ int32_t tdFetchTbUidList(SSma *pSma, STbUidStore **ppStore, tb_uid_t suid, tb_ui } SRSmaStat *pStat = (SRSmaStat *)SMA_ENV_STAT(pEnv); - SHashObj * infoHash = NULL; + SHashObj *infoHash = NULL; if (!pStat || !(infoHash = RSMA_INFO_HASH(pStat))) { terrno = TSDB_CODE_RSMA_INVALID_STAT; return TSDB_CODE_FAILED; @@ -264,11 +264,11 @@ static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat int8_t idx) { if ((param->qmsgLen > 0) && param->qmsg[idx]) { SRSmaInfoItem *pItem = &(pRSmaInfo->items[idx]); - SRetention * pRetention = SMA_RETENTION(pSma); - STsdbCfg * pTsdbCfg = SMA_TSDB_CFG(pSma); - SVnode * pVnode = pSma->pVnode; + SRetention *pRetention = SMA_RETENTION(pSma); + STsdbCfg *pTsdbCfg = SMA_TSDB_CFG(pSma); + SVnode *pVnode = pSma->pVnode; char taskInfDir[TSDB_FILENAME_LEN] = {0}; - void * pStreamState = NULL; + void *pStreamState = NULL; // set the backend of stream state tdRSmaQTaskInfoGetFullPath(pVnode, pRSmaInfo->suid, idx + 1, pVnode->pTfs, taskInfDir); @@ -362,6 +362,8 @@ static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat * @return int32_t */ int32_t tdRSmaProcessCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, const char *tbName) { + int32_t code; + if ((param->qmsgLen[0] == 0) && (param->qmsgLen[1] == 0)) { smaDebug("vgId:%d, no qmsg1/qmsg2 for rollup table %s %" PRIi64, SMA_VID(pSma), tbName, suid); return TSDB_CODE_SUCCESS; @@ -374,7 +376,7 @@ int32_t tdRSmaProcessCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con } #endif - SSmaEnv * pEnv = SMA_RSMA_ENV(pSma); + SSmaEnv *pEnv = SMA_RSMA_ENV(pSma); SRSmaStat *pStat = (SRSmaStat *)SMA_ENV_STAT(pEnv); SRSmaInfo *pRSmaInfo = NULL; @@ -401,8 +403,13 @@ int32_t tdRSmaProcessCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con pRSmaInfo->suid = suid; T_REF_INIT_VAL(pRSmaInfo, 1); - if (!(pRSmaInfo->queue = taosOpenQueue()) || !(pRSmaInfo->qall = taosAllocateQall()) || - tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, 0) < 0 || + code = taosOpenQueue(&pRSmaInfo->queue); + if (code) goto _err; + + code = taosAllocateQall(&pRSmaInfo->qall); + if (code) goto _err; + + if (tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, 0) < 0 || tdSetRSmaInfoItemParams(pSma, param, pStat, pRSmaInfo, 1) < 0) { goto _err; } @@ -673,8 +680,8 @@ static int32_t tdRSmaExecAndSubmitResult(SSma *pSma, qTaskInfo_t taskInfo, SRSma int32_t code = 0; int32_t lino = 0; SSDataBlock *output = NULL; - SArray * pResList = pItem->pResList; - STSchema * pTSchema = pInfo->pTSchema; + SArray *pResList = pItem->pResList; + STSchema *pTSchema = pInfo->pTSchema; int64_t suid = pInfo->suid; while (1) { @@ -733,7 +740,7 @@ static int32_t tdRSmaExecAndSubmitResult(SSma *pSma, qTaskInfo_t taskInfo, SRSma } } - STsdb * sinkTsdb = (pItem->level == TSDB_RETENTION_L1 ? pSma->pRSmaTsdb[0] : pSma->pRSmaTsdb[1]); + STsdb *sinkTsdb = (pItem->level == TSDB_RETENTION_L1 ? pSma->pRSmaTsdb[0] : pSma->pRSmaTsdb[1]); SSubmitReq2 *pReq = NULL; if (buildSubmitReqFromDataBlock(&pReq, output, pTSchema, output->info.id.groupId, SMA_VID(pSma), suid) < 0) { @@ -795,11 +802,13 @@ _exit: */ static int32_t tdExecuteRSmaImplAsync(SSma *pSma, int64_t version, const void *pMsg, int32_t len, int32_t inputType, SRSmaInfo *pInfo, tb_uid_t suid) { + int32_t code; int32_t size = RSMA_EXEC_MSG_HLEN + len; // header + payload - void * qItem = taosAllocateQitem(size, DEF_QITEM, 0); + void *qItem; - if (!qItem) { - return TSDB_CODE_FAILED; + code = taosAllocateQitem(size, DEF_QITEM, 0, (void **)&qItem); + if (code) { + return code; } void *pItem = qItem; @@ -874,7 +883,7 @@ static int32_t tdRsmaPrintSubmitReq(SSma *pSma, SSubmitReq *pReq) { static int32_t tdExecuteRSmaImpl(SSma *pSma, const void *pMsg, int32_t msgSize, int64_t version, int32_t inputType, SRSmaInfo *pInfo, ERsmaExecType type, int8_t level) { int32_t idx = level - 1; - void * qTaskInfo = RSMA_INFO_QTASK(pInfo, idx); + void *qTaskInfo = RSMA_INFO_QTASK(pInfo, idx); SRSmaInfoItem *pItem = RSMA_INFO_ITEM(pInfo, idx); if (!qTaskInfo) { @@ -914,7 +923,7 @@ static int32_t tdExecuteRSmaImpl(SSma *pSma, const void *pMsg, int32_t msgSize, static SRSmaInfo *tdAcquireRSmaInfoBySuid(SSma *pSma, int64_t suid) { int32_t code = 0; int32_t lino = 0; - SSmaEnv * pEnv = SMA_RSMA_ENV(pSma); + SSmaEnv *pEnv = SMA_RSMA_ENV(pSma); SRSmaStat *pStat = NULL; SRSmaInfo *pRSmaInfo = NULL; @@ -1069,8 +1078,8 @@ _err: static int32_t tdRSmaRestoreQTaskInfoInit(SSma *pSma, int64_t *nTables) { int32_t code = 0; int32_t lino = 0; - SVnode * pVnode = pSma->pVnode; - SArray * suidList = NULL; + SVnode *pVnode = pSma->pVnode; + SArray *suidList = NULL; STbUidStore uidStore = {0}; SMetaReader mr = {0}; tb_uid_t suid = 0; @@ -1198,7 +1207,7 @@ int32_t tdRSmaPersistExecImpl(SRSmaStat *pRSmaStat, SHashObj *pInfoHash) { int32_t code = 0; int32_t lino = 0; int32_t nTaskInfo = 0; - SSma * pSma = pRSmaStat->pSma; + SSma *pSma = pRSmaStat->pSma; SVnode *pVnode = pSma->pVnode; if (taosHashGetSize(pInfoHash) <= 0) { @@ -1231,7 +1240,7 @@ int32_t tdRSmaPersistExecImpl(SRSmaStat *pRSmaStat, SHashObj *pInfoHash) { do { int32_t nStreamFlushed = 0; int32_t nSleep = 0; - void * infoHash = NULL; + void *infoHash = NULL; while (true) { while ((infoHash = taosHashIterate(pInfoHash, infoHash))) { SRSmaInfo *pRSmaInfo = *(SRSmaInfo **)infoHash; @@ -1273,7 +1282,7 @@ _checkpoint: SStreamMeta *pMeta = NULL; int64_t checkpointId = taosGetTimestampNs(); bool checkpointBuilt = false; - void * infoHash = NULL; + void *infoHash = NULL; while ((infoHash = taosHashIterate(pInfoHash, infoHash))) { SRSmaInfo *pRSmaInfo = *(SRSmaInfo **)infoHash; if (RSMA_INFO_IS_DEL(pRSmaInfo)) { @@ -1346,10 +1355,10 @@ _exit: * @param tmrId */ static void tdRSmaFetchTrigger(void *param, void *tmrId) { - SRSmaRef * pRSmaRef = NULL; - SSma * pSma = NULL; - SRSmaStat * pStat = NULL; - SRSmaInfo * pRSmaInfo = NULL; + SRSmaRef *pRSmaRef = NULL; + SSma *pSma = NULL; + SRSmaStat *pStat = NULL; + SRSmaInfo *pRSmaInfo = NULL; SRSmaInfoItem *pItem = NULL; if (!(pRSmaRef = taosHashGet(smaMgmt.refHash, ¶m, POINTER_BYTES))) { @@ -1517,7 +1526,7 @@ _err: } static int32_t tdRSmaBatchExec(SSma *pSma, SRSmaInfo *pInfo, STaosQall *qall, SArray *pSubmitArr, ERsmaExecType type) { - void * msg = NULL; + void *msg = NULL; int8_t resume = 0; int32_t nSubmit = 0; int32_t nDelete = 0; @@ -1548,7 +1557,7 @@ static int32_t tdRSmaBatchExec(SSma *pSma, SRSmaInfo *pInfo, STaosQall *qall, SA _resume_delete: version = RSMA_EXEC_MSG_VER(msg); if ((terrno = tqExtractDelDataBlock(RSMA_EXEC_MSG_BODY(msg), RSMA_EXEC_MSG_LEN(msg), version, - &packData.pDataBlock, 1))) { + &packData.pDataBlock, 1))) { taosFreeQitem(msg); goto _err; } @@ -1621,11 +1630,11 @@ _err: int32_t tdRSmaProcessExecImpl(SSma *pSma, ERsmaExecType type) { int32_t code = 0; int32_t lino = 0; - SVnode * pVnode = pSma->pVnode; - SSmaEnv * pEnv = SMA_RSMA_ENV(pSma); + SVnode *pVnode = pSma->pVnode; + SSmaEnv *pEnv = SMA_RSMA_ENV(pSma); SRSmaStat *pRSmaStat = (SRSmaStat *)SMA_ENV_STAT(pEnv); - SHashObj * infoHash = NULL; - SArray * pSubmitArr = NULL; + SHashObj *infoHash = NULL; + SArray *pSubmitArr = NULL; bool isFetchAll = false; if (!pRSmaStat || !(infoHash = RSMA_INFO_HASH(pRSmaStat))) { diff --git a/source/dnode/vnode/src/tq/tqUtil.c b/source/dnode/vnode/src/tq/tqUtil.c index eb1da51b45..16c523a50e 100644 --- a/source/dnode/vnode/src/tq/tqUtil.c +++ b/source/dnode/vnode/src/tq/tqUtil.c @@ -164,7 +164,8 @@ static int32_t extractDataAndRspForNormalSubscribe(STQ* pTq, STqHandle* pHandle, taosWUnLockLatch(&pTq->lock); } - tOffsetCopy(&dataRsp.common.reqOffset, pOffset); // reqOffset represents the current date offset, may be changed if wal not exists + tOffsetCopy(&dataRsp.common.reqOffset, + pOffset); // reqOffset represents the current date offset, may be changed if wal not exists code = tqSendDataRsp(pHandle, pMsg, pRequest, &dataRsp, TMQ_MSG_TYPE__POLL_DATA_RSP, vgId); end : { @@ -178,25 +179,25 @@ end : { } } -#define PROCESS_EXCLUDED_MSG(TYPE, DECODE_FUNC, DELETE_FUNC) \ - SDecoder decoder = {0};\ - TYPE req = {0}; \ - void* data = POINTER_SHIFT(pHead->body, sizeof(SMsgHead)); \ - int32_t len = pHead->bodyLen - sizeof(SMsgHead); \ - tDecoderInit(&decoder, data, len); \ - if (DECODE_FUNC(&decoder, &req) == 0 && (req.source & TD_REQ_FROM_TAOX) != 0) { \ - tqDebug("tmq poll: consumer:0x%" PRIx64 " (epoch %d) iter log, jump meta for, vgId:%d offset %" PRId64 " msgType %d", \ - pRequest->consumerId, pRequest->epoch, vgId, fetchVer, pHead->msgType); \ - fetchVer++; \ - DELETE_FUNC(&req); \ - tDecoderClear(&decoder); \ - continue; \ - } \ - DELETE_FUNC(&req); \ +#define PROCESS_EXCLUDED_MSG(TYPE, DECODE_FUNC, DELETE_FUNC) \ + SDecoder decoder = {0}; \ + TYPE req = {0}; \ + void* data = POINTER_SHIFT(pHead->body, sizeof(SMsgHead)); \ + int32_t len = pHead->bodyLen - sizeof(SMsgHead); \ + tDecoderInit(&decoder, data, len); \ + if (DECODE_FUNC(&decoder, &req) == 0 && (req.source & TD_REQ_FROM_TAOX) != 0) { \ + tqDebug("tmq poll: consumer:0x%" PRIx64 " (epoch %d) iter log, jump meta for, vgId:%d offset %" PRId64 \ + " msgType %d", \ + pRequest->consumerId, pRequest->epoch, vgId, fetchVer, pHead->msgType); \ + fetchVer++; \ + DELETE_FUNC(&req); \ + tDecoderClear(&decoder); \ + continue; \ + } \ + DELETE_FUNC(&req); \ tDecoderClear(&decoder); -static void tDeleteCommon(void* parm) { -} +static void tDeleteCommon(void* parm) {} static int32_t extractDataAndRspForDbStbSubscribe(STQ* pTq, STqHandle* pHandle, const SMqPollReq* pRequest, SRpcMsg* pMsg, STqOffsetVal* offset) { @@ -313,9 +314,9 @@ static int32_t extractDataAndRspForDbStbSubscribe(STQ* pTq, STqHandle* pHandle, tqError("tmq extract meta from log, tEncodeMqMetaRsp error"); continue; } - int32_t tLen = sizeof(SMqRspHead) + len; - void* tBuf = taosMemoryCalloc(1, tLen); - void* metaBuff = POINTER_SHIFT(tBuf, sizeof(SMqRspHead)); + int32_t tLen = sizeof(SMqRspHead) + len; + void* tBuf = taosMemoryCalloc(1, tLen); + void* metaBuff = POINTER_SHIFT(tBuf, sizeof(SMqRspHead)); SEncoder encoder = {0}; tEncoderInit(&encoder, metaBuff, len); code = tEncodeMqMetaRsp(&encoder, &tmpMetaRsp); @@ -374,13 +375,13 @@ end: } int32_t tqExtractDataForMq(STQ* pTq, STqHandle* pHandle, const SMqPollReq* pRequest, SRpcMsg* pMsg) { - int32_t code = 0; + int32_t code = 0; STqOffsetVal reqOffset = {0}; tOffsetCopy(&reqOffset, &pRequest->reqOffset); // reset the offset if needed if (IS_OFFSET_RESET_TYPE(pRequest->reqOffset.type)) { - bool blockReturned = false; + bool blockReturned = false; code = extractResetOffsetVal(&reqOffset, pTq, pHandle, pRequest, pMsg, &blockReturned); if (code != 0) { goto END; @@ -392,7 +393,7 @@ int32_t tqExtractDataForMq(STQ* pTq, STqHandle* pHandle, const SMqPollReq* pRequ } } else if (reqOffset.type == 0) { // use the consumer specified offset uError("req offset type is 0"); - code = TSDB_CODE_TMQ_INVALID_MSG; + code = TSDB_CODE_TMQ_INVALID_MSG; goto END; } @@ -416,8 +417,8 @@ static void initMqRspHead(SMqRspHead* pMsgHead, int32_t type, int32_t epoch, int pMsgHead->walever = ever; } -int32_t tqSendBatchMetaPollRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPollReq* pReq, const SMqBatchMetaRsp* pRsp, - int32_t vgId) { +int32_t tqSendBatchMetaPollRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SMqPollReq* pReq, + const SMqBatchMetaRsp* pRsp, int32_t vgId) { int32_t len = 0; int32_t code = 0; tEncodeSize(tEncodeMqBatchMetaRsp, pRsp, len, code); @@ -444,8 +445,8 @@ int32_t tqSendBatchMetaPollRsp(STqHandle* pHandle, const SRpcMsg* pMsg, const SM SRpcMsg resp = {.info = pMsg->info, .pCont = buf, .contLen = tlen, .code = 0}; tmsgSendRsp(&resp); - tqDebug("vgId:%d, from consumer:0x%" PRIx64 " (epoch %d) send rsp, res msg type: batch meta, size:%ld offset type:%d", vgId, - pReq->consumerId, pReq->epoch, taosArrayGetSize(pRsp->batchMetaReq), pRsp->rspOffset.type); + tqDebug("vgId:%d, from consumer:0x%" PRIx64 " (epoch %d) send rsp, res msg type: batch meta, size:%ld offset type:%d", + vgId, pReq->consumerId, pReq->epoch, taosArrayGetSize(pRsp->batchMetaReq), pRsp->rspOffset.type); return 0; } @@ -527,6 +528,7 @@ int32_t tqDoSendDataRsp(const SRpcHandleInfo* pRpcHandleInfo, const void* pRsp, } int32_t tqExtractDelDataBlock(const void* pData, int32_t len, int64_t ver, void** pRefBlock, int32_t type) { + int32_t code; SDecoder* pCoder = &(SDecoder){0}; SDeleteRes* pRes = &(SDeleteRes){0}; @@ -570,11 +572,11 @@ int32_t tqExtractDelDataBlock(const void* pData, int32_t len, int64_t ver, void* taosArrayDestroy(pRes->uidList); if (type == 0) { - *pRefBlock = taosAllocateQitem(sizeof(SStreamRefDataBlock), DEF_QITEM, 0); - if (*pRefBlock == NULL) { + code = taosAllocateQitem(sizeof(SStreamRefDataBlock), DEF_QITEM, 0, pRefBlock); + if (code) { blockDataCleanup(pDelBlock); taosMemoryFree(pDelBlock); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } ((SStreamRefDataBlock*)(*pRefBlock))->type = STREAM_INPUT__REF_DATA_BLOCK; @@ -614,7 +616,7 @@ int32_t tqGetStreamExecInfo(SVnode* pVnode, int64_t streamId, int64_t* pDelay, b continue; } - STaskId id = {.streamId = pId->streamId, .taskId = pId->taskId}; + STaskId id = {.streamId = pId->streamId, .taskId = pId->taskId}; SStreamTask** ppTask = taosHashGet(pMeta->pTasksMap, &id, sizeof(id)); if (ppTask == NULL) { tqError("vgId:%d failed to acquire task:0x%x in retrieving progress", pMeta->vgId, pId->taskId); diff --git a/source/libs/executor/src/dataDeleter.c b/source/libs/executor/src/dataDeleter.c index 15288c4406..aa377cd922 100644 --- a/source/libs/executor/src/dataDeleter.c +++ b/source/libs/executor/src/dataDeleter.c @@ -130,9 +130,11 @@ static int32_t getStatus(SDataDeleterHandle* pDeleter) { static int32_t putDataBlock(SDataSinkHandle* pHandle, const SInputData* pInput, bool* pContinue) { SDataDeleterHandle* pDeleter = (SDataDeleterHandle*)pHandle; - SDataDeleterBuf* pBuf = taosAllocateQitem(sizeof(SDataDeleterBuf), DEF_QITEM, 0); - if (NULL == pBuf) { - return TSDB_CODE_OUT_OF_MEMORY; + SDataDeleterBuf* pBuf; + + int32_t code = taosAllocateQitem(sizeof(SDataDeleterBuf), DEF_QITEM, 0, (void**)&pBuf); + if (code) { + return code; } if (!allocBuf(pDeleter, pInput, pBuf)) { @@ -227,7 +229,7 @@ static int32_t destroyDataSinker(SDataSinkHandle* pHandle) { } taosCloseQueue(pDeleter->pDataBlocks); taosThreadMutexDestroy(&pDeleter->mutex); - + taosMemoryFree(pDeleter->pManager); return TSDB_CODE_SUCCESS; } @@ -270,12 +272,11 @@ int32_t createDataDeleter(SDataSinkManager* pManager, const SDataSinkNode* pData deleter->pParam = pParam; deleter->status = DS_BUF_EMPTY; deleter->queryEnd = false; - deleter->pDataBlocks = taosOpenQueue(); - taosThreadMutexInit(&deleter->mutex, NULL); - if (NULL == deleter->pDataBlocks) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = taosOpenQueue(&deleter->pDataBlocks); + if (code) { goto _end; } + taosThreadMutexInit(&deleter->mutex, NULL); *pHandle = deleter; return code; diff --git a/source/libs/executor/src/dataDispatcher.c b/source/libs/executor/src/dataDispatcher.c index 297c87ab40..3981cedd3f 100644 --- a/source/libs/executor/src/dataDispatcher.c +++ b/source/libs/executor/src/dataDispatcher.c @@ -104,7 +104,8 @@ static void toDataCacheEntry(SDataDispatchHandle* pHandle, const SInputData* pIn } int32_t dataLen = blockEncode(pInput->pData, pHandle->pCompressBuf, numOfCols); - int32_t len = tsCompressString(pHandle->pCompressBuf, dataLen, 1, pEntry->data, pBuf->allocSize, ONE_STAGE_COMP, NULL, 0); + int32_t len = + tsCompressString(pHandle->pCompressBuf, dataLen, 1, pEntry->data, pBuf->allocSize, ONE_STAGE_COMP, NULL, 0); if (len < dataLen) { pEntry->compressed = 1; pEntry->dataLen = len; @@ -168,9 +169,11 @@ static int32_t getStatus(SDataDispatchHandle* pDispatcher) { static int32_t putDataBlock(SDataSinkHandle* pHandle, const SInputData* pInput, bool* pContinue) { int32_t code = 0; SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle; - SDataDispatchBuf* pBuf = taosAllocateQitem(sizeof(SDataDispatchBuf), DEF_QITEM, 0); - if (NULL == pBuf) { - return TSDB_CODE_OUT_OF_MEMORY; + SDataDispatchBuf* pBuf; + + code = taosAllocateQitem(sizeof(SDataDispatchBuf), DEF_QITEM, 0, (void**)&pBuf); + if (code) { + return code; } if (!allocBuf(pDispatcher, pInput, pBuf)) { @@ -228,7 +231,6 @@ static void getDataLength(SDataSinkHandle* pHandle, int64_t* pLen, int64_t* pRow ((SDataCacheEntry*)(pDispatcher->nextOutput.pData))->numOfRows); } - static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) { SDataDispatchHandle* pDispatcher = (SDataDispatchHandle*)pHandle; if (NULL == pDispatcher->nextOutput.pData) { @@ -291,6 +293,8 @@ static int32_t getCacheSize(struct SDataSinkHandle* pHandle, uint64_t* size) { } int32_t createDataDispatcher(SDataSinkManager* pManager, const SDataSinkNode* pDataSink, DataSinkHandle* pHandle) { + int32_t code; + SDataDispatchHandle* dispatcher = taosMemoryCalloc(1, sizeof(SDataDispatchHandle)); if (NULL == dispatcher) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -309,7 +313,11 @@ int32_t createDataDispatcher(SDataSinkManager* pManager, const SDataSinkNode* pD dispatcher->pSchema = pDataSink->pInputDataBlockDesc; dispatcher->status = DS_BUF_EMPTY; dispatcher->queryEnd = false; - dispatcher->pDataBlocks = taosOpenQueue(); + code = taosOpenQueue(&dispatcher->pDataBlocks); + if (code) { + terrno = code; + goto _return; + } taosThreadMutexInit(&dispatcher->mutex, NULL); if (NULL == dispatcher->pDataBlocks) { diff --git a/source/libs/qcom/src/queryUtil.c b/source/libs/qcom/src/queryUtil.c index 9ff6fc3e49..8502856754 100644 --- a/source/libs/qcom/src/queryUtil.c +++ b/source/libs/qcom/src/queryUtil.c @@ -158,7 +158,9 @@ int32_t cleanupTaskQueue() { } int32_t taosAsyncExec(__async_exec_fn_t execFn, void* execParam, int32_t* code) { - SSchedMsg* pSchedMsg = taosAllocateQitem(sizeof(SSchedMsg), DEF_QITEM, 0); + SSchedMsg* pSchedMsg; + int32_t rc = taosAllocateQitem(sizeof(SSchedMsg), DEF_QITEM, 0, (void **)&pSchedMsg); + if (rc) return rc; pSchedMsg->fp = NULL; pSchedMsg->ahandle = execFn; pSchedMsg->thandle = execParam; diff --git a/source/libs/stream/src/streamCheckpoint.c b/source/libs/stream/src/streamCheckpoint.c index 990e7fb987..023783a2ae 100644 --- a/source/libs/stream/src/streamCheckpoint.c +++ b/source/libs/stream/src/streamCheckpoint.c @@ -31,9 +31,11 @@ static void checkpointTriggerMonitorFn(void* param, void* tmrId); SStreamDataBlock* createChkptTriggerBlock(SStreamTask* pTask, int32_t checkpointType, int64_t checkpointId, int32_t transId, int32_t srcTaskId) { - SStreamDataBlock* pChkpoint = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, sizeof(SSDataBlock)); - if (pChkpoint == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + SStreamDataBlock* pChkpoint; + + int32_t code = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, sizeof(SSDataBlock), (void**)&pChkpoint); + if (code) { + terrno = code; return NULL; } @@ -425,7 +427,7 @@ int32_t streamTaskProcessCheckpointReadyRsp(SStreamTask* pTask, int32_t upstream } void streamTaskClearCheckInfo(SStreamTask* pTask, bool clearChkpReadyMsg) { - pTask->chkInfo.startTs = 0; // clear the recorded start time + pTask->chkInfo.startTs = 0; // clear the recorded start time streamTaskOpenAllUpstreamInput(pTask); // open inputQ for all upstream tasks taosThreadMutexLock(&pTask->chkInfo.pActiveInfo->lock); diff --git a/source/libs/stream/src/streamData.c b/source/libs/stream/src/streamData.c index fae90f4db8..2994287aff 100644 --- a/source/libs/stream/src/streamData.c +++ b/source/libs/stream/src/streamData.c @@ -16,8 +16,11 @@ #include "streamInt.h" SStreamDataBlock* createStreamBlockFromDispatchMsg(const SStreamDispatchReq* pReq, int32_t blockType, int32_t srcVg) { - SStreamDataBlock* pData = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, pReq->totalLen); - if (pData == NULL) { + SStreamDataBlock* pData; + + int32_t code = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, pReq->totalLen, (void**)&pData); + if (code) { + terrno = code; return NULL; } @@ -34,7 +37,7 @@ SStreamDataBlock* createStreamBlockFromDispatchMsg(const SStreamDispatchReq* pRe ASSERT((pReq->blockNum == taosArrayGetSize(pReq->data)) && (pReq->blockNum == taosArrayGetSize(pReq->dataLen))); for (int32_t i = 0; i < blockNum; i++) { - SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*) taosArrayGetP(pReq->data, i); + SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*)taosArrayGetP(pReq->data, i); SSDataBlock* pDataBlock = taosArrayGet(pArray, i); int32_t compLen = *(int32_t*)pRetrieve->data; @@ -42,7 +45,7 @@ SStreamDataBlock* createStreamBlockFromDispatchMsg(const SStreamDispatchReq* pRe char* pInput = pRetrieve->data + PAYLOAD_PREFIX_LEN; if (pRetrieve->compressed && compLen < fullLen) { - char* p = taosMemoryMalloc(fullLen); + char* p = taosMemoryMalloc(fullLen); int32_t len = tsDecompressString(pInput, compLen, 1, p, fullLen, ONE_STAGE_COMP, NULL, 0); ASSERT(len == fullLen); pInput = p; @@ -69,10 +72,14 @@ SStreamDataBlock* createStreamBlockFromDispatchMsg(const SStreamDispatchReq* pRe return pData; } -SStreamDataBlock* createStreamBlockFromResults(SStreamQueueItem* pItem, SStreamTask* pTask, int64_t resultSize, SArray* pRes) { - SStreamDataBlock* pStreamBlocks = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, resultSize); - if (pStreamBlocks == NULL) { +SStreamDataBlock* createStreamBlockFromResults(SStreamQueueItem* pItem, SStreamTask* pTask, int64_t resultSize, + SArray* pRes) { + SStreamDataBlock* pStreamBlocks; + + int32_t code = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, resultSize, (void**)&pStreamBlocks); + if (code) { taosArrayClearEx(pRes, (FDelete)blockDataFreeRes); + terrno = code; return NULL; } @@ -132,8 +139,10 @@ int32_t streamRetrieveReqToData(const SStreamRetrieveReq* pReq, SStreamDataBlock } SStreamDataSubmit* streamDataSubmitNew(SPackedData* pData, int32_t type) { - SStreamDataSubmit* pDataSubmit = (SStreamDataSubmit*)taosAllocateQitem(sizeof(SStreamDataSubmit), DEF_QITEM, pData->msgLen); - if (pDataSubmit == NULL) { + SStreamDataSubmit* pDataSubmit; + int32_t code = taosAllocateQitem(sizeof(SStreamDataSubmit), DEF_QITEM, pData->msgLen, (void**)&pDataSubmit); + if (code) { + terrno = code; return NULL; } @@ -151,8 +160,11 @@ void streamDataSubmitDestroy(SStreamDataSubmit* pDataSubmit) { } SStreamMergedSubmit* streamMergedSubmitNew() { - SStreamMergedSubmit* pMerged = (SStreamMergedSubmit*)taosAllocateQitem(sizeof(SStreamMergedSubmit), DEF_QITEM, 0); - if (pMerged == NULL) { + SStreamMergedSubmit* pMerged; + + int32_t code = taosAllocateQitem(sizeof(SStreamMergedSubmit), DEF_QITEM, 0, (void**)&pMerged); + if (code) { + terrno = code; return NULL; } @@ -178,7 +190,7 @@ int32_t streamMergeSubmit(SStreamMergedSubmit* pMerged, SStreamDataSubmit* pSubm // todo handle memory error SStreamQueueItem* streamQueueMergeQueueItem(SStreamQueueItem* dst, SStreamQueueItem* pElem) { terrno = 0; - + if (dst->type == STREAM_INPUT__DATA_BLOCK && pElem->type == STREAM_INPUT__DATA_BLOCK) { SStreamDataBlock* pBlock = (SStreamDataBlock*)dst; SStreamDataBlock* pBlockSrc = (SStreamDataBlock*)pElem; @@ -212,7 +224,8 @@ SStreamQueueItem* streamQueueMergeQueueItem(SStreamQueueItem* dst, SStreamQueueI taosFreeQitem(pElem); return (SStreamQueueItem*)pMerged; } else { - stDebug("block type:%s not merged with existed blocks list, type:%d", streamQueueItemGetTypeStr(pElem->type), dst->type); + stDebug("block type:%s not merged with existed blocks list, type:%d", streamQueueItemGetTypeStr(pElem->type), + dst->type); return NULL; } } @@ -245,8 +258,9 @@ void streamFreeQitem(SStreamQueueItem* data) { SStreamRefDataBlock* pRefBlock = (SStreamRefDataBlock*)data; blockDataDestroy(pRefBlock->pBlock); taosFreeQitem(pRefBlock); - } else if (type == STREAM_INPUT__CHECKPOINT || type == STREAM_INPUT__CHECKPOINT_TRIGGER || type == STREAM_INPUT__TRANS_STATE) { - SStreamDataBlock* pBlock = (SStreamDataBlock*) data; + } else if (type == STREAM_INPUT__CHECKPOINT || type == STREAM_INPUT__CHECKPOINT_TRIGGER || + type == STREAM_INPUT__TRANS_STATE) { + SStreamDataBlock* pBlock = (SStreamDataBlock*)data; taosArrayDestroyEx(pBlock->blocks, freeItems); taosFreeQitem(pBlock); } diff --git a/source/libs/stream/src/streamQueue.c b/source/libs/stream/src/streamQueue.c index 9c5c230a3d..7bc50417bd 100644 --- a/source/libs/stream/src/streamQueue.c +++ b/source/libs/stream/src/streamQueue.c @@ -15,8 +15,8 @@ #include "streamInt.h" -#define MAX_STREAM_EXEC_BATCH_NUM 32 -#define MAX_SMOOTH_BURST_RATIO 5 // 5 sec +#define MAX_STREAM_EXEC_BATCH_NUM 32 +#define MAX_SMOOTH_BURST_RATIO 5 // 5 sec // todo refactor: // read data from input queue @@ -42,18 +42,26 @@ static void streamQueueCleanup(SStreamQueue* pQueue) { static void* streamQueueCurItem(SStreamQueue* queue) { return queue->qItem; } SStreamQueue* streamQueueOpen(int64_t cap) { + int32_t code; + SStreamQueue* pQueue = taosMemoryCalloc(1, sizeof(SStreamQueue)); if (pQueue == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - pQueue->pQueue = taosOpenQueue(); - pQueue->qall = taosAllocateQall(); + code = taosOpenQueue(&pQueue->pQueue); + if (code) { + taosMemoryFreeClear(pQueue); + terrno = code; + return NULL; + } - if (pQueue->pQueue == NULL || pQueue->qall == NULL) { - if (pQueue->pQueue) taosCloseQueue(pQueue->pQueue); - if (pQueue->qall) taosFreeQall(pQueue->qall); + code = taosAllocateQall(&pQueue->qall); + if (code) { + taosCloseQueue(pQueue->pQueue); taosMemoryFree(pQueue); + terrno = code; return NULL; } @@ -64,7 +72,8 @@ SStreamQueue* streamQueueOpen(int64_t cap) { } void streamQueueClose(SStreamQueue* pQueue, int32_t taskId) { - stDebug("s-task:0x%x free the queue:%p, items in queue:%d", taskId, pQueue->pQueue, taosQueueItemSize(pQueue->pQueue)); + stDebug("s-task:0x%x free the queue:%p, items in queue:%d", taskId, pQueue->pQueue, + taosQueueItemSize(pQueue->pQueue)); streamQueueCleanup(pQueue); taosFreeQall(pQueue->qall); @@ -129,12 +138,12 @@ int32_t streamQueueGetItemSize(const SStreamQueue* pQueue) { } int32_t streamQueueItemGetSize(const SStreamQueueItem* pItem) { - STaosQnode* p = (STaosQnode*)((char*) pItem - sizeof(STaosQnode)); + STaosQnode* p = (STaosQnode*)((char*)pItem - sizeof(STaosQnode)); return p->dataSize; } void streamQueueItemIncSize(const SStreamQueueItem* pItem, int32_t size) { - STaosQnode* p = (STaosQnode*)((char*) pItem - sizeof(STaosQnode)); + STaosQnode* p = (STaosQnode*)((char*)pItem - sizeof(STaosQnode)); p->dataSize += size; } @@ -152,7 +161,7 @@ const char* streamQueueItemGetTypeStr(int32_t type) { } EExtractDataCode streamTaskGetDataFromInputQ(SStreamTask* pTask, SStreamQueueItem** pInput, int32_t* numOfBlocks, - int32_t* blockSize) { + int32_t* blockSize) { const char* id = pTask->id.idStr; int32_t taskLevel = pTask->info.taskLevel; @@ -174,7 +183,6 @@ EExtractDataCode streamTaskGetDataFromInputQ(SStreamTask* pTask, SStreamQueueIte SStreamQueueItem* qItem = streamQueueNextItem(pTask->inputq.queue); if (qItem == NULL) { - // restore the token to bucket if (*numOfBlocks > 0) { *blockSize = streamQueueItemGetSize(*pInput); @@ -203,7 +211,7 @@ EExtractDataCode streamTaskGetDataFromInputQ(SStreamTask* pTask, SStreamQueueIte *numOfBlocks = 1; *pInput = qItem; return EXEC_CONTINUE; - } else { // previous existed blocks needs to be handle, before handle the checkpoint msg block + } else { // previous existed blocks needs to be handle, before handle the checkpoint msg block stDebug("s-task:%s %s msg extracted, handle previous blocks, numOfBlocks:%d", id, p, *numOfBlocks); *blockSize = streamQueueItemGetSize(*pInput); if (taskLevel == TASK_LEVEL__SINK) { @@ -223,7 +231,7 @@ EExtractDataCode streamTaskGetDataFromInputQ(SStreamTask* pTask, SStreamQueueIte if (newRet == NULL) { if (terrno != 0) { stError("s-task:%s failed to merge blocks from inputQ, numOfBlocks:%d, code:%s", id, *numOfBlocks, - tstrerror(terrno)); + tstrerror(terrno)); } *blockSize = streamQueueItemGetSize(*pInput); @@ -284,14 +292,14 @@ int32_t streamTaskPutDataIntoInputQ(SStreamTask* pTask, SStreamQueueItem* pItem) // use the local variable to avoid the pItem be freed by other threads, since it has been put into queue already. stDebug("s-task:%s submit enqueue msgLen:%d ver:%" PRId64 ", total in queue:%d, size:%.2fMiB", pTask->id.idStr, - msgLen, ver, total, size + SIZE_IN_MiB(msgLen)); + msgLen, ver, total, size + SIZE_IN_MiB(msgLen)); } else if (type == STREAM_INPUT__DATA_BLOCK || type == STREAM_INPUT__DATA_RETRIEVE || type == STREAM_INPUT__REF_DATA_BLOCK) { if (streamQueueIsFull(pTask->inputq.queue)) { double size = SIZE_IN_MiB(taosQueueMemorySize(pQueue)); stTrace("s-task:%s input queue is full, capacity:%d size:%d MiB, current(blocks:%d, size:%.2fMiB) abort", - pTask->id.idStr, STREAM_TASK_QUEUE_CAPACITY, STREAM_TASK_QUEUE_CAPACITY_IN_SIZE, total, size); + pTask->id.idStr, STREAM_TASK_QUEUE_CAPACITY, STREAM_TASK_QUEUE_CAPACITY_IN_SIZE, total, size); streamFreeQitem(pItem); return -1; } @@ -314,7 +322,7 @@ int32_t streamTaskPutDataIntoInputQ(SStreamTask* pTask, SStreamQueueItem* pItem) double size = SIZE_IN_MiB(taosQueueMemorySize(pQueue)); stDebug("s-task:%s level:%d %s blockdata enqueue, total in queue:%d, size:%.2fMiB", pTask->id.idStr, - pTask->info.taskLevel, streamQueueItemGetTypeStr(type), total, size); + pTask->info.taskLevel, streamQueueItemGetTypeStr(type), total, size); } else if (type == STREAM_INPUT__GET_RES) { // use the default memory limit, refactor later. int32_t code = taosWriteQitem(pQueue, pItem); @@ -332,16 +340,20 @@ int32_t streamTaskPutDataIntoInputQ(SStreamTask* pTask, SStreamQueueItem* pItem) if (type != STREAM_INPUT__GET_RES && type != STREAM_INPUT__CHECKPOINT && type != STREAM_INPUT__CHECKPOINT_TRIGGER && (pTask->info.delaySchedParam != 0)) { atomic_val_compare_exchange_8(&pTask->schedInfo.status, TASK_TRIGGER_STATUS__INACTIVE, TASK_TRIGGER_STATUS__ACTIVE); - stDebug("s-task:%s new data arrived, active the sched-trigger, triggerStatus:%d", pTask->id.idStr, pTask->schedInfo.status); + stDebug("s-task:%s new data arrived, active the sched-trigger, triggerStatus:%d", pTask->id.idStr, + pTask->schedInfo.status); } return 0; } int32_t streamTaskPutTranstateIntoInputQ(SStreamTask* pTask) { - SStreamDataBlock* pTranstate = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, sizeof(SSDataBlock)); - if (pTranstate == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + int32_t code; + SStreamDataBlock* pTranstate; + + code = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, sizeof(SSDataBlock), (void**)&pTranstate); + if (code) { + return code; } SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock)); @@ -371,13 +383,13 @@ int32_t streamTaskPutTranstateIntoInputQ(SStreamTask* pTask) { // the result should be put into the outputQ in any cases, the result may be lost otherwise. int32_t streamTaskPutDataIntoOutputQ(SStreamTask* pTask, SStreamDataBlock* pBlock) { STaosQueue* pQueue = pTask->outputq.queue->pQueue; - int32_t code = taosWriteQitem(pQueue, pBlock); + int32_t code = taosWriteQitem(pQueue, pBlock); int32_t total = streamQueueGetNumOfItems(pTask->outputq.queue); double size = SIZE_IN_MiB(taosQueueMemorySize(pQueue)); if (code != 0) { stError("s-task:%s failed to put res into outputQ, outputQ items:%d, size:%.2fMiB code:%s, result lost", - pTask->id.idStr, total + 1, size, tstrerror(code)); + pTask->id.idStr, total + 1, size, tstrerror(code)); } else { if (streamQueueIsFull(pTask->outputq.queue)) { stWarn( @@ -427,7 +439,7 @@ static void fillTokenBucket(STokenBucket* pBucket, const char* id) { // increase the new available quota as time goes on int64_t deltaQuota = now - pBucket->quotaFillTimestamp; - double incSize = (deltaQuota / 1000.0) * pBucket->quotaRate; + double incSize = (deltaQuota / 1000.0) * pBucket->quotaRate; if (incSize > 0) { pBucket->quotaRemain = TMIN(pBucket->quotaRemain + incSize, pBucket->quotaCapacity); pBucket->quotaFillTimestamp = now; @@ -447,7 +459,7 @@ bool streamTaskExtractAvailableToken(STokenBucket* pBucket, const char* id) { if (pBucket->quotaRemain > 0) { pBucket->numOfToken -= 1; return true; - } else { // no available size quota now + } else { // no available size quota now return false; } } else { @@ -460,8 +472,6 @@ void streamTaskPutbackToken(STokenBucket* pBucket) { } // size in KB -void streamTaskConsumeQuota(STokenBucket* pBucket, int32_t bytes) { - pBucket->quotaRemain -= SIZE_IN_MiB(bytes); -} +void streamTaskConsumeQuota(STokenBucket* pBucket, int32_t bytes) { pBucket->quotaRemain -= SIZE_IN_MiB(bytes); } void streamTaskInputFail(SStreamTask* pTask) { atomic_store_8(&pTask->inputq.status, TASK_INPUT_STATUS__FAILED); } \ No newline at end of file diff --git a/source/libs/stream/src/streamSched.c b/source/libs/stream/src/streamSched.c index 0a54dfa4c8..f33c2c7b68 100644 --- a/source/libs/stream/src/streamSched.c +++ b/source/libs/stream/src/streamSched.c @@ -134,11 +134,14 @@ void streamTaskSchedHelper(void* param, void* tmrId) { stDebug("s-task:%s in checkpoint procedure, not retrieve result, next:%dms", id, nextTrigger); } else { if (status == TASK_TRIGGER_STATUS__ACTIVE) { - SStreamTrigger* pTrigger = taosAllocateQitem(sizeof(SStreamTrigger), DEF_QITEM, 0); - if (pTrigger == NULL) { + SStreamTrigger* pTrigger; + + int32_t code = taosAllocateQitem(sizeof(SStreamTrigger), DEF_QITEM, 0, (void**)&pTrigger); + if (code) { stError("s-task:%s failed to prepare retrieve data trigger, code:%s, try again in %dms", id, "out of memory", nextTrigger); taosTmrReset(streamTaskSchedHelper, nextTrigger, pTask, streamTimer, &pTask->schedInfo.pDelayTimer); + terrno = code; return; } @@ -156,7 +159,7 @@ void streamTaskSchedHelper(void* param, void* tmrId) { atomic_store_8(&pTask->schedInfo.status, TASK_TRIGGER_STATUS__INACTIVE); pTrigger->pBlock->info.type = STREAM_GET_ALL; - int32_t code = streamTaskPutDataIntoInputQ(pTask, (SStreamQueueItem*)pTrigger); + code = streamTaskPutDataIntoInputQ(pTask, (SStreamQueueItem*)pTrigger); if (code != TSDB_CODE_SUCCESS) { taosTmrReset(streamTaskSchedHelper, nextTrigger, pTask, streamTimer, &pTask->schedInfo.pDelayTimer); return; diff --git a/source/libs/stream/src/streamTask.c b/source/libs/stream/src/streamTask.c index 4cbe0cb136..221250ba74 100644 --- a/source/libs/stream/src/streamTask.c +++ b/source/libs/stream/src/streamTask.c @@ -979,10 +979,13 @@ char* createStreamTaskIdStr(int64_t streamId, int32_t taskId) { } static int32_t streamTaskEnqueueRetrieve(SStreamTask* pTask, SStreamRetrieveReq* pReq) { - SStreamDataBlock* pData = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, sizeof(SStreamDataBlock)); - if (pData == NULL) { + int32_t code; + SStreamDataBlock* pData; + + code = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, sizeof(SStreamDataBlock), (void**)&pData); + if (code) { stError("s-task:%s failed to allocated retrieve-block", pTask->id.idStr); - return terrno; + return terrno = code; } // enqueue @@ -992,7 +995,7 @@ static int32_t streamTaskEnqueueRetrieve(SStreamTask* pTask, SStreamRetrieveReq* pData->type = STREAM_INPUT__DATA_RETRIEVE; pData->srcVgId = 0; - int32_t code = streamRetrieveReqToData(pReq, pData, pTask->id.idStr); + code = streamRetrieveReqToData(pReq, pData, pTask->id.idStr); if (code != TSDB_CODE_SUCCESS) { taosFreeQitem(pData); return code; diff --git a/source/util/src/tqueue.c b/source/util/src/tqueue.c index 45a8a462fb..b2d2622407 100644 --- a/source/util/src/tqueue.c +++ b/source/util/src/tqueue.c @@ -17,6 +17,7 @@ #include "tqueue.h" #include "taoserror.h" #include "tlog.h" +#include "tutil.h" int64_t tsRpcQueueMemoryAllowed = 0; int64_t tsRpcQueueMemoryUsed = 0; @@ -58,20 +59,20 @@ struct STaosQall { void taosSetQueueMemoryCapacity(STaosQueue *queue, int64_t cap) { queue->memLimit = cap; } void taosSetQueueCapacity(STaosQueue *queue, int64_t size) { queue->itemLimit = size; } -STaosQueue *taosOpenQueue() { - STaosQueue *queue = taosMemoryCalloc(1, sizeof(STaosQueue)); - if (queue == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; +int32_t taosOpenQueue(STaosQueue **queue) { + *queue = taosMemoryCalloc(1, sizeof(STaosQueue)); + if (*queue == NULL) { + return (terrno = TSDB_CODE_OUT_OF_MEMORY); } - if (taosThreadMutexInit(&queue->mutex, NULL) != 0) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + int32_t code = taosThreadMutexInit(&(*queue)->mutex, NULL); + if (code) { + taosMemoryFreeClear(*queue); + return (terrno = TAOS_SYSTEM_ERROR(code)); } uDebug("queue:%p is opened", queue); - return queue; + return 0; } void taosSetQueueFp(STaosQueue *queue, FItem itemFp, FItems itemsFp) { @@ -146,11 +147,12 @@ int64_t taosQueueMemorySize(STaosQueue *queue) { return memOfItems; } -void *taosAllocateQitem(int32_t size, EQItype itype, int64_t dataSize) { +int32_t taosAllocateQitem(int32_t size, EQItype itype, int64_t dataSize, void **item) { + *item = NULL; + STaosQnode *pNode = taosMemoryCalloc(1, sizeof(STaosQnode) + size); if (pNode == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + return terrno = TSDB_CODE_OUT_OF_MEMORY; } pNode->dataSize = dataSize; @@ -165,15 +167,15 @@ void *taosAllocateQitem(int32_t size, EQItype itype, int64_t dataSize) { tsRpcQueueMemoryAllowed); atomic_sub_fetch_64(&tsRpcQueueMemoryUsed, size + dataSize); taosMemoryFree(pNode); - terrno = TSDB_CODE_OUT_OF_RPC_MEMORY_QUEUE; - return NULL; + return (terrno = TSDB_CODE_OUT_OF_RPC_MEMORY_QUEUE); } uTrace("item:%p, node:%p is allocated, alloc:%" PRId64, pNode->item, pNode, alloced); } else { uTrace("item:%p, node:%p is allocated", pNode->item, pNode); } - return pNode->item; + *item = pNode->item; + return 0; } void taosFreeQitem(void *pItem) { @@ -221,13 +223,17 @@ int32_t taosWriteQitem(STaosQueue *queue, void *pItem) { } queue->numOfItems++; queue->memOfItems += (pNode->size + pNode->dataSize); - if (queue->qset) atomic_add_fetch_32(&queue->qset->numOfItems, 1); + if (queue->qset) { + atomic_add_fetch_32(&queue->qset->numOfItems, 1); + } uTrace("item:%p is put into queue:%p, items:%d mem:%" PRId64, pItem, queue, queue->numOfItems, queue->memOfItems); taosThreadMutexUnlock(&queue->mutex); - if (queue->qset) tsem_post(&queue->qset->sem); + if (queue->qset) { + tsem_post(&queue->qset->sem); + } return code; } @@ -241,10 +247,14 @@ int32_t taosReadQitem(STaosQueue *queue, void **ppItem) { pNode = queue->head; *ppItem = pNode->item; queue->head = pNode->next; - if (queue->head == NULL) queue->tail = NULL; + if (queue->head == NULL) { + queue->tail = NULL; + } queue->numOfItems--; queue->memOfItems -= (pNode->size + pNode->dataSize); - if (queue->qset) atomic_sub_fetch_32(&queue->qset->numOfItems, 1); + if (queue->qset) { + atomic_sub_fetch_32(&queue->qset->numOfItems, 1); + } code = 1; uTrace("item:%p is read out from queue:%p, items:%d mem:%" PRId64, *ppItem, queue, queue->numOfItems, queue->memOfItems); @@ -255,12 +265,12 @@ int32_t taosReadQitem(STaosQueue *queue, void **ppItem) { return code; } -STaosQall *taosAllocateQall() { - STaosQall *qall = taosMemoryCalloc(1, sizeof(STaosQall)); - if (qall != NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; +int32_t taosAllocateQall(STaosQall **qall) { + *qall = taosMemoryCalloc(1, sizeof(STaosQall)); + if (*qall == NULL) { + return terrno = TSDB_CODE_OUT_OF_MEMORY; } - return qall; + return 0; } void taosFreeQall(STaosQall *qall) { taosMemoryFree(qall); } @@ -290,7 +300,9 @@ int32_t taosReadAllQitems(STaosQueue *queue, STaosQall *qall) { queue->memOfItems = 0; uTrace("read %d items from queue:%p, items:%d mem:%" PRId64, numOfItems, queue, queue->numOfItems, queue->memOfItems); - if (queue->qset) atomic_sub_fetch_32(&queue->qset->numOfItems, qall->numOfItems); + if (queue->qset) { + atomic_sub_fetch_32(&queue->qset->numOfItems, qall->numOfItems); + } } taosThreadMutexUnlock(&queue->mutex); @@ -326,18 +338,17 @@ int32_t taosGetQitem(STaosQall *qall, void **ppItem) { return num; } -STaosQset *taosOpenQset() { - STaosQset *qset = taosMemoryCalloc(sizeof(STaosQset), 1); - if (qset == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; +int32_t taosOpenQset(STaosQset **qset) { + *qset = taosMemoryCalloc(sizeof(STaosQset), 1); + if (*qset == NULL) { + return terrno = TSDB_CODE_OUT_OF_MEMORY; } - taosThreadMutexInit(&qset->mutex, NULL); - tsem_init(&qset->sem, 0, 0); + taosThreadMutexInit(&(*qset)->mutex, NULL); + tsem_init(&(*qset)->sem, 0, 0); uDebug("qset:%p is opened", qset); - return qset; + return 0; } void taosCloseQset(STaosQset *qset) { @@ -533,9 +544,7 @@ int64_t taosQallUnAccessedMemSize(STaosQall *qall) { return qall->unAccessMemOfI void taosResetQitems(STaosQall *qall) { qall->current = qall->start; } int32_t taosGetQueueNumber(STaosQset *qset) { return qset->numOfQueues; } -void taosQueueSetThreadId(STaosQueue* pQueue, int64_t threadId) { - pQueue->threadId = threadId; -} +void taosQueueSetThreadId(STaosQueue *pQueue, int64_t threadId) { pQueue->threadId = threadId; } int64_t taosQueueGetThreadId(STaosQueue *pQueue) { return pQueue->threadId; } diff --git a/source/util/src/tworker.c b/source/util/src/tworker.c index 7a97dc3527..0960d37817 100644 --- a/source/util/src/tworker.c +++ b/source/util/src/tworker.c @@ -16,20 +16,22 @@ #define _DEFAULT_SOURCE #include "tworker.h" #include "taoserror.h" +#include "tcompare.h" #include "tgeosctx.h" #include "tlog.h" -#include "tcompare.h" #define QUEUE_THRESHOLD (1000 * 1000) typedef void *(*ThreadFp)(void *param); int32_t tQWorkerInit(SQWorkerPool *pool) { - pool->qset = taosOpenQset(); + int32_t code = taosOpenQset(&pool->qset); + if (code) return code; + pool->workers = taosMemoryCalloc(pool->max, sizeof(SQueueWorker)); if (pool->workers == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + taosCloseQset(pool->qset); + return terrno = TSDB_CODE_OUT_OF_MEMORY; } (void)taosThreadMutexInit(&pool->mutex, NULL); @@ -109,8 +111,14 @@ static void *tQWorkerThreadFp(SQueueWorker *worker) { } STaosQueue *tQWorkerAllocQueue(SQWorkerPool *pool, void *ahandle, FItem fp) { - STaosQueue *queue = taosOpenQueue(); - if (queue == NULL) return NULL; + int32_t code; + STaosQueue *queue; + + code = taosOpenQueue(&queue); + if (code) { + terrno = code; + return NULL; + } taosThreadMutexLock(&pool->mutex); taosSetQueueFp(queue, fp, NULL); @@ -150,11 +158,17 @@ void tQWorkerFreeQueue(SQWorkerPool *pool, STaosQueue *queue) { } int32_t tAutoQWorkerInit(SAutoQWorkerPool *pool) { - pool->qset = taosOpenQset(); + int32_t code; + + code = taosOpenQset(&pool->qset); + if (code) { + return terrno = code; + } + pool->workers = taosArrayInit(2, sizeof(SQueueWorker *)); if (pool->workers == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + taosCloseQset(pool->qset); + return terrno = TSDB_CODE_OUT_OF_MEMORY; } (void)taosThreadMutexInit(&pool->mutex, NULL); @@ -228,8 +242,14 @@ static void *tAutoQWorkerThreadFp(SQueueWorker *worker) { } STaosQueue *tAutoQWorkerAllocQueue(SAutoQWorkerPool *pool, void *ahandle, FItem fp) { - STaosQueue *queue = taosOpenQueue(); - if (queue == NULL) return NULL; + int32_t code; + STaosQueue *queue; + + code = taosOpenQueue(&queue); + if (code) { + terrno = code; + return NULL; + } taosThreadMutexLock(&pool->mutex); taosSetQueueFp(queue, fp, NULL); @@ -375,20 +395,21 @@ static void *tWWorkerThreadFp(SWWorker *worker) { STaosQueue *tWWorkerAllocQueue(SWWorkerPool *pool, void *ahandle, FItems fp) { taosThreadMutexLock(&pool->mutex); - SWWorker *worker = pool->workers + pool->nextId; - int32_t code = -1; + SWWorker *worker = pool->workers + pool->nextId; + int32_t code = -1; + STaosQueue *queue; - STaosQueue *queue = taosOpenQueue(); - if (queue == NULL) goto _OVER; + code = taosOpenQueue(&queue); + if (code) goto _OVER; taosSetQueueFp(queue, NULL, fp); if (worker->qset == NULL) { - worker->qset = taosOpenQset(); - if (worker->qset == NULL) goto _OVER; + code = taosOpenQset(&worker->qset); + if (code) goto _OVER; taosAddIntoQset(worker->qset, queue, ahandle); - worker->qall = taosAllocateQall(); - if (worker->qall == NULL) goto _OVER; + code = taosAllocateQall(&worker->qall); + if (code) goto _OVER; TdThreadAttr thAttr; taosThreadAttrInit(&thAttr); @@ -406,12 +427,10 @@ STaosQueue *tWWorkerAllocQueue(SWWorkerPool *pool, void *ahandle, FItems fp) { pool->nextId = (pool->nextId + 1) % pool->max; } - code = 0; - _OVER: taosThreadMutexUnlock(&pool->mutex); - if (code == -1) { + if (code) { if (queue != NULL) taosCloseQueue(queue); if (worker->qset != NULL) taosCloseQset(worker->qset); if (worker->qall != NULL) taosFreeQall(worker->qall); @@ -517,13 +536,13 @@ void tMultiWorkerCleanup(SMultiWorker *pWorker) { tWWorkerFreeQueue(&pWorker->pool, pWorker->queue); } -static int32_t tQueryAutoQWorkerAddWorker(SQueryAutoQWorkerPool* pool); +static int32_t tQueryAutoQWorkerAddWorker(SQueryAutoQWorkerPool *pool); static int32_t tQueryAutoQWorkerBeforeBlocking(void *p); static int32_t tQueryAutoQWorkerRecoverFromBlocking(void *p); -static int32_t tQueryAutoQWorkerWaitingCheck(SQueryAutoQWorkerPool* pPool); -static bool tQueryAutoQWorkerTryRecycleWorker(SQueryAutoQWorkerPool* pPool, SQueryAutoQWorker* pWorker); +static int32_t tQueryAutoQWorkerWaitingCheck(SQueryAutoQWorkerPool *pPool); +static bool tQueryAutoQWorkerTryRecycleWorker(SQueryAutoQWorkerPool *pPool, SQueryAutoQWorker *pWorker); -#define GET_ACTIVE_N(int64_val) (int32_t)((int64_val) >> 32) +#define GET_ACTIVE_N(int64_val) (int32_t)((int64_val) >> 32) #define GET_RUNNING_N(int64_val) (int32_t)(int64_val & 0xFFFFFFFF) static int32_t atomicFetchSubActive(int64_t *ptr, int32_t val) { @@ -544,7 +563,7 @@ static int32_t atomicFetchAddActive(int64_t *ptr, int32_t val) { static int32_t atomicFetchAddRunning(int64_t *ptr, int32_t val) { return GET_RUNNING_N(atomic_fetch_add_64(ptr, val)); } -static bool atomicCompareExchangeActive(int64_t* ptr, int32_t* expectedVal, int32_t newVal) { +static bool atomicCompareExchangeActive(int64_t *ptr, int32_t *expectedVal, int32_t newVal) { int64_t oldVal64 = *expectedVal, newVal64 = newVal; int32_t running = GET_RUNNING_N(*ptr); oldVal64 <<= 32; @@ -560,7 +579,7 @@ static bool atomicCompareExchangeActive(int64_t* ptr, int32_t* expectedVal, int3 } } -static int64_t atomicCompareExchangeRunning(int64_t* ptr, int32_t* expectedVal, int32_t newVal) { +static int64_t atomicCompareExchangeRunning(int64_t *ptr, int32_t *expectedVal, int32_t newVal) { int64_t oldVal64 = *expectedVal, newVal64 = newVal; int64_t activeShifted = GET_ACTIVE_N(*ptr); activeShifted <<= 32; @@ -576,7 +595,7 @@ static int64_t atomicCompareExchangeRunning(int64_t* ptr, int32_t* expectedVal, } static int64_t atomicCompareExchangeActiveAndRunning(int64_t *ptr, int32_t *expectedActive, int32_t newActive, - int32_t *expectedRunning, int32_t newRunning) { + int32_t *expectedRunning, int32_t newRunning) { int64_t oldVal64 = *expectedActive, newVal64 = newActive; oldVal64 <<= 32; oldVal64 |= *expectedRunning; @@ -641,7 +660,7 @@ static void *tQueryAutoQWorkerThreadFp(SQueryAutoQWorker *worker) { static bool tQueryAutoQWorkerTrySignalWaitingAfterBlock(void *p) { SQueryAutoQWorkerPool *pPool = p; bool ret = false; - int32_t waiting = pPool->waitingAfterBlockN; + int32_t waiting = pPool->waitingAfterBlockN; while (waiting > 0) { int32_t waitingNew = atomic_val_compare_exchange_32(&pPool->waitingAfterBlockN, waiting, waiting - 1); if (waitingNew == waiting) { @@ -656,10 +675,10 @@ static bool tQueryAutoQWorkerTrySignalWaitingAfterBlock(void *p) { return ret; } -static bool tQueryAutoQWorkerTrySignalWaitingBeforeProcess(void* p) { +static bool tQueryAutoQWorkerTrySignalWaitingBeforeProcess(void *p) { SQueryAutoQWorkerPool *pPool = p; bool ret = false; - int32_t waiting = pPool->waitingBeforeProcessMsgN; + int32_t waiting = pPool->waitingBeforeProcessMsgN; while (waiting > 0) { int32_t waitingNew = atomic_val_compare_exchange_32(&pPool->waitingBeforeProcessMsgN, waiting, waiting - 1); if (waitingNew == waiting) { @@ -674,10 +693,10 @@ static bool tQueryAutoQWorkerTrySignalWaitingBeforeProcess(void* p) { return ret; } -static bool tQueryAutoQWorkerTryDecActive(void* p, int32_t minActive) { +static bool tQueryAutoQWorkerTryDecActive(void *p, int32_t minActive) { SQueryAutoQWorkerPool *pPool = p; bool ret = false; - int64_t val64 = pPool->activeRunningN; + int64_t val64 = pPool->activeRunningN; int32_t active = GET_ACTIVE_N(val64), running = GET_RUNNING_N(val64); while (active > minActive) { if (atomicCompareExchangeActiveAndRunning(&pPool->activeRunningN, &active, active - 1, &running, running - 1)) @@ -687,7 +706,7 @@ static bool tQueryAutoQWorkerTryDecActive(void* p, int32_t minActive) { return false; } -static int32_t tQueryAutoQWorkerWaitingCheck(SQueryAutoQWorkerPool* pPool) { +static int32_t tQueryAutoQWorkerWaitingCheck(SQueryAutoQWorkerPool *pPool) { while (1) { int64_t val64 = pPool->activeRunningN; int32_t running = GET_RUNNING_N(val64), active = GET_ACTIVE_N(val64); @@ -709,17 +728,17 @@ static int32_t tQueryAutoQWorkerWaitingCheck(SQueryAutoQWorkerPool* pPool) { return TSDB_CODE_SUCCESS; } -bool tQueryAutoQWorkerTryRecycleWorker(SQueryAutoQWorkerPool* pPool, SQueryAutoQWorker* pWorker) { +bool tQueryAutoQWorkerTryRecycleWorker(SQueryAutoQWorkerPool *pPool, SQueryAutoQWorker *pWorker) { if (tQueryAutoQWorkerTrySignalWaitingAfterBlock(pPool) || tQueryAutoQWorkerTrySignalWaitingBeforeProcess(pPool) || tQueryAutoQWorkerTryDecActive(pPool, pPool->num)) { taosThreadMutexLock(&pPool->poolLock); - SListNode* pNode = listNode(pWorker); + SListNode *pNode = listNode(pWorker); tdListPopNode(pPool->workers, pNode); // reclaim some workers if (pWorker->id >= pPool->maxInUse) { while (listNEles(pPool->exitedWorkers) > pPool->maxInUse - pPool->num) { - SListNode* head = tdListPopHead(pPool->exitedWorkers); - SQueryAutoQWorker* pWorker = (SQueryAutoQWorker*)head->data; + SListNode *head = tdListPopHead(pPool->exitedWorkers); + SQueryAutoQWorker *pWorker = (SQueryAutoQWorker *)head->data; if (pWorker && taosCheckPthreadValid(pWorker->thread)) { taosThreadJoin(pWorker->thread, NULL); taosThreadClear(&pWorker->thread); @@ -758,8 +777,9 @@ bool tQueryAutoQWorkerTryRecycleWorker(SQueryAutoQWorkerPool* pPool, SQueryAutoQ } int32_t tQueryAutoQWorkerInit(SQueryAutoQWorkerPool *pool) { - pool->qset = taosOpenQset(); - if (!pool->qset) return terrno; + int32_t code; + code = taosOpenQset(&pool->qset); + if (code) return terrno = code; pool->workers = tdListNew(sizeof(SQueryAutoQWorker)); if (!pool->workers) return TSDB_CODE_OUT_OF_MEMORY; pool->backupWorkers = tdListNew(sizeof(SQueryAutoQWorker)); @@ -812,16 +832,16 @@ void tQueryAutoQWorkerCleanup(SQueryAutoQWorkerPool *pPool) { taosThreadCondBroadcast(&pPool->waitingBeforeProcessMsgCond); taosThreadMutexUnlock(&pPool->waitingBeforeProcessMsgLock); - int32_t idx = 0; - SQueryAutoQWorker* worker = NULL; + int32_t idx = 0; + SQueryAutoQWorker *worker = NULL; while (true) { taosThreadMutexLock(&pPool->poolLock); if (listNEles(pPool->workers) == 0) { taosThreadMutexUnlock(&pPool->poolLock); break; } - SListNode* pNode = tdListPopHead(pPool->workers); - worker = (SQueryAutoQWorker*)pNode->data; + SListNode *pNode = tdListPopHead(pPool->workers); + worker = (SQueryAutoQWorker *)pNode->data; taosThreadMutexUnlock(&pPool->poolLock); if (worker && taosCheckPthreadValid(worker->thread)) { taosThreadJoin(worker->thread, NULL); @@ -831,8 +851,8 @@ void tQueryAutoQWorkerCleanup(SQueryAutoQWorkerPool *pPool) { } while (listNEles(pPool->backupWorkers) > 0) { - SListNode* pNode = tdListPopHead(pPool->backupWorkers); - worker = (SQueryAutoQWorker*)pNode->data; + SListNode *pNode = tdListPopHead(pPool->backupWorkers); + worker = (SQueryAutoQWorker *)pNode->data; if (worker && taosCheckPthreadValid(worker->thread)) { taosThreadJoin(worker->thread, NULL); taosThreadClear(&worker->thread); @@ -841,8 +861,8 @@ void tQueryAutoQWorkerCleanup(SQueryAutoQWorkerPool *pPool) { } while (listNEles(pPool->exitedWorkers) > 0) { - SListNode* pNode = tdListPopHead(pPool->exitedWorkers); - worker = (SQueryAutoQWorker*)pNode->data; + SListNode *pNode = tdListPopHead(pPool->exitedWorkers); + worker = (SQueryAutoQWorker *)pNode->data; if (worker && taosCheckPthreadValid(worker->thread)) { taosThreadJoin(worker->thread, NULL); taosThreadClear(&worker->thread); @@ -867,14 +887,18 @@ void tQueryAutoQWorkerCleanup(SQueryAutoQWorkerPool *pPool) { } STaosQueue *tQueryAutoQWorkerAllocQueue(SQueryAutoQWorkerPool *pool, void *ahandle, FItem fp) { - STaosQueue *queue = taosOpenQueue(); - if (queue == NULL) return NULL; + STaosQueue *queue; + int32_t code = taosOpenQueue(&queue); + if (code) { + terrno = code; + return NULL; + } taosThreadMutexLock(&pool->poolLock); taosSetQueueFp(queue, fp, NULL); taosAddIntoQset(pool->qset, queue, ahandle); - SQueryAutoQWorker worker = {0}; - SQueryAutoQWorker* pWorker = NULL; + SQueryAutoQWorker worker = {0}; + SQueryAutoQWorker *pWorker = NULL; // spawn a thread to process queue if (pool->num < pool->max) { @@ -882,14 +906,14 @@ STaosQueue *tQueryAutoQWorkerAllocQueue(SQueryAutoQWorkerPool *pool, void *ahand worker.id = listNEles(pool->workers); worker.backupIdx = -1; worker.pool = pool; - SListNode* pNode = tdListAdd(pool->workers, &worker); + SListNode *pNode = tdListAdd(pool->workers, &worker); if (!pNode) { taosCloseQueue(queue); queue = NULL; terrno = TSDB_CODE_OUT_OF_MEMORY; break; } - pWorker = (SQueryAutoQWorker*)pNode->data; + pWorker = (SQueryAutoQWorker *)pNode->data; TdThreadAttr thAttr; taosThreadAttrInit(&thAttr); @@ -915,11 +939,9 @@ STaosQueue *tQueryAutoQWorkerAllocQueue(SQueryAutoQWorkerPool *pool, void *ahand return queue; } -void tQueryAutoQWorkerFreeQueue(SQueryAutoQWorkerPool *pPool, STaosQueue *pQ) { - taosCloseQueue(pQ); -} +void tQueryAutoQWorkerFreeQueue(SQueryAutoQWorkerPool *pPool, STaosQueue *pQ) { taosCloseQueue(pQ); } -static int32_t tQueryAutoQWorkerAddWorker(SQueryAutoQWorkerPool* pool) { +static int32_t tQueryAutoQWorkerAddWorker(SQueryAutoQWorkerPool *pool) { // try backup pool int32_t backup = pool->backupNum; while (backup > 0) { @@ -931,20 +953,20 @@ static int32_t tQueryAutoQWorkerAddWorker(SQueryAutoQWorkerPool* pool) { backup = backupNew; } // backup pool is empty, create new - SQueryAutoQWorker* pWorker = NULL; - SQueryAutoQWorker worker = {0}; + SQueryAutoQWorker *pWorker = NULL; + SQueryAutoQWorker worker = {0}; worker.pool = pool; worker.backupIdx = -1; taosThreadMutexLock(&pool->poolLock); worker.id = listNEles(pool->workers); - SListNode* pNode = tdListAdd(pool->workers, &worker); + SListNode *pNode = tdListAdd(pool->workers, &worker); if (!pNode) { taosThreadMutexUnlock(&pool->poolLock); terrno = TSDB_CODE_OUT_OF_MEMORY; return terrno; } taosThreadMutexUnlock(&pool->poolLock); - pWorker = (SQueryAutoQWorker*)pNode->data; + pWorker = (SQueryAutoQWorker *)pNode->data; TdThreadAttr thAttr; taosThreadAttrInit(&thAttr); @@ -960,7 +982,7 @@ static int32_t tQueryAutoQWorkerAddWorker(SQueryAutoQWorkerPool* pool) { } static int32_t tQueryAutoQWorkerBeforeBlocking(void *p) { - SQueryAutoQWorkerPool* pPool = p; + SQueryAutoQWorkerPool *pPool = p; if (tQueryAutoQWorkerTrySignalWaitingAfterBlock(p) || tQueryAutoQWorkerTrySignalWaitingBeforeProcess(p) || tQueryAutoQWorkerTryDecActive(p, 1)) { } else { @@ -974,9 +996,9 @@ static int32_t tQueryAutoQWorkerBeforeBlocking(void *p) { } static int32_t tQueryAutoQWorkerRecoverFromBlocking(void *p) { - SQueryAutoQWorkerPool* pPool = p; - int64_t val64 = pPool->activeRunningN; - int32_t running = GET_RUNNING_N(val64), active = GET_ACTIVE_N(val64); + SQueryAutoQWorkerPool *pPool = p; + int64_t val64 = pPool->activeRunningN; + int32_t running = GET_RUNNING_N(val64), active = GET_ACTIVE_N(val64); while (running < pPool->num) { if (atomicCompareExchangeActiveAndRunning(&pPool->activeRunningN, &active, active + 1, &running, running + 1)) { return TSDB_CODE_SUCCESS; From 5c6c9a8219fd455ff6f44e203d7f899b0fd80845 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 16 Jul 2024 20:26:46 +0800 Subject: [PATCH 02/12] =?UTF-8?q?fix=EF=BC=9A=20test=20compile?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/libs/transport/test/svrBench.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/source/libs/transport/test/svrBench.c b/source/libs/transport/test/svrBench.c index a3fa81662c..dff3efef12 100644 --- a/source/libs/transport/test/svrBench.c +++ b/source/libs/transport/test/svrBench.c @@ -67,7 +67,7 @@ void *processShellMsg(void *arg) { int type; SQueueInfo qinfo = {0}; - qall = taosAllocateQall(); + taosAllocateQall(&qall); while (1) { int numOfMsgs = taosReadAllQitemsFromQset(multiQ->qset[idx], qall, &qinfo); @@ -129,7 +129,7 @@ void *processShellMsg(void *arg) { void processRequestMsg(void *pParent, SRpcMsg *pMsg, SEpSet *pEpSet) { SRpcMsg *pTemp; - pTemp = taosAllocateQitem(sizeof(SRpcMsg), DEF_QITEM, 0); + taosAllocateQitem(sizeof(SRpcMsg), DEF_QITEM, 0, (void **)&pTemp); memcpy(pTemp, pMsg, sizeof(SRpcMsg)); int32_t idx = balance % multiQ->numOfThread; @@ -212,8 +212,8 @@ int main(int argc, char *argv[]) { multiQ->qset = (STaosQset **)taosMemoryMalloc(sizeof(STaosQset *) * numOfAthread); for (int i = 0; i < numOfAthread; i++) { - multiQ->qhandle[i] = taosOpenQueue(); - multiQ->qset[i] = taosOpenQset(); + taosOpenQueue(&multiQ->qhandle[i]); + taosOpenQset(&multiQ->qset[i]); taosAddIntoQset(multiQ->qset[i], multiQ->qhandle[i], NULL); } TThread *threads = taosMemoryMalloc(sizeof(TThread) * numOfAthread); From d8e3279ca65304e1279498234b06785494709f64 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 17 Jul 2024 08:58:59 +0800 Subject: [PATCH 03/12] fix: little fix --- source/dnode/vnode/src/tq/tqUtil.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/dnode/vnode/src/tq/tqUtil.c b/source/dnode/vnode/src/tq/tqUtil.c index 16c523a50e..4ecab9e400 100644 --- a/source/dnode/vnode/src/tq/tqUtil.c +++ b/source/dnode/vnode/src/tq/tqUtil.c @@ -572,7 +572,7 @@ int32_t tqExtractDelDataBlock(const void* pData, int32_t len, int64_t ver, void* taosArrayDestroy(pRes->uidList); if (type == 0) { - code = taosAllocateQitem(sizeof(SStreamRefDataBlock), DEF_QITEM, 0, pRefBlock); + code = taosAllocateQitem(sizeof(SStreamRefDataBlock), DEF_QITEM, 0, (void**)&pRefBlock); if (code) { blockDataCleanup(pDelBlock); taosMemoryFree(pDelBlock); From 53d917cf897c9656549c971bb6ddef630455e128 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 17 Jul 2024 09:57:13 +0800 Subject: [PATCH 04/12] fix CI problem --- source/client/src/clientTmq.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/client/src/clientTmq.c b/source/client/src/clientTmq.c index 1ea03e15a6..c363686343 100644 --- a/source/client/src/clientTmq.c +++ b/source/client/src/clientTmq.c @@ -741,7 +741,7 @@ static void generateTimedTask(int64_t refId, int32_t type) { if (tmq == NULL) return; code = taosAllocateQitem(sizeof(int8_t), DEF_QITEM, 0, (void**)&pTaskType); - if (code) { + if (code == TSDB_CODE_SUCCESS) { *pTaskType = type; if (taosWriteQitem(tmq->delayedTask, pTaskType) == 0) { tsem2_post(&tmq->rspSem); From 0cccaa8ac473b01ea41363dce678448ccab8df59 Mon Sep 17 00:00:00 2001 From: wangjiaming0909 <604227650@qq.com> Date: Tue, 16 Jul 2024 18:08:34 +0800 Subject: [PATCH 05/12] ret value for parTranslater.c --- include/libs/parser/parser.h | 4 +- source/client/src/clientRawBlockWrite.c | 12 +- source/common/src/tname.c | 5 +- source/libs/parser/inc/parTranslater.h | 4 +- source/libs/parser/inc/sql.y | 2 +- source/libs/parser/src/parAstCreater.c | 43 +- source/libs/parser/src/parTranslater.c | 1600 +++++++++++++++-------- 7 files changed, 1085 insertions(+), 585 deletions(-) diff --git a/include/libs/parser/parser.h b/include/libs/parser/parser.h index 3ac357055e..db92285e11 100644 --- a/include/libs/parser/parser.h +++ b/include/libs/parser/parser.h @@ -163,8 +163,8 @@ int rawBlockBindData(SQuery *query, STableMeta* pTableMeta, void* data, SVCr int numFields, bool needChangeLength, char* errstr, int32_t errstrLen); int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray); -SArray* serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap); -SArray* serializeVgroupsDropTableBatch(SHashObj* pVgroupHashmap); +int32_t serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap, SArray** pOut); +int32_t serializeVgroupsDropTableBatch(SHashObj* pVgroupHashmap, SArray** pOut); void destoryCatalogReq(SCatalogReq *pCatalogReq); bool isPrimaryKeyImpl(SNode* pExpr); int32_t insAppendStmtTableDataCxt(SHashObj* pAllVgHash, STableColsData* pTbData, STableDataCxt* pTbCtx, SStbInterlaceInfo* pBuildInfo); diff --git a/source/client/src/clientRawBlockWrite.c b/source/client/src/clientRawBlockWrite.c index ce404092b0..dd61bd8500 100644 --- a/source/client/src/clientRawBlockWrite.c +++ b/source/client/src/clientRawBlockWrite.c @@ -1116,9 +1116,9 @@ static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) { if (taosHashGetSize(pVgroupHashmap) == 0) { goto end; } - SArray* pBufArray = serializeVgroupsCreateTableBatch(pVgroupHashmap); - if (NULL == pBufArray) { - code = TSDB_CODE_OUT_OF_MEMORY; + SArray* pBufArray = NULL; + code = serializeVgroupsCreateTableBatch(pVgroupHashmap, &pBufArray); + if (TSDB_CODE_SUCCESS != code) { goto end; } @@ -1264,9 +1264,9 @@ static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) { if (taosHashGetSize(pVgroupHashmap) == 0) { goto end; } - SArray* pBufArray = serializeVgroupsDropTableBatch(pVgroupHashmap); - if (NULL == pBufArray) { - code = TSDB_CODE_OUT_OF_MEMORY; + SArray* pBufArray = NULL; + code = serializeVgroupsDropTableBatch(pVgroupHashmap, &pBufArray); + if (TSDB_CODE_SUCCESS != code) { goto end; } diff --git a/source/common/src/tname.c b/source/common/src/tname.c index 4fe2beb6aa..a4d740d427 100644 --- a/source/common/src/tname.c +++ b/source/common/src/tname.c @@ -98,7 +98,7 @@ SName* toName(int32_t acctId, const char* pDbName, const char* pTableName, SName int32_t tNameExtractFullName(const SName* name, char* dst) { // invalid full name format, abort if (!tNameIsValid(name)) { - return -1; + return TSDB_CODE_INVALID_PARA; } int32_t len = snprintf(dst, TSDB_DB_FNAME_LEN, "%d.%s", name->acctId, name->dbname); @@ -154,8 +154,7 @@ int32_t tNameGetDbName(const SName* name, char* dst) { const char* tNameGetDbNameP(const SName* name) { return &name->dbname[0]; } int32_t tNameGetFullDbName(const SName* name, char* dst) { - snprintf(dst, TSDB_DB_FNAME_LEN, "%d.%s", name->acctId, name->dbname); - return 0; + return snprintf(dst, TSDB_DB_FNAME_LEN, "%d.%s", name->acctId, name->dbname); } bool tNameIsEmpty(const SName* name) { return name->type == 0 || name->acctId == 0; } diff --git a/source/libs/parser/inc/parTranslater.h b/source/libs/parser/inc/parTranslater.h index 55ea71a368..99e303e51c 100644 --- a/source/libs/parser/inc/parTranslater.h +++ b/source/libs/parser/inc/parTranslater.h @@ -47,7 +47,7 @@ typedef struct STranslateContext { SNode* pPostRoot; } STranslateContext; -bool biRewriteToTbnameFunc(STranslateContext* pCxt, SNode** ppNode); +int32_t biRewriteToTbnameFunc(STranslateContext* pCxt, SNode** ppNode, bool* pRet); int32_t biRewriteSelectStar(STranslateContext* pCxt, SSelectStmt* pSelect); int32_t biCheckCreateTableTbnameCol(STranslateContext* pCxt, SCreateTableStmt* pStmt); int32_t findTable(STranslateContext* pCxt, const char* pTableAlias, STableNode** pOutput); @@ -57,4 +57,4 @@ int32_t getTargetMetaImpl(SParseContext* pParCxt, SParseMetaCache* pMetaCache, c } #endif -#endif /*_TD_PARSER_TRANS_H_*/ \ No newline at end of file +#endif /*_TD_PARSER_TRANS_H_*/ diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index 149e02ad3d..c53180eb87 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -509,7 +509,7 @@ cmd ::= SHOW USERS FULL. cmd ::= SHOW USER PRIVILEGES. { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USER_PRIVILEGES_STMT); } cmd ::= SHOW db_kind_opt(A) DATABASES. { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT); - setShowKind(pCxt, pCxt->pRootNode, A); + (void)setShowKind(pCxt, pCxt->pRootNode, A); } cmd ::= SHOW table_kind_db_name_cond_opt(A) TABLES like_pattern_opt(B). { pCxt->pRootNode = createShowTablesStmt(pCxt, A, B, OP_TYPE_LIKE); diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 7c2f504a4f..d61d80a691 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -101,7 +101,7 @@ static bool checkPassword(SAstCreateContext* pCxt, const SToken* pPasswordToken, pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_NAME_OR_PASSWD_TOO_LONG); } else { strncpy(pPassword, pPasswordToken->z, pPasswordToken->n); - strdequote(pPassword); + (void)strdequote(pPassword); if (strtrim(pPassword) <= 0) { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_PASSWD_EMPTY); } else if (invalidPassword(pPassword)) { @@ -126,8 +126,8 @@ static int32_t parseEndpoint(SAstCreateContext* pCxt, const SToken* pEp, char* p char ep[TSDB_FQDN_LEN + 1 + 5] = {0}; COPY_STRING_FORM_ID_TOKEN(ep, pEp); - strdequote(ep); - strtrim(ep); + (void)strdequote(ep); + (void)strtrim(ep); if (NULL == pPort) { strcpy(pFqdn, ep); return TSDB_CODE_SUCCESS; @@ -371,7 +371,7 @@ SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* val->literal = strndup(pLiteral->z, pLiteral->n); if (TK_NK_ID != pLiteral->type && TK_TIMEZONE != pLiteral->type && (IS_VAR_DATA_TYPE(dataType) || TSDB_DATA_TYPE_TIMESTAMP == dataType)) { - trimString(pLiteral->z, pLiteral->n, val->literal, pLiteral->n); + (void)trimString(pLiteral->z, pLiteral->n, val->literal, pLiteral->n); } CHECK_OUT_OF_MEM(val->literal); val->node.resType.type = dataType; @@ -784,7 +784,10 @@ SNode* createPlaceholderValueNode(SAstCreateContext* pCxt, const SToken* pLitera return NULL; } } - taosArrayPush(pCxt->pPlaceholderValues, &val); + if (NULL == taosArrayPush(pCxt->pPlaceholderValues, &val)) { + pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + } + CHECK_PARSER_STATUS(pCxt); return (SNode*)val; } @@ -905,7 +908,8 @@ SNode* createCastFunctionNode(SAstCreateContext* pCxt, SNode* pExpr, SDataType d } else if (TSDB_DATA_TYPE_NCHAR == dt.type) { func->node.resType.bytes = func->node.resType.bytes * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE; } - nodesListMakeAppend(&func->pParameterList, pExpr); + pCxt->errCode = nodesListMakeAppend(&func->pParameterList, pExpr); + CHECK_PARSER_STATUS(pCxt); return (SNode*)func; } @@ -923,8 +927,10 @@ SNode* createNodeListNodeEx(SAstCreateContext* pCxt, SNode* p1, SNode* p2) { CHECK_OUT_OF_MEM(list); list->pNodeList = nodesMakeList(); CHECK_OUT_OF_MEM(list->pNodeList); - nodesListAppend(list->pNodeList, p1); - nodesListAppend(list->pNodeList, p2); + pCxt->errCode = nodesListAppend(list->pNodeList, p1); + CHECK_PARSER_STATUS(pCxt); + pCxt->errCode = nodesListAppend(list->pNodeList, p2); + CHECK_PARSER_STATUS(pCxt); return (SNode*)list; } @@ -1121,7 +1127,8 @@ SNode* createGroupingSetNode(SAstCreateContext* pCxt, SNode* pNode) { CHECK_OUT_OF_MEM(groupingSet); groupingSet->groupingSetType = GP_TYPE_NORMAL; groupingSet->pParameterList = nodesMakeList(); - nodesListAppend(groupingSet->pParameterList, pNode); + pCxt->errCode = nodesListAppend(groupingSet->pParameterList, pNode); + CHECK_PARSER_STATUS(pCxt); return (SNode*)groupingSet; } @@ -1842,7 +1849,7 @@ SNode* createCreateSubTableFromFileClause(SAstCreateContext* pCxt, bool ignoreEx pStmt->ignoreExists = ignoreExists; pStmt->pSpecificTags = pSpecificTags; if (TK_NK_STRING == pFilePath->type) { - trimString(pFilePath->z, pFilePath->n, pStmt->filePath, PATH_MAX); + (void)trimString(pFilePath->z, pFilePath->n, pStmt->filePath, PATH_MAX); } else { strncpy(pStmt->filePath, pFilePath->z, pFilePath->n); } @@ -2087,7 +2094,7 @@ SNode* createShowTablesStmt(SAstCreateContext* pCxt, SShowTablesOption option, S pDbName = createIdentifierValueNode(pCxt, &option.dbName); } SNode* pStmt = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TABLES_STMT, pDbName, pTbName, tableCondType); - setShowKind(pCxt, pStmt, option.kind); + (void)setShowKind(pCxt, pStmt, option.kind); return pStmt; } @@ -2408,9 +2415,9 @@ SNode* createAlterDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode, const } else { pStmt->dnodeId = -1; } - trimString(pConfig->z, pConfig->n, pStmt->config, sizeof(pStmt->config)); + (void)trimString(pConfig->z, pConfig->n, pStmt->config, sizeof(pStmt->config)); if (NULL != pValue) { - trimString(pValue->z, pValue->n, pStmt->value, sizeof(pStmt->value)); + (void)trimString(pValue->z, pValue->n, pStmt->value, sizeof(pStmt->value)); } return (SNode*)pStmt; } @@ -2591,9 +2598,9 @@ SNode* createAlterClusterStmt(SAstCreateContext* pCxt, const SToken* pConfig, co CHECK_PARSER_STATUS(pCxt); SAlterClusterStmt* pStmt = (SAlterClusterStmt*)nodesMakeNode(QUERY_NODE_ALTER_CLUSTER_STMT); CHECK_OUT_OF_MEM(pStmt); - trimString(pConfig->z, pConfig->n, pStmt->config, sizeof(pStmt->config)); + (void)trimString(pConfig->z, pConfig->n, pStmt->config, sizeof(pStmt->config)); if (NULL != pValue) { - trimString(pValue->z, pValue->n, pStmt->value, sizeof(pStmt->value)); + (void)trimString(pValue->z, pValue->n, pStmt->value, sizeof(pStmt->value)); } return (SNode*)pStmt; } @@ -2602,9 +2609,9 @@ SNode* createAlterLocalStmt(SAstCreateContext* pCxt, const SToken* pConfig, cons CHECK_PARSER_STATUS(pCxt); SAlterLocalStmt* pStmt = (SAlterLocalStmt*)nodesMakeNode(QUERY_NODE_ALTER_LOCAL_STMT); CHECK_OUT_OF_MEM(pStmt); - trimString(pConfig->z, pConfig->n, pStmt->config, sizeof(pStmt->config)); + (void)trimString(pConfig->z, pConfig->n, pStmt->config, sizeof(pStmt->config)); if (NULL != pValue) { - trimString(pValue->z, pValue->n, pStmt->value, sizeof(pStmt->value)); + (void)trimString(pValue->z, pValue->n, pStmt->value, sizeof(pStmt->value)); } return (SNode*)pStmt; } @@ -2869,7 +2876,7 @@ SNode* createKillQueryStmt(SAstCreateContext* pCxt, const SToken* pQueryId) { CHECK_PARSER_STATUS(pCxt); SKillQueryStmt* pStmt = (SKillQueryStmt*)nodesMakeNode(QUERY_NODE_KILL_QUERY_STMT); CHECK_OUT_OF_MEM(pStmt); - trimString(pQueryId->z, pQueryId->n, pStmt->queryId, sizeof(pStmt->queryId) - 1); + (void)trimString(pQueryId->z, pQueryId->n, pStmt->queryId, sizeof(pStmt->queryId) - 1); return (SNode*)pStmt; } diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 9b1c8096aa..210e8d59db 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -384,10 +384,13 @@ static bool hasSameTableAlias(SArray* pTables) { } static int32_t addNamespace(STranslateContext* pCxt, void* pTable) { - size_t currTotalLevel = taosArrayGetSize(pCxt->pNsLevel); + int32_t code = 0; + size_t currTotalLevel = taosArrayGetSize(pCxt->pNsLevel); if (currTotalLevel > pCxt->currLevel) { SArray* pTables = taosArrayGetP(pCxt->pNsLevel, pCxt->currLevel); - taosArrayPush(pTables, &pTable); + if (NULL == taosArrayPush(pTables, &pTable)) { + return TSDB_CODE_OUT_OF_MEMORY; + } if (hasSameTableAlias(pTables)) { return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_NOT_UNIQUE_TABLE_ALIAS, "Not unique table/alias: '%s'", ((STableNode*)pTable)->tableAlias); @@ -399,18 +402,22 @@ static int32_t addNamespace(STranslateContext* pCxt, void* pTable) { return TSDB_CODE_OUT_OF_MEMORY; } if (pCxt->currLevel == currTotalLevel) { - taosArrayPush(pTables, &pTable); + (void)taosArrayPush(pTables, &pTable); if (hasSameTableAlias(pTables)) { - taosArrayDestroy(pTables); + (void)taosArrayDestroy(pTables); return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_NOT_UNIQUE_TABLE_ALIAS, "Not unique table/alias: '%s'", ((STableNode*)pTable)->tableAlias); } } - taosArrayPush(pCxt->pNsLevel, &pTables); + if (NULL == taosArrayPush(pCxt->pNsLevel, &pTables)) { + code = TSDB_CODE_OUT_OF_MEMORY; + (void)taosArrayDestroy(pTables); + break; + } ++currTotalLevel; } while (currTotalLevel <= pCxt->currLevel); } - return TSDB_CODE_SUCCESS; + return code; } static int32_t collectUseDatabaseImpl(const char* pFullDbName, SHashObj* pDbs) { @@ -421,13 +428,16 @@ static int32_t collectUseDatabaseImpl(const char* pFullDbName, SHashObj* pDbs) { static int32_t collectUseDatabase(const SName* pName, SHashObj* pDbs) { char dbFName[TSDB_DB_FNAME_LEN] = {0}; - tNameGetFullDbName(pName, dbFName); + (void)tNameGetFullDbName(pName, dbFName); return collectUseDatabaseImpl(dbFName, pDbs); } static int32_t collectUseTable(const SName* pName, SHashObj* pTable) { char fullName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(pName, fullName); + int32_t code = tNameExtractFullName(pName, fullName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } return taosHashPut(pTable, fullName, strlen(fullName), pName, sizeof(SName)); } @@ -537,7 +547,7 @@ static int32_t refreshGetTableMeta(STranslateContext* pCxt, const char* pDbName, STableMeta** pMeta) { SParseContext* pParCxt = pCxt->pParseCxt; SName name; - toName(pCxt->pParseCxt->acctId, pDbName, pTableName, &name); + (void)toName(pCxt->pParseCxt->acctId, pDbName, pTableName, &name); int32_t code = TSDB_CODE_SUCCESS; if (pParCxt->async) { code = getTableMetaFromCache(pCxt->pMetaCache, &name, pMeta); @@ -559,7 +569,7 @@ static int32_t refreshGetTableMeta(STranslateContext* pCxt, const char* pDbName, static int32_t getDBVgInfoImpl(STranslateContext* pCxt, const SName* pName, SArray** pVgInfo) { SParseContext* pParCxt = pCxt->pParseCxt; char fullDbName[TSDB_DB_FNAME_LEN]; - tNameGetFullDbName(pName, fullDbName); + (void)tNameGetFullDbName(pName, fullDbName); int32_t code = collectUseDatabaseImpl(fullDbName, pCxt->pDbs); if (TSDB_CODE_SUCCESS == code) { if (pParCxt->async) { @@ -581,9 +591,10 @@ static int32_t getDBVgInfoImpl(STranslateContext* pCxt, const SName* pName, SArr static int32_t getDBVgInfo(STranslateContext* pCxt, const char* pDbName, SArray** pVgInfo) { SName name; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pDbName, strlen(pDbName)); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pDbName, strlen(pDbName)); + if (TSDB_CODE_SUCCESS != code) return code; char dbFname[TSDB_DB_FNAME_LEN] = {0}; - tNameGetFullDbName(&name, dbFname); + (void)tNameGetFullDbName(&name, dbFname); return getDBVgInfoImpl(pCxt, &name, pVgInfo); } @@ -642,10 +653,11 @@ static int32_t getDBCfg(STranslateContext* pCxt, const char* pDbName, SDbCfgInfo SParseContext* pParCxt = pCxt->pParseCxt; SName name; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pDbName, strlen(pDbName)); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pDbName, strlen(pDbName)); + if (TSDB_CODE_SUCCESS != code) return code; char dbFname[TSDB_DB_FNAME_LEN] = {0}; - tNameGetFullDbName(&name, dbFname); - int32_t code = collectUseDatabaseImpl(dbFname, pCxt->pDbs); + (void)tNameGetFullDbName(&name, dbFname); + code = collectUseDatabaseImpl(dbFname, pCxt->pDbs); if (TSDB_CODE_SUCCESS == code) { if (pParCxt->async) { code = getDbCfgFromCache(pCxt->pMetaCache, dbFname, pInfo); @@ -801,7 +813,7 @@ static int32_t resetHighLevelTranslateNamespace(STranslateContext* pCxt) { } for (int32_t i = size - 1; i >= pCxt->currLevel; --i) { - taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); + (void)taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); } taosArrayPopTailBatch(pCxt->pNsLevel, levelNum); @@ -818,9 +830,9 @@ static int32_t resetTranslateNamespace(STranslateContext* pCxt) { if (NULL != pCxt->pNsLevel) { size_t size = taosArrayGetSize(pCxt->pNsLevel); for (size_t i = 0; i < size; ++i) { - taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); + (void)taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); } - taosArrayDestroy(pCxt->pNsLevel); + (void)taosArrayDestroy(pCxt->pNsLevel); } pCxt->pNsLevel = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES); if (NULL == pCxt->pNsLevel) { @@ -833,9 +845,9 @@ static void destroyTranslateContext(STranslateContext* pCxt) { if (NULL != pCxt->pNsLevel) { size_t size = taosArrayGetSize(pCxt->pNsLevel); for (size_t i = 0; i < size; ++i) { - taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); + (void)taosArrayDestroy(taosArrayGetP(pCxt->pNsLevel, i)); } - taosArrayDestroy(pCxt->pNsLevel); + (void)taosArrayDestroy(pCxt->pNsLevel); } if (NULL != pCxt->pCmdMsg) { @@ -1024,66 +1036,83 @@ static bool isBlockTimeLineAlignedQuery(SNode* pStmt) { return false; } -SNodeList* buildPartitionListFromOrderList(SNodeList* pOrderList, int32_t nodesNum) { +int32_t buildPartitionListFromOrderList(SNodeList* pOrderList, int32_t nodesNum, SNodeList**ppOut) { + *ppOut = NULL; SNodeList* pPartitionList = NULL; SNode* pNode = NULL; if (pOrderList->length <= nodesNum) { - return NULL; + return TSDB_CODE_SUCCESS; } pNode = nodesListGetNode(pOrderList, nodesNum); SOrderByExprNode* pOrder = (SOrderByExprNode*)pNode; if (!isPrimaryKeyImpl(pOrder->pExpr)) { - return NULL; + return TSDB_CODE_SUCCESS; } + int32_t code = 0; for (int32_t i = 0; i < nodesNum; ++i) { pNode = nodesListGetNode(pOrderList, i); pOrder = (SOrderByExprNode*)pNode; - nodesListMakeStrictAppend(&pPartitionList, nodesCloneNode(pOrder->pExpr)); + code = nodesListMakeStrictAppend(&pPartitionList, nodesCloneNode(pOrder->pExpr)); + if (TSDB_CODE_SUCCESS != code) { + break; + } } + if(TSDB_CODE_SUCCESS == code) + *ppOut = pPartitionList; - return pPartitionList; + return code; } -static bool isTimeLineAlignedQuery(SNode* pStmt) { +static int32_t isTimeLineAlignedQuery(SNode* pStmt, bool* pRes) { + int32_t code = TSDB_CODE_SUCCESS; SSelectStmt* pSelect = (SSelectStmt*)pStmt; if (!isTimeLineQuery(((STempTableNode*)pSelect->pFromTable)->pSubquery)) { - return false; + *pRes = false; + return code; } if (QUERY_NODE_SELECT_STMT == nodeType(((STempTableNode*)pSelect->pFromTable)->pSubquery)) { SSelectStmt* pSub = (SSelectStmt*)((STempTableNode*)pSelect->pFromTable)->pSubquery; if (pSelect->pPartitionByList) { if (!pSub->timeLineFromOrderBy && nodesListMatch(pSelect->pPartitionByList, pSub->pPartitionByList)) { - return true; + *pRes = true; + return code; } if (pSub->timeLineFromOrderBy && pSub->pOrderByList->length > 1) { - SNodeList* pPartitionList = - buildPartitionListFromOrderList(pSub->pOrderByList, pSelect->pPartitionByList->length); - bool match = nodesListMatch(pSelect->pPartitionByList, pPartitionList); - nodesDestroyList(pPartitionList); + SNodeList* pPartitionList = NULL; + code = buildPartitionListFromOrderList(pSub->pOrderByList, pSelect->pPartitionByList->length, &pPartitionList); + if (TSDB_CODE_SUCCESS == code) { + bool match = nodesListMatch(pSelect->pPartitionByList, pPartitionList); + nodesDestroyList(pPartitionList); - if (match) { - return true; + if (match) { + *pRes = true; + return code; + } } } } } - if (QUERY_NODE_SET_OPERATOR == nodeType(((STempTableNode*)pSelect->pFromTable)->pSubquery)) { + if (TSDB_CODE_SUCCESS == code && QUERY_NODE_SET_OPERATOR == nodeType(((STempTableNode*)pSelect->pFromTable)->pSubquery)) { SSetOperator* pSub = (SSetOperator*)((STempTableNode*)pSelect->pFromTable)->pSubquery; if (pSelect->pPartitionByList && pSub->timeLineFromOrderBy && pSub->pOrderByList->length > 1) { - SNodeList* pPartitionList = - buildPartitionListFromOrderList(pSub->pOrderByList, pSelect->pPartitionByList->length); - bool match = nodesListMatch(pSelect->pPartitionByList, pPartitionList); - nodesDestroyList(pPartitionList); + SNodeList* pPartitionList = NULL; + code = buildPartitionListFromOrderList(pSub->pOrderByList, pSelect->pPartitionByList->length, &pPartitionList); + if (TSDB_CODE_SUCCESS == code) { + bool match = nodesListMatch(pSelect->pPartitionByList, pPartitionList); + nodesDestroyList(pPartitionList); - if (match) { - return true; + if (match) { + *pRes = true; + return code; + } } } } - return false; + *pRes = false; + return code; } bool isPrimaryKeyImpl(SNode* pExpr) { @@ -1159,16 +1188,17 @@ static void setColumnInfoBySchema(const SRealTableNode* pTable, const SSchema* p pCol->numOfPKs = pTable->pMeta->tableInfo.numOfPKs; } -static void setColumnInfoByExpr(STempTableNode* pTable, SExprNode* pExpr, SColumnNode** pColRef) { +static int32_t setColumnInfoByExpr(STempTableNode* pTable, SExprNode* pExpr, SColumnNode** pColRef) { SColumnNode* pCol = *pColRef; if (NULL == pExpr->pAssociation) { pExpr->pAssociation = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SAssociationNode)); + if (!pExpr->pAssociation) return TSDB_CODE_OUT_OF_MEMORY; } SAssociationNode assNode; assNode.pPlace = (SNode**)pColRef; assNode.pAssociationNode = (SNode*)*pColRef; - taosArrayPush(pExpr->pAssociation, &assNode); + (void)taosArrayPush(pExpr->pAssociation, &assNode); strcpy(pCol->tableAlias, pTable->table.tableAlias); pCol->isPrimTs = isPrimaryKeyImpl((SNode*)pExpr); @@ -1186,6 +1216,7 @@ static void setColumnInfoByExpr(STempTableNode* pTable, SExprNode* pExpr, SColum strcpy(pCol->node.userAlias, pExpr->userAlias); } pCol->node.resType = pExpr->resType; + return TSDB_CODE_SUCCESS; } static void setColumnPrimTs(STranslateContext* pCxt, SColumnNode* pCol, const STableNode* pTable) { @@ -1230,6 +1261,7 @@ static void setColumnPrimTs(STranslateContext* pCxt, SColumnNode* pCol, const ST } static int32_t createColumnsByTable(STranslateContext* pCxt, const STableNode* pTable, bool igTags, SNodeList* pList) { + int32_t code = 0; if (QUERY_NODE_REAL_TABLE == nodeType(pTable)) { const STableMeta* pMeta = ((SRealTableNode*)pTable)->pMeta; int32_t nums = pMeta->tableInfo.numOfColumns + @@ -1245,7 +1277,7 @@ static int32_t createColumnsByTable(STranslateContext* pCxt, const STableNode* p } setColumnInfoBySchema((SRealTableNode*)pTable, pMeta->schema + i, (i - pMeta->tableInfo.numOfColumns), pCol); setColumnPrimTs(pCxt, pCol, pTable); - nodesListAppend(pList, (SNode*)pCol); + code = nodesListStrictAppend(pList, (SNode*)pCol); } } else { STempTableNode* pTempTable = (STempTableNode*)pTable; @@ -1256,12 +1288,15 @@ static int32_t createColumnsByTable(STranslateContext* pCxt, const STableNode* p if (NULL == pCol) { return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY); } - nodesListAppend(pList, (SNode*)pCol); - SListCell* pCell = nodesListGetCell(pList, LIST_LENGTH(pList) - 1); - setColumnInfoByExpr(pTempTable, (SExprNode*)pNode, (SColumnNode**)&pCell->pNode); + code = nodesListStrictAppend(pList, (SNode*)pCol); + if (TSDB_CODE_SUCCESS == code) { + SListCell* pCell = nodesListGetCell(pList, LIST_LENGTH(pList) - 1); + code = setColumnInfoByExpr(pTempTable, (SExprNode*)pNode, (SColumnNode**)&pCell->pNode); + } + if (TSDB_CODE_SUCCESS != code) break; } } - return TSDB_CODE_SUCCESS; + return code; } static bool isInternalPrimaryKey(const SColumnNode* pCol) { @@ -1294,6 +1329,7 @@ static int32_t findAndSetColumn(STranslateContext* pCxt, SColumnNode** pColRef, } } + int32_t code = 0; if (QUERY_NODE_REAL_TABLE == nodeType(pTable)) { const STableMeta* pMeta = ((SRealTableNode*)pTable)->pMeta; if (isInternalPrimaryKey(pCol)) { @@ -1326,16 +1362,20 @@ static int32_t findAndSetColumn(STranslateContext* pCxt, SColumnNode** pColRef, if (*pFound) { return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_AMBIGUOUS_COLUMN, pCol->colName); } - setColumnInfoByExpr(pTempTable, pExpr, pColRef); + code = setColumnInfoByExpr(pTempTable, pExpr, pColRef); + if (TSDB_CODE_SUCCESS != code) { + break; + } *pFound = true; } else if (isPrimaryKeyImpl(pNode) && isInternalPrimaryKey(pCol)) { - setColumnInfoByExpr(pTempTable, pExpr, pColRef); + code = setColumnInfoByExpr(pTempTable, pExpr, pColRef); + if (TSDB_CODE_SUCCESS != code) break; pCol->isPrimTs = true; *pFound = true; } } } - return TSDB_CODE_SUCCESS; + return code; } static EDealRes translateColumnWithPrefix(STranslateContext* pCxt, SColumnNode** pCol) { @@ -1441,11 +1481,17 @@ static void biMakeAliasNameInMD5(char* pExprStr, int32_t len, char* pAlias) { } } -static SNode* biMakeTbnameProjectAstNode(char* funcName, char* tableAlias) { +static int32_t biMakeTbnameProjectAstNode(char* funcName, char* tableAlias, SNode** pOutNode) { + int32_t code = 0; SValueNode* valNode = NULL; if (tableAlias != NULL) { SValueNode* n = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + if (!n) return TSDB_CODE_OUT_OF_MEMORY; n->literal = tstrdup(tableAlias); + if (!n->literal) { + nodesDestroyNode((SNode*)n); + return TSDB_CODE_OUT_OF_MEMORY; + } n->node.resType.type = TSDB_DATA_TYPE_BINARY; n->node.resType.bytes = strlen(n->literal); n->translate = false; @@ -1453,39 +1499,63 @@ static SNode* biMakeTbnameProjectAstNode(char* funcName, char* tableAlias) { } SFunctionNode* tbNameFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - tstrncpy(tbNameFunc->functionName, "tbname", TSDB_FUNC_NAME_LEN); - if (valNode != NULL) { - nodesListMakeAppend(&tbNameFunc->pParameterList, (SNode*)valNode); + if (!tbNameFunc) { + nodesDestroyNode((SNode*)valNode); + valNode = NULL; + code = TSDB_CODE_OUT_OF_MEMORY; } - snprintf(tbNameFunc->node.userAlias, sizeof(tbNameFunc->node.userAlias), (tableAlias) ? "%s.tbname" : "%stbname", - (tableAlias) ? tableAlias : ""); - strncpy(tbNameFunc->node.aliasName, tbNameFunc->functionName, TSDB_COL_NAME_LEN); - - if (funcName == NULL) { - return (SNode*)tbNameFunc; - } else { - SFunctionNode* multiResFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - tstrncpy(multiResFunc->functionName, funcName, TSDB_FUNC_NAME_LEN); - nodesListMakeAppend(&multiResFunc->pParameterList, (SNode*)tbNameFunc); - - if (tsKeepColumnName) { - snprintf(multiResFunc->node.userAlias, sizeof(tbNameFunc->node.userAlias), - (tableAlias) ? "%s.tbname" : "%stbname", (tableAlias) ? tableAlias : ""); - strcpy(multiResFunc->node.aliasName, tbNameFunc->functionName); - } else { - snprintf(multiResFunc->node.userAlias, sizeof(multiResFunc->node.userAlias), - tableAlias ? "%s(%s.tbname)" : "%s(%stbname)", funcName, tableAlias ? tableAlias : ""); - biMakeAliasNameInMD5(multiResFunc->node.userAlias, strlen(multiResFunc->node.userAlias), - multiResFunc->node.aliasName); + if (TSDB_CODE_SUCCESS == code) { + tstrncpy(tbNameFunc->functionName, "tbname", TSDB_FUNC_NAME_LEN); + if (valNode != NULL) { + code = nodesListMakeStrictAppend(&tbNameFunc->pParameterList, (SNode*)valNode); + valNode = NULL; } - - return (SNode*)multiResFunc; } + if (TSDB_CODE_SUCCESS == code) { + snprintf(tbNameFunc->node.userAlias, sizeof(tbNameFunc->node.userAlias), (tableAlias) ? "%s.tbname" : "%stbname", + (tableAlias) ? tableAlias : ""); + strncpy(tbNameFunc->node.aliasName, tbNameFunc->functionName, TSDB_COL_NAME_LEN); + if (funcName == NULL) { + *pOutNode = (SNode*)tbNameFunc; + return code; + } else { + SFunctionNode* multiResFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + if (!multiResFunc) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + + if (TSDB_CODE_SUCCESS == code) { + tstrncpy(multiResFunc->functionName, funcName, TSDB_FUNC_NAME_LEN); + code = nodesListMakeStrictAppend(&multiResFunc->pParameterList, (SNode*)tbNameFunc); + if (TSDB_CODE_SUCCESS != code) tbNameFunc = NULL; + } + + if (TSDB_CODE_SUCCESS == code) { + if (tsKeepColumnName) { + snprintf(multiResFunc->node.userAlias, sizeof(tbNameFunc->node.userAlias), + (tableAlias) ? "%s.tbname" : "%stbname", (tableAlias) ? tableAlias : ""); + strcpy(multiResFunc->node.aliasName, tbNameFunc->functionName); + } else { + snprintf(multiResFunc->node.userAlias, sizeof(multiResFunc->node.userAlias), + tableAlias ? "%s(%s.tbname)" : "%s(%stbname)", funcName, tableAlias ? tableAlias : ""); + biMakeAliasNameInMD5(multiResFunc->node.userAlias, strlen(multiResFunc->node.userAlias), + multiResFunc->node.aliasName); + } + *pOutNode = (SNode*)multiResFunc; + } else { + nodesDestroyNode((SNode*)multiResFunc); + } + } + } + if (TSDB_CODE_SUCCESS != code) nodesDestroyNode((SNode*)tbNameFunc); + return code; } static int32_t biRewriteSelectFuncParamStar(STranslateContext* pCxt, SSelectStmt* pSelect, SNode* pNode, SListCell* pSelectListCell) { SNodeList* pTbnameNodeList = nodesMakeList(); + if (!pTbnameNodeList) return TSDB_CODE_OUT_OF_MEMORY; + int32_t code = 0; SFunctionNode* pFunc = (SFunctionNode*)pNode; if (strcasecmp(pFunc->functionName, "last") == 0 || strcasecmp(pFunc->functionName, "last_row") == 0 || @@ -1496,16 +1566,19 @@ static int32_t biRewriteSelectFuncParamStar(STranslateContext* pCxt, SSelectStmt if (nodesIsStar(pPara)) { SArray* pTables = taosArrayGetP(pCxt->pNsLevel, pCxt->currLevel); size_t n = taosArrayGetSize(pTables); - for (int32_t i = 0; i < n; ++i) { + for (int32_t i = 0; i < n && TSDB_CODE_SUCCESS == code; ++i) { STableNode* pTable = taosArrayGetP(pTables, i); if (nodeType(pTable) == QUERY_NODE_REAL_TABLE && ((SRealTableNode*)pTable)->pMeta != NULL && ((SRealTableNode*)pTable)->pMeta->tableType == TSDB_SUPER_TABLE) { - SNode* pTbnameNode = biMakeTbnameProjectAstNode(pFunc->functionName, NULL); - nodesListAppend(pTbnameNodeList, pTbnameNode); + SNode* pTbnameNode = NULL; + code = biMakeTbnameProjectAstNode(pFunc->functionName, NULL, &pTbnameNode); + if (TSDB_CODE_SUCCESS == code) + code = nodesListStrictAppend(pTbnameNodeList, pTbnameNode); } } - if (LIST_LENGTH(pTbnameNodeList) > 0) { + if (TSDB_CODE_SUCCESS == code && LIST_LENGTH(pTbnameNodeList) > 0) { nodesListInsertListAfterPos(pSelect->pProjectionList, pSelectListCell, pTbnameNodeList); + pTbnameNodeList = NULL; } } else if (nodesIsTableStar(pPara)) { char* pTableAlias = ((SColumnNode*)pPara)->tableAlias; @@ -1514,37 +1587,47 @@ static int32_t biRewriteSelectFuncParamStar(STranslateContext* pCxt, SSelectStmt if (TSDB_CODE_SUCCESS == code && nodeType(pTable) == QUERY_NODE_REAL_TABLE && ((SRealTableNode*)pTable)->pMeta != NULL && ((SRealTableNode*)pTable)->pMeta->tableType == TSDB_SUPER_TABLE) { - SNode* pTbnameNode = biMakeTbnameProjectAstNode(pFunc->functionName, pTableAlias); - nodesListAppend(pTbnameNodeList, pTbnameNode); + SNode* pTbnameNode = NULL; + code = biMakeTbnameProjectAstNode(pFunc->functionName, pTableAlias, &pTbnameNode); + if (TSDB_CODE_SUCCESS == code) + code = nodesListStrictAppend(pTbnameNodeList, pTbnameNode); } - if (LIST_LENGTH(pTbnameNodeList) > 0) { + if (TSDB_CODE_SUCCESS == code && LIST_LENGTH(pTbnameNodeList) > 0) { nodesListInsertListAfterPos(pSelect->pProjectionList, pSelectListCell, pTbnameNodeList); + pTbnameNodeList = NULL; } } + if (TSDB_CODE_SUCCESS != code) break; } } - return TSDB_CODE_SUCCESS; + nodesDestroyList(pTbnameNodeList); + return code; } // after translate from // before translate select list int32_t biRewriteSelectStar(STranslateContext* pCxt, SSelectStmt* pSelect) { + int32_t code = TSDB_CODE_SUCCESS; SNode* pNode = NULL; SNodeList* pTbnameNodeList = nodesMakeList(); + if (!pTbnameNodeList) return TSDB_CODE_OUT_OF_MEMORY; WHERE_EACH(pNode, pSelect->pProjectionList) { if (nodesIsStar(pNode)) { SArray* pTables = taosArrayGetP(pCxt->pNsLevel, pCxt->currLevel); size_t n = taosArrayGetSize(pTables); - for (int32_t i = 0; i < n; ++i) { + for (int32_t i = 0; i < n && TSDB_CODE_SUCCESS == code; ++i) { STableNode* pTable = taosArrayGetP(pTables, i); if (nodeType(pTable) == QUERY_NODE_REAL_TABLE && ((SRealTableNode*)pTable)->pMeta != NULL && ((SRealTableNode*)pTable)->pMeta->tableType == TSDB_SUPER_TABLE) { - SNode* pTbnameNode = biMakeTbnameProjectAstNode(NULL, NULL); - nodesListAppend(pTbnameNodeList, pTbnameNode); + SNode* pTbnameNode = NULL; + code = biMakeTbnameProjectAstNode(NULL, NULL, &pTbnameNode); + if (TSDB_CODE_SUCCESS == code) + code = nodesListStrictAppend(pTbnameNodeList, pTbnameNode); } } - if (LIST_LENGTH(pTbnameNodeList) > 0) { + if (TSDB_CODE_SUCCESS == code && LIST_LENGTH(pTbnameNodeList) > 0) { nodesListInsertListAfterPos(pSelect->pProjectionList, cell, pTbnameNodeList); + pTbnameNodeList = NULL; } } else if (nodesIsTableStar(pNode)) { char* pTableAlias = ((SColumnNode*)pNode)->tableAlias; @@ -1552,38 +1635,46 @@ int32_t biRewriteSelectStar(STranslateContext* pCxt, SSelectStmt* pSelect) { int32_t code = findTable(pCxt, pTableAlias, &pTable); if (TSDB_CODE_SUCCESS == code && nodeType(pTable) == QUERY_NODE_REAL_TABLE && ((SRealTableNode*)pTable)->pMeta != NULL && ((SRealTableNode*)pTable)->pMeta->tableType == TSDB_SUPER_TABLE) { - SNode* pTbnameNode = biMakeTbnameProjectAstNode(NULL, pTableAlias); - nodesListAppend(pTbnameNodeList, pTbnameNode); + SNode* pTbnameNode = NULL; + code = biMakeTbnameProjectAstNode(NULL, pTableAlias, &pTbnameNode); + if (TSDB_CODE_SUCCESS ==code) + code = nodesListStrictAppend(pTbnameNodeList, pTbnameNode); } - if (LIST_LENGTH(pTbnameNodeList) > 0) { + if (TSDB_CODE_SUCCESS == code && LIST_LENGTH(pTbnameNodeList) > 0) { nodesListInsertListAfterPos(pSelect->pProjectionList, cell, pTbnameNodeList); + pTbnameNodeList = NULL; } } else if (nodeType(pNode) == QUERY_NODE_FUNCTION) { - biRewriteSelectFuncParamStar(pCxt, pSelect, pNode, cell); + code = biRewriteSelectFuncParamStar(pCxt, pSelect, pNode, cell); } + if (TSDB_CODE_SUCCESS != code) break; WHERE_NEXT; } + nodesDestroyList(pTbnameNodeList); - return TSDB_CODE_SUCCESS; + return code; } -bool biRewriteToTbnameFunc(STranslateContext* pCxt, SNode** ppNode) { +int32_t biRewriteToTbnameFunc(STranslateContext* pCxt, SNode** ppNode, bool* pRet) { SColumnNode* pCol = (SColumnNode*)(*ppNode); if ((strcasecmp(pCol->colName, "tbname") == 0) && ((SSelectStmt*)pCxt->pCurrStmt)->pFromTable && QUERY_NODE_REAL_TABLE == nodeType(((SSelectStmt*)pCxt->pCurrStmt)->pFromTable)) { SFunctionNode* tbnameFuncNode = NULL; - tbnameFuncNode = - (SFunctionNode*)biMakeTbnameProjectAstNode(NULL, (pCol->tableAlias[0] != '\0') ? pCol->tableAlias : NULL); + int32_t code = biMakeTbnameProjectAstNode(NULL, (pCol->tableAlias[0] != '\0') ? pCol->tableAlias : NULL, + (SNode**)&tbnameFuncNode); + if (TSDB_CODE_SUCCESS != code) return code; tbnameFuncNode->node.resType = pCol->node.resType; strcpy(tbnameFuncNode->node.aliasName, pCol->node.aliasName); strcpy(tbnameFuncNode->node.userAlias, pCol->node.userAlias); nodesDestroyNode(*ppNode); *ppNode = (SNode*)tbnameFuncNode; - return true; + *pRet = true; + return TSDB_CODE_SUCCESS; } - return false; + *pRet = false; + return TSDB_CODE_SUCCESS; } int32_t biCheckCreateTableTbnameCol(STranslateContext* pCxt, SCreateTableStmt* pStmt) { @@ -1625,7 +1716,10 @@ static EDealRes translateColumn(STranslateContext* pCxt, SColumnNode** pCol) { if (pCxt->pParseCxt->biMode) { SNode** ppNode = (SNode**)pCol; - if (biRewriteToTbnameFunc(pCxt, ppNode)) { + bool ret; + pCxt->errCode = biRewriteToTbnameFunc(pCxt, ppNode, &ret); + if (TSDB_CODE_SUCCESS != pCxt->errCode) return DEAL_RES_ERROR; + if (ret) { return translateFunction(pCxt, (SFunctionNode**)ppNode); } } @@ -2034,9 +2128,9 @@ static int32_t rewriteCountStarAsCount1(STranslateContext* pCxt, SFunctionNode* pVal->node.resType.type = TSDB_DATA_TYPE_INT; pVal->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes; const int32_t val = 1; - nodesSetValueNodeValue(pVal, (void*)&val); + (void)nodesSetValueNodeValue(pVal, (void*)&val); pVal->translate = true; - nodesListErase(pCount->pParameterList, nodesListGetCell(pCount->pParameterList, 0)); + (void)nodesListErase(pCount->pParameterList, nodesListGetCell(pCount->pParameterList, 0)); code = nodesListAppend(pCount->pParameterList, (SNode*)pVal); return code; } @@ -2292,7 +2386,7 @@ static int32_t translateInterpPseudoColumnFunc(STranslateContext* pCxt, SNode** if (code != TSDB_CODE_SUCCESS) { return code; } - translateColumn(pCxt, (SColumnNode**)ppNode); + (void)translateColumn(pCxt, (SColumnNode**)ppNode); return pCxt->errCode; } return TSDB_CODE_SUCCESS; @@ -2307,11 +2401,17 @@ static int32_t translateTimelineFunc(STranslateContext* pCxt, SFunctionNode* pFu "%s function must be used in select statements", pFunc->functionName); } SSelectStmt* pSelect = (SSelectStmt*)pCxt->pCurrStmt; + bool isTimelineAlignedQuery = false; if ((NULL != pSelect->pFromTable && QUERY_NODE_TEMP_TABLE == nodeType(pSelect->pFromTable) && - !isGlobalTimeLineQuery(((STempTableNode*)pSelect->pFromTable)->pSubquery) && - !isTimeLineAlignedQuery(pCxt->pCurrStmt)) || - (NULL != pSelect->pFromTable && QUERY_NODE_JOIN_TABLE == nodeType(pSelect->pFromTable) && - (TIME_LINE_GLOBAL != pSelect->timeLineCurMode && TIME_LINE_MULTI != pSelect->timeLineCurMode))) { + !isGlobalTimeLineQuery(((STempTableNode*)pSelect->pFromTable)->pSubquery))) { + int32_t code = isTimeLineAlignedQuery(pCxt->pCurrStmt, &isTimelineAlignedQuery); + if (TSDB_CODE_SUCCESS != code) return code; + if (!isTimelineAlignedQuery) + return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_NOT_ALLOWED_FUNC, + "%s function requires valid time series input", pFunc->functionName); + } + if (NULL != pSelect->pFromTable && QUERY_NODE_JOIN_TABLE == nodeType(pSelect->pFromTable) && + (TIME_LINE_GLOBAL != pSelect->timeLineCurMode && TIME_LINE_MULTI != pSelect->timeLineCurMode)) { return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_NOT_ALLOWED_FUNC, "%s function requires valid time series input", pFunc->functionName); } @@ -2494,7 +2594,7 @@ static void setFuncClassification(SNode* pCurrStmt, SFunctionNode* pFunc) { } } -static int32_t rewriteFuncToValue(STranslateContext* pCxt, char* pLiteral, SNode** pNode) { +static int32_t rewriteFuncToValue(STranslateContext* pCxt, char** pLiteral, SNode** pNode) { SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); if (NULL == pVal) { return TSDB_CODE_OUT_OF_MEMORY; @@ -2502,13 +2602,14 @@ static int32_t rewriteFuncToValue(STranslateContext* pCxt, char* pLiteral, SNode strcpy(pVal->node.aliasName, ((SExprNode*)*pNode)->aliasName); strcpy(pVal->node.userAlias, ((SExprNode*)*pNode)->userAlias); pVal->node.resType = ((SExprNode*)*pNode)->resType; - if (NULL == pLiteral) { + if (NULL == pLiteral || NULL == *pLiteral) { pVal->isNull = true; } else { - pVal->literal = pLiteral; + pVal->literal = *pLiteral; if (IS_VAR_DATA_TYPE(pVal->node.resType.type)) { - pVal->node.resType.bytes = strlen(pLiteral); + pVal->node.resType.bytes = strlen(*pLiteral); } + *pLiteral = NULL; } if (DEAL_RES_ERROR != translateValue(pCxt, pVal)) { nodesDestroyNode(*pNode); @@ -2527,7 +2628,9 @@ static int32_t rewriteDatabaseFunc(STranslateContext* pCxt, SNode** pNode) { return TSDB_CODE_OUT_OF_MEMORY; } } - return rewriteFuncToValue(pCxt, pCurrDb, pNode); + int32_t code = rewriteFuncToValue(pCxt, &pCurrDb, pNode); + if (TSDB_CODE_SUCCESS != code) taosMemoryFree(pCurrDb); + return code; } static int32_t rewriteClentVersionFunc(STranslateContext* pCxt, SNode** pNode) { @@ -2535,7 +2638,9 @@ static int32_t rewriteClentVersionFunc(STranslateContext* pCxt, SNode** pNode) { if (NULL == pVer) { return TSDB_CODE_OUT_OF_MEMORY; } - return rewriteFuncToValue(pCxt, pVer, pNode); + int32_t code = rewriteFuncToValue(pCxt, &pVer, pNode); + if (TSDB_CODE_SUCCESS != code) taosMemoryFree(pVer); + return code; } static int32_t rewriteServerVersionFunc(STranslateContext* pCxt, SNode** pNode) { @@ -2543,7 +2648,9 @@ static int32_t rewriteServerVersionFunc(STranslateContext* pCxt, SNode** pNode) if (NULL == pVer) { return TSDB_CODE_OUT_OF_MEMORY; } - return rewriteFuncToValue(pCxt, pVer, pNode); + int32_t code = rewriteFuncToValue(pCxt, &pVer, pNode); + if (TSDB_CODE_SUCCESS != code) taosMemoryFree(pVer); + return code; } static int32_t rewriteServerStatusFunc(STranslateContext* pCxt, SNode** pNode) { @@ -2551,18 +2658,26 @@ static int32_t rewriteServerStatusFunc(STranslateContext* pCxt, SNode** pNode) { return TSDB_CODE_RPC_NETWORK_UNAVAIL; } char* pStatus = taosStrdup((void*)"1"); - return rewriteFuncToValue(pCxt, pStatus, pNode); + int32_t code = rewriteFuncToValue(pCxt, &pStatus, pNode); + if (TSDB_CODE_SUCCESS != code) taosMemoryFree(pStatus); + return code; } static int32_t rewriteUserFunc(STranslateContext* pCxt, SNode** pNode) { char userConn[TSDB_USER_LEN + 1 + TSDB_FQDN_LEN] = {0}; // format 'user@host' int32_t len = snprintf(userConn, sizeof(userConn), "%s@", pCxt->pParseCxt->pUser); - taosGetFqdn(userConn + len); + if (TSDB_CODE_SUCCESS != taosGetFqdn(userConn + len)) { + return terrno; + } char* pUserConn = taosStrdup((void*)userConn); if (NULL == pUserConn) { return TSDB_CODE_OUT_OF_MEMORY; } - return rewriteFuncToValue(pCxt, pUserConn, pNode); + int32_t code = rewriteFuncToValue(pCxt, &pUserConn, pNode); + if (TSDB_CODE_SUCCESS != code) { + taosMemoryFree(pUserConn); + } + return code; } static int32_t rewriteSystemInfoFunc(STranslateContext* pCxt, SNode** pNode) { @@ -2622,7 +2737,7 @@ static int32_t rewriteToColumnAndRetranslate(STranslateContext* pCxt, SNode** pp if (code != TSDB_CODE_SUCCESS) { return code; } - translateColumn(pCxt, (SColumnNode**)ppNode); + (void)translateColumn(pCxt, (SColumnNode**)ppNode); if (pCxt->errCode != TSDB_CODE_SUCCESS) { return generateSyntaxErrMsg(&pCxt->msgBuf, errCode); } else { @@ -2750,7 +2865,9 @@ static int32_t rewriteQueryTimeFunc(STranslateContext* pCxt, int64_t val, SNode* return TSDB_CODE_OUT_OF_MEMORY; } snprintf(pStr, 20, "%" PRId64 "", val); - return rewriteFuncToValue(pCxt, pStr, pNode); + int32_t code = rewriteFuncToValue(pCxt, &pStr, pNode); + if (TSDB_CODE_SUCCESS != code) taosMemoryFree(pStr); + return code; } static int32_t rewriteQstartFunc(STranslateContext* pCxt, SNode** pNode) { @@ -3389,12 +3506,17 @@ static EDealRes doCheckAggColCoexist(SNode** pNode, void* pContext) { static EDealRes doCheckGetAggColCoexist(SNode** pNode, void* pContext) { CheckAggColCoexistCxt* pCxt = (CheckAggColCoexistCxt*)pContext; + int32_t code = 0; if (isVectorFunc(*pNode)) { return DEAL_RES_IGNORE_CHILD; } if (isScanPseudoColumnFunc(*pNode) || QUERY_NODE_COLUMN == nodeType(*pNode)) { pCxt->existCol = true; - nodesListMakeStrictAppend(&pCxt->pColList, *pNode); + code = nodesListMakeStrictAppend(&pCxt->pColList, *pNode); + if (TSDB_CODE_SUCCESS != code) { + pCxt->pTranslateCxt->errCode = code; + return DEAL_RES_ERROR; + } } return DEAL_RES_CONTINUE; } @@ -3563,7 +3685,9 @@ static int32_t addMnodeToVgroupList(const SEpSet* pEpSet, SArray** pVgroupList) } SVgroupInfo vg = {.vgId = MNODE_HANDLE}; memcpy(&vg.epSet, pEpSet, sizeof(SEpSet)); - taosArrayPush(*pVgroupList, &vg); + if (NULL == taosArrayPush(*pVgroupList, &vg)) { + return TSDB_CODE_OUT_OF_MEMORY; + } return TSDB_CODE_SUCCESS; } @@ -3616,7 +3740,9 @@ static int32_t getVnodeSysTableVgroupListImpl(STranslateContext* pCxt, SName* pT if (NULL == *pVgroupList) { code = TSDB_CODE_OUT_OF_MEMORY; } else { - taosArrayPush(*pVgroupList, &vgInfo); + if (NULL == taosArrayPush(*pVgroupList, &vgInfo)) { + code = TSDB_CODE_OUT_OF_MEMORY; + } } } else if (TSDB_CODE_MND_DB_NOT_EXIST == code || TSDB_CODE_MND_DB_IN_CREATING == code || TSDB_CODE_MND_DB_IN_DROPPING == code) { @@ -3659,7 +3785,7 @@ static int32_t setVnodeSysTableVgroupList(STranslateContext* pCxt, SName* pName, if (TSDB_CODE_SUCCESS == code) { code = toVgroupsInfo(pVgs, &pRealTable->pVgroupList); } - taosArrayDestroy(pVgs); + (void)taosArrayDestroy(pVgs); return code; } @@ -3670,7 +3796,7 @@ static int32_t setDnodeSysTableVgroupList(STranslateContext* pCxt, SName* pName, if (TSDB_CODE_SUCCESS == code) { code = dnodeToVgroupsInfo(pDnodes, &pRealTable->pVgroupList); } - taosArrayDestroy(pDnodes); + (void)taosArrayDestroy(pDnodes); return code; } @@ -3690,7 +3816,7 @@ static int32_t setSuperTableVgroupList(STranslateContext* pCxt, SName* pName, SR if (TSDB_CODE_SUCCESS == code) { code = toVgroupsInfo(vgroupList, &pRealTable->pVgroupList); } - taosArrayDestroy(vgroupList); + (void)taosArrayDestroy(vgroupList); return code; } @@ -3785,15 +3911,16 @@ static int32_t setTableTsmas(STranslateContext* pCxt, SName* pName, SRealTableNo for (int32_t i = 0; i < pRealTable->pTsmas->size; ++i) { STableTSMAInfo* pTsma = taosArrayGetP(pRealTable->pTsmas, i); SName tsmaTargetTbName = {0}; - toName(pCxt->pParseCxt->acctId, pRealTable->table.dbName, "", &tsmaTargetTbName); + SVgroupInfo vgInfo = {0}; + bool exists = false; + (void)toName(pCxt->pParseCxt->acctId, pRealTable->table.dbName, "", &tsmaTargetTbName); int32_t len = snprintf(buf, TSDB_TABLE_FNAME_LEN + TSDB_TABLE_NAME_LEN, "%s.%s_%s", pTsma->dbFName, pTsma->name, pRealTable->table.tableName); len = taosCreateMD5Hash(buf, len); strncpy(tsmaTargetTbName.tname, buf, MD5_OUTPUT_LEN); - collectUseTable(&tsmaTargetTbName, pCxt->pTargetTables); - SVgroupInfo vgInfo = {0}; - bool exists = false; - code = catalogGetCachedTableHashVgroup(pCxt->pParseCxt->pCatalog, &tsmaTargetTbName, &vgInfo, &exists); + code = collectUseTable(&tsmaTargetTbName, pCxt->pTargetTables); + if (TSDB_CODE_SUCCESS == code) + code = catalogGetCachedTableHashVgroup(pCxt->pParseCxt->pCatalog, &tsmaTargetTbName, &vgInfo, &exists); if (TSDB_CODE_SUCCESS == code) { ASSERT(exists); if (!pRealTable->tsmaTargetTbVgInfo) { @@ -3810,7 +3937,7 @@ static int32_t setTableTsmas(STranslateContext* pCxt, SName* pName, SRealTableNo } pVgpsInfo->numOfVgroups = 1; pVgpsInfo->vgroups[0] = vgInfo; - taosArrayPush(pRealTable->tsmaTargetTbVgInfo, &pVgpsInfo); + (void)taosArrayPush(pRealTable->tsmaTargetTbVgInfo, &pVgpsInfo); } else { break; } @@ -3839,7 +3966,7 @@ static int32_t setTableTsmas(STranslateContext* pCxt, SName* pName, SRealTableNo // ignore table not exists error code = TSDB_CODE_SUCCESS; } - taosArrayPush(pRealTable->tsmaTargetTbInfo, &ctbInfo); + (void)taosArrayPush(pRealTable->tsmaTargetTbInfo, &ctbInfo); } } } @@ -4449,9 +4576,10 @@ int32_t translateTable(STranslateContext* pCxt, SNode** pTable, SNode* pJoinPare if (TSDB_VIEW_TABLE == pRealTable->pMeta->tableType && !pCurrSmt->tagScan) { return translateView(pCxt, pTable, &name); } - translateAudit(pCxt, pRealTable, &name); + code = translateAudit(pCxt, pRealTable, &name); #endif - code = setTableVgroupList(pCxt, &name, pRealTable); + if (TSDB_CODE_SUCCESS == code) + code = setTableVgroupList(pCxt, &name, pRealTable); if (TSDB_CODE_SUCCESS == code) { code = setTableIndex(pCxt, &name, pRealTable); } @@ -4579,7 +4707,7 @@ static SNode* createMultiResFunc(SFunctionNode* pSrcFunc, SExprNode* pExpr) { strcpy(pFunc->node.aliasName, pCol->colName); } else { len = snprintf(buf, sizeof(buf) - 1, "%s(%s.%s)", pSrcFunc->functionName, pCol->tableAlias, pCol->colName); - taosCreateMD5Hash(buf, len); + (void)taosCreateMD5Hash(buf, len); strncpy(pFunc->node.aliasName, buf, TSDB_COL_NAME_LEN - 1); len = snprintf(buf, sizeof(buf) - 1, "%s(%s)", pSrcFunc->functionName, pCol->colName); // note: userAlias could be truncated here @@ -4587,7 +4715,7 @@ static SNode* createMultiResFunc(SFunctionNode* pSrcFunc, SExprNode* pExpr) { } } else { len = snprintf(buf, sizeof(buf) - 1, "%s(%s)", pSrcFunc->functionName, pExpr->aliasName); - taosCreateMD5Hash(buf, len); + (void)taosCreateMD5Hash(buf, len); strncpy(pFunc->node.aliasName, buf, TSDB_COL_NAME_LEN - 1); len = snprintf(buf, sizeof(buf) - 1, "%s(%s)", pSrcFunc->functionName, pExpr->userAlias); // note: userAlias could be truncated here @@ -4906,21 +5034,24 @@ static int32_t rewriteProjectAlias(SNodeList* pProjectionList) { static int32_t checkProjectAlias(STranslateContext* pCxt, SNodeList* pProjectionList, SHashObj** pOutput) { SHashObj* pUserAliasSet = taosHashInit(LIST_LENGTH(pProjectionList), taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK); + if (!pUserAliasSet) return TSDB_CODE_OUT_OF_MEMORY; SNode* pProject = NULL; + int32_t code = TSDB_CODE_SUCCESS; FOREACH(pProject, pProjectionList) { SExprNode* pExpr = (SExprNode*)pProject; if (NULL != taosHashGet(pUserAliasSet, pExpr->userAlias, strlen(pExpr->userAlias))) { taosHashCleanup(pUserAliasSet); return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_AMBIGUOUS_COLUMN, pExpr->userAlias); } - taosHashPut(pUserAliasSet, pExpr->userAlias, strlen(pExpr->userAlias), &pExpr, POINTER_BYTES); + code = taosHashPut(pUserAliasSet, pExpr->userAlias, strlen(pExpr->userAlias), &pExpr, POINTER_BYTES); + if (TSDB_CODE_SUCCESS != code) break; } - if (NULL == pOutput) { - taosHashCleanup(pUserAliasSet); - } else { + if (TSDB_CODE_SUCCESS == code && NULL != pOutput) { *pOutput = pUserAliasSet; + } else { + taosHashCleanup(pUserAliasSet); } - return TSDB_CODE_SUCCESS; + return code; } static int32_t translateProjectionList(STranslateContext* pCxt, SSelectStmt* pSelect) { @@ -5009,14 +5140,15 @@ static int32_t getQueryTimeRange(STranslateContext* pCxt, SNode* pWhere, STimeWi } SNode* pPrimaryKeyCond = NULL; - filterPartitionCond(&pCond, &pPrimaryKeyCond, NULL, NULL, NULL); + int32_t code = filterPartitionCond(&pCond, &pPrimaryKeyCond, NULL, NULL, NULL); - int32_t code = TSDB_CODE_SUCCESS; - if (NULL != pPrimaryKeyCond) { - bool isStrict = false; - code = getTimeRange(&pPrimaryKeyCond, pTimeRange, &isStrict); - } else { - *pTimeRange = TSWINDOW_INITIALIZER; + if (TSDB_CODE_SUCCESS == code) { + if (NULL != pPrimaryKeyCond) { + bool isStrict = false; + code = getTimeRange(&pPrimaryKeyCond, pTimeRange, &isStrict); + } else { + *pTimeRange = TSWINDOW_INITIALIZER; + } } nodesDestroyNode(pCond); nodesDestroyNode(pPrimaryKeyCond); @@ -5325,7 +5457,9 @@ static EDealRes collectWindowsPseudocolumns(SNode* pNode, void* pContext) { SFunctionNode* pFunc = (SFunctionNode*)pNode; if (FUNCTION_TYPE_WSTART == pFunc->funcType || FUNCTION_TYPE_WEND == pFunc->funcType || FUNCTION_TYPE_WDURATION == pFunc->funcType) { - nodesListStrictAppend(pCols, nodesCloneNode(pNode)); + if (TSDB_CODE_SUCCESS != nodesListStrictAppend(pCols, nodesCloneNode(pNode))) { + return DEAL_RES_ERROR; + } } } return DEAL_RES_CONTINUE; @@ -5363,26 +5497,37 @@ static int32_t translateWindow(STranslateContext* pCxt, SSelectStmt* pSelect) { ((SRealTableNode*)pSelect->pFromTable)->pMeta->tableType == TSDB_SYSTEM_TABLE) { return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_SYSTABLE_NOT_ALLOWED, "WINDOW"); } - if (QUERY_NODE_INTERVAL_WINDOW != nodeType(pSelect->pWindow) && - ((NULL != pSelect->pFromTable && QUERY_NODE_TEMP_TABLE == nodeType(pSelect->pFromTable) && - !isGlobalTimeLineQuery(((STempTableNode*)pSelect->pFromTable)->pSubquery) && - !isTimeLineAlignedQuery(pCxt->pCurrStmt)) || - (NULL != pSelect->pFromTable && QUERY_NODE_JOIN_TABLE == nodeType(pSelect->pFromTable) && - (TIME_LINE_GLOBAL != pSelect->timeLineCurMode && TIME_LINE_MULTI != pSelect->timeLineCurMode)))) { - return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY); + int32_t code = 0; + if (QUERY_NODE_INTERVAL_WINDOW != nodeType(pSelect->pWindow)) { + if (NULL != pSelect->pFromTable && QUERY_NODE_TEMP_TABLE == nodeType(pSelect->pFromTable) && + !isGlobalTimeLineQuery(((STempTableNode*)pSelect->pFromTable)->pSubquery)) { + bool isTimelineAlignedQuery = false; + code = isTimeLineAlignedQuery(pCxt->pCurrStmt, &isTimelineAlignedQuery); + if (TSDB_CODE_SUCCESS != code) return code; + if (!isTimelineAlignedQuery) return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY); + } + if (NULL != pSelect->pFromTable && QUERY_NODE_JOIN_TABLE == nodeType(pSelect->pFromTable) && + (TIME_LINE_GLOBAL != pSelect->timeLineCurMode && TIME_LINE_MULTI != pSelect->timeLineCurMode)) { + return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY); + } } - if (QUERY_NODE_INTERVAL_WINDOW == nodeType(pSelect->pWindow) && - ((NULL != pSelect->pFromTable && QUERY_NODE_TEMP_TABLE == nodeType(pSelect->pFromTable) && - !isBlockTimeLineQuery(((STempTableNode*)pSelect->pFromTable)->pSubquery) && - !isTimeLineAlignedQuery(pCxt->pCurrStmt)) || - (NULL != pSelect->pFromTable && QUERY_NODE_JOIN_TABLE == nodeType(pSelect->pFromTable) && - (TIME_LINE_NONE == pSelect->timeLineCurMode)))) { - return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY); + if (QUERY_NODE_INTERVAL_WINDOW == nodeType(pSelect->pWindow)) { + if (NULL != pSelect->pFromTable && QUERY_NODE_TEMP_TABLE == nodeType(pSelect->pFromTable) && + !isBlockTimeLineQuery(((STempTableNode*)pSelect->pFromTable)->pSubquery)) { + bool isTimelineAlignedQuery = false; + code = isTimeLineAlignedQuery(pCxt->pCurrStmt, &isTimelineAlignedQuery); + if (TSDB_CODE_SUCCESS != code) return code; + if (!isTimelineAlignedQuery) return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY); + } + if (NULL != pSelect->pFromTable && QUERY_NODE_JOIN_TABLE == nodeType(pSelect->pFromTable) && + (TIME_LINE_NONE == pSelect->timeLineCurMode)) { + return generateDealNodeErrMsg(pCxt, TSDB_CODE_PAR_NOT_ALLOWED_WIN_QUERY); + } } pCxt->currClause = SQL_CLAUSE_WINDOW; - int32_t code = translateExpr(pCxt, &pSelect->pWindow); + code = translateExpr(pCxt, &pSelect->pWindow); if (TSDB_CODE_SUCCESS == code) { code = translateSpecificWindow(pCxt, pSelect); } @@ -5576,9 +5721,12 @@ typedef struct SEqCondTbNameTableInfo { } SEqCondTbNameTableInfo; //[tableAlias.]tbname = tbNamVal -static bool isOperatorEqTbnameCond(STranslateContext* pCxt, SOperatorNode* pOperator, char** ppTableAlias, - SArray** ppTabNames) { - if (pOperator->opType != OP_TYPE_EQUAL) return false; +static int32_t isOperatorEqTbnameCond(STranslateContext* pCxt, SOperatorNode* pOperator, char** ppTableAlias, + SArray** ppTabNames, bool* pRet) { + if (pOperator->opType != OP_TYPE_EQUAL) { + *pRet = false; + return TSDB_CODE_SUCCESS; + } SFunctionNode* pTbnameFunc = NULL; SValueNode* pValueNode = NULL; if (nodeType(pOperator->pLeft) == QUERY_NODE_FUNCTION && @@ -5592,7 +5740,8 @@ static bool isOperatorEqTbnameCond(STranslateContext* pCxt, SOperatorNode* pOper pTbnameFunc = (SFunctionNode*)pOperator->pRight; pValueNode = (SValueNode*)pOperator->pLeft; } else { - return false; + *pRet = false; + return TSDB_CODE_SUCCESS; } if (LIST_LENGTH(pTbnameFunc->pParameterList) == 0) { @@ -5603,21 +5752,25 @@ static bool isOperatorEqTbnameCond(STranslateContext* pCxt, SOperatorNode* pOper SValueNode* pQualValNode = (SValueNode*)pQualNode; *ppTableAlias = pQualValNode->literal; } else { - return false; + *pRet = false; + return TSDB_CODE_SUCCESS; } *ppTabNames = taosArrayInit(1, sizeof(void*)); - taosArrayPush(*ppTabNames, &(pValueNode->literal)); - return true; + if (!*ppTabNames) return TSDB_CODE_OUT_OF_MEMORY; + (void)taosArrayPush(*ppTabNames, &(pValueNode->literal)); + *pRet = true; + return TSDB_CODE_SUCCESS; } //[tableAlias.]tbname in (value1, value2, ...) -static bool isOperatorTbnameInCond(STranslateContext* pCxt, SOperatorNode* pOperator, char** ppTableAlias, - SArray** ppTbNames) { +static int32_t isOperatorTbnameInCond(STranslateContext* pCxt, SOperatorNode* pOperator, char** ppTableAlias, + SArray** ppTbNames, bool* pRet) { if (pOperator->opType != OP_TYPE_IN) return false; if (nodeType(pOperator->pLeft) != QUERY_NODE_FUNCTION || ((SFunctionNode*)(pOperator->pLeft))->funcType != FUNCTION_TYPE_TBNAME || nodeType(pOperator->pRight) != QUERY_NODE_NODE_LIST) { - return false; + *pRet = false; + return TSDB_CODE_SUCCESS; } SFunctionNode* pTbnameFunc = (SFunctionNode*)pOperator->pLeft; @@ -5629,27 +5782,36 @@ static bool isOperatorTbnameInCond(STranslateContext* pCxt, SOperatorNode* pOper SValueNode* pQualValNode = (SValueNode*)pQualNode; *ppTableAlias = pQualValNode->literal; } else { - return false; + *pRet = false; + return TSDB_CODE_SUCCESS; } - *ppTbNames = taosArrayInit(1, sizeof(void*)); SNodeListNode* pValueListNode = (SNodeListNode*)pOperator->pRight; + *ppTbNames = taosArrayInit(LIST_LENGTH(pValueListNode->pNodeList), sizeof(void*)); + if (!*ppTbNames) return TSDB_CODE_OUT_OF_MEMORY; SNodeList* pValueNodeList = pValueListNode->pNodeList; SNode* pValNode = NULL; FOREACH(pValNode, pValueNodeList) { if (nodeType(pValNode) != QUERY_NODE_VALUE) { - return false; + *pRet = false; + return TSDB_CODE_SUCCESS; } - taosArrayPush(*ppTbNames, &((SValueNode*)pValNode)->literal); + (void)taosArrayPush(*ppTbNames, &((SValueNode*)pValNode)->literal); } - return true; + *pRet = true; + return TSDB_CODE_SUCCESS; } -static bool findEqCondTbNameInOperatorNode(STranslateContext* pCxt, SNode* pWhere, SEqCondTbNameTableInfo* pInfo) { +static int32_t findEqCondTbNameInOperatorNode(STranslateContext* pCxt, SNode* pWhere, SEqCondTbNameTableInfo* pInfo, bool* pRet) { int32_t code = TSDB_CODE_SUCCESS; char* pTableAlias = NULL; char* pTbNameVal = NULL; - if (isOperatorEqTbnameCond(pCxt, (SOperatorNode*)pWhere, &pTableAlias, &pInfo->aTbnames) || - isOperatorTbnameInCond(pCxt, (SOperatorNode*)pWhere, &pTableAlias, &pInfo->aTbnames)) { + bool eqTbnameCond = false, tbnameInCond = false; + code = isOperatorEqTbnameCond(pCxt, (SOperatorNode*)pWhere, &pTableAlias, &pInfo->aTbnames, &eqTbnameCond); + if (TSDB_CODE_SUCCESS == code) { + code = isOperatorTbnameInCond(pCxt, (SOperatorNode*)pWhere, &pTableAlias, &pInfo->aTbnames, &tbnameInCond); + } + if (TSDB_CODE_SUCCESS != code) return code; + if (eqTbnameCond || tbnameInCond) { STableNode* pTable; if (pTableAlias == NULL) { pTable = (STableNode*)((SSelectStmt*)(pCxt->pCurrStmt))->pFromTable; @@ -5659,12 +5821,14 @@ static bool findEqCondTbNameInOperatorNode(STranslateContext* pCxt, SNode* pWher if (code == TSDB_CODE_SUCCESS && nodeType(pTable) == QUERY_NODE_REAL_TABLE && ((SRealTableNode*)pTable)->pMeta && ((SRealTableNode*)pTable)->pMeta->tableType == TSDB_SUPER_TABLE) { pInfo->pRealTable = (SRealTableNode*)pTable; - return true; + *pRet = true; + return TSDB_CODE_SUCCESS; } - taosArrayDestroy(pInfo->aTbnames); + (void)taosArrayDestroy(pInfo->aTbnames); pInfo->aTbnames = NULL; } - return false; + *pRet = false; + return TSDB_CODE_SUCCESS; } static bool isTableExistInTableTbnames(SArray* aTableTbNames, SRealTableNode* pTable) { @@ -5677,103 +5841,127 @@ static bool isTableExistInTableTbnames(SArray* aTableTbNames, SRealTableNode* pT return false; } -static void findEqualCondTbnameInLogicCondAnd(STranslateContext* pCxt, SNode* pWhere, SArray* aTableTbnames) { - SNode* pTmpNode = NULL; +static int32_t findEqualCondTbnameInLogicCondAnd(STranslateContext* pCxt, SNode* pWhere, SArray* aTableTbnames) { + SNode* pTmpNode = NULL; + int32_t code = TSDB_CODE_SUCCESS; FOREACH(pTmpNode, ((SLogicConditionNode*)pWhere)->pParameterList) { if (nodeType(pTmpNode) == QUERY_NODE_OPERATOR) { SEqCondTbNameTableInfo info = {0}; - bool bIsEqTbnameCond = findEqCondTbNameInOperatorNode(pCxt, pTmpNode, &info); + bool bIsEqTbnameCond; + code = findEqCondTbNameInOperatorNode(pCxt, pTmpNode, &info, &bIsEqTbnameCond); + if (TSDB_CODE_SUCCESS != code) break; if (bIsEqTbnameCond) { if (!isTableExistInTableTbnames(aTableTbnames, info.pRealTable)) { // TODO: intersect tbNames of same table? speed - taosArrayPush(aTableTbnames, &info); + if (NULL == taosArrayPush(aTableTbnames, &info)) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } } else { - taosArrayDestroy(info.aTbnames); + (void)taosArrayDestroy(info.aTbnames); } } } // TODO: logic cond } + return code; } -static void unionEqualCondTbnamesOfSameTable(SArray* aTableTbnames, SEqCondTbNameTableInfo* pInfo) { +static int32_t unionEqualCondTbnamesOfSameTable(SArray* aTableTbnames, SEqCondTbNameTableInfo* pInfo) { + int32_t code = TSDB_CODE_SUCCESS; bool bFoundTable = false; for (int i = 0; i < taosArrayGetSize(aTableTbnames); ++i) { SEqCondTbNameTableInfo* info = taosArrayGet(aTableTbnames, i); if (info->pRealTable == pInfo->pRealTable) { - taosArrayAddAll(info->aTbnames, pInfo->aTbnames); - taosArrayDestroy(pInfo->aTbnames); + if (NULL == taosArrayAddAll(info->aTbnames, pInfo->aTbnames)) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } + (void)taosArrayDestroy(pInfo->aTbnames); pInfo->aTbnames = NULL; bFoundTable = true; break; } } - if (!bFoundTable) { - taosArrayPush(aTableTbnames, pInfo); + if (TSDB_CODE_SUCCESS == code && !bFoundTable) { + if (NULL == taosArrayPush(aTableTbnames, pInfo)) { + code = TSDB_CODE_OUT_OF_MEMORY; + } } + return code; } -static void findEqualCondTbnameInLogicCondOr(STranslateContext* pCxt, SNode* pWhere, SArray* aTableTbnames) { - bool bAllTbName = true; - SNode* pTmpNode = NULL; +static int32_t findEqualCondTbnameInLogicCondOr(STranslateContext* pCxt, SNode* pWhere, SArray* aTableTbnames) { + int32_t code = TSDB_CODE_SUCCESS; + bool bAllTbName = true; + SNode* pTmpNode = NULL; FOREACH(pTmpNode, ((SLogicConditionNode*)pWhere)->pParameterList) { // TODO: logic cond if (nodeType(pTmpNode) == QUERY_NODE_OPERATOR) { SEqCondTbNameTableInfo info = {0}; - bool bIsEqTbnameCond = findEqCondTbNameInOperatorNode(pCxt, pTmpNode, &info); + bool bIsEqTbnameCond; + code = findEqCondTbNameInOperatorNode(pCxt, pTmpNode, &info, &bIsEqTbnameCond); + if (TSDB_CODE_SUCCESS != code) break; if (!bIsEqTbnameCond) { bAllTbName = false; break; } else { - unionEqualCondTbnamesOfSameTable(aTableTbnames, &info); + code = unionEqualCondTbnamesOfSameTable(aTableTbnames, &info); + if (TSDB_CODE_SUCCESS != code) break; } } else { bAllTbName = false; break; } } - if (!bAllTbName) { + if (TSDB_CODE_SUCCESS == code && !bAllTbName) { for (int i = 0; i < taosArrayGetSize(aTableTbnames); ++i) { SEqCondTbNameTableInfo* pInfo = taosArrayGet(aTableTbnames, i); - taosArrayDestroy(pInfo->aTbnames); + (void)taosArrayDestroy(pInfo->aTbnames); pInfo->aTbnames = NULL; } taosArrayClear(aTableTbnames); } + return code; } static int32_t findEqualCondTbname(STranslateContext* pCxt, SNode* pWhere, SArray* aTableTbnames) { + int32_t code = TSDB_CODE_SUCCESS; // TODO: optimize nested and/or condition. now only the fist level is processed. if (nodeType(pWhere) == QUERY_NODE_OPERATOR) { SEqCondTbNameTableInfo info = {0}; - bool bIsEqTbnameCond = findEqCondTbNameInOperatorNode(pCxt, pWhere, &info); + bool bIsEqTbnameCond; + code = findEqCondTbNameInOperatorNode(pCxt, pWhere, &info, &bIsEqTbnameCond); + if (TSDB_CODE_SUCCESS != code) return code; if (bIsEqTbnameCond) { - taosArrayPush(aTableTbnames, &info); + if (NULL == taosArrayPush(aTableTbnames, &info)) { + return TSDB_CODE_OUT_OF_MEMORY; + } } } else if (nodeType(pWhere) == QUERY_NODE_LOGIC_CONDITION) { if (((SLogicConditionNode*)pWhere)->condType == LOGIC_COND_TYPE_AND) { - findEqualCondTbnameInLogicCondAnd(pCxt, pWhere, aTableTbnames); + code = findEqualCondTbnameInLogicCondAnd(pCxt, pWhere, aTableTbnames); } else if (((SLogicConditionNode*)pWhere)->condType == LOGIC_COND_TYPE_OR) { - findEqualCondTbnameInLogicCondOr(pCxt, pWhere, aTableTbnames); + code = findEqualCondTbnameInLogicCondOr(pCxt, pWhere, aTableTbnames); } } - return TSDB_CODE_SUCCESS; + return code; } -static int32_t findVgroupsFromEqualTbname(STranslateContext* pCxt, SArray* aTbnames, const char* dbName, +static void findVgroupsFromEqualTbname(STranslateContext* pCxt, SArray* aTbnames, const char* dbName, int32_t numOfVgroups, SVgroupsInfo* vgsInfo) { int32_t nVgroups = 0; int32_t nTbls = taosArrayGetSize(aTbnames); if (nTbls >= numOfVgroups) { vgsInfo->numOfVgroups = 0; - return TSDB_CODE_SUCCESS; + return; } for (int j = 0; j < nTbls; ++j) { SName snameTb; char* tbName = taosArrayGetP(aTbnames, j); - toName(pCxt->pParseCxt->acctId, dbName, tbName, &snameTb); + (void)toName(pCxt->pParseCxt->acctId, dbName, tbName, &snameTb); SVgroupInfo vgInfo = {0}; bool bExists; int32_t code = catalogGetCachedTableHashVgroup(pCxt->pParseCxt->pCatalog, &snameTb, &vgInfo, &bExists); @@ -5795,7 +5983,6 @@ static int32_t findVgroupsFromEqualTbname(STranslateContext* pCxt, SArray* aTbna break; } } - return TSDB_CODE_SUCCESS; } static int32_t setEqualTbnameTableVgroups(STranslateContext* pCxt, SSelectStmt* pSelect, SArray* aTables) { @@ -5831,7 +6018,7 @@ static int32_t setEqualTbnameTableVgroups(STranslateContext* pCxt, SSelectStmt* code = TSDB_CODE_OUT_OF_MEMORY; break; } - taosArrayPush(pTbNames, &pNewTbName); + (void)taosArrayPush(pTbNames, &pNewTbName); sprintf(pNewTbName, "%s.%s_%s", pTsma->dbFName, pTsma->name, pTbName); int32_t len = taosCreateMD5Hash(pNewTbName, strlen(pNewTbName)); } @@ -5842,7 +6029,7 @@ static int32_t setEqualTbnameTableVgroups(STranslateContext* pCxt, SSelectStmt* if (TSDB_CODE_SUCCESS == code) { findVgroupsFromEqualTbname(pCxt, pTbNames, pInfo->pRealTable->table.dbName, numOfVgs, vgsInfo); if (vgsInfo->numOfVgroups != 0) { - taosArrayPush(pInfo->pRealTable->tsmaTargetTbVgInfo, &vgsInfo); + (void)taosArrayPush(pInfo->pRealTable->tsmaTargetTbVgInfo, &vgsInfo); } else { taosMemoryFree(vgsInfo); } @@ -5864,9 +6051,9 @@ static int32_t setTableVgroupsFromEqualTbnameCond(STranslateContext* pCxt, SSele } for (int i = 0; i < taosArrayGetSize(aTables); ++i) { SEqCondTbNameTableInfo* pInfo = taosArrayGet(aTables, i); - taosArrayDestroy(pInfo->aTbnames); + (void)taosArrayDestroy(pInfo->aTbnames); } - taosArrayDestroy(aTables); + (void)taosArrayDestroy(aTables); return code; } @@ -5877,7 +6064,7 @@ static int32_t translateWhere(STranslateContext* pCxt, SSelectStmt* pSelect) { code = getQueryTimeRange(pCxt, pSelect->pWhere, &pSelect->timeRange); } if (pSelect->pWhere != NULL && pCxt->pParseCxt->topicQuery == false) { - setTableVgroupsFromEqualTbnameCond(pCxt, pSelect); + code = setTableVgroupsFromEqualTbnameCond(pCxt, pSelect); } return code; } @@ -5939,8 +6126,10 @@ static EDealRes collectTableAlias(SNode* pNode, void* pContext) { *(SSHashObj**)pContext = pHash; } - tSimpleHashPut(*(SSHashObj**)pContext, pCol->tableAlias, strlen(pCol->tableAlias), pCol->tableAlias, - sizeof(pCol->tableAlias)); + if (TSDB_CODE_SUCCESS != tSimpleHashPut(*(SSHashObj**)pContext, pCol->tableAlias, strlen(pCol->tableAlias), pCol->tableAlias, + sizeof(pCol->tableAlias))) { + return DEAL_RES_ERROR; + } return DEAL_RES_CONTINUE; } @@ -6200,8 +6389,9 @@ static int32_t translateSelectFrom(STranslateContext* pCxt, SSelectStmt* pSelect code = checkIsEmptyResult(pCxt, pSelect); } if (TSDB_CODE_SUCCESS == code) { - resetSelectFuncNumWithoutDup(pSelect); - code = checkAggColCoexist(pCxt, pSelect); + code = resetSelectFuncNumWithoutDup(pSelect); + if (TSDB_CODE_SUCCESS == code) + code = checkAggColCoexist(pCxt, pSelect); } /* if (TSDB_CODE_SUCCESS == code) { @@ -6574,6 +6764,7 @@ static int64_t getBigintFromValueNode(SValueNode* pVal) { } static int32_t buildCreateDbRetentions(const SNodeList* pRetentions, SCreateDbReq* pReq) { + int32_t code = TSDB_CODE_SUCCESS; if (NULL != pRetentions) { pReq->pRetensions = taosArrayInit(LIST_LENGTH(pRetentions), sizeof(SRetention)); if (NULL == pReq->pRetensions) { @@ -6588,17 +6779,23 @@ static int32_t buildCreateDbRetentions(const SNodeList* pRetentions, SCreateDbRe pKeep = (SValueNode*)nodesListGetNode(((SNodeListNode*)pNode)->pNodeList, 1); SRetention retention = { .freq = pFreq->datum.i, .freqUnit = pFreq->unit, .keep = pKeep->datum.i, .keepUnit = pKeep->unit}; - taosArrayPush(pReq->pRetensions, &retention); + if (NULL == taosArrayPush(pReq->pRetensions, &retention)) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } + } + if (TSDB_CODE_SUCCESS == code) { + pReq->numOfRetensions = taosArrayGetSize(pReq->pRetensions); } - pReq->numOfRetensions = taosArrayGetSize(pReq->pRetensions); } - return TSDB_CODE_SUCCESS; + return code; } static int32_t buildCreateDbReq(STranslateContext* pCxt, SCreateDatabaseStmt* pStmt, SCreateDbReq* pReq) { SName name = {0}; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); - tNameGetFullDbName(&name, pReq->db); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, pReq->db); pReq->numOfVgroups = pStmt->pOptions->numOfVgroups; pReq->numOfStables = pStmt->pOptions->singleStable; pReq->buffer = pStmt->pOptions->buffer; @@ -7256,7 +7453,9 @@ static int32_t fillCmdSql(STranslateContext* pCxt, int16_t msgType, void* pReq) typedef int32_t (*FSerializeFunc)(void* pBuf, int32_t bufLen, void* pReq); static int32_t buildCmdMsg(STranslateContext* pCxt, int16_t msgType, FSerializeFunc func, void* pReq) { - fillCmdSql(pCxt, msgType, pReq); + int32_t code = TSDB_CODE_SUCCESS; + code = fillCmdSql(pCxt, msgType, pReq); + if (TSDB_CODE_SUCCESS != code) return code; pCxt->pCmdMsg = taosMemoryMalloc(sizeof(SCmdMsgInfo)); if (NULL == pCxt->pCmdMsg) { return TSDB_CODE_OUT_OF_MEMORY; @@ -7269,9 +7468,10 @@ static int32_t buildCmdMsg(STranslateContext* pCxt, int16_t msgType, FSerializeF taosMemoryFreeClear(pCxt->pCmdMsg); return TSDB_CODE_OUT_OF_MEMORY; } - func(pCxt->pCmdMsg->pMsg, pCxt->pCmdMsg->msgLen, pReq); - - return TSDB_CODE_SUCCESS; + if (-1 == func(pCxt->pCmdMsg->pMsg, pCxt->pCmdMsg->msgLen, pReq)) { + code = TSDB_CODE_INVALID_MSG; + } + return code; } static int32_t translateCreateDatabase(STranslateContext* pCxt, SCreateDatabaseStmt* pStmt) { @@ -7290,19 +7490,22 @@ static int32_t translateCreateDatabase(STranslateContext* pCxt, SCreateDatabaseS static int32_t translateDropDatabase(STranslateContext* pCxt, SDropDatabaseStmt* pStmt) { SDropDbReq dropReq = {0}; SName name = {0}; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); - tNameGetFullDbName(&name, dropReq.db); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, dropReq.db); dropReq.ignoreNotExists = pStmt->ignoreNotExists; - int32_t code = buildCmdMsg(pCxt, TDMT_MND_DROP_DB, (FSerializeFunc)tSerializeSDropDbReq, &dropReq); + code = buildCmdMsg(pCxt, TDMT_MND_DROP_DB, (FSerializeFunc)tSerializeSDropDbReq, &dropReq); tFreeSDropDbReq(&dropReq); return code; } -static void buildAlterDbReq(STranslateContext* pCxt, SAlterDatabaseStmt* pStmt, SAlterDbReq* pReq) { - SName name = {0}; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); - tNameGetFullDbName(&name, pReq->db); +static int32_t buildAlterDbReq(STranslateContext* pCxt, SAlterDatabaseStmt* pStmt, SAlterDbReq* pReq) { + SName name = {0}; + int32_t code = TSDB_CODE_SUCCESS; + code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, pReq->db); pReq->buffer = pStmt->pOptions->buffer; pReq->pageSize = -1; pReq->pages = pStmt->pOptions->pages; @@ -7324,7 +7527,7 @@ static void buildAlterDbReq(STranslateContext* pCxt, SAlterDatabaseStmt* pStmt, pReq->s3KeepLocal = pStmt->pOptions->s3KeepLocal; pReq->s3Compact = pStmt->pOptions->s3Compact; pReq->withArbitrator = pStmt->pOptions->withArbitrator; - return; + return code; } static int32_t translateAlterDatabase(STranslateContext* pCxt, SAlterDatabaseStmt* pStmt) { @@ -7358,9 +7561,10 @@ static int32_t translateAlterDatabase(STranslateContext* pCxt, SAlterDatabaseStm } SAlterDbReq alterReq = {0}; - buildAlterDbReq(pCxt, pStmt, &alterReq); + code = buildAlterDbReq(pCxt, pStmt, &alterReq); - code = buildCmdMsg(pCxt, TDMT_MND_ALTER_DB, (FSerializeFunc)tSerializeSAlterDbReq, &alterReq); + if (TSDB_CODE_SUCCESS == code) + code = buildCmdMsg(pCxt, TDMT_MND_ALTER_DB, (FSerializeFunc)tSerializeSAlterDbReq, &alterReq); tFreeSAlterDbReq(&alterReq); return code; } @@ -7368,8 +7572,9 @@ static int32_t translateAlterDatabase(STranslateContext* pCxt, SAlterDatabaseStm static int32_t translateTrimDatabase(STranslateContext* pCxt, STrimDatabaseStmt* pStmt) { STrimDbReq req = {.maxSpeed = pStmt->maxSpeed}; SName name = {0}; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); - tNameGetFullDbName(&name, req.db); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, req.db); return buildCmdMsg(pCxt, TDMT_MND_TRIM_DB, (FSerializeFunc)tSerializeSTrimDbReq, &req); } @@ -7393,13 +7598,17 @@ static int32_t checkColumnOptions(SNodeList* pList) { static int32_t translateS3MigrateDatabase(STranslateContext* pCxt, SS3MigrateDatabaseStmt* pStmt) { SS3MigrateDbReq req = {0}; SName name = {0}; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); - tNameGetFullDbName(&name, req.db); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, req.db); return buildCmdMsg(pCxt, TDMT_MND_S3MIGRATE_DB, (FSerializeFunc)tSerializeSS3MigrateDbReq, &req); } static int32_t columnDefNodeToField(SNodeList* pList, SArray** pArray, bool calBytes) { *pArray = taosArrayInit(LIST_LENGTH(pList), sizeof(SFieldWithOptions)); + if (!pArray) return TSDB_CODE_OUT_OF_MEMORY; + + int32_t code = TSDB_CODE_SUCCESS; SNode* pNode; FOREACH(pNode, pList) { SColumnDefNode* pCol = (SColumnDefNode*)pNode; @@ -7422,13 +7631,21 @@ static int32_t columnDefNodeToField(SNodeList* pList, SArray** pArray, bool calB if (pCol->pOptions && ((SColumnOptions*)pCol->pOptions)->bPrimaryKey) { field.flags |= COL_IS_KEY; } - taosArrayPush(*pArray, &field); + if (NULL == taosArrayPush(*pArray, &field)) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } } - return TSDB_CODE_SUCCESS; + if (TSDB_CODE_SUCCESS != code) { + (void)taosArrayDestroy(*pArray); + *pArray = NULL; + } + return code; } static int32_t tagDefNodeToField(SNodeList* pList, SArray** pArray, bool calBytes) { *pArray = taosArrayInit(LIST_LENGTH(pList), sizeof(SField)); + if (!*pArray) return TSDB_CODE_OUT_OF_MEMORY; SNode* pNode; FOREACH(pNode, pList) { SColumnDefNode* pCol = (SColumnDefNode*)pNode; @@ -7444,7 +7661,7 @@ static int32_t tagDefNodeToField(SNodeList* pList, SArray** pArray, bool calByte if (pCol->sma) { field.flags |= COL_SMA_ON; } - taosArrayPush(*pArray, &field); + (void)taosArrayPush(*pArray, &field); } return TSDB_CODE_SUCCESS; } @@ -8143,12 +8360,15 @@ static int32_t buildRollupFuncs(SNodeList* pFuncs, SArray** pArray) { return TSDB_CODE_SUCCESS; } *pArray = taosArrayInit(LIST_LENGTH(pFuncs), TSDB_FUNC_NAME_LEN); + if (!*pArray) return TSDB_CODE_OUT_OF_MEMORY; SNode* pNode; - FOREACH(pNode, pFuncs) { taosArrayPush(*pArray, ((SFunctionNode*)pNode)->functionName); } + FOREACH(pNode, pFuncs) { (void)taosArrayPush(*pArray, ((SFunctionNode*)pNode)->functionName); } return TSDB_CODE_SUCCESS; } static int32_t buildCreateStbReq(STranslateContext* pCxt, SCreateTableStmt* pStmt, SMCreateStbReq* pReq) { + int32_t code = TSDB_CODE_SUCCESS; + SName tableName; pReq->igExists = pStmt->ignoreExists; pReq->delay1 = pStmt->pOptions->maxDelay1; pReq->delay2 = pStmt->pOptions->maxDelay2; @@ -8161,25 +8381,29 @@ static int32_t buildCreateStbReq(STranslateContext* pCxt, SCreateTableStmt* pStm pReq->source = TD_REQ_FROM_APP; // columnDefNodeToField(pStmt->pCols, &pReq->pColumns, true); // columnDefNodeToField(pStmt->pTags, &pReq->pTags, true); - columnDefNodeToField(pStmt->pCols, &pReq->pColumns, true); - tagDefNodeToField(pStmt->pTags, &pReq->pTags, true); - pReq->numOfColumns = LIST_LENGTH(pStmt->pCols); - pReq->numOfTags = LIST_LENGTH(pStmt->pTags); - if (pStmt->pOptions->commentNull == false) { - pReq->pComment = taosStrdup(pStmt->pOptions->comment); - if (NULL == pReq->pComment) { - return TSDB_CODE_OUT_OF_MEMORY; + code = columnDefNodeToField(pStmt->pCols, &pReq->pColumns, true); + if (TSDB_CODE_SUCCESS == code) + code = tagDefNodeToField(pStmt->pTags, &pReq->pTags, true); + if (TSDB_CODE_SUCCESS == code) { + pReq->numOfColumns = LIST_LENGTH(pStmt->pCols); + pReq->numOfTags = LIST_LENGTH(pStmt->pTags); + if (pStmt->pOptions->commentNull == false) { + pReq->pComment = taosStrdup(pStmt->pOptions->comment); + if (NULL == pReq->pComment) { + return TSDB_CODE_OUT_OF_MEMORY; + } + pReq->commentLen = strlen(pStmt->pOptions->comment); + } else { + pReq->commentLen = -1; } - pReq->commentLen = strlen(pStmt->pOptions->comment); - } else { - pReq->commentLen = -1; + code = buildRollupFuncs(pStmt->pOptions->pRollupFuncs, &pReq->pFuncs); } - buildRollupFuncs(pStmt->pOptions->pRollupFuncs, &pReq->pFuncs); - pReq->numOfFuncs = taosArrayGetSize(pReq->pFuncs); - - SName tableName; - tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tableName), pReq->name); - int32_t code = collectUseTable(&tableName, pCxt->pTables); + if (TSDB_CODE_SUCCESS == code) { + pReq->numOfFuncs = taosArrayGetSize(pReq->pFuncs); + code = tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tableName), pReq->name); + } + if (TSDB_CODE_SUCCESS == code) + code = collectUseTable(&tableName, pCxt->pTables); if (TSDB_CODE_SUCCESS == code) { code = collectUseTable(&tableName, pCxt->pTargetTables); } @@ -8206,9 +8430,11 @@ static int32_t doTranslateDropSuperTable(STranslateContext* pCxt, const SName* p int32_t code = collectUseTable(pTableName, pCxt->pTargetTables); if (TSDB_CODE_SUCCESS == code) { SMDropStbReq dropReq = {0}; - tNameExtractFullName(pTableName, dropReq.name); - dropReq.igNotExists = ignoreNotExists; - code = buildCmdMsg(pCxt, TDMT_MND_DROP_STB, (FSerializeFunc)tSerializeSMDropStbReq, &dropReq); + code = tNameExtractFullName(pTableName, dropReq.name); + if (TSDB_CODE_SUCCESS == code) { + dropReq.igNotExists = ignoreNotExists; + code = buildCmdMsg(pCxt, TDMT_MND_DROP_STB, (FSerializeFunc)tSerializeSMDropStbReq, &dropReq); + } tFreeSMDropStbReq(&dropReq); } return code; @@ -8230,7 +8456,8 @@ static int32_t translateDropSuperTable(STranslateContext* pCxt, SDropSuperTableS static int32_t buildAlterSuperTableReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, SMAlterStbReq* pAlterReq) { SName tableName; - tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tableName), pAlterReq->name); + int32_t code = tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tableName), pAlterReq->name); + if (TSDB_CODE_SUCCESS != code) return code; pAlterReq->alterType = pStmt->alterType; if (TSDB_ALTER_TABLE_UPDATE_OPTIONS == pStmt->alterType) { @@ -8262,17 +8489,23 @@ static int32_t buildAlterSuperTableReq(STranslateContext* pCxt, SAlterTableStmt* case TSDB_ALTER_TABLE_UPDATE_TAG_BYTES: { TAOS_FIELD field = {.type = pStmt->dataType.type, .bytes = calcTypeBytes(pStmt->dataType)}; strcpy(field.name, pStmt->colName); - taosArrayPush(pAlterReq->pFields, &field); + if (NULL == taosArrayPush(pAlterReq->pFields, &field)) { + return TSDB_CODE_OUT_OF_MEMORY; + } break; } case TSDB_ALTER_TABLE_UPDATE_TAG_NAME: case TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME: { TAOS_FIELD oldField = {0}; strcpy(oldField.name, pStmt->colName); - taosArrayPush(pAlterReq->pFields, &oldField); + if (NULL == taosArrayPush(pAlterReq->pFields, &oldField)) { + return TSDB_CODE_OUT_OF_MEMORY; + } TAOS_FIELD newField = {0}; strcpy(newField.name, pStmt->newColName); - taosArrayPush(pAlterReq->pFields, &newField); + if (NULL == taosArrayPush(pAlterReq->pFields, &newField)) { + return TSDB_CODE_OUT_OF_MEMORY; + } break; } case TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS: { @@ -8288,13 +8521,16 @@ static int32_t buildAlterSuperTableReq(STranslateContext* pCxt, SAlterTableStmt* if (code != TSDB_CODE_SUCCESS) { return code; } - taosArrayPush(pAlterReq->pFields, &field); + if (NULL == taosArrayPush(pAlterReq->pFields, &field)) { + return TSDB_CODE_OUT_OF_MEMORY; + } break; } case TSDB_ALTER_TABLE_ADD_COLUMN_WITH_COMPRESS_OPTION: { - taosArrayDestroy(pAlterReq->pFields); + (void)taosArrayDestroy(pAlterReq->pFields); pAlterReq->pFields = taosArrayInit(1, sizeof(SFieldWithOptions)); + if (!pAlterReq->pFields) return TSDB_CODE_OUT_OF_MEMORY; SFieldWithOptions field = {.type = pStmt->dataType.type, .bytes = calcTypeBytes(pStmt->dataType)}; // TAOS_FIELD field = {.type = pStmt->dataType.type, .bytes = calcTypeBytes(pStmt->dataType)}; strcpy(field.name, pStmt->colName); @@ -8313,7 +8549,7 @@ static int32_t buildAlterSuperTableReq(STranslateContext* pCxt, SAlterTableStmt* return code; } } - taosArrayPush(pAlterReq->pFields, &field); + if (NULL == taosArrayPush(pAlterReq->pFields, &field)) return TSDB_CODE_OUT_OF_MEMORY; break; } default: @@ -8518,10 +8754,12 @@ static int32_t translateAlterSuperTable(STranslateContext* pCxt, SAlterTableStmt static int32_t translateUseDatabase(STranslateContext* pCxt, SUseDatabaseStmt* pStmt) { SUseDbReq usedbReq = {0}; SName name = {0}; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); - tNameExtractFullName(&name, usedbReq.db); - int32_t code = - getDBVgVersion(pCxt, usedbReq.db, &usedbReq.vgVersion, &usedbReq.dbId, &usedbReq.numOfTable, &usedbReq.stateTs); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + if (TSDB_CODE_SUCCESS == code) { + code = tNameExtractFullName(&name, usedbReq.db); + } + if (TSDB_CODE_SUCCESS == code) + code = getDBVgVersion(pCxt, usedbReq.db, &usedbReq.vgVersion, &usedbReq.dbId, &usedbReq.numOfTable, &usedbReq.stateTs); if (TSDB_CODE_SUCCESS == code) { code = buildCmdMsg(pCxt, TDMT_MND_USE_DB, (FSerializeFunc)tSerializeSUseDbReq, &usedbReq); } @@ -8735,20 +8973,23 @@ static int32_t getSmaIndexAst(STranslateContext* pCxt, SCreateIndexStmt* pStmt, static int32_t buildCreateSmaReq(STranslateContext* pCxt, SCreateIndexStmt* pStmt, SMCreateSmaReq* pReq) { SName name; - tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->indexDbName, pStmt->indexName, &name), pReq->name); - memset(&name, 0, sizeof(SName)); - tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name), pReq->stb); - pReq->igExists = pStmt->ignoreExists; - pReq->interval = ((SValueNode*)pStmt->pOptions->pInterval)->datum.i; - pReq->intervalUnit = ((SValueNode*)pStmt->pOptions->pInterval)->unit; - pReq->offset = (NULL != pStmt->pOptions->pOffset ? ((SValueNode*)pStmt->pOptions->pOffset)->datum.i : 0); - pReq->sliding = + int32_t code = tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->indexDbName, pStmt->indexName, &name), pReq->name); + if (TSDB_CODE_SUCCESS == code) { + memset(&name, 0, sizeof(SName)); + code = tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name), pReq->stb); + } + if (TSDB_CODE_SUCCESS == code) { + pReq->igExists = pStmt->ignoreExists; + pReq->interval = ((SValueNode*)pStmt->pOptions->pInterval)->datum.i; + pReq->intervalUnit = ((SValueNode*)pStmt->pOptions->pInterval)->unit; + pReq->offset = (NULL != pStmt->pOptions->pOffset ? ((SValueNode*)pStmt->pOptions->pOffset)->datum.i : 0); + pReq->sliding = (NULL != pStmt->pOptions->pSliding ? ((SValueNode*)pStmt->pOptions->pSliding)->datum.i : pReq->interval); - pReq->slidingUnit = + pReq->slidingUnit = (NULL != pStmt->pOptions->pSliding ? ((SValueNode*)pStmt->pOptions->pSliding)->unit : pReq->intervalUnit); + } - int32_t code = TSDB_CODE_SUCCESS; - if (NULL != pStmt->pOptions->pStreamOptions) { + if (TSDB_CODE_SUCCESS == code && NULL != pStmt->pOptions->pStreamOptions) { SStreamOptions* pStreamOpt = (SStreamOptions*)pStmt->pOptions->pStreamOptions; if (NULL != pStreamOpt->pDelay) { code = getTableMaxDelayOption(pCxt, (SValueNode*)pStreamOpt->pDelay, &pReq->maxDelay); @@ -8868,7 +9109,8 @@ int32_t translatePostCreateSmaIndex(SParseContext* pParseCxt, SQuery* pQuery, SS if (TSDB_CODE_SUCCESS == code) { code = setQuery(&pCxt, pQuery); } - setRefreshMeta(&pCxt, pQuery); + int32_t tmpCode = setRefreshMeta(&pCxt, pQuery); + if (TSDB_CODE_SUCCESS == code) code = tmpCode; destroyTranslateContext(&pCxt); tFreeSMCreateSmaReq(pStmt->pReq); taosMemoryFreeClear(pStmt->pReq); @@ -8882,14 +9124,17 @@ static int32_t buildCreateFullTextReq(STranslateContext* pCxt, SCreateIndexStmt* static int32_t buildCreateTagIndexReq(STranslateContext* pCxt, SCreateIndexStmt* pStmt, SCreateTagIndexReq* pReq) { SName name; - tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->indexDbName, pStmt->indexName, &name), pReq->idxName); - memset(&name, 0, sizeof(SName)); - - tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name), pReq->stbName); - memset(&name, 0, sizeof(SName)); - - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); - tNameGetFullDbName(&name, pReq->dbFName); + int32_t code = tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->indexDbName, pStmt->indexName, &name), pReq->idxName); + if (TSDB_CODE_SUCCESS == code) { + memset(&name, 0, sizeof(SName)); + code = tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name), pReq->stbName); + } + if (TSDB_CODE_SUCCESS == code) { + memset(&name, 0, sizeof(SName)); + code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + } + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, pReq->dbFName); SNode* pNode = NULL; ASSERT(LIST_LENGTH(pStmt->pCols) == 1); @@ -8959,7 +9204,8 @@ static int32_t translateCreateIndex(STranslateContext* pCxt, SCreateIndexStmt* p static int32_t translateDropIndex(STranslateContext* pCxt, SDropIndexStmt* pStmt) { SMDropSmaReq dropSmaReq = {0}; SName name; - tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->indexDbName, pStmt->indexName, &name), dropSmaReq.name); + int32_t code = tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->indexDbName, pStmt->indexName, &name), dropSmaReq.name); + if (TSDB_CODE_SUCCESS != code) return code; dropSmaReq.igNotExists = pStmt->ignoreNotExists; return buildCmdMsg(pCxt, TDMT_MND_DROP_SMA, (FSerializeFunc)tSerializeSMDropSmaReq, &dropSmaReq); } @@ -9033,23 +9279,28 @@ static int32_t buildCreateTopicReq(STranslateContext* pCxt, SCreateTopicStmt* pS SName name; if ('\0' != pStmt->subSTbName[0]) { pReq->subType = TOPIC_SUB_TYPE__TABLE; - toName(pCxt->pParseCxt->acctId, pStmt->subDbName, pStmt->subSTbName, &name); - tNameGetFullDbName(&name, pReq->subDbName); - tNameExtractFullName(&name, pReq->subStbName); - if (pStmt->pQuery != NULL) { - code = nodesNodeToString(pStmt->pQuery, false, &pReq->ast, NULL); + (void)toName(pCxt->pParseCxt->acctId, pStmt->subDbName, pStmt->subSTbName, &name); + (void)tNameGetFullDbName(&name, pReq->subDbName); + if (TSDB_CODE_SUCCESS == code) { + (void)tNameExtractFullName(&name, pReq->subStbName); + if (pStmt->pQuery != NULL) { + code = nodesNodeToString(pStmt->pQuery, false, &pReq->ast, NULL); + } } } else if ('\0' != pStmt->subDbName[0]) { pReq->subType = TOPIC_SUB_TYPE__DB; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->subDbName, strlen(pStmt->subDbName)); - tNameGetFullDbName(&name, pReq->subDbName); + code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->subDbName, strlen(pStmt->subDbName)); + if (TSDB_CODE_SUCCESS == code) + (void)tNameGetFullDbName(&name, pReq->subDbName); } else { pReq->subType = TOPIC_SUB_TYPE__COLUMN; char* dbName = ((SRealTableNode*)(((SSelectStmt*)pStmt->pQuery)->pFromTable))->table.dbName; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, dbName, strlen(dbName)); - tNameGetFullDbName(&name, pReq->subDbName); - pCxt->pParseCxt->topicQuery = true; - code = translateQuery(pCxt, pStmt->pQuery); + code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, dbName, strlen(dbName)); + if (TSDB_CODE_SUCCESS == code) { + (void)tNameGetFullDbName(&name, pReq->subDbName); + pCxt->pParseCxt->topicQuery = true; + code = translateQuery(pCxt, pStmt->pQuery); + } if (TSDB_CODE_SUCCESS == code) { code = checkTopicQuery(pCxt, (SSelectStmt*)pStmt->pQuery); } @@ -9061,14 +9312,20 @@ static int32_t buildCreateTopicReq(STranslateContext* pCxt, SCreateTopicStmt* pS return code; } -static int32_t addTagList(SNodeList** ppList, SNode* pNode) { +static int32_t addTagList(SNodeList** ppList, SNode** pNode) { if (NULL == *ppList) { *ppList = nodesMakeList(); + if (!*ppList) return TSDB_CODE_OUT_OF_MEMORY; } - nodesListStrictAppend(*ppList, pNode); + int32_t code = nodesListStrictAppend(*ppList, *pNode); + *pNode = NULL; + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(*ppList); + *ppList = NULL; + } - return TSDB_CODE_SUCCESS; + return code; } static EDealRes checkColumnTagsInCond(SNode* pNode, void* pContext) { @@ -9080,7 +9337,10 @@ static EDealRes checkColumnTagsInCond(SNode* pNode, void* pContext) { pCxt->colExists = true; return DEAL_RES_ERROR; } else if (type == TCOL_TYPE_TAG) { - addTagList(&pCxt->pTags, nodesCloneNode(pNode)); + SNode* pNodeClone = nodesCloneNode(pNode); + int32_t code = addTagList(&pCxt->pTags, &pNodeClone); + if (TSDB_CODE_SUCCESS != code) nodesDestroyNode(pNodeClone); + return DEAL_RES_ERROR; } else { pCxt->colNotFound = true; return DEAL_RES_ERROR; @@ -9088,7 +9348,11 @@ static EDealRes checkColumnTagsInCond(SNode* pNode, void* pContext) { } else if (QUERY_NODE_FUNCTION == nodeType(pNode)) { SFunctionNode* pFunc = (SFunctionNode*)pNode; if (0 == strcasecmp(pFunc->functionName, "tbname")) { - addTagList(&pCxt->pTags, nodesCloneNode(pNode)); + SNode* pNodeClone = nodesCloneNode(pNode); + if (TSDB_CODE_SUCCESS != addTagList(&pCxt->pTags, &pNodeClone)) { + nodesDestroyNode(pNodeClone); + return DEAL_RES_ERROR; + } } } @@ -9116,8 +9380,11 @@ static int32_t checkCollectTopicTags(STranslateContext* pCxt, SCreateTopicStmt* strcpy(col->colName, column->name); strcpy(col->node.aliasName, col->colName); strcpy(col->node.userAlias, col->colName); - addTagList(&colCxt.pTags, (SNode*)col); - // } + int32_t code = addTagList(&colCxt.pTags, (SNode**)&col); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)col); + return code; + } } *ppProjection = colCxt.pTags; @@ -9207,9 +9474,11 @@ static int32_t translateDropTopic(STranslateContext* pCxt, SDropTopicStmt* pStmt static int32_t translateDropCGroup(STranslateContext* pCxt, SDropCGroupStmt* pStmt) { SMDropCgroupReq dropReq = {0}; - SName name; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->topicName, strlen(pStmt->topicName)); - tNameGetFullDbName(&name, dropReq.topic); + SName name; + int32_t code = TSDB_CODE_SUCCESS; + code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->topicName, strlen(pStmt->topicName)); + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, dropReq.topic); dropReq.igNotExists = pStmt->ignoreNotExists; strcpy(dropReq.cgroup, pStmt->cgroup); @@ -9242,7 +9511,7 @@ static int32_t translateDescribe(STranslateContext* pCxt, SDescribeStmt* pStmt) if (TSDB_CODE_PAR_TABLE_NOT_EXIST == code) { int32_t origCode = code; SName name; - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name); + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name); SViewMeta* pMeta = NULL; code = getViewMetaFromMetaCache(pCxt, &name, &pMeta); if (TSDB_CODE_SUCCESS != code) { @@ -9250,7 +9519,7 @@ static int32_t translateDescribe(STranslateContext* pCxt, SDescribeStmt* pStmt) } else { SParseSqlRes res = {.resType = PARSE_SQL_RES_SCHEMA}; char dbFName[TSDB_DB_FNAME_LEN]; - tNameGetFullDbName(&name, dbFName); + (void)tNameGetFullDbName(&name, dbFName); code = (*pCxt->pParseCxt->parseSqlFp)(pCxt->pParseCxt->parseSqlParam, name.dbname, pMeta->querySql, false, pMeta->user, &res); if (TSDB_CODE_SUCCESS == code) { @@ -9299,9 +9568,12 @@ static int32_t translateCompactRange(STranslateContext* pCxt, SCompactDatabaseSt static int32_t translateCompact(STranslateContext* pCxt, SCompactDatabaseStmt* pStmt) { SCompactDbReq compactReq = {0}; SName name; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); - tNameGetFullDbName(&name, compactReq.db); - int32_t code = translateCompactRange(pCxt, pStmt, &compactReq); + int32_t code = TSDB_CODE_SUCCESS; + code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + if (TSDB_CODE_SUCCESS != code) return code; + + (void)tNameGetFullDbName(&name, compactReq.db); + code = translateCompactRange(pCxt, pStmt, &compactReq); if (TSDB_CODE_SUCCESS == code) { code = buildCmdMsg(pCxt, TDMT_MND_COMPACT_DB, (FSerializeFunc)tSerializeSCompactDbReq, &compactReq); } @@ -9380,7 +9652,7 @@ static int32_t checkCreateStream(STranslateContext* pCxt, SCreateStreamStmt* pSt static void getSourceDatabase(SNode* pStmt, int32_t acctId, char* pDbFName) { SName name = {.type = TSDB_DB_NAME_T, .acctId = acctId}; strcpy(name.dbname, ((SRealTableNode*)(((SSelectStmt*)pStmt)->pFromTable))->table.dbName); - tNameGetFullDbName(&name, pDbFName); + (void)tNameGetFullDbName(&name, pDbFName); } static void getStreamQueryFirstProjectAliasName(SHashObj* pUserAliasSet, char* aliasName, int32_t len) { @@ -9568,8 +9840,8 @@ static int32_t addNullTagsToCreateStreamQuery(STranslateContext* pCxt, STableMet return addNullTagsForExistTable(pCxt, pMeta, (SSelectStmt*)pStmt->pQuery); } -static int32_t addColDefNodeByProj(SNodeList** ppCols, SNode* pProject, int8_t flags) { - SExprNode* pExpr = (SExprNode*)pProject; +static int32_t addColDefNodeByProj(SNodeList** ppCols, const SNode* pProject, int8_t flags) { + const SExprNode* pExpr = (const SExprNode*)pProject; SColumnDefNode* pColDef = (SColumnDefNode*)nodesMakeNode(QUERY_NODE_COLUMN_DEF); strcpy(pColDef->colName, pExpr->userAlias); pColDef->dataType = pExpr->resType; @@ -9702,7 +9974,9 @@ static int32_t checkStreamQuery(STranslateContext* pCxt, SCreateStreamStmt* pStm int64_t watermark = 0; if (pStmt->pOptions->pWatermark) { - translateValue(pCxt, (SValueNode*)pStmt->pOptions->pWatermark); + if (DEAL_RES_ERROR == translateValue(pCxt, (SValueNode*)pStmt->pOptions->pWatermark)) { + return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY, "Invalid watermark value."); + } watermark = ((SValueNode*)pStmt->pOptions->pWatermark)->datum.i; } if (watermark <= 0) { @@ -9805,6 +10079,7 @@ static int32_t setFillNullCols(SArray* pProjColPos, const STableMeta* pMeta, SCM } const SSchema* pSchemas = getTableColumnSchema(pMeta); int32_t indexOfBoundCols = 0; + int32_t code = TSDB_CODE_SUCCESS; for (int32_t i = 0; i < pMeta->tableInfo.numOfColumns; ++i) { const SSchema* pSchema = pSchemas + i; if (indexOfBoundCols < numOfBoundCols) { @@ -9815,9 +10090,12 @@ static int32_t setFillNullCols(SArray* pProjColPos, const STableMeta* pMeta, SCM } } SColLocation colLoc = {.colId = pSchema->colId, .slotId = i, .type = pSchema->type}; - taosArrayPush(pReq->fillNullCols, &colLoc); + if (NULL == taosArrayPush(pReq->fillNullCols, &colLoc)) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } } - return TSDB_CODE_SUCCESS; + return code; } static int32_t adjustOrderOfProjections(STranslateContext* pCxt, SNodeList** ppCols, const STableMeta* pMeta, @@ -9873,13 +10151,15 @@ static int32_t adjustOrderOfProjections(STranslateContext* pCxt, SNodeList** ppC int32_t num = taosArrayGetSize(pProjColPos); pNewProjections = nodesMakeList(); pNewCols = nodesMakeList(); - if (NULL == pNewProjections) { + if (NULL == pNewProjections || !pNewCols) { code = TSDB_CODE_OUT_OF_MEMORY; } for (int32_t i = 0; TSDB_CODE_SUCCESS == code && i < num; ++i) { SProjColPos* pPos = taosArrayGet(pProjColPos, i); code = nodesListStrictAppend(pNewProjections, pPos->pProj); - addColDefNodeByProj(&pNewCols, pPos->pProj, pPos->flags); + if (TSDB_CODE_SUCCESS == code) { + code = addColDefNodeByProj(&pNewCols, pPos->pProj, pPos->flags); + } pPos->pProj = NULL; } } @@ -9889,7 +10169,7 @@ static int32_t adjustOrderOfProjections(STranslateContext* pCxt, SNodeList** ppC } if (TSDB_CODE_SUCCESS == code) { - taosArrayDestroy(pProjColPos); + (void)taosArrayDestroy(pProjColPos); nodesDestroyList(*pProjections); nodesDestroyList(*ppCols); *pProjections = pNewProjections; @@ -9998,7 +10278,7 @@ static int32_t adjustOrderOfTags(STranslateContext* pCxt, SNodeList* pTags, cons } if (TSDB_CODE_SUCCESS == code) { - taosArrayDestroy(pTagPos); + (void)taosArrayDestroy(pTagPos); nodesDestroyList(*pTagExprs); *pTagExprs = pNewTagExprs; } else { @@ -10316,17 +10596,19 @@ static int32_t translateStreamOptions(STranslateContext* pCxt, SCreateStreamStmt static int32_t buildCreateStreamReq(STranslateContext* pCxt, SCreateStreamStmt* pStmt, SCMCreateStreamReq* pReq) { pReq->igExists = pStmt->ignoreExists; - SName name; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->streamName, strlen(pStmt->streamName)); - tNameGetFullDbName(&name, pReq->name); + SName name; + int32_t code = TSDB_CODE_SUCCESS; + code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->streamName, strlen(pStmt->streamName)); + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, pReq->name); if ('\0' != pStmt->targetTabName[0]) { strcpy(name.dbname, pStmt->targetDbName); strcpy(name.tname, pStmt->targetTabName); - tNameExtractFullName(&name, pReq->targetStbFullName); + (void)tNameExtractFullName(&name, pReq->targetStbFullName); } - int32_t code = buildCreateStreamQuery(pCxt, pStmt, pReq); + code = buildCreateStreamQuery(pCxt, pStmt, pReq); if (TSDB_CODE_SUCCESS == code) { pReq->sql = taosStrdup(pCxt->pParseCxt->pSql); if (NULL == pReq->sql) { @@ -10346,12 +10628,14 @@ static int32_t buildCreateStreamReq(STranslateContext* pCxt, SCreateStreamStmt* (NULL != pStmt->pOptions->pDeleteMark ? ((SValueNode*)pStmt->pOptions->pDeleteMark)->datum.i : 0); pReq->fillHistory = pStmt->pOptions->fillHistory; pReq->igExpired = pStmt->pOptions->ignoreExpired; - if (pReq->createStb) { - tagDefNodeToField(pStmt->pTags, &pReq->pTags, true); - pReq->numOfTags = LIST_LENGTH(pStmt->pTags); - } - columnDefNodeToField(pStmt->pCols, &pReq->pCols, false); pReq->igUpdate = pStmt->pOptions->ignoreUpdate; + if (pReq->createStb) { + pReq->numOfTags = LIST_LENGTH(pStmt->pTags); + code = tagDefNodeToField(pStmt->pTags, &pReq->pTags, true); + } + if (TSDB_CODE_SUCCESS == code) { + code = columnDefNodeToField(pStmt->pCols, &pReq->pCols, false); + } } return code; @@ -10419,7 +10703,7 @@ static int32_t createStreamReqVersionInfo(SSDataBlock* pBlock, SArray** pArray, for (int32_t i = 0; i < pBlock->info.rows; ++i) { SVgroupVer v = {.vgId = *(int32_t*)colDataGetData(pCol1, i), .ver = *(int64_t*)colDataGetData(pCol2, i)}; - taosArrayPush(*pArray, &v); + (void)taosArrayPush(*pArray, &v); } } else { int32_t precision = (pInterval->interval > 0) ? pInterval->precision : TSDB_TIME_PRECISION_MILLI; @@ -10458,7 +10742,8 @@ int32_t translatePostCreateStream(SParseContext* pParseCxt, SQuery* pQuery, SSDa code = setQuery(&cxt, pQuery); } - setRefreshMeta(&cxt, pQuery); + int32_t tmpCode = setRefreshMeta(&cxt, pQuery); + if (TSDB_CODE_SUCCESS == code) code = tmpCode; destroyTranslateContext(&cxt); tFreeSCMCreateStreamReq(pStmt->pReq); @@ -10470,10 +10755,11 @@ int32_t translatePostCreateStream(SParseContext* pParseCxt, SQuery* pQuery, SSDa static int32_t translateDropStream(STranslateContext* pCxt, SDropStreamStmt* pStmt) { SMDropStreamReq dropReq = {0}; SName name; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->streamName, strlen(pStmt->streamName)); - tNameGetFullDbName(&name, dropReq.name); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->streamName, strlen(pStmt->streamName)); + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, dropReq.name); dropReq.igNotExists = pStmt->ignoreNotExists; - int32_t code = buildCmdMsg(pCxt, TDMT_MND_DROP_STREAM, (FSerializeFunc)tSerializeSMDropStreamReq, &dropReq); + code = buildCmdMsg(pCxt, TDMT_MND_DROP_STREAM, (FSerializeFunc)tSerializeSMDropStreamReq, &dropReq); tFreeMDropStreamReq(&dropReq); return code; } @@ -10481,8 +10767,9 @@ static int32_t translateDropStream(STranslateContext* pCxt, SDropStreamStmt* pSt static int32_t translatePauseStream(STranslateContext* pCxt, SPauseStreamStmt* pStmt) { SMPauseStreamReq req = {0}; SName name; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->streamName, strlen(pStmt->streamName)); - tNameGetFullDbName(&name, req.name); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->streamName, strlen(pStmt->streamName)); + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, req.name); req.igNotExists = pStmt->ignoreNotExists; return buildCmdMsg(pCxt, TDMT_MND_PAUSE_STREAM, (FSerializeFunc)tSerializeSMPauseStreamReq, &req); } @@ -10490,8 +10777,9 @@ static int32_t translatePauseStream(STranslateContext* pCxt, SPauseStreamStmt* p static int32_t translateResumeStream(STranslateContext* pCxt, SResumeStreamStmt* pStmt) { SMResumeStreamReq req = {0}; SName name; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->streamName, strlen(pStmt->streamName)); - tNameGetFullDbName(&name, req.name); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->streamName, strlen(pStmt->streamName)); + if (TSDB_CODE_SUCCESS != code) return code; + (void)tNameGetFullDbName(&name, req.name); req.igNotExists = pStmt->ignoreNotExists; req.igUntreated = pStmt->ignoreUntreated; return buildCmdMsg(pCxt, TDMT_MND_RESUME_STREAM, (FSerializeFunc)tSerializeSMResumeStreamReq, &req); @@ -10523,8 +10811,8 @@ static int32_t translateCreateView(STranslateContext* pCxt, SCreateViewStmt* pSt SParseSqlRes res = {.resType = PARSE_SQL_RES_SCHEMA}; SName name; char dbFName[TSDB_DB_FNAME_LEN]; - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->viewName, &name); - tNameGetFullDbName(&name, dbFName); + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->viewName, &name); + (void)tNameGetFullDbName(&name, dbFName); int32_t code = validateCreateView(pCxt, pStmt); if (TSDB_CODE_SUCCESS == code) { @@ -10564,18 +10852,20 @@ static int32_t translateDropView(STranslateContext* pCxt, SDropViewStmt* pStmt) SCMDropViewReq dropReq = {0}; SName name; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); - tNameGetFullDbName(&name, dropReq.dbFName); - strncpy(dropReq.name, pStmt->viewName, sizeof(dropReq.name) - 1); - snprintf(dropReq.fullname, sizeof(dropReq.fullname) - 1, "%s.%s", dropReq.dbFName, dropReq.name); - dropReq.sql = (char*)pCxt->pParseCxt->pSql; - if (NULL == dropReq.sql) { - return TSDB_CODE_OUT_OF_MEMORY; + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + if (TSDB_CODE_SUCCESS == code) { + (void)tNameGetFullDbName(&name, dropReq.dbFName); + strncpy(dropReq.name, pStmt->viewName, sizeof(dropReq.name) - 1); + snprintf(dropReq.fullname, sizeof(dropReq.fullname) - 1, "%s.%s", dropReq.dbFName, dropReq.name); + dropReq.sql = (char*)pCxt->pParseCxt->pSql; + if (NULL == dropReq.sql) { + return TSDB_CODE_OUT_OF_MEMORY; + } + dropReq.igNotExists = pStmt->ignoreNotExists; + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->viewName, &name); + code = collectUseTable(&name, pCxt->pTargetTables); } - dropReq.igNotExists = pStmt->ignoreNotExists; - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->viewName, &name); - int32_t code = collectUseTable(&name, pCxt->pTargetTables); if (TSDB_CODE_SUCCESS != code) { return code; } @@ -10608,12 +10898,11 @@ static int32_t readFromFile(char* pName, int32_t* len, char** buf) { int64_t s = taosReadFile(tfile, *buf, *len); if (s != *len) { - taosCloseFile(&tfile); + (void)taosCloseFile(&tfile); taosMemoryFreeClear(*buf); return TSDB_CODE_APP_ERROR; } - taosCloseFile(&tfile); - return TSDB_CODE_SUCCESS; + return taosCloseFile(&tfile); } static int32_t translateCreateFunction(STranslateContext* pCxt, SCreateFunctionStmt* pStmt) { @@ -10792,7 +11081,7 @@ static int32_t translateBalanceVgroup(STranslateContext* pCxt, SBalanceVgroupStm static int32_t translateBalanceVgroupLeader(STranslateContext* pCxt, SBalanceVgroupLeaderStmt* pStmt) { SBalanceVgroupLeaderReq req = {0}; req.vgId = pStmt->vgId; - if (pStmt->dbName != NULL) strcpy(req.db, pStmt->dbName); + strcpy(req.db, pStmt->dbName); int32_t code = buildCmdMsg(pCxt, TDMT_MND_BALANCE_VGROUP_LEADER, (FSerializeFunc)tSerializeSBalanceVgroupLeaderReq, &req); tFreeSBalanceVgroupLeaderReq(&req); @@ -10861,10 +11150,11 @@ static int32_t translateShowCreateDatabase(STranslateContext* pCxt, SShowCreateD } SName name; - tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); - tNameGetFullDbName(&name, pStmt->dbFName); - - return getDBCfg(pCxt, pStmt->dbName, (SDbCfgInfo*)pStmt->pCfg); + int32_t code = tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + (void)tNameGetFullDbName(&name, pStmt->dbFName); + if (TSDB_CODE_SUCCESS == code) + return getDBCfg(pCxt, pStmt->dbName, (SDbCfgInfo*)pStmt->pCfg); + return code; } static int32_t translateShowCreateTable(STranslateContext* pCxt, SShowCreateTableStmt* pStmt) { @@ -10875,7 +11165,7 @@ static int32_t translateShowCreateTable(STranslateContext* pCxt, SShowCreateTabl int32_t code = getDBCfg(pCxt, pStmt->dbName, (SDbCfgInfo*)pStmt->pDbCfg); if (TSDB_CODE_SUCCESS == code) { SName name; - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name); + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name); code = getTableCfg(pCxt, &name, (STableCfg**)&pStmt->pTableCfg); } return code; @@ -10886,7 +11176,7 @@ static int32_t translateShowCreateView(STranslateContext* pCxt, SShowCreateViewS return TSDB_CODE_OPS_NOT_SUPPORT; #else SName name; - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->viewName, &name); + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->viewName, &name); return getViewMetaFromMetaCache(pCxt, &name, (SViewMeta**)&pStmt->pViewMeta); #endif } @@ -10926,7 +11216,7 @@ static int32_t compareTsmaFuncWithFuncAndColId(SNode* pNode1, SNode* pNode2) { } // pFuncs are already sorted by funcId and colId -static int32_t deduplicateTsmaFuncs(SNodeList* pFuncs) { +static void deduplicateTsmaFuncs(SNodeList* pFuncs) { SNode* pLast = NULL; SNode* pFunc = NULL; SNodeList* pRes = NULL; @@ -10942,7 +11232,6 @@ static int32_t deduplicateTsmaFuncs(SNodeList* pFuncs) { pLast = pFunc; } } - return TSDB_CODE_SUCCESS; } static int32_t buildTSMAAstStreamSubTable(SCreateTSMAStmt* pStmt, SMCreateSmaReq* pReq, const SNode* pTbname, @@ -11020,8 +11309,9 @@ static int32_t buildTSMAAst(STranslateContext* pCxt, SCreateTSMAStmt* pStmt, SMC code = TSDB_CODE_OUT_OF_MEMORY; break; } - nodesListAppend(info.pPartitionByList, pTagCol); - code = nodesListMakeStrictAppend(&info.pTags, nodesCloneNode(pTagCol)); + code = nodesListAppend(info.pPartitionByList, pTagCol); + if (TSDB_CODE_SUCCESS == code) + code = nodesListMakeStrictAppend(&info.pTags, nodesCloneNode(pTagCol)); } // sub table @@ -11081,13 +11371,14 @@ static int32_t rewriteTSMAFuncs(STranslateContext* pCxt, SCreateTSMAStmt* pStmt, pFunc = (SFunctionNode*)pNode; const SSchema* pSchema = pCols + i; code = createColumnBySchema(pSchema, &pCol); - if (code) break; - nodesListErase(pFunc->pParameterList, pFunc->pParameterList->pHead); - nodesListPushFront(pFunc->pParameterList, (SNode*)pCol); + if (TSDB_CODE_SUCCESS != code) break; + (void)nodesListErase(pFunc->pParameterList, pFunc->pParameterList->pHead); + code = nodesListPushFront(pFunc->pParameterList, (SNode*)pCol); + if (TSDB_CODE_SUCCESS != code) break; snprintf(pFunc->node.userAlias, TSDB_COL_NAME_LEN, "%s", pSchema->name); // for first or last, the second param will be pk ts col, here we should remove it if (fmIsImplicitTsFunc(pFunc->funcId) && LIST_LENGTH(pFunc->pParameterList) == 2) { - nodesListErase(pFunc->pParameterList, pFunc->pParameterList->pTail); + (void)nodesListErase(pFunc->pParameterList, pFunc->pParameterList->pTail); } ++i; } @@ -11140,13 +11431,16 @@ static int32_t buildCreateTSMAReq(STranslateContext* pCxt, SCreateTSMAStmt* pStm SName name; SDbCfgInfo pDbInfo = {0}; int32_t code = TSDB_CODE_SUCCESS; - tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tsmaName, &name), pReq->name); - memset(&name, 0, sizeof(SName)); - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, useTbName); - tNameExtractFullName(useTbName, pReq->stb); - pReq->igExists = pStmt->ignoreExists; - - code = getDBCfg(pCxt, pStmt->dbName, &pDbInfo); + code = tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tsmaName, &name), pReq->name); + if (TSDB_CODE_SUCCESS == code) { + memset(&name, 0, sizeof(SName)); + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, useTbName); + code = tNameExtractFullName(useTbName, pReq->stb); + } + if (TSDB_CODE_SUCCESS == code) { + pReq->igExists = pStmt->ignoreExists; + code = getDBCfg(pCxt, pStmt->dbName, &pDbInfo); + } if (code != TSDB_CODE_SUCCESS) { return code; } @@ -11182,12 +11476,14 @@ static int32_t buildCreateTSMAReq(STranslateContext* pCxt, SCreateTSMAStmt* pStm code = getTsma(pCxt, useTbName, &pRecursiveTsma); if (code == TSDB_CODE_SUCCESS) { pReq->recursiveTsma = true; - tNameExtractFullName(useTbName, pReq->baseTsmaName); - SValueNode* pInterval = (SValueNode*)pStmt->pOptions->pInterval; - if (checkRecursiveTsmaInterval(pRecursiveTsma->interval, pRecursiveTsma->unit, pInterval->datum.i, - pInterval->unit, pDbInfo.precision, true)) { - } else { - code = TSDB_CODE_TSMA_INVALID_PARA; + code = tNameExtractFullName(useTbName, pReq->baseTsmaName); + if (TSDB_CODE_SUCCESS == code) { + SValueNode* pInterval = (SValueNode*)pStmt->pOptions->pInterval; + if (checkRecursiveTsmaInterval(pRecursiveTsma->interval, pRecursiveTsma->unit, pInterval->datum.i, + pInterval->unit, pDbInfo.precision, true)) { + } else { + code = TSDB_CODE_TSMA_INVALID_PARA; + } } } if (code == TSDB_CODE_SUCCESS) { @@ -11199,17 +11495,24 @@ static int32_t buildCreateTSMAReq(STranslateContext* pCxt, SCreateTSMAStmt* pStm FOREACH(pNode, pSelect->pProjectionList) { SFunctionNode* pFuncNode = (SFunctionNode*)pNode; if (!fmIsTSMASupportedFunc(pFuncNode->funcId)) continue; - nodesListMakeStrictAppend(&pStmt->pOptions->pFuncs, nodesCloneNode(pNode)); + code = nodesListMakeStrictAppend(&pStmt->pOptions->pFuncs, nodesCloneNode(pNode)); + if (TSDB_CODE_SUCCESS != code) { + break; + } } nodesDestroyNode((SNode*)pSelect); - memset(useTbName, 0, sizeof(SName)); - memcpy(pStmt->originalTbName, pRecursiveTsma->tb, TSDB_TABLE_NAME_LEN); - tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pRecursiveTsma->tb, useTbName), pReq->stb); - numOfCols = pRecursiveTsma->pUsedCols->size; - numOfTags = pRecursiveTsma->pTags ? pRecursiveTsma->pTags->size : 0; - pCols = pRecursiveTsma->pUsedCols->pData; - pTags = pRecursiveTsma->pTags ? pRecursiveTsma->pTags->pData : NULL; - code = getTableMeta(pCxt, pStmt->dbName, pRecursiveTsma->targetTb, &pTableMeta); + if (TSDB_CODE_SUCCESS == code) { + memset(useTbName, 0, sizeof(SName)); + memcpy(pStmt->originalTbName, pRecursiveTsma->tb, TSDB_TABLE_NAME_LEN); + code = tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pRecursiveTsma->tb, useTbName), pReq->stb); + } + if (TSDB_CODE_SUCCESS == code) { + numOfCols = pRecursiveTsma->pUsedCols->size; + numOfTags = pRecursiveTsma->pTags ? pRecursiveTsma->pTags->size : 0; + pCols = pRecursiveTsma->pUsedCols->pData; + pTags = pRecursiveTsma->pTags ? pRecursiveTsma->pTags->pData : NULL; + code = getTableMeta(pCxt, pStmt->dbName, pRecursiveTsma->targetTb, &pTableMeta); + } } } else { code = getTableMeta(pCxt, pStmt->dbName, pStmt->tableName, &pTableMeta); @@ -11322,11 +11625,12 @@ int32_t translatePostCreateTSMA(SParseContext* pParseCxt, SQuery* pQuery, SSData if (TSDB_CODE_SUCCESS == code) { SName name = {0}; - toName(pParseCxt->acctId, pStmt->dbName, pStmt->originalTbName, &name); + (void)toName(pParseCxt->acctId, pStmt->dbName, pStmt->originalTbName, &name); code = collectUseTable(&name, cxt.pTargetTables); } - setRefreshMeta(&cxt, pQuery); + int32_t tmpCode = setRefreshMeta(&cxt, pQuery); + if (TSDB_CODE_SUCCESS == code) code = tmpCode; destroyTranslateContext(&cxt); tFreeSMCreateSmaReq(pStmt->pReq); @@ -11336,15 +11640,17 @@ int32_t translatePostCreateTSMA(SParseContext* pParseCxt, SQuery* pQuery, SSData } static int32_t translateDropTSMA(STranslateContext* pCxt, SDropTSMAStmt* pStmt) { - int32_t code = TSDB_CODE_SUCCESS; - SMDropSmaReq dropReq = {0}; - SName name; - tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tsmaName, &name), dropReq.name); - dropReq.igNotExists = pStmt->ignoreNotExists; + int32_t code = TSDB_CODE_SUCCESS; + SMDropSmaReq dropReq = {0}; + SName name; STableTSMAInfo* pTsma = NULL; - code = getTsma(pCxt, &name, &pTsma); + code = tNameExtractFullName(toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tsmaName, &name), dropReq.name); + if (TSDB_CODE_SUCCESS == code) { + dropReq.igNotExists = pStmt->ignoreNotExists; + code = getTsma(pCxt, &name, &pTsma); + } if (code == TSDB_CODE_SUCCESS) { - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pTsma->tb, &name); + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pTsma->tb, &name); code = collectUseTable(&name, pCxt->pTargetTables); } if (TSDB_CODE_SUCCESS == code) @@ -11798,20 +12104,26 @@ static SNode* createProjectCol(const char* pProjCol) { return (SNode*)pCol; } -static SNodeList* createProjectCols(int32_t ncols, const char* const pCols[]) { +static int32_t createProjectCols(int32_t ncols, const char* const pCols[], SNodeList** pResList) { SNodeList* pProjections = NULL; + int32_t code = TSDB_CODE_SUCCESS; if (0 == ncols) { - nodesListMakeStrictAppend(&pProjections, createStarCol()); - return pProjections; + code = nodesListMakeStrictAppend(&pProjections, createStarCol()); + if (TSDB_CODE_SUCCESS == code) + *pResList = pProjections; + else + nodesDestroyList(pProjections); + return code; } for (int32_t i = 0; i < ncols; ++i) { - int32_t code = nodesListMakeStrictAppend(&pProjections, createProjectCol(pCols[i])); + code = nodesListMakeStrictAppend(&pProjections, createProjectCol(pCols[i])); if (TSDB_CODE_SUCCESS != code) { nodesDestroyList(pProjections); - return NULL; + break; } } - return pProjections; + if (TSDB_CODE_SUCCESS == code) *pResList = pProjections; + return code; } static int32_t createSimpleSelectStmtImpl(const char* pDb, const char* pTable, SNodeList* pProjectionList, @@ -11842,10 +12154,8 @@ static int32_t createSimpleSelectStmtFromCols(const char* pDb, const char* pTabl const char* const pProjCol[], SSelectStmt** pStmt) { SNodeList* pProjectionList = NULL; if (numOfProjs >= 0) { - pProjectionList = createProjectCols(numOfProjs, pProjCol); - if (NULL == pProjectionList) { - return TSDB_CODE_OUT_OF_MEMORY; - } + int32_t code = createProjectCols(numOfProjs, pProjCol, &pProjectionList); + if (TSDB_CODE_SUCCESS != code) return code; } return createSimpleSelectStmtImpl(pDb, pTable, pProjectionList, pStmt); @@ -11924,7 +12234,8 @@ static const char* getTbNameColName(ENodeType type) { return colName; } -static int32_t createLogicCondNode(SNode* pCond1, SNode* pCond2, SNode** pCond, ELogicConditionType logicCondType) { +static int32_t createLogicCondNode(SNode** pCond1, SNode** pCond2, SNode** pCond, ELogicConditionType logicCondType) { + int32_t code = TSDB_CODE_SUCCESS; SLogicConditionNode* pCondition = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); if (NULL == pCondition) { return TSDB_CODE_OUT_OF_MEMORY; @@ -11935,114 +12246,199 @@ static int32_t createLogicCondNode(SNode* pCond1, SNode* pCond2, SNode** pCond, nodesDestroyNode((SNode*)pCondition); return TSDB_CODE_OUT_OF_MEMORY; } - if (TSDB_CODE_SUCCESS != nodesListAppend(pCondition->pParameterList, pCond1) || - TSDB_CODE_SUCCESS != nodesListAppend(pCondition->pParameterList, pCond2)) { + code = nodesListAppend(pCondition->pParameterList, *pCond1); + if (TSDB_CODE_SUCCESS == code) { + *pCond1 = NULL; + code = nodesListAppend(pCondition->pParameterList, *pCond2); + } + if (TSDB_CODE_SUCCESS == code) { + *pCond2 = NULL; + *pCond = (SNode*)pCondition; + } else { nodesDestroyNode((SNode*)pCondition); - return TSDB_CODE_OUT_OF_MEMORY; } - *pCond = (SNode*)pCondition; - return TSDB_CODE_SUCCESS; + return code; } -static int32_t insertCondIntoSelectStmt(SSelectStmt* pSelect, SNode* pCond) { +static int32_t insertCondIntoSelectStmt(SSelectStmt* pSelect, SNode** pCond) { + int32_t code = TSDB_CODE_SUCCESS; if (pSelect->pWhere == NULL) { - pSelect->pWhere = pCond; + pSelect->pWhere = *pCond; + *pCond = NULL; } else { SNodeList* pLogicCondListWhere = NULL; SNodeList* pLogicCondList2 = NULL; if (nodeType(pSelect->pWhere) == QUERY_NODE_LOGIC_CONDITION && ((SLogicConditionNode*)pSelect->pWhere)->condType == LOGIC_COND_TYPE_AND) { pLogicCondListWhere = ((SLogicConditionNode*)pSelect->pWhere)->pParameterList; + ((SLogicConditionNode*)pSelect->pWhere)->pParameterList = NULL; } else { - nodesListMakeAppend(&pLogicCondListWhere, pSelect->pWhere); + code = nodesListMakeAppend(&pLogicCondListWhere, pSelect->pWhere); + if (TSDB_CODE_SUCCESS == code) { + pSelect->pWhere = NULL; + } } - if (nodeType(pCond) == QUERY_NODE_LOGIC_CONDITION && - ((SLogicConditionNode*)pCond)->condType == LOGIC_COND_TYPE_AND) { - pLogicCondList2 = ((SLogicConditionNode*)pCond)->pParameterList; - } else { - nodesListMakeAppend(&pLogicCondList2, pCond); + if (TSDB_CODE_SUCCESS == code) { + if (nodeType(*pCond) == QUERY_NODE_LOGIC_CONDITION && + ((SLogicConditionNode*)(*pCond))->condType == LOGIC_COND_TYPE_AND) { + pLogicCondList2 = ((SLogicConditionNode*)(*pCond))->pParameterList; + ((SLogicConditionNode*)(*pCond))->pParameterList = NULL; + } else { + code = nodesListMakeAppend(&pLogicCondList2, (*pCond)); + if (TSDB_CODE_SUCCESS == code) { + *pCond = NULL; + } + } } - nodesListAppendList(pLogicCondListWhere, pLogicCondList2); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListAppendList(pLogicCondListWhere, pLogicCondList2); + } - SLogicConditionNode* pWhere = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); - pWhere->condType = LOGIC_COND_TYPE_AND; - pWhere->pParameterList = pLogicCondListWhere; + if (TSDB_CODE_SUCCESS == code) { + SLogicConditionNode* pWhere = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + if (pWhere) { + pWhere->condType = LOGIC_COND_TYPE_AND; + pWhere->pParameterList = pLogicCondListWhere; - pSelect->pWhere = (SNode*)pWhere; + pSelect->pWhere = (SNode*)pWhere; + } + } + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pLogicCondListWhere); + nodesDestroyList(pLogicCondList2); + } } - return TSDB_CODE_SUCCESS; + return code; } static int32_t addShowUserDatabasesCond(SSelectStmt* pSelect) { + int32_t code = TSDB_CODE_SUCCESS; SNode* pNameCond1 = NULL; SNode* pNameCond2 = NULL; - SValueNode* pValNode1 = nodesMakeValueNodeFromString(TSDB_INFORMATION_SCHEMA_DB); - SValueNode* pValNode2 = nodesMakeValueNodeFromString(TSDB_PERFORMANCE_SCHEMA_DB); - createOperatorNode(OP_TYPE_NOT_EQUAL, "name", (SNode*)pValNode1, &pNameCond1); - createOperatorNode(OP_TYPE_NOT_EQUAL, "name", (SNode*)pValNode2, &pNameCond2); + SNode* pNameCond = NULL; + SValueNode* pValNode1 = NULL, *pValNode2 = NULL; + pValNode1 = nodesMakeValueNodeFromString(TSDB_INFORMATION_SCHEMA_DB); + if (!pValNode1) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + if (TSDB_CODE_SUCCESS == code) { + pValNode2 = nodesMakeValueNodeFromString(TSDB_PERFORMANCE_SCHEMA_DB); + if (!pValNode2) code = TSDB_CODE_OUT_OF_MEMORY; + } + if (TSDB_CODE_SUCCESS == code) { + code = createOperatorNode(OP_TYPE_NOT_EQUAL, "name", (SNode*)pValNode1, &pNameCond1); + } + if (TSDB_CODE_SUCCESS == code) { + code = createOperatorNode(OP_TYPE_NOT_EQUAL, "name", (SNode*)pValNode2, &pNameCond2); + } nodesDestroyNode((SNode*)pValNode2); nodesDestroyNode((SNode*)pValNode1); - SNode* pNameCond = NULL; - createLogicCondNode(pNameCond1, pNameCond2, &pNameCond, LOGIC_COND_TYPE_AND); - insertCondIntoSelectStmt(pSelect, pNameCond); - return TSDB_CODE_SUCCESS; + if (TSDB_CODE_SUCCESS == code) + code = createLogicCondNode(&pNameCond1, &pNameCond2, &pNameCond, LOGIC_COND_TYPE_AND); + + if (TSDB_CODE_SUCCESS == code) + code = insertCondIntoSelectStmt(pSelect, &pNameCond); + + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pNameCond1); + nodesDestroyNode(pNameCond2); + nodesDestroyNode(pNameCond); + } + return code; } static int32_t addShowSystemDatabasesCond(SSelectStmt* pSelect) { + int32_t code = TSDB_CODE_SUCCESS; SNode* pNameCond1 = NULL; SNode* pNameCond2 = NULL; - SValueNode* pValNode1 = nodesMakeValueNodeFromString(TSDB_INFORMATION_SCHEMA_DB); - SValueNode* pValNode2 = nodesMakeValueNodeFromString(TSDB_PERFORMANCE_SCHEMA_DB); - createOperatorNode(OP_TYPE_EQUAL, "name", (SNode*)pValNode1, &pNameCond1); - createOperatorNode(OP_TYPE_EQUAL, "name", (SNode*)pValNode2, &pNameCond2); + SValueNode* pValNode1 = NULL, * pValNode2 = NULL; + SNode* pNameCond = NULL; + pValNode1 = nodesMakeValueNodeFromString(TSDB_INFORMATION_SCHEMA_DB); + if (!pValNode1) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + if (TSDB_CODE_SUCCESS == code) { + pValNode2 = nodesMakeValueNodeFromString(TSDB_PERFORMANCE_SCHEMA_DB); + if (!pValNode2) code = terrno; + } + if (TSDB_CODE_SUCCESS == code) { + code = createOperatorNode(OP_TYPE_EQUAL, "name", (SNode*)pValNode1, &pNameCond1); + } + if (TSDB_CODE_SUCCESS == code) { + code = createOperatorNode(OP_TYPE_EQUAL, "name", (SNode*)pValNode2, &pNameCond2); + } nodesDestroyNode((SNode*)pValNode2); nodesDestroyNode((SNode*)pValNode1); - SNode* pNameCond = NULL; - createLogicCondNode(pNameCond1, pNameCond2, &pNameCond, LOGIC_COND_TYPE_OR); - insertCondIntoSelectStmt(pSelect, pNameCond); - return TSDB_CODE_SUCCESS; + if (TSDB_CODE_SUCCESS == code) { + code = createLogicCondNode(&pNameCond1, &pNameCond2, &pNameCond, LOGIC_COND_TYPE_OR); + } + + if (TSDB_CODE_SUCCESS == code) + code = insertCondIntoSelectStmt(pSelect, &pNameCond); + + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pNameCond1); + nodesDestroyNode(pNameCond2); + nodesDestroyNode(pNameCond); + } + return code; } static int32_t addShowNormalTablesCond(SSelectStmt* pSelect) { SNode* pTypeCond = NULL; + int32_t code = TSDB_CODE_SUCCESS; SValueNode* pValNode1 = nodesMakeValueNodeFromString("NORMAL_TABLE"); - createOperatorNode(OP_TYPE_EQUAL, "type", (SNode*)pValNode1, &pTypeCond); + if (!pValNode1) code = TSDB_CODE_OUT_OF_MEMORY; + + if (TSDB_CODE_SUCCESS == code) + code = createOperatorNode(OP_TYPE_EQUAL, "type", (SNode*)pValNode1, &pTypeCond); + nodesDestroyNode((SNode*)pValNode1); - insertCondIntoSelectStmt(pSelect, pTypeCond); - return TSDB_CODE_SUCCESS; + + if (TSDB_CODE_SUCCESS == code) code = insertCondIntoSelectStmt(pSelect, &pTypeCond); + if (TSDB_CODE_SUCCESS != code) nodesDestroyNode(pTypeCond); + return code; } static int32_t addShowChildTablesCond(SSelectStmt* pSelect) { + int32_t code = TSDB_CODE_SUCCESS; SNode* pTypeCond = NULL; SValueNode* pValNode1 = nodesMakeValueNodeFromString("CHILD_TABLE"); - createOperatorNode(OP_TYPE_EQUAL, "type", (SNode*)pValNode1, &pTypeCond); + if (!pValNode1) code = TSDB_CODE_OUT_OF_MEMORY; + + if (TSDB_CODE_SUCCESS == code) + code = createOperatorNode(OP_TYPE_EQUAL, "type", (SNode*)pValNode1, &pTypeCond); + nodesDestroyNode((SNode*)pValNode1); - insertCondIntoSelectStmt(pSelect, pTypeCond); - return TSDB_CODE_SUCCESS; + + if (TSDB_CODE_SUCCESS == code) code = insertCondIntoSelectStmt(pSelect, &pTypeCond); + if (TSDB_CODE_SUCCESS != code) nodesDestroyNode(pTypeCond); + return code; } static int32_t addShowKindCond(const SShowStmt* pShow, SSelectStmt* pSelect) { + int32_t code = TSDB_CODE_SUCCESS; if (pShow->type != QUERY_NODE_SHOW_DATABASES_STMT && pShow->type != QUERY_NODE_SHOW_TABLES_STMT || pShow->showKind == SHOW_KIND_ALL) { return TSDB_CODE_SUCCESS; } if (pShow->type == QUERY_NODE_SHOW_DATABASES_STMT) { if (pShow->showKind == SHOW_KIND_DATABASES_USER) { - addShowUserDatabasesCond(pSelect); + code = addShowUserDatabasesCond(pSelect); } else if (pShow->showKind == SHOW_KIND_DATABASES_SYSTEM) { - addShowSystemDatabasesCond(pSelect); + code = addShowSystemDatabasesCond(pSelect); } } else if (pShow->type == QUERY_NODE_SHOW_TABLES_STMT) { if (pShow->showKind == SHOW_KIND_TABLES_NORMAL) { - addShowNormalTablesCond(pSelect); + code = addShowNormalTablesCond(pSelect); } else if (pShow->showKind == SHOW_KIND_TABLES_CHILD) { - addShowChildTablesCond(pSelect); + code = addShowChildTablesCond(pSelect); } } - return TSDB_CODE_SUCCESS; + return code; } static int32_t createShowCondition(const SShowStmt* pShow, SSelectStmt* pSelect) { @@ -12057,7 +12453,7 @@ static int32_t createShowCondition(const SShowStmt* pShow, SSelectStmt* pSelect) } if (NULL != pDbCond && NULL != pTbCond) { - if (TSDB_CODE_SUCCESS != createLogicCondNode(pDbCond, pTbCond, &pSelect->pWhere, LOGIC_COND_TYPE_AND)) { + if (TSDB_CODE_SUCCESS != createLogicCondNode(&pDbCond, &pTbCond, &pSelect->pWhere, LOGIC_COND_TYPE_AND)) { nodesDestroyNode(pDbCond); nodesDestroyNode(pTbCond); return TSDB_CODE_OUT_OF_MEMORY; @@ -12195,7 +12591,7 @@ static int32_t rewriteShowDnodeVariables(STranslateContext* pCxt, SQuery* pQuery } if (TSDB_CODE_SUCCESS == code) { if (NULL != pLikeCond) { - code = createLogicCondNode(pDnodeCond, pLikeCond, &pSelect->pWhere, LOGIC_COND_TYPE_AND); + code = createLogicCondNode(&pDnodeCond, &pLikeCond, &pSelect->pWhere, LOGIC_COND_TYPE_AND); } else { pSelect->pWhere = pDnodeCond; } @@ -12279,8 +12675,8 @@ static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt* SVgroupCreateTableBatch* pBatch) { char dbFName[TSDB_DB_FNAME_LEN] = {0}; SName name = {.type = TSDB_DB_NAME_T, .acctId = acctId}; - strcpy(name.dbname, pStmt->dbName); - tNameGetFullDbName(&name, dbFName); + (void)strcpy(name.dbname, pStmt->dbName); + (void)tNameGetFullDbName(&name, dbFName); SVCreateTbReq req = {0}; req.type = TD_NORMAL_TABLE; @@ -12327,13 +12723,16 @@ static int32_t buildNormalTableBatchReq(int32_t acctId, const SCreateTableStmt* ++index; } pBatch->info = *pVgroupInfo; - strcpy(pBatch->dbName, pStmt->dbName); + (void)strcpy(pBatch->dbName, pStmt->dbName); pBatch->req.pArray = taosArrayInit(1, sizeof(struct SVCreateTbReq)); if (NULL == pBatch->req.pArray) { tdDestroySVCreateTbReq(&req); return TSDB_CODE_OUT_OF_MEMORY; } - taosArrayPush(pBatch->req.pArray, &req); + if (NULL == taosArrayPush(pBatch->req.pArray, &req)) { + tdDestroySVCreateTbReq(&req); + return TSDB_CODE_OUT_OF_MEMORY; + } return TSDB_CODE_SUCCESS; } @@ -12344,6 +12743,9 @@ static int32_t serializeVgroupCreateTableBatch(SVgroupCreateTableBatch* pTbBatch int32_t ret = 0; tEncodeSize(tEncodeSVCreateTbBatchReq, &pTbBatch->req, tlen, ret); + if (TSDB_CODE_SUCCESS != ret) { + return ret; + } tlen += sizeof(SMsgHead); void* buf = taosMemoryMalloc(tlen); if (NULL == buf) { @@ -12354,20 +12756,29 @@ static int32_t serializeVgroupCreateTableBatch(SVgroupCreateTableBatch* pTbBatch void* pBuf = POINTER_SHIFT(buf, sizeof(SMsgHead)); tEncoderInit(&coder, pBuf, tlen - sizeof(SMsgHead)); - tEncodeSVCreateTbBatchReq(&coder, &pTbBatch->req); + ret = tEncodeSVCreateTbBatchReq(&coder, &pTbBatch->req); tEncoderClear(&coder); + if (TSDB_CODE_SUCCESS != ret) { + taosMemoryFreeClear(buf); + return ret; + } SVgDataBlocks* pVgData = taosMemoryCalloc(1, sizeof(SVgDataBlocks)); if (NULL == pVgData) { + taosMemoryFreeClear(buf); return TSDB_CODE_OUT_OF_MEMORY; } pVgData->vg = pTbBatch->info; pVgData->pData = buf; pVgData->size = tlen; pVgData->numOfTables = (int32_t)taosArrayGetSize(pTbBatch->req.pArray); - taosArrayPush(pBufArray, &pVgData); + if (NULL == taosArrayPush(pBufArray, &pVgData)) { + ret = TSDB_CODE_OUT_OF_MEMORY; + taosMemoryFreeClear(buf); + taosMemoryFreeClear(pVgData); + } - return TSDB_CODE_SUCCESS; + return ret; } static void destroyCreateTbReqBatch(void* data) { @@ -12378,7 +12789,7 @@ static void destroyCreateTbReqBatch(void* data) { tdDestroySVCreateTbReq(pTableReq); } - taosArrayDestroy(pTbBatch->req.pArray); + (void)taosArrayDestroy(pTbBatch->req.pArray); } int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray) { @@ -12400,7 +12811,7 @@ static void destroyCreateTbReqArray(SArray* pArray) { taosMemoryFreeClear(pVg->pData); taosMemoryFreeClear(pVg); } - taosArrayDestroy(pArray); + (void)taosArrayDestroy(pArray); } static int32_t buildCreateTableDataBlock(int32_t acctId, const SCreateTableStmt* pStmt, const SVgroupInfo* pInfo, @@ -12429,7 +12840,7 @@ static int32_t rewriteCreateTable(STranslateContext* pCxt, SQuery* pQuery) { int32_t code = checkCreateTable(pCxt, pStmt, false); SVgroupInfo info = {0}; SName name; - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name); + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name); if (TSDB_CODE_SUCCESS == code) { code = getTableHashVgroupImpl(pCxt, &name, &info); } @@ -12478,6 +12889,7 @@ static int32_t addCreateTbReqIntoVgroup(SHashObj* pVgroupHashmap, const char* db return TSDB_CODE_OUT_OF_MEMORY; } + int32_t code = TSDB_CODE_SUCCESS; SVgroupCreateTableBatch* pTableBatch = taosHashGet(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId)); if (pTableBatch == NULL) { SVgroupCreateTableBatch tBatch = {0}; @@ -12485,14 +12897,28 @@ static int32_t addCreateTbReqIntoVgroup(SHashObj* pVgroupHashmap, const char* db strcpy(tBatch.dbName, dbName); tBatch.req.pArray = taosArrayInit(4, sizeof(struct SVCreateTbReq)); - taosArrayPush(tBatch.req.pArray, &req); - - taosHashPut(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &tBatch, sizeof(tBatch)); + if (!tBatch.req.pArray) { + code = terrno; + } else if (NULL == taosArrayPush(tBatch.req.pArray, &req)) { + (void)taosArrayDestroy(tBatch.req.pArray); + code = TSDB_CODE_OUT_OF_MEMORY; + } else { + code = taosHashPut(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &tBatch, sizeof(tBatch)); + if (TSDB_CODE_SUCCESS != code) { + (void)taosArrayDestroy(tBatch.req.pArray); + } + } } else { // add to the correct vgroup - taosArrayPush(pTableBatch->req.pArray, &req); + if (NULL == taosArrayPush(pTableBatch->req.pArray, &req)) { + code = TSDB_CODE_OUT_OF_MEMORY; + } } - return TSDB_CODE_SUCCESS; + if (TSDB_CODE_SUCCESS != code) { + tdDestroySVCreateTbReq(&req); + } + + return code; } static int32_t createCastFuncForTag(STranslateContext* pCxt, SNode* pNode, SDataType dt, SNode** pCast) { @@ -12575,7 +13001,7 @@ static int32_t buildKVRowForBindTags(STranslateContext* pCxt, SCreateSubTableCla taosMemoryFreeClear(p->pData); } } - taosArrayDestroy(pTagArray); + (void)taosArrayDestroy(pTagArray); return code; } @@ -12638,7 +13064,7 @@ static int32_t buildKVRowForAllTags(STranslateContext* pCxt, SCreateSubTableClau taosMemoryFreeClear(p->pData); } } - taosArrayDestroy(pTagArray); + (void)taosArrayDestroy(pTagArray); return code; } @@ -12661,7 +13087,7 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla } if (TSDB_CODE_SUCCESS == code) { SName name; - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name); + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name); code = collectUseTable(&name, pCxt->pTargetTables); } @@ -12689,7 +13115,7 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla taosMemoryFree(pTag); } - taosArrayDestroy(tagName); + (void)taosArrayDestroy(tagName); taosMemoryFreeClear(pSuperTableMeta); return code; } @@ -12900,7 +13326,7 @@ static int32_t parseCsvFile(SMsgBuf* pMsgBuf, SParseContext* pParseCxt, SParseFi if (pLine[0] == '#') continue; // ignore comment line begins with '#' - strtolower(pLine, pLine); + (void)strtolower(pLine, pLine); pParFileCxt->pSql = pLine; code = parseOneStbRow(pMsgBuf, pParFileCxt); @@ -12927,7 +13353,10 @@ static int32_t parseCsvFile(SMsgBuf* pMsgBuf, SParseContext* pParseCxt, SParseFi .pTag = pParFileCxt->pTag, .vg = pParFileCxt->vg}; - taosArrayPush(pParFileCxt->aCreateTbData, &data); + if (NULL == taosArrayPush(pParFileCxt->aCreateTbData, &data)) { + taosMemoryFreeClear(pParFileCxt->pTag); + code = TSDB_CODE_OUT_OF_MEMORY; + } } else { taosMemoryFreeClear(pParFileCxt->pTag); } @@ -13132,10 +13561,10 @@ static int32_t createSubTableFromFile(SMsgBuf* pMsgBuf, SParseContext* pParseCxt return code; } -SArray* serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap) { +int32_t serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap, SArray** pOut) { SArray* pBufArray = taosArrayInit(taosHashGetSize(pVgroupHashmap), sizeof(void*)); if (NULL == pBufArray) { - return NULL; + return terrno; } int32_t code = TSDB_CODE_SUCCESS; @@ -13146,10 +13575,20 @@ SArray* serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap) { break; } - serializeVgroupCreateTableBatch(pTbBatch, pBufArray); + code = serializeVgroupCreateTableBatch(pTbBatch, pBufArray); + if (TSDB_CODE_SUCCESS != code) { + taosHashCancelIterate(pVgroupHashmap, pTbBatch); + break; + } } while (true); - return pBufArray; + if (TSDB_CODE_SUCCESS != code) { + (void)taosArrayDestroy(pBufArray); + } else { + *pOut = pBufArray; + } + + return code; } static int32_t rewriteCreateMultiTable(STranslateContext* pCxt, SQuery* pQuery) { @@ -13172,10 +13611,11 @@ static int32_t rewriteCreateMultiTable(STranslateContext* pCxt, SQuery* pQuery) } } - SArray* pBufArray = serializeVgroupsCreateTableBatch(pVgroupHashmap); + SArray* pBufArray = NULL; + code = serializeVgroupsCreateTableBatch(pVgroupHashmap, &pBufArray); taosHashCleanup(pVgroupHashmap); - if (NULL == pBufArray) { - return TSDB_CODE_OUT_OF_MEMORY; + if (TSDB_CODE_SUCCESS != code) { + return code; } return rewriteToVnodeModifyOpStmt(pQuery, pBufArray); @@ -13209,11 +13649,12 @@ static int32_t rewriteCreateTableFromFile(STranslateContext* pCxt, SQuery* pQuer return code; } - SArray* pBufArray = serializeVgroupsCreateTableBatch(pModifyStmt->pVgroupsHashObj); + SArray* pBufArray = NULL; + code = serializeVgroupsCreateTableBatch(pModifyStmt->pVgroupsHashObj, &pBufArray); taosHashClear(pModifyStmt->pVgroupsHashObj); - if (NULL == pBufArray) { + if (TSDB_CODE_SUCCESS != code) { taosHashCleanup(pModifyStmt->pVgroupsHashObj); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pModifyStmt->pDataBlocks = pBufArray; @@ -13231,10 +13672,10 @@ int32_t continueCreateTbFromFile(SParseContext* pParseCxt, SQuery** pQuery) { int32_t code = createSubTableFromFile(&tmpBuf, pParseCxt, pModifyStmt); if (TSDB_CODE_SUCCESS != code) goto _OUT; - SArray* pBufArray = serializeVgroupsCreateTableBatch(pModifyStmt->pVgroupsHashObj); + SArray* pBufArray = NULL; + code = serializeVgroupsCreateTableBatch(pModifyStmt->pVgroupsHashObj, &pBufArray); taosHashClear(pModifyStmt->pVgroupsHashObj); - if (NULL == pBufArray) { - code = TSDB_CODE_OUT_OF_MEMORY; + if (TSDB_CODE_SUCCESS != code) { goto _OUT; } @@ -13256,18 +13697,31 @@ typedef struct SVgroupDropTableBatch { char dbName[TSDB_DB_NAME_LEN]; } SVgroupDropTableBatch; -static void addDropTbReqIntoVgroup(SHashObj* pVgroupHashmap, SVgroupInfo* pVgInfo, SVDropTbReq* pReq) { +static int32_t addDropTbReqIntoVgroup(SHashObj* pVgroupHashmap, SVgroupInfo* pVgInfo, SVDropTbReq* pReq) { SVgroupDropTableBatch* pTableBatch = taosHashGet(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId)); + int32_t code = TSDB_CODE_SUCCESS; if (NULL == pTableBatch) { SVgroupDropTableBatch tBatch = {0}; tBatch.info = *pVgInfo; tBatch.req.pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVDropTbReq)); - taosArrayPush(tBatch.req.pArray, pReq); + if (NULL == taosArrayPush(tBatch.req.pArray, pReq)) { + (void)taosArrayDestroy(tBatch.req.pArray); + tBatch.req.pArray = NULL; + return TSDB_CODE_OUT_OF_MEMORY; + } - taosHashPut(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &tBatch, sizeof(tBatch)); + code = taosHashPut(pVgroupHashmap, &pVgInfo->vgId, sizeof(pVgInfo->vgId), &tBatch, sizeof(tBatch)); + if (TSDB_CODE_SUCCESS != code) { + (void)taosArrayDestroy(tBatch.req.pArray); + tBatch.req.pArray = NULL; + return code; + } } else { // add to the correct vgroup - taosArrayPush(pTableBatch->req.pArray, pReq); + if (NULL == taosArrayPush(pTableBatch->req.pArray, pReq)) { + return TSDB_CODE_OUT_OF_MEMORY; + } } + return code; } static int32_t buildDropTableVgroupHashmap(STranslateContext* pCxt, SDropTableClause* pClause, const SName* name, @@ -13295,7 +13749,7 @@ static int32_t buildDropTableVgroupHashmap(STranslateContext* pCxt, SDropTableCl if (TSDB_CODE_SUCCESS == code) { SVDropTbReq req = {.suid = pTableMeta->suid, .igNotExists = pClause->ignoreNotExists}; req.name = pClause->tableName; - addDropTbReqIntoVgroup(pVgroupHashmap, &info, &req); + code = addDropTbReqIntoVgroup(pVgroupHashmap, &info, &req); } over: @@ -13305,7 +13759,7 @@ over: static void destroyDropTbReqBatch(void* data) { SVgroupDropTableBatch* pTbBatch = (SVgroupDropTableBatch*)data; - taosArrayDestroy(pTbBatch->req.pArray); + (void)taosArrayDestroy(pTbBatch->req.pArray); } static int32_t serializeVgroupDropTableBatch(SVgroupDropTableBatch* pTbBatch, SArray* pBufArray) { @@ -13314,6 +13768,7 @@ static int32_t serializeVgroupDropTableBatch(SVgroupDropTableBatch* pTbBatch, SA int32_t ret = 0; tEncodeSize(tEncodeSVDropTbBatchReq, &pTbBatch->req, tlen, ret); + if (TSDB_CODE_SUCCESS != ret) return ret; tlen += sizeof(SMsgHead); void* buf = taosMemoryMalloc(tlen); if (NULL == buf) { @@ -13324,26 +13779,35 @@ static int32_t serializeVgroupDropTableBatch(SVgroupDropTableBatch* pTbBatch, SA void* pBuf = POINTER_SHIFT(buf, sizeof(SMsgHead)); tEncoderInit(&coder, pBuf, tlen - sizeof(SMsgHead)); - tEncodeSVDropTbBatchReq(&coder, &pTbBatch->req); + ret = tEncodeSVDropTbBatchReq(&coder, &pTbBatch->req); tEncoderClear(&coder); + if (TSDB_CODE_SUCCESS != ret) { + taosMemoryFreeClear(buf); + return ret; + } SVgDataBlocks* pVgData = taosMemoryCalloc(1, sizeof(SVgDataBlocks)); if (NULL == pVgData) { + taosMemoryFreeClear(buf); return TSDB_CODE_OUT_OF_MEMORY; } pVgData->vg = pTbBatch->info; pVgData->pData = buf; pVgData->size = tlen; pVgData->numOfTables = (int32_t)taosArrayGetSize(pTbBatch->req.pArray); - taosArrayPush(pBufArray, &pVgData); + if (NULL == taosArrayPush(pBufArray, &pVgData)) { + ret = TSDB_CODE_OUT_OF_MEMORY; + taosMemoryFreeClear(pVgData); + taosMemoryFreeClear(buf); + } - return TSDB_CODE_SUCCESS; + return ret; } -SArray* serializeVgroupsDropTableBatch(SHashObj* pVgroupHashmap) { +int32_t serializeVgroupsDropTableBatch(SHashObj* pVgroupHashmap, SArray** pOut) { SArray* pBufArray = taosArrayInit(taosHashGetSize(pVgroupHashmap), sizeof(void*)); if (NULL == pBufArray) { - return NULL; + return terrno; } int32_t code = TSDB_CODE_SUCCESS; @@ -13354,10 +13818,16 @@ SArray* serializeVgroupsDropTableBatch(SHashObj* pVgroupHashmap) { break; } - serializeVgroupDropTableBatch(pTbBatch, pBufArray); + code = serializeVgroupDropTableBatch(pTbBatch, pBufArray); + if (TSDB_CODE_SUCCESS != code) { + taosHashCancelIterate(pVgroupHashmap, pTbBatch); + (void)taosArrayDestroy(pBufArray); + break; + } } while (true); - return pBufArray; + *pOut = pBufArray; + return code; } static int32_t rewriteDropTable(STranslateContext* pCxt, SQuery* pQuery) { @@ -13375,7 +13845,7 @@ static int32_t rewriteDropTable(STranslateContext* pCxt, SQuery* pQuery) { FOREACH(pNode, pStmt->pTables) { SDropTableClause* pClause = (SDropTableClause*)pNode; SName name; - toName(pCxt->pParseCxt->acctId, pClause->dbName, pClause->tableName, &name); + (void)toName(pCxt->pParseCxt->acctId, pClause->dbName, pClause->tableName, &name); int32_t code = buildDropTableVgroupHashmap(pCxt, pClause, &name, &tableType, pVgroupHashmap); if (TSDB_CODE_SUCCESS != code) { taosHashCleanup(pVgroupHashmap); @@ -13420,20 +13890,26 @@ static int32_t rewriteDropTable(STranslateContext* pCxt, SQuery* pQuery) { SMDropTbReqsOnSingleVg reqOnVg = {0}; reqOnVg.vgInfo = pTbBatch->info; reqOnVg.pTbs = pTbBatch->req.pArray; - taosArrayPush(req.pVgReqs, &reqOnVg); + if (NULL == taosArrayPush(req.pVgReqs, &reqOnVg)) { + taosHashCancelIterate(pVgroupHashmap, pTbBatch); + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } } while (true); - - code = buildCmdMsg(pCxt, TDMT_MND_DROP_TB_WITH_TSMA, (FSerializeFunc)tSerializeSMDropTbsReq, &req); - taosArrayDestroy(req.pVgReqs); + if (TSDB_CODE_SUCCESS == code) { + code = buildCmdMsg(pCxt, TDMT_MND_DROP_TB_WITH_TSMA, (FSerializeFunc)tSerializeSMDropTbsReq, &req); + } + (void)taosArrayDestroy(req.pVgReqs); } taosHashCleanup(pVgroupHashmap); return code; } - SArray* pBufArray = serializeVgroupsDropTableBatch(pVgroupHashmap); + SArray* pBufArray = NULL; + code = serializeVgroupsDropTableBatch(pVgroupHashmap, &pBufArray); taosHashCleanup(pVgroupHashmap); - if (NULL == pBufArray) { - return TSDB_CODE_OUT_OF_MEMORY; + if (TSDB_CODE_SUCCESS != code) { + return code; } return rewriteToVnodeModifyOpStmt(pQuery, pBufArray); @@ -13445,7 +13921,7 @@ static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pS SArray* pTsmas = NULL; int32_t code = TSDB_CODE_SUCCESS; if (pCxt->pMetaCache) { - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tbName); + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tbName); code = getTableTsmasFromCache(pCxt->pMetaCache, &tbName, &pTsmas); if (code != TSDB_CODE_SUCCESS) return code; if (pTsmas && pTsmas->size > 0) return TSDB_CODE_TSMA_MUST_BE_DROPPED; @@ -13629,7 +14105,7 @@ static int32_t buildRenameColReq(STranslateContext* pCxt, SAlterTableStmt* pStmt SArray* pTsmas = NULL; SName tbName; int32_t code = 0; - toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tbName); + (void)toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &tbName); if (pCxt->pMetaCache) code = getTableTsmasFromCache(pCxt->pMetaCache, &tbName, &pTsmas); if (TSDB_CODE_SUCCESS != code) return code; if (pTsmas && pTsmas->size > 0) { @@ -13754,7 +14230,10 @@ static int32_t serializeAlterTbReq(STranslateContext* pCxt, SAlterTableStmt* pSt void* pBuf = POINTER_SHIFT(pMsg, sizeof(SMsgHead)); SEncoder coder = {0}; tEncoderInit(&coder, pBuf, tlen - sizeof(SMsgHead)); - tEncodeSVAlterTbReq(&coder, pReq); + if (TSDB_CODE_SUCCESS != tEncodeSVAlterTbReq(&coder, pReq)) { + taosMemoryFree(pMsg); + return terrno; + } tEncoderClear(&coder); SVgDataBlocks* pVgData = taosMemoryCalloc(1, sizeof(SVgDataBlocks)); @@ -13766,7 +14245,9 @@ static int32_t serializeAlterTbReq(STranslateContext* pCxt, SAlterTableStmt* pSt pVgData->pData = pMsg; pVgData->size = tlen; pVgData->numOfTables = 1; - taosArrayPush(pArray, &pVgData); + if (NULL == taosArrayPush(pArray, &pVgData)) { + code = TSDB_CODE_OUT_OF_MEMORY; + } } return code; @@ -13783,7 +14264,7 @@ static int32_t buildModifyVnodeArray(STranslateContext* pCxt, SAlterTableStmt* p if (TSDB_CODE_SUCCESS == code) { *pArray = pTmpArray; } else { - taosArrayDestroy(pTmpArray); + (void)taosArrayDestroy(pTmpArray); } return code; @@ -13801,7 +14282,7 @@ static void destoryAlterTbReq(SVAlterTbReq* pReq) { taosMemoryFreeClear(p->pData); } } - taosArrayDestroy(pReq->pTagArray); + (void)taosArrayDestroy(pReq->pTagArray); if (pReq->tagFree) tTagFree((STag*)pReq->pTagVal); } @@ -13853,6 +14334,7 @@ static int32_t rewriteAlterTable(STranslateContext* pCxt, SQuery* pQuery) { static int32_t serializeFlushVgroup(SVgroupInfo* pVg, SArray* pBufArray) { int32_t len = sizeof(SMsgHead); void* buf = taosMemoryMalloc(len); + int32_t code = TSDB_CODE_SUCCESS; if (NULL == buf) { return TSDB_CODE_OUT_OF_MEMORY; } @@ -13867,9 +14349,11 @@ static int32_t serializeFlushVgroup(SVgroupInfo* pVg, SArray* pBufArray) { pVgData->vg = *pVg; pVgData->pData = buf; pVgData->size = len; - taosArrayPush(pBufArray, &pVgData); + if (NULL == taosArrayPush(pBufArray, &pVgData)) { + code = TSDB_CODE_OUT_OF_MEMORY; + } - return TSDB_CODE_SUCCESS; + return code; } static int32_t serializeFlushDb(SArray* pVgs, SArray** pOutput) { @@ -13883,7 +14367,7 @@ static int32_t serializeFlushDb(SArray* pVgs, SArray** pOutput) { for (int32_t i = 0; i < numOfVgs; ++i) { int32_t code = serializeFlushVgroup((SVgroupInfo*)taosArrayGet(pVgs, i), pBufArray); if (TSDB_CODE_SUCCESS != code) { - taosArrayDestroy(pBufArray); + (void)taosArrayDestroy(pBufArray); return code; } } @@ -13905,9 +14389,9 @@ static int32_t rewriteFlushDatabase(STranslateContext* pCxt, SQuery* pQuery) { code = rewriteToVnodeModifyOpStmt(pQuery, pBufArray); } if (TSDB_CODE_SUCCESS != code) { - taosArrayDestroy(pBufArray); + (void)taosArrayDestroy(pBufArray); } - taosArrayDestroy(pVgs); + (void)taosArrayDestroy(pVgs); return code; } @@ -14026,9 +14510,9 @@ static int32_t rewriteShowAliveStmt(STranslateContext* pCxt, SQuery* pQuery) { SNode* pTemp1 = NULL; SNode* pTemp2 = NULL; SNode* pFullCond = NULL; - CHECK_RES_OUT_OF_MEM(createLogicCondNode(pCond1, pCond2, &pTemp1, LOGIC_COND_TYPE_OR)); - CHECK_RES_OUT_OF_MEM(createLogicCondNode(pTemp1, pCond3, &pTemp2, LOGIC_COND_TYPE_OR)); - CHECK_RES_OUT_OF_MEM(createLogicCondNode(pTemp2, pCond4, &pFullCond, LOGIC_COND_TYPE_OR)); + CHECK_RES_OUT_OF_MEM(createLogicCondNode(&pCond1, &pCond2, &pTemp1, LOGIC_COND_TYPE_OR)); + CHECK_RES_OUT_OF_MEM(createLogicCondNode(&pTemp1, &pCond3, &pTemp2, LOGIC_COND_TYPE_OR)); + CHECK_RES_OUT_OF_MEM(createLogicCondNode(&pTemp2, &pCond4, &pFullCond, LOGIC_COND_TYPE_OR)); SNode* pThen = nodesMakeValueNodeFromInt32(1); CHECK_POINTER_OUT_OF_MEM(pThen); @@ -14093,7 +14577,7 @@ static int32_t rewriteShowAliveStmt(STranslateContext* pCxt, SQuery* pQuery) { CHECK_RES_OUT_OF_MEM(createOperatorNode(OP_TYPE_GREATER_THAN, pSumColAlias, pTempVal, &pCond2)); // leader_col = count_col and leader_col > 0 pTemp1 = NULL; - CHECK_RES_OUT_OF_MEM(createLogicCondNode(pCond1, pCond2, &pTemp1, LOGIC_COND_TYPE_AND)); + CHECK_RES_OUT_OF_MEM(createLogicCondNode(&pCond1, &pCond2, &pTemp1, LOGIC_COND_TYPE_AND)); pThen = nodesMakeValueNodeFromInt32(1); CHECK_POINTER_OUT_OF_MEM(pThen); @@ -14108,7 +14592,7 @@ static int32_t rewriteShowAliveStmt(STranslateContext* pCxt, SQuery* pQuery) { CHECK_RES_OUT_OF_MEM(createOperatorNode(OP_TYPE_GREATER_THAN, pSumColAlias, pTempVal, &pCond2)); // leader_col < count_col and leader_col > 0 pTemp2 = NULL; - CHECK_RES_OUT_OF_MEM(createLogicCondNode(pCond1, pCond2, &pTemp2, LOGIC_COND_TYPE_AND)); + CHECK_RES_OUT_OF_MEM(createLogicCondNode(&pCond1, &pCond2, &pTemp2, LOGIC_COND_TYPE_AND)); nodesDestroyNode((SNode*)pTempVal); pThen = nodesMakeValueNodeFromInt32(2); @@ -14247,40 +14731,49 @@ static int32_t toMsgType(ENodeType type) { static int32_t setRefreshMeta(STranslateContext* pCxt, SQuery* pQuery) { if (NULL != pCxt->pDbs) { - taosArrayDestroy(pQuery->pDbList); + (void)taosArrayDestroy(pQuery->pDbList); pQuery->pDbList = taosArrayInit(taosHashGetSize(pCxt->pDbs), TSDB_DB_FNAME_LEN); if (NULL == pQuery->pDbList) { return TSDB_CODE_OUT_OF_MEMORY; } SFullDatabaseName* pDb = taosHashIterate(pCxt->pDbs, NULL); while (NULL != pDb) { - taosArrayPush(pQuery->pDbList, pDb->fullDbName); + if (NULL == taosArrayPush(pQuery->pDbList, pDb->fullDbName)) { + taosHashCancelIterate(pCxt->pDbs, pDb); + return TSDB_CODE_OUT_OF_MEMORY; + } pDb = taosHashIterate(pCxt->pDbs, pDb); } } if (NULL != pCxt->pTables) { - taosArrayDestroy(pQuery->pTableList); + (void)taosArrayDestroy(pQuery->pTableList); pQuery->pTableList = taosArrayInit(taosHashGetSize(pCxt->pTables), sizeof(SName)); if (NULL == pQuery->pTableList) { return TSDB_CODE_OUT_OF_MEMORY; } SName* pTable = taosHashIterate(pCxt->pTables, NULL); while (NULL != pTable) { - taosArrayPush(pQuery->pTableList, pTable); + if (NULL == taosArrayPush(pQuery->pTableList, pTable)) { + taosHashCancelIterate(pCxt->pTables, pTable); + return TSDB_CODE_OUT_OF_MEMORY; + } pTable = taosHashIterate(pCxt->pTables, pTable); } } if (NULL != pCxt->pTargetTables) { - taosArrayDestroy(pQuery->pTargetTableList); + (void)taosArrayDestroy(pQuery->pTargetTableList); pQuery->pTargetTableList = taosArrayInit(taosHashGetSize(pCxt->pTargetTables), sizeof(SName)); if (NULL == pQuery->pTargetTableList) { return TSDB_CODE_OUT_OF_MEMORY; } SName* pTable = taosHashIterate(pCxt->pTargetTables, NULL); while (NULL != pTable) { - taosArrayPush(pQuery->pTargetTableList, pTable); + if (NULL == taosArrayPush(pQuery->pTargetTableList, pTable)) { + taosHashCancelIterate(pCxt->pTargetTables, pTable); + return TSDB_CODE_OUT_OF_MEMORY; + } pTable = taosHashIterate(pCxt->pTargetTables, pTable); } } @@ -14381,7 +14874,8 @@ int32_t translate(SParseContext* pParseCxt, SQuery* pQuery, SParseMetaCache* pMe if (TSDB_CODE_SUCCESS == code) { code = setQuery(&cxt, pQuery); } - setRefreshMeta(&cxt, pQuery); + int32_t tmpCode = setRefreshMeta(&cxt, pQuery); + if (TSDB_CODE_SUCCESS == code) code = tmpCode; destroyTranslateContext(&cxt); return code; } From 0afc8a687ad32c4146fb2732fcc582b3b2635abc Mon Sep 17 00:00:00 2001 From: kailixu Date: Wed, 17 Jul 2024 10:54:30 +0800 Subject: [PATCH 06/12] enh: grant supports mongodb --- tests/system-test/0-others/information_schema.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/system-test/0-others/information_schema.py b/tests/system-test/0-others/information_schema.py index d5754b1063..d7a5540544 100644 --- a/tests/system-test/0-others/information_schema.py +++ b/tests/system-test/0-others/information_schema.py @@ -297,7 +297,8 @@ class TDTestCase: 'mysql':'MySQL', 'postgres':'PostgreSQL', 'oracle':'Oracle', - 'mssql':'SqlServer' + 'mssql':'SqlServer', + 'mongodb':'MongoDB', } tdSql.execute('drop database if exists db2') From e68ac2300e571a93b3aa23b1794ec4776fad8c71 Mon Sep 17 00:00:00 2001 From: dmchen Date: Wed, 17 Jul 2024 03:22:02 +0000 Subject: [PATCH 07/12] fix/TD-30973 --- source/dnode/mnode/impl/src/mndStreamUtil.c | 1 + 1 file changed, 1 insertion(+) diff --git a/source/dnode/mnode/impl/src/mndStreamUtil.c b/source/dnode/mnode/impl/src/mndStreamUtil.c index e4e30bdf10..843c024286 100644 --- a/source/dnode/mnode/impl/src/mndStreamUtil.c +++ b/source/dnode/mnode/impl/src/mndStreamUtil.c @@ -105,6 +105,7 @@ SArray *mndTakeVgroupSnapshot(SMnode *pMnode, bool *allReady) { mInfo("vgId:%d replica:%d inconsistent with other vgroups replica:%d, not ready for stream operations", pVgroup->vgId, pVgroup->replica, replica); *allReady = false; + sdbRelease(pSdb, pVgroup); break; } } From fdd866737d00c7534a9af37d9191626d6187fd3d Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 17 Jul 2024 13:17:40 +0800 Subject: [PATCH 08/12] fix more --- source/dnode/vnode/src/tq/tqUtil.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/dnode/vnode/src/tq/tqUtil.c b/source/dnode/vnode/src/tq/tqUtil.c index 4ecab9e400..16c523a50e 100644 --- a/source/dnode/vnode/src/tq/tqUtil.c +++ b/source/dnode/vnode/src/tq/tqUtil.c @@ -572,7 +572,7 @@ int32_t tqExtractDelDataBlock(const void* pData, int32_t len, int64_t ver, void* taosArrayDestroy(pRes->uidList); if (type == 0) { - code = taosAllocateQitem(sizeof(SStreamRefDataBlock), DEF_QITEM, 0, (void**)&pRefBlock); + code = taosAllocateQitem(sizeof(SStreamRefDataBlock), DEF_QITEM, 0, pRefBlock); if (code) { blockDataCleanup(pDelBlock); taosMemoryFree(pDelBlock); From 931749dca6e1f902be972b26958dca4ada3ee123 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 17 Jul 2024 16:15:19 +0800 Subject: [PATCH 09/12] refactor tsdb code --- include/util/tbuffer.inc | 17 +- include/util/tutil.h | 2 + source/dnode/vnode/src/inc/tsdb.h | 153 ++-- .../dnode/vnode/src/tsdb/tsdbReaderWriter.c | 7 +- source/dnode/vnode/src/tsdb/tsdbUpgrade.c | 37 +- source/dnode/vnode/src/tsdb/tsdbUtil.c | 835 ++++-------------- source/dnode/vnode/src/tsdb/tsdbUtil2.c | 258 +++--- 7 files changed, 387 insertions(+), 922 deletions(-) diff --git a/include/util/tbuffer.inc b/include/util/tbuffer.inc index 2c1405d6c5..595c1e0827 100644 --- a/include/util/tbuffer.inc +++ b/include/util/tbuffer.inc @@ -15,6 +15,7 @@ #include "taoserror.h" #include "tcoding.h" +#include "tutil.h" struct SBuffer { uint32_t size; @@ -67,8 +68,7 @@ static FORCE_INLINE int32_t tBufferEnsureCapacity(SBuffer *buffer, uint32_t capa } static FORCE_INLINE int32_t tBufferPut(SBuffer *buffer, const void *data, uint32_t size) { - int32_t code = tBufferEnsureCapacity(buffer, buffer->size + size); - if (code) return code; + TAOS_CHECK_RETURN(tBufferEnsureCapacity(buffer, buffer->size + size)); memcpy((char *)buffer->data + buffer->size, data, size); buffer->size += size; return 0; @@ -119,10 +119,8 @@ static FORCE_INLINE int32_t tBufferPutU16v(SBuffer *buffer, uint16_t value) { re static FORCE_INLINE int32_t tBufferPutU32v(SBuffer *buffer, uint32_t value) { return tBufferPutU64v(buffer, value); } static FORCE_INLINE int32_t tBufferPutU64v(SBuffer *buffer, uint64_t value) { - int32_t code; while (value >= 0x80) { - code = tBufferPutU8(buffer, (value & 0x7F) | 0x80); - if (code) return code; + TAOS_CHECK_RETURN(tBufferPutU8(buffer, (value & 0x7F) | 0x80)); value >>= 7; } return tBufferPutU8(buffer, value); @@ -141,8 +139,7 @@ static FORCE_INLINE int32_t tBufferPutI64v(SBuffer *buffer, int64_t value) { } static FORCE_INLINE int32_t tBufferPutBinary(SBuffer *buffer, const void *data, uint32_t size) { - int32_t code = tBufferPutU32v(buffer, size); - if (code) return code; + TAOS_CHECK_RETURN(tBufferPutU32v(buffer, size)); return tBufferPut(buffer, data, size); } @@ -324,8 +321,7 @@ static int32_t tBufferGetF32(SBufferReader *reader, float *value) { float f; uint32_t u; } u; - int32_t code = tBufferGetU32(reader, &u.u); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetU32(reader, &u.u)); if (value) { *value = u.f; } @@ -337,8 +333,7 @@ static int32_t tBufferGetF64(SBufferReader *reader, double *value) { double f; uint64_t u; } u; - int32_t code = tBufferGetU64(reader, &u.u); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetU64(reader, &u.u)); if (value) { *value = u.f; } diff --git a/include/util/tutil.h b/include/util/tutil.h index 31ce34f667..2aa28ac1df 100644 --- a/include/util/tutil.h +++ b/include/util/tutil.h @@ -172,6 +172,8 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen, } \ } while (0) +#define TAOS_UNUSED(expr) (void)(expr) + #ifdef __cplusplus } #endif diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h index 943ba099f6..21dd48919e 100644 --- a/source/dnode/vnode/src/inc/tsdb.h +++ b/source/dnode/vnode/src/inc/tsdb.h @@ -147,7 +147,6 @@ int32_t tsdbRowKeyCmpr(const STsdbRowKey *key1, const STsdbRowKey *key2); void tsdbRowGetKey(TSDBROW *row, STsdbRowKey *key); void tColRowGetPrimaryKey(SBlockData *pBlock, int32_t irow, SRowKey *key); - // STSDBRowIter int32_t tsdbRowIterOpen(STSDBRowIter *pIter, TSDBROW *pRow, STSchema *pTSchema); void tsdbRowClose(STSDBRowIter *pIter); @@ -223,11 +222,11 @@ void tMapDataReset(SMapData *pMapData); void tMapDataClear(SMapData *pMapData); int32_t tMapDataPutItem(SMapData *pMapData, void *pItem, int32_t (*tPutItemFn)(uint8_t *, void *)); int32_t tMapDataCopy(SMapData *pFrom, SMapData *pTo); -void tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)); +int32_t tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)); 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, int64_t *decodeSize); int32_t tMapDataToArray(SMapData *pMapData, int32_t itemSize, int32_t (*tGetItemFn)(uint8_t *, void *), SArray **ppArray); // other @@ -245,10 +244,10 @@ void tsdbMemTableDestroy(SMemTable *pMemTable, bool proactive); STbData *tsdbGetTbDataFromMemTable(SMemTable *pMemTable, tb_uid_t suid, tb_uid_t uid); int32_t tsdbRefMemTable(SMemTable *pMemTable, SQueryNode *pQNode); int32_t tsdbUnrefMemTable(SMemTable *pMemTable, SQueryNode *pNode, bool proactive); -SArray * tsdbMemTableGetTbDataArray(SMemTable *pMemTable); +SArray *tsdbMemTableGetTbDataArray(SMemTable *pMemTable); // STbDataIter int32_t tsdbTbDataIterCreate(STbData *pTbData, STsdbRowKey *pFrom, int8_t backward, STbDataIter **ppIter); -void * tsdbTbDataIterDestroy(STbDataIter *pIter); +void *tsdbTbDataIterDestroy(STbDataIter *pIter); void tsdbTbDataIterOpen(STbData *pTbData, STsdbRowKey *pFrom, int8_t backward, STbDataIter *pIter); bool tsdbTbDataIterNext(STbDataIter *pIter); void tsdbMemTableCountRows(SMemTable *pMemTable, SSHashObj *pTableMap, int64_t *rowsNum); @@ -301,7 +300,7 @@ int32_t tsdbGetTableSchema(SMeta *pMeta, int64_t uid, STSchema **pSchema, int64_ // tsdbMerge.c ============================================================================================== typedef struct { - STsdb * tsdb; + STsdb *tsdb; int32_t fid; } SMergeArg; @@ -332,22 +331,22 @@ int32_t tsdbDataIterNext2(STsdbDataIter2 *pIter, STsdbFilterInfo *pFilterInfo); // structs ======================= struct STsdbFS { SDelFile *pDelFile; - SArray * aDFileSet; // SArray + SArray *aDFileSet; // SArray }; typedef struct { - rocksdb_t * db; - rocksdb_comparator_t * my_comparator; - rocksdb_cache_t * blockcache; + rocksdb_t *db; + rocksdb_comparator_t *my_comparator; + rocksdb_cache_t *blockcache; rocksdb_block_based_table_options_t *tableoptions; - rocksdb_options_t * options; - rocksdb_flushoptions_t * flushoptions; - rocksdb_writeoptions_t * writeoptions; - rocksdb_readoptions_t * readoptions; - rocksdb_writebatch_t * writebatch; - rocksdb_writebatch_t * rwritebatch; + rocksdb_options_t *options; + rocksdb_flushoptions_t *flushoptions; + rocksdb_writeoptions_t *writeoptions; + rocksdb_readoptions_t *readoptions; + rocksdb_writebatch_t *writebatch; + rocksdb_writebatch_t *rwritebatch; TdThreadMutex rMutex; - STSchema * pTSchema; + STSchema *pTSchema; } SRocksCache; typedef struct { @@ -358,26 +357,26 @@ typedef struct { typedef struct SCompMonitor SCompMonitor; struct STsdb { - char * path; - SVnode * pVnode; + char *path; + SVnode *pVnode; STsdbKeepCfg keepCfg; TdThreadMutex mutex; bool bgTaskDisabled; - SMemTable * mem; - SMemTable * imem; + SMemTable *mem; + SMemTable *imem; STsdbFS fs; // old - SLRUCache * lruCache; + SLRUCache *lruCache; SCacheFlushState flushState; TdThreadMutex lruMutex; - SLRUCache * biCache; + SLRUCache *biCache; TdThreadMutex biMutex; - SLRUCache * bCache; + SLRUCache *bCache; TdThreadMutex bMutex; - SLRUCache * pgCache; + SLRUCache *pgCache; TdThreadMutex pgMutex; struct STFileSystem *pFS; // new SRocksCache rCache; - SCompMonitor *pCompMonitor; + SCompMonitor *pCompMonitor; struct { SVHashTable *ht; SArray *arr; @@ -405,17 +404,17 @@ struct STbData { TSKEY minKey; TSKEY maxKey; SRWLatch lock; - SDelData * pHead; - SDelData * pTail; + SDelData *pHead; + SDelData *pTail; SMemSkipList sl; - STbData * next; + STbData *next; SRBTreeNode rbtn[1]; }; struct SMemTable { SRWLatch latch; - STsdb * pTsdb; - SVBufPool * pPool; + STsdb *pTsdb; + SVBufPool *pPool; volatile int32_t nRef; int64_t minVer; int64_t maxVer; @@ -425,7 +424,7 @@ struct SMemTable { int64_t nDel; int32_t nTbData; int32_t nBucket; - STbData ** aBucket; + STbData **aBucket; SRBTree tbDataTree[1]; }; @@ -434,7 +433,7 @@ struct TSDBROW { union { struct { int64_t version; - SRow * pTSRow; + SRow *pTSRow; }; struct { SBlockData *pBlockData; @@ -535,9 +534,9 @@ struct SBlockData { int64_t suid; // 0 means normal table block data, otherwise child table block data int64_t uid; // 0 means block data in .last file, otherwise in .data file int32_t nRow; // number of rows - int64_t * aUid; // uids of each row, only exist in block data in .last file (uid == 0) - int64_t * aVersion; // versions of each row - TSKEY * aTSKEY; // timestamp of each row + int64_t *aUid; // uids of each row, only exist in block data in .last file (uid == 0) + int64_t *aVersion; // versions of each row + TSKEY *aTSKEY; // timestamp of each row int32_t nColData; SColData *aColData; }; @@ -548,10 +547,10 @@ struct TABLEID { }; struct STbDataIter { - STbData * pTbData; + STbData *pTbData; int8_t backward; SMemSkipListNode *pNode; - TSDBROW * pRow; + TSDBROW *pRow; TSDBROW row; }; @@ -629,9 +628,9 @@ struct SDFileSet { int32_t fid; SHeadFile *pHeadF; SDataFile *pDataF; - SSmaFile * pSmaF; + SSmaFile *pSmaF; uint8_t nSttF; - SSttFile * aSttF[TSDB_STT_TRIGGER_ARRAY_SIZE]; + SSttFile *aSttF[TSDB_STT_TRIGGER_ARRAY_SIZE]; }; struct STSDBRowIter { @@ -647,18 +646,18 @@ struct STSDBRowIter { struct SRowMerger { STSchema *pTSchema; int64_t version; - SArray * pArray; // SArray + SArray *pArray; // SArray }; typedef struct { - char * path; + char *path; int32_t szPage; int32_t flag; TdFilePtr pFD; int64_t pgno; - uint8_t * pBuf; + uint8_t *pBuf; int64_t szFile; - STsdb * pTsdb; + STsdb *pTsdb; const char *objName; uint8_t s3File; int32_t lcn; @@ -668,7 +667,7 @@ typedef struct { } STsdbFD; struct SDelFWriter { - STsdb * pTsdb; + STsdb *pTsdb; SDelFile fDel; STsdbFD *pWriteH; uint8_t *aBuf[1]; @@ -728,15 +727,15 @@ int32_t tDeserializeTsdbRepOpts(void *buf, int32_t bufLen, STsdbRepOpts *pInfo); // snap read struct STsdbReadSnap { - SMemTable * pMem; - SQueryNode * pNode; - SMemTable * pIMem; - SQueryNode * pINode; + SMemTable *pMem; + SQueryNode *pNode; + SMemTable *pIMem; + SQueryNode *pINode; TFileSetArray *pfSetArray; }; struct SDataFWriter { - STsdb * pTsdb; + STsdb *pTsdb; SDFileSet wSet; STsdbFD *pHeadFD; @@ -753,13 +752,13 @@ struct SDataFWriter { }; struct SDataFReader { - STsdb * pTsdb; + STsdb *pTsdb; SDFileSet *pSet; - STsdbFD * pHeadFD; - STsdbFD * pDataFD; - STsdbFD * pSmaFD; - STsdbFD * aSttFD[TSDB_STT_TRIGGER_ARRAY_SIZE]; - uint8_t * aBuf[3]; + STsdbFD *pHeadFD; + STsdbFD *pDataFD; + STsdbFD *pSmaFD; + STsdbFD *aSttFD[TSDB_STT_TRIGGER_ARRAY_SIZE]; + uint8_t *aBuf[3]; }; // NOTE: do NOT change the order of the fields @@ -794,10 +793,10 @@ typedef struct { typedef struct SSttBlockLoadInfo { SBlockDataInfo blockData[2]; // buffered block data - SArray * aSttBlk; + SArray *aSttBlk; int32_t currentLoadBlockIndex; - STSchema * pSchema; - int16_t * colIds; + STSchema *pSchema; + int16_t *colIds; int32_t numOfCols; bool checkRemainingRow; // todo: no assign value? bool isLast; @@ -834,7 +833,7 @@ struct SDiskData { const uint8_t *pUid; const uint8_t *pVer; const uint8_t *pKey; - SArray * aDiskCol; // SArray + SArray *aDiskCol; // SArray }; struct SDiskDataBuilder { @@ -847,15 +846,15 @@ struct SDiskDataBuilder { SCompressor *pVerC; SCompressor *pKeyC; int32_t nBuilder; - SArray * aBuilder; // SArray - uint8_t * aBuf[2]; + SArray *aBuilder; // SArray + uint8_t *aBuf[2]; SDiskData dd; SBlkInfo bi; }; struct SLDataIter { SRBTreeNode node; - SSttBlk * pSttBlk; + SSttBlk *pSttBlk; int64_t cid; // for debug purpose int8_t backward; int32_t iSttBlk; @@ -864,8 +863,8 @@ struct SLDataIter { uint64_t uid; STimeWindow timeWindow; SVersionRange verRange; - SSttBlockLoadInfo * pBlockLoadInfo; - SRowKey * pStartRowKey; // current row key + SSttBlockLoadInfo *pBlockLoadInfo; + SRowKey *pStartRowKey; // current row key bool ignoreEarlierTs; struct SSttFileReader *pReader; }; @@ -878,21 +877,21 @@ typedef int32_t (*_load_tomb_fn)(STsdbReader *pReader, struct SSttFileReader *pS typedef struct SMergeTreeConf { int8_t backward; - STsdb * pTsdb; + STsdb *pTsdb; uint64_t suid; uint64_t uid; STimeWindow timewindow; SVersionRange verRange; bool strictTimeRange; - SArray * pSttFileBlockIterArray; - void * pCurrentFileset; - STSchema * pSchema; - int16_t * pCols; + SArray *pSttFileBlockIterArray; + void *pCurrentFileset; + STSchema *pSchema; + int16_t *pCols; int32_t numOfCols; - SRowKey * pCurRowKey; + SRowKey *pCurRowKey; _load_tomb_fn loadTombFn; - void * pReader; - void * idstr; + void *pReader; + void *idstr; bool rspRows; // response the rows in stt-file, if possible } SMergeTreeConf; @@ -1023,7 +1022,7 @@ struct STsdbDataIter2 { // TSDB_DATA_FILE_DATA_ITER struct { SDataFReader *pReader; - SArray * aBlockIdx; // SArray + SArray *aBlockIdx; // SArray SMapData mDataBlk; SBlockData bData; int32_t iBlockIdx; @@ -1035,7 +1034,7 @@ struct STsdbDataIter2 { struct { SDataFReader *pReader; int32_t iStt; - SArray * aSttBlk; + SArray *aSttBlk; SBlockData bData; int32_t iSttBlk; int32_t iRow; @@ -1043,8 +1042,8 @@ struct STsdbDataIter2 { // TSDB_TOMB_FILE_DATA_ITER struct { SDelFReader *pReader; - SArray * aDelIdx; - SArray * aDelData; + SArray *aDelIdx; + SArray *aDelData; int32_t iDelIdx; int32_t iDelData; } tIter; diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c index 932bf2d92c..8cbcdbc34f 100644 --- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c +++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c @@ -803,11 +803,8 @@ int32_t tsdbReadDataBlk(SDataFReader *pReader, SBlockIdx *pBlockIdx, SMapData *m if (code) goto _err; // decode - int64_t n = tGetMapData(pReader->aBuf[0], mDataBlk); - if (n < 0) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; - } + int64_t n; + TAOS_CHECK_GOTO(tGetMapData(pReader->aBuf[0], mDataBlk, &n), NULL, _err); ASSERT(n == size); return code; diff --git a/source/dnode/vnode/src/tsdb/tsdbUpgrade.c b/source/dnode/vnode/src/tsdb/tsdbUpgrade.c index 09ab2243a0..1052d1c1a1 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUpgrade.c +++ b/source/dnode/vnode/src/tsdb/tsdbUpgrade.c @@ -37,8 +37,8 @@ static int32_t tsdbUpgradeHead(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader * int8_t cmprAlg; int32_t szPage; SBuffer buffers[10]; - int32_t encryptAlgorithm; - char* encryptKey; + int32_t encryptAlgorithm; + char *encryptKey; // reader SArray *aBlockIdx; SMapData mDataBlk[1]; @@ -96,7 +96,7 @@ static int32_t tsdbUpgradeHead(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader * for (int32_t iDataBlk = 0; iDataBlk < ctx->mDataBlk->nItem; ++iDataBlk) { SDataBlk dataBlk[1]; - tMapDataGetItemByIdx(ctx->mDataBlk, iDataBlk, dataBlk, tGetDataBlk); + TAOS_CHECK_GOTO(tMapDataGetItemByIdx(ctx->mDataBlk, iDataBlk, dataBlk, tGetDataBlk), &lino, _exit); SBrinRecord record = { .suid = pBlockIdx->suid, @@ -139,8 +139,9 @@ static int32_t tsdbUpgradeHead(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader * if (ctx->brinBlock->numOfRecords >= ctx->maxRow) { SVersionRange range = {.minVer = VERSION_MAX, .maxVer = VERSION_MIN}; - code = tsdbFileWriteBrinBlock(ctx->fd, ctx->brinBlock, ctx->cmprAlg, &fset->farr[TSDB_FTYPE_HEAD]->f->size, - ctx->brinBlkArray, ctx->buffers, &range, ctx->encryptAlgorithm, ctx->encryptKey); + code = + tsdbFileWriteBrinBlock(ctx->fd, ctx->brinBlock, ctx->cmprAlg, &fset->farr[TSDB_FTYPE_HEAD]->f->size, + ctx->brinBlkArray, ctx->buffers, &range, ctx->encryptAlgorithm, ctx->encryptKey); TSDB_CHECK_CODE(code, lino, _exit); } } @@ -157,8 +158,8 @@ static int32_t tsdbUpgradeHead(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader * &fset->farr[TSDB_FTYPE_HEAD]->f->size, ctx->encryptAlgorithm, ctx->encryptKey); TSDB_CHECK_CODE(code, lino, _exit); - code = tsdbFileWriteHeadFooter(ctx->fd, &fset->farr[TSDB_FTYPE_HEAD]->f->size, ctx->footer, ctx->encryptAlgorithm, - ctx->encryptKey); + code = tsdbFileWriteHeadFooter(ctx->fd, &fset->farr[TSDB_FTYPE_HEAD]->f->size, ctx->footer, ctx->encryptAlgorithm, + ctx->encryptKey); TSDB_CHECK_CODE(code, lino, _exit); code = tsdbFsyncFile(ctx->fd, ctx->encryptAlgorithm, ctx->encryptKey); @@ -258,7 +259,7 @@ static int32_t tsdbUpgradeSttFile(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReade struct { int32_t szPage; int32_t encryptAlgorithm; - char* encryptKey; + char *encryptKey; // writer STsdbFD *fd; TSttBlkArray sttBlkArray[1]; @@ -290,7 +291,7 @@ static int32_t tsdbUpgradeSttFile(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReade } code = tsdbFileWriteSttBlk(ctx->fd, ctx->sttBlkArray, ctx->footer->sttBlkPtr, &fobj->f->size, ctx->encryptAlgorithm, - ctx->encryptKey); + ctx->encryptKey); TSDB_CHECK_CODE(code, lino, _exit1); code = tsdbFileWriteSttFooter(ctx->fd, ctx->footer, &fobj->f->size, ctx->encryptAlgorithm, ctx->encryptKey); @@ -442,7 +443,7 @@ static int32_t tsdbUpgradeOpenTombFile(STsdb *tsdb, STFileSet *fset, STsdbFD **f uint8_t hdr[TSDB_FHDR_SIZE] = {0}; int32_t encryptAlgorithm = tsdb->pVnode->config.tsdbCfg.encryptAlgorithm; - char* encryptKey = tsdb->pVnode->config.tsdbCfg.encryptKey; + char *encryptKey = tsdb->pVnode->config.tsdbCfg.encryptKey; code = tsdbWriteFile(fd[0], 0, hdr, TSDB_FHDR_SIZE, encryptAlgorithm, encryptKey); TSDB_CHECK_CODE(code, lino, _exit); @@ -467,8 +468,8 @@ static int32_t tsdbDumpTombDataToFSet(STsdb *tsdb, SDelFReader *reader, SArray * int64_t minKey; int64_t maxKey; SBuffer buffers[10]; - int32_t encryptAlgorithm; - char* encryptKey; + int32_t encryptAlgorithm; + char *encryptKey; // reader SArray *aDelData; // writer @@ -538,20 +539,20 @@ static int32_t tsdbDumpTombDataToFSet(STsdb *tsdb, SDelFReader *reader, SArray * if (ctx->fd != NULL) { if (ctx->toStt) { - code = tsdbFileWriteTombBlk(ctx->fd, ctx->tombBlkArray, ctx->sttFooter->tombBlkPtr, &ctx->fobj->f->size, + code = tsdbFileWriteTombBlk(ctx->fd, ctx->tombBlkArray, ctx->sttFooter->tombBlkPtr, &ctx->fobj->f->size, ctx->encryptAlgorithm, ctx->encryptKey); TSDB_CHECK_CODE(code, lino, _exit); - code = tsdbFileWriteSttFooter(ctx->fd, ctx->sttFooter, &ctx->fobj->f->size, ctx->encryptAlgorithm, - ctx->encryptKey); + code = + tsdbFileWriteSttFooter(ctx->fd, ctx->sttFooter, &ctx->fobj->f->size, ctx->encryptAlgorithm, ctx->encryptKey); TSDB_CHECK_CODE(code, lino, _exit); } else { - code = tsdbFileWriteTombBlk(ctx->fd, ctx->tombBlkArray, ctx->tombFooter->tombBlkPtr, &ctx->fobj->f->size, + code = tsdbFileWriteTombBlk(ctx->fd, ctx->tombBlkArray, ctx->tombFooter->tombBlkPtr, &ctx->fobj->f->size, ctx->encryptAlgorithm, ctx->encryptKey); TSDB_CHECK_CODE(code, lino, _exit); - code = tsdbFileWriteTombFooter(ctx->fd, ctx->tombFooter, &ctx->fobj->f->size, ctx->encryptAlgorithm, - ctx->encryptKey); + code = tsdbFileWriteTombFooter(ctx->fd, ctx->tombFooter, &ctx->fobj->f->size, ctx->encryptAlgorithm, + ctx->encryptKey); TSDB_CHECK_CODE(code, lino, _exit); } diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c index 58075cf0ac..025fbf3eb7 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUtil.c +++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c @@ -36,183 +36,47 @@ void tMapDataClear(SMapData *pMapData) { pMapData->aOffset = NULL; } -#ifdef BUILD_NO_CALL -int32_t tMapDataPutItem(SMapData *pMapData, void *pItem, int32_t (*tPutItemFn)(uint8_t *, void *)) { - int32_t code = 0; - int32_t offset = pMapData->nData; - int32_t nItem = pMapData->nItem; - - pMapData->nItem++; - pMapData->nData += tPutItemFn(NULL, pItem); - - // alloc - code = tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem); - if (code) goto _exit; - code = tRealloc(&pMapData->pData, pMapData->nData); - if (code) goto _exit; - - // put - pMapData->aOffset[nItem] = offset; - tPutItemFn(pMapData->pData + offset, pItem); - -_exit: - return code; -} - -int32_t tMapDataCopy(SMapData *pFrom, SMapData *pTo) { - int32_t code = 0; - - pTo->nItem = pFrom->nItem; - pTo->nData = pFrom->nData; - code = tRealloc((uint8_t **)&pTo->aOffset, sizeof(int32_t) * pFrom->nItem); - if (code) goto _exit; - code = tRealloc(&pTo->pData, pFrom->nData); - if (code) goto _exit; - memcpy(pTo->aOffset, pFrom->aOffset, sizeof(int32_t) * pFrom->nItem); - memcpy(pTo->pData, pFrom->pData, pFrom->nData); - -_exit: - return code; -} - -int32_t tMapDataSearch(SMapData *pMapData, void *pSearchItem, int32_t (*tGetItemFn)(uint8_t *, void *), - int32_t (*tItemCmprFn)(const void *, const void *), void *pItem) { - int32_t code = 0; - int32_t lidx = 0; - int32_t ridx = pMapData->nItem - 1; - int32_t midx; - int32_t c; - - while (lidx <= ridx) { - midx = (lidx + ridx) / 2; - - tMapDataGetItemByIdx(pMapData, midx, pItem, tGetItemFn); - - c = tItemCmprFn(pSearchItem, pItem); - if (c == 0) { - goto _exit; - } else if (c < 0) { - ridx = midx - 1; - } else { - lidx = midx + 1; - } +int32_t tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)) { + if (idx < 0 || idx >= pMapData->nItem) { + return TSDB_CODE_OUT_OF_RANGE; } - code = TSDB_CODE_NOT_FOUND; - -_exit: - return code; -} -#endif - -void tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)) { - ASSERT(idx >= 0 && idx < pMapData->nItem); tGetItemFn(pMapData->pData + pMapData->aOffset[idx], pItem); + return 0; } -#ifdef BUILD_NO_CALL -int32_t tMapDataToArray(SMapData *pMapData, int32_t itemSize, int32_t (*tGetItemFn)(uint8_t *, void *), - SArray **ppArray) { - int32_t code = 0; - - SArray *pArray = taosArrayInit(pMapData->nItem, itemSize); - if (pArray == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; - } - - for (int32_t i = 0; i < pMapData->nItem; i++) { - tMapDataGetItemByIdx(pMapData, i, taosArrayReserve(pArray, 1), tGetItemFn); - } - -_exit: - *ppArray = pArray; - return code; -} - -int32_t tPutMapData(uint8_t *p, SMapData *pMapData) { - int32_t n = 0; - - n += tPutI32v(p ? p + n : p, pMapData->nItem); - if (pMapData->nItem) { - int32_t lOffset = 0; - for (int32_t iItem = 0; iItem < pMapData->nItem; iItem++) { - n += tPutI32v(p ? p + n : p, pMapData->aOffset[iItem] - lOffset); - lOffset = pMapData->aOffset[iItem]; - } - - n += tPutI32v(p ? p + n : p, pMapData->nData); - if (p) { - memcpy(p + n, pMapData->pData, pMapData->nData); - } - n += pMapData->nData; - } - - return n; -} -#endif - -int32_t tGetMapData(uint8_t *p, SMapData *pMapData) { - int32_t n = 0; - int32_t offset; +int32_t tGetMapData(uint8_t *p, SMapData *pMapData, int64_t *decodeSize) { + int64_t size = 0; tMapDataReset(pMapData); - n += tGetI32v(p + n, &pMapData->nItem); + size += tGetI32v(p + size, &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++) { - n += tGetI32v(p + n, &pMapData->aOffset[iItem]); + size += tGetI32v(p + size, &pMapData->aOffset[iItem]); pMapData->aOffset[iItem] += lOffset; lOffset = pMapData->aOffset[iItem]; } - n += tGetI32v(p + n, &pMapData->nData); - if (tRealloc(&pMapData->pData, pMapData->nData)) return -1; - memcpy(pMapData->pData, p + n, pMapData->nData); - n += pMapData->nData; + size += tGetI32v(p + size, &pMapData->nData); + if (tRealloc(&pMapData->pData, pMapData->nData)) { + return TSDB_CODE_OUT_OF_MEMORY; + } + memcpy(pMapData->pData, p + size, pMapData->nData); + size += pMapData->nData; } - return n; -} - -#ifdef BUILD_NO_CALL -// TABLEID ======================================================================= -int32_t tTABLEIDCmprFn(const void *p1, const void *p2) { - TABLEID *pId1 = (TABLEID *)p1; - TABLEID *pId2 = (TABLEID *)p2; - - if (pId1->suid < pId2->suid) { - return -1; - } else if (pId1->suid > pId2->suid) { - return 1; + if (decodeSize) { + *decodeSize = size; } - - if (pId1->uid < pId2->uid) { - return -1; - } else if (pId1->uid > pId2->uid) { - return 1; - } - return 0; } -// SBlockIdx ====================================================== -int32_t tPutBlockIdx(uint8_t *p, void *ph) { - int32_t n = 0; - SBlockIdx *pBlockIdx = (SBlockIdx *)ph; - - n += tPutI64(p ? p + n : p, pBlockIdx->suid); - n += tPutI64(p ? p + n : p, pBlockIdx->uid); - n += tPutI64v(p ? p + n : p, pBlockIdx->offset); - n += tPutI64v(p ? p + n : p, pBlockIdx->size); - - return n; -} -#endif - int32_t tGetBlockIdx(uint8_t *p, void *ph) { int32_t n = 0; SBlockIdx *pBlockIdx = (SBlockIdx *)ph; @@ -225,77 +89,6 @@ int32_t tGetBlockIdx(uint8_t *p, void *ph) { return n; } -#ifdef BUILD_NO_CALL -int32_t tCmprBlockIdx(void const *lhs, void const *rhs) { - SBlockIdx *lBlockIdx = (SBlockIdx *)lhs; - SBlockIdx *rBlockIdx = (SBlockIdx *)rhs; - - if (lBlockIdx->suid < rBlockIdx->suid) { - return -1; - } else if (lBlockIdx->suid > rBlockIdx->suid) { - return 1; - } - - if (lBlockIdx->uid < rBlockIdx->uid) { - return -1; - } else if (lBlockIdx->uid > rBlockIdx->uid) { - return 1; - } - - return 0; -} - -int32_t tCmprBlockL(void const *lhs, void const *rhs) { - SBlockIdx *lBlockIdx = (SBlockIdx *)lhs; - SSttBlk *rBlockL = (SSttBlk *)rhs; - - if (lBlockIdx->suid < rBlockL->suid) { - return -1; - } else if (lBlockIdx->suid > rBlockL->suid) { - return 1; - } - - if (lBlockIdx->uid < rBlockL->minUid) { - return -1; - } else if (lBlockIdx->uid > rBlockL->maxUid) { - return 1; - } - - return 0; -} - -// SDataBlk ====================================================== -void tDataBlkReset(SDataBlk *pDataBlk) { - *pDataBlk = (SDataBlk){.minKey = TSDBKEY_MAX, .maxKey = TSDBKEY_MIN, .minVer = VERSION_MAX, .maxVer = VERSION_MIN}; -} - -int32_t tPutDataBlk(uint8_t *p, void *ph) { - int32_t n = 0; - SDataBlk *pDataBlk = (SDataBlk *)ph; - - n += tPutI64v(p ? p + n : p, pDataBlk->minKey.version); - n += tPutI64v(p ? p + n : p, pDataBlk->minKey.ts); - n += tPutI64v(p ? p + n : p, pDataBlk->maxKey.version); - n += tPutI64v(p ? p + n : p, pDataBlk->maxKey.ts); - n += tPutI64v(p ? p + n : p, pDataBlk->minVer); - n += tPutI64v(p ? p + n : p, pDataBlk->maxVer); - n += tPutI32v(p ? p + n : p, pDataBlk->nRow); - n += tPutI8(p ? p + n : p, pDataBlk->hasDup); - n += tPutI8(p ? p + n : p, pDataBlk->nSubBlock); - for (int8_t iSubBlock = 0; iSubBlock < pDataBlk->nSubBlock; iSubBlock++) { - n += tPutI64v(p ? p + n : p, pDataBlk->aSubBlock[iSubBlock].offset); - n += tPutI32v(p ? p + n : p, pDataBlk->aSubBlock[iSubBlock].szBlock); - n += tPutI32v(p ? p + n : p, pDataBlk->aSubBlock[iSubBlock].szKey); - } - if (pDataBlk->nSubBlock == 1 && !pDataBlk->hasDup) { - n += tPutI64v(p ? p + n : p, pDataBlk->smaInfo.offset); - n += tPutI32v(p ? p + n : p, pDataBlk->smaInfo.size); - } - - return n; -} -#endif - int32_t tGetDataBlk(uint8_t *p, void *ph) { int32_t n = 0; SDataBlk *pDataBlk = (SDataBlk *)ph; @@ -325,48 +118,6 @@ int32_t tGetDataBlk(uint8_t *p, void *ph) { return n; } -#ifdef BUILD_NO_CALL -int32_t tDataBlkCmprFn(const void *p1, const void *p2) { - SDataBlk *pBlock1 = (SDataBlk *)p1; - SDataBlk *pBlock2 = (SDataBlk *)p2; - - if (tsdbKeyCmprFn(&pBlock1->maxKey, &pBlock2->minKey) < 0) { - return -1; - } else if (tsdbKeyCmprFn(&pBlock1->minKey, &pBlock2->maxKey) > 0) { - return 1; - } - - return 0; -} - -bool tDataBlkHasSma(SDataBlk *pDataBlk) { - if (pDataBlk->nSubBlock > 1) return false; - if (pDataBlk->hasDup) return false; - - return pDataBlk->smaInfo.size > 0; -} - -// SSttBlk ====================================================== -int32_t tPutSttBlk(uint8_t *p, void *ph) { - int32_t n = 0; - SSttBlk *pSttBlk = (SSttBlk *)ph; - - n += tPutI64(p ? p + n : p, pSttBlk->suid); - n += tPutI64(p ? p + n : p, pSttBlk->minUid); - n += tPutI64(p ? p + n : p, pSttBlk->maxUid); - n += tPutI64v(p ? p + n : p, pSttBlk->minKey); - n += tPutI64v(p ? p + n : p, pSttBlk->maxKey); - n += tPutI64v(p ? p + n : p, pSttBlk->minVer); - n += tPutI64v(p ? p + n : p, pSttBlk->maxVer); - n += tPutI32v(p ? p + n : p, pSttBlk->nRow); - n += tPutI64v(p ? p + n : p, pSttBlk->bInfo.offset); - n += tPutI32v(p ? p + n : p, pSttBlk->bInfo.szBlock); - n += tPutI32v(p ? p + n : p, pSttBlk->bInfo.szKey); - - return n; -} -#endif - int32_t tGetSttBlk(uint8_t *p, void *ph) { int32_t n = 0; SSttBlk *pSttBlk = (SSttBlk *)ph; @@ -391,47 +142,42 @@ int32_t tGetSttBlk(uint8_t *p, void *ph) { static const int32_t BLOCK_WITH_ALG_VER = 2; int32_t tPutBlockCol(SBuffer *buffer, const SBlockCol *pBlockCol, int32_t ver, uint32_t defaultCmprAlg) { - int32_t code; - ASSERT(pBlockCol->flag && (pBlockCol->flag != HAS_NONE)); - if ((code = tBufferPutI16v(buffer, pBlockCol->cid))) return code; - if ((code = tBufferPutI8(buffer, pBlockCol->type))) return code; - if ((code = tBufferPutI8(buffer, pBlockCol->cflag))) return code; - if ((code = tBufferPutI8(buffer, pBlockCol->flag))) return code; - if ((code = tBufferPutI32v(buffer, pBlockCol->szOrigin))) return code; + TAOS_CHECK_RETURN(tBufferPutI16v(buffer, pBlockCol->cid)); + TAOS_CHECK_RETURN(tBufferPutI8(buffer, pBlockCol->type)); + TAOS_CHECK_RETURN(tBufferPutI8(buffer, pBlockCol->cflag)); + TAOS_CHECK_RETURN(tBufferPutI8(buffer, pBlockCol->flag)); + TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pBlockCol->szOrigin)); if (pBlockCol->flag != HAS_NULL) { if (pBlockCol->flag != HAS_VALUE) { - if ((code = tBufferPutI32v(buffer, pBlockCol->szBitmap))) return code; + TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pBlockCol->szBitmap)); } if (IS_VAR_DATA_TYPE(pBlockCol->type)) { - if ((code = tBufferPutI32v(buffer, pBlockCol->szOffset))) return code; + TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pBlockCol->szOffset)); } if (pBlockCol->flag != (HAS_NULL | HAS_NONE)) { - if ((code = tBufferPutI32v(buffer, pBlockCol->szValue))) return code; + TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pBlockCol->szValue)); } - - if ((code = tBufferPutI32v(buffer, pBlockCol->offset))) return code; + TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pBlockCol->offset)); } if (ver >= BLOCK_WITH_ALG_VER) { - if ((code = tBufferPutU32(buffer, pBlockCol->alg))) return code; + TAOS_CHECK_RETURN(tBufferPutU32(buffer, pBlockCol->alg)); } else { - if ((code = tBufferPutU32(buffer, defaultCmprAlg))) return code; + TAOS_CHECK_RETURN(tBufferPutU32(buffer, defaultCmprAlg)); } return 0; } int32_t tGetBlockCol(SBufferReader *br, SBlockCol *pBlockCol, int32_t ver, uint32_t defaultCmprAlg) { - int32_t code; - - if ((code = tBufferGetI16v(br, &pBlockCol->cid))) return code; - if ((code = tBufferGetI8(br, &pBlockCol->type))) return code; - if ((code = tBufferGetI8(br, &pBlockCol->cflag))) return code; - if ((code = tBufferGetI8(br, &pBlockCol->flag))) return code; - if ((code = tBufferGetI32v(br, &pBlockCol->szOrigin))) return code; + TAOS_CHECK_RETURN(tBufferGetI16v(br, &pBlockCol->cid)); + TAOS_CHECK_RETURN(tBufferGetI8(br, &pBlockCol->type)); + TAOS_CHECK_RETURN(tBufferGetI8(br, &pBlockCol->cflag)); + TAOS_CHECK_RETURN(tBufferGetI8(br, &pBlockCol->flag)); + TAOS_CHECK_RETURN(tBufferGetI32v(br, &pBlockCol->szOrigin)); ASSERT(pBlockCol->flag && (pBlockCol->flag != HAS_NONE)); @@ -442,22 +188,22 @@ int32_t tGetBlockCol(SBufferReader *br, SBlockCol *pBlockCol, int32_t ver, uint3 if (pBlockCol->flag != HAS_NULL) { if (pBlockCol->flag != HAS_VALUE) { - if ((code = tBufferGetI32v(br, &pBlockCol->szBitmap))) return code; + TAOS_CHECK_RETURN(tBufferGetI32v(br, &pBlockCol->szBitmap)); } if (IS_VAR_DATA_TYPE(pBlockCol->type)) { - if ((code = tBufferGetI32v(br, &pBlockCol->szOffset))) return code; + TAOS_CHECK_RETURN(tBufferGetI32v(br, &pBlockCol->szOffset)); } if (pBlockCol->flag != (HAS_NULL | HAS_NONE)) { - if ((code = tBufferGetI32v(br, &pBlockCol->szValue))) return code; + TAOS_CHECK_RETURN(tBufferGetI32v(br, &pBlockCol->szValue)); } - if ((code = tBufferGetI32v(br, &pBlockCol->offset))) return code; + TAOS_CHECK_RETURN(tBufferGetI32v(br, &pBlockCol->offset)); } if (ver >= BLOCK_WITH_ALG_VER) { - if ((code = tBufferGetU32(br, &pBlockCol->alg))) return code; + TAOS_CHECK_RETURN(tBufferGetU32(br, &pBlockCol->alg)); } else { pBlockCol->alg = defaultCmprAlg; } @@ -465,50 +211,6 @@ int32_t tGetBlockCol(SBufferReader *br, SBlockCol *pBlockCol, int32_t ver, uint3 return 0; } -#ifdef BUILD_NO_CALL -int32_t tBlockColCmprFn(const void *p1, const void *p2) { - if (((SBlockCol *)p1)->cid < ((SBlockCol *)p2)->cid) { - return -1; - } else if (((SBlockCol *)p1)->cid > ((SBlockCol *)p2)->cid) { - return 1; - } - - return 0; -} - -// SDelIdx ====================================================== -int32_t tCmprDelIdx(void const *lhs, void const *rhs) { - SDelIdx *lDelIdx = (SDelIdx *)lhs; - SDelIdx *rDelIdx = (SDelIdx *)rhs; - - if (lDelIdx->suid < rDelIdx->suid) { - return -1; - } else if (lDelIdx->suid > rDelIdx->suid) { - return 1; - } - - if (lDelIdx->uid < rDelIdx->uid) { - return -1; - } else if (lDelIdx->uid > rDelIdx->uid) { - return 1; - } - - return 0; -} - -int32_t tPutDelIdx(uint8_t *p, void *ph) { - SDelIdx *pDelIdx = (SDelIdx *)ph; - int32_t n = 0; - - n += tPutI64(p ? p + n : p, pDelIdx->suid); - n += tPutI64(p ? p + n : p, pDelIdx->uid); - n += tPutI64v(p ? p + n : p, pDelIdx->offset); - n += tPutI64v(p ? p + n : p, pDelIdx->size); - - return n; -} -#endif - int32_t tGetDelIdx(uint8_t *p, void *ph) { SDelIdx *pDelIdx = (SDelIdx *)ph; int32_t n = 0; @@ -521,20 +223,6 @@ int32_t tGetDelIdx(uint8_t *p, void *ph) { return n; } -#ifdef BUILD_NO_CALL -// SDelData ====================================================== -int32_t tPutDelData(uint8_t *p, void *ph) { - SDelData *pDelData = (SDelData *)ph; - int32_t n = 0; - - n += tPutI64v(p ? p + n : p, pDelData->version); - n += tPutI64(p ? p + n : p, pDelData->sKey); - n += tPutI64(p ? p + n : p, pDelData->eKey); - - return n; -} -#endif - int32_t tGetDelData(uint8_t *p, void *ph) { SDelData *pDelData = (SDelData *)ph; int32_t n = 0; @@ -680,20 +368,16 @@ 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; + TAOS_CHECK_RETURN(tRowIterOpen(pRow->pTSRow, pTSchema, &pIter->pIter)); } else if (pRow->type == TSDBROW_COL_FMT) { pIter->iColData = 0; } else { ASSERT(0); } -_exit: - return code; + return 0; } void tsdbRowClose(STSDBRowIter *pIter) { @@ -748,8 +432,7 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) *pColVal = COL_VAL_VALUE(pTColumn->colId, ((SValue){.type = pTColumn->type, .val = key.ts})); if (taosArrayPush(pMerger->pArray, pColVal) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - return code; + return TSDB_CODE_OUT_OF_MEMORY; } // other @@ -760,7 +443,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; } @@ -769,10 +454,7 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) uint8_t *pVal = pColVal->value.pData; pColVal->value.pData = NULL; - code = tRealloc(&pColVal->value.pData, pColVal->value.nData); - if (code) { - return TSDB_CODE_OUT_OF_MEMORY; - } + TAOS_CHECK_RETURN(tRealloc(&pColVal->value.pData, pColVal->value.nData)); if (pColVal->value.nData) { memcpy(pColVal->value.pData, pVal, pColVal->value.nData); @@ -780,14 +462,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; @@ -812,8 +495,7 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) if (IS_VAR_DATA_TYPE(pColVal->value.type)) { SColVal *pTColVal = taosArrayGet(pMerger->pArray, iCol); if (!COL_VAL_IS_NULL(pColVal)) { - code = tRealloc(&pTColVal->value.pData, pColVal->value.nData); - if (code) return code; + TAOS_CHECK_RETURN(tRealloc(&pTColVal->value.pData, pColVal->value.nData)); pTColVal->value.nData = pColVal->value.nData; if (pTColVal->value.nData) { @@ -832,8 +514,7 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) SColVal *tColVal = (SColVal *)taosArrayGet(pMerger->pArray, iCol); if (COL_VAL_IS_NONE(tColVal) && !COL_VAL_IS_NONE(pColVal)) { if ((!COL_VAL_IS_NULL(pColVal)) && IS_VAR_DATA_TYPE(pColVal->value.type)) { - code = tRealloc(&tColVal->value.pData, pColVal->value.nData); - if (code) return code; + TAOS_CHECK_RETURN(tRealloc(&tColVal->value.pData, pColVal->value.nData)); tColVal->value.nData = pColVal->value.nData; if (pColVal->value.nData) { @@ -891,79 +572,8 @@ int32_t tsdbRowMergerGetRow(SRowMerger *pMerger, SRow **ppRow) { return tRowBuild(pMerger->pArray, pMerger->pTSchema, ppRow); } -/* -// delete skyline ====================================================== -static int32_t tsdbMergeSkyline2(SArray *aSkyline1, SArray *aSkyline2, SArray *aSkyline) { - int32_t code = 0; - int32_t i1 = 0; - int32_t n1 = taosArrayGetSize(aSkyline1); - int32_t i2 = 0; - int32_t n2 = taosArrayGetSize(aSkyline2); - TSDBKEY *pSkyline1; - TSDBKEY *pSkyline2; - TSDBKEY item; - int64_t version1 = 0; - int64_t version2 = 0; - - ASSERT(n1 > 0 && n2 > 0); - - taosArrayClear(aSkyline); - - while (i1 < n1 && i2 < n2) { - pSkyline1 = (TSDBKEY *)taosArrayGet(aSkyline1, i1); - pSkyline2 = (TSDBKEY *)taosArrayGet(aSkyline2, i2); - - if (pSkyline1->ts < pSkyline2->ts) { - version1 = pSkyline1->version; - i1++; - } else if (pSkyline1->ts > pSkyline2->ts) { - version2 = pSkyline2->version; - i2++; - } else { - version1 = pSkyline1->version; - version2 = pSkyline2->version; - i1++; - i2++; - } - - item.ts = TMIN(pSkyline1->ts, pSkyline2->ts); - item.version = TMAX(version1, version2); - if (taosArrayPush(aSkyline, &item) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; - } - } - - while (i1 < n1) { - pSkyline1 = (TSDBKEY *)taosArrayGet(aSkyline1, i1); - item.ts = pSkyline1->ts; - item.version = pSkyline1->version; - if (taosArrayPush(aSkyline, &item) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; - } - i1++; - } - - while (i2 < n2) { - pSkyline2 = (TSDBKEY *)taosArrayGet(aSkyline2, i2); - item.ts = pSkyline2->ts; - item.version = pSkyline2->version; - if (taosArrayPush(aSkyline, &item) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; - } - i2++; - } - -_exit: - return code; -} -*/ - // delete skyline ====================================================== static int32_t tsdbMergeSkyline(SArray *pSkyline1, SArray *pSkyline2, SArray *pSkyline) { - int32_t code = 0; int32_t i1 = 0; int32_t n1 = taosArrayGetSize(pSkyline1); int32_t i2 = 0; @@ -1017,7 +627,7 @@ static int32_t tsdbMergeSkyline(SArray *pSkyline1, SArray *pSkyline2, SArray *pS } pSkyline->size = TARRAY_ELEM_IDX(pSkyline, pItem); - return code; + return 0; } int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx, SArray *pSkyline) { @@ -1029,8 +639,12 @@ 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; @@ -1043,11 +657,8 @@ int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx, goto _clear; } - code = tsdbBuildDeleteSkylineImpl(aSkyline, sidx, midx, pSkyline1); - if (code) goto _clear; - - code = tsdbBuildDeleteSkylineImpl(aSkyline, midx + 1, eidx, pSkyline2); - if (code) goto _clear; + TAOS_CHECK_GOTO(tsdbBuildDeleteSkylineImpl(aSkyline, sidx, midx, pSkyline1), NULL, _clear); + TAOS_CHECK_GOTO(tsdbBuildDeleteSkylineImpl(aSkyline, midx + 1, eidx, pSkyline2), NULL, _clear); code = tsdbMergeSkyline(pSkyline1, pSkyline2, pSkyline); @@ -1063,72 +674,48 @@ int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SAr SDelData *pDelData; int32_t code = 0; int32_t dataNum = eidx - sidx + 1; - SArray *aTmpSkyline = taosArrayInit(dataNum * 2, sizeof(TSDBKEY)); - SArray *pSkyline = taosArrayInit(dataNum * 2, POINTER_BYTES); + SArray *aTmpSkyline; + SArray *pSkyline; + + aTmpSkyline = taosArrayInit(dataNum * 2, sizeof(TSDBKEY)); + if (aTmpSkyline == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pSkyline = taosArrayInit(dataNum * 2, POINTER_BYTES); + if (pSkyline) { + 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) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _clear); + } + + if (taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0}) == NULL) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _clear); + } } - code = tsdbBuildDeleteSkylineImpl(aTmpSkyline, sidx, eidx, pSkyline); - if (code) goto _clear; + TAOS_CHECK_GOTO(tsdbBuildDeleteSkylineImpl(aTmpSkyline, sidx, eidx, pSkyline), NULL, _clear); 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) { + TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _clear); + } } _clear: taosArrayDestroy(aTmpSkyline); taosArrayDestroy(pSkyline); - return code; } -/* -int32_t tsdbBuildDeleteSkyline2(SArray *aDelData, int32_t sidx, int32_t eidx, SArray *aSkyline) { - int32_t code = 0; - SDelData *pDelData; - int32_t midx; - - taosArrayClear(aSkyline); - if (sidx == eidx) { - pDelData = (SDelData *)taosArrayGet(aDelData, sidx); - taosArrayPush(aSkyline, &(TSDBKEY){.ts = pDelData->sKey, .version = pDelData->version}); - taosArrayPush(aSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0}); - } else { - SArray *aSkyline1 = NULL; - SArray *aSkyline2 = NULL; - - aSkyline1 = taosArrayInit(0, sizeof(TSDBKEY)); - aSkyline2 = taosArrayInit(0, sizeof(TSDBKEY)); - if (aSkyline1 == NULL || aSkyline2 == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _clear; - } - midx = (sidx + eidx) / 2; - - code = tsdbBuildDeleteSkyline(aDelData, sidx, midx, aSkyline1); - if (code) goto _clear; - - code = tsdbBuildDeleteSkyline(aDelData, midx + 1, eidx, aSkyline2); - if (code) goto _clear; - - code = tsdbMergeSkyline(aSkyline1, aSkyline2, aSkyline); - - _clear: - taosArrayDestroy(aSkyline1); - taosArrayDestroy(aSkyline2); - } - - return code; -} -*/ - // SBlockData ====================================================== int32_t tBlockDataCreate(SBlockData *pBlockData) { pBlockData->suid = 0; @@ -1158,8 +745,6 @@ void tBlockDataDestroy(SBlockData *pBlockData) { } static int32_t tBlockDataAdjustColData(SBlockData *pBlockData, int32_t nColData) { - int32_t code = 0; - if (pBlockData->nColData > nColData) { for (int32_t i = nColData; i < pBlockData->nColData; i++) { tColDataDestroy(&pBlockData->aColData[i]); @@ -1167,8 +752,7 @@ static int32_t tBlockDataAdjustColData(SBlockData *pBlockData, int32_t nColData) } else if (pBlockData->nColData < nColData) { SColData *aColData = taosMemoryRealloc(pBlockData->aColData, sizeof(SBlockData) * nColData); if (aColData == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; + return TSDB_CODE_OUT_OF_MEMORY; } pBlockData->aColData = aColData; @@ -1176,12 +760,10 @@ static int32_t tBlockDataAdjustColData(SBlockData *pBlockData, int32_t nColData) } pBlockData->nColData = nColData; -_exit: - return code; + return 0; } -int32_t tBlockDataInit(SBlockData *pBlockData, TABLEID *pId, STSchema *pTSchema, int16_t *aCid, int32_t nCid) { - int32_t code = 0; +int32_t tBlockDataInit(SBlockData *pBlockData, TABLEID *pId, STSchema *pTSchema, int16_t *aCid, int32_t nCid) { ASSERT(pId->suid || pId->uid); pBlockData->suid = pId->suid; @@ -1189,8 +771,7 @@ int32_t tBlockDataInit(SBlockData *pBlockData, TABLEID *pId, STSchema *pTSchema, pBlockData->nRow = 0; if (aCid) { - code = tBlockDataAdjustColData(pBlockData, nCid); - if (code) goto _exit; + TAOS_CHECK_RETURN(tBlockDataAdjustColData(pBlockData, nCid)); int32_t iColumn = 1; STColumn *pTColumn = &pTSchema->columns[iColumn]; @@ -1217,17 +798,14 @@ int32_t tBlockDataInit(SBlockData *pBlockData, TABLEID *pId, STSchema *pTSchema, pTColumn = (iColumn < pTSchema->numOfCols) ? &pTSchema->columns[iColumn] : NULL; } } else { - code = tBlockDataAdjustColData(pBlockData, pTSchema->numOfCols - 1); - if (code) goto _exit; + TAOS_CHECK_RETURN(tBlockDataAdjustColData(pBlockData, pTSchema->numOfCols - 1)); for (int32_t iColData = 0; iColData < pBlockData->nColData; iColData++) { STColumn *pTColumn = &pTSchema->columns[iColData + 1]; tColDataInit(&pBlockData->aColData[iColData], pTColumn->colId, pTColumn->type, pTColumn->flags); } } - -_exit: - return code; + return 0; } void tBlockDataReset(SBlockData *pBlockData) { @@ -1309,43 +887,35 @@ _exit: } int32_t tBlockDataAppendRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema, int64_t uid) { - int32_t code = 0; - ASSERT(pBlockData->suid || pBlockData->uid); // uid if (pBlockData->uid == 0) { ASSERT(uid); - code = tRealloc((uint8_t **)&pBlockData->aUid, sizeof(int64_t) * (pBlockData->nRow + 1)); - if (code) goto _exit; + TAOS_CHECK_RETURN(tRealloc((uint8_t **)&pBlockData->aUid, sizeof(int64_t) * (pBlockData->nRow + 1))); pBlockData->aUid[pBlockData->nRow] = uid; } // version - code = tRealloc((uint8_t **)&pBlockData->aVersion, sizeof(int64_t) * (pBlockData->nRow + 1)); - if (code) goto _exit; + TAOS_CHECK_RETURN(tRealloc((uint8_t **)&pBlockData->aVersion, sizeof(int64_t) * (pBlockData->nRow + 1))); pBlockData->aVersion[pBlockData->nRow] = TSDBROW_VERSION(pRow); // timestamp - code = tRealloc((uint8_t **)&pBlockData->aTSKEY, sizeof(TSKEY) * (pBlockData->nRow + 1)); - if (code) goto _exit; + TAOS_CHECK_RETURN(tRealloc((uint8_t **)&pBlockData->aTSKEY, sizeof(TSKEY) * (pBlockData->nRow + 1))); pBlockData->aTSKEY[pBlockData->nRow] = TSDBROW_TS(pRow); if (pRow->type == TSDBROW_ROW_FMT) { - code = tRowUpsertColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData, 0 /* append */); - if (code) goto _exit; + TAOS_CHECK_RETURN( + tRowUpsertColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData, 0 /* append */)); } else if (pRow->type == TSDBROW_COL_FMT) { - code = tBlockDataUpsertBlockRow(pBlockData, pRow->pBlockData, pRow->iRow, 0 /* append */); - if (code) goto _exit; + TAOS_CHECK_RETURN(tBlockDataUpsertBlockRow(pBlockData, pRow->pBlockData, pRow->iRow, 0 /* append */)); } else { ASSERT(0); } pBlockData->nRow++; -_exit: - return code; + return 0; } -int32_t tBlockDataUpdateRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema) { - int32_t code = 0; +int32_t tBlockDataUpdateRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema) { // version int64_t lversion = pBlockData->aVersion[pBlockData->nRow - 1]; int64_t rversion = TSDBROW_VERSION(pRow); @@ -1356,40 +926,18 @@ int32_t tBlockDataUpdateRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTS // update other rows if (pRow->type == TSDBROW_ROW_FMT) { - code = tRowUpsertColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData, - (rversion > lversion) ? 1 : -1 /* update */); - if (code) goto _exit; + TAOS_CHECK_RETURN(tRowUpsertColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData, + (rversion > lversion) ? 1 : -1 /* update */)); } else if (pRow->type == TSDBROW_COL_FMT) { - code = tBlockDataUpsertBlockRow(pBlockData, pRow->pBlockData, pRow->iRow, (rversion > lversion) ? 1 : -1); - if (code) goto _exit; + TAOS_CHECK_RETURN( + tBlockDataUpsertBlockRow(pBlockData, pRow->pBlockData, pRow->iRow, (rversion > lversion) ? 1 : -1)); } else { ASSERT(0); } -_exit: - return code; + return 0; } -#ifdef BUILD_NO_CALL -int32_t tBlockDataTryUpsertRow(SBlockData *pBlockData, TSDBROW *pRow, int64_t uid) { - if (pBlockData->nRow == 0) { - return 1; - } else if (pBlockData->aTSKEY[pBlockData->nRow - 1] == TSDBROW_TS(pRow)) { - return pBlockData->nRow; - } else { - return pBlockData->nRow + 1; - } -} - -int32_t tBlockDataUpsertRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema, int64_t uid) { - if (pBlockData->nRow > 0 && pBlockData->aTSKEY[pBlockData->nRow - 1] == TSDBROW_TS(pRow)) { - return tBlockDataUpdateRow(pBlockData, pRow, pTSchema); - } else { - return tBlockDataAppendRow(pBlockData, pRow, pTSchema, uid); - } -} -#endif - SColData *tBlockDataGetColData(SBlockData *pBlockData, int16_t cid) { ASSERT(cid != PRIMARYKEY_TIMESTAMP_COL_ID); int32_t lidx = 0; @@ -1422,7 +970,8 @@ int32_t tBlockDataCompress(SBlockData *bData, void *pCompr, SBuffer *buffers, SB int32_t lino = 0; SColCompressInfo *pInfo = pCompr; - code = tsdbGetColCmprAlgFromSet(pInfo->pColCmpr, 1, &pInfo->defaultCmprAlg); + + TAOS_CHECK_GOTO(tsdbGetColCmprAlgFromSet(pInfo->pColCmpr, 1, &pInfo->defaultCmprAlg), &lino, _exit); SDiskDataHdr hdr = { .delimiter = TSDB_FILE_DLMT, @@ -1440,8 +989,7 @@ int32_t tBlockDataCompress(SBlockData *bData, void *pCompr, SBuffer *buffers, SB // Key part tBufferClear(&buffers[1]); - code = tBlockDataCompressKeyPart(bData, &hdr, &buffers[1], assist, (SColCompressInfo *)pInfo); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tBlockDataCompressKeyPart(bData, &hdr, &buffers[1], assist, (SColCompressInfo *)pInfo), &lino, _exit); // Regulart column part tBufferClear(&buffers[2]); @@ -1459,14 +1007,10 @@ int32_t tBlockDataCompress(SBlockData *bData, void *pCompr, SBuffer *buffers, SB SColDataCompressInfo cinfo = { .cmprAlg = pInfo->defaultCmprAlg, }; - code = tsdbGetColCmprAlgFromSet(pInfo->pColCmpr, colData->cid, &cinfo.cmprAlg); - if (code < 0) { - // - } + TAOS_UNUSED(tsdbGetColCmprAlgFromSet(pInfo->pColCmpr, colData->cid, &cinfo.cmprAlg)); int32_t offset = buffers[3].size; - code = tColDataCompress(colData, &cinfo, &buffers[3], assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tColDataCompress(colData, &cinfo, &buffers[3], assist), &lino, _exit); SBlockCol blockCol = (SBlockCol){.cid = cinfo.columnId, .type = cinfo.dataType, @@ -1479,15 +1023,13 @@ int32_t tBlockDataCompress(SBlockData *bData, void *pCompr, SBuffer *buffers, SB .offset = offset, .alg = cinfo.cmprAlg}; - code = tPutBlockCol(&buffers[2], &blockCol, hdr.fmtVer, hdr.cmprAlg); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tPutBlockCol(&buffers[2], &blockCol, hdr.fmtVer, hdr.cmprAlg), &lino, _exit); } hdr.szBlkCol = buffers[2].size; // SDiskDataHdr part tBufferClear(&buffers[0]); - code = tPutDiskDataHdr(&buffers[0], &hdr); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tPutDiskDataHdr(&buffers[0], &hdr), &lino, _exit); _exit: return code; @@ -1500,8 +1042,7 @@ int32_t tBlockDataDecompress(SBufferReader *br, SBlockData *blockData, SBuffer * SCompressInfo cinfo; // SDiskDataHdr - code = tGetDiskDataHdr(br, &hdr); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tGetDiskDataHdr(br, &hdr), &lino, _exit); tBlockDataReset(blockData); blockData->suid = hdr.suid; @@ -1509,8 +1050,7 @@ int32_t tBlockDataDecompress(SBufferReader *br, SBlockData *blockData, SBuffer * blockData->nRow = hdr.nRow; // Key part - code = tBlockDataDecompressKeyPart(&hdr, br, blockData, assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tBlockDataDecompressKeyPart(&hdr, br, blockData, assist), &lino, _exit); // Column part SBufferReader br2 = *br; @@ -1518,11 +1058,11 @@ int32_t tBlockDataDecompress(SBufferReader *br, SBlockData *blockData, SBuffer * for (uint32_t startOffset = br2.offset; br2.offset - startOffset < hdr.szBlkCol;) { SBlockCol blockCol; - code = tGetBlockCol(&br2, &blockCol, hdr.fmtVer, hdr.cmprAlg); + TAOS_CHECK_GOTO(tGetBlockCol(&br2, &blockCol, hdr.fmtVer, hdr.cmprAlg), &lino, _exit); + if (blockCol.alg == 0) blockCol.alg = hdr.cmprAlg; - TSDB_CHECK_CODE(code, lino, _exit); - code = tBlockDataDecompressColData(&hdr, &blockCol, br, blockData, assist); - TSDB_CHECK_CODE(code, lino, _exit); + + TAOS_CHECK_GOTO(tBlockDataDecompressColData(&hdr, &blockCol, br, blockData, assist), &lino, _exit); } _exit: @@ -1531,28 +1071,26 @@ _exit: // SDiskDataHdr ============================== int32_t tPutDiskDataHdr(SBuffer *buffer, const SDiskDataHdr *pHdr) { - int32_t code; - - if ((code = tBufferPutU32(buffer, pHdr->delimiter))) return code; - if ((code = tBufferPutU32v(buffer, pHdr->fmtVer))) return code; - if ((code = tBufferPutI64(buffer, pHdr->suid))) return code; - if ((code = tBufferPutI64(buffer, pHdr->uid))) return code; - if ((code = tBufferPutI32v(buffer, pHdr->szUid))) return code; - if ((code = tBufferPutI32v(buffer, pHdr->szVer))) return code; - if ((code = tBufferPutI32v(buffer, pHdr->szKey))) return code; - if ((code = tBufferPutI32v(buffer, pHdr->szBlkCol))) return code; - if ((code = tBufferPutI32v(buffer, pHdr->nRow))) return code; + TAOS_CHECK_RETURN(tBufferPutU32(buffer, pHdr->delimiter)); + TAOS_CHECK_RETURN(tBufferPutU32v(buffer, pHdr->fmtVer)); + TAOS_CHECK_RETURN(tBufferPutI64(buffer, pHdr->suid)); + TAOS_CHECK_RETURN(tBufferPutI64(buffer, pHdr->uid)); + TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pHdr->szUid)); + TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pHdr->szVer)); + TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pHdr->szKey)); + TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pHdr->szBlkCol)); + TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pHdr->nRow)); if (pHdr->fmtVer < 2) { - if ((code = tBufferPutI8(buffer, pHdr->cmprAlg))) return code; + TAOS_CHECK_RETURN(tBufferPutI8(buffer, pHdr->cmprAlg)); } else if (pHdr->fmtVer == 2) { - if ((code = tBufferPutU32(buffer, pHdr->cmprAlg))) return code; + TAOS_CHECK_RETURN(tBufferPutU32(buffer, pHdr->cmprAlg)); } else { // more data fmt ver } if (pHdr->fmtVer >= 1) { - if ((code = tBufferPutI8(buffer, pHdr->numOfPKs))) return code; + TAOS_CHECK_RETURN(tBufferPutI8(buffer, pHdr->numOfPKs)); for (int i = 0; i < pHdr->numOfPKs; i++) { - if ((code = tPutBlockCol(buffer, &pHdr->primaryBlockCols[i], pHdr->fmtVer, pHdr->cmprAlg))) return code; + TAOS_CHECK_RETURN(tPutBlockCol(buffer, &pHdr->primaryBlockCols[i], pHdr->fmtVer, pHdr->cmprAlg)); } } @@ -1560,32 +1098,28 @@ int32_t tPutDiskDataHdr(SBuffer *buffer, const SDiskDataHdr *pHdr) { } int32_t tGetDiskDataHdr(SBufferReader *br, SDiskDataHdr *pHdr) { - int32_t code; - - if ((code = tBufferGetU32(br, &pHdr->delimiter))) return code; - if ((code = tBufferGetU32v(br, &pHdr->fmtVer))) return code; - if ((code = tBufferGetI64(br, &pHdr->suid))) return code; - if ((code = tBufferGetI64(br, &pHdr->uid))) return code; - if ((code = tBufferGetI32v(br, &pHdr->szUid))) return code; - if ((code = tBufferGetI32v(br, &pHdr->szVer))) return code; - if ((code = tBufferGetI32v(br, &pHdr->szKey))) return code; - if ((code = tBufferGetI32v(br, &pHdr->szBlkCol))) return code; - if ((code = tBufferGetI32v(br, &pHdr->nRow))) return code; + TAOS_CHECK_RETURN(tBufferGetU32(br, &pHdr->delimiter)); + TAOS_CHECK_RETURN(tBufferGetU32v(br, &pHdr->fmtVer)); + TAOS_CHECK_RETURN(tBufferGetI64(br, &pHdr->suid)); + TAOS_CHECK_RETURN(tBufferGetI64(br, &pHdr->uid)); + TAOS_CHECK_RETURN(tBufferGetI32v(br, &pHdr->szUid)); + TAOS_CHECK_RETURN(tBufferGetI32v(br, &pHdr->szVer)); + TAOS_CHECK_RETURN(tBufferGetI32v(br, &pHdr->szKey)); + TAOS_CHECK_RETURN(tBufferGetI32v(br, &pHdr->szBlkCol)); + TAOS_CHECK_RETURN(tBufferGetI32v(br, &pHdr->nRow)); if (pHdr->fmtVer < 2) { int8_t cmprAlg = 0; - if ((code = tBufferGetI8(br, &cmprAlg))) return code; + TAOS_CHECK_RETURN(tBufferGetI8(br, &cmprAlg)); pHdr->cmprAlg = cmprAlg; } else if (pHdr->fmtVer == 2) { - if ((code = tBufferGetU32(br, &pHdr->cmprAlg))) return code; + TAOS_CHECK_RETURN(tBufferGetU32(br, &pHdr->cmprAlg)); } else { // more data fmt ver } if (pHdr->fmtVer >= 1) { - if ((code = tBufferGetI8(br, &pHdr->numOfPKs))) return code; + TAOS_CHECK_RETURN(tBufferGetI8(br, &pHdr->numOfPKs)); for (int i = 0; i < pHdr->numOfPKs; i++) { - if ((code = tGetBlockCol(br, &pHdr->primaryBlockCols[i], pHdr->fmtVer, pHdr->cmprAlg))) { - return code; - } + TAOS_CHECK_RETURN(tGetBlockCol(br, &pHdr->primaryBlockCols[i], pHdr->fmtVer, pHdr->cmprAlg)); } } else { pHdr->numOfPKs = 0; @@ -1596,26 +1130,20 @@ int32_t tGetDiskDataHdr(SBufferReader *br, SDiskDataHdr *pHdr) { // ALGORITHM ============================== int32_t tPutColumnDataAgg(SBuffer *buffer, SColumnDataAgg *pColAgg) { - int32_t code; - - if ((code = tBufferPutI16v(buffer, pColAgg->colId))) return code; - if ((code = tBufferPutI16v(buffer, pColAgg->numOfNull))) return code; - if ((code = tBufferPutI64(buffer, pColAgg->sum))) return code; - if ((code = tBufferPutI64(buffer, pColAgg->max))) return code; - if ((code = tBufferPutI64(buffer, pColAgg->min))) return code; - + TAOS_CHECK_RETURN(tBufferPutI16v(buffer, pColAgg->colId)); + TAOS_CHECK_RETURN(tBufferPutI16v(buffer, pColAgg->numOfNull)); + TAOS_CHECK_RETURN(tBufferPutI64(buffer, pColAgg->sum)); + TAOS_CHECK_RETURN(tBufferPutI64(buffer, pColAgg->max)); + TAOS_CHECK_RETURN(tBufferPutI64(buffer, pColAgg->min)); return 0; } int32_t tGetColumnDataAgg(SBufferReader *br, SColumnDataAgg *pColAgg) { - int32_t code; - - if ((code = tBufferGetI16v(br, &pColAgg->colId))) return code; - if ((code = tBufferGetI16v(br, &pColAgg->numOfNull))) return code; - if ((code = tBufferGetI64(br, &pColAgg->sum))) return code; - if ((code = tBufferGetI64(br, &pColAgg->max))) return code; - if ((code = tBufferGetI64(br, &pColAgg->min))) return code; - + TAOS_CHECK_RETURN(tBufferGetI16v(br, &pColAgg->colId)); + TAOS_CHECK_RETURN(tBufferGetI16v(br, &pColAgg->numOfNull)); + TAOS_CHECK_RETURN(tBufferGetI64(br, &pColAgg->sum)); + TAOS_CHECK_RETURN(tBufferGetI64(br, &pColAgg->max)); + TAOS_CHECK_RETURN(tBufferGetI64(br, &pColAgg->min)); return 0; } @@ -1632,8 +1160,7 @@ static int32_t tBlockDataCompressKeyPart(SBlockData *bData, SDiskDataHdr *hdr, S .dataType = TSDB_DATA_TYPE_BIGINT, .originalSize = sizeof(int64_t) * bData->nRow, }; - code = tCompressDataToBuffer(bData->aUid, &cinfo, buffer, assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tCompressDataToBuffer(bData->aUid, &cinfo, buffer, assist), &lino, _exit); hdr->szUid = cinfo.compressedSize; } @@ -1643,8 +1170,7 @@ static int32_t tBlockDataCompressKeyPart(SBlockData *bData, SDiskDataHdr *hdr, S .dataType = TSDB_DATA_TYPE_BIGINT, .originalSize = sizeof(int64_t) * bData->nRow, }; - code = tCompressDataToBuffer((uint8_t *)bData->aVersion, &cinfo, buffer, assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tCompressDataToBuffer((uint8_t *)bData->aVersion, &cinfo, buffer, assist), &lino, _exit); hdr->szVer = cinfo.compressedSize; // ts @@ -1654,8 +1180,7 @@ static int32_t tBlockDataCompressKeyPart(SBlockData *bData, SDiskDataHdr *hdr, S .originalSize = sizeof(TSKEY) * bData->nRow, }; - code = tCompressDataToBuffer((uint8_t *)bData->aTSKEY, &cinfo, buffer, assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tCompressDataToBuffer((uint8_t *)bData->aTSKEY, &cinfo, buffer, assist), &lino, _exit); hdr->szKey = cinfo.compressedSize; // primary keys @@ -1672,14 +1197,9 @@ static int32_t tBlockDataCompressKeyPart(SBlockData *bData, SDiskDataHdr *hdr, S SColDataCompressInfo info = { .cmprAlg = hdr->cmprAlg, }; - code = tsdbGetColCmprAlgFromSet(compressInfo->pColCmpr, colData->cid, &info.cmprAlg); - if (code < 0) { - // do nothing - } else { - } + TAOS_UNUSED(tsdbGetColCmprAlgFromSet(compressInfo->pColCmpr, colData->cid, &info.cmprAlg)); - code = tColDataCompress(colData, &info, buffer, assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tColDataCompress(colData, &info, buffer, assist), &lino, _exit); *blockCol = (SBlockCol){ .cid = info.columnId, @@ -1706,8 +1226,8 @@ int32_t tBlockDataDecompressColData(const SDiskDataHdr *hdr, const SBlockCol *bl SColData *colData; - code = tBlockDataAddColData(blockData, blockCol->cid, blockCol->type, blockCol->cflag, &colData); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tBlockDataAddColData(blockData, blockCol->cid, blockCol->type, blockCol->cflag, &colData), &lino, + _exit); // ASSERT(blockCol->flag != HAS_NONE); @@ -1737,8 +1257,7 @@ int32_t tBlockDataDecompressColData(const SDiskDataHdr *hdr, const SBlockCol *bl break; } - code = tColDataDecompress(BR_PTR(br), &info, colData, assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tColDataDecompress(BR_PTR(br), &info, colData, assist), &lino, _exit); br->offset += blockCol->szBitmap + blockCol->szOffset + blockCol->szValue; _exit: @@ -1760,10 +1279,8 @@ int32_t tBlockDataDecompressKeyPart(const SDiskDataHdr *hdr, SBufferReader *br, .originalSize = sizeof(int64_t) * hdr->nRow, }; - code = tRealloc((uint8_t **)&blockData->aUid, cinfo.originalSize); - TSDB_CHECK_CODE(code, lino, _exit); - code = tDecompressData(BR_PTR(br), &cinfo, blockData->aUid, cinfo.originalSize, assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tRealloc((uint8_t **)&blockData->aUid, cinfo.originalSize), &lino, _exit); + TAOS_CHECK_GOTO(tDecompressData(BR_PTR(br), &cinfo, blockData->aUid, cinfo.originalSize, assist), &lino, _exit); br->offset += cinfo.compressedSize; } @@ -1774,10 +1291,8 @@ int32_t tBlockDataDecompressKeyPart(const SDiskDataHdr *hdr, SBufferReader *br, .compressedSize = hdr->szVer, .originalSize = sizeof(int64_t) * hdr->nRow, }; - code = tRealloc((uint8_t **)&blockData->aVersion, cinfo.originalSize); - TSDB_CHECK_CODE(code, lino, _exit); - code = tDecompressData(BR_PTR(br), &cinfo, blockData->aVersion, cinfo.originalSize, assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tRealloc((uint8_t **)&blockData->aVersion, cinfo.originalSize), &lino, _exit); + TAOS_CHECK_GOTO(tDecompressData(BR_PTR(br), &cinfo, blockData->aVersion, cinfo.originalSize, assist), &lino, _exit); br->offset += cinfo.compressedSize; // ts @@ -1787,10 +1302,8 @@ int32_t tBlockDataDecompressKeyPart(const SDiskDataHdr *hdr, SBufferReader *br, .compressedSize = hdr->szKey, .originalSize = sizeof(TSKEY) * hdr->nRow, }; - code = tRealloc((uint8_t **)&blockData->aTSKEY, cinfo.originalSize); - TSDB_CHECK_CODE(code, lino, _exit); - code = tDecompressData(BR_PTR(br), &cinfo, blockData->aTSKEY, cinfo.originalSize, assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tRealloc((uint8_t **)&blockData->aTSKEY, cinfo.originalSize), &lino, _exit); + TAOS_CHECK_GOTO(tDecompressData(BR_PTR(br), &cinfo, blockData->aTSKEY, cinfo.originalSize, assist), &lino, _exit); br->offset += cinfo.compressedSize; // primary keys @@ -1800,8 +1313,7 @@ int32_t tBlockDataDecompressKeyPart(const SDiskDataHdr *hdr, SBufferReader *br, ASSERT(blockCol->flag == HAS_VALUE); ASSERT(blockCol->cflag & COL_IS_KEY); - code = tBlockDataDecompressColData(hdr, blockCol, br, blockData, assist); - TSDB_CHECK_CODE(code, lino, _exit); + TAOS_CHECK_GOTO(tBlockDataDecompressColData(hdr, blockCol, br, blockData, assist), &lino, _exit); } _exit: @@ -1809,14 +1321,19 @@ _exit: } int32_t tsdbGetColCmprAlgFromSet(SHashObj *set, int16_t colId, uint32_t *alg) { - if (set == NULL) return -1; + if (set == NULL) { + return TSDB_CODE_INVALID_PARA; + } 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; } + uint32_t tsdbCvtTimestampAlg(uint32_t alg) { DEFINE_VAR(alg) diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil2.c b/source/dnode/vnode/src/tsdb/tsdbUtil2.c index 9b88500ad1..97fea598cd 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUtil2.c +++ b/source/dnode/vnode/src/tsdb/tsdbUtil2.c @@ -17,17 +17,24 @@ // SDelBlock ---------- int32_t tTombBlockInit(STombBlock *tombBlock) { + int32_t code; + tombBlock->numOfRecords = 0; for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) { - tBufferInit(&tombBlock->buffers[i]); + TAOS_CHECK_GOTO(tBufferInit(&tombBlock->buffers[i]), NULL, _exit); } - return 0; + +_exit: + if (code) { + TAOS_UNUSED(tTombBlockDestroy(tombBlock)); + } + return code; } int32_t tTombBlockDestroy(STombBlock *tombBlock) { tombBlock->numOfRecords = 0; for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) { - tBufferDestroy(&tombBlock->buffers[i]); + TAOS_UNUSED(tBufferDestroy(&tombBlock->buffers[i])); } return 0; } @@ -35,15 +42,14 @@ int32_t tTombBlockDestroy(STombBlock *tombBlock) { int32_t tTombBlockClear(STombBlock *tombBlock) { tombBlock->numOfRecords = 0; for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) { - tBufferClear(&tombBlock->buffers[i]); + TAOS_UNUSED(tBufferClear(&tombBlock->buffers[i])); } return 0; } int32_t tTombBlockPut(STombBlock *tombBlock, const STombRecord *record) { for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) { - int32_t code = tBufferPutI64(&tombBlock->buffers[i], record->data[i]); - if (code) return code; + TAOS_CHECK_RETURN(tBufferPutI64(&tombBlock->buffers[i], record->data[i])); } tombBlock->numOfRecords++; return 0; @@ -56,8 +62,7 @@ int32_t tTombBlockGet(STombBlock *tombBlock, int32_t idx, STombRecord *record) { for (int32_t i = 0; i < TOMB_RECORD_ELEM_NUM; ++i) { SBufferReader br = BUFFER_READER_INITIALIZER(sizeof(int64_t) * idx, &tombBlock->buffers[i]); - int32_t code = tBufferGetI64(&br, &record->data[i]); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&br, &record->data[i])); } return 0; } @@ -74,27 +79,34 @@ int32_t tTombRecordCompare(const STombRecord *r1, const STombRecord *r2) { // STbStatisBlock ---------- int32_t tStatisBlockInit(STbStatisBlock *statisBlock) { + int32_t code; + statisBlock->numOfPKs = 0; statisBlock->numOfRecords = 0; for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) { - tBufferInit(&statisBlock->buffers[i]); + TAOS_CHECK_GOTO(tBufferInit(&statisBlock->buffers[i]), NULL, _exit); } for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) { - tValueColumnInit(&statisBlock->firstKeyPKs[i]); - tValueColumnInit(&statisBlock->lastKeyPKs[i]); + TAOS_CHECK_GOTO(tValueColumnInit(&statisBlock->firstKeyPKs[i]), NULL, _exit); + TAOS_CHECK_GOTO(tValueColumnInit(&statisBlock->lastKeyPKs[i]), NULL, _exit); } - return 0; + +_exit: + if (code) { + TAOS_UNUSED(tStatisBlockDestroy(statisBlock)); + } + return code; } int32_t tStatisBlockDestroy(STbStatisBlock *statisBlock) { statisBlock->numOfPKs = 0; statisBlock->numOfRecords = 0; for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) { - tBufferDestroy(&statisBlock->buffers[i]); + TAOS_UNUSED(tBufferDestroy(&statisBlock->buffers[i])); } for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) { - tValueColumnDestroy(&statisBlock->firstKeyPKs[i]); - tValueColumnDestroy(&statisBlock->lastKeyPKs[i]); + TAOS_UNUSED(tValueColumnDestroy(&statisBlock->firstKeyPKs[i])); + TAOS_UNUSED(tValueColumnDestroy(&statisBlock->lastKeyPKs[i])); } return 0; } @@ -103,17 +115,16 @@ int32_t tStatisBlockClear(STbStatisBlock *statisBlock) { statisBlock->numOfPKs = 0; statisBlock->numOfRecords = 0; for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) { - tBufferClear(&statisBlock->buffers[i]); + TAOS_UNUSED(tBufferClear(&statisBlock->buffers[i])); } for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) { - tValueColumnClear(&statisBlock->firstKeyPKs[i]); - tValueColumnClear(&statisBlock->lastKeyPKs[i]); + TAOS_UNUSED(tValueColumnClear(&statisBlock->firstKeyPKs[i])); + TAOS_UNUSED(tValueColumnClear(&statisBlock->lastKeyPKs[i])); } return 0; } static int32_t tStatisBlockAppend(STbStatisBlock *block, SRowInfo *row) { - int32_t code; STsdbRowKey key; tsdbRowGetKey(&row->row, &key); @@ -129,14 +140,14 @@ static int32_t tStatisBlockAppend(STbStatisBlock *block, SRowInfo *row) { } } - if ((code = tBufferPutI64(&block->suids, row->suid))) return code; - if ((code = tBufferPutI64(&block->uids, row->uid))) return code; - if ((code = tBufferPutI64(&block->firstKeyTimestamps, key.key.ts))) return code; - if ((code = tBufferPutI64(&block->lastKeyTimestamps, key.key.ts))) return code; - if ((code = tBufferPutI64(&block->counts, 1))) return code; + TAOS_CHECK_RETURN(tBufferPutI64(&block->suids, row->suid)); + TAOS_CHECK_RETURN(tBufferPutI64(&block->uids, row->uid)); + TAOS_CHECK_RETURN(tBufferPutI64(&block->firstKeyTimestamps, key.key.ts)); + TAOS_CHECK_RETURN(tBufferPutI64(&block->lastKeyTimestamps, key.key.ts)); + TAOS_CHECK_RETURN(tBufferPutI64(&block->counts, 1)); for (int32_t i = 0; i < block->numOfPKs; ++i) { - if ((code = tValueColumnAppend(block->firstKeyPKs + i, key.key.pks + i))) return code; - if ((code = tValueColumnAppend(block->lastKeyPKs + i, key.key.pks + i))) return code; + TAOS_CHECK_RETURN(tValueColumnAppend(block->firstKeyPKs + i, key.key.pks + i)); + TAOS_CHECK_RETURN(tValueColumnAppend(block->lastKeyPKs + i, key.key.pks + i)); } block->numOfRecords++; @@ -147,9 +158,8 @@ static int32_t tStatisBlockUpdate(STbStatisBlock *block, SRowInfo *row) { STbStatisRecord record; STsdbRowKey key; int32_t c; - int32_t code; - tStatisBlockGet(block, block->numOfRecords - 1, &record); + TAOS_CHECK_RETURN(tStatisBlockGet(block, block->numOfRecords - 1, &record)); tsdbRowGetKey(&row->row, &key); c = tRowKeyCompare(&record.lastKey, &key.key); @@ -157,21 +167,18 @@ static int32_t tStatisBlockUpdate(STbStatisBlock *block, SRowInfo *row) { return 0; } else if (c < 0) { // last ts - code = tBufferPutAt(&block->lastKeyTimestamps, (block->numOfRecords - 1) * sizeof(record.lastKey.ts), &key.key.ts, - sizeof(key.key.ts)); - if (code) return code; + TAOS_CHECK_RETURN(tBufferPutAt(&block->lastKeyTimestamps, (block->numOfRecords - 1) * sizeof(record.lastKey.ts), + &key.key.ts, sizeof(key.key.ts))); // last primary keys for (int i = 0; i < block->numOfPKs; i++) { - code = tValueColumnUpdate(&block->lastKeyPKs[i], block->numOfRecords - 1, &key.key.pks[i]); - if (code) return code; + TAOS_CHECK_RETURN(tValueColumnUpdate(&block->lastKeyPKs[i], block->numOfRecords - 1, &key.key.pks[i])); } // count record.count++; - code = tBufferPutAt(&block->counts, (block->numOfRecords - 1) * sizeof(record.count), &record.count, - sizeof(record.count)); - if (code) return code; + TAOS_CHECK_RETURN(tBufferPutAt(&block->counts, (block->numOfRecords - 1) * sizeof(record.count), &record.count, + sizeof(record.count))); } else { ASSERT(0); } @@ -183,8 +190,7 @@ int32_t tStatisBlockPut(STbStatisBlock *block, SRowInfo *row, int32_t maxRecords if (block->numOfRecords > 0) { int64_t lastUid; SBufferReader br = BUFFER_READER_INITIALIZER(sizeof(int64_t) * (block->numOfRecords - 1), &block->uids); - int32_t code = tBufferGetI64(&br, &lastUid); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&br, &lastUid)); if (lastUid == row->uid) { return tStatisBlockUpdate(block, row); @@ -196,7 +202,6 @@ int32_t tStatisBlockPut(STbStatisBlock *block, SRowInfo *row, int32_t maxRecords } int32_t tStatisBlockGet(STbStatisBlock *statisBlock, int32_t idx, STbStatisRecord *record) { - int32_t code; SBufferReader reader; if (idx < 0 || idx >= statisBlock->numOfRecords) { @@ -204,36 +209,29 @@ int32_t tStatisBlockGet(STbStatisBlock *statisBlock, int32_t idx, STbStatisRecor } reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->suid), &statisBlock->suids); - code = tBufferGetI64(&reader, &record->suid); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->suid)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->uid), &statisBlock->uids); - code = tBufferGetI64(&reader, &record->uid); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->uid)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->firstKey.ts), &statisBlock->firstKeyTimestamps); - code = tBufferGetI64(&reader, &record->firstKey.ts); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.ts)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->lastKey.ts), &statisBlock->lastKeyTimestamps); - code = tBufferGetI64(&reader, &record->lastKey.ts); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.ts)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(record->count), &statisBlock->counts); - code = tBufferGetI64(&reader, &record->count); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->count)); // primary keys for (record->firstKey.numOfPKs = 0; record->firstKey.numOfPKs < statisBlock->numOfPKs; record->firstKey.numOfPKs++) { - code = tValueColumnGet(&statisBlock->firstKeyPKs[record->firstKey.numOfPKs], idx, - &record->firstKey.pks[record->firstKey.numOfPKs]); - if (code) return code; + TAOS_CHECK_RETURN(tValueColumnGet(&statisBlock->firstKeyPKs[record->firstKey.numOfPKs], idx, + &record->firstKey.pks[record->firstKey.numOfPKs])); } for (record->lastKey.numOfPKs = 0; record->lastKey.numOfPKs < statisBlock->numOfPKs; record->lastKey.numOfPKs++) { - code = tValueColumnGet(&statisBlock->lastKeyPKs[record->lastKey.numOfPKs], idx, - &record->lastKey.pks[record->lastKey.numOfPKs]); - if (code) return code; + TAOS_CHECK_RETURN(tValueColumnGet(&statisBlock->lastKeyPKs[record->lastKey.numOfPKs], idx, + &record->lastKey.pks[record->lastKey.numOfPKs])); } return 0; @@ -241,27 +239,34 @@ int32_t tStatisBlockGet(STbStatisBlock *statisBlock, int32_t idx, STbStatisRecor // SBrinRecord ---------- int32_t tBrinBlockInit(SBrinBlock *brinBlock) { + int32_t code; + brinBlock->numOfPKs = 0; brinBlock->numOfRecords = 0; for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) { - tBufferInit(&brinBlock->buffers[i]); + TAOS_CHECK_GOTO(tBufferInit(&brinBlock->buffers[i]), NULL, _exit); } for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) { - tValueColumnInit(&brinBlock->firstKeyPKs[i]); - tValueColumnInit(&brinBlock->lastKeyPKs[i]); + TAOS_CHECK_GOTO(tValueColumnInit(&brinBlock->firstKeyPKs[i]), NULL, _exit); + TAOS_CHECK_GOTO(tValueColumnInit(&brinBlock->lastKeyPKs[i]), NULL, _exit); } - return 0; + +_exit: + if (code) { + TAOS_UNUSED(tBrinBlockDestroy(brinBlock)); + } + return code; } int32_t tBrinBlockDestroy(SBrinBlock *brinBlock) { brinBlock->numOfPKs = 0; brinBlock->numOfRecords = 0; for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) { - tBufferDestroy(&brinBlock->buffers[i]); + TAOS_UNUSED(tBufferDestroy(&brinBlock->buffers[i])); } for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) { - tValueColumnDestroy(&brinBlock->firstKeyPKs[i]); - tValueColumnDestroy(&brinBlock->lastKeyPKs[i]); + TAOS_UNUSED(tValueColumnDestroy(&brinBlock->firstKeyPKs[i])); + TAOS_UNUSED(tValueColumnDestroy(&brinBlock->lastKeyPKs[i])); } return 0; } @@ -270,18 +275,16 @@ int32_t tBrinBlockClear(SBrinBlock *brinBlock) { brinBlock->numOfPKs = 0; brinBlock->numOfRecords = 0; for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) { - tBufferClear(&brinBlock->buffers[i]); + TAOS_UNUSED(tBufferClear(&brinBlock->buffers[i])); } for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) { - tValueColumnClear(&brinBlock->firstKeyPKs[i]); - tValueColumnClear(&brinBlock->lastKeyPKs[i]); + TAOS_UNUSED(tValueColumnClear(&brinBlock->firstKeyPKs[i])); + TAOS_UNUSED(tValueColumnClear(&brinBlock->lastKeyPKs[i])); } return 0; } int32_t tBrinBlockPut(SBrinBlock *brinBlock, const SBrinRecord *record) { - int32_t code; - ASSERT(record->firstKey.key.numOfPKs == record->lastKey.key.numOfPKs); if (brinBlock->numOfRecords == 0) { // the first row @@ -298,60 +301,29 @@ int32_t tBrinBlockPut(SBrinBlock *brinBlock, const SBrinRecord *record) { } } - code = tBufferPutI64(&brinBlock->suids, record->suid); - if (code) return code; - - code = tBufferPutI64(&brinBlock->uids, record->uid); - if (code) return code; - - code = tBufferPutI64(&brinBlock->firstKeyTimestamps, record->firstKey.key.ts); - if (code) return code; - - code = tBufferPutI64(&brinBlock->firstKeyVersions, record->firstKey.version); - if (code) return code; - - code = tBufferPutI64(&brinBlock->lastKeyTimestamps, record->lastKey.key.ts); - if (code) return code; - - code = tBufferPutI64(&brinBlock->lastKeyVersions, record->lastKey.version); - if (code) return code; - - code = tBufferPutI64(&brinBlock->minVers, record->minVer); - if (code) return code; - - code = tBufferPutI64(&brinBlock->maxVers, record->maxVer); - if (code) return code; - - code = tBufferPutI64(&brinBlock->blockOffsets, record->blockOffset); - if (code) return code; - - code = tBufferPutI64(&brinBlock->smaOffsets, record->smaOffset); - if (code) return code; - - code = tBufferPutI32(&brinBlock->blockSizes, record->blockSize); - if (code) return code; - - code = tBufferPutI32(&brinBlock->blockKeySizes, record->blockKeySize); - if (code) return code; - - code = tBufferPutI32(&brinBlock->smaSizes, record->smaSize); - if (code) return code; - - code = tBufferPutI32(&brinBlock->numRows, record->numRow); - if (code) return code; - - code = tBufferPutI32(&brinBlock->counts, record->count); - if (code) return code; + TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->suids, record->suid)); + TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->uids, record->uid)); + TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->firstKeyTimestamps, record->firstKey.key.ts)); + TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->firstKeyVersions, record->firstKey.version)); + TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->lastKeyTimestamps, record->lastKey.key.ts)); + TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->lastKeyVersions, record->lastKey.version)); + TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->minVers, record->minVer)); + TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->maxVers, record->maxVer)); + TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->blockOffsets, record->blockOffset)); + TAOS_CHECK_RETURN(tBufferPutI64(&brinBlock->smaOffsets, record->smaOffset)); + TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->blockSizes, record->blockSize)); + TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->blockKeySizes, record->blockKeySize)); + TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->smaSizes, record->smaSize)); + TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->numRows, record->numRow)); + TAOS_CHECK_RETURN(tBufferPutI32(&brinBlock->counts, record->count)); if (brinBlock->numOfPKs > 0) { for (int32_t i = 0; i < brinBlock->numOfPKs; ++i) { - code = tValueColumnAppend(&brinBlock->firstKeyPKs[i], &record->firstKey.key.pks[i]); - if (code) return code; + TAOS_CHECK_RETURN(tValueColumnAppend(&brinBlock->firstKeyPKs[i], &record->firstKey.key.pks[i])); } for (int32_t i = 0; i < brinBlock->numOfPKs; ++i) { - code = tValueColumnAppend(&brinBlock->lastKeyPKs[i], &record->lastKey.key.pks[i]); - if (code) return code; + TAOS_CHECK_RETURN(tValueColumnAppend(&brinBlock->lastKeyPKs[i], &record->lastKey.key.pks[i])); } } @@ -361,7 +333,6 @@ int32_t tBrinBlockPut(SBrinBlock *brinBlock, const SBrinRecord *record) { } int32_t tBrinBlockGet(SBrinBlock *brinBlock, int32_t idx, SBrinRecord *record) { - int32_t code; SBufferReader reader; if (idx < 0 || idx >= brinBlock->numOfRecords) { @@ -369,78 +340,61 @@ int32_t tBrinBlockGet(SBrinBlock *brinBlock, int32_t idx, SBrinRecord *record) { } reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->suids); - code = tBufferGetI64(&reader, &record->suid); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->suid)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->uids); - code = tBufferGetI64(&reader, &record->uid); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->uid)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->firstKeyTimestamps); - code = tBufferGetI64(&reader, &record->firstKey.key.ts); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.key.ts)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->firstKeyVersions); - code = tBufferGetI64(&reader, &record->firstKey.version); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->firstKey.version)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->lastKeyTimestamps); - code = tBufferGetI64(&reader, &record->lastKey.key.ts); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.key.ts)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->lastKeyVersions); - code = tBufferGetI64(&reader, &record->lastKey.version); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->lastKey.version)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->minVers); - code = tBufferGetI64(&reader, &record->minVer); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->minVer)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->maxVers); - code = tBufferGetI64(&reader, &record->maxVer); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->maxVer)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->blockOffsets); - code = tBufferGetI64(&reader, &record->blockOffset); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->blockOffset)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int64_t), &brinBlock->smaOffsets); - code = tBufferGetI64(&reader, &record->smaOffset); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI64(&reader, &record->smaOffset)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->blockSizes); - code = tBufferGetI32(&reader, &record->blockSize); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->blockSize)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->blockKeySizes); - code = tBufferGetI32(&reader, &record->blockKeySize); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->blockKeySize)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->smaSizes); - code = tBufferGetI32(&reader, &record->smaSize); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->smaSize)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->numRows); - code = tBufferGetI32(&reader, &record->numRow); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->numRow)); reader = BUFFER_READER_INITIALIZER(idx * sizeof(int32_t), &brinBlock->counts); - code = tBufferGetI32(&reader, &record->count); - if (code) return code; + TAOS_CHECK_RETURN(tBufferGetI32(&reader, &record->count)); // primary keys for (record->firstKey.key.numOfPKs = 0; record->firstKey.key.numOfPKs < brinBlock->numOfPKs; record->firstKey.key.numOfPKs++) { - code = tValueColumnGet(&brinBlock->firstKeyPKs[record->firstKey.key.numOfPKs], idx, - &record->firstKey.key.pks[record->firstKey.key.numOfPKs]); - if (code) return code; + TAOS_CHECK_RETURN(tValueColumnGet(&brinBlock->firstKeyPKs[record->firstKey.key.numOfPKs], idx, + &record->firstKey.key.pks[record->firstKey.key.numOfPKs])); } for (record->lastKey.key.numOfPKs = 0; record->lastKey.key.numOfPKs < brinBlock->numOfPKs; record->lastKey.key.numOfPKs++) { - code = tValueColumnGet(&brinBlock->lastKeyPKs[record->lastKey.key.numOfPKs], idx, - &record->lastKey.key.pks[record->lastKey.key.numOfPKs]); - if (code) return code; + TAOS_CHECK_RETURN(tValueColumnGet(&brinBlock->lastKeyPKs[record->lastKey.key.numOfPKs], idx, + &record->lastKey.key.pks[record->lastKey.key.numOfPKs])); } return 0; From c7abeaed087995d767442e728204958e3df6c83f Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Wed, 17 Jul 2024 16:17:01 +0800 Subject: [PATCH 10/12] fix(util): suppress error report by valgrind on loogson --- source/util/src/thash.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/source/util/src/thash.c b/source/util/src/thash.c index 8c0ca3e5a7..3a53145fc4 100644 --- a/source/util/src/thash.c +++ b/source/util/src/thash.c @@ -675,7 +675,11 @@ void taosHashTableResize(SHashObj *pHashObj) { } SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *pData, size_t dsize, uint32_t hashVal) { +#ifdef _TD_LOONGARCH_64 + SHashNode *pNewNode = taosMemoryCalloc(1, sizeof(SHashNode) + keyLen + dsize + 1); +#else SHashNode *pNewNode = taosMemoryMalloc(sizeof(SHashNode) + keyLen + dsize + 1); +#endif if (pNewNode == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; From db40210a63e7daf25e322bda7ab77070fcdd9a58 Mon Sep 17 00:00:00 2001 From: zhiyong Date: Wed, 17 Jul 2024 17:27:14 +0800 Subject: [PATCH 11/12] add cast case --- tests/army/query/function/cast.py | 477 +++++++++++++++++++++++++++--- 1 file changed, 429 insertions(+), 48 deletions(-) diff --git a/tests/army/query/function/cast.py b/tests/army/query/function/cast.py index 66718ce715..af72f1de2c 100644 --- a/tests/army/query/function/cast.py +++ b/tests/army/query/function/cast.py @@ -11,61 +11,216 @@ class TDTestCase(TBase): def init(self, conn, logSql, replicaVar=1): tdLog.debug(f"start to excute {__file__}") tdSql.init(conn.cursor(), True) - self.dbname = "cast_db" self._datetime_epoch = datetime.datetime.fromtimestamp(0) - def cast_without_from(self): + def cast_from_int_to_other(self): # int - int_num = 2147483648 - tdSql.query(f"select cast({int_num} as int) re;") - tdSql.checkData(0, 0, -int_num) + int_num1 = 2147483647 + int_num2 = 2147483648 + tdSql.query(f"select cast({int_num1} as int) re;") + tdSql.checkData(0, 0, int_num1) - tdSql.query(f"select cast(2147483647 as int) re;") - tdSql.checkData(0, 0, 2147483647) + tdSql.query(f"select cast({int_num2} as int) re;") + tdSql.checkData(0, 0, -int_num2) - tdSql.query(f"select cast({int_num} as int unsigned) re;") - tdSql.checkData(0, 0, int_num) + tdSql.query(f"select cast({int_num2} as int unsigned) re;") + tdSql.checkData(0, 0, int_num2) - tdSql.query(f"select cast({int_num} as bigint) re;") - tdSql.checkData(0, 0, int_num) + tdSql.query(f"select cast({int_num1} as bigint) re;") + tdSql.checkData(0, 0, int_num1) - tdSql.query(f"select cast({int_num} as bigint unsigned) re;") - tdSql.checkData(0, 0, int_num) + tdSql.query(f"select cast({int_num1} as bigint unsigned) re;") + tdSql.checkData(0, 0, int_num1) - tdSql.query(f"select cast({int_num} as smallint) re;") - tdSql.checkData(0, 0, 0) + tdSql.query(f"select cast({int_num1} as smallint) re;") + tdSql.checkData(0, 0, -1) - tdSql.query(f"select cast({int_num} as smallint unsigned) re;") - tdSql.checkData(0, 0, 0) + tdSql.query(f"select cast({int_num1} as smallint unsigned) re;") + tdSql.checkData(0, 0, 65535) - tdSql.query(f"select cast({int_num} as tinyint) re;") - tdSql.checkData(0, 0, 0) + tdSql.query(f"select cast({int_num1} as tinyint) re;") + tdSql.checkData(0, 0, -1) - tdSql.query(f"select cast({int_num} as tinyint unsigned) re;") - tdSql.checkData(0, 0, 0) + tdSql.query(f"select cast({int_num1} as tinyint unsigned) re;") + tdSql.checkData(0, 0, 255) - tdSql.query(f"select cast({int_num} as float) re;") - tdSql.checkData(0, 0, '2147483648.0') + tdSql.query(f"select cast({int_num2} as float) re;") + tdSql.checkData(0, 0, "2147483648.0") - tdSql.query(f"select cast({int_num} as double) re;") - tdSql.checkData(0, 0, '2147483648.0') + tdSql.query(f"select cast({int_num2} as double) re;") + tdSql.checkData(0, 0, "2147483648.0") - tdSql.query(f"select cast({int_num} as bool) as re;") + tdSql.query(f"select cast({int_num2} as bool) as re;") tdSql.checkData(0, 0, True) - tdSql.query(f"select cast({int_num} as timestamp) as re;") - tdSql.checkData(0, 0, self._datetime_epoch + datetime.timedelta(seconds=int(int_num) / 1000)) + tdSql.query(f"select cast({int_num2} as timestamp) as re;") + tdSql.checkData(0, 0, self._datetime_epoch + datetime.timedelta(seconds=int(int_num2) / 1000)) - tdSql.query(f"select cast({int_num} as varchar(10)) as re;") - tdSql.checkData(0, 0, int_num) + tdSql.query(f"select cast({int_num1} as varchar(5)) as re;") + tdSql.checkData(0, 0, "21474") - tdSql.query(f"select cast({int_num} as binary(10)) as re;") - tdSql.checkData(0, 0, int_num) + tdSql.query(f"select cast({int_num1} as binary(5)) as re;") + tdSql.checkData(0, 0, "21474") - sql = f"select cast({int_num} as nchar(10));" - tdSql.query(sql) - tdSql.checkData(0, 0, int_num) + tdSql.query(f"select cast({int_num1} as nchar(5));") + tdSql.checkData(0, 0, "21474") + def cast_from_bigint_to_other(self): + # bigint + bigint_num = 9223372036854775807 + bigint_num2 = 9223372036854775808 + tdSql.query(f"select cast({bigint_num} as int) re;") + tdSql.checkData(0, 0, -1) + + tdSql.query(f"select cast({bigint_num} as int unsigned) re;") + tdSql.checkData(0, 0, 4294967295) + + tdSql.query(f"select cast({bigint_num} as bigint) re;") + tdSql.checkData(0, 0, bigint_num) + + tdSql.query(f"select cast({bigint_num2} as bigint) re;") + tdSql.checkData(0, 0, -bigint_num2) + + tdSql.query(f"select cast({bigint_num2} as bigint unsigned) re;") + tdSql.checkData(0, 0, bigint_num2) + + tdSql.query(f"select cast({bigint_num} as smallint) re;") + tdSql.checkData(0, 0, -1) + + tdSql.query(f"select cast({bigint_num} as smallint unsigned) re;") + tdSql.checkData(0, 0, 65535) + + tdSql.query(f"select cast({bigint_num} as tinyint) re;") + tdSql.checkData(0, 0, -1) + + tdSql.query(f"select cast({bigint_num} as tinyint unsigned) re;") + tdSql.checkData(0, 0, 255) + + tdSql.query(f"select cast({bigint_num} as float) re;") + tdSql.checkData(0, 0, 9.2233720e18) + + tdSql.query(f"select cast({bigint_num} as double) re;") + tdSql.checkData(0, 0, 9.2233720e18) + + tdSql.query(f"select cast({bigint_num} as bool) as re;") + tdSql.checkData(0, 0, True) + + # WARN: datetime overflow dont worry + tdSql.query(f"select cast({bigint_num} as timestamp) as re;") + # tdSql.checkData(0, 0, "292278994-08-17 15:12:55.807") + + tdSql.query(f"select cast({bigint_num} as varchar(5)) as re;") + tdSql.checkData(0, 0, "92233") + + tdSql.query(f"select cast({bigint_num} as binary(5)) as re;") + tdSql.checkData(0, 0, "92233") + + tdSql.query(f"select cast({bigint_num} as nchar(5));") + tdSql.checkData(0, 0, "92233") + + def cast_from_smallint_to_other(self): + smallint_num = 32767 + smallint_num2 = 32768 + tdSql.query(f"select cast({smallint_num} as int) re;") + tdSql.checkData(0, 0, smallint_num) + + tdSql.query(f"select cast({smallint_num} as int unsigned) re;") + tdSql.checkData(0, 0, smallint_num) + + tdSql.query(f"select cast({smallint_num} as bigint) re;") + tdSql.checkData(0, 0, smallint_num) + + tdSql.query(f"select cast({smallint_num2} as bigint unsigned) re;") + tdSql.checkData(0, 0, smallint_num2) + + tdSql.query(f"select cast({smallint_num} as smallint) re;") + tdSql.checkData(0, 0, smallint_num) + + tdSql.query(f"select cast({smallint_num2} as smallint) re;") + tdSql.checkData(0, 0, -smallint_num2) + + tdSql.query(f"select cast({smallint_num2} as smallint unsigned) re;") + tdSql.checkData(0, 0, smallint_num2) + + tdSql.query(f"select cast({smallint_num} as tinyint) re;") + tdSql.checkData(0, 0, -1) + + tdSql.query(f"select cast({smallint_num} as tinyint unsigned) re;") + tdSql.checkData(0, 0, 255) + + tdSql.query(f"select cast({smallint_num} as float) re;") + tdSql.checkData(0, 0, "32767.0") + + tdSql.query(f"select cast({smallint_num} as double) re;") + tdSql.checkData(0, 0, "32767.0") + + tdSql.query(f"select cast({smallint_num} as bool) as re;") + tdSql.checkData(0, 0, True) + + tdSql.query(f"select cast({smallint_num} as timestamp) as re;") + tdSql.checkData(0, 0, self._datetime_epoch + datetime.timedelta(seconds=int(smallint_num) / 1000)) + + tdSql.query(f"select cast({smallint_num} as varchar(3)) as re;") + tdSql.checkData(0, 0, "327") + + tdSql.query(f"select cast({smallint_num} as binary(3)) as re;") + tdSql.checkData(0, 0, "327") + + tdSql.query(f"select cast({smallint_num} as nchar(3));") + tdSql.checkData(0, 0, "327") + + def cast_from_tinyint_to_other(self): + tinyint_num = 127 + tinyint_num2 = 128 + tdSql.query(f"select cast({tinyint_num} as int) re;") + tdSql.checkData(0, 0, tinyint_num) + + tdSql.query(f"select cast({tinyint_num} as int unsigned) re;") + tdSql.checkData(0, 0, tinyint_num) + + tdSql.query(f"select cast({tinyint_num} as bigint) re;") + tdSql.checkData(0, 0, tinyint_num) + + tdSql.query(f"select cast({tinyint_num2} as bigint unsigned) re;") + tdSql.checkData(0, 0, tinyint_num2) + + tdSql.query(f"select cast({tinyint_num} as smallint) re;") + tdSql.checkData(0, 0, tinyint_num) + + tdSql.query(f"select cast({tinyint_num} as smallint unsigned) re;") + tdSql.checkData(0, 0, tinyint_num) + + tdSql.query(f"select cast({tinyint_num} as tinyint) re;") + tdSql.checkData(0, 0, tinyint_num) + + tdSql.query(f"select cast({tinyint_num2} as tinyint) re;") + tdSql.checkData(0, 0, -tinyint_num2) + + tdSql.query(f"select cast({tinyint_num2} as tinyint unsigned) re;") + tdSql.checkData(0, 0, tinyint_num2) + + tdSql.query(f"select cast({tinyint_num} as float) re;") + tdSql.checkData(0, 0, "127.0") + + tdSql.query(f"select cast({tinyint_num} as double) re;") + tdSql.checkData(0, 0, "127.0") + + tdSql.query(f"select cast({tinyint_num} as bool) as re;") + tdSql.checkData(0, 0, True) + + tdSql.query(f"select cast({tinyint_num} as timestamp) as re;") + tdSql.checkData(0, 0, self._datetime_epoch + datetime.timedelta(seconds=int(tinyint_num) / 1000)) + + tdSql.query(f"select cast({tinyint_num} as varchar(2)) as re;") + tdSql.checkData(0, 0, "12") + + tdSql.query(f"select cast({tinyint_num} as binary(2)) as re;") + tdSql.checkData(0, 0, "12") + + tdSql.query(f"select cast({tinyint_num} as nchar(2));") + tdSql.checkData(0, 0, "12") + + def cast_from_float_to_other(self): # float float_1001 = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631558817488152092096282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912983367336244065664308602139494639522473719070217986094370277053921717629317675238467481846766940513200056812714526356082778577134275778960917363717872146844090122495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837297804995105973173281609631859502445945534690830264252230825334468503526193118817101000313783875288658753320838142061717766914730359825349042875546873115956286388235378759375195778185778053217122680661300192787661119590921642019 @@ -116,22 +271,31 @@ class TDTestCase(TBase): tdSql.query(f"select cast({float_1001} as nchar(5));") tdSql.checkData(0, 0, 3.141) + def cast_from_str_to_other(self): # str - str_410 = "bcdefghigk" * 41 - big_str = "bcdefghigk" * 6552 + _str = "bcdefghigk" + str_410 = _str * 41 + str_401 = _str * 40 + "b" + big_str = _str * 6552 - tdSql.query(f"select cast('{str_410}' as binary(3)) as re;") - tdSql.checkData(0, 0, "bcd") + tdSql.query(f"select cast('{str_410}' as binary(401)) as re;") + tdSql.checkData(0, 0, str_401) - tdSql.query(f"select cast('{str_410}' as varchar(2)) as re;") - tdSql.checkData(0, 0, "bc") + tdSql.query(f"select cast('{str_410}' as varchar(401)) as re;") + tdSql.checkData(0, 0, str_401) - tdSql.query(f"select cast('{str_410}' as nchar(10));") - tdSql.checkData(0, 0, "bcdefghigk") + tdSql.query(f"select cast('{big_str}' as varchar(420)) as re;") + tdSql.checkData(0, 0, _str * 42) + + tdSql.query(f"select cast('{str_410}' as nchar(401));") + tdSql.checkData(0, 0, str_401) tdSql.query(f"select cast('北京' as nchar(10));") tdSql.checkData(0, 0, "北京") + # tdSql.query(f"select cast('北京涛思数据有限公司' as nchar(6));") + # tdSql.checkData(0, 0, "北京涛思数据") + tdSql.query(f"select cast('{str_410}' as int) as re;") tdSql.checkData(0, 0, 0) @@ -165,15 +329,232 @@ class TDTestCase(TBase): tdSql.query(f"select cast('{str_410}' as bool) as re") tdSql.checkData(0, 0, False) - tdSql.query( f"select cast('{str_410}' as timestamp) as re") + tdSql.query(f"select cast('{str_410}' as timestamp) as re") tdSql.checkData(0, 0, "1970-01-01 08:00:00.000") + def cast_from_bool_to_other(self): + true_val = True + false_val = False + tdSql.query(f"select cast({false_val} as int) re, cast({true_val} as int) re;") + tdSql.checkData(0, 0, 0) + tdSql.checkData(0, 1, 1) + + tdSql.query(f"select cast({false_val} as int unsigned) re, cast({true_val} as int unsigned) re;") + tdSql.checkData(0, 0, 0) + tdSql.checkData(0, 1, 1) + + tdSql.query(f"select cast({false_val} as bigint) re, cast({true_val} as bigint) re;") + tdSql.checkData(0, 0, 0) + tdSql.checkData(0, 1, 1) + + tdSql.query( + f"select cast({false_val} as bigint unsigned) re, cast({true_val} as bigint unsigned) re;" + ) + tdSql.checkData(0, 0, 0) + tdSql.checkData(0, 1, 1) + + tdSql.query(f"select cast({false_val} as smallint) re, cast({true_val} as smallint) re;") + tdSql.checkData(0, 0, 0) + tdSql.checkData(0, 1, 1) + + tdSql.query( + f"select cast({false_val} as smallint unsigned) re, cast({true_val} as smallint unsigned) re;" + ) + tdSql.checkData(0, 0, 0) + tdSql.checkData(0, 1, 1) + + tdSql.query(f"select cast({false_val} as tinyint) re, cast({true_val} as tinyint) re;") + tdSql.checkData(0, 0, 0) + tdSql.checkData(0, 1, 1) + + tdSql.query( + f"select cast({false_val} as tinyint unsigned) re, cast({true_val} as tinyint unsigned) re;" + ) + tdSql.checkData(0, 0, 0) + tdSql.checkData(0, 1, 1) + + tdSql.query(f"select cast({false_val} as smallint) re, cast({true_val} as smallint) re;") + tdSql.checkData(0, 0, 0) + tdSql.checkData(0, 1, 1) + + tdSql.query(f"select cast({false_val} as float) re, cast({true_val} as float) re;") + tdSql.checkData(0, 0, 0.0000000) + tdSql.checkData(0, 1, 1.0000000) + + tdSql.query(f"select cast({false_val} as double) re, cast({true_val} as double) re;") + tdSql.checkData(0, 0, 0.000000000000000) + tdSql.checkData(0, 1, 1.000000000000000) + + tdSql.query(f"select cast({false_val} as bool) re, cast({true_val} as bool) re;") + tdSql.checkData(0, 0, false_val) + tdSql.checkData(0, 1, true_val) + + tdSql.query(f"select cast({false_val} as timestamp) re, cast({true_val} as timestamp) re;") + tdSql.checkData(0, 0, "1970-01-01 08:00:00.000") + tdSql.checkData(0, 1, "1970-01-01 08:00:00.001") + + tdSql.query(f"select cast({false_val} as varchar(3)) re, cast({true_val} as varchar(3)) re;") + tdSql.checkData(0, 0, "fal") + tdSql.checkData(0, 1, "tru") + + tdSql.query(f"select cast({false_val} as binary(3)) re, cast({true_val} as binary(3)) re;") + tdSql.checkData(0, 0, "fal") + tdSql.checkData(0, 1, "tru") + + tdSql.query(f"select cast({false_val} as nchar(3)) re, cast({true_val} as nchar(3)) re;") + tdSql.checkData(0, 0, "fal") + tdSql.checkData(0, 1, "tru") + + def cast_from_timestamp_to_other(self): + # ts = self._datetime_epoch + # tdSql.query(f"select cast({ts} as int) re;") + # tdSql.checkData(0, 0, None) + # todo + pass + + def cast_from_null_to_other(self): + tdSql.query(f"select cast(null as int) re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as int unsigned) re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as bigint) re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as bigint unsigned) re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as smallint) re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as smallint unsigned) re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as tinyint) re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as tinyint unsigned) re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as float) re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as double) re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as bool) as re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as timestamp) as re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as varchar(55)) as re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as binary(5)) as re;") + tdSql.checkData(0, 0, None) + + tdSql.query(f"select cast(null as nchar(5));") + tdSql.checkData(0, 0, None) + + def cast_from_compute_to_other(self): + add1 = 123 + add2 = 456 + re = 579 + tdSql.query(f"select cast({add1}+{add2} as int) re;") + tdSql.checkData(0, 0, re) + + tdSql.query(f"select cast({add1}+{add2} as int unsigned) re;") + tdSql.checkData(0, 0, re) + + tdSql.query(f"select cast({add1}+{add2} as bigint) re;") + tdSql.checkData(0, 0, re) + + tdSql.query(f"select cast({add1}+{add2} as bigint unsigned) re;") + tdSql.checkData(0, 0, re) + + tdSql.query(f"select cast({add1}+{add2} as smallint) re;") + tdSql.checkData(0, 0, re) + + tdSql.query(f"select cast({add1}+{add2} as smallint unsigned) re;") + tdSql.checkData(0, 0, re) + + tdSql.query(f"select cast({add1}+{add2} as tinyint) re;") + tdSql.checkData(0, 0, 67) + + tdSql.query(f"select cast({add1}+{add2} as tinyint unsigned) re;") + tdSql.checkData(0, 0, 67) + + tdSql.query(f"select cast({add1}+{add2} as float) re;") + tdSql.checkData(0, 0, "579.0") + + tdSql.query(f"select cast({add1}+{add2} as double) re;") + tdSql.checkData(0, 0, "579.0") + + tdSql.query(f"select cast({add1}+{add2} as bool) as re;") + tdSql.checkData(0, 0, True) + + tdSql.query(f"select cast({add1}+{add2} as timestamp) as re;") + tdSql.checkData(0, 0, self._datetime_epoch + datetime.timedelta(seconds=int(re) / 1000)) + + tdSql.query(f"select cast({add1}+{add2} as varchar(2)) as re;") + tdSql.checkData(0, 0, "57") + + tdSql.query(f"select cast({add1}+{add2} as binary(2)) as re;") + tdSql.checkData(0, 0, "57") + + tdSql.query(f"select cast({add1}+{add2} as nchar(2));") + tdSql.checkData(0, 0, "57") + + test_str = "'!@#'" + tdSql.query(f"select cast({add1}+{test_str} as int) re;") + tdSql.checkData(0, 0, add1) + + tdSql.query(f"select cast({add1}+{test_str} as bigint) re;") + tdSql.checkData(0, 0, add1) + + tdSql.query(f"select cast({add1}+{test_str} as smallint) re;") + tdSql.checkData(0, 0, add1) + + tdSql.query(f"select cast({add1}+{test_str} as tinyint) re;") + tdSql.checkData(0, 0, add1) + + tdSql.query(f"select cast({add1}+{test_str} as float) re;") + tdSql.checkData(0, 0, "123.0") + + tdSql.query(f"select cast({add1}+{test_str} as double) re;") + tdSql.checkData(0, 0, "123.0") + + tdSql.query(f"select cast({add1}+{test_str} as bool) re;") + tdSql.checkData(0, 0, True) + + tdSql.query(f"select cast({add1}+{test_str} as timestamp) re;") + tdSql.checkData(0, 0, self._datetime_epoch + datetime.timedelta(seconds=int(add1) / 1000)) + + tdSql.query(f"select cast({add1}+{test_str} as varchar(2)) re;") + tdSql.checkData(0, 0, "12") + + tdSql.query(f"select cast({add1}+{test_str} as binary(2)) re;") + tdSql.checkData(0, 0, "12") + + tdSql.query(f"select cast({add1}+{test_str} as nchar(2)) re;") + tdSql.checkData(0, 0, "12") + + def cast_without_from(self): + self.cast_from_int_to_other() + self.cast_from_bigint_to_other() + self.cast_from_smallint_to_other() + self.cast_from_tinyint_to_other() + self.cast_from_float_to_other() + self.cast_from_str_to_other() + self.cast_from_bool_to_other() + self.cast_from_timestamp_to_other() + self.cast_from_compute_to_other() + # self.cast_from_null_to_other() def run(self): - # self.prepare_data() - # self.all_test() - # tdSql.execute(f"flush database {self.dbname}") - # self.all_test() + # 'from table' case see system-test/2-query/cast.py self.cast_without_from() tdLog.success(f"{__file__} successfully executed") From 3bada98670cbe57f1908746e38e3cfe39b488b56 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 17 Jul 2024 21:58:23 +0800 Subject: [PATCH 12/12] revert some change to make CI pass --- source/dnode/vnode/src/inc/tsdb.h | 4 +- .../dnode/vnode/src/tsdb/tsdbReaderWriter.c | 7 +- source/dnode/vnode/src/tsdb/tsdbUpgrade.c | 2 +- source/dnode/vnode/src/tsdb/tsdbUtil.c | 839 ++++++++++++++---- 4 files changed, 669 insertions(+), 183 deletions(-) diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h index 21dd48919e..75dfd03402 100644 --- a/source/dnode/vnode/src/inc/tsdb.h +++ b/source/dnode/vnode/src/inc/tsdb.h @@ -222,11 +222,11 @@ void tMapDataReset(SMapData *pMapData); void tMapDataClear(SMapData *pMapData); int32_t tMapDataPutItem(SMapData *pMapData, void *pItem, int32_t (*tPutItemFn)(uint8_t *, void *)); int32_t tMapDataCopy(SMapData *pFrom, SMapData *pTo); -int32_t tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)); +void tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)); 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, int64_t *decodeSize); +int32_t tGetMapData(uint8_t *p, SMapData *pMapData); int32_t tMapDataToArray(SMapData *pMapData, int32_t itemSize, int32_t (*tGetItemFn)(uint8_t *, void *), SArray **ppArray); // other diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c index 8cbcdbc34f..932bf2d92c 100644 --- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c +++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c @@ -803,8 +803,11 @@ int32_t tsdbReadDataBlk(SDataFReader *pReader, SBlockIdx *pBlockIdx, SMapData *m if (code) goto _err; // decode - int64_t n; - TAOS_CHECK_GOTO(tGetMapData(pReader->aBuf[0], mDataBlk, &n), NULL, _err); + int64_t n = tGetMapData(pReader->aBuf[0], mDataBlk); + if (n < 0) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _err; + } ASSERT(n == size); return code; diff --git a/source/dnode/vnode/src/tsdb/tsdbUpgrade.c b/source/dnode/vnode/src/tsdb/tsdbUpgrade.c index 1052d1c1a1..5d0500998e 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUpgrade.c +++ b/source/dnode/vnode/src/tsdb/tsdbUpgrade.c @@ -96,7 +96,7 @@ static int32_t tsdbUpgradeHead(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader * for (int32_t iDataBlk = 0; iDataBlk < ctx->mDataBlk->nItem; ++iDataBlk) { SDataBlk dataBlk[1]; - TAOS_CHECK_GOTO(tMapDataGetItemByIdx(ctx->mDataBlk, iDataBlk, dataBlk, tGetDataBlk), &lino, _exit); + tMapDataGetItemByIdx(ctx->mDataBlk, iDataBlk, dataBlk, tGetDataBlk); SBrinRecord record = { .suid = pBlockIdx->suid, diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c index 025fbf3eb7..58075cf0ac 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUtil.c +++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c @@ -36,47 +36,183 @@ void tMapDataClear(SMapData *pMapData) { pMapData->aOffset = NULL; } -int32_t tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)) { - if (idx < 0 || idx >= pMapData->nItem) { - return TSDB_CODE_OUT_OF_RANGE; - } +#ifdef BUILD_NO_CALL +int32_t tMapDataPutItem(SMapData *pMapData, void *pItem, int32_t (*tPutItemFn)(uint8_t *, void *)) { + int32_t code = 0; + int32_t offset = pMapData->nData; + int32_t nItem = pMapData->nItem; - tGetItemFn(pMapData->pData + pMapData->aOffset[idx], pItem); - return 0; + pMapData->nItem++; + pMapData->nData += tPutItemFn(NULL, pItem); + + // alloc + code = tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem); + if (code) goto _exit; + code = tRealloc(&pMapData->pData, pMapData->nData); + if (code) goto _exit; + + // put + pMapData->aOffset[nItem] = offset; + tPutItemFn(pMapData->pData + offset, pItem); + +_exit: + return code; } -int32_t tGetMapData(uint8_t *p, SMapData *pMapData, int64_t *decodeSize) { - int64_t size = 0; +int32_t tMapDataCopy(SMapData *pFrom, SMapData *pTo) { + int32_t code = 0; + + pTo->nItem = pFrom->nItem; + pTo->nData = pFrom->nData; + code = tRealloc((uint8_t **)&pTo->aOffset, sizeof(int32_t) * pFrom->nItem); + if (code) goto _exit; + code = tRealloc(&pTo->pData, pFrom->nData); + if (code) goto _exit; + memcpy(pTo->aOffset, pFrom->aOffset, sizeof(int32_t) * pFrom->nItem); + memcpy(pTo->pData, pFrom->pData, pFrom->nData); + +_exit: + return code; +} + +int32_t tMapDataSearch(SMapData *pMapData, void *pSearchItem, int32_t (*tGetItemFn)(uint8_t *, void *), + int32_t (*tItemCmprFn)(const void *, const void *), void *pItem) { + int32_t code = 0; + int32_t lidx = 0; + int32_t ridx = pMapData->nItem - 1; + int32_t midx; + int32_t c; + + while (lidx <= ridx) { + midx = (lidx + ridx) / 2; + + tMapDataGetItemByIdx(pMapData, midx, pItem, tGetItemFn); + + c = tItemCmprFn(pSearchItem, pItem); + if (c == 0) { + goto _exit; + } else if (c < 0) { + ridx = midx - 1; + } else { + lidx = midx + 1; + } + } + + code = TSDB_CODE_NOT_FOUND; + +_exit: + return code; +} +#endif + +void tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *)) { + ASSERT(idx >= 0 && idx < pMapData->nItem); + tGetItemFn(pMapData->pData + pMapData->aOffset[idx], pItem); +} + +#ifdef BUILD_NO_CALL +int32_t tMapDataToArray(SMapData *pMapData, int32_t itemSize, int32_t (*tGetItemFn)(uint8_t *, void *), + SArray **ppArray) { + int32_t code = 0; + + SArray *pArray = taosArrayInit(pMapData->nItem, itemSize); + if (pArray == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _exit; + } + + for (int32_t i = 0; i < pMapData->nItem; i++) { + tMapDataGetItemByIdx(pMapData, i, taosArrayReserve(pArray, 1), tGetItemFn); + } + +_exit: + *ppArray = pArray; + return code; +} + +int32_t tPutMapData(uint8_t *p, SMapData *pMapData) { + int32_t n = 0; + + n += tPutI32v(p ? p + n : p, pMapData->nItem); + if (pMapData->nItem) { + int32_t lOffset = 0; + for (int32_t iItem = 0; iItem < pMapData->nItem; iItem++) { + n += tPutI32v(p ? p + n : p, pMapData->aOffset[iItem] - lOffset); + lOffset = pMapData->aOffset[iItem]; + } + + n += tPutI32v(p ? p + n : p, pMapData->nData); + if (p) { + memcpy(p + n, pMapData->pData, pMapData->nData); + } + n += pMapData->nData; + } + + return n; +} +#endif + +int32_t tGetMapData(uint8_t *p, SMapData *pMapData) { + int32_t n = 0; + int32_t offset; tMapDataReset(pMapData); - size += tGetI32v(p + size, &pMapData->nItem); + n += tGetI32v(p + n, &pMapData->nItem); if (pMapData->nItem) { - if (tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem)) { - return TSDB_CODE_OUT_OF_MEMORY; - } + if (tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem)) return -1; int32_t lOffset = 0; for (int32_t iItem = 0; iItem < pMapData->nItem; iItem++) { - size += tGetI32v(p + size, &pMapData->aOffset[iItem]); + n += tGetI32v(p + n, &pMapData->aOffset[iItem]); pMapData->aOffset[iItem] += lOffset; lOffset = pMapData->aOffset[iItem]; } - size += tGetI32v(p + size, &pMapData->nData); - if (tRealloc(&pMapData->pData, pMapData->nData)) { - return TSDB_CODE_OUT_OF_MEMORY; - } - memcpy(pMapData->pData, p + size, pMapData->nData); - size += pMapData->nData; + n += tGetI32v(p + n, &pMapData->nData); + if (tRealloc(&pMapData->pData, pMapData->nData)) return -1; + memcpy(pMapData->pData, p + n, pMapData->nData); + n += pMapData->nData; } - if (decodeSize) { - *decodeSize = size; + return n; +} + +#ifdef BUILD_NO_CALL +// TABLEID ======================================================================= +int32_t tTABLEIDCmprFn(const void *p1, const void *p2) { + TABLEID *pId1 = (TABLEID *)p1; + TABLEID *pId2 = (TABLEID *)p2; + + if (pId1->suid < pId2->suid) { + return -1; + } else if (pId1->suid > pId2->suid) { + return 1; } + + if (pId1->uid < pId2->uid) { + return -1; + } else if (pId1->uid > pId2->uid) { + return 1; + } + return 0; } +// SBlockIdx ====================================================== +int32_t tPutBlockIdx(uint8_t *p, void *ph) { + int32_t n = 0; + SBlockIdx *pBlockIdx = (SBlockIdx *)ph; + + n += tPutI64(p ? p + n : p, pBlockIdx->suid); + n += tPutI64(p ? p + n : p, pBlockIdx->uid); + n += tPutI64v(p ? p + n : p, pBlockIdx->offset); + n += tPutI64v(p ? p + n : p, pBlockIdx->size); + + return n; +} +#endif + int32_t tGetBlockIdx(uint8_t *p, void *ph) { int32_t n = 0; SBlockIdx *pBlockIdx = (SBlockIdx *)ph; @@ -89,6 +225,77 @@ int32_t tGetBlockIdx(uint8_t *p, void *ph) { return n; } +#ifdef BUILD_NO_CALL +int32_t tCmprBlockIdx(void const *lhs, void const *rhs) { + SBlockIdx *lBlockIdx = (SBlockIdx *)lhs; + SBlockIdx *rBlockIdx = (SBlockIdx *)rhs; + + if (lBlockIdx->suid < rBlockIdx->suid) { + return -1; + } else if (lBlockIdx->suid > rBlockIdx->suid) { + return 1; + } + + if (lBlockIdx->uid < rBlockIdx->uid) { + return -1; + } else if (lBlockIdx->uid > rBlockIdx->uid) { + return 1; + } + + return 0; +} + +int32_t tCmprBlockL(void const *lhs, void const *rhs) { + SBlockIdx *lBlockIdx = (SBlockIdx *)lhs; + SSttBlk *rBlockL = (SSttBlk *)rhs; + + if (lBlockIdx->suid < rBlockL->suid) { + return -1; + } else if (lBlockIdx->suid > rBlockL->suid) { + return 1; + } + + if (lBlockIdx->uid < rBlockL->minUid) { + return -1; + } else if (lBlockIdx->uid > rBlockL->maxUid) { + return 1; + } + + return 0; +} + +// SDataBlk ====================================================== +void tDataBlkReset(SDataBlk *pDataBlk) { + *pDataBlk = (SDataBlk){.minKey = TSDBKEY_MAX, .maxKey = TSDBKEY_MIN, .minVer = VERSION_MAX, .maxVer = VERSION_MIN}; +} + +int32_t tPutDataBlk(uint8_t *p, void *ph) { + int32_t n = 0; + SDataBlk *pDataBlk = (SDataBlk *)ph; + + n += tPutI64v(p ? p + n : p, pDataBlk->minKey.version); + n += tPutI64v(p ? p + n : p, pDataBlk->minKey.ts); + n += tPutI64v(p ? p + n : p, pDataBlk->maxKey.version); + n += tPutI64v(p ? p + n : p, pDataBlk->maxKey.ts); + n += tPutI64v(p ? p + n : p, pDataBlk->minVer); + n += tPutI64v(p ? p + n : p, pDataBlk->maxVer); + n += tPutI32v(p ? p + n : p, pDataBlk->nRow); + n += tPutI8(p ? p + n : p, pDataBlk->hasDup); + n += tPutI8(p ? p + n : p, pDataBlk->nSubBlock); + for (int8_t iSubBlock = 0; iSubBlock < pDataBlk->nSubBlock; iSubBlock++) { + n += tPutI64v(p ? p + n : p, pDataBlk->aSubBlock[iSubBlock].offset); + n += tPutI32v(p ? p + n : p, pDataBlk->aSubBlock[iSubBlock].szBlock); + n += tPutI32v(p ? p + n : p, pDataBlk->aSubBlock[iSubBlock].szKey); + } + if (pDataBlk->nSubBlock == 1 && !pDataBlk->hasDup) { + n += tPutI64v(p ? p + n : p, pDataBlk->smaInfo.offset); + n += tPutI32v(p ? p + n : p, pDataBlk->smaInfo.size); + } + + return n; +} +#endif + int32_t tGetDataBlk(uint8_t *p, void *ph) { int32_t n = 0; SDataBlk *pDataBlk = (SDataBlk *)ph; @@ -118,6 +325,48 @@ int32_t tGetDataBlk(uint8_t *p, void *ph) { return n; } +#ifdef BUILD_NO_CALL +int32_t tDataBlkCmprFn(const void *p1, const void *p2) { + SDataBlk *pBlock1 = (SDataBlk *)p1; + SDataBlk *pBlock2 = (SDataBlk *)p2; + + if (tsdbKeyCmprFn(&pBlock1->maxKey, &pBlock2->minKey) < 0) { + return -1; + } else if (tsdbKeyCmprFn(&pBlock1->minKey, &pBlock2->maxKey) > 0) { + return 1; + } + + return 0; +} + +bool tDataBlkHasSma(SDataBlk *pDataBlk) { + if (pDataBlk->nSubBlock > 1) return false; + if (pDataBlk->hasDup) return false; + + return pDataBlk->smaInfo.size > 0; +} + +// SSttBlk ====================================================== +int32_t tPutSttBlk(uint8_t *p, void *ph) { + int32_t n = 0; + SSttBlk *pSttBlk = (SSttBlk *)ph; + + n += tPutI64(p ? p + n : p, pSttBlk->suid); + n += tPutI64(p ? p + n : p, pSttBlk->minUid); + n += tPutI64(p ? p + n : p, pSttBlk->maxUid); + n += tPutI64v(p ? p + n : p, pSttBlk->minKey); + n += tPutI64v(p ? p + n : p, pSttBlk->maxKey); + n += tPutI64v(p ? p + n : p, pSttBlk->minVer); + n += tPutI64v(p ? p + n : p, pSttBlk->maxVer); + n += tPutI32v(p ? p + n : p, pSttBlk->nRow); + n += tPutI64v(p ? p + n : p, pSttBlk->bInfo.offset); + n += tPutI32v(p ? p + n : p, pSttBlk->bInfo.szBlock); + n += tPutI32v(p ? p + n : p, pSttBlk->bInfo.szKey); + + return n; +} +#endif + int32_t tGetSttBlk(uint8_t *p, void *ph) { int32_t n = 0; SSttBlk *pSttBlk = (SSttBlk *)ph; @@ -142,42 +391,47 @@ int32_t tGetSttBlk(uint8_t *p, void *ph) { static const int32_t BLOCK_WITH_ALG_VER = 2; int32_t tPutBlockCol(SBuffer *buffer, const SBlockCol *pBlockCol, int32_t ver, uint32_t defaultCmprAlg) { + int32_t code; + ASSERT(pBlockCol->flag && (pBlockCol->flag != HAS_NONE)); - TAOS_CHECK_RETURN(tBufferPutI16v(buffer, pBlockCol->cid)); - TAOS_CHECK_RETURN(tBufferPutI8(buffer, pBlockCol->type)); - TAOS_CHECK_RETURN(tBufferPutI8(buffer, pBlockCol->cflag)); - TAOS_CHECK_RETURN(tBufferPutI8(buffer, pBlockCol->flag)); - TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pBlockCol->szOrigin)); + if ((code = tBufferPutI16v(buffer, pBlockCol->cid))) return code; + if ((code = tBufferPutI8(buffer, pBlockCol->type))) return code; + if ((code = tBufferPutI8(buffer, pBlockCol->cflag))) return code; + if ((code = tBufferPutI8(buffer, pBlockCol->flag))) return code; + if ((code = tBufferPutI32v(buffer, pBlockCol->szOrigin))) return code; if (pBlockCol->flag != HAS_NULL) { if (pBlockCol->flag != HAS_VALUE) { - TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pBlockCol->szBitmap)); + if ((code = tBufferPutI32v(buffer, pBlockCol->szBitmap))) return code; } if (IS_VAR_DATA_TYPE(pBlockCol->type)) { - TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pBlockCol->szOffset)); + if ((code = tBufferPutI32v(buffer, pBlockCol->szOffset))) return code; } if (pBlockCol->flag != (HAS_NULL | HAS_NONE)) { - TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pBlockCol->szValue)); + if ((code = tBufferPutI32v(buffer, pBlockCol->szValue))) return code; } - TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pBlockCol->offset)); + + if ((code = tBufferPutI32v(buffer, pBlockCol->offset))) return code; } if (ver >= BLOCK_WITH_ALG_VER) { - TAOS_CHECK_RETURN(tBufferPutU32(buffer, pBlockCol->alg)); + if ((code = tBufferPutU32(buffer, pBlockCol->alg))) return code; } else { - TAOS_CHECK_RETURN(tBufferPutU32(buffer, defaultCmprAlg)); + if ((code = tBufferPutU32(buffer, defaultCmprAlg))) return code; } return 0; } int32_t tGetBlockCol(SBufferReader *br, SBlockCol *pBlockCol, int32_t ver, uint32_t defaultCmprAlg) { - TAOS_CHECK_RETURN(tBufferGetI16v(br, &pBlockCol->cid)); - TAOS_CHECK_RETURN(tBufferGetI8(br, &pBlockCol->type)); - TAOS_CHECK_RETURN(tBufferGetI8(br, &pBlockCol->cflag)); - TAOS_CHECK_RETURN(tBufferGetI8(br, &pBlockCol->flag)); - TAOS_CHECK_RETURN(tBufferGetI32v(br, &pBlockCol->szOrigin)); + int32_t code; + + if ((code = tBufferGetI16v(br, &pBlockCol->cid))) return code; + if ((code = tBufferGetI8(br, &pBlockCol->type))) return code; + if ((code = tBufferGetI8(br, &pBlockCol->cflag))) return code; + if ((code = tBufferGetI8(br, &pBlockCol->flag))) return code; + if ((code = tBufferGetI32v(br, &pBlockCol->szOrigin))) return code; ASSERT(pBlockCol->flag && (pBlockCol->flag != HAS_NONE)); @@ -188,22 +442,22 @@ int32_t tGetBlockCol(SBufferReader *br, SBlockCol *pBlockCol, int32_t ver, uint3 if (pBlockCol->flag != HAS_NULL) { if (pBlockCol->flag != HAS_VALUE) { - TAOS_CHECK_RETURN(tBufferGetI32v(br, &pBlockCol->szBitmap)); + if ((code = tBufferGetI32v(br, &pBlockCol->szBitmap))) return code; } if (IS_VAR_DATA_TYPE(pBlockCol->type)) { - TAOS_CHECK_RETURN(tBufferGetI32v(br, &pBlockCol->szOffset)); + if ((code = tBufferGetI32v(br, &pBlockCol->szOffset))) return code; } if (pBlockCol->flag != (HAS_NULL | HAS_NONE)) { - TAOS_CHECK_RETURN(tBufferGetI32v(br, &pBlockCol->szValue)); + if ((code = tBufferGetI32v(br, &pBlockCol->szValue))) return code; } - TAOS_CHECK_RETURN(tBufferGetI32v(br, &pBlockCol->offset)); + if ((code = tBufferGetI32v(br, &pBlockCol->offset))) return code; } if (ver >= BLOCK_WITH_ALG_VER) { - TAOS_CHECK_RETURN(tBufferGetU32(br, &pBlockCol->alg)); + if ((code = tBufferGetU32(br, &pBlockCol->alg))) return code; } else { pBlockCol->alg = defaultCmprAlg; } @@ -211,6 +465,50 @@ int32_t tGetBlockCol(SBufferReader *br, SBlockCol *pBlockCol, int32_t ver, uint3 return 0; } +#ifdef BUILD_NO_CALL +int32_t tBlockColCmprFn(const void *p1, const void *p2) { + if (((SBlockCol *)p1)->cid < ((SBlockCol *)p2)->cid) { + return -1; + } else if (((SBlockCol *)p1)->cid > ((SBlockCol *)p2)->cid) { + return 1; + } + + return 0; +} + +// SDelIdx ====================================================== +int32_t tCmprDelIdx(void const *lhs, void const *rhs) { + SDelIdx *lDelIdx = (SDelIdx *)lhs; + SDelIdx *rDelIdx = (SDelIdx *)rhs; + + if (lDelIdx->suid < rDelIdx->suid) { + return -1; + } else if (lDelIdx->suid > rDelIdx->suid) { + return 1; + } + + if (lDelIdx->uid < rDelIdx->uid) { + return -1; + } else if (lDelIdx->uid > rDelIdx->uid) { + return 1; + } + + return 0; +} + +int32_t tPutDelIdx(uint8_t *p, void *ph) { + SDelIdx *pDelIdx = (SDelIdx *)ph; + int32_t n = 0; + + n += tPutI64(p ? p + n : p, pDelIdx->suid); + n += tPutI64(p ? p + n : p, pDelIdx->uid); + n += tPutI64v(p ? p + n : p, pDelIdx->offset); + n += tPutI64v(p ? p + n : p, pDelIdx->size); + + return n; +} +#endif + int32_t tGetDelIdx(uint8_t *p, void *ph) { SDelIdx *pDelIdx = (SDelIdx *)ph; int32_t n = 0; @@ -223,6 +521,20 @@ int32_t tGetDelIdx(uint8_t *p, void *ph) { return n; } +#ifdef BUILD_NO_CALL +// SDelData ====================================================== +int32_t tPutDelData(uint8_t *p, void *ph) { + SDelData *pDelData = (SDelData *)ph; + int32_t n = 0; + + n += tPutI64v(p ? p + n : p, pDelData->version); + n += tPutI64(p ? p + n : p, pDelData->sKey); + n += tPutI64(p ? p + n : p, pDelData->eKey); + + return n; +} +#endif + int32_t tGetDelData(uint8_t *p, void *ph) { SDelData *pDelData = (SDelData *)ph; int32_t n = 0; @@ -368,16 +680,20 @@ 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) { - TAOS_CHECK_RETURN(tRowIterOpen(pRow->pTSRow, pTSchema, &pIter->pIter)); + code = tRowIterOpen(pRow->pTSRow, pTSchema, &pIter->pIter); + if (code) goto _exit; } else if (pRow->type == TSDBROW_COL_FMT) { pIter->iColData = 0; } else { ASSERT(0); } - return 0; +_exit: + return code; } void tsdbRowClose(STSDBRowIter *pIter) { @@ -432,7 +748,8 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) *pColVal = COL_VAL_VALUE(pTColumn->colId, ((SValue){.type = pTColumn->type, .val = key.ts})); if (taosArrayPush(pMerger->pArray, pColVal) == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; + return code; } // other @@ -443,9 +760,7 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) --iCol; continue; } else if (pTSchema->columns[jCol].colId > pTColumn->colId) { - if (taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)) == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; - } + taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)); continue; } @@ -454,7 +769,10 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) uint8_t *pVal = pColVal->value.pData; pColVal->value.pData = NULL; - TAOS_CHECK_RETURN(tRealloc(&pColVal->value.pData, pColVal->value.nData)); + code = tRealloc(&pColVal->value.pData, pColVal->value.nData); + if (code) { + return TSDB_CODE_OUT_OF_MEMORY; + } if (pColVal->value.nData) { memcpy(pColVal->value.pData, pVal, pColVal->value.nData); @@ -462,15 +780,14 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) } if (taosArrayPush(pMerger->pArray, pColVal) == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; + return code; } } for (; iCol < pMerger->pTSchema->numOfCols; ++iCol) { pTColumn = &pMerger->pTSchema->columns[iCol]; - if (taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)) == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; - } + taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)); } pMerger->version = key.version; @@ -495,7 +812,8 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) if (IS_VAR_DATA_TYPE(pColVal->value.type)) { SColVal *pTColVal = taosArrayGet(pMerger->pArray, iCol); if (!COL_VAL_IS_NULL(pColVal)) { - TAOS_CHECK_RETURN(tRealloc(&pTColVal->value.pData, pColVal->value.nData)); + code = tRealloc(&pTColVal->value.pData, pColVal->value.nData); + if (code) return code; pTColVal->value.nData = pColVal->value.nData; if (pTColVal->value.nData) { @@ -514,7 +832,8 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) SColVal *tColVal = (SColVal *)taosArrayGet(pMerger->pArray, iCol); if (COL_VAL_IS_NONE(tColVal) && !COL_VAL_IS_NONE(pColVal)) { if ((!COL_VAL_IS_NULL(pColVal)) && IS_VAR_DATA_TYPE(pColVal->value.type)) { - TAOS_CHECK_RETURN(tRealloc(&tColVal->value.pData, pColVal->value.nData)); + code = tRealloc(&tColVal->value.pData, pColVal->value.nData); + if (code) return code; tColVal->value.nData = pColVal->value.nData; if (pColVal->value.nData) { @@ -572,8 +891,79 @@ int32_t tsdbRowMergerGetRow(SRowMerger *pMerger, SRow **ppRow) { return tRowBuild(pMerger->pArray, pMerger->pTSchema, ppRow); } +/* +// delete skyline ====================================================== +static int32_t tsdbMergeSkyline2(SArray *aSkyline1, SArray *aSkyline2, SArray *aSkyline) { + int32_t code = 0; + int32_t i1 = 0; + int32_t n1 = taosArrayGetSize(aSkyline1); + int32_t i2 = 0; + int32_t n2 = taosArrayGetSize(aSkyline2); + TSDBKEY *pSkyline1; + TSDBKEY *pSkyline2; + TSDBKEY item; + int64_t version1 = 0; + int64_t version2 = 0; + + ASSERT(n1 > 0 && n2 > 0); + + taosArrayClear(aSkyline); + + while (i1 < n1 && i2 < n2) { + pSkyline1 = (TSDBKEY *)taosArrayGet(aSkyline1, i1); + pSkyline2 = (TSDBKEY *)taosArrayGet(aSkyline2, i2); + + if (pSkyline1->ts < pSkyline2->ts) { + version1 = pSkyline1->version; + i1++; + } else if (pSkyline1->ts > pSkyline2->ts) { + version2 = pSkyline2->version; + i2++; + } else { + version1 = pSkyline1->version; + version2 = pSkyline2->version; + i1++; + i2++; + } + + item.ts = TMIN(pSkyline1->ts, pSkyline2->ts); + item.version = TMAX(version1, version2); + if (taosArrayPush(aSkyline, &item) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _exit; + } + } + + while (i1 < n1) { + pSkyline1 = (TSDBKEY *)taosArrayGet(aSkyline1, i1); + item.ts = pSkyline1->ts; + item.version = pSkyline1->version; + if (taosArrayPush(aSkyline, &item) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _exit; + } + i1++; + } + + while (i2 < n2) { + pSkyline2 = (TSDBKEY *)taosArrayGet(aSkyline2, i2); + item.ts = pSkyline2->ts; + item.version = pSkyline2->version; + if (taosArrayPush(aSkyline, &item) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _exit; + } + i2++; + } + +_exit: + return code; +} +*/ + // delete skyline ====================================================== static int32_t tsdbMergeSkyline(SArray *pSkyline1, SArray *pSkyline2, SArray *pSkyline) { + int32_t code = 0; int32_t i1 = 0; int32_t n1 = taosArrayGetSize(pSkyline1); int32_t i2 = 0; @@ -627,7 +1017,7 @@ static int32_t tsdbMergeSkyline(SArray *pSkyline1, SArray *pSkyline2, SArray *pS } pSkyline->size = TARRAY_ELEM_IDX(pSkyline, pItem); - return 0; + return code; } int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx, SArray *pSkyline) { @@ -639,12 +1029,8 @@ 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); - if (taosArrayPush(pSkyline, &pItem1) == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; - } - if (taosArrayPush(pSkyline, &pItem2) == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; - } + taosArrayPush(pSkyline, &pItem1); + taosArrayPush(pSkyline, &pItem2); } else { SArray *pSkyline1 = NULL; SArray *pSkyline2 = NULL; @@ -657,8 +1043,11 @@ int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx, goto _clear; } - TAOS_CHECK_GOTO(tsdbBuildDeleteSkylineImpl(aSkyline, sidx, midx, pSkyline1), NULL, _clear); - TAOS_CHECK_GOTO(tsdbBuildDeleteSkylineImpl(aSkyline, midx + 1, eidx, pSkyline2), NULL, _clear); + code = tsdbBuildDeleteSkylineImpl(aSkyline, sidx, midx, pSkyline1); + if (code) goto _clear; + + code = tsdbBuildDeleteSkylineImpl(aSkyline, midx + 1, eidx, pSkyline2); + if (code) goto _clear; code = tsdbMergeSkyline(pSkyline1, pSkyline2, pSkyline); @@ -674,48 +1063,72 @@ int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SAr SDelData *pDelData; int32_t code = 0; int32_t dataNum = eidx - sidx + 1; - SArray *aTmpSkyline; - SArray *pSkyline; - - aTmpSkyline = taosArrayInit(dataNum * 2, sizeof(TSDBKEY)); - if (aTmpSkyline == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; - } - - pSkyline = taosArrayInit(dataNum * 2, POINTER_BYTES); - if (pSkyline) { - taosArrayDestroy(aTmpSkyline); - return TSDB_CODE_OUT_OF_MEMORY; - } + SArray *aTmpSkyline = taosArrayInit(dataNum * 2, sizeof(TSDBKEY)); + SArray *pSkyline = taosArrayInit(dataNum * 2, POINTER_BYTES); taosArrayClear(aSkyline); for (int32_t i = sidx; i <= eidx; ++i) { pDelData = (SDelData *)taosArrayGet(aDelData, i); - if (taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->sKey, .version = pDelData->version}) == NULL) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _clear); - } - - if (taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0}) == NULL) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _clear); - } + taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->sKey, .version = pDelData->version}); + taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0}); } - TAOS_CHECK_GOTO(tsdbBuildDeleteSkylineImpl(aTmpSkyline, sidx, eidx, pSkyline), NULL, _clear); + code = tsdbBuildDeleteSkylineImpl(aTmpSkyline, sidx, eidx, pSkyline); + if (code) goto _clear; int32_t skylineNum = taosArrayGetSize(pSkyline); for (int32_t i = 0; i < skylineNum; ++i) { TSDBKEY *p = taosArrayGetP(pSkyline, i); - if (taosArrayPush(aSkyline, p) == NULL) { - TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _clear); - } + taosArrayPush(aSkyline, p); } _clear: taosArrayDestroy(aTmpSkyline); taosArrayDestroy(pSkyline); + return code; } +/* +int32_t tsdbBuildDeleteSkyline2(SArray *aDelData, int32_t sidx, int32_t eidx, SArray *aSkyline) { + int32_t code = 0; + SDelData *pDelData; + int32_t midx; + + taosArrayClear(aSkyline); + if (sidx == eidx) { + pDelData = (SDelData *)taosArrayGet(aDelData, sidx); + taosArrayPush(aSkyline, &(TSDBKEY){.ts = pDelData->sKey, .version = pDelData->version}); + taosArrayPush(aSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0}); + } else { + SArray *aSkyline1 = NULL; + SArray *aSkyline2 = NULL; + + aSkyline1 = taosArrayInit(0, sizeof(TSDBKEY)); + aSkyline2 = taosArrayInit(0, sizeof(TSDBKEY)); + if (aSkyline1 == NULL || aSkyline2 == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _clear; + } + midx = (sidx + eidx) / 2; + + code = tsdbBuildDeleteSkyline(aDelData, sidx, midx, aSkyline1); + if (code) goto _clear; + + code = tsdbBuildDeleteSkyline(aDelData, midx + 1, eidx, aSkyline2); + if (code) goto _clear; + + code = tsdbMergeSkyline(aSkyline1, aSkyline2, aSkyline); + + _clear: + taosArrayDestroy(aSkyline1); + taosArrayDestroy(aSkyline2); + } + + return code; +} +*/ + // SBlockData ====================================================== int32_t tBlockDataCreate(SBlockData *pBlockData) { pBlockData->suid = 0; @@ -745,6 +1158,8 @@ void tBlockDataDestroy(SBlockData *pBlockData) { } static int32_t tBlockDataAdjustColData(SBlockData *pBlockData, int32_t nColData) { + int32_t code = 0; + if (pBlockData->nColData > nColData) { for (int32_t i = nColData; i < pBlockData->nColData; i++) { tColDataDestroy(&pBlockData->aColData[i]); @@ -752,7 +1167,8 @@ static int32_t tBlockDataAdjustColData(SBlockData *pBlockData, int32_t nColData) } else if (pBlockData->nColData < nColData) { SColData *aColData = taosMemoryRealloc(pBlockData->aColData, sizeof(SBlockData) * nColData); if (aColData == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; + goto _exit; } pBlockData->aColData = aColData; @@ -760,10 +1176,12 @@ static int32_t tBlockDataAdjustColData(SBlockData *pBlockData, int32_t nColData) } pBlockData->nColData = nColData; - return 0; +_exit: + return code; } - int32_t tBlockDataInit(SBlockData *pBlockData, TABLEID *pId, STSchema *pTSchema, int16_t *aCid, int32_t nCid) { + int32_t code = 0; + ASSERT(pId->suid || pId->uid); pBlockData->suid = pId->suid; @@ -771,7 +1189,8 @@ int32_t tBlockDataInit(SBlockData *pBlockData, TABLEID *pId, STSchema *pTSchema, pBlockData->nRow = 0; if (aCid) { - TAOS_CHECK_RETURN(tBlockDataAdjustColData(pBlockData, nCid)); + code = tBlockDataAdjustColData(pBlockData, nCid); + if (code) goto _exit; int32_t iColumn = 1; STColumn *pTColumn = &pTSchema->columns[iColumn]; @@ -798,14 +1217,17 @@ int32_t tBlockDataInit(SBlockData *pBlockData, TABLEID *pId, STSchema *pTSchema, pTColumn = (iColumn < pTSchema->numOfCols) ? &pTSchema->columns[iColumn] : NULL; } } else { - TAOS_CHECK_RETURN(tBlockDataAdjustColData(pBlockData, pTSchema->numOfCols - 1)); + code = tBlockDataAdjustColData(pBlockData, pTSchema->numOfCols - 1); + if (code) goto _exit; for (int32_t iColData = 0; iColData < pBlockData->nColData; iColData++) { STColumn *pTColumn = &pTSchema->columns[iColData + 1]; tColDataInit(&pBlockData->aColData[iColData], pTColumn->colId, pTColumn->type, pTColumn->flags); } } - return 0; + +_exit: + return code; } void tBlockDataReset(SBlockData *pBlockData) { @@ -887,35 +1309,43 @@ _exit: } int32_t tBlockDataAppendRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema, int64_t uid) { + int32_t code = 0; + ASSERT(pBlockData->suid || pBlockData->uid); // uid if (pBlockData->uid == 0) { ASSERT(uid); - TAOS_CHECK_RETURN(tRealloc((uint8_t **)&pBlockData->aUid, sizeof(int64_t) * (pBlockData->nRow + 1))); + code = tRealloc((uint8_t **)&pBlockData->aUid, sizeof(int64_t) * (pBlockData->nRow + 1)); + if (code) goto _exit; pBlockData->aUid[pBlockData->nRow] = uid; } // version - TAOS_CHECK_RETURN(tRealloc((uint8_t **)&pBlockData->aVersion, sizeof(int64_t) * (pBlockData->nRow + 1))); + code = tRealloc((uint8_t **)&pBlockData->aVersion, sizeof(int64_t) * (pBlockData->nRow + 1)); + if (code) goto _exit; pBlockData->aVersion[pBlockData->nRow] = TSDBROW_VERSION(pRow); // timestamp - TAOS_CHECK_RETURN(tRealloc((uint8_t **)&pBlockData->aTSKEY, sizeof(TSKEY) * (pBlockData->nRow + 1))); + code = tRealloc((uint8_t **)&pBlockData->aTSKEY, sizeof(TSKEY) * (pBlockData->nRow + 1)); + if (code) goto _exit; pBlockData->aTSKEY[pBlockData->nRow] = TSDBROW_TS(pRow); if (pRow->type == TSDBROW_ROW_FMT) { - TAOS_CHECK_RETURN( - tRowUpsertColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData, 0 /* append */)); + code = tRowUpsertColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData, 0 /* append */); + if (code) goto _exit; } else if (pRow->type == TSDBROW_COL_FMT) { - TAOS_CHECK_RETURN(tBlockDataUpsertBlockRow(pBlockData, pRow->pBlockData, pRow->iRow, 0 /* append */)); + code = tBlockDataUpsertBlockRow(pBlockData, pRow->pBlockData, pRow->iRow, 0 /* append */); + if (code) goto _exit; } else { ASSERT(0); } pBlockData->nRow++; - return 0; +_exit: + return code; } - int32_t tBlockDataUpdateRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema) { + int32_t code = 0; + // version int64_t lversion = pBlockData->aVersion[pBlockData->nRow - 1]; int64_t rversion = TSDBROW_VERSION(pRow); @@ -926,18 +1356,40 @@ int32_t tBlockDataUpdateRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTS // update other rows if (pRow->type == TSDBROW_ROW_FMT) { - TAOS_CHECK_RETURN(tRowUpsertColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData, - (rversion > lversion) ? 1 : -1 /* update */)); + code = tRowUpsertColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData, + (rversion > lversion) ? 1 : -1 /* update */); + if (code) goto _exit; } else if (pRow->type == TSDBROW_COL_FMT) { - TAOS_CHECK_RETURN( - tBlockDataUpsertBlockRow(pBlockData, pRow->pBlockData, pRow->iRow, (rversion > lversion) ? 1 : -1)); + code = tBlockDataUpsertBlockRow(pBlockData, pRow->pBlockData, pRow->iRow, (rversion > lversion) ? 1 : -1); + if (code) goto _exit; } else { ASSERT(0); } - return 0; +_exit: + return code; } +#ifdef BUILD_NO_CALL +int32_t tBlockDataTryUpsertRow(SBlockData *pBlockData, TSDBROW *pRow, int64_t uid) { + if (pBlockData->nRow == 0) { + return 1; + } else if (pBlockData->aTSKEY[pBlockData->nRow - 1] == TSDBROW_TS(pRow)) { + return pBlockData->nRow; + } else { + return pBlockData->nRow + 1; + } +} + +int32_t tBlockDataUpsertRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema, int64_t uid) { + if (pBlockData->nRow > 0 && pBlockData->aTSKEY[pBlockData->nRow - 1] == TSDBROW_TS(pRow)) { + return tBlockDataUpdateRow(pBlockData, pRow, pTSchema); + } else { + return tBlockDataAppendRow(pBlockData, pRow, pTSchema, uid); + } +} +#endif + SColData *tBlockDataGetColData(SBlockData *pBlockData, int16_t cid) { ASSERT(cid != PRIMARYKEY_TIMESTAMP_COL_ID); int32_t lidx = 0; @@ -970,8 +1422,7 @@ int32_t tBlockDataCompress(SBlockData *bData, void *pCompr, SBuffer *buffers, SB int32_t lino = 0; SColCompressInfo *pInfo = pCompr; - - TAOS_CHECK_GOTO(tsdbGetColCmprAlgFromSet(pInfo->pColCmpr, 1, &pInfo->defaultCmprAlg), &lino, _exit); + code = tsdbGetColCmprAlgFromSet(pInfo->pColCmpr, 1, &pInfo->defaultCmprAlg); SDiskDataHdr hdr = { .delimiter = TSDB_FILE_DLMT, @@ -989,7 +1440,8 @@ int32_t tBlockDataCompress(SBlockData *bData, void *pCompr, SBuffer *buffers, SB // Key part tBufferClear(&buffers[1]); - TAOS_CHECK_GOTO(tBlockDataCompressKeyPart(bData, &hdr, &buffers[1], assist, (SColCompressInfo *)pInfo), &lino, _exit); + code = tBlockDataCompressKeyPart(bData, &hdr, &buffers[1], assist, (SColCompressInfo *)pInfo); + TSDB_CHECK_CODE(code, lino, _exit); // Regulart column part tBufferClear(&buffers[2]); @@ -1007,10 +1459,14 @@ int32_t tBlockDataCompress(SBlockData *bData, void *pCompr, SBuffer *buffers, SB SColDataCompressInfo cinfo = { .cmprAlg = pInfo->defaultCmprAlg, }; - TAOS_UNUSED(tsdbGetColCmprAlgFromSet(pInfo->pColCmpr, colData->cid, &cinfo.cmprAlg)); + code = tsdbGetColCmprAlgFromSet(pInfo->pColCmpr, colData->cid, &cinfo.cmprAlg); + if (code < 0) { + // + } int32_t offset = buffers[3].size; - TAOS_CHECK_GOTO(tColDataCompress(colData, &cinfo, &buffers[3], assist), &lino, _exit); + code = tColDataCompress(colData, &cinfo, &buffers[3], assist); + TSDB_CHECK_CODE(code, lino, _exit); SBlockCol blockCol = (SBlockCol){.cid = cinfo.columnId, .type = cinfo.dataType, @@ -1023,13 +1479,15 @@ int32_t tBlockDataCompress(SBlockData *bData, void *pCompr, SBuffer *buffers, SB .offset = offset, .alg = cinfo.cmprAlg}; - TAOS_CHECK_GOTO(tPutBlockCol(&buffers[2], &blockCol, hdr.fmtVer, hdr.cmprAlg), &lino, _exit); + code = tPutBlockCol(&buffers[2], &blockCol, hdr.fmtVer, hdr.cmprAlg); + TSDB_CHECK_CODE(code, lino, _exit); } hdr.szBlkCol = buffers[2].size; // SDiskDataHdr part tBufferClear(&buffers[0]); - TAOS_CHECK_GOTO(tPutDiskDataHdr(&buffers[0], &hdr), &lino, _exit); + code = tPutDiskDataHdr(&buffers[0], &hdr); + TSDB_CHECK_CODE(code, lino, _exit); _exit: return code; @@ -1042,7 +1500,8 @@ int32_t tBlockDataDecompress(SBufferReader *br, SBlockData *blockData, SBuffer * SCompressInfo cinfo; // SDiskDataHdr - TAOS_CHECK_GOTO(tGetDiskDataHdr(br, &hdr), &lino, _exit); + code = tGetDiskDataHdr(br, &hdr); + TSDB_CHECK_CODE(code, lino, _exit); tBlockDataReset(blockData); blockData->suid = hdr.suid; @@ -1050,7 +1509,8 @@ int32_t tBlockDataDecompress(SBufferReader *br, SBlockData *blockData, SBuffer * blockData->nRow = hdr.nRow; // Key part - TAOS_CHECK_GOTO(tBlockDataDecompressKeyPart(&hdr, br, blockData, assist), &lino, _exit); + code = tBlockDataDecompressKeyPart(&hdr, br, blockData, assist); + TSDB_CHECK_CODE(code, lino, _exit); // Column part SBufferReader br2 = *br; @@ -1058,11 +1518,11 @@ int32_t tBlockDataDecompress(SBufferReader *br, SBlockData *blockData, SBuffer * for (uint32_t startOffset = br2.offset; br2.offset - startOffset < hdr.szBlkCol;) { SBlockCol blockCol; - TAOS_CHECK_GOTO(tGetBlockCol(&br2, &blockCol, hdr.fmtVer, hdr.cmprAlg), &lino, _exit); - + code = tGetBlockCol(&br2, &blockCol, hdr.fmtVer, hdr.cmprAlg); if (blockCol.alg == 0) blockCol.alg = hdr.cmprAlg; - - TAOS_CHECK_GOTO(tBlockDataDecompressColData(&hdr, &blockCol, br, blockData, assist), &lino, _exit); + TSDB_CHECK_CODE(code, lino, _exit); + code = tBlockDataDecompressColData(&hdr, &blockCol, br, blockData, assist); + TSDB_CHECK_CODE(code, lino, _exit); } _exit: @@ -1071,26 +1531,28 @@ _exit: // SDiskDataHdr ============================== int32_t tPutDiskDataHdr(SBuffer *buffer, const SDiskDataHdr *pHdr) { - TAOS_CHECK_RETURN(tBufferPutU32(buffer, pHdr->delimiter)); - TAOS_CHECK_RETURN(tBufferPutU32v(buffer, pHdr->fmtVer)); - TAOS_CHECK_RETURN(tBufferPutI64(buffer, pHdr->suid)); - TAOS_CHECK_RETURN(tBufferPutI64(buffer, pHdr->uid)); - TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pHdr->szUid)); - TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pHdr->szVer)); - TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pHdr->szKey)); - TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pHdr->szBlkCol)); - TAOS_CHECK_RETURN(tBufferPutI32v(buffer, pHdr->nRow)); + int32_t code; + + if ((code = tBufferPutU32(buffer, pHdr->delimiter))) return code; + if ((code = tBufferPutU32v(buffer, pHdr->fmtVer))) return code; + if ((code = tBufferPutI64(buffer, pHdr->suid))) return code; + if ((code = tBufferPutI64(buffer, pHdr->uid))) return code; + if ((code = tBufferPutI32v(buffer, pHdr->szUid))) return code; + if ((code = tBufferPutI32v(buffer, pHdr->szVer))) return code; + if ((code = tBufferPutI32v(buffer, pHdr->szKey))) return code; + if ((code = tBufferPutI32v(buffer, pHdr->szBlkCol))) return code; + if ((code = tBufferPutI32v(buffer, pHdr->nRow))) return code; if (pHdr->fmtVer < 2) { - TAOS_CHECK_RETURN(tBufferPutI8(buffer, pHdr->cmprAlg)); + if ((code = tBufferPutI8(buffer, pHdr->cmprAlg))) return code; } else if (pHdr->fmtVer == 2) { - TAOS_CHECK_RETURN(tBufferPutU32(buffer, pHdr->cmprAlg)); + if ((code = tBufferPutU32(buffer, pHdr->cmprAlg))) return code; } else { // more data fmt ver } if (pHdr->fmtVer >= 1) { - TAOS_CHECK_RETURN(tBufferPutI8(buffer, pHdr->numOfPKs)); + if ((code = tBufferPutI8(buffer, pHdr->numOfPKs))) return code; for (int i = 0; i < pHdr->numOfPKs; i++) { - TAOS_CHECK_RETURN(tPutBlockCol(buffer, &pHdr->primaryBlockCols[i], pHdr->fmtVer, pHdr->cmprAlg)); + if ((code = tPutBlockCol(buffer, &pHdr->primaryBlockCols[i], pHdr->fmtVer, pHdr->cmprAlg))) return code; } } @@ -1098,28 +1560,32 @@ int32_t tPutDiskDataHdr(SBuffer *buffer, const SDiskDataHdr *pHdr) { } int32_t tGetDiskDataHdr(SBufferReader *br, SDiskDataHdr *pHdr) { - TAOS_CHECK_RETURN(tBufferGetU32(br, &pHdr->delimiter)); - TAOS_CHECK_RETURN(tBufferGetU32v(br, &pHdr->fmtVer)); - TAOS_CHECK_RETURN(tBufferGetI64(br, &pHdr->suid)); - TAOS_CHECK_RETURN(tBufferGetI64(br, &pHdr->uid)); - TAOS_CHECK_RETURN(tBufferGetI32v(br, &pHdr->szUid)); - TAOS_CHECK_RETURN(tBufferGetI32v(br, &pHdr->szVer)); - TAOS_CHECK_RETURN(tBufferGetI32v(br, &pHdr->szKey)); - TAOS_CHECK_RETURN(tBufferGetI32v(br, &pHdr->szBlkCol)); - TAOS_CHECK_RETURN(tBufferGetI32v(br, &pHdr->nRow)); + int32_t code; + + if ((code = tBufferGetU32(br, &pHdr->delimiter))) return code; + if ((code = tBufferGetU32v(br, &pHdr->fmtVer))) return code; + if ((code = tBufferGetI64(br, &pHdr->suid))) return code; + if ((code = tBufferGetI64(br, &pHdr->uid))) return code; + if ((code = tBufferGetI32v(br, &pHdr->szUid))) return code; + if ((code = tBufferGetI32v(br, &pHdr->szVer))) return code; + if ((code = tBufferGetI32v(br, &pHdr->szKey))) return code; + if ((code = tBufferGetI32v(br, &pHdr->szBlkCol))) return code; + if ((code = tBufferGetI32v(br, &pHdr->nRow))) return code; if (pHdr->fmtVer < 2) { int8_t cmprAlg = 0; - TAOS_CHECK_RETURN(tBufferGetI8(br, &cmprAlg)); + if ((code = tBufferGetI8(br, &cmprAlg))) return code; pHdr->cmprAlg = cmprAlg; } else if (pHdr->fmtVer == 2) { - TAOS_CHECK_RETURN(tBufferGetU32(br, &pHdr->cmprAlg)); + if ((code = tBufferGetU32(br, &pHdr->cmprAlg))) return code; } else { // more data fmt ver } if (pHdr->fmtVer >= 1) { - TAOS_CHECK_RETURN(tBufferGetI8(br, &pHdr->numOfPKs)); + if ((code = tBufferGetI8(br, &pHdr->numOfPKs))) return code; for (int i = 0; i < pHdr->numOfPKs; i++) { - TAOS_CHECK_RETURN(tGetBlockCol(br, &pHdr->primaryBlockCols[i], pHdr->fmtVer, pHdr->cmprAlg)); + if ((code = tGetBlockCol(br, &pHdr->primaryBlockCols[i], pHdr->fmtVer, pHdr->cmprAlg))) { + return code; + } } } else { pHdr->numOfPKs = 0; @@ -1130,20 +1596,26 @@ int32_t tGetDiskDataHdr(SBufferReader *br, SDiskDataHdr *pHdr) { // ALGORITHM ============================== int32_t tPutColumnDataAgg(SBuffer *buffer, SColumnDataAgg *pColAgg) { - TAOS_CHECK_RETURN(tBufferPutI16v(buffer, pColAgg->colId)); - TAOS_CHECK_RETURN(tBufferPutI16v(buffer, pColAgg->numOfNull)); - TAOS_CHECK_RETURN(tBufferPutI64(buffer, pColAgg->sum)); - TAOS_CHECK_RETURN(tBufferPutI64(buffer, pColAgg->max)); - TAOS_CHECK_RETURN(tBufferPutI64(buffer, pColAgg->min)); + int32_t code; + + if ((code = tBufferPutI16v(buffer, pColAgg->colId))) return code; + if ((code = tBufferPutI16v(buffer, pColAgg->numOfNull))) return code; + if ((code = tBufferPutI64(buffer, pColAgg->sum))) return code; + if ((code = tBufferPutI64(buffer, pColAgg->max))) return code; + if ((code = tBufferPutI64(buffer, pColAgg->min))) return code; + return 0; } int32_t tGetColumnDataAgg(SBufferReader *br, SColumnDataAgg *pColAgg) { - TAOS_CHECK_RETURN(tBufferGetI16v(br, &pColAgg->colId)); - TAOS_CHECK_RETURN(tBufferGetI16v(br, &pColAgg->numOfNull)); - TAOS_CHECK_RETURN(tBufferGetI64(br, &pColAgg->sum)); - TAOS_CHECK_RETURN(tBufferGetI64(br, &pColAgg->max)); - TAOS_CHECK_RETURN(tBufferGetI64(br, &pColAgg->min)); + int32_t code; + + if ((code = tBufferGetI16v(br, &pColAgg->colId))) return code; + if ((code = tBufferGetI16v(br, &pColAgg->numOfNull))) return code; + if ((code = tBufferGetI64(br, &pColAgg->sum))) return code; + if ((code = tBufferGetI64(br, &pColAgg->max))) return code; + if ((code = tBufferGetI64(br, &pColAgg->min))) return code; + return 0; } @@ -1160,7 +1632,8 @@ static int32_t tBlockDataCompressKeyPart(SBlockData *bData, SDiskDataHdr *hdr, S .dataType = TSDB_DATA_TYPE_BIGINT, .originalSize = sizeof(int64_t) * bData->nRow, }; - TAOS_CHECK_GOTO(tCompressDataToBuffer(bData->aUid, &cinfo, buffer, assist), &lino, _exit); + code = tCompressDataToBuffer(bData->aUid, &cinfo, buffer, assist); + TSDB_CHECK_CODE(code, lino, _exit); hdr->szUid = cinfo.compressedSize; } @@ -1170,7 +1643,8 @@ static int32_t tBlockDataCompressKeyPart(SBlockData *bData, SDiskDataHdr *hdr, S .dataType = TSDB_DATA_TYPE_BIGINT, .originalSize = sizeof(int64_t) * bData->nRow, }; - TAOS_CHECK_GOTO(tCompressDataToBuffer((uint8_t *)bData->aVersion, &cinfo, buffer, assist), &lino, _exit); + code = tCompressDataToBuffer((uint8_t *)bData->aVersion, &cinfo, buffer, assist); + TSDB_CHECK_CODE(code, lino, _exit); hdr->szVer = cinfo.compressedSize; // ts @@ -1180,7 +1654,8 @@ static int32_t tBlockDataCompressKeyPart(SBlockData *bData, SDiskDataHdr *hdr, S .originalSize = sizeof(TSKEY) * bData->nRow, }; - TAOS_CHECK_GOTO(tCompressDataToBuffer((uint8_t *)bData->aTSKEY, &cinfo, buffer, assist), &lino, _exit); + code = tCompressDataToBuffer((uint8_t *)bData->aTSKEY, &cinfo, buffer, assist); + TSDB_CHECK_CODE(code, lino, _exit); hdr->szKey = cinfo.compressedSize; // primary keys @@ -1197,9 +1672,14 @@ static int32_t tBlockDataCompressKeyPart(SBlockData *bData, SDiskDataHdr *hdr, S SColDataCompressInfo info = { .cmprAlg = hdr->cmprAlg, }; - TAOS_UNUSED(tsdbGetColCmprAlgFromSet(compressInfo->pColCmpr, colData->cid, &info.cmprAlg)); + code = tsdbGetColCmprAlgFromSet(compressInfo->pColCmpr, colData->cid, &info.cmprAlg); + if (code < 0) { + // do nothing + } else { + } - TAOS_CHECK_GOTO(tColDataCompress(colData, &info, buffer, assist), &lino, _exit); + code = tColDataCompress(colData, &info, buffer, assist); + TSDB_CHECK_CODE(code, lino, _exit); *blockCol = (SBlockCol){ .cid = info.columnId, @@ -1226,8 +1706,8 @@ int32_t tBlockDataDecompressColData(const SDiskDataHdr *hdr, const SBlockCol *bl SColData *colData; - TAOS_CHECK_GOTO(tBlockDataAddColData(blockData, blockCol->cid, blockCol->type, blockCol->cflag, &colData), &lino, - _exit); + code = tBlockDataAddColData(blockData, blockCol->cid, blockCol->type, blockCol->cflag, &colData); + TSDB_CHECK_CODE(code, lino, _exit); // ASSERT(blockCol->flag != HAS_NONE); @@ -1257,7 +1737,8 @@ int32_t tBlockDataDecompressColData(const SDiskDataHdr *hdr, const SBlockCol *bl break; } - TAOS_CHECK_GOTO(tColDataDecompress(BR_PTR(br), &info, colData, assist), &lino, _exit); + code = tColDataDecompress(BR_PTR(br), &info, colData, assist); + TSDB_CHECK_CODE(code, lino, _exit); br->offset += blockCol->szBitmap + blockCol->szOffset + blockCol->szValue; _exit: @@ -1279,8 +1760,10 @@ int32_t tBlockDataDecompressKeyPart(const SDiskDataHdr *hdr, SBufferReader *br, .originalSize = sizeof(int64_t) * hdr->nRow, }; - TAOS_CHECK_GOTO(tRealloc((uint8_t **)&blockData->aUid, cinfo.originalSize), &lino, _exit); - TAOS_CHECK_GOTO(tDecompressData(BR_PTR(br), &cinfo, blockData->aUid, cinfo.originalSize, assist), &lino, _exit); + code = tRealloc((uint8_t **)&blockData->aUid, cinfo.originalSize); + TSDB_CHECK_CODE(code, lino, _exit); + code = tDecompressData(BR_PTR(br), &cinfo, blockData->aUid, cinfo.originalSize, assist); + TSDB_CHECK_CODE(code, lino, _exit); br->offset += cinfo.compressedSize; } @@ -1291,8 +1774,10 @@ int32_t tBlockDataDecompressKeyPart(const SDiskDataHdr *hdr, SBufferReader *br, .compressedSize = hdr->szVer, .originalSize = sizeof(int64_t) * hdr->nRow, }; - TAOS_CHECK_GOTO(tRealloc((uint8_t **)&blockData->aVersion, cinfo.originalSize), &lino, _exit); - TAOS_CHECK_GOTO(tDecompressData(BR_PTR(br), &cinfo, blockData->aVersion, cinfo.originalSize, assist), &lino, _exit); + code = tRealloc((uint8_t **)&blockData->aVersion, cinfo.originalSize); + TSDB_CHECK_CODE(code, lino, _exit); + code = tDecompressData(BR_PTR(br), &cinfo, blockData->aVersion, cinfo.originalSize, assist); + TSDB_CHECK_CODE(code, lino, _exit); br->offset += cinfo.compressedSize; // ts @@ -1302,8 +1787,10 @@ int32_t tBlockDataDecompressKeyPart(const SDiskDataHdr *hdr, SBufferReader *br, .compressedSize = hdr->szKey, .originalSize = sizeof(TSKEY) * hdr->nRow, }; - TAOS_CHECK_GOTO(tRealloc((uint8_t **)&blockData->aTSKEY, cinfo.originalSize), &lino, _exit); - TAOS_CHECK_GOTO(tDecompressData(BR_PTR(br), &cinfo, blockData->aTSKEY, cinfo.originalSize, assist), &lino, _exit); + code = tRealloc((uint8_t **)&blockData->aTSKEY, cinfo.originalSize); + TSDB_CHECK_CODE(code, lino, _exit); + code = tDecompressData(BR_PTR(br), &cinfo, blockData->aTSKEY, cinfo.originalSize, assist); + TSDB_CHECK_CODE(code, lino, _exit); br->offset += cinfo.compressedSize; // primary keys @@ -1313,7 +1800,8 @@ int32_t tBlockDataDecompressKeyPart(const SDiskDataHdr *hdr, SBufferReader *br, ASSERT(blockCol->flag == HAS_VALUE); ASSERT(blockCol->cflag & COL_IS_KEY); - TAOS_CHECK_GOTO(tBlockDataDecompressColData(hdr, blockCol, br, blockData, assist), &lino, _exit); + code = tBlockDataDecompressColData(hdr, blockCol, br, blockData, assist); + TSDB_CHECK_CODE(code, lino, _exit); } _exit: @@ -1321,19 +1809,14 @@ _exit: } int32_t tsdbGetColCmprAlgFromSet(SHashObj *set, int16_t colId, uint32_t *alg) { - if (set == NULL) { - return TSDB_CODE_INVALID_PARA; - } + if (set == NULL) return -1; uint32_t *ret = taosHashGet(set, &colId, sizeof(colId)); - if (ret == NULL) { - return TSDB_CODE_NOT_FOUND; - } + if (ret == NULL) return -1; *alg = *ret; return 0; } - uint32_t tsdbCvtTimestampAlg(uint32_t alg) { DEFINE_VAR(alg)