queryExecutor.h 7.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
/*
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
 *
 * This program is free software: you can use, redistribute, and/or modify
 * it under the terms of the GNU Affero General Public License, version 3
 * or later ("AGPL"), as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef TDENGINE_QUERYEXECUTOR_H
#define TDENGINE_QUERYEXECUTOR_H

#include "os.h"

#include "hash.h"
#include "qinterpolation.h"
#include "qresultBuf.h"
#include "qsqlparser.h"
#include "qtsbuf.h"
#include "taosdef.h"
#include "tref.h"
#include "tsqlfunction.h"
H
hjxilinx 已提交
28
#include "tarray.h"
29 30 31 32 33 34 35 36

typedef struct SData {
  int32_t num;
  char    data[];
} SData;

struct SColumnFilterElem;
typedef bool (*__filter_func_t)(struct SColumnFilterElem* pFilter, char* val1, char* val2);
H
hjxilinx 已提交
37
typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int32_t order);
38 39 40 41

typedef struct SSqlGroupbyExpr {
  int16_t     tableIndex;
  int16_t     numOfGroupCols;
42
  SColIndex*  columnInfo;                 // group by columns information
43 44 45 46 47 48 49 50 51 52 53 54 55 56
  int16_t     orderIndex;                 // order by column index
  int16_t     orderType;                  // order by type: asc/desc
} SSqlGroupbyExpr;

typedef struct SPosInfo {
  int16_t pageId;
  int16_t rowId;
} SPosInfo;

typedef struct SWindowStatus {
  bool closed;
} SWindowStatus;

typedef struct SWindowResult {
H
hjxilinx 已提交
57
  uint16_t      numOfRows;   // number of rows of current  time window
58 59 60
  SPosInfo      pos;         // Position of current result in disk-based output buffer
  SResultInfo*  resultInfo;  // For each result column, there is a resultInfo
  STimeWindow   window;      // The time window that current result covers.
H
hjxilinx 已提交
61
  SWindowStatus status;      // this result status: closed or opened
62 63 64
} SWindowResult;

typedef struct SResultRec {
H
hjxilinx 已提交
65
  int64_t total;     // total generated result size in rows
66
  int64_t rows;      // current result set size in rows
H
hjxilinx 已提交
67 68 69 70
  int64_t capacity;  // capacity of current result output buffer
  
  // result size threshold in rows. If the result buffer is larger than this, pause query and return to client
  int32_t threshold;
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
} SResultRec;

typedef struct SWindowResInfo {
  SWindowResult* pResult;    // result list
  void*          hashList;   // hash list for quick access
  int16_t        type;       // data type for hash key
  int32_t        capacity;   // max capacity
  int32_t        curIndex;   // current start active index
  int32_t        size;       // number of result set
  int64_t        startTime;  // start time of the first time window for sliding query
  int64_t        prevSKey;   // previous (not completed) sliding window start key
  int64_t        threshold;  // threshold to pausing query and return closed results.
} SWindowResInfo;

typedef struct SColumnFilterElem {
  int16_t           bytes;  // column length
  __filter_func_t   fp;
  SColumnFilterInfo filterInfo;
} SColumnFilterElem;

typedef struct SSingleColumnFilterInfo {
H
hjxilinx 已提交
92
  SColumnInfoData      info;
93 94 95 96 97 98 99 100 101 102 103 104
  int32_t            numOfFilters;
  SColumnFilterElem* pFilters;
  void*              pData;
} SSingleColumnFilterInfo;

typedef struct STableQueryInfo {
  int64_t     lastKey;
  STimeWindow win;
  int32_t     numOfRes;
  int16_t     queryRangeSet;  // denote if the query range is set, only available for interval query
  int64_t     tag;
  STSCursor   cur;
H
hjxilinx 已提交
105
  int32_t     tid;  // for retrieve the page id list
106 107 108 109 110 111

  SWindowResInfo windowResInfo;
} STableQueryInfo;

typedef struct STableDataInfo {
  int32_t          numOfBlocks;
H
hjxilinx 已提交
112
  int32_t          start;     // start block index
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
  int32_t          tableIndex;
  int32_t          groupIdx;  // group id in table list
  STableQueryInfo* pTableQInfo;
} STableDataInfo;

typedef struct SQuery {
  int16_t           numOfCols;
  SOrderVal         order;
  STimeWindow       window;
  int64_t           intervalTime;
  int64_t           slidingTime;      // sliding time for sliding window query
  char              slidingTimeUnit;  // interval data type, used for daytime revise
  int8_t            precision;
  int16_t           numOfOutputCols;
  int16_t           interpoType;
128
  int16_t           checkBuffer;  // check if the buffer is full during scan each block
129 130 131 132
  SLimitVal         limit;
  int32_t           rowSize;
  SSqlGroupbyExpr*  pGroupbyExpr;
  SSqlFunctionExpr* pSelectExpr;
H
hjxilinx 已提交
133
  SColumnInfoData*    colList;
134 135 136 137 138 139 140
  int32_t           numOfFilterCols;
  int64_t*          defaultVal;
  TSKEY             lastKey;
  uint32_t          status;  // query status
  SResultRec        rec;
  int32_t           pos;
  int64_t           pointsOffset;  // the number of points offset to save read data
H
hjxilinx 已提交
141
  SData**           sdata;
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
  SSingleColumnFilterInfo* pFilterInfo;
} SQuery;

typedef struct SQueryCostSummary {
} SQueryCostSummary;

typedef struct SQueryRuntimeEnv {
  SResultInfo*       resultInfo;  // todo refactor to merge with SWindowResInfo
  SQuery*            pQuery;
  SData**            pInterpoBuf;
  SQLFunctionCtx*    pCtx;
  int16_t            numOfRowsPerPage;
  int16_t            offset[TSDB_MAX_COLUMNS];
  uint16_t           scanFlag;  // denotes reversed scan of data or not
  SInterpolationInfo interpoInfo;
  SWindowResInfo     windowResInfo;
  STSBuf*            pTSBuf;
  STSCursor          cur;
  SQueryCostSummary  summary;
  bool               stableQuery;  // super table query or not
  void*              pQueryHandle;
163
  void*              pSecQueryHandle; // another thread for
164 165 166 167
  SDiskbasedResultBuf* pResultBuf;  // query result buffer based on blocked-wised disk file
} SQueryRuntimeEnv;

typedef struct SQInfo {
H
hjxilinx 已提交
168
  void*            signature;
169
  TSKEY            startTime;
H
hjxilinx 已提交
170
  TSKEY            elapsedTime;
H
hjxilinx 已提交
171
  int32_t          pointsInterpo;
H
hjxilinx 已提交
172
  int32_t          code;          // error code to returned to client
173
  sem_t            dataReady;
174
  SArray*          pTableList;    // table id list
175 176
  void*            tsdb;
  
177 178 179
  SQueryRuntimeEnv runtimeEnv;
  int32_t          subgroupIdx;
  int32_t          offset; /* offset in group result set of subgroup */
