diff --git a/src/dnode/src/dnodeVRead.c b/src/dnode/src/dnodeVRead.c index cb53bb5e60b1d4f0316c776644e7582af0579ebe..c99cf87b210b9089f32e6e3a71418f8631ec8041 100644 --- a/src/dnode/src/dnodeVRead.c +++ b/src/dnode/src/dnodeVRead.c @@ -202,8 +202,9 @@ static void *dnodeProcessReadQueue(void *param) { break; } - dDebug("%p, msg:%s will be processed in vread queue, qtype:%d", pReadMsg->rpcMsg.ahandle, - taosMsg[pReadMsg->rpcMsg.msgType], type); + dDebug("%p, msg:%s will be processed in vread queue, qtype:%d, msg:%p", pReadMsg->rpcMsg.ahandle, + taosMsg[pReadMsg->rpcMsg.msgType], type, pReadMsg); + int32_t code = vnodeProcessRead(pVnode, pReadMsg); if (type == TAOS_QTYPE_RPC && code != TSDB_CODE_QRY_NOT_READY) { diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h index ece08ae173f171364943a94e1962f90d486f4811..9af4cee28ae2eb11ab24e987cecbf787e7e8fe50 100644 --- a/src/inc/taoserror.h +++ b/src/inc/taoserror.h @@ -219,6 +219,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_QRY_DUP_JOIN_KEY, 0, 0x0705, "Duplicated TAOS_DEFINE_ERROR(TSDB_CODE_QRY_EXCEED_TAGS_LIMIT, 0, 0x0706, "Tag conditon too many") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_NOT_READY, 0, 0x0707, "Query not ready") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_HAS_RSP, 0, 0x0708, "Query should response") +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_IN_EXEC, 0, 0x0709, "Multiple retrieval of this query") // grant TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_EXPIRED, 0, 0x0800, "License expired") diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h index 328078fb600310d1663b9dd3d630ad103075361e..44d5d26f7132efa78a78acb2a8aad7cde73149b3 100644 --- a/src/query/inc/qExecutor.h +++ b/src/query/inc/qExecutor.h @@ -184,8 +184,8 @@ enum { typedef struct SQInfo { void* signature; - int32_t pointsInterpo; - int32_t code; // error code to returned to client + int32_t code; // error code to returned to client + pthread_t owner; // if it is in execution void* tsdb; int32_t vgId; STableGroupInfo tableGroupInfo; // table id list < only includes the STable list> diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c index 613c3ae14cab4c2eeb6c2afffc38b30b7a254004..ac90ca95956323928fd6994e0997f8d572657dd6 100644 --- a/src/query/src/qExecutor.c +++ b/src/query/src/qExecutor.c @@ -2784,6 +2784,7 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) { setWindowResultInfo(pResultInfo, pQuery, pRuntimeEnv->stableQuery, buf); resetMergeResultBuf(pQuery, pRuntimeEnv->pCtx, pResultInfo); + // todo add windowRes iterator int64_t lastTimestamp = -1; int64_t startt = taosGetTimestampMs(); @@ -2791,7 +2792,7 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) { int32_t pos = pTree->pNode[0].index; SWindowResInfo *pWindowResInfo = &pTableList[pos]->windowResInfo; - SWindowResult * pWindowRes = getWindowResult(pWindowResInfo, cs.position[pos]); + SWindowResult *pWindowRes = getWindowResult(pWindowResInfo, cs.position[pos]); tFilePage *page = getResBufPage(pRuntimeEnv->pResultBuf, pWindowRes->pos.pageId); char *b = getPosInResultPage(pRuntimeEnv, PRIMARYKEY_TIMESTAMP_COL_INDEX, pWindowRes, page); @@ -2828,6 +2829,9 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) { lastTimestamp = ts; + // move to the next element of current entry + int32_t currentPageId = pWindowRes->pos.pageId; + cs.position[pos] += 1; if (cs.position[pos] >= pWindowResInfo->size) { cs.position[pos] = -1; @@ -2836,6 +2840,12 @@ int32_t mergeIntoGroupResultImpl(SQInfo *pQInfo, SArray *pGroup) { if (--numOfTables == 0) { break; } + } else { + // current page is not needed anymore + SWindowResult *pNextWindowRes = getWindowResult(pWindowResInfo, cs.position[pos]); + if (pNextWindowRes->pos.pageId != currentPageId) { + releaseResBufPage(pRuntimeEnv->pResultBuf, page); + } } } @@ -5081,8 +5091,6 @@ static void tableIntervalProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) { copyFromWindowResToSData(pQInfo, &pRuntimeEnv->windowResInfo); clearFirstNTimeWindow(pRuntimeEnv, pQInfo->groupIndex); } - - pQInfo->pointsInterpo += numOfFilled; } static void tableQueryImpl(SQInfo *pQInfo) { @@ -6330,16 +6338,24 @@ static bool doBuildResCheck(SQInfo* pQInfo) { pthread_mutex_unlock(&pQInfo->lock); + // clear qhandle owner +// assert(pQInfo->owner == pthread_self()); +// pQInfo->owner = 0; + return buildRes; } bool qTableQuery(qinfo_t qinfo) { SQInfo *pQInfo = (SQInfo *)qinfo; - - if (pQInfo == NULL || pQInfo->signature != pQInfo) { - qDebug("QInfo:%p has been freed, no need to execute", pQInfo); - return false; - } + assert(pQInfo && pQInfo->signature == pQInfo); +// int64_t threadId = pthread_self(); + +// int64_t curOwner = 0; +// if ((curOwner = atomic_val_compare_exchange_64(&pQInfo->owner, 0, threadId)) != 0) { +// qError("QInfo:%p qhandle is now executed by thread:%p", pQInfo, (void*) curOwner); +// pQInfo->code = TSDB_CODE_QRY_IN_EXEC; +// return false; +// } if (IS_QUERY_KILLED(pQInfo)) { qDebug("QInfo:%p it is already killed, abort", pQInfo); diff --git a/src/query/src/qResultbuf.c b/src/query/src/qResultbuf.c index a5770709706e019af322d6a6689f956afa3e82aa..8235bd7b1f7a7e75c8ca2d6e621ddba3db155007 100644 --- a/src/query/src/qResultbuf.c +++ b/src/query/src/qResultbuf.c @@ -186,7 +186,7 @@ static char* loadPageFromDisk(SDiskbasedResultBuf* pResultBuf, SPageInfo* pg) { return GET_DATA_PAYLOAD(pg); } -#define NO_AVAILABLE_PAGES(_b) ((_b)->numOfPages >= (_b)->inMemPages) +#define NO_IN_MEM_AVAILABLE_PAGES(_b) (listNEles((_b)->lruList) >= (_b)->inMemPages) static SIDList addNewGroup(SDiskbasedResultBuf* pResultBuf, int32_t groupId) { assert(taosHashGet(pResultBuf->groupSet, (const char*) &groupId, sizeof(int32_t)) == NULL); @@ -281,7 +281,7 @@ tFilePage* getNewDataBuf(SDiskbasedResultBuf* pResultBuf, int32_t groupId, int32 pResultBuf->statis.getPages += 1; char* availablePage = NULL; - if (NO_AVAILABLE_PAGES(pResultBuf)) { + if (NO_IN_MEM_AVAILABLE_PAGES(pResultBuf)) { availablePage = evicOneDataPage(pResultBuf); } @@ -340,7 +340,7 @@ tFilePage* getResBufPage(SDiskbasedResultBuf* pResultBuf, int32_t id) { assert((*pi)->pData == NULL && (*pi)->pn == NULL && (*pi)->info.length >= 0 && (*pi)->info.offset >= 0); char* availablePage = NULL; - if (NO_AVAILABLE_PAGES(pResultBuf)) { + if (NO_IN_MEM_AVAILABLE_PAGES(pResultBuf)) { availablePage = evicOneDataPage(pResultBuf); } @@ -396,12 +396,13 @@ void destroyResultBuf(SDiskbasedResultBuf* pResultBuf) { } if (pResultBuf->file != NULL) { - qDebug("QInfo:%p disk-based output buffer closed, total:%" PRId64 " bytes, file size:%"PRId64" bytes", - pResultBuf->handle, pResultBuf->totalBufSize, pResultBuf->fileSize); + qDebug("QInfo:%p res output buffer closed, total:%" PRId64 " bytes, inmem size:%dbytes, file size:%"PRId64" bytes", + pResultBuf->handle, pResultBuf->totalBufSize, listNEles(pResultBuf->lruList) * pResultBuf->pageSize, + pResultBuf->fileSize); fclose(pResultBuf->file); } else { - qDebug("QInfo:%p disk-based output buffer closed, total:%" PRId64 " bytes, no file created", pResultBuf->handle, + qDebug("QInfo:%p res output buffer closed, total:%" PRId64 " bytes, no file created", pResultBuf->handle, pResultBuf->totalBufSize); } diff --git a/src/util/inc/hash.h b/src/util/inc/hash.h index 71493788acff2cb57ded10492e4b5db33c23e8ca..f289a4e8c366c6569ce6f7db1ceaef350be3478b 100644 --- a/src/util/inc/hash.h +++ b/src/util/inc/hash.h @@ -32,7 +32,7 @@ typedef void (*_hash_free_fn_t)(void *param); typedef struct SHashNode { char *key; - struct SHashNode *prev; +// struct SHashNode *prev; struct SHashNode *next; uint32_t hashVal; // the hash value of key, if hashVal == HASH_VALUE_IN_TRASH, this node is moved to trash uint32_t keyLen; // length of the key @@ -47,7 +47,7 @@ typedef enum SHashLockTypeE { typedef struct SHashEntry { int32_t num; // number of elements in current entry SRWLatch latch; // entry latch - SHashNode head; // dummy head + SHashNode *next; } SHashEntry; typedef struct SHashObj { diff --git a/src/util/src/hash.c b/src/util/src/hash.c index 71a51c4cea2b2b73fcfff42216a79e752e4839ae..8c74db008203a054a53c19581b4186c78167b981 100644 --- a/src/util/src/hash.c +++ b/src/util/src/hash.c @@ -20,12 +20,21 @@ #define HASH_NEED_RESIZE(_h) ((_h)->size >= (_h)->capacity * HASH_DEFAULT_LOAD_FACTOR) -#define FREE_HASH_NODE(_n) \ - do { \ - taosTFree((_n)->data); \ - taosTFree(_n); \ +#define DO_FREE_HASH_NODE(_n) \ + do { \ + taosTFree((_n)->data); \ + taosTFree(_n); \ } while (0) +#define FREE_HASH_NODE(_h, _n) \ + do { \ + if ((_h)->freeFp) { \ + (_h)->freeFp((_n)->data); \ + } \ + \ + DO_FREE_HASH_NODE(_n); \ + } while (0); + static FORCE_INLINE void __wr_lock(void *lock, int32_t type) { if (type == HASH_NO_LOCK) { return; @@ -65,17 +74,8 @@ static FORCE_INLINE int32_t taosHashCapacity(int32_t length) { return i; } -/** - * Get SHashNode from hashlist, nodes from trash are not included. - * @param pHashObj Cache objection - * @param key key for hash - * @param keyLen key length - * @param hashVal hash value by hash function - * @return - */ - static FORCE_INLINE SHashNode *doSearchInEntryList(SHashEntry *pe, const void *key, size_t keyLen, uint32_t hashVal) { - SHashNode *pNode = pe->head.next; + SHashNode *pNode = pe->next; while (pNode) { if ((pNode->keyLen == keyLen) && (memcmp(pNode->key, key, keyLen) == 0)) { assert(pNode->hashVal == hashVal); @@ -88,28 +88,21 @@ static FORCE_INLINE SHashNode *doSearchInEntryList(SHashEntry *pe, const void *k return pNode; } -static FORCE_INLINE SHashNode *doGetNodeFromHashTable(SHashObj *pHashObj, const void *key, uint32_t keyLen, - uint32_t hashVal) { - int32_t slot = HASH_INDEX(hashVal, pHashObj->capacity); +static FORCE_INLINE SHashNode *doSerchPrevInEntryList(SHashEntry *pe, const void *key, size_t keyLen, uint32_t hashVal) { + SHashNode *prev= NULL; + SHashNode *pNode = pe->next; - SHashEntry *pe = pHashObj->hashList[slot]; - - // no data, return directly - if (atomic_load_32(&pe->num) == 0) { - return NULL; - } - - if (pHashObj->type == HASH_ENTRY_LOCK) { - taosRLockLatch(&pe->latch); - } - - SHashNode *pNode = doSearchInEntryList(pe, key, keyLen, hashVal); + while (pNode) { + if ((pNode->keyLen == keyLen) && (memcmp(pNode->key, key, keyLen) == 0)) { + assert(pNode->hashVal == hashVal); + break; + } - if (pHashObj->type == HASH_ENTRY_LOCK) { - taosRUnLockLatch(&pe->latch); + prev = pNode; + pNode = pNode->next; } - return pNode; + return prev; } /** @@ -153,7 +146,7 @@ static FORCE_INLINE SHashNode *doUpdateHashNode(SHashNode *pNode, SHashNode *pNe * @param pHashObj * @param pNode */ -static void pushfrontNode(SHashEntry *pEntry, SHashNode *pNode); +static void pushfrontNodeInEntryList(SHashEntry *pEntry, SHashNode *pNode); /** * Get the next element in hash table for iterator @@ -225,7 +218,13 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *da taosWLockLatch(&pe->latch); } - SHashNode *pNode = pe->head.next; + SHashNode *pNode = pe->next; + if (pe->num > 0) { + assert(pNode != NULL); + } else { + assert(pNode == NULL); + } + while (pNode) { if ((pNode->keyLen == keyLen) && (memcmp(pNode->key, key, keyLen) == 0)) { assert(pNode->hashVal == hashVal); @@ -237,7 +236,7 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *da if (pNode == NULL) { // no data in hash table with the specified key, add it into hash table - pushfrontNode(pe, pNewNode); + pushfrontNodeInEntryList(pe, pNewNode); if (pHashObj->type == HASH_ENTRY_LOCK) { taosWUnLockLatch(&pe->latch); @@ -261,7 +260,7 @@ int32_t taosHashPut(SHashObj *pHashObj, const void *key, size_t keyLen, void *da // enable resize __rd_unlock(&pHashObj->lock, pHashObj->type); - FREE_HASH_NODE(pNewNode); + DO_FREE_HASH_NODE(pNewNode); return pHashObj->enableUpdate ? 0 : -1; } } @@ -301,6 +300,7 @@ void *taosHashGetCB(SHashObj *pHashObj, const void *key, size_t keyLen, void (*f if (fp != NULL) { fp(pNode->data); } + data = pNode->data; } @@ -316,13 +316,12 @@ int32_t taosHashRemove(SHashObj *pHashObj, const void *key, size_t keyLen) { return taosHashRemoveWithData(pHashObj, key, keyLen, NULL, 0); } -static FORCE_INLINE void doPopFromEntryList(SHashEntry *pe, SHashNode *pNode) { +static FORCE_INLINE void doPopNextFromEntryList(SHashEntry *pe, SHashNode *pNode) { SHashNode *pNext = pNode->next; - - assert(pNode->prev != NULL); - pNode->prev->next = pNext; if (pNext != NULL) { - pNext->prev = pNode->prev; + pNode->next = pNext->next; + } else { + pNode->next = NULL; } pe->num -= 1; @@ -351,9 +350,27 @@ int32_t taosHashRemoveWithData(SHashObj *pHashObj, const void *key, size_t keyLe taosWLockLatch(&pe->latch); } - SHashNode *pNode = doSearchInEntryList(pe, key, keyLen, hashVal); - if (pNode != NULL) { - doPopFromEntryList(pe, pNode); + SHashNode *pNode = pe->next; + SHashNode *pRes = NULL; + // remove it + if ((pNode->keyLen == keyLen) && (memcmp(pNode->key, key, keyLen) == 0)) { + pe->next = pNode->next; + pRes = pNode; + } else { + while (pNode->next != NULL) { + if (((pNode->next)->keyLen == keyLen) && (memcmp((pNode->next)->key, key, keyLen) == 0)) { + assert((pNode->next)->hashVal == hashVal); + break; + } + + pNode = pNode->next; + } + + + if (pNode->next != NULL) { + pRes = pNode->next; + pNode->next = pNode->next->next; + } } if (pHashObj->type == HASH_ENTRY_LOCK) { @@ -362,18 +379,14 @@ int32_t taosHashRemoveWithData(SHashObj *pHashObj, const void *key, size_t keyLe __rd_unlock(&pHashObj->lock, pHashObj->type); - if (data != NULL) { - memcpy(data, pNode->data, dsize); + if (data != NULL && pRes != NULL) { + memcpy(data, pRes->data, dsize); } - if (pNode != NULL) { + if (pRes != NULL) { + pe->num -= 1; atomic_sub_fetch_64(&pHashObj->size, 1); - - pNode->next = NULL; - pNode->prev = NULL; - - FREE_HASH_NODE(pNode); - + FREE_HASH_NODE(pHashObj, pRes); return 0; } else { return -1; @@ -391,7 +404,7 @@ int32_t taosHashCondTraverse(SHashObj *pHashObj, bool (*fp)(void *, void *), voi int32_t numOfEntries = pHashObj->capacity; for (int32_t i = 0; i < numOfEntries; ++i) { SHashEntry *pEntry = pHashObj->hashList[i]; - if (pEntry->num <= 0) { + if (pEntry->num == 0) { continue; } @@ -399,20 +412,35 @@ int32_t taosHashCondTraverse(SHashObj *pHashObj, bool (*fp)(void *, void *), voi taosWLockLatch(&pEntry->latch); } - SHashNode *pNode = pEntry->head.next; - assert(pNode != NULL); - - SHashNode *pNext = NULL; - while (pNode != NULL) { - pNext = pNode->next; - - // not qualified, remove it + // todo remove first node + SHashNode *pNode = NULL; + while((pNode = pEntry->next) != NULL) { if (fp && (!fp(param, pNode->data))) { - doPopFromEntryList(pEntry, pNode); - FREE_HASH_NODE(pNode); + pEntry->num -= 1; + pEntry->next = pNode->next; + + FREE_HASH_NODE(pHashObj, pNode); + } else { + break; } + } + + // handle the following node + if (pNode != NULL) { + assert(pNode == pEntry->next); + SHashNode *pNext = NULL; - pNode = pNext; + while ((pNext = pNode->next) != NULL) { + // not qualified, remove it + if (fp && (!fp(param, pNext->data))) { + pNode->next = pNext->next; + pEntry->num -= 1; + + FREE_HASH_NODE(pHashObj, pNext); + } else { + pNode = pNext; + } + } } if (pHashObj->type == HASH_ENTRY_LOCK) { @@ -437,18 +465,15 @@ void taosHashCleanup(SHashObj *pHashObj) { for (int32_t i = 0; i < pHashObj->capacity; ++i) { SHashEntry *pEntry = pHashObj->hashList[i]; if (pEntry->num == 0) { - assert(pEntry->head.next == 0); + assert(pEntry->next == 0); continue; } - pNode = pEntry->head.next; + pNode = pEntry->next; while (pNode) { pNext = pNode->next; - if (pHashObj->freeFp) { - pHashObj->freeFp(pNode->data); - } + FREE_HASH_NODE(pHashObj, pNode); - FREE_HASH_NODE(pNode); pNode = pNext; } } @@ -501,6 +526,8 @@ bool taosHashIterNext(SHashMutableIterator *pIter) { while (1) { SHashEntry *pEntry = pIter->pHashObj->hashList[pIter->entryIndex]; if (pEntry->num == 0) { + assert(pEntry->next == NULL); + pIter->entryIndex++; continue; } @@ -509,7 +536,7 @@ bool taosHashIterNext(SHashMutableIterator *pIter) { taosRLockLatch(&pEntry->latch); } - pIter->pCur = pEntry->head.next; + pIter->pCur = pEntry->next; if (pIter->pCur->next) { pIter->pNext = pIter->pCur->next; @@ -595,7 +622,7 @@ void taosHashTableResize(SHashObj *pHashObj) { return; } - void *pNewEntryList = realloc(pHashObj->hashList, sizeof(SHashEntry) * newSize); + void *pNewEntryList = realloc(pHashObj->hashList, sizeof(void*) * newSize); if (pNewEntryList == NULL) { // todo handle error // uDebug("cache resize failed due to out of memory, capacity remain:%d", pHashObj->capacity); return; @@ -616,33 +643,39 @@ void taosHashTableResize(SHashObj *pHashObj) { for (int32_t i = 0; i < pHashObj->capacity; ++i) { SHashEntry *pe = pHashObj->hashList[i]; if (pe->num == 0) { - assert(pe->head.next == NULL); + assert(pe->next == NULL); continue; } - pNode = pe->head.next; - while (pNode) { + while ((pNode = pe->next) != NULL) { int32_t j = HASH_INDEX(pNode->hashVal, pHashObj->capacity); - if (j == i) { // this key locates in the same slot, no need to relocate it - pNode = pNode->next; - } else { - pNext = pNode->next; - assert(pNode != pNext && (pNext == NULL || pNext->prev == pNode) && pNode->prev->next == pNode); - - doPopFromEntryList(pe, pNode); - - // clear pointer - pNode->next = NULL; - pNode->prev = NULL; + if (j != i) { + pe->num -= 1; + pe->next = pNode->next; - // added into new slot SHashEntry *pNewEntry = pHashObj->hashList[j]; - pushfrontNode(pNewEntry, pNode); + pushfrontNodeInEntryList(pNewEntry, pNode); + } else { + break; + } + } - // continue - pNode = pNext; + if (pNode != NULL) { + while ((pNext = pNode->next) != NULL) { + int32_t j = HASH_INDEX(pNext->hashVal, pHashObj->capacity); + if (j != i) { + pNode->next = pNext->next; + pNext->next = NULL; + + // added into new slot + SHashEntry *pNewEntry = pHashObj->hashList[j]; + pushfrontNodeInEntryList(pNewEntry, pNext); + } else { + pNode = pNext; + } } } + } // uDebug("hash table resize completed, new capacity:%d, load factor:%f, elapsed time:%fms", pHashObj->capacity, @@ -668,17 +701,11 @@ SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *pData, s return pNewNode; } -void pushfrontNode(SHashEntry *pEntry, SHashNode *pNode) { +void pushfrontNodeInEntryList(SHashEntry *pEntry, SHashNode *pNode) { assert(pNode != NULL && pEntry != NULL); - SHashNode *pNext = pEntry->head.next; - if (pNext != NULL) { - pNext->prev = pNode; - } - - pNode->next = pNext; - pNode->prev = &pEntry->head; - pEntry->head.next = pNode; + pNode->next = pEntry->next; + pEntry->next = pNode; pEntry->num += 1; } @@ -700,7 +727,7 @@ SHashNode *getNextHashNode(SHashMutableIterator *pIter) { taosRLockLatch(&pEntry->latch); } - p = pEntry->head.next; + p = pEntry->next; if (pIter->pHashObj->type == HASH_ENTRY_LOCK) { taosRUnLockLatch(&pEntry->latch); diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c index 3c642b509854c26f06d253abf56aff5274836cf5..3cf5c1382f1a261a688315901e7de917becb9e71 100644 --- a/src/vnode/src/vnodeRead.c +++ b/src/vnode/src/vnodeRead.c @@ -74,6 +74,8 @@ static void vnodePutItemIntoReadQueue(SVnodeObj *pVnode, void *qhandle) { pRead->rpcMsg.handle = NULL; atomic_add_fetch_32(&pVnode->refCount, 1); + + vDebug("QInfo:%p add to query task queue for exec, msg:%p", qhandle, pRead); taosWriteQitem(pVnode->rqueue, TAOS_QTYPE_QUERY, pRead); } @@ -83,7 +85,6 @@ static int32_t vnodeDumpQueryResult(SRspRet *pRet, void* pVnode, void* handle, b int32_t code = TSDB_CODE_SUCCESS; if ((code = qDumpRetrieveResult(handle, (SRetrieveTableRsp **)&pRet->rsp, &pRet->len, &continueExec)) == TSDB_CODE_SUCCESS) { if (continueExec) { - vDebug("QInfo:%p add to query task queue for exec", handle); vnodePutItemIntoReadQueue(pVnode, handle); pRet->qhandle = handle; *freeHandle = false;