[td-169] fix limit offset error for table projection/diff query
This commit is contained in:
hjxilinx
parent
e591a3eb2f
commit
3f24ff44e0
|
|
@ -16,17 +16,17 @@
|
|||
|
||||
#include "hash.h"
|
||||
#include "hashfunc.h"
|
||||
#include "qast.h"
|
||||
#include "qresultBuf.h"
|
||||
#include "query.h"
|
||||
#include "queryExecutor.h"
|
||||
#include "queryLog.h"
|
||||
#include "queryUtil.h"
|
||||
#include "taosmsg.h"
|
||||
#include "tlosertree.h"
|
||||
#include "tscompression.h"
|
||||
#include "ttime.h"
|
||||
#include "qast.h"
|
||||
#include "qresultBuf.h"
|
||||
#include "queryExecutor.h"
|
||||
#include "queryUtil.h"
|
||||
#include "query.h"
|
||||
#include "tsdbMain.h" //todo use TableId instead of STable object
|
||||
#include "queryLog.h"
|
||||
#include "ttime.h"
|
||||
|
||||
#define DEFAULT_INTERN_BUF_SIZE 16384L
|
||||
|
||||
|
|
@ -53,8 +53,7 @@
|
|||
/* get the qinfo struct address from the query struct address */
|
||||
#define GET_COLUMN_BYTES(query, colidx) \
|
||||
((query)->colList[(query)->pSelectExpr[colidx].pBase.colInfo.colIndex].info.bytes)
|
||||
#define GET_COLUMN_TYPE(query, colidx) \
|
||||
((query)->colList[(query)->pSelectExpr[colidx].pBase.colInfo.colIndex].info.type)
|
||||
#define GET_COLUMN_TYPE(query, colidx) ((query)->colList[(query)->pSelectExpr[colidx].pBase.colInfo.colIndex].info.type)
|
||||
|
||||
typedef struct SPointInterpoSupporter {
|
||||
int32_t numOfCols;
|
||||
|
|
@ -93,7 +92,7 @@ typedef struct {
|
|||
int32_t status; // query status
|
||||
TSKEY lastKey; // the lastKey value before query executed
|
||||
STimeWindow w; // whole query time window
|
||||
STimeWindow current; // current query window
|
||||
STimeWindow curWindow; // current query window
|
||||
int32_t windowIndex; // index of active time window result for interval query
|
||||
STSCursor cur;
|
||||
} SQueryStatusInfo;
|
||||
|
|
@ -865,9 +864,9 @@ char *getDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, SArithmeticSupport *sas, int3
|
|||
dataBlock = NULL;
|
||||
} else {
|
||||
/*
|
||||
* the colIndex is acquired from the first meter of all qualified meters in this vnode during query prepare stage,
|
||||
* the remain meter may not have the required column in cache actually.
|
||||
* So, the validation of required column in cache with the corresponding meter schema is reinforced.
|
||||
* the colIndex is acquired from the first meter of all qualified meters in this vnode during query prepare
|
||||
* stage, the remain meter may not have the required column in cache actually. So, the validation of required
|
||||
* column in cache with the corresponding meter schema is reinforced.
|
||||
*/
|
||||
if (pDataBlock == NULL) {
|
||||
return NULL;
|
||||
|
|
@ -911,7 +910,6 @@ static void blockwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStati
|
|||
primaryKeyCol = (TSKEY *)(pColInfo->pData);
|
||||
}
|
||||
|
||||
pQuery->pos = QUERY_IS_ASC_QUERY(pQuery) ? 0 : pDataBlockInfo->rows - 1;
|
||||
SArithmeticSupport *sasArray = calloc((size_t)pQuery->numOfOutputCols, sizeof(SArithmeticSupport));
|
||||
|
||||
for (int32_t k = 0; k < pQuery->numOfOutputCols; ++k) {
|
||||
|
|
@ -922,8 +920,8 @@ static void blockwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStati
|
|||
bool hasNull = hasNullValue(pQuery, k, pDataBlockInfo, pStatis, &tpField);
|
||||
char *dataBlock = getDataBlocks(pRuntimeEnv, &sasArray[k], k, pDataBlockInfo->rows, pDataBlock);
|
||||
|
||||
setExecParams(pQuery, &pCtx[k], dataBlock, primaryKeyCol, pDataBlockInfo->rows, functionId, tpField,
|
||||
hasNull, &sasArray[k], pRuntimeEnv->scanFlag);
|
||||
setExecParams(pQuery, &pCtx[k], dataBlock, primaryKeyCol, pDataBlockInfo->rows, functionId, tpField, hasNull,
|
||||
&sasArray[k], pRuntimeEnv->scanFlag);
|
||||
}
|
||||
|
||||
int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
|
||||
|
|
@ -1131,8 +1129,8 @@ static int32_t rowwiseApplyAllFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStat
|
|||
bool hasNull = hasNullValue(pQuery, k, pDataBlockInfo, pStatis, &pColStatis);
|
||||
char *dataBlock = getDataBlocks(pRuntimeEnv, &sasArray[k], k, pDataBlockInfo->rows, pDataBlock);
|
||||
|
||||
setExecParams(pQuery, &pCtx[k], dataBlock, primaryKeyCol, pDataBlockInfo->rows, functionId, pColStatis,
|
||||
hasNull, &sasArray[k], pRuntimeEnv->scanFlag);
|
||||
setExecParams(pQuery, &pCtx[k], dataBlock, primaryKeyCol, pDataBlockInfo->rows, functionId, pColStatis, hasNull,
|
||||
&sasArray[k], pRuntimeEnv->scanFlag);
|
||||
}
|
||||
|
||||
// set the input column data
|
||||
|
|
@ -1308,8 +1306,8 @@ static UNUSED_FUNC int32_t reviseForwardSteps(SQueryRuntimeEnv *pRuntimeEnv, int
|
|||
}
|
||||
|
||||
static int32_t tableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBlockInfo *pDataBlockInfo,
|
||||
SDataStatis *pStatis, __block_search_fn_t searchFn, SWindowResInfo *pWindowResInfo, SArray *pDataBlock) {
|
||||
|
||||
SDataStatis *pStatis, __block_search_fn_t searchFn,
|
||||
SWindowResInfo *pWindowResInfo, SArray *pDataBlock) {
|
||||
SQuery *pQuery = pRuntimeEnv->pQuery;
|
||||
|
||||
if (pQuery->numOfFilterCols > 0 || pRuntimeEnv->pTSBuf != NULL || isGroupbyNormalCol(pQuery->pGroupbyExpr)) {
|
||||
|
|
@ -1360,15 +1358,19 @@ void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void *inputData, TSKEY
|
|||
pCtx->preAggVals.isSet = false;
|
||||
}
|
||||
|
||||
if ((aAggs[functionId].nStatus & TSDB_FUNCSTATE_SELECTIVITY) != 0 && (tsCol != NULL)) {
|
||||
pCtx->ptsList = tsCol;
|
||||
pCtx->startOffset = QUERY_IS_ASC_QUERY(pQuery)? pQuery->pos : 0;
|
||||
pCtx->size = QUERY_IS_ASC_QUERY(pQuery)? size - pQuery->pos : pQuery->pos + 1;
|
||||
|
||||
uint32_t status = aAggs[functionId].nStatus;
|
||||
if (((status & (TSDB_FUNCSTATE_SELECTIVITY | TSDB_FUNCSTATE_NEED_TS)) != 0) && (tsCol != NULL)) {
|
||||
pCtx->ptsList = &tsCol[pCtx->startOffset];
|
||||
}
|
||||
|
||||
if (functionId >= TSDB_FUNC_FIRST_DST && functionId <= TSDB_FUNC_LAST_DST) {
|
||||
// last_dist or first_dist function
|
||||
// store the first&last timestamp into the intermediate buffer [1], the true
|
||||
// value may be null but timestamp will never be null
|
||||
pCtx->ptsList = tsCol;
|
||||
// pCtx->ptsList = tsCol;
|
||||
} else if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_TWA ||
|
||||
functionId == TSDB_FUNC_DIFF || (functionId >= TSDB_FUNC_RATE && functionId <= TSDB_FUNC_AVG_IRATE)) {
|
||||
/*
|
||||
|
|
@ -1384,15 +1386,12 @@ void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void *inputData, TSKEY
|
|||
pTWAInfo->EKey = pQuery->window.ekey;
|
||||
}
|
||||
|
||||
pCtx->ptsList = tsCol;
|
||||
// pCtx->ptsList = tsCol;
|
||||
|
||||
} else if (functionId == TSDB_FUNC_ARITHM) {
|
||||
pCtx->param[1].pz = param;
|
||||
}
|
||||
|
||||
pCtx->startOffset = 0;
|
||||
pCtx->size = size;
|
||||
|
||||
#if defined(_DEBUG_VIEW)
|
||||
// int64_t *tsList = (int64_t *)primaryColumnData;
|
||||
// int64_t s = tsList[0];
|
||||
|
|
@ -1446,7 +1445,7 @@ static void setWindowResultInfo(SResultInfo *pResultInfo, SQuery *pQuery, bool i
|
|||
}
|
||||
}
|
||||
|
||||
static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, SColumnModel *pTagsSchema, int16_t order) {
|
||||
static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int16_t order) {
|
||||
qTrace("QInfo:%p setup runtime env", GET_QINFO_ADDR(pRuntimeEnv));
|
||||
SQuery *pQuery = pRuntimeEnv->pQuery;
|
||||
|
||||
|
|
@ -1583,9 +1582,7 @@ static bool isQueryKilled(SQInfo *pQInfo) {
|
|||
#endif
|
||||
}
|
||||
|
||||
static void setQueryKilled(SQInfo* pQInfo) {
|
||||
pQInfo->code = TSDB_CODE_QUERY_CANCELLED;
|
||||
}
|
||||
static void setQueryKilled(SQInfo *pQInfo) { pQInfo->code = TSDB_CODE_QUERY_CANCELLED; }
|
||||
|
||||
bool isFixedOutputQuery(SQuery *pQuery) {
|
||||
if (pQuery->intervalTime != 0) {
|
||||
|
|
@ -1679,8 +1676,8 @@ static bool needReverseScan(SQuery *pQuery) {
|
|||
}
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void getAlignQueryTimeWindow(SQuery *pQuery, int64_t key, int64_t keyFirst, int64_t keyLast,
|
||||
int64_t *realSkey, int64_t *realEkey, STimeWindow *win) {
|
||||
void getAlignQueryTimeWindow(SQuery *pQuery, int64_t key, int64_t keyFirst, int64_t keyLast, int64_t *realSkey,
|
||||
int64_t *realEkey, STimeWindow *win) {
|
||||
assert(key >= keyFirst && key <= keyLast && pQuery->slidingTime <= pQuery->intervalTime);
|
||||
|
||||
win->skey = taosGetIntervalStartTimestamp(key, pQuery->slidingTime, pQuery->slidingTimeUnit, pQuery->precision);
|
||||
|
|
@ -2374,8 +2371,8 @@ SArray *loadDataBlockOnDemand(SQueryRuntimeEnv *pRuntimeEnv, SDataBlockInfo *pBl
|
|||
}
|
||||
|
||||
if (r == BLK_DATA_NO_NEEDED) {
|
||||
qTrace("QInfo:%p slot:%d, data block ignored, brange:%" PRId64 "-%" PRId64 ", rows:%d",
|
||||
GET_QINFO_ADDR(pRuntimeEnv), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
|
||||
qTrace("QInfo:%p slot:%d, data block ignored, brange:%" PRId64 "-%" PRId64 ", rows:%d", GET_QINFO_ADDR(pRuntimeEnv),
|
||||
pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
|
||||
} else if (r == BLK_DATA_FILEDS_NEEDED) {
|
||||
if (tsdbRetrieveDataBlockStatisInfo(pRuntimeEnv->pQueryHandle, pStatis) != TSDB_CODE_SUCCESS) {
|
||||
// return DISK_DATA_LOAD_FAILED;
|
||||
|
|
@ -2477,9 +2474,9 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
|
|||
qTrace("QInfo:%p query start, qrange:%" PRId64 "-%" PRId64 ", lastkey:%" PRId64 ", order:%d",
|
||||
GET_QINFO_ADDR(pRuntimeEnv), pQuery->window.skey, pQuery->window.ekey, pQuery->lastKey, pQuery->order.order);
|
||||
|
||||
TsdbQueryHandleT pQueryHandle = pRuntimeEnv->scanFlag == MASTER_SCAN? pRuntimeEnv->pQueryHandle:pRuntimeEnv->pSecQueryHandle;
|
||||
TsdbQueryHandleT pQueryHandle =
|
||||
pRuntimeEnv->scanFlag == MASTER_SCAN ? pRuntimeEnv->pQueryHandle : pRuntimeEnv->pSecQueryHandle;
|
||||
while (tsdbNextDataBlock(pQueryHandle)) {
|
||||
|
||||
if (isQueryKilled(GET_QINFO_ADDR(pRuntimeEnv))) {
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -2493,8 +2490,8 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
|
|||
SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
|
||||
|
||||
if (QUERY_IS_ASC_QUERY(pQuery)) {
|
||||
getAlignQueryTimeWindow(pQuery, blockInfo.window.skey, blockInfo.window.skey, pQuery->window.ekey,
|
||||
&skey1, &ekey1, &w);
|
||||
getAlignQueryTimeWindow(pQuery, blockInfo.window.skey, blockInfo.window.skey, pQuery->window.ekey, &skey1,
|
||||
&ekey1, &w);
|
||||
pWindowResInfo->startTime = w.skey;
|
||||
pWindowResInfo->prevSKey = w.skey;
|
||||
} else {
|
||||
|
|
@ -2534,11 +2531,13 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
|
|||
|
||||
SDataStatis *pStatis = NULL;
|
||||
SArray * pDataBlock = loadDataBlockOnDemand(pRuntimeEnv, &blockInfo, &pStatis);
|
||||
|
||||
pQuery->pos = QUERY_IS_ASC_QUERY(pQuery) ? 0 : blockInfo.rows - 1;
|
||||
int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, &blockInfo, pStatis, binarySearchForKey,
|
||||
&pRuntimeEnv->windowResInfo, pDataBlock);
|
||||
|
||||
qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", rows:%d, res:%d",
|
||||
GET_QINFO_ADDR(pRuntimeEnv), blockInfo.window.skey, blockInfo.window.ekey, blockInfo.rows, numOfRes);
|
||||
qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", rows:%d, res:%d", GET_QINFO_ADDR(pRuntimeEnv),
|
||||
blockInfo.window.skey, blockInfo.window.ekey, blockInfo.rows, numOfRes);
|
||||
|
||||
// save last access position
|
||||
if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL)) {
|
||||
|
|
@ -2600,7 +2599,6 @@ void setTagVal(SQueryRuntimeEnv *pRuntimeEnv, STableId id, void* tsdb) {
|
|||
continue;
|
||||
}
|
||||
|
||||
|
||||
// todo use tag column index to optimize performance
|
||||
doSetTagValueInParam(tsdb, id, pCol->colId, &pRuntimeEnv->pCtx[idx].tag);
|
||||
}
|
||||
|
|
@ -2835,8 +2833,8 @@ int32_t mergeIntoGroupResult(SQInfo *pQInfo) {
|
|||
qTrace("QInfo:%p no result in group %d, continue", pQInfo, pQInfo->groupIndex - 1);
|
||||
}
|
||||
|
||||
qTrace("QInfo:%p merge res data into group, index:%d, total group:%d, elapsed time:%lldms",
|
||||
pQInfo, pQInfo->groupIndex - 1, numOfGroups, taosGetTimestampMs() - st);
|
||||
qTrace("QInfo:%p merge res data into group, index:%d, total group:%d, elapsed time:%lldms", pQInfo,
|
||||
pQInfo->groupIndex - 1, numOfGroups, taosGetTimestampMs() - st);
|
||||
|
||||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
|
@ -3175,7 +3173,8 @@ void disableFuncForReverseScan(SQInfo *pQInfo, int32_t order) {
|
|||
void switchCtxOrder(SQueryRuntimeEnv *pRuntimeEnv) {
|
||||
SQuery *pQuery = pRuntimeEnv->pQuery;
|
||||
for (int32_t i = 0; i < pQuery->numOfOutputCols; ++i) {
|
||||
SWITCH_ORDER(pRuntimeEnv->pCtx[i].order);// = (pRuntimeEnv->pCtx[i].order == TSDB_ORDER_ASC)? TSDB_ORDER_DESC:TSDB_ORDER_ASC;
|
||||
SWITCH_ORDER(pRuntimeEnv->pCtx[i]
|
||||
.order); // = (pRuntimeEnv->pCtx[i].order == TSDB_ORDER_ASC)? TSDB_ORDER_DESC:TSDB_ORDER_ASC;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3353,6 +3352,7 @@ static SQueryStatusInfo getQueryStatusInfo(SQueryRuntimeEnv* pRuntimeEnv) {
|
|||
.windowIndex = pRuntimeEnv->windowResInfo.curIndex,
|
||||
.lastKey = pQuery->lastKey,
|
||||
.w = pQuery->window,
|
||||
.curWindow = {.skey = pQuery->lastKey, .ekey = pQuery->window.ekey},
|
||||
};
|
||||
|
||||
return info;
|
||||
|
|
@ -3362,9 +3362,6 @@ static void setEnvBeforeReverseScan(SQueryRuntimeEnv* pRuntimeEnv, SQueryStatusI
|
|||
SQInfo *pQInfo = GET_QINFO_ADDR(pRuntimeEnv);
|
||||
SQuery *pQuery = pRuntimeEnv->pQuery;
|
||||
|
||||
// the step should be placed before order changed
|
||||
int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
|
||||
|
||||
pStatus->cur = tsBufGetCursor(pRuntimeEnv->pTSBuf); // save the cursor
|
||||
if (pRuntimeEnv->pTSBuf) {
|
||||
SWITCH_ORDER(pRuntimeEnv->pTSBuf->cur.order);
|
||||
|
|
@ -3372,8 +3369,8 @@ static void setEnvBeforeReverseScan(SQueryRuntimeEnv* pRuntimeEnv, SQueryStatusI
|
|||
}
|
||||
|
||||
// reverse order time range
|
||||
pQuery->window.skey = pQuery->lastKey - step;
|
||||
pQuery->window.ekey = pStatus->lastKey; // the start timestamp of current query
|
||||
pQuery->window = pStatus->curWindow;
|
||||
SWAP(pQuery->window.skey, pQuery->window.ekey, TSKEY);
|
||||
|
||||
SWITCH_ORDER(pQuery->order.order);
|
||||
SET_SUPPLEMENT_SCAN_FLAG(pRuntimeEnv);
|
||||
|
|
@ -3397,7 +3394,7 @@ static void setEnvBeforeReverseScan(SQueryRuntimeEnv* pRuntimeEnv, SQueryStatusI
|
|||
disableFuncInReverseScan(pRuntimeEnv);
|
||||
}
|
||||
|
||||
static void clearEnvAfterReverseScan(SQueryRuntimeEnv* pRuntimeEnv, TSKEY lastKey, SQueryStatusInfo* pStatus) {
|
||||
static void clearEnvAfterReverseScan(SQueryRuntimeEnv *pRuntimeEnv, SQueryStatusInfo *pStatus) {
|
||||
SQuery *pQuery = pRuntimeEnv->pQuery;
|
||||
|
||||
SWITCH_ORDER(pQuery->order.order);
|
||||
|
|
@ -3412,7 +3409,7 @@ static void clearEnvAfterReverseScan(SQueryRuntimeEnv* pRuntimeEnv, TSKEY lastKe
|
|||
|
||||
// update the pQuery->window.skey and pQuery->window.ekey to limit the scan scope of sliding query
|
||||
// during reverse scan
|
||||
pQuery->lastKey = lastKey;
|
||||
pQuery->lastKey = pStatus->lastKey;
|
||||
pQuery->status = pStatus->status;
|
||||
pQuery->window = pStatus->w;
|
||||
}
|
||||
|
|
@ -3433,6 +3430,7 @@ void scanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
|
|||
|
||||
if (pRuntimeEnv->scanFlag == MASTER_SCAN) {
|
||||
qstatus.status = pQuery->status;
|
||||
qstatus.curWindow.ekey = pQuery->lastKey - step;
|
||||
}
|
||||
|
||||
if (!needScanDataBlocksAgain(pRuntimeEnv)) {
|
||||
|
|
@ -3445,7 +3443,7 @@ void scanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
|
|||
}
|
||||
|
||||
STsdbQueryCond cond = {
|
||||
.twindow = {.skey = qstatus.lastKey, .ekey = pQuery->lastKey - step},
|
||||
.twindow = qstatus.curWindow,
|
||||
.order = pQuery->order.order,
|
||||
.colList = pQuery->colList,
|
||||
.numOfCols = pQuery->numOfCols,
|
||||
|
|
@ -3471,14 +3469,13 @@ void scanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
|
|||
return;
|
||||
}
|
||||
|
||||
TSKEY lastKey = pQuery->lastKey;
|
||||
setEnvBeforeReverseScan(pRuntimeEnv, &qstatus);
|
||||
|
||||
// reverse scan from current position
|
||||
qTrace("QInfo:%p start to reverse scan", GET_QINFO_ADDR(pRuntimeEnv));
|
||||
qTrace("QInfo:%p start to reverse scan", pQInfo);
|
||||
doScanAllDataBlocks(pRuntimeEnv);
|
||||
|
||||
clearEnvAfterReverseScan(pRuntimeEnv, lastKey, &qstatus);
|
||||
clearEnvAfterReverseScan(pRuntimeEnv, &qstatus);
|
||||
}
|
||||
|
||||
void finalizeQueryResult(SQueryRuntimeEnv *pRuntimeEnv) {
|
||||
|
|
@ -3860,8 +3857,9 @@ static void updateWindowResNumOfRes(SQueryRuntimeEnv *pRuntimeEnv, STableDataInf
|
|||
}
|
||||
}
|
||||
|
||||
void stableApplyFunctionsOnBlock(SQueryRuntimeEnv* pRuntimeEnv, STableDataInfo *pTableDataInfo, SDataBlockInfo *pDataBlockInfo,
|
||||
SDataStatis *pStatis, SArray *pDataBlock, __block_search_fn_t searchFn) {
|
||||
void stableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, STableDataInfo *pTableDataInfo,
|
||||
SDataBlockInfo *pDataBlockInfo, SDataStatis *pStatis, SArray *pDataBlock,
|
||||
__block_search_fn_t searchFn) {
|
||||
SQuery * pQuery = pRuntimeEnv->pQuery;
|
||||
STableQueryInfo *pTableQueryInfo = pTableDataInfo->pTableQInfo;
|
||||
SWindowResInfo * pWindowResInfo = &pTableQueryInfo->windowResInfo;
|
||||
|
|
@ -4058,6 +4056,208 @@ void vnodePrintQueryStatistics(SQInfo *pQInfo) {
|
|||
#endif
|
||||
}
|
||||
|
||||
static void updateOffsetVal(SQueryRuntimeEnv *pRuntimeEnv, SDataBlockInfo *pBlockInfo) {
|
||||
SQuery *pQuery = pRuntimeEnv->pQuery;
|
||||
int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
|
||||
|
||||
if (pQuery->limit.offset == pBlockInfo->rows) { // current block will ignore completed
|
||||
pQuery->lastKey = QUERY_IS_ASC_QUERY(pQuery)? pBlockInfo->window.ekey + step : pBlockInfo->window.skey + step;
|
||||
pQuery->limit.offset = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
if (QUERY_IS_ASC_QUERY(pQuery)) {
|
||||
pQuery->pos = pQuery->limit.offset;
|
||||
} else {
|
||||
pQuery->pos = pBlockInfo->rows - pQuery->limit.offset - 1;
|
||||
}
|
||||
|
||||
assert(pQuery->pos >= 0 && pQuery->pos <= pBlockInfo->rows - 1);
|
||||
|
||||
SArray *pDataBlock = tsdbRetrieveDataBlock(pRuntimeEnv->pQueryHandle, NULL);
|
||||
SColumnInfoData *pColInfoData = taosArrayGet(pDataBlock, 0);
|
||||
|
||||
// update the pQuery->limit.offset value, and pQuery->pos value
|
||||
TSKEY *keys = (TSKEY *)pColInfoData->pData;
|
||||
|
||||
// update the offset value
|
||||
pQuery->lastKey = keys[pQuery->pos];
|
||||
pQuery->limit.offset = 0;
|
||||
|
||||
int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, pBlockInfo, NULL, binarySearchForKey,
|
||||
&pRuntimeEnv->windowResInfo, pDataBlock);
|
||||
|
||||
qTrace("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", rows:%d, res:%d", GET_QINFO_ADDR(pRuntimeEnv),
|
||||
pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, numOfRes);
|
||||
}
|
||||
|
||||
void skipBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
|
||||
SQuery *pQuery = pRuntimeEnv->pQuery;
|
||||
|
||||
if (pQuery->limit.offset <= 0 || pQuery->numOfFilterCols > 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
pQuery->pos = 0;
|
||||
int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
|
||||
|
||||
TsdbQueryHandleT pQueryHandle = pRuntimeEnv->pQueryHandle;
|
||||
|
||||
while (tsdbNextDataBlock(pQueryHandle)) {
|
||||
if (isQueryKilled(GET_QINFO_ADDR(pRuntimeEnv))) {
|
||||
return;
|
||||
}
|
||||
|
||||
SDataBlockInfo blockInfo = tsdbRetrieveDataBlockInfo(pQueryHandle);
|
||||
|
||||
if (pQuery->limit.offset > blockInfo.rows) {
|
||||
pQuery->limit.offset -= blockInfo.rows;
|
||||
pQuery->lastKey = (QUERY_IS_ASC_QUERY(pQuery)) ? blockInfo.window.ekey : blockInfo.window.skey;
|
||||
pQuery->lastKey += step;
|
||||
|
||||
qTrace("QInfo:%p skip rows:%d, offset:%" PRId64 "", GET_QINFO_ADDR(pRuntimeEnv), blockInfo.rows, pQuery->limit.offset);
|
||||
} else { // find the appropriated start position in current block
|
||||
updateOffsetVal(pRuntimeEnv, &blockInfo);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static UNUSED_FUNC bool forwardQueryStartPosIfNeeded(SQInfo *pQInfo) {
|
||||
SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
|
||||
SQuery * pQuery = pRuntimeEnv->pQuery;
|
||||
|
||||
// if queried with value filter, do NOT forward query start position
|
||||
if (pQuery->numOfFilterCols > 0 || pRuntimeEnv->pTSBuf != NULL) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (pQuery->limit.offset > 0 && (!isTopBottomQuery(pQuery)) && pQuery->interpoType == TSDB_INTERPO_NONE) {
|
||||
/*
|
||||
* 1. for top/bottom query, the offset applies to the final result, not here
|
||||
* 2. for interval without interpolation query we forward pQuery->intervalTime at a time for
|
||||
* pQuery->limit.offset times. Since hole exists, pQuery->intervalTime*pQuery->limit.offset value is
|
||||
* not valid. otherwise, we only forward pQuery->limit.offset number of points
|
||||
*/
|
||||
if (isIntervalQuery(pQuery)) {
|
||||
assert(pRuntimeEnv->windowResInfo.prevSKey == 0);
|
||||
|
||||
TSKEY skey1, ekey1;
|
||||
STimeWindow w = {0};
|
||||
SWindowResInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
|
||||
|
||||
if (!tsdbNextDataBlock(pRuntimeEnv->pQueryHandle)) {
|
||||
// todo handle no data situation
|
||||
}
|
||||
|
||||
SDataBlockInfo blockInfo = tsdbRetrieveDataBlockInfo(pRuntimeEnv->pQueryHandle);
|
||||
|
||||
if (QUERY_IS_ASC_QUERY(pQuery)) {
|
||||
getAlignQueryTimeWindow(pQuery, blockInfo.window.skey, blockInfo.window.skey, pQuery->window.ekey, &skey1,
|
||||
&ekey1, &w);
|
||||
pWindowResInfo->startTime = w.skey;
|
||||
pWindowResInfo->prevSKey = w.skey;
|
||||
} else {
|
||||
// the start position of the first time window in the endpoint that spreads beyond the queried last timestamp
|
||||
TSKEY start = blockInfo.window.ekey - pQuery->intervalTime;
|
||||
getAlignQueryTimeWindow(pQuery, start, pQuery->window.ekey, blockInfo.window.ekey, &skey1, &ekey1, &w);
|
||||
|
||||
pWindowResInfo->startTime = pQuery->window.skey;
|
||||
pWindowResInfo->prevSKey = w.skey;
|
||||
}
|
||||
|
||||
// the first time window
|
||||
STimeWindow win = getActiveTimeWindow(pWindowResInfo, pWindowResInfo->prevSKey, pQuery);
|
||||
|
||||
while (pQuery->limit.offset > 0) {
|
||||
STimeWindow tw = win;
|
||||
getNextTimeWindow(pQuery, &tw);
|
||||
|
||||
// next time window starts from current data block
|
||||
if ((tw.skey <= blockInfo.window.ekey && QUERY_IS_ASC_QUERY(pQuery)) ||
|
||||
(tw.ekey >= blockInfo.window.skey && !QUERY_IS_ASC_QUERY(pQuery))) {
|
||||
// query completed
|
||||
if ((tw.skey > pQuery->window.ekey && QUERY_IS_ASC_QUERY(pQuery)) ||
|
||||
(tw.ekey < pQuery->window.ekey && !QUERY_IS_ASC_QUERY(pQuery))) {
|
||||
setQueryStatus(pQuery, QUERY_COMPLETED);
|
||||
break;
|
||||
}
|
||||
|
||||
tw = win;
|
||||
SArray * pDataBlock = tsdbRetrieveDataBlock(pRuntimeEnv->pQueryHandle, NULL);
|
||||
SColumnInfoData *pColInfoData = taosArrayGet(pDataBlock, 0);
|
||||
|
||||
int32_t startPos = getNextQualifiedWindow(pRuntimeEnv, &tw, pWindowResInfo, &blockInfo, pColInfoData->pData,
|
||||
binarySearchForKey);
|
||||
assert(startPos >= 0);
|
||||
pQuery->limit.offset -= 1;
|
||||
|
||||
// set the abort info
|
||||
pQuery->pos = startPos;
|
||||
pQuery->lastKey = ((TSKEY *)pColInfoData->pData)[startPos];
|
||||
pWindowResInfo->prevSKey = tw.skey;
|
||||
win = tw;
|
||||
continue;
|
||||
} else {
|
||||
if (!tsdbNextDataBlock(pRuntimeEnv->pQueryHandle)) {
|
||||
setQueryStatus(pQuery, QUERY_COMPLETED);
|
||||
break;
|
||||
}
|
||||
|
||||
blockInfo = tsdbRetrieveDataBlockInfo(pRuntimeEnv->pQueryHandle);
|
||||
if ((blockInfo.window.skey > pQuery->window.ekey && QUERY_IS_ASC_QUERY(pQuery)) ||
|
||||
(blockInfo.window.ekey < pQuery->window.ekey && !QUERY_IS_ASC_QUERY(pQuery))) {
|
||||
setQueryStatus(pQuery, QUERY_COMPLETED);
|
||||
break;
|
||||
}
|
||||
|
||||
// set the window that start from the next data block
|
||||
TSKEY key = (QUERY_IS_ASC_QUERY(pQuery)) ? blockInfo.window.skey : blockInfo.window.ekey;
|
||||
STimeWindow n = getActiveTimeWindow(pWindowResInfo, key, pQuery);
|
||||
|
||||
// next data block are still covered by current time window
|
||||
if (n.skey == win.skey && n.ekey == win.ekey) {
|
||||
// do nothing
|
||||
} else {
|
||||
pQuery->limit.offset -= 1;
|
||||
|
||||
// query completed
|
||||
if ((n.skey > pQuery->window.ekey && QUERY_IS_ASC_QUERY(pQuery)) ||
|
||||
(n.ekey < pQuery->window.ekey && !QUERY_IS_ASC_QUERY(pQuery))) {
|
||||
setQueryStatus(pQuery, QUERY_COMPLETED);
|
||||
break;
|
||||
}
|
||||
|
||||
// set the abort info
|
||||
pQuery->pos = QUERY_IS_ASC_QUERY(pQuery) ? 0 : blockInfo.rows - 1;
|
||||
pQuery->lastKey = QUERY_IS_ASC_QUERY(pQuery) ? blockInfo.window.skey : blockInfo.window.ekey;
|
||||
pWindowResInfo->prevSKey = n.skey;
|
||||
|
||||
win = n;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED) || pQuery->limit.offset > 0) {
|
||||
setQueryStatus(pQuery, QUERY_COMPLETED);
|
||||
return false;
|
||||
} else {
|
||||
assert(0);
|
||||
// if (IS_DISK_DATA_BLOCK(pQuery)) {
|
||||
// getTimestampInDiskBlock(pRuntimeEnv, 0);
|
||||
}
|
||||
}
|
||||
} else { // forward the start position for projection query
|
||||
skipBlocks(&pQInfo->runtimeEnv);
|
||||
if (pQuery->limit.offset > 0) {
|
||||
setQueryStatus(pQuery, QUERY_COMPLETED);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int32_t doInitQInfo(SQInfo *pQInfo, void *param, void *tsdb, bool isSTableQuery) {
|
||||
SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
|
||||
|
||||
|
|
@ -4091,7 +4291,7 @@ int32_t doInitQInfo(SQInfo *pQInfo, void *param, void* tsdb, bool isSTableQuery)
|
|||
}
|
||||
|
||||
// create runtime environment
|
||||
code = setupQueryRuntimeEnv(pRuntimeEnv, NULL, pQuery->order.order);
|
||||
code = setupQueryRuntimeEnv(pRuntimeEnv, pQuery->order.order);
|
||||
if (code != TSDB_CODE_SUCCESS) {
|
||||
return code;
|
||||
}
|
||||
|
|
@ -4158,11 +4358,6 @@ int32_t doInitQInfo(SQInfo *pQInfo, void *param, void* tsdb, bool isSTableQuery)
|
|||
pointInterpSupporterSetData(pQInfo, &interpInfo);
|
||||
pointInterpSupporterDestroy(&interpInfo);
|
||||
|
||||
// todo move to other location
|
||||
// if (!forwardQueryStartPosIfNeeded(pQInfo, pQInfo, dataInDisk, dataInCache)) {
|
||||
// return TSDB_CODE_SUCCESS;
|
||||
// }
|
||||
|
||||
int64_t rs = taosGetIntervalStartTimestamp(pQuery->window.skey, pQuery->intervalTime, pQuery->slidingTimeUnit,
|
||||
pQuery->precision);
|
||||
taosInitInterpoInfo(&pRuntimeEnv->interpoInfo, pQuery->order.order, rs, 0, 0);
|
||||
|
|
@ -4298,7 +4493,6 @@ static bool multiTableMultioutputHelper(SQInfo *pQInfo, int32_t index) {
|
|||
.numOfCols = pQuery->numOfCols,
|
||||
};
|
||||
|
||||
|
||||
SArray *g1 = taosArrayInit(1, POINTER_BYTES);
|
||||
SArray *tx = taosArrayInit(1, sizeof(SPair));
|
||||
|
||||
|
|
@ -4468,7 +4662,8 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
|
|||
resetTimeWindowInfo(pRuntimeEnv, &pRuntimeEnv->windowResInfo);
|
||||
|
||||
SArray *group = taosArrayGetP(pQInfo->groupInfo.pGroupList, 0);
|
||||
assert(taosArrayGetSize(group) == pQInfo->groupInfo.numOfTables && 1 == taosArrayGetSize(pQInfo->groupInfo.pGroupList));
|
||||
assert(taosArrayGetSize(group) == pQInfo->groupInfo.numOfTables &&
|
||||
1 == taosArrayGetSize(pQInfo->groupInfo.pGroupList));
|
||||
|
||||
while (pQInfo->tableIndex < pQInfo->groupInfo.numOfTables) {
|
||||
if (isQueryKilled(pQInfo)) {
|
||||
|
|
@ -4492,7 +4687,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
|
|||
|
||||
// TODO handle the limit problem
|
||||
if (pQuery->numOfFilterCols == 0 && pQuery->limit.offset > 0) {
|
||||
// forwardQueryStartPosition(pRuntimeEnv);
|
||||
// skipBlocks(pRuntimeEnv);
|
||||
|
||||
if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED)) {
|
||||
pQInfo->tableIndex++;
|
||||
|
|
@ -4587,9 +4782,11 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
|
|||
|
||||
pQuery->rec.total += pQuery->rec.rows;
|
||||
|
||||
qTrace( "QInfo %p, numOfTables:%d, index:%d, numOfGroups:%d, %d points returned, total:%d totalReturn:%d,"
|
||||
" offset:%" PRId64, pQInfo, pQInfo->groupInfo.numOfTables, pQInfo->tableIndex, numOfGroups,
|
||||
pQuery->rec.rows, pQuery->rec.total, pQuery->limit.offset);
|
||||
qTrace(
|
||||
"QInfo %p, numOfTables:%d, index:%d, numOfGroups:%d, %d points returned, total:%d totalReturn:%d,"
|
||||
" offset:%" PRId64,
|
||||
pQInfo, pQInfo->groupInfo.numOfTables, pQInfo->tableIndex, numOfGroups, pQuery->rec.rows, pQuery->rec.total,
|
||||
pQuery->limit.offset);
|
||||
}
|
||||
|
||||
static void createTableDataInfo(SQInfo *pQInfo) {
|
||||
|
|
@ -4614,7 +4811,8 @@ static void createTableDataInfo(SQInfo* pQInfo) {
|
|||
STableDataInfo *pInfo = calloc(1, sizeof(STableDataInfo));
|
||||
|
||||
setTableDataInfo(pInfo, index, i);
|
||||
pInfo->pTableQInfo = createTableQueryInfo(&pQInfo->runtimeEnv, ((STable*)(p->first))->tableId.tid, pQuery->window);
|
||||
pInfo->pTableQInfo =
|
||||
createTableQueryInfo(&pQInfo->runtimeEnv, ((STable *)(p->first))->tableId.tid, pQuery->window);
|
||||
|
||||
p->sec = pInfo;
|
||||
|
||||
|
|
@ -4715,8 +4913,8 @@ static void multiTableQueryProcess(SQInfo *pQInfo) {
|
|||
return;
|
||||
}
|
||||
|
||||
qTrace("QInfo:%p query start, qrange:%" PRId64 "-%" PRId64 ", order:%d, forward scan start", pQInfo, pQuery->window.skey,
|
||||
pQuery->window.ekey, pQuery->order.order);
|
||||
qTrace("QInfo:%p query start, qrange:%" PRId64 "-%" PRId64 ", order:%d, forward scan start", pQInfo,
|
||||
pQuery->window.skey, pQuery->window.ekey, pQuery->order.order);
|
||||
|
||||
// create the query support structures
|
||||
createTableDataInfo(pQInfo);
|
||||
|
|
@ -4809,6 +5007,13 @@ static void tableMultiOutputProcess(SQInfo *pQInfo) {
|
|||
resetCtxOutputBuf(pRuntimeEnv);
|
||||
}
|
||||
|
||||
// skip blocks without load the actual data block from file if no filter condition present
|
||||
skipBlocks(&pQInfo->runtimeEnv);
|
||||
if (pQuery->limit.offset > 0 && pQuery->numOfFilterCols == 0) {
|
||||
setQueryStatus(pQuery, QUERY_COMPLETED);
|
||||
return;
|
||||
}
|
||||
|
||||
while (1) {
|
||||
scanAllDataBlocks(pRuntimeEnv);
|
||||
finalizeQueryResult(pRuntimeEnv);
|
||||
|
|
@ -4838,13 +5043,10 @@ static void tableMultiOutputProcess(SQInfo *pQInfo) {
|
|||
|
||||
doRevisedResultsByLimit(pQInfo);
|
||||
if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL)) {
|
||||
qTrace("QInfo:%p query paused due to output limitation, next qrange:%" PRId64 "-%" PRId64,
|
||||
pQInfo, pQuery->lastKey, pQuery->window.ekey);
|
||||
qTrace("QInfo:%p query paused due to output limitation, next qrange:%" PRId64 "-%" PRId64, pQInfo, pQuery->lastKey,
|
||||
pQuery->window.ekey);
|
||||
}
|
||||
|
||||
// qTrace("QInfo:%p vid:%d sid:%d id:%s, %d points returned, totalRead:%d totalReturn:%d", pQInfo, pMeterObj->vnode,
|
||||
// pMeterObj->sid, pMeterObj->meterId, pQuery->size, pQInfo->size, pQInfo->pointsReturned);
|
||||
|
||||
if (!isTSCompQuery(pQuery)) {
|
||||
assert(pQuery->rec.rows <= pQuery->rec.capacity);
|
||||
}
|
||||
|
|
@ -4912,8 +5114,8 @@ static void tableIntervalProcess(SQInfo *pQInfo) {
|
|||
}
|
||||
|
||||
numOfInterpo = 0;
|
||||
pQuery->rec.rows = vnodeQueryResultInterpolate(
|
||||
pQInfo, (tFilePage **)pQuery->sdata, (tFilePage **)pInterpoBuf, pQuery->rec.rows, &numOfInterpo);
|
||||
pQuery->rec.rows = vnodeQueryResultInterpolate(pQInfo, (tFilePage **)pQuery->sdata, (tFilePage **)pInterpoBuf,
|
||||
pQuery->rec.rows, &numOfInterpo);
|
||||
|
||||
qTrace("QInfo: %p interpo completed, final:%d", pQInfo, pQuery->rec.rows);
|
||||
if (pQuery->rec.rows > 0 || Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED)) {
|
||||
|
|
@ -4964,7 +5166,6 @@ static void tableQueryImpl(SQInfo* pQInfo) {
|
|||
// continue to get push data from the group result
|
||||
if (isGroupbyNormalCol(pQuery->pGroupbyExpr) ||
|
||||
((isIntervalQuery(pQuery) && pQuery->rec.total < pQuery->limit.limit))) {
|
||||
|
||||
// todo limit the output for interval query?
|
||||
pQuery->rec.rows = 0;
|
||||
pQInfo->groupIndex = 0; // always start from 0
|
||||
|
|
@ -5012,7 +5213,8 @@ static void tableQueryImpl(SQInfo* pQInfo) {
|
|||
qTrace("QInfo:%p query is killed", pQInfo);
|
||||
} else {
|
||||
// STableId* pTableId = taosArrayGet(pQInfo->groupInfo, 0);
|
||||
// qTrace("QInfo:%p uid:%" PRIu64 " tid:%d, query completed, %" PRId64 " rows returned, numOfTotal:%" PRId64 " rows",
|
||||
// qTrace("QInfo:%p uid:%" PRIu64 " tid:%d, query completed, %" PRId64 " rows returned, numOfTotal:%" PRId64 "
|
||||
// rows",
|
||||
// pQInfo, pTableId->uid, pTableId->tid, pQuery->rec.rows, pQuery->rec.total + pQuery->rec.rows);
|
||||
}
|
||||
|
||||
|
|
@ -5040,7 +5242,8 @@ static void stableQueryImpl(SQInfo* pQInfo) {
|
|||
// taosInterpoSetStartInfo(&pQInfo->runtimeEnv.interpoInfo, pQuery->size, pQInfo->query.interpoType);
|
||||
|
||||
if (pQuery->rec.rows == 0) {
|
||||
qTrace("QInfo:%p over, %d tables queried, %d points are returned", pQInfo, pQInfo->groupInfo.numOfTables, pQuery->rec.total);
|
||||
qTrace("QInfo:%p over, %d tables queried, %d points are returned", pQInfo, pQInfo->groupInfo.numOfTables,
|
||||
pQuery->rec.total);
|
||||
// vnodePrintQueryStatistics(pSupporter);
|
||||
}
|
||||
|
||||
|
|
@ -5294,12 +5497,13 @@ static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SArray **pTableIdList,
|
|||
memcpy(*tagCond, pMsg, pQueryMsg->tagCondLen);
|
||||
}
|
||||
|
||||
qTrace("qmsg:%p query on %d table(s), qrange:%" PRId64 "-%" PRId64 ", numOfGroupbyTagCols:%d, ts order:%d, "
|
||||
"outputCols:%d, numOfCols:%d, interval:%d" PRId64 ", fillType:%d, comptsLen:%d, limit:%" PRId64 ", offset:%" PRId64,
|
||||
pQueryMsg, pQueryMsg->numOfTables, pQueryMsg->window.skey, pQueryMsg->window.ekey,
|
||||
pQueryMsg->numOfGroupCols, pQueryMsg->order, pQueryMsg->numOfOutputCols,
|
||||
pQueryMsg->numOfCols, pQueryMsg->intervalTime, pQueryMsg->interpoType, pQueryMsg->tsLen,
|
||||
pQueryMsg->limit, pQueryMsg->offset);
|
||||
qTrace("qmsg:%p query on %d table(s), qrange:%" PRId64 "-%" PRId64
|
||||
", numOfGroupbyTagCols:%d, ts order:%d, "
|
||||
"outputCols:%d, numOfCols:%d, interval:%d" PRId64 ", fillType:%d, comptsLen:%d, limit:%" PRId64
|
||||
", offset:%" PRId64,
|
||||
pQueryMsg, pQueryMsg->numOfTables, pQueryMsg->window.skey, pQueryMsg->window.ekey, pQueryMsg->numOfGroupCols,
|
||||
pQueryMsg->order, pQueryMsg->numOfOutputCols, pQueryMsg->numOfCols, pQueryMsg->intervalTime,
|
||||
pQueryMsg->interpoType, pQueryMsg->tsLen, pQueryMsg->limit, pQueryMsg->offset);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -5355,7 +5559,8 @@ static int32_t buildAirthmeticExprFromMsg(SSqlFunctionExpr *pExpr, SQueryTableMs
|
|||
return TSDB_CODE_SUCCESS;
|
||||
}
|
||||
|
||||
static int32_t createSqlFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SSqlFunctionExpr **pSqlFuncExpr, SSqlFuncExprMsg** pExprMsg) {
|
||||
static int32_t createSqlFunctionExprFromMsg(SQueryTableMsg *pQueryMsg, SSqlFunctionExpr **pSqlFuncExpr,
|
||||
SSqlFuncExprMsg **pExprMsg) {
|
||||
*pSqlFuncExpr = NULL;
|
||||
int32_t code = TSDB_CODE_SUCCESS;
|
||||
|
||||
|
|
@ -5927,7 +6132,8 @@ int32_t qCreateQueryInfo(void* tsdb, SQueryTableMsg *pQueryMsg, qinfo_t *pQInfo)
|
|||
STableId *id = taosArrayGet(pTableIdList, 0);
|
||||
id->uid = -1; // todo fix me
|
||||
|
||||
/*int32_t ret =*/ tsdbQueryByTagsCond(tsdb, id->uid, tagCond, pQueryMsg->tagCondLen, &groupInfo, pGroupColIndex, pQueryMsg->numOfGroupCols);
|
||||
/*int32_t ret =*/tsdbQueryByTagsCond(tsdb, id->uid, tagCond, pQueryMsg->tagCondLen, &groupInfo, pGroupColIndex,
|
||||
pQueryMsg->numOfGroupCols);
|
||||
if (groupInfo.numOfTables == 0) { // no qualified tables no need to do query
|
||||
code = TSDB_CODE_SUCCESS;
|
||||
goto _query_over;
|
||||
|
|
|
|||
Loading…
Reference in New Issue