H
hjxilinx 已提交
180
  
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
  T_REF_DECLARE()
  /*
   * the query is executed position on which meter of the whole list.
   * when the index reaches the last one of the list, it means the query is completed.
   * We later may refactor to remove this attribution by using another flag to denote
   * whether a multimeter query is completed or not.
   */
  int32_t         tableIndex;
  int32_t         numOfGroupResultPages;
  STableDataInfo* pTableDataInfo;
  TSKEY*          tsList;
} SQInfo;

/**
 * create the qinfo object before adding the query task to each tsdb query worker
 *
 * @param pReadMsg
 * @param pQInfo
 * @return
 */
H
hjxilinx 已提交
201
int32_t qCreateQueryInfo(void* pVnode, SQueryTableMsg* pQueryTableMsg, SQInfo** pQInfo);
202

203 204 205 206 207 208
/**
 * destroy the query info struct
 * @param pQInfo
 */
void qDestroyQueryInfo(SQInfo* pQInfo);

209 210 211 212
/**
 * query on single table
 * @param pReadMsg
 */
H
hjxilinx 已提交
213
void qTableQuery(SQInfo* pQInfo);
214

H
hjxilinx 已提交
215 216 217 218
/**
 * wait for the query completed, and retrieve final results to client
 * @param pQInfo
 */
H
hjxilinx 已提交
219
int32_t qRetrieveQueryResultInfo(SQInfo* pQInfo);
H
hjxilinx 已提交
220

221 222 223 224 225 226 227
/**
 *
 * @param pQInfo
 * @param pRsp
 * @return
 */
int32_t qDumpRetrieveResult(SQInfo *pQInfo, SRetrieveTableRsp** pRsp, int32_t* contLen);
H
hjxilinx 已提交
228

H
hjxilinx 已提交
229 230 231 232 233
/**
 *
 * @param pQInfo
 * @return
 */
H
[TD-32]  
hjxilinx 已提交
234
bool qHasMoreResultsToRetrieve(SQInfo* pQInfo);
H
hjxilinx 已提交
235

236
#endif  // TDENGINE_QUERYEXECUTOR_H