diff --git a/example/src/tmq.c b/example/src/tmq.c index 3b4b6afbaf..8757104ad9 100644 --- a/example/src/tmq.c +++ b/example/src/tmq.c @@ -80,8 +80,9 @@ int32_t create_topic() { } taos_free_result(pRes); - const char* sql = "select * from tu1"; - pRes = tmq_create_topic(pConn, "test_stb_topic_1", sql, strlen(sql)); + /*const char* sql = "select * from tu1";*/ + /*pRes = tmq_create_topic(pConn, "test_stb_topic_1", sql, strlen(sql));*/ + pRes = taos_query(pConn, "create topic test_stb_topic_1 as select * from tu1"); if (taos_errno(pRes) != 0) { printf("failed to create topic test_stb_topic_1, reason:%s\n", taos_errstr(pRes)); return -1; diff --git a/include/client/taos.h b/include/client/taos.h index dc54b89d04..0260316618 100644 --- a/include/client/taos.h +++ b/include/client/taos.h @@ -26,9 +26,11 @@ extern "C" { typedef void TAOS; typedef void TAOS_STMT; typedef void TAOS_RES; -typedef void TAOS_STREAM; -typedef void TAOS_SUB; typedef void **TAOS_ROW; +#if 0 +typedef void TAOS_STREAM; +#endif +typedef void TAOS_SUB; // Data type definition #define TSDB_DATA_TYPE_NULL 0 // 1 bytes @@ -149,6 +151,7 @@ DLL_EXPORT int taos_stmt_execute(TAOS_STMT *stmt); DLL_EXPORT TAOS_RES *taos_stmt_use_result(TAOS_STMT *stmt); DLL_EXPORT int taos_stmt_close(TAOS_STMT *stmt); DLL_EXPORT char *taos_stmt_errstr(TAOS_STMT *stmt); +DLL_EXPORT int taos_stmt_affected_rows(TAOS_STMT *stmt); DLL_EXPORT TAOS_RES *taos_query(TAOS *taos, const char *sql); DLL_EXPORT TAOS_RES *taos_query_l(TAOS *taos, const char *sql, int sqlLen); @@ -179,15 +182,20 @@ DLL_EXPORT int taos_errno(TAOS_RES *tres); DLL_EXPORT void taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param); DLL_EXPORT void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param); +// Shuduo: temporary enable for app build +#if 1 typedef void (*__taos_sub_fn_t)(TAOS_SUB *tsub, TAOS_RES *res, void *param, int code); DLL_EXPORT TAOS_SUB *taos_subscribe(TAOS *taos, int restart, const char *topic, const char *sql, __taos_sub_fn_t fp, void *param, int interval); DLL_EXPORT TAOS_RES *taos_consume(TAOS_SUB *tsub); DLL_EXPORT void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress); +#endif +#if 0 DLL_EXPORT TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sql, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), int64_t stime, void *param, void (*callback)(void *)); DLL_EXPORT void taos_close_stream(TAOS_STREAM *tstr); +#endif DLL_EXPORT int taos_load_table_info(TAOS *taos, const char *tableNameList); DLL_EXPORT TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision); @@ -215,8 +223,12 @@ DLL_EXPORT tmq_list_t *tmq_list_new(); DLL_EXPORT int32_t tmq_list_append(tmq_list_t *, const char *); DLL_EXPORT void tmq_list_destroy(tmq_list_t *); -DLL_EXPORT tmq_t *tmq_consumer_new(void *conn, tmq_conf_t *conf, char *errstr, int32_t errstrLen); -DLL_EXPORT tmq_t *tmq_consumer_new1(tmq_conf_t *conf, char *errstr, int32_t errstrLen); +// will be removed in 3.0 +DLL_EXPORT tmq_t *tmq_consumer_new(void *conn, tmq_conf_t *conf, char *errstr, int32_t errstrLen); + +// will replace last one +DLL_EXPORT tmq_t *tmq_consumer_new1(tmq_conf_t *conf, char *errstr, int32_t errstrLen); + DLL_EXPORT const char *tmq_err2str(tmq_resp_err_t); /* ------------------------TMQ CONSUMER INTERFACE------------------------ */ @@ -255,20 +267,26 @@ int32_t tmqGetSkipLogNum(tmq_message_t *tmq_message); /* -------------------------TMQ MSG HANDLE INTERFACE---------------------- */ -DLL_EXPORT TAOS_ROW tmq_get_row(tmq_message_t *message); -DLL_EXPORT char *tmq_get_topic_name(tmq_message_t *message); -DLL_EXPORT void *tmq_get_topic_schema(tmq_t *tmq, const char *topic); -DLL_EXPORT void tmq_message_destroy(tmq_message_t *tmq_message); +DLL_EXPORT TAOS_ROW tmq_get_row(tmq_message_t *message); +DLL_EXPORT char *tmq_get_topic_name(tmq_message_t *message); +DLL_EXPORT int32_t tmq_get_vgroup_id(tmq_message_t *message); +DLL_EXPORT int64_t tmq_get_request_offset(tmq_message_t *message); +DLL_EXPORT int64_t tmq_get_response_offset(tmq_message_t *message); +DLL_EXPORT TAOS_FIELD *tmq_get_fields(tmq_t *tmq, const char *topic); +DLL_EXPORT int32_t tmq_field_count(tmq_t *tmq, const char *topic); +DLL_EXPORT void tmq_message_destroy(tmq_message_t *tmq_message); /* --------------------TMPORARY INTERFACE FOR TESTING--------------------- */ +#if 0 DLL_EXPORT TAOS_RES *tmq_create_topic(TAOS *taos, const char *name, const char *sql, int sqlLen); +#endif DLL_EXPORT TAOS_RES *tmq_create_stream(TAOS *taos, const char *streamName, const char *tbName, const char *sql); -/* -------------------------------- OTHER -------------------------------- */ +/* ------------------------------ TMQ END -------------------------------- */ +#if 1 // Shuduo: temporary enable for app build typedef void (*TAOS_SUBSCRIBE_CALLBACK)(TAOS_SUB *tsub, TAOS_RES *res, void *param, int code); - -DLL_EXPORT int taos_stmt_affected_rows(TAOS_STMT *stmt); +#endif #ifdef __cplusplus } diff --git a/include/common/tcommon.h b/include/common/tcommon.h index b7fb988cec..51eabb7d61 100644 --- a/include/common/tcommon.h +++ b/include/common/tcommon.h @@ -197,6 +197,11 @@ typedef struct SGroupbyExpr { bool groupbyTag; // group by tag or column } SGroupbyExpr; +enum { + FUNC_PARAM_TYPE_VALUE = 0, + FUNC_PARAM_TYPE_COLUMN, +}; + typedef struct SFunctParam { int32_t type; SColumn* pCol; diff --git a/include/common/tmsg.h b/include/common/tmsg.h index e4b3ce722b..de21638179 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -2215,23 +2215,6 @@ static FORCE_INLINE void* tDecodeTSmaWrapper(void* buf, STSmaWrapper* pSW) { return buf; } -typedef struct { - int64_t uid; - int32_t numOfRows; - char* colData; -} SMqTbData; - -typedef struct { - char topicName[TSDB_TOPIC_FNAME_LEN]; - int64_t committedOffset; - int64_t reqOffset; - int64_t rspOffset; - int32_t skipLogNum; - int32_t bodyLen; - int32_t numOfTb; - SMqTbData* tbData; -} SMqTopicData; - typedef struct { int8_t mqMsgType; int32_t code; @@ -2259,8 +2242,11 @@ typedef struct { } SMqSubVgEp; typedef struct { - char topic[TSDB_TOPIC_FNAME_LEN]; - SArray* vgs; // SArray + char topic[TSDB_TOPIC_FNAME_LEN]; + int8_t isSchemaAdaptive; + SArray* vgs; // SArray + int32_t numOfFields; + TAOS_FIELD* fields; } SMqSubTopicEp; typedef struct { @@ -2281,32 +2267,6 @@ typedef struct { SArray* topics; // SArray } SMqCMGetSubEpRsp; -typedef struct { - int32_t curBlock; - int32_t curRow; - void** uData; -} SMqRowIter; - -struct tmq_message_t { - SMqPollRsp msg; - void* vg; - SMqRowIter iter; -}; - -#if 0 -struct tmq_message_t { - SMqRspHead head; - union { - SMqPollRsp consumeRsp; - SMqCMGetSubEpRsp getEpRsp; - }; - void* extra; - int32_t curBlock; - int32_t curRow; - void** uData; -}; -#endif - static FORCE_INLINE void tDeleteSMqSubTopicEp(SMqSubTopicEp* pSubTopicEp) { taosArrayDestroy(pSubTopicEp->vgs); } static FORCE_INLINE int32_t tEncodeSMqSubVgEp(void** buf, const SMqSubVgEp* pVgEp) { @@ -2331,17 +2291,21 @@ static FORCE_INLINE void tDeleteSMqCMGetSubEpRsp(SMqCMGetSubEpRsp* pRsp) { static FORCE_INLINE int32_t tEncodeSMqSubTopicEp(void** buf, const SMqSubTopicEp* pTopicEp) { int32_t tlen = 0; tlen += taosEncodeString(buf, pTopicEp->topic); + tlen += taosEncodeFixedI8(buf, pTopicEp->isSchemaAdaptive); int32_t sz = taosArrayGetSize(pTopicEp->vgs); tlen += taosEncodeFixedI32(buf, sz); for (int32_t i = 0; i < sz; i++) { SMqSubVgEp* pVgEp = (SMqSubVgEp*)taosArrayGet(pTopicEp->vgs, i); tlen += tEncodeSMqSubVgEp(buf, pVgEp); } + tlen += taosEncodeFixedI32(buf, pTopicEp->numOfFields); + // tlen += taosEncodeBinary(buf, pTopicEp->fields, pTopicEp->numOfFields * sizeof(TAOS_FIELD)); return tlen; } static FORCE_INLINE void* tDecodeSMqSubTopicEp(void* buf, SMqSubTopicEp* pTopicEp) { buf = taosDecodeStringTo(buf, pTopicEp->topic); + buf = taosDecodeFixedI8(buf, &pTopicEp->isSchemaAdaptive); int32_t sz; buf = taosDecodeFixedI32(buf, &sz); pTopicEp->vgs = taosArrayInit(sz, sizeof(SMqSubVgEp)); @@ -2353,6 +2317,8 @@ static FORCE_INLINE void* tDecodeSMqSubTopicEp(void* buf, SMqSubTopicEp* pTopicE buf = tDecodeSMqSubVgEp(buf, &vgEp); taosArrayPush(pTopicEp->vgs, &vgEp); } + buf = taosDecodeFixedI32(buf, &pTopicEp->numOfFields); + // buf = taosDecodeBinary(buf, (void**)&pTopicEp->fields, pTopicEp->numOfFields * sizeof(TAOS_FIELD)); return buf; } diff --git a/include/common/tmsgcb.h b/include/common/tmsgcb.h index 50ff735f86..cb59599d9a 100644 --- a/include/common/tmsgcb.h +++ b/include/common/tmsgcb.h @@ -56,13 +56,14 @@ typedef struct { ReleaseHandleFp releaseHandleFp; } SMsgCb; +void tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb); int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq); int32_t tmsgGetQueueSize(const SMsgCb* pMsgCb, int32_t vgId, EQueueType qtype); int32_t tmsgSendReq(const SMsgCb* pMsgCb, const SEpSet* epSet, SRpcMsg* pReq); int32_t tmsgSendMnodeReq(const SMsgCb* pMsgCb, SRpcMsg* pReq); -void tmsgSendRsp(const SMsgCb* pMsgCb, const SRpcMsg* pRsp); +void tmsgSendRsp(const SRpcMsg* pRsp); void tmsgRegisterBrokenLinkArg(const SMsgCb* pMsgCb, SRpcMsg* pMsg); -void tmsgReleaseHandle(const SMsgCb* pMsgCb, void* handle, int8_t type); +void tmsgReleaseHandle(void* handle, int8_t type); #ifdef __cplusplus } diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h index c5904904ab..83de5b6918 100644 --- a/include/common/ttokendef.h +++ b/include/common/ttokendef.h @@ -139,18 +139,18 @@ #define TK_TOPIC 121 #define TK_AS 122 #define TK_NK_BOOL 123 -#define TK_NK_VARIABLE 124 -#define TK_NK_UNDERLINE 125 -#define TK_ROWTS 126 -#define TK_TBNAME 127 -#define TK_QSTARTTS 128 -#define TK_QENDTS 129 -#define TK_WSTARTTS 130 -#define TK_WENDTS 131 -#define TK_WDURATION 132 -#define TK_BETWEEN 133 -#define TK_IS 134 -#define TK_NULL 135 +#define TK_NULL 124 +#define TK_NK_VARIABLE 125 +#define TK_NK_UNDERLINE 126 +#define TK_ROWTS 127 +#define TK_TBNAME 128 +#define TK_QSTARTTS 129 +#define TK_QENDTS 130 +#define TK_WSTARTTS 131 +#define TK_WENDTS 132 +#define TK_WDURATION 133 +#define TK_BETWEEN 134 +#define TK_IS 135 #define TK_NK_LT 136 #define TK_NK_GT 137 #define TK_NK_LE 138 diff --git a/include/libs/executor/executor.h b/include/libs/executor/executor.h index 1d78702bc2..fbdb1d66b4 100644 --- a/include/libs/executor/executor.h +++ b/include/libs/executor/executor.h @@ -20,8 +20,8 @@ extern "C" { #endif -#include "tcommon.h" #include "query.h" +#include "tcommon.h" typedef void* qTaskInfo_t; typedef void* DataSinkHandle; @@ -36,7 +36,7 @@ typedef struct SReadHandle { #define STREAM_DATA_TYPE_SUBMIT_BLOCK 0x1 #define STREAM_DATA_TYPE_SSDATA_BLOCK 0x2 - + /** * Create the exec task for streaming mode * @param pMsg @@ -62,7 +62,7 @@ int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type); * @param type * @return */ -int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, void** pBlocks, size_t numOfBlocks, int32_t type); +int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type); /** * Update the table id list, add or remove. @@ -167,7 +167,6 @@ int32_t qUpdateQueriedTableIdList(qTaskInfo_t tinfo, int64_t uid, int32_t type); */ void** qReleaseTask(void* pMgmt, void* pQInfo, bool freeHandle); - void qProcessFetchRsp(void* parent, struct SRpcMsg* pMsg, struct SEpSet* pEpSet); #ifdef __cplusplus diff --git a/include/os/os.h b/include/os/os.h index e7ce7d09ea..fa9d61b997 100644 --- a/include/os/os.h +++ b/include/os/os.h @@ -42,6 +42,9 @@ extern "C" { #include #include #include +#include +#include +#include #if defined(DARWIN) #else diff --git a/include/util/taoserror.h b/include/util/taoserror.h index 994ad7afc6..d49e83b012 100644 --- a/include/util/taoserror.h +++ b/include/util/taoserror.h @@ -16,7 +16,7 @@ #ifndef _TD_UTIL_TAOS_ERROR_H_ #define _TD_UTIL_TAOS_ERROR_H_ -#include "os.h" +#include #ifdef __cplusplus extern "C" { diff --git a/include/util/tprocess.h b/include/util/tprocess.h index be6d58615e..51ce0243b7 100644 --- a/include/util/tprocess.h +++ b/include/util/tprocess.h @@ -22,7 +22,7 @@ extern "C" { #endif -typedef enum { PROC_REQ, PROC_RSP, PROC_REGISTER } ProcFuncType; +typedef enum { PROC_REQ, PROC_RSP, PROC_REG, PROC_RELEASE } ProcFuncType; typedef struct SProcQueue SProcQueue; typedef struct SProcObj SProcObj; diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c index a84aebabc8..40c601f63f 100644 --- a/source/client/src/clientMain.c +++ b/source/client/src/clientMain.c @@ -1,12 +1,27 @@ -#include "os.h" -#include "tref.h" -#include "trpc.h" +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#include "catalog.h" #include "clientInt.h" #include "clientLog.h" +#include "os.h" #include "query.h" -#include "tmsg.h" #include "tglobal.h" -#include "catalog.h" +#include "tmsg.h" +#include "tref.h" +#include "trpc.h" #include "version.h" #define TSC_VAR_NOT_RELEASE 1 @@ -24,7 +39,7 @@ int taos_options(TSDB_OPTION option, const void *arg, ...) { } } - int ret = taos_options_imp(option, (const char*)arg); + int ret = taos_options_imp(option, (const char *)arg); atomic_store_32(&lock, 0); return ret; } @@ -69,13 +84,13 @@ TAOS *taos_connect(const char *ip, const char *user, const char *pass, const cha return taos_connect_internal(ip, user, pass, NULL, db, port); } -void taos_close(TAOS* taos) { +void taos_close(TAOS *taos) { if (taos == NULL) { return; } STscObj *pTscObj = (STscObj *)taos; - tscDebug("0x%"PRIx64" try to close connection, numOfReq:%d", pTscObj->id, pTscObj->numOfReqs); + tscDebug("0x%" PRIx64 " try to close connection, numOfReq:%d", pTscObj->id, pTscObj->numOfReqs); /*taosRemoveRef(clientConnRefPool, pTscObj->id);*/ } @@ -85,48 +100,46 @@ int taos_errno(TAOS_RES *tres) { return terrno; } - return ((SRequestObj*) tres)->code; + return ((SRequestObj *)tres)->code; } const char *taos_errstr(TAOS_RES *res) { - SRequestObj *pRequest = (SRequestObj *) res; + SRequestObj *pRequest = (SRequestObj *)res; if (pRequest == NULL) { - return (const char*) tstrerror(terrno); + return (const char *)tstrerror(terrno); } if (strlen(pRequest->msgBuf) > 0 || pRequest->code == TSDB_CODE_RPC_FQDN_ERROR) { return pRequest->msgBuf; } else { - return (const char*)tstrerror(pRequest->code); + return (const char *)tstrerror(pRequest->code); } } void taos_free_result(TAOS_RES *res) { - SRequestObj* pRequest = (SRequestObj*) res; + SRequestObj *pRequest = (SRequestObj *)res; destroyRequest(pRequest); } -int taos_field_count(TAOS_RES *res) { +int taos_field_count(TAOS_RES *res) { if (res == NULL) { return 0; } - SRequestObj* pRequest = (SRequestObj*) res; - SReqResultInfo* pResInfo = &pRequest->body.resInfo; + SRequestObj *pRequest = (SRequestObj *)res; + SReqResultInfo *pResInfo = &pRequest->body.resInfo; return pResInfo->numOfCols; } -int taos_num_fields(TAOS_RES *res) { - return taos_field_count(res); -} +int taos_num_fields(TAOS_RES *res) { return taos_field_count(res); } TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) { if (taos_num_fields(res) == 0) { return NULL; } - SReqResultInfo* pResInfo = &(((SRequestObj*) res)->body.resInfo); + SReqResultInfo *pResInfo = &(((SRequestObj *)res)->body.resInfo); return pResInfo->fields; } @@ -135,7 +148,7 @@ TAOS_RES *taos_query(TAOS *taos, const char *sql) { return NULL; } - return taos_query_l(taos, sql, (int32_t) strlen(sql)); + return taos_query_l(taos, sql, (int32_t)strlen(sql)); } TAOS_ROW taos_fetch_row(TAOS_RES *res) { @@ -143,18 +156,16 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) { return NULL; } - SRequestObj *pRequest = (SRequestObj *) res; - if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT || - pRequest->type == TSDB_SQL_INSERT || - pRequest->code != TSDB_CODE_SUCCESS || - taos_num_fields(res) == 0) { + SRequestObj *pRequest = (SRequestObj *)res; + if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT || pRequest->type == TSDB_SQL_INSERT || + pRequest->code != TSDB_CODE_SUCCESS || taos_num_fields(res) == 0) { return NULL; } return doFetchRow(pRequest, true); } -int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) { +int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) { int32_t len = 0; for (int i = 0; i < num_fields; ++i) { if (i > 0) { @@ -213,7 +224,7 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) case TSDB_DATA_TYPE_BINARY: case TSDB_DATA_TYPE_NCHAR: { - int32_t charLen = varDataLen((char*)row[i] - VARSTR_HEADER_SIZE); + int32_t charLen = varDataLen((char *)row[i] - VARSTR_HEADER_SIZE); if (fields[i].type == TSDB_DATA_TYPE_BINARY) { assert(charLen <= fields[i].bytes && charLen >= 0); } else { @@ -238,31 +249,44 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) return len; } -int* taos_fetch_lengths(TAOS_RES *res) { +int *taos_fetch_lengths(TAOS_RES *res) { if (res == NULL) { return NULL; } - return ((SRequestObj*) res)->body.resInfo.length; + return ((SRequestObj *)res)->body.resInfo.length; } // todo intergrate with tDataTypes const char *taos_data_type(int type) { switch (type) { - case TSDB_DATA_TYPE_NULL: return "TSDB_DATA_TYPE_NULL"; - case TSDB_DATA_TYPE_BOOL: return "TSDB_DATA_TYPE_BOOL"; - case TSDB_DATA_TYPE_TINYINT: return "TSDB_DATA_TYPE_TINYINT"; - case TSDB_DATA_TYPE_SMALLINT: return "TSDB_DATA_TYPE_SMALLINT"; - case TSDB_DATA_TYPE_INT: return "TSDB_DATA_TYPE_INT"; - case TSDB_DATA_TYPE_BIGINT: return "TSDB_DATA_TYPE_BIGINT"; - case TSDB_DATA_TYPE_FLOAT: return "TSDB_DATA_TYPE_FLOAT"; - case TSDB_DATA_TYPE_DOUBLE: return "TSDB_DATA_TYPE_DOUBLE"; - case TSDB_DATA_TYPE_VARCHAR: return "TSDB_DATA_TYPE_VARCHAR"; -// case TSDB_DATA_TYPE_BINARY: return "TSDB_DATA_TYPE_VARCHAR"; - case TSDB_DATA_TYPE_TIMESTAMP: return "TSDB_DATA_TYPE_TIMESTAMP"; - case TSDB_DATA_TYPE_NCHAR: return "TSDB_DATA_TYPE_NCHAR"; - case TSDB_DATA_TYPE_JSON: return "TSDB_DATA_TYPE_JSON"; - default: return "UNKNOWN"; + case TSDB_DATA_TYPE_NULL: + return "TSDB_DATA_TYPE_NULL"; + case TSDB_DATA_TYPE_BOOL: + return "TSDB_DATA_TYPE_BOOL"; + case TSDB_DATA_TYPE_TINYINT: + return "TSDB_DATA_TYPE_TINYINT"; + case TSDB_DATA_TYPE_SMALLINT: + return "TSDB_DATA_TYPE_SMALLINT"; + case TSDB_DATA_TYPE_INT: + return "TSDB_DATA_TYPE_INT"; + case TSDB_DATA_TYPE_BIGINT: + return "TSDB_DATA_TYPE_BIGINT"; + case TSDB_DATA_TYPE_FLOAT: + return "TSDB_DATA_TYPE_FLOAT"; + case TSDB_DATA_TYPE_DOUBLE: + return "TSDB_DATA_TYPE_DOUBLE"; + case TSDB_DATA_TYPE_VARCHAR: + return "TSDB_DATA_TYPE_VARCHAR"; + // case TSDB_DATA_TYPE_BINARY: return "TSDB_DATA_TYPE_VARCHAR"; + case TSDB_DATA_TYPE_TIMESTAMP: + return "TSDB_DATA_TYPE_TIMESTAMP"; + case TSDB_DATA_TYPE_NCHAR: + return "TSDB_DATA_TYPE_NCHAR"; + case TSDB_DATA_TYPE_JSON: + return "TSDB_DATA_TYPE_JSON"; + default: + return "UNKNOWN"; } } @@ -273,8 +297,8 @@ int taos_affected_rows(TAOS_RES *res) { return 0; } - SRequestObj* pRequest = (SRequestObj*) res; - SReqResultInfo* pResInfo = &pRequest->body.resInfo; + SRequestObj *pRequest = (SRequestObj *)res; + SReqResultInfo *pResInfo = &pRequest->body.resInfo; return pResInfo->numOfRows; } @@ -295,8 +319,8 @@ int taos_select_db(TAOS *taos, const char *db) { char sql[256] = {0}; snprintf(sql, tListLen(sql), "use %s", db); - TAOS_RES* pRequest = taos_query(taos, sql); - int32_t code = taos_errno(pRequest); + TAOS_RES *pRequest = taos_query(taos, sql); + int32_t code = taos_errno(pRequest); taos_free_result(pRequest); return code; @@ -307,61 +331,57 @@ void taos_stop_query(TAOS_RES *res) { return; } - SRequestObj* pRequest = (SRequestObj*) res; - int32_t numOfFields = taos_num_fields(pRequest); + SRequestObj *pRequest = (SRequestObj *)res; + int32_t numOfFields = taos_num_fields(pRequest); // It is not a query, no need to stop. if (numOfFields == 0) { return; } -// scheduleCancelJob(pRequest->body.pQueryJob); + // scheduleCancelJob(pRequest->body.pQueryJob); } bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) { - SRequestObj* pRequestObj = res; - SReqResultInfo* pResultInfo = &pRequestObj->body.resInfo; + SRequestObj *pRequestObj = res; + SReqResultInfo *pResultInfo = &pRequestObj->body.resInfo; if (col >= pResultInfo->numOfCols || col < 0 || row >= pResultInfo->numOfRows || row < 0) { return true; } - SResultColumn* pCol = &pRequestObj->body.resInfo.pCol[col]; + SResultColumn *pCol = &pRequestObj->body.resInfo.pCol[col]; return colDataIsNull_f(pCol->nullbitmap, row); } -int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) { +int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) { if (res == NULL) { return 0; } - SRequestObj *pRequest = (SRequestObj *) res; - if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT || - pRequest->type == TSDB_SQL_INSERT || - pRequest->code != TSDB_CODE_SUCCESS || - taos_num_fields(res) == 0) { + SRequestObj *pRequest = (SRequestObj *)res; + if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT || pRequest->type == TSDB_SQL_INSERT || + pRequest->code != TSDB_CODE_SUCCESS || taos_num_fields(res) == 0) { return 0; } doFetchRow(pRequest, false); // TODO refactor - SReqResultInfo* pResultInfo = &pRequest->body.resInfo; + SReqResultInfo *pResultInfo = &pRequest->body.resInfo; pResultInfo->current = pResultInfo->numOfRows; *rows = pResultInfo->row; return pResultInfo->numOfRows; } -int taos_validate_sql(TAOS *taos, const char *sql) { - return true; -} +int taos_validate_sql(TAOS *taos, const char *sql) { return true; } const char *taos_get_server_info(TAOS *taos) { if (taos == NULL) { return NULL; } - STscObj* pTscObj = (STscObj*) taos; + STscObj *pTscObj = (STscObj *)taos; return pTscObj->ver; } @@ -387,52 +407,67 @@ void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress) { // TODO } -TAOS_STMT* taos_stmt_init(TAOS* taos) { - // TODO - return NULL; +int taos_load_table_info(TAOS *taos, const char *tableNameList) { + // TODO + return -1; } -int taos_stmt_close(TAOS_STMT* stmt) { - // TODO - return -1; +TAOS_STMT *taos_stmt_init(TAOS *taos) { + // TODO + return NULL; } -int taos_stmt_execute(TAOS_STMT* stmt) { - // TODO - return -1; +int taos_stmt_close(TAOS_STMT *stmt) { + // TODO + return -1; +} + +int taos_stmt_execute(TAOS_STMT *stmt) { + // TODO + return -1; } char *taos_stmt_errstr(TAOS_STMT *stmt) { - // TODO - return NULL; + // TODO + return NULL; } -int taos_stmt_affected_rows(TAOS_STMT* stmt) { +int taos_stmt_affected_rows(TAOS_STMT *stmt) { + // TODO + return -1; +} + +TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision) { + // TODO + return NULL; +} + +int taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_BIND *bind) { + // TODO + return -1; +} + +int taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length) { + // TODO + return -1; +} + +int taos_stmt_set_tbname_tags(TAOS_STMT *stmt, const char *name, TAOS_BIND *tags) { + // TODO + return -1; +} + +int taos_stmt_set_tbname(TAOS_STMT *stmt, const char *name) { + // TODO + return -1; +} + +int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) { // TODO return -1; } -TAOS_RES* taos_schemaless_insert(TAOS* taos, char* lines[], int numLines, int protocol, int precision) { - // TODO - return NULL; -} - -int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) { - // TODO - return -1; -} - -int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) { - // TODO - return -1; -} - -int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags) { - // TODO - return -1; -} - -int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) { +int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) { // TODO return -1; } @@ -442,6 +477,11 @@ int taos_stmt_add_batch(TAOS_STMT* stmt) { return -1; } +TAOS_RES *taos_stmt_use_result(TAOS_STMT *stmt) { + // TODO + return NULL; +} + int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) { // TODO return -1; diff --git a/source/client/src/tmq.c b/source/client/src/tmq.c index 5d00cca76e..f7593595b0 100644 --- a/source/client/src/tmq.c +++ b/source/client/src/tmq.c @@ -26,6 +26,18 @@ #include "tqueue.h" #include "tref.h" +typedef struct { + int32_t curBlock; + int32_t curRow; + void** uData; +} SMqRowIter; + +struct tmq_message_t { + SMqPollRsp msg; + void* vg; + SMqRowIter iter; +}; + struct tmq_list_t { SArray container; }; @@ -99,13 +111,14 @@ typedef struct { typedef struct { // subscribe info - int32_t sqlLen; - char* sql; - char* topicName; - int64_t topicId; - int32_t nextVgIdx; - SArray* vgs; // SArray - SSchemaWrapper schema; + int32_t sqlLen; + char* sql; + char* topicName; + int64_t topicId; + SArray* vgs; // SArray + int8_t isSchemaAdaptive; + int32_t numOfFields; + TAOS_FIELD* fields; } SMqClientTopic; typedef struct { @@ -130,11 +143,11 @@ typedef struct { } SMqPollCbParam; typedef struct { - tmq_t* tmq; - /*SMqClientVg* pVg;*/ + tmq_t* tmq; int32_t async; tsem_t rspSem; tmq_resp_err_t rspErr; + /*SMqClientVg* pVg;*/ } SMqCommitCbParam; tmq_conf_t* tmq_conf_new() { @@ -471,7 +484,12 @@ tmq_resp_err_t tmq_subscribe(tmq_t* tmq, tmq_list_t* topic_list) { tNameExtractFullName(&name, topicFname); tscDebug("subscribe topic: %s", topicFname); SMqClientTopic topic = { - .nextVgIdx = 0, .sql = NULL, .sqlLen = 0, .topicId = 0, .topicName = topicFname, .vgs = NULL}; + .sql = NULL, + .sqlLen = 0, + .topicId = 0, + .topicName = topicFname, + .vgs = NULL, + }; topic.vgs = taosArrayInit(0, sizeof(SMqClientVg)); taosArrayPush(tmq->clientTopics, &topic); taosArrayPush(req.topicNames, &topicFname); @@ -615,6 +633,7 @@ _return: return pRequest; } +#if 0 TAOS_RES* tmq_create_topic(TAOS* taos, const char* topicName, const char* sql, int sqlLen) { STscObj* pTscObj = (STscObj*)taos; SRequestObj* pRequest = NULL; @@ -700,6 +719,7 @@ _return: return pRequest; } +#endif static char* formatTimestamp(char* buf, int64_t val, int precision) { time_t tt; diff --git a/source/client/test/tmqTest.cpp b/source/client/test/tmqTest.cpp index c34c10d871..d45050d7ff 100644 --- a/source/client/test/tmqTest.cpp +++ b/source/client/test/tmqTest.cpp @@ -35,7 +35,7 @@ int main(int argc, char** argv) { TEST(testCase, driverInit_Test) { // taosInitGlobalCfg(); -// taos_init(); + // taos_init(); } TEST(testCase, create_topic_ctb_Test) { @@ -55,8 +55,9 @@ TEST(testCase, create_topic_ctb_Test) { taos_free_result(pRes); - char* sql = "select * from tu"; - pRes = tmq_create_topic(pConn, "test_ctb_topic_1", sql, strlen(sql)); + // char* sql = "select * from tu"; + // pRes = tmq_create_topic(pConn, "test_ctb_topic_1", sql, strlen(sql)); + pRes = taos_query(pConn, "create test_ctb_topic_1 as select * from tu"); taos_free_result(pRes); taos_close(pConn); } @@ -69,7 +70,7 @@ TEST(testCase, create_topic_stb_Test) { if (taos_errno(pRes) != 0) { printf("error in use db, reason:%s\n", taos_errstr(pRes)); } - //taos_free_result(pRes); + // taos_free_result(pRes); TAOS_FIELD* pFields = taos_fetch_fields(pRes); ASSERT_TRUE(pFields == nullptr); @@ -79,8 +80,9 @@ TEST(testCase, create_topic_stb_Test) { taos_free_result(pRes); - char* sql = "select * from st1"; - pRes = tmq_create_topic(pConn, "test_stb_topic_1", sql, strlen(sql)); + // char* sql = "select * from st1"; + // pRes = tmq_create_topic(pConn, "test_stb_topic_1", sql, strlen(sql)); + pRes = taos_query(pConn, "create test_ctb_topic_1 as select * from st1"); taos_free_result(pRes); taos_close(pConn); } diff --git a/source/common/src/tmsgcb.c b/source/common/src/tmsgcb.c index 2b68aab95a..e90634a604 100644 --- a/source/common/src/tmsgcb.c +++ b/source/common/src/tmsgcb.c @@ -16,6 +16,10 @@ #define _DEFAULT_SOURCE #include "tmsgcb.h" +static SMsgCb tsDefaultMsgCb; + +void tmsgSetDefaultMsgCb(const SMsgCb* pMsgCb) { tsDefaultMsgCb = *pMsgCb; } + int32_t tmsgPutToQueue(const SMsgCb* pMsgCb, EQueueType qtype, SRpcMsg* pReq) { return (*pMsgCb->queueFps[qtype])(pMsgCb->pWrapper, pReq); } @@ -32,12 +36,12 @@ int32_t tmsgSendMnodeReq(const SMsgCb* pMsgCb, SRpcMsg* pReq) { return (*pMsgCb->sendMnodeReqFp)(pMsgCb->pWrapper, pReq); } -void tmsgSendRsp(const SMsgCb* pMsgCb, const SRpcMsg* pRsp) { return (*pMsgCb->sendRspFp)(pMsgCb->pWrapper, pRsp); } +void tmsgSendRsp(const SRpcMsg* pRsp) { return (*tsDefaultMsgCb.sendRspFp)(tsDefaultMsgCb.pWrapper, pRsp); } void tmsgRegisterBrokenLinkArg(const SMsgCb* pMsgCb, SRpcMsg* pMsg) { (*pMsgCb->registerBrokenLinkArgFp)(pMsgCb->pWrapper, pMsg); } -void tmsgReleaseHandle(const SMsgCb* pMsgCb, void* handle, int8_t type) { - (*pMsgCb->releaseHandleFp)(pMsgCb->pWrapper, handle, type); +void tmsgReleaseHandle(void* handle, int8_t type) { + (*tsDefaultMsgCb.releaseHandleFp)(tsDefaultMsgCb.pWrapper, handle, type); } \ No newline at end of file diff --git a/source/dnode/mgmt/CMakeLists.txt b/source/dnode/mgmt/CMakeLists.txt index 35ea166983..81c434eb27 100644 --- a/source/dnode/mgmt/CMakeLists.txt +++ b/source/dnode/mgmt/CMakeLists.txt @@ -1,12 +1,10 @@ -aux_source_directory(src DNODE_SRC) -aux_source_directory(dnode/src DNODE_SRC) -aux_source_directory(qnode/src DNODE_SRC) -aux_source_directory(bnode/src DNODE_SRC) -aux_source_directory(snode/src DNODE_SRC) -aux_source_directory(vnode/src DNODE_SRC) -aux_source_directory(mnode/src DNODE_SRC) -aux_source_directory(container/src DNODE_SRC) - +aux_source_directory(dm/src DNODE_SRC) +aux_source_directory(qm/src DNODE_SRC) +aux_source_directory(bm/src DNODE_SRC) +aux_source_directory(sm/src DNODE_SRC) +aux_source_directory(vm/src DNODE_SRC) +aux_source_directory(mm/src DNODE_SRC) +aux_source_directory(main/src DNODE_SRC) add_library(dnode STATIC ${DNODE_SRC}) target_link_libraries( dnode cjson mnode vnode qnode snode bnode wal sync taos tfs monitor @@ -14,16 +12,22 @@ target_link_libraries( target_include_directories( dnode PUBLIC "${CMAKE_SOURCE_DIR}/include/dnode/mgmt" - PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/dnode/inc" - PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/qnode/inc" - PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/bnode/inc" - PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/snode/inc" - PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/vnode/inc" - PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/mnode/inc" - PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/container/inc" + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/dm/inc" + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/qm/inc" + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/bm/inc" + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/sm/inc" + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/vm/inc" + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/mm/inc" + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/main/inc" ) -add_subdirectory(main) +aux_source_directory(main/exe EXEC_SRC) +add_executable(taosd ${EXEC_SRC}) +target_include_directories( + taosd + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/main/inc" +) +target_link_libraries(taosd dnode) if(${BUILD_TEST}) add_subdirectory(test) diff --git a/source/dnode/mgmt/bnode/inc/bm.h b/source/dnode/mgmt/bm/inc/bm.h similarity index 100% rename from source/dnode/mgmt/bnode/inc/bm.h rename to source/dnode/mgmt/bm/inc/bm.h diff --git a/source/dnode/mgmt/bnode/inc/bmInt.h b/source/dnode/mgmt/bm/inc/bmInt.h similarity index 100% rename from source/dnode/mgmt/bnode/inc/bmInt.h rename to source/dnode/mgmt/bm/inc/bmInt.h diff --git a/source/dnode/mgmt/bnode/src/bmInt.c b/source/dnode/mgmt/bm/src/bmInt.c similarity index 100% rename from source/dnode/mgmt/bnode/src/bmInt.c rename to source/dnode/mgmt/bm/src/bmInt.c diff --git a/source/dnode/mgmt/bnode/src/bmMsg.c b/source/dnode/mgmt/bm/src/bmMsg.c similarity index 100% rename from source/dnode/mgmt/bnode/src/bmMsg.c rename to source/dnode/mgmt/bm/src/bmMsg.c diff --git a/source/dnode/mgmt/bnode/src/bmWorker.c b/source/dnode/mgmt/bm/src/bmWorker.c similarity index 100% rename from source/dnode/mgmt/bnode/src/bmWorker.c rename to source/dnode/mgmt/bm/src/bmWorker.c diff --git a/source/dnode/mgmt/dnode/inc/dm.h b/source/dnode/mgmt/dm/inc/dm.h similarity index 100% rename from source/dnode/mgmt/dnode/inc/dm.h rename to source/dnode/mgmt/dm/inc/dm.h diff --git a/source/dnode/mgmt/dnode/inc/dmInt.h b/source/dnode/mgmt/dm/inc/dmInt.h similarity index 100% rename from source/dnode/mgmt/dnode/inc/dmInt.h rename to source/dnode/mgmt/dm/inc/dmInt.h diff --git a/source/dnode/mgmt/dnode/src/dmFile.c b/source/dnode/mgmt/dm/src/dmFile.c similarity index 100% rename from source/dnode/mgmt/dnode/src/dmFile.c rename to source/dnode/mgmt/dm/src/dmFile.c diff --git a/source/dnode/mgmt/dnode/src/dmInt.c b/source/dnode/mgmt/dm/src/dmInt.c similarity index 100% rename from source/dnode/mgmt/dnode/src/dmInt.c rename to source/dnode/mgmt/dm/src/dmInt.c diff --git a/source/dnode/mgmt/dnode/src/dmMsg.c b/source/dnode/mgmt/dm/src/dmMsg.c similarity index 100% rename from source/dnode/mgmt/dnode/src/dmMsg.c rename to source/dnode/mgmt/dm/src/dmMsg.c diff --git a/source/dnode/mgmt/dnode/src/dmWorker.c b/source/dnode/mgmt/dm/src/dmWorker.c similarity index 100% rename from source/dnode/mgmt/dnode/src/dmWorker.c rename to source/dnode/mgmt/dm/src/dmWorker.c diff --git a/source/dnode/mgmt/main/CMakeLists.txt b/source/dnode/mgmt/main/CMakeLists.txt deleted file mode 100644 index baa486b91f..0000000000 --- a/source/dnode/mgmt/main/CMakeLists.txt +++ /dev/null @@ -1,9 +0,0 @@ -aux_source_directory(src EXEC_SRC) -add_executable(taosd ${EXEC_SRC}) - -target_include_directories( - taosd - PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc" -) - -target_link_libraries(taosd dnode) diff --git a/source/dnode/mgmt/main/exe/dndMain.c b/source/dnode/mgmt/main/exe/dndMain.c new file mode 100644 index 0000000000..634e2caa28 --- /dev/null +++ b/source/dnode/mgmt/main/exe/dndMain.c @@ -0,0 +1,199 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#define _DEFAULT_SOURCE +#include "dnd.h" +#include "tconfig.h" + +static struct { + bool dumpConfig; + bool generateGrant; + bool printAuth; + bool printVersion; + char envFile[PATH_MAX]; + char apolloUrl[PATH_MAX]; + SArray *pArgs; // SConfigPair + SDnode *pDnode; + ENodeType ntype; +} global = {0}; + +static void dndSigintHandle(int signum, void *info, void *ctx) { + dInfo("signal:%d is received", signum); + SDnode *pDnode = atomic_val_compare_exchange_ptr(&global.pDnode, 0, global.pDnode); + if (pDnode != NULL) { + dndHandleEvent(pDnode, DND_EVENT_STOP); + } +} + +static void dndSetSignalHandle() { + taosSetSignal(SIGTERM, dndSigintHandle); + taosSetSignal(SIGHUP, dndSigintHandle); + taosSetSignal(SIGINT, dndSigintHandle); + taosSetSignal(SIGABRT, dndSigintHandle); + taosSetSignal(SIGBREAK, dndSigintHandle); +} + +static int32_t dndParseArgs(int32_t argc, char const *argv[]) { + for (int32_t i = 1; i < argc; ++i) { + if (strcmp(argv[i], "-c") == 0) { + if (i < argc - 1) { + if (strlen(argv[++i]) >= PATH_MAX) { + printf("config file path overflow"); + return -1; + } + tstrncpy(configDir, argv[i], PATH_MAX); + } else { + printf("'-c' requires a parameter, default is %s\n", configDir); + return -1; + } + } else if (strcmp(argv[i], "-a") == 0) { + tstrncpy(global.apolloUrl, argv[++i], PATH_MAX); + } else if (strcmp(argv[i], "-e") == 0) { + tstrncpy(global.envFile, argv[++i], PATH_MAX); + } else if (strcmp(argv[i], "-k") == 0) { + global.generateGrant = true; + } else if (strcmp(argv[i], "-n") == 0) { + global.ntype = atoi(argv[++i]); + } else if (strcmp(argv[i], "-C") == 0) { + global.dumpConfig = true; + } else if (strcmp(argv[i], "-V") == 0) { + global.printVersion = true; + } else { + } + } + + return 0; +} + +static void dndGenerateGrant() { + // grantParseParameter(); + printf("this feature is not implemented yet\n"); +} + +static void dndPrintVersion() { +#ifdef TD_ENTERPRISE + char *releaseName = "enterprise"; +#else + char *releaseName = "community"; +#endif + printf("%s version: %s compatible_version: %s\n", releaseName, version, compatible_version); + printf("gitinfo: %s\n", gitinfo); + printf("buildInfo: %s\n", buildinfo); +} + +static void dndDumpCfg() { + SConfig *pCfg = taosGetCfg(); + cfgDumpCfg(pCfg, 0, 1); +} + +static SDnodeOpt dndGetOpt() { + SConfig *pCfg = taosGetCfg(); + SDnodeOpt option = {0}; + + option.numOfSupportVnodes = cfgGetItem(pCfg, "supportVnodes")->i32; + tstrncpy(option.dataDir, tsDataDir, sizeof(option.dataDir)); + tstrncpy(option.firstEp, tsFirst, sizeof(option.firstEp)); + tstrncpy(option.secondEp, tsSecond, sizeof(option.firstEp)); + option.serverPort = tsServerPort; + tstrncpy(option.localFqdn, tsLocalFqdn, sizeof(option.localFqdn)); + snprintf(option.localEp, sizeof(option.localEp), "%s:%u", option.localFqdn, option.serverPort); + option.pDisks = tsDiskCfg; + option.numOfDisks = tsDiskCfgNum; + return option; +} + +static int32_t dndInitLog() { + char logName[12] = {0}; + snprintf(logName, sizeof(logName), "%slog", dndNodeLogStr(global.ntype)); + return taosCreateLog(logName, 1, configDir, global.envFile, global.apolloUrl, global.pArgs, 0); +} + +static void dndSetProcName(char **argv) { + if (global.ntype != 0) { + const char *name = dndNodeProcStr(global.ntype); + prctl(PR_SET_NAME, name); + strcpy(argv[0], name); + } +} + +static int32_t dndRunDnode() { + if (dndInit() != 0) { + dError("failed to initialize environment since %s", terrstr()); + return -1; + } + + SDnodeOpt option = dndGetOpt(); + SDnode *pDnode = dndCreate(&option); + if (pDnode == NULL) { + dError("failed to to create dnode object since %s", terrstr()); + return -1; + } else { + global.pDnode = pDnode; + dndSetSignalHandle(); + } + + dInfo("start the service"); + int32_t code = dndRun(pDnode); + dInfo("start shutting down the service"); + + global.pDnode = NULL; + dndClose(pDnode); + dndCleanup(); + taosCloseLog(); + taosCleanupCfg(); + return code; +} + +int main(int argc, char const *argv[]) { + if (!taosCheckSystemIsSmallEnd()) { + printf("failed to start since on non-small-end machines\n"); + return -1; + } + + if (dndParseArgs(argc, argv) != 0) { + printf("failed to start since parse args error\n"); + return -1; + } + + if (global.generateGrant) { + dndGenerateGrant(); + return 0; + } + + if (global.printVersion) { + dndPrintVersion(); + return 0; + } + + if (dndInitLog() != 0) { + printf("failed to start since init log error\n"); + return -1; + } + + if (taosInitCfg(configDir, global.envFile, global.apolloUrl, global.pArgs, 0) != 0) { + dError("failed to start since read config error"); + return -1; + } + + if (global.dumpConfig) { + dndDumpCfg(); + taosCleanupCfg(); + taosCloseLog(); + return 0; + } + + dndSetProcName((char **)argv); + return dndRunDnode(); +} diff --git a/source/dnode/mgmt/container/inc/dnd.h b/source/dnode/mgmt/main/inc/dnd.h similarity index 90% rename from source/dnode/mgmt/container/inc/dnd.h rename to source/dnode/mgmt/main/inc/dnd.h index 3cdde09532..046200510d 100644 --- a/source/dnode/mgmt/container/inc/dnd.h +++ b/source/dnode/mgmt/main/inc/dnd.h @@ -33,6 +33,7 @@ #include "tthread.h" #include "ttime.h" #include "tworker.h" +#include "tmsgcb.h" #include "dnode.h" #include "monitor.h" @@ -130,16 +131,19 @@ typedef struct SDnode { SMgmtWrapper wrappers[NODE_MAX]; } SDnode; -EDndStatus dndGetStatus(SDnode *pDnode); -void dndSetStatus(SDnode *pDnode, EDndStatus stat); -void dndSetMsgHandle(SMgmtWrapper *pWrapper, int32_t msgType, NodeMsgFp nodeMsgFp, int32_t vgId); -void dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc); -void dndSendMonitorReport(SDnode *pDnode); +const char *dndNodeLogStr(ENodeType ntype); +const char *dndNodeProcStr(ENodeType ntype); +EDndStatus dndGetStatus(SDnode *pDnode); +void dndSetStatus(SDnode *pDnode, EDndStatus stat); +void dndSetMsgHandle(SMgmtWrapper *pWrapper, int32_t msgType, NodeMsgFp nodeMsgFp, int32_t vgId); +void dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc); +void dndSendMonitorReport(SDnode *pDnode); int32_t dndSendReqToMnode(SMgmtWrapper *pWrapper, SRpcMsg *pMsg); int32_t dndSendReqToDnode(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pMsg); void dndSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp); void dndRegisterBrokenLinkArg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg); +SMsgCb dndCreateMsgcb(SMgmtWrapper *pWrapper); int32_t dndProcessNodeMsg(SDnode *pDnode, SNodeMsg *pMsg); int32_t dndReadFile(SMgmtWrapper *pWrapper, bool *pDeployed); diff --git a/source/dnode/mgmt/container/inc/dndInt.h b/source/dnode/mgmt/main/inc/dndInt.h similarity index 100% rename from source/dnode/mgmt/container/inc/dndInt.h rename to source/dnode/mgmt/main/inc/dndInt.h diff --git a/source/dnode/mgmt/main/inc/dndMain.h b/source/dnode/mgmt/main/inc/dndMain.h deleted file mode 100644 index 1958d628a0..0000000000 --- a/source/dnode/mgmt/main/inc/dndMain.h +++ /dev/null @@ -1,48 +0,0 @@ - -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#ifndef _TD_DND_MAIN_H_ -#define _TD_DND_MAIN_H_ - -#include "dnode.h" - -#include "taoserror.h" -#include "tconfig.h" -#include "tglobal.h" -#include "tlog.h" -#include "version.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define dFatal(...) { if (dDebugFlag & DEBUG_FATAL) { taosPrintLog("DND FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); }} -#define dError(...) { if (dDebugFlag & DEBUG_ERROR) { taosPrintLog("DND ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }} -#define dWarn(...) { if (dDebugFlag & DEBUG_WARN) { taosPrintLog("DND WARN ", DEBUG_WARN, 255, __VA_ARGS__); }} -#define dInfo(...) { if (dDebugFlag & DEBUG_INFO) { taosPrintLog("DND ", DEBUG_INFO, 255, __VA_ARGS__); }} -#define dDebug(...) { if (dDebugFlag & DEBUG_DEBUG) { taosPrintLog("DND ", DEBUG_DEBUG, dDebugFlag, __VA_ARGS__); }} -#define dTrace(...) { if (dDebugFlag & DEBUG_TRACE) { taosPrintLog("DND ", DEBUG_TRACE, dDebugFlag, __VA_ARGS__); }} - -void dndDumpCfg(); -void dndPrintVersion(); -void dndGenerateGrant(); -SDnodeOpt dndGetOpt(); - -#ifdef __cplusplus -} -#endif - -#endif /*_TD_DND_MAIN_H_*/ diff --git a/source/dnode/mgmt/container/src/dndExec.c b/source/dnode/mgmt/main/src/dndExec.c similarity index 88% rename from source/dnode/mgmt/container/src/dndExec.c rename to source/dnode/mgmt/main/src/dndExec.c index 412fa388b6..5a9077a937 100644 --- a/source/dnode/mgmt/container/src/dndExec.c +++ b/source/dnode/mgmt/main/src/dndExec.c @@ -77,6 +77,8 @@ static int32_t dndRunInSingleProcess(SDnode *pDnode) { SMgmtWrapper *pWrapper = &pDnode->wrappers[n]; pWrapper->required = dndRequireNode(pWrapper); if (!pWrapper->required) continue; + SMsgCb msgCb = dndCreateMsgcb(pWrapper); + tmsgSetDefaultMsgCb(&msgCb); if (taosMkDir(pWrapper->path) != 0) { terrno = TAOS_SYSTEM_ERROR(errno); @@ -120,8 +122,7 @@ static void dndConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t ProcFuncType ftype) { SRpcMsg *pRpc = &pMsg->rpcMsg; pRpc->pCont = pCont; - dTrace("msg:%p, get from child queue, type:%s handle:%p app:%p", pMsg, TMSG_INFO(pRpc->msgType), pRpc->handle, - pRpc->ahandle); + dTrace("msg:%p, get from child queue, handle:%p app:%p", pMsg, pRpc->handle, pRpc->ahandle); NodeMsgFp msgFp = pWrapper->msgFps[TMSG_INDEX(pRpc->msgType)]; int32_t code = (*msgFp)(pWrapper, pMsg); @@ -142,13 +143,19 @@ static void dndConsumeChildQueue(SMgmtWrapper *pWrapper, SNodeMsg *pMsg, int16_t static void dndConsumeParentQueue(SMgmtWrapper *pWrapper, SRpcMsg *pMsg, int16_t msgLen, void *pCont, int32_t contLen, ProcFuncType ftype) { pMsg->pCont = pCont; - dTrace("msg:%p, get from parent queue, type:%s handle:%p app:%p", pMsg, TMSG_INFO(pMsg->msgType), pMsg->handle, - pMsg->ahandle); + dTrace("msg:%p, get from parent queue, handle:%p app:%p", pMsg, pMsg->handle, pMsg->ahandle); switch (ftype) { - case PROC_REGISTER: + case PROC_REG: rpcRegisterBrokenLinkArg(pMsg); break; + case PROC_RELEASE: + rpcReleaseHandle(pMsg->handle, (int8_t)pMsg->code); + rpcFreeCont(pCont); + break; + case PROC_REQ: + // todo send to dnode + dndSendReqToMnode(pWrapper, pMsg); default: dndSendRpcRsp(pWrapper, pMsg); break; @@ -164,6 +171,9 @@ static int32_t dndRunInMultiProcess(SDnode *pDnode) { pWrapper->required = dndRequireNode(pWrapper); if (!pWrapper->required) continue; + SMsgCb msgCb = dndCreateMsgcb(pWrapper); + tmsgSetDefaultMsgCb(&msgCb); + if (taosMkDir(pWrapper->path) != 0) { terrno = TAOS_SYSTEM_ERROR(errno); dError("failed to create dir:%s since %s", pWrapper->path, terrstr()); @@ -211,15 +221,23 @@ static int32_t dndRunInMultiProcess(SDnode *pDnode) { dndClearNodesExecpt(pDnode, n); dInfo("node:%s, will be initialized in child process", pWrapper->name); - dndOpenNode(pWrapper); + if (dndOpenNode(pWrapper) != 0) { + dInfo("node:%s, failed to init in child process since %s", pWrapper->name, terrstr()); + return -1; + } + + if (taosProcRun(pProc) != 0) { + dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr()); + return -1; + } + break; } else { dInfo("node:%s, will not start in parent process, child pid:%d", pWrapper->name, taosProcChildId(pProc)); pWrapper->procType = PROC_PARENT; - } - - if (taosProcRun(pProc) != 0) { - dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr()); - return -1; + if (taosProcRun(pProc) != 0) { + dError("node:%s, failed to run proc since %s", pWrapper->name, terrstr()); + return -1; + } } } diff --git a/source/dnode/mgmt/container/src/dndFile.c b/source/dnode/mgmt/main/src/dndFile.c similarity index 100% rename from source/dnode/mgmt/container/src/dndFile.c rename to source/dnode/mgmt/main/src/dndFile.c diff --git a/source/dnode/mgmt/container/src/dndInt.c b/source/dnode/mgmt/main/src/dndInt.c similarity index 93% rename from source/dnode/mgmt/container/src/dndInt.c rename to source/dnode/mgmt/main/src/dndInt.c index 33d6bb0ee3..a9b1982138 100644 --- a/source/dnode/mgmt/container/src/dndInt.c +++ b/source/dnode/mgmt/main/src/dndInt.c @@ -80,19 +80,6 @@ void dndSetStatus(SDnode *pDnode, EDndStatus status) { } } -const char *dndStatStr(EDndStatus status) { - switch (status) { - case DND_STAT_INIT: - return "init"; - case DND_STAT_RUNNING: - return "running"; - case DND_STAT_STOPPED: - return "stopped"; - default: - return "unknown"; - } -} - void dndReportStartup(SDnode *pDnode, const char *pName, const char *pDesc) { SStartupReq *pStartup = &pDnode->startup; tstrncpy(pStartup->name, pName, TSDB_STEP_NAME_LEN); diff --git a/source/dnode/mgmt/main/src/dndMain.c b/source/dnode/mgmt/main/src/dndMain.c deleted file mode 100644 index 3aff3446da..0000000000 --- a/source/dnode/mgmt/main/src/dndMain.c +++ /dev/null @@ -1,138 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "dndMain.h" - -static struct { - bool dumpConfig; - bool generateGrant; - bool printAuth; - bool printVersion; - char envFile[PATH_MAX]; - char apolloUrl[PATH_MAX]; - SDnode *pDnode; -} global = {0}; - -static void dndSigintHandle(int signum, void *info, void *ctx) { - dInfo("signal:%d is received", signum); - SDnode *pDnode = atomic_val_compare_exchange_ptr(&global.pDnode, 0, global.pDnode); - if (pDnode != NULL) { - dndHandleEvent(pDnode, DND_EVENT_STOP); - } -} - -static void dndSetSignalHandle() { - taosSetSignal(SIGTERM, dndSigintHandle); - taosSetSignal(SIGHUP, dndSigintHandle); - taosSetSignal(SIGINT, dndSigintHandle); - taosSetSignal(SIGABRT, dndSigintHandle); - taosSetSignal(SIGBREAK, dndSigintHandle); -} - -static int32_t dndParseOption(int32_t argc, char const *argv[]) { - for (int32_t i = 1; i < argc; ++i) { - if (strcmp(argv[i], "-c") == 0) { - if (i < argc - 1) { - if (strlen(argv[++i]) >= PATH_MAX) { - printf("config file path overflow"); - return -1; - } - tstrncpy(configDir, argv[i], PATH_MAX); - } else { - printf("'-c' requires a parameter, default is %s\n", configDir); - return -1; - } - } else if (strcmp(argv[i], "-C") == 0) { - global.dumpConfig = true; - } else if (strcmp(argv[i], "-k") == 0) { - global.generateGrant = true; - } else if (strcmp(argv[i], "-V") == 0) { - global.printVersion = true; - } else { - } - } - - return 0; -} - -static int32_t dndRunDnode() { - if (dndInit() != 0) { - dInfo("failed to initialize dnode environment since %s", terrstr()); - return -1; - } - - SDnodeOpt option = dndGetOpt(); - - SDnode *pDnode = dndCreate(&option); - if (pDnode == NULL) { - dError("failed to to create dnode object since %s", terrstr()); - return -1; - } else { - global.pDnode = pDnode; - dndSetSignalHandle(); - } - - dInfo("start the TDengine service"); - int32_t code = dndRun(pDnode); - dInfo("start shutting down the TDengine service"); - - global.pDnode = NULL; - dndClose(pDnode); - dndCleanup(); - taosCloseLog(); - taosCleanupCfg(); - return code; -} - -int main(int argc, char const *argv[]) { - if (!taosCheckSystemIsSmallEnd()) { - dError("failed to start TDengine since on non-small-end machines"); - return -1; - } - - if (dndParseOption(argc, argv) != 0) { - return -1; - } - - if (global.generateGrant) { - dndGenerateGrant(); - return 0; - } - - if (global.printVersion) { - dndPrintVersion(); - return 0; - } - - if (taosCreateLog("taosdlog", 1, configDir, global.envFile, global.apolloUrl, NULL, 0) != 0) { - dError("failed to start TDengine since read log config error"); - return -1; - } - - if (taosInitCfg(configDir, global.envFile, global.apolloUrl, NULL, 0) != 0) { - dError("failed to start TDengine since read config error"); - return -1; - } - - if (global.dumpConfig) { - dndDumpCfg(); - taosCleanupCfg(); - taosCloseLog(); - return 0; - } - - return dndRunDnode(); -} diff --git a/source/dnode/mgmt/container/src/dndMonitor.c b/source/dnode/mgmt/main/src/dndMonitor.c similarity index 100% rename from source/dnode/mgmt/container/src/dndMonitor.c rename to source/dnode/mgmt/main/src/dndMonitor.c diff --git a/source/dnode/mgmt/container/src/dndMsg.c b/source/dnode/mgmt/main/src/dndMsg.c similarity index 100% rename from source/dnode/mgmt/container/src/dndMsg.c rename to source/dnode/mgmt/main/src/dndMsg.c diff --git a/source/dnode/mgmt/container/src/dndObj.c b/source/dnode/mgmt/main/src/dndObj.c similarity index 100% rename from source/dnode/mgmt/container/src/dndObj.c rename to source/dnode/mgmt/main/src/dndObj.c diff --git a/source/dnode/mgmt/main/src/dndStr.c b/source/dnode/mgmt/main/src/dndStr.c new file mode 100644 index 0000000000..00d8b0d6e0 --- /dev/null +++ b/source/dnode/mgmt/main/src/dndStr.c @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#define _DEFAULT_SOURCE +#include "dndInt.h" + +const char *dndStatStr(EDndStatus status) { + switch (status) { + case DND_STAT_INIT: + return "init"; + case DND_STAT_RUNNING: + return "running"; + case DND_STAT_STOPPED: + return "stopped"; + default: + return "unknown"; + } +} + +const char *dndNodeLogStr(ENodeType ntype) { + switch (ntype) { + case VNODES: + return "vnode"; + case QNODE: + return "qnode"; + case SNODE: + return "snode"; + case MNODE: + return "mnode"; + case BNODE: + return "bnode"; + default: + return "taosd"; + } +} + +const char *dndNodeProcStr(ENodeType ntype) { + switch (ntype) { + case VNODES: + return "taosv"; + case QNODE: + return "taosq"; + case SNODE: + return "taoss"; + case MNODE: + return "taosm"; + case BNODE: + return "taosb"; + default: + return "taosd"; + } +} diff --git a/source/dnode/mgmt/container/src/dndTransport.c b/source/dnode/mgmt/main/src/dndTransport.c similarity index 88% rename from source/dnode/mgmt/container/src/dndTransport.c rename to source/dnode/mgmt/main/src/dndTransport.c index baf25b73d6..07ea0309a8 100644 --- a/source/dnode/mgmt/container/src/dndTransport.c +++ b/source/dnode/mgmt/main/src/dndTransport.c @@ -320,8 +320,7 @@ static int32_t dndSendRpcReq(STransMgmt *pMgmt, const SEpSet *pEpSet, SRpcMsg *p } int32_t dndSendReqToDnode(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg *pReq) { - if (pWrapper->procType == PROC_CHILD) { - } else { + if (pWrapper->procType != PROC_CHILD) { SDnode *pDnode = pWrapper->pDnode; if (dndGetStatus(pDnode) != DND_STAT_RUNNING) { terrno = TSDB_CODE_DND_OFFLINE; @@ -329,23 +328,24 @@ int32_t dndSendReqToDnode(SMgmtWrapper *pWrapper, const SEpSet *pEpSet, SRpcMsg return -1; } return dndSendRpcReq(&pDnode->trans, pEpSet, pReq); + } else { + while (taosProcPutToParentQ(pWrapper->pProc, pReq, sizeof(SRpcMsg), pReq->pCont, pReq->contLen, PROC_REQ) != 0) { + taosMsleep(1); + } } } int32_t dndSendReqToMnode(SMgmtWrapper *pWrapper, SRpcMsg *pReq) { - if (pWrapper->procType == PROC_CHILD) { - } else { - SDnode *pDnode = pWrapper->pDnode; - STransMgmt *pTrans = &pDnode->trans; - SEpSet epSet = {0}; + SDnode *pDnode = pWrapper->pDnode; + STransMgmt *pTrans = &pDnode->trans; + SEpSet epSet = {0}; - SMgmtWrapper *pWrapper = dndAcquireWrapper(pDnode, DNODE); - if (pWrapper != NULL) { - dmGetMnodeEpSet(pWrapper->pMgmt, &epSet); - dndReleaseWrapper(pWrapper); - } - return dndSendRpcReq(pTrans, &epSet, pReq); + SMgmtWrapper *pWrapper2 = dndAcquireWrapper(pDnode, DNODE); + if (pWrapper2 != NULL) { + dmGetMnodeEpSet(pWrapper2->pMgmt, &epSet); + dndReleaseWrapper(pWrapper2); } + return dndSendRpcReq(pTrans, &epSet, pReq); } void dndSendRpcRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) { @@ -363,29 +363,44 @@ void dndSendRpcRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) { } void dndSendRsp(SMgmtWrapper *pWrapper, const SRpcMsg *pRsp) { - if (pWrapper->procType == PROC_CHILD) { - int32_t code = -1; - do { - code = taosProcPutToParentQ(pWrapper->pProc, pRsp, sizeof(SRpcMsg), pRsp->pCont, pRsp->contLen, PROC_RSP); - if (code != 0) { - taosMsleep(10); - } - } while (code != 0); - } else { + if (pWrapper->procType != PROC_CHILD) { dndSendRpcRsp(pWrapper, pRsp); + } else { + while (taosProcPutToParentQ(pWrapper->pProc, pRsp, sizeof(SRpcMsg), pRsp->pCont, pRsp->contLen, PROC_RSP) != 0) { + taosMsleep(1); + } } } void dndRegisterBrokenLinkArg(SMgmtWrapper *pWrapper, SRpcMsg *pMsg) { - if (pWrapper->procType == PROC_CHILD) { - int32_t code = -1; - do { - code = taosProcPutToParentQ(pWrapper->pProc, pMsg, sizeof(SRpcMsg), pMsg->pCont, pMsg->contLen, PROC_REGISTER); - if (code != 0) { - taosMsleep(10); - } - } while (code != 0); - } else { + if (pWrapper->procType != PROC_CHILD) { rpcRegisterBrokenLinkArg(pMsg); + } else { + while (taosProcPutToParentQ(pWrapper->pProc, pMsg, sizeof(SRpcMsg), pMsg->pCont, pMsg->contLen, PROC_REG) != 0) { + taosMsleep(1); + } } +} + +static void dndReleaseHandle(SMgmtWrapper *pWrapper, void *handle, int8_t type) { + if (pWrapper->procType != PROC_CHILD) { + rpcReleaseHandle(handle, type); + } else { + SRpcMsg msg = {.handle = handle, .code = type}; + while (taosProcPutToParentQ(pWrapper->pProc, &msg, sizeof(SRpcMsg), NULL, 0, PROC_RELEASE) != 0) { + taosMsleep(1); + } + } +} + +SMsgCb dndCreateMsgcb(SMgmtWrapper *pWrapper) { + SMsgCb msgCb = { + .pWrapper = pWrapper, + .registerBrokenLinkArgFp = dndRegisterBrokenLinkArg, + .releaseHandleFp = dndReleaseHandle, + .sendMnodeReqFp = dndSendReqToMnode, + .sendReqFp = dndSendReqToDnode, + .sendRspFp = dndSendRsp, + }; + return msgCb; } \ No newline at end of file diff --git a/source/dnode/mgmt/main/src/dndUtil.c b/source/dnode/mgmt/main/src/dndUtil.c deleted file mode 100644 index e07ef68c77..0000000000 --- a/source/dnode/mgmt/main/src/dndUtil.c +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (c) 2019 TAOS Data, Inc. - * - * This program is free software: you can use, redistribute, and/or modify - * it under the terms of the GNU Affero General Public License, version 3 - * or later ("AGPL"), as published by the Free Software Foundation. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -#define _DEFAULT_SOURCE -#include "dndMain.h" - -void dndGenerateGrant() { -#if 0 - grantParseParameter(); -#endif -} - -void dndPrintVersion() { -#ifdef TD_ENTERPRISE - char *releaseName = "enterprise"; -#else - char *releaseName = "community"; -#endif - printf("%s version: %s compatible_version: %s\n", releaseName, version, compatible_version); - printf("gitinfo: %s\n", gitinfo); - printf("builuInfo: %s\n", buildinfo); -} - -void dndDumpCfg() { - SConfig *pCfg = taosGetCfg(); - cfgDumpCfg(pCfg, 0, 1); -} - -SDnodeOpt dndGetOpt() { - SConfig *pCfg = taosGetCfg(); - SDnodeOpt option = {0}; - - option.numOfSupportVnodes = cfgGetItem(pCfg, "supportVnodes")->i32; - tstrncpy(option.dataDir, tsDataDir, sizeof(option.dataDir)); - tstrncpy(option.firstEp, tsFirst, sizeof(option.firstEp)); - tstrncpy(option.secondEp, tsSecond, sizeof(option.firstEp)); - option.serverPort = tsServerPort; - tstrncpy(option.localFqdn, tsLocalFqdn, sizeof(option.localFqdn)); - snprintf(option.localEp, sizeof(option.localEp), "%s:%u", option.localFqdn, option.serverPort); - option.pDisks = tsDiskCfg; - option.numOfDisks = tsDiskCfgNum; - return option; -} diff --git a/source/dnode/mgmt/mnode/inc/mm.h b/source/dnode/mgmt/mm/inc/mm.h similarity index 100% rename from source/dnode/mgmt/mnode/inc/mm.h rename to source/dnode/mgmt/mm/inc/mm.h diff --git a/source/dnode/mgmt/mnode/inc/mmInt.h b/source/dnode/mgmt/mm/inc/mmInt.h similarity index 100% rename from source/dnode/mgmt/mnode/inc/mmInt.h rename to source/dnode/mgmt/mm/inc/mmInt.h diff --git a/source/dnode/mgmt/mnode/src/mmFile.c b/source/dnode/mgmt/mm/src/mmFile.c similarity index 100% rename from source/dnode/mgmt/mnode/src/mmFile.c rename to source/dnode/mgmt/mm/src/mmFile.c diff --git a/source/dnode/mgmt/mnode/src/mmInt.c b/source/dnode/mgmt/mm/src/mmInt.c similarity index 100% rename from source/dnode/mgmt/mnode/src/mmInt.c rename to source/dnode/mgmt/mm/src/mmInt.c diff --git a/source/dnode/mgmt/mnode/src/mmMsg.c b/source/dnode/mgmt/mm/src/mmMsg.c similarity index 100% rename from source/dnode/mgmt/mnode/src/mmMsg.c rename to source/dnode/mgmt/mm/src/mmMsg.c diff --git a/source/dnode/mgmt/mnode/src/mmWorker.c b/source/dnode/mgmt/mm/src/mmWorker.c similarity index 100% rename from source/dnode/mgmt/mnode/src/mmWorker.c rename to source/dnode/mgmt/mm/src/mmWorker.c diff --git a/source/dnode/mgmt/qnode/inc/qm.h b/source/dnode/mgmt/qm/inc/qm.h similarity index 100% rename from source/dnode/mgmt/qnode/inc/qm.h rename to source/dnode/mgmt/qm/inc/qm.h diff --git a/source/dnode/mgmt/qnode/inc/qmInt.h b/source/dnode/mgmt/qm/inc/qmInt.h similarity index 100% rename from source/dnode/mgmt/qnode/inc/qmInt.h rename to source/dnode/mgmt/qm/inc/qmInt.h diff --git a/source/dnode/mgmt/qnode/src/qmInt.c b/source/dnode/mgmt/qm/src/qmInt.c similarity index 100% rename from source/dnode/mgmt/qnode/src/qmInt.c rename to source/dnode/mgmt/qm/src/qmInt.c diff --git a/source/dnode/mgmt/qnode/src/qmMsg.c b/source/dnode/mgmt/qm/src/qmMsg.c similarity index 100% rename from source/dnode/mgmt/qnode/src/qmMsg.c rename to source/dnode/mgmt/qm/src/qmMsg.c diff --git a/source/dnode/mgmt/qnode/src/qmWorker.c b/source/dnode/mgmt/qm/src/qmWorker.c similarity index 100% rename from source/dnode/mgmt/qnode/src/qmWorker.c rename to source/dnode/mgmt/qm/src/qmWorker.c diff --git a/source/dnode/mgmt/snode/inc/sm.h b/source/dnode/mgmt/sm/inc/sm.h similarity index 100% rename from source/dnode/mgmt/snode/inc/sm.h rename to source/dnode/mgmt/sm/inc/sm.h diff --git a/source/dnode/mgmt/snode/inc/smInt.h b/source/dnode/mgmt/sm/inc/smInt.h similarity index 100% rename from source/dnode/mgmt/snode/inc/smInt.h rename to source/dnode/mgmt/sm/inc/smInt.h diff --git a/source/dnode/mgmt/snode/src/smInt.c b/source/dnode/mgmt/sm/src/smInt.c similarity index 100% rename from source/dnode/mgmt/snode/src/smInt.c rename to source/dnode/mgmt/sm/src/smInt.c diff --git a/source/dnode/mgmt/snode/src/smMsg.c b/source/dnode/mgmt/sm/src/smMsg.c similarity index 100% rename from source/dnode/mgmt/snode/src/smMsg.c rename to source/dnode/mgmt/sm/src/smMsg.c diff --git a/source/dnode/mgmt/snode/src/smWorker.c b/source/dnode/mgmt/sm/src/smWorker.c similarity index 100% rename from source/dnode/mgmt/snode/src/smWorker.c rename to source/dnode/mgmt/sm/src/smWorker.c diff --git a/source/dnode/mgmt/vnode/inc/vm.h b/source/dnode/mgmt/vm/inc/vm.h similarity index 100% rename from source/dnode/mgmt/vnode/inc/vm.h rename to source/dnode/mgmt/vm/inc/vm.h diff --git a/source/dnode/mgmt/vnode/inc/vmInt.h b/source/dnode/mgmt/vm/inc/vmInt.h similarity index 100% rename from source/dnode/mgmt/vnode/inc/vmInt.h rename to source/dnode/mgmt/vm/inc/vmInt.h diff --git a/source/dnode/mgmt/vnode/src/vmFile.c b/source/dnode/mgmt/vm/src/vmFile.c similarity index 100% rename from source/dnode/mgmt/vnode/src/vmFile.c rename to source/dnode/mgmt/vm/src/vmFile.c diff --git a/source/dnode/mgmt/vnode/src/vmInt.c b/source/dnode/mgmt/vm/src/vmInt.c similarity index 100% rename from source/dnode/mgmt/vnode/src/vmInt.c rename to source/dnode/mgmt/vm/src/vmInt.c diff --git a/source/dnode/mgmt/vnode/src/vmMsg.c b/source/dnode/mgmt/vm/src/vmMsg.c similarity index 100% rename from source/dnode/mgmt/vnode/src/vmMsg.c rename to source/dnode/mgmt/vm/src/vmMsg.c diff --git a/source/dnode/mgmt/vnode/src/vmWorker.c b/source/dnode/mgmt/vm/src/vmWorker.c similarity index 100% rename from source/dnode/mgmt/vnode/src/vmWorker.c rename to source/dnode/mgmt/vm/src/vmWorker.c diff --git a/source/dnode/mnode/impl/src/mndInfoSchema.c b/source/dnode/mnode/impl/src/mndInfoSchema.c index c9b69bc161..ce08dfaaa3 100644 --- a/source/dnode/mnode/impl/src/mndInfoSchema.c +++ b/source/dnode/mnode/impl/src/mndInfoSchema.c @@ -20,138 +20,178 @@ #define SYSTABLE_SCH_DB_NAME_LEN ((TSDB_DB_NAME_LEN - 1) + VARSTR_HEADER_SIZE) //!!!! Note: only APPEND columns in below tables, NO insert !!!! -static const SInfosTableSchema dnodesSchema[] = {{.name = "id", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, - {.name = "endpoint", .bytes = TSDB_EP_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "vnodes", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, - {.name = "max_vnodes", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, - {.name = "status", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - {.name = "note", .bytes = 256 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, - }; -static const SInfosTableSchema mnodesSchema[] = {{.name = "id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "endpoint", .bytes = TSDB_EP_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "role", .bytes = 12 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "role_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - }; -static const SInfosTableSchema modulesSchema[] = {{.name = "id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "endpoint", .bytes = 134, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "module", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, - }; -static const SInfosTableSchema qnodesSchema[] = {{.name = "id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "endpoint", .bytes = 134, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - }; -static const SInfosTableSchema userDBSchema[] = {{.name = "name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - {.name = "vgroups", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, - {.name = "ntables", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT}, - {.name = "replica", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, - {.name = "quorum", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, - {.name = "days", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, - {.name = "keep", .bytes = 24 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "cache", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "blocks", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "minrows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "maxrows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "wallevel", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT}, - {.name = "fsync", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "comp", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT}, - {.name = "cachelast", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT}, - {.name = "precision", .bytes = 3 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, -// {.name = "update", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT}, // disable update - }; -static const SInfosTableSchema userFuncSchema[] = {{.name = "name", .bytes = 32, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - {.name = "ntables", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "precision", .bytes = 2, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "status", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, - }; -static const SInfosTableSchema userIdxSchema[] = {{.name = "db_name", .bytes = 32, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "table_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "index_database", .bytes = 32, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "index_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "column_name", .bytes = 64, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "index_type", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "index_extensions", .bytes = 256, .type = TSDB_DATA_TYPE_BINARY}, - }; -static const SInfosTableSchema userStbsSchema[] = {{.name = "stable_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - {.name = "columns", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "tags", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "tables", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "last_update", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - {.name = "table_comment", .bytes = 1024 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_INT}, - }; -static const SInfosTableSchema userStreamsSchema[] = {{.name = "stream_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "user_name", .bytes = 23, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "dest_table", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - {.name = "sql", .bytes = 1024, .type = TSDB_DATA_TYPE_BINARY}, - }; +static const SInfosTableSchema dnodesSchema[] = { + {.name = "id", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, + {.name = "endpoint", .bytes = TSDB_EP_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "vnodes", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, + {.name = "max_vnodes", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, + {.name = "status", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, + {.name = "note", .bytes = 256 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, +}; +static const SInfosTableSchema mnodesSchema[] = { + {.name = "id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "endpoint", .bytes = TSDB_EP_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "role", .bytes = 12 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "role_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, + {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, +}; +static const SInfosTableSchema modulesSchema[] = { + {.name = "id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "endpoint", .bytes = 134, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "module", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, +}; +static const SInfosTableSchema qnodesSchema[] = { + {.name = "id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "endpoint", .bytes = 134, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, +}; +static const SInfosTableSchema userDBSchema[] = { + {.name = "name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, + {.name = "vgroups", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, + {.name = "ntables", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT}, + {.name = "replica", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, + {.name = "quorum", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, + {.name = "days", .bytes = 2, .type = TSDB_DATA_TYPE_SMALLINT}, + {.name = "keep", .bytes = 24 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "cache", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "blocks", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "minrows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "maxrows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "wallevel", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT}, + {.name = "fsync", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "comp", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT}, + {.name = "cachelast", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT}, + {.name = "precision", .bytes = 3 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, + // {.name = "update", .bytes = 1, .type = + // TSDB_DATA_TYPE_TINYINT}, // disable update +}; +static const SInfosTableSchema userFuncSchema[] = { + {.name = "name", .bytes = 32, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, + {.name = "ntables", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "precision", .bytes = 2, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "status", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, +}; +static const SInfosTableSchema userIdxSchema[] = { + {.name = "db_name", .bytes = 32, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "table_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "index_database", .bytes = 32, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "index_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "column_name", .bytes = 64, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "index_type", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "index_extensions", .bytes = 256, .type = TSDB_DATA_TYPE_BINARY}, +}; +static const SInfosTableSchema userStbsSchema[] = { + {.name = "stable_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, + {.name = "columns", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "tags", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "tables", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "last_update", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, + {.name = "table_comment", .bytes = 1024 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_INT}, +}; +static const SInfosTableSchema userStreamsSchema[] = { + {.name = "stream_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "user_name", .bytes = 23, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "dest_table", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, + {.name = "sql", .bytes = 1024, .type = TSDB_DATA_TYPE_BINARY}, +}; static const SInfosTableSchema userTblsSchema[] = { - {.name = "table_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - {.name = "columns", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "stable_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "uid", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT}, - {.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "ttl", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "table_comment", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - }; -static const SInfosTableSchema userTblDistSchema[] = {{.name = "db_name", .bytes = 32, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "table_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "distributed_histogram", .bytes = 500, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "min_of_rows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "max_of_rows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "avg_of_rows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "stddev_of_rows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "rows", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT}, - {.name = "blocks", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "storage_size", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT}, - {.name = "compression_ratio", .bytes = 8, .type = TSDB_DATA_TYPE_DOUBLE}, - {.name = "rows_in_mem", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "seek_header_time", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - }; -static const SInfosTableSchema userUsersSchema[] = {{.name = "name", .bytes = TSDB_USER_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "privilege", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, - {.name = "account", .bytes = TSDB_USER_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, - }; -static const SInfosTableSchema vgroupsSchema[] = {{.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "tables", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "status", .bytes = 12 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "onlines", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "v1_dnode", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "v1_status", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "v2_dnode", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "v2_status", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "v3_dnode", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "v3_status", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, - {.name = "compacting", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "nfiles", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "file_size", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - }; + {.name = "table_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, + {.name = "columns", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "stable_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "uid", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT}, + {.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "ttl", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "table_comment", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, +}; +static const SInfosTableSchema userTblDistSchema[] = { + {.name = "db_name", .bytes = 32, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "table_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "distributed_histogram", .bytes = 500, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "min_of_rows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "max_of_rows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "avg_of_rows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "stddev_of_rows", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "rows", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT}, + {.name = "blocks", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "storage_size", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT}, + {.name = "compression_ratio", .bytes = 8, .type = TSDB_DATA_TYPE_DOUBLE}, + {.name = "rows_in_mem", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "seek_header_time", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, +}; +static const SInfosTableSchema userUsersSchema[] = { + {.name = "name", .bytes = TSDB_USER_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "privilege", .bytes = 10 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, + {.name = "account", .bytes = TSDB_USER_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, +}; +static const SInfosTableSchema vgroupsSchema[] = { + {.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "tables", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "status", .bytes = 12 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "onlines", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "v1_dnode", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "v1_status", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "v2_dnode", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "v2_status", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "v3_dnode", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "v3_status", .bytes = 10, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "compacting", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "nfiles", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "file_size", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, +}; -static const SInfosTableMeta infosMeta[] = {{TSDB_INS_TABLE_DNODES, dnodesSchema, tListLen(dnodesSchema)}, - {TSDB_INS_TABLE_MNODES, mnodesSchema, tListLen(mnodesSchema)}, - {TSDB_INS_TABLE_MODULES, modulesSchema, tListLen(modulesSchema)}, - {TSDB_INS_TABLE_QNODES, qnodesSchema, tListLen(qnodesSchema)}, - {TSDB_INS_TABLE_USER_DATABASES, userDBSchema, tListLen(userDBSchema)}, - {TSDB_INS_TABLE_USER_FUNCTIONS, userFuncSchema, tListLen(userFuncSchema)}, - {TSDB_INS_TABLE_USER_INDEXES, userIdxSchema, tListLen(userIdxSchema)}, - {TSDB_INS_TABLE_USER_STABLES, userStbsSchema, tListLen(userStbsSchema)}, - {TSDB_INS_TABLE_USER_STREAMS, userStreamsSchema, tListLen(userStreamsSchema)}, - {TSDB_INS_TABLE_USER_TABLES, userTblsSchema, tListLen(userTblsSchema)}, - {TSDB_INS_TABLE_USER_TABLE_DISTRIBUTED, userTblDistSchema, tListLen(userTblDistSchema)}, - {TSDB_INS_TABLE_USER_USERS, userUsersSchema, tListLen(userUsersSchema)}, - {TSDB_INS_TABLE_VGROUPS, vgroupsSchema, tListLen(vgroupsSchema)}, - }; +// TODO put into perf schema +static const SInfosTableSchema topicSchema[] = { + {.name = "topic_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "create_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, + {.name = "sql", .bytes = 1024, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "row_len", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, +}; -//connection/application/ +static const SInfosTableSchema consumerSchema[] = { + {.name = "client_id", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "group_id", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "pid", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "status", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + // ep + // up time + // topics +}; + +static const SInfosTableSchema subscribeSchema[] = { + {.name = "topic_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "group_id", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, + {.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, + {.name = "client_id", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_BINARY}, +}; + +static const SInfosTableMeta infosMeta[] = { + {TSDB_INS_TABLE_DNODES, dnodesSchema, tListLen(dnodesSchema)}, + {TSDB_INS_TABLE_MNODES, mnodesSchema, tListLen(mnodesSchema)}, + {TSDB_INS_TABLE_MODULES, modulesSchema, tListLen(modulesSchema)}, + {TSDB_INS_TABLE_QNODES, qnodesSchema, tListLen(qnodesSchema)}, + {TSDB_INS_TABLE_USER_DATABASES, userDBSchema, tListLen(userDBSchema)}, + {TSDB_INS_TABLE_USER_FUNCTIONS, userFuncSchema, tListLen(userFuncSchema)}, + {TSDB_INS_TABLE_USER_INDEXES, userIdxSchema, tListLen(userIdxSchema)}, + {TSDB_INS_TABLE_USER_STABLES, userStbsSchema, tListLen(userStbsSchema)}, + {TSDB_INS_TABLE_USER_STREAMS, userStreamsSchema, tListLen(userStreamsSchema)}, + {TSDB_INS_TABLE_USER_TABLES, userTblsSchema, tListLen(userTblsSchema)}, + {TSDB_INS_TABLE_USER_TABLE_DISTRIBUTED, userTblDistSchema, tListLen(userTblDistSchema)}, + {TSDB_INS_TABLE_USER_USERS, userUsersSchema, tListLen(userUsersSchema)}, + {TSDB_INS_TABLE_VGROUPS, vgroupsSchema, tListLen(vgroupsSchema)}, +}; + +// connection/application/ int32_t mndInitInfosTableSchema(const SInfosTableSchema *pSrc, int32_t colNum, SSchema **pDst) { SSchema *schema = taosMemoryCalloc(colNum, sizeof(SSchema)); if (NULL == schema) { @@ -161,7 +201,7 @@ int32_t mndInitInfosTableSchema(const SInfosTableSchema *pSrc, int32_t colNum, S for (int32_t i = 0; i < colNum; ++i) { strcpy(schema[i].name, pSrc[i].name); - + schema[i].type = pSrc[i].type; schema[i].colId = i + 1; schema[i].bytes = pSrc[i].bytes; @@ -182,11 +222,11 @@ int32_t mndInsInitMeta(SHashObj *hash) { for (int32_t i = 0; i < tListLen(infosMeta); ++i) { strcpy(meta.tbName, infosMeta[i].name); meta.numOfColumns = infosMeta[i].colNum; - + if (mndInitInfosTableSchema(infosMeta[i].schema, infosMeta[i].colNum, &meta.pSchemas)) { return -1; } - + if (taosHashPut(hash, meta.tbName, strlen(meta.tbName), &meta, sizeof(meta))) { terrno = TSDB_CODE_OUT_OF_MEMORY; return -1; @@ -210,7 +250,7 @@ int32_t mndBuildInsTableSchema(SMnode *pMnode, const char *dbFName, const char * } *pRsp = *meta; - + pRsp->pSchemas = taosMemoryCalloc(meta->numOfColumns, sizeof(SSchema)); if (pRsp->pSchemas == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -237,13 +277,13 @@ void mndCleanupInfos(SMnode *pMnode) { if (NULL == pMnode->infosMeta) { return; } - + void *pIter = taosHashIterate(pMnode->infosMeta, NULL); while (pIter) { STableMetaRsp *meta = (STableMetaRsp *)pIter; taosMemoryFreeClear(meta->pSchemas); - + pIter = taosHashIterate(pMnode->infosMeta, pIter); } @@ -251,5 +291,3 @@ void mndCleanupInfos(SMnode *pMnode) { pMnode->infosMeta = NULL; } - - diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c index 08a88a19ec..806415ccd9 100644 --- a/source/dnode/mnode/impl/src/mndSubscribe.c +++ b/source/dnode/mnode/impl/src/mndSubscribe.c @@ -62,8 +62,6 @@ static int32_t mndPersistMqSetConnReq(SMnode *pMnode, STrans *pTrans, const SMqT static int32_t mndPersistRebalanceMsg(SMnode *pMnode, STrans *pTrans, const SMqConsumerEp *pConsumerEp); -static int32_t mndInitUnassignedVg(SMnode *pMnode, const SMqTopicObj *pTopic, SMqSubscribeObj *pSub); - int32_t mndInitSubscribe(SMnode *pMnode) { SSdbTable table = {.sdbType = SDB_SUBSCRIBE, .keyType = SDB_KEY_BINARY, @@ -98,14 +96,6 @@ static SMqSubscribeObj *mndCreateSubscription(SMnode *pMnode, const SMqTopicObj return NULL; } -#if 0 - if (mndInitUnassignedVg(pMnode, pTopic, pSub) < 0) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - tDeleteSMqSubscribeObj(pSub); - taosMemoryFree(pSub); - return NULL; - } -#endif // TODO: disable alter subscribed table return pSub; } @@ -210,45 +200,6 @@ static int32_t mndPersistCancelConnReq(SMnode *pMnode, STrans *pTrans, const SMq return 0; } -#if 0 -static int32_t mndProcessResetOffsetReq(SNodeMsg *pMsg) { - SMnode *pMnode = pMsg->pNode; - uint8_t *str = pMsg->rpcMsg.pCont; - SMqCMResetOffsetReq req; - - SCoder decoder; - tCoderInit(&decoder, TD_LITTLE_ENDIAN, str, pMsg->rpcMsg.contLen, TD_DECODER); - tDecodeSMqCMResetOffsetReq(&decoder, &req); - - SHashObj *pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK); - if (pHash == NULL) { - return -1; - } - - for (int32_t i = 0; i < req.num; i++) { - SMqOffset *pOffset = &req.offsets[i]; - SMqVgOffsets *pVgOffset = taosHashGet(pHash, &pOffset->vgId, sizeof(int32_t)); - if (pVgOffset == NULL) { - pVgOffset = taosMemoryMalloc(sizeof(SMqVgOffsets)); - if (pVgOffset == NULL) { - return -1; - } - pVgOffset->offsets = taosArrayInit(0, sizeof(void *)); - taosArrayPush(pVgOffset->offsets, &pOffset); - } - taosHashPut(pHash, &pOffset->vgId, sizeof(int32_t), &pVgOffset, sizeof(void *)); - } - - STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, &pMsg->rpcMsg); - if (pTrans == NULL) { - mError("mq-reset-offset: failed since %s", terrstr()); - return -1; - } - - return 0; -} -#endif - static int32_t mndProcessGetSubEpReq(SNodeMsg *pMsg) { SMnode *pMnode = pMsg->pNode; SMqCMGetSubEpReq *pReq = (SMqCMGetSubEpReq *)pMsg->rpcMsg.pCont; @@ -574,251 +525,6 @@ static int32_t mndProcessDoRebalanceMsg(SNodeMsg *pMsg) { return 0; } -#if 0 - for (int32_t j = 0; j < consumerNum; j++) { - bool changed = false; - bool unfished = false; - - bool canUseLeft = imbalanceSolved < imbalanceVg; - bool mustUseLeft = canUseLeft && (imbalanceVg - imbalanceSolved >= consumerNum - j); - ASSERT(imbalanceVg - imbalanceSolved <= consumerNum - j); - - int32_t maxVg = vgEachConsumer + canUseLeft; - int32_t minVg = vgEachConsumer + mustUseLeft; - - SMqSubConsumer *pSubConsumer = taosArrayGet(pSub->consumers, j); - int32_t vgThisConsumerBeforeRb = taosArrayGetSize(pSubConsumer->vgInfo); - int32_t vgThisConsumerAfterRb; - if (vgThisConsumerBeforeRb > maxVg) { - vgThisConsumerAfterRb = maxVg; - imbalanceSolved++; - changed = true; - } else if (vgThisConsumerBeforeRb < minVg) { - vgThisConsumerAfterRb = minVg; - if (mustUseLeft) imbalanceSolved++; - changed = true; - } else { - vgThisConsumerAfterRb = vgThisConsumerBeforeRb; - } - - if (vgThisConsumerBeforeRb > vgThisConsumerAfterRb) { - while (taosArrayGetSize(pSubConsumer->vgInfo) > vgThisConsumerAfterRb) { - // put into unassigned - SMqConsumerEp *pConsumerEp = taosArrayPop(pSubConsumer->vgInfo); - ASSERT(pConsumerEp != NULL); - ASSERT(pConsumerEp->consumerId == pSubConsumer->consumerId); - taosArrayPush(unassignedVgStash, pConsumerEp); - } - - } else if (vgThisConsumerBeforeRb < vgThisConsumerAfterRb) { - // assign from unassigned - while (taosArrayGetSize(pSubConsumer->vgInfo) < vgThisConsumerAfterRb) { - // if no unassgined, save j - if (taosArrayGetSize(unassignedVgStash) == 0) { - taosArrayPush(unassignedConsumerIdx, &j); - unfished = true; - break; - } - // assign vg to consumer - SMqConsumerEp *pConsumerEp = taosArrayPop(unassignedVgStash); - ASSERT(pConsumerEp != NULL); - pConsumerEp->oldConsumerId = pConsumerEp->consumerId; - pConsumerEp->consumerId = pSubConsumer->consumerId; - taosArrayPush(pSubConsumer->vgInfo, pConsumerEp); - // build msg and persist into trans - } - } - - if (changed && !unfished) { - SMqConsumerObj *pRebConsumer = mndAcquireConsumer(pMnode, pSubConsumer->consumerId); - pRebConsumer->epoch++; - if (vgThisConsumerAfterRb != 0) { - atomic_store_32(&pRebConsumer->status, MQ_CONSUMER_STATUS__ACTIVE); - } else { - atomic_store_32(&pRebConsumer->status, MQ_CONSUMER_STATUS__IDLE); - } - SSdbRaw *pConsumerRaw = mndConsumerActionEncode(pRebConsumer); - sdbSetRawStatus(pConsumerRaw, SDB_STATUS_READY); - mndTransAppendRedolog(pTrans, pConsumerRaw); - mndReleaseConsumer(pMnode, pRebConsumer); - // TODO: save history - } - } - - for (int32_t j = 0; j < taosArrayGetSize(unassignedConsumerIdx); j++) { - bool canUseLeft = imbalanceSolved < imbalanceVg; - int32_t consumerIdx = *(int32_t *)taosArrayGet(unassignedConsumerIdx, j); - SMqSubConsumer *pSubConsumer = taosArrayGet(pSub->consumers, consumerIdx); - if (canUseLeft) imbalanceSolved++; - // must use - int32_t vgThisConsumerAfterRb = taosArrayGetSize(pSubConsumer->vgInfo) + canUseLeft; - while (taosArrayGetSize(pSubConsumer->vgInfo) < vgEachConsumer + canUseLeft) { - // assign vg to consumer - SMqConsumerEp *pConsumerEp = taosArrayPop(unassignedVgStash); - ASSERT(pConsumerEp != NULL); - pConsumerEp->oldConsumerId = pConsumerEp->consumerId; - pConsumerEp->consumerId = pSubConsumer->consumerId; - taosArrayPush(pSubConsumer->vgInfo, pConsumerEp); - // build msg and persist into trans - } - SMqConsumerObj *pRebConsumer = mndAcquireConsumer(pMnode, pSubConsumer->consumerId); - pRebConsumer->epoch++; - atomic_store_32(&pRebConsumer->status, MQ_CONSUMER_STATUS__ACTIVE); - SSdbRaw *pConsumerRaw = mndConsumerActionEncode(pRebConsumer); - sdbSetRawStatus(pConsumerRaw, SDB_STATUS_READY); - mndTransAppendRedolog(pTrans, pConsumerRaw); - mndReleaseConsumer(pMnode, pRebConsumer); - // TODO: save history - } -#endif - -#if 0 - //update consumer status for the subscribption - for (int32_t i = 0; i < taosArrayGetSize(pSub->assigned); i++) { - SMqConsumerEp *pCEp = taosArrayGet(pSub->assigned, i); - int64_t consumerId = pCEp->consumerId; - if (pCEp->status != -1) { - int32_t consumerHbStatus = atomic_fetch_add_32(&pCEp->consumerHbStatus, 1); - if (consumerHbStatus < MND_SUBSCRIBE_REBALANCE_CNT) { - continue; - } - // put consumer into lostConsumer - SMqConsumerEp* lostConsumer = taosArrayPush(pSub->lostConsumer, pCEp); - lostConsumer->qmsg = NULL; - // put vg into unassigned - taosArrayPush(pSub->unassignedVg, pCEp); - // remove from assigned - // TODO: swap with last one, reduce size and reset i - taosArrayRemove(pSub->assigned, i); - // remove from available consumer - for (int32_t j = 0; j < taosArrayGetSize(pSub->availConsumer); j++) { - if (*(int64_t *)taosArrayGet(pSub->availConsumer, i) == pCEp->consumerId) { - taosArrayRemove(pSub->availConsumer, j); - break; - } - // TODO: acquire consumer, set status to unavail - } -#if 0 - SMqConsumerObj* pConsumer = mndAcquireConsumer(pMnode, consumerId); - pConsumer->epoch++; - printf("current epoch %ld size %ld", pConsumer->epoch, pConsumer->topics->size); - SSdbRaw* pRaw = mndConsumerActionEncode(pConsumer); - sdbSetRawStatus(pRaw, SDB_STATUS_READY); - sdbWriteNotFree(pMnode->pSdb, pRaw); - mndReleaseConsumer(pMnode, pConsumer); -#endif - } - } - // no available consumer, skip rebalance - if (taosArrayGetSize(pSub->availConsumer) == 0) { - continue; - } - taosArrayGet(pSub->availConsumer, 0); - // rebalance condition1 : have unassigned vg - // assign vg to a consumer, trying to find the least assigned one - if ((sz = taosArrayGetSize(pSub->unassignedVg)) > 0) { - char *topic = NULL; - char *cgroup = NULL; - mndSplitSubscribeKey(pSub->key, &topic, &cgroup); - - SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic); - STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, &pMsg->rpcMsg); - for (int32_t i = 0; i < sz; i++) { - int64_t consumerId = *(int64_t *)taosArrayGet(pSub->availConsumer, pSub->nextConsumerIdx); - pSub->nextConsumerIdx = (pSub->nextConsumerIdx + 1) % taosArrayGetSize(pSub->availConsumer); - - SMqConsumerEp *pCEp = taosArrayPop(pSub->unassignedVg); - pCEp->oldConsumerId = pCEp->consumerId; - pCEp->consumerId = consumerId; - taosArrayPush(pSub->assigned, pCEp); - - SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, consumerId); - pConsumer->epoch++; - SSdbRaw* pConsumerRaw = mndConsumerActionEncode(pConsumer); - sdbSetRawStatus(pConsumerRaw, SDB_STATUS_READY); - sdbWrite(pMnode->pSdb, pConsumerRaw); - mndReleaseConsumer(pMnode, pConsumer); - - void* msg; - int32_t msgLen; - mndBuildRebalanceMsg(&msg, &msgLen, pTopic, pCEp, cgroup, topic); - - // persist msg - STransAction action = {0}; - action.epSet = pCEp->epSet; - action.pCont = msg; - action.contLen = sizeof(SMsgHead) + msgLen; - action.msgType = TDMT_VND_MQ_SET_CONN; - mndTransAppendRedoAction(pTrans, &action); - - // persist data - SSdbRaw *pRaw = mndSubActionEncode(pSub); - sdbSetRawStatus(pRaw, SDB_STATUS_READY); - mndTransAppendRedolog(pTrans, pRaw); - } - - if (mndTransPrepare(pMnode, pTrans) != 0) { - mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); - } - mndReleaseTopic(pMnode, pTopic); - mndTransDrop(pTrans); - taosMemoryFreeClear(topic); - taosMemoryFreeClear(cgroup); - } - // rebalance condition2 : imbalance assignment - } - return 0; -} -#endif - -#if 0 -static int32_t mndInitUnassignedVg(SMnode *pMnode, const SMqTopicObj *pTopic, SMqSubscribeObj *pSub) { - SSdb *pSdb = pMnode->pSdb; - SVgObj *pVgroup = NULL; - SQueryPlan *pPlan = qStringToQueryPlan(pTopic->physicalPlan); - SArray *pArray = NULL; - SNodeListNode *inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0); - SSubplan *plan = (SSubplan*)nodesListGetNode(inner->pNodeList, 0); - SArray *unassignedVg = pSub->unassignedVg; - - void *pIter = NULL; - while (1) { - pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup); - if (pIter == NULL) break; - if (pVgroup->dbUid != pTopic->dbUid) { - sdbRelease(pSdb, pVgroup); - continue; - } - - pSub->vgNum++; - plan->execNode.nodeId = pVgroup->vgId; - plan->execNode.epset = mndGetVgroupEpset(pMnode, pVgroup); - - if (schedulerConvertDagToTaskList(pPlan, &pArray) < 0) { - terrno = TSDB_CODE_MND_UNSUPPORTED_TOPIC; - mError("unsupport topic: %s, sql: %s", pTopic->name, pTopic->sql); - return -1; - } - - SMqConsumerEp consumerEp = {0}; - consumerEp.status = 0; - consumerEp.consumerId = -1; - STaskInfo *pTaskInfo = taosArrayGet(pArray, 0); - consumerEp.epSet = pTaskInfo->addr.epset; - consumerEp.vgId = pTaskInfo->addr.nodeId; - - ASSERT(consumerEp.vgId == pVgroup->vgId); - consumerEp.qmsg = strdup(pTaskInfo->msg->msg); - taosArrayPush(unassignedVg, &consumerEp); - // TODO: free taskInfo - taosArrayDestroy(pArray); - } - - /*qDestroyQueryDag(pDag);*/ - return 0; -} -#endif - static int32_t mndPersistMqSetConnReq(SMnode *pMnode, STrans *pTrans, const SMqTopicObj *pTopic, const char *cgroup, const SMqConsumerEp *pConsumerEp) { ASSERT(pConsumerEp->oldConsumerId == -1); @@ -1140,7 +846,7 @@ static int32_t mndProcessSubscribeReq(SNodeMsg *pMsg) { } } - if (oldSub) taosArrayDestroyEx(oldSub, (void (*)(void*))taosMemoryFree); + if (oldSub) taosArrayDestroyEx(oldSub, (void (*)(void *))taosMemoryFree); // persist consumerObj SSdbRaw *pConsumerRaw = mndConsumerActionEncode(pConsumer); diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c index fa2ba4bfc0..c0f591d1f2 100644 --- a/source/dnode/mnode/impl/src/mndTopic.c +++ b/source/dnode/mnode/impl/src/mndTopic.c @@ -65,9 +65,11 @@ void mndCleanupTopic(SMnode *pMnode) {} SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) { terrno = TSDB_CODE_OUT_OF_MEMORY; - int32_t logicalPlanLen = strlen(pTopic->logicalPlan) + 1; - int32_t physicalPlanLen = strlen(pTopic->physicalPlan) + 1; - int32_t size = sizeof(SMqTopicObj) + logicalPlanLen + physicalPlanLen + pTopic->sqlLen + MND_TOPIC_RESERVE_SIZE; + int32_t logicalPlanLen = strlen(pTopic->logicalPlan) + 1; + int32_t physicalPlanLen = strlen(pTopic->physicalPlan) + 1; + int32_t swLen = taosEncodeSSchemaWrapper(NULL, &pTopic->schema); + int32_t size = + sizeof(SMqTopicObj) + logicalPlanLen + physicalPlanLen + pTopic->sqlLen + swLen + MND_TOPIC_RESERVE_SIZE; SSdbRaw *pRaw = sdbAllocRaw(SDB_TOPIC, MND_TOPIC_VER_NUMBER, size); if (pRaw == NULL) goto TOPIC_ENCODE_OVER; @@ -86,8 +88,7 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) { SDB_SET_INT32(pRaw, dataPos, physicalPlanLen, TOPIC_ENCODE_OVER); SDB_SET_BINARY(pRaw, dataPos, pTopic->physicalPlan, physicalPlanLen, TOPIC_ENCODE_OVER); - int32_t swLen = taosEncodeSSchemaWrapper(NULL, &pTopic->schema); - void *swBuf = taosMemoryMalloc(swLen); + void *swBuf = taosMemoryMalloc(swLen); if (swBuf == NULL) { goto TOPIC_ENCODE_OVER; } diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c index d59ed3e605..4e54d56c09 100644 --- a/source/dnode/mnode/impl/src/mndTrans.c +++ b/source/dnode/mnode/impl/src/mndTrans.c @@ -771,7 +771,7 @@ static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) { .ahandle = pTrans->rpcAHandle, .pCont = rpcCont, .contLen = pTrans->rpcRspLen}; - tmsgSendRsp(&pMnode->msgCb, &rspMsg); + tmsgSendRsp(&rspMsg); pTrans->rpcHandle = NULL; pTrans->rpcRsp = NULL; pTrans->rpcRspLen = 0; @@ -898,7 +898,7 @@ static int32_t mndTransSendActionMsg(SMnode *pMnode, STrans *pTrans, SArray *pAr pAction->msgReceived = 0; pAction->errCode = 0; } else { - mDebug("trans:%d, action:%d not send since %s", pTrans->id, action, terrstr()); + mError("trans:%d, action:%d not send since %s", pTrans->id, action, terrstr()); return -1; } } @@ -938,7 +938,7 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA return errCode; } } else { - mDebug("trans:%d, %d of %d actions executed, code:0x%04x", pTrans->id, numOfReceived, numOfActions, errCode & 0XFFFF); + mDebug("trans:%d, %d of %d actions executing", pTrans->id, numOfReceived, numOfActions); return TSDB_CODE_MND_ACTION_IN_PROGRESS; } } diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c index 159ec5b3e8..fce423d811 100644 --- a/source/dnode/vnode/src/tq/tq.c +++ b/source/dnode/vnode/src/tq/tq.c @@ -275,7 +275,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) { pMsg->pCont = NULL; pMsg->contLen = 0; pMsg->code = -1; - rpcSendResponse(pMsg); + tmsgSendRsp(pMsg); return 0; } @@ -340,7 +340,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) { pMsg->pCont = buf; pMsg->contLen = tlen; pMsg->code = 0; - rpcSendResponse(pMsg); + tmsgSendRsp(pMsg); return 0; } } else { @@ -356,6 +356,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) { void* buf = rpcMallocCont(tlen); if (buf == NULL) { pMsg->code = -1; + ASSERT(0); return -1; } ((SMqRspHead*)buf)->mqMsgType = TMQ_MSG_TYPE__POLL_RSP; @@ -367,7 +368,7 @@ int32_t tqProcessPollReq(STQ* pTq, SRpcMsg* pMsg) { pMsg->pCont = buf; pMsg->contLen = tlen; pMsg->code = 0; - rpcSendResponse(pMsg); + tmsgSendRsp(pMsg); /*}*/ return 0; diff --git a/source/dnode/vnode/src/tq/tqRead.c b/source/dnode/vnode/src/tq/tqRead.c index 9169f78866..3d9d9a90dd 100644 --- a/source/dnode/vnode/src/tq/tqRead.c +++ b/source/dnode/vnode/src/tq/tqRead.c @@ -114,10 +114,9 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) { SSchemaWrapper* pSchemaWrapper = pHandle->pSchemaWrapper; int32_t numOfRows = pHandle->pBlock->numOfRows; - int32_t numOfCols = pHandle->pSchema->numOfCols; + /*int32_t numOfCols = pHandle->pSchema->numOfCols;*/ int32_t colNumNeed = taosArrayGetSize(pHandle->pColIdList); - // TODO: stable case if (colNumNeed > pSchemaWrapper->nCols) { colNumNeed = pSchemaWrapper->nCols; } @@ -138,58 +137,24 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) { colNeed++; } else { SColumnInfoData colInfo = {0}; - int sz = numOfRows * pColSchema->bytes; + /*int sz = numOfRows * pColSchema->bytes;*/ colInfo.info.bytes = pColSchema->bytes; colInfo.info.colId = pColSchema->colId; colInfo.info.type = pColSchema->type; - colInfo.pData = taosMemoryCalloc(1, sz); - if (colInfo.pData == NULL) { - // TODO free - taosArrayDestroy(pArray); + if (blockDataEnsureColumnCapacity(&colInfo, numOfRows) < 0) { + taosArrayDestroyEx(pArray, (void (*)(void*))tDeleteSSDataBlock); return NULL; } - - blockDataEnsureColumnCapacity(&colInfo, numOfRows); taosArrayPush(pArray, &colInfo); colMeta++; colNeed++; } } -#if 0 - int j = 0; - for (int32_t i = 0; i < colNumNeed; i++) { - col_id_t colId = *(col_id_t*)taosArrayGet(pHandle->pColIdList, i); - while (j < pSchemaWrapper->nCols && pSchemaWrapper->pSchema[j].colId < colId) { - j++; - } - if (j >= pSchemaWrapper->nCols) { - continue; - } - SSchema* pColSchema = &pSchemaWrapper->pSchema[j]; - SColumnInfoData colInfo = {0}; - int sz = numOfRows * pColSchema->bytes; - colInfo.info.bytes = pColSchema->bytes; - colInfo.info.colId = colId; - colInfo.info.type = pColSchema->type; - - colInfo.pData = taosMemoryCalloc(1, sz); - if (colInfo.pData == NULL) { - // TODO free - taosArrayDestroy(pArray); - return NULL; - } - - blockDataEnsureColumnCapacity(&colInfo, numOfRows); - taosArrayPush(pArray, &colInfo); - } -#endif - STSRowIter iter = {0}; tdSTSRowIterInit(&iter, pTschema); STSRow* row; - // int32_t kvIdx = 0; int32_t curRow = 0; tInitSubmitBlkIter(pHandle->pBlock, &pHandle->blkIter); while ((row = tGetSubmitBlkNext(&pHandle->blkIter)) != NULL) { @@ -202,25 +167,9 @@ SArray* tqRetrieveDataBlock(STqReadHandle* pHandle) { if (!tdSTSRowIterNext(&iter, pColData->info.colId, pColData->info.type, &sVal)) { break; } - memcpy(POINTER_SHIFT(pColData->pData, curRow * pColData->info.bytes), sVal.val, pColData->info.bytes); + // TODO handle null + colDataAppend(pColData, curRow, sVal.val, sVal.valType == TD_VTYPE_NULL); } -#if 0 - for (int32_t i = 0; i < colNumNeed; i++) { - SColumnInfoData* pColData = taosArrayGet(pArray, i); - STColumn* pCol = schemaColAt(pTschema, i); - // TODO - if(pCol->colId != pColData->info.colId) { - continue; - } - // void* val = tdGetMemRowDataOfColEx(row, pCol->colId, pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset, &kvIdx); - SCellVal sVal = {0}; - if (!tdSTSRowIterNext(&iter, pCol->colId, pCol->type, &sVal)) { - // TODO: reach end - break; - } - memcpy(POINTER_SHIFT(pColData->pData, curRow * pCol->bytes), sVal.val, pCol->bytes); - } -#endif curRow++; } return pArray; diff --git a/source/dnode/vnode/src/vnd/vnodeQuery.c b/source/dnode/vnode/src/vnd/vnodeQuery.c index 74d7558e0d..8ebdad48f7 100644 --- a/source/dnode/vnode/src/vnd/vnodeQuery.c +++ b/source/dnode/vnode/src/vnd/vnodeQuery.c @@ -205,8 +205,7 @@ _exit: rpcMsg.contLen = rspLen; rpcMsg.code = code; - rpcSendResponse(&rpcMsg); - + tmsgSendRsp(&rpcMsg); return TSDB_CODE_SUCCESS; } @@ -276,8 +275,7 @@ static int32_t vnodeGetTableList(SVnode *pVnode, SRpcMsg *pMsg) { .code = 0, }; - rpcSendResponse(&rpcMsg); - + tmsgSendRsp(&rpcMsg); taosArrayDestroyEx(pArray, freeItemHelper); return 0; } diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index 3be496bc2b..615bcdcdbb 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -14,12 +14,12 @@ */ #include "executor.h" -#include "tdatablock.h" #include "executorimpl.h" #include "planner.h" +#include "tdatablock.h" #include "vnode.h" -static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void** input, size_t numOfBlocks, int32_t type, char* id) { +static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, char* id) { ASSERT(pOperator != NULL); if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) { if (pOperator->numOfDownstream == 0) { @@ -44,17 +44,18 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void** input, size_t n } if (type == STREAM_DATA_TYPE_SUBMIT_BLOCK) { - if (tqReadHandleSetMsg(pInfo->readerHandle, input[0], 0) < 0) { + if (tqReadHandleSetMsg(pInfo->readerHandle, input, 0) < 0) { qError("submit msg messed up when initing stream block, %s" PRIx64, id); return TSDB_CODE_QRY_APP_ERROR; } } else { for (int32_t i = 0; i < numOfBlocks; ++i) { - SSDataBlock* pDataBlock = input[i]; + SSDataBlock* pDataBlock = &((SSDataBlock*)input)[i]; SSDataBlock* p = createOneDataBlock(pDataBlock); p->info = pDataBlock->info; + taosArrayClear(p->pDataBlock); taosArrayAddAll(p->pDataBlock, pDataBlock->pDataBlock); taosArrayPush(pInfo->pBlockLists, &p); } @@ -65,10 +66,10 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void** input, size_t n } int32_t qSetStreamInput(qTaskInfo_t tinfo, const void* input, int32_t type) { - qSetMultiStreamInput(tinfo, (void**) &input, 1, type); + return qSetMultiStreamInput(tinfo, input, 1, type); } -int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, void** pBlocks, size_t numOfBlocks, int32_t type) { +int32_t qSetMultiStreamInput(qTaskInfo_t tinfo, const void* pBlocks, size_t numOfBlocks, int32_t type) { if (tinfo == NULL) { return TSDB_CODE_QRY_APP_ERROR; } diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c index 5ec5d8cd70..22016cf458 100644 --- a/source/libs/executor/src/executorimpl.c +++ b/source/libs/executor/src/executorimpl.c @@ -43,27 +43,28 @@ #define IS_MAIN_SCAN(runtime) ((runtime)->scanFlag == MAIN_SCAN) #define IS_REVERSE_SCAN(runtime) ((runtime)->scanFlag == REVERSE_SCAN) #define IS_REPEAT_SCAN(runtime) ((runtime)->scanFlag == REPEAT_SCAN) -#define SET_MAIN_SCAN_FLAG(runtime) ((runtime)->scanFlag = MAIN_SCAN) +#define SET_MAIN_SCAN_FLAG(runtime) ((runtime)->scanFlag = MAIN_SCAN) #define SET_REVERSE_SCAN_FLAG(runtime) ((runtime)->scanFlag = REVERSE_SCAN) #define TSWINDOW_IS_EQUAL(t1, t2) (((t1).skey == (t2).skey) && ((t1).ekey == (t2).ekey)) -#define SWITCH_ORDER(n) (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC)) +#define SWITCH_ORDER(n) (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC)) -#define SDATA_BLOCK_INITIALIZER (SDataBlockInfo) {{0}, 0} +#define SDATA_BLOCK_INITIALIZER \ + (SDataBlockInfo) { {0}, 0 } #define GET_FORWARD_DIRECTION_FACTOR(ord) (((ord) == TSDB_ORDER_ASC) ? QUERY_ASC_FORWARD_STEP : QUERY_DESC_FORWARD_STEP) -#define MULTI_KEY_DELIM "-" +#define MULTI_KEY_DELIM "-" enum { - TS_JOIN_TS_EQUAL = 0, - TS_JOIN_TS_NOT_EQUALS = 1, + TS_JOIN_TS_EQUAL = 0, + TS_JOIN_TS_NOT_EQUALS = 1, TS_JOIN_TAG_NOT_EQUALS = 2, }; typedef enum SResultTsInterpType { RESULT_ROW_START_INTERP = 1, - RESULT_ROW_END_INTERP = 2, + RESULT_ROW_END_INTERP = 2, } SResultTsInterpType; typedef struct SColMatchInfo { @@ -110,47 +111,51 @@ static UNUSED_FUNC void* u_realloc(void* p, size_t __size) { #define GET_NUM_OF_TABLEGROUP(q) taosArrayGetSize((q)->tableqinfoGroupInfo.pGroupList) #define QUERY_IS_INTERVAL_QUERY(_q) ((_q)->interval.interval > 0) -#define TSKEY_MAX_ADD(a,b) \ -do { \ - if (a < 0) { a = a + b; break;} \ - if (sizeof(a) == sizeof(int32_t)) { \ - if((b) > 0 && ((b) >= INT32_MAX - (a))){\ - a = INT32_MAX; \ - } else { \ - a = a + b; \ - } \ - } else { \ - if((b) > 0 && ((b) >= INT64_MAX - (a))){\ - a = INT64_MAX; \ - } else { \ - a = a + b; \ - } \ - } \ -} while(0) +#define TSKEY_MAX_ADD(a, b) \ + do { \ + if (a < 0) { \ + a = a + b; \ + break; \ + } \ + if (sizeof(a) == sizeof(int32_t)) { \ + if ((b) > 0 && ((b) >= INT32_MAX - (a))) { \ + a = INT32_MAX; \ + } else { \ + a = a + b; \ + } \ + } else { \ + if ((b) > 0 && ((b) >= INT64_MAX - (a))) { \ + a = INT64_MAX; \ + } else { \ + a = a + b; \ + } \ + } \ + } while (0) -#define TSKEY_MIN_SUB(a,b) \ -do { \ - if (a >= 0) { a = a + b; break;} \ - if (sizeof(a) == sizeof(int32_t)){ \ - if((b) < 0 && ((b) <= INT32_MIN - (a))){\ - a = INT32_MIN; \ - } else { \ - a = a + b; \ - } \ - } else { \ - if((b) < 0 && ((b) <= INT64_MIN-(a))) {\ - a = INT64_MIN; \ - } else { \ - a = a + b; \ - } \ - } \ -} while (0) +#define TSKEY_MIN_SUB(a, b) \ + do { \ + if (a >= 0) { \ + a = a + b; \ + break; \ + } \ + if (sizeof(a) == sizeof(int32_t)) { \ + if ((b) < 0 && ((b) <= INT32_MIN - (a))) { \ + a = INT32_MIN; \ + } else { \ + a = a + b; \ + } \ + } else { \ + if ((b) < 0 && ((b) <= INT64_MIN - (a))) { \ + a = INT64_MIN; \ + } else { \ + a = a + b; \ + } \ + } \ + } while (0) -int32_t getMaximumIdleDurationSec() { - return tsShellActivityTimer * 2; -} +int32_t getMaximumIdleDurationSec() { return tsShellActivityTimer * 2; } -static int32_t getExprFunctionId(SExprInfo *pExprInfo) { +static int32_t getExprFunctionId(SExprInfo* pExprInfo) { assert(pExprInfo != NULL && pExprInfo->pExpr != NULL && pExprInfo->pExpr->nodeType == TEXPR_UNARYEXPR_NODE); return 0; } @@ -164,7 +169,7 @@ static void getNextTimeWindow(SInterval* pInterval, int32_t precision, int32_t o } int64_t key = tw->skey, interval = pInterval->interval; - //convert key to second + // convert key to second key = convertTimePrecision(key, precision, TSDB_TIME_PRECISION_MILLI) / 1000; if (pInterval->intervalUnit == 'y') { @@ -172,7 +177,7 @@ static void getNextTimeWindow(SInterval* pInterval, int32_t precision, int32_t o } struct tm tm; - time_t t = (time_t)key; + time_t t = (time_t)key; taosLocalTime(&t, &tm); int mon = (int)(tm.tm_year * 12 + tm.tm_mon + interval * factor); @@ -192,20 +197,21 @@ static void doSetTagValueToResultBuf(char* output, const char* val, int16_t type static void setResultOutputBuf(STaskRuntimeEnv* pRuntimeEnv, SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numOfCols, int32_t* rowCellInfoOffset); -void setResultRowOutputBufInitCtx(STaskRuntimeEnv *pRuntimeEnv, SResultRow *pResult, SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowCellInfoOffset); -static bool functionNeedToExecute(SqlFunctionCtx *pCtx); +void setResultRowOutputBufInitCtx(STaskRuntimeEnv* pRuntimeEnv, SResultRow* pResult, SqlFunctionCtx* pCtx, + int32_t numOfOutput, int32_t* rowCellInfoOffset); +static bool functionNeedToExecute(SqlFunctionCtx* pCtx); -static void setBlockStatisInfo(SqlFunctionCtx *pCtx, SSDataBlock* pSDataBlock, SColumn* pColumn); +static void setBlockStatisInfo(SqlFunctionCtx* pCtx, SSDataBlock* pSDataBlock, SColumn* pColumn); -static void destroyTableQueryInfoImpl(STableQueryInfo *pTableQueryInfo); -static bool hasMainOutput(STaskAttr *pQueryAttr); +static void destroyTableQueryInfoImpl(STableQueryInfo* pTableQueryInfo); +static bool hasMainOutput(STaskAttr* pQueryAttr); static SColumnInfo* extractColumnFilterInfo(SExprInfo* pExpr, int32_t numOfOutput, int32_t* numOfFilterCols); -static int32_t setTimestampListJoinInfo(STaskRuntimeEnv* pRuntimeEnv, SVariant* pTag, STableQueryInfo *pTableQueryInfo); -static void releaseQueryBuf(size_t numOfTables); -static int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order); -//static STsdbQueryCond createTsdbQueryCond(STaskAttr* pQueryAttr, STimeWindow* win); +static int32_t setTimestampListJoinInfo(STaskRuntimeEnv* pRuntimeEnv, SVariant* pTag, STableQueryInfo* pTableQueryInfo); +static void releaseQueryBuf(size_t numOfTables); +static int32_t binarySearchForKey(char* pValue, int num, TSKEY key, int order); +// static STsdbQueryCond createTsdbQueryCond(STaskAttr* pQueryAttr, STimeWindow* win); static STableIdInfo createTableIdInfo(STableQueryInfo* pTableQueryInfo); static void setTableScanFilterOperatorInfo(STableScanInfo* pTableScanInfo, SOperatorInfo* pDownstream); @@ -235,59 +241,65 @@ static void doSetOperatorCompleted(SOperatorInfo* pOperator) { setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED); } } - #define OPTR_IS_OPENED(_optr) (((_optr)->status & OP_OPENED) == OP_OPENED) #define OPTR_SET_OPENED(_optr) ((_optr)->status |= OP_OPENED) -static int32_t operatorDummyOpenFn(SOperatorInfo *pOperator) { +static int32_t operatorDummyOpenFn(SOperatorInfo* pOperator) { OPTR_SET_OPENED(pOperator); return TSDB_CODE_SUCCESS; } static void operatorDummyCloseFn(void* param, int32_t numOfCols) {} -static int32_t doCopyToSDataBlock(SDiskbasedBuf *pBuf, SGroupResInfo* pGroupResInfo, int32_t orderType, SSDataBlock* pBlock, int32_t rowCapacity, int32_t* rowCellOffset); +static int32_t doCopyToSDataBlock(SDiskbasedBuf* pBuf, SGroupResInfo* pGroupResInfo, int32_t orderType, + SSDataBlock* pBlock, int32_t rowCapacity, int32_t* rowCellOffset); -static int32_t getGroupbyColumnIndex(SGroupbyExpr *pGroupbyExpr, SSDataBlock* pDataBlock); -static int32_t setGroupResultOutputBuf_rv(SOptrBasicInfo *binfo, int32_t numOfCols, char *pData, int16_t type, int16_t bytes, int32_t groupId, - SDiskbasedBuf* pBuf, SExecTaskInfo* pTaskInfo, SAggSupporter* pAggSup); -static void initCtxOutputBuffer(SqlFunctionCtx* pCtx, int32_t size); -static void getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key, int64_t keyFirst, int64_t keyLast, STimeWindow *win); +static int32_t getGroupbyColumnIndex(SGroupbyExpr* pGroupbyExpr, SSDataBlock* pDataBlock); +static int32_t setGroupResultOutputBuf_rv(SOptrBasicInfo* binfo, int32_t numOfCols, char* pData, int16_t type, + int16_t bytes, int32_t groupId, SDiskbasedBuf* pBuf, SExecTaskInfo* pTaskInfo, + SAggSupporter* pAggSup); +static void initCtxOutputBuffer(SqlFunctionCtx* pCtx, int32_t size); +static void getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key, int64_t keyFirst, + int64_t keyLast, STimeWindow* win); static void setResultBufSize(STaskAttr* pQueryAttr, SResultInfo* pResultInfo); static void setCtxTagForJoin(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, SExprInfo* pExprInfo, void* pTable); -static void setParamForStableStddev(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, int32_t numOfOutput, SExprInfo* pExpr); -static void setParamForStableStddevByColData(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, int32_t numOfOutput, SExprInfo* pExpr, char* val, int16_t bytes); -static void doSetTableGroupOutputBuf(SAggOperatorInfo* pAggInfo, int32_t numOfOutput, int32_t tableGroupId, SExecTaskInfo* pTaskInfo); +static void setParamForStableStddev(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, int32_t numOfOutput, + SExprInfo* pExpr); +static void setParamForStableStddevByColData(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, int32_t numOfOutput, + SExprInfo* pExpr, char* val, int16_t bytes); +static void doSetTableGroupOutputBuf(SAggOperatorInfo* pAggInfo, int32_t numOfOutput, int32_t tableGroupId, + SExecTaskInfo* pTaskInfo); SArray* getOrderCheckColumns(STaskAttr* pQuery); typedef struct SRowCompSupporter { - STaskRuntimeEnv *pRuntimeEnv; - int16_t dataOffset; - __compar_fn_t comFunc; + STaskRuntimeEnv* pRuntimeEnv; + int16_t dataOffset; + __compar_fn_t comFunc; } SRowCompSupporter; -static int compareRowData(const void *a, const void *b, const void *userData) { - const SResultRow *pRow1 = (const SResultRow *)a; - const SResultRow *pRow2 = (const SResultRow *)b; +static int compareRowData(const void* a, const void* b, const void* userData) { + const SResultRow* pRow1 = (const SResultRow*)a; + const SResultRow* pRow2 = (const SResultRow*)b; - SRowCompSupporter *supporter = (SRowCompSupporter *)userData; - STaskRuntimeEnv* pRuntimeEnv = supporter->pRuntimeEnv; + SRowCompSupporter* supporter = (SRowCompSupporter*)userData; + STaskRuntimeEnv* pRuntimeEnv = supporter->pRuntimeEnv; - SFilePage *page1 = getBufPage(pRuntimeEnv->pResultBuf, pRow1->pageId); - SFilePage *page2 = getBufPage(pRuntimeEnv->pResultBuf, pRow2->pageId); + SFilePage* page1 = getBufPage(pRuntimeEnv->pResultBuf, pRow1->pageId); + SFilePage* page2 = getBufPage(pRuntimeEnv->pResultBuf, pRow2->pageId); int16_t offset = supporter->dataOffset; - char *in1 = getPosInResultPage(pRuntimeEnv->pQueryAttr, page1, pRow1->offset, offset); - char *in2 = getPosInResultPage(pRuntimeEnv->pQueryAttr, page2, pRow2->offset, offset); + char* in1 = getPosInResultPage(pRuntimeEnv->pQueryAttr, page1, pRow1->offset, offset); + char* in2 = getPosInResultPage(pRuntimeEnv->pQueryAttr, page2, pRow2->offset, offset); return (in1 != NULL && in2 != NULL) ? supporter->comFunc(in1, in2) : 0; } -static void sortGroupResByOrderList(SGroupResInfo *pGroupResInfo, STaskRuntimeEnv *pRuntimeEnv, SSDataBlock* pDataBlock) { - SArray *columnOrderList = getOrderCheckColumns(pRuntimeEnv->pQueryAttr); - size_t size = taosArrayGetSize(columnOrderList); +static void sortGroupResByOrderList(SGroupResInfo* pGroupResInfo, STaskRuntimeEnv* pRuntimeEnv, + SSDataBlock* pDataBlock) { + SArray* columnOrderList = getOrderCheckColumns(pRuntimeEnv->pQueryAttr); + size_t size = taosArrayGetSize(columnOrderList); taosArrayDestroy(columnOrderList); if (size <= 0) { @@ -299,11 +311,11 @@ static void sortGroupResByOrderList(SGroupResInfo *pGroupResInfo, STaskRuntimeEn return; } - bool found = false; + bool found = false; int16_t dataOffset = 0; for (int32_t j = 0; j < pDataBlock->info.numOfCols; ++j) { - SColumnInfoData* pColInfoData = (SColumnInfoData *)taosArrayGet(pDataBlock->pDataBlock, j); + SColumnInfoData* pColInfoData = (SColumnInfoData*)taosArrayGet(pDataBlock->pDataBlock, j); if (orderId == j) { found = true; break; @@ -322,7 +334,7 @@ static void sortGroupResByOrderList(SGroupResInfo *pGroupResInfo, STaskRuntimeEn taosArraySortPWithExt(pGroupResInfo->pRows, compareRowData, &support); } -//setup the output buffer for each operator +// setup the output buffer for each operator SSDataBlock* createOutputBuf_rv1(SDataBlockDescNode* pNode) { int32_t numOfCols = LIST_LENGTH(pNode->pSlots); @@ -333,16 +345,16 @@ SSDataBlock* createOutputBuf_rv1(SDataBlockDescNode* pNode) { pBlock->info.blockId = pNode->dataBlockId; pBlock->info.rowSize = pNode->totalRowSize; // todo ?? - for(int32_t i = 0; i < numOfCols; ++i) { + for (int32_t i = 0; i < numOfCols; ++i) { SColumnInfoData idata = {{0}}; - SSlotDescNode* pDescNode = nodesListGetNode(pNode->pSlots, i); + SSlotDescNode* pDescNode = nodesListGetNode(pNode->pSlots, i); if (!pDescNode->output) { continue; } - idata.info.type = pDescNode->dataType.type; - idata.info.bytes = pDescNode->dataType.bytes; - idata.info.scale = pDescNode->dataType.scale; + idata.info.type = pDescNode->dataType.type; + idata.info.bytes = pDescNode->dataType.bytes; + idata.info.scale = pDescNode->dataType.scale; idata.info.slotId = pDescNode->slotId; idata.info.precision = pDescNode->dataType.precision; @@ -352,27 +364,27 @@ SSDataBlock* createOutputBuf_rv1(SDataBlockDescNode* pNode) { return pBlock; } -static bool isSelectivityWithTagsQuery(SqlFunctionCtx *pCtx, int32_t numOfOutput) { +static bool isSelectivityWithTagsQuery(SqlFunctionCtx* pCtx, int32_t numOfOutput) { return true; -// bool hasTags = false; -// int32_t numOfSelectivity = 0; -// -// for (int32_t i = 0; i < numOfOutput; ++i) { -// int32_t functId = pCtx[i].functionId; -// if (functId == FUNCTION_TAG_DUMMY || functId == FUNCTION_TS_DUMMY) { -// hasTags = true; -// continue; -// } -// -// if ((aAggs[functId].status & FUNCSTATE_SELECTIVITY) != 0) { -// numOfSelectivity++; -// } -// } -// -// return (numOfSelectivity > 0 && hasTags); + // bool hasTags = false; + // int32_t numOfSelectivity = 0; + // + // for (int32_t i = 0; i < numOfOutput; ++i) { + // int32_t functId = pCtx[i].functionId; + // if (functId == FUNCTION_TAG_DUMMY || functId == FUNCTION_TS_DUMMY) { + // hasTags = true; + // continue; + // } + // + // if ((aAggs[functId].status & FUNCSTATE_SELECTIVITY) != 0) { + // numOfSelectivity++; + // } + // } + // + // return (numOfSelectivity > 0 && hasTags); } -static bool isProjQuery(STaskAttr *pQueryAttr) { +static bool isProjQuery(STaskAttr* pQueryAttr) { for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { int32_t functId = getExprFunctionId(&pQueryAttr->pExpr1[i]); if (functId != FUNCTION_PRJ && functId != FUNCTION_TAGPRJ) { @@ -383,8 +395,9 @@ static bool isProjQuery(STaskAttr *pQueryAttr) { return true; } -static bool hasNull(SColumn* pColumn, SColumnDataAgg *pStatis) { - if (TSDB_COL_IS_TAG(pColumn->flag) || TSDB_COL_IS_UD_COL(pColumn->flag) || pColumn->colId == PRIMARYKEY_TIMESTAMP_COL_ID) { +static bool hasNull(SColumn* pColumn, SColumnDataAgg* pStatis) { + if (TSDB_COL_IS_TAG(pColumn->flag) || TSDB_COL_IS_UD_COL(pColumn->flag) || + pColumn->colId == PRIMARYKEY_TIMESTAMP_COL_ID) { return false; } @@ -413,13 +426,13 @@ static void prepareResultListBuffer(SResultRowInfo* pResultRowInfo, jmp_buf env) newCapacity += 4; } - char *t = taosMemoryRealloc(pResultRowInfo->pResult, (size_t)(newCapacity * POINTER_BYTES)); + char* t = taosMemoryRealloc(pResultRowInfo->pResult, (size_t)(newCapacity * POINTER_BYTES)); if (t == NULL) { longjmp(env, TSDB_CODE_QRY_OUT_OF_MEMORY); } pResultRowInfo->pPosition = taosMemoryRealloc(pResultRowInfo->pPosition, newCapacity * sizeof(SResultRowPosition)); - pResultRowInfo->pResult = (SResultRow **)t; + pResultRowInfo->pResult = (SResultRow**)t; int32_t inc = (int32_t)newCapacity - pResultRowInfo->capacity; memset(&pResultRowInfo->pResult[pResultRowInfo->capacity], 0, POINTER_BYTES * inc); @@ -428,13 +441,13 @@ static void prepareResultListBuffer(SResultRowInfo* pResultRowInfo, jmp_buf env) pResultRowInfo->capacity = (int32_t)newCapacity; } -static bool chkResultRowFromKey(STaskRuntimeEnv *pRuntimeEnv, SResultRowInfo *pResultRowInfo, char *pData, - int16_t bytes, bool masterscan, uint64_t uid) { +static bool chkResultRowFromKey(STaskRuntimeEnv* pRuntimeEnv, SResultRowInfo* pResultRowInfo, char* pData, + int16_t bytes, bool masterscan, uint64_t uid) { bool existed = false; SET_RES_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, uid); - SResultRow **p1 = - (SResultRow **)taosHashGet(pRuntimeEnv->pResultRowHashTable, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes)); + SResultRow** p1 = + (SResultRow**)taosHashGet(pRuntimeEnv->pResultRowHashTable, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes)); // in case of repeat scan/reverse scan, no new time window added. if (QUERY_IS_INTERVAL_QUERY(pRuntimeEnv->pQueryAttr)) { @@ -450,7 +463,8 @@ static bool chkResultRowFromKey(STaskRuntimeEnv *pRuntimeEnv, SResultRowInfo *pR existed = (pResultRowInfo->pResult[0] == (*p1)); } else { // check if current pResultRowInfo contains the existed pResultRow SET_RES_EXT_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, uid, pResultRowInfo); - int64_t* index = taosHashGet(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes)); + int64_t* index = + taosHashGet(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes)); if (index != NULL) { existed = true; } else { @@ -465,19 +479,18 @@ static bool chkResultRowFromKey(STaskRuntimeEnv *pRuntimeEnv, SResultRowInfo *pR return p1 != NULL; } - static SResultRow* doSetResultOutBufByKey(STaskRuntimeEnv* pRuntimeEnv, SResultRowInfo* pResultRowInfo, int64_t tid, char* pData, int16_t bytes, bool masterscan, uint64_t tableGroupId) { bool existed = false; SET_RES_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tableGroupId); - SResultRow **p1 = - (SResultRow **)taosHashGet(pRuntimeEnv->pResultRowHashTable, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes)); + SResultRow** p1 = + (SResultRow**)taosHashGet(pRuntimeEnv->pResultRowHashTable, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes)); // in case of repeat scan/reverse scan, no new time window added. if (QUERY_IS_INTERVAL_QUERY(pRuntimeEnv->pQueryAttr)) { if (!masterscan) { // the *p1 may be NULL in case of sliding+offset exists. - return (p1 != NULL)? *p1:NULL; + return (p1 != NULL) ? *p1 : NULL; } if (p1 != NULL) { @@ -489,9 +502,10 @@ static SResultRow* doSetResultOutBufByKey(STaskRuntimeEnv* pRuntimeEnv, SResultR pResultRowInfo->curPos = 0; } else { // check if current pResultRowInfo contains the existed pResultRow SET_RES_EXT_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tid, pResultRowInfo); - int64_t* index = taosHashGet(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes)); + int64_t* index = + taosHashGet(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes)); if (index != NULL) { - pResultRowInfo->curPos = (int32_t) *index; + pResultRowInfo->curPos = (int32_t)*index; existed = true; } else { existed = false; @@ -506,9 +520,9 @@ static SResultRow* doSetResultOutBufByKey(STaskRuntimeEnv* pRuntimeEnv, SResultR } if (!existed) { -// prepareResultListBuffer(pResultRowInfo, pRuntimeEnv); + // prepareResultListBuffer(pResultRowInfo, pRuntimeEnv); - SResultRow *pResult = NULL; + SResultRow* pResult = NULL; if (p1 == NULL) { pResult = getNewResultRow(pRuntimeEnv->pool); int32_t ret = initResultRow(pResult); @@ -517,7 +531,8 @@ static SResultRow* doSetResultOutBufByKey(STaskRuntimeEnv* pRuntimeEnv, SResultR } // add a new result set for a new group - taosHashPut(pRuntimeEnv->pResultRowHashTable, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pResult, POINTER_BYTES); + taosHashPut(pRuntimeEnv->pResultRowHashTable, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pResult, + POINTER_BYTES); SResultRowCell cell = {.groupId = tableGroupId, .pRow = pResult}; taosArrayPush(pRuntimeEnv->pResultRowArrayList, &cell); } else { @@ -529,7 +544,8 @@ static SResultRow* doSetResultOutBufByKey(STaskRuntimeEnv* pRuntimeEnv, SResultR int64_t index = pResultRowInfo->curPos; SET_RES_EXT_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tid, pResultRowInfo); - taosHashPut(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes), &index, POINTER_BYTES); + taosHashPut(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes), &index, + POINTER_BYTES); } // too many time window in query @@ -541,7 +557,7 @@ static SResultRow* doSetResultOutBufByKey(STaskRuntimeEnv* pRuntimeEnv, SResultR } SResultRow* getNewResultRow_rv(SDiskbasedBuf* pResultBuf, int64_t tableGroupId, int32_t interBufSize) { - SFilePage *pData = NULL; + SFilePage* pData = NULL; // in the first scan, new space needed for results int32_t pageId = -1; @@ -580,18 +596,18 @@ SResultRow* getNewResultRow_rv(SDiskbasedBuf* pResultBuf, int64_t tableGroupId, return pResultRow; } -static SResultRow* doSetResultOutBufByKey_rv(SDiskbasedBuf* pResultBuf, SResultRowInfo* pResultRowInfo, int64_t tid, char* pData, int16_t bytes, - bool masterscan, uint64_t tableGroupId, SExecTaskInfo* pTaskInfo, bool isIntervalQuery, SAggSupporter* pSup) { +static SResultRow* doSetResultOutBufByKey_rv(SDiskbasedBuf* pResultBuf, SResultRowInfo* pResultRowInfo, int64_t tid, + char* pData, int16_t bytes, bool masterscan, uint64_t tableGroupId, + SExecTaskInfo* pTaskInfo, bool isIntervalQuery, SAggSupporter* pSup) { bool existed = false; SET_RES_WINDOW_KEY(pSup->keyBuf, pData, bytes, tableGroupId); - SResultRow **p1 = - (SResultRow **)taosHashGet(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes)); + SResultRow** p1 = (SResultRow**)taosHashGet(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes)); // in case of repeat scan/reverse scan, no new time window added. if (isIntervalQuery) { if (!masterscan) { // the *p1 may be NULL in case of sliding+offset exists. - return (p1 != NULL)? *p1:NULL; + return (p1 != NULL) ? *p1 : NULL; } if (p1 != NULL) { @@ -605,7 +621,7 @@ static SResultRow* doSetResultOutBufByKey_rv(SDiskbasedBuf* pResultBuf, SResultR SET_RES_EXT_WINDOW_KEY(pSup->keyBuf, pData, bytes, tid, pResultRowInfo); int64_t* index = taosHashGet(pSup->pResultRowListSet, pSup->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes)); if (index != NULL) { - pResultRowInfo->curPos = (int32_t) *index; + pResultRowInfo->curPos = (int32_t)*index; existed = true; } else { existed = false; @@ -622,7 +638,7 @@ static SResultRow* doSetResultOutBufByKey_rv(SDiskbasedBuf* pResultBuf, SResultR if (!existed) { prepareResultListBuffer(pResultRowInfo, pTaskInfo->env); - SResultRow *pResult = NULL; + SResultRow* pResult = NULL; if (p1 == NULL) { pResult = getNewResultRow_rv(pResultBuf, tableGroupId, pSup->resultRowSize); int32_t ret = initResultRow(pResult); @@ -639,7 +655,8 @@ static SResultRow* doSetResultOutBufByKey_rv(SDiskbasedBuf* pResultBuf, SResultR } pResultRowInfo->curPos = pResultRowInfo->size; - pResultRowInfo->pPosition[pResultRowInfo->size] = (SResultRowPosition) {.pageId = pResult->pageId, .offset = pResult->offset}; + pResultRowInfo->pPosition[pResultRowInfo->size] = + (SResultRowPosition){.pageId = pResult->pageId, .offset = pResult->offset}; pResultRowInfo->pResult[pResultRowInfo->size++] = pResult; int64_t index = pResultRowInfo->curPos; @@ -655,7 +672,8 @@ static SResultRow* doSetResultOutBufByKey_rv(SDiskbasedBuf* pResultBuf, SResultR return pResultRowInfo->pResult[pResultRowInfo->curPos]; } -static void getInitialStartTimeWindow(SInterval* pInterval, int32_t precision, TSKEY ts, STimeWindow* w, TSKEY ekey, bool ascQuery) { +static void getInitialStartTimeWindow(SInterval* pInterval, int32_t precision, TSKEY ts, STimeWindow* w, TSKEY ekey, + bool ascQuery) { if (ascQuery) { getAlignQueryTimeWindow(pInterval, precision, ts, ts, ekey, w); } else { @@ -663,7 +681,7 @@ static void getInitialStartTimeWindow(SInterval* pInterval, int32_t precision, T getAlignQueryTimeWindow(pInterval, precision, ts, ekey, ts, w); int64_t key = w->skey; - while(key < ts) { // moving towards end + while (key < ts) { // moving towards end key = taosTimeAdd(key, pInterval->sliding, pInterval->slidingUnit, precision); if (key >= ts) { break; @@ -675,10 +693,11 @@ static void getInitialStartTimeWindow(SInterval* pInterval, int32_t precision, T } // get the correct time window according to the handled timestamp -static STimeWindow getActiveTimeWindow(SResultRowInfo * pResultRowInfo, int64_t ts, SInterval* pInterval, int32_t precision, STimeWindow* win) { +static STimeWindow getActiveTimeWindow(SResultRowInfo* pResultRowInfo, int64_t ts, SInterval* pInterval, + int32_t precision, STimeWindow* win) { STimeWindow w = {0}; - if (pResultRowInfo->curPos == -1) { // the first window, from the previous stored value + if (pResultRowInfo->curPos == -1) { // the first window, from the previous stored value getInitialStartTimeWindow(pInterval, precision, ts, &w, win->ekey, true); w.ekey = taosTimeAdd(w.skey, pInterval->interval, pInterval->intervalUnit, precision) - 1; } else { @@ -709,14 +728,16 @@ static STimeWindow getActiveTimeWindow(SResultRowInfo * pResultRowInfo, int64_t } // get the correct time window according to the handled timestamp -static STimeWindow getCurrentActiveTimeWindow(SResultRowInfo * pResultRowInfo, int64_t ts, STaskAttr *pQueryAttr) { +static STimeWindow getCurrentActiveTimeWindow(SResultRowInfo* pResultRowInfo, int64_t ts, STaskAttr* pQueryAttr) { STimeWindow w = {0}; - if (pResultRowInfo->curPos == -1) { // the first window, from the previous stored value -// getInitialStartTimeWindow(pQueryAttr, ts, &w); + if (pResultRowInfo->curPos == -1) { // the first window, from the previous stored value + // getInitialStartTimeWindow(pQueryAttr, ts, &w); if (pQueryAttr->interval.intervalUnit == 'n' || pQueryAttr->interval.intervalUnit == 'y') { - w.ekey = taosTimeAdd(w.skey, pQueryAttr->interval.interval, pQueryAttr->interval.intervalUnit, pQueryAttr->precision) - 1; + w.ekey = + taosTimeAdd(w.skey, pQueryAttr->interval.interval, pQueryAttr->interval.intervalUnit, pQueryAttr->precision) - + 1; } else { w.ekey = w.skey + pQueryAttr->interval.interval - 1; } @@ -736,12 +757,12 @@ static STimeWindow getCurrentActiveTimeWindow(SResultRowInfo * pResultRowInfo, i } // a new buffer page for each table. Needs to opt this design -static int32_t addNewWindowResultBuf(SResultRow *pWindowRes, SDiskbasedBuf *pResultBuf, int32_t tid, uint32_t size) { +static int32_t addNewWindowResultBuf(SResultRow* pWindowRes, SDiskbasedBuf* pResultBuf, int32_t tid, uint32_t size) { if (pWindowRes->pageId != -1) { return 0; } - SFilePage *pData = NULL; + SFilePage* pData = NULL; // in the first scan, new space needed for results int32_t pageId = -1; @@ -782,20 +803,21 @@ static int32_t addNewWindowResultBuf(SResultRow *pWindowRes, SDiskbasedBuf *pRes return 0; } -static bool chkWindowOutputBufByKey(STaskRuntimeEnv *pRuntimeEnv, SResultRowInfo *pResultRowInfo, STimeWindow *win, - bool masterscan, SResultRow **pResult, int64_t groupId, SqlFunctionCtx* pCtx, - int32_t numOfOutput, int32_t* rowCellInfoOffset) { +static bool chkWindowOutputBufByKey(STaskRuntimeEnv* pRuntimeEnv, SResultRowInfo* pResultRowInfo, STimeWindow* win, + bool masterscan, SResultRow** pResult, int64_t groupId, SqlFunctionCtx* pCtx, + int32_t numOfOutput, int32_t* rowCellInfoOffset) { assert(win->skey <= win->ekey); - return chkResultRowFromKey(pRuntimeEnv, pResultRowInfo, (char *)&win->skey, TSDB_KEYSIZE, masterscan, groupId); + return chkResultRowFromKey(pRuntimeEnv, pResultRowInfo, (char*)&win->skey, TSDB_KEYSIZE, masterscan, groupId); } -static int32_t setResultOutputBufByKey(STaskRuntimeEnv *pRuntimeEnv, SResultRowInfo *pResultRowInfo, int64_t tid, STimeWindow *win, - bool masterscan, SResultRow **pResult, int64_t tableGroupId, SqlFunctionCtx* pCtx, - int32_t numOfOutput, int32_t* rowCellInfoOffset) { +static int32_t setResultOutputBufByKey(STaskRuntimeEnv* pRuntimeEnv, SResultRowInfo* pResultRowInfo, int64_t tid, + STimeWindow* win, bool masterscan, SResultRow** pResult, int64_t tableGroupId, + SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowCellInfoOffset) { assert(win->skey <= win->ekey); - SDiskbasedBuf *pResultBuf = pRuntimeEnv->pResultBuf; + SDiskbasedBuf* pResultBuf = pRuntimeEnv->pResultBuf; - SResultRow *pResultRow = doSetResultOutBufByKey(pRuntimeEnv, pResultRowInfo, tid, (char *)&win->skey, TSDB_KEYSIZE, masterscan, tableGroupId); + SResultRow* pResultRow = doSetResultOutBufByKey(pRuntimeEnv, pResultRowInfo, tid, (char*)&win->skey, TSDB_KEYSIZE, + masterscan, tableGroupId); if (pResultRow == NULL) { *pResult = NULL; return TSDB_CODE_SUCCESS; @@ -803,7 +825,8 @@ static int32_t setResultOutputBufByKey(STaskRuntimeEnv *pRuntimeEnv, SResultRowI // not assign result buffer yet, add new result buffer if (pResultRow->pageId == -1) { - int32_t ret = addNewWindowResultBuf(pResultRow, pResultBuf, (int32_t) tableGroupId, pRuntimeEnv->pQueryAttr->intermediateResultRowSize); + int32_t ret = addNewWindowResultBuf(pResultRow, pResultBuf, (int32_t)tableGroupId, + pRuntimeEnv->pQueryAttr->intermediateResultRowSize); if (ret != TSDB_CODE_SUCCESS) { return -1; } @@ -817,14 +840,16 @@ static int32_t setResultOutputBufByKey(STaskRuntimeEnv *pRuntimeEnv, SResultRowI return TSDB_CODE_SUCCESS; } -static void setResultRowOutputBufInitCtx_rv(SDiskbasedBuf * pBuf, SResultRow *pResult, SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowCellInfoOffset); +static void setResultRowOutputBufInitCtx_rv(SDiskbasedBuf* pBuf, SResultRow* pResult, SqlFunctionCtx* pCtx, + int32_t numOfOutput, int32_t* rowCellInfoOffset); -static int32_t setResultOutputBufByKey_rv(SResultRowInfo *pResultRowInfo, int64_t id, STimeWindow *win, - bool masterscan, SResultRow **pResult, int64_t tableGroupId, SqlFunctionCtx* pCtx, - int32_t numOfOutput, int32_t* rowCellInfoOffset, SAggSupporter *pAggSup, SExecTaskInfo* pTaskInfo) { +static int32_t setResultOutputBufByKey_rv(SResultRowInfo* pResultRowInfo, int64_t id, STimeWindow* win, bool masterscan, + SResultRow** pResult, int64_t tableGroupId, SqlFunctionCtx* pCtx, + int32_t numOfOutput, int32_t* rowCellInfoOffset, SAggSupporter* pAggSup, + SExecTaskInfo* pTaskInfo) { assert(win->skey <= win->ekey); - SResultRow *pResultRow = doSetResultOutBufByKey_rv(pAggSup->pResultBuf, pResultRowInfo, id, (char *)&win->skey, TSDB_KEYSIZE, masterscan, tableGroupId, - pTaskInfo, true, pAggSup); + SResultRow* pResultRow = doSetResultOutBufByKey_rv(pAggSup->pResultBuf, pResultRowInfo, id, (char*)&win->skey, + TSDB_KEYSIZE, masterscan, tableGroupId, pTaskInfo, true, pAggSup); if (pResultRow == NULL) { *pResult = NULL; @@ -838,13 +863,12 @@ static int32_t setResultOutputBufByKey_rv(SResultRowInfo *pResultRowInfo, int64_ return TSDB_CODE_SUCCESS; } - static void setResultRowInterpo(SResultRow* pResult, SResultTsInterpType type) { assert(pResult != NULL && (type == RESULT_ROW_START_INTERP || type == RESULT_ROW_END_INTERP)); if (type == RESULT_ROW_START_INTERP) { pResult->startInterp = true; } else { - pResult->endInterp = true; + pResult->endInterp = true; } } @@ -853,16 +877,16 @@ static bool resultRowInterpolated(SResultRow* pResult, SResultTsInterpType type) if (type == RESULT_ROW_START_INTERP) { return pResult->startInterp == true; } else { - return pResult->endInterp == true; + return pResult->endInterp == true; } } -static FORCE_INLINE int32_t getForwardStepsInBlock(int32_t numOfRows, __block_search_fn_t searchFn, TSKEY ekey, int16_t pos, - int16_t order, int64_t *pData) { +static FORCE_INLINE int32_t getForwardStepsInBlock(int32_t numOfRows, __block_search_fn_t searchFn, TSKEY ekey, + int16_t pos, int16_t order, int64_t* pData) { int32_t forwardStep = 0; if (order == TSDB_ORDER_ASC) { - int32_t end = searchFn((char*) &pData[pos], numOfRows - pos, ekey, order); + int32_t end = searchFn((char*)&pData[pos], numOfRows - pos, ekey, order); if (end >= 0) { forwardStep = end; @@ -871,7 +895,7 @@ static FORCE_INLINE int32_t getForwardStepsInBlock(int32_t numOfRows, __block_se } } } else { - int32_t end = searchFn((char *)pData, pos + 1, ekey, order); + int32_t end = searchFn((char*)pData, pos + 1, ekey, order); if (end >= 0) { forwardStep = pos - end; @@ -885,19 +909,21 @@ static FORCE_INLINE int32_t getForwardStepsInBlock(int32_t numOfRows, __block_se return forwardStep; } -static void doUpdateResultRowIndex(SResultRowInfo*pResultRowInfo, TSKEY lastKey, bool ascQuery, bool timeWindowInterpo) { +static void doUpdateResultRowIndex(SResultRowInfo* pResultRowInfo, TSKEY lastKey, bool ascQuery, + bool timeWindowInterpo) { int64_t skey = TSKEY_INITIAL_VAL; int32_t i = 0; for (i = pResultRowInfo->size - 1; i >= 0; --i) { - SResultRow *pResult = pResultRowInfo->pResult[i]; + SResultRow* pResult = pResultRowInfo->pResult[i]; if (pResult->closed) { break; } // new closed result rows if (timeWindowInterpo) { - if (pResult->endInterp && ((pResult->win.skey <= lastKey && ascQuery) || (pResult->win.skey >= lastKey && !ascQuery))) { - if (i > 0) { // the first time window, the startInterp is false. + if (pResult->endInterp && + ((pResult->win.skey <= lastKey && ascQuery) || (pResult->win.skey >= lastKey && !ascQuery))) { + if (i > 0) { // the first time window, the startInterp is false. assert(pResult->startInterp); } @@ -917,16 +943,15 @@ static void doUpdateResultRowIndex(SResultRowInfo*pResultRowInfo, TSKEY lastKey, // all result rows are closed, set the last one to be the skey if (skey == TSKEY_INITIAL_VAL) { if (pResultRowInfo->size == 0) { -// assert(pResultRowInfo->current == NULL); + // assert(pResultRowInfo->current == NULL); assert(pResultRowInfo->curPos == -1); pResultRowInfo->curPos = -1; } else { pResultRowInfo->curPos = pResultRowInfo->size - 1; } } else { - for (i = pResultRowInfo->size - 1; i >= 0; --i) { - SResultRow *pResult = pResultRowInfo->pResult[i]; + SResultRow* pResult = pResultRowInfo->pResult[i]; if (pResult->closed) { break; } @@ -940,7 +965,8 @@ static void doUpdateResultRowIndex(SResultRowInfo*pResultRowInfo, TSKEY lastKey, } } -static void updateResultRowInfoActiveIndex(SResultRowInfo* pResultRowInfo, const STimeWindow* pWin, TSKEY lastKey, bool ascQuery, bool interp) { +static void updateResultRowInfoActiveIndex(SResultRowInfo* pResultRowInfo, const STimeWindow* pWin, TSKEY lastKey, + bool ascQuery, bool interp) { if ((lastKey > pWin->ekey && ascQuery) || (lastKey < pWin->ekey && (!ascQuery))) { closeAllResultRows(pResultRowInfo); pResultRowInfo->curPos = pResultRowInfo->size - 1; @@ -950,12 +976,13 @@ static void updateResultRowInfoActiveIndex(SResultRowInfo* pResultRowInfo, const } } -static int32_t getNumOfRowsInTimeWindow(SDataBlockInfo *pDataBlockInfo, TSKEY *pPrimaryColumn, - int32_t startPos, TSKEY ekey, __block_search_fn_t searchFn, STableQueryInfo* item, int32_t order) { +static int32_t getNumOfRowsInTimeWindow(SDataBlockInfo* pDataBlockInfo, TSKEY* pPrimaryColumn, int32_t startPos, + TSKEY ekey, __block_search_fn_t searchFn, STableQueryInfo* item, + int32_t order) { assert(startPos >= 0 && startPos < pDataBlockInfo->rows); - int32_t num = -1; - int32_t step = GET_FORWARD_DIRECTION_FACTOR(order); + int32_t num = -1; + int32_t step = GET_FORWARD_DIRECTION_FACTOR(order); if (order == TSDB_ORDER_ASC) { if (ekey < pDataBlockInfo->window.ekey && pPrimaryColumn) { @@ -993,9 +1020,9 @@ static void doApplyFunctions(SqlFunctionCtx* pCtx, STimeWindow* pWin, int32_t of pCtx[k].startTs = pWin->skey; // keep it temporarialy - bool hasAgg = pCtx[k].input.colDataAggIsSet; + bool hasAgg = pCtx[k].input.colDataAggIsSet; int32_t startOffset = pCtx[k].input.startRowIndex; - int32_t numOfRows = pCtx[k].input.numOfRows; + int32_t numOfRows = pCtx[k].input.numOfRows; int32_t pos = (order == TSDB_ORDER_ASC) ? offset : offset - (forwardStep - 1); pCtx[k].input.startRowIndex = pos; @@ -1025,7 +1052,7 @@ static void doApplyFunctions(SqlFunctionCtx* pCtx, STimeWindow* pWin, int32_t of static int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext, SDataBlockInfo* pDataBlockInfo, TSKEY* primaryKeys, int32_t prevPosition, STableIntervalOperatorInfo* pInfo) { int32_t order = pInfo->order; - bool ascQuery = (order == TSDB_ORDER_ASC); + bool ascQuery = (order == TSDB_ORDER_ASC); int32_t precision = pInfo->precision; getNextTimeWindow(pInterval, precision, order, pNext); @@ -1036,7 +1063,7 @@ static int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext, return -1; } - TSKEY startKey = ascQuery? pNext->skey:pNext->ekey; + TSKEY startKey = ascQuery ? pNext->skey : pNext->ekey; int32_t startPos = 0; // tumbling time window query, a special case of sliding time window query @@ -1049,14 +1076,14 @@ static int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext, } else if (startKey >= pDataBlockInfo->window.ekey && !ascQuery) { startPos = pDataBlockInfo->rows - 1; } else { - startPos = binarySearchForKey((char *)primaryKeys, pDataBlockInfo->rows, startKey, order); + startPos = binarySearchForKey((char*)primaryKeys, pDataBlockInfo->rows, startKey, order); } } /* interp query with fill should not skip time window */ -// if (pQueryAttr->pointInterpQuery && pQueryAttr->fillType != TSDB_FILL_NONE) { -// return startPos; -// } + // if (pQueryAttr->pointInterpQuery && pQueryAttr->fillType != TSDB_FILL_NONE) { + // return startPos; + // } /* * This time window does not cover any data, try next time window, @@ -1075,7 +1102,7 @@ static int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext, pNext->skey = taosTimeTruncate(next, pInterval, precision); pNext->ekey = taosTimeAdd(pNext->skey, pInterval->interval, pInterval->intervalUnit, precision) - 1; } else { - pNext->ekey += ((next - pNext->ekey + pInterval->sliding - 1)/pInterval->sliding) * pInterval->sliding; + pNext->ekey += ((next - pNext->ekey + pInterval->sliding - 1) / pInterval->sliding) * pInterval->sliding; pNext->skey = pNext->ekey - pInterval->interval + 1; } } else if ((!ascQuery) && primaryKeys[startPos] < pNext->skey) { @@ -1093,7 +1120,7 @@ static int32_t getNextQualifiedWindow(SInterval* pInterval, STimeWindow* pNext, return startPos; } -static FORCE_INLINE TSKEY reviseWindowEkey(STaskAttr *pQueryAttr, STimeWindow *pWindow) { +static FORCE_INLINE TSKEY reviseWindowEkey(STaskAttr* pQueryAttr, STimeWindow* pWindow) { TSKEY ekey = -1; if (QUERY_IS_ASC_QUERY(pQueryAttr)) { ekey = pWindow->ekey; @@ -1128,7 +1155,7 @@ static void saveDataBlockLastRow(char** pRow, SArray* pDataBlock, int32_t rowInd } for (int32_t k = 0; k < numOfCols; ++k) { - SColumnInfoData *pColInfo = taosArrayGet(pDataBlock, k); + SColumnInfoData* pColInfo = taosArrayGet(pDataBlock, k); memcpy(pRow[k], ((char*)pColInfo->pData) + (pColInfo->info.bytes * rowIndex), pColInfo->info.bytes); } } @@ -1136,9 +1163,9 @@ static void saveDataBlockLastRow(char** pRow, SArray* pDataBlock, int32_t rowInd static TSKEY getStartTsKey(STimeWindow* win, const TSKEY* tsCols, int32_t rows, bool ascQuery) { TSKEY ts = TSKEY_INITIAL_VAL; if (tsCols == NULL) { - ts = ascQuery? win->skey : win->ekey; + ts = ascQuery ? win->skey : win->ekey; } else { - int32_t offset = ascQuery? 0:rows-1; + int32_t offset = ascQuery ? 0 : rows - 1; ts = tsCols[offset]; } @@ -1147,13 +1174,14 @@ static TSKEY getStartTsKey(STimeWindow* win, const TSKEY* tsCols, int32_t rows, static void doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t order); -static void doSetInputDataBlockInfo(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t order) { +static void doSetInputDataBlockInfo(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx, SSDataBlock* pBlock, + int32_t order) { for (int32_t i = 0; i < pOperator->numOfOutput; ++i) { pCtx[i].order = order; - pCtx[i].size = pBlock->info.rows; + pCtx[i].size = pBlock->info.rows; pCtx[i].currentStage = (uint8_t)pOperator->pRuntimeEnv->scanFlag; - setBlockStatisInfo(&pCtx[i], pBlock, NULL/*&pOperator->pExpr[i].base.colInfo*/); + setBlockStatisInfo(&pCtx[i], pBlock, NULL /*&pOperator->pExpr[i].base.colInfo*/); } } @@ -1168,11 +1196,22 @@ void setInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx, SSDataBlo static void doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t order) { for (int32_t i = 0; i < pOperator->numOfOutput; ++i) { pCtx[i].order = order; - pCtx[i].size = pBlock->info.rows; + pCtx[i].size = pBlock->info.rows; pCtx[i].currentStage = MAIN_SCAN; + SExprInfo expr = pOperator->pExpr[i]; + for (int32_t j = 0; j < expr.base.numOfParams; ++j) { + SFunctParam *pFuncParam = &expr.base.pParam[j]; + if (pFuncParam->type == FUNC_PARAM_TYPE_COLUMN) { + int32_t slotId = pFuncParam->pCol->slotId; + pCtx[i].input.pData[j] = taosArrayGet(pBlock->pDataBlock, slotId); + pCtx[i].input.totalRows = pBlock->info.rows; + pCtx[i].input.numOfRows = pBlock->info.rows; + pCtx[i].input.startRowIndex = 0; + ASSERT(pCtx[i].input.pData[j] != NULL); + } + } // setBlockStatisInfo(&pCtx[i], pBlock, pOperator->pExpr[i].base.pColumns); - int32_t slotId = pOperator->pExpr[i].base.pParam[0].pCol->slotId; // uint32_t flag = pOperator->pExpr[i].base.pParam[0].pCol->flag; // if (TSDB_COL_IS_NORMAL_COL(flag) /*|| (pCtx[i].functionId == FUNCTION_BLKINFO) || @@ -1190,12 +1229,11 @@ static void doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx, // } // in case of the block distribution query, the inputBytes is not a constant value. - pCtx[i].input.pData[0] = taosArrayGet(pBlock->pDataBlock, slotId); - pCtx[i].input.totalRows = pBlock->info.rows; - pCtx[i].input.numOfRows = pBlock->info.rows; - pCtx[i].input.startRowIndex = 0; + //pCtx[i].input.pData[0] = taosArrayGet(pBlock->pDataBlock, slotId); + //pCtx[i].input.totalRows = pBlock->info.rows; + //pCtx[i].input.numOfRows = pBlock->info.rows; + //pCtx[i].input.startRowIndex = 0; - ASSERT(pCtx[i].input.pData[0] != NULL); // uint32_t status = aAggs[pCtx[i].functionId].status; // if ((status & (FUNCSTATE_SELECTIVITY | FUNCSTATE_NEED_TS)) != 0) { @@ -1225,15 +1263,16 @@ static void doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx, static void doAggregateImpl(SOperatorInfo* pOperator, TSKEY startTs, SqlFunctionCtx* pCtx) { for (int32_t k = 0; k < pOperator->numOfOutput; ++k) { if (functionNeedToExecute(&pCtx[k])) { - pCtx[k].startTs = startTs;// this can be set during create the struct + pCtx[k].startTs = startTs; // this can be set during create the struct pCtx[k].fpSet.process(&pCtx[k]); } } } -static void projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBlock* pSrcBlock, SqlFunctionCtx *pCtx, int32_t numOfOutput) { +static void projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBlock* pSrcBlock, SqlFunctionCtx* pCtx, + int32_t numOfOutput) { for (int32_t k = 0; k < numOfOutput; ++k) { - if (pExpr[k].pExpr->nodeType == QUERY_NODE_COLUMN) { // it is a project query + if (pExpr[k].pExpr->nodeType == QUERY_NODE_COLUMN) { // it is a project query SColumnInfoData* pColInfoData = taosArrayGet(pResult->pDataBlock, k); colDataAssign(pColInfoData, pCtx[k].input.pData[0], pCtx[k].input.numOfRows); @@ -1252,15 +1291,17 @@ static void projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSData } else if (pExpr[k].pExpr->nodeType == QUERY_NODE_FUNCTION) { ASSERT(!fmIsAggFunc(pCtx->functionId)); - SScalarParam p = {.numOfRows = pSrcBlock->info.rows}; - int32_t slotId = pExpr[k].base.pParam[0].pCol->slotId; - p.columnData = taosArrayGet(pSrcBlock->pDataBlock, slotId); + SArray* pBlockList = taosArrayInit(4, POINTER_BYTES); + taosArrayPush(pBlockList, &pSrcBlock); SScalarParam dest = {0}; dest.columnData = taosArrayGet(pResult->pDataBlock, k); - pCtx[k].sfp.process(&p, 1, &dest); + scalarCalculate((SNode *)pExpr[k].pExpr->_function.pFunctNode, pBlockList, &dest); pResult->info.rows = dest.numOfRows; + + taosArrayDestroy(pBlockList); + } else { ASSERT(0); } @@ -1269,8 +1310,8 @@ static void projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSData void doTimeWindowInterpolation(SOperatorInfo* pOperator, SOptrBasicInfo* pInfo, SArray* pDataBlock, TSKEY prevTs, int32_t prevRowIndex, TSKEY curTs, int32_t curRowIndex, TSKEY windowKey, int32_t type) { - STaskRuntimeEnv *pRuntimeEnv = pOperator->pRuntimeEnv; - SExprInfo* pExpr = pOperator->pExpr; + STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv; + SExprInfo* pExpr = pOperator->pExpr; SqlFunctionCtx* pCtx = pInfo->pCtx; @@ -1281,20 +1322,20 @@ void doTimeWindowInterpolation(SOperatorInfo* pOperator, SOptrBasicInfo* pInfo, continue; } - SColIndex * pColIndex = NULL/*&pExpr[k].base.colInfo*/; + SColIndex* pColIndex = NULL /*&pExpr[k].base.colInfo*/; int16_t index = pColIndex->colIndex; - SColumnInfoData *pColInfo = taosArrayGet(pDataBlock, index); + SColumnInfoData* pColInfo = taosArrayGet(pDataBlock, index); -// assert(pColInfo->info.colId == pColIndex->info.colId && curTs != windowKey); + // assert(pColInfo->info.colId == pColIndex->info.colId && curTs != windowKey); double v1 = 0, v2 = 0, v = 0; if (prevRowIndex == -1) { - GET_TYPED_DATA(v1, double, pColInfo->info.type, (char *)pRuntimeEnv->prevRow[index]); + GET_TYPED_DATA(v1, double, pColInfo->info.type, (char*)pRuntimeEnv->prevRow[index]); } else { - GET_TYPED_DATA(v1, double, pColInfo->info.type, (char *)pColInfo->pData + prevRowIndex * pColInfo->info.bytes); + GET_TYPED_DATA(v1, double, pColInfo->info.type, (char*)pColInfo->pData + prevRowIndex * pColInfo->info.bytes); } - GET_TYPED_DATA(v2, double, pColInfo->info.type, (char *)pColInfo->pData + curRowIndex * pColInfo->info.bytes); + GET_TYPED_DATA(v2, double, pColInfo->info.type, (char*)pColInfo->pData + curRowIndex * pColInfo->info.bytes); if (functionId == FUNCTION_INTERP) { if (type == RESULT_ROW_START_INTERP) { @@ -1306,18 +1347,18 @@ void doTimeWindowInterpolation(SOperatorInfo* pOperator, SOptrBasicInfo* pInfo, if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) { if (prevRowIndex == -1) { - pCtx[k].start.ptr = (char *)pRuntimeEnv->prevRow[index]; + pCtx[k].start.ptr = (char*)pRuntimeEnv->prevRow[index]; } else { - pCtx[k].start.ptr = (char *)pColInfo->pData + prevRowIndex * pColInfo->info.bytes; + pCtx[k].start.ptr = (char*)pColInfo->pData + prevRowIndex * pColInfo->info.bytes; } - pCtx[k].end.ptr = (char *)pColInfo->pData + curRowIndex * pColInfo->info.bytes; + pCtx[k].end.ptr = (char*)pColInfo->pData + curRowIndex * pColInfo->info.bytes; } } } else if (functionId == FUNCTION_TWA) { - SPoint point1 = (SPoint){.key = prevTs, .val = &v1}; - SPoint point2 = (SPoint){.key = curTs, .val = &v2}; - SPoint point = (SPoint){.key = windowKey, .val = &v }; + SPoint point1 = (SPoint){.key = prevTs, .val = &v1}; + SPoint point2 = (SPoint){.key = curTs, .val = &v2}; + SPoint point = (SPoint){.key = windowKey, .val = &v}; taosGetLinearInterpolationVal(&point, TSDB_DATA_TYPE_DOUBLE, &point1, &point2, TSDB_DATA_TYPE_DOUBLE); @@ -1333,18 +1374,19 @@ void doTimeWindowInterpolation(SOperatorInfo* pOperator, SOptrBasicInfo* pInfo, } static bool setTimeWindowInterpolationStartTs(SOperatorInfo* pOperatorInfo, SqlFunctionCtx* pCtx, int32_t pos, - int32_t numOfRows, SArray* pDataBlock, const TSKEY* tsCols, STimeWindow* win) { + int32_t numOfRows, SArray* pDataBlock, const TSKEY* tsCols, + STimeWindow* win) { STaskRuntimeEnv* pRuntimeEnv = pOperatorInfo->pRuntimeEnv; - STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; + STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; bool ascQuery = QUERY_IS_ASC_QUERY(pQueryAttr); - TSKEY curTs = tsCols[pos]; - TSKEY lastTs = *(TSKEY *) pRuntimeEnv->prevRow[0]; + TSKEY curTs = tsCols[pos]; + TSKEY lastTs = *(TSKEY*)pRuntimeEnv->prevRow[0]; // lastTs == INT64_MIN and pos == 0 means this is the first time window, interpolation is not needed. // start exactly from this point, no need to do interpolation - TSKEY key = ascQuery? win->skey:win->ekey; + TSKEY key = ascQuery ? win->skey : win->ekey; if (key == curTs) { setNotInterpoWindowKey(pCtx, pOperatorInfo->numOfOutput, RESULT_ROW_START_INTERP); return true; @@ -1356,22 +1398,23 @@ static bool setTimeWindowInterpolationStartTs(SOperatorInfo* pOperatorInfo, SqlF } int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQueryAttr->order.order); - TSKEY prevTs = ((pos == 0 && ascQuery) || (pos == (numOfRows - 1) && !ascQuery))? lastTs:tsCols[pos - step]; + TSKEY prevTs = ((pos == 0 && ascQuery) || (pos == (numOfRows - 1) && !ascQuery)) ? lastTs : tsCols[pos - step]; - doTimeWindowInterpolation(pOperatorInfo, pOperatorInfo->info, pDataBlock, prevTs, pos - step, curTs, pos, - key, RESULT_ROW_START_INTERP); + doTimeWindowInterpolation(pOperatorInfo, pOperatorInfo->info, pDataBlock, prevTs, pos - step, curTs, pos, key, + RESULT_ROW_START_INTERP); return true; } -static bool setTimeWindowInterpolationEndTs(SOperatorInfo* pOperatorInfo, SqlFunctionCtx* pCtx, - int32_t endRowIndex, SArray* pDataBlock, const TSKEY* tsCols, TSKEY blockEkey, STimeWindow* win) { - STaskRuntimeEnv *pRuntimeEnv = pOperatorInfo->pRuntimeEnv; - STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; - int32_t numOfOutput = pOperatorInfo->numOfOutput; +static bool setTimeWindowInterpolationEndTs(SOperatorInfo* pOperatorInfo, SqlFunctionCtx* pCtx, int32_t endRowIndex, + SArray* pDataBlock, const TSKEY* tsCols, TSKEY blockEkey, + STimeWindow* win) { + STaskRuntimeEnv* pRuntimeEnv = pOperatorInfo->pRuntimeEnv; + STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; + int32_t numOfOutput = pOperatorInfo->numOfOutput; - TSKEY actualEndKey = tsCols[endRowIndex]; + TSKEY actualEndKey = tsCols[endRowIndex]; - TSKEY key = QUERY_IS_ASC_QUERY(pQueryAttr)? win->ekey:win->skey; + TSKEY key = QUERY_IS_ASC_QUERY(pQueryAttr) ? win->ekey : win->skey; // not ended in current data block, do not invoke interpolation if ((key > blockEkey && QUERY_IS_ASC_QUERY(pQueryAttr)) || (key < blockEkey && !QUERY_IS_ASC_QUERY(pQueryAttr))) { @@ -1391,12 +1434,13 @@ static bool setTimeWindowInterpolationEndTs(SOperatorInfo* pOperatorInfo, SqlFun TSKEY nextKey = tsCols[nextRowIndex]; doTimeWindowInterpolation(pOperatorInfo, pOperatorInfo->info, pDataBlock, actualEndKey, endRowIndex, nextKey, - nextRowIndex, key, RESULT_ROW_END_INTERP); + nextRowIndex, key, RESULT_ROW_END_INTERP); return true; } static void doWindowBorderInterpolation(SOperatorInfo* pOperatorInfo, SSDataBlock* pBlock, SqlFunctionCtx* pCtx, - SResultRow* pResult, STimeWindow* win, int32_t startPos, int32_t forwardStep, int32_t order, bool timeWindowInterpo) { + SResultRow* pResult, STimeWindow* win, int32_t startPos, int32_t forwardStep, + int32_t order, bool timeWindowInterpo) { if (!timeWindowInterpo) { return; } @@ -1404,19 +1448,19 @@ static void doWindowBorderInterpolation(SOperatorInfo* pOperatorInfo, SSDataBloc assert(pBlock != NULL); int32_t step = GET_FORWARD_DIRECTION_FACTOR(order); - if (pBlock->pDataBlock == NULL){ -// tscError("pBlock->pDataBlock == NULL"); + if (pBlock->pDataBlock == NULL) { + // tscError("pBlock->pDataBlock == NULL"); return; } - SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, 0); + SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, 0); - TSKEY *tsCols = (TSKEY *)(pColInfo->pData); - bool done = resultRowInterpolated(pResult, RESULT_ROW_START_INTERP); - if (!done) { // it is not interpolated, now start to generated the interpolated value + TSKEY* tsCols = (TSKEY*)(pColInfo->pData); + bool done = resultRowInterpolated(pResult, RESULT_ROW_START_INTERP); + if (!done) { // it is not interpolated, now start to generated the interpolated value int32_t startRowIndex = startPos; - bool interp = setTimeWindowInterpolationStartTs(pOperatorInfo, pCtx, startRowIndex, pBlock->info.rows, pBlock->pDataBlock, - tsCols, win); + bool interp = setTimeWindowInterpolationStartTs(pOperatorInfo, pCtx, startRowIndex, pBlock->info.rows, + pBlock->pDataBlock, tsCols, win); if (interp) { setResultRowInterpo(pResult, RESULT_ROW_START_INTERP); } @@ -1425,17 +1469,18 @@ static void doWindowBorderInterpolation(SOperatorInfo* pOperatorInfo, SSDataBloc } // point interpolation does not require the end key time window interpolation. -// if (pointInterpQuery) { -// return; -// } + // if (pointInterpQuery) { + // return; + // } // interpolation query does not generate the time window end interpolation done = resultRowInterpolated(pResult, RESULT_ROW_END_INTERP); if (!done) { int32_t endRowIndex = startPos + (forwardStep - 1) * step; - TSKEY endKey = (order == TSDB_ORDER_ASC)? pBlock->info.window.ekey:pBlock->info.window.skey; - bool interp = setTimeWindowInterpolationEndTs(pOperatorInfo, pCtx, endRowIndex, pBlock->pDataBlock, tsCols, endKey, win); + TSKEY endKey = (order == TSDB_ORDER_ASC) ? pBlock->info.window.ekey : pBlock->info.window.skey; + bool interp = + setTimeWindowInterpolationEndTs(pOperatorInfo, pCtx, endRowIndex, pBlock->pDataBlock, tsCols, endKey, win); if (interp) { setResultRowInterpo(pResult, RESULT_ROW_END_INTERP); } @@ -1444,33 +1489,36 @@ static void doWindowBorderInterpolation(SOperatorInfo* pOperatorInfo, SSDataBloc } } -static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResultRowInfo, SSDataBlock* pSDataBlock, int32_t tableGroupId) { - STableIntervalOperatorInfo* pInfo = (STableIntervalOperatorInfo*) pOperatorInfo->info; +static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResultRowInfo, SSDataBlock* pSDataBlock, + int32_t tableGroupId) { + STableIntervalOperatorInfo* pInfo = (STableIntervalOperatorInfo*)pOperatorInfo->info; SExecTaskInfo* pTaskInfo = pOperatorInfo->pTaskInfo; - int32_t numOfOutput = pOperatorInfo->numOfOutput; + int32_t numOfOutput = pOperatorInfo->numOfOutput; int32_t step = 1; - bool ascQuery = true; + bool ascQuery = true; int32_t prevIndex = pResultRowInfo->curPos; TSKEY* tsCols = NULL; if (pSDataBlock->pDataBlock != NULL) { SColumnInfoData* pColDataInfo = taosArrayGet(pSDataBlock->pDataBlock, 0); - tsCols = (int64_t*) pColDataInfo->pData; - assert(tsCols[0] == pSDataBlock->info.window.skey && tsCols[pSDataBlock->info.rows - 1] == pSDataBlock->info.window.ekey); + tsCols = (int64_t*)pColDataInfo->pData; + assert(tsCols[0] == pSDataBlock->info.window.skey && + tsCols[pSDataBlock->info.rows - 1] == pSDataBlock->info.window.ekey); } - int32_t startPos = ascQuery? 0 : (pSDataBlock->info.rows - 1); - TSKEY ts = getStartTsKey(&pSDataBlock->info.window, tsCols, pSDataBlock->info.rows, ascQuery); + int32_t startPos = ascQuery ? 0 : (pSDataBlock->info.rows - 1); + TSKEY ts = getStartTsKey(&pSDataBlock->info.window, tsCols, pSDataBlock->info.rows, ascQuery); STimeWindow win = getActiveTimeWindow(pResultRowInfo, ts, &pInfo->interval, pInfo->precision, &pInfo->win); - bool masterScan = true; + bool masterScan = true; SResultRow* pResult = NULL; - int32_t ret = setResultOutputBufByKey_rv(pResultRowInfo, pSDataBlock->info.uid, &win, masterScan, &pResult, tableGroupId, pInfo->binfo.pCtx, - numOfOutput, pInfo->binfo.rowCellInfoOffset, &pInfo->aggSup, pTaskInfo); + int32_t ret = setResultOutputBufByKey_rv(pResultRowInfo, pSDataBlock->info.uid, &win, masterScan, &pResult, + tableGroupId, pInfo->binfo.pCtx, numOfOutput, pInfo->binfo.rowCellInfoOffset, + &pInfo->aggSup, pTaskInfo); if (ret != TSDB_CODE_SUCCESS || pResult == NULL) { longjmp(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY); } @@ -1486,39 +1534,44 @@ static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul for (int32_t j = prevIndex; j < curIndex; ++j) { // previous time window may be all closed already. SResultRow* pRes = getResultRow(pResultRowInfo, j); if (pRes->closed) { - assert(resultRowInterpolated(pRes, RESULT_ROW_START_INTERP) && resultRowInterpolated(pRes, RESULT_ROW_END_INTERP)); + assert(resultRowInterpolated(pRes, RESULT_ROW_START_INTERP) && + resultRowInterpolated(pRes, RESULT_ROW_END_INTERP)); continue; } - STimeWindow w = pRes->win; - ret = setResultOutputBufByKey_rv(pResultRowInfo, pSDataBlock->info.uid, &w, masterScan, &pResult, - tableGroupId, pInfo->binfo.pCtx, numOfOutput, pInfo->binfo.rowCellInfoOffset, &pInfo->aggSup, pTaskInfo); - if (ret != TSDB_CODE_SUCCESS) { - longjmp(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY); - } - - assert(!resultRowInterpolated(pResult, RESULT_ROW_END_INTERP)); - - doTimeWindowInterpolation(pOperatorInfo, &pInfo->binfo, pSDataBlock->pDataBlock, *(TSKEY*)pInfo->pRow[0], -1, - tsCols[startPos], startPos, w.ekey, RESULT_ROW_END_INTERP); - - setResultRowInterpo(pResult, RESULT_ROW_END_INTERP); - setNotInterpoWindowKey(pInfo->binfo.pCtx, pOperatorInfo->numOfOutput, RESULT_ROW_START_INTERP); - - doApplyFunctions(pInfo->binfo.pCtx, &w, startPos, 0, tsCols, pSDataBlock->info.rows, numOfOutput, TSDB_ORDER_ASC); + STimeWindow w = pRes->win; + ret = setResultOutputBufByKey_rv(pResultRowInfo, pSDataBlock->info.uid, &w, masterScan, &pResult, tableGroupId, + pInfo->binfo.pCtx, numOfOutput, pInfo->binfo.rowCellInfoOffset, &pInfo->aggSup, + pTaskInfo); + if (ret != TSDB_CODE_SUCCESS) { + longjmp(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY); } + assert(!resultRowInterpolated(pResult, RESULT_ROW_END_INTERP)); + + doTimeWindowInterpolation(pOperatorInfo, &pInfo->binfo, pSDataBlock->pDataBlock, *(TSKEY*)pInfo->pRow[0], -1, + tsCols[startPos], startPos, w.ekey, RESULT_ROW_END_INTERP); + + setResultRowInterpo(pResult, RESULT_ROW_END_INTERP); + setNotInterpoWindowKey(pInfo->binfo.pCtx, pOperatorInfo->numOfOutput, RESULT_ROW_START_INTERP); + + doApplyFunctions(pInfo->binfo.pCtx, &w, startPos, 0, tsCols, pSDataBlock->info.rows, numOfOutput, TSDB_ORDER_ASC); + } + // restore current time window - ret = setResultOutputBufByKey_rv(pResultRowInfo, pSDataBlock->info.uid, &win, masterScan, &pResult, tableGroupId, pInfo->binfo.pCtx, - numOfOutput, pInfo->binfo.rowCellInfoOffset, &pInfo->aggSup, pTaskInfo); + ret = setResultOutputBufByKey_rv(pResultRowInfo, pSDataBlock->info.uid, &win, masterScan, &pResult, tableGroupId, + pInfo->binfo.pCtx, numOfOutput, pInfo->binfo.rowCellInfoOffset, &pInfo->aggSup, + pTaskInfo); if (ret != TSDB_CODE_SUCCESS) { longjmp(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY); } } // window start key interpolation - doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->binfo.pCtx, pResult, &win, startPos, forwardStep, pInfo->order, false); - doApplyFunctions(pInfo->binfo.pCtx, &win, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput, TSDB_ORDER_ASC); + doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->binfo.pCtx, pResult, &win, startPos, forwardStep, + pInfo->order, false); + doApplyFunctions(pInfo->binfo.pCtx, &win, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput, + TSDB_ORDER_ASC); STimeWindow nextWin = win; while (1) { @@ -1529,55 +1582,60 @@ static void hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul } // null data, failed to allocate more memory buffer - int32_t code = setResultOutputBufByKey_rv(pResultRowInfo, pSDataBlock->info.uid, &nextWin, masterScan, &pResult, tableGroupId, - pInfo->binfo.pCtx, numOfOutput, pInfo->binfo.rowCellInfoOffset, &pInfo->aggSup, pTaskInfo); + int32_t code = setResultOutputBufByKey_rv(pResultRowInfo, pSDataBlock->info.uid, &nextWin, masterScan, &pResult, + tableGroupId, pInfo->binfo.pCtx, numOfOutput, + pInfo->binfo.rowCellInfoOffset, &pInfo->aggSup, pTaskInfo); if (code != TSDB_CODE_SUCCESS || pResult == NULL) { longjmp(pTaskInfo->env, TSDB_CODE_QRY_OUT_OF_MEMORY); } - ekey = nextWin.ekey;//reviseWindowEkey(pQueryAttr, &nextWin); - forwardStep = getNumOfRowsInTimeWindow(&pSDataBlock->info, tsCols, startPos, ekey, binarySearchForKey, NULL, TSDB_ORDER_ASC); + ekey = nextWin.ekey; // reviseWindowEkey(pQueryAttr, &nextWin); + forwardStep = + getNumOfRowsInTimeWindow(&pSDataBlock->info, tsCols, startPos, ekey, binarySearchForKey, NULL, TSDB_ORDER_ASC); // window start(end) key interpolation - doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->binfo.pCtx, pResult, &nextWin, startPos, forwardStep, pInfo->order, false); - doApplyFunctions(pInfo->binfo.pCtx, &nextWin, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput, TSDB_ORDER_ASC); + doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->binfo.pCtx, pResult, &nextWin, startPos, forwardStep, + pInfo->order, false); + doApplyFunctions(pInfo->binfo.pCtx, &nextWin, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput, + TSDB_ORDER_ASC); } if (pInfo->timeWindowInterpo) { - int32_t rowIndex = ascQuery? (pSDataBlock->info.rows-1):0; + int32_t rowIndex = ascQuery ? (pSDataBlock->info.rows - 1) : 0; saveDataBlockLastRow(pInfo->pRow, pSDataBlock->pDataBlock, rowIndex, pSDataBlock->info.numOfCols); } -// updateResultRowInfoActiveIndex(pResultRowInfo, &pInfo->win, pRuntimeEnv->current->lastKey, true, false); + // updateResultRowInfoActiveIndex(pResultRowInfo, &pInfo->win, pRuntimeEnv->current->lastKey, true, false); } -static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResultRowInfo, SSDataBlock* pSDataBlock, int32_t tableGroupId) { - STableIntervalOperatorInfo* pInfo = (STableIntervalOperatorInfo*) pOperatorInfo->info; +static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResultRowInfo, SSDataBlock* pSDataBlock, + int32_t tableGroupId) { + STableIntervalOperatorInfo* pInfo = (STableIntervalOperatorInfo*)pOperatorInfo->info; STaskRuntimeEnv* pRuntimeEnv = pOperatorInfo->pRuntimeEnv; - int32_t numOfOutput = pOperatorInfo->numOfOutput; + int32_t numOfOutput = pOperatorInfo->numOfOutput; STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQueryAttr->order.order); - bool ascQuery = QUERY_IS_ASC_QUERY(pQueryAttr); + bool ascQuery = QUERY_IS_ASC_QUERY(pQueryAttr); TSKEY* tsCols = NULL; if (pSDataBlock->pDataBlock != NULL) { SColumnInfoData* pColDataInfo = taosArrayGet(pSDataBlock->pDataBlock, 0); - tsCols = (int64_t*) pColDataInfo->pData; + tsCols = (int64_t*)pColDataInfo->pData; assert(tsCols[0] == pSDataBlock->info.window.skey && tsCols[pSDataBlock->info.rows - 1] == pSDataBlock->info.window.ekey); } - int32_t startPos = ascQuery? 0 : (pSDataBlock->info.rows - 1); - TSKEY ts = getStartTsKey(&pSDataBlock->info.window, tsCols, pSDataBlock->info.rows, ascQuery); + int32_t startPos = ascQuery ? 0 : (pSDataBlock->info.rows - 1); + TSKEY ts = getStartTsKey(&pSDataBlock->info.window, tsCols, pSDataBlock->info.rows, ascQuery); STimeWindow win = getCurrentActiveTimeWindow(pResultRowInfo, ts, pQueryAttr); - bool masterScan = IS_MAIN_SCAN(pRuntimeEnv); + bool masterScan = IS_MAIN_SCAN(pRuntimeEnv); SResultRow* pResult = NULL; - int32_t forwardStep = 0; - int32_t ret = 0; + int32_t forwardStep = 0; + int32_t ret = 0; STimeWindow preWin = win; while (1) { @@ -1588,20 +1646,24 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY); } - TSKEY ekey = reviseWindowEkey(pQueryAttr, &win); -// forwardStep = getNumOfRowsInTimeWindow(pRuntimeEnv, &pSDataBlock->info, tsCols, startPos, ekey, binarySearchForKey, true); + TSKEY ekey = reviseWindowEkey(pQueryAttr, &win); + // forwardStep = getNumOfRowsInTimeWindow(pRuntimeEnv, &pSDataBlock->info, tsCols, startPos, ekey, + // binarySearchForKey, true); // window start(end) key interpolation -// doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->binfo.pCtx, pResult, &win, startPos, forwardStep); -// doApplyFunctions(pRuntimeEnv, pInfo->binfo.pCtx, ascQuery ? &win : &preWin, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput); + // doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->binfo.pCtx, pResult, &win, startPos, + // forwardStep); doApplyFunctions(pRuntimeEnv, pInfo->binfo.pCtx, ascQuery ? &win : &preWin, startPos, + // forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput); preWin = win; int32_t prevEndPos = (forwardStep - 1) * step + startPos; -// startPos = getNextQualifiedWindow(pQueryAttr, &win, &pSDataBlock->info, tsCols, binarySearchForKey, prevEndPos); + // startPos = getNextQualifiedWindow(pQueryAttr, &win, &pSDataBlock->info, tsCols, binarySearchForKey, + // prevEndPos); if (startPos < 0) { if ((ascQuery && win.skey <= pQueryAttr->window.ekey) || ((!ascQuery) && win.ekey >= pQueryAttr->window.ekey)) { - int32_t code = setResultOutputBufByKey(pRuntimeEnv, pResultRowInfo, pSDataBlock->info.uid, &win, masterScan, &pResult, tableGroupId, - pInfo->binfo.pCtx, numOfOutput, pInfo->binfo.rowCellInfoOffset); + int32_t code = + setResultOutputBufByKey(pRuntimeEnv, pResultRowInfo, pSDataBlock->info.uid, &win, masterScan, &pResult, + tableGroupId, pInfo->binfo.pCtx, numOfOutput, pInfo->binfo.rowCellInfoOffset); if (code != TSDB_CODE_SUCCESS || pResult == NULL) { longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY); } @@ -1609,8 +1671,9 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe startPos = pSDataBlock->info.rows - 1; // window start(end) key interpolation -// doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->binfo.pCtx, pResult, &win, startPos, forwardStep); -// doApplyFunctions(pRuntimeEnv, pInfo->binfo.pCtx, ascQuery ? &win : &preWin, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput); + // doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->binfo.pCtx, pResult, &win, startPos, + // forwardStep); doApplyFunctions(pRuntimeEnv, pInfo->binfo.pCtx, ascQuery ? &win : &preWin, startPos, + // forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput); } break; @@ -1619,14 +1682,15 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe } if (pQueryAttr->timeWindowInterpo) { - int32_t rowIndex = ascQuery? (pSDataBlock->info.rows-1):0; -// saveDataBlockLastRow(pRuntimeEnv, &pSDataBlock->info, pSDataBlock->pDataBlock, rowIndex); + int32_t rowIndex = ascQuery ? (pSDataBlock->info.rows - 1) : 0; + // saveDataBlockLastRow(pRuntimeEnv, &pSDataBlock->info, pSDataBlock->pDataBlock, rowIndex); } -// updateResultRowInfoActiveIndex(pResultRowInfo, pQueryAttr, pRuntimeEnv->current->lastKey); + // updateResultRowInfoActiveIndex(pResultRowInfo, pQueryAttr, pRuntimeEnv->current->lastKey); } -static bool groupKeyCompare(SGroupbyOperatorInfo* pInfo, SSDataBlock* pBlock, int32_t rowIndex, int32_t numOfGroupCols) { +static bool groupKeyCompare(SGroupbyOperatorInfo* pInfo, SSDataBlock* pBlock, int32_t rowIndex, + int32_t numOfGroupCols) { SColumnDataAgg* pColAgg = NULL; for (int32_t i = 0; i < numOfGroupCols; ++i) { SColumn* pCol = taosArrayGet(pInfo->pGroupCols, i); @@ -1694,9 +1758,9 @@ static int32_t generatedHashKey(void* pKey, int32_t* length, SArray* pGroupColVa ASSERT(pKey != NULL); size_t numOfGroupCols = taosArrayGetSize(pGroupColVals); - char* isNull = (char*) pKey; - char* pStart = (char*) pKey + sizeof(int8_t) * numOfGroupCols; - for(int32_t i = 0; i < numOfGroupCols; ++i) { + char* isNull = (char*)pKey; + char* pStart = (char*)pKey + sizeof(int8_t) * numOfGroupCols; + for (int32_t i = 0; i < numOfGroupCols; ++i) { SGroupKeys* pkey = taosArrayGet(pGroupColVals, i); if (pkey->isNull) { isNull[i] = 1; @@ -1714,13 +1778,13 @@ static int32_t generatedHashKey(void* pKey, int32_t* length, SArray* pGroupColVa } } - *length = (pStart - (char*) pKey); + *length = (pStart - (char*)pKey); return 0; } // assign the group keys or user input constant values if required static void doAssignGroupKeys(SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t totalRows, int32_t rowIndex) { - for(int32_t i = 0; i < numOfOutput; ++i) { + for (int32_t i = 0; i < numOfOutput; ++i) { if (pCtx[i].functionId == -1) { SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(&pCtx[i]); @@ -1738,18 +1802,18 @@ static void doAssignGroupKeys(SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t } } -static void doHashGroupbyAgg(SOperatorInfo* pOperator, SSDataBlock *pBlock) { - SExecTaskInfo *pTaskInfo = pOperator->pTaskInfo; - SGroupbyOperatorInfo *pInfo = pOperator->info; +static void doHashGroupbyAgg(SOperatorInfo* pOperator, SSDataBlock* pBlock) { + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SGroupbyOperatorInfo* pInfo = pOperator->info; SqlFunctionCtx* pCtx = pInfo->binfo.pCtx; - int32_t numOfGroupCols = taosArrayGetSize(pInfo->pGroupCols); -// if (type == TSDB_DATA_TYPE_FLOAT || type == TSDB_DATA_TYPE_DOUBLE) { - //qError("QInfo:0x%"PRIx64" group by not supported on double/float columns, abort", GET_TASKID(pRuntimeEnv)); -// return; -// } + int32_t numOfGroupCols = taosArrayGetSize(pInfo->pGroupCols); + // if (type == TSDB_DATA_TYPE_FLOAT || type == TSDB_DATA_TYPE_DOUBLE) { + // qError("QInfo:0x%"PRIx64" group by not supported on double/float columns, abort", GET_TASKID(pRuntimeEnv)); + // return; + // } - int32_t len = 0; + int32_t len = 0; STimeWindow w = TSWINDOW_INITIALIZER; int32_t num = 0; @@ -1768,9 +1832,10 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SSDataBlock *pBlock) { continue; } - /*int32_t ret = */generatedHashKey(pInfo->keyBuf, &len, pInfo->pGroupColVals); - int32_t ret = setGroupResultOutputBuf_rv(&(pInfo->binfo), pOperator->numOfOutput, pInfo->keyBuf, TSDB_DATA_TYPE_VARCHAR, len, 0, - pInfo->aggSup.pResultBuf, pTaskInfo, &pInfo->aggSup); + /*int32_t ret = */ generatedHashKey(pInfo->keyBuf, &len, pInfo->pGroupColVals); + int32_t ret = + setGroupResultOutputBuf_rv(&(pInfo->binfo), pOperator->numOfOutput, pInfo->keyBuf, TSDB_DATA_TYPE_VARCHAR, len, + 0, pInfo->aggSup.pResultBuf, pTaskInfo, &pInfo->aggSup); if (ret != TSDB_CODE_SUCCESS) { // null data, too many state code longjmp(pTaskInfo->env, TSDB_CODE_QRY_APP_ERROR); } @@ -1785,9 +1850,10 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SSDataBlock *pBlock) { } if (num > 0) { - /*int32_t ret = */generatedHashKey(pInfo->keyBuf, &len, pInfo->pGroupColVals); - int32_t ret = setGroupResultOutputBuf_rv(&(pInfo->binfo), pOperator->numOfOutput, pInfo->keyBuf, TSDB_DATA_TYPE_VARCHAR, len, 0, - pInfo->aggSup.pResultBuf, pTaskInfo, &pInfo->aggSup); + /*int32_t ret = */ generatedHashKey(pInfo->keyBuf, &len, pInfo->pGroupColVals); + int32_t ret = + setGroupResultOutputBuf_rv(&(pInfo->binfo), pOperator->numOfOutput, pInfo->keyBuf, TSDB_DATA_TYPE_VARCHAR, len, + 0, pInfo->aggSup.pResultBuf, pTaskInfo, &pInfo->aggSup); if (ret != TSDB_CODE_SUCCESS) { longjmp(pTaskInfo->env, TSDB_CODE_QRY_APP_ERROR); } @@ -1799,20 +1865,20 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SSDataBlock *pBlock) { } // todo handle multiple tables cases. -static void doSessionWindowAggImpl(SOperatorInfo* pOperator, SSessionAggOperatorInfo *pInfo, SSDataBlock *pBlock) { +static void doSessionWindowAggImpl(SOperatorInfo* pOperator, SSessionAggOperatorInfo* pInfo, SSDataBlock* pBlock) { SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; // primary timestamp column SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, 0); - bool masterScan = true; + bool masterScan = true; STimeWindow window = {0}; - int32_t numOfOutput = pOperator->numOfOutput; - int64_t gid = pBlock->info.groupId; + int32_t numOfOutput = pOperator->numOfOutput; + int64_t gid = pBlock->info.groupId; int64_t gap = pInfo->gap; pInfo->numOfRows = 0; - if (/*IS_REPEAT_SCAN(pRuntimeEnv) && */!pInfo->reptScan) { + if (/*IS_REPEAT_SCAN(pRuntimeEnv) && */ !pInfo->reptScan) { pInfo->reptScan = true; pInfo->prevTs = INT64_MIN; } @@ -1836,14 +1902,16 @@ static void doSessionWindowAggImpl(SOperatorInfo* pOperator, SSessionAggOperator } else { // start a new session window SResultRow* pResult = NULL; pInfo->curWindow.ekey = pInfo->curWindow.skey; - int32_t ret = setResultOutputBufByKey_rv(&pInfo->binfo.resultRowInfo, pBlock->info.uid, &window, masterScan, &pResult, gid, pInfo->binfo.pCtx, - numOfOutput, pInfo->binfo.rowCellInfoOffset, &pInfo->aggSup, pTaskInfo); + int32_t ret = setResultOutputBufByKey_rv(&pInfo->binfo.resultRowInfo, pBlock->info.uid, &window, masterScan, + &pResult, gid, pInfo->binfo.pCtx, numOfOutput, + pInfo->binfo.rowCellInfoOffset, &pInfo->aggSup, pTaskInfo); if (ret != TSDB_CODE_SUCCESS) { // null data, too many state code longjmp(pTaskInfo->env, TSDB_CODE_QRY_APP_ERROR); } // pInfo->numOfRows data belong to the current session window - doApplyFunctions(pInfo->binfo.pCtx, &window, pInfo->start, pInfo->numOfRows, NULL, pBlock->info.rows, numOfOutput, TSDB_ORDER_ASC); + doApplyFunctions(pInfo->binfo.pCtx, &window, pInfo->start, pInfo->numOfRows, NULL, pBlock->info.rows, numOfOutput, + TSDB_ORDER_ASC); pInfo->curWindow.skey = tsList[j]; pInfo->curWindow.ekey = tsList[j]; @@ -1856,13 +1924,15 @@ static void doSessionWindowAggImpl(SOperatorInfo* pOperator, SSessionAggOperator SResultRow* pResult = NULL; pInfo->curWindow.ekey = pInfo->curWindow.skey; - int32_t ret = setResultOutputBufByKey_rv(&pInfo->binfo.resultRowInfo, pBlock->info.uid, &window, masterScan, &pResult, gid, pInfo->binfo.pCtx, - numOfOutput, pInfo->binfo.rowCellInfoOffset, &pInfo->aggSup, pTaskInfo); + int32_t ret = setResultOutputBufByKey_rv(&pInfo->binfo.resultRowInfo, pBlock->info.uid, &window, masterScan, &pResult, + gid, pInfo->binfo.pCtx, numOfOutput, pInfo->binfo.rowCellInfoOffset, + &pInfo->aggSup, pTaskInfo); if (ret != TSDB_CODE_SUCCESS) { // null data, too many state code longjmp(pTaskInfo->env, TSDB_CODE_QRY_APP_ERROR); } - doApplyFunctions(pInfo->binfo.pCtx, &window, pInfo->start, pInfo->numOfRows, NULL, pBlock->info.rows, numOfOutput, TSDB_ORDER_ASC); + doApplyFunctions(pInfo->binfo.pCtx, &window, pInfo->start, pInfo->numOfRows, NULL, pBlock->info.rows, numOfOutput, + TSDB_ORDER_ASC); } static void setResultRowKey(SResultRow* pResultRow, char* pData, int16_t type) { @@ -1882,14 +1952,15 @@ static void setResultRowKey(SResultRow* pResultRow, char* pData, int16_t type) { } } -static int32_t setGroupResultOutputBuf_rv(SOptrBasicInfo *binfo, int32_t numOfCols, char *pData, int16_t type, int16_t bytes, int32_t groupId, - SDiskbasedBuf* pBuf, SExecTaskInfo* pTaskInfo, SAggSupporter* pAggSup) { - SResultRowInfo *pResultRowInfo = &binfo->resultRowInfo; - SqlFunctionCtx *pCtx = binfo->pCtx; +static int32_t setGroupResultOutputBuf_rv(SOptrBasicInfo* binfo, int32_t numOfCols, char* pData, int16_t type, + int16_t bytes, int32_t groupId, SDiskbasedBuf* pBuf, SExecTaskInfo* pTaskInfo, + SAggSupporter* pAggSup) { + SResultRowInfo* pResultRowInfo = &binfo->resultRowInfo; + SqlFunctionCtx* pCtx = binfo->pCtx; - SResultRow *pResultRow = doSetResultOutBufByKey_rv(pBuf, pResultRowInfo, groupId, (char *)pData, bytes, true, groupId, - pTaskInfo, true, pAggSup); - assert (pResultRow != NULL); + SResultRow* pResultRow = doSetResultOutBufByKey_rv(pBuf, pResultRowInfo, groupId, (char*)pData, bytes, true, groupId, + pTaskInfo, true, pAggSup); + assert(pResultRow != NULL); setResultRowKey(pResultRow, pData, type); @@ -1897,7 +1968,7 @@ static int32_t setGroupResultOutputBuf_rv(SOptrBasicInfo *binfo, int32_t numOfCo return TSDB_CODE_SUCCESS; } -static int32_t getGroupbyColumnIndex(SGroupbyExpr *pGroupbyExpr, SSDataBlock* pDataBlock) { +static int32_t getGroupbyColumnIndex(SGroupbyExpr* pGroupbyExpr, SSDataBlock* pDataBlock) { size_t num = taosArrayGetSize(pGroupbyExpr->columnInfo); for (int32_t k = 0; k < num; ++k) { SColIndex* pColIndex = taosArrayGet(pGroupbyExpr->columnInfo, k); @@ -1919,8 +1990,8 @@ static int32_t getGroupbyColumnIndex(SGroupbyExpr *pGroupbyExpr, SSDataBlock* pD return -1; } -static bool functionNeedToExecute(SqlFunctionCtx *pCtx) { - struct SResultRowEntryInfo *pResInfo = GET_RES_INFO(pCtx); +static bool functionNeedToExecute(SqlFunctionCtx* pCtx) { + struct SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx); // in case of timestamp column, always generated results. int32_t functionId = pCtx->functionId; @@ -1937,31 +2008,31 @@ static bool functionNeedToExecute(SqlFunctionCtx *pCtx) { } if (functionId == FUNCTION_FIRST_DST || functionId == FUNCTION_FIRST) { -// return QUERY_IS_ASC_QUERY(pQueryAttr); + // return QUERY_IS_ASC_QUERY(pQueryAttr); } // denote the order type if ((functionId == FUNCTION_LAST_DST || functionId == FUNCTION_LAST)) { -// return pCtx->param[0].i == pQueryAttr->order.order; + // return pCtx->param[0].i == pQueryAttr->order.order; } // in the reverse table scan, only the following functions need to be executed -// if (IS_REVERSE_SCAN(pRuntimeEnv) || -// (pRuntimeEnv->scanFlag == REPEAT_SCAN && functionId != FUNCTION_STDDEV && functionId != FUNCTION_PERCT)) { -// return false; -// } + // if (IS_REVERSE_SCAN(pRuntimeEnv) || + // (pRuntimeEnv->scanFlag == REPEAT_SCAN && functionId != FUNCTION_STDDEV && functionId != FUNCTION_PERCT)) { + // return false; + // } return true; } -void setBlockStatisInfo(SqlFunctionCtx *pCtx, SSDataBlock* pSDataBlock, SColumn* pColumn) { - SColumnDataAgg *pAgg = NULL; +void setBlockStatisInfo(SqlFunctionCtx* pCtx, SSDataBlock* pSDataBlock, SColumn* pColumn) { + SColumnDataAgg* pAgg = NULL; if (pSDataBlock->pBlockAgg != NULL && TSDB_COL_IS_NORMAL_COL(pColumn->flag)) { pAgg = &pSDataBlock->pBlockAgg[pCtx->columnIndex]; pCtx->agg = *pAgg; - pCtx->isAggSet = true; + pCtx->isAggSet = true; assert(pCtx->agg.numOfNull <= pSDataBlock->info.rows); } else { pCtx->isAggSet = false; @@ -1971,14 +2042,14 @@ void setBlockStatisInfo(SqlFunctionCtx *pCtx, SSDataBlock* pSDataBlock, SColumn* // set the statistics data for primary time stamp column if (pCtx->functionId == FUNCTION_SPREAD && pColumn->colId == PRIMARYKEY_TIMESTAMP_COL_ID) { - pCtx->isAggSet = true; + pCtx->isAggSet = true; pCtx->agg.min = pSDataBlock->info.window.skey; pCtx->agg.max = pSDataBlock->info.window.ekey; } } // set the output buffer for the selectivity + tag query -static int32_t setCtxTagColumnInfo(SqlFunctionCtx *pCtx, int32_t numOfOutput) { +static int32_t setCtxTagColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutput) { if (!isSelectivityWithTagsQuery(pCtx, numOfOutput)) { return TSDB_CODE_SUCCESS; } @@ -1998,7 +2069,7 @@ static int32_t setCtxTagColumnInfo(SqlFunctionCtx *pCtx, int32_t numOfOutput) { if (functionId == FUNCTION_TAG_DUMMY || functionId == FUNCTION_TS_DUMMY) { tagLen += pCtx[i].resDataInfo.bytes; pTagCtx[num++] = &pCtx[i]; - } else if (1/*(aAggs[functionId].status & FUNCSTATE_SELECTIVITY) != 0*/) { + } else if (1 /*(aAggs[functionId].status & FUNCSTATE_SELECTIVITY) != 0*/) { p = &pCtx[i]; } else if (functionId == FUNCTION_TS || functionId == FUNCTION_TAG) { // tag function may be the group by tag column @@ -2020,7 +2091,7 @@ static int32_t setCtxTagColumnInfo(SqlFunctionCtx *pCtx, int32_t numOfOutput) { } static SqlFunctionCtx* createSqlFunctionCtx_rv(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowCellInfoOffset) { - SqlFunctionCtx * pFuncCtx = (SqlFunctionCtx *)taosMemoryCalloc(numOfOutput, sizeof(SqlFunctionCtx)); + SqlFunctionCtx* pFuncCtx = (SqlFunctionCtx*)taosMemoryCalloc(numOfOutput, sizeof(SqlFunctionCtx)); if (pFuncCtx == NULL) { return NULL; } @@ -2034,7 +2105,7 @@ static SqlFunctionCtx* createSqlFunctionCtx_rv(SExprInfo* pExprInfo, int32_t num for (int32_t i = 0; i < numOfOutput; ++i) { SExprInfo* pExpr = &pExprInfo[i]; - SExprBasicInfo *pFunct = &pExpr->base; + SExprBasicInfo* pFunct = &pExpr->base; SqlFunctionCtx* pCtx = &pFuncCtx[i]; pCtx->functionId = -1; @@ -2050,21 +2121,19 @@ static SqlFunctionCtx* createSqlFunctionCtx_rv(SExprInfo* pExprInfo, int32_t num } pCtx->resDataInfo.interBufSize = env.calcMemSize; } else if (pExpr->pExpr->nodeType == QUERY_NODE_COLUMN) { - } else if (pExpr->pExpr->nodeType == QUERY_NODE_OPERATOR) { - } pCtx->input.numOfInputCols = pFunct->numOfParams; pCtx->input.pData = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES); pCtx->input.pColumnDataAgg = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES); - pCtx->ptsOutputBuf = NULL; - pCtx->resDataInfo.bytes = pFunct->resSchema.bytes; - pCtx->resDataInfo.type = pFunct->resSchema.type; - pCtx->order = TSDB_ORDER_ASC; - pCtx->start.key = INT64_MIN; - pCtx->end.key = INT64_MIN; + pCtx->ptsOutputBuf = NULL; + pCtx->resDataInfo.bytes = pFunct->resSchema.bytes; + pCtx->resDataInfo.type = pFunct->resSchema.type; + pCtx->order = TSDB_ORDER_ASC; + pCtx->start.key = INT64_MIN; + pCtx->end.key = INT64_MIN; #if 0 for (int32_t j = 0; j < pCtx->numOfParams; ++j) { // int16_t type = pFunct->param[j].nType; @@ -2114,8 +2183,9 @@ static SqlFunctionCtx* createSqlFunctionCtx_rv(SExprInfo* pExprInfo, int32_t num #endif } - for(int32_t i = 1; i < numOfOutput; ++i) { - (*rowCellInfoOffset)[i] = (int32_t)((*rowCellInfoOffset)[i - 1] + sizeof(SResultRowEntryInfo) + pFuncCtx[i - 1].resDataInfo.interBufSize); + for (int32_t i = 1; i < numOfOutput; ++i) { + (*rowCellInfoOffset)[i] = + (int32_t)((*rowCellInfoOffset)[i - 1] + sizeof(SResultRowEntryInfo) + pFuncCtx[i - 1].resDataInfo.interBufSize); } setCtxTagColumnInfo(pFuncCtx, numOfOutput); @@ -2140,52 +2210,56 @@ static void* destroySqlFunctionCtx(SqlFunctionCtx* pCtx, int32_t numOfOutput) { return NULL; } -static int32_t setupQueryRuntimeEnv(STaskRuntimeEnv *pRuntimeEnv, int32_t numOfTables, SArray* pOperator, void* merger) { - //qDebug("QInfo:0x%"PRIx64" setup runtime env", GET_TASKID(pRuntimeEnv)); - STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; +static int32_t setupQueryRuntimeEnv(STaskRuntimeEnv* pRuntimeEnv, int32_t numOfTables, SArray* pOperator, + void* merger) { + // qDebug("QInfo:0x%"PRIx64" setup runtime env", GET_TASKID(pRuntimeEnv)); + STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; pRuntimeEnv->prevGroupId = INT32_MIN; pRuntimeEnv->pQueryAttr = pQueryAttr; - pRuntimeEnv->pResultRowHashTable = taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK); - pRuntimeEnv->pResultRowListSet = taosHashInit(numOfTables * 10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK); - pRuntimeEnv->keyBuf = taosMemoryMalloc(pQueryAttr->maxTableColumnWidth + sizeof(int64_t) + POINTER_BYTES); -// pRuntimeEnv->pool = initResultRowPool(getResultRowSize(pRuntimeEnv)); + pRuntimeEnv->pResultRowHashTable = + taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK); + pRuntimeEnv->pResultRowListSet = + taosHashInit(numOfTables * 10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK); + pRuntimeEnv->keyBuf = taosMemoryMalloc(pQueryAttr->maxTableColumnWidth + sizeof(int64_t) + POINTER_BYTES); + // pRuntimeEnv->pool = initResultRowPool(getResultRowSize(pRuntimeEnv)); pRuntimeEnv->pResultRowArrayList = taosArrayInit(numOfTables, sizeof(SResultRowCell)); pRuntimeEnv->prevRow = taosMemoryMalloc(POINTER_BYTES * pQueryAttr->numOfCols + pQueryAttr->srcRowSize); - pRuntimeEnv->tagVal = taosMemoryMalloc(pQueryAttr->tagLen); + pRuntimeEnv->tagVal = taosMemoryMalloc(pQueryAttr->tagLen); // NOTE: pTableCheckInfo need to update the query time range and the lastKey info - pRuntimeEnv->pTableRetrieveTsMap = taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK); + pRuntimeEnv->pTableRetrieveTsMap = + taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK); - //pRuntimeEnv->scalarSup = createScalarFuncSupport(pQueryAttr->numOfOutput); + // pRuntimeEnv->scalarSup = createScalarFuncSupport(pQueryAttr->numOfOutput); if (pRuntimeEnv->scalarSup == NULL || pRuntimeEnv->pResultRowHashTable == NULL || pRuntimeEnv->keyBuf == NULL || - pRuntimeEnv->prevRow == NULL || pRuntimeEnv->tagVal == NULL) { + pRuntimeEnv->prevRow == NULL || pRuntimeEnv->tagVal == NULL) { goto _clean; } if (pQueryAttr->numOfCols) { - char* start = POINTER_BYTES * pQueryAttr->numOfCols + (char*) pRuntimeEnv->prevRow; + char* start = POINTER_BYTES * pQueryAttr->numOfCols + (char*)pRuntimeEnv->prevRow; pRuntimeEnv->prevRow[0] = start; - for(int32_t i = 1; i < pQueryAttr->numOfCols; ++i) { - pRuntimeEnv->prevRow[i] = pRuntimeEnv->prevRow[i - 1] + pQueryAttr->tableCols[i-1].bytes; + for (int32_t i = 1; i < pQueryAttr->numOfCols; ++i) { + pRuntimeEnv->prevRow[i] = pRuntimeEnv->prevRow[i - 1] + pQueryAttr->tableCols[i - 1].bytes; } if (pQueryAttr->tableCols[0].type == TSDB_DATA_TYPE_TIMESTAMP) { - *(int64_t*) pRuntimeEnv->prevRow[0] = INT64_MIN; + *(int64_t*)pRuntimeEnv->prevRow[0] = INT64_MIN; } } - //qDebug("QInfo:0x%"PRIx64" init runtime environment completed", GET_TASKID(pRuntimeEnv)); + // qDebug("QInfo:0x%"PRIx64" init runtime environment completed", GET_TASKID(pRuntimeEnv)); // group by normal column, sliding window query, interval query are handled by interval query processor // interval (down sampling operation) return TSDB_CODE_SUCCESS; _clean: - //destroyScalarFuncSupport(pRuntimeEnv->scalarSup, pRuntimeEnv->pQueryAttr->numOfOutput); + // destroyScalarFuncSupport(pRuntimeEnv->scalarSup, pRuntimeEnv->pQueryAttr->numOfOutput); taosMemoryFreeClear(pRuntimeEnv->pResultRowHashTable); taosMemoryFreeClear(pRuntimeEnv->keyBuf); taosMemoryFreeClear(pRuntimeEnv->prevRow); @@ -2197,70 +2271,71 @@ _clean: static void doFreeQueryHandle(STaskRuntimeEnv* pRuntimeEnv) { STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; -// tsdbCleanupReadHandle(pRuntimeEnv->pTsdbReadHandle); + // tsdbCleanupReadHandle(pRuntimeEnv->pTsdbReadHandle); pRuntimeEnv->pTsdbReadHandle = NULL; -// SMemRef* pMemRef = &pQueryAttr->memRef; -// assert(pMemRef->ref == 0 && pMemRef->snapshot.imem == NULL && pMemRef->snapshot.mem == NULL); + // SMemRef* pMemRef = &pQueryAttr->memRef; + // assert(pMemRef->ref == 0 && pMemRef->snapshot.imem == NULL && pMemRef->snapshot.mem == NULL); } -static void destroyTsComp(STaskRuntimeEnv *pRuntimeEnv, STaskAttr *pQueryAttr) { - if (pQueryAttr->tsCompQuery && pRuntimeEnv->outputBuf && pRuntimeEnv->outputBuf->pDataBlock && taosArrayGetSize(pRuntimeEnv->outputBuf->pDataBlock) > 0) { +static void destroyTsComp(STaskRuntimeEnv* pRuntimeEnv, STaskAttr* pQueryAttr) { + if (pQueryAttr->tsCompQuery && pRuntimeEnv->outputBuf && pRuntimeEnv->outputBuf->pDataBlock && + taosArrayGetSize(pRuntimeEnv->outputBuf->pDataBlock) > 0) { SColumnInfoData* pColInfoData = taosArrayGet(pRuntimeEnv->outputBuf->pDataBlock, 0); if (pColInfoData) { - TdFilePtr pFile = *(TdFilePtr *)pColInfoData->pData; // TODO refactor + TdFilePtr pFile = *(TdFilePtr*)pColInfoData->pData; // TODO refactor if (pFile != NULL) { taosCloseFile(&pFile); - *(TdFilePtr *)pColInfoData->pData = NULL; + *(TdFilePtr*)pColInfoData->pData = NULL; } } } } -bool isTaskKilled(SExecTaskInfo *pTaskInfo) { +bool isTaskKilled(SExecTaskInfo* pTaskInfo) { // query has been executed more than tsShellActivityTimer, and the retrieve has not arrived // abort current query execution. - if (pTaskInfo->owner != 0 && ((taosGetTimestampSec() - pTaskInfo->cost.start/1000) > 10*getMaximumIdleDurationSec()) + if (pTaskInfo->owner != 0 && + ((taosGetTimestampSec() - pTaskInfo->cost.start / 1000) > 10 * getMaximumIdleDurationSec()) /*(!needBuildResAfterQueryComplete(pTaskInfo))*/) { - assert(pTaskInfo->cost.start != 0); -// qDebug("QInfo:%" PRIu64 " retrieve not arrive beyond %d ms, abort current query execution, start:%" PRId64 -// ", current:%d", pQInfo->qId, 1, pQInfo->startExecTs, taosGetTimestampSec()); -// return true; + // qDebug("QInfo:%" PRIu64 " retrieve not arrive beyond %d ms, abort current query execution, start:%" PRId64 + // ", current:%d", pQInfo->qId, 1, pQInfo->startExecTs, taosGetTimestampSec()); + // return true; } return false; } -void setTaskKilled(SExecTaskInfo *pTaskInfo) { pTaskInfo->code = TSDB_CODE_TSC_QUERY_CANCELLED;} +void setTaskKilled(SExecTaskInfo* pTaskInfo) { pTaskInfo->code = TSDB_CODE_TSC_QUERY_CANCELLED; } -//static bool isFixedOutputQuery(STaskAttr* pQueryAttr) { -// if (QUERY_IS_INTERVAL_QUERY(pQueryAttr)) { -// return false; -// } +// static bool isFixedOutputQuery(STaskAttr* pQueryAttr) { +// if (QUERY_IS_INTERVAL_QUERY(pQueryAttr)) { +// return false; +// } // -// // Note:top/bottom query is fixed output query -// if (pQueryAttr->topBotQuery || pQueryAttr->groupbyColumn || pQueryAttr->tsCompQuery) { -// return true; -// } +// // Note:top/bottom query is fixed output query +// if (pQueryAttr->topBotQuery || pQueryAttr->groupbyColumn || pQueryAttr->tsCompQuery) { +// return true; +// } // -// for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { -// SExprBasicInfo *pExpr = &pQueryAttr->pExpr1[i].base; +// for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { +// SExprBasicInfo *pExpr = &pQueryAttr->pExpr1[i].base; // -// if (pExpr->functionId == FUNCTION_TS || pExpr->functionId == FUNCTION_TS_DUMMY) { -// continue; -// } +// if (pExpr->functionId == FUNCTION_TS || pExpr->functionId == FUNCTION_TS_DUMMY) { +// continue; +// } // -// if (!IS_MULTIOUTPUT(aAggs[pExpr->functionId].status)) { -// return true; -// } -// } +// if (!IS_MULTIOUTPUT(aAggs[pExpr->functionId].status)) { +// return true; +// } +// } // -// return false; -//} +// return false; +// } // todo refactor with isLastRowQuery -//bool isPointInterpoQuery(STaskAttr *pQueryAttr) { +// bool isPointInterpoQuery(STaskAttr *pQueryAttr) { // for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { // int32_t functionId = pQueryAttr->pExpr1[i].base.functionId; // if (functionId == FUNCTION_INTERP) { @@ -2271,7 +2346,7 @@ void setTaskKilled(SExecTaskInfo *pTaskInfo) { pTaskInfo->code = TSDB_CODE_TSC_Q // return false; //} -static bool isFirstLastRowQuery(STaskAttr *pQueryAttr) { +static bool isFirstLastRowQuery(STaskAttr* pQueryAttr) { for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { int32_t functionID = getExprFunctionId(&pQueryAttr->pExpr1[i]); if (functionID == FUNCTION_LAST_ROW) { @@ -2282,7 +2357,7 @@ static bool isFirstLastRowQuery(STaskAttr *pQueryAttr) { return false; } -static bool isCachedLastQuery(STaskAttr *pQueryAttr) { +static bool isCachedLastQuery(STaskAttr* pQueryAttr) { for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { int32_t functionId = getExprFunctionId(&pQueryAttr->pExpr1[i]); if (functionId == FUNCTION_LAST || functionId == FUNCTION_LAST_DST) { @@ -2312,8 +2387,9 @@ static bool isCachedLastQuery(STaskAttr *pQueryAttr) { } ///////////////////////////////////////////////////////////////////////////////////////////// -//todo refactor : return window -void getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key, int64_t keyFirst, int64_t keyLast, STimeWindow *win) { +// todo refactor : return window +void getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t key, int64_t keyFirst, int64_t keyLast, + STimeWindow* win) { ASSERT(key >= keyFirst && key <= keyLast); win->skey = taosTimeTruncate(key, pInterval, precision); @@ -2332,11 +2408,11 @@ void getAlignQueryTimeWindow(SInterval* pInterval, int32_t precision, int64_t ke /* * todo add more parameters to check soon.. */ -bool colIdCheck(STaskAttr *pQueryAttr, uint64_t qId) { +bool colIdCheck(STaskAttr* pQueryAttr, uint64_t qId) { // load data column information is incorrect for (int32_t i = 0; i < pQueryAttr->numOfCols - 1; ++i) { if (pQueryAttr->tableCols[i].colId == pQueryAttr->tableCols[i + 1].colId) { - //qError("QInfo:0x%"PRIx64" invalid data load column for query", qId); + // qError("QInfo:0x%"PRIx64" invalid data load column for query", qId); return false; } } @@ -2346,7 +2422,7 @@ bool colIdCheck(STaskAttr *pQueryAttr, uint64_t qId) { // todo ignore the avg/sum/min/max/count/stddev/top/bottom functions, of which // the scan order is not matter -static bool onlyOneQueryType(STaskAttr *pQueryAttr, int32_t functId, int32_t functIdDst) { +static bool onlyOneQueryType(STaskAttr* pQueryAttr, int32_t functId, int32_t functIdDst) { for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { int32_t functionId = getExprFunctionId(&pQueryAttr->pExpr1[i]); @@ -2363,13 +2439,19 @@ static bool onlyOneQueryType(STaskAttr *pQueryAttr, int32_t functId, int32_t fun return true; } -static bool onlyFirstQuery(STaskAttr *pQueryAttr) { return onlyOneQueryType(pQueryAttr, FUNCTION_FIRST, FUNCTION_FIRST_DST); } +static bool onlyFirstQuery(STaskAttr* pQueryAttr) { + return onlyOneQueryType(pQueryAttr, FUNCTION_FIRST, FUNCTION_FIRST_DST); +} -static bool onlyLastQuery(STaskAttr *pQueryAttr) { return onlyOneQueryType(pQueryAttr, FUNCTION_LAST, FUNCTION_LAST_DST); } +static bool onlyLastQuery(STaskAttr* pQueryAttr) { + return onlyOneQueryType(pQueryAttr, FUNCTION_LAST, FUNCTION_LAST_DST); +} -static bool notContainSessionOrStateWindow(STaskAttr *pQueryAttr) { return !(pQueryAttr->sw.gap > 0 || pQueryAttr->stateWindow); } +static bool notContainSessionOrStateWindow(STaskAttr* pQueryAttr) { + return !(pQueryAttr->sw.gap > 0 || pQueryAttr->stateWindow); +} -static int32_t updateBlockLoadStatus(STaskAttr *pQuery, int32_t status) { +static int32_t updateBlockLoadStatus(STaskAttr* pQuery, int32_t status) { bool hasFirstLastFunc = false; bool hasOtherFunc = false; @@ -2393,7 +2475,7 @@ static int32_t updateBlockLoadStatus(STaskAttr *pQuery, int32_t status) { } if (hasFirstLastFunc && status == BLK_DATA_NO_NEEDED) { - if(!hasOtherFunc) { + if (!hasOtherFunc) { return BLK_DATA_DISCARD; } else { return BLK_DATA_ALL_NEEDED; @@ -2407,67 +2489,70 @@ static void doUpdateLastKey(STaskAttr* pQueryAttr) { STimeWindow* win = &pQueryAttr->window; size_t num = taosArrayGetSize(pQueryAttr->tableGroupInfo.pGroupList); - for(int32_t i = 0; i < num; ++i) { + for (int32_t i = 0; i < num; ++i) { SArray* p1 = taosArrayGetP(pQueryAttr->tableGroupInfo.pGroupList, i); size_t len = taosArrayGetSize(p1); - for(int32_t j = 0; j < len; ++j) { -// STableKeyInfo* pInfo = taosArrayGet(p1, j); -// -// // update the new lastkey if it is equalled to the value of the old skey -// if (pInfo->lastKey == win->ekey) { -// pInfo->lastKey = win->skey; -// } + for (int32_t j = 0; j < len; ++j) { + // STableKeyInfo* pInfo = taosArrayGet(p1, j); + // + // // update the new lastkey if it is equalled to the value of the old skey + // if (pInfo->lastKey == win->ekey) { + // pInfo->lastKey = win->skey; + // } } } } -//static void updateDataCheckOrder(SQInfo *pQInfo, SQueryTableReq* pQueryMsg, bool stableQuery) { -// STaskAttr* pQueryAttr = pQInfo->runtimeEnv.pQueryAttr; +// static void updateDataCheckOrder(SQInfo *pQInfo, SQueryTableReq* pQueryMsg, bool stableQuery) { +// STaskAttr* pQueryAttr = pQInfo->runtimeEnv.pQueryAttr; // -// // in case of point-interpolation query, use asc order scan -// char msg[] = "QInfo:0x%"PRIx64" scan order changed for %s query, old:%d, new:%d, qrange exchanged, old qrange:%" PRId64 -// "-%" PRId64 ", new qrange:%" PRId64 "-%" PRId64; +// // in case of point-interpolation query, use asc order scan +// char msg[] = "QInfo:0x%"PRIx64" scan order changed for %s query, old:%d, new:%d, qrange exchanged, old qrange:%" +// PRId64 +// "-%" PRId64 ", new qrange:%" PRId64 "-%" PRId64; // -// // todo handle the case the the order irrelevant query type mixed up with order critical query type -// // descending order query for last_row query -// if (isFirstLastRowQuery(pQueryAttr)) { -// //qDebug("QInfo:0x%"PRIx64" scan order changed for last_row query, old:%d, new:%d", pQInfo->qId, pQueryAttr->order.order, TSDB_ORDER_ASC); +// // todo handle the case the the order irrelevant query type mixed up with order critical query type +// // descending order query for last_row query +// if (isFirstLastRowQuery(pQueryAttr)) { +// //qDebug("QInfo:0x%"PRIx64" scan order changed for last_row query, old:%d, new:%d", pQInfo->qId, +// pQueryAttr->order.order, TSDB_ORDER_ASC); // -// pQueryAttr->order.order = TSDB_ORDER_ASC; -// if (pQueryAttr->window.skey > pQueryAttr->window.ekey) { -// TSWAP(pQueryAttr->window.skey, pQueryAttr->window.ekey, TSKEY); -// } +// pQueryAttr->order.order = TSDB_ORDER_ASC; +// if (pQueryAttr->window.skey > pQueryAttr->window.ekey) { +// TSWAP(pQueryAttr->window.skey, pQueryAttr->window.ekey, TSKEY); +// } // -// pQueryAttr->needReverseScan = false; -// return; -// } +// pQueryAttr->needReverseScan = false; +// return; +// } // -// if (pQueryAttr->groupbyColumn && pQueryAttr->order.order == TSDB_ORDER_DESC) { -// pQueryAttr->order.order = TSDB_ORDER_ASC; -// if (pQueryAttr->window.skey > pQueryAttr->window.ekey) { -// TSWAP(pQueryAttr->window.skey, pQueryAttr->window.ekey, TSKEY); -// } +// if (pQueryAttr->groupbyColumn && pQueryAttr->order.order == TSDB_ORDER_DESC) { +// pQueryAttr->order.order = TSDB_ORDER_ASC; +// if (pQueryAttr->window.skey > pQueryAttr->window.ekey) { +// TSWAP(pQueryAttr->window.skey, pQueryAttr->window.ekey, TSKEY); +// } // -// pQueryAttr->needReverseScan = false; -// doUpdateLastKey(pQueryAttr); -// return; -// } +// pQueryAttr->needReverseScan = false; +// doUpdateLastKey(pQueryAttr); +// return; +// } // -// if (pQueryAttr->pointInterpQuery && pQueryAttr->interval.interval == 0) { -// if (!QUERY_IS_ASC_QUERY(pQueryAttr)) { -// //qDebug(msg, pQInfo->qId, "interp", pQueryAttr->order.order, TSDB_ORDER_ASC, pQueryAttr->window.skey, pQueryAttr->window.ekey, pQueryAttr->window.ekey, pQueryAttr->window.skey); -// TSWAP(pQueryAttr->window.skey, pQueryAttr->window.ekey, TSKEY); -// } +// if (pQueryAttr->pointInterpQuery && pQueryAttr->interval.interval == 0) { +// if (!QUERY_IS_ASC_QUERY(pQueryAttr)) { +// //qDebug(msg, pQInfo->qId, "interp", pQueryAttr->order.order, TSDB_ORDER_ASC, pQueryAttr->window.skey, +// pQueryAttr->window.ekey, pQueryAttr->window.ekey, pQueryAttr->window.skey); TSWAP(pQueryAttr->window.skey, +// pQueryAttr->window.ekey, TSKEY); +// } // -// pQueryAttr->order.order = TSDB_ORDER_ASC; -// return; -// } +// pQueryAttr->order.order = TSDB_ORDER_ASC; +// return; +// } // -// if (pQueryAttr->interval.interval == 0) { -// if (onlyFirstQuery(pQueryAttr)) { -// if (!QUERY_IS_ASC_QUERY(pQueryAttr)) { -// //qDebug(msg, pQInfo->qId, "only-first", pQueryAttr->order.order, TSDB_ORDER_ASC, pQueryAttr->window.skey, +// if (pQueryAttr->interval.interval == 0) { +// if (onlyFirstQuery(pQueryAttr)) { +// if (!QUERY_IS_ASC_QUERY(pQueryAttr)) { +// //qDebug(msg, pQInfo->qId, "only-first", pQueryAttr->order.order, TSDB_ORDER_ASC, pQueryAttr->window.skey, //// pQueryAttr->window.ekey, pQueryAttr->window.ekey, pQueryAttr->window.skey); // // TSWAP(pQueryAttr->window.skey, pQueryAttr->window.ekey, TSKEY); @@ -2494,7 +2579,8 @@ static void doUpdateLastKey(STaskAttr* pQueryAttr) { // if (onlyFirstQuery(pQueryAttr)) { // if (!QUERY_IS_ASC_QUERY(pQueryAttr)) { // //qDebug(msg, pQInfo->qId, "only-first stable", pQueryAttr->order.order, TSDB_ORDER_ASC, -//// pQueryAttr->window.skey, pQueryAttr->window.ekey, pQueryAttr->window.ekey, pQueryAttr->window.skey); +//// pQueryAttr->window.skey, pQueryAttr->window.ekey, pQueryAttr->window.ekey, +/// pQueryAttr->window.skey); // // TSWAP(pQueryAttr->window.skey, pQueryAttr->window.ekey, TSKEY); // doUpdateLastKey(pQueryAttr); @@ -2505,7 +2591,8 @@ static void doUpdateLastKey(STaskAttr* pQueryAttr) { // } else if (onlyLastQuery(pQueryAttr)) { // if (QUERY_IS_ASC_QUERY(pQueryAttr)) { // //qDebug(msg, pQInfo->qId, "only-last stable", pQueryAttr->order.order, TSDB_ORDER_DESC, -//// pQueryAttr->window.skey, pQueryAttr->window.ekey, pQueryAttr->window.ekey, pQueryAttr->window.skey); +//// pQueryAttr->window.skey, pQueryAttr->window.ekey, pQueryAttr->window.ekey, +/// pQueryAttr->window.skey); // // TSWAP(pQueryAttr->window.skey, pQueryAttr->window.ekey, TSKEY); // doUpdateLastKey(pQueryAttr); @@ -2520,29 +2607,31 @@ static void doUpdateLastKey(STaskAttr* pQueryAttr) { static void getIntermediateBufInfo(STaskRuntimeEnv* pRuntimeEnv, int32_t* ps, int32_t* rowsize) { STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; - int32_t MIN_ROWS_PER_PAGE = 4; + int32_t MIN_ROWS_PER_PAGE = 4; - *rowsize = (int32_t)(pQueryAttr->resultRowSize * getRowNumForMultioutput(pQueryAttr, pQueryAttr->topBotQuery, pQueryAttr->stableQuery)); + *rowsize = (int32_t)(pQueryAttr->resultRowSize * + getRowNumForMultioutput(pQueryAttr, pQueryAttr->topBotQuery, pQueryAttr->stableQuery)); int32_t overhead = sizeof(SFilePage); // one page contains at least two rows *ps = DEFAULT_INTERN_BUF_PAGE_SIZE; - while(((*rowsize) * MIN_ROWS_PER_PAGE) > (*ps) - overhead) { + while (((*rowsize) * MIN_ROWS_PER_PAGE) > (*ps) - overhead) { *ps = ((*ps) << 1u); } } #define IS_PREFILTER_TYPE(_t) ((_t) != TSDB_DATA_TYPE_BINARY && (_t) != TSDB_DATA_TYPE_NCHAR) -//static FORCE_INLINE bool doFilterByBlockStatistics(STaskRuntimeEnv* pRuntimeEnv, SDataStatis *pDataStatis, SqlFunctionCtx *pCtx, int32_t numOfRows) { -// STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; +// static FORCE_INLINE bool doFilterByBlockStatistics(STaskRuntimeEnv* pRuntimeEnv, SDataStatis *pDataStatis, +// SqlFunctionCtx *pCtx, int32_t numOfRows) { +// STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; // -// if (pDataStatis == NULL || pQueryAttr->pFilters == NULL) { -// return true; -// } +// if (pDataStatis == NULL || pQueryAttr->pFilters == NULL) { +// return true; +// } // -// return filterRangeExecute(pQueryAttr->pFilters, pDataStatis, pQueryAttr->numOfCols, numOfRows); -//} +// return filterRangeExecute(pQueryAttr->pFilters, pDataStatis, pQueryAttr->numOfCols, numOfRows); +// } static bool overlapWithTimeWindow(STaskAttr* pQueryAttr, SDataBlockInfo* pBlockInfo) { STimeWindow w = {0}; @@ -2551,15 +2640,15 @@ static bool overlapWithTimeWindow(STaskAttr* pQueryAttr, SDataBlockInfo* pBlockI TSKEY ek = TMAX(pQueryAttr->window.skey, pQueryAttr->window.ekey); if (QUERY_IS_ASC_QUERY(pQueryAttr)) { -// getAlignQueryTimeWindow(pQueryAttr, pBlockInfo->window.skey, sk, ek, &w); + // getAlignQueryTimeWindow(pQueryAttr, pBlockInfo->window.skey, sk, ek, &w); assert(w.ekey >= pBlockInfo->window.skey); if (w.ekey < pBlockInfo->window.ekey) { return true; } - while(1) { -// getNextTimeWindow(pQueryAttr, &w); + while (1) { + // getNextTimeWindow(pQueryAttr, &w); if (w.skey > pBlockInfo->window.ekey) { break; } @@ -2570,15 +2659,15 @@ static bool overlapWithTimeWindow(STaskAttr* pQueryAttr, SDataBlockInfo* pBlockI } } } else { -// getAlignQueryTimeWindow(pQueryAttr, pBlockInfo->window.ekey, sk, ek, &w); + // getAlignQueryTimeWindow(pQueryAttr, pBlockInfo->window.ekey, sk, ek, &w); assert(w.skey <= pBlockInfo->window.ekey); if (w.skey > pBlockInfo->window.skey) { return true; } - while(1) { -// getNextTimeWindow(pQueryAttr, &w); + while (1) { + // getNextTimeWindow(pQueryAttr, &w); if (w.ekey < pBlockInfo->window.skey) { break; } @@ -2593,11 +2682,12 @@ static bool overlapWithTimeWindow(STaskAttr* pQueryAttr, SDataBlockInfo* pBlockI return false; } -static int32_t doTSJoinFilter(STaskRuntimeEnv *pRuntimeEnv, TSKEY key, bool ascQuery) { +static int32_t doTSJoinFilter(STaskRuntimeEnv* pRuntimeEnv, TSKEY key, bool ascQuery) { STSElem elem = tsBufGetElem(pRuntimeEnv->pTsBuf); #if defined(_DEBUG_VIEW) - printf("elem in comp ts file:%" PRId64 ", key:%" PRId64 ", tag:%"PRIu64", query order:%d, ts order:%d, traverse:%d, index:%d\n", + printf("elem in comp ts file:%" PRId64 ", key:%" PRId64 ", tag:%" PRIu64 + ", query order:%d, ts order:%d, traverse:%d, index:%d\n", elem.ts, key, elem.tag.i, pQueryAttr->order.order, pRuntimeEnv->pTsBuf->tsOrder, pRuntimeEnv->pTsBuf->cur.order, pRuntimeEnv->pTsBuf->cur.tsIndex); #endif @@ -2631,23 +2721,23 @@ bool doFilterDataBlock(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilter qualified = false; for (int32_t j = 0; j < pFilterInfo[k].numOfFilters; ++j) { SColumnFilterElem* pFilterElem = NULL; -// SColumnFilterElem* pFilterElem = &pFilterInfo[k].pFilters[j]; + // SColumnFilterElem* pFilterElem = &pFilterInfo[k].pFilters[j]; bool isnull = isNull(pElem, pFilterInfo[k].info.type); if (isnull) { -// if (pFilterElem->fp == isNullOperator) { -// qualified = true; -// break; -// } else { -// continue; -// } + // if (pFilterElem->fp == isNullOperator) { + // qualified = true; + // break; + // } else { + // continue; + // } } else { -// if (pFilterElem->fp == notNullOperator) { -// qualified = true; -// break; -// } else if (pFilterElem->fp == isNullOperator) { -// continue; -// } + // if (pFilterElem->fp == notNullOperator) { + // qualified = true; + // break; + // } else if (pFilterElem->fp == isNullOperator) { + // continue; + // } } if (pFilterElem->fp(pFilterElem, pElem, pElem, pFilterInfo[k].info.type)) { @@ -2723,7 +2813,7 @@ void filterRowsInDataBlock(STaskRuntimeEnv* pRuntimeEnv, SSingleColumnFilterInfo SSDataBlock* pBlock, bool ascQuery) { int32_t numOfRows = pBlock->info.rows; - int8_t *p = taosMemoryCalloc(numOfRows, sizeof(int8_t)); + int8_t* p = taosMemoryCalloc(numOfRows, sizeof(int8_t)); bool all = true; #if 0 if (pRuntimeEnv->pTsBuf != NULL) { @@ -2763,58 +2853,59 @@ void filterRowsInDataBlock(STaskRuntimeEnv* pRuntimeEnv, SSingleColumnFilterInfo } void filterColRowsInDataBlock(STaskRuntimeEnv* pRuntimeEnv, SSDataBlock* pBlock, bool ascQuery) { - int32_t numOfRows = pBlock->info.rows; + int32_t numOfRows = pBlock->info.rows; - int8_t *p = NULL; - bool all = true; + int8_t* p = NULL; + bool all = true; - if (pRuntimeEnv->pTsBuf != NULL) { - SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, 0); - p = taosMemoryCalloc(numOfRows, sizeof(int8_t)); - - TSKEY* k = (TSKEY*) pColInfoData->pData; - for (int32_t i = 0; i < numOfRows; ++i) { - int32_t offset = ascQuery? i:(numOfRows - i - 1); - int32_t ret = doTSJoinFilter(pRuntimeEnv, k[offset], ascQuery); - if (ret == TS_JOIN_TAG_NOT_EQUALS) { - break; - } else if (ret == TS_JOIN_TS_NOT_EQUALS) { - all = false; - continue; - } else { - assert(ret == TS_JOIN_TS_EQUAL); - p[offset] = true; - } + if (pRuntimeEnv->pTsBuf != NULL) { + SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, 0); + p = taosMemoryCalloc(numOfRows, sizeof(int8_t)); - if (!tsBufNextPos(pRuntimeEnv->pTsBuf)) { - break; - } - } + TSKEY* k = (TSKEY*)pColInfoData->pData; + for (int32_t i = 0; i < numOfRows; ++i) { + int32_t offset = ascQuery ? i : (numOfRows - i - 1); + int32_t ret = doTSJoinFilter(pRuntimeEnv, k[offset], ascQuery); + if (ret == TS_JOIN_TAG_NOT_EQUALS) { + break; + } else if (ret == TS_JOIN_TS_NOT_EQUALS) { + all = false; + continue; + } else { + assert(ret == TS_JOIN_TS_EQUAL); + p[offset] = true; + } - // save the cursor status -// pRuntimeEnv->current->cur = tsBufGetCursor(pRuntimeEnv->pTsBuf); - } else { -// all = filterExecute(pRuntimeEnv->pQueryAttr->pFilters, numOfRows, &p, pBlock->pBlockAgg, pRuntimeEnv->pQueryAttr->numOfCols); - } + if (!tsBufNextPos(pRuntimeEnv->pTsBuf)) { + break; + } + } - if (!all) { - if (p) { - doCompactSDataBlock(pBlock, numOfRows, p); - } else { - pBlock->info.rows = 0; - pBlock->pBlockAgg = NULL; // clean the block statistics info - } - } + // save the cursor status + // pRuntimeEnv->current->cur = tsBufGetCursor(pRuntimeEnv->pTsBuf); + } else { + // all = filterExecute(pRuntimeEnv->pQueryAttr->pFilters, numOfRows, &p, pBlock->pBlockAgg, + // pRuntimeEnv->pQueryAttr->numOfCols); + } - taosMemoryFreeClear(p); + if (!all) { + if (p) { + doCompactSDataBlock(pBlock, numOfRows, p); + } else { + pBlock->info.rows = 0; + pBlock->pBlockAgg = NULL; // clean the block statistics info + } + } + + taosMemoryFreeClear(p); } static SColumnInfo* doGetTagColumnInfoById(SColumnInfo* pTagColList, int32_t numOfTags, int16_t colId); -static void doSetTagValueInParam(void* pTable, int32_t tagColId, SVariant *tag, int16_t type, int16_t bytes); +static void doSetTagValueInParam(void* pTable, int32_t tagColId, SVariant* tag, int16_t type, int16_t bytes); static uint32_t doFilterByBlockTimeWindow(STableScanInfo* pTableScanInfo, SSDataBlock* pBlock) { SqlFunctionCtx* pCtx = pTableScanInfo->pCtx; - uint32_t status = BLK_DATA_NO_NEEDED; + uint32_t status = BLK_DATA_NO_NEEDED; int32_t numOfOutput = pTableScanInfo->numOfOutput; for (int32_t i = 0; i < numOfOutput; ++i) { @@ -2826,10 +2917,10 @@ static uint32_t doFilterByBlockTimeWindow(STableScanInfo* pTableScanInfo, SSData status |= BLK_DATA_ALL_NEEDED; return status; } else { -// status |= aAggs[functionId].dataReqFunc(&pTableScanInfo->pCtx[i], &pBlock->info.window, colId); -// if ((status & BLK_DATA_ALL_NEEDED) == BLK_DATA_ALL_NEEDED) { -// return status; -// } + // status |= aAggs[functionId].dataReqFunc(&pTableScanInfo->pCtx[i], &pBlock->info.window, colId); + // if ((status & BLK_DATA_ALL_NEEDED) == BLK_DATA_ALL_NEEDED) { + // return status; + // } } } @@ -2850,7 +2941,7 @@ void doSetFilterColumnInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFi } } -int32_t loadDataBlock(SExecTaskInfo *pTaskInfo, STableScanInfo* pTableScanInfo, SSDataBlock* pBlock, uint32_t* status) { +int32_t loadDataBlock(SExecTaskInfo* pTaskInfo, STableScanInfo* pTableScanInfo, SSDataBlock* pBlock, uint32_t* status) { STaskCostInfo* pCost = &pTaskInfo->cost; pCost->totalBlocks += 1; @@ -2869,7 +2960,7 @@ int32_t loadDataBlock(SExecTaskInfo *pTaskInfo, STableScanInfo* pTableScanInfo, int32_t numOfCols = pBlock->info.numOfCols; for (int32_t i = 0; i < numOfCols; ++i) { SColumnInfoData* p = taosArrayGet(pCols, i); - SColMatchInfo* pColMatchInfo = taosArrayGet(pTableScanInfo->pColMatchInfo, i); + SColMatchInfo* pColMatchInfo = taosArrayGet(pTableScanInfo->pColMatchInfo, i); if (!pColMatchInfo->output) { continue; } @@ -2881,14 +2972,15 @@ int32_t loadDataBlock(SExecTaskInfo *pTaskInfo, STableScanInfo* pTableScanInfo, return TSDB_CODE_SUCCESS; } -int32_t loadDataBlockOnDemand(SExecTaskInfo *pTaskInfo, STableScanInfo* pTableScanInfo, SSDataBlock* pBlock, uint32_t* status) { +int32_t loadDataBlockOnDemand(SExecTaskInfo* pTaskInfo, STableScanInfo* pTableScanInfo, SSDataBlock* pBlock, + uint32_t* status) { *status = BLK_DATA_NO_NEEDED; pBlock->pDataBlock = NULL; - pBlock->pBlockAgg = NULL; + pBlock->pBlockAgg = NULL; -// int64_t groupId = pRuntimeEnv->current->groupIndex; -// bool ascQuery = QUERY_IS_ASC_QUERY(pQueryAttr); + // int64_t groupId = pRuntimeEnv->current->groupIndex; + // bool ascQuery = QUERY_IS_ASC_QUERY(pQueryAttr); STaskCostInfo* pCost = &pTaskInfo->cost; @@ -3044,7 +3136,7 @@ int32_t loadDataBlockOnDemand(SExecTaskInfo *pTaskInfo, STableScanInfo* pTableSc return TSDB_CODE_SUCCESS; } -int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order) { +int32_t binarySearchForKey(char* pValue, int num, TSKEY key, int order) { int32_t midPos = -1; int32_t numOfRows; @@ -3054,7 +3146,7 @@ int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order) { assert(order == TSDB_ORDER_ASC || order == TSDB_ORDER_DESC); - TSKEY * keyList = (TSKEY *)pValue; + TSKEY* keyList = (TSKEY*)pValue; int32_t firstPos = 0; int32_t lastPos = num - 1; @@ -3111,16 +3203,16 @@ int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order) { * set tag value in SqlFunctionCtx * e.g.,tag information into input buffer */ -static void doSetTagValueInParam(void* pTable, int32_t tagColId, SVariant *tag, int16_t type, int16_t bytes) { +static void doSetTagValueInParam(void* pTable, int32_t tagColId, SVariant* tag, int16_t type, int16_t bytes) { taosVariantDestroy(tag); char* val = NULL; -// if (tagColId == TSDB_TBNAME_COLUMN_INDEX) { -// val = tsdbGetTableName(pTable); -// assert(val != NULL); -// } else { -// val = tsdbGetTableTagVal(pTable, tagColId, type, bytes); -// } + // if (tagColId == TSDB_TBNAME_COLUMN_INDEX) { + // val = tsdbGetTableName(pTable); + // assert(val != NULL); + // } else { + // val = tsdbGetTableTagVal(pTable, tagColId, type, bytes); + // } if (val == NULL || isNull(val, type)) { tag->nType = TSDB_DATA_TYPE_NULL; @@ -3129,9 +3221,9 @@ static void doSetTagValueInParam(void* pTable, int32_t tagColId, SVariant *tag, if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) { int32_t maxLen = bytes - VARSTR_HEADER_SIZE; - int32_t len = (varDataLen(val) > maxLen)? maxLen:varDataLen(val); + int32_t len = (varDataLen(val) > maxLen) ? maxLen : varDataLen(val); taosVariantCreateFromBinary(tag, varDataVal(val), len, type); - //taosVariantCreateFromBinary(tag, varDataVal(val), varDataLen(val), type); + // taosVariantCreateFromBinary(tag, varDataVal(val), varDataLen(val), type); } else { taosVariantCreateFromBinary(tag, val, bytes, type); } @@ -3140,7 +3232,7 @@ static void doSetTagValueInParam(void* pTable, int32_t tagColId, SVariant *tag, static SColumnInfo* doGetTagColumnInfoById(SColumnInfo* pTagColList, int32_t numOfTags, int16_t colId) { assert(pTagColList != NULL && numOfTags > 0); - for(int32_t i = 0; i < numOfTags; ++i) { + for (int32_t i = 0; i < numOfTags; ++i) { if (pTagColList[i].colId == colId) { return &pTagColList[i]; } @@ -3149,19 +3241,19 @@ static SColumnInfo* doGetTagColumnInfoById(SColumnInfo* pTagColList, int32_t num return NULL; } -void setTagValue(SOperatorInfo* pOperatorInfo, void *pTable, SqlFunctionCtx* pCtx, int32_t numOfOutput) { +void setTagValue(SOperatorInfo* pOperatorInfo, void* pTable, SqlFunctionCtx* pCtx, int32_t numOfOutput) { STaskRuntimeEnv* pRuntimeEnv = pOperatorInfo->pRuntimeEnv; - SExprInfo *pExpr = pOperatorInfo->pExpr; - STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; + SExprInfo* pExpr = pOperatorInfo->pExpr; + STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; SExprInfo* pExprInfo = &pExpr[0]; - int32_t functionId = getExprFunctionId(pExprInfo); + int32_t functionId = getExprFunctionId(pExprInfo); if (pQueryAttr->numOfOutput == 1 && functionId == FUNCTION_TS_COMP && pQueryAttr->stableQuery) { assert(pExprInfo->base.numOfParams == 1); -// int16_t tagColId = (int16_t)pExprInfo->base.param[0].i; + // int16_t tagColId = (int16_t)pExprInfo->base.param[0].i; int16_t tagColId = -1; SColumnInfo* pColInfo = doGetTagColumnInfoById(pQueryAttr->tagColList, pQueryAttr->numOfTags, tagColId); @@ -3181,23 +3273,23 @@ void setTagValue(SOperatorInfo* pOperatorInfo, void *pTable, SqlFunctionCtx* pCt } // todo use tag column index to optimize performance - doSetTagValueInParam(pTable, pLocalExprInfo->base.pParam[0].pCol->colId, &pCtx[idx].tag, pLocalExprInfo->base.resSchema.type, - pLocalExprInfo->base.resSchema.bytes); + doSetTagValueInParam(pTable, pLocalExprInfo->base.pParam[0].pCol->colId, &pCtx[idx].tag, + pLocalExprInfo->base.resSchema.type, pLocalExprInfo->base.resSchema.bytes); - if (IS_NUMERIC_TYPE(pLocalExprInfo->base.resSchema.type) - || pLocalExprInfo->base.resSchema.type == TSDB_DATA_TYPE_BOOL - || pLocalExprInfo->base.resSchema.type == TSDB_DATA_TYPE_TIMESTAMP) { + if (IS_NUMERIC_TYPE(pLocalExprInfo->base.resSchema.type) || + pLocalExprInfo->base.resSchema.type == TSDB_DATA_TYPE_BOOL || + pLocalExprInfo->base.resSchema.type == TSDB_DATA_TYPE_TIMESTAMP) { memcpy(pRuntimeEnv->tagVal + offset, &pCtx[idx].tag.i, pLocalExprInfo->base.resSchema.bytes); } else { if (pCtx[idx].tag.pz != NULL) { memcpy(pRuntimeEnv->tagVal + offset, pCtx[idx].tag.pz, pCtx[idx].tag.nLen); - } + } } offset += pLocalExprInfo->base.resSchema.bytes; } - //todo : use index to avoid iterator all possible output columns + // todo : use index to avoid iterator all possible output columns if (pQueryAttr->stableQuery && pQueryAttr->stabledev && (pRuntimeEnv->prevResult != NULL)) { setParamForStableStddev(pRuntimeEnv, pCtx, numOfOutput, pExprInfo); } @@ -3217,12 +3309,12 @@ void copyToSDataBlock(SSDataBlock* pBlock, int32_t* offset, SGroupResInfo* pGrou // all results in current group have been returned to client, try next group if ((pGroupResInfo->pRows == NULL) || taosArrayGetSize(pGroupResInfo->pRows) == 0) { assert(pGroupResInfo->index == 0); -// if ((code = mergeIntoGroupResult(&pGroupResInfo, pRuntimeEnv, offset)) != TSDB_CODE_SUCCESS) { - return; -// } + // if ((code = mergeIntoGroupResult(&pGroupResInfo, pRuntimeEnv, offset)) != TSDB_CODE_SUCCESS) { + return; + // } } -// doCopyToSDataBlock(pResBuf, pGroupResInfo, TSDB_ORDER_ASC, pBlock, ); + // doCopyToSDataBlock(pResBuf, pGroupResInfo, TSDB_ORDER_ASC, pBlock, ); // current data are all dumped to result buffer, clear it if (!hasRemainDataInCurrentGroup(pGroupResInfo)) { @@ -3233,22 +3325,22 @@ void copyToSDataBlock(SSDataBlock* pBlock, int32_t* offset, SGroupResInfo* pGrou } // enough results in data buffer, return -// if (pBlock->info.rows >= threshold) { -// break; -// } + // if (pBlock->info.rows >= threshold) { + // break; + // } } } -static void updateTableQueryInfoForReverseScan(STableQueryInfo *pTableQueryInfo) { +static void updateTableQueryInfoForReverseScan(STableQueryInfo* pTableQueryInfo) { if (pTableQueryInfo == NULL) { return; } -// TSWAP(pTableQueryInfo->win.skey, pTableQueryInfo->win.ekey, TSKEY); -// pTableQueryInfo->lastKey = pTableQueryInfo->win.skey; + // TSWAP(pTableQueryInfo->win.skey, pTableQueryInfo->win.ekey, TSKEY); + // pTableQueryInfo->lastKey = pTableQueryInfo->win.skey; -// SWITCH_ORDER(pTableQueryInfo->cur.order); -// pTableQueryInfo->cur.vgroupIndex = -1; + // SWITCH_ORDER(pTableQueryInfo->cur.order); + // pTableQueryInfo->cur.vgroupIndex = -1; // set the index to be the end slot of result rows array SResultRowInfo* pResultRowInfo = &pTableQueryInfo->resInfo; @@ -3280,7 +3372,6 @@ static void setupQueryRangeForReverseScan(STableScanInfo* pTableScanInfo) { } } #endif - } void switchCtxOrder(SqlFunctionCtx* pCtx, int32_t numOfOutput) { @@ -3290,7 +3381,7 @@ void switchCtxOrder(SqlFunctionCtx* pCtx, int32_t numOfOutput) { } // TODO fix this bug. -int32_t initResultRow(SResultRow *pResultRow) { +int32_t initResultRow(SResultRow* pResultRow) { pResultRow->pEntryInfo = (struct SResultRowEntryInfo*)((char*)pResultRow + sizeof(SResultRow)); return TSDB_CODE_SUCCESS; } @@ -3305,39 +3396,40 @@ int32_t initResultRow(SResultRow *pResultRow) { */ // TODO refactor: some function move away void setFunctionResultOutput(SOptrBasicInfo* pInfo, SAggSupporter* pSup, int32_t stage, SExecTaskInfo* pTaskInfo) { - SqlFunctionCtx* pCtx = pInfo->pCtx; - SSDataBlock* pDataBlock = pInfo->pRes; - int32_t* rowCellInfoOffset = pInfo->rowCellInfoOffset; + SqlFunctionCtx* pCtx = pInfo->pCtx; + SSDataBlock* pDataBlock = pInfo->pRes; + int32_t* rowCellInfoOffset = pInfo->rowCellInfoOffset; SResultRowInfo* pResultRowInfo = &pInfo->resultRowInfo; - int64_t tid = 0; - int64_t groupId = 0; - SResultRow* pRow = doSetResultOutBufByKey_rv(pSup->pResultBuf, pResultRowInfo, tid, (char *)&tid, sizeof(tid), true, groupId, pTaskInfo, false, pSup); + int64_t tid = 0; + int64_t groupId = 0; + SResultRow* pRow = doSetResultOutBufByKey_rv(pSup->pResultBuf, pResultRowInfo, tid, (char*)&tid, sizeof(tid), true, + groupId, pTaskInfo, false, pSup); for (int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) { struct SResultRowEntryInfo* pEntry = getResultCell(pRow, i, rowCellInfoOffset); cleanupResultRowEntry(pEntry); - pCtx[i].resultInfo = pEntry; + pCtx[i].resultInfo = pEntry; pCtx[i].currentStage = stage; // set the timestamp output buffer for top/bottom/diff query -// int32_t fid = pCtx[i].functionId; -// if (fid == FUNCTION_TOP || fid == FUNCTION_BOTTOM || fid == FUNCTION_DIFF || fid == FUNCTION_DERIVATIVE) { -// if (i > 0) pCtx[i].ptsOutputBuf = pCtx[i-1].pOutput; -// } + // int32_t fid = pCtx[i].functionId; + // if (fid == FUNCTION_TOP || fid == FUNCTION_BOTTOM || fid == FUNCTION_DIFF || fid == FUNCTION_DERIVATIVE) { + // if (i > 0) pCtx[i].ptsOutputBuf = pCtx[i-1].pOutput; + // } } initCtxOutputBuffer(pCtx, pDataBlock->info.numOfCols); } -void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOfInputRows) { +void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t* bufCapacity, int32_t numOfInputRows) { SSDataBlock* pDataBlock = pBInfo->pRes; - int32_t newSize = pDataBlock->info.rows + numOfInputRows + 5; // extra output buffer + int32_t newSize = pDataBlock->info.rows + numOfInputRows + 5; // extra output buffer if ((*bufCapacity) < newSize) { - for(int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) { - SColumnInfoData *pColInfo = taosArrayGet(pDataBlock->pDataBlock, i); + for (int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) { + SColumnInfoData* pColInfo = taosArrayGet(pDataBlock->pDataBlock, i); char* p = taosMemoryRealloc(pColInfo->pData, newSize * pColInfo->info.bytes); if (p != NULL) { @@ -3352,16 +3444,16 @@ void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOf } } - for (int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) { - SColumnInfoData *pColInfo = taosArrayGet(pDataBlock->pDataBlock, i); + SColumnInfoData* pColInfo = taosArrayGet(pDataBlock->pDataBlock, i); pBInfo->pCtx[i].pOutput = pColInfo->pData + pColInfo->info.bytes * pDataBlock->info.rows; // set the correct pointer after the memory buffer reallocated. int32_t functionId = pBInfo->pCtx[i].functionId; - if (functionId == FUNCTION_TOP || functionId == FUNCTION_BOTTOM || functionId == FUNCTION_DIFF || functionId == FUNCTION_DERIVATIVE) { - if (i > 0) pBInfo->pCtx[i].ptsOutputBuf = pBInfo->pCtx[i-1].pOutput; + if (functionId == FUNCTION_TOP || functionId == FUNCTION_BOTTOM || functionId == FUNCTION_DIFF || + functionId == FUNCTION_DERIVATIVE) { + if (i > 0) pBInfo->pCtx[i].ptsOutputBuf = pBInfo->pCtx[i - 1].pOutput; } } } @@ -3369,16 +3461,16 @@ void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOf void copyTsColoum(SSDataBlock* pRes, SqlFunctionCtx* pCtx, int32_t numOfOutput) { bool needCopyTs = false; int32_t tsNum = 0; - char *src = NULL; + char* src = NULL; for (int32_t i = 0; i < numOfOutput; i++) { int32_t functionId = pCtx[i].functionId; if (functionId == FUNCTION_DIFF || functionId == FUNCTION_DERIVATIVE) { needCopyTs = true; - if (i > 0 && pCtx[i-1].functionId == FUNCTION_TS_DUMMY) { - SColumnInfoData* pColRes = taosArrayGet(pRes->pDataBlock, i - 1); // find ts data + if (i > 0 && pCtx[i - 1].functionId == FUNCTION_TS_DUMMY) { + SColumnInfoData* pColRes = taosArrayGet(pRes->pDataBlock, i - 1); // find ts data src = pColRes->pData; } - } else if(functionId == FUNCTION_TS_DUMMY) { + } else if (functionId == FUNCTION_TS_DUMMY) { tsNum++; } } @@ -3389,18 +3481,18 @@ void copyTsColoum(SSDataBlock* pRes, SqlFunctionCtx* pCtx, int32_t numOfOutput) for (int32_t i = 0; i < numOfOutput; i++) { int32_t functionId = pCtx[i].functionId; - if(functionId == FUNCTION_TS_DUMMY) { + if (functionId == FUNCTION_TS_DUMMY) { SColumnInfoData* pColRes = taosArrayGet(pRes->pDataBlock, i); memcpy(pColRes->pData, src, pColRes->info.bytes * pRes->info.rows); } } } -void clearOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity) { +void clearOutputBuf(SOptrBasicInfo* pBInfo, int32_t* bufCapacity) { SSDataBlock* pDataBlock = pBInfo->pRes; for (int32_t i = 0; i < pDataBlock->info.numOfCols; ++i) { - SColumnInfoData *pColInfo = taosArrayGet(pDataBlock->pDataBlock, i); + SColumnInfoData* pColInfo = taosArrayGet(pDataBlock->pDataBlock, i); int32_t functionId = pBInfo->pCtx[i].functionId; if (functionId < 0) { @@ -3420,7 +3512,7 @@ void initCtxOutputBuffer(SqlFunctionCtx* pCtx, int32_t size) { } } -void setTaskStatus(SExecTaskInfo *pTaskInfo, int8_t status) { +void setTaskStatus(SExecTaskInfo* pTaskInfo, int8_t status) { if (status == TASK_NOT_COMPLETED) { pTaskInfo->status = status; } else { @@ -3430,24 +3522,24 @@ void setTaskStatus(SExecTaskInfo *pTaskInfo, int8_t status) { } } -static void setupEnvForReverseScan(STableScanInfo *pTableScanInfo, SqlFunctionCtx* pCtx, int32_t numOfOutput) { -// if (pRuntimeEnv->pTsBuf) { -// SWITCH_ORDER(pRuntimeEnv->pTsBuf->cur.order); -// bool ret = tsBufNextPos(pRuntimeEnv->pTsBuf); -// assert(ret); -// } +static void setupEnvForReverseScan(STableScanInfo* pTableScanInfo, SqlFunctionCtx* pCtx, int32_t numOfOutput) { + // if (pRuntimeEnv->pTsBuf) { + // SWITCH_ORDER(pRuntimeEnv->pTsBuf->cur.order); + // bool ret = tsBufNextPos(pRuntimeEnv->pTsBuf); + // assert(ret); + // } // reverse order time range SET_REVERSE_SCAN_FLAG(pTableScanInfo); -// setTaskStatus(pTableScanInfo, QUERY_NOT_COMPLETED); + // setTaskStatus(pTableScanInfo, QUERY_NOT_COMPLETED); switchCtxOrder(pCtx, numOfOutput); SWITCH_ORDER(pTableScanInfo->order); setupQueryRangeForReverseScan(pTableScanInfo); - pTableScanInfo->times = 1; - pTableScanInfo->current = 0; + pTableScanInfo->times = 1; + pTableScanInfo->current = 0; pTableScanInfo->reverseTimes = 0; } @@ -3461,11 +3553,12 @@ void finalizeQueryResult(SqlFunctionCtx* pCtx, int32_t numOfOutput) { } } -void finalizeMultiTupleQueryResult(SqlFunctionCtx* pCtx, int32_t numOfOutput, SDiskbasedBuf *pBuf, SResultRowInfo* pResultRowInfo, int32_t* rowCellInfoOffset) { +void finalizeMultiTupleQueryResult(SqlFunctionCtx* pCtx, int32_t numOfOutput, SDiskbasedBuf* pBuf, + SResultRowInfo* pResultRowInfo, int32_t* rowCellInfoOffset) { for (int32_t i = 0; i < pResultRowInfo->size; ++i) { SResultRowPosition* pPos = &pResultRowInfo->pPosition[i]; - SFilePage* bufPage = getBufPage(pBuf, pPos->pageId); + SFilePage* bufPage = getBufPage(pBuf, pPos->pageId); SResultRow* pRow = (SResultRow*)((char*)bufPage + pPos->offset); if (!isResultRowClosed(pResultRowInfo, i)) { continue; @@ -3479,7 +3572,7 @@ void finalizeMultiTupleQueryResult(SqlFunctionCtx* pCtx, int32_t numOfOutput, SD continue; } - if (pCtx[j].fpSet.process) { // TODO set the dummy function. + if (pCtx[j].fpSet.process) { // TODO set the dummy function. pCtx[j].fpSet.finalize(&pCtx[j]); } @@ -3493,11 +3586,11 @@ void finalizeMultiTupleQueryResult(SqlFunctionCtx* pCtx, int32_t numOfOutput, SD * set the number of output results for group by normal columns, the number of output rows usually is 1 except * the top and bottom query */ -// buf->numOfRows = (uint16_t)getNumOfResult(pCtx, numOfOutput); + // buf->numOfRows = (uint16_t)getNumOfResult(pCtx, numOfOutput); } } -static bool hasMainOutput(STaskAttr *pQueryAttr) { +static bool hasMainOutput(STaskAttr* pQueryAttr) { for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { int32_t functionId = getExprFunctionId(&pQueryAttr->pExpr1[i]); @@ -3509,19 +3602,19 @@ static bool hasMainOutput(STaskAttr *pQueryAttr) { return false; } -STableQueryInfo *createTableQueryInfo(void* buf, bool groupbyColumn, STimeWindow win) { - STableQueryInfo *pTableQueryInfo = buf; +STableQueryInfo* createTableQueryInfo(void* buf, bool groupbyColumn, STimeWindow win) { + STableQueryInfo* pTableQueryInfo = buf; pTableQueryInfo->lastKey = win.skey; // set more initial size of interval/groupby query -// if (/*QUERY_IS_INTERVAL_QUERY(pQueryAttr) || */groupbyColumn) { - int32_t initialSize = 128; - int32_t code = initResultRowInfo(&pTableQueryInfo->resInfo, initialSize); - if (code != TSDB_CODE_SUCCESS) { - return NULL; - } -// } else { // in other aggregate query, do not initialize the windowResInfo -// } + // if (/*QUERY_IS_INTERVAL_QUERY(pQueryAttr) || */groupbyColumn) { + int32_t initialSize = 128; + int32_t code = initResultRowInfo(&pTableQueryInfo->resInfo, initialSize); + if (code != TSDB_CODE_SUCCESS) { + return NULL; + } + // } else { // in other aggregate query, do not initialize the windowResInfo + // } return pTableQueryInfo; } @@ -3529,7 +3622,7 @@ STableQueryInfo *createTableQueryInfo(void* buf, bool groupbyColumn, STimeWindow STableQueryInfo* createTmpTableQueryInfo(STimeWindow win) { STableQueryInfo* pTableQueryInfo = taosMemoryCalloc(1, sizeof(STableQueryInfo)); -// pTableQueryInfo->win = win; + // pTableQueryInfo->win = win; pTableQueryInfo->lastKey = win.skey; // set more initial size of interval/groupby query @@ -3543,17 +3636,17 @@ STableQueryInfo* createTmpTableQueryInfo(STimeWindow win) { return pTableQueryInfo; } -void destroyTableQueryInfoImpl(STableQueryInfo *pTableQueryInfo) { +void destroyTableQueryInfoImpl(STableQueryInfo* pTableQueryInfo) { if (pTableQueryInfo == NULL) { return; } -// taosVariantDestroy(&pTableQueryInfo->tag); + // taosVariantDestroy(&pTableQueryInfo->tag); cleanupResultRowInfo(&pTableQueryInfo->resInfo); } -void setResultRowOutputBufInitCtx(STaskRuntimeEnv *pRuntimeEnv, SResultRow *pResult, SqlFunctionCtx* pCtx, - int32_t numOfOutput, int32_t* rowCellInfoOffset) { +void setResultRowOutputBufInitCtx(STaskRuntimeEnv* pRuntimeEnv, SResultRow* pResult, SqlFunctionCtx* pCtx, + int32_t numOfOutput, int32_t* rowCellInfoOffset) { // Note: pResult->pos[i]->num == 0, there is only fixed number of results for each group SFilePage* bufPage = getBufPage(pRuntimeEnv->pResultBuf, pResult->pageId); @@ -3576,16 +3669,17 @@ void setResultRowOutputBufInitCtx(STaskRuntimeEnv *pRuntimeEnv, SResultRow *pRes } if (functionId == FUNCTION_TOP || functionId == FUNCTION_BOTTOM || functionId == FUNCTION_DIFF) { - if(i > 0) pCtx[i].ptsOutputBuf = pCtx[i-1].pOutput; + if (i > 0) pCtx[i].ptsOutputBuf = pCtx[i - 1].pOutput; } -// if (!pResInfo->initialized) { -// aAggs[functionId].init(&pCtx[i], pResInfo); -// } + // if (!pResInfo->initialized) { + // aAggs[functionId].init(&pCtx[i], pResInfo); + // } } } -void setResultRowOutputBufInitCtx_rv(SDiskbasedBuf * pBuf, SResultRow *pResult, SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowCellInfoOffset) { +void setResultRowOutputBufInitCtx_rv(SDiskbasedBuf* pBuf, SResultRow* pResult, SqlFunctionCtx* pCtx, + int32_t numOfOutput, int32_t* rowCellInfoOffset) { // Note: pResult->pos[i]->num == 0, there is only fixed number of results for each group for (int32_t i = 0; i < numOfOutput; ++i) { pCtx[i].resultInfo = getResultCell(pResult, i, rowCellInfoOffset); @@ -3594,13 +3688,13 @@ void setResultRowOutputBufInitCtx_rv(SDiskbasedBuf * pBuf, SResultRow *pResult, if (isRowEntryCompleted(pResInfo) && isRowEntryInitialized(pResInfo)) { continue; } -// int32_t functionId = pCtx[i].functionId; -// if (functionId < 0) { -// continue; -// } -// if (functionId == FUNCTION_TOP || functionId == FUNCTION_BOTTOM || functionId == FUNCTION_DIFF) { -// if (i > 0) pCtx[i].ptsOutputBuf = pCtx[i - 1].pOutput; -// } + // int32_t functionId = pCtx[i].functionId; + // if (functionId < 0) { + // continue; + // } + // if (functionId == FUNCTION_TOP || functionId == FUNCTION_BOTTOM || functionId == FUNCTION_DIFF) { + // if (i > 0) pCtx[i].ptsOutputBuf = pCtx[i - 1].pOutput; + // } if (!pResInfo->initialized && pCtx[i].functionId != -1) { pCtx[i].fpSet.init(&pCtx[i], pResInfo); @@ -3608,25 +3702,28 @@ void setResultRowOutputBufInitCtx_rv(SDiskbasedBuf * pBuf, SResultRow *pResult, } } -void doSetTableGroupOutputBuf(SAggOperatorInfo* pAggInfo, int32_t numOfOutput, int32_t tableGroupId, SExecTaskInfo* pTaskInfo) { +void doSetTableGroupOutputBuf(SAggOperatorInfo* pAggInfo, int32_t numOfOutput, int32_t tableGroupId, + SExecTaskInfo* pTaskInfo) { // for simple group by query without interval, all the tables belong to one group result. int64_t uid = 0; int64_t tid = 0; SResultRowInfo* pResultRowInfo = &pAggInfo->binfo.resultRowInfo; SqlFunctionCtx* pCtx = pAggInfo->binfo.pCtx; - int32_t* rowCellInfoOffset = pAggInfo->binfo.rowCellInfoOffset; + int32_t* rowCellInfoOffset = pAggInfo->binfo.rowCellInfoOffset; SResultRow* pResultRow = - doSetResultOutBufByKey_rv(pAggInfo->pResultBuf, pResultRowInfo, tid, (char*)&tableGroupId, sizeof(tableGroupId), true, uid, pTaskInfo, false, &pAggInfo->aggSup); - assert (pResultRow != NULL); + doSetResultOutBufByKey_rv(pAggInfo->pResultBuf, pResultRowInfo, tid, (char*)&tableGroupId, sizeof(tableGroupId), + true, uid, pTaskInfo, false, &pAggInfo->aggSup); + assert(pResultRow != NULL); /* * not assign result buffer yet, add new result buffer * all group belong to one result set, and each group result has different group id so set the id to be one */ if (pResultRow->pageId == -1) { - int32_t ret = addNewWindowResultBuf(pResultRow, pAggInfo->pResultBuf, tableGroupId, pAggInfo->binfo.pRes->info.rowSize); + int32_t ret = + addNewWindowResultBuf(pResultRow, pAggInfo->pResultBuf, tableGroupId, pAggInfo->binfo.pRes->info.rowSize); if (ret != TSDB_CODE_SUCCESS) { return; } @@ -3635,7 +3732,8 @@ void doSetTableGroupOutputBuf(SAggOperatorInfo* pAggInfo, int32_t numOfOutput, i setResultRowOutputBufInitCtx_rv(pAggInfo->pResultBuf, pResultRow, pCtx, numOfOutput, rowCellInfoOffset); } -void setExecutionContext(int32_t numOfOutput, int32_t tableGroupId, TSKEY nextKey, SExecTaskInfo* pTaskInfo, STableQueryInfo *pTableQueryInfo, SAggOperatorInfo* pAggInfo) { +void setExecutionContext(int32_t numOfOutput, int32_t tableGroupId, TSKEY nextKey, SExecTaskInfo* pTaskInfo, + STableQueryInfo* pTableQueryInfo, SAggOperatorInfo* pAggInfo) { // lastKey needs to be updated pTableQueryInfo->lastKey = nextKey; if (pAggInfo->groupId != INT32_MIN && pAggInfo->groupId == tableGroupId) { @@ -3648,10 +3746,10 @@ void setExecutionContext(int32_t numOfOutput, int32_t tableGroupId, TSKEY nextKe pAggInfo->groupId = tableGroupId; } -void setResultOutputBuf(STaskRuntimeEnv *pRuntimeEnv, SResultRow *pResult, SqlFunctionCtx* pCtx, - int32_t numOfCols, int32_t* rowCellInfoOffset) { +void setResultOutputBuf(STaskRuntimeEnv* pRuntimeEnv, SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numOfCols, + int32_t* rowCellInfoOffset) { // Note: pResult->pos[i]->num == 0, there is only fixed number of results for each group - SFilePage *page = getBufPage(pRuntimeEnv->pResultBuf, pResult->pageId); + SFilePage* page = getBufPage(pRuntimeEnv->pResultBuf, pResult->pageId); int16_t offset = 0; for (int32_t i = 0; i < numOfCols; ++i) { @@ -3659,8 +3757,9 @@ void setResultOutputBuf(STaskRuntimeEnv *pRuntimeEnv, SResultRow *pResult, SqlFu offset += pCtx[i].resDataInfo.bytes; int32_t functionId = pCtx[i].functionId; - if (functionId == FUNCTION_TOP || functionId == FUNCTION_BOTTOM || functionId == FUNCTION_DIFF || functionId == FUNCTION_DERIVATIVE) { - if(i > 0) pCtx[i].ptsOutputBuf = pCtx[i-1].pOutput; + if (functionId == FUNCTION_TOP || functionId == FUNCTION_BOTTOM || functionId == FUNCTION_DIFF || + functionId == FUNCTION_DERIVATIVE) { + if (i > 0) pCtx[i].ptsOutputBuf = pCtx[i - 1].pOutput; } /* @@ -3675,28 +3774,30 @@ void setCtxTagForJoin(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, SExprI STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; SExprBasicInfo* pExpr = &pExprInfo->base; -// if (pQueryAttr->stableQuery && (pRuntimeEnv->pTsBuf != NULL) && -// (pExpr->functionId == FUNCTION_TS || pExpr->functionId == FUNCTION_PRJ) && -// (pExpr->colInfo.colIndex == PRIMARYKEY_TIMESTAMP_COL_ID)) { -// assert(pExpr->numOfParams == 1); -// -// int16_t tagColId = (int16_t)pExprInfo->base.param[0].i; -// SColumnInfo* pColInfo = doGetTagColumnInfoById(pQueryAttr->tagColList, pQueryAttr->numOfTags, tagColId); -// -// doSetTagValueInParam(pTable, tagColId, &pCtx->tag, pColInfo->type, pColInfo->bytes); -// -// int16_t tagType = pCtx[0].tag.nType; -// if (tagType == TSDB_DATA_TYPE_BINARY || tagType == TSDB_DATA_TYPE_NCHAR) { -// //qDebug("QInfo:0x%"PRIx64" set tag value for join comparison, colId:%" PRId64 ", val:%s", GET_TASKID(pRuntimeEnv), -//// pExprInfo->base.param[0].i, pCtx[0].tag.pz); -// } else { -// //qDebug("QInfo:0x%"PRIx64" set tag value for join comparison, colId:%" PRId64 ", val:%" PRId64, GET_TASKID(pRuntimeEnv), -//// pExprInfo->base.param[0].i, pCtx[0].tag.i); -// } -// } + // if (pQueryAttr->stableQuery && (pRuntimeEnv->pTsBuf != NULL) && + // (pExpr->functionId == FUNCTION_TS || pExpr->functionId == FUNCTION_PRJ) && + // (pExpr->colInfo.colIndex == PRIMARYKEY_TIMESTAMP_COL_ID)) { + // assert(pExpr->numOfParams == 1); + // + // int16_t tagColId = (int16_t)pExprInfo->base.param[0].i; + // SColumnInfo* pColInfo = doGetTagColumnInfoById(pQueryAttr->tagColList, pQueryAttr->numOfTags, tagColId); + // + // doSetTagValueInParam(pTable, tagColId, &pCtx->tag, pColInfo->type, pColInfo->bytes); + // + // int16_t tagType = pCtx[0].tag.nType; + // if (tagType == TSDB_DATA_TYPE_BINARY || tagType == TSDB_DATA_TYPE_NCHAR) { + // //qDebug("QInfo:0x%"PRIx64" set tag value for join comparison, colId:%" PRId64 ", val:%s", + // GET_TASKID(pRuntimeEnv), + //// pExprInfo->base.param[0].i, pCtx[0].tag.pz); + // } else { + // //qDebug("QInfo:0x%"PRIx64" set tag value for join comparison, colId:%" PRId64 ", val:%" PRId64, + // GET_TASKID(pRuntimeEnv), + //// pExprInfo->base.param[0].i, pCtx[0].tag.i); + // } + // } } -int32_t setTimestampListJoinInfo(STaskRuntimeEnv* pRuntimeEnv, SVariant* pTag, STableQueryInfo *pTableQueryInfo) { +int32_t setTimestampListJoinInfo(STaskRuntimeEnv* pRuntimeEnv, SVariant* pTag, STableQueryInfo* pTableQueryInfo) { STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; assert(pRuntimeEnv->pTsBuf != NULL); @@ -3739,7 +3840,8 @@ int32_t setTimestampListJoinInfo(STaskRuntimeEnv* pRuntimeEnv, SVariant* pTag, S } // TODO refactor: this funciton should be merged with setparamForStableStddevColumnData function. -void setParamForStableStddev(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, int32_t numOfOutput, SExprInfo* pExprInfo) { +void setParamForStableStddev(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, int32_t numOfOutput, + SExprInfo* pExprInfo) { #if 0 STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; @@ -3774,7 +3876,8 @@ void setParamForStableStddev(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, #endif } -void setParamForStableStddevByColData(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, int32_t numOfOutput, SExprInfo* pExpr, char* val, int16_t bytes) { +void setParamForStableStddevByColData(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionCtx* pCtx, int32_t numOfOutput, + SExprInfo* pExpr, char* val, int16_t bytes) { STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; #if 0 int32_t numOfExprs = pQueryAttr->numOfOutput; @@ -3809,22 +3912,22 @@ void setParamForStableStddevByColData(STaskRuntimeEnv* pRuntimeEnv, SqlFunctionC /* * There are two cases to handle: * - * 1. Query range is not set yet (queryRangeSet = 0). we need to set the query range info, including pQueryAttr->lastKey, - * pQueryAttr->window.skey, and pQueryAttr->eKey. + * 1. Query range is not set yet (queryRangeSet = 0). we need to set the query range info, including + * pQueryAttr->lastKey, pQueryAttr->window.skey, and pQueryAttr->eKey. * 2. Query range is set and query is in progress. There may be another result with the same query ranges to be * merged during merge stage. In this case, we need the pTableQueryInfo->lastResRows to decide if there * is a previous result generated or not. */ -void setIntervalQueryRange(STaskRuntimeEnv *pRuntimeEnv, TSKEY key) { - STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; - STableQueryInfo *pTableQueryInfo = pRuntimeEnv->current; - SResultRowInfo *pResultRowInfo = &pTableQueryInfo->resInfo; +void setIntervalQueryRange(STaskRuntimeEnv* pRuntimeEnv, TSKEY key) { + STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; + STableQueryInfo* pTableQueryInfo = pRuntimeEnv->current; + SResultRowInfo* pResultRowInfo = &pTableQueryInfo->resInfo; if (pResultRowInfo->curPos != -1) { return; } -// pTableQueryInfo->win.skey = key; + // pTableQueryInfo->win.skey = key; STimeWindow win = {.skey = key, .ekey = pQueryAttr->window.ekey}; /** @@ -3837,17 +3940,17 @@ void setIntervalQueryRange(STaskRuntimeEnv *pRuntimeEnv, TSKEY key) { TSKEY sk = TMIN(win.skey, win.ekey); TSKEY ek = TMAX(win.skey, win.ekey); -// getAlignQueryTimeWindow(pQueryAttr, win.skey, sk, ek, &w); + // getAlignQueryTimeWindow(pQueryAttr, win.skey, sk, ek, &w); -// if (pResultRowInfo->prevSKey == TSKEY_INITIAL_VAL) { -// if (!QUERY_IS_ASC_QUERY(pQueryAttr)) { -// assert(win.ekey == pQueryAttr->window.ekey); -// } -// -// pResultRowInfo->prevSKey = w.skey; -// } + // if (pResultRowInfo->prevSKey == TSKEY_INITIAL_VAL) { + // if (!QUERY_IS_ASC_QUERY(pQueryAttr)) { + // assert(win.ekey == pQueryAttr->window.ekey); + // } + // + // pResultRowInfo->prevSKey = w.skey; + // } -// pTableQueryInfo->lastKey = pTableQueryInfo->win.skey; + // pTableQueryInfo->lastKey = pTableQueryInfo->win.skey; } /** @@ -3859,14 +3962,15 @@ void setIntervalQueryRange(STaskRuntimeEnv *pRuntimeEnv, TSKEY key) { * @param pQInfo * @param result */ -static int32_t doCopyToSDataBlock(SDiskbasedBuf *pBuf, SGroupResInfo* pGroupResInfo, int32_t orderType, SSDataBlock* pBlock, int32_t rowCapacity, int32_t* rowCellOffset) { +static int32_t doCopyToSDataBlock(SDiskbasedBuf* pBuf, SGroupResInfo* pGroupResInfo, int32_t orderType, + SSDataBlock* pBlock, int32_t rowCapacity, int32_t* rowCellOffset) { int32_t numOfRows = getNumOfTotalRes(pGroupResInfo); - int32_t numOfResult = pBlock->info.rows; // there are already exists result rows + int32_t numOfResult = pBlock->info.rows; // there are already exists result rows int32_t start = 0; int32_t step = -1; - //qDebug("QInfo:0x%"PRIx64" start to copy data from windowResInfo to output buf", GET_TASKID(pRuntimeEnv)); + // qDebug("QInfo:0x%"PRIx64" start to copy data from windowResInfo to output buf", GET_TASKID(pRuntimeEnv)); assert(orderType == TSDB_ORDER_ASC || orderType == TSDB_ORDER_DESC); if (orderType == TSDB_ORDER_ASC) { @@ -3881,7 +3985,7 @@ static int32_t doCopyToSDataBlock(SDiskbasedBuf *pBuf, SGroupResInfo* pGroupResI for (int32_t i = start; (i < numOfRows) && (i >= 0); i += step) { SResultRowPosition* pPos = taosArrayGet(pGroupResInfo->pRows, i); - SFilePage *page = getBufPage(pBuf, pPos->pageId); + SFilePage* page = getBufPage(pBuf, pPos->pageId); SResultRow* pRow = (SResultRow*)((char*)page + pPos->offset); if (pRow->numOfRows == 0) { @@ -3891,14 +3995,14 @@ static int32_t doCopyToSDataBlock(SDiskbasedBuf *pBuf, SGroupResInfo* pGroupResI // TODO copy multiple rows? int32_t numOfRowsToCopy = pRow->numOfRows; - if (numOfResult + numOfRowsToCopy >= rowCapacity) { + if (numOfResult + numOfRowsToCopy >= rowCapacity) { break; } pGroupResInfo->index += 1; for (int32_t j = 0; j < pBlock->info.numOfCols; ++j) { - SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, j); + SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, j); SResultRowEntryInfo* pEntryInfo = getResultCell(pRow, j, rowCellOffset); char* in = GET_ROWCELL_INTERBUF(pEntryInfo); @@ -3914,12 +4018,13 @@ static int32_t doCopyToSDataBlock(SDiskbasedBuf *pBuf, SGroupResInfo* pGroupResI } } - //qDebug("QInfo:0x%"PRIx64" copy data to query buf completed", GET_TASKID(pRuntimeEnv)); + // qDebug("QInfo:0x%"PRIx64" copy data to query buf completed", GET_TASKID(pRuntimeEnv)); pBlock->info.rows = numOfResult; return 0; } -static void toSDatablock(SGroupResInfo *pGroupResInfo, SDiskbasedBuf* pBuf, SSDataBlock* pBlock, int32_t rowCapacity, int32_t* rowCellOffset) { +static void toSDatablock(SGroupResInfo* pGroupResInfo, SDiskbasedBuf* pBuf, SSDataBlock* pBlock, int32_t rowCapacity, + int32_t* rowCellOffset) { assert(pGroupResInfo->currentGroup <= pGroupResInfo->totalGroup); blockDataCleanup(pBlock); @@ -3927,22 +4032,23 @@ static void toSDatablock(SGroupResInfo *pGroupResInfo, SDiskbasedBuf* pBuf, SSDa return; } - int32_t orderType = TSDB_ORDER_ASC;//(pQueryAttr->pGroupbyExpr != NULL) ? pQueryAttr->pGroupbyExpr->orderType : TSDB_ORDER_ASC; + int32_t orderType = + TSDB_ORDER_ASC; //(pQueryAttr->pGroupbyExpr != NULL) ? pQueryAttr->pGroupbyExpr->orderType : TSDB_ORDER_ASC; doCopyToSDataBlock(pBuf, pGroupResInfo, orderType, pBlock, rowCapacity, rowCellOffset); // add condition (pBlock->info.rows >= 1) just to runtime happy blockDataUpdateTsWindow(pBlock); } -static void updateNumOfRowsInResultRows(SqlFunctionCtx* pCtx, int32_t numOfOutput, - SResultRowInfo* pResultRowInfo, int32_t* rowCellInfoOffset) { +static void updateNumOfRowsInResultRows(SqlFunctionCtx* pCtx, int32_t numOfOutput, SResultRowInfo* pResultRowInfo, + int32_t* rowCellInfoOffset) { // update the number of result for each, only update the number of rows for the corresponding window result. -// if (QUERY_IS_INTERVAL_QUERY(pQueryAttr)) { -// return; -// } + // if (QUERY_IS_INTERVAL_QUERY(pQueryAttr)) { + // return; + // } for (int32_t i = 0; i < pResultRowInfo->size; ++i) { - SResultRow *pResult = pResultRowInfo->pResult[i]; + SResultRow* pResult = pResultRowInfo->pResult[i]; for (int32_t j = 0; j < numOfOutput; ++j) { int32_t functionId = pCtx[j].functionId; @@ -3956,17 +4062,17 @@ static void updateNumOfRowsInResultRows(SqlFunctionCtx* pCtx, int32_t numOfOutpu } } -static int32_t compressQueryColData(SColumnInfoData *pColRes, int32_t numOfRows, char *data, int8_t compressed) { +static int32_t compressQueryColData(SColumnInfoData* pColRes, int32_t numOfRows, char* data, int8_t compressed) { int32_t colSize = pColRes->info.bytes * numOfRows; return (*(tDataTypes[pColRes->info.type].compFunc))(pColRes->pData, colSize, numOfRows, data, - colSize + COMP_OVERFLOW_BYTES, compressed, NULL, 0); + colSize + COMP_OVERFLOW_BYTES, compressed, NULL, 0); } -int32_t doFillTimeIntervalGapsInResults(struct SFillInfo* pFillInfo, SSDataBlock *pOutput, int32_t capacity, void** p) { -// for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) { -// SColumnInfoData* pColInfoData = taosArrayGet(pOutput->pDataBlock, i); -// p[i] = pColInfoData->pData + (pColInfoData->info.bytes * pOutput->info.rows); -// } +int32_t doFillTimeIntervalGapsInResults(struct SFillInfo* pFillInfo, SSDataBlock* pOutput, int32_t capacity, void** p) { + // for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) { + // SColumnInfoData* pColInfoData = taosArrayGet(pOutput->pDataBlock, i); + // p[i] = pColInfoData->pData + (pColInfoData->info.bytes * pOutput->info.rows); + // } int32_t numOfRows = (int32_t)taosFillResultDataBlock(pFillInfo, p, capacity - pOutput->info.rows); pOutput->info.rows += numOfRows; @@ -3977,19 +4083,19 @@ int32_t doFillTimeIntervalGapsInResults(struct SFillInfo* pFillInfo, SSDataBlock void publishOperatorProfEvent(SOperatorInfo* operatorInfo, EQueryProfEventType eventType) { SQueryProfEvent event = {0}; - event.eventType = eventType; - event.eventTime = taosGetTimestampUs(); + event.eventType = eventType; + event.eventTime = taosGetTimestampUs(); event.operatorType = operatorInfo->operatorType; if (operatorInfo->pRuntimeEnv) { -// SQInfo* pQInfo = operatorInfo->pRuntimeEnv->qinfo; -// if (pQInfo->summary.queryProfEvents) { -// taosArrayPush(pQInfo->summary.queryProfEvents, &event); -// } + // SQInfo* pQInfo = operatorInfo->pRuntimeEnv->qinfo; + // if (pQInfo->summary.queryProfEvents) { + // taosArrayPush(pQInfo->summary.queryProfEvents, &event); + // } } } -void publishQueryAbortEvent(SExecTaskInfo * pTaskInfo, int32_t code) { +void publishQueryAbortEvent(SExecTaskInfo* pTaskInfo, int32_t code) { SQueryProfEvent event; event.eventType = QUERY_PROF_QUERY_ABORT; event.eventTime = taosGetTimestampUs(); @@ -4000,7 +4106,7 @@ void publishQueryAbortEvent(SExecTaskInfo * pTaskInfo, int32_t code) { } } -typedef struct { +typedef struct { uint8_t operatorType; int64_t beginTime; int64_t endTime; @@ -4008,7 +4114,8 @@ typedef struct { int64_t descendantsTime; } SOperatorStackItem; -static void doOperatorExecProfOnce(SOperatorStackItem* item, SQueryProfEvent* event, SArray* opStack, SHashObj* profResults) { +static void doOperatorExecProfOnce(SOperatorStackItem* item, SQueryProfEvent* event, SArray* opStack, + SHashObj* profResults) { item->endTime = event->eventTime; item->selfTime = (item->endTime - item->beginTime) - (item->descendantsTime); @@ -4017,7 +4124,7 @@ static void doOperatorExecProfOnce(SOperatorStackItem* item, SQueryProfEvent* ev ancestor->descendantsTime += item->selfTime; } - uint8_t operatorType = item->operatorType; + uint8_t operatorType = item->operatorType; SOperatorProfResult* result = taosHashGet(profResults, &operatorType, sizeof(operatorType)); if (result != NULL) { result->sumRunTimes++; @@ -4027,19 +4134,18 @@ static void doOperatorExecProfOnce(SOperatorStackItem* item, SQueryProfEvent* ev opResult.operatorType = operatorType; opResult.sumSelfTime = item->selfTime; opResult.sumRunTimes = 1; - taosHashPut(profResults, &(operatorType), sizeof(operatorType), - &opResult, sizeof(opResult)); + taosHashPut(profResults, &(operatorType), sizeof(operatorType), &opResult, sizeof(opResult)); } } void calculateOperatorProfResults(SQInfo* pQInfo) { if (pQInfo->summary.queryProfEvents == NULL) { - //qDebug("QInfo:0x%"PRIx64" query prof events array is null", pQInfo->qId); + // qDebug("QInfo:0x%"PRIx64" query prof events array is null", pQInfo->qId); return; } if (pQInfo->summary.operatorProfResults == NULL) { - //qDebug("QInfo:0x%"PRIx64" operator prof results hash is null", pQInfo->qId); + // qDebug("QInfo:0x%"PRIx64" operator prof results hash is null", pQInfo->qId); return; } @@ -4048,7 +4154,7 @@ void calculateOperatorProfResults(SQInfo* pQInfo) { return; } - size_t size = taosArrayGetSize(pQInfo->summary.queryProfEvents); + size_t size = taosArrayGetSize(pQInfo->summary.queryProfEvents); SHashObj* profResults = pQInfo->summary.operatorProfResults; for (int i = 0; i < size; ++i) { @@ -4074,280 +4180,287 @@ void calculateOperatorProfResults(SQInfo* pQInfo) { taosArrayDestroy(opStack); } -void queryCostStatis(SExecTaskInfo *pTaskInfo) { - STaskCostInfo *pSummary = &pTaskInfo->cost; +void queryCostStatis(SExecTaskInfo* pTaskInfo) { + STaskCostInfo* pSummary = &pTaskInfo->cost; -// uint64_t hashSize = taosHashGetMemSize(pQInfo->runtimeEnv.pResultRowHashTable); -// hashSize += taosHashGetMemSize(pRuntimeEnv->tableqinfoGroupInfo.map); -// pSummary->hashSize = hashSize; + // uint64_t hashSize = taosHashGetMemSize(pQInfo->runtimeEnv.pResultRowHashTable); + // hashSize += taosHashGetMemSize(pRuntimeEnv->tableqinfoGroupInfo.map); + // pSummary->hashSize = hashSize; // add the merge time pSummary->elapsedTime += pSummary->firstStageMergeTime; -// SResultRowPool* p = pTaskInfo->pool; -// if (p != NULL) { -// pSummary->winInfoSize = getResultRowPoolMemSize(p); -// pSummary->numOfTimeWindows = getNumOfAllocatedResultRows(p); -// } else { -// pSummary->winInfoSize = 0; -// pSummary->numOfTimeWindows = 0; -// } -// -// calculateOperatorProfResults(pQInfo); + // SResultRowPool* p = pTaskInfo->pool; + // if (p != NULL) { + // pSummary->winInfoSize = getResultRowPoolMemSize(p); + // pSummary->numOfTimeWindows = getNumOfAllocatedResultRows(p); + // } else { + // pSummary->winInfoSize = 0; + // pSummary->numOfTimeWindows = 0; + // } + // + // calculateOperatorProfResults(pQInfo); - qDebug("%s :cost summary: elapsed time:%"PRId64" us, first merge:%"PRId64" us, total blocks:%d, " - "load block statis:%d, load data block:%d, total rows:%"PRId64 ", check rows:%"PRId64, - GET_TASKID(pTaskInfo), pSummary->elapsedTime, pSummary->firstStageMergeTime, pSummary->totalBlocks, pSummary->loadBlockStatis, - pSummary->loadBlocks, pSummary->totalRows, pSummary->totalCheckedRows); -// - //qDebug("QInfo:0x%"PRIx64" :cost summary: winResPool size:%.2f Kb, numOfWin:%"PRId64", tableInfoSize:%.2f Kb, hashTable:%.2f Kb", pQInfo->qId, pSummary->winInfoSize/1024.0, -// pSummary->numOfTimeWindows, pSummary->tableInfoSize/1024.0, pSummary->hashSize/1024.0); + qDebug("%s :cost summary: elapsed time:%" PRId64 " us, first merge:%" PRId64 + " us, total blocks:%d, " + "load block statis:%d, load data block:%d, total rows:%" PRId64 ", check rows:%" PRId64, + GET_TASKID(pTaskInfo), pSummary->elapsedTime, pSummary->firstStageMergeTime, pSummary->totalBlocks, + pSummary->loadBlockStatis, pSummary->loadBlocks, pSummary->totalRows, pSummary->totalCheckedRows); + // + // qDebug("QInfo:0x%"PRIx64" :cost summary: winResPool size:%.2f Kb, numOfWin:%"PRId64", tableInfoSize:%.2f Kb, + // hashTable:%.2f Kb", pQInfo->qId, pSummary->winInfoSize/1024.0, + // pSummary->numOfTimeWindows, pSummary->tableInfoSize/1024.0, pSummary->hashSize/1024.0); if (pSummary->operatorProfResults) { SOperatorProfResult* opRes = taosHashIterate(pSummary->operatorProfResults, NULL); while (opRes != NULL) { - //qDebug("QInfo:0x%" PRIx64 " :cost summary: operator : %d, exec times: %" PRId64 ", self time: %" PRId64, -// pQInfo->qId, opRes->operatorType, opRes->sumRunTimes, opRes->sumSelfTime); + // qDebug("QInfo:0x%" PRIx64 " :cost summary: operator : %d, exec times: %" PRId64 ", self time: %" PRId64, + // pQInfo->qId, opRes->operatorType, opRes->sumRunTimes, opRes->sumSelfTime); opRes = taosHashIterate(pSummary->operatorProfResults, opRes); } } } -//static void updateOffsetVal(STaskRuntimeEnv *pRuntimeEnv, SDataBlockInfo *pBlockInfo) { -// STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; -// STableQueryInfo* pTableQueryInfo = pRuntimeEnv->current; +// static void updateOffsetVal(STaskRuntimeEnv *pRuntimeEnv, SDataBlockInfo *pBlockInfo) { +// STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; +// STableQueryInfo* pTableQueryInfo = pRuntimeEnv->current; // -// int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQueryAttr->order.order); +// int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQueryAttr->order.order); // -// if (pQueryAttr->limit.offset == pBlockInfo->rows) { // current block will ignore completed -// pTableQueryInfo->lastKey = QUERY_IS_ASC_QUERY(pQueryAttr) ? pBlockInfo->window.ekey + step : pBlockInfo->window.skey + step; -// pQueryAttr->limit.offset = 0; -// return; -// } +// if (pQueryAttr->limit.offset == pBlockInfo->rows) { // current block will ignore completed +// pTableQueryInfo->lastKey = QUERY_IS_ASC_QUERY(pQueryAttr) ? pBlockInfo->window.ekey + step : +// pBlockInfo->window.skey + step; pQueryAttr->limit.offset = 0; return; +// } // -// if (QUERY_IS_ASC_QUERY(pQueryAttr)) { -// pQueryAttr->pos = (int32_t)pQueryAttr->limit.offset; -// } else { -// pQueryAttr->pos = pBlockInfo->rows - (int32_t)pQueryAttr->limit.offset - 1; -// } +// if (QUERY_IS_ASC_QUERY(pQueryAttr)) { +// pQueryAttr->pos = (int32_t)pQueryAttr->limit.offset; +// } else { +// pQueryAttr->pos = pBlockInfo->rows - (int32_t)pQueryAttr->limit.offset - 1; +// } // -// assert(pQueryAttr->pos >= 0 && pQueryAttr->pos <= pBlockInfo->rows - 1); +// assert(pQueryAttr->pos >= 0 && pQueryAttr->pos <= pBlockInfo->rows - 1); // -// SArray * pDataBlock = tsdbRetrieveDataBlock(pRuntimeEnv->pTsdbReadHandle, NULL); -// SColumnInfoData *pColInfoData = taosArrayGet(pDataBlock, 0); +// SArray * pDataBlock = tsdbRetrieveDataBlock(pRuntimeEnv->pTsdbReadHandle, NULL); +// SColumnInfoData *pColInfoData = taosArrayGet(pDataBlock, 0); // -// // update the pQueryAttr->limit.offset value, and pQueryAttr->pos value -// TSKEY *keys = (TSKEY *) pColInfoData->pData; +// // update the pQueryAttr->limit.offset value, and pQueryAttr->pos value +// TSKEY *keys = (TSKEY *) pColInfoData->pData; // -// // update the offset value -// pTableQueryInfo->lastKey = keys[pQueryAttr->pos]; -// pQueryAttr->limit.offset = 0; +// // update the offset value +// pTableQueryInfo->lastKey = keys[pQueryAttr->pos]; +// pQueryAttr->limit.offset = 0; // -// int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, pBlockInfo, NULL, binarySearchForKey, pDataBlock); +// int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, pBlockInfo, NULL, binarySearchForKey, pDataBlock); // -// //qDebug("QInfo:0x%"PRIx64" check data block, brange:%" PRId64 "-%" PRId64 ", numBlocksOfStep:%d, numOfRes:%d, lastKey:%"PRId64, GET_TASKID(pRuntimeEnv), -// pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, numOfRes, pQuery->current->lastKey); -//} +// //qDebug("QInfo:0x%"PRIx64" check data block, brange:%" PRId64 "-%" PRId64 ", numBlocksOfStep:%d, numOfRes:%d, +// lastKey:%"PRId64, GET_TASKID(pRuntimeEnv), +// pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, numOfRes, pQuery->current->lastKey); +// } -//void skipBlocks(STaskRuntimeEnv *pRuntimeEnv) { -// STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; +// void skipBlocks(STaskRuntimeEnv *pRuntimeEnv) { +// STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; // -// if (pQueryAttr->limit.offset <= 0 || pQueryAttr->numOfFilterCols > 0) { -// return; -// } +// if (pQueryAttr->limit.offset <= 0 || pQueryAttr->numOfFilterCols > 0) { +// return; +// } // -// pQueryAttr->pos = 0; -// int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQueryAttr->order.order); +// pQueryAttr->pos = 0; +// int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQueryAttr->order.order); // -// STableQueryInfo* pTableQueryInfo = pRuntimeEnv->current; -// TsdbQueryHandleT pTsdbReadHandle = pRuntimeEnv->pTsdbReadHandle; +// STableQueryInfo* pTableQueryInfo = pRuntimeEnv->current; +// TsdbQueryHandleT pTsdbReadHandle = pRuntimeEnv->pTsdbReadHandle; // -// SDataBlockInfo blockInfo = SDATA_BLOCK_INITIALIZER; -// while (tsdbNextDataBlock(pTsdbReadHandle)) { -// if (isTaskKilled(pRuntimeEnv->qinfo)) { -// longjmp(pRuntimeEnv->env, TSDB_CODE_TSC_QUERY_CANCELLED); -// } +// SDataBlockInfo blockInfo = SDATA_BLOCK_INITIALIZER; +// while (tsdbNextDataBlock(pTsdbReadHandle)) { +// if (isTaskKilled(pRuntimeEnv->qinfo)) { +// longjmp(pRuntimeEnv->env, TSDB_CODE_TSC_QUERY_CANCELLED); +// } // -// tsdbRetrieveDataBlockInfo(pTsdbReadHandle, &blockInfo); +// tsdbRetrieveDataBlockInfo(pTsdbReadHandle, &blockInfo); // -// if (pQueryAttr->limit.offset > blockInfo.rows) { -// pQueryAttr->limit.offset -= blockInfo.rows; -// pTableQueryInfo->lastKey = (QUERY_IS_ASC_QUERY(pQueryAttr)) ? blockInfo.window.ekey : blockInfo.window.skey; -// pTableQueryInfo->lastKey += step; +// if (pQueryAttr->limit.offset > blockInfo.rows) { +// pQueryAttr->limit.offset -= blockInfo.rows; +// pTableQueryInfo->lastKey = (QUERY_IS_ASC_QUERY(pQueryAttr)) ? blockInfo.window.ekey : blockInfo.window.skey; +// pTableQueryInfo->lastKey += step; // -// //qDebug("QInfo:0x%"PRIx64" skip rows:%d, offset:%" PRId64, GET_TASKID(pRuntimeEnv), blockInfo.rows, -// pQuery->limit.offset); -// } else { // find the appropriated start position in current block -// updateOffsetVal(pRuntimeEnv, &blockInfo); -// break; -// } -// } +// //qDebug("QInfo:0x%"PRIx64" skip rows:%d, offset:%" PRId64, GET_TASKID(pRuntimeEnv), blockInfo.rows, +// pQuery->limit.offset); +// } else { // find the appropriated start position in current block +// updateOffsetVal(pRuntimeEnv, &blockInfo); +// break; +// } +// } // -// if (terrno != TSDB_CODE_SUCCESS) { -// longjmp(pRuntimeEnv->env, terrno); -// } -//} +// if (terrno != TSDB_CODE_SUCCESS) { +// longjmp(pRuntimeEnv->env, terrno); +// } +// } -//static TSKEY doSkipIntervalProcess(STaskRuntimeEnv* pRuntimeEnv, STimeWindow* win, SDataBlockInfo* pBlockInfo, STableQueryInfo* pTableQueryInfo) { -// STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; -// SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo; +// static TSKEY doSkipIntervalProcess(STaskRuntimeEnv* pRuntimeEnv, STimeWindow* win, SDataBlockInfo* pBlockInfo, +// STableQueryInfo* pTableQueryInfo) { +// STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; +// SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo; // -// assert(pQueryAttr->limit.offset == 0); -// STimeWindow tw = *win; -// getNextTimeWindow(pQueryAttr, &tw); +// assert(pQueryAttr->limit.offset == 0); +// STimeWindow tw = *win; +// getNextTimeWindow(pQueryAttr, &tw); // -// if ((tw.skey <= pBlockInfo->window.ekey && QUERY_IS_ASC_QUERY(pQueryAttr)) || -// (tw.ekey >= pBlockInfo->window.skey && !QUERY_IS_ASC_QUERY(pQueryAttr))) { +// if ((tw.skey <= pBlockInfo->window.ekey && QUERY_IS_ASC_QUERY(pQueryAttr)) || +// (tw.ekey >= pBlockInfo->window.skey && !QUERY_IS_ASC_QUERY(pQueryAttr))) { // -// // load the data block and check data remaining in current data block -// // TODO optimize performance -// SArray * pDataBlock = tsdbRetrieveDataBlock(pRuntimeEnv->pTsdbReadHandle, NULL); -// SColumnInfoData *pColInfoData = taosArrayGet(pDataBlock, 0); +// // load the data block and check data remaining in current data block +// // TODO optimize performance +// SArray * pDataBlock = tsdbRetrieveDataBlock(pRuntimeEnv->pTsdbReadHandle, NULL); +// SColumnInfoData *pColInfoData = taosArrayGet(pDataBlock, 0); // -// tw = *win; -// int32_t startPos = -// getNextQualifiedWindow(pQueryAttr, &tw, pBlockInfo, pColInfoData->pData, binarySearchForKey, -1); -// assert(startPos >= 0); +// tw = *win; +// int32_t startPos = +// getNextQualifiedWindow(pQueryAttr, &tw, pBlockInfo, pColInfoData->pData, binarySearchForKey, -1); +// assert(startPos >= 0); // -// // set the abort info -// pQueryAttr->pos = startPos; +// // set the abort info +// pQueryAttr->pos = startPos; // -// // reset the query start timestamp -// pTableQueryInfo->win.skey = ((TSKEY *)pColInfoData->pData)[startPos]; -// pQueryAttr->window.skey = pTableQueryInfo->win.skey; -// TSKEY key = pTableQueryInfo->win.skey; +// // reset the query start timestamp +// pTableQueryInfo->win.skey = ((TSKEY *)pColInfoData->pData)[startPos]; +// pQueryAttr->window.skey = pTableQueryInfo->win.skey; +// TSKEY key = pTableQueryInfo->win.skey; // -// pWindowResInfo->prevSKey = tw.skey; -// int32_t index = pRuntimeEnv->resultRowInfo.curIndex; +// pWindowResInfo->prevSKey = tw.skey; +// int32_t index = pRuntimeEnv->resultRowInfo.curIndex; // -// int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, pBlockInfo, NULL, binarySearchForKey, pDataBlock); -// pRuntimeEnv->resultRowInfo.curIndex = index; // restore the window index +// int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, pBlockInfo, NULL, binarySearchForKey, pDataBlock); +// pRuntimeEnv->resultRowInfo.curIndex = index; // restore the window index // -// //qDebug("QInfo:0x%"PRIx64" check data block, brange:%" PRId64 "-%" PRId64 ", numOfRows:%d, numOfRes:%d, lastKey:%" PRId64, -// GET_TASKID(pRuntimeEnv), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, numOfRes, -// pQueryAttr->current->lastKey); +// //qDebug("QInfo:0x%"PRIx64" check data block, brange:%" PRId64 "-%" PRId64 ", numOfRows:%d, numOfRes:%d, +// lastKey:%" PRId64, +// GET_TASKID(pRuntimeEnv), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, numOfRes, +// pQueryAttr->current->lastKey); // -// return key; -// } else { // do nothing -// pQueryAttr->window.skey = tw.skey; -// pWindowResInfo->prevSKey = tw.skey; -// pTableQueryInfo->lastKey = tw.skey; +// return key; +// } else { // do nothing +// pQueryAttr->window.skey = tw.skey; +// pWindowResInfo->prevSKey = tw.skey; +// pTableQueryInfo->lastKey = tw.skey; // -// return tw.skey; -// } +// return tw.skey; +// } // -// return true; -//} +// return true; +// } -//static bool skipTimeInterval(STaskRuntimeEnv *pRuntimeEnv, TSKEY* start) { -// STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; -// if (QUERY_IS_ASC_QUERY(pQueryAttr)) { -// assert(*start <= pRuntimeEnv->current->lastKey); -// } else { -// assert(*start >= pRuntimeEnv->current->lastKey); -// } +// static bool skipTimeInterval(STaskRuntimeEnv *pRuntimeEnv, TSKEY* start) { +// STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; +// if (QUERY_IS_ASC_QUERY(pQueryAttr)) { +// assert(*start <= pRuntimeEnv->current->lastKey); +// } else { +// assert(*start >= pRuntimeEnv->current->lastKey); +// } // -// // if queried with value filter, do NOT forward query start position -// if (pQueryAttr->limit.offset <= 0 || pQueryAttr->numOfFilterCols > 0 || pRuntimeEnv->pTsBuf != NULL || pRuntimeEnv->pFillInfo != NULL) { -// return true; -// } +// // if queried with value filter, do NOT forward query start position +// if (pQueryAttr->limit.offset <= 0 || pQueryAttr->numOfFilterCols > 0 || pRuntimeEnv->pTsBuf != NULL || +// pRuntimeEnv->pFillInfo != NULL) { +// return true; +// } // -// /* -// * 1. for interval without interpolation query we forward pQueryAttr->interval.interval at a time for -// * pQueryAttr->limit.offset times. Since hole exists, pQueryAttr->interval.interval*pQueryAttr->limit.offset value is -// * not valid. otherwise, we only forward pQueryAttr->limit.offset number of points -// */ -// assert(pRuntimeEnv->resultRowInfo.prevSKey == TSKEY_INITIAL_VAL); +// /* +// * 1. for interval without interpolation query we forward pQueryAttr->interval.interval at a time for +// * pQueryAttr->limit.offset times. Since hole exists, pQueryAttr->interval.interval*pQueryAttr->limit.offset +// value is +// * not valid. otherwise, we only forward pQueryAttr->limit.offset number of points +// */ +// assert(pRuntimeEnv->resultRowInfo.prevSKey == TSKEY_INITIAL_VAL); // -// STimeWindow w = TSWINDOW_INITIALIZER; -// bool ascQuery = QUERY_IS_ASC_QUERY(pQueryAttr); +// STimeWindow w = TSWINDOW_INITIALIZER; +// bool ascQuery = QUERY_IS_ASC_QUERY(pQueryAttr); // -// SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo; -// STableQueryInfo *pTableQueryInfo = pRuntimeEnv->current; +// SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo; +// STableQueryInfo *pTableQueryInfo = pRuntimeEnv->current; // -// SDataBlockInfo blockInfo = SDATA_BLOCK_INITIALIZER; -// while (tsdbNextDataBlock(pRuntimeEnv->pTsdbReadHandle)) { -// tsdbRetrieveDataBlockInfo(pRuntimeEnv->pTsdbReadHandle, &blockInfo); +// SDataBlockInfo blockInfo = SDATA_BLOCK_INITIALIZER; +// while (tsdbNextDataBlock(pRuntimeEnv->pTsdbReadHandle)) { +// tsdbRetrieveDataBlockInfo(pRuntimeEnv->pTsdbReadHandle, &blockInfo); // -// if (QUERY_IS_ASC_QUERY(pQueryAttr)) { -// if (pWindowResInfo->prevSKey == TSKEY_INITIAL_VAL) { -// getAlignQueryTimeWindow(pQueryAttr, blockInfo.window.skey, blockInfo.window.skey, pQueryAttr->window.ekey, &w); -// pWindowResInfo->prevSKey = w.skey; -// } -// } else { -// getAlignQueryTimeWindow(pQueryAttr, blockInfo.window.ekey, pQueryAttr->window.ekey, blockInfo.window.ekey, &w); -// pWindowResInfo->prevSKey = w.skey; -// } +// if (QUERY_IS_ASC_QUERY(pQueryAttr)) { +// if (pWindowResInfo->prevSKey == TSKEY_INITIAL_VAL) { +// getAlignQueryTimeWindow(pQueryAttr, blockInfo.window.skey, blockInfo.window.skey, pQueryAttr->window.ekey, +// &w); pWindowResInfo->prevSKey = w.skey; +// } +// } else { +// getAlignQueryTimeWindow(pQueryAttr, blockInfo.window.ekey, pQueryAttr->window.ekey, blockInfo.window.ekey, &w); +// pWindowResInfo->prevSKey = w.skey; +// } // -// // the first time window -// STimeWindow win = getActiveTimeWindow(pWindowResInfo, pWindowResInfo->prevSKey, pQueryAttr); +// // the first time window +// STimeWindow win = getActiveTimeWindow(pWindowResInfo, pWindowResInfo->prevSKey, pQueryAttr); // -// while (pQueryAttr->limit.offset > 0) { -// STimeWindow tw = win; +// while (pQueryAttr->limit.offset > 0) { +// STimeWindow tw = win; // -// if ((win.ekey <= blockInfo.window.ekey && ascQuery) || (win.ekey >= blockInfo.window.skey && !ascQuery)) { -// pQueryAttr->limit.offset -= 1; -// pWindowResInfo->prevSKey = win.skey; +// if ((win.ekey <= blockInfo.window.ekey && ascQuery) || (win.ekey >= blockInfo.window.skey && !ascQuery)) { +// pQueryAttr->limit.offset -= 1; +// pWindowResInfo->prevSKey = win.skey; // -// // current time window is aligned with blockInfo.window.ekey -// // restart it from next data block by set prevSKey to be TSKEY_INITIAL_VAL; -// if ((win.ekey == blockInfo.window.ekey && ascQuery) || (win.ekey == blockInfo.window.skey && !ascQuery)) { -// pWindowResInfo->prevSKey = TSKEY_INITIAL_VAL; -// } -// } +// // current time window is aligned with blockInfo.window.ekey +// // restart it from next data block by set prevSKey to be TSKEY_INITIAL_VAL; +// if ((win.ekey == blockInfo.window.ekey && ascQuery) || (win.ekey == blockInfo.window.skey && !ascQuery)) { +// pWindowResInfo->prevSKey = TSKEY_INITIAL_VAL; +// } +// } // -// if (pQueryAttr->limit.offset == 0) { -// *start = doSkipIntervalProcess(pRuntimeEnv, &win, &blockInfo, pTableQueryInfo); -// return true; -// } +// if (pQueryAttr->limit.offset == 0) { +// *start = doSkipIntervalProcess(pRuntimeEnv, &win, &blockInfo, pTableQueryInfo); +// return true; +// } // -// // current window does not ended in current data block, try next data block -// getNextTimeWindow(pQueryAttr, &tw); +// // current window does not ended in current data block, try next data block +// getNextTimeWindow(pQueryAttr, &tw); // -// /* -// * If the next time window still starts from current data block, -// * load the primary timestamp column first, and then find the start position for the next queried time window. -// * Note that only the primary timestamp column is required. -// * TODO: Optimize for this cases. All data blocks are not needed to be loaded, only if the first actually required -// * time window resides in current data block. -// */ -// if ((tw.skey <= blockInfo.window.ekey && ascQuery) || (tw.ekey >= blockInfo.window.skey && !ascQuery)) { +// /* +// * If the next time window still starts from current data block, +// * load the primary timestamp column first, and then find the start position for the next queried time window. +// * Note that only the primary timestamp column is required. +// * TODO: Optimize for this cases. All data blocks are not needed to be loaded, only if the first actually +// required +// * time window resides in current data block. +// */ +// if ((tw.skey <= blockInfo.window.ekey && ascQuery) || (tw.ekey >= blockInfo.window.skey && !ascQuery)) { // -// SArray *pDataBlock = tsdbRetrieveDataBlock(pRuntimeEnv->pTsdbReadHandle, NULL); -// SColumnInfoData *pColInfoData = taosArrayGet(pDataBlock, 0); +// SArray *pDataBlock = tsdbRetrieveDataBlock(pRuntimeEnv->pTsdbReadHandle, NULL); +// SColumnInfoData *pColInfoData = taosArrayGet(pDataBlock, 0); // -// if ((win.ekey > blockInfo.window.ekey && ascQuery) || (win.ekey < blockInfo.window.skey && !ascQuery)) { -// pQueryAttr->limit.offset -= 1; -// } +// if ((win.ekey > blockInfo.window.ekey && ascQuery) || (win.ekey < blockInfo.window.skey && !ascQuery)) { +// pQueryAttr->limit.offset -= 1; +// } // -// if (pQueryAttr->limit.offset == 0) { -// *start = doSkipIntervalProcess(pRuntimeEnv, &win, &blockInfo, pTableQueryInfo); -// return true; -// } else { -// tw = win; -// int32_t startPos = -// getNextQualifiedWindow(pQueryAttr, &tw, &blockInfo, pColInfoData->pData, binarySearchForKey, -1); -// assert(startPos >= 0); +// if (pQueryAttr->limit.offset == 0) { +// *start = doSkipIntervalProcess(pRuntimeEnv, &win, &blockInfo, pTableQueryInfo); +// return true; +// } else { +// tw = win; +// int32_t startPos = +// getNextQualifiedWindow(pQueryAttr, &tw, &blockInfo, pColInfoData->pData, binarySearchForKey, -1); +// assert(startPos >= 0); // -// // set the abort info -// pQueryAttr->pos = startPos; -// pTableQueryInfo->lastKey = ((TSKEY *)pColInfoData->pData)[startPos]; -// pWindowResInfo->prevSKey = tw.skey; -// win = tw; -// } -// } else { -// break; // offset is not 0, and next time window begins or ends in the next block. -// } -// } -// } +// // set the abort info +// pQueryAttr->pos = startPos; +// pTableQueryInfo->lastKey = ((TSKEY *)pColInfoData->pData)[startPos]; +// pWindowResInfo->prevSKey = tw.skey; +// win = tw; +// } +// } else { +// break; // offset is not 0, and next time window begins or ends in the next block. +// } +// } +// } // -// // check for error -// if (terrno != TSDB_CODE_SUCCESS) { -// longjmp(pRuntimeEnv->env, terrno); -// } +// // check for error +// if (terrno != TSDB_CODE_SUCCESS) { +// longjmp(pRuntimeEnv->env, terrno); +// } // -// return true; -//} +// return true; +// } int32_t appendDownstream(SOperatorInfo* p, SOperatorInfo** pDownstream, int32_t num) { if (p->pDownstream == NULL) { @@ -4367,7 +4480,7 @@ int32_t appendDownstream(SOperatorInfo* p, SOperatorInfo** pDownstream, int32_t static void doDestroyTableQueryInfo(STableGroupInfo* pTableqinfoGroupInfo); static int32_t setupQueryHandle(void* tsdb, STaskRuntimeEnv* pRuntimeEnv, int64_t qId, bool isSTableQuery) { - STaskAttr *pQueryAttr = pRuntimeEnv->pQueryAttr; + STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; #if 0 // TODO set the tags scan handle if (onlyQueryTags(pQueryAttr)) { @@ -4425,10 +4538,10 @@ static int32_t setupQueryHandle(void* tsdb, STaskRuntimeEnv* pRuntimeEnv, int64_ } int32_t doInitQInfo(SQInfo* pQInfo, STSBuf* pTsBuf, void* tsdb, void* sourceOptr, int32_t tbScanner, SArray* pOperator, - void* param) { - STaskRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv; + void* param) { + STaskRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv; - STaskAttr *pQueryAttr = pQInfo->runtimeEnv.pQueryAttr; + STaskAttr* pQueryAttr = pQInfo->runtimeEnv.pQueryAttr; pQueryAttr->tsdb = tsdb; if (tsdb != NULL) { @@ -4440,7 +4553,7 @@ int32_t doInitQInfo(SQInfo* pQInfo, STSBuf* pTsBuf, void* tsdb, void* sourceOptr pQueryAttr->interBufSize = getOutputInterResultBufSize(pQueryAttr); - pRuntimeEnv->groupResInfo.totalGroup = (int32_t) (pQueryAttr->stableQuery? GET_NUM_OF_TABLEGROUP(pRuntimeEnv):0); + pRuntimeEnv->groupResInfo.totalGroup = (int32_t)(pQueryAttr->stableQuery ? GET_NUM_OF_TABLEGROUP(pRuntimeEnv) : 0); pRuntimeEnv->enableGroupData = false; pRuntimeEnv->pQueryAttr = pQueryAttr; @@ -4461,7 +4574,7 @@ int32_t doInitQInfo(SQInfo* pQInfo, STSBuf* pTsBuf, void* tsdb, void* sourceOptr int32_t ps = 4096; getIntermediateBufInfo(pRuntimeEnv, &ps, &pQueryAttr->intermediateResultRowSize); - int32_t TENMB = 1024*1024*10; + int32_t TENMB = 1024 * 1024 * 10; int32_t code = createDiskbasedBuf(&pRuntimeEnv->pResultBuf, ps, TENMB, "", "/tmp"); if (code != TSDB_CODE_SUCCESS) { return code; @@ -4472,22 +4585,22 @@ int32_t doInitQInfo(SQInfo* pQInfo, STSBuf* pTsBuf, void* tsdb, void* sourceOptr pQInfo->summary.tableInfoSize += (numOfTables * sizeof(STableQueryInfo)); pQInfo->summary.queryProfEvents = taosArrayInit(512, sizeof(SQueryProfEvent)); if (pQInfo->summary.queryProfEvents == NULL) { - //qDebug("QInfo:0x%"PRIx64" failed to allocate query prof events array", pQInfo->qId); + // qDebug("QInfo:0x%"PRIx64" failed to allocate query prof events array", pQInfo->qId); } pQInfo->summary.operatorProfResults = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_TINYINT), true, HASH_NO_LOCK); if (pQInfo->summary.operatorProfResults == NULL) { - //qDebug("QInfo:0x%"PRIx64" failed to allocate operator prof results hash", pQInfo->qId); + // qDebug("QInfo:0x%"PRIx64" failed to allocate operator prof results hash", pQInfo->qId); } - code = setupQueryRuntimeEnv(pRuntimeEnv, (int32_t) pQueryAttr->tableGroupInfo.numOfTables, pOperator, param); + code = setupQueryRuntimeEnv(pRuntimeEnv, (int32_t)pQueryAttr->tableGroupInfo.numOfTables, pOperator, param); if (code != TSDB_CODE_SUCCESS) { return code; } -// setTaskStatus(pOperator->pTaskInfo, QUERY_NOT_COMPLETED); + // setTaskStatus(pOperator->pTaskInfo, QUERY_NOT_COMPLETED); return TSDB_CODE_SUCCESS; } @@ -4505,50 +4618,50 @@ static void doTableQueryInfoTimeWindowCheck(SExecTaskInfo* pTaskInfo, STableQuer (pTableQueryInfo->win.skey <= pTaskInfo->window.skey && pTableQueryInfo->win.ekey >= pTaskInfo->window.ekey)); } #endif - } -//STsdbQueryCond createTsdbQueryCond(STaskAttr* pQueryAttr, STimeWindow* win) { -// STsdbQueryCond cond = { -// .colList = pQueryAttr->tableCols, -// .order = pQueryAttr->order.order, -// .numOfCols = pQueryAttr->numOfCols, -// .type = BLOCK_LOAD_OFFSET_SEQ_ORDER, -// .loadExternalRows = false, -// }; +// STsdbQueryCond createTsdbQueryCond(STaskAttr* pQueryAttr, STimeWindow* win) { +// STsdbQueryCond cond = { +// .colList = pQueryAttr->tableCols, +// .order = pQueryAttr->order.order, +// .numOfCols = pQueryAttr->numOfCols, +// .type = BLOCK_LOAD_OFFSET_SEQ_ORDER, +// .loadExternalRows = false, +// }; // -// TIME_WINDOW_COPY(cond.twindow, *win); -// return cond; -//} +// TIME_WINDOW_COPY(cond.twindow, *win); +// return cond; +// } static STableIdInfo createTableIdInfo(STableQueryInfo* pTableQueryInfo) { STableIdInfo tidInfo; -// STableId* id = TSDB_TABLEID(pTableQueryInfo->pTable); -// -// tidInfo.uid = id->uid; -// tidInfo.tid = id->tid; -// tidInfo.key = pTableQueryInfo->lastKey; + // STableId* id = TSDB_TABLEID(pTableQueryInfo->pTable); + // + // tidInfo.uid = id->uid; + // tidInfo.tid = id->tid; + // tidInfo.key = pTableQueryInfo->lastKey; return tidInfo; } -//static void updateTableIdInfo(STableQueryInfo* pTableQueryInfo, SSDataBlock* pBlock, SHashObj* pTableIdInfo, int32_t order) { -// int32_t step = GET_FORWARD_DIRECTION_FACTOR(order); -// pTableQueryInfo->lastKey = ((order == TSDB_ORDER_ASC)? pBlock->info.window.ekey:pBlock->info.window.skey) + step; +// static void updateTableIdInfo(STableQueryInfo* pTableQueryInfo, SSDataBlock* pBlock, SHashObj* pTableIdInfo, int32_t +// order) { +// int32_t step = GET_FORWARD_DIRECTION_FACTOR(order); +// pTableQueryInfo->lastKey = ((order == TSDB_ORDER_ASC)? pBlock->info.window.ekey:pBlock->info.window.skey) + step; // -// if (pTableQueryInfo->pTable == NULL) { -// return; -// } +// if (pTableQueryInfo->pTable == NULL) { +// return; +// } // -// STableIdInfo tidInfo = createTableIdInfo(pTableQueryInfo); -// STableIdInfo *idinfo = taosHashGet(pTableIdInfo, &tidInfo.tid, sizeof(tidInfo.tid)); -// if (idinfo != NULL) { -// assert(idinfo->tid == tidInfo.tid && idinfo->uid == tidInfo.uid); -// idinfo->key = tidInfo.key; -// } else { -// taosHashPut(pTableIdInfo, &tidInfo.tid, sizeof(tidInfo.tid), &tidInfo, sizeof(STableIdInfo)); -// } -//} +// STableIdInfo tidInfo = createTableIdInfo(pTableQueryInfo); +// STableIdInfo *idinfo = taosHashGet(pTableIdInfo, &tidInfo.tid, sizeof(tidInfo.tid)); +// if (idinfo != NULL) { +// assert(idinfo->tid == tidInfo.tid && idinfo->uid == tidInfo.uid); +// idinfo->key = tidInfo.key; +// } else { +// taosHashPut(pTableIdInfo, &tidInfo.tid, sizeof(tidInfo.tid), &tidInfo, sizeof(STableIdInfo)); +// } +// } static void doCloseAllTimeWindow(STaskRuntimeEnv* pRuntimeEnv) { size_t numOfGroup = GET_NUM_OF_TABLEGROUP(pRuntimeEnv); @@ -4563,12 +4676,12 @@ static void doCloseAllTimeWindow(STaskRuntimeEnv* pRuntimeEnv) { } } -static SSDataBlock* doTableScanImpl(SOperatorInfo *pOperator, bool* newgroup) { - STableScanInfo *pTableScanInfo = pOperator->info; - SExecTaskInfo *pTaskInfo = pOperator->pTaskInfo; +static SSDataBlock* doTableScanImpl(SOperatorInfo* pOperator, bool* newgroup) { + STableScanInfo* pTableScanInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SSDataBlock *pBlock = &pTableScanInfo->block; - STableGroupInfo *pTableGroupInfo = &pOperator->pTaskInfo->tableqinfoGroupInfo; + SSDataBlock* pBlock = &pTableScanInfo->block; + STableGroupInfo* pTableGroupInfo = &pOperator->pTaskInfo->tableqinfoGroupInfo; *newgroup = false; @@ -4581,21 +4694,21 @@ static SSDataBlock* doTableScanImpl(SOperatorInfo *pOperator, bool* newgroup) { tsdbRetrieveDataBlockInfo(pTableScanInfo->pTsdbReadHandle, &pBlock->info); // todo opt -// if (pTableGroupInfo->numOfTables > 1 || (pRuntimeEnv->current == NULL && pTableGroupInfo->numOfTables == 1)) { -// STableQueryInfo** pTableQueryInfo = -// (STableQueryInfo**)taosHashGet(pTableGroupInfo->map, &pBlock->info.uid, sizeof(pBlock->info.uid)); -// if (pTableQueryInfo == NULL) { -// break; -// } -// -// pRuntimeEnv->current = *pTableQueryInfo; -// doTableQueryInfoTimeWindowCheck(pTaskInfo, *pTableQueryInfo, pTableScanInfo->order); -// } + // if (pTableGroupInfo->numOfTables > 1 || (pRuntimeEnv->current == NULL && pTableGroupInfo->numOfTables == 1)) { + // STableQueryInfo** pTableQueryInfo = + // (STableQueryInfo**)taosHashGet(pTableGroupInfo->map, &pBlock->info.uid, sizeof(pBlock->info.uid)); + // if (pTableQueryInfo == NULL) { + // break; + // } + // + // pRuntimeEnv->current = *pTableQueryInfo; + // doTableQueryInfoTimeWindowCheck(pTaskInfo, *pTableQueryInfo, pTableScanInfo->order); + // } // this function never returns error? uint32_t status = BLK_DATA_ALL_NEEDED; - int32_t code = loadDataBlock(pTaskInfo, pTableScanInfo, pBlock, &status); -// int32_t code = loadDataBlockOnDemand(pOperator->pRuntimeEnv, pTableScanInfo, pBlock, &status); + int32_t code = loadDataBlock(pTaskInfo, pTableScanInfo, pBlock, &status); + // int32_t code = loadDataBlockOnDemand(pOperator->pRuntimeEnv, pTableScanInfo, pBlock, &status); if (code != TSDB_CODE_SUCCESS) { longjmp(pOperator->pTaskInfo->env, code); } @@ -4611,9 +4724,9 @@ static SSDataBlock* doTableScanImpl(SOperatorInfo *pOperator, bool* newgroup) { return NULL; } -static SSDataBlock* doTableScan(SOperatorInfo *pOperator, bool *newgroup) { - STableScanInfo *pTableScanInfo = pOperator->info; - SExecTaskInfo *pTaskInfo = pOperator->pTaskInfo; +static SSDataBlock* doTableScan(SOperatorInfo* pOperator, bool* newgroup) { + STableScanInfo* pTableScanInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; // The read handle is not initialized yet, since no qualified tables exists if (pTableScanInfo->pTsdbReadHandle == NULL) { @@ -4630,7 +4743,7 @@ static SSDataBlock* doTableScan(SOperatorInfo *pOperator, bool *newgroup) { } if (++pTableScanInfo->current >= pTableScanInfo->times) { - if (pTableScanInfo->reverseTimes <= 0/* || isTsdbCacheLastRow(pTableScanInfo->pTsdbReadHandle)*/) { + if (pTableScanInfo->reverseTimes <= 0 /* || isTsdbCacheLastRow(pTableScanInfo->pTsdbReadHandle)*/) { return NULL; } else { break; @@ -4638,17 +4751,17 @@ static SSDataBlock* doTableScan(SOperatorInfo *pOperator, bool *newgroup) { } // do prepare for the next round table scan operation -// STsdbQueryCond cond = createTsdbQueryCond(pQueryAttr, &pQueryAttr->window); -// tsdbResetQueryHandle(pTableScanInfo->pTsdbReadHandle, &cond); + // STsdbQueryCond cond = createTsdbQueryCond(pQueryAttr, &pQueryAttr->window); + // tsdbResetQueryHandle(pTableScanInfo->pTsdbReadHandle, &cond); setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED); pTableScanInfo->scanFlag = REPEAT_SCAN; -// if (pTaskInfo->pTsBuf) { -// bool ret = tsBufNextPos(pRuntimeEnv->pTsBuf); -// assert(ret); -// } -// + // if (pTaskInfo->pTsBuf) { + // bool ret = tsBufNextPos(pRuntimeEnv->pTsBuf); + // assert(ret); + // } + // if (pResultRowInfo->size > 0) { pResultRowInfo->curPos = 0; } @@ -4657,12 +4770,12 @@ static SSDataBlock* doTableScan(SOperatorInfo *pOperator, bool *newgroup) { GET_TASKID(pTaskInfo), pTaskInfo->window.skey, pTaskInfo->window.ekey); } - SSDataBlock *p = NULL; + SSDataBlock* p = NULL; // todo refactor if (pTableScanInfo->reverseTimes > 0) { setupEnvForReverseScan(pTableScanInfo, pTableScanInfo->pCtx, pTableScanInfo->numOfOutput); -// STsdbQueryCond cond = createTsdbQueryCond(pQueryAttr, &pQueryAttr->window); -// tsdbResetQueryHandle(pTableScanInfo->pTsdbReadHandle, &cond); + // STsdbQueryCond cond = createTsdbQueryCond(pQueryAttr, &pQueryAttr->window); + // tsdbResetQueryHandle(pTableScanInfo->pTsdbReadHandle, &cond); qDebug("%s start to reverse scan data blocks due to query func required, qrange:%" PRId64 "-%" PRId64, GET_TASKID(pTaskInfo), pTaskInfo->window.skey, pTaskInfo->window.ekey); @@ -4677,12 +4790,12 @@ static SSDataBlock* doTableScan(SOperatorInfo *pOperator, bool *newgroup) { return p; } -static SSDataBlock* doBlockInfoScan(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } - STableScanInfo *pTableScanInfo = pOperator->info; + STableScanInfo* pTableScanInfo = pOperator->info; *newgroup = false; #if 0 STableBlockDist tableBlockDist = {0}; @@ -4728,19 +4841,18 @@ static void doClearBufferedBlocks(SStreamBlockScanInfo* pInfo) { size_t total = taosArrayGetSize(pInfo->pBlockLists); pInfo->validBlockIndex = 0; - for(int32_t i = 0; i < total; ++i) { - SSDataBlock* p = taosArrayGet(pInfo->pBlockLists, i); + for (int32_t i = 0; i < total; ++i) { + SSDataBlock* p = taosArrayGetP(pInfo->pBlockLists, i); blockDataDestroy(p); } taosArrayClear(pInfo->pBlockLists); } -static SSDataBlock* doStreamBlockScan(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doStreamBlockScan(SOperatorInfo* pOperator, bool* newgroup) { // NOTE: this operator does never check if current status is done or not - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStreamBlockScanInfo* pInfo = pOperator->info; - pTaskInfo->code = pOperator->_openFn(pOperator); if (pTaskInfo->code != TSDB_CODE_SUCCESS) { return NULL; @@ -4754,7 +4866,7 @@ static SSDataBlock* doStreamBlockScan(SOperatorInfo *pOperator, bool* newgroup) } int32_t current = pInfo->validBlockIndex++; - return taosArrayGet(pInfo->pBlockLists, current); + return taosArrayGetP(pInfo->pBlockLists, current); } else { SDataBlockInfo* pBlockInfo = &pInfo->pRes->info; blockDataCleanup(pInfo->pRes); @@ -4789,13 +4901,13 @@ static SSDataBlock* doStreamBlockScan(SOperatorInfo *pOperator, bool* newgroup) } int32_t loadRemoteDataCallback(void* param, const SDataBuf* pMsg, int32_t code) { - SSourceDataInfo* pSourceDataInfo = (SSourceDataInfo*) param; + SSourceDataInfo* pSourceDataInfo = (SSourceDataInfo*)param; pSourceDataInfo->pRsp = pMsg->pData; SRetrieveTableRsp* pRsp = pSourceDataInfo->pRsp; pRsp->numOfRows = htonl(pRsp->numOfRows); - pRsp->useconds = htobe64(pRsp->useconds); - pRsp->compLen = htonl(pRsp->compLen); + pRsp->useconds = htobe64(pRsp->useconds); + pRsp->compLen = htonl(pRsp->compLen); pSourceDataInfo->status = EX_SOURCE_DATA_READY; tsem_post(&pSourceDataInfo->pEx->ready); @@ -4808,7 +4920,7 @@ static void destroySendMsgInfo(SMsgSendInfo* pMsgBody) { } void qProcessFetchRsp(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) { - SMsgSendInfo *pSendInfo = (SMsgSendInfo *) pMsg->ahandle; + SMsgSendInfo* pSendInfo = (SMsgSendInfo*)pMsg->ahandle; assert(pMsg->ahandle != NULL); SDataBuf buf = {.len = pMsg->contLen, .pData = NULL}; @@ -4828,7 +4940,7 @@ void qProcessFetchRsp(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) { destroySendMsgInfo(pSendInfo); } -static int32_t doSendFetchDataRequest(SExchangeInfo *pExchangeInfo, SExecTaskInfo *pTaskInfo, int32_t sourceIndex) { +static int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex) { size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); SResFetchReq* pMsg = taosMemoryCalloc(1, sizeof(SResFetchReq)); @@ -4837,11 +4949,11 @@ static int32_t doSendFetchDataRequest(SExchangeInfo *pExchangeInfo, SExecTaskInf return pTaskInfo->code; } - SDownstreamSourceNode *pSource = taosArrayGet(pExchangeInfo->pSources, sourceIndex); - SSourceDataInfo *pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, sourceIndex); + SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, sourceIndex); + SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, sourceIndex); - qDebug("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", %d/%" PRIzu, - GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->addr.epSet.eps[0].fqdn, pSource->taskId, sourceIndex, totalSources); + qDebug("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", %d/%" PRIzu, GET_TASKID(pTaskInfo), + pSource->addr.nodeId, pSource->addr.epSet.eps[0].fqdn, pSource->taskId, sourceIndex, totalSources); pMsg->header.vgId = htonl(pSource->addr.nodeId); pMsg->sId = htobe64(pSource->schedId); @@ -4869,13 +4981,14 @@ static int32_t doSendFetchDataRequest(SExchangeInfo *pExchangeInfo, SExecTaskInf } // TODO if only one or two columnss required, how to extract data? -static int32_t setSDataBlockFromFetchRsp(SSDataBlock* pRes, SLoadRemoteDataInfo* pLoadInfo, int32_t numOfRows, char* pData, int32_t compLen, - int32_t numOfOutput, int64_t startTs, uint64_t* total, SArray* pColList) { +static int32_t setSDataBlockFromFetchRsp(SSDataBlock* pRes, SLoadRemoteDataInfo* pLoadInfo, int32_t numOfRows, + char* pData, int32_t compLen, int32_t numOfOutput, int64_t startTs, + uint64_t* total, SArray* pColList) { blockDataEnsureCapacity(pRes, numOfRows); if (pColList == NULL) { // data from other sources int32_t* colLen = (int32_t*)pData; - char* pStart = pData + sizeof(int32_t) * numOfOutput; + char* pStart = pData + sizeof(int32_t) * numOfOutput; for (int32_t i = 0; i < numOfOutput; ++i) { colLen[i] = htonl(colLen[i]); @@ -4886,8 +4999,8 @@ static int32_t setSDataBlockFromFetchRsp(SSDataBlock* pRes, SLoadRemoteDataInfo* pColInfoData->varmeta.length = colLen[i]; pColInfoData->varmeta.allocLen = colLen[i]; - memcpy(pColInfoData->varmeta.offset, pStart, sizeof(int32_t)*numOfRows); - pStart += sizeof(int32_t)*numOfRows; + memcpy(pColInfoData->varmeta.offset, pStart, sizeof(int32_t) * numOfRows); + pStart += sizeof(int32_t) * numOfRows; pColInfoData->pData = taosMemoryMalloc(colLen[i]); } else { @@ -4902,10 +5015,9 @@ static int32_t setSDataBlockFromFetchRsp(SSDataBlock* pRes, SLoadRemoteDataInfo* ASSERT(numOfOutput == taosArrayGetSize(pColList)); // data from mnode - for(int32_t i = 0; i < numOfOutput; ++i) { - - for(int32_t j = 0; j < numOfOutput; ++j) { - int16_t colIndex = *(int16_t*) taosArrayGet(pColList, j); + for (int32_t i = 0; i < numOfOutput; ++i) { + for (int32_t j = 0; j < numOfOutput; ++j) { + int16_t colIndex = *(int16_t*)taosArrayGet(pColList, j); if (colIndex - 1 == i) { SColumnInfoData* pColInfoData = taosArrayGet(pRes->pDataBlock, j); @@ -4934,23 +5046,25 @@ static int32_t setSDataBlockFromFetchRsp(SSDataBlock* pRes, SLoadRemoteDataInfo* return TSDB_CODE_SUCCESS; } -static void* setAllSourcesCompleted(SOperatorInfo *pOperator, int64_t startTs) { - SExchangeInfo *pExchangeInfo = pOperator->info; +static void* setAllSourcesCompleted(SOperatorInfo* pOperator, int64_t startTs) { + SExchangeInfo* pExchangeInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - int64_t el = taosGetTimestampUs() - startTs; + int64_t el = taosGetTimestampUs() - startTs; SLoadRemoteDataInfo* pLoadInfo = &pExchangeInfo->loadInfo; pLoadInfo->totalElapsed += el; size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); - qDebug("%s all %"PRIzu" sources are exhausted, total rows: %"PRIu64" bytes:%"PRIu64", elapsed:%.2f ms", GET_TASKID(pTaskInfo), totalSources, - pLoadInfo->totalRows, pLoadInfo->totalSize, pLoadInfo->totalElapsed/1000.0); + qDebug("%s all %" PRIzu " sources are exhausted, total rows: %" PRIu64 " bytes:%" PRIu64 ", elapsed:%.2f ms", + GET_TASKID(pTaskInfo), totalSources, pLoadInfo->totalRows, pLoadInfo->totalSize, + pLoadInfo->totalElapsed / 1000.0); doSetOperatorCompleted(pOperator); return NULL; } -static SSDataBlock* concurrentlyLoadRemoteDataImpl(SOperatorInfo *pOperator, SExchangeInfo *pExchangeInfo, SExecTaskInfo *pTaskInfo) { +static SSDataBlock* concurrentlyLoadRemoteDataImpl(SOperatorInfo* pOperator, SExchangeInfo* pExchangeInfo, + SExecTaskInfo* pTaskInfo) { int32_t code = 0; int64_t startTs = taosGetTimestampUs(); size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); @@ -4969,13 +5083,14 @@ static SSDataBlock* concurrentlyLoadRemoteDataImpl(SOperatorInfo *pOperator, SEx continue; } - SRetrieveTableRsp* pRsp = pDataInfo->pRsp; + SRetrieveTableRsp* pRsp = pDataInfo->pRsp; SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, i); - SSDataBlock* pRes = pExchangeInfo->pResult; + SSDataBlock* pRes = pExchangeInfo->pResult; SLoadRemoteDataInfo* pLoadInfo = &pExchangeInfo->loadInfo; if (pRsp->numOfRows == 0) { - qDebug("%s vgId:%d, taskID:0x%" PRIx64 " index:%d completed, rowsOfSource:%" PRIu64 ", totalRows:%" PRIu64 " try next", + qDebug("%s vgId:%d, taskID:0x%" PRIx64 " index:%d completed, rowsOfSource:%" PRIu64 ", totalRows:%" PRIu64 + " try next", GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, i + 1, pDataInfo->totalRows, pExchangeInfo->loadInfo.totalRows); pDataInfo->status = DATA_EXHAUSTED; @@ -4984,8 +5099,9 @@ static SSDataBlock* concurrentlyLoadRemoteDataImpl(SOperatorInfo *pOperator, SEx } SRetrieveTableRsp* pTableRsp = pDataInfo->pRsp; - code = setSDataBlockFromFetchRsp(pExchangeInfo->pResult, pLoadInfo, pTableRsp->numOfRows, - pTableRsp->data, pTableRsp->compLen, pOperator->numOfOutput, startTs, &pDataInfo->totalRows, NULL); + code = + setSDataBlockFromFetchRsp(pExchangeInfo->pResult, pLoadInfo, pTableRsp->numOfRows, pTableRsp->data, + pTableRsp->compLen, pOperator->numOfOutput, startTs, &pDataInfo->totalRows, NULL); if (code != 0) { goto _error; } @@ -4993,12 +5109,12 @@ static SSDataBlock* concurrentlyLoadRemoteDataImpl(SOperatorInfo *pOperator, SEx if (pRsp->completed == 1) { qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " numOfRows:%d, rowsOfSource:%" PRIu64 ", totalRows:%" PRIu64 ", totalBytes:%" PRIu64 " try next %d/%" PRIzu, - GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pRes->info.rows, - pDataInfo->totalRows, pLoadInfo->totalRows, pLoadInfo->totalSize, i + 1, - totalSources); + GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pRes->info.rows, pDataInfo->totalRows, + pLoadInfo->totalRows, pLoadInfo->totalSize, i + 1, totalSources); pDataInfo->status = DATA_EXHAUSTED; } else { - qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " numOfRows:%d, totalRows:%" PRIu64 ", totalBytes:%" PRIu64, + qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " numOfRows:%d, totalRows:%" PRIu64 + ", totalBytes:%" PRIu64, GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pRes->info.rows, pLoadInfo->totalRows, pLoadInfo->totalSize); } @@ -5024,19 +5140,19 @@ _error: return NULL; } -static SSDataBlock* concurrentlyLoadRemoteData(SOperatorInfo *pOperator) { - SExchangeInfo *pExchangeInfo = pOperator->info; - SExecTaskInfo *pTaskInfo = pOperator->pTaskInfo; +static SSDataBlock* concurrentlyLoadRemoteData(SOperatorInfo* pOperator) { + SExchangeInfo* pExchangeInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (pOperator->status == OP_RES_TO_RETURN) { return concurrentlyLoadRemoteDataImpl(pOperator, pExchangeInfo, pTaskInfo); } - size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); + size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); int64_t startTs = taosGetTimestampUs(); // Asynchronously send all fetch requests to all sources. - for(int32_t i = 0; i < totalSources; ++i) { + for (int32_t i = 0; i < totalSources; ++i) { int32_t code = doSendFetchDataRequest(pExchangeInfo, pTaskInfo, i); if (code != TSDB_CODE_SUCCESS) { return NULL; @@ -5044,7 +5160,8 @@ static SSDataBlock* concurrentlyLoadRemoteData(SOperatorInfo *pOperator) { } int64_t endTs = taosGetTimestampUs(); - qDebug("%s send all fetch request to %"PRIzu" sources completed, elapsed:%"PRId64, GET_TASKID(pTaskInfo), totalSources, endTs - startTs); + qDebug("%s send all fetch request to %" PRIzu " sources completed, elapsed:%" PRId64, GET_TASKID(pTaskInfo), + totalSources, endTs - startTs); tsem_wait(&pExchangeInfo->ready); @@ -5052,15 +5169,15 @@ static SSDataBlock* concurrentlyLoadRemoteData(SOperatorInfo *pOperator) { return concurrentlyLoadRemoteDataImpl(pOperator, pExchangeInfo, pTaskInfo); } -static int32_t prepareConcurrentlyLoad(SOperatorInfo *pOperator) { - SExchangeInfo *pExchangeInfo = pOperator->info; - SExecTaskInfo *pTaskInfo = pOperator->pTaskInfo; +static int32_t prepareConcurrentlyLoad(SOperatorInfo* pOperator) { + SExchangeInfo* pExchangeInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); + size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); int64_t startTs = taosGetTimestampUs(); // Asynchronously send all fetch requests to all sources. - for(int32_t i = 0; i < totalSources; ++i) { + for (int32_t i = 0; i < totalSources; ++i) { int32_t code = doSendFetchDataRequest(pExchangeInfo, pTaskInfo, i); if (code != TSDB_CODE_SUCCESS) { pTaskInfo->code = code; @@ -5069,7 +5186,8 @@ static int32_t prepareConcurrentlyLoad(SOperatorInfo *pOperator) { } int64_t endTs = taosGetTimestampUs(); - qDebug("%s send all fetch request to %"PRIzu" sources completed, elapsed:%"PRId64, GET_TASKID(pTaskInfo), totalSources, endTs - startTs); + qDebug("%s send all fetch request to %" PRIzu " sources completed, elapsed:%" PRId64, GET_TASKID(pTaskInfo), + totalSources, endTs - startTs); tsem_wait(&pExchangeInfo->ready); pOperator->cost.openCost = taosGetTimestampUs() - startTs; @@ -5077,14 +5195,14 @@ static int32_t prepareConcurrentlyLoad(SOperatorInfo *pOperator) { return TSDB_CODE_SUCCESS; } -static SSDataBlock* seqLoadRemoteData(SOperatorInfo *pOperator) { - SExchangeInfo *pExchangeInfo = pOperator->info; - SExecTaskInfo *pTaskInfo = pOperator->pTaskInfo; +static SSDataBlock* seqLoadRemoteData(SOperatorInfo* pOperator) { + SExchangeInfo* pExchangeInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); + size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); int64_t startTs = taosGetTimestampUs(); - while(1) { + while (1) { if (pExchangeInfo->current >= totalSources) { return setAllSourcesCompleted(pOperator, startTs); } @@ -5093,14 +5211,15 @@ static SSDataBlock* seqLoadRemoteData(SOperatorInfo *pOperator) { tsem_wait(&pExchangeInfo->ready); - SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pExchangeInfo->current); + SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pExchangeInfo->current); SDownstreamSourceNode* pSource = taosArrayGet(pExchangeInfo->pSources, pExchangeInfo->current); - SRetrieveTableRsp* pRsp = pDataInfo->pRsp; + SRetrieveTableRsp* pRsp = pDataInfo->pRsp; SLoadRemoteDataInfo* pLoadInfo = &pExchangeInfo->loadInfo; if (pRsp->numOfRows == 0) { - qDebug("%s vgId:%d, taskID:0x%"PRIx64" %d of total completed, rowsOfSource:%"PRIu64", totalRows:%"PRIu64" try next", + qDebug("%s vgId:%d, taskID:0x%" PRIx64 " %d of total completed, rowsOfSource:%" PRIu64 ", totalRows:%" PRIu64 + " try next", GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pExchangeInfo->current + 1, pDataInfo->totalRows, pLoadInfo->totalRows); @@ -5109,35 +5228,37 @@ static SSDataBlock* seqLoadRemoteData(SOperatorInfo *pOperator) { continue; } - SSDataBlock* pRes = pExchangeInfo->pResult; + SSDataBlock* pRes = pExchangeInfo->pResult; SRetrieveTableRsp* pTableRsp = pDataInfo->pRsp; - int32_t code = setSDataBlockFromFetchRsp(pExchangeInfo->pResult, pLoadInfo, pTableRsp->numOfRows, - pTableRsp->data, pTableRsp->compLen, pOperator->numOfOutput, startTs, &pDataInfo->totalRows, NULL); + int32_t code = + setSDataBlockFromFetchRsp(pExchangeInfo->pResult, pLoadInfo, pTableRsp->numOfRows, pTableRsp->data, + pTableRsp->compLen, pOperator->numOfOutput, startTs, &pDataInfo->totalRows, NULL); if (pRsp->completed == 1) { qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " numOfRows:%d, rowsOfSource:%" PRIu64 - ", totalRows:%" PRIu64 ", totalBytes:%" PRIu64 " try next %d/%" PRIzu, - GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pRes->info.rows, - pDataInfo->totalRows, pLoadInfo->totalRows, pLoadInfo->totalSize, pExchangeInfo->current + 1, - totalSources); + ", totalRows:%" PRIu64 ", totalBytes:%" PRIu64 " try next %d/%" PRIzu, + GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pRes->info.rows, pDataInfo->totalRows, + pLoadInfo->totalRows, pLoadInfo->totalSize, pExchangeInfo->current + 1, totalSources); pDataInfo->status = DATA_EXHAUSTED; pExchangeInfo->current += 1; } else { - qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " numOfRows:%d, totalRows:%" PRIu64 ", totalBytes:%" PRIu64, - GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pRes->info.rows, pLoadInfo->totalRows, pLoadInfo->totalSize); + qDebug("%s fetch msg rsp from vgId:%d, taskId:0x%" PRIx64 " numOfRows:%d, totalRows:%" PRIu64 + ", totalBytes:%" PRIu64, + GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pRes->info.rows, pLoadInfo->totalRows, + pLoadInfo->totalSize); } return pExchangeInfo->pResult; } } -static int32_t prepareLoadRemoteData(SOperatorInfo *pOperator) { +static int32_t prepareLoadRemoteData(SOperatorInfo* pOperator) { if (OPTR_IS_OPENED(pOperator)) { return TSDB_CODE_SUCCESS; } - SExchangeInfo *pExchangeInfo = pOperator->info; + SExchangeInfo* pExchangeInfo = pOperator->info; if (pExchangeInfo->seqLoadData) { // do nothing for sequentially load data } else { @@ -5151,21 +5272,22 @@ static int32_t prepareLoadRemoteData(SOperatorInfo *pOperator) { return TSDB_CODE_SUCCESS; } -static SSDataBlock* doLoadRemoteData(SOperatorInfo *pOperator, bool* newgroup) { - SExchangeInfo *pExchangeInfo = pOperator->info; - SExecTaskInfo *pTaskInfo = pOperator->pTaskInfo; +static SSDataBlock* doLoadRemoteData(SOperatorInfo* pOperator, bool* newgroup) { + SExchangeInfo* pExchangeInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; pTaskInfo->code = pOperator->_openFn(pOperator); if (pTaskInfo->code != TSDB_CODE_SUCCESS) { return NULL; } - size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); + size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); SLoadRemoteDataInfo* pLoadInfo = &pExchangeInfo->loadInfo; if (pOperator->status == OP_EXEC_DONE) { - qDebug("%s all %"PRIzu" source(s) are exhausted, total rows:%"PRIu64" bytes:%"PRIu64", elapsed:%.2f ms", GET_TASKID(pTaskInfo), totalSources, - pLoadInfo->totalRows, pLoadInfo->totalSize, pLoadInfo->totalElapsed/1000.0); + qDebug("%s all %" PRIzu " source(s) are exhausted, total rows:%" PRIu64 " bytes:%" PRIu64 ", elapsed:%.2f ms", + GET_TASKID(pTaskInfo), totalSources, pLoadInfo->totalRows, pLoadInfo->totalSize, + pLoadInfo->totalElapsed / 1000.0); return NULL; } @@ -5193,11 +5315,11 @@ static int32_t initDataSource(int32_t numOfSources, SExchangeInfo* pInfo) { return TSDB_CODE_OUT_OF_MEMORY; } - for(int32_t i = 0; i < numOfSources; ++i) { + for (int32_t i = 0; i < numOfSources; ++i) { SSourceDataInfo dataInfo = {0}; dataInfo.status = EX_SOURCE_DATA_NOT_READY; - dataInfo.pEx = pInfo; - dataInfo.index = i; + dataInfo.pEx = pInfo; + dataInfo.index = i; void* ret = taosArrayPush(pInfo->pSourceDataInfo, &dataInfo); if (ret == NULL) { @@ -5210,7 +5332,7 @@ static int32_t initDataSource(int32_t numOfSources, SExchangeInfo* pInfo) { } SOperatorInfo* createExchangeOperatorInfo(const SNodeList* pSources, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) { - SExchangeInfo* pInfo = taosMemoryCalloc(1, sizeof(SExchangeInfo)); + SExchangeInfo* pInfo = taosMemoryCalloc(1, sizeof(SExchangeInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -5227,8 +5349,8 @@ SOperatorInfo* createExchangeOperatorInfo(const SNodeList* pSources, SSDataBlock goto _error; } - for(int32_t i = 0; i < numOfSources; ++i) { - SNodeListNode* pNode = nodesListGetNode((SNodeList*) pSources, i); + for (int32_t i = 0; i < numOfSources; ++i) { + SNodeListNode* pNode = nodesListGetNode((SNodeList*)pSources, i); taosArrayPush(pInfo->pSources, pNode); } @@ -5237,25 +5359,25 @@ SOperatorInfo* createExchangeOperatorInfo(const SNodeList* pSources, SSDataBlock goto _error; } - size_t size = pBlock->info.numOfCols; - pInfo->pResult = pBlock; + size_t size = pBlock->info.numOfCols; + pInfo->pResult = pBlock; pInfo->seqLoadData = true; tsem_init(&pInfo->ready, 0, 0); - pOperator->name = "ExchangeOperator"; + pOperator->name = "ExchangeOperator"; pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_EXCHANGE; pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; - pOperator->numOfOutput = size; - pOperator->pTaskInfo = pTaskInfo; - pOperator->_openFn = prepareLoadRemoteData; // assign a dummy function. - pOperator->getNextFn = doLoadRemoteData; - pOperator->closeFn = destroyExchangeOperatorInfo; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; + pOperator->numOfOutput = size; + pOperator->pTaskInfo = pTaskInfo; + pOperator->_openFn = prepareLoadRemoteData; // assign a dummy function. + pOperator->getNextFn = doLoadRemoteData; + pOperator->closeFn = destroyExchangeOperatorInfo; #if 1 - { // todo refactor + { // todo refactor SRpcInit rpcInit; memset(&rpcInit, 0, sizeof(rpcInit)); rpcInit.localPort = 0; @@ -5264,22 +5386,22 @@ SOperatorInfo* createExchangeOperatorInfo(const SNodeList* pSources, SSDataBlock rpcInit.cfp = qProcessFetchRsp; rpcInit.sessions = tsMaxConnections; rpcInit.connType = TAOS_CONN_CLIENT; - rpcInit.user = (char *)"root"; + rpcInit.user = (char*)"root"; rpcInit.idleTime = tsShellActivityTimer * 1000; rpcInit.ckey = "key"; rpcInit.spi = 1; - rpcInit.secret = (char *)"dcc5bed04851fec854c035b2e40263b6"; + rpcInit.secret = (char*)"dcc5bed04851fec854c035b2e40263b6"; pInfo->pTransporter = rpcOpen(&rpcInit); if (pInfo->pTransporter == NULL) { - return NULL; // todo + return NULL; // todo } } #endif return pOperator; - _error: +_error: if (pInfo != NULL) { destroyExchangeOperatorInfo(pInfo, numOfSources); } @@ -5300,12 +5422,12 @@ SSDataBlock* createResultDataBlock(const SArray* pExprInfo) { pResBlock->pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData)); SArray* pResult = pResBlock->pDataBlock; - for(int32_t i = 0; i < numOfCols; ++i) { + for (int32_t i = 0; i < numOfCols; ++i) { SColumnInfoData colInfoData = {0}; - SExprInfo* p = taosArrayGetP(pExprInfo, i); + SExprInfo* p = taosArrayGetP(pExprInfo, i); SResSchema* pSchema = &p->base.resSchema; - colInfoData.info.type = pSchema->type; + colInfoData.info.type = pSchema->type; colInfoData.info.colId = pSchema->colId; colInfoData.info.bytes = pSchema->bytes; colInfoData.info.scale = pSchema->scale; @@ -5316,12 +5438,13 @@ SSDataBlock* createResultDataBlock(const SArray* pExprInfo) { return pResBlock; } -SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order, int32_t numOfOutput, int32_t repeatTime, int32_t reverseTime, SArray* pColMatchInfo, - SExecTaskInfo* pTaskInfo) { +SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order, int32_t numOfOutput, + int32_t repeatTime, int32_t reverseTime, SArray* pColMatchInfo, + SExecTaskInfo* pTaskInfo) { assert(repeatTime > 0); - STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { taosMemoryFreeClear(pInfo); taosMemoryFreeClear(pOperator); @@ -5331,26 +5454,26 @@ SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order, } pInfo->block.pDataBlock = taosArrayInit(numOfOutput, sizeof(SColumnInfoData)); - for(int32_t i = 0; i < numOfOutput; ++i) { + for (int32_t i = 0; i < numOfOutput; ++i) { SColumnInfoData idata = {0}; taosArrayPush(pInfo->block.pDataBlock, &idata); } pInfo->pTsdbReadHandle = pTsdbReadHandle; - pInfo->times = repeatTime; - pInfo->reverseTimes = reverseTime; - pInfo->order = order; - pInfo->current = 0; - pInfo->scanFlag = MAIN_SCAN; - pInfo->pColMatchInfo = pColMatchInfo; - pOperator->name = "TableScanOperator"; - pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN; - pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; - pOperator->numOfOutput = numOfOutput; - pOperator->getNextFn = doTableScan; - pOperator->pTaskInfo = pTaskInfo; + pInfo->times = repeatTime; + pInfo->reverseTimes = reverseTime; + pInfo->order = order; + pInfo->current = 0; + pInfo->scanFlag = MAIN_SCAN; + pInfo->pColMatchInfo = pColMatchInfo; + pOperator->name = "TableScanOperator"; + pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN; + pOperator->blockingOptr = false; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; + pOperator->numOfOutput = numOfOutput; + pOperator->getNextFn = doTableScan; + pOperator->pTaskInfo = pTaskInfo; return pOperator; } @@ -5358,23 +5481,23 @@ SOperatorInfo* createTableScanOperatorInfo(void* pTsdbReadHandle, int32_t order, SOperatorInfo* createTableSeqScanOperatorInfo(void* pTsdbReadHandle, STaskRuntimeEnv* pRuntimeEnv) { STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo)); - pInfo->pTsdbReadHandle = pTsdbReadHandle; - pInfo->times = 1; - pInfo->reverseTimes = 0; - pInfo->order = pRuntimeEnv->pQueryAttr->order.order; - pInfo->current = 0; - pInfo->prevGroupId = -1; + pInfo->pTsdbReadHandle = pTsdbReadHandle; + pInfo->times = 1; + pInfo->reverseTimes = 0; + pInfo->order = pRuntimeEnv->pQueryAttr->order.order; + pInfo->current = 0; + pInfo->prevGroupId = -1; pRuntimeEnv->enableGroupData = true; SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - pOperator->name = "TableSeqScanOperator"; + pOperator->name = "TableSeqScanOperator"; pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN; pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; - pOperator->numOfOutput = pRuntimeEnv->pQueryAttr->numOfCols; - pOperator->pRuntimeEnv = pRuntimeEnv; - pOperator->getNextFn = doTableScanImpl; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; + pOperator->numOfOutput = pRuntimeEnv->pQueryAttr->numOfCols; + pOperator->pRuntimeEnv = pRuntimeEnv; + pOperator->getNextFn = doTableScanImpl; return pOperator; } @@ -5382,7 +5505,7 @@ SOperatorInfo* createTableSeqScanOperatorInfo(void* pTsdbReadHandle, STaskRuntim SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbReadHandle, STaskRuntimeEnv* pRuntimeEnv) { STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo)); - pInfo->pTsdbReadHandle = pTsdbReadHandle; + pInfo->pTsdbReadHandle = pTsdbReadHandle; pInfo->block.pDataBlock = taosArrayInit(1, sizeof(SColumnInfoData)); SColumnInfoData infoData = {{0}}; @@ -5392,20 +5515,21 @@ SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbReadHandle, STaskRunt taosArrayPush(pInfo->block.pDataBlock, &infoData); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - pOperator->name = "TableBlockInfoScanOperator"; -// pOperator->operatorType = OP_TableBlockInfoScan; + pOperator->name = "TableBlockInfoScanOperator"; + // pOperator->operatorType = OP_TableBlockInfoScan; pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; -// pOperator->numOfOutput = pRuntimeEnv->pQueryAttr->numOfCols; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; + // pOperator->numOfOutput = pRuntimeEnv->pQueryAttr->numOfCols; pOperator->getNextFn = doBlockInfoScan; return pOperator; } -SOperatorInfo* createStreamScanOperatorInfo(void *streamReadHandle, SSDataBlock* pResBlock, SArray* pColList, SArray* pTableIdList, SExecTaskInfo* pTaskInfo) { +SOperatorInfo* createStreamScanOperatorInfo(void* streamReadHandle, SSDataBlock* pResBlock, SArray* pColList, + SArray* pTableIdList, SExecTaskInfo* pTaskInfo) { SStreamBlockScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamBlockScanInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { taosMemoryFreeClear(pInfo); taosMemoryFreeClear(pOperator); @@ -5414,7 +5538,7 @@ SOperatorInfo* createStreamScanOperatorInfo(void *streamReadHandle, SSDataBlock* } // set the extract column id to streamHandle - tqReadHandleSetColIdList((STqReadHandle* )streamReadHandle, pColList); + tqReadHandleSetColIdList((STqReadHandle*)streamReadHandle, pColList); int32_t code = tqReadHandleSetTbUidList(streamReadHandle, pTableIdList); if (code != 0) { taosMemoryFreeClear(pInfo); @@ -5422,40 +5546,40 @@ SOperatorInfo* createStreamScanOperatorInfo(void *streamReadHandle, SSDataBlock* return NULL; } - pInfo->pBlockLists = taosArrayInit(4, POINTER_BYTES); + pInfo->pBlockLists = taosArrayInit(4, POINTER_BYTES); if (pInfo->pBlockLists == NULL) { taosMemoryFreeClear(pInfo); taosMemoryFreeClear(pOperator); return NULL; } - pInfo->readerHandle = streamReadHandle; - pInfo->pRes = pResBlock; + pInfo->readerHandle = streamReadHandle; + pInfo->pRes = pResBlock; - pOperator->name = "StreamBlockScanOperator"; - pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN; - pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; - pOperator->numOfOutput = pResBlock->info.numOfCols; - pOperator->_openFn = operatorDummyOpenFn; - pOperator->getNextFn = doStreamBlockScan; - pOperator->closeFn = operatorDummyCloseFn; - pOperator->pTaskInfo = pTaskInfo; + pOperator->name = "StreamBlockScanOperator"; + pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN; + pOperator->blockingOptr = false; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; + pOperator->numOfOutput = pResBlock->info.numOfCols; + pOperator->_openFn = operatorDummyOpenFn; + pOperator->getNextFn = doStreamBlockScan; + pOperator->closeFn = operatorDummyCloseFn; + pOperator->pTaskInfo = pTaskInfo; return pOperator; } static int32_t loadSysTableContentCb(void* param, const SDataBuf* pMsg, int32_t code) { - SOperatorInfo* operator = (SOperatorInfo *)param; - SSysTableScanInfo* pScanResInfo = (SSysTableScanInfo *)operator->info; + SOperatorInfo* operator=(SOperatorInfo*) param; + SSysTableScanInfo* pScanResInfo = (SSysTableScanInfo*)operator->info; if (TSDB_CODE_SUCCESS == code) { pScanResInfo->pRsp = pMsg->pData; SRetrieveMetaTableRsp* pRsp = pScanResInfo->pRsp; pRsp->numOfRows = htonl(pRsp->numOfRows); - pRsp->useconds = htobe64(pRsp->useconds); - pRsp->handle = htobe64(pRsp->handle); - pRsp->compLen = htonl(pRsp->compLen); + pRsp->useconds = htobe64(pRsp->useconds); + pRsp->handle = htobe64(pRsp->handle); + pRsp->compLen = htonl(pRsp->compLen); } else { operator->pTaskInfo->code = code; } @@ -5463,10 +5587,9 @@ static int32_t loadSysTableContentCb(void* param, const SDataBuf* pMsg, int32_t tsem_post(&pScanResInfo->ready); } - static SSDataBlock* doFilterResult(SSysTableScanInfo* pInfo) { if (pInfo->pCondition == NULL) { - return pInfo->pRes->info.rows == 0? NULL:pInfo->pRes; + return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes; } SFilterInfo* filter = NULL; @@ -5481,7 +5604,7 @@ static SSDataBlock* doFilterResult(SSysTableScanInfo* pInfo) { SSDataBlock* px = createOneDataBlock(pInfo->pRes); blockDataEnsureCapacity(px, pInfo->pRes->info.rows); - //TODO refactor + // TODO refactor int32_t numOfRow = 0; for (int32_t i = 0; i < pInfo->pRes->info.numOfCols; ++i) { SColumnInfoData* pDest = taosArrayGet(px->pDataBlock, i); @@ -5501,49 +5624,49 @@ static SSDataBlock* doFilterResult(SSysTableScanInfo* pInfo) { px->info.rows = numOfRow; pInfo->pRes = px; - return pInfo->pRes->info.rows == 0? NULL:pInfo->pRes; + return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes; } EDealRes getDBNameFromConditionWalker(SNode* pNode, void* pContext) { - int32_t code = TSDB_CODE_SUCCESS; + int32_t code = TSDB_CODE_SUCCESS; ENodeType nType = nodeType(pNode); switch (nType) { case QUERY_NODE_OPERATOR: { - SOperatorNode *node = (SOperatorNode *)pNode; + SOperatorNode* node = (SOperatorNode*)pNode; if (OP_TYPE_EQUAL == node->opType) { - *(int32_t *)pContext = 1; + *(int32_t*)pContext = 1; return DEAL_RES_CONTINUE; } - *(int32_t *)pContext = 0; + *(int32_t*)pContext = 0; return DEAL_RES_IGNORE_CHILD; } case QUERY_NODE_COLUMN: { - if (1 != *(int32_t *)pContext) { + if (1 != *(int32_t*)pContext) { return DEAL_RES_CONTINUE; } - SColumnNode *node = (SColumnNode *)pNode; + SColumnNode* node = (SColumnNode*)pNode; if (TSDB_INS_USER_STABLES_DBNAME_COLID == node->colId) { - *(int32_t *)pContext = 2; + *(int32_t*)pContext = 2; return DEAL_RES_CONTINUE; } - *(int32_t *)pContext = 0; + *(int32_t*)pContext = 0; return DEAL_RES_CONTINUE; } case QUERY_NODE_VALUE: { - if (2 != *(int32_t *)pContext) { + if (2 != *(int32_t*)pContext) { return DEAL_RES_CONTINUE; } - SValueNode *node = (SValueNode *)pNode; - char *dbName = nodesGetValueFromNode(node); + SValueNode* node = (SValueNode*)pNode; + char* dbName = nodesGetValueFromNode(node); strncpy(pContext, varDataVal(dbName), varDataLen(dbName)); - *((char *)pContext + varDataLen(dbName)) = 0; + *((char*)pContext + varDataLen(dbName)) = 0; return DEAL_RES_ERROR; // stop walk } default: @@ -5553,8 +5676,7 @@ EDealRes getDBNameFromConditionWalker(SNode* pNode, void* pContext) { return DEAL_RES_CONTINUE; } - -void getDBNameFromCondition(SNode *pCondition, char *dbName) { +void getDBNameFromCondition(SNode* pCondition, char* dbName) { if (NULL == pCondition) { return; } @@ -5562,9 +5684,9 @@ void getDBNameFromCondition(SNode *pCondition, char *dbName) { nodesWalkNode(pCondition, getDBNameFromConditionWalker, dbName); } -static SSDataBlock* doSysTableScan(SOperatorInfo *pOperator, bool* newgroup) { -// build message and send to mnode to fetch the content of system tables. - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; +static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator, bool* newgroup) { + // build message and send to mnode to fetch the content of system tables. + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SSysTableScanInfo* pInfo = pOperator->info; // retrieve local table list info from vnode @@ -5575,10 +5697,10 @@ static SSDataBlock* doSysTableScan(SOperatorInfo *pOperator, bool* newgroup) { blockDataCleanup(pInfo->pRes); - int32_t tableNameSlotId = 1; + int32_t tableNameSlotId = 1; SColumnInfoData* pTableNameCol = taosArrayGet(pInfo->pRes->pDataBlock, tableNameSlotId); - char * name = NULL; + char* name = NULL; int32_t numOfRows = 0; char n[TSDB_TABLE_NAME_LEN] = {0}; @@ -5590,19 +5712,19 @@ static SSDataBlock* doSysTableScan(SOperatorInfo *pOperator, bool* newgroup) { break; } - for(int32_t i = 0; i < pInfo->pRes->info.numOfCols; ++i) { + for (int32_t i = 0; i < pInfo->pRes->info.numOfCols; ++i) { if (i == tableNameSlotId) { continue; } SColumnInfoData* pColInfoData = taosArrayGet(pInfo->pRes->pDataBlock, i); - int64_t tmp = 0; - char t[10] = {0}; + int64_t tmp = 0; + char t[10] = {0}; STR_TO_VARSTR(t, "_"); if (IS_VAR_DATA_TYPE(pColInfoData->info.type)) { colDataAppend(pColInfoData, numOfRows, t, false); } else { - colDataAppend(pColInfoData, numOfRows, (char*) &tmp, false); + colDataAppend(pColInfoData, numOfRows, (char*)&tmp, false); } } } @@ -5610,9 +5732,9 @@ static SSDataBlock* doSysTableScan(SOperatorInfo *pOperator, bool* newgroup) { pInfo->loadInfo.totalRows += numOfRows; pInfo->pRes->info.rows = numOfRows; -// pInfo->elapsedTime; -// pInfo->totalBytes; - return (pInfo->pRes->info.rows == 0)? NULL:pInfo->pRes; + // pInfo->elapsedTime; + // pInfo->totalBytes; + return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; } else { // load the meta from mnode of the given epset int64_t startTs = taosGetTimestampUs(); @@ -5625,7 +5747,7 @@ static SSDataBlock* doSysTableScan(SOperatorInfo *pOperator, bool* newgroup) { } int32_t contLen = tSerializeSRetrieveTableReq(NULL, 0, &pInfo->req); - char* buf1 = taosMemoryCalloc(1, contLen); + char* buf1 = taosMemoryCalloc(1, contLen); tSerializeSRetrieveTableReq(buf1, contLen, &pInfo->req); // send the fetch remote task result reques @@ -5654,15 +5776,16 @@ static SSDataBlock* doSysTableScan(SOperatorInfo *pOperator, bool* newgroup) { pInfo->req.showId = pRsp->handle; if (pRsp->numOfRows == 0) { -// qDebug("%s vgId:%d, taskID:0x%"PRIx64" %d of total completed, rowsOfSource:%"PRIu64", totalRows:%"PRIu64" try next", -// GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pExchangeInfo->current + 1, -// pDataInfo->totalRows, pExchangeInfo->totalRows); + // qDebug("%s vgId:%d, taskID:0x%"PRIx64" %d of total completed, rowsOfSource:%"PRIu64", totalRows:%"PRIu64" + // try next", + // GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->taskId, pExchangeInfo->current + 1, + // pDataInfo->totalRows, pExchangeInfo->totalRows); return NULL; } SRetrieveMetaTableRsp* pTableRsp = pInfo->pRsp; - setSDataBlockFromFetchRsp(pInfo->pRes, &pInfo->loadInfo, pTableRsp->numOfRows, - pTableRsp->data, pTableRsp->compLen, pOperator->numOfOutput, startTs, NULL, pInfo->scanCols); + setSDataBlockFromFetchRsp(pInfo->pRes, &pInfo->loadInfo, pTableRsp->numOfRows, pTableRsp->data, pTableRsp->compLen, + pOperator->numOfOutput, startTs, NULL, pInfo->scanCols); return doFilterResult(pInfo); } @@ -5671,9 +5794,10 @@ static SSDataBlock* doSysTableScan(SOperatorInfo *pOperator, bool* newgroup) { } SOperatorInfo* createSysTableScanOperatorInfo(void* pSysTableReadHandle, SSDataBlock* pResBlock, const SName* pName, - SNode* pCondition, SEpSet epset, SArray* colList, SExecTaskInfo* pTaskInfo, bool showRewrite, int32_t accountId) { + SNode* pCondition, SEpSet epset, SArray* colList, + SExecTaskInfo* pTaskInfo, bool showRewrite, int32_t accountId) { SSysTableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SSysTableScanInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { taosMemoryFreeClear(pInfo); taosMemoryFreeClear(pOperator); @@ -5681,15 +5805,15 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* pSysTableReadHandle, SSDataB return NULL; } - pInfo->accountId = accountId; + pInfo->accountId = accountId; pInfo->showRewrite = showRewrite; - pInfo->pRes = pResBlock; - pInfo->capacity = 4096; - pInfo->pCondition = pCondition; - pInfo->scanCols = colList; + pInfo->pRes = pResBlock; + pInfo->capacity = 4096; + pInfo->pCondition = pCondition; + pInfo->scanCols = colList; // TODO remove it - int32_t tableType = 0; + int32_t tableType = 0; const char* name = tNameGetTableName(pName); if (strncasecmp(name, TSDB_INS_TABLE_USER_DATABASES, tListLen(pName->tname)) == 0) { tableType = TSDB_MGMT_TABLE_DB; @@ -5706,7 +5830,7 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* pSysTableReadHandle, SSDataB } else if (strncasecmp(name, TSDB_INS_TABLE_USER_FUNCTIONS, tListLen(pName->tname)) == 0) { tableType = TSDB_MGMT_TABLE_FUNC; } else if (strncasecmp(name, TSDB_INS_TABLE_USER_INDEXES, tListLen(pName->tname)) == 0) { -// tableType = TSDB_MGMT_TABLE_INDEX; + // tableType = TSDB_MGMT_TABLE_INDEX; } else if (strncasecmp(name, TSDB_INS_TABLE_USER_STABLES, tListLen(pName->tname)) == 0) { tableType = TSDB_MGMT_TABLE_STB; } else if (strncasecmp(name, TSDB_INS_TABLE_USER_STREAMS, tListLen(pName->tname)) == 0) { @@ -5716,7 +5840,7 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* pSysTableReadHandle, SSDataB } else if (strncasecmp(name, TSDB_INS_TABLE_VGROUPS, tListLen(pName->tname)) == 0) { tableType = TSDB_MGMT_TABLE_VGROUP; } else if (strncasecmp(name, TSDB_INS_TABLE_USER_TABLE_DISTRIBUTED, tListLen(pName->tname)) == 0) { -// tableType = TSDB_MGMT_TABLE_DIST; + // tableType = TSDB_MGMT_TABLE_DIST; } else { ASSERT(0); } @@ -5731,7 +5855,7 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* pSysTableReadHandle, SSDataB pInfo->epSet = epset; #if 1 - { // todo refactor + { // todo refactor SRpcInit rpcInit; memset(&rpcInit, 0, sizeof(rpcInit)); rpcInit.localPort = 0; @@ -5740,35 +5864,35 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* pSysTableReadHandle, SSDataB rpcInit.cfp = qProcessFetchRsp; rpcInit.sessions = tsMaxConnections; rpcInit.connType = TAOS_CONN_CLIENT; - rpcInit.user = (char *)"root"; + rpcInit.user = (char*)"root"; rpcInit.idleTime = tsShellActivityTimer * 1000; rpcInit.ckey = "key"; rpcInit.spi = 1; - rpcInit.secret = (char *)"dcc5bed04851fec854c035b2e40263b6"; + rpcInit.secret = (char*)"dcc5bed04851fec854c035b2e40263b6"; pInfo->pTransporter = rpcOpen(&rpcInit); if (pInfo->pTransporter == NULL) { - return NULL; // todo + return NULL; // todo } } #endif } - pOperator->name = "SysTableScanOperator"; - pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN; - pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; - pOperator->numOfOutput = pResBlock->info.numOfCols; - pOperator->getNextFn = doSysTableScan; - pOperator->closeFn = destroySysTableScannerOperatorInfo; - pOperator->pTaskInfo = pTaskInfo; + pOperator->name = "SysTableScanOperator"; + pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN; + pOperator->blockingOptr = false; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; + pOperator->numOfOutput = pResBlock->info.numOfCols; + pOperator->getNextFn = doSysTableScan; + pOperator->closeFn = destroySysTableScannerOperatorInfo; + pOperator->pTaskInfo = pTaskInfo; return pOperator; } SArray* getOrderCheckColumns(STaskAttr* pQuery) { - int32_t numOfCols = (pQuery->pGroupbyExpr == NULL)? 0: taosArrayGetSize(pQuery->pGroupbyExpr->columnInfo); + int32_t numOfCols = (pQuery->pGroupbyExpr == NULL) ? 0 : taosArrayGetSize(pQuery->pGroupbyExpr->columnInfo); SArray* pOrderColumns = NULL; if (numOfCols > 0) { @@ -5787,12 +5911,12 @@ SArray* getOrderCheckColumns(STaskAttr* pQuery) { } { - numOfCols = (int32_t) taosArrayGetSize(pOrderColumns); - for(int32_t i = 0; i < numOfCols; ++i) { + numOfCols = (int32_t)taosArrayGetSize(pOrderColumns); + for (int32_t i = 0; i < numOfCols; ++i) { SColIndex* index = taosArrayGet(pOrderColumns, i); - for(int32_t j = 0; j < pQuery->numOfOutput; ++j) { + for (int32_t j = 0; j < pQuery->numOfOutput; ++j) { SExprBasicInfo* pExpr = &pQuery->pExpr1[j].base; - int32_t functionId = getExprFunctionId(&pQuery->pExpr1[j]); + int32_t functionId = getExprFunctionId(&pQuery->pExpr1[j]); if (index->colId == pExpr->pParam[0].pCol->colId && (functionId == FUNCTION_PRJ || functionId == FUNCTION_TAG || functionId == FUNCTION_TS)) { @@ -5807,7 +5931,7 @@ SArray* getOrderCheckColumns(STaskAttr* pQuery) { } SArray* getResultGroupCheckColumns(STaskAttr* pQuery) { - int32_t numOfCols = (pQuery->pGroupbyExpr == NULL)? 0 : taosArrayGetSize(pQuery->pGroupbyExpr->columnInfo); + int32_t numOfCols = (pQuery->pGroupbyExpr == NULL) ? 0 : taosArrayGetSize(pQuery->pGroupbyExpr->columnInfo); SArray* pOrderColumns = NULL; if (numOfCols > 0) { @@ -5816,23 +5940,23 @@ SArray* getResultGroupCheckColumns(STaskAttr* pQuery) { pOrderColumns = taosArrayInit(4, sizeof(SColIndex)); } - for(int32_t i = 0; i < numOfCols; ++i) { + for (int32_t i = 0; i < numOfCols; ++i) { SColIndex* index = taosArrayGet(pOrderColumns, i); bool found = false; - for(int32_t j = 0; j < pQuery->numOfOutput; ++j) { + for (int32_t j = 0; j < pQuery->numOfOutput; ++j) { SExprBasicInfo* pExpr = &pQuery->pExpr1[j].base; - int32_t functionId = getExprFunctionId(&pQuery->pExpr1[j]); + int32_t functionId = getExprFunctionId(&pQuery->pExpr1[j]); // FUNCTION_TAG_DUMMY function needs to be ignored -// if (index->colId == pExpr->pColumns->info.colId && -// ((TSDB_COL_IS_TAG(pExpr->pColumns->flag) && functionId == FUNCTION_TAG) || -// (TSDB_COL_IS_NORMAL_COL(pExpr->pColumns->flag) && functionId == FUNCTION_PRJ))) { -// index->colIndex = j; -// index->colId = pExpr->resSchema.colId; -// found = true; -// break; -// } + // if (index->colId == pExpr->pColumns->info.colId && + // ((TSDB_COL_IS_TAG(pExpr->pColumns->flag) && functionId == FUNCTION_TAG) || + // (TSDB_COL_IS_NORMAL_COL(pExpr->pColumns->flag) && functionId == FUNCTION_PRJ))) { + // index->colIndex = j; + // index->colId = pExpr->resSchema.colId; + // found = true; + // break; + // } } assert(found && index->colIndex >= 0 && index->colIndex < pQuery->numOfOutput); @@ -5841,11 +5965,11 @@ SArray* getResultGroupCheckColumns(STaskAttr* pQuery) { return pOrderColumns; } -static int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx *pCtx, int32_t numOfOutput, const char* pKey); -static void cleanupAggSup(SAggSupporter* pAggSup); +static int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t numOfOutput, const char* pKey); +static void cleanupAggSup(SAggSupporter* pAggSup); static void destroySortedMergeOperatorInfo(void* param, int32_t numOfOutput) { - SSortedMergeOperatorInfo* pInfo = (SSortedMergeOperatorInfo*) param; + SSortedMergeOperatorInfo* pInfo = (SSortedMergeOperatorInfo*)param; taosArrayDestroy(pInfo->pSortInfo); taosArrayDestroy(pInfo->groupInfo); @@ -5858,7 +5982,7 @@ static void destroySortedMergeOperatorInfo(void* param, int32_t numOfOutput) { } static void destroySlimitOperatorInfo(void* param, int32_t numOfOutput) { - SSLimitOperatorInfo *pInfo = (SSLimitOperatorInfo*) param; + SSLimitOperatorInfo* pInfo = (SSLimitOperatorInfo*)param; taosArrayDestroy(pInfo->orderColumnList); pInfo->pRes = blockDataDestroy(pInfo->pRes); taosMemoryFreeClear(pInfo->prevRow); @@ -5873,10 +5997,10 @@ static void assignExprInfo(SExprInfo* dst, const SExprInfo* src) { dst->base.pParam = taosMemoryCalloc(src->base.numOfParams, sizeof(SColumn)); memcpy(dst->base.pParam, src->base.pParam, sizeof(SColumn) * src->base.numOfParams); -// memset(dst->base.param, 0, sizeof(SVariant) * tListLen(dst->base.param)); -// for (int32_t j = 0; j < src->base.numOfParams; ++j) { -// taosVariantAssign(&dst->base.param[j], &src->base.param[j]); -// } + // memset(dst->base.param, 0, sizeof(SVariant) * tListLen(dst->base.param)); + // for (int32_t j = 0; j < src->base.numOfParams; ++j) { + // taosVariantAssign(&dst->base.param[j], &src->base.param[j]); + // } } static SExprInfo* exprArrayDup(SArray* pExprList) { @@ -5892,7 +6016,7 @@ static SExprInfo* exprArrayDup(SArray* pExprList) { } // TODO merge aggregate super table -static void appendOneRowToDataBlock(SSDataBlock *pBlock, STupleHandle* pTupleHandle) { +static void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle) { for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) { SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i); @@ -5908,10 +6032,11 @@ static void appendOneRowToDataBlock(SSDataBlock *pBlock, STupleHandle* pTupleHan pBlock->info.rows += 1; } -static SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, bool hasVarCol, int32_t capacity) { +static SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, bool hasVarCol, + int32_t capacity) { blockDataCleanup(pDataBlock); - while(1) { + while (1) { STupleHandle* pTupleHandle = tsortNextTuple(pHandle); if (pTupleHandle == NULL) { break; @@ -5923,17 +6048,17 @@ static SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataB } } - return (pDataBlock->info.rows > 0)? pDataBlock:NULL; + return (pDataBlock->info.rows > 0) ? pDataBlock : NULL; } SSDataBlock* loadNextDataBlock(void* param) { - SOperatorInfo* pOperator = (SOperatorInfo*) param; - bool newgroup = false; + SOperatorInfo* pOperator = (SOperatorInfo*)param; + bool newgroup = false; return pOperator->getNextFn(pOperator, &newgroup); } -static bool needToMerge(SSDataBlock* pBlock, SArray* groupInfo, char **buf, int32_t rowIndex) { +static bool needToMerge(SSDataBlock* pBlock, SArray* groupInfo, char** buf, int32_t rowIndex) { size_t size = taosArrayGetSize(groupInfo); if (size == 0) { return true; @@ -5943,7 +6068,7 @@ static bool needToMerge(SSDataBlock* pBlock, SArray* groupInfo, char **buf, int3 int32_t* index = taosArrayGet(groupInfo, i); SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, *index); - bool isNull = colDataIsNull(pColInfo, rowIndex, pBlock->info.rows, NULL); + bool isNull = colDataIsNull(pColInfo, rowIndex, pBlock->info.rows, NULL); if ((isNull && buf[i] != NULL) || (!isNull && buf[i] == NULL)) { return false; @@ -5968,27 +6093,28 @@ static bool needToMerge(SSDataBlock* pBlock, SArray* groupInfo, char **buf, int3 return 0; } -static void doMergeResultImpl(SSortedMergeOperatorInfo* pInfo, SqlFunctionCtx *pCtx, int32_t numOfExpr, int32_t rowIndex) { - for (int32_t j = 0; j < numOfExpr; ++j) { // TODO set row index +static void doMergeResultImpl(SSortedMergeOperatorInfo* pInfo, SqlFunctionCtx* pCtx, int32_t numOfExpr, + int32_t rowIndex) { + for (int32_t j = 0; j < numOfExpr; ++j) { // TODO set row index pCtx[j].startRow = rowIndex; } for (int32_t j = 0; j < numOfExpr; ++j) { int32_t functionId = pCtx[j].functionId; -// pCtx[j].fpSet->addInput(&pCtx[j]); + // pCtx[j].fpSet->addInput(&pCtx[j]); -// if (functionId < 0) { -// SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1); -// doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE); -// } else { -// assert(!TSDB_FUNC_IS_SCALAR(functionId)); -// aAggs[functionId].mergeFunc(&pCtx[j]); -// } + // if (functionId < 0) { + // SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1); + // doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE); + // } else { + // assert(!TSDB_FUNC_IS_SCALAR(functionId)); + // aAggs[functionId].mergeFunc(&pCtx[j]); + // } } } -static void doFinalizeResultImpl(SqlFunctionCtx *pCtx, int32_t numOfExpr) { - for(int32_t j = 0; j < numOfExpr; ++j) { +static void doFinalizeResultImpl(SqlFunctionCtx* pCtx, int32_t numOfExpr) { + for (int32_t j = 0; j < numOfExpr; ++j) { int32_t functionId = pCtx[j].functionId; // if (functionId == FUNC_TAG_DUMMY || functionId == FUNC_TS_DUMMY) { // continue; @@ -6003,10 +6129,10 @@ static void doFinalizeResultImpl(SqlFunctionCtx *pCtx, int32_t numOfExpr) { } static bool saveCurrentTuple(char** rowColData, SArray* pColumnList, SSDataBlock* pBlock, int32_t rowIndex) { - int32_t size = (int32_t) taosArrayGetSize(pColumnList); + int32_t size = (int32_t)taosArrayGetSize(pColumnList); - for(int32_t i = 0; i < size; ++i) { - int32_t* index = taosArrayGet(pColumnList, i); + for (int32_t i = 0; i < size; ++i) { + int32_t* index = taosArrayGet(pColumnList, i); SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, *index); char* data = colDataGetData(pColInfo, rowIndex); @@ -6020,11 +6146,11 @@ static void doMergeImpl(SOperatorInfo* pOperator, int32_t numOfExpr, SSDataBlock SSortedMergeOperatorInfo* pInfo = pOperator->info; SqlFunctionCtx* pCtx = pInfo->binfo.pCtx; - for(int32_t i = 0; i < pBlock->info.numOfCols; ++i) { + for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) { pCtx[i].size = 1; } - for(int32_t i = 0; i < pBlock->info.rows; ++i) { + for (int32_t i = 0; i < pBlock->info.rows; ++i) { if (!pInfo->hasGroupVal) { ASSERT(i == 0); doMergeResultImpl(pInfo, pCtx, numOfExpr, i); @@ -6058,13 +6184,12 @@ static void doMergeImpl(SOperatorInfo* pOperator, int32_t numOfExpr, SSDataBlock static SSDataBlock* doMerge(SOperatorInfo* pOperator) { SSortedMergeOperatorInfo* pInfo = pOperator->info; - SSortHandle* pHandle = pInfo->pSortHandle; + SSortHandle* pHandle = pInfo->pSortHandle; SSDataBlock* pDataBlock = createOneDataBlock(pInfo->binfo.pRes); blockDataEnsureCapacity(pDataBlock, pInfo->binfo.capacity); - while(1) { - + while (1) { blockDataCleanup(pDataBlock); while (1) { STupleHandle* pTupleHandle = tsortNextTuple(pHandle); @@ -6084,7 +6209,8 @@ static SSDataBlock* doMerge(SOperatorInfo* pOperator) { } setInputDataBlock(pOperator, pInfo->binfo.pCtx, pDataBlock, TSDB_ORDER_ASC); - // updateOutputBuf(&pInfo->binfo, &pAggInfo->bufCapacity, pBlock->info.rows * pAggInfo->resultRowFactor, pOperator->pRuntimeEnv, true); + // updateOutputBuf(&pInfo->binfo, &pAggInfo->bufCapacity, pBlock->info.rows * pAggInfo->resultRowFactor, + // pOperator->pRuntimeEnv, true); doMergeImpl(pOperator, pOperator->numOfOutput, pDataBlock); // flush to tuple store, and after all data have been handled, return to upstream node or sink node } @@ -6097,27 +6223,27 @@ static SSDataBlock* doMerge(SOperatorInfo* pOperator) { // next group info data pInfo->binfo.pRes->info.rows += numOfRows; - return (pInfo->binfo.pRes->info.rows > 0)? pInfo->binfo.pRes:NULL; + return (pInfo->binfo.pRes->info.rows > 0) ? pInfo->binfo.pRes : NULL; } -static SSDataBlock* doSortedMerge(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doSortedMerge(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SSortedMergeOperatorInfo* pInfo = pOperator->info; if (pOperator->status == OP_RES_TO_RETURN) { return getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pInfo->hasVarCol, pInfo->binfo.capacity); } int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize; - pInfo->pSortHandle = tsortCreateSortHandle(pInfo->pSortInfo, SORT_MULTISOURCE_MERGE, pInfo->bufPageSize, - numOfBufPage, pInfo->binfo.pRes, "GET_TASKID(pTaskInfo)"); + pInfo->pSortHandle = tsortCreateSortHandle(pInfo->pSortInfo, SORT_MULTISOURCE_MERGE, pInfo->bufPageSize, numOfBufPage, + pInfo->binfo.pRes, "GET_TASKID(pTaskInfo)"); tsortSetFetchRawDataFp(pInfo->pSortHandle, loadNextDataBlock); - for(int32_t i = 0; i < pOperator->numOfDownstream; ++i) { + for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) { SGenericSource* ps = taosMemoryCalloc(1, sizeof(SGenericSource)); ps->param = pOperator->pDownstream[i]; tsortAddSource(pInfo->pSortHandle, ps); @@ -6132,7 +6258,8 @@ static SSDataBlock* doSortedMerge(SOperatorInfo *pOperator, bool* newgroup) { return doMerge(pOperator); } -static int32_t initGroupCol(SExprInfo* pExprInfo, int32_t numOfCols, SArray* pGroupInfo, SSortedMergeOperatorInfo* pInfo) { +static int32_t initGroupCol(SExprInfo* pExprInfo, int32_t numOfCols, SArray* pGroupInfo, + SSortedMergeOperatorInfo* pInfo) { if (pGroupInfo == NULL || taosArrayGetSize(pGroupInfo) == 0) { return 0; } @@ -6145,10 +6272,10 @@ static int32_t initGroupCol(SExprInfo* pExprInfo, int32_t numOfCols, SArray* pGr return TSDB_CODE_OUT_OF_MEMORY; } - size_t numOfGroupCol = taosArrayGetSize(pInfo->groupInfo); - for(int32_t i = 0; i < numOfGroupCol; ++i) { + size_t numOfGroupCol = taosArrayGetSize(pInfo->groupInfo); + for (int32_t i = 0; i < numOfGroupCol; ++i) { SColumn* pCol = taosArrayGet(pGroupInfo, i); - for(int32_t j = 0; j < numOfCols; ++j) { + for (int32_t j = 0; j < numOfCols; ++j) { SExprInfo* pe = &pExprInfo[j]; if (pe->base.resSchema.colId == pCol->colId) { taosArrayPush(plist, pCol); @@ -6168,8 +6295,8 @@ static int32_t initGroupCol(SExprInfo* pExprInfo, int32_t numOfCols, SArray* pGr } int32_t offset = 0; - char *start = (char*)(pInfo->groupVal + (POINTER_BYTES * numOfGroupCol)); - for(int32_t i = 0; i < numOfGroupCol; ++i) { + char* start = (char*)(pInfo->groupVal + (POINTER_BYTES * numOfGroupCol)); + for (int32_t i = 0; i < numOfGroupCol; ++i) { pInfo->groupVal[i] = start + offset; SColumn* pCol = taosArrayGet(plist, i); offset += pCol->bytes; @@ -6180,14 +6307,16 @@ static int32_t initGroupCol(SExprInfo* pExprInfo, int32_t numOfCols, SArray* pGr return TSDB_CODE_SUCCESS; } -SOperatorInfo* createSortedMergeOperatorInfo(SOperatorInfo** downstream, int32_t numOfDownstream, SExprInfo* pExprInfo, int32_t num, SArray* pSortInfo, SArray* pGroupInfo, SExecTaskInfo* pTaskInfo) { +SOperatorInfo* createSortedMergeOperatorInfo(SOperatorInfo** downstream, int32_t numOfDownstream, SExprInfo* pExprInfo, + int32_t num, SArray* pSortInfo, SArray* pGroupInfo, + SExecTaskInfo* pTaskInfo) { SSortedMergeOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SSortedMergeOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { goto _error; } - pInfo->binfo.pCtx = createSqlFunctionCtx_rv(pExprInfo, num, &pInfo->binfo.rowCellInfoOffset); + pInfo->binfo.pCtx = createSqlFunctionCtx_rv(pExprInfo, num, &pInfo->binfo.rowCellInfoOffset); initResultRowInfo(&pInfo->binfo.resultRowInfo, (int32_t)1); if (pInfo->binfo.pCtx == NULL || pInfo->binfo.pRes == NULL) { @@ -6205,25 +6334,25 @@ SOperatorInfo* createSortedMergeOperatorInfo(SOperatorInfo** downstream, int32_t goto _error; } -// pInfo->resultRowFactor = (int32_t)(getRowNumForMultioutput(pRuntimeEnv->pQueryAttr, -// pRuntimeEnv->pQueryAttr->topBotQuery, false)); - pInfo->sortBufSize = 1024 * 16; // 1MB - pInfo->bufPageSize = 1024; - pInfo->pSortInfo = pSortInfo; + // pInfo->resultRowFactor = (int32_t)(getRowNumForMultioutput(pRuntimeEnv->pQueryAttr, + // pRuntimeEnv->pQueryAttr->topBotQuery, false)); + pInfo->sortBufSize = 1024 * 16; // 1MB + pInfo->bufPageSize = 1024; + pInfo->pSortInfo = pSortInfo; pInfo->binfo.capacity = blockDataGetCapacityInRow(pInfo->binfo.pRes, pInfo->bufPageSize); - pOperator->name = "SortedMerge"; + pOperator->name = "SortedMerge"; // pOperator->operatorType = OP_SortedMerge; pOperator->blockingOptr = true; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; - pOperator->numOfOutput = num; - pOperator->pExpr = pExprInfo; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; + pOperator->numOfOutput = num; + pOperator->pExpr = pExprInfo; - pOperator->pTaskInfo = pTaskInfo; - pOperator->getNextFn = doSortedMerge; - pOperator->closeFn = destroySortedMergeOperatorInfo; + pOperator->pTaskInfo = pTaskInfo; + pOperator->getNextFn = doSortedMerge; + pOperator->closeFn = destroySortedMergeOperatorInfo; code = appendDownstream(pOperator, downstream, numOfDownstream); if (code != TSDB_CODE_SUCCESS) { @@ -6232,7 +6361,7 @@ SOperatorInfo* createSortedMergeOperatorInfo(SOperatorInfo** downstream, int32_t return pOperator; - _error: +_error: if (pInfo != NULL) { destroySortedMergeOperatorInfo(pInfo, num); } @@ -6243,22 +6372,22 @@ SOperatorInfo* createSortedMergeOperatorInfo(SOperatorInfo** downstream, int32_t return NULL; } -static SSDataBlock* doSort(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doSort(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SSortOperatorInfo* pInfo = pOperator->info; - bool hasVarCol = pInfo->pDataBlock->info.hasVarCol; + bool hasVarCol = pInfo->pDataBlock->info.hasVarCol; if (pOperator->status == OP_RES_TO_RETURN) { return getSortedBlockData(pInfo->pSortHandle, pInfo->pDataBlock, hasVarCol, pInfo->numOfRowsInRes); } int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize; - pInfo->pSortHandle = tsortCreateSortHandle(pInfo->pSortInfo, SORT_SINGLESOURCE_SORT, pInfo->bufPageSize, - numOfBufPage, pInfo->pDataBlock, "GET_TASKID(pTaskInfo)"); + pInfo->pSortHandle = tsortCreateSortHandle(pInfo->pSortInfo, SORT_SINGLESOURCE_SORT, pInfo->bufPageSize, numOfBufPage, + pInfo->pDataBlock, "GET_TASKID(pTaskInfo)"); tsortSetFetchRawDataFp(pInfo->pSortHandle, loadNextDataBlock); @@ -6275,9 +6404,10 @@ static SSDataBlock* doSort(SOperatorInfo *pOperator, bool* newgroup) { return getSortedBlockData(pInfo->pSortHandle, pInfo->pDataBlock, hasVarCol, pInfo->numOfRowsInRes); } -SOperatorInfo *createSortOperatorInfo(SOperatorInfo* downstream, SSDataBlock* pResBlock, SArray* pSortInfo, SExecTaskInfo* pTaskInfo) { +SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSDataBlock* pResBlock, SArray* pSortInfo, + SExecTaskInfo* pTaskInfo) { SSortOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SSortOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { taosMemoryFreeClear(pInfo); taosMemoryFreeClear(pOperator); @@ -6285,32 +6415,30 @@ SOperatorInfo *createSortOperatorInfo(SOperatorInfo* downstream, SSDataBlock* pR return NULL; } - pInfo->sortBufSize = 1024 * 16; // 1MB, TODO dynamic set the available sort buffer - pInfo->bufPageSize = 1024; - pInfo->numOfRowsInRes = 1024; - pInfo->pDataBlock = pResBlock; - pInfo->pSortInfo = pSortInfo; + pInfo->sortBufSize = 1024 * 16; // 1MB, TODO dynamic set the available sort buffer + pInfo->bufPageSize = 1024; + pInfo->numOfRowsInRes = 1024; + pInfo->pDataBlock = pResBlock; + pInfo->pSortInfo = pSortInfo; - pOperator->name = "Sort"; - pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_SORT; - pOperator->blockingOptr = true; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; + pOperator->name = "Sort"; + pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_SORT; + pOperator->blockingOptr = true; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; - pOperator->pTaskInfo = pTaskInfo; - pOperator->getNextFn = doSort; - pOperator->closeFn = destroyOrderOperatorInfo; + pOperator->pTaskInfo = pTaskInfo; + pOperator->getNextFn = doSort; + pOperator->closeFn = destroyOrderOperatorInfo; int32_t code = appendDownstream(pOperator, &downstream, 1); return pOperator; } -static int32_t getTableScanOrder(STableScanInfo* pTableScanInfo) { - return pTableScanInfo->order; -} +static int32_t getTableScanOrder(STableScanInfo* pTableScanInfo) { return pTableScanInfo->order; } // this is a blocking operator -static int32_t doOpenAggregateOptr(SOperatorInfo *pOperator) { +static int32_t doOpenAggregateOptr(SOperatorInfo* pOperator) { if (OPTR_IS_OPENED(pOperator)) { return TSDB_CODE_SUCCESS; } @@ -6356,15 +6484,15 @@ static int32_t doOpenAggregateOptr(SOperatorInfo *pOperator) { return TSDB_CODE_SUCCESS; } -static SSDataBlock* getAggregateResult(SOperatorInfo *pOperator, bool* newgroup) { - SAggOperatorInfo *pAggInfo = pOperator->info; +static SSDataBlock* getAggregateResult(SOperatorInfo* pOperator, bool* newgroup) { + SAggOperatorInfo* pAggInfo = pOperator->info; SOptrBasicInfo* pInfo = &pAggInfo->binfo; if (pOperator->status == OP_EXEC_DONE) { return NULL; } - SExecTaskInfo *pTaskInfo = pOperator->pTaskInfo; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; pTaskInfo->code = pOperator->_openFn(pOperator); if (pTaskInfo->code != TSDB_CODE_SUCCESS) { return NULL; @@ -6373,7 +6501,7 @@ static SSDataBlock* getAggregateResult(SOperatorInfo *pOperator, bool* newgroup) getNumOfResult(pInfo->pCtx, pOperator->numOfOutput, pInfo->pRes); doSetOperatorCompleted(pOperator); - return (blockDataGetNumOfRows(pInfo->pRes) != 0)? pInfo->pRes:NULL; + return (blockDataGetNumOfRows(pInfo->pRes) != 0) ? pInfo->pRes : NULL; } static void aggEncodeResultRow(SOperatorInfo* pOperator, char **result, int32_t *length) { @@ -6400,30 +6528,30 @@ static void aggEncodeResultRow(SOperatorInfo* pOperator, char **result, int32_t } int32_t size = taosHashGetSize(pSup->pResultRowHashTable); - size_t keyLen = POINTER_BYTES; // estimate the key length + size_t keyLen = POINTER_BYTES; // estimate the key length int32_t totalSize = sizeof(int32_t) + size * (sizeof(int32_t) + keyLen + sizeof(int32_t) + pSup->resultRowSize); *result = taosMemoryCalloc(1, totalSize); - if(*result == NULL){ + if (*result == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return; } *(int32_t*)(*result) = size; int32_t offset = sizeof(int32_t); - void *pIter = taosHashIterate(pSup->pResultRowHashTable, NULL); + void* pIter = taosHashIterate(pSup->pResultRowHashTable, NULL); while (pIter) { - void *key = taosHashGetKey(pIter, &keyLen); - SResultRow **p1 = (SResultRow **)pIter; + void* key = taosHashGetKey(pIter, &keyLen); + SResultRow** p1 = (SResultRow**)pIter; // recalculate the result size int32_t realTotalSize = offset + sizeof(int32_t) + keyLen + sizeof(int32_t) + pSup->resultRowSize; - if (realTotalSize > totalSize){ - char *tmp = taosMemoryRealloc(*result, realTotalSize); - if (tmp == NULL){ + if (realTotalSize > totalSize) { + char* tmp = taosMemoryRealloc(*result, realTotalSize); + if (tmp == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; taosMemoryFree(*result); *result = NULL; return; - }else{ + } else { *result = tmp; } } @@ -6442,14 +6570,14 @@ static void aggEncodeResultRow(SOperatorInfo* pOperator, char **result, int32_t pIter = taosHashIterate(pSup->pResultRowHashTable, pIter); } - if(length) { + if (length) { *length = offset; } return; } -static bool aggDecodeResultRow(SOperatorInfo* pOperator, char *result, int32_t length) { - if (!result || length <= 0){ +static bool aggDecodeResultRow(SOperatorInfo* pOperator, char* result, int32_t length) { + if (!result || length <= 0) { return false; } @@ -6480,13 +6608,13 @@ static bool aggDecodeResultRow(SOperatorInfo* pOperator, char *result, int32_t l int32_t count = *(int32_t*)(result); int32_t offset = sizeof(int32_t); - while(count-- > 0 && length > offset){ + while (count-- > 0 && length > offset) { int32_t keyLen = *(int32_t*)(result + offset); offset += sizeof(int32_t); - uint64_t tableGroupId = *(uint64_t *)(result + offset); - SResultRow *resultRow = getNewResultRow_rv(pSup->pResultBuf, tableGroupId, pSup->resultRowSize); - if (!resultRow){ + uint64_t tableGroupId = *(uint64_t*)(result + offset); + SResultRow* resultRow = getNewResultRow_rv(pSup->pResultBuf, tableGroupId, pSup->resultRowSize); + if (!resultRow) { terrno = TSDB_CODE_TSC_INVALID_INPUT; return false; } @@ -6495,7 +6623,7 @@ static bool aggDecodeResultRow(SOperatorInfo* pOperator, char *result, int32_t l offset += keyLen; int32_t valueLen = *(int32_t*)(result + offset); - if (valueLen != pSup->resultRowSize){ + if (valueLen != pSup->resultRowSize) { terrno = TSDB_CODE_TSC_INVALID_INPUT; return false; } @@ -6511,24 +6639,25 @@ static bool aggDecodeResultRow(SOperatorInfo* pOperator, char *result, int32_t l //pInfo->resultRowInfo.pPosition[pInfo->resultRowInfo.size++] = (SResultRowPosition) {.pageId = resultRow->pageId, .offset = resultRow->offset}; } - if (offset != length){ + if (offset != length) { terrno = TSDB_CODE_TSC_INVALID_INPUT; return false; } return true; } -static SSDataBlock* doMultiTableAggregate(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doMultiTableAggregate(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } SAggOperatorInfo* pAggInfo = pOperator->info; - SOptrBasicInfo* pInfo = &pAggInfo->binfo; - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SOptrBasicInfo* pInfo = &pAggInfo->binfo; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (pOperator->status == OP_RES_TO_RETURN) { - toSDatablock(&pAggInfo->groupResInfo, pAggInfo->pResultBuf, pInfo->pRes, pAggInfo->binfo.capacity, pAggInfo->binfo.rowCellInfoOffset); + toSDatablock(&pAggInfo->groupResInfo, pAggInfo->pResultBuf, pInfo->pRes, pAggInfo->binfo.capacity, + pAggInfo->binfo.rowCellInfoOffset); if (pInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pAggInfo->groupResInfo)) { pOperator->status = OP_EXEC_DONE; @@ -6538,10 +6667,10 @@ static SSDataBlock* doMultiTableAggregate(SOperatorInfo *pOperator, bool* newgro } // table scan order - int32_t order = TSDB_ORDER_ASC; + int32_t order = TSDB_ORDER_ASC; SOperatorInfo* downstream = pOperator->pDownstream[0]; - while(1) { + while (1) { publishOperatorProfEvent(downstream, QUERY_PROF_BEFORE_OPERATOR_EXEC); SSDataBlock* pBlock = downstream->getNextFn(downstream, newgroup); publishOperatorProfEvent(downstream, QUERY_PROF_AFTER_OPERATOR_EXEC); @@ -6550,11 +6679,11 @@ static SSDataBlock* doMultiTableAggregate(SOperatorInfo *pOperator, bool* newgro break; } -// setTagValue(pOperator, pRuntimeEnv->current->pTable, pInfo->pCtx, pOperator->numOfOutput); -// if (downstream->operatorType == OP_TableScan) { -// STableScanInfo* pScanInfo = downstream->info; -// order = getTableScanOrder(pScanInfo); -// } + // setTagValue(pOperator, pRuntimeEnv->current->pTable, pInfo->pCtx, pOperator->numOfOutput); + // if (downstream->operatorType == OP_TableScan) { + // STableScanInfo* pScanInfo = downstream->info; + // order = getTableScanOrder(pScanInfo); + // } // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pOperator, pInfo->pCtx, pBlock, order); @@ -6567,8 +6696,9 @@ static SSDataBlock* doMultiTableAggregate(SOperatorInfo *pOperator, bool* newgro key = pBlock->info.window.skey; TSKEY_MIN_SUB(key, -1); } - - setExecutionContext(pOperator->numOfOutput, pAggInfo->current->groupIndex, key, pTaskInfo, pAggInfo->current, pAggInfo); + + setExecutionContext(pOperator->numOfOutput, pAggInfo->current->groupIndex, key, pTaskInfo, pAggInfo->current, + pAggInfo); doAggregateImpl(pOperator, 0, pInfo->pCtx); } @@ -6577,7 +6707,8 @@ static SSDataBlock* doMultiTableAggregate(SOperatorInfo *pOperator, bool* newgro updateNumOfRowsInResultRows(pInfo->pCtx, pOperator->numOfOutput, &pInfo->resultRowInfo, pInfo->rowCellInfoOffset); initGroupResInfo(&pAggInfo->groupResInfo, &pInfo->resultRowInfo); - toSDatablock(&pAggInfo->groupResInfo, pAggInfo->pResultBuf, pInfo->pRes, pAggInfo->binfo.capacity, pAggInfo->binfo.rowCellInfoOffset); + toSDatablock(&pAggInfo->groupResInfo, pAggInfo->pResultBuf, pInfo->pRes, pAggInfo->binfo.capacity, + pAggInfo->binfo.rowCellInfoOffset); if (pInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pAggInfo->groupResInfo)) { doSetOperatorCompleted(pOperator); @@ -6586,9 +6717,9 @@ static SSDataBlock* doMultiTableAggregate(SOperatorInfo *pOperator, bool* newgro return pInfo->pRes; } -static SSDataBlock* doProjectOperation(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doProjectOperation(SOperatorInfo* pOperator, bool* newgroup) { SProjectOperatorInfo* pProjectInfo = pOperator->info; - SOptrBasicInfo *pInfo = &pProjectInfo->binfo; + SOptrBasicInfo* pInfo = &pProjectInfo->binfo; SSDataBlock* pRes = pInfo->pRes; blockDataCleanup(pRes); @@ -6599,16 +6730,16 @@ static SSDataBlock* doProjectOperation(SOperatorInfo *pOperator, bool* newgroup) *newgroup = true; // todo dynamic set tags -// if (pTableQueryInfo != NULL) { -// setTagValue(pOperator, pTableQueryInfo->pTable, pInfo->pCtx, pOperator->numOfOutput); -// } + // if (pTableQueryInfo != NULL) { + // setTagValue(pOperator, pTableQueryInfo->pTable, pInfo->pCtx, pOperator->numOfOutput); + // } // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pOperator, pInfo->pCtx, pBlock, TSDB_ORDER_ASC); blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows); projectApplyFunctions(pOperator->pExpr, pInfo->pRes, pBlock, pInfo->pCtx, pOperator->numOfOutput); - if (pRes->info.rows >= pProjectInfo->binfo.capacity*0.8) { + if (pRes->info.rows >= pProjectInfo->binfo.capacity * 0.8) { copyTsColoum(pRes, pInfo->pCtx, pOperator->numOfOutput); resetResultRowEntryResult(pInfo->pCtx, pOperator->numOfOutput); return pRes; @@ -6617,7 +6748,7 @@ static SSDataBlock* doProjectOperation(SOperatorInfo *pOperator, bool* newgroup) SOperatorInfo* downstream = pOperator->pDownstream[0]; - while(1) { + while (1) { bool prevVal = *newgroup; // The downstream exec may change the value of the newgroup, so use a local variable instead. @@ -6637,7 +6768,7 @@ static SSDataBlock* doProjectOperation(SOperatorInfo *pOperator, bool* newgroup) if (pRes->info.rows > 0) { pProjectInfo->existDataBlock = pBlock; break; - } else { // init output buffer for a new group data + } else { // init output buffer for a new group data initCtxOutputBuffer(pInfo->pCtx, pOperator->numOfOutput); } } @@ -6658,18 +6789,18 @@ static SSDataBlock* doProjectOperation(SOperatorInfo *pOperator, bool* newgroup) } } -// copyTsColoum(pRes, pInfo->pCtx, pOperator->numOfOutput); - return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL; + // copyTsColoum(pRes, pInfo->pCtx, pOperator->numOfOutput); + return (pInfo->pRes->info.rows > 0) ? pInfo->pRes : NULL; } -static SSDataBlock* doLimit(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doLimit(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } SLimitOperatorInfo* pInfo = pOperator->info; - SSDataBlock* pBlock = NULL; + SSDataBlock* pBlock = NULL; SOperatorInfo* pDownstream = pOperator->pDownstream[0]; while (1) { @@ -6686,7 +6817,7 @@ static SSDataBlock* doLimit(SOperatorInfo *pOperator, bool* newgroup) { break; } else if (pInfo->currentOffset >= pBlock->info.rows) { pInfo->currentOffset -= pBlock->info.rows; - } else { // TODO handle the data movement + } else { // TODO handle the data movement int32_t remain = (int32_t)(pBlock->info.rows - pInfo->currentOffset); pBlock->info.rows = remain; @@ -6715,17 +6846,17 @@ static SSDataBlock* doLimit(SOperatorInfo *pOperator, bool* newgroup) { } static SSDataBlock* doFilter(void* param, bool* newgroup) { - SOperatorInfo *pOperator = (SOperatorInfo *)param; + SOperatorInfo* pOperator = (SOperatorInfo*)param; if (pOperator->status == OP_EXEC_DONE) { return NULL; } SFilterOperatorInfo* pCondInfo = pOperator->info; - STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv; + STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv; while (1) { publishOperatorProfEvent(pOperator->pDownstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC); - SSDataBlock *pBlock = pOperator->pDownstream[0]->getNextFn(pOperator->pDownstream[0], newgroup); + SSDataBlock* pBlock = pOperator->pDownstream[0]->getNextFn(pOperator->pDownstream[0], newgroup); publishOperatorProfEvent(pOperator->pDownstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC); if (pBlock == NULL) { @@ -6745,7 +6876,7 @@ static SSDataBlock* doFilter(void* param, bool* newgroup) { return NULL; } -static int32_t doOpenIntervalAgg(SOperatorInfo *pOperator) { +static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) { if (OPTR_IS_OPENED(pOperator)) { return TSDB_CODE_SUCCESS; } @@ -6754,7 +6885,7 @@ static int32_t doOpenIntervalAgg(SOperatorInfo *pOperator) { int32_t order = TSDB_ORDER_ASC; // STimeWindow win = pQueryAttr->window; - bool newgroup = false; + bool newgroup = false; SOperatorInfo* downstream = pOperator->pDownstream[0]; while (1) { @@ -6784,16 +6915,17 @@ static int32_t doOpenIntervalAgg(SOperatorInfo *pOperator) { } closeAllResultRows(&pInfo->binfo.resultRowInfo); - finalizeMultiTupleQueryResult(pInfo->binfo.pCtx, pOperator->numOfOutput, pInfo->aggSup.pResultBuf, &pInfo->binfo.resultRowInfo, pInfo->binfo.rowCellInfoOffset); + finalizeMultiTupleQueryResult(pInfo->binfo.pCtx, pOperator->numOfOutput, pInfo->aggSup.pResultBuf, + &pInfo->binfo.resultRowInfo, pInfo->binfo.rowCellInfoOffset); initGroupResInfo(&pInfo->groupResInfo, &pInfo->binfo.resultRowInfo); OPTR_SET_OPENED(pOperator); return TSDB_CODE_SUCCESS; } -static SSDataBlock* doBuildIntervalResult(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator, bool* newgroup) { STableIntervalOperatorInfo* pInfo = pOperator->info; - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (pOperator->status == OP_EXEC_DONE) { return NULL; @@ -6805,16 +6937,17 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo *pOperator, bool* newgro } blockDataEnsureCapacity(pInfo->binfo.pRes, pInfo->binfo.capacity); - toSDatablock(&pInfo->groupResInfo, pInfo->aggSup.pResultBuf, pInfo->binfo.pRes, pInfo->binfo.capacity, pInfo->binfo.rowCellInfoOffset); + toSDatablock(&pInfo->groupResInfo, pInfo->aggSup.pResultBuf, pInfo->binfo.pRes, pInfo->binfo.capacity, + pInfo->binfo.rowCellInfoOffset); if (pInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) { doSetOperatorCompleted(pOperator); } - return pInfo->binfo.pRes->info.rows == 0? NULL:pInfo->binfo.pRes; + return pInfo->binfo.pRes->info.rows == 0 ? NULL : pInfo->binfo.pRes; } -static SSDataBlock* doAllIntervalAgg(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doAllIntervalAgg(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } @@ -6823,7 +6956,7 @@ static SSDataBlock* doAllIntervalAgg(SOperatorInfo *pOperator, bool* newgroup) { STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv; if (pOperator->status == OP_RES_TO_RETURN) { -// toSDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pIntervalInfo->pRes); + // toSDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pIntervalInfo->pRes); if (pIntervalInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pRuntimeEnv->groupResInfo)) { doSetOperatorCompleted(pOperator); @@ -6832,13 +6965,13 @@ static SSDataBlock* doAllIntervalAgg(SOperatorInfo *pOperator, bool* newgroup) { return pIntervalInfo->binfo.pRes; } - STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; - int32_t order = pQueryAttr->order.order; + STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; + int32_t order = pQueryAttr->order.order; STimeWindow win = pQueryAttr->window; SOperatorInfo* downstream = pOperator->pDownstream[0]; - while(1) { + while (1) { publishOperatorProfEvent(downstream, QUERY_PROF_BEFORE_OPERATOR_EXEC); SSDataBlock* pBlock = downstream->getNextFn(downstream, newgroup); publishOperatorProfEvent(downstream, QUERY_PROF_AFTER_OPERATOR_EXEC); @@ -6847,7 +6980,7 @@ static SSDataBlock* doAllIntervalAgg(SOperatorInfo *pOperator, bool* newgroup) { break; } -// setTagValue(pOperator, pRuntimeEnv->current->pTable, pIntervalInfo->pCtx, pOperator->numOfOutput); + // setTagValue(pOperator, pRuntimeEnv->current->pTable, pIntervalInfo->pCtx, pOperator->numOfOutput); // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pOperator, pIntervalInfo->binfo.pCtx, pBlock, pQueryAttr->order.order); @@ -6864,27 +6997,27 @@ static SSDataBlock* doAllIntervalAgg(SOperatorInfo *pOperator, bool* newgroup) { finalizeQueryResult(pIntervalInfo->binfo.pCtx, pOperator->numOfOutput); initGroupResInfo(&pRuntimeEnv->groupResInfo, &pIntervalInfo->binfo.resultRowInfo); -// toSDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pIntervalInfo->pRes); + // toSDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pIntervalInfo->pRes); if (pIntervalInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pRuntimeEnv->groupResInfo)) { pOperator->status = OP_EXEC_DONE; } - return pIntervalInfo->binfo.pRes->info.rows == 0? NULL:pIntervalInfo->binfo.pRes; + return pIntervalInfo->binfo.pRes->info.rows == 0 ? NULL : pIntervalInfo->binfo.pRes; } -static SSDataBlock* doSTableIntervalAgg(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doSTableIntervalAgg(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } STableIntervalOperatorInfo* pIntervalInfo = pOperator->info; - STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv; + STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv; if (pOperator->status == OP_RES_TO_RETURN) { int64_t st = taosGetTimestampUs(); -// copyToSDataBlock(NULL, 3000, pIntervalInfo->pRes, pIntervalInfo->rowCellInfoOffset); + // copyToSDataBlock(NULL, 3000, pIntervalInfo->pRes, pIntervalInfo->rowCellInfoOffset); if (pIntervalInfo->binfo.pRes->info.rows == 0 || !hasRemainData(&pRuntimeEnv->groupResInfo)) { doSetOperatorCompleted(pOperator); } @@ -6892,11 +7025,11 @@ static SSDataBlock* doSTableIntervalAgg(SOperatorInfo *pOperator, bool* newgroup } STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; - int32_t order = pQueryAttr->order.order; + int32_t order = pQueryAttr->order.order; SOperatorInfo* downstream = pOperator->pDownstream[0]; - while(1) { + while (1) { publishOperatorProfEvent(downstream, QUERY_PROF_BEFORE_OPERATOR_EXEC); SSDataBlock* pBlock = downstream->getNextFn(downstream, newgroup); publishOperatorProfEvent(downstream, QUERY_PROF_AFTER_OPERATOR_EXEC); @@ -6908,7 +7041,7 @@ static SSDataBlock* doSTableIntervalAgg(SOperatorInfo *pOperator, bool* newgroup // the pDataBlock are always the same one, no need to call this again STableQueryInfo* pTableQueryInfo = pRuntimeEnv->current; -// setTagValue(pOperator, pTableQueryInfo->pTable, pIntervalInfo->pCtx, pOperator->numOfOutput); + // setTagValue(pOperator, pTableQueryInfo->pTable, pIntervalInfo->pCtx, pOperator->numOfOutput); setInputDataBlock(pOperator, pIntervalInfo->binfo.pCtx, pBlock, pQueryAttr->order.order); setIntervalQueryRange(pRuntimeEnv, pBlock->info.window.skey); @@ -6916,11 +7049,11 @@ static SSDataBlock* doSTableIntervalAgg(SOperatorInfo *pOperator, bool* newgroup } pOperator->status = OP_RES_TO_RETURN; - pQueryAttr->order.order = order; // TODO : restore the order + pQueryAttr->order.order = order; // TODO : restore the order doCloseAllTimeWindow(pRuntimeEnv); setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED); -// copyToSDataBlock(pRuntimeEnv, 3000, pIntervalInfo->pRes, pIntervalInfo->rowCellInfoOffset); + // copyToSDataBlock(pRuntimeEnv, 3000, pIntervalInfo->pRes, pIntervalInfo->rowCellInfoOffset); if (pIntervalInfo->binfo.pRes->info.rows == 0 || !hasRemainData(&pRuntimeEnv->groupResInfo)) { pOperator->status = OP_EXEC_DONE; } @@ -6928,16 +7061,16 @@ static SSDataBlock* doSTableIntervalAgg(SOperatorInfo *pOperator, bool* newgroup return pIntervalInfo->binfo.pRes; } -static SSDataBlock* doAllSTableIntervalAgg(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doAllSTableIntervalAgg(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } STableIntervalOperatorInfo* pIntervalInfo = pOperator->info; - STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv; + STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv; if (pOperator->status == OP_RES_TO_RETURN) { -// copyToSDataBlock(pRuntimeEnv, 3000, pIntervalInfo->pRes, pIntervalInfo->rowCellInfoOffset); + // copyToSDataBlock(pRuntimeEnv, 3000, pIntervalInfo->pRes, pIntervalInfo->rowCellInfoOffset); if (pIntervalInfo->binfo.pRes->info.rows == 0 || !hasRemainData(&pRuntimeEnv->groupResInfo)) { pOperator->status = OP_EXEC_DONE; } @@ -6946,11 +7079,11 @@ static SSDataBlock* doAllSTableIntervalAgg(SOperatorInfo *pOperator, bool* newgr } STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; - int32_t order = pQueryAttr->order.order; + int32_t order = pQueryAttr->order.order; SOperatorInfo* downstream = pOperator->pDownstream[0]; - while(1) { + while (1) { publishOperatorProfEvent(downstream, QUERY_PROF_BEFORE_OPERATOR_EXEC); SSDataBlock* pBlock = downstream->getNextFn(downstream, newgroup); publishOperatorProfEvent(downstream, QUERY_PROF_AFTER_OPERATOR_EXEC); @@ -6962,7 +7095,7 @@ static SSDataBlock* doAllSTableIntervalAgg(SOperatorInfo *pOperator, bool* newgr // the pDataBlock are always the same one, no need to call this again STableQueryInfo* pTableQueryInfo = pRuntimeEnv->current; -// setTagValue(pOperator, pTableQueryInfo->pTable, pIntervalInfo->pCtx, pOperator->numOfOutput); + // setTagValue(pOperator, pTableQueryInfo->pTable, pIntervalInfo->pCtx, pOperator->numOfOutput); setInputDataBlock(pOperator, pIntervalInfo->binfo.pCtx, pBlock, pQueryAttr->order.order); setIntervalQueryRange(pRuntimeEnv, pBlock->info.window.skey); @@ -6970,35 +7103,35 @@ static SSDataBlock* doAllSTableIntervalAgg(SOperatorInfo *pOperator, bool* newgr } pOperator->status = OP_RES_TO_RETURN; - pQueryAttr->order.order = order; // TODO : restore the order + pQueryAttr->order.order = order; // TODO : restore the order doCloseAllTimeWindow(pRuntimeEnv); setTaskStatus(pOperator->pTaskInfo, TASK_COMPLETED); int64_t st = taosGetTimestampUs(); -// copyToSDataBlock(pRuntimeEnv, 3000, pIntervalInfo->pRes, pIntervalInfo->rowCellInfoOffset); + // copyToSDataBlock(pRuntimeEnv, 3000, pIntervalInfo->pRes, pIntervalInfo->rowCellInfoOffset); if (pIntervalInfo->binfo.pRes->info.rows == 0 || !hasRemainData(&pRuntimeEnv->groupResInfo)) { pOperator->status = OP_EXEC_DONE; } -// SQInfo* pQInfo = pRuntimeEnv->qinfo; -// pQInfo->summary.firstStageMergeTime += (taosGetTimestampUs() - st); + // SQInfo* pQInfo = pRuntimeEnv->qinfo; + // pQInfo->summary.firstStageMergeTime += (taosGetTimestampUs() - st); return pIntervalInfo->binfo.pRes; } -static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorInfo *pInfo, SSDataBlock *pSDataBlock) { +static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorInfo* pInfo, SSDataBlock* pSDataBlock) { STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv; - STableQueryInfo* item = pRuntimeEnv->current; + STableQueryInfo* item = pRuntimeEnv->current; SColumnInfoData* pColInfoData = taosArrayGet(pSDataBlock->pDataBlock, pInfo->colIndex); SOptrBasicInfo* pBInfo = &pInfo->binfo; bool masterScan = IS_MAIN_SCAN(pRuntimeEnv); - int16_t bytes = pColInfoData->info.bytes; - int16_t type = pColInfoData->info.type; + int16_t bytes = pColInfoData->info.bytes; + int16_t type = pColInfoData->info.type; SColumnInfoData* pTsColInfoData = taosArrayGet(pSDataBlock->pDataBlock, 0); - TSKEY* tsList = (TSKEY*)pTsColInfoData->pData; + TSKEY* tsList = (TSKEY*)pTsColInfoData->pData; if (IS_REPEAT_SCAN(pRuntimeEnv) && !pInfo->reptScan) { pInfo->reptScan = true; taosMemoryFreeClear(pInfo->prevData); @@ -7021,7 +7154,7 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI } else if (memcmp(pInfo->prevData, val, bytes) == 0) { pInfo->curWindow.ekey = tsList[j]; pInfo->numOfRows += 1; - //pInfo->start = j; + // pInfo->start = j; if (j == 0 && pInfo->start != 0) { pInfo->numOfRows = 1; pInfo->start = 0; @@ -7029,49 +7162,48 @@ static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorI } else { SResultRow* pResult = NULL; pInfo->curWindow.ekey = pInfo->curWindow.skey; - int32_t ret = setResultOutputBufByKey(pRuntimeEnv, &pBInfo->resultRowInfo, pSDataBlock->info.uid, &pInfo->curWindow, masterScan, - &pResult, item->groupIndex, pBInfo->pCtx, pOperator->numOfOutput, - pBInfo->rowCellInfoOffset); + int32_t ret = setResultOutputBufByKey(pRuntimeEnv, &pBInfo->resultRowInfo, pSDataBlock->info.uid, + &pInfo->curWindow, masterScan, &pResult, item->groupIndex, pBInfo->pCtx, + pOperator->numOfOutput, pBInfo->rowCellInfoOffset); if (ret != TSDB_CODE_SUCCESS) { // null data, too many state code longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_APP_ERROR); } -// doApplyFunctions(pRuntimeEnv, pBInfo->pCtx, &pInfo->curWindow, pInfo->start, pInfo->numOfRows, tsList, -// pSDataBlock->info.rows, pOperator->numOfOutput); + // doApplyFunctions(pRuntimeEnv, pBInfo->pCtx, &pInfo->curWindow, pInfo->start, pInfo->numOfRows, tsList, + // pSDataBlock->info.rows, pOperator->numOfOutput); pInfo->curWindow.skey = tsList[j]; pInfo->curWindow.ekey = tsList[j]; memcpy(pInfo->prevData, val, bytes); pInfo->numOfRows = 1; pInfo->start = j; - } } SResultRow* pResult = NULL; pInfo->curWindow.ekey = pInfo->curWindow.skey; - int32_t ret = setResultOutputBufByKey(pRuntimeEnv, &pBInfo->resultRowInfo, pSDataBlock->info.uid, &pInfo->curWindow, masterScan, - &pResult, item->groupIndex, pBInfo->pCtx, pOperator->numOfOutput, + int32_t ret = setResultOutputBufByKey(pRuntimeEnv, &pBInfo->resultRowInfo, pSDataBlock->info.uid, &pInfo->curWindow, + masterScan, &pResult, item->groupIndex, pBInfo->pCtx, pOperator->numOfOutput, pBInfo->rowCellInfoOffset); if (ret != TSDB_CODE_SUCCESS) { // null data, too many state code longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_APP_ERROR); } -// doApplyFunctions(pRuntimeEnv, pBInfo->pCtx, &pInfo->curWindow, pInfo->start, pInfo->numOfRows, tsList, -// pSDataBlock->info.rows, pOperator->numOfOutput); + // doApplyFunctions(pRuntimeEnv, pBInfo->pCtx, &pInfo->curWindow, pInfo->start, pInfo->numOfRows, tsList, + // pSDataBlock->info.rows, pOperator->numOfOutput); } -static SSDataBlock* doStateWindowAgg(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } SStateWindowOperatorInfo* pWindowInfo = pOperator->info; - SOptrBasicInfo* pBInfo = &pWindowInfo->binfo; + SOptrBasicInfo* pBInfo = &pWindowInfo->binfo; STaskRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv; if (pOperator->status == OP_RES_TO_RETURN) { -// toSDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pBInfo->pRes); + // toSDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pBInfo->pRes); if (pBInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pRuntimeEnv->groupResInfo)) { pOperator->status = OP_EXEC_DONE; @@ -7080,9 +7212,9 @@ static SSDataBlock* doStateWindowAgg(SOperatorInfo *pOperator, bool* newgroup) { return pBInfo->pRes; } - STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; - int32_t order = pQueryAttr->order.order; - STimeWindow win = pQueryAttr->window; + STaskAttr* pQueryAttr = pRuntimeEnv->pQueryAttr; + int32_t order = pQueryAttr->order.order; + STimeWindow win = pQueryAttr->window; SOperatorInfo* downstream = pOperator->pDownstream[0]; while (1) { publishOperatorProfEvent(downstream, QUERY_PROF_BEFORE_OPERATOR_EXEC); @@ -7096,7 +7228,7 @@ static SSDataBlock* doStateWindowAgg(SOperatorInfo *pOperator, bool* newgroup) { if (pWindowInfo->colIndex == -1) { pWindowInfo->colIndex = getGroupbyColumnIndex(pRuntimeEnv->pQueryAttr->pGroupbyExpr, pBlock); } - doStateWindowAggImpl(pOperator, pWindowInfo, pBlock); + doStateWindowAggImpl(pOperator, pWindowInfo, pBlock); } // restore the value @@ -7109,25 +7241,26 @@ static SSDataBlock* doStateWindowAgg(SOperatorInfo *pOperator, bool* newgroup) { finalizeQueryResult(pBInfo->pCtx, pOperator->numOfOutput); initGroupResInfo(&pRuntimeEnv->groupResInfo, &pBInfo->resultRowInfo); -// toSDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pBInfo->pRes); + // toSDatablock(&pRuntimeEnv->groupResInfo, pRuntimeEnv, pBInfo->pRes); if (pBInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pRuntimeEnv->groupResInfo)) { pOperator->status = OP_EXEC_DONE; } - return pBInfo->pRes->info.rows == 0? NULL:pBInfo->pRes; + return pBInfo->pRes->info.rows == 0 ? NULL : pBInfo->pRes; } -static SSDataBlock* doSessionWindowAgg(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } SSessionAggOperatorInfo* pInfo = pOperator->info; - SOptrBasicInfo* pBInfo = &pInfo->binfo; + SOptrBasicInfo* pBInfo = &pInfo->binfo; if (pOperator->status == OP_RES_TO_RETURN) { - toSDatablock(&pInfo->groupResInfo, pInfo->aggSup.pResultBuf, pBInfo->pRes, pBInfo->capacity, pBInfo->rowCellInfoOffset); + toSDatablock(&pInfo->groupResInfo, pInfo->aggSup.pResultBuf, pBInfo->pRes, pBInfo->capacity, + pBInfo->rowCellInfoOffset); if (pBInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) { doSetOperatorCompleted(pOperator); return NULL; @@ -7136,10 +7269,10 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo *pOperator, bool* newgroup) return pBInfo->pRes; } - int32_t order = TSDB_ORDER_ASC; + int32_t order = TSDB_ORDER_ASC; SOperatorInfo* downstream = pOperator->pDownstream[0]; - while(1) { + while (1) { publishOperatorProfEvent(downstream, QUERY_PROF_BEFORE_OPERATOR_EXEC); SSDataBlock* pBlock = downstream->getNextFn(downstream, newgroup); publishOperatorProfEvent(downstream, QUERY_PROF_AFTER_OPERATOR_EXEC); @@ -7155,37 +7288,40 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo *pOperator, bool* newgroup) // restore the value pOperator->status = OP_RES_TO_RETURN; closeAllResultRows(&pBInfo->resultRowInfo); - finalizeMultiTupleQueryResult(pBInfo->pCtx, pOperator->numOfOutput, pInfo->aggSup.pResultBuf, &pBInfo->resultRowInfo, pBInfo->rowCellInfoOffset); + finalizeMultiTupleQueryResult(pBInfo->pCtx, pOperator->numOfOutput, pInfo->aggSup.pResultBuf, &pBInfo->resultRowInfo, + pBInfo->rowCellInfoOffset); initGroupResInfo(&pInfo->groupResInfo, &pBInfo->resultRowInfo); blockDataEnsureCapacity(pBInfo->pRes, pBInfo->capacity); - toSDatablock(&pInfo->groupResInfo, pInfo->aggSup.pResultBuf, pBInfo->pRes, pBInfo->capacity, pBInfo->rowCellInfoOffset); + toSDatablock(&pInfo->groupResInfo, pInfo->aggSup.pResultBuf, pBInfo->pRes, pBInfo->capacity, + pBInfo->rowCellInfoOffset); if (pBInfo->pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) { doSetOperatorCompleted(pOperator); } - return pBInfo->pRes->info.rows == 0? NULL:pBInfo->pRes; + return pBInfo->pRes->info.rows == 0 ? NULL : pBInfo->pRes; } -static SSDataBlock* hashGroupbyAggregate(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } - SGroupbyOperatorInfo *pInfo = pOperator->info; + SGroupbyOperatorInfo* pInfo = pOperator->info; if (pOperator->status == OP_RES_TO_RETURN) { - toSDatablock(&pInfo->groupResInfo, pInfo->aggSup.pResultBuf, pInfo->binfo.pRes, pInfo->binfo.capacity, pInfo->binfo.rowCellInfoOffset); - if (pInfo->binfo.pRes->info.rows == 0|| !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) { + toSDatablock(&pInfo->groupResInfo, pInfo->aggSup.pResultBuf, pInfo->binfo.pRes, pInfo->binfo.capacity, + pInfo->binfo.rowCellInfoOffset); + if (pInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) { pOperator->status = OP_EXEC_DONE; } return pInfo->binfo.pRes; } - int32_t order = TSDB_ORDER_ASC; + int32_t order = TSDB_ORDER_ASC; SOperatorInfo* downstream = pOperator->pDownstream[0]; - while(1) { + while (1) { publishOperatorProfEvent(downstream, QUERY_PROF_BEFORE_OPERATOR_EXEC); SSDataBlock* pBlock = downstream->getNextFn(downstream, newgroup); publishOperatorProfEvent(downstream, QUERY_PROF_AFTER_OPERATOR_EXEC); @@ -7195,7 +7331,7 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo *pOperator, bool* newgrou // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pOperator, pInfo->binfo.pCtx, pBlock, order); -// setTagValue(pOperator, pRuntimeEnv->current->pTable, pInfo->binfo.pCtx, pOperator->numOfOutput); + // setTagValue(pOperator, pRuntimeEnv->current->pTable, pInfo->binfo.pCtx, pOperator->numOfOutput); doHashGroupbyAgg(pOperator, pBlock); char *result = NULL; @@ -7212,16 +7348,19 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo *pOperator, bool* newgrou pOperator->status = OP_RES_TO_RETURN; closeAllResultRows(&pInfo->binfo.resultRowInfo); - finalizeMultiTupleQueryResult(pInfo->binfo.pCtx, pOperator->numOfOutput, pInfo->aggSup.pResultBuf, &pInfo->binfo.resultRowInfo, pInfo->binfo.rowCellInfoOffset); -// if (!pRuntimeEnv->pQueryAttr->stableQuery) { // finalize include the update of result rows -// finalizeQueryResult(pInfo->binfo.pCtx, pOperator->numOfOutput); -// } else { -// updateNumOfRowsInResultRows(pInfo->binfo.pCtx, pOperator->numOfOutput, &pInfo->binfo.resultRowInfo, pInfo->binfo.rowCellInfoOffset); -// } + finalizeMultiTupleQueryResult(pInfo->binfo.pCtx, pOperator->numOfOutput, pInfo->aggSup.pResultBuf, + &pInfo->binfo.resultRowInfo, pInfo->binfo.rowCellInfoOffset); + // if (!pRuntimeEnv->pQueryAttr->stableQuery) { // finalize include the update of result rows + // finalizeQueryResult(pInfo->binfo.pCtx, pOperator->numOfOutput); + // } else { + // updateNumOfRowsInResultRows(pInfo->binfo.pCtx, pOperator->numOfOutput, &pInfo->binfo.resultRowInfo, + // pInfo->binfo.rowCellInfoOffset); + // } blockDataEnsureCapacity(pInfo->binfo.pRes, pInfo->binfo.capacity); initGroupResInfo(&pInfo->groupResInfo, &pInfo->binfo.resultRowInfo); - toSDatablock(&pInfo->groupResInfo, pInfo->aggSup.pResultBuf, pInfo->binfo.pRes, pInfo->binfo.capacity, pInfo->binfo.rowCellInfoOffset); + toSDatablock(&pInfo->groupResInfo, pInfo->aggSup.pResultBuf, pInfo->binfo.pRes, pInfo->binfo.capacity, + pInfo->binfo.rowCellInfoOffset); if (pInfo->binfo.pRes->info.rows == 0 || !hasRemainDataInCurrentGroup(&pInfo->groupResInfo)) { pOperator->status = OP_EXEC_DONE; } @@ -7229,10 +7368,12 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo *pOperator, bool* newgrou return pInfo->binfo.pRes; } -static void doHandleRemainBlockForNewGroupImpl(SFillOperatorInfo *pInfo, SResultInfo* pResultInfo, bool* newgroup, SExecTaskInfo* pTaskInfo) { +static void doHandleRemainBlockForNewGroupImpl(SFillOperatorInfo* pInfo, SResultInfo* pResultInfo, bool* newgroup, + SExecTaskInfo* pTaskInfo) { pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows; - int64_t ekey = Q_STATUS_EQUAL(pTaskInfo->status, TASK_COMPLETED)? pTaskInfo->window.ekey:pInfo->existNewGroupBlock->info.window.ekey; + int64_t ekey = Q_STATUS_EQUAL(pTaskInfo->status, TASK_COMPLETED) ? pTaskInfo->window.ekey + : pInfo->existNewGroupBlock->info.window.ekey; taosResetFillInfo(pInfo->pFillInfo, getFillInfoStart(pInfo->pFillInfo)); taosFillSetStartInfo(pInfo->pFillInfo, pInfo->existNewGroupBlock->info.rows, ekey); @@ -7243,7 +7384,8 @@ static void doHandleRemainBlockForNewGroupImpl(SFillOperatorInfo *pInfo, SResult *newgroup = true; } -static void doHandleRemainBlockFromNewGroup(SFillOperatorInfo *pInfo, SResultInfo *pResultInfo, bool *newgroup, SExecTaskInfo* pTaskInfo) { +static void doHandleRemainBlockFromNewGroup(SFillOperatorInfo* pInfo, SResultInfo* pResultInfo, bool* newgroup, + SExecTaskInfo* pTaskInfo) { if (taosFillHasMoreResults(pInfo->pFillInfo)) { *newgroup = false; doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, (int32_t)pResultInfo->capacity, pInfo->p); @@ -7258,9 +7400,9 @@ static void doHandleRemainBlockFromNewGroup(SFillOperatorInfo *pInfo, SResultInf } } -static SSDataBlock* doFill(SOperatorInfo *pOperator, bool* newgroup) { - SFillOperatorInfo *pInfo = pOperator->info; - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; +static SSDataBlock* doFill(SOperatorInfo* pOperator, bool* newgroup) { + SFillOperatorInfo* pInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SResultInfo* pResultInfo = &pOperator->resultInfo; blockDataCleanup(pInfo->pRes); @@ -7274,7 +7416,7 @@ static SSDataBlock* doFill(SOperatorInfo *pOperator, bool* newgroup) { } SOperatorInfo* pDownstream = pOperator->pDownstream[0]; - while(1) { + while (1) { publishOperatorProfEvent(pDownstream, QUERY_PROF_BEFORE_OPERATOR_EXEC); SSDataBlock* pBlock = pDownstream->getNextFn(pDownstream, newgroup); publishOperatorProfEvent(pDownstream, QUERY_PROF_AFTER_OPERATOR_EXEC); @@ -7333,7 +7475,7 @@ static SSDataBlock* doFill(SOperatorInfo *pOperator, bool* newgroup) { // todo set the attribute of query scan count static int32_t getNumOfScanTimes(STaskAttr* pQueryAttr) { - for(int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { + for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) { int32_t functionId = getExprFunctionId(&pQueryAttr->pExpr1[i]); if (functionId == FUNCTION_STDDEV || functionId == FUNCTION_PERCT) { return 2; @@ -7353,7 +7495,7 @@ static void destroyOperatorInfo(SOperatorInfo* pOperator) { } if (pOperator->pDownstream != NULL) { - for(int32_t i = 0; i < pOperator->numOfDownstream; ++i) { + for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) { destroyOperatorInfo(pOperator->pDownstream[i]); } @@ -7365,13 +7507,13 @@ static void destroyOperatorInfo(SOperatorInfo* pOperator) { taosMemoryFreeClear(pOperator); } -int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx *pCtx, int32_t numOfOutput, const char* pKey) { +int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t numOfOutput, const char* pKey) { _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); - pAggSup->resultRowSize = getResultRowSize(pCtx, numOfOutput); - pAggSup->keyBuf = taosMemoryCalloc(1, sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES); + pAggSup->resultRowSize = getResultRowSize(pCtx, numOfOutput); + pAggSup->keyBuf = taosMemoryCalloc(1, sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES); pAggSup->pResultRowHashTable = taosHashInit(10, hashFn, true, HASH_NO_LOCK); - pAggSup->pResultRowListSet = taosHashInit(100, hashFn, false, HASH_NO_LOCK); + pAggSup->pResultRowListSet = taosHashInit(100, hashFn, false, HASH_NO_LOCK); pAggSup->pResultRowArrayList = taosArrayInit(10, sizeof(SResultRowCell)); if (pAggSup->keyBuf == NULL || pAggSup->pResultRowArrayList == NULL || pAggSup->pResultRowListSet == NULL || @@ -7411,14 +7553,14 @@ static STableQueryInfo* initTableQueryInfo(const STableGroupInfo* pTableGroupInf } int32_t index = 0; - for(int32_t i = 0; i < taosArrayGetSize(pTableGroupInfo->pGroupList); ++i) { + for (int32_t i = 0; i < taosArrayGetSize(pTableGroupInfo->pGroupList); ++i) { SArray* pa = taosArrayGetP(pTableGroupInfo->pGroupList, i); - for(int32_t j = 0; j < taosArrayGetSize(pa); ++j) { + for (int32_t j = 0; j < taosArrayGetSize(pa); ++j) { STableKeyInfo* pk = taosArrayGet(pa, j); STableQueryInfo* pTQueryInfo = &pTableQueryInfo[index++]; - pTQueryInfo->uid = pk->uid; - pTQueryInfo->lastKey = pk->lastKey; + pTQueryInfo->uid = pk->uid; + pTQueryInfo->lastKey = pk->lastKey; pTQueryInfo->groupIndex = i; } } @@ -7428,17 +7570,19 @@ static STableQueryInfo* initTableQueryInfo(const STableGroupInfo* pTableGroupInf return pTableQueryInfo; } -SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, SSDataBlock* pResultBlock, - SExecTaskInfo* pTaskInfo, const STableGroupInfo* pTableGroupInfo) { +SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, + SSDataBlock* pResultBlock, SExecTaskInfo* pTaskInfo, + const STableGroupInfo* pTableGroupInfo) { SAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SAggOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { goto _error; } //(int32_t)(getRowNumForMultioutput(pQueryAttr, pQueryAttr->topBotQuery, pQueryAttr->stableQuery)); int32_t numOfRows = 1; - int32_t code = initAggInfo(&pInfo->binfo, &pInfo->aggSup, pExprInfo, numOfCols, numOfRows, pResultBlock, pTaskInfo->id.str); + int32_t code = + initAggInfo(&pInfo->binfo, &pInfo->aggSup, pExprInfo, numOfCols, numOfRows, pResultBlock, pTaskInfo->id.str); pInfo->pTableQueryInfo = initTableQueryInfo(pTableGroupInfo); if (code != TSDB_CODE_SUCCESS || pInfo->pTableQueryInfo == NULL) { goto _error; @@ -7446,18 +7590,18 @@ SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SExprInfo* setFunctionResultOutput(&pInfo->binfo, &pInfo->aggSup, MAIN_SCAN, pTaskInfo); - pOperator->name = "TableAggregate"; + pOperator->name = "TableAggregate"; pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_AGG; pOperator->blockingOptr = true; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; - pOperator->pExpr = pExprInfo; - pOperator->numOfOutput = numOfCols; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; + pOperator->pExpr = pExprInfo; + pOperator->numOfOutput = numOfCols; - pOperator->pTaskInfo = pTaskInfo; - pOperator->_openFn = doOpenAggregateOptr; - pOperator->getNextFn = getAggregateResult; - pOperator->closeFn = destroyAggOperatorInfo; + pOperator->pTaskInfo = pTaskInfo; + pOperator->_openFn = doOpenAggregateOptr; + pOperator->getNextFn = getAggregateResult; + pOperator->closeFn = destroyAggOperatorInfo; pOperator->encodeResultRow = aggEncodeResultRow; pOperator->decodeResultRow = aggDecodeResultRow; @@ -7467,7 +7611,7 @@ SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SExprInfo* } return pOperator; - _error: +_error: destroyAggOperatorInfo(pInfo, numOfCols); taosMemoryFreeClear(pInfo); taosMemoryFreeClear(pOperator); @@ -7486,41 +7630,41 @@ static void doDestroyBasicInfo(SOptrBasicInfo* pInfo, int32_t numOfOutput) { } void destroyBasicOperatorInfo(void* param, int32_t numOfOutput) { - SOptrBasicInfo* pInfo = (SOptrBasicInfo*) param; + SOptrBasicInfo* pInfo = (SOptrBasicInfo*)param; doDestroyBasicInfo(pInfo, numOfOutput); } void destroyStateWindowOperatorInfo(void* param, int32_t numOfOutput) { - SStateWindowOperatorInfo* pInfo = (SStateWindowOperatorInfo*) param; + SStateWindowOperatorInfo* pInfo = (SStateWindowOperatorInfo*)param; doDestroyBasicInfo(&pInfo->binfo, numOfOutput); taosMemoryFreeClear(pInfo->prevData); } void destroyAggOperatorInfo(void* param, int32_t numOfOutput) { - SAggOperatorInfo* pInfo = (SAggOperatorInfo*) param; + SAggOperatorInfo* pInfo = (SAggOperatorInfo*)param; doDestroyBasicInfo(&pInfo->binfo, numOfOutput); } void destroyIntervalOperatorInfo(void* param, int32_t numOfOutput) { - STableIntervalOperatorInfo* pInfo = (STableIntervalOperatorInfo*) param; + STableIntervalOperatorInfo* pInfo = (STableIntervalOperatorInfo*)param; doDestroyBasicInfo(&pInfo->binfo, numOfOutput); cleanupAggSup(&pInfo->aggSup); } void destroySWindowOperatorInfo(void* param, int32_t numOfOutput) { - SSessionAggOperatorInfo* pInfo = (SSessionAggOperatorInfo*) param; + SSessionAggOperatorInfo* pInfo = (SSessionAggOperatorInfo*)param; doDestroyBasicInfo(&pInfo->binfo, numOfOutput); } void destroySFillOperatorInfo(void* param, int32_t numOfOutput) { - SFillOperatorInfo* pInfo = (SFillOperatorInfo*) param; + SFillOperatorInfo* pInfo = (SFillOperatorInfo*)param; pInfo->pFillInfo = taosDestroyFillInfo(pInfo->pFillInfo); pInfo->pRes = blockDataDestroy(pInfo->pRes); taosMemoryFreeClear(pInfo->p); } void destroyGroupbyOperatorInfo(void* param, int32_t numOfOutput) { - SGroupbyOperatorInfo* pInfo = (SGroupbyOperatorInfo*) param; + SGroupbyOperatorInfo* pInfo = (SGroupbyOperatorInfo*)param; doDestroyBasicInfo(&pInfo->binfo, numOfOutput); taosMemoryFreeClear(pInfo->keyBuf); taosArrayDestroy(pInfo->pGroupCols); @@ -7528,29 +7672,29 @@ void destroyGroupbyOperatorInfo(void* param, int32_t numOfOutput) { } static void destroyProjectOperatorInfo(void* param, int32_t numOfOutput) { - SProjectOperatorInfo* pInfo = (SProjectOperatorInfo*) param; + SProjectOperatorInfo* pInfo = (SProjectOperatorInfo*)param; doDestroyBasicInfo(&pInfo->binfo, numOfOutput); } static void destroyTagScanOperatorInfo(void* param, int32_t numOfOutput) { - STagScanInfo* pInfo = (STagScanInfo*) param; + STagScanInfo* pInfo = (STagScanInfo*)param; pInfo->pRes = blockDataDestroy(pInfo->pRes); } static void destroyOrderOperatorInfo(void* param, int32_t numOfOutput) { - SSortOperatorInfo* pInfo = (SSortOperatorInfo*) param; + SSortOperatorInfo* pInfo = (SSortOperatorInfo*)param; pInfo->pDataBlock = blockDataDestroy(pInfo->pDataBlock); taosArrayDestroy(pInfo->pSortInfo); } static void destroyConditionOperatorInfo(void* param, int32_t numOfOutput) { - SFilterOperatorInfo* pInfo = (SFilterOperatorInfo*) param; + SFilterOperatorInfo* pInfo = (SFilterOperatorInfo*)param; doDestroyFilterInfo(pInfo->pFilterInfo, pInfo->numOfFilterCols); } static void destroyDistinctOperatorInfo(void* param, int32_t numOfOutput) { - SDistinctOperatorInfo* pInfo = (SDistinctOperatorInfo*) param; + SDistinctOperatorInfo* pInfo = (SDistinctOperatorInfo*)param; taosHashCleanup(pInfo->pSet); taosMemoryFreeClear(pInfo->buf); taosArrayDestroy(pInfo->pDistinctDataInfo); @@ -7558,7 +7702,7 @@ static void destroyDistinctOperatorInfo(void* param, int32_t numOfOutput) { } static void destroySysTableScannerOperatorInfo(void* param, int32_t numOfOutput) { - SSysTableScanInfo* pInfo = (SSysTableScanInfo*) param; + SSysTableScanInfo* pInfo = (SSysTableScanInfo*)param; tsem_destroy(&pInfo->ready); blockDataDestroy(pInfo->pRes); @@ -7568,7 +7712,7 @@ static void destroySysTableScannerOperatorInfo(void* param, int32_t numOfOutput) } void destroyExchangeOperatorInfo(void* param, int32_t numOfOutput) { - SExchangeInfo* pExInfo = (SExchangeInfo*) param; + SExchangeInfo* pExInfo = (SExchangeInfo*)param; taosArrayDestroy(pExInfo->pSources); taosArrayDestroy(pExInfo->pSourceDataInfo); if (pExInfo->pResult != NULL) { @@ -7578,28 +7722,31 @@ void destroyExchangeOperatorInfo(void* param, int32_t numOfOutput) { tsem_destroy(&pExInfo->ready); } -SOperatorInfo* createMultiTableAggOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, SSDataBlock* pResBlock, SExecTaskInfo* pTaskInfo, const STableGroupInfo* pTableGroupInfo) { +SOperatorInfo* createMultiTableAggOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, + SSDataBlock* pResBlock, SExecTaskInfo* pTaskInfo, + const STableGroupInfo* pTableGroupInfo) { SAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SAggOperatorInfo)); int32_t numOfRows = 1; - int32_t code = initAggInfo(&pInfo->binfo, &pInfo->aggSup, pExprInfo, numOfCols, numOfRows, pResBlock, pTaskInfo->id.str); + int32_t code = + initAggInfo(&pInfo->binfo, &pInfo->aggSup, pExprInfo, numOfCols, numOfRows, pResBlock, pTaskInfo->id.str); pInfo->pTableQueryInfo = initTableQueryInfo(pTableGroupInfo); if (code != TSDB_CODE_SUCCESS || pInfo->pTableQueryInfo == NULL) { goto _error; } - size_t tableGroup = taosArrayGetSize(pTableGroupInfo->pGroupList); + size_t tableGroup = taosArrayGetSize(pTableGroupInfo->pGroupList); initResultRowInfo(&pInfo->binfo.resultRowInfo, (int32_t)tableGroup); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - pOperator->name = "MultiTableAggregate"; + pOperator->name = "MultiTableAggregate"; // pOperator->operatorType = OP_MultiTableAggregate; pOperator->blockingOptr = true; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; - pOperator->pExpr = pExprInfo; - pOperator->numOfOutput = numOfCols; - pOperator->pTaskInfo = pTaskInfo; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; + pOperator->pExpr = pExprInfo; + pOperator->numOfOutput = numOfCols; + pOperator->pTaskInfo = pTaskInfo; pOperator->getNextFn = doMultiTableAggregate; pOperator->closeFn = destroyAggOperatorInfo; @@ -7614,9 +7761,10 @@ _error: return NULL; } -SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t num, SSDataBlock* pResBlock, SExecTaskInfo* pTaskInfo) { +SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t num, + SSDataBlock* pResBlock, SExecTaskInfo* pTaskInfo) { SProjectOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SProjectOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { goto _error; } @@ -7627,21 +7775,21 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SExprInfo* p goto _error; } -// initResultRowInfo(&pBInfo->resultRowInfo, 8); -// setFunctionResultOutput(pBInfo, MAIN_SCAN); + // initResultRowInfo(&pBInfo->resultRowInfo, 8); + // setFunctionResultOutput(pBInfo, MAIN_SCAN); - pOperator->name = "ProjectOperator"; + pOperator->name = "ProjectOperator"; pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_PROJECT; pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; - pOperator->pExpr = pExprInfo; - pOperator->numOfOutput = num; - pOperator->_openFn = operatorDummyOpenFn; - pOperator->getNextFn = doProjectOperation; - pOperator->closeFn = destroyProjectOperatorInfo; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; + pOperator->pExpr = pExprInfo; + pOperator->numOfOutput = num; + pOperator->_openFn = operatorDummyOpenFn; + pOperator->getNextFn = doProjectOperation; + pOperator->closeFn = destroyProjectOperatorInfo; - pOperator->pTaskInfo = pTaskInfo; + pOperator->pTaskInfo = pTaskInfo; int32_t code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { goto _error; @@ -7649,7 +7797,7 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SExprInfo* p return pOperator; - _error: +_error: pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; return NULL; } @@ -7689,58 +7837,60 @@ SColumnInfo* extractColumnFilterInfo(SExprInfo* pExpr, int32_t numOfOutput, int3 SOperatorInfo* createLimitOperatorInfo(SOperatorInfo* downstream, SLimit* pLimit, SExecTaskInfo* pTaskInfo) { SLimitOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SLimitOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { goto _error; } - pInfo->limit = *pLimit; - pInfo->currentOffset = pLimit->offset; + pInfo->limit = *pLimit; + pInfo->currentOffset = pLimit->offset; - pOperator->name = "LimitOperator"; -// pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_LIMIT; + pOperator->name = "LimitOperator"; + // pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_LIMIT; pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; - pOperator->_openFn = operatorDummyOpenFn; - pOperator->getNextFn = doLimit; - pOperator->info = pInfo; - pOperator->pTaskInfo = pTaskInfo; + pOperator->status = OP_NOT_OPENED; + pOperator->_openFn = operatorDummyOpenFn; + pOperator->getNextFn = doLimit; + pOperator->info = pInfo; + pOperator->pTaskInfo = pTaskInfo; int32_t code = appendDownstream(pOperator, &downstream, 1); return pOperator; - _error: +_error: taosMemoryFreeClear(pInfo); taosMemoryFreeClear(pOperator); terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } -SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, SSDataBlock* pResBlock, SInterval* pInterval, +SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, + SSDataBlock* pResBlock, SInterval* pInterval, const STableGroupInfo* pTableGroupInfo, SExecTaskInfo* pTaskInfo) { STableIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableIntervalOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { goto _error; } - pInfo->order = TSDB_ORDER_ASC; + pInfo->order = TSDB_ORDER_ASC; pInfo->precision = TSDB_TIME_PRECISION_MILLI; - pInfo->win = pTaskInfo->window; - pInfo->interval = *pInterval; + pInfo->win = pTaskInfo->window; + pInfo->interval = *pInterval; pInfo->win.skey = INT64_MIN; pInfo->win.ekey = INT64_MAX; int32_t numOfRows = 4096; - int32_t code = initAggInfo(&pInfo->binfo, &pInfo->aggSup, pExprInfo, numOfCols, numOfRows, pResBlock, pTaskInfo->id.str); -// pInfo->pTableQueryInfo = initTableQueryInfo(pTableGroupInfo); - if (code != TSDB_CODE_SUCCESS/* || pInfo->pTableQueryInfo == NULL*/) { + int32_t code = + initAggInfo(&pInfo->binfo, &pInfo->aggSup, pExprInfo, numOfCols, numOfRows, pResBlock, pTaskInfo->id.str); + // pInfo->pTableQueryInfo = initTableQueryInfo(pTableGroupInfo); + if (code != TSDB_CODE_SUCCESS /* || pInfo->pTableQueryInfo == NULL*/) { goto _error; } initResultRowInfo(&pInfo->binfo.resultRowInfo, (int32_t)1); - pOperator->name = "TimeIntervalAggOperator"; + pOperator->name = "TimeIntervalAggOperator"; pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_INTERVAL; pOperator->blockingOptr = true; pOperator->status = OP_NOT_OPENED; @@ -7761,7 +7911,7 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* return pOperator; - _error: +_error: destroyIntervalOperatorInfo(pInfo, numOfCols); taosMemoryFreeClear(pInfo); taosMemoryFreeClear(pOperator); @@ -7769,47 +7919,49 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SExprInfo* return NULL; } -SOperatorInfo* createAllTimeIntervalOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfOutput) { +SOperatorInfo* createAllTimeIntervalOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, + SExprInfo* pExpr, int32_t numOfOutput) { STableIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableIntervalOperatorInfo)); -// pInfo->binfo.pCtx = createSqlFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset); -// pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pResultInfo->capacity); + // pInfo->binfo.pCtx = createSqlFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset); + // pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pResultInfo->capacity); initResultRowInfo(&pInfo->binfo.resultRowInfo, 8); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - pOperator->name = "AllTimeIntervalAggOperator"; -// pOperator->operatorType = OP_AllTimeWindow; + pOperator->name = "AllTimeIntervalAggOperator"; + // pOperator->operatorType = OP_AllTimeWindow; pOperator->blockingOptr = true; - pOperator->status = OP_NOT_OPENED; - pOperator->pExpr = pExpr; - pOperator->numOfOutput = numOfOutput; - pOperator->info = pInfo; - pOperator->pRuntimeEnv = pRuntimeEnv; + pOperator->status = OP_NOT_OPENED; + pOperator->pExpr = pExpr; + pOperator->numOfOutput = numOfOutput; + pOperator->info = pInfo; + pOperator->pRuntimeEnv = pRuntimeEnv; pOperator->getNextFn = doAllIntervalAgg; pOperator->closeFn = destroyBasicOperatorInfo; - int32_t code = appendDownstream(pOperator, &downstream, 1); + int32_t code = appendDownstream(pOperator, &downstream, 1); return pOperator; } -SOperatorInfo* createStatewindowOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfOutput) { +SOperatorInfo* createStatewindowOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, + int32_t numOfOutput) { SStateWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStateWindowOperatorInfo)); - pInfo->colIndex = -1; - pInfo->reptScan = false; -// pInfo->binfo.pCtx = createSqlFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset); -// pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pResultInfo->capacity); + pInfo->colIndex = -1; + pInfo->reptScan = false; + // pInfo->binfo.pCtx = createSqlFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset); + // pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pResultInfo->capacity); initResultRowInfo(&pInfo->binfo.resultRowInfo, 8); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - pOperator->name = "StateWindowOperator"; -// pOperator->operatorType = OP_StateWindow; + pOperator->name = "StateWindowOperator"; + // pOperator->operatorType = OP_StateWindow; pOperator->blockingOptr = true; - pOperator->status = OP_NOT_OPENED; - pOperator->pExpr = pExpr; - pOperator->numOfOutput = numOfOutput; - pOperator->info = pInfo; - pOperator->pRuntimeEnv = pRuntimeEnv; + pOperator->status = OP_NOT_OPENED; + pOperator->pExpr = pExpr; + pOperator->numOfOutput = numOfOutput; + pOperator->info = pInfo; + pOperator->pRuntimeEnv = pRuntimeEnv; pOperator->getNextFn = doStateWindowAgg; pOperator->closeFn = destroyStateWindowOperatorInfo; @@ -7817,40 +7969,42 @@ SOperatorInfo* createStatewindowOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOper return pOperator; } -SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, SSDataBlock* pResBlock, int64_t gap, SExecTaskInfo* pTaskInfo) { +SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, + SSDataBlock* pResBlock, int64_t gap, SExecTaskInfo* pTaskInfo) { SSessionAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SSessionAggOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { goto _error; } int32_t numOfRows = 4096; - int32_t code = initAggInfo(&pInfo->binfo, &pInfo->aggSup, pExprInfo, numOfCols, numOfRows, pResBlock, pTaskInfo->id.str); + int32_t code = + initAggInfo(&pInfo->binfo, &pInfo->aggSup, pExprInfo, numOfCols, numOfRows, pResBlock, pTaskInfo->id.str); if (code != TSDB_CODE_SUCCESS) { goto _error; } initResultRowInfo(&pInfo->binfo.resultRowInfo, 8); - pInfo->gap = gap; - pInfo->binfo.pRes = pResBlock; - pInfo->prevTs = INT64_MIN; - pInfo->reptScan = false; - pOperator->name = "SessionWindowAggOperator"; + pInfo->gap = gap; + pInfo->binfo.pRes = pResBlock; + pInfo->prevTs = INT64_MIN; + pInfo->reptScan = false; + pOperator->name = "SessionWindowAggOperator"; pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_SESSION_WINDOW; pOperator->blockingOptr = true; - pOperator->status = OP_NOT_OPENED; - pOperator->pExpr = pExprInfo; - pOperator->numOfOutput = numOfCols; - pOperator->info = pInfo; - pOperator->getNextFn = doSessionWindowAgg; - pOperator->closeFn = destroySWindowOperatorInfo; - pOperator->pTaskInfo = pTaskInfo; + pOperator->status = OP_NOT_OPENED; + pOperator->pExpr = pExprInfo; + pOperator->numOfOutput = numOfCols; + pOperator->info = pInfo; + pOperator->getNextFn = doSessionWindowAgg; + pOperator->closeFn = destroySWindowOperatorInfo; + pOperator->pTaskInfo = pTaskInfo; code = appendDownstream(pOperator, &downstream, 1); return pOperator; - _error: +_error: if (pInfo != NULL) { destroySWindowOperatorInfo(pInfo, numOfCols); } @@ -7861,71 +8015,73 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SExprInfo return NULL; } -SOperatorInfo* createMultiTableTimeIntervalOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfOutput) { +SOperatorInfo* createMultiTableTimeIntervalOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, + SExprInfo* pExpr, int32_t numOfOutput) { STableIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableIntervalOperatorInfo)); -// pInfo->binfo.pCtx = createSqlFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset); -// pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pResultInfo->capacity); + // pInfo->binfo.pCtx = createSqlFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset); + // pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pResultInfo->capacity); initResultRowInfo(&pInfo->binfo.resultRowInfo, 8); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - pOperator->name = "MultiTableTimeIntervalOperator"; -// pOperator->operatorType = OP_MultiTableTimeInterval; + pOperator->name = "MultiTableTimeIntervalOperator"; + // pOperator->operatorType = OP_MultiTableTimeInterval; pOperator->blockingOptr = true; - pOperator->status = OP_NOT_OPENED; - pOperator->pExpr = pExpr; - pOperator->numOfOutput = numOfOutput; - pOperator->info = pInfo; - pOperator->pRuntimeEnv = pRuntimeEnv; + pOperator->status = OP_NOT_OPENED; + pOperator->pExpr = pExpr; + pOperator->numOfOutput = numOfOutput; + pOperator->info = pInfo; + pOperator->pRuntimeEnv = pRuntimeEnv; pOperator->getNextFn = doSTableIntervalAgg; pOperator->closeFn = destroyBasicOperatorInfo; - int32_t code = appendDownstream(pOperator, &downstream, 1); + int32_t code = appendDownstream(pOperator, &downstream, 1); return pOperator; } -SOperatorInfo* createAllMultiTableTimeIntervalOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfOutput) { +SOperatorInfo* createAllMultiTableTimeIntervalOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, + SExprInfo* pExpr, int32_t numOfOutput) { STableIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableIntervalOperatorInfo)); -// pInfo->binfo.pCtx = createSqlFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset); -// pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pResultInfo->capacity); + // pInfo->binfo.pCtx = createSqlFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset); + // pInfo->binfo.pRes = createOutputBuf(pExpr, numOfOutput, pResultInfo->capacity); initResultRowInfo(&pInfo->binfo.resultRowInfo, 8); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - pOperator->name = "AllMultiTableTimeIntervalOperator"; -// pOperator->operatorType = OP_AllMultiTableTimeInterval; + pOperator->name = "AllMultiTableTimeIntervalOperator"; + // pOperator->operatorType = OP_AllMultiTableTimeInterval; pOperator->blockingOptr = true; - pOperator->status = OP_NOT_OPENED; - pOperator->pExpr = pExpr; - pOperator->numOfOutput = numOfOutput; - pOperator->info = pInfo; - pOperator->pRuntimeEnv = pRuntimeEnv; + pOperator->status = OP_NOT_OPENED; + pOperator->pExpr = pExpr; + pOperator->numOfOutput = numOfOutput; + pOperator->info = pInfo; + pOperator->pRuntimeEnv = pRuntimeEnv; pOperator->getNextFn = doAllSTableIntervalAgg; pOperator->closeFn = destroyBasicOperatorInfo; - int32_t code = appendDownstream(pOperator, &downstream, 1); + int32_t code = appendDownstream(pOperator, &downstream, 1); return pOperator; } -static int32_t initGroupOptrInfo(SGroupbyOperatorInfo *pInfo, SArray* pGroupColList) { +static int32_t initGroupOptrInfo(SGroupbyOperatorInfo* pInfo, SArray* pGroupColList) { pInfo->pGroupColVals = taosArrayInit(4, sizeof(SGroupKeys)); if (pInfo->pGroupColVals == NULL) { return TSDB_CODE_OUT_OF_MEMORY; } int32_t numOfGroupCols = taosArrayGetSize(pGroupColList); - for(int32_t i = 0; i < numOfGroupCols; ++i) { + for (int32_t i = 0; i < numOfGroupCols; ++i) { SColumn* pCol = taosArrayGet(pGroupColList, i); pInfo->groupKeyLen += pCol->bytes; struct SGroupKeys key = {0}; - key.bytes = pCol->bytes; - key.type = pCol->type; + key.bytes = pCol->bytes; + key.type = pCol->type; key.isNull = false; - key.pData = taosMemoryCalloc(1, pCol->bytes); + key.pData = taosMemoryCalloc(1, pCol->bytes); if (key.pData == NULL) { return TSDB_CODE_OUT_OF_MEMORY; } @@ -7943,10 +8099,11 @@ static int32_t initGroupOptrInfo(SGroupbyOperatorInfo *pInfo, SArray* pGroupColL return TSDB_CODE_SUCCESS; } -SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, SSDataBlock* pResultBlock, - SArray* pGroupColList, SExecTaskInfo* pTaskInfo, const STableGroupInfo* pTableGroupInfo) { +SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExprInfo, int32_t numOfCols, + SSDataBlock* pResultBlock, SArray* pGroupColList, SExecTaskInfo* pTaskInfo, + const STableGroupInfo* pTableGroupInfo) { SGroupbyOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupbyOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { goto _error; } @@ -7960,7 +8117,7 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SExprInfo* pEx goto _error; } - pOperator->name = "GroupbyAggOperator"; + pOperator->name = "GroupbyAggOperator"; pOperator->blockingOptr = true; pOperator->status = OP_NOT_OPENED; pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_GROUPBY; @@ -7976,14 +8133,14 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SExprInfo* pEx code = appendDownstream(pOperator, &downstream, 1); return pOperator; - _error: +_error: taosMemoryFreeClear(pInfo); taosMemoryFreeClear(pOperator); return NULL; } static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t numOfCols, int64_t* fillVal, - STimeWindow win, int32_t capacity, const char* id, SInterval* pInterval, int32_t fillType) { + STimeWindow win, int32_t capacity, const char* id, SInterval* pInterval, int32_t fillType) { struct SFillColInfo* pColInfo = createFillColInfo(pExpr, numOfCols, (int64_t*)fillVal); TSKEY sk = TMIN(win.skey, win.ekey); @@ -7994,9 +8151,8 @@ static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t getAlignQueryTimeWindow(pInterval, TSDB_TIME_PRECISION_MILLI, win.skey, sk, ek, &w); int32_t order = TSDB_ORDER_ASC; - pInfo->pFillInfo = - taosCreateFillInfo(order, w.skey, 0, capacity, numOfCols, pInterval->sliding, - pInterval->slidingUnit, (int8_t)pInterval->precision, fillType, pColInfo, id); + pInfo->pFillInfo = taosCreateFillInfo(order, w.skey, 0, capacity, numOfCols, pInterval->sliding, + pInterval->slidingUnit, (int8_t)pInterval->precision, fillType, pColInfo, id); pInfo->p = taosMemoryCalloc(numOfCols, POINTER_BYTES); @@ -8007,90 +8163,92 @@ static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t } } -SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfCols, SInterval* pInterval, SSDataBlock* pResBlock, - int32_t fillType, char* fillVal, bool multigroupResult, SExecTaskInfo* pTaskInfo) { +SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfCols, + SInterval* pInterval, SSDataBlock* pResBlock, int32_t fillType, char* fillVal, + bool multigroupResult, SExecTaskInfo* pTaskInfo) { SFillOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SFillOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - pInfo->pRes = pResBlock; + pInfo->pRes = pResBlock; pInfo->multigroupResult = multigroupResult; - pInfo->intervalInfo = *pInterval; + pInfo->intervalInfo = *pInterval; SResultInfo* pResultInfo = &pOperator->resultInfo; - int32_t code = initFillInfo(pInfo, pExpr, numOfCols, (int64_t*) fillVal, pTaskInfo->window, pResultInfo->capacity, pTaskInfo->id.str, pInterval, fillType); + int32_t code = initFillInfo(pInfo, pExpr, numOfCols, (int64_t*)fillVal, pTaskInfo->window, pResultInfo->capacity, + pTaskInfo->id.str, pInterval, fillType); if (code != TSDB_CODE_SUCCESS) { goto _error; } - pOperator->name = "FillOperator"; + pOperator->name = "FillOperator"; pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; -// pOperator->operatorType = OP_Fill; - pOperator->pExpr = pExpr; - pOperator->numOfOutput = numOfCols; - pOperator->info = pInfo; - pOperator->_openFn = operatorDummyOpenFn; - pOperator->getNextFn = doFill; - pOperator->pTaskInfo = pTaskInfo; + pOperator->status = OP_NOT_OPENED; + // pOperator->operatorType = OP_Fill; + pOperator->pExpr = pExpr; + pOperator->numOfOutput = numOfCols; + pOperator->info = pInfo; + pOperator->_openFn = operatorDummyOpenFn; + pOperator->getNextFn = doFill; + pOperator->pTaskInfo = pTaskInfo; - pOperator->closeFn = destroySFillOperatorInfo; + pOperator->closeFn = destroySFillOperatorInfo; code = appendDownstream(pOperator, &downstream, 1); return pOperator; - _error: +_error: taosMemoryFreeClear(pOperator); taosMemoryFreeClear(pInfo); return NULL; } -SOperatorInfo* createSLimitOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfOutput, void* pMerger, bool multigroupResult) { +SOperatorInfo* createSLimitOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, + int32_t numOfOutput, void* pMerger, bool multigroupResult) { SSLimitOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SSLimitOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); -// pInfo->orderColumnList = getResultGroupCheckColumns(pQueryAttr); -// pInfo->slimit = pQueryAttr->slimit; -// pInfo->limit = pQueryAttr->limit; -// pInfo->capacity = pResultInfo->capacity; -// pInfo->threshold = (int64_t)(pInfo->capacity * 0.8); -// pInfo->currentOffset = pQueryAttr->limit.offset; -// pInfo->currentGroupOffset = pQueryAttr->slimit.offset; - pInfo->multigroupResult= multigroupResult; + // pInfo->orderColumnList = getResultGroupCheckColumns(pQueryAttr); + // pInfo->slimit = pQueryAttr->slimit; + // pInfo->limit = pQueryAttr->limit; + // pInfo->capacity = pResultInfo->capacity; + // pInfo->threshold = (int64_t)(pInfo->capacity * 0.8); + // pInfo->currentOffset = pQueryAttr->limit.offset; + // pInfo->currentGroupOffset = pQueryAttr->slimit.offset; + pInfo->multigroupResult = multigroupResult; // TODO refactor int32_t len = 0; - for(int32_t i = 0; i < numOfOutput; ++i) { + for (int32_t i = 0; i < numOfOutput; ++i) { len += pExpr[i].base.resSchema.bytes; } - int32_t numOfCols = (pInfo->orderColumnList != NULL)? (int32_t) taosArrayGetSize(pInfo->orderColumnList):0; + int32_t numOfCols = (pInfo->orderColumnList != NULL) ? (int32_t)taosArrayGetSize(pInfo->orderColumnList) : 0; pInfo->prevRow = taosMemoryCalloc(1, (POINTER_BYTES * numOfCols + len)); int32_t offset = POINTER_BYTES * numOfCols; - for(int32_t i = 0; i < numOfCols; ++i) { + for (int32_t i = 0; i < numOfCols; ++i) { pInfo->prevRow[i] = (char*)pInfo->prevRow + offset; SColIndex* index = taosArrayGet(pInfo->orderColumnList, i); offset += pExpr[index->colIndex].base.resSchema.bytes; } -// pInfo->pRes = createOutputBuf(pExpr, numOfOutput, pOperator->resultInfo.capacity); + // pInfo->pRes = createOutputBuf(pExpr, numOfOutput, pOperator->resultInfo.capacity); - - pOperator->name = "SLimitOperator"; + pOperator->name = "SLimitOperator"; // pOperator->operatorType = OP_SLimit; pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; -// pOperator->exec = doSLimit; - pOperator->info = pInfo; - pOperator->pRuntimeEnv = pRuntimeEnv; + pOperator->status = OP_NOT_OPENED; + // pOperator->exec = doSLimit; + pOperator->info = pInfo; + pOperator->pRuntimeEnv = pRuntimeEnv; pOperator->closeFn = destroySlimitOperatorInfo; - int32_t code = appendDownstream(pOperator, &downstream, 1); + int32_t code = appendDownstream(pOperator, &downstream, 1); return pOperator; } -static SSDataBlock* doTagScan(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* doTagScan(SOperatorInfo* pOperator, bool* newgroup) { #if 0 SOperatorInfo* pOperator = (SOperatorInfo*) param; if (pOperator->status == OP_EXEC_DONE) { @@ -8224,7 +8382,7 @@ static SSDataBlock* doTagScan(SOperatorInfo *pOperator, bool* newgroup) { SOperatorInfo* createTagScanOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SExprInfo* pExpr, int32_t numOfOutput) { STagScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo)); -// pInfo->pRes = createOutputBuf(pExpr, numOfOutput, pResultInfo->capacity); + // pInfo->pRes = createOutputBuf(pExpr, numOfOutput, pResultInfo->capacity); size_t numOfGroup = GET_NUM_OF_TABLEGROUP(pRuntimeEnv); assert(numOfGroup == 0 || numOfGroup == 1); @@ -8233,26 +8391,26 @@ SOperatorInfo* createTagScanOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SExprInfo pInfo->curPos = 0; SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - pOperator->name = "SeqTableTagScan"; + pOperator->name = "SeqTableTagScan"; pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN; pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; + pOperator->status = OP_NOT_OPENED; + pOperator->info = pInfo; pOperator->getNextFn = doTagScan; - pOperator->pExpr = pExpr; - pOperator->numOfOutput = numOfOutput; - pOperator->pRuntimeEnv = pRuntimeEnv; + pOperator->pExpr = pExpr; + pOperator->numOfOutput = numOfOutput; + pOperator->pRuntimeEnv = pRuntimeEnv; pOperator->closeFn = destroyTagScanOperatorInfo; return pOperator; } -static bool initMultiDistinctInfo(SDistinctOperatorInfo *pInfo, SOperatorInfo* pOperator, SSDataBlock *pBlock) { +static bool initMultiDistinctInfo(SDistinctOperatorInfo* pInfo, SOperatorInfo* pOperator, SSDataBlock* pBlock) { if (taosArrayGetSize(pInfo->pDistinctDataInfo) == pOperator->numOfOutput) { - // distinct info already inited + // distinct info already inited return true; } for (int i = 0; i < pOperator->numOfOutput; i++) { -// pInfo->totalBytes += pOperator->pExpr[i].base.colBytes; + // pInfo->totalBytes += pOperator->pExpr[i].base.colBytes; } for (int i = 0; i < pOperator->numOfOutput; i++) { int numOfBlock = (int)(taosArrayGetSize(pBlock->pDataBlock)); @@ -8266,20 +8424,20 @@ static bool initMultiDistinctInfo(SDistinctOperatorInfo *pInfo, SOperatorInfo* p } } pInfo->totalBytes += (int32_t)strlen(MULTI_KEY_DELIM) * (pOperator->numOfOutput); - pInfo->buf = taosMemoryCalloc(1, pInfo->totalBytes); - return taosArrayGetSize(pInfo->pDistinctDataInfo) == pOperator->numOfOutput ? true : false; + pInfo->buf = taosMemoryCalloc(1, pInfo->totalBytes); + return taosArrayGetSize(pInfo->pDistinctDataInfo) == pOperator->numOfOutput ? true : false; } -static void buildMultiDistinctKey(SDistinctOperatorInfo *pInfo, SSDataBlock *pBlock, int32_t rowId) { - char *p = pInfo->buf; - memset(p, 0, pInfo->totalBytes); +static void buildMultiDistinctKey(SDistinctOperatorInfo* pInfo, SSDataBlock* pBlock, int32_t rowId) { + char* p = pInfo->buf; + memset(p, 0, pInfo->totalBytes); for (int i = 0; i < taosArrayGetSize(pInfo->pDistinctDataInfo); i++) { - SDistinctDataInfo* pDistDataInfo = (SDistinctDataInfo *)taosArrayGet(pInfo->pDistinctDataInfo, i); + SDistinctDataInfo* pDistDataInfo = (SDistinctDataInfo*)taosArrayGet(pInfo->pDistinctDataInfo, i); SColumnInfoData* pColDataInfo = taosArrayGet(pBlock->pDataBlock, pDistDataInfo->index); - char *val = ((char *)pColDataInfo->pData) + pColDataInfo->info.bytes * rowId; - if (isNull(val, pDistDataInfo->type)) { - p += pDistDataInfo->bytes; + char* val = ((char*)pColDataInfo->pData) + pColDataInfo->info.bytes * rowId; + if (isNull(val, pDistDataInfo->type)) { + p += pDistDataInfo->bytes; continue; } if (IS_VAR_DATA_TYPE(pDistDataInfo->type)) { @@ -8294,18 +8452,18 @@ static void buildMultiDistinctKey(SDistinctOperatorInfo *pInfo, SSDataBlock *pBl } } -static SSDataBlock* hashDistinct(SOperatorInfo *pOperator, bool* newgroup) { +static SSDataBlock* hashDistinct(SOperatorInfo* pOperator, bool* newgroup) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } SDistinctOperatorInfo* pInfo = pOperator->info; - SSDataBlock* pRes = pInfo->pRes; + SSDataBlock* pRes = pInfo->pRes; pRes->info.rows = 0; SSDataBlock* pBlock = NULL; - - while(1) { + + while (1) { publishOperatorProfEvent(pOperator->pDownstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC); pBlock = pOperator->pDownstream[0]->getNextFn(pOperator->pDownstream[0], newgroup); publishOperatorProfEvent(pOperator->pDownstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC); @@ -8318,13 +8476,13 @@ static SSDataBlock* hashDistinct(SOperatorInfo *pOperator, bool* newgroup) { doSetOperatorCompleted(pOperator); break; } - // ensure result output buf + // ensure result output buf if (pRes->info.rows + pBlock->info.rows > pInfo->outputCapacity) { int32_t newSize = pRes->info.rows + pBlock->info.rows; for (int i = 0; i < taosArrayGetSize(pRes->pDataBlock); i++) { SColumnInfoData* pResultColInfoData = taosArrayGet(pRes->pDataBlock, i); - SDistinctDataInfo* pDistDataInfo = taosArrayGet(pInfo->pDistinctDataInfo, i); - char* tmp = taosMemoryRealloc(pResultColInfoData->pData, newSize * pDistDataInfo->bytes); + SDistinctDataInfo* pDistDataInfo = taosArrayGet(pInfo->pDistinctDataInfo, i); + char* tmp = taosMemoryRealloc(pResultColInfoData->pData, newSize * pDistDataInfo->bytes); if (tmp == NULL) { return NULL; } else { @@ -8341,53 +8499,53 @@ static SSDataBlock* hashDistinct(SOperatorInfo *pOperator, bool* newgroup) { taosHashPut(pInfo->pSet, pInfo->buf, pInfo->totalBytes, &dummy, sizeof(dummy)); for (int j = 0; j < taosArrayGetSize(pRes->pDataBlock); j++) { SDistinctDataInfo* pDistDataInfo = taosArrayGet(pInfo->pDistinctDataInfo, j); // distinct meta info - SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pDistDataInfo->index); //src - SColumnInfoData* pResultColInfoData = taosArrayGet(pRes->pDataBlock, j); // dist + SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pDistDataInfo->index); // src + SColumnInfoData* pResultColInfoData = taosArrayGet(pRes->pDataBlock, j); // dist char* val = ((char*)pColInfoData->pData) + pDistDataInfo->bytes * i; - char *start = pResultColInfoData->pData + pDistDataInfo->bytes * pInfo->pRes->info.rows; + char* start = pResultColInfoData->pData + pDistDataInfo->bytes * pInfo->pRes->info.rows; memcpy(start, val, pDistDataInfo->bytes); } pRes->info.rows += 1; - } + } } if (pRes->info.rows >= pInfo->threshold) { break; } } - return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL; + return (pInfo->pRes->info.rows > 0) ? pInfo->pRes : NULL; } -SOperatorInfo* createDistinctOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, int32_t numOfOutput) { +SOperatorInfo* createDistinctOperatorInfo(STaskRuntimeEnv* pRuntimeEnv, SOperatorInfo* downstream, SExprInfo* pExpr, + int32_t numOfOutput) { SDistinctOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SDistinctOperatorInfo)); - pInfo->totalBytes = 0; - pInfo->buf = NULL; - pInfo->threshold = tsMaxNumOfDistinctResults; // distinct result threshold - pInfo->outputCapacity = 4096; - pInfo->pDistinctDataInfo = taosArrayInit(numOfOutput, sizeof(SDistinctDataInfo)); + pInfo->totalBytes = 0; + pInfo->buf = NULL; + pInfo->threshold = tsMaxNumOfDistinctResults; // distinct result threshold + pInfo->outputCapacity = 4096; + pInfo->pDistinctDataInfo = taosArrayInit(numOfOutput, sizeof(SDistinctDataInfo)); pInfo->pSet = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK); -// pInfo->pRes = createOutputBuf(pExpr, numOfOutput, (int32_t) pInfo->outputCapacity); - + // pInfo->pRes = createOutputBuf(pExpr, numOfOutput, (int32_t) pInfo->outputCapacity); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - pOperator->name = "DistinctOperator"; + pOperator->name = "DistinctOperator"; pOperator->blockingOptr = false; - pOperator->status = OP_NOT_OPENED; -// pOperator->operatorType = OP_Distinct; - pOperator->pExpr = pExpr; - pOperator->numOfOutput = numOfOutput; - pOperator->info = pInfo; - pOperator->pRuntimeEnv = pRuntimeEnv; + pOperator->status = OP_NOT_OPENED; + // pOperator->operatorType = OP_Distinct; + pOperator->pExpr = pExpr; + pOperator->numOfOutput = numOfOutput; + pOperator->info = pInfo; + pOperator->pRuntimeEnv = pRuntimeEnv; pOperator->getNextFn = hashDistinct; - pOperator->pExpr = pExpr; + pOperator->pExpr = pExpr; pOperator->closeFn = destroyDistinctOperatorInfo; - int32_t code = appendDownstream(pOperator, &downstream, 1); + int32_t code = appendDownstream(pOperator, &downstream, 1); return pOperator; } -static int32_t getColumnIndexInSource(SQueriedTableInfo *pTableInfo, SExprBasicInfo *pExpr, SColumnInfo* pTagCols) { +static int32_t getColumnIndexInSource(SQueriedTableInfo* pTableInfo, SExprBasicInfo* pExpr, SColumnInfo* pTagCols) { int32_t j = 0; if (TSDB_COL_IS_TAG(pExpr->pParam[0].pCol->type)) { @@ -8395,7 +8553,7 @@ static int32_t getColumnIndexInSource(SQueriedTableInfo *pTableInfo, SExprBasicI return TSDB_TBNAME_COLUMN_INDEX; } - while(j < pTableInfo->numOfTags) { + while (j < pTableInfo->numOfTags) { if (pExpr->pParam[0].pCol->colId == pTagCols[j].colId) { return j; } @@ -8418,16 +8576,16 @@ static int32_t getColumnIndexInSource(SQueriedTableInfo *pTableInfo, SExprBasicI return INT32_MIN; // return a less than TSDB_TBNAME_COLUMN_INDEX value } -bool validateExprColumnInfo(SQueriedTableInfo *pTableInfo, SExprBasicInfo *pExpr, SColumnInfo* pTagCols) { +bool validateExprColumnInfo(SQueriedTableInfo* pTableInfo, SExprBasicInfo* pExpr, SColumnInfo* pTagCols) { int32_t j = getColumnIndexInSource(pTableInfo, pExpr, pTagCols); return j != INT32_MIN; } static int32_t deserializeColFilterInfo(SColumnFilterInfo* pColFilters, int16_t numOfFilters, char** pMsg) { for (int32_t f = 0; f < numOfFilters; ++f) { - SColumnFilterInfo *pFilterMsg = (SColumnFilterInfo *)(*pMsg); + SColumnFilterInfo* pFilterMsg = (SColumnFilterInfo*)(*pMsg); - SColumnFilterInfo *pColFilter = &pColFilters[f]; + SColumnFilterInfo* pColFilter = &pColFilters[f]; pColFilter->filterstr = htons(pFilterMsg->filterstr); (*pMsg) += sizeof(SColumnFilterInfo); @@ -8435,12 +8593,13 @@ static int32_t deserializeColFilterInfo(SColumnFilterInfo* pColFilters, int16_t if (pColFilter->filterstr) { pColFilter->len = htobe64(pFilterMsg->len); - pColFilter->pz = (int64_t)taosMemoryCalloc(1, (size_t)(pColFilter->len + 1 * TSDB_NCHAR_SIZE)); // note: null-terminator + pColFilter->pz = + (int64_t)taosMemoryCalloc(1, (size_t)(pColFilter->len + 1 * TSDB_NCHAR_SIZE)); // note: null-terminator if (pColFilter->pz == 0) { return TSDB_CODE_QRY_OUT_OF_MEMORY; } - memcpy((void *)pColFilter->pz, (*pMsg), (size_t)pColFilter->len); + memcpy((void*)pColFilter->pz, (*pMsg), (size_t)pColFilter->len); (*pMsg) += (pColFilter->len + 1); } else { pColFilter->lowerBndi = htobe64(pFilterMsg->lowerBndi); @@ -8454,10 +8613,11 @@ static int32_t deserializeColFilterInfo(SColumnFilterInfo* pColFilters, int16_t return TSDB_CODE_SUCCESS; } -static SResSchema createResSchema(int32_t type, int32_t bytes, int32_t slotId, int32_t scale, int32_t precision, const char* name) { +static SResSchema createResSchema(int32_t type, int32_t bytes, int32_t slotId, int32_t scale, int32_t precision, + const char* name) { SResSchema s = {0}; s.scale = scale; - s.type = type; + s.type = type; s.bytes = bytes; s.colId = slotId; s.precision = precision; @@ -8476,7 +8636,7 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* *numOfExprs = numOfFuncs + numOfGroupKeys; SExprInfo* pExprs = taosMemoryCalloc(*numOfExprs, sizeof(SExprInfo)); - for(int32_t i = 0; i < (*numOfExprs); ++i) { + for (int32_t i = 0; i < (*numOfExprs); ++i) { STargetNode* pTargetNode = NULL; if (i < numOfFuncs) { pTargetNode = (STargetNode*)nodesListGetNode(pNodeList, i); @@ -8490,19 +8650,20 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* pExp->pExpr->_function.num = 1; pExp->pExpr->_function.functionId = -1; - pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam)); - pExp->base.numOfParams = 1; - - pExp->base.pParam[0].pCol = taosMemoryCalloc(1, sizeof(SColumn)); - SColumn* pCol = pExp->base.pParam[0].pCol; - // it is a project query, or group by column if (nodeType(pTargetNode->pExpr) == QUERY_NODE_COLUMN) { pExp->pExpr->nodeType = QUERY_NODE_COLUMN; - SColumnNode* pColNode = (SColumnNode*) pTargetNode->pExpr; + SColumnNode* pColNode = (SColumnNode*)pTargetNode->pExpr; + + pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam)); + pExp->base.numOfParams = 1; + pExp->base.pParam[0].pCol = taosMemoryCalloc(1, sizeof(SColumn)); + pExp->base.pParam[0].type = FUNC_PARAM_TYPE_COLUMN; SDataType* pType = &pColNode->node.resType; pExp->base.resSchema = createResSchema(pType->type, pType->bytes, pTargetNode->slotId, pType->scale, pType->precision, pColNode->colName); + + SColumn* pCol = pExp->base.pParam[0].pCol; pCol->slotId = pColNode->slotId; // TODO refactor pCol->bytes = pType->bytes; pCol->type = pType->type; @@ -8513,34 +8674,57 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* SFunctionNode* pFuncNode = (SFunctionNode*)pTargetNode->pExpr; SDataType* pType = &pFuncNode->node.resType; - pExp->base.resSchema = createResSchema(pType->type, pType->bytes, pTargetNode->slotId, pType->scale, pType->precision, pFuncNode->node.aliasName); + pExp->base.resSchema = createResSchema(pType->type, pType->bytes, pTargetNode->slotId, pType->scale, + pType->precision, pFuncNode->node.aliasName); pExp->pExpr->_function.functionId = pFuncNode->funcId; pExp->pExpr->_function.pFunctNode = pFuncNode; - strncpy(pExp->pExpr->_function.functionName, pFuncNode->functionName, tListLen(pExp->pExpr->_function.functionName)); + strncpy(pExp->pExpr->_function.functionName, pFuncNode->functionName, + tListLen(pExp->pExpr->_function.functionName)); // TODO: value parameter needs to be handled int32_t numOfParam = LIST_LENGTH(pFuncNode->pParameterList); + + pExp->base.pParam = taosMemoryCalloc(numOfParam, sizeof(SFunctParam)); + pExp->base.numOfParams = numOfParam; + for (int32_t j = 0; j < numOfParam; ++j) { SNode* p1 = nodesListGetNode(pFuncNode->pParameterList, j); - SColumnNode* pcn = (SColumnNode*)p1; // TODO refactor + if (p1->type == QUERY_NODE_COLUMN) { + SColumnNode* pcn = (SColumnNode*)p1; // TODO refactor - pCol->slotId = pcn->slotId; - pCol->bytes = pcn->node.resType.bytes; - pCol->type = pcn->node.resType.type; - pCol->scale = pcn->node.resType.scale; - pCol->precision = pcn->node.resType.precision; - pCol->dataBlockId = pcn->dataBlockId; + pExp->base.pParam[j].type = FUNC_PARAM_TYPE_COLUMN; + pExp->base.pParam[j].pCol = taosMemoryCalloc(1, sizeof(SColumn)); + SColumn* pCol = pExp->base.pParam[j].pCol; + + pCol->slotId = pcn->slotId; + pCol->bytes = pcn->node.resType.bytes; + pCol->type = pcn->node.resType.type; + pCol->scale = pcn->node.resType.scale; + pCol->precision = pcn->node.resType.precision; + pCol->dataBlockId = pcn->dataBlockId; + } else if (p1->type == QUERY_NODE_VALUE) { + SValueNode* pvn = (SValueNode*)p1; + + pExp->base.pParam[j].type = FUNC_PARAM_TYPE_VALUE; + } } } else if (nodeType(pTargetNode->pExpr) == QUERY_NODE_OPERATOR) { pExp->pExpr->nodeType = QUERY_NODE_OPERATOR; - SOperatorNode* pNode = (SOperatorNode*) pTargetNode->pExpr; + SOperatorNode* pNode = (SOperatorNode*)pTargetNode->pExpr; + + pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam)); + pExp->base.numOfParams = 1; + pExp->base.pParam[0].pCol = taosMemoryCalloc(1, sizeof(SColumn)); + pExp->base.pParam[0].type = FUNC_PARAM_TYPE_COLUMN; SDataType* pType = &pNode->node.resType; - pExp->base.resSchema = createResSchema(pType->type, pType->bytes, pTargetNode->slotId, pType->scale, pType->precision, pNode->node.aliasName); + pExp->base.resSchema = createResSchema(pType->type, pType->bytes, pTargetNode->slotId, pType->scale, + pType->precision, pNode->node.aliasName); pExp->pExpr->_optrRoot.pRootNode = pTargetNode->pExpr; + SColumn* pCol = pExp->base.pParam[0].pCol; pCol->slotId = pTargetNode->slotId; // TODO refactor pCol->bytes = pType->bytes; pCol->type = pType->type; @@ -8562,57 +8746,65 @@ static SExecTaskInfo* createExecTaskInfo(uint64_t queryId, uint64_t taskId) { pTaskInfo->id.queryId = queryId; char* p = taosMemoryCalloc(1, 128); - snprintf(p, 128, "TID:0x%"PRIx64" QID:0x%"PRIx64, taskId, queryId); + snprintf(p, 128, "TID:0x%" PRIx64 " QID:0x%" PRIx64, taskId, queryId); pTaskInfo->id.str = strdup(p); return pTaskInfo; } -static tsdbReaderT doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle, STableGroupInfo *pTableGroupInfo, uint64_t queryId, uint64_t taskId); +static tsdbReaderT doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle, + STableGroupInfo* pTableGroupInfo, uint64_t queryId, uint64_t taskId); -static int32_t doCreateTableGroup(void* metaHandle, int32_t tableType, uint64_t tableUid, STableGroupInfo* pGroupInfo, uint64_t queryId, uint64_t taskId); +static int32_t doCreateTableGroup(void* metaHandle, int32_t tableType, uint64_t tableUid, STableGroupInfo* pGroupInfo, + uint64_t queryId, uint64_t taskId); static SArray* extractTableIdList(const STableGroupInfo* pTableGroupInfo); static SArray* extractScanColumnId(SNodeList* pNodeList); static SArray* extractColumnInfo(SNodeList* pNodeList); static SArray* extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols); static SArray* createSortInfo(SNodeList* pNodeList); -SOperatorInfo* doCreateOperatorTreeNode(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, uint64_t queryId, uint64_t taskId, STableGroupInfo* pTableGroupInfo) { +SOperatorInfo* doCreateOperatorTreeNode(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, + uint64_t queryId, uint64_t taskId, STableGroupInfo* pTableGroupInfo) { if (pPhyNode->pChildren == NULL || LIST_LENGTH(pPhyNode->pChildren) == 0) { if (QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == nodeType(pPhyNode)) { SScanPhysiNode* pScanPhyNode = (SScanPhysiNode*)pPhyNode; int32_t numOfCols = 0; - tsdbReaderT pDataReader = doCreateDataReader((STableScanPhysiNode*)pPhyNode, pHandle, pTableGroupInfo, (uint64_t)queryId, taskId); - SArray* pColList = extractColMatchInfo(pScanPhyNode->pScanCols, pScanPhyNode->node.pOutputDataBlockDesc, &numOfCols); + tsdbReaderT pDataReader = + doCreateDataReader((STableScanPhysiNode*)pPhyNode, pHandle, pTableGroupInfo, (uint64_t)queryId, taskId); + SArray* pColList = + extractColMatchInfo(pScanPhyNode->pScanCols, pScanPhyNode->node.pOutputDataBlockDesc, &numOfCols); - return createTableScanOperatorInfo(pDataReader, pScanPhyNode->order, numOfCols, pScanPhyNode->count, pScanPhyNode->reverse, pColList, pTaskInfo); + return createTableScanOperatorInfo(pDataReader, pScanPhyNode->order, numOfCols, pScanPhyNode->count, + pScanPhyNode->reverse, pColList, pTaskInfo); } else if (QUERY_NODE_PHYSICAL_PLAN_EXCHANGE == nodeType(pPhyNode)) { SExchangePhysiNode* pExchange = (SExchangePhysiNode*)pPhyNode; - SSDataBlock* pResBlock = createOutputBuf_rv1(pExchange->node.pOutputDataBlockDesc); + SSDataBlock* pResBlock = createOutputBuf_rv1(pExchange->node.pOutputDataBlockDesc); return createExchangeOperatorInfo(pExchange->pSrcEndPoints, pResBlock, pTaskInfo); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN == nodeType(pPhyNode)) { SScanPhysiNode* pScanPhyNode = (SScanPhysiNode*)pPhyNode; // simple child table. - int32_t code = doCreateTableGroup(pHandle->meta, pScanPhyNode->tableType, pScanPhyNode->uid, pTableGroupInfo, queryId, taskId); + int32_t code = doCreateTableGroup(pHandle->meta, pScanPhyNode->tableType, pScanPhyNode->uid, pTableGroupInfo, + queryId, taskId); SArray* tableIdList = extractTableIdList(pTableGroupInfo); SSDataBlock* pResBlock = createOutputBuf_rv1(pScanPhyNode->node.pOutputDataBlockDesc); - SArray* colList = extractScanColumnId(pScanPhyNode->pScanCols); + SArray* colList = extractScanColumnId(pScanPhyNode->pScanCols); - SOperatorInfo* pOperator = createStreamScanOperatorInfo(pHandle->reader, pResBlock, colList, tableIdList, pTaskInfo); + SOperatorInfo* pOperator = + createStreamScanOperatorInfo(pHandle->reader, pResBlock, colList, tableIdList, pTaskInfo); taosArrayDestroy(tableIdList); return pOperator; } else if (QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN == nodeType(pPhyNode)) { - SSystemTableScanPhysiNode * pSysScanPhyNode = (SSystemTableScanPhysiNode*)pPhyNode; - SSDataBlock* pResBlock = createOutputBuf_rv1(pSysScanPhyNode->scan.node.pOutputDataBlockDesc); + SSystemTableScanPhysiNode* pSysScanPhyNode = (SSystemTableScanPhysiNode*)pPhyNode; + SSDataBlock* pResBlock = createOutputBuf_rv1(pSysScanPhyNode->scan.node.pOutputDataBlockDesc); struct SScanPhysiNode* pScanNode = &pSysScanPhyNode->scan; - SArray* colList = extractScanColumnId(pScanNode->pScanCols); + SArray* colList = extractScanColumnId(pScanNode->pScanCols); - SOperatorInfo* pOperator = createSysTableScanOperatorInfo(pHandle->meta, pResBlock, &pScanNode->tableName, - pScanNode->node.pConditions, pSysScanPhyNode->mgmtEpSet, - colList, pTaskInfo, pSysScanPhyNode->showRewrite, pSysScanPhyNode->accountId); + SOperatorInfo* pOperator = createSysTableScanOperatorInfo( + pHandle->meta, pResBlock, &pScanNode->tableName, pScanNode->node.pConditions, pSysScanPhyNode->mgmtEpSet, + colList, pTaskInfo, pSysScanPhyNode->showRewrite, pSysScanPhyNode->accountId); return pOperator; } else { ASSERT(0); @@ -8626,8 +8818,8 @@ SOperatorInfo* doCreateOperatorTreeNode(SPhysiNode* pPhyNode, SExecTaskInfo* pTa SPhysiNode* pChildNode = (SPhysiNode*)nodesListGetNode(pPhyNode->pChildren, 0); SOperatorInfo* op = doCreateOperatorTreeNode(pChildNode, pTaskInfo, pHandle, queryId, taskId, pTableGroupInfo); - int32_t num = 0; - SExprInfo* pExprInfo = createExprInfo(((SProjectPhysiNode*)pPhyNode)->pProjections, NULL, &num); + int32_t num = 0; + SExprInfo* pExprInfo = createExprInfo(((SProjectPhysiNode*)pPhyNode)->pProjections, NULL, &num); SSDataBlock* pResBlock = createOutputBuf_rv1(pPhyNode->pOutputDataBlockDesc); return createProjectOperatorInfo(op, pExprInfo, num, pResBlock, pTaskInfo); } else if (QUERY_NODE_PHYSICAL_PLAN_AGG == nodeType(pPhyNode)) { @@ -8641,8 +8833,8 @@ SOperatorInfo* doCreateOperatorTreeNode(SPhysiNode* pPhyNode, SExecTaskInfo* pTa int32_t num = 0; SAggPhysiNode* pAggNode = (SAggPhysiNode*)pPhyNode; - SExprInfo* pExprInfo = createExprInfo(pAggNode->pAggFuncs, pAggNode->pGroupKeys, &num); - SSDataBlock* pResBlock = createOutputBuf_rv1(pPhyNode->pOutputDataBlockDesc); + SExprInfo* pExprInfo = createExprInfo(pAggNode->pAggFuncs, pAggNode->pGroupKeys, &num); + SSDataBlock* pResBlock = createOutputBuf_rv1(pPhyNode->pOutputDataBlockDesc); if (pAggNode->pGroupKeys != NULL) { SArray* pColList = extractColumnInfo(pAggNode->pGroupKeys); @@ -8661,9 +8853,9 @@ SOperatorInfo* doCreateOperatorTreeNode(SPhysiNode* pPhyNode, SExecTaskInfo* pTa SIntervalPhysiNode* pIntervalPhyNode = (SIntervalPhysiNode*)pPhyNode; - //todo: set the correct primary timestamp key column - int32_t num = 0; - SExprInfo* pExprInfo = createExprInfo(pIntervalPhyNode->window.pFuncs, NULL, &num); + // todo: set the correct primary timestamp key column + int32_t num = 0; + SExprInfo* pExprInfo = createExprInfo(pIntervalPhyNode->window.pFuncs, NULL, &num); SSDataBlock* pResBlock = createOutputBuf_rv1(pPhyNode->pOutputDataBlockDesc); SInterval interval = {.interval = pIntervalPhyNode->interval, @@ -8700,24 +8892,25 @@ SOperatorInfo* doCreateOperatorTreeNode(SPhysiNode* pPhyNode, SExecTaskInfo* pTa return createSessionAggOperatorInfo(op, pExprInfo, num, pResBlock, pSessionNode->gap, pTaskInfo); } else { ASSERT(0); - }/*else if (pPhyNode->info.type == OP_MultiTableAggregate) { - size_t size = taosArrayGetSize(pPhyNode->pChildren); - assert(size == 1); + } /*else if (pPhyNode->info.type == OP_MultiTableAggregate) { + size_t size = taosArrayGetSize(pPhyNode->pChildren); + assert(size == 1); - for (int32_t i = 0; i < size; ++i) { - SPhysiNode* pChildNode = taosArrayGetP(pPhyNode->pChildren, i); - SOperatorInfo* op = doCreateOperatorTreeNode(pChildNode, pTaskInfo, pHandle, queryId, taskId, pTableGroupInfo); - return createMultiTableAggOperatorInfo(op, pPhyNode->pTargets, pTaskInfo, pTableGroupInfo); - } - }*/ + for (int32_t i = 0; i < size; ++i) { + SPhysiNode* pChildNode = taosArrayGetP(pPhyNode->pChildren, i); + SOperatorInfo* op = doCreateOperatorTreeNode(pChildNode, pTaskInfo, pHandle, queryId, taskId, pTableGroupInfo); + return createMultiTableAggOperatorInfo(op, pPhyNode->pTargets, pTaskInfo, pTableGroupInfo); + } + }*/ } -static tsdbReaderT createDataReaderImpl(STableScanPhysiNode* pTableScanNode, STableGroupInfo* pGroupInfo, void* readHandle, uint64_t queryId, uint64_t taskId) { +static tsdbReaderT createDataReaderImpl(STableScanPhysiNode* pTableScanNode, STableGroupInfo* pGroupInfo, + void* readHandle, uint64_t queryId, uint64_t taskId) { STsdbQueryCond cond = {.loadExternalRows = false}; - cond.order = pTableScanNode->scan.order; + cond.order = pTableScanNode->scan.order; cond.numOfCols = LIST_LENGTH(pTableScanNode->scan.pScanCols); - cond.colList = taosMemoryCalloc(cond.numOfCols, sizeof(SColumnInfo)); + cond.colList = taosMemoryCalloc(cond.numOfCols, sizeof(SColumnInfo)); if (cond.colList == NULL) { terrno = TSDB_CODE_QRY_OUT_OF_MEMORY; return NULL; @@ -8725,7 +8918,7 @@ static tsdbReaderT createDataReaderImpl(STableScanPhysiNode* pTableScanNode, STa cond.twindow = pTableScanNode->scanRange; cond.type = BLOCK_LOAD_OFFSET_SEQ_ORDER; -// cond.type = pTableScanNode->scanFlag; + // cond.type = pTableScanNode->scanFlag; int32_t j = 0; for (int32_t i = 0; i < cond.numOfCols; ++i) { @@ -8735,7 +8928,7 @@ static tsdbReaderT createDataReaderImpl(STableScanPhysiNode* pTableScanNode, STa continue; } - cond.colList[j].type = pColNode->node.resType.type; + cond.colList[j].type = pColNode->node.resType.type; cond.colList[j].bytes = pColNode->node.resType.bytes; cond.colList[j].colId = pColNode->colId; j += 1; @@ -8746,18 +8939,18 @@ static tsdbReaderT createDataReaderImpl(STableScanPhysiNode* pTableScanNode, STa } SArray* extractScanColumnId(SNodeList* pNodeList) { - size_t numOfCols = LIST_LENGTH(pNodeList); + size_t numOfCols = LIST_LENGTH(pNodeList); SArray* pList = taosArrayInit(numOfCols, sizeof(int16_t)); if (pList == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - for(int32_t i = 0; i < numOfCols; ++i) { + for (int32_t i = 0; i < numOfCols; ++i) { for (int32_t j = 0; j < numOfCols; ++j) { - STargetNode* pNode = (STargetNode*) nodesListGetNode(pNodeList, j); + STargetNode* pNode = (STargetNode*)nodesListGetNode(pNodeList, j); if (pNode->slotId == i) { - SColumnNode* pColNode = (SColumnNode*) pNode->pExpr; + SColumnNode* pColNode = (SColumnNode*)pNode->pExpr; taosArrayPush(pList, &pColNode->colId); break; } @@ -8768,24 +8961,24 @@ SArray* extractScanColumnId(SNodeList* pNodeList) { } SArray* extractColumnInfo(SNodeList* pNodeList) { - size_t numOfCols = LIST_LENGTH(pNodeList); + size_t numOfCols = LIST_LENGTH(pNodeList); SArray* pList = taosArrayInit(numOfCols, sizeof(SColumn)); if (pList == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - for(int32_t i = 0; i < numOfCols; ++i) { - STargetNode* pNode = (STargetNode*) nodesListGetNode(pNodeList, i); - SColumnNode* pColNode = (SColumnNode*) pNode->pExpr; + for (int32_t i = 0; i < numOfCols; ++i) { + STargetNode* pNode = (STargetNode*)nodesListGetNode(pNodeList, i); + SColumnNode* pColNode = (SColumnNode*)pNode->pExpr; SColumn c = {0}; c.slotId = pColNode->slotId; - c.colId = pColNode->colId; - c.type = pColNode->node.resType.type; - c.bytes = pColNode->node.resType.bytes; - c.precision = pColNode->node.resType.precision; - c.scale = pColNode->node.resType.scale; + c.colId = pColNode->colId; + c.type = pColNode->node.resType.type; + c.bytes = pColNode->node.resType.bytes; + c.precision = pColNode->node.resType.precision; + c.scale = pColNode->node.resType.scale; taosArrayPush(pList, &c); } @@ -8794,30 +8987,30 @@ SArray* extractColumnInfo(SNodeList* pNodeList) { } SArray* createSortInfo(SNodeList* pNodeList) { - size_t numOfCols = LIST_LENGTH(pNodeList); + size_t numOfCols = LIST_LENGTH(pNodeList); SArray* pList = taosArrayInit(numOfCols, sizeof(SBlockOrderInfo)); if (pList == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return pList; } - for(int32_t i = 0; i < numOfCols; ++i) { - STargetNode* pNode = (STargetNode*) nodesListGetNode(pNodeList, i); - SOrderByExprNode* pSortKey = (SOrderByExprNode*) pNode->pExpr; - SBlockOrderInfo bi = {0}; - bi.order = (pSortKey->order == ORDER_ASC)? TSDB_ORDER_ASC:TSDB_ORDER_DESC; + for (int32_t i = 0; i < numOfCols; ++i) { + STargetNode* pNode = (STargetNode*)nodesListGetNode(pNodeList, i); + SOrderByExprNode* pSortKey = (SOrderByExprNode*)pNode->pExpr; + SBlockOrderInfo bi = {0}; + bi.order = (pSortKey->order == ORDER_ASC) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC; bi.nullFirst = (pSortKey->nullOrder == NULL_ORDER_FIRST); SColumnNode* pColNode = (SColumnNode*)pSortKey->pExpr; bi.slotId = pColNode->slotId; -// pColNode->order; -// SColumn c = {0}; -// c.slotId = pColNode->slotId; -// c.colId = pColNode->colId; -// c.type = pColNode->node.resType.type; -// c.bytes = pColNode->node.resType.bytes; -// c.precision = pColNode->node.resType.precision; -// c.scale = pColNode->node.resType.scale; + // pColNode->order; + // SColumn c = {0}; + // c.slotId = pColNode->slotId; + // c.colId = pColNode->colId; + // c.type = pColNode->node.resType.type; + // c.bytes = pColNode->node.resType.bytes; + // c.precision = pColNode->node.resType.precision; + // c.scale = pColNode->node.resType.scale; taosArrayPush(pList, &bi); } @@ -8826,41 +9019,42 @@ SArray* createSortInfo(SNodeList* pNodeList) { } SArray* extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols) { - size_t numOfCols = LIST_LENGTH(pNodeList); + size_t numOfCols = LIST_LENGTH(pNodeList); SArray* pList = taosArrayInit(numOfCols, sizeof(SColMatchInfo)); if (pList == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - for(int32_t i = 0; i < numOfCols; ++i) { - STargetNode* pNode = (STargetNode*) nodesListGetNode(pNodeList, i); - SColumnNode* pColNode = (SColumnNode*) pNode->pExpr; + for (int32_t i = 0; i < numOfCols; ++i) { + STargetNode* pNode = (STargetNode*)nodesListGetNode(pNodeList, i); + SColumnNode* pColNode = (SColumnNode*)pNode->pExpr; SColMatchInfo c = {0}; - c.colId = pColNode->colId; + c.colId = pColNode->colId; c.targetSlotId = pNode->slotId; - c.output = true; + c.output = true; taosArrayPush(pList, &c); } *numOfOutputCols = 0; int32_t num = LIST_LENGTH(pOutputNodeList->pSlots); - for(int32_t i = 0; i < num; ++i) { - SSlotDescNode* pNode = (SSlotDescNode*) nodesListGetNode(pOutputNodeList->pSlots, i); + for (int32_t i = 0; i < num; ++i) { + SSlotDescNode* pNode = (SSlotDescNode*)nodesListGetNode(pOutputNodeList->pSlots, i); SColMatchInfo* info = taosArrayGet(pList, pNode->slotId); -// if (pNode->output) { - (*numOfOutputCols) += 1; -// } else { -// info->output = false; -// } + // if (pNode->output) { + (*numOfOutputCols) += 1; + // } else { + // info->output = false; + // } } return pList; } -int32_t doCreateTableGroup(void* metaHandle, int32_t tableType, uint64_t tableUid, STableGroupInfo* pGroupInfo, uint64_t queryId, uint64_t taskId) { +int32_t doCreateTableGroup(void* metaHandle, int32_t tableType, uint64_t tableUid, STableGroupInfo* pGroupInfo, + uint64_t queryId, uint64_t taskId) { int32_t code = 0; if (tableType == TSDB_SUPER_TABLE) { code = tsdbQuerySTableByTagCond(metaHandle, tableUid, 0, NULL, 0, 0, NULL, pGroupInfo, NULL, 0, queryId, taskId); @@ -8889,22 +9083,24 @@ SArray* extractTableIdList(const STableGroupInfo* pTableGroupInfo) { return tableIdList; } -tsdbReaderT doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle, STableGroupInfo *pTableGroupInfo, uint64_t queryId, uint64_t taskId) { +tsdbReaderT doCreateDataReader(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle, + STableGroupInfo* pTableGroupInfo, uint64_t queryId, uint64_t taskId) { uint64_t uid = pTableScanNode->scan.uid; - int32_t code = doCreateTableGroup(pHandle->meta, pTableScanNode->scan.tableType, uid, pTableGroupInfo, queryId, taskId); + int32_t code = + doCreateTableGroup(pHandle->meta, pTableScanNode->scan.tableType, uid, pTableGroupInfo, queryId, taskId); if (code != TSDB_CODE_SUCCESS) { goto _error; } if (pTableGroupInfo->numOfTables == 0) { code = 0; - qDebug("no table qualified for query, TID:0x%"PRIx64", QID:0x%"PRIx64, taskId, queryId); + qDebug("no table qualified for query, TID:0x%" PRIx64 ", QID:0x%" PRIx64, taskId, queryId); goto _error; } return createDataReaderImpl(pTableScanNode, pTableGroupInfo, pHandle->reader, queryId, taskId); - _error: +_error: terrno = code; return NULL; } @@ -8922,7 +9118,7 @@ int32_t createExecTaskInfoImpl(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SRead STableGroupInfo group = {0}; (*pTaskInfo)->pRoot = doCreateOperatorTreeNode(pPlan->pNode, *pTaskInfo, pHandle, queryId, taskId, &group); if (NULL == (*pTaskInfo)->pRoot) { - code = terrno; + code = terrno; goto _complete; } @@ -8940,7 +9136,7 @@ _complete: return code; } -int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int32_t filterNum) { +int32_t cloneExprFilterInfo(SColumnFilterInfo** dst, SColumnFilterInfo* src, int32_t filterNum) { if (filterNum <= 0) { return TSDB_CODE_SUCCESS; } @@ -8954,7 +9150,7 @@ int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int for (int32_t i = 0; i < filterNum; i++) { if ((*dst)[i].filterstr && dst[i]->len > 0) { - void *pz = taosMemoryCalloc(1, (size_t)(*dst)[i].len + 1); + void* pz = taosMemoryCalloc(1, (size_t)(*dst)[i].len + 1); if (pz == NULL) { if (i == 0) { @@ -8966,7 +9162,7 @@ int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int return TSDB_CODE_QRY_OUT_OF_MEMORY; } - memcpy(pz, (void *)src->pz, (size_t)src->len + 1); + memcpy(pz, (void*)src->pz, (size_t)src->len + 1); (*dst)[i].pz = (int64_t)pz; } @@ -8975,7 +9171,8 @@ int32_t cloneExprFilterInfo(SColumnFilterInfo **dst, SColumnFilterInfo* src, int return TSDB_CODE_SUCCESS; } -static int32_t updateOutputBufForTopBotQuery(SQueriedTableInfo* pTableInfo, SColumnInfo* pTagCols, SExprInfo* pExprs, int32_t numOfOutput, int32_t tagLen, bool superTable) { +static int32_t updateOutputBufForTopBotQuery(SQueriedTableInfo* pTableInfo, SColumnInfo* pTagCols, SExprInfo* pExprs, + int32_t numOfOutput, int32_t tagLen, bool superTable) { for (int32_t i = 0; i < numOfOutput; ++i) { int16_t functId = getExprFunctionId(&pExprs[i]); @@ -8985,9 +9182,10 @@ static int32_t updateOutputBufForTopBotQuery(SQueriedTableInfo* pTableInfo, SCol return TSDB_CODE_QRY_INVALID_MSG; } else { SColumnInfo* pCol = &pTableInfo->colList[j]; -// int32_t ret = getResultDataInfo(pCol->type, pCol->bytes, functId, (int32_t)pExprs[i].base.param[0].i, -// &pExprs[i].base.resSchema.type, &pExprs[i].base.resSchema.bytes, &pExprs[i].base.interBytes, tagLen, superTable, NULL); -// assert(ret == TSDB_CODE_SUCCESS); + // int32_t ret = getResultDataInfo(pCol->type, pCol->bytes, functId, (int32_t)pExprs[i].base.param[0].i, + // &pExprs[i].base.resSchema.type, &pExprs[i].base.resSchema.bytes, + // &pExprs[i].base.interBytes, tagLen, superTable, NULL); + // assert(ret == TSDB_CODE_SUCCESS); } } } @@ -8996,67 +9194,69 @@ static int32_t updateOutputBufForTopBotQuery(SQueriedTableInfo* pTableInfo, SCol } // TODO tag length should be passed from client, refactor -int32_t createQueryFilter(char *data, uint16_t len, SFilterInfo** pFilters) { +int32_t createQueryFilter(char* data, uint16_t len, SFilterInfo** pFilters) { tExprNode* expr = NULL; - - TRY(TSDB_MAX_TAG_CONDITIONS) { - expr = exprTreeFromBinary(data, len); - } CATCH( code ) { + + TRY(TSDB_MAX_TAG_CONDITIONS) { expr = exprTreeFromBinary(data, len); } + CATCH(code) { CLEANUP_EXECUTE(); return code; - } END_TRY + } + END_TRY if (expr == NULL) { - //qError("failed to create expr tree"); + // qError("failed to create expr tree"); return TSDB_CODE_QRY_APP_ERROR; } -// int32_t ret = filterInitFromTree(expr, pFilters, 0); -// tExprTreeDestroy(expr, NULL); + // int32_t ret = filterInitFromTree(expr, pFilters, 0); + // tExprTreeDestroy(expr, NULL); -// return ret; + // return ret; } -//int32_t doCreateFilterInfo(SColumnInfo* pCols, int32_t numOfCols, int32_t numOfFilterCols, SSingleColumnFilterInfo** pFilterInfo, uint64_t qId) { -// *pFilterInfo = taosMemoryCalloc(1, sizeof(SSingleColumnFilterInfo) * numOfFilterCols); -// if (*pFilterInfo == NULL) { -// return TSDB_CODE_QRY_OUT_OF_MEMORY; -// } +// int32_t doCreateFilterInfo(SColumnInfo* pCols, int32_t numOfCols, int32_t numOfFilterCols, SSingleColumnFilterInfo** +// pFilterInfo, uint64_t qId) { +// *pFilterInfo = taosMemoryCalloc(1, sizeof(SSingleColumnFilterInfo) * numOfFilterCols); +// if (*pFilterInfo == NULL) { +// return TSDB_CODE_QRY_OUT_OF_MEMORY; +// } // -// for (int32_t i = 0, j = 0; i < numOfCols; ++i) { -// if (pCols[i].flist.numOfFilters > 0) { -// SSingleColumnFilterInfo* pFilter = &((*pFilterInfo)[j]); +// for (int32_t i = 0, j = 0; i < numOfCols; ++i) { +// if (pCols[i].flist.numOfFilters > 0) { +// SSingleColumnFilterInfo* pFilter = &((*pFilterInfo)[j]); // -// memcpy(&pFilter->info, &pCols[i], sizeof(SColumnInfo)); -// pFilter->info = pCols[i]; +// memcpy(&pFilter->info, &pCols[i], sizeof(SColumnInfo)); +// pFilter->info = pCols[i]; // -// pFilter->numOfFilters = pCols[i].flist.numOfFilters; -// pFilter->pFilters = taosMemoryCalloc(pFilter->numOfFilters, sizeof(SColumnFilterElem)); -// if (pFilter->pFilters == NULL) { -// return TSDB_CODE_QRY_OUT_OF_MEMORY; -// } +// pFilter->numOfFilters = pCols[i].flist.numOfFilters; +// pFilter->pFilters = taosMemoryCalloc(pFilter->numOfFilters, sizeof(SColumnFilterElem)); +// if (pFilter->pFilters == NULL) { +// return TSDB_CODE_QRY_OUT_OF_MEMORY; +// } // -// for (int32_t f = 0; f < pFilter->numOfFilters; ++f) { -// SColumnFilterElem* pSingleColFilter = &pFilter->pFilters[f]; -// pSingleColFilter->filterInfo = pCols[i].flist.filterInfo[f]; +// for (int32_t f = 0; f < pFilter->numOfFilters; ++f) { +// SColumnFilterElem* pSingleColFilter = &pFilter->pFilters[f]; +// pSingleColFilter->filterInfo = pCols[i].flist.filterInfo[f]; // -// int32_t lower = pSingleColFilter->filterInfo.lowerRelOptr; -// int32_t upper = pSingleColFilter->filterInfo.upperRelOptr; -// if (lower == TSDB_RELATION_INVALID && upper == TSDB_RELATION_INVALID) { -// //qError("QInfo:0x%"PRIx64" invalid filter info", qId); -// return TSDB_CODE_QRY_INVALID_MSG; -// } +// int32_t lower = pSingleColFilter->filterInfo.lowerRelOptr; +// int32_t upper = pSingleColFilter->filterInfo.upperRelOptr; +// if (lower == TSDB_RELATION_INVALID && upper == TSDB_RELATION_INVALID) { +// //qError("QInfo:0x%"PRIx64" invalid filter info", qId); +// return TSDB_CODE_QRY_INVALID_MSG; +// } // -// pSingleColFilter->fp = getFilterOperator(lower, upper); -// if (pSingleColFilter->fp == NULL) { -// //qError("QInfo:0x%"PRIx64" invalid filter info", qId); -// return TSDB_CODE_QRY_INVALID_MSG; -// } +// pSingleColFilter->fp = getFilterOperator(lower, upper); +// if (pSingleColFilter->fp == NULL) { +// //qError("QInfo:0x%"PRIx64" invalid filter info", qId); +// return TSDB_CODE_QRY_INVALID_MSG; +// } // -// pSingleColFilter->bytes = pCols[i].bytes; +// pSingleColFilter->bytes = pCols[i].bytes; // -// if (lower == TSDB_RELATION_IN) { -//// buildFilterSetFromBinary(&pSingleColFilter->q, (char *)(pSingleColFilter->filterInfo.pz), (int32_t)(pSingleColFilter->filterInfo.len)); +// if (lower == TSDB_RELATION_IN) { +//// buildFilterSetFromBinary(&pSingleColFilter->q, (char *)(pSingleColFilter->filterInfo.pz), +///(int32_t)(pSingleColFilter->filterInfo.len)); // } // } // @@ -9068,49 +9268,49 @@ int32_t createQueryFilter(char *data, uint16_t len, SFilterInfo** pFilters) { //} void* doDestroyFilterInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols) { -// for (int32_t i = 0; i < numOfFilterCols; ++i) { -// if (pFilterInfo[i].numOfFilters > 0) { -// if (pFilterInfo[i].pFilters->filterInfo.lowerRelOptr == TSDB_RELATION_IN) { -// taosHashCleanup((SHashObj *)(pFilterInfo[i].pFilters->q)); -// } -// taosMemoryFreeClear(pFilterInfo[i].pFilters); -// } -// } -// -// taosMemoryFreeClear(pFilterInfo); + // for (int32_t i = 0; i < numOfFilterCols; ++i) { + // if (pFilterInfo[i].numOfFilters > 0) { + // if (pFilterInfo[i].pFilters->filterInfo.lowerRelOptr == TSDB_RELATION_IN) { + // taosHashCleanup((SHashObj *)(pFilterInfo[i].pFilters->q)); + // } + // taosMemoryFreeClear(pFilterInfo[i].pFilters); + // } + // } + // + // taosMemoryFreeClear(pFilterInfo); return NULL; } int32_t createFilterInfo(STaskAttr* pQueryAttr, uint64_t qId) { for (int32_t i = 0; i < pQueryAttr->numOfCols; ++i) { -// if (pQueryAttr->tableCols[i].flist.numOfFilters > 0 && pQueryAttr->tableCols[i].flist.filterInfo != NULL) { -// pQueryAttr->numOfFilterCols++; -// } + // if (pQueryAttr->tableCols[i].flist.numOfFilters > 0 && pQueryAttr->tableCols[i].flist.filterInfo != NULL) { + // pQueryAttr->numOfFilterCols++; + // } } if (pQueryAttr->numOfFilterCols == 0) { return TSDB_CODE_SUCCESS; } -// doCreateFilterInfo(pQueryAttr->tableCols, pQueryAttr->numOfCols, pQueryAttr->numOfFilterCols, -// &pQueryAttr->pFilterInfo, qId); + // doCreateFilterInfo(pQueryAttr->tableCols, pQueryAttr->numOfCols, pQueryAttr->numOfFilterCols, + // &pQueryAttr->pFilterInfo, qId); pQueryAttr->createFilterOperator = true; return TSDB_CODE_SUCCESS; } -static void doUpdateExprColumnIndex(STaskAttr *pQueryAttr) { +static void doUpdateExprColumnIndex(STaskAttr* pQueryAttr) { assert(pQueryAttr->pExpr1 != NULL && pQueryAttr != NULL); for (int32_t k = 0; k < pQueryAttr->numOfOutput; ++k) { - SExprBasicInfo *pSqlExprMsg = &pQueryAttr->pExpr1[k].base; -// if (pSqlExprMsg->functionId == FUNCTION_ARITHM) { -// continue; -// } + SExprBasicInfo* pSqlExprMsg = &pQueryAttr->pExpr1[k].base; + // if (pSqlExprMsg->functionId == FUNCTION_ARITHM) { + // continue; + // } // todo opt performance - SColIndex *pColIndex = NULL;/*&pSqlExprMsg->colInfo;*/ + SColIndex* pColIndex = NULL; /*&pSqlExprMsg->colInfo;*/ if (TSDB_COL_IS_NORMAL_COL(pColIndex->flag)) { int32_t f = 0; for (f = 0; f < pQueryAttr->numOfCols; ++f) { @@ -9152,7 +9352,7 @@ void setResultBufSize(STaskAttr* pQueryAttr, SResultInfo* pResultInfo) { numOfRes = MIN_ROWS_FOR_PRJ_QUERY; } - pResultInfo->capacity = numOfRes; + pResultInfo->capacity = numOfRes; } else { // in case of non-prj query, a smaller output buffer will be used. pResultInfo->capacity = DEFAULT_MIN_ROWS; } @@ -9161,29 +9361,29 @@ void setResultBufSize(STaskAttr* pQueryAttr, SResultInfo* pResultInfo) { pResultInfo->totalRows = 0; } -//TODO refactor +// TODO refactor void freeColumnFilterInfo(SColumnFilterInfo* pFilter, int32_t numOfFilters) { - if (pFilter == NULL || numOfFilters == 0) { - return; - } + if (pFilter == NULL || numOfFilters == 0) { + return; + } - for (int32_t i = 0; i < numOfFilters; i++) { - if (pFilter[i].filterstr && pFilter[i].pz) { - taosMemoryFree((void*)(pFilter[i].pz)); - } + for (int32_t i = 0; i < numOfFilters; i++) { + if (pFilter[i].filterstr && pFilter[i].pz) { + taosMemoryFree((void*)(pFilter[i].pz)); } + } - taosMemoryFree(pFilter); + taosMemoryFree(pFilter); } static void doDestroyTableQueryInfo(STableGroupInfo* pTableqinfoGroupInfo) { if (pTableqinfoGroupInfo->pGroupList != NULL) { - int32_t numOfGroups = (int32_t) taosArrayGetSize(pTableqinfoGroupInfo->pGroupList); + int32_t numOfGroups = (int32_t)taosArrayGetSize(pTableqinfoGroupInfo->pGroupList); for (int32_t i = 0; i < numOfGroups; ++i) { - SArray *p = taosArrayGetP(pTableqinfoGroupInfo->pGroupList, i); + SArray* p = taosArrayGetP(pTableqinfoGroupInfo->pGroupList, i); size_t num = taosArrayGetSize(p); - for(int32_t j = 0; j < num; ++j) { + for (int32_t j = 0; j < num; ++j) { STableQueryInfo* item = taosArrayGetP(p, j); destroyTableQueryInfoImpl(item); } @@ -9200,12 +9400,12 @@ static void doDestroyTableQueryInfo(STableGroupInfo* pTableqinfoGroupInfo) { pTableqinfoGroupInfo->numOfTables = 0; } -void doDestroyTask(SExecTaskInfo *pTaskInfo) { +void doDestroyTask(SExecTaskInfo* pTaskInfo) { qDebug("%s execTask is freed", GET_TASKID(pTaskInfo)); doDestroyTableQueryInfo(&pTaskInfo->tableqinfoGroupInfo); -// taosArrayDestroy(pTaskInfo->summary.queryProfEvents); -// taosHashCleanup(pTaskInfo->summary.operatorProfResults); + // taosArrayDestroy(pTaskInfo->summary.queryProfEvents); + // taosHashCleanup(pTaskInfo->summary.operatorProfResults); taosMemoryFreeClear(pTaskInfo->sql); taosMemoryFreeClear(pTaskInfo->id.str); @@ -9222,7 +9422,7 @@ static void doSetTagValueToResultBuf(char* output, const char* val, int16_t type // Binary data overflows for sort of unknown reasons. Let trim the overflow data if (varDataTLen(val) > bytes) { int32_t maxLen = bytes - VARSTR_HEADER_SIZE; - int32_t len = (varDataLen(val) > maxLen)? maxLen:varDataLen(val); + int32_t len = (varDataLen(val) > maxLen) ? maxLen : varDataLen(val); memcpy(varDataVal(output), varDataVal(val), len); varDataSetLen(output, len); } else { @@ -9235,8 +9435,8 @@ static void doSetTagValueToResultBuf(char* output, const char* val, int16_t type static int64_t getQuerySupportBufSize(size_t numOfTables) { size_t s1 = sizeof(STableQueryInfo); -// size_t s3 = sizeof(STableCheckInfo); buffer consumption in tsdb - return (int64_t)(s1* 1.5 * numOfTables); + // size_t s3 = sizeof(STableCheckInfo); buffer consumption in tsdb + return (int64_t)(s1 * 1.5 * numOfTables); } int32_t checkForQueryBuf(size_t numOfTables) { @@ -9244,8 +9444,7 @@ int32_t checkForQueryBuf(size_t numOfTables) { if (tsQueryBufferSizeBytes < 0) { return TSDB_CODE_SUCCESS; } else if (tsQueryBufferSizeBytes > 0) { - - while(1) { + while (1) { int64_t s = tsQueryBufferSizeBytes; int64_t remain = s - t; if (remain >= 0) { diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c index 823cb3315e..0a5a90d2d9 100644 --- a/source/libs/function/src/builtins.c +++ b/source/libs/function/src/builtins.c @@ -173,7 +173,7 @@ const SBuiltinFuncDefinition funcMgtBuiltins[] = { .finalizeFunc = NULL }, { - .name = "power", + .name = "pow", .type = FUNCTION_TYPE_POW, .classification = FUNC_MGT_SCALAR_FUNC, .checkFunc = stubCheckAndGetResultType, @@ -409,13 +409,29 @@ int32_t stubCheckAndGetResultType(SFunctionNode* pFunc) { // todo break; - case FUNCTION_TYPE_ABS: { + case FUNCTION_TYPE_ABS: + case FUNCTION_TYPE_CEIL: + case FUNCTION_TYPE_FLOOR: + case FUNCTION_TYPE_ROUND: { SColumnNode* pParam = nodesListGetNode(pFunc->pParameterList, 0); int32_t paraType = pParam->node.resType.type; pFunc->node.resType = (SDataType) { .bytes = tDataTypes[paraType].bytes, .type = paraType }; break; } + case FUNCTION_TYPE_SIN: + case FUNCTION_TYPE_COS: + case FUNCTION_TYPE_TAN: + case FUNCTION_TYPE_ASIN: + case FUNCTION_TYPE_ACOS: + case FUNCTION_TYPE_ATAN: + case FUNCTION_TYPE_SQRT: + case FUNCTION_TYPE_LOG: + case FUNCTION_TYPE_POW: { + pFunc->node.resType = (SDataType) { .bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes, .type = TSDB_DATA_TYPE_DOUBLE }; + break; + } + default: ASSERT(0); // to found the fault ASAP. } diff --git a/source/libs/index/inc/index_cache.h b/source/libs/index/inc/indexCache.h similarity index 96% rename from source/libs/index/inc/index_cache.h rename to source/libs/index/inc/indexCache.h index 086e75d99f..3ea986ad48 100644 --- a/source/libs/index/inc/index_cache.h +++ b/source/libs/index/inc/indexCache.h @@ -1,6 +1,5 @@ /* - * Copyright (c) 2019 TAOS Data, Inc. - * + * Copyright (c) 2019 TAOS Data, Inc. * * This program is free software: you can use, redistribute, and/or modify * it under the terms of the GNU Affero General Public License, version 3 * or later ("AGPL"), as published by the Free Software Foundation. @@ -16,7 +15,7 @@ #define __INDEX_CACHE_H__ #include "indexInt.h" -#include "index_util.h" +#include "indexUtil.h" #include "tskiplist.h" // ----------------- key structure in skiplist --------------------- diff --git a/source/libs/index/inc/index_comm.h b/source/libs/index/inc/indexComm.h similarity index 100% rename from source/libs/index/inc/index_comm.h rename to source/libs/index/inc/indexComm.h diff --git a/source/libs/index/inc/index_fst.h b/source/libs/index/inc/indexFst.h similarity index 98% rename from source/libs/index/inc/index_fst.h rename to source/libs/index/inc/indexFst.h index b131aa0d9d..39ad5ffa8c 100644 --- a/source/libs/index/inc/index_fst.h +++ b/source/libs/index/inc/indexFst.h @@ -20,12 +20,12 @@ extern "C" { #endif +#include "indexFstAutomation.h" +#include "indexFstCountingWriter.h" +#include "indexFstNode.h" +#include "indexFstRegistry.h" +#include "indexFstUtil.h" #include "indexInt.h" -#include "index_fst_automation.h" -#include "index_fst_counting_writer.h" -#include "index_fst_node.h" -#include "index_fst_registry.h" -#include "index_fst_util.h" #define OUTPUT_PREFIX(a, b) ((a) > (b) ? (b) : (a) diff --git a/source/libs/index/inc/index_fst_automation.h b/source/libs/index/inc/indexFstAutomation.h similarity index 98% rename from source/libs/index/inc/index_fst_automation.h rename to source/libs/index/inc/indexFstAutomation.h index 786d3eb7d2..3a0f74ee76 100644 --- a/source/libs/index/inc/index_fst_automation.h +++ b/source/libs/index/inc/indexFstAutomation.h @@ -19,8 +19,8 @@ extern "C" { #endif +#include "indexFstUtil.h" #include "indexInt.h" -#include "index_fst_util.h" typedef struct AutomationCtx AutomationCtx; diff --git a/source/libs/index/inc/index_fst_common.h b/source/libs/index/inc/indexFstCommon.h similarity index 100% rename from source/libs/index/inc/index_fst_common.h rename to source/libs/index/inc/indexFstCommon.h diff --git a/source/libs/index/inc/index_fst_counting_writer.h b/source/libs/index/inc/indexFstCountingWriter.h similarity index 100% rename from source/libs/index/inc/index_fst_counting_writer.h rename to source/libs/index/inc/indexFstCountingWriter.h diff --git a/source/libs/index/inc/index_fst_node.h b/source/libs/index/inc/indexFstNode.h similarity index 96% rename from source/libs/index/inc/index_fst_node.h rename to source/libs/index/inc/indexFstNode.h index 4dbf4cea04..4bbc739c73 100644 --- a/source/libs/index/inc/index_fst_node.h +++ b/source/libs/index/inc/indexFstNode.h @@ -20,9 +20,9 @@ extern "C" { #endif +#include "indexFstCountingWriter.h" +#include "indexFstUtil.h" #include "indexInt.h" -#include "index_fst_counting_writer.h" -#include "index_fst_util.h" #define FST_BUILDER_NODE_IS_FINAL(bn) (bn->isFinal) #define FST_BUILDER_NODE_TRANS_ISEMPTY(bn) (taosArrayGetSize(bn->trans) == 0) diff --git a/source/libs/index/inc/index_fst_registry.h b/source/libs/index/inc/indexFstRegistry.h similarity index 97% rename from source/libs/index/inc/index_fst_registry.h rename to source/libs/index/inc/indexFstRegistry.h index 20b70e2866..09cde6c131 100644 --- a/source/libs/index/inc/index_fst_registry.h +++ b/source/libs/index/inc/indexFstRegistry.h @@ -19,9 +19,9 @@ extern "C" { #endif +#include "indexFstNode.h" +#include "indexFstUtil.h" #include "indexInt.h" -#include "index_fst_node.h" -#include "index_fst_util.h" typedef struct FstRegistryCell { CompiledAddr addr; diff --git a/source/libs/index/inc/index_fst_util.h b/source/libs/index/inc/indexFstUtil.h similarity index 99% rename from source/libs/index/inc/index_fst_util.h rename to source/libs/index/inc/indexFstUtil.h index f173dd9a15..d0bbc923d1 100644 --- a/source/libs/index/inc/index_fst_util.h +++ b/source/libs/index/inc/indexFstUtil.h @@ -20,8 +20,8 @@ extern "C" { #endif +#include "indexFstCommon.h" #include "indexInt.h" -#include "index_fst_common.h" typedef uint64_t FstType; typedef uint64_t CompiledAddr; diff --git a/source/libs/scalar/inc/sclfunc.h b/source/libs/index/inc/indexSparse.h similarity index 56% rename from source/libs/scalar/inc/sclfunc.h rename to source/libs/index/inc/indexSparse.h index 679411e004..8035f6e08d 100644 --- a/source/libs/scalar/inc/sclfunc.h +++ b/source/libs/index/inc/indexSparse.h @@ -12,21 +12,32 @@ * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ -#ifndef TDENGINE_TSCALARFUNCTION_H -#define TDENGINE_TSCALARFUNCTION_H + +#ifndef _TD_INDEX_SPARSE_H_ +#define _TD_INDEX_SPARSE_H_ + +#include "tarray.h" #ifdef __cplusplus extern "C" { #endif -#include "function.h" -#include "scalar.h" - - +typedef struct FstSparseSet { + SArray *dense; + SArray *sparse; + int32_t size; +} FstSparseSet; +FstSparseSet *sparSetCreate(int32_t sz); +void sparSetDestroy(FstSparseSet *s); +uint32_t sparSetLen(FstSparseSet *ss); +uint32_t sparSetAdd(FstSparseSet *ss, uint32_t ip); +uint32_t sparSetGet(FstSparseSet *ss, uint32_t i); +bool sparSetContains(FstSparseSet *ss, uint32_t ip); +void sparSetClear(FstSparseSet *ss); #ifdef __cplusplus } #endif -#endif // TDENGINE_TSCALARFUNCTION_H +#endif diff --git a/source/libs/index/inc/index_tfile.h b/source/libs/index/inc/indexTfile.h similarity index 97% rename from source/libs/index/inc/index_tfile.h rename to source/libs/index/inc/indexTfile.h index 3794898d3a..9712e4b30f 100644 --- a/source/libs/index/inc/index_tfile.h +++ b/source/libs/index/inc/indexTfile.h @@ -15,11 +15,11 @@ #ifndef __INDEX_TFILE_H__ #define __INDEX_TFILE_H__ +#include "indexFst.h" +#include "indexFstCountingWriter.h" #include "indexInt.h" -#include "index_fst.h" -#include "index_fst_counting_writer.h" -#include "index_tfile.h" -#include "index_util.h" +#include "indexTfile.h" +#include "indexUtil.h" #include "tlockfree.h" #ifdef __cplusplus diff --git a/source/libs/index/inc/index_util.h b/source/libs/index/inc/indexUtil.h similarity index 100% rename from source/libs/index/inc/index_util.h rename to source/libs/index/inc/indexUtil.h diff --git a/source/libs/index/src/index.c b/source/libs/index/src/index.c index 61dd952381..d3ca3a1acf 100644 --- a/source/libs/index/src/index.c +++ b/source/libs/index/src/index.c @@ -14,11 +14,11 @@ */ #include "index.h" +#include "indexCache.h" +#include "indexComm.h" #include "indexInt.h" -#include "index_cache.h" -#include "index_comm.h" -#include "index_tfile.h" -#include "index_util.h" +#include "indexTfile.h" +#include "indexUtil.h" #include "tdef.h" #include "tsched.h" @@ -236,11 +236,11 @@ int indexDelete(SIndex* index, SIndexMultiTermQuery* query) { return 1; } -int indexRebuild(SIndex* index, SIndexOpts* opts){ +int indexRebuild(SIndex* index, SIndexOpts* opts) { #ifdef USE_INVERTED_INDEX #endif - return 0; + return 0; } SIndexOpts* indexOptsCreate() { diff --git a/source/libs/index/src/index_cache.c b/source/libs/index/src/indexCache.c similarity index 99% rename from source/libs/index/src/index_cache.c rename to source/libs/index/src/indexCache.c index bf907726bc..ca26cf38e5 100644 --- a/source/libs/index/src/index_cache.c +++ b/source/libs/index/src/indexCache.c @@ -13,9 +13,9 @@ * along with this program. If not, see . */ -#include "index_cache.h" -#include "index_comm.h" -#include "index_util.h" +#include "indexCache.h" +#include "indexComm.h" +#include "indexUtil.h" #include "tcompare.h" #include "tsched.h" diff --git a/source/libs/index/src/index_comm.c b/source/libs/index/src/indexComm.c similarity index 100% rename from source/libs/index/src/index_comm.c rename to source/libs/index/src/indexComm.c diff --git a/source/libs/index/src/index_fst.c b/source/libs/index/src/indexFst.c similarity index 99% rename from source/libs/index/src/index_fst.c rename to source/libs/index/src/indexFst.c index eaefaca887..24bc7a93a2 100644 --- a/source/libs/index/src/index_fst.c +++ b/source/libs/index/src/indexFst.c @@ -13,9 +13,9 @@ * along with this program. If not, see . */ -#include "index_fst.h" +#include "indexFst.h" +#include "indexFstAutomation.h" #include "indexInt.h" -#include "index_fst_automation.h" #include "tchecksum.h" #include "tcoding.h" diff --git a/source/libs/index/src/index_fst_automation.c b/source/libs/index/src/indexFstAutomation.c similarity index 99% rename from source/libs/index/src/index_fst_automation.c rename to source/libs/index/src/indexFstAutomation.c index 20e981559d..0702e3b94e 100644 --- a/source/libs/index/src/index_fst_automation.c +++ b/source/libs/index/src/indexFstAutomation.c @@ -13,7 +13,7 @@ * along with this program. If not, see . */ -#include "index_fst_automation.h" +#include "indexFstAutomation.h" StartWithStateValue* startWithStateValueCreate(StartWithStateKind kind, ValueType ty, void* val) { StartWithStateValue* sv = taosMemoryCalloc(1, sizeof(StartWithStateValue)); diff --git a/source/libs/index/src/index_fst_common.c b/source/libs/index/src/indexFstCommon.c similarity index 74% rename from source/libs/index/src/index_fst_common.c rename to source/libs/index/src/indexFstCommon.c index 2d7586e8d9..e2544c7ac3 100644 --- a/source/libs/index/src/index_fst_common.c +++ b/source/libs/index/src/indexFstCommon.c @@ -12,7 +12,7 @@ * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ -#include "index_fst_common.h" +#include "indexFstCommon.h" const uint8_t COMMON_INPUTS[] = { 84, // '\x00' @@ -274,20 +274,23 @@ const uint8_t COMMON_INPUTS[] = { }; const char COMMON_INPUTS_INV[] = { - 't', 'e', '/', 'o', 'a', 's', 'r', 'i', 'p', 'c', 'n', 'w', '.', 'h', 'l', 'm', - '-', 'd', 'u', '0', '1', '2', 'g', '=', ':', 'b', 'f', '3', 'y', '5', '&', '_', - '4', 'v', '9', '6', '7', '8', 'k', '%', '?', 'x', 'C', 'D', 'A', 'S', 'F', 'I', - 'B', 'E', 'j', 'P', 'T', 'z', 'R', 'N', 'M', '+', 'L', 'O', 'q', 'H', 'G', 'W', - 'U', 'V', ',', 'Y', 'K', 'J', 'Z', 'X', 'Q', ';', ')', '(', '~', '[', ']', '$', - '!', '\'', '*', '@', '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', - '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', - '\x1c', '\x1d', '\x1e', '\x1f', ' ', '"', '#', '<', '>', '\\', '^', '`', '{', '|', '}', '\x7f', - '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87', '\x88', '\x89', '\x8a', '\x8b', '\x8c', '\x8d', '\x8e', '\x8f', - '\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97', '\x98', '\x99', '\x9a', '\x9b', '\x9c', '\x9d', '\x9e', '\x9f', - '\xa0', '\xa1', '\xa2', '\xa3', '\xa4', '\xa5', '\xa6', '\xa7', '\xa8', '\xa9', '\xaa', '\xab', '\xac', '\xad', '\xae', '\xaf', - '\xb0', '\xb1', '\xb2', '\xb3', '\xb4', '\xb5', '\xb6', '\xb7', '\xb8', '\xb9', '\xba', '\xbb', '\xbc', '\xbd', '\xbe', '\xbf', - '\xc0', '\xc1', '\xc2', '\xc3', '\xc4', '\xc5', '\xc6', '\xc7', '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce', '\xcf', - '\xd0', '\xd1', '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd7', '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde', '\xdf', - '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7', '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\xed', '\xee', '\xef', - '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf7', '\xf8', '\xf9', '\xfa', '\xfb', '\xfc', '\xfd', '\xfe', '\xff', + 't', 'e', '/', 'o', 'a', 's', 'r', 'i', 'p', 'c', 'n', 'w', '.', 'h', + 'l', 'm', '-', 'd', 'u', '0', '1', '2', 'g', '=', ':', 'b', 'f', '3', + 'y', '5', '&', '_', '4', 'v', '9', '6', '7', '8', 'k', '%', '?', 'x', + 'C', 'D', 'A', 'S', 'F', 'I', 'B', 'E', 'j', 'P', 'T', 'z', 'R', 'N', + 'M', '+', 'L', 'O', 'q', 'H', 'G', 'W', 'U', 'V', ',', 'Y', 'K', 'J', + 'Z', 'X', 'Q', ';', ')', '(', '~', '[', ']', '$', '!', '\'', '*', '@', + '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', + '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', + '\x1c', '\x1d', '\x1e', '\x1f', ' ', '"', '#', '<', '>', '\\', '^', '`', '{', '|', + '}', '\x7f', '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87', '\x88', '\x89', '\x8a', '\x8b', + '\x8c', '\x8d', '\x8e', '\x8f', '\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97', '\x98', '\x99', + '\x9a', '\x9b', '\x9c', '\x9d', '\x9e', '\x9f', '\xa0', '\xa1', '\xa2', '\xa3', '\xa4', '\xa5', '\xa6', '\xa7', + '\xa8', '\xa9', '\xaa', '\xab', '\xac', '\xad', '\xae', '\xaf', '\xb0', '\xb1', '\xb2', '\xb3', '\xb4', '\xb5', + '\xb6', '\xb7', '\xb8', '\xb9', '\xba', '\xbb', '\xbc', '\xbd', '\xbe', '\xbf', '\xc0', '\xc1', '\xc2', '\xc3', + '\xc4', '\xc5', '\xc6', '\xc7', '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce', '\xcf', '\xd0', '\xd1', + '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd7', '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde', '\xdf', + '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7', '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\xed', + '\xee', '\xef', '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf7', '\xf8', '\xf9', '\xfa', '\xfb', + '\xfc', '\xfd', '\xfe', '\xff', }; diff --git a/source/libs/index/src/index_fst_counting_writer.c b/source/libs/index/src/indexFstCountingWriter.c similarity index 94% rename from source/libs/index/src/index_fst_counting_writer.c rename to source/libs/index/src/indexFstCountingWriter.c index 6a161ba7e9..76ff4309b5 100644 --- a/source/libs/index/src/index_fst_counting_writer.c +++ b/source/libs/index/src/indexFstCountingWriter.c @@ -13,10 +13,10 @@ * along with this program. If not, see . */ -#include "os.h" -#include "index_fst_counting_writer.h" +#include "indexFstCountingWriter.h" +#include "indexFstUtil.h" #include "indexInt.h" -#include "index_fst_util.h" +#include "os.h" #include "tutil.h" static int writeCtxDoWrite(WriterCtx* ctx, uint8_t* buf, int len) { @@ -82,7 +82,9 @@ static int writeCtxDoFlush(WriterCtx* ctx) { WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int32_t capacity) { WriterCtx* ctx = taosMemoryCalloc(1, sizeof(WriterCtx)); - if (ctx == NULL) { return NULL; } + if (ctx == NULL) { + return NULL; + } ctx->type = type; if (ctx->type == TFile) { @@ -126,7 +128,9 @@ WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int return ctx; END: - if (ctx->type == TMemory) { taosMemoryFree(ctx->mem.buf); } + if (ctx->type == TMemory) { + taosMemoryFree(ctx->mem.buf); + } taosMemoryFree(ctx); return NULL; } @@ -148,14 +152,18 @@ void writerCtxDestroy(WriterCtx* ctx, bool remove) { // stat(ctx->file.buf, &fstat); // indexError("write file size: %d", (int)(fstat.st_size)); } - if (remove) { unlink(ctx->file.buf); } + if (remove) { + unlink(ctx->file.buf); + } } taosMemoryFree(ctx); } FstCountingWriter* fstCountingWriterCreate(void* wrt) { FstCountingWriter* cw = taosMemoryCalloc(1, sizeof(FstCountingWriter)); - if (cw == NULL) { return NULL; } + if (cw == NULL) { + return NULL; + } cw->wrt = wrt; //(void *)(writerCtxCreate(TFile, readOnly)); @@ -169,7 +177,9 @@ void fstCountingWriterDestroy(FstCountingWriter* cw) { } int fstCountingWriterWrite(FstCountingWriter* write, uint8_t* buf, uint32_t len) { - if (write == NULL) { return 0; } + if (write == NULL) { + return 0; + } // update checksum // write data to file/socket or mem WriterCtx* ctx = write->wrt; @@ -182,7 +192,9 @@ int fstCountingWriterWrite(FstCountingWriter* write, uint8_t* buf, uint32_t len) return len; } int fstCountingWriterRead(FstCountingWriter* write, uint8_t* buf, uint32_t len) { - if (write == NULL) { return 0; } + if (write == NULL) { + return 0; + } WriterCtx* ctx = write->wrt; int nRead = ctx->read(ctx, buf, len); // assert(nRead == len); diff --git a/source/libs/index/src/index_fst_node.c b/source/libs/index/src/indexFstNode.c similarity index 89% rename from source/libs/index/src/index_fst_node.c rename to source/libs/index/src/indexFstNode.c index a0d59150d7..e11f9dd37d 100644 --- a/source/libs/index/src/index_fst_node.c +++ b/source/libs/index/src/indexFstNode.c @@ -12,7 +12,7 @@ * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ -#include "index_fst_node.h" +#include "indexFstNode.h" FstBuilderNode* fstBuilderNodeDefault() { FstBuilderNode* bn = taosMemoryMalloc(sizeof(FstBuilderNode)); @@ -22,31 +22,45 @@ FstBuilderNode* fstBuilderNodeDefault() { return bn; } void fstBuilderNodeDestroy(FstBuilderNode* node) { - if (node == NULL) { return; } + if (node == NULL) { + return; + } taosArrayDestroy(node->trans); taosMemoryFree(node); } bool fstBuilderNodeEqual(FstBuilderNode* n1, FstBuilderNode* n2) { - if (n1 == n2) { return true; } - if (n1 == NULL || n2 == NULL) { return false; } + if (n1 == n2) { + return true; + } + if (n1 == NULL || n2 == NULL) { + return false; + } - if (n1->isFinal != n2->isFinal || n1->finalOutput != n2->finalOutput) { return false; } + if (n1->isFinal != n2->isFinal || n1->finalOutput != n2->finalOutput) { + return false; + } size_t s1 = n1->trans ? taosArrayGetSize(n1->trans) : 0; size_t s2 = n2->trans ? taosArrayGetSize(n2->trans) : 0; - if (s1 != s2) { return false; } + if (s1 != s2) { + return false; + } for (size_t i = 0; i < s1; i++) { FstTransition* t1 = taosArrayGet(n1->trans, i); FstTransition* t2 = taosArrayGet(n2->trans, i); - if (t1->inp != t2->inp || t1->out != t2->out || t1->addr != t2->addr) { return false; } + if (t1->inp != t2->inp || t1->out != t2->out || t1->addr != t2->addr) { + return false; + } } return true; } FstBuilderNode* fstBuilderNodeClone(FstBuilderNode* src) { FstBuilderNode* node = taosMemoryMalloc(sizeof(FstBuilderNode)); - if (node == NULL) { return NULL; } + if (node == NULL) { + return NULL; + } // size_t sz = taosArrayGetSize(src->trans); @@ -64,7 +78,9 @@ FstBuilderNode* fstBuilderNodeClone(FstBuilderNode* src) { } // not destroy src, User's bussiness void fstBuilderNodeCloneFrom(FstBuilderNode* dst, FstBuilderNode* src) { - if (dst == NULL || src == NULL) { return; } + if (dst == NULL || src == NULL) { + return; + } dst->isFinal = src->isFinal; dst->finalOutput = src->finalOutput; diff --git a/source/libs/index/src/index_fst_registry.c b/source/libs/index/src/indexFstRegister.c similarity index 93% rename from source/libs/index/src/index_fst_registry.c rename to source/libs/index/src/indexFstRegister.c index 7b6b8df25f..34efee0d0d 100644 --- a/source/libs/index/src/index_fst_registry.c +++ b/source/libs/index/src/indexFstRegister.c @@ -13,8 +13,8 @@ * along with this program. If not, see . */ +#include "indexFstRegistry.h" #include "os.h" -#include "index_fst_registry.h" uint64_t fstRegistryHash(FstRegistry* registry, FstBuilderNode* bNode) { // TODO(yihaoDeng): refactor later @@ -35,7 +35,9 @@ uint64_t fstRegistryHash(FstRegistry* registry, FstBuilderNode* bNode) { } static void fstRegistryCellSwap(SArray* arr, uint32_t a, uint32_t b) { size_t sz = taosArrayGetSize(arr); - if (a >= sz || b >= sz) { return; } + if (a >= sz || b >= sz) { + return; + } FstRegistryCell* cell1 = (FstRegistryCell*)taosArrayGet(arr, a); FstRegistryCell* cell2 = (FstRegistryCell*)taosArrayGet(arr, b); @@ -52,7 +54,9 @@ static void fstRegistryCellSwap(SArray* arr, uint32_t a, uint32_t b) { static void fstRegistryCellPromote(SArray* arr, uint32_t start, uint32_t end) { size_t sz = taosArrayGetSize(arr); - if (start >= sz && end >= sz) { return; } + if (start >= sz && end >= sz) { + return; + } assert(start >= end); @@ -66,7 +70,9 @@ static void fstRegistryCellPromote(SArray* arr, uint32_t start, uint32_t end) { FstRegistry* fstRegistryCreate(uint64_t tableSize, uint64_t mruSize) { FstRegistry* registry = taosMemoryMalloc(sizeof(FstRegistry)); - if (registry == NULL) { return NULL; } + if (registry == NULL) { + return NULL; + } uint64_t nCells = tableSize * mruSize; SArray* tb = (SArray*)taosArrayInit(nCells, sizeof(FstRegistryCell)); @@ -87,7 +93,9 @@ FstRegistry* fstRegistryCreate(uint64_t tableSize, uint64_t mruSize) { } void fstRegistryDestroy(FstRegistry* registry) { - if (registry == NULL) { return; } + if (registry == NULL) { + return; + } SArray* tb = registry->table; size_t sz = taosArrayGetSize(tb); @@ -100,7 +108,9 @@ void fstRegistryDestroy(FstRegistry* registry) { } FstRegistryEntry* fstRegistryGetEntry(FstRegistry* registry, FstBuilderNode* bNode) { - if (taosArrayGetSize(registry->table) <= 0) { return NULL; } + if (taosArrayGetSize(registry->table) <= 0) { + return NULL; + } uint64_t bucket = fstRegistryHash(registry, bNode); uint64_t start = registry->mruSize * bucket; uint64_t end = start + registry->mruSize; @@ -165,6 +175,4 @@ FstRegistryEntry* fstRegistryGetEntry(FstRegistry* registry, FstBuilderNode* bNo } return entry; } -void fstRegistryEntryDestroy(FstRegistryEntry* entry) { - taosMemoryFree(entry); -} +void fstRegistryEntryDestroy(FstRegistryEntry* entry) { taosMemoryFree(entry); } diff --git a/source/libs/index/src/index_fst_util.c b/source/libs/index/src/indexFstUtil.c similarity index 98% rename from source/libs/index/src/index_fst_util.c rename to source/libs/index/src/indexFstUtil.c index f9581f7202..ec9a6943dc 100644 --- a/source/libs/index/src/index_fst_util.c +++ b/source/libs/index/src/indexFstUtil.c @@ -12,8 +12,8 @@ * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ -#include "index_fst_util.h" -#include "index_fst_common.h" +#include "indexFstUtil.h" +#include "indexFstCommon.h" // A sentinel value used to indicate an empty final state const CompiledAddr EMPTY_ADDRESS = 0; diff --git a/source/libs/index/src/index_json.c b/source/libs/index/src/indexJson.c similarity index 100% rename from source/libs/index/src/index_json.c rename to source/libs/index/src/indexJson.c diff --git a/source/libs/index/src/indexSparse.c b/source/libs/index/src/indexSparse.c new file mode 100644 index 0000000000..8bcf04602f --- /dev/null +++ b/source/libs/index/src/indexSparse.c @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#include "indexSparse.h" + +FstSparseSet *sparSetCreate(int32_t sz) { + FstSparseSet *ss = taosMemoryCalloc(1, sizeof(FstSparseSet)); + if (ss = NULL) { + return NULL; + } + + ss->dense = taosArrayInit(sz, sizeof(uint32_t)); + ss->sparse = taosArrayInit(sz, sizeof(uint32_t)); + ss->size = sz; + return ss; +} +void sparSetDestroy(FstSparseSet *ss) { + if (ss == NULL) { + return; + } + taosArrayDestroy(ss->dense); + taosArrayDestroy(ss->sparse); + taosMemoryFree(ss); +} +uint32_t sparSetLen(FstSparseSet *ss) { return ss == NULL ? 0 : ss->size; } +uint32_t sparSetAdd(FstSparseSet *ss, uint32_t ip) { + if (ss == NULL) { + return 0; + } + uint32_t i = ss->size; + taosArraySet(ss->dense, i, &ip); + taosArraySet(ss->sparse, ip, &i); + ss->size += 1; + return i; +} +uint32_t sparSetGet(FstSparseSet *ss, uint32_t i) { + if (i >= taosArrayGetSize(ss->dense)) { + return 0; + } + uint32_t *v = taosArrayGet(ss->dense, i); + return *v; +} +bool sparSetContains(FstSparseSet *ss, uint32_t ip) { + if (ip >= taosArrayGetSize(ss->sparse)) { + return false; + } + uint32_t i = *(uint32_t *)taosArrayGet(ss->sparse, ip); + if (i >= taosArrayGetSize(ss->dense)) { + return false; + } + uint32_t v = *(uint32_t *)taosArrayGet(ss->dense, i); + return v == ip; +} +void sparSetClear(FstSparseSet *ss) { + if (ss == NULL) { + return; + } + ss->size = 0; +} diff --git a/source/libs/index/src/index_tfile.c b/source/libs/index/src/indexTfile.c similarity index 99% rename from source/libs/index/src/index_tfile.c rename to source/libs/index/src/indexTfile.c index 53813e13e6..058c33b725 100644 --- a/source/libs/index/src/index_tfile.c +++ b/source/libs/index/src/indexTfile.c @@ -13,12 +13,12 @@ p * * along with this program. If not, see . */ -#include "index_tfile.h" +#include "indexTfile.h" #include "index.h" -#include "index_comm.h" -#include "index_fst.h" -#include "index_fst_counting_writer.h" -#include "index_util.h" +#include "indexComm.h" +#include "indexFst.h" +#include "indexFstCountingWriter.h" +#include "indexUtil.h" #include "taosdef.h" #include "tcoding.h" #include "tcompare.h" diff --git a/source/libs/index/src/index_util.c b/source/libs/index/src/indexUtil.c similarity index 99% rename from source/libs/index/src/index_util.c rename to source/libs/index/src/indexUtil.c index 65c16ca65b..7b83cf465d 100644 --- a/source/libs/index/src/index_util.c +++ b/source/libs/index/src/indexUtil.c @@ -12,7 +12,7 @@ * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ -#include "index_util.h" +#include "indexUtil.h" #include "index.h" #include "tcompare.h" diff --git a/source/libs/index/test/fstTest.cc b/source/libs/index/test/fstTest.cc index e0b12a6f33..eff53108cd 100644 --- a/source/libs/index/test/fstTest.cc +++ b/source/libs/index/test/fstTest.cc @@ -5,12 +5,12 @@ #include #include #include "index.h" +#include "indexCache.h" +#include "indexFst.h" +#include "indexFstCountingWriter.h" +#include "indexFstUtil.h" #include "indexInt.h" -#include "index_cache.h" -#include "index_fst.h" -#include "index_fst_counting_writer.h" -#include "index_fst_util.h" -#include "index_tfile.h" +#include "indexTfile.h" #include "tskiplist.h" #include "tutil.h" void* callback(void* s) { return s; } diff --git a/source/libs/index/test/fstUT.cc b/source/libs/index/test/fstUT.cc index e7efbaf21f..ab6c1a4704 100644 --- a/source/libs/index/test/fstUT.cc +++ b/source/libs/index/test/fstUT.cc @@ -6,12 +6,12 @@ #include #include #include "index.h" +#include "indexCache.h" +#include "indexFst.h" +#include "indexFstCountingWriter.h" +#include "indexFstUtil.h" #include "indexInt.h" -#include "index_cache.h" -#include "index_fst.h" -#include "index_fst_counting_writer.h" -#include "index_fst_util.h" -#include "index_tfile.h" +#include "indexTfile.h" #include "tglobal.h" #include "tlog.h" #include "tskiplist.h" diff --git a/source/libs/index/test/indexTests.cc b/source/libs/index/test/indexTests.cc index 0e4eb060cf..ee9da50ab2 100644 --- a/source/libs/index/test/indexTests.cc +++ b/source/libs/index/test/indexTests.cc @@ -18,13 +18,13 @@ #include #include #include "index.h" +#include "indexCache.h" +#include "indexFst.h" +#include "indexFstCountingWriter.h" +#include "indexFstUtil.h" #include "indexInt.h" -#include "index_cache.h" -#include "index_fst.h" -#include "index_fst_counting_writer.h" -#include "index_fst_util.h" -#include "index_tfile.h" -#include "index_util.h" +#include "indexTfile.h" +#include "indexUtil.h" #include "tskiplist.h" #include "tutil.h" using namespace std; diff --git a/source/libs/index/test/jsonUT.cc b/source/libs/index/test/jsonUT.cc index df9f8b8439..9b0452425a 100644 --- a/source/libs/index/test/jsonUT.cc +++ b/source/libs/index/test/jsonUT.cc @@ -5,13 +5,13 @@ #include #include #include "index.h" +#include "indexCache.h" +#include "indexFst.h" +#include "indexFstCountingWriter.h" +#include "indexFstUtil.h" #include "indexInt.h" -#include "index_cache.h" -#include "index_fst.h" -#include "index_fst_counting_writer.h" -#include "index_fst_util.h" -#include "index_tfile.h" -#include "index_util.h" +#include "indexTfile.h" +#include "indexUtil.h" #include "tglobal.h" #include "tskiplist.h" #include "tutil.h" diff --git a/source/libs/index/test/utilUT.cc b/source/libs/index/test/utilUT.cc index 6ba8cc9525..30f1a089f7 100644 --- a/source/libs/index/test/utilUT.cc +++ b/source/libs/index/test/utilUT.cc @@ -5,13 +5,13 @@ #include #include #include "index.h" +#include "indexCache.h" +#include "indexFst.h" +#include "indexFstCountingWriter.h" +#include "indexFstUtil.h" #include "indexInt.h" -#include "index_cache.h" -#include "index_fst.h" -#include "index_fst_counting_writer.h" -#include "index_fst_util.h" -#include "index_tfile.h" -#include "index_util.h" +#include "indexTfile.h" +#include "indexUtil.h" #include "tglobal.h" #include "tskiplist.h" #include "tutil.h" diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index 951fba0052..7556684e8b 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -349,6 +349,7 @@ literal(A) ::= NK_STRING(B). literal(A) ::= NK_BOOL(B). { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &B)); } literal(A) ::= TIMESTAMP(B) NK_STRING(C). { A = createRawExprNodeExt(pCxt, &B, &C, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &C)); } literal(A) ::= duration_literal(B). { A = B; } +literal(A) ::= NULL(B). { A = createRawExprNode(pCxt, &B, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, NULL)); } duration_literal(A) ::= NK_VARIABLE(B). { A = createRawExprNode(pCxt, &B, createDurationValueNode(pCxt, &B)); } @@ -372,6 +373,7 @@ signed_literal(A) ::= NK_STRING(B). signed_literal(A) ::= NK_BOOL(B). { A = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &B); } signed_literal(A) ::= TIMESTAMP NK_STRING(B). { A = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &B); } signed_literal(A) ::= duration_literal(B). { A = releaseRawExprNode(pCxt, B); } +signed_literal(A) ::= NULL. { A = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, NULL); } %type literal_list { SNodeList* } %destructor literal_list { nodesDestroyList($$); } diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 0a533ecd2c..fcabd4614c 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -577,11 +577,13 @@ SNode* createColumnNode(SAstCreateContext* pCxt, SToken* pTableAlias, SToken* pC SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral) { SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); CHECK_OUT_OF_MEM(val); - val->literal = strndup(pLiteral->z, pLiteral->n); - if (TK_NK_ID != pLiteral->type && (IS_VAR_DATA_TYPE(dataType) || TSDB_DATA_TYPE_TIMESTAMP == dataType)) { - trimString(pLiteral->z, pLiteral->n, val->literal, pLiteral->n); + if (NULL != pLiteral) { + val->literal = strndup(pLiteral->z, pLiteral->n); + if (TK_NK_ID != pLiteral->type && (IS_VAR_DATA_TYPE(dataType) || TSDB_DATA_TYPE_TIMESTAMP == dataType)) { + trimString(pLiteral->z, pLiteral->n, val->literal, pLiteral->n); + } + CHECK_OUT_OF_MEM(val->literal); } - CHECK_OUT_OF_MEM(val->literal); val->node.resType.type = dataType; val->node.resType.bytes = IS_VAR_DATA_TYPE(dataType) ? strlen(val->literal) : tDataTypes[dataType].bytes; if (TSDB_DATA_TYPE_TIMESTAMP == dataType) { diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index fcc47d53fb..ef2c547e44 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -133,16 +133,16 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYNSTATE 432 -#define YYNRULE 346 +#define YYNRULE 348 #define YYNTOKEN 172 #define YY_MAX_SHIFT 431 -#define YY_MIN_SHIFTREDUCE 673 -#define YY_MAX_SHIFTREDUCE 1018 -#define YY_ERROR_ACTION 1019 -#define YY_ACCEPT_ACTION 1020 -#define YY_NO_ACTION 1021 -#define YY_MIN_REDUCE 1022 -#define YY_MAX_REDUCE 1367 +#define YY_MIN_SHIFTREDUCE 675 +#define YY_MAX_SHIFTREDUCE 1022 +#define YY_ERROR_ACTION 1023 +#define YY_ACCEPT_ACTION 1024 +#define YY_NO_ACTION 1025 +#define YY_MIN_REDUCE 1026 +#define YY_MAX_REDUCE 1373 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -209,270 +209,269 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (1291) +#define YY_ACTTAB_COUNT (1282) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 1225, 43, 306, 1237, 1114, 350, 1221, 1227, 238, 1110, - /* 10 */ 89, 1201, 31, 29, 27, 26, 25, 1253, 1120, 24, - /* 20 */ 170, 1346, 226, 1253, 347, 31, 29, 27, 26, 25, - /* 30 */ 347, 363, 363, 1103, 1345, 362, 66, 270, 1344, 1225, - /* 40 */ 349, 1237, 307, 280, 1213, 1221, 1226, 212, 1065, 335, - /* 50 */ 321, 362, 1125, 1125, 61, 1238, 1239, 1242, 1285, 879, - /* 60 */ 212, 1253, 211, 1281, 246, 363, 271, 1346, 347, 894, - /* 70 */ 1122, 1192, 1194, 239, 1346, 106, 1092, 924, 349, 271, - /* 80 */ 117, 104, 1213, 12, 1344, 189, 1125, 117, 1155, 1127, - /* 90 */ 924, 1344, 107, 1238, 1239, 1242, 1023, 416, 415, 414, + /* 0 */ 1230, 43, 306, 1243, 1118, 350, 1226, 1233, 238, 1114, + /* 10 */ 89, 1205, 31, 29, 27, 26, 25, 1259, 1124, 24, + /* 20 */ 170, 1352, 226, 1259, 347, 31, 29, 27, 26, 25, + /* 30 */ 347, 363, 363, 251, 1351, 362, 66, 270, 1350, 1230, + /* 40 */ 349, 1243, 307, 280, 1217, 1226, 1232, 212, 1069, 335, + /* 50 */ 321, 362, 1129, 1129, 61, 1244, 1245, 1248, 1291, 210, + /* 60 */ 212, 1259, 211, 1287, 246, 363, 1065, 1352, 347, 898, + /* 70 */ 1126, 1196, 1198, 239, 1352, 106, 1096, 928, 349, 350, + /* 80 */ 117, 104, 1217, 12, 1350, 1206, 1129, 117, 293, 1131, + /* 90 */ 928, 1350, 107, 1244, 1245, 1248, 1027, 416, 415, 414, /* 100 */ 413, 412, 411, 410, 409, 408, 407, 406, 405, 404, - /* 110 */ 403, 402, 401, 400, 399, 43, 925, 78, 926, 346, - /* 120 */ 77, 76, 75, 74, 73, 72, 71, 70, 69, 925, - /* 130 */ 336, 1359, 1121, 23, 233, 21, 919, 920, 921, 922, - /* 140 */ 923, 927, 928, 929, 883, 930, 23, 233, 1102, 919, - /* 150 */ 920, 921, 922, 923, 927, 928, 929, 9, 8, 1237, - /* 160 */ 362, 782, 386, 385, 384, 786, 383, 788, 789, 382, - /* 170 */ 791, 379, 309, 797, 376, 799, 800, 373, 370, 1253, - /* 180 */ 30, 28, 363, 1172, 98, 118, 334, 360, 235, 225, - /* 190 */ 861, 30, 28, 961, 1170, 105, 349, 1034, 284, 235, - /* 200 */ 1213, 861, 283, 1125, 1237, 395, 859, 916, 12, 394, - /* 210 */ 62, 1238, 1239, 1242, 1285, 11, 251, 859, 228, 1281, - /* 220 */ 112, 1253, 363, 285, 1253, 937, 11, 66, 347, 1116, - /* 230 */ 396, 334, 166, 881, 286, 52, 1, 109, 313, 1312, - /* 240 */ 219, 349, 210, 1125, 243, 1213, 165, 1, 1165, 393, - /* 250 */ 392, 391, 1118, 390, 324, 62, 1238, 1239, 1242, 1285, - /* 260 */ 428, 1225, 284, 228, 1281, 112, 283, 1221, 1226, 1172, - /* 270 */ 1213, 428, 860, 325, 1237, 240, 220, 104, 218, 217, - /* 280 */ 1170, 282, 118, 860, 1313, 1128, 118, 285, 710, 1299, - /* 290 */ 709, 862, 865, 201, 1253, 907, 31, 29, 27, 26, - /* 300 */ 25, 347, 862, 865, 201, 882, 907, 1296, 711, 1101, - /* 310 */ 1237, 349, 1045, 78, 118, 1213, 77, 76, 75, 74, - /* 320 */ 73, 72, 71, 70, 69, 62, 1238, 1239, 1242, 1285, - /* 330 */ 1253, 424, 423, 228, 1281, 1358, 363, 347, 245, 350, - /* 340 */ 1237, 361, 30, 28, 1319, 1202, 104, 349, 30, 28, - /* 350 */ 235, 1213, 861, 1213, 1127, 398, 235, 1125, 861, 709, - /* 360 */ 1253, 62, 1238, 1239, 1242, 1285, 985, 347, 859, 228, - /* 370 */ 1281, 1358, 968, 1172, 859, 278, 338, 349, 881, 247, - /* 380 */ 1342, 1213, 320, 11, 1170, 1044, 317, 983, 984, 986, - /* 390 */ 987, 62, 1238, 1239, 1242, 1285, 1237, 398, 7, 228, - /* 400 */ 1281, 1358, 339, 906, 1, 908, 909, 910, 911, 912, - /* 410 */ 1303, 880, 1299, 326, 322, 342, 1253, 30, 28, 348, - /* 420 */ 1068, 59, 428, 347, 1172, 235, 1213, 861, 428, 1043, - /* 430 */ 1295, 93, 1189, 349, 860, 1193, 960, 1213, 1117, 120, - /* 440 */ 860, 363, 335, 859, 1304, 956, 184, 202, 1238, 1239, - /* 450 */ 1242, 1014, 1015, 862, 865, 201, 248, 907, 389, 862, - /* 460 */ 865, 201, 1125, 907, 104, 259, 1112, 1346, 879, 292, - /* 470 */ 1213, 287, 1127, 7, 291, 252, 118, 290, 264, 288, - /* 480 */ 117, 1035, 289, 982, 1344, 340, 1237, 265, 31, 29, - /* 490 */ 27, 26, 25, 30, 28, 41, 1299, 428, 6, 363, - /* 500 */ 343, 235, 137, 861, 249, 135, 1253, 30, 28, 860, - /* 510 */ 122, 121, 1061, 347, 1294, 235, 1237, 861, 139, 859, - /* 520 */ 1125, 138, 884, 349, 27, 26, 25, 1213, 862, 865, - /* 530 */ 201, 1108, 907, 859, 293, 337, 1253, 63, 1238, 1239, - /* 540 */ 1242, 1285, 1056, 347, 388, 1284, 1281, 1042, 1093, 7, - /* 550 */ 1054, 318, 167, 349, 1172, 263, 1041, 1213, 258, 257, - /* 560 */ 256, 255, 254, 1, 295, 1171, 431, 63, 1238, 1239, - /* 570 */ 1242, 1285, 298, 428, 1237, 345, 1281, 868, 141, 959, - /* 580 */ 187, 140, 1040, 88, 160, 860, 277, 428, 1213, 420, - /* 590 */ 1039, 186, 331, 1166, 1253, 156, 1038, 1213, 1037, 860, - /* 600 */ 956, 347, 1100, 304, 862, 865, 201, 154, 907, 9, - /* 610 */ 8, 349, 1315, 92, 60, 1213, 302, 182, 862, 865, - /* 620 */ 201, 332, 907, 1213, 151, 63, 1238, 1239, 1242, 1285, - /* 630 */ 143, 1213, 335, 142, 1282, 1237, 1036, 1213, 1254, 1213, - /* 640 */ 90, 1017, 1018, 871, 1237, 169, 58, 867, 359, 1033, - /* 650 */ 163, 1292, 330, 1032, 329, 1253, 54, 1346, 1031, 395, - /* 660 */ 1030, 879, 347, 394, 1253, 312, 931, 1029, 147, 2, - /* 670 */ 117, 347, 349, 1237, 1344, 1028, 1213, 1213, 32, 234, - /* 680 */ 1020, 349, 1237, 119, 396, 1213, 206, 1238, 1239, 1242, - /* 690 */ 1213, 1237, 1191, 1253, 1213, 204, 1238, 1239, 1242, 1213, - /* 700 */ 347, 1213, 1253, 393, 392, 391, 253, 390, 1213, 347, - /* 710 */ 349, 1253, 1027, 870, 1213, 261, 1213, 314, 347, 349, - /* 720 */ 887, 1237, 260, 1213, 206, 1238, 1239, 1242, 349, 250, - /* 730 */ 262, 124, 1213, 205, 1238, 1239, 1242, 242, 241, 1237, - /* 740 */ 266, 1253, 107, 1238, 1239, 1242, 1026, 873, 347, 267, - /* 750 */ 886, 268, 194, 1213, 1346, 127, 331, 196, 349, 1253, - /* 760 */ 42, 1025, 1213, 866, 269, 327, 347, 117, 1237, 195, - /* 770 */ 891, 1344, 207, 1238, 1239, 1242, 349, 92, 130, 123, - /* 780 */ 1213, 1360, 32, 232, 272, 885, 20, 1213, 1253, 854, - /* 790 */ 206, 1238, 1239, 1242, 279, 347, 31, 29, 27, 26, - /* 800 */ 25, 32, 1213, 68, 90, 349, 1022, 281, 1115, 1213, - /* 810 */ 134, 1231, 236, 333, 113, 1292, 1293, 364, 1297, 206, - /* 820 */ 1238, 1239, 1242, 1229, 1237, 1111, 136, 100, 101, 869, - /* 830 */ 87, 86, 85, 84, 83, 82, 81, 80, 79, 861, - /* 840 */ 64, 175, 355, 1113, 1253, 181, 1237, 132, 874, 865, - /* 850 */ 111, 347, 1237, 173, 95, 859, 276, 96, 131, 775, - /* 860 */ 1109, 349, 102, 103, 224, 1213, 1253, 308, 146, 311, - /* 870 */ 770, 98, 1253, 347, 1237, 199, 1238, 1239, 1242, 347, - /* 880 */ 118, 44, 41, 349, 129, 310, 331, 1213, 149, 349, - /* 890 */ 884, 1316, 319, 1213, 1253, 1326, 152, 208, 1238, 1239, - /* 900 */ 1242, 347, 1237, 200, 1238, 1239, 1242, 92, 803, 428, - /* 910 */ 1237, 349, 807, 353, 316, 1213, 865, 1325, 5, 155, - /* 920 */ 368, 860, 1253, 227, 96, 209, 1238, 1239, 1242, 347, - /* 930 */ 1253, 128, 323, 1306, 90, 125, 159, 347, 1237, 349, - /* 940 */ 862, 865, 315, 1213, 114, 1292, 1293, 349, 1297, 328, - /* 950 */ 4, 1213, 161, 1250, 1238, 1239, 1242, 1237, 1253, 22, - /* 960 */ 110, 1249, 1238, 1239, 1242, 347, 1237, 956, 813, 31, - /* 970 */ 29, 27, 26, 25, 883, 349, 812, 1253, 1300, 1213, - /* 980 */ 97, 91, 33, 162, 347, 1237, 1253, 229, 98, 1248, - /* 990 */ 1238, 1239, 1242, 347, 349, 1361, 344, 341, 1213, 1343, - /* 1000 */ 168, 17, 1267, 349, 99, 1253, 356, 1213, 215, 1238, - /* 1010 */ 1239, 1242, 347, 1237, 1200, 351, 96, 214, 1238, 1239, - /* 1020 */ 1242, 352, 349, 177, 1199, 237, 1213, 357, 331, 358, - /* 1030 */ 179, 188, 51, 1253, 1126, 53, 216, 1238, 1239, 1242, - /* 1040 */ 347, 1237, 366, 297, 190, 185, 427, 197, 198, 92, - /* 1050 */ 349, 193, 1207, 192, 1213, 837, 1184, 1183, 305, 94, - /* 1060 */ 1182, 1253, 1181, 1180, 213, 1238, 1239, 1242, 347, 1179, - /* 1070 */ 1178, 1177, 145, 1176, 1175, 300, 90, 839, 349, 1174, - /* 1080 */ 294, 1173, 1213, 144, 1067, 1206, 115, 1292, 1293, 1197, - /* 1090 */ 1297, 126, 203, 1238, 1239, 1242, 1104, 722, 1066, 1064, - /* 1100 */ 292, 275, 287, 273, 274, 291, 40, 1053, 290, 39, - /* 1110 */ 288, 1052, 1049, 289, 1106, 31, 29, 27, 26, 25, - /* 1120 */ 67, 133, 818, 1105, 820, 819, 750, 1062, 749, 748, - /* 1130 */ 747, 746, 745, 1057, 296, 221, 1055, 222, 223, 299, - /* 1140 */ 1048, 301, 1047, 303, 65, 1205, 1204, 36, 1196, 148, - /* 1150 */ 45, 150, 14, 3, 15, 34, 32, 37, 158, 19, - /* 1160 */ 1229, 48, 10, 164, 8, 917, 153, 1003, 1002, 230, - /* 1170 */ 1007, 981, 894, 108, 354, 1006, 157, 231, 975, 974, - /* 1180 */ 1195, 180, 875, 1021, 116, 46, 47, 1021, 1021, 953, - /* 1190 */ 1021, 952, 1021, 1021, 178, 1008, 1063, 1051, 1050, 367, - /* 1200 */ 1021, 244, 1021, 371, 892, 781, 35, 172, 1021, 16, - /* 1210 */ 979, 13, 18, 374, 171, 174, 377, 176, 49, 380, - /* 1220 */ 50, 425, 1021, 1021, 38, 815, 809, 426, 804, 742, - /* 1230 */ 811, 54, 369, 810, 1228, 183, 801, 365, 372, 1021, - /* 1240 */ 798, 375, 734, 792, 378, 422, 790, 381, 741, 740, - /* 1250 */ 720, 739, 397, 55, 738, 737, 736, 735, 56, 733, - /* 1260 */ 796, 418, 795, 794, 387, 732, 793, 731, 57, 730, - /* 1270 */ 729, 728, 727, 726, 725, 417, 1046, 421, 863, 191, - /* 1280 */ 429, 419, 430, 1021, 1021, 1021, 1021, 1021, 1021, 1021, - /* 1290 */ 814, + /* 110 */ 403, 402, 401, 400, 399, 189, 929, 77, 1159, 1120, + /* 120 */ 76, 75, 74, 73, 72, 71, 70, 69, 68, 929, + /* 130 */ 336, 1365, 424, 423, 23, 233, 923, 924, 925, 926, + /* 140 */ 927, 931, 932, 933, 27, 26, 25, 23, 233, 923, + /* 150 */ 924, 925, 926, 927, 931, 932, 933, 9, 8, 1243, + /* 160 */ 1217, 784, 386, 385, 384, 788, 383, 790, 791, 382, + /* 170 */ 793, 379, 883, 799, 376, 801, 802, 373, 370, 1259, + /* 180 */ 30, 28, 105, 1176, 1038, 243, 334, 1049, 235, 225, + /* 190 */ 863, 30, 28, 965, 1174, 271, 349, 362, 1259, 235, + /* 200 */ 1217, 863, 1230, 1243, 885, 347, 861, 1107, 1226, 1232, + /* 210 */ 62, 1244, 1245, 1248, 1291, 11, 363, 861, 228, 1287, + /* 220 */ 112, 360, 712, 1259, 711, 941, 11, 339, 1217, 1105, + /* 230 */ 347, 324, 166, 30, 28, 1024, 1, 1129, 313, 1318, + /* 240 */ 349, 235, 713, 863, 1217, 12, 320, 1, 31, 29, + /* 250 */ 27, 26, 25, 271, 62, 1244, 1245, 1248, 1291, 861, + /* 260 */ 428, 338, 228, 1287, 1364, 1310, 960, 1048, 11, 363, + /* 270 */ 930, 428, 862, 1325, 66, 398, 1176, 326, 322, 1243, + /* 280 */ 1047, 286, 240, 862, 250, 242, 241, 1174, 21, 1, + /* 290 */ 1129, 864, 867, 868, 201, 876, 911, 934, 118, 1259, + /* 300 */ 325, 109, 864, 867, 868, 201, 334, 911, 1217, 1352, + /* 310 */ 340, 869, 1169, 428, 118, 1243, 349, 1046, 1176, 1045, + /* 320 */ 1217, 1217, 117, 118, 247, 862, 1350, 259, 1060, 1174, + /* 330 */ 62, 1244, 1245, 1248, 1291, 1259, 363, 1305, 228, 1287, + /* 340 */ 112, 361, 347, 363, 864, 867, 868, 201, 184, 911, + /* 350 */ 295, 1243, 349, 30, 28, 1302, 1217, 1129, 1217, 1319, + /* 360 */ 1217, 235, 1305, 863, 1129, 364, 62, 1244, 1245, 1248, + /* 370 */ 1291, 1259, 122, 121, 228, 1287, 1364, 872, 347, 861, + /* 380 */ 1301, 30, 28, 348, 972, 1348, 1044, 389, 349, 235, + /* 390 */ 885, 863, 1217, 118, 363, 331, 877, 880, 868, 249, + /* 400 */ 1043, 1042, 62, 1244, 1245, 1248, 1291, 861, 1041, 7, + /* 410 */ 228, 1287, 1364, 964, 245, 1129, 92, 886, 30, 28, + /* 420 */ 337, 1309, 104, 398, 30, 28, 235, 1217, 863, 59, + /* 430 */ 1131, 1243, 235, 428, 863, 1040, 1176, 7, 1037, 93, + /* 440 */ 248, 1217, 1217, 90, 861, 862, 1121, 1197, 104, 1217, + /* 450 */ 861, 1259, 333, 113, 1298, 1299, 1131, 1303, 347, 1036, + /* 460 */ 1035, 428, 884, 1193, 864, 867, 868, 201, 349, 911, + /* 470 */ 120, 1034, 1217, 862, 7, 887, 1217, 335, 1176, 1217, + /* 480 */ 1, 1033, 202, 1244, 1245, 1248, 284, 118, 297, 1175, + /* 490 */ 283, 1116, 864, 867, 868, 201, 43, 911, 428, 1112, + /* 500 */ 1217, 1217, 1352, 305, 428, 1032, 1243, 1106, 1031, 1030, + /* 510 */ 862, 285, 1217, 1125, 1029, 117, 862, 145, 888, 1350, + /* 520 */ 300, 1305, 1217, 9, 8, 294, 1259, 52, 144, 864, + /* 530 */ 867, 868, 201, 347, 911, 864, 867, 868, 201, 1300, + /* 540 */ 911, 989, 1243, 349, 1122, 104, 1217, 1217, 6, 1217, + /* 550 */ 1217, 40, 342, 1132, 39, 1217, 963, 63, 1244, 1245, + /* 560 */ 1248, 1291, 1259, 331, 395, 1290, 1287, 304, 394, 347, + /* 570 */ 863, 388, 317, 987, 988, 990, 991, 165, 1243, 349, + /* 580 */ 302, 871, 137, 1217, 92, 135, 861, 194, 139, 396, + /* 590 */ 1039, 138, 196, 63, 1244, 1245, 1248, 1291, 1259, 318, + /* 600 */ 711, 345, 1287, 335, 195, 347, 309, 1243, 393, 392, + /* 610 */ 391, 90, 390, 1058, 123, 349, 278, 346, 98, 1217, + /* 620 */ 151, 163, 1298, 330, 1104, 329, 1243, 1259, 1352, 63, + /* 630 */ 1244, 1245, 1248, 1291, 347, 298, 141, 343, 1288, 140, + /* 640 */ 428, 117, 986, 156, 349, 1350, 1259, 874, 1217, 1243, + /* 650 */ 960, 234, 862, 347, 41, 154, 1021, 1022, 206, 1244, + /* 660 */ 1245, 1248, 143, 349, 58, 142, 1097, 1217, 1243, 1259, + /* 670 */ 314, 864, 867, 868, 54, 64, 347, 206, 1244, 1245, + /* 680 */ 1248, 395, 870, 1170, 935, 394, 349, 895, 1259, 167, + /* 690 */ 1217, 160, 277, 1321, 920, 347, 32, 883, 1237, 32, + /* 700 */ 205, 1244, 1245, 1248, 252, 349, 396, 264, 1243, 1217, + /* 710 */ 1235, 856, 175, 1243, 332, 118, 265, 169, 355, 107, + /* 720 */ 1244, 1245, 1248, 32, 173, 393, 392, 391, 1259, 390, + /* 730 */ 95, 1260, 327, 1259, 2, 347, 883, 1195, 119, 253, + /* 740 */ 347, 181, 261, 260, 266, 349, 891, 262, 873, 1217, + /* 750 */ 349, 777, 232, 96, 1217, 1072, 268, 236, 1366, 206, + /* 760 */ 1244, 1245, 1248, 98, 206, 1244, 1245, 1248, 1026, 267, + /* 770 */ 124, 77, 890, 772, 76, 75, 74, 73, 72, 71, + /* 780 */ 70, 69, 68, 127, 263, 41, 42, 258, 257, 256, + /* 790 */ 255, 254, 86, 85, 84, 83, 82, 81, 80, 79, + /* 800 */ 78, 431, 1243, 272, 292, 269, 287, 1243, 130, 291, + /* 810 */ 889, 805, 290, 279, 288, 187, 281, 289, 88, 87, + /* 820 */ 809, 308, 1259, 368, 420, 224, 186, 1259, 292, 347, + /* 830 */ 287, 310, 96, 291, 347, 815, 290, 1243, 288, 349, + /* 840 */ 1119, 289, 134, 1217, 349, 1243, 1115, 97, 1217, 60, + /* 850 */ 814, 136, 182, 204, 1244, 1245, 1248, 1259, 207, 1244, + /* 860 */ 1245, 1248, 98, 99, 347, 1259, 31, 29, 27, 26, + /* 870 */ 25, 100, 347, 101, 349, 96, 1117, 146, 1217, 1113, + /* 880 */ 102, 1243, 349, 359, 103, 149, 1217, 311, 199, 1244, + /* 890 */ 1245, 1248, 888, 1322, 319, 1332, 208, 1244, 1245, 1248, + /* 900 */ 312, 1259, 353, 147, 1243, 152, 316, 227, 347, 1243, + /* 910 */ 31, 29, 27, 26, 25, 1331, 868, 155, 349, 323, + /* 920 */ 5, 328, 1217, 898, 1259, 315, 1312, 159, 4, 1259, + /* 930 */ 110, 347, 200, 1244, 1245, 1248, 347, 960, 91, 887, + /* 940 */ 33, 349, 161, 1306, 1243, 1217, 349, 162, 344, 341, + /* 950 */ 1217, 17, 1243, 229, 1367, 209, 1244, 1245, 1248, 331, + /* 960 */ 1256, 1244, 1245, 1248, 1259, 1273, 356, 357, 179, 1349, + /* 970 */ 168, 347, 1259, 1204, 1243, 1203, 351, 177, 352, 347, + /* 980 */ 92, 349, 51, 237, 358, 1217, 188, 1130, 53, 349, + /* 990 */ 190, 366, 185, 1217, 1259, 1255, 1244, 1245, 1248, 427, + /* 1000 */ 197, 347, 1243, 1254, 1244, 1245, 1248, 90, 198, 193, + /* 1010 */ 1243, 349, 192, 1211, 839, 1217, 1188, 114, 1298, 1299, + /* 1020 */ 94, 1303, 1259, 1187, 1186, 215, 1244, 1245, 1248, 347, + /* 1030 */ 1259, 1185, 1243, 1184, 1183, 1182, 1181, 347, 126, 349, + /* 1040 */ 1243, 841, 1180, 1217, 1179, 1178, 1177, 349, 1071, 1210, + /* 1050 */ 1201, 1217, 1259, 214, 1244, 1245, 1248, 1108, 724, 347, + /* 1060 */ 1259, 216, 1244, 1245, 1248, 1018, 1019, 347, 1070, 349, + /* 1070 */ 1068, 132, 275, 1217, 111, 219, 1057, 349, 331, 273, + /* 1080 */ 276, 1217, 131, 213, 1244, 1245, 1248, 274, 1056, 1053, + /* 1090 */ 1110, 203, 1244, 1245, 1248, 67, 133, 284, 822, 92, + /* 1100 */ 821, 283, 820, 1109, 752, 44, 1066, 751, 129, 750, + /* 1110 */ 749, 220, 748, 218, 217, 747, 282, 20, 221, 1061, + /* 1120 */ 222, 296, 285, 1059, 223, 299, 90, 31, 29, 27, + /* 1130 */ 26, 25, 22, 1052, 301, 1051, 115, 1298, 1299, 303, + /* 1140 */ 1303, 65, 31, 29, 27, 26, 25, 910, 1209, 912, + /* 1150 */ 913, 914, 915, 916, 1208, 128, 1200, 148, 14, 125, + /* 1160 */ 45, 36, 3, 153, 150, 32, 37, 158, 985, 108, + /* 1170 */ 34, 1235, 157, 164, 979, 46, 19, 978, 47, 48, + /* 1180 */ 15, 35, 957, 1007, 1006, 956, 8, 1012, 230, 116, + /* 1190 */ 1011, 1010, 16, 10, 896, 231, 13, 921, 172, 18, + /* 1200 */ 171, 983, 174, 354, 176, 49, 1199, 178, 50, 878, + /* 1210 */ 38, 367, 244, 806, 180, 369, 54, 371, 803, 1234, + /* 1220 */ 800, 183, 365, 372, 374, 783, 375, 377, 794, 378, + /* 1230 */ 380, 792, 817, 381, 813, 812, 811, 55, 722, 56, + /* 1240 */ 57, 744, 397, 743, 736, 742, 741, 740, 739, 738, + /* 1250 */ 387, 737, 1067, 735, 798, 734, 733, 797, 732, 731, + /* 1260 */ 796, 795, 730, 729, 728, 727, 417, 418, 1055, 1054, + /* 1270 */ 421, 422, 419, 1050, 816, 425, 426, 1025, 865, 191, + /* 1280 */ 429, 430, }; static const YYCODETYPE yy_lookahead[] = { /* 0 */ 216, 183, 181, 175, 196, 212, 222, 223, 215, 196, /* 10 */ 192, 218, 12, 13, 14, 15, 16, 195, 200, 231, /* 20 */ 232, 246, 199, 195, 202, 12, 13, 14, 15, 16, - /* 30 */ 202, 181, 181, 0, 259, 20, 186, 186, 263, 216, + /* 30 */ 202, 181, 181, 181, 259, 20, 186, 186, 263, 216, /* 40 */ 212, 175, 221, 193, 216, 222, 223, 47, 0, 221, - /* 50 */ 228, 20, 202, 202, 226, 227, 228, 229, 230, 20, - /* 60 */ 47, 195, 234, 235, 204, 181, 46, 246, 202, 69, - /* 70 */ 186, 211, 212, 187, 246, 184, 185, 77, 212, 46, - /* 80 */ 259, 195, 216, 68, 263, 188, 202, 259, 191, 203, + /* 50 */ 228, 20, 202, 202, 226, 227, 228, 229, 230, 207, + /* 60 */ 47, 195, 234, 235, 204, 181, 0, 246, 202, 69, + /* 70 */ 186, 211, 212, 187, 246, 184, 185, 77, 212, 212, + /* 80 */ 259, 195, 216, 68, 263, 218, 202, 259, 22, 203, /* 90 */ 77, 263, 226, 227, 228, 229, 0, 49, 50, 51, /* 100 */ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - /* 110 */ 62, 63, 64, 65, 66, 183, 116, 21, 116, 47, + /* 110 */ 62, 63, 64, 65, 66, 188, 116, 21, 191, 175, /* 120 */ 24, 25, 26, 27, 28, 29, 30, 31, 32, 116, - /* 130 */ 264, 265, 200, 133, 134, 133, 136, 137, 138, 139, - /* 140 */ 140, 141, 142, 143, 20, 143, 133, 134, 0, 136, + /* 130 */ 264, 265, 178, 179, 134, 135, 136, 137, 138, 139, + /* 140 */ 140, 141, 142, 143, 14, 15, 16, 134, 135, 136, /* 150 */ 137, 138, 139, 140, 141, 142, 143, 1, 2, 175, - /* 160 */ 20, 83, 84, 85, 86, 87, 88, 89, 90, 91, - /* 170 */ 92, 93, 69, 95, 96, 97, 98, 99, 100, 195, - /* 180 */ 12, 13, 181, 195, 81, 146, 202, 186, 20, 201, - /* 190 */ 22, 12, 13, 14, 206, 174, 212, 176, 57, 20, - /* 200 */ 216, 22, 61, 202, 175, 57, 38, 135, 68, 61, + /* 160 */ 216, 83, 84, 85, 86, 87, 88, 89, 90, 91, + /* 170 */ 92, 93, 20, 95, 96, 97, 98, 99, 100, 195, + /* 180 */ 12, 13, 174, 195, 176, 199, 202, 175, 20, 201, + /* 190 */ 22, 12, 13, 14, 206, 46, 212, 20, 195, 20, + /* 200 */ 216, 22, 216, 175, 20, 202, 38, 0, 222, 223, /* 210 */ 226, 227, 228, 229, 230, 47, 181, 38, 234, 235, - /* 220 */ 236, 195, 181, 82, 195, 69, 47, 186, 202, 175, - /* 230 */ 82, 202, 248, 20, 193, 180, 68, 194, 254, 255, - /* 240 */ 35, 212, 207, 202, 199, 216, 122, 68, 205, 101, - /* 250 */ 102, 103, 197, 105, 228, 226, 227, 228, 229, 230, - /* 260 */ 92, 216, 57, 234, 235, 236, 61, 222, 223, 195, - /* 270 */ 216, 92, 104, 20, 175, 201, 71, 195, 73, 74, - /* 280 */ 206, 76, 146, 104, 255, 203, 146, 82, 20, 224, - /* 290 */ 22, 123, 124, 125, 195, 127, 12, 13, 14, 15, - /* 300 */ 16, 202, 123, 124, 125, 20, 127, 242, 40, 0, - /* 310 */ 175, 212, 175, 21, 146, 216, 24, 25, 26, 27, - /* 320 */ 28, 29, 30, 31, 32, 226, 227, 228, 229, 230, - /* 330 */ 195, 178, 179, 234, 235, 236, 181, 202, 187, 212, - /* 340 */ 175, 186, 12, 13, 245, 218, 195, 212, 12, 13, - /* 350 */ 20, 216, 22, 216, 203, 46, 20, 202, 22, 22, - /* 360 */ 195, 226, 227, 228, 229, 230, 135, 202, 38, 234, - /* 370 */ 235, 236, 14, 195, 38, 38, 3, 212, 20, 201, - /* 380 */ 245, 216, 120, 47, 206, 175, 155, 156, 157, 158, - /* 390 */ 159, 226, 227, 228, 229, 230, 175, 46, 68, 234, - /* 400 */ 235, 236, 81, 126, 68, 128, 129, 130, 131, 132, - /* 410 */ 245, 20, 224, 151, 152, 81, 195, 12, 13, 14, - /* 420 */ 0, 180, 92, 202, 195, 20, 216, 22, 92, 175, - /* 430 */ 242, 190, 202, 212, 104, 206, 4, 216, 197, 209, - /* 440 */ 104, 181, 221, 38, 144, 145, 186, 226, 227, 228, - /* 450 */ 229, 167, 168, 123, 124, 125, 187, 127, 79, 123, - /* 460 */ 124, 125, 202, 127, 195, 63, 196, 246, 20, 49, - /* 470 */ 216, 51, 203, 68, 54, 27, 146, 57, 30, 59, - /* 480 */ 259, 176, 62, 69, 263, 164, 175, 39, 12, 13, - /* 490 */ 14, 15, 16, 12, 13, 81, 224, 92, 43, 181, - /* 500 */ 166, 20, 72, 22, 186, 75, 195, 12, 13, 104, - /* 510 */ 108, 109, 0, 202, 242, 20, 175, 22, 72, 38, - /* 520 */ 202, 75, 20, 212, 14, 15, 16, 216, 123, 124, - /* 530 */ 125, 196, 127, 38, 22, 162, 195, 226, 227, 228, - /* 540 */ 229, 230, 0, 202, 196, 234, 235, 175, 185, 68, - /* 550 */ 0, 257, 266, 212, 195, 107, 175, 216, 110, 111, - /* 560 */ 112, 113, 114, 68, 22, 206, 19, 226, 227, 228, - /* 570 */ 229, 230, 22, 92, 175, 234, 235, 38, 72, 147, - /* 580 */ 33, 75, 175, 36, 251, 104, 178, 92, 216, 42, - /* 590 */ 175, 44, 181, 205, 195, 69, 175, 216, 175, 104, - /* 600 */ 145, 202, 0, 21, 123, 124, 125, 81, 127, 1, - /* 610 */ 2, 212, 225, 202, 67, 216, 34, 70, 123, 124, - /* 620 */ 125, 244, 127, 216, 122, 226, 227, 228, 229, 230, - /* 630 */ 72, 216, 221, 75, 235, 175, 175, 216, 195, 216, - /* 640 */ 229, 170, 171, 104, 175, 260, 68, 38, 101, 175, - /* 650 */ 239, 240, 241, 175, 243, 195, 78, 246, 175, 57, - /* 660 */ 175, 20, 202, 61, 195, 118, 69, 175, 121, 247, - /* 670 */ 259, 202, 212, 175, 263, 175, 216, 216, 81, 219, - /* 680 */ 172, 212, 175, 115, 82, 216, 226, 227, 228, 229, - /* 690 */ 216, 175, 181, 195, 216, 226, 227, 228, 229, 216, - /* 700 */ 202, 216, 195, 101, 102, 103, 210, 105, 216, 202, - /* 710 */ 212, 195, 175, 104, 216, 116, 216, 219, 202, 212, - /* 720 */ 20, 175, 208, 216, 226, 227, 228, 229, 212, 221, - /* 730 */ 208, 183, 216, 226, 227, 228, 229, 12, 13, 175, - /* 740 */ 181, 195, 226, 227, 228, 229, 175, 22, 202, 220, - /* 750 */ 20, 202, 18, 216, 246, 183, 181, 23, 212, 195, - /* 760 */ 183, 175, 216, 38, 213, 258, 202, 259, 175, 35, - /* 770 */ 69, 263, 226, 227, 228, 229, 212, 202, 183, 45, - /* 780 */ 216, 265, 81, 219, 181, 20, 2, 216, 195, 69, - /* 790 */ 226, 227, 228, 229, 177, 202, 12, 13, 14, 15, - /* 800 */ 16, 81, 216, 181, 229, 212, 0, 195, 195, 216, - /* 810 */ 195, 68, 219, 238, 239, 240, 241, 92, 243, 226, - /* 820 */ 227, 228, 229, 80, 175, 195, 195, 195, 195, 104, - /* 830 */ 24, 25, 26, 27, 28, 29, 30, 31, 32, 22, - /* 840 */ 106, 69, 69, 195, 195, 69, 175, 33, 123, 124, - /* 850 */ 36, 202, 175, 81, 81, 38, 42, 81, 44, 69, - /* 860 */ 195, 212, 195, 195, 177, 216, 195, 220, 180, 213, - /* 870 */ 69, 81, 195, 202, 175, 226, 227, 228, 229, 202, - /* 880 */ 146, 67, 81, 212, 70, 202, 181, 216, 180, 212, - /* 890 */ 20, 225, 154, 216, 195, 256, 217, 226, 227, 228, - /* 900 */ 229, 202, 175, 226, 227, 228, 229, 202, 69, 92, - /* 910 */ 175, 212, 69, 153, 216, 216, 124, 256, 161, 217, - /* 920 */ 81, 104, 195, 216, 81, 226, 227, 228, 229, 202, - /* 930 */ 195, 117, 216, 253, 229, 121, 252, 202, 175, 212, - /* 940 */ 123, 124, 149, 216, 239, 240, 241, 212, 243, 160, - /* 950 */ 148, 216, 249, 226, 227, 228, 229, 175, 195, 2, - /* 960 */ 250, 226, 227, 228, 229, 202, 175, 145, 69, 12, - /* 970 */ 13, 14, 15, 16, 20, 212, 69, 195, 224, 216, - /* 980 */ 81, 202, 115, 237, 202, 175, 195, 169, 81, 226, - /* 990 */ 227, 228, 229, 202, 212, 267, 165, 163, 216, 262, - /* 1000 */ 261, 68, 233, 212, 69, 195, 119, 216, 226, 227, - /* 1010 */ 228, 229, 202, 175, 217, 216, 81, 226, 227, 228, - /* 1020 */ 229, 216, 212, 202, 217, 216, 216, 214, 181, 213, - /* 1030 */ 180, 191, 180, 195, 202, 68, 226, 227, 228, 229, - /* 1040 */ 202, 175, 198, 4, 181, 180, 177, 189, 189, 202, - /* 1050 */ 212, 173, 0, 182, 216, 80, 0, 0, 19, 115, - /* 1060 */ 0, 195, 0, 0, 226, 227, 228, 229, 202, 0, - /* 1070 */ 0, 0, 33, 0, 0, 36, 229, 22, 212, 0, - /* 1080 */ 41, 0, 216, 44, 0, 0, 239, 240, 241, 0, - /* 1090 */ 243, 43, 226, 227, 228, 229, 0, 48, 0, 0, - /* 1100 */ 49, 43, 51, 38, 36, 54, 67, 0, 57, 70, - /* 1110 */ 59, 0, 0, 62, 0, 12, 13, 14, 15, 16, - /* 1120 */ 77, 75, 22, 0, 38, 38, 38, 0, 38, 38, - /* 1130 */ 38, 38, 38, 0, 39, 22, 0, 22, 22, 38, - /* 1140 */ 0, 22, 0, 22, 20, 0, 0, 122, 0, 43, - /* 1150 */ 68, 117, 150, 81, 150, 144, 81, 81, 81, 81, - /* 1160 */ 80, 4, 150, 80, 2, 135, 69, 38, 38, 38, - /* 1170 */ 38, 69, 69, 68, 120, 38, 68, 38, 69, 69, - /* 1180 */ 0, 117, 22, 268, 80, 68, 68, 268, 268, 69, - /* 1190 */ 268, 69, 268, 268, 43, 69, 0, 0, 0, 38, - /* 1200 */ 268, 38, 268, 38, 69, 22, 81, 69, 268, 81, - /* 1210 */ 69, 68, 68, 38, 80, 68, 38, 68, 68, 38, - /* 1220 */ 68, 22, 268, 268, 68, 38, 22, 21, 69, 22, - /* 1230 */ 38, 78, 68, 38, 80, 80, 69, 79, 68, 268, - /* 1240 */ 69, 68, 22, 69, 68, 37, 69, 68, 38, 38, - /* 1250 */ 48, 38, 47, 68, 38, 38, 38, 38, 68, 38, - /* 1260 */ 94, 36, 94, 94, 82, 38, 94, 38, 68, 38, - /* 1270 */ 38, 38, 38, 38, 38, 38, 0, 38, 22, 22, - /* 1280 */ 21, 43, 20, 268, 268, 268, 268, 268, 268, 268, - /* 1290 */ 104, 268, 268, 268, 268, 268, 268, 268, 268, 268, + /* 220 */ 236, 186, 20, 195, 22, 69, 47, 81, 216, 0, + /* 230 */ 202, 228, 248, 12, 13, 172, 68, 202, 254, 255, + /* 240 */ 212, 20, 40, 22, 216, 68, 120, 68, 12, 13, + /* 250 */ 14, 15, 16, 46, 226, 227, 228, 229, 230, 38, + /* 260 */ 92, 3, 234, 235, 236, 144, 145, 175, 47, 181, + /* 270 */ 116, 92, 104, 245, 186, 46, 195, 151, 152, 175, + /* 280 */ 175, 193, 201, 104, 221, 12, 13, 206, 134, 68, + /* 290 */ 202, 123, 124, 125, 126, 22, 128, 143, 146, 195, + /* 300 */ 20, 194, 123, 124, 125, 126, 202, 128, 216, 246, + /* 310 */ 164, 38, 205, 92, 146, 175, 212, 175, 195, 175, + /* 320 */ 216, 216, 259, 146, 201, 104, 263, 63, 0, 206, + /* 330 */ 226, 227, 228, 229, 230, 195, 181, 224, 234, 235, + /* 340 */ 236, 186, 202, 181, 123, 124, 125, 126, 186, 128, + /* 350 */ 22, 175, 212, 12, 13, 242, 216, 202, 216, 255, + /* 360 */ 216, 20, 224, 22, 202, 92, 226, 227, 228, 229, + /* 370 */ 230, 195, 108, 109, 234, 235, 236, 104, 202, 38, + /* 380 */ 242, 12, 13, 14, 14, 245, 175, 79, 212, 20, + /* 390 */ 20, 22, 216, 146, 181, 181, 123, 124, 125, 186, + /* 400 */ 175, 175, 226, 227, 228, 229, 230, 38, 175, 68, + /* 410 */ 234, 235, 236, 4, 187, 202, 202, 20, 12, 13, + /* 420 */ 162, 245, 195, 46, 12, 13, 20, 216, 22, 180, + /* 430 */ 203, 175, 20, 92, 22, 175, 195, 68, 175, 190, + /* 440 */ 187, 216, 216, 229, 38, 104, 197, 206, 195, 216, + /* 450 */ 38, 195, 238, 239, 240, 241, 203, 243, 202, 175, + /* 460 */ 175, 92, 20, 202, 123, 124, 125, 126, 212, 128, + /* 470 */ 209, 175, 216, 104, 68, 20, 216, 221, 195, 216, + /* 480 */ 68, 175, 226, 227, 228, 229, 57, 146, 4, 206, + /* 490 */ 61, 196, 123, 124, 125, 126, 183, 128, 92, 196, + /* 500 */ 216, 216, 246, 19, 92, 175, 175, 0, 175, 175, + /* 510 */ 104, 82, 216, 200, 175, 259, 104, 33, 20, 263, + /* 520 */ 36, 224, 216, 1, 2, 41, 195, 180, 44, 123, + /* 530 */ 124, 125, 126, 202, 128, 123, 124, 125, 126, 242, + /* 540 */ 128, 124, 175, 212, 197, 195, 216, 216, 43, 216, + /* 550 */ 216, 67, 81, 203, 70, 216, 147, 226, 227, 228, + /* 560 */ 229, 230, 195, 181, 57, 234, 235, 21, 61, 202, + /* 570 */ 22, 196, 155, 156, 157, 158, 159, 122, 175, 212, + /* 580 */ 34, 38, 72, 216, 202, 75, 38, 18, 72, 82, + /* 590 */ 176, 75, 23, 226, 227, 228, 229, 230, 195, 257, + /* 600 */ 22, 234, 235, 221, 35, 202, 69, 175, 101, 102, + /* 610 */ 103, 229, 105, 0, 45, 212, 38, 47, 81, 216, + /* 620 */ 122, 239, 240, 241, 0, 243, 175, 195, 246, 226, + /* 630 */ 227, 228, 229, 230, 202, 22, 72, 166, 235, 75, + /* 640 */ 92, 259, 69, 69, 212, 263, 195, 104, 216, 175, + /* 650 */ 145, 219, 104, 202, 81, 81, 170, 171, 226, 227, + /* 660 */ 228, 229, 72, 212, 68, 75, 185, 216, 175, 195, + /* 670 */ 219, 123, 124, 125, 78, 106, 202, 226, 227, 228, + /* 680 */ 229, 57, 38, 205, 69, 61, 212, 69, 195, 266, + /* 690 */ 216, 251, 178, 225, 124, 202, 81, 20, 68, 81, + /* 700 */ 226, 227, 228, 229, 27, 212, 82, 30, 175, 216, + /* 710 */ 80, 69, 69, 175, 244, 146, 39, 260, 69, 226, + /* 720 */ 227, 228, 229, 81, 81, 101, 102, 103, 195, 105, + /* 730 */ 81, 195, 258, 195, 247, 202, 20, 181, 115, 210, + /* 740 */ 202, 69, 116, 208, 181, 212, 20, 208, 104, 216, + /* 750 */ 212, 69, 219, 81, 216, 0, 202, 219, 265, 226, + /* 760 */ 227, 228, 229, 81, 226, 227, 228, 229, 0, 220, + /* 770 */ 183, 21, 20, 69, 24, 25, 26, 27, 28, 29, + /* 780 */ 30, 31, 32, 183, 107, 81, 183, 110, 111, 112, + /* 790 */ 113, 114, 24, 25, 26, 27, 28, 29, 30, 31, + /* 800 */ 32, 19, 175, 181, 49, 213, 51, 175, 183, 54, + /* 810 */ 20, 69, 57, 177, 59, 33, 195, 62, 36, 181, + /* 820 */ 69, 220, 195, 81, 42, 177, 44, 195, 49, 202, + /* 830 */ 51, 202, 81, 54, 202, 69, 57, 175, 59, 212, + /* 840 */ 195, 62, 195, 216, 212, 175, 195, 81, 216, 67, + /* 850 */ 69, 195, 70, 226, 227, 228, 229, 195, 226, 227, + /* 860 */ 228, 229, 81, 69, 202, 195, 12, 13, 14, 15, + /* 870 */ 16, 195, 202, 195, 212, 81, 195, 180, 216, 195, + /* 880 */ 195, 175, 212, 101, 195, 180, 216, 213, 226, 227, + /* 890 */ 228, 229, 20, 225, 154, 256, 226, 227, 228, 229, + /* 900 */ 118, 195, 153, 121, 175, 217, 216, 216, 202, 175, + /* 910 */ 12, 13, 14, 15, 16, 256, 125, 217, 212, 216, + /* 920 */ 161, 160, 216, 69, 195, 149, 253, 252, 148, 195, + /* 930 */ 250, 202, 226, 227, 228, 229, 202, 145, 202, 20, + /* 940 */ 115, 212, 249, 224, 175, 216, 212, 237, 165, 163, + /* 950 */ 216, 68, 175, 169, 267, 226, 227, 228, 229, 181, + /* 960 */ 226, 227, 228, 229, 195, 233, 119, 214, 180, 262, + /* 970 */ 261, 202, 195, 217, 175, 217, 216, 202, 216, 202, + /* 980 */ 202, 212, 180, 216, 213, 216, 191, 202, 68, 212, + /* 990 */ 181, 198, 180, 216, 195, 226, 227, 228, 229, 177, + /* 1000 */ 189, 202, 175, 226, 227, 228, 229, 229, 189, 173, + /* 1010 */ 175, 212, 182, 0, 80, 216, 0, 239, 240, 241, + /* 1020 */ 115, 243, 195, 0, 0, 226, 227, 228, 229, 202, + /* 1030 */ 195, 0, 175, 0, 0, 0, 0, 202, 43, 212, + /* 1040 */ 175, 22, 0, 216, 0, 0, 0, 212, 0, 0, + /* 1050 */ 0, 216, 195, 226, 227, 228, 229, 0, 48, 202, + /* 1060 */ 195, 226, 227, 228, 229, 167, 168, 202, 0, 212, + /* 1070 */ 0, 33, 43, 216, 36, 35, 0, 212, 181, 38, + /* 1080 */ 42, 216, 44, 226, 227, 228, 229, 36, 0, 0, + /* 1090 */ 0, 226, 227, 228, 229, 77, 75, 57, 38, 202, + /* 1100 */ 38, 61, 22, 0, 38, 67, 0, 38, 70, 38, + /* 1110 */ 38, 71, 38, 73, 74, 38, 76, 2, 22, 0, + /* 1120 */ 22, 39, 82, 0, 22, 38, 229, 12, 13, 14, + /* 1130 */ 15, 16, 2, 0, 22, 0, 239, 240, 241, 22, + /* 1140 */ 243, 20, 12, 13, 14, 15, 16, 127, 0, 129, + /* 1150 */ 130, 131, 132, 133, 0, 117, 0, 43, 150, 121, + /* 1160 */ 68, 122, 81, 69, 117, 81, 81, 81, 69, 68, + /* 1170 */ 144, 80, 68, 80, 69, 68, 81, 69, 68, 4, + /* 1180 */ 150, 81, 69, 38, 38, 69, 2, 69, 38, 80, + /* 1190 */ 38, 38, 81, 150, 69, 38, 68, 124, 69, 68, + /* 1200 */ 80, 69, 68, 120, 68, 68, 0, 43, 68, 22, + /* 1210 */ 68, 38, 38, 69, 117, 68, 78, 38, 69, 80, + /* 1220 */ 69, 80, 79, 68, 38, 22, 68, 38, 69, 68, + /* 1230 */ 38, 69, 38, 68, 38, 38, 22, 68, 48, 68, + /* 1240 */ 68, 22, 47, 38, 22, 38, 38, 38, 38, 38, + /* 1250 */ 82, 38, 0, 38, 94, 38, 38, 94, 38, 38, + /* 1260 */ 94, 94, 38, 38, 38, 38, 38, 36, 0, 0, + /* 1270 */ 38, 37, 43, 0, 104, 22, 21, 268, 22, 22, + /* 1280 */ 21, 20, 268, 268, 268, 268, 268, 268, 268, 268, + /* 1290 */ 268, 268, 268, 268, 268, 268, 268, 268, 268, 268, /* 1300 */ 268, 268, 268, 268, 268, 268, 268, 268, 268, 268, /* 1310 */ 268, 268, 268, 268, 268, 268, 268, 268, 268, 268, /* 1320 */ 268, 268, 268, 268, 268, 268, 268, 268, 268, 268, @@ -488,128 +487,127 @@ static const YYCODETYPE yy_lookahead[] = { /* 1420 */ 268, 268, 268, 268, 268, 268, 268, 268, 268, 268, /* 1430 */ 268, 268, 268, 268, 268, 268, 268, 268, 268, 268, /* 1440 */ 268, 268, 268, 268, 268, 268, 268, 268, 268, 268, - /* 1450 */ 268, 268, 268, 268, 268, 268, 268, 268, 268, 268, - /* 1460 */ 268, 268, 268, + /* 1450 */ 268, 268, 268, 268, }; #define YY_SHIFT_COUNT (431) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (1276) +#define YY_SHIFT_MAX (1273) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 734, 168, 179, 336, 336, 336, 336, 330, 336, 336, - /* 10 */ 481, 495, 140, 405, 481, 481, 481, 481, 481, 481, - /* 20 */ 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, - /* 30 */ 481, 481, 481, 15, 15, 15, 39, 725, 725, 31, - /* 40 */ 31, 725, 31, 31, 20, 213, 253, 253, 136, 285, - /* 50 */ 213, 31, 31, 213, 31, 213, 285, 213, 213, 31, - /* 60 */ 351, 0, 13, 13, 448, 292, 205, 817, 1051, 817, - /* 70 */ 817, 817, 817, 817, 817, 817, 817, 817, 817, 817, - /* 80 */ 817, 817, 817, 817, 817, 817, 817, 817, 268, 33, - /* 90 */ 124, 124, 124, 309, 391, 285, 213, 213, 213, 379, - /* 100 */ 78, 78, 78, 78, 78, 96, 420, 284, 231, 141, - /* 110 */ 262, 337, 502, 300, 455, 300, 358, 373, 432, 641, - /* 120 */ 568, 599, 599, 641, 700, 20, 391, 730, 20, 20, - /* 130 */ 641, 20, 765, 213, 213, 213, 213, 213, 213, 213, - /* 140 */ 213, 213, 213, 213, 641, 765, 700, 351, 391, 730, - /* 150 */ 351, 870, 738, 760, 792, 738, 760, 792, 792, 757, - /* 160 */ 789, 793, 802, 822, 391, 954, 867, 818, 831, 834, - /* 170 */ 933, 213, 760, 792, 792, 760, 792, 887, 391, 730, - /* 180 */ 351, 379, 351, 391, 967, 641, 351, 765, 1291, 1291, - /* 190 */ 1291, 1291, 48, 806, 547, 814, 1039, 148, 602, 784, - /* 200 */ 957, 277, 1103, 476, 476, 476, 476, 476, 476, 476, - /* 210 */ 402, 156, 2, 510, 510, 510, 510, 430, 446, 506, - /* 220 */ 558, 512, 542, 550, 582, 103, 414, 526, 608, 471, - /* 230 */ 321, 334, 597, 72, 701, 743, 720, 772, 773, 776, - /* 240 */ 790, 539, 609, 801, 839, 843, 899, 907, 935, 578, - /* 250 */ 1052, 975, 1056, 1057, 944, 1060, 1062, 1063, 1069, 1070, - /* 260 */ 1071, 1055, 1073, 1074, 1079, 1081, 1084, 1085, 1089, 1048, - /* 270 */ 1096, 1049, 1098, 1099, 1065, 1068, 1058, 1107, 1111, 1112, - /* 280 */ 1114, 1043, 1046, 1086, 1087, 1100, 1123, 1088, 1090, 1091, - /* 290 */ 1092, 1093, 1094, 1127, 1113, 1133, 1115, 1095, 1136, 1116, - /* 300 */ 1101, 1140, 1119, 1142, 1121, 1124, 1145, 1146, 1025, 1148, - /* 310 */ 1082, 1106, 1034, 1072, 1075, 1002, 1097, 1076, 1102, 1105, - /* 320 */ 1108, 1109, 1117, 1110, 1077, 1080, 1118, 1078, 1004, 1120, - /* 330 */ 1122, 1083, 1011, 1125, 1104, 1126, 1128, 1012, 1157, 1129, - /* 340 */ 1130, 1131, 1132, 1137, 1139, 1162, 1030, 1134, 1135, 1143, - /* 350 */ 1144, 1138, 1141, 1147, 1149, 1054, 1150, 1180, 1151, 1064, - /* 360 */ 1152, 1153, 1154, 1155, 1160, 1156, 1158, 1159, 1161, 1163, - /* 370 */ 1164, 1167, 1165, 1170, 1171, 1175, 1173, 1174, 1178, 1176, - /* 380 */ 1177, 1181, 1179, 1166, 1168, 1169, 1172, 1183, 1182, 1185, - /* 390 */ 1187, 1186, 1190, 1200, 1192, 1195, 1204, 1202, 1205, 1207, - /* 400 */ 1210, 1211, 1213, 1216, 1217, 1218, 1219, 1220, 1221, 1227, - /* 410 */ 1229, 1231, 1232, 1233, 1234, 1235, 1236, 1196, 1237, 1225, - /* 420 */ 1238, 1197, 1239, 1208, 1198, 1276, 1199, 1206, 1256, 1257, - /* 430 */ 1259, 1262, + /* 0 */ 569, 168, 179, 221, 221, 221, 221, 341, 221, 221, + /* 10 */ 406, 412, 177, 369, 406, 406, 406, 406, 406, 406, + /* 20 */ 406, 406, 406, 406, 406, 406, 406, 406, 406, 406, + /* 30 */ 406, 406, 406, 15, 15, 15, 152, 273, 273, 31, + /* 40 */ 31, 273, 31, 31, 149, 184, 280, 280, 247, 397, + /* 50 */ 184, 31, 31, 184, 31, 184, 397, 184, 184, 31, + /* 60 */ 377, 0, 13, 13, 677, 750, 1040, 548, 548, 548, + /* 70 */ 548, 548, 548, 548, 548, 548, 548, 548, 548, 548, + /* 80 */ 548, 548, 548, 548, 548, 548, 548, 779, 202, 207, + /* 90 */ 455, 455, 455, 229, 442, 397, 184, 184, 184, 308, + /* 100 */ 78, 78, 78, 78, 78, 96, 755, 898, 417, 429, + /* 110 */ 126, 578, 498, 121, 505, 121, 370, 258, 409, 716, + /* 120 */ 623, 626, 626, 716, 726, 149, 442, 752, 149, 149, + /* 130 */ 716, 149, 790, 184, 184, 184, 184, 184, 184, 184, + /* 140 */ 184, 184, 184, 184, 716, 790, 726, 377, 442, 752, + /* 150 */ 377, 872, 740, 749, 791, 740, 749, 791, 791, 759, + /* 160 */ 761, 776, 780, 792, 442, 919, 825, 784, 783, 786, + /* 170 */ 883, 184, 749, 791, 791, 749, 791, 847, 442, 752, + /* 180 */ 377, 308, 377, 442, 920, 716, 377, 790, 1282, 1282, + /* 190 */ 1282, 1282, 48, 768, 782, 1038, 484, 507, 624, 1115, + /* 200 */ 1130, 1020, 854, 236, 236, 236, 236, 236, 236, 236, + /* 210 */ 264, 156, 154, 130, 130, 130, 130, 510, 516, 564, + /* 220 */ 590, 66, 328, 613, 546, 537, 573, 574, 522, 486, + /* 230 */ 146, 471, 615, 570, 618, 630, 642, 643, 649, 672, + /* 240 */ 682, 543, 644, 704, 742, 751, 766, 781, 794, 596, + /* 250 */ 1013, 934, 1016, 1023, 905, 1024, 1031, 1033, 1034, 1035, + /* 260 */ 1036, 1019, 1042, 1044, 1045, 1046, 1048, 1049, 1050, 995, + /* 270 */ 1057, 1010, 1068, 1070, 1041, 1051, 1029, 1076, 1088, 1089, + /* 280 */ 1090, 1018, 1021, 1060, 1062, 1080, 1103, 1066, 1069, 1071, + /* 290 */ 1072, 1074, 1077, 1106, 1096, 1119, 1098, 1082, 1123, 1102, + /* 300 */ 1087, 1133, 1112, 1135, 1117, 1121, 1148, 1154, 1039, 1156, + /* 310 */ 1092, 1114, 1047, 1081, 1084, 1008, 1094, 1085, 1099, 1101, + /* 320 */ 1104, 1105, 1107, 1108, 1086, 1091, 1110, 1095, 1030, 1113, + /* 330 */ 1116, 1093, 1026, 1100, 1109, 1118, 1111, 1043, 1175, 1145, + /* 340 */ 1146, 1150, 1152, 1153, 1157, 1184, 1073, 1120, 1125, 1128, + /* 350 */ 1131, 1129, 1132, 1134, 1136, 1083, 1137, 1206, 1164, 1097, + /* 360 */ 1140, 1138, 1139, 1141, 1187, 1142, 1143, 1144, 1173, 1174, + /* 370 */ 1147, 1149, 1179, 1155, 1151, 1186, 1158, 1159, 1189, 1161, + /* 380 */ 1162, 1192, 1165, 1160, 1163, 1166, 1167, 1203, 1168, 1169, + /* 390 */ 1194, 1170, 1171, 1172, 1196, 1197, 1214, 1190, 1195, 1219, + /* 400 */ 1205, 1207, 1208, 1209, 1210, 1211, 1213, 1222, 1215, 1217, + /* 410 */ 1218, 1220, 1221, 1224, 1225, 1226, 1227, 1252, 1228, 1231, + /* 420 */ 1229, 1268, 1232, 1234, 1269, 1273, 1253, 1255, 1256, 1257, + /* 430 */ 1259, 1261, }; #define YY_REDUCE_COUNT (191) #define YY_REDUCE_MIN (-225) -#define YY_REDUCE_MAX (878) +#define YY_REDUCE_MAX (897) static const short yy_reduce_ofst[] = { - /* 0 */ 508, -172, -16, 29, 99, 135, 165, 221, 311, 341, - /* 10 */ -134, 399, 411, 460, 498, 507, 516, 564, 593, 469, - /* 20 */ 546, 649, 671, 677, 699, 727, 735, 763, 782, 791, - /* 30 */ 810, 838, 866, 575, 705, 847, -179, -177, 45, -150, - /* 40 */ 41, -216, -149, -116, -182, -12, -178, 26, -225, -207, - /* 50 */ -114, 1, 155, 74, 260, 151, -140, 178, 269, 318, - /* 60 */ 241, -212, -212, -212, 35, 21, 43, 54, -109, 137, - /* 70 */ 210, 254, 372, 381, 407, 415, 421, 423, 461, 474, - /* 80 */ 478, 483, 485, 492, 500, 537, 571, 586, 153, -68, - /* 90 */ 65, 188, 272, 55, 230, 127, 82, 229, 359, -103, - /* 100 */ -192, -187, 270, 335, 348, 305, 363, 286, 294, 388, - /* 110 */ 333, 408, 387, 377, 377, 377, 443, 385, 422, 511, - /* 120 */ 496, 514, 522, 559, 529, 548, 549, 551, 572, 577, - /* 130 */ 603, 595, 617, 612, 613, 615, 630, 631, 632, 633, - /* 140 */ 648, 665, 667, 668, 622, 687, 647, 688, 683, 656, - /* 150 */ 708, 666, 639, 679, 698, 661, 702, 707, 716, 680, - /* 160 */ 684, 710, 703, 377, 779, 754, 746, 728, 737, 739, - /* 170 */ 769, 443, 797, 799, 805, 807, 809, 813, 821, 816, - /* 180 */ 850, 840, 852, 832, 844, 863, 865, 869, 858, 859, - /* 190 */ 871, 878, + /* 0 */ 63, -172, -16, 104, 28, 140, 176, 256, 331, 367, + /* 10 */ -134, 403, 382, 432, 451, 474, 493, 533, 538, 627, + /* 20 */ 632, 662, 670, 706, 729, 734, 769, 777, 799, 827, + /* 30 */ 835, 857, 865, 214, 778, 897, -179, -177, -14, -150, + /* 40 */ 88, -216, -149, -116, -182, -12, -178, 3, -225, -207, + /* 50 */ -114, 35, 155, 81, 162, 227, -140, 123, 253, 213, + /* 60 */ 249, -212, -212, -212, -148, 8, 107, -56, 12, 92, + /* 70 */ 105, 142, 144, 211, 225, 226, 233, 260, 263, 284, + /* 80 */ 285, 296, 306, 330, 333, 334, 339, -109, -46, 313, + /* 90 */ 113, 138, 297, 347, 261, -133, 350, 241, 283, -73, + /* 100 */ -192, -187, 295, 303, 375, 414, 481, 423, 342, 478, + /* 110 */ 440, 514, 468, 470, 470, 470, 536, 457, 487, 556, + /* 120 */ 529, 535, 539, 563, 549, 587, 554, 592, 600, 603, + /* 130 */ 622, 625, 636, 621, 645, 647, 651, 656, 676, 678, + /* 140 */ 681, 684, 685, 689, 638, 648, 601, 697, 629, 674, + /* 150 */ 705, 668, 639, 688, 690, 659, 700, 691, 703, 673, + /* 160 */ 675, 680, 693, 470, 736, 719, 710, 687, 707, 709, + /* 170 */ 732, 536, 756, 760, 762, 758, 767, 753, 775, 771, + /* 180 */ 788, 795, 802, 785, 793, 809, 812, 822, 811, 819, + /* 190 */ 830, 836, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 10 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 20 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 30 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 40 */ 1019, 1019, 1019, 1019, 1072, 1019, 1019, 1019, 1019, 1019, - /* 50 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 60 */ 1070, 1019, 1287, 1019, 1185, 1019, 1019, 1019, 1019, 1019, - /* 70 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 80 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1072, - /* 90 */ 1298, 1298, 1298, 1070, 1019, 1019, 1019, 1019, 1019, 1154, - /* 100 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1362, 1019, 1107, - /* 110 */ 1322, 1019, 1314, 1290, 1304, 1291, 1019, 1347, 1307, 1019, - /* 120 */ 1190, 1187, 1187, 1019, 1019, 1072, 1019, 1019, 1072, 1072, - /* 130 */ 1019, 1072, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 140 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1070, 1019, 1019, - /* 150 */ 1070, 1019, 1329, 1327, 1019, 1329, 1327, 1019, 1019, 1341, - /* 160 */ 1337, 1320, 1318, 1304, 1019, 1019, 1019, 1365, 1353, 1349, - /* 170 */ 1019, 1019, 1327, 1019, 1019, 1327, 1019, 1198, 1019, 1019, - /* 180 */ 1070, 1019, 1070, 1019, 1123, 1019, 1070, 1019, 1157, 1157, - /* 190 */ 1073, 1024, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 200 */ 1019, 1019, 1019, 1252, 1340, 1339, 1251, 1264, 1263, 1262, - /* 210 */ 1019, 1019, 1019, 1246, 1247, 1245, 1244, 1019, 1019, 1019, - /* 220 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1288, 1019, - /* 230 */ 1350, 1354, 1019, 1019, 1019, 1230, 1019, 1019, 1019, 1019, - /* 240 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 250 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 260 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 270 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 280 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 290 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 300 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 310 */ 1019, 1019, 1019, 1311, 1321, 1019, 1019, 1019, 1019, 1019, - /* 320 */ 1019, 1019, 1019, 1019, 1019, 1230, 1019, 1338, 1019, 1297, - /* 330 */ 1293, 1019, 1019, 1289, 1019, 1019, 1348, 1019, 1019, 1019, - /* 340 */ 1019, 1019, 1019, 1019, 1019, 1283, 1019, 1019, 1019, 1019, - /* 350 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 360 */ 1019, 1019, 1229, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 370 */ 1151, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 380 */ 1019, 1019, 1019, 1136, 1134, 1133, 1132, 1019, 1129, 1019, - /* 390 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 400 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 410 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 420 */ 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, 1019, - /* 430 */ 1019, 1019, + /* 0 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 10 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 20 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 30 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 40 */ 1023, 1023, 1023, 1023, 1076, 1023, 1023, 1023, 1023, 1023, + /* 50 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 60 */ 1074, 1023, 1293, 1023, 1189, 1023, 1023, 1023, 1023, 1023, + /* 70 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 80 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1076, + /* 90 */ 1304, 1304, 1304, 1074, 1023, 1023, 1023, 1023, 1023, 1158, + /* 100 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1368, 1023, 1111, + /* 110 */ 1328, 1023, 1320, 1296, 1310, 1297, 1023, 1353, 1313, 1023, + /* 120 */ 1194, 1191, 1191, 1023, 1023, 1076, 1023, 1023, 1076, 1076, + /* 130 */ 1023, 1076, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 140 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1074, 1023, 1023, + /* 150 */ 1074, 1023, 1335, 1333, 1023, 1335, 1333, 1023, 1023, 1347, + /* 160 */ 1343, 1326, 1324, 1310, 1023, 1023, 1023, 1371, 1359, 1355, + /* 170 */ 1023, 1023, 1333, 1023, 1023, 1333, 1023, 1202, 1023, 1023, + /* 180 */ 1074, 1023, 1074, 1023, 1127, 1023, 1074, 1023, 1161, 1161, + /* 190 */ 1077, 1028, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 200 */ 1023, 1023, 1023, 1258, 1346, 1345, 1257, 1270, 1269, 1268, + /* 210 */ 1023, 1023, 1023, 1252, 1253, 1251, 1250, 1023, 1023, 1023, + /* 220 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1294, 1023, + /* 230 */ 1356, 1360, 1023, 1023, 1023, 1236, 1023, 1023, 1023, 1023, + /* 240 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 250 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 260 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 270 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 280 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 290 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 300 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 310 */ 1023, 1023, 1023, 1317, 1327, 1023, 1023, 1023, 1023, 1023, + /* 320 */ 1023, 1023, 1023, 1023, 1023, 1236, 1023, 1344, 1023, 1303, + /* 330 */ 1299, 1023, 1023, 1295, 1023, 1023, 1354, 1023, 1023, 1023, + /* 340 */ 1023, 1023, 1023, 1023, 1023, 1289, 1023, 1023, 1023, 1023, + /* 350 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 360 */ 1023, 1023, 1235, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 370 */ 1155, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 380 */ 1023, 1023, 1023, 1140, 1138, 1137, 1136, 1023, 1133, 1023, + /* 390 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 400 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 410 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 420 */ 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1023, + /* 430 */ 1023, 1023, }; /********** End of lemon-generated parsing tables *****************************/ @@ -840,18 +838,18 @@ static const char *const yyTokenName[] = { /* 121 */ "TOPIC", /* 122 */ "AS", /* 123 */ "NK_BOOL", - /* 124 */ "NK_VARIABLE", - /* 125 */ "NK_UNDERLINE", - /* 126 */ "ROWTS", - /* 127 */ "TBNAME", - /* 128 */ "QSTARTTS", - /* 129 */ "QENDTS", - /* 130 */ "WSTARTTS", - /* 131 */ "WENDTS", - /* 132 */ "WDURATION", - /* 133 */ "BETWEEN", - /* 134 */ "IS", - /* 135 */ "NULL", + /* 124 */ "NULL", + /* 125 */ "NK_VARIABLE", + /* 126 */ "NK_UNDERLINE", + /* 127 */ "ROWTS", + /* 128 */ "TBNAME", + /* 129 */ "QSTARTTS", + /* 130 */ "QENDTS", + /* 131 */ "WSTARTTS", + /* 132 */ "WENDTS", + /* 133 */ "WDURATION", + /* 134 */ "BETWEEN", + /* 135 */ "IS", /* 136 */ "NK_LT", /* 137 */ "NK_GT", /* 138 */ "NK_LE", @@ -1183,160 +1181,162 @@ static const char *const yyRuleName[] = { /* 189 */ "literal ::= NK_BOOL", /* 190 */ "literal ::= TIMESTAMP NK_STRING", /* 191 */ "literal ::= duration_literal", - /* 192 */ "duration_literal ::= NK_VARIABLE", - /* 193 */ "signed ::= NK_INTEGER", - /* 194 */ "signed ::= NK_PLUS NK_INTEGER", - /* 195 */ "signed ::= NK_MINUS NK_INTEGER", - /* 196 */ "signed ::= NK_FLOAT", - /* 197 */ "signed ::= NK_PLUS NK_FLOAT", - /* 198 */ "signed ::= NK_MINUS NK_FLOAT", - /* 199 */ "signed_literal ::= signed", - /* 200 */ "signed_literal ::= NK_STRING", - /* 201 */ "signed_literal ::= NK_BOOL", - /* 202 */ "signed_literal ::= TIMESTAMP NK_STRING", - /* 203 */ "signed_literal ::= duration_literal", - /* 204 */ "literal_list ::= signed_literal", - /* 205 */ "literal_list ::= literal_list NK_COMMA signed_literal", - /* 206 */ "db_name ::= NK_ID", - /* 207 */ "table_name ::= NK_ID", - /* 208 */ "column_name ::= NK_ID", - /* 209 */ "function_name ::= NK_ID", - /* 210 */ "table_alias ::= NK_ID", - /* 211 */ "column_alias ::= NK_ID", - /* 212 */ "user_name ::= NK_ID", - /* 213 */ "index_name ::= NK_ID", - /* 214 */ "topic_name ::= NK_ID", - /* 215 */ "expression ::= literal", - /* 216 */ "expression ::= pseudo_column", - /* 217 */ "expression ::= column_reference", - /* 218 */ "expression ::= function_name NK_LP expression_list NK_RP", - /* 219 */ "expression ::= function_name NK_LP NK_STAR NK_RP", - /* 220 */ "expression ::= subquery", - /* 221 */ "expression ::= NK_LP expression NK_RP", - /* 222 */ "expression ::= NK_PLUS expression", - /* 223 */ "expression ::= NK_MINUS expression", - /* 224 */ "expression ::= expression NK_PLUS expression", - /* 225 */ "expression ::= expression NK_MINUS expression", - /* 226 */ "expression ::= expression NK_STAR expression", - /* 227 */ "expression ::= expression NK_SLASH expression", - /* 228 */ "expression ::= expression NK_REM expression", - /* 229 */ "expression_list ::= expression", - /* 230 */ "expression_list ::= expression_list NK_COMMA expression", - /* 231 */ "column_reference ::= column_name", - /* 232 */ "column_reference ::= table_name NK_DOT column_name", - /* 233 */ "pseudo_column ::= NK_UNDERLINE ROWTS", - /* 234 */ "pseudo_column ::= TBNAME", - /* 235 */ "pseudo_column ::= NK_UNDERLINE QSTARTTS", - /* 236 */ "pseudo_column ::= NK_UNDERLINE QENDTS", - /* 237 */ "pseudo_column ::= NK_UNDERLINE WSTARTTS", - /* 238 */ "pseudo_column ::= NK_UNDERLINE WENDTS", - /* 239 */ "pseudo_column ::= NK_UNDERLINE WDURATION", - /* 240 */ "predicate ::= expression compare_op expression", - /* 241 */ "predicate ::= expression BETWEEN expression AND expression", - /* 242 */ "predicate ::= expression NOT BETWEEN expression AND expression", - /* 243 */ "predicate ::= expression IS NULL", - /* 244 */ "predicate ::= expression IS NOT NULL", - /* 245 */ "predicate ::= expression in_op in_predicate_value", - /* 246 */ "compare_op ::= NK_LT", - /* 247 */ "compare_op ::= NK_GT", - /* 248 */ "compare_op ::= NK_LE", - /* 249 */ "compare_op ::= NK_GE", - /* 250 */ "compare_op ::= NK_NE", - /* 251 */ "compare_op ::= NK_EQ", - /* 252 */ "compare_op ::= LIKE", - /* 253 */ "compare_op ::= NOT LIKE", - /* 254 */ "compare_op ::= MATCH", - /* 255 */ "compare_op ::= NMATCH", - /* 256 */ "in_op ::= IN", - /* 257 */ "in_op ::= NOT IN", - /* 258 */ "in_predicate_value ::= NK_LP expression_list NK_RP", - /* 259 */ "boolean_value_expression ::= boolean_primary", - /* 260 */ "boolean_value_expression ::= NOT boolean_primary", - /* 261 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", - /* 262 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", - /* 263 */ "boolean_primary ::= predicate", - /* 264 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", - /* 265 */ "common_expression ::= expression", - /* 266 */ "common_expression ::= boolean_value_expression", - /* 267 */ "from_clause ::= FROM table_reference_list", - /* 268 */ "table_reference_list ::= table_reference", - /* 269 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", - /* 270 */ "table_reference ::= table_primary", - /* 271 */ "table_reference ::= joined_table", - /* 272 */ "table_primary ::= table_name alias_opt", - /* 273 */ "table_primary ::= db_name NK_DOT table_name alias_opt", - /* 274 */ "table_primary ::= subquery alias_opt", - /* 275 */ "table_primary ::= parenthesized_joined_table", - /* 276 */ "alias_opt ::=", - /* 277 */ "alias_opt ::= table_alias", - /* 278 */ "alias_opt ::= AS table_alias", - /* 279 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", - /* 280 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", - /* 281 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", - /* 282 */ "join_type ::=", - /* 283 */ "join_type ::= INNER", - /* 284 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt", - /* 285 */ "set_quantifier_opt ::=", - /* 286 */ "set_quantifier_opt ::= DISTINCT", - /* 287 */ "set_quantifier_opt ::= ALL", - /* 288 */ "select_list ::= NK_STAR", - /* 289 */ "select_list ::= select_sublist", - /* 290 */ "select_sublist ::= select_item", - /* 291 */ "select_sublist ::= select_sublist NK_COMMA select_item", - /* 292 */ "select_item ::= common_expression", - /* 293 */ "select_item ::= common_expression column_alias", - /* 294 */ "select_item ::= common_expression AS column_alias", - /* 295 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 296 */ "where_clause_opt ::=", - /* 297 */ "where_clause_opt ::= WHERE search_condition", - /* 298 */ "partition_by_clause_opt ::=", - /* 299 */ "partition_by_clause_opt ::= PARTITION BY expression_list", - /* 300 */ "twindow_clause_opt ::=", - /* 301 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", - /* 302 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP column_reference NK_RP", - /* 303 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", - /* 304 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", - /* 305 */ "sliding_opt ::=", - /* 306 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", - /* 307 */ "fill_opt ::=", - /* 308 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 309 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", - /* 310 */ "fill_mode ::= NONE", - /* 311 */ "fill_mode ::= PREV", - /* 312 */ "fill_mode ::= NULL", - /* 313 */ "fill_mode ::= LINEAR", - /* 314 */ "fill_mode ::= NEXT", - /* 315 */ "group_by_clause_opt ::=", - /* 316 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 317 */ "group_by_list ::= expression", - /* 318 */ "group_by_list ::= group_by_list NK_COMMA expression", - /* 319 */ "having_clause_opt ::=", - /* 320 */ "having_clause_opt ::= HAVING search_condition", - /* 321 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 322 */ "query_expression_body ::= query_primary", - /* 323 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body", - /* 324 */ "query_primary ::= query_specification", - /* 325 */ "order_by_clause_opt ::=", - /* 326 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 327 */ "slimit_clause_opt ::=", - /* 328 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 329 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 330 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 331 */ "limit_clause_opt ::=", - /* 332 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 333 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 334 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 335 */ "subquery ::= NK_LP query_expression NK_RP", - /* 336 */ "search_condition ::= common_expression", - /* 337 */ "sort_specification_list ::= sort_specification", - /* 338 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 339 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt", - /* 340 */ "ordering_specification_opt ::=", - /* 341 */ "ordering_specification_opt ::= ASC", - /* 342 */ "ordering_specification_opt ::= DESC", - /* 343 */ "null_ordering_opt ::=", - /* 344 */ "null_ordering_opt ::= NULLS FIRST", - /* 345 */ "null_ordering_opt ::= NULLS LAST", + /* 192 */ "literal ::= NULL", + /* 193 */ "duration_literal ::= NK_VARIABLE", + /* 194 */ "signed ::= NK_INTEGER", + /* 195 */ "signed ::= NK_PLUS NK_INTEGER", + /* 196 */ "signed ::= NK_MINUS NK_INTEGER", + /* 197 */ "signed ::= NK_FLOAT", + /* 198 */ "signed ::= NK_PLUS NK_FLOAT", + /* 199 */ "signed ::= NK_MINUS NK_FLOAT", + /* 200 */ "signed_literal ::= signed", + /* 201 */ "signed_literal ::= NK_STRING", + /* 202 */ "signed_literal ::= NK_BOOL", + /* 203 */ "signed_literal ::= TIMESTAMP NK_STRING", + /* 204 */ "signed_literal ::= duration_literal", + /* 205 */ "signed_literal ::= NULL", + /* 206 */ "literal_list ::= signed_literal", + /* 207 */ "literal_list ::= literal_list NK_COMMA signed_literal", + /* 208 */ "db_name ::= NK_ID", + /* 209 */ "table_name ::= NK_ID", + /* 210 */ "column_name ::= NK_ID", + /* 211 */ "function_name ::= NK_ID", + /* 212 */ "table_alias ::= NK_ID", + /* 213 */ "column_alias ::= NK_ID", + /* 214 */ "user_name ::= NK_ID", + /* 215 */ "index_name ::= NK_ID", + /* 216 */ "topic_name ::= NK_ID", + /* 217 */ "expression ::= literal", + /* 218 */ "expression ::= pseudo_column", + /* 219 */ "expression ::= column_reference", + /* 220 */ "expression ::= function_name NK_LP expression_list NK_RP", + /* 221 */ "expression ::= function_name NK_LP NK_STAR NK_RP", + /* 222 */ "expression ::= subquery", + /* 223 */ "expression ::= NK_LP expression NK_RP", + /* 224 */ "expression ::= NK_PLUS expression", + /* 225 */ "expression ::= NK_MINUS expression", + /* 226 */ "expression ::= expression NK_PLUS expression", + /* 227 */ "expression ::= expression NK_MINUS expression", + /* 228 */ "expression ::= expression NK_STAR expression", + /* 229 */ "expression ::= expression NK_SLASH expression", + /* 230 */ "expression ::= expression NK_REM expression", + /* 231 */ "expression_list ::= expression", + /* 232 */ "expression_list ::= expression_list NK_COMMA expression", + /* 233 */ "column_reference ::= column_name", + /* 234 */ "column_reference ::= table_name NK_DOT column_name", + /* 235 */ "pseudo_column ::= NK_UNDERLINE ROWTS", + /* 236 */ "pseudo_column ::= TBNAME", + /* 237 */ "pseudo_column ::= NK_UNDERLINE QSTARTTS", + /* 238 */ "pseudo_column ::= NK_UNDERLINE QENDTS", + /* 239 */ "pseudo_column ::= NK_UNDERLINE WSTARTTS", + /* 240 */ "pseudo_column ::= NK_UNDERLINE WENDTS", + /* 241 */ "pseudo_column ::= NK_UNDERLINE WDURATION", + /* 242 */ "predicate ::= expression compare_op expression", + /* 243 */ "predicate ::= expression BETWEEN expression AND expression", + /* 244 */ "predicate ::= expression NOT BETWEEN expression AND expression", + /* 245 */ "predicate ::= expression IS NULL", + /* 246 */ "predicate ::= expression IS NOT NULL", + /* 247 */ "predicate ::= expression in_op in_predicate_value", + /* 248 */ "compare_op ::= NK_LT", + /* 249 */ "compare_op ::= NK_GT", + /* 250 */ "compare_op ::= NK_LE", + /* 251 */ "compare_op ::= NK_GE", + /* 252 */ "compare_op ::= NK_NE", + /* 253 */ "compare_op ::= NK_EQ", + /* 254 */ "compare_op ::= LIKE", + /* 255 */ "compare_op ::= NOT LIKE", + /* 256 */ "compare_op ::= MATCH", + /* 257 */ "compare_op ::= NMATCH", + /* 258 */ "in_op ::= IN", + /* 259 */ "in_op ::= NOT IN", + /* 260 */ "in_predicate_value ::= NK_LP expression_list NK_RP", + /* 261 */ "boolean_value_expression ::= boolean_primary", + /* 262 */ "boolean_value_expression ::= NOT boolean_primary", + /* 263 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", + /* 264 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", + /* 265 */ "boolean_primary ::= predicate", + /* 266 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", + /* 267 */ "common_expression ::= expression", + /* 268 */ "common_expression ::= boolean_value_expression", + /* 269 */ "from_clause ::= FROM table_reference_list", + /* 270 */ "table_reference_list ::= table_reference", + /* 271 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", + /* 272 */ "table_reference ::= table_primary", + /* 273 */ "table_reference ::= joined_table", + /* 274 */ "table_primary ::= table_name alias_opt", + /* 275 */ "table_primary ::= db_name NK_DOT table_name alias_opt", + /* 276 */ "table_primary ::= subquery alias_opt", + /* 277 */ "table_primary ::= parenthesized_joined_table", + /* 278 */ "alias_opt ::=", + /* 279 */ "alias_opt ::= table_alias", + /* 280 */ "alias_opt ::= AS table_alias", + /* 281 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", + /* 282 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", + /* 283 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", + /* 284 */ "join_type ::=", + /* 285 */ "join_type ::= INNER", + /* 286 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt", + /* 287 */ "set_quantifier_opt ::=", + /* 288 */ "set_quantifier_opt ::= DISTINCT", + /* 289 */ "set_quantifier_opt ::= ALL", + /* 290 */ "select_list ::= NK_STAR", + /* 291 */ "select_list ::= select_sublist", + /* 292 */ "select_sublist ::= select_item", + /* 293 */ "select_sublist ::= select_sublist NK_COMMA select_item", + /* 294 */ "select_item ::= common_expression", + /* 295 */ "select_item ::= common_expression column_alias", + /* 296 */ "select_item ::= common_expression AS column_alias", + /* 297 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 298 */ "where_clause_opt ::=", + /* 299 */ "where_clause_opt ::= WHERE search_condition", + /* 300 */ "partition_by_clause_opt ::=", + /* 301 */ "partition_by_clause_opt ::= PARTITION BY expression_list", + /* 302 */ "twindow_clause_opt ::=", + /* 303 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", + /* 304 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP column_reference NK_RP", + /* 305 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", + /* 306 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", + /* 307 */ "sliding_opt ::=", + /* 308 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", + /* 309 */ "fill_opt ::=", + /* 310 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 311 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", + /* 312 */ "fill_mode ::= NONE", + /* 313 */ "fill_mode ::= PREV", + /* 314 */ "fill_mode ::= NULL", + /* 315 */ "fill_mode ::= LINEAR", + /* 316 */ "fill_mode ::= NEXT", + /* 317 */ "group_by_clause_opt ::=", + /* 318 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 319 */ "group_by_list ::= expression", + /* 320 */ "group_by_list ::= group_by_list NK_COMMA expression", + /* 321 */ "having_clause_opt ::=", + /* 322 */ "having_clause_opt ::= HAVING search_condition", + /* 323 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 324 */ "query_expression_body ::= query_primary", + /* 325 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body", + /* 326 */ "query_primary ::= query_specification", + /* 327 */ "order_by_clause_opt ::=", + /* 328 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 329 */ "slimit_clause_opt ::=", + /* 330 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 331 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 332 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 333 */ "limit_clause_opt ::=", + /* 334 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 335 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 336 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 337 */ "subquery ::= NK_LP query_expression NK_RP", + /* 338 */ "search_condition ::= common_expression", + /* 339 */ "sort_specification_list ::= sort_specification", + /* 340 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 341 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt", + /* 342 */ "ordering_specification_opt ::=", + /* 343 */ "ordering_specification_opt ::= ASC", + /* 344 */ "ordering_specification_opt ::= DESC", + /* 345 */ "null_ordering_opt ::=", + /* 346 */ "null_ordering_opt ::= NULLS FIRST", + /* 347 */ "null_ordering_opt ::= NULLS LAST", }; #endif /* NDEBUG */ @@ -2093,160 +2093,162 @@ static const struct { { 175, -1 }, /* (189) literal ::= NK_BOOL */ { 175, -2 }, /* (190) literal ::= TIMESTAMP NK_STRING */ { 175, -1 }, /* (191) literal ::= duration_literal */ - { 216, -1 }, /* (192) duration_literal ::= NK_VARIABLE */ - { 222, -1 }, /* (193) signed ::= NK_INTEGER */ - { 222, -2 }, /* (194) signed ::= NK_PLUS NK_INTEGER */ - { 222, -2 }, /* (195) signed ::= NK_MINUS NK_INTEGER */ - { 222, -1 }, /* (196) signed ::= NK_FLOAT */ - { 222, -2 }, /* (197) signed ::= NK_PLUS NK_FLOAT */ - { 222, -2 }, /* (198) signed ::= NK_MINUS NK_FLOAT */ - { 223, -1 }, /* (199) signed_literal ::= signed */ - { 223, -1 }, /* (200) signed_literal ::= NK_STRING */ - { 223, -1 }, /* (201) signed_literal ::= NK_BOOL */ - { 223, -2 }, /* (202) signed_literal ::= TIMESTAMP NK_STRING */ - { 223, -1 }, /* (203) signed_literal ::= duration_literal */ - { 199, -1 }, /* (204) literal_list ::= signed_literal */ - { 199, -3 }, /* (205) literal_list ::= literal_list NK_COMMA signed_literal */ - { 181, -1 }, /* (206) db_name ::= NK_ID */ - { 202, -1 }, /* (207) table_name ::= NK_ID */ - { 195, -1 }, /* (208) column_name ::= NK_ID */ - { 212, -1 }, /* (209) function_name ::= NK_ID */ - { 224, -1 }, /* (210) table_alias ::= NK_ID */ - { 225, -1 }, /* (211) column_alias ::= NK_ID */ - { 177, -1 }, /* (212) user_name ::= NK_ID */ - { 213, -1 }, /* (213) index_name ::= NK_ID */ - { 220, -1 }, /* (214) topic_name ::= NK_ID */ - { 226, -1 }, /* (215) expression ::= literal */ - { 226, -1 }, /* (216) expression ::= pseudo_column */ - { 226, -1 }, /* (217) expression ::= column_reference */ - { 226, -4 }, /* (218) expression ::= function_name NK_LP expression_list NK_RP */ - { 226, -4 }, /* (219) expression ::= function_name NK_LP NK_STAR NK_RP */ - { 226, -1 }, /* (220) expression ::= subquery */ - { 226, -3 }, /* (221) expression ::= NK_LP expression NK_RP */ - { 226, -2 }, /* (222) expression ::= NK_PLUS expression */ - { 226, -2 }, /* (223) expression ::= NK_MINUS expression */ - { 226, -3 }, /* (224) expression ::= expression NK_PLUS expression */ - { 226, -3 }, /* (225) expression ::= expression NK_MINUS expression */ - { 226, -3 }, /* (226) expression ::= expression NK_STAR expression */ - { 226, -3 }, /* (227) expression ::= expression NK_SLASH expression */ - { 226, -3 }, /* (228) expression ::= expression NK_REM expression */ - { 219, -1 }, /* (229) expression_list ::= expression */ - { 219, -3 }, /* (230) expression_list ::= expression_list NK_COMMA expression */ - { 228, -1 }, /* (231) column_reference ::= column_name */ - { 228, -3 }, /* (232) column_reference ::= table_name NK_DOT column_name */ - { 227, -2 }, /* (233) pseudo_column ::= NK_UNDERLINE ROWTS */ - { 227, -1 }, /* (234) pseudo_column ::= TBNAME */ - { 227, -2 }, /* (235) pseudo_column ::= NK_UNDERLINE QSTARTTS */ - { 227, -2 }, /* (236) pseudo_column ::= NK_UNDERLINE QENDTS */ - { 227, -2 }, /* (237) pseudo_column ::= NK_UNDERLINE WSTARTTS */ - { 227, -2 }, /* (238) pseudo_column ::= NK_UNDERLINE WENDTS */ - { 227, -2 }, /* (239) pseudo_column ::= NK_UNDERLINE WDURATION */ - { 230, -3 }, /* (240) predicate ::= expression compare_op expression */ - { 230, -5 }, /* (241) predicate ::= expression BETWEEN expression AND expression */ - { 230, -6 }, /* (242) predicate ::= expression NOT BETWEEN expression AND expression */ - { 230, -3 }, /* (243) predicate ::= expression IS NULL */ - { 230, -4 }, /* (244) predicate ::= expression IS NOT NULL */ - { 230, -3 }, /* (245) predicate ::= expression in_op in_predicate_value */ - { 231, -1 }, /* (246) compare_op ::= NK_LT */ - { 231, -1 }, /* (247) compare_op ::= NK_GT */ - { 231, -1 }, /* (248) compare_op ::= NK_LE */ - { 231, -1 }, /* (249) compare_op ::= NK_GE */ - { 231, -1 }, /* (250) compare_op ::= NK_NE */ - { 231, -1 }, /* (251) compare_op ::= NK_EQ */ - { 231, -1 }, /* (252) compare_op ::= LIKE */ - { 231, -2 }, /* (253) compare_op ::= NOT LIKE */ - { 231, -1 }, /* (254) compare_op ::= MATCH */ - { 231, -1 }, /* (255) compare_op ::= NMATCH */ - { 232, -1 }, /* (256) in_op ::= IN */ - { 232, -2 }, /* (257) in_op ::= NOT IN */ - { 233, -3 }, /* (258) in_predicate_value ::= NK_LP expression_list NK_RP */ - { 234, -1 }, /* (259) boolean_value_expression ::= boolean_primary */ - { 234, -2 }, /* (260) boolean_value_expression ::= NOT boolean_primary */ - { 234, -3 }, /* (261) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - { 234, -3 }, /* (262) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - { 235, -1 }, /* (263) boolean_primary ::= predicate */ - { 235, -3 }, /* (264) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - { 236, -1 }, /* (265) common_expression ::= expression */ - { 236, -1 }, /* (266) common_expression ::= boolean_value_expression */ - { 237, -2 }, /* (267) from_clause ::= FROM table_reference_list */ - { 238, -1 }, /* (268) table_reference_list ::= table_reference */ - { 238, -3 }, /* (269) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - { 239, -1 }, /* (270) table_reference ::= table_primary */ - { 239, -1 }, /* (271) table_reference ::= joined_table */ - { 240, -2 }, /* (272) table_primary ::= table_name alias_opt */ - { 240, -4 }, /* (273) table_primary ::= db_name NK_DOT table_name alias_opt */ - { 240, -2 }, /* (274) table_primary ::= subquery alias_opt */ - { 240, -1 }, /* (275) table_primary ::= parenthesized_joined_table */ - { 242, 0 }, /* (276) alias_opt ::= */ - { 242, -1 }, /* (277) alias_opt ::= table_alias */ - { 242, -2 }, /* (278) alias_opt ::= AS table_alias */ - { 243, -3 }, /* (279) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - { 243, -3 }, /* (280) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - { 241, -6 }, /* (281) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ - { 244, 0 }, /* (282) join_type ::= */ - { 244, -1 }, /* (283) join_type ::= INNER */ - { 246, -9 }, /* (284) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ - { 247, 0 }, /* (285) set_quantifier_opt ::= */ - { 247, -1 }, /* (286) set_quantifier_opt ::= DISTINCT */ - { 247, -1 }, /* (287) set_quantifier_opt ::= ALL */ - { 248, -1 }, /* (288) select_list ::= NK_STAR */ - { 248, -1 }, /* (289) select_list ::= select_sublist */ - { 254, -1 }, /* (290) select_sublist ::= select_item */ - { 254, -3 }, /* (291) select_sublist ::= select_sublist NK_COMMA select_item */ - { 255, -1 }, /* (292) select_item ::= common_expression */ - { 255, -2 }, /* (293) select_item ::= common_expression column_alias */ - { 255, -3 }, /* (294) select_item ::= common_expression AS column_alias */ - { 255, -3 }, /* (295) select_item ::= table_name NK_DOT NK_STAR */ - { 249, 0 }, /* (296) where_clause_opt ::= */ - { 249, -2 }, /* (297) where_clause_opt ::= WHERE search_condition */ - { 250, 0 }, /* (298) partition_by_clause_opt ::= */ - { 250, -3 }, /* (299) partition_by_clause_opt ::= PARTITION BY expression_list */ - { 251, 0 }, /* (300) twindow_clause_opt ::= */ - { 251, -6 }, /* (301) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ - { 251, -4 }, /* (302) twindow_clause_opt ::= STATE_WINDOW NK_LP column_reference NK_RP */ - { 251, -6 }, /* (303) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ - { 251, -8 }, /* (304) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ - { 217, 0 }, /* (305) sliding_opt ::= */ - { 217, -4 }, /* (306) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ - { 256, 0 }, /* (307) fill_opt ::= */ - { 256, -4 }, /* (308) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - { 256, -6 }, /* (309) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ - { 257, -1 }, /* (310) fill_mode ::= NONE */ - { 257, -1 }, /* (311) fill_mode ::= PREV */ - { 257, -1 }, /* (312) fill_mode ::= NULL */ - { 257, -1 }, /* (313) fill_mode ::= LINEAR */ - { 257, -1 }, /* (314) fill_mode ::= NEXT */ - { 252, 0 }, /* (315) group_by_clause_opt ::= */ - { 252, -3 }, /* (316) group_by_clause_opt ::= GROUP BY group_by_list */ - { 258, -1 }, /* (317) group_by_list ::= expression */ - { 258, -3 }, /* (318) group_by_list ::= group_by_list NK_COMMA expression */ - { 253, 0 }, /* (319) having_clause_opt ::= */ - { 253, -2 }, /* (320) having_clause_opt ::= HAVING search_condition */ - { 221, -4 }, /* (321) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ - { 259, -1 }, /* (322) query_expression_body ::= query_primary */ - { 259, -4 }, /* (323) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ - { 263, -1 }, /* (324) query_primary ::= query_specification */ - { 260, 0 }, /* (325) order_by_clause_opt ::= */ - { 260, -3 }, /* (326) order_by_clause_opt ::= ORDER BY sort_specification_list */ - { 261, 0 }, /* (327) slimit_clause_opt ::= */ - { 261, -2 }, /* (328) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - { 261, -4 }, /* (329) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - { 261, -4 }, /* (330) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 262, 0 }, /* (331) limit_clause_opt ::= */ - { 262, -2 }, /* (332) limit_clause_opt ::= LIMIT NK_INTEGER */ - { 262, -4 }, /* (333) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - { 262, -4 }, /* (334) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 229, -3 }, /* (335) subquery ::= NK_LP query_expression NK_RP */ - { 245, -1 }, /* (336) search_condition ::= common_expression */ - { 264, -1 }, /* (337) sort_specification_list ::= sort_specification */ - { 264, -3 }, /* (338) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - { 265, -3 }, /* (339) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ - { 266, 0 }, /* (340) ordering_specification_opt ::= */ - { 266, -1 }, /* (341) ordering_specification_opt ::= ASC */ - { 266, -1 }, /* (342) ordering_specification_opt ::= DESC */ - { 267, 0 }, /* (343) null_ordering_opt ::= */ - { 267, -2 }, /* (344) null_ordering_opt ::= NULLS FIRST */ - { 267, -2 }, /* (345) null_ordering_opt ::= NULLS LAST */ + { 175, -1 }, /* (192) literal ::= NULL */ + { 216, -1 }, /* (193) duration_literal ::= NK_VARIABLE */ + { 222, -1 }, /* (194) signed ::= NK_INTEGER */ + { 222, -2 }, /* (195) signed ::= NK_PLUS NK_INTEGER */ + { 222, -2 }, /* (196) signed ::= NK_MINUS NK_INTEGER */ + { 222, -1 }, /* (197) signed ::= NK_FLOAT */ + { 222, -2 }, /* (198) signed ::= NK_PLUS NK_FLOAT */ + { 222, -2 }, /* (199) signed ::= NK_MINUS NK_FLOAT */ + { 223, -1 }, /* (200) signed_literal ::= signed */ + { 223, -1 }, /* (201) signed_literal ::= NK_STRING */ + { 223, -1 }, /* (202) signed_literal ::= NK_BOOL */ + { 223, -2 }, /* (203) signed_literal ::= TIMESTAMP NK_STRING */ + { 223, -1 }, /* (204) signed_literal ::= duration_literal */ + { 223, -1 }, /* (205) signed_literal ::= NULL */ + { 199, -1 }, /* (206) literal_list ::= signed_literal */ + { 199, -3 }, /* (207) literal_list ::= literal_list NK_COMMA signed_literal */ + { 181, -1 }, /* (208) db_name ::= NK_ID */ + { 202, -1 }, /* (209) table_name ::= NK_ID */ + { 195, -1 }, /* (210) column_name ::= NK_ID */ + { 212, -1 }, /* (211) function_name ::= NK_ID */ + { 224, -1 }, /* (212) table_alias ::= NK_ID */ + { 225, -1 }, /* (213) column_alias ::= NK_ID */ + { 177, -1 }, /* (214) user_name ::= NK_ID */ + { 213, -1 }, /* (215) index_name ::= NK_ID */ + { 220, -1 }, /* (216) topic_name ::= NK_ID */ + { 226, -1 }, /* (217) expression ::= literal */ + { 226, -1 }, /* (218) expression ::= pseudo_column */ + { 226, -1 }, /* (219) expression ::= column_reference */ + { 226, -4 }, /* (220) expression ::= function_name NK_LP expression_list NK_RP */ + { 226, -4 }, /* (221) expression ::= function_name NK_LP NK_STAR NK_RP */ + { 226, -1 }, /* (222) expression ::= subquery */ + { 226, -3 }, /* (223) expression ::= NK_LP expression NK_RP */ + { 226, -2 }, /* (224) expression ::= NK_PLUS expression */ + { 226, -2 }, /* (225) expression ::= NK_MINUS expression */ + { 226, -3 }, /* (226) expression ::= expression NK_PLUS expression */ + { 226, -3 }, /* (227) expression ::= expression NK_MINUS expression */ + { 226, -3 }, /* (228) expression ::= expression NK_STAR expression */ + { 226, -3 }, /* (229) expression ::= expression NK_SLASH expression */ + { 226, -3 }, /* (230) expression ::= expression NK_REM expression */ + { 219, -1 }, /* (231) expression_list ::= expression */ + { 219, -3 }, /* (232) expression_list ::= expression_list NK_COMMA expression */ + { 228, -1 }, /* (233) column_reference ::= column_name */ + { 228, -3 }, /* (234) column_reference ::= table_name NK_DOT column_name */ + { 227, -2 }, /* (235) pseudo_column ::= NK_UNDERLINE ROWTS */ + { 227, -1 }, /* (236) pseudo_column ::= TBNAME */ + { 227, -2 }, /* (237) pseudo_column ::= NK_UNDERLINE QSTARTTS */ + { 227, -2 }, /* (238) pseudo_column ::= NK_UNDERLINE QENDTS */ + { 227, -2 }, /* (239) pseudo_column ::= NK_UNDERLINE WSTARTTS */ + { 227, -2 }, /* (240) pseudo_column ::= NK_UNDERLINE WENDTS */ + { 227, -2 }, /* (241) pseudo_column ::= NK_UNDERLINE WDURATION */ + { 230, -3 }, /* (242) predicate ::= expression compare_op expression */ + { 230, -5 }, /* (243) predicate ::= expression BETWEEN expression AND expression */ + { 230, -6 }, /* (244) predicate ::= expression NOT BETWEEN expression AND expression */ + { 230, -3 }, /* (245) predicate ::= expression IS NULL */ + { 230, -4 }, /* (246) predicate ::= expression IS NOT NULL */ + { 230, -3 }, /* (247) predicate ::= expression in_op in_predicate_value */ + { 231, -1 }, /* (248) compare_op ::= NK_LT */ + { 231, -1 }, /* (249) compare_op ::= NK_GT */ + { 231, -1 }, /* (250) compare_op ::= NK_LE */ + { 231, -1 }, /* (251) compare_op ::= NK_GE */ + { 231, -1 }, /* (252) compare_op ::= NK_NE */ + { 231, -1 }, /* (253) compare_op ::= NK_EQ */ + { 231, -1 }, /* (254) compare_op ::= LIKE */ + { 231, -2 }, /* (255) compare_op ::= NOT LIKE */ + { 231, -1 }, /* (256) compare_op ::= MATCH */ + { 231, -1 }, /* (257) compare_op ::= NMATCH */ + { 232, -1 }, /* (258) in_op ::= IN */ + { 232, -2 }, /* (259) in_op ::= NOT IN */ + { 233, -3 }, /* (260) in_predicate_value ::= NK_LP expression_list NK_RP */ + { 234, -1 }, /* (261) boolean_value_expression ::= boolean_primary */ + { 234, -2 }, /* (262) boolean_value_expression ::= NOT boolean_primary */ + { 234, -3 }, /* (263) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + { 234, -3 }, /* (264) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + { 235, -1 }, /* (265) boolean_primary ::= predicate */ + { 235, -3 }, /* (266) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + { 236, -1 }, /* (267) common_expression ::= expression */ + { 236, -1 }, /* (268) common_expression ::= boolean_value_expression */ + { 237, -2 }, /* (269) from_clause ::= FROM table_reference_list */ + { 238, -1 }, /* (270) table_reference_list ::= table_reference */ + { 238, -3 }, /* (271) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + { 239, -1 }, /* (272) table_reference ::= table_primary */ + { 239, -1 }, /* (273) table_reference ::= joined_table */ + { 240, -2 }, /* (274) table_primary ::= table_name alias_opt */ + { 240, -4 }, /* (275) table_primary ::= db_name NK_DOT table_name alias_opt */ + { 240, -2 }, /* (276) table_primary ::= subquery alias_opt */ + { 240, -1 }, /* (277) table_primary ::= parenthesized_joined_table */ + { 242, 0 }, /* (278) alias_opt ::= */ + { 242, -1 }, /* (279) alias_opt ::= table_alias */ + { 242, -2 }, /* (280) alias_opt ::= AS table_alias */ + { 243, -3 }, /* (281) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + { 243, -3 }, /* (282) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + { 241, -6 }, /* (283) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + { 244, 0 }, /* (284) join_type ::= */ + { 244, -1 }, /* (285) join_type ::= INNER */ + { 246, -9 }, /* (286) query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + { 247, 0 }, /* (287) set_quantifier_opt ::= */ + { 247, -1 }, /* (288) set_quantifier_opt ::= DISTINCT */ + { 247, -1 }, /* (289) set_quantifier_opt ::= ALL */ + { 248, -1 }, /* (290) select_list ::= NK_STAR */ + { 248, -1 }, /* (291) select_list ::= select_sublist */ + { 254, -1 }, /* (292) select_sublist ::= select_item */ + { 254, -3 }, /* (293) select_sublist ::= select_sublist NK_COMMA select_item */ + { 255, -1 }, /* (294) select_item ::= common_expression */ + { 255, -2 }, /* (295) select_item ::= common_expression column_alias */ + { 255, -3 }, /* (296) select_item ::= common_expression AS column_alias */ + { 255, -3 }, /* (297) select_item ::= table_name NK_DOT NK_STAR */ + { 249, 0 }, /* (298) where_clause_opt ::= */ + { 249, -2 }, /* (299) where_clause_opt ::= WHERE search_condition */ + { 250, 0 }, /* (300) partition_by_clause_opt ::= */ + { 250, -3 }, /* (301) partition_by_clause_opt ::= PARTITION BY expression_list */ + { 251, 0 }, /* (302) twindow_clause_opt ::= */ + { 251, -6 }, /* (303) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ + { 251, -4 }, /* (304) twindow_clause_opt ::= STATE_WINDOW NK_LP column_reference NK_RP */ + { 251, -6 }, /* (305) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ + { 251, -8 }, /* (306) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ + { 217, 0 }, /* (307) sliding_opt ::= */ + { 217, -4 }, /* (308) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ + { 256, 0 }, /* (309) fill_opt ::= */ + { 256, -4 }, /* (310) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + { 256, -6 }, /* (311) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ + { 257, -1 }, /* (312) fill_mode ::= NONE */ + { 257, -1 }, /* (313) fill_mode ::= PREV */ + { 257, -1 }, /* (314) fill_mode ::= NULL */ + { 257, -1 }, /* (315) fill_mode ::= LINEAR */ + { 257, -1 }, /* (316) fill_mode ::= NEXT */ + { 252, 0 }, /* (317) group_by_clause_opt ::= */ + { 252, -3 }, /* (318) group_by_clause_opt ::= GROUP BY group_by_list */ + { 258, -1 }, /* (319) group_by_list ::= expression */ + { 258, -3 }, /* (320) group_by_list ::= group_by_list NK_COMMA expression */ + { 253, 0 }, /* (321) having_clause_opt ::= */ + { 253, -2 }, /* (322) having_clause_opt ::= HAVING search_condition */ + { 221, -4 }, /* (323) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + { 259, -1 }, /* (324) query_expression_body ::= query_primary */ + { 259, -4 }, /* (325) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ + { 263, -1 }, /* (326) query_primary ::= query_specification */ + { 260, 0 }, /* (327) order_by_clause_opt ::= */ + { 260, -3 }, /* (328) order_by_clause_opt ::= ORDER BY sort_specification_list */ + { 261, 0 }, /* (329) slimit_clause_opt ::= */ + { 261, -2 }, /* (330) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + { 261, -4 }, /* (331) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + { 261, -4 }, /* (332) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 262, 0 }, /* (333) limit_clause_opt ::= */ + { 262, -2 }, /* (334) limit_clause_opt ::= LIMIT NK_INTEGER */ + { 262, -4 }, /* (335) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + { 262, -4 }, /* (336) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 229, -3 }, /* (337) subquery ::= NK_LP query_expression NK_RP */ + { 245, -1 }, /* (338) search_condition ::= common_expression */ + { 264, -1 }, /* (339) sort_specification_list ::= sort_specification */ + { 264, -3 }, /* (340) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + { 265, -3 }, /* (341) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ + { 266, 0 }, /* (342) ordering_specification_opt ::= */ + { 266, -1 }, /* (343) ordering_specification_opt ::= ASC */ + { 266, -1 }, /* (344) ordering_specification_opt ::= DESC */ + { 267, 0 }, /* (345) null_ordering_opt ::= */ + { 267, -2 }, /* (346) null_ordering_opt ::= NULLS FIRST */ + { 267, -2 }, /* (347) null_ordering_opt ::= NULLS LAST */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -2421,15 +2423,15 @@ static YYACTIONTYPE yy_reduce( case 36: /* dnode_endpoint ::= NK_STRING */ case 37: /* dnode_host_name ::= NK_ID */ yytestcase(yyruleno==37); case 38: /* dnode_host_name ::= NK_IPTOKEN */ yytestcase(yyruleno==38); - case 206: /* db_name ::= NK_ID */ yytestcase(yyruleno==206); - case 207: /* table_name ::= NK_ID */ yytestcase(yyruleno==207); - case 208: /* column_name ::= NK_ID */ yytestcase(yyruleno==208); - case 209: /* function_name ::= NK_ID */ yytestcase(yyruleno==209); - case 210: /* table_alias ::= NK_ID */ yytestcase(yyruleno==210); - case 211: /* column_alias ::= NK_ID */ yytestcase(yyruleno==211); - case 212: /* user_name ::= NK_ID */ yytestcase(yyruleno==212); - case 213: /* index_name ::= NK_ID */ yytestcase(yyruleno==213); - case 214: /* topic_name ::= NK_ID */ yytestcase(yyruleno==214); + case 208: /* db_name ::= NK_ID */ yytestcase(yyruleno==208); + case 209: /* table_name ::= NK_ID */ yytestcase(yyruleno==209); + case 210: /* column_name ::= NK_ID */ yytestcase(yyruleno==210); + case 211: /* function_name ::= NK_ID */ yytestcase(yyruleno==211); + case 212: /* table_alias ::= NK_ID */ yytestcase(yyruleno==212); + case 213: /* column_alias ::= NK_ID */ yytestcase(yyruleno==213); + case 214: /* user_name ::= NK_ID */ yytestcase(yyruleno==214); + case 215: /* index_name ::= NK_ID */ yytestcase(yyruleno==215); + case 216: /* topic_name ::= NK_ID */ yytestcase(yyruleno==216); { yylhsminor.yy225 = yymsp[0].minor.yy0; } yymsp[0].minor.yy225 = yylhsminor.yy225; break; @@ -2462,7 +2464,7 @@ static YYACTIONTYPE yy_reduce( break; case 48: /* not_exists_opt ::= */ case 50: /* exists_opt ::= */ yytestcase(yyruleno==50); - case 285: /* set_quantifier_opt ::= */ yytestcase(yyruleno==285); + case 287: /* set_quantifier_opt ::= */ yytestcase(yyruleno==287); { yymsp[1].minor.yy505 = false; } break; case 49: /* exists_opt ::= IF EXISTS */ @@ -2633,9 +2635,9 @@ static YYACTIONTYPE yy_reduce( case 148: /* col_name_list ::= col_name */ yytestcase(yyruleno==148); case 170: /* func_name_list ::= func_name */ yytestcase(yyruleno==170); case 179: /* func_list ::= func */ yytestcase(yyruleno==179); - case 204: /* literal_list ::= signed_literal */ yytestcase(yyruleno==204); - case 290: /* select_sublist ::= select_item */ yytestcase(yyruleno==290); - case 337: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==337); + case 206: /* literal_list ::= signed_literal */ yytestcase(yyruleno==206); + case 292: /* select_sublist ::= select_item */ yytestcase(yyruleno==292); + case 339: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==339); { yylhsminor.yy512 = createNodeList(pCxt, yymsp[0].minor.yy176); } yymsp[0].minor.yy512 = yylhsminor.yy512; break; @@ -2654,9 +2656,9 @@ static YYACTIONTYPE yy_reduce( break; case 101: /* specific_tags_opt ::= */ case 132: /* tags_def_opt ::= */ yytestcase(yyruleno==132); - case 298: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==298); - case 315: /* group_by_clause_opt ::= */ yytestcase(yyruleno==315); - case 325: /* order_by_clause_opt ::= */ yytestcase(yyruleno==325); + case 300: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==300); + case 317: /* group_by_clause_opt ::= */ yytestcase(yyruleno==317); + case 327: /* order_by_clause_opt ::= */ yytestcase(yyruleno==327); { yymsp[1].minor.yy512 = NULL; } break; case 102: /* specific_tags_opt ::= NK_LP col_name_list NK_RP */ @@ -2674,9 +2676,9 @@ static YYACTIONTYPE yy_reduce( case 149: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==149); case 171: /* func_name_list ::= func_name_list NK_COMMA col_name */ yytestcase(yyruleno==171); case 180: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==180); - case 205: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==205); - case 291: /* select_sublist ::= select_sublist NK_COMMA select_item */ yytestcase(yyruleno==291); - case 338: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==338); + case 207: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==207); + case 293: /* select_sublist ::= select_sublist NK_COMMA select_item */ yytestcase(yyruleno==293); + case 340: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==340); { yylhsminor.yy512 = addNodeToList(pCxt, yymsp[-2].minor.yy512, yymsp[0].minor.yy176); } yymsp[-2].minor.yy512 = yylhsminor.yy512; break; @@ -2756,7 +2758,7 @@ static YYACTIONTYPE yy_reduce( { yymsp[-5].minor.yy448 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 133: /* tags_def_opt ::= tags_def */ - case 289: /* select_list ::= select_sublist */ yytestcase(yyruleno==289); + case 291: /* select_list ::= select_sublist */ yytestcase(yyruleno==291); { yylhsminor.yy512 = yymsp[0].minor.yy512; } yymsp[0].minor.yy512 = yylhsminor.yy512; break; @@ -2861,13 +2863,13 @@ static YYACTIONTYPE yy_reduce( break; case 165: /* like_pattern_opt ::= */ case 176: /* index_options ::= */ yytestcase(yyruleno==176); - case 296: /* where_clause_opt ::= */ yytestcase(yyruleno==296); - case 300: /* twindow_clause_opt ::= */ yytestcase(yyruleno==300); - case 305: /* sliding_opt ::= */ yytestcase(yyruleno==305); - case 307: /* fill_opt ::= */ yytestcase(yyruleno==307); - case 319: /* having_clause_opt ::= */ yytestcase(yyruleno==319); - case 327: /* slimit_clause_opt ::= */ yytestcase(yyruleno==327); - case 331: /* limit_clause_opt ::= */ yytestcase(yyruleno==331); + case 298: /* where_clause_opt ::= */ yytestcase(yyruleno==298); + case 302: /* twindow_clause_opt ::= */ yytestcase(yyruleno==302); + case 307: /* sliding_opt ::= */ yytestcase(yyruleno==307); + case 309: /* fill_opt ::= */ yytestcase(yyruleno==309); + case 321: /* having_clause_opt ::= */ yytestcase(yyruleno==321); + case 329: /* slimit_clause_opt ::= */ yytestcase(yyruleno==329); + case 333: /* limit_clause_opt ::= */ yytestcase(yyruleno==333); { yymsp[1].minor.yy176 = NULL; } break; case 166: /* like_pattern_opt ::= LIKE NK_STRING */ @@ -2933,36 +2935,40 @@ static YYACTIONTYPE yy_reduce( yymsp[-1].minor.yy176 = yylhsminor.yy176; break; case 191: /* literal ::= duration_literal */ - case 199: /* signed_literal ::= signed */ yytestcase(yyruleno==199); - case 215: /* expression ::= literal */ yytestcase(yyruleno==215); - case 216: /* expression ::= pseudo_column */ yytestcase(yyruleno==216); - case 217: /* expression ::= column_reference */ yytestcase(yyruleno==217); - case 220: /* expression ::= subquery */ yytestcase(yyruleno==220); - case 259: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==259); - case 263: /* boolean_primary ::= predicate */ yytestcase(yyruleno==263); - case 265: /* common_expression ::= expression */ yytestcase(yyruleno==265); - case 266: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==266); - case 268: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==268); - case 270: /* table_reference ::= table_primary */ yytestcase(yyruleno==270); - case 271: /* table_reference ::= joined_table */ yytestcase(yyruleno==271); - case 275: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==275); - case 322: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==322); - case 324: /* query_primary ::= query_specification */ yytestcase(yyruleno==324); + case 200: /* signed_literal ::= signed */ yytestcase(yyruleno==200); + case 217: /* expression ::= literal */ yytestcase(yyruleno==217); + case 218: /* expression ::= pseudo_column */ yytestcase(yyruleno==218); + case 219: /* expression ::= column_reference */ yytestcase(yyruleno==219); + case 222: /* expression ::= subquery */ yytestcase(yyruleno==222); + case 261: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==261); + case 265: /* boolean_primary ::= predicate */ yytestcase(yyruleno==265); + case 267: /* common_expression ::= expression */ yytestcase(yyruleno==267); + case 268: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==268); + case 270: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==270); + case 272: /* table_reference ::= table_primary */ yytestcase(yyruleno==272); + case 273: /* table_reference ::= joined_table */ yytestcase(yyruleno==273); + case 277: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==277); + case 324: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==324); + case 326: /* query_primary ::= query_specification */ yytestcase(yyruleno==326); { yylhsminor.yy176 = yymsp[0].minor.yy176; } yymsp[0].minor.yy176 = yylhsminor.yy176; break; - case 192: /* duration_literal ::= NK_VARIABLE */ + case 192: /* literal ::= NULL */ +{ yylhsminor.yy176 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, NULL)); } + yymsp[0].minor.yy176 = yylhsminor.yy176; + break; + case 193: /* duration_literal ::= NK_VARIABLE */ { yylhsminor.yy176 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy176 = yylhsminor.yy176; break; - case 193: /* signed ::= NK_INTEGER */ + case 194: /* signed ::= NK_INTEGER */ { yylhsminor.yy176 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } yymsp[0].minor.yy176 = yylhsminor.yy176; break; - case 194: /* signed ::= NK_PLUS NK_INTEGER */ + case 195: /* signed ::= NK_PLUS NK_INTEGER */ { yymsp[-1].minor.yy176 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } break; - case 195: /* signed ::= NK_MINUS NK_INTEGER */ + case 196: /* signed ::= NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; @@ -2970,14 +2976,14 @@ static YYACTIONTYPE yy_reduce( } yymsp[-1].minor.yy176 = yylhsminor.yy176; break; - case 196: /* signed ::= NK_FLOAT */ + case 197: /* signed ::= NK_FLOAT */ { yylhsminor.yy176 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } yymsp[0].minor.yy176 = yylhsminor.yy176; break; - case 197: /* signed ::= NK_PLUS NK_FLOAT */ + case 198: /* signed ::= NK_PLUS NK_FLOAT */ { yymsp[-1].minor.yy176 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } break; - case 198: /* signed ::= NK_MINUS NK_FLOAT */ + case 199: /* signed ::= NK_MINUS NK_FLOAT */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; @@ -2985,50 +2991,53 @@ static YYACTIONTYPE yy_reduce( } yymsp[-1].minor.yy176 = yylhsminor.yy176; break; - case 200: /* signed_literal ::= NK_STRING */ + case 201: /* signed_literal ::= NK_STRING */ { yylhsminor.yy176 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } yymsp[0].minor.yy176 = yylhsminor.yy176; break; - case 201: /* signed_literal ::= NK_BOOL */ + case 202: /* signed_literal ::= NK_BOOL */ { yylhsminor.yy176 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } yymsp[0].minor.yy176 = yylhsminor.yy176; break; - case 202: /* signed_literal ::= TIMESTAMP NK_STRING */ + case 203: /* signed_literal ::= TIMESTAMP NK_STRING */ { yymsp[-1].minor.yy176 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; - case 203: /* signed_literal ::= duration_literal */ - case 336: /* search_condition ::= common_expression */ yytestcase(yyruleno==336); + case 204: /* signed_literal ::= duration_literal */ + case 338: /* search_condition ::= common_expression */ yytestcase(yyruleno==338); { yylhsminor.yy176 = releaseRawExprNode(pCxt, yymsp[0].minor.yy176); } yymsp[0].minor.yy176 = yylhsminor.yy176; break; - case 218: /* expression ::= function_name NK_LP expression_list NK_RP */ + case 205: /* signed_literal ::= NULL */ +{ yymsp[0].minor.yy176 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, NULL); } + break; + case 220: /* expression ::= function_name NK_LP expression_list NK_RP */ { yylhsminor.yy176 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy225, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy225, yymsp[-1].minor.yy512)); } yymsp[-3].minor.yy176 = yylhsminor.yy176; break; - case 219: /* expression ::= function_name NK_LP NK_STAR NK_RP */ + case 221: /* expression ::= function_name NK_LP NK_STAR NK_RP */ { yylhsminor.yy176 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy225, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy225, createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy0)))); } yymsp[-3].minor.yy176 = yylhsminor.yy176; break; - case 221: /* expression ::= NK_LP expression NK_RP */ - case 264: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==264); + case 223: /* expression ::= NK_LP expression NK_RP */ + case 266: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==266); { yylhsminor.yy176 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy176)); } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 222: /* expression ::= NK_PLUS expression */ + case 224: /* expression ::= NK_PLUS expression */ { SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); yylhsminor.yy176 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy176)); } yymsp[-1].minor.yy176 = yylhsminor.yy176; break; - case 223: /* expression ::= NK_MINUS expression */ + case 225: /* expression ::= NK_MINUS expression */ { SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); yylhsminor.yy176 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[0].minor.yy176), NULL)); } yymsp[-1].minor.yy176 = yylhsminor.yy176; break; - case 224: /* expression ::= expression NK_PLUS expression */ + case 226: /* expression ::= expression NK_PLUS expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy176); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); @@ -3036,7 +3045,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 225: /* expression ::= expression NK_MINUS expression */ + case 227: /* expression ::= expression NK_MINUS expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy176); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); @@ -3044,7 +3053,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 226: /* expression ::= expression NK_STAR expression */ + case 228: /* expression ::= expression NK_STAR expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy176); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); @@ -3052,7 +3061,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 227: /* expression ::= expression NK_SLASH expression */ + case 229: /* expression ::= expression NK_SLASH expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy176); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); @@ -3060,7 +3069,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 228: /* expression ::= expression NK_REM expression */ + case 230: /* expression ::= expression NK_REM expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy176); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); @@ -3068,28 +3077,28 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 229: /* expression_list ::= expression */ + case 231: /* expression_list ::= expression */ { yylhsminor.yy512 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy176)); } yymsp[0].minor.yy512 = yylhsminor.yy512; break; - case 230: /* expression_list ::= expression_list NK_COMMA expression */ + case 232: /* expression_list ::= expression_list NK_COMMA expression */ { yylhsminor.yy512 = addNodeToList(pCxt, yymsp[-2].minor.yy512, releaseRawExprNode(pCxt, yymsp[0].minor.yy176)); } yymsp[-2].minor.yy512 = yylhsminor.yy512; break; - case 231: /* column_reference ::= column_name */ + case 233: /* column_reference ::= column_name */ { yylhsminor.yy176 = createRawExprNode(pCxt, &yymsp[0].minor.yy225, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy225)); } yymsp[0].minor.yy176 = yylhsminor.yy176; break; - case 232: /* column_reference ::= table_name NK_DOT column_name */ + case 234: /* column_reference ::= table_name NK_DOT column_name */ { yylhsminor.yy176 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy225, createColumnNode(pCxt, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy225)); } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 233: /* pseudo_column ::= NK_UNDERLINE ROWTS */ - case 235: /* pseudo_column ::= NK_UNDERLINE QSTARTTS */ yytestcase(yyruleno==235); - case 236: /* pseudo_column ::= NK_UNDERLINE QENDTS */ yytestcase(yyruleno==236); - case 237: /* pseudo_column ::= NK_UNDERLINE WSTARTTS */ yytestcase(yyruleno==237); - case 238: /* pseudo_column ::= NK_UNDERLINE WENDTS */ yytestcase(yyruleno==238); - case 239: /* pseudo_column ::= NK_UNDERLINE WDURATION */ yytestcase(yyruleno==239); + case 235: /* pseudo_column ::= NK_UNDERLINE ROWTS */ + case 237: /* pseudo_column ::= NK_UNDERLINE QSTARTTS */ yytestcase(yyruleno==237); + case 238: /* pseudo_column ::= NK_UNDERLINE QENDTS */ yytestcase(yyruleno==238); + case 239: /* pseudo_column ::= NK_UNDERLINE WSTARTTS */ yytestcase(yyruleno==239); + case 240: /* pseudo_column ::= NK_UNDERLINE WENDTS */ yytestcase(yyruleno==240); + case 241: /* pseudo_column ::= NK_UNDERLINE WDURATION */ yytestcase(yyruleno==241); { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; @@ -3097,12 +3106,12 @@ static YYACTIONTYPE yy_reduce( } yymsp[-1].minor.yy176 = yylhsminor.yy176; break; - case 234: /* pseudo_column ::= TBNAME */ + case 236: /* pseudo_column ::= TBNAME */ { yylhsminor.yy176 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } yymsp[0].minor.yy176 = yylhsminor.yy176; break; - case 240: /* predicate ::= expression compare_op expression */ - case 245: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==245); + case 242: /* predicate ::= expression compare_op expression */ + case 247: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==247); { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy176); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); @@ -3110,7 +3119,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 241: /* predicate ::= expression BETWEEN expression AND expression */ + case 243: /* predicate ::= expression BETWEEN expression AND expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy176); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); @@ -3118,7 +3127,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-4].minor.yy176 = yylhsminor.yy176; break; - case 242: /* predicate ::= expression NOT BETWEEN expression AND expression */ + case 244: /* predicate ::= expression NOT BETWEEN expression AND expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy176); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); @@ -3126,68 +3135,68 @@ static YYACTIONTYPE yy_reduce( } yymsp[-5].minor.yy176 = yylhsminor.yy176; break; - case 243: /* predicate ::= expression IS NULL */ + case 245: /* predicate ::= expression IS NULL */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy176); yylhsminor.yy176 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy176), NULL)); } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 244: /* predicate ::= expression IS NOT NULL */ + case 246: /* predicate ::= expression IS NOT NULL */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy176); yylhsminor.yy176 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy176), NULL)); } yymsp[-3].minor.yy176 = yylhsminor.yy176; break; - case 246: /* compare_op ::= NK_LT */ + case 248: /* compare_op ::= NK_LT */ { yymsp[0].minor.yy404 = OP_TYPE_LOWER_THAN; } break; - case 247: /* compare_op ::= NK_GT */ + case 249: /* compare_op ::= NK_GT */ { yymsp[0].minor.yy404 = OP_TYPE_GREATER_THAN; } break; - case 248: /* compare_op ::= NK_LE */ + case 250: /* compare_op ::= NK_LE */ { yymsp[0].minor.yy404 = OP_TYPE_LOWER_EQUAL; } break; - case 249: /* compare_op ::= NK_GE */ + case 251: /* compare_op ::= NK_GE */ { yymsp[0].minor.yy404 = OP_TYPE_GREATER_EQUAL; } break; - case 250: /* compare_op ::= NK_NE */ + case 252: /* compare_op ::= NK_NE */ { yymsp[0].minor.yy404 = OP_TYPE_NOT_EQUAL; } break; - case 251: /* compare_op ::= NK_EQ */ + case 253: /* compare_op ::= NK_EQ */ { yymsp[0].minor.yy404 = OP_TYPE_EQUAL; } break; - case 252: /* compare_op ::= LIKE */ + case 254: /* compare_op ::= LIKE */ { yymsp[0].minor.yy404 = OP_TYPE_LIKE; } break; - case 253: /* compare_op ::= NOT LIKE */ + case 255: /* compare_op ::= NOT LIKE */ { yymsp[-1].minor.yy404 = OP_TYPE_NOT_LIKE; } break; - case 254: /* compare_op ::= MATCH */ + case 256: /* compare_op ::= MATCH */ { yymsp[0].minor.yy404 = OP_TYPE_MATCH; } break; - case 255: /* compare_op ::= NMATCH */ + case 257: /* compare_op ::= NMATCH */ { yymsp[0].minor.yy404 = OP_TYPE_NMATCH; } break; - case 256: /* in_op ::= IN */ + case 258: /* in_op ::= IN */ { yymsp[0].minor.yy404 = OP_TYPE_IN; } break; - case 257: /* in_op ::= NOT IN */ + case 259: /* in_op ::= NOT IN */ { yymsp[-1].minor.yy404 = OP_TYPE_NOT_IN; } break; - case 258: /* in_predicate_value ::= NK_LP expression_list NK_RP */ + case 260: /* in_predicate_value ::= NK_LP expression_list NK_RP */ { yylhsminor.yy176 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy512)); } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 260: /* boolean_value_expression ::= NOT boolean_primary */ + case 262: /* boolean_value_expression ::= NOT boolean_primary */ { SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); yylhsminor.yy176 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy176), NULL)); } yymsp[-1].minor.yy176 = yylhsminor.yy176; break; - case 261: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + case 263: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy176); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); @@ -3195,7 +3204,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 262: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + case 264: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy176); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); @@ -3203,52 +3212,52 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 267: /* from_clause ::= FROM table_reference_list */ - case 297: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==297); - case 320: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==320); + case 269: /* from_clause ::= FROM table_reference_list */ + case 299: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==299); + case 322: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==322); { yymsp[-1].minor.yy176 = yymsp[0].minor.yy176; } break; - case 269: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ + case 271: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ { yylhsminor.yy176 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy176, yymsp[0].minor.yy176, NULL); } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 272: /* table_primary ::= table_name alias_opt */ + case 274: /* table_primary ::= table_name alias_opt */ { yylhsminor.yy176 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy225, &yymsp[0].minor.yy225); } yymsp[-1].minor.yy176 = yylhsminor.yy176; break; - case 273: /* table_primary ::= db_name NK_DOT table_name alias_opt */ + case 275: /* table_primary ::= db_name NK_DOT table_name alias_opt */ { yylhsminor.yy176 = createRealTableNode(pCxt, &yymsp[-3].minor.yy225, &yymsp[-1].minor.yy225, &yymsp[0].minor.yy225); } yymsp[-3].minor.yy176 = yylhsminor.yy176; break; - case 274: /* table_primary ::= subquery alias_opt */ + case 276: /* table_primary ::= subquery alias_opt */ { yylhsminor.yy176 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy176), &yymsp[0].minor.yy225); } yymsp[-1].minor.yy176 = yylhsminor.yy176; break; - case 276: /* alias_opt ::= */ + case 278: /* alias_opt ::= */ { yymsp[1].minor.yy225 = nil_token; } break; - case 277: /* alias_opt ::= table_alias */ + case 279: /* alias_opt ::= table_alias */ { yylhsminor.yy225 = yymsp[0].minor.yy225; } yymsp[0].minor.yy225 = yylhsminor.yy225; break; - case 278: /* alias_opt ::= AS table_alias */ + case 280: /* alias_opt ::= AS table_alias */ { yymsp[-1].minor.yy225 = yymsp[0].minor.yy225; } break; - case 279: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - case 280: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==280); + case 281: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + case 282: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==282); { yymsp[-2].minor.yy176 = yymsp[-1].minor.yy176; } break; - case 281: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + case 283: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ { yylhsminor.yy176 = createJoinTableNode(pCxt, yymsp[-4].minor.yy236, yymsp[-5].minor.yy176, yymsp[-2].minor.yy176, yymsp[0].minor.yy176); } yymsp[-5].minor.yy176 = yylhsminor.yy176; break; - case 282: /* join_type ::= */ + case 284: /* join_type ::= */ { yymsp[1].minor.yy236 = JOIN_TYPE_INNER; } break; - case 283: /* join_type ::= INNER */ + case 285: /* join_type ::= INNER */ { yymsp[0].minor.yy236 = JOIN_TYPE_INNER; } break; - case 284: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + case 286: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause where_clause_opt partition_by_clause_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ { yymsp[-8].minor.yy176 = createSelectStmt(pCxt, yymsp[-7].minor.yy505, yymsp[-6].minor.yy512, yymsp[-5].minor.yy176); yymsp[-8].minor.yy176 = addWhereClause(pCxt, yymsp[-8].minor.yy176, yymsp[-4].minor.yy176); @@ -3258,84 +3267,84 @@ static YYACTIONTYPE yy_reduce( yymsp[-8].minor.yy176 = addHavingClause(pCxt, yymsp[-8].minor.yy176, yymsp[0].minor.yy176); } break; - case 286: /* set_quantifier_opt ::= DISTINCT */ + case 288: /* set_quantifier_opt ::= DISTINCT */ { yymsp[0].minor.yy505 = true; } break; - case 287: /* set_quantifier_opt ::= ALL */ + case 289: /* set_quantifier_opt ::= ALL */ { yymsp[0].minor.yy505 = false; } break; - case 288: /* select_list ::= NK_STAR */ + case 290: /* select_list ::= NK_STAR */ { yymsp[0].minor.yy512 = NULL; } break; - case 292: /* select_item ::= common_expression */ + case 294: /* select_item ::= common_expression */ { SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy176); yylhsminor.yy176 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy176), &t); } yymsp[0].minor.yy176 = yylhsminor.yy176; break; - case 293: /* select_item ::= common_expression column_alias */ + case 295: /* select_item ::= common_expression column_alias */ { yylhsminor.yy176 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy176), &yymsp[0].minor.yy225); } yymsp[-1].minor.yy176 = yylhsminor.yy176; break; - case 294: /* select_item ::= common_expression AS column_alias */ + case 296: /* select_item ::= common_expression AS column_alias */ { yylhsminor.yy176 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy176), &yymsp[0].minor.yy225); } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 295: /* select_item ::= table_name NK_DOT NK_STAR */ + case 297: /* select_item ::= table_name NK_DOT NK_STAR */ { yylhsminor.yy176 = createColumnNode(pCxt, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 299: /* partition_by_clause_opt ::= PARTITION BY expression_list */ - case 316: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==316); - case 326: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==326); + case 301: /* partition_by_clause_opt ::= PARTITION BY expression_list */ + case 318: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==318); + case 328: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==328); { yymsp[-2].minor.yy512 = yymsp[0].minor.yy512; } break; - case 301: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ + case 303: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ { yymsp[-5].minor.yy176 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy176), releaseRawExprNode(pCxt, yymsp[-1].minor.yy176)); } break; - case 302: /* twindow_clause_opt ::= STATE_WINDOW NK_LP column_reference NK_RP */ + case 304: /* twindow_clause_opt ::= STATE_WINDOW NK_LP column_reference NK_RP */ { yymsp[-3].minor.yy176 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy176)); } break; - case 303: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ + case 305: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ { yymsp[-5].minor.yy176 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy176), NULL, yymsp[-1].minor.yy176, yymsp[0].minor.yy176); } break; - case 304: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ + case 306: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ { yymsp[-7].minor.yy176 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy176), releaseRawExprNode(pCxt, yymsp[-3].minor.yy176), yymsp[-1].minor.yy176, yymsp[0].minor.yy176); } break; - case 306: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ + case 308: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ { yymsp[-3].minor.yy176 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy176); } break; - case 308: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ + case 310: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ { yymsp[-3].minor.yy176 = createFillNode(pCxt, yymsp[-1].minor.yy142, NULL); } break; - case 309: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ + case 311: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ { yymsp[-5].minor.yy176 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy512)); } break; - case 310: /* fill_mode ::= NONE */ + case 312: /* fill_mode ::= NONE */ { yymsp[0].minor.yy142 = FILL_MODE_NONE; } break; - case 311: /* fill_mode ::= PREV */ + case 313: /* fill_mode ::= PREV */ { yymsp[0].minor.yy142 = FILL_MODE_PREV; } break; - case 312: /* fill_mode ::= NULL */ + case 314: /* fill_mode ::= NULL */ { yymsp[0].minor.yy142 = FILL_MODE_NULL; } break; - case 313: /* fill_mode ::= LINEAR */ + case 315: /* fill_mode ::= LINEAR */ { yymsp[0].minor.yy142 = FILL_MODE_LINEAR; } break; - case 314: /* fill_mode ::= NEXT */ + case 316: /* fill_mode ::= NEXT */ { yymsp[0].minor.yy142 = FILL_MODE_NEXT; } break; - case 317: /* group_by_list ::= expression */ + case 319: /* group_by_list ::= expression */ { yylhsminor.yy512 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy176))); } yymsp[0].minor.yy512 = yylhsminor.yy512; break; - case 318: /* group_by_list ::= group_by_list NK_COMMA expression */ + case 320: /* group_by_list ::= group_by_list NK_COMMA expression */ { yylhsminor.yy512 = addNodeToList(pCxt, yymsp[-2].minor.yy512, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy176))); } yymsp[-2].minor.yy512 = yylhsminor.yy512; break; - case 321: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + case 323: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ { yylhsminor.yy176 = addOrderByClause(pCxt, yymsp[-3].minor.yy176, yymsp[-2].minor.yy512); yylhsminor.yy176 = addSlimitClause(pCxt, yylhsminor.yy176, yymsp[-1].minor.yy176); @@ -3343,46 +3352,46 @@ static YYACTIONTYPE yy_reduce( } yymsp[-3].minor.yy176 = yylhsminor.yy176; break; - case 323: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */ + case 325: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */ { yylhsminor.yy176 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy176, yymsp[0].minor.yy176); } yymsp[-3].minor.yy176 = yylhsminor.yy176; break; - case 328: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ - case 332: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==332); + case 330: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ + case 334: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==334); { yymsp[-1].minor.yy176 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } break; - case 329: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 333: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==333); + case 331: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 335: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==335); { yymsp[-3].minor.yy176 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } break; - case 330: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 334: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==334); + case 332: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 336: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==336); { yymsp[-3].minor.yy176 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } break; - case 335: /* subquery ::= NK_LP query_expression NK_RP */ + case 337: /* subquery ::= NK_LP query_expression NK_RP */ { yylhsminor.yy176 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy176); } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 339: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */ + case 341: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */ { yylhsminor.yy176 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy176), yymsp[-1].minor.yy106, yymsp[0].minor.yy465); } yymsp[-2].minor.yy176 = yylhsminor.yy176; break; - case 340: /* ordering_specification_opt ::= */ + case 342: /* ordering_specification_opt ::= */ { yymsp[1].minor.yy106 = ORDER_ASC; } break; - case 341: /* ordering_specification_opt ::= ASC */ + case 343: /* ordering_specification_opt ::= ASC */ { yymsp[0].minor.yy106 = ORDER_ASC; } break; - case 342: /* ordering_specification_opt ::= DESC */ + case 344: /* ordering_specification_opt ::= DESC */ { yymsp[0].minor.yy106 = ORDER_DESC; } break; - case 343: /* null_ordering_opt ::= */ + case 345: /* null_ordering_opt ::= */ { yymsp[1].minor.yy465 = NULL_ORDER_DEFAULT; } break; - case 344: /* null_ordering_opt ::= NULLS FIRST */ + case 346: /* null_ordering_opt ::= NULLS FIRST */ { yymsp[-1].minor.yy465 = NULL_ORDER_FIRST; } break; - case 345: /* null_ordering_opt ::= NULLS LAST */ + case 347: /* null_ordering_opt ::= NULLS LAST */ { yymsp[-1].minor.yy465 = NULL_ORDER_LAST; } break; default: diff --git a/source/libs/parser/test/parserAstTest.cpp b/source/libs/parser/test/parserAstTest.cpp index 88708ef369..87f20e8d25 100644 --- a/source/libs/parser/test/parserAstTest.cpp +++ b/source/libs/parser/test/parserAstTest.cpp @@ -487,7 +487,10 @@ TEST_F(ParserTest, createTable) { bind("create table " "if not exists test.t1 using test.st1 (tag1, tag2) tags(1, 'abc') " "if not exists test.t2 using test.st1 (tag1, tag2) tags(2, 'abc') " - "if not exists test.t3 using test.st1 (tag1, tag2) tags(3, 'abc')" + "if not exists test.t3 using test.st1 (tag1, tag2) tags(3, 'abc') " + "if not exists test.t4 using test.st1 (tag1, tag2) tags(3, null) " + "if not exists test.t5 using test.st1 (tag1, tag2) tags(null, 'abc') " + "if not exists test.t6 using test.st1 (tag1, tag2) tags(null, null)" ); ASSERT_TRUE(run()); diff --git a/source/libs/qworker/inc/qworkerMsg.h b/source/libs/qworker/inc/qworkerMsg.h index 2ccd255909..313b9459e2 100644 --- a/source/libs/qworker/inc/qworkerMsg.h +++ b/source/libs/qworker/inc/qworkerMsg.h @@ -30,18 +30,18 @@ int32_t qwProcessFetch(QW_FPARAMS_DEF, SQWMsg *qwMsg); int32_t qwProcessDrop(QW_FPARAMS_DEF, SQWMsg *qwMsg); int32_t qwProcessHb(SQWorkerMgmt *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req); -int32_t qwBuildAndSendDropRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t code); -int32_t qwBuildAndSendCancelRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t code); -int32_t qwBuildAndSendFetchRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, SRetrieveTableRsp *pRsp, int32_t dataLength, +int32_t qwBuildAndSendDropRsp(SQWConnInfo *pConn, int32_t code); +int32_t qwBuildAndSendCancelRsp(SQWConnInfo *pConn, int32_t code); +int32_t qwBuildAndSendFetchRsp(SQWConnInfo *pConn, SRetrieveTableRsp *pRsp, int32_t dataLength, int32_t code); void qwBuildFetchRsp(void *msg, SOutputData *input, int32_t len, bool qComplete); int32_t qwBuildAndSendCQueryMsg(QW_FPARAMS_DEF, SQWConnInfo *pConn); -int32_t qwBuildAndSendReadyRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t code); -int32_t qwBuildAndSendQueryRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t code); +int32_t qwBuildAndSendReadyRsp(SQWConnInfo *pConn, int32_t code); +int32_t qwBuildAndSendQueryRsp(SQWConnInfo *pConn, int32_t code); void qwFreeFetchRsp(void *msg); int32_t qwMallocFetchRsp(int32_t length, SRetrieveTableRsp **rsp); int32_t qwGetSchTasksStatus(SQWorkerMgmt *mgmt, uint64_t sId, SSchedulerStatusRsp **rsp); -int32_t qwBuildAndSendHbRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, SSchedulerHbRsp *rsp, int32_t code); +int32_t qwBuildAndSendHbRsp(SQWConnInfo *pConn, SSchedulerHbRsp *rsp, int32_t code); int32_t qwRegisterBrokenLinkArg(QW_FPARAMS_DEF, SQWConnInfo *pConn); #ifdef __cplusplus diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c index 133a80b154..34159a1355 100644 --- a/source/libs/qworker/src/qworker.c +++ b/source/libs/qworker/src/qworker.c @@ -432,7 +432,7 @@ int32_t qwKillTaskHandle(QW_FPARAMS_DEF, SQWTaskCtx *ctx) { void qwFreeTask(QW_FPARAMS_DEF, SQWTaskCtx *ctx) { - rpcReleaseHandle(ctx->connInfo.handle, TAOS_CONN_SERVER); + tmsgReleaseHandle(ctx->connInfo.handle, TAOS_CONN_SERVER); ctx->connInfo.handle = NULL; qwFreeTaskHandle(QW_FPARAMS(), &ctx->taskHandle); @@ -764,7 +764,7 @@ int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inpu QW_ERR_JRET(qwDropTask(QW_FPARAMS())); dropConnection = NULL; - qwBuildAndSendDropRsp(&mgmt->msgCb, &ctx->connInfo, code); + qwBuildAndSendDropRsp(&ctx->connInfo, code); QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", ctx->connInfo.handle, code, tstrerror(code)); QW_ERR_JRET(TSDB_CODE_QRY_TASK_DROPPED); @@ -802,7 +802,7 @@ int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inpu QW_ERR_JRET(qwDropTask(QW_FPARAMS())); dropConnection = NULL; - qwBuildAndSendDropRsp(&mgmt->msgCb, &ctx->connInfo, code); + qwBuildAndSendDropRsp(&ctx->connInfo, code); QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", ctx->connInfo.handle, code, tstrerror(code)); QW_ERR_JRET(TSDB_CODE_QRY_TASK_DROPPED); @@ -830,12 +830,12 @@ _return: } if (dropConnection) { - qwBuildAndSendDropRsp(&mgmt->msgCb, dropConnection, code); + qwBuildAndSendDropRsp(dropConnection, code); QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", dropConnection->handle, code, tstrerror(code)); } if (cancelConnection) { - qwBuildAndSendCancelRsp(&mgmt->msgCb, cancelConnection, code); + qwBuildAndSendCancelRsp(cancelConnection, code); QW_TASK_DLOG("cancel rsp send, handle:%p, code:%x - %s", cancelConnection->handle, code, tstrerror(code)); } @@ -886,7 +886,7 @@ int32_t qwHandlePostPhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *inp QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); } - qwBuildAndSendDropRsp(&mgmt->msgCb, &ctx->connInfo, code); + qwBuildAndSendDropRsp(&ctx->connInfo, code); QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", ctx->connInfo.handle, code, tstrerror(code)); QW_ERR_JRET(qwDropTask(QW_FPARAMS())); @@ -918,7 +918,7 @@ _return: } if (readyConnection) { - qwBuildAndSendReadyRsp(&mgmt->msgCb, readyConnection, code); + qwBuildAndSendReadyRsp(readyConnection, code); QW_TASK_DLOG("ready msg rsped, handle:%p, code:%x - %s", readyConnection->handle, code, tstrerror(code)); } @@ -970,7 +970,7 @@ int32_t qwProcessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg, int8_t taskType) { QW_ERR_JRET(TSDB_CODE_QRY_APP_ERROR); } - QW_ERR_JRET(qwBuildAndSendQueryRsp(&mgmt->msgCb, &qwMsg->connInfo, code)); + QW_ERR_JRET(qwBuildAndSendQueryRsp(&qwMsg->connInfo, code)); QW_TASK_DLOG("query msg rsped, handle:%p, code:%x - %s", qwMsg->connInfo.handle, code, tstrerror(code)); queryRsped = true; @@ -988,7 +988,7 @@ _return: code = qwHandlePostPhaseEvents(QW_FPARAMS(), QW_PHASE_POST_QUERY, &input, NULL); if (!queryRsped) { - qwBuildAndSendQueryRsp(&mgmt->msgCb, &qwMsg->connInfo, code); + qwBuildAndSendQueryRsp(&qwMsg->connInfo, code); QW_TASK_DLOG("query msg rsped, handle:%p, code:%x - %s", qwMsg->connInfo.handle, code, tstrerror(code)); } @@ -1051,7 +1051,7 @@ _return: } if (needRsp) { - qwBuildAndSendReadyRsp(&mgmt->msgCb, &qwMsg->connInfo, code); + qwBuildAndSendReadyRsp(&qwMsg->connInfo, code); QW_TASK_DLOG("ready msg rsped, handle:%p, code:%x - %s", qwMsg->connInfo.handle, code, tstrerror(code)); } @@ -1095,7 +1095,7 @@ int32_t qwProcessCQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg) { qwMsg->connInfo = ctx->connInfo; QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH); - qwBuildAndSendFetchRsp(&mgmt->msgCb, &qwMsg->connInfo, rsp, dataLen, code); + qwBuildAndSendFetchRsp(&qwMsg->connInfo, rsp, dataLen, code); QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code), dataLen); } else { atomic_store_8((int8_t*)&ctx->queryContinue, 1); @@ -1114,7 +1114,7 @@ _return: rsp = NULL; qwMsg->connInfo = ctx->connInfo; - qwBuildAndSendFetchRsp(&mgmt->msgCb, &qwMsg->connInfo, rsp, 0, code); + qwBuildAndSendFetchRsp(&qwMsg->connInfo, rsp, 0, code); QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code), 0); } @@ -1195,7 +1195,7 @@ _return: } if (code || rsp) { - qwBuildAndSendFetchRsp(&mgmt->msgCb, &qwMsg->connInfo, rsp, dataLen, code); + qwBuildAndSendFetchRsp(&qwMsg->connInfo, rsp, dataLen, code); QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code), dataLen); } @@ -1226,7 +1226,7 @@ int32_t qwProcessDrop(QW_FPARAMS_DEF, SQWMsg *qwMsg) { QW_ERR_JRET(qwKillTaskHandle(QW_FPARAMS(), ctx)); qwUpdateTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_DROPPING); } else if (ctx->phase > 0) { - qwBuildAndSendDropRsp(&mgmt->msgCb, &qwMsg->connInfo, code); + qwBuildAndSendDropRsp(&qwMsg->connInfo, code); QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", qwMsg->connInfo.handle, code, tstrerror(code)); QW_ERR_JRET(qwDropTask(QW_FPARAMS())); @@ -1261,7 +1261,7 @@ _return: } if (TSDB_CODE_SUCCESS != code) { - qwBuildAndSendDropRsp(&mgmt->msgCb, &qwMsg->connInfo, code); + qwBuildAndSendDropRsp(&qwMsg->connInfo, code); QW_TASK_DLOG("drop rsp send, handle:%p, code:%x - %s", qwMsg->connInfo.handle, code, tstrerror(code)); } @@ -1282,7 +1282,7 @@ int32_t qwProcessHb(SQWorkerMgmt *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req) { QW_LOCK(QW_WRITE, &sch->hbConnLock); if (sch->hbConnInfo.handle) { - rpcReleaseHandle(sch->hbConnInfo.handle, TAOS_CONN_SERVER); + tmsgReleaseHandle(sch->hbConnInfo.handle, TAOS_CONN_SERVER); } memcpy(&sch->hbConnInfo, &qwMsg->connInfo, sizeof(qwMsg->connInfo)); @@ -1297,7 +1297,7 @@ int32_t qwProcessHb(SQWorkerMgmt *mgmt, SQWMsg *qwMsg, SSchedulerHbReq *req) { _return: - qwBuildAndSendHbRsp(&mgmt->msgCb, &qwMsg->connInfo, &rsp, code); + qwBuildAndSendHbRsp(&qwMsg->connInfo, &rsp, code); QW_DLOG("hb rsp send, handle:%p, code:%x - %s", qwMsg->connInfo.handle, code, tstrerror(code)); QW_RET(TSDB_CODE_SUCCESS); @@ -1351,7 +1351,7 @@ _return: QW_UNLOCK(QW_READ, &mgmt->schLock); for (int32_t j = 0; j < i; ++j) { - qwBuildAndSendHbRsp(&mgmt->msgCb, &rspList[j].connInfo, &rspList[j].rsp, code); + qwBuildAndSendHbRsp(&rspList[j].connInfo, &rspList[j].rsp, code); QW_DLOG("hb rsp send, handle:%p, code:%x - %s, taskNum:%d", rspList[j].connInfo.handle, code, tstrerror(code), (rspList[j].rsp.taskStatus ? (int32_t)taosArrayGetSize(rspList[j].rsp.taskStatus) : 0)); tFreeSSchedulerHbRsp(&rspList[j].rsp); diff --git a/source/libs/qworker/src/qworkerMsg.c b/source/libs/qworker/src/qworkerMsg.c index 78553462b8..80ae013653 100644 --- a/source/libs/qworker/src/qworkerMsg.c +++ b/source/libs/qworker/src/qworkerMsg.c @@ -46,7 +46,7 @@ void qwFreeFetchRsp(void *msg) { } } -int32_t qwBuildAndSendQueryRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t code) { +int32_t qwBuildAndSendQueryRsp(SQWConnInfo *pConn, int32_t code) { SQueryTableRsp rsp = {.code = code}; int32_t contLen = tSerializeSQueryTableRsp(NULL, 0, &rsp); @@ -62,12 +62,12 @@ int32_t qwBuildAndSendQueryRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t .code = code, }; - tmsgSendRsp(pMsgCb, &rpcRsp); + tmsgSendRsp(&rpcRsp); return TSDB_CODE_SUCCESS; } -int32_t qwBuildAndSendReadyRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t code) { +int32_t qwBuildAndSendReadyRsp(SQWConnInfo *pConn, int32_t code) { SResReadyRsp *pRsp = (SResReadyRsp *)rpcMallocCont(sizeof(SResReadyRsp)); pRsp->code = code; @@ -80,12 +80,12 @@ int32_t qwBuildAndSendReadyRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t .code = code, }; - tmsgSendRsp(pMsgCb, &rpcRsp); + tmsgSendRsp(&rpcRsp); return TSDB_CODE_SUCCESS; } -int32_t qwBuildAndSendHbRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, SSchedulerHbRsp *pStatus, int32_t code) { +int32_t qwBuildAndSendHbRsp(SQWConnInfo *pConn, SSchedulerHbRsp *pStatus, int32_t code) { int32_t contLen = tSerializeSSchedulerHbRsp(NULL, 0, pStatus); void *pRsp = rpcMallocCont(contLen); tSerializeSSchedulerHbRsp(pRsp, contLen, pStatus); @@ -99,12 +99,12 @@ int32_t qwBuildAndSendHbRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, SScheduler .code = code, }; - tmsgSendRsp(pMsgCb, &rpcRsp); + tmsgSendRsp(&rpcRsp); return TSDB_CODE_SUCCESS; } -int32_t qwBuildAndSendFetchRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, SRetrieveTableRsp *pRsp, int32_t dataLength, int32_t code) { +int32_t qwBuildAndSendFetchRsp(SQWConnInfo *pConn, SRetrieveTableRsp *pRsp, int32_t dataLength, int32_t code) { if (NULL == pRsp) { pRsp = (SRetrieveTableRsp *)rpcMallocCont(sizeof(SRetrieveTableRsp)); memset(pRsp, 0, sizeof(SRetrieveTableRsp)); @@ -120,12 +120,12 @@ int32_t qwBuildAndSendFetchRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, SRetrie .code = code, }; - tmsgSendRsp(pMsgCb, &rpcRsp); + tmsgSendRsp(&rpcRsp); return TSDB_CODE_SUCCESS; } -int32_t qwBuildAndSendCancelRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t code) { +int32_t qwBuildAndSendCancelRsp(SQWConnInfo *pConn, int32_t code) { STaskCancelRsp *pRsp = (STaskCancelRsp *)rpcMallocCont(sizeof(STaskCancelRsp)); pRsp->code = code; @@ -138,11 +138,11 @@ int32_t qwBuildAndSendCancelRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_ .code = code, }; - tmsgSendRsp(pMsgCb, &rpcRsp); + tmsgSendRsp(&rpcRsp); return TSDB_CODE_SUCCESS; } -int32_t qwBuildAndSendDropRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t code) { +int32_t qwBuildAndSendDropRsp(SQWConnInfo *pConn, int32_t code) { STaskDropRsp *pRsp = (STaskDropRsp *)rpcMallocCont(sizeof(STaskDropRsp)); pRsp->code = code; @@ -155,11 +155,11 @@ int32_t qwBuildAndSendDropRsp(const SMsgCb *pMsgCb, SQWConnInfo *pConn, int32_t .code = code, }; - tmsgSendRsp(pMsgCb, &rpcRsp); + tmsgSendRsp(&rpcRsp); return TSDB_CODE_SUCCESS; } -int32_t qwBuildAndSendShowRsp(const SMsgCb *pMsgCb, SRpcMsg *pMsg, int32_t code) { +int32_t qwBuildAndSendShowRsp(SRpcMsg *pMsg, int32_t code) { int32_t numOfCols = 6; SVShowTablesRsp showRsp = {0}; @@ -210,11 +210,11 @@ int32_t qwBuildAndSendShowRsp(const SMsgCb *pMsgCb, SRpcMsg *pMsg, int32_t code) .code = code, }; - tmsgSendRsp(pMsgCb, &rpcMsg); + tmsgSendRsp(&rpcMsg); return TSDB_CODE_SUCCESS; } -int32_t qwBuildAndSendShowFetchRsp(const SMsgCb *pMsgCb, SRpcMsg *pMsg, SVShowTablesFetchReq* pFetchReq) { +int32_t qwBuildAndSendShowFetchRsp(SRpcMsg *pMsg, SVShowTablesFetchReq* pFetchReq) { SVShowTablesFetchRsp *pRsp = (SVShowTablesFetchRsp *)rpcMallocCont(sizeof(SVShowTablesFetchRsp)); int32_t handle = htonl(pFetchReq->id); @@ -227,7 +227,7 @@ int32_t qwBuildAndSendShowFetchRsp(const SMsgCb *pMsgCb, SRpcMsg *pMsg, SVShowTa .code = 0, }; - tmsgSendRsp(pMsgCb, &rpcMsg); + tmsgSendRsp(&rpcMsg); return TSDB_CODE_SUCCESS; } @@ -498,7 +498,7 @@ int32_t qWorkerProcessCancelMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) { _return: - QW_ERR_RET(qwBuildAndSendCancelRsp(&mgmt->msgCb, &qwMsg.connInfo, code)); + QW_ERR_RET(qwBuildAndSendCancelRsp(&qwMsg.connInfo, code)); QW_SCH_TASK_DLOG("cancel rsp send, handle:%p, code:%x - %s", qwMsg.connInfo.handle, code, tstrerror(code)); return TSDB_CODE_SUCCESS; @@ -584,11 +584,9 @@ int32_t qWorkerProcessShowMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) { return TSDB_CODE_QRY_INVALID_INPUT; } - SQWorkerMgmt *pMgmt = qWorkerMgmt; - int32_t code = 0; SVShowTablesReq *pReq = pMsg->pCont; - QW_RET(qwBuildAndSendShowRsp(&pMgmt->msgCb, pMsg, code)); + QW_RET(qwBuildAndSendShowRsp(pMsg, code)); } int32_t qWorkerProcessShowFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) { @@ -596,8 +594,6 @@ int32_t qWorkerProcessShowFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg) return TSDB_CODE_QRY_INVALID_INPUT; } - SQWorkerMgmt *pMgmt = qWorkerMgmt; - SVShowTablesFetchReq *pFetchReq = pMsg->pCont; - QW_RET(qwBuildAndSendShowFetchRsp(&pMgmt->msgCb, pMsg, pFetchReq)); + QW_RET(qwBuildAndSendShowFetchRsp(pMsg, pFetchReq)); } diff --git a/source/libs/scalar/src/sclfunc.c b/source/libs/scalar/src/sclfunc.c index feada84685..db0aa21f42 100644 --- a/source/libs/scalar/src/sclfunc.c +++ b/source/libs/scalar/src/sclfunc.c @@ -1,14 +1,9 @@ -#include "sclfunc.h" -#include +#include "function.h" +#include "scalar.h" +#include "tdatablock.h" #include "sclInt.h" #include "sclvector.h" -static void assignBasicParaInfo(struct SScalarParam* dst, const struct SScalarParam* src) { -// dst->type = src->type; -// dst->bytes = src->bytes; -// dst->num = src->num; -} - /** Math functions **/ int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { SColumnInfoData *pInputData = pInput->columnData; @@ -107,94 +102,13 @@ int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu return TSDB_CODE_SUCCESS; } -int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { -#if 0 - if (inputNum != 2 || !IS_NUMERIC_TYPE(pInput[0].type) || !IS_NUMERIC_TYPE(pInput[1].type)) { - return TSDB_CODE_FAILED; - } - - char **input = NULL, *output = NULL; - bool hasNullInput = false; - input = taosMemoryCalloc(inputNum, sizeof(char *)); - for (int32_t i = 0; i < pOutput->num; ++i) { - for (int32_t j = 0; j < inputNum; ++j) { - if (pInput[j].num == 1) { - input[j] = pInput[j].data; - } else { - input[j] = pInput[j].data + i * pInput[j].bytes; - } - if (isNull(input[j], pInput[j].type)) { - hasNullInput = true; - break; - } - } - output = pOutput->data + i * pOutput->bytes; - - if (hasNullInput) { - setNull(output, pOutput->type, pOutput->bytes); - continue; - } - - double base; - GET_TYPED_DATA(base, double, pInput[1].type, input[1]); - double v; - GET_TYPED_DATA(v, double, pInput[0].type, input[0]); - double result = log(v) / log(base); - SET_TYPED_DATA(output, pOutput->type, result); - } - - taosMemoryFree(input); -#endif - - return TSDB_CODE_SUCCESS; -} - -int32_t powFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { -#if 0 - if (inputNum != 2 || !IS_NUMERIC_TYPE(pInput[0].type) || !IS_NUMERIC_TYPE(pInput[1].type)) { - return TSDB_CODE_FAILED; - } - - pOutput->type = TSDB_DATA_TYPE_DOUBLE; - pOutput->bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes; - - char **input = NULL, *output = NULL; - bool hasNullInput = false; - input = taosMemoryCalloc(inputNum, sizeof(char *)); - for (int32_t i = 0; i < pOutput->num; ++i) { - for (int32_t j = 0; j < inputNum; ++j) { - if (pInput[j].num == 1) { - input[j] = pInput[j].data; - } else { - input[j] = pInput[j].data + i * pInput[j].bytes; - } - if (isNull(input[j], pInput[j].type)) { - hasNullInput = true; - break; - } - } - output = pOutput->data + i * pOutput->bytes; - - if (hasNullInput) { - setNull(output, pOutput->type, pOutput->bytes); - continue; - } - - double base; - GET_TYPED_DATA(base, double, pInput[1].type, input[1]); - double v; - GET_TYPED_DATA(v, double, pInput[0].type, input[0]); - double result = pow(v, base); - SET_TYPED_DATA(output, pOutput->type, result); - } - - taosMemoryFree(input); -#endif - return TSDB_CODE_SUCCESS; -} - typedef float (*_float_fn)(float); typedef double (*_double_fn)(double); +typedef double (*_double_fn_2)(double, double); + +double tlog(double v, double base) { + return log(v) / log(base); +} int32_t doScalarFunctionUnique(SScalarParam *pInput, int32_t inputNum, SScalarParam* pOutput, _double_fn valFn) { int32_t type = GET_PARAM_TYPE(pInput); @@ -221,6 +135,35 @@ int32_t doScalarFunctionUnique(SScalarParam *pInput, int32_t inputNum, SScalarPa return TSDB_CODE_SUCCESS; } +int32_t doScalarFunctionUnique2(SScalarParam *pInput, int32_t inputNum, SScalarParam* pOutput, _double_fn_2 valFn) { + if (inputNum != 2 || !IS_NUMERIC_TYPE(GET_PARAM_TYPE(&pInput[0])) || !IS_NUMERIC_TYPE(GET_PARAM_TYPE(&pInput[1]))) { + return TSDB_CODE_FAILED; + } + + SColumnInfoData *pInputData[2]; + SColumnInfoData *pOutputData = pOutput->columnData; + _getDoubleValue_fn_t getValueFn[2]; + + for (int32_t i = 0; i < inputNum; ++i) { + pInputData[i] = pInput[i].columnData; + getValueFn[i]= getVectorDoubleValueFn(GET_PARAM_TYPE(&pInput[i])); + } + + double *out = (double *)pOutputData->pData; + + for (int32_t i = 0; i < pInput->numOfRows; ++i) { + if (colDataIsNull_f(pInputData[0]->nullbitmap, i) || + colDataIsNull_f(pInputData[1]->nullbitmap, 0)) { + colDataSetNull_f(pOutputData->nullbitmap, i); + continue; + } + out[i] = valFn(getValueFn[0](pInputData[0]->pData, i), getValueFn[1](pInputData[1]->pData, 0)); + } + + pOutput->numOfRows = pInput->numOfRows; + return TSDB_CODE_SUCCESS; +} + int32_t doScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam* pOutput, _float_fn f1, _double_fn d1) { int32_t type = GET_PARAM_TYPE(pInput); if (inputNum != 1 || !IS_NUMERIC_TYPE(type)) { @@ -292,6 +235,14 @@ int32_t acosFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp return doScalarFunctionUnique(pInput, inputNum, pOutput, acos); } +int32_t powFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + return doScalarFunctionUnique2(pInput, inputNum, pOutput, pow); +} + +int32_t logFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { + return doScalarFunctionUnique2(pInput, inputNum, pOutput, tlog); +} + int32_t sqrtFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { return doScalarFunctionUnique(pInput, inputNum, pOutput, sqrt); } diff --git a/source/libs/scalar/test/scalar/scalarTests.cpp b/source/libs/scalar/test/scalar/scalarTests.cpp index b3211babf1..153222516c 100644 --- a/source/libs/scalar/test/scalar/scalarTests.cpp +++ b/source/libs/scalar/test/scalar/scalarTests.cpp @@ -2833,11 +2833,11 @@ TEST(ScalarFunctionTest, logFunction_column) { int32_t rowNum = 3; int32_t type; int32_t otype = TSDB_DATA_TYPE_DOUBLE; - double result[] = {2.0, 4.0, 3.0}; + double result[] = {2.0, 3.0, 4.0}; pInput = (SScalarParam *)taosMemoryCalloc(2, sizeof(SScalarParam)); //TINYINT - int8_t val_tinyint[2][3] = {{25, 81, 64}, {5, 3, 4}}; + int8_t val_tinyint[2][3] = {{9, 27, 81}, {3, 3, 3}}; type = TSDB_DATA_TYPE_TINYINT; for (int32_t i = 0; i < 2; ++i) { scltMakeDataBlock(&input[i], type, 0, rowNum, false); @@ -2863,7 +2863,7 @@ TEST(ScalarFunctionTest, logFunction_column) { scltDestroyDataBlock(pOutput); //FLOAT - float val_float[2][3] = {{25.0, 81.0, 64.0}, {5.0, 3.0, 4.0}}; + float val_float[2][3] = {{9.0, 27.0, 81.0}, {3.0, 3.0, 3.0}}; type = TSDB_DATA_TYPE_FLOAT; for (int32_t i = 0; i < 2; ++i) { scltMakeDataBlock(&input[i], type, 0, rowNum, false); @@ -2888,8 +2888,8 @@ TEST(ScalarFunctionTest, logFunction_column) { scltDestroyDataBlock(pOutput); //TINYINT AND FLOAT - int8_t param0[] = {25, 81, 64}; - float param1[] = {5.0, 3.0, 4.0}; + int8_t param0[] = {9, 27, 81}; + float param1[] = {3.0, 3.0, 3.0}; scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, 0, rowNum, false); pInput[0] = *input[0]; for (int32_t i = 0; i < rowNum; ++i) { @@ -3003,17 +3003,17 @@ TEST(ScalarFunctionTest, powFunction_column) { int32_t rowNum = 3; int32_t type; int32_t otype = TSDB_DATA_TYPE_DOUBLE; - double result[] = {32.0, 27.0, 16.0}; + double result[] = {8.0, 27.0, 64.0}; pInput = (SScalarParam *)taosMemoryCalloc(2, sizeof(SScalarParam)); //TINYINT - int8_t val_tinyint[2][3] = {{2, 3, 4}, {5, 3, 2}}; + int8_t val_tinyint[2][3] = {{2, 3, 4}, {3, 3, 3}}; type = TSDB_DATA_TYPE_TINYINT; for (int32_t i = 0; i < 2; ++i) { scltMakeDataBlock(&input[i], type, 0, rowNum, false); pInput[i] = *input[i]; for (int32_t j = 0; j < rowNum; ++j) { - colDataAppend(pInput[i].columnData, i, (const char*) &val_tinyint[i][j], false); + colDataAppend(pInput[i].columnData, j, (const char*) &val_tinyint[i][j], false); } PRINTF("tiny_int before POW:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0), @@ -3034,7 +3034,7 @@ TEST(ScalarFunctionTest, powFunction_column) { scltDestroyDataBlock(pOutput); //FLOAT - float val_float[2][3] = {{2.0, 3.0, 4.0}, {5.0, 3.0, 2.0}}; + float val_float[2][3] = {{2.0, 3.0, 4.0}, {3.0, 3.0, 3.0}}; type = TSDB_DATA_TYPE_FLOAT; for (int32_t i = 0; i < 2; ++i) { scltMakeDataBlock(&input[i], type, 0, rowNum, false); @@ -3060,7 +3060,7 @@ TEST(ScalarFunctionTest, powFunction_column) { //TINYINT AND FLOAT int8_t param0[] = {2, 3, 4}; - float param1[] = {5.0, 3.0, 2.0}; + float param1[] = {3.0, 3.0, 2.0}; scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, 0, rowNum, false); pInput[0] = *input[0]; for (int32_t i = 0; i < rowNum; ++i) { diff --git a/source/libs/stream/src/tstream.c b/source/libs/stream/src/tstream.c index c5189637ac..fb6c0f6c12 100644 --- a/source/libs/stream/src/tstream.c +++ b/source/libs/stream/src/tstream.c @@ -124,22 +124,23 @@ int32_t streamExecTask(SStreamTask* pTask, SMsgCb* pMsgCb, const void* input, in } } else if (inputType == STREAM_DATA_TYPE_SSDATA_BLOCK) { const SArray* blocks = (const SArray*)input; - int32_t sz = taosArrayGetSize(blocks); - for (int32_t i = 0; i < sz; i++) { - SSDataBlock* pBlock = taosArrayGet(blocks, i); - qSetStreamInput(exec, pBlock, inputType); - while (1) { - SSDataBlock* output; - uint64_t ts; - if (qExecTask(exec, &output, &ts) < 0) { - ASSERT(false); - } - if (output == NULL) { - break; - } - taosArrayPush(pRes, output); + /*int32_t sz = taosArrayGetSize(blocks);*/ + /*for (int32_t i = 0; i < sz; i++) {*/ + /*SSDataBlock* pBlock = taosArrayGet(blocks, i);*/ + /*qSetStreamInput(exec, pBlock, inputType);*/ + qSetMultiStreamInput(exec, blocks->pData, blocks->size, STREAM_DATA_TYPE_SSDATA_BLOCK); + while (1) { + SSDataBlock* output; + uint64_t ts; + if (qExecTask(exec, &output, &ts) < 0) { + ASSERT(false); } + if (output == NULL) { + break; + } + taosArrayPush(pRes, output); } + /*}*/ } else { ASSERT(0); } diff --git a/source/util/src/tprocess.c b/source/util/src/tprocess.c index 2675c6cdf2..86cec2d271 100644 --- a/source/util/src/tprocess.c +++ b/source/util/src/tprocess.c @@ -19,10 +19,6 @@ #include "tlog.h" #include "tqueue.h" -// todo -#include -#include - #define SHM_DEFAULT_SIZE (20 * 1024 * 1024) typedef void *(*ProcThreadFp)(void *param); @@ -208,16 +204,11 @@ static void taosProcCleanupQueue(SProcQueue *pQueue) { } static int32_t taosProcQueuePush(SProcQueue *pQueue, const char *pHead, int16_t rawHeadLen, const char *pBody, - int32_t rawBodyLen, ProcFuncType funcType) { + int32_t rawBodyLen, ProcFuncType ftype) { const int32_t headLen = CEIL8(rawHeadLen); const int32_t bodyLen = CEIL8(rawBodyLen); const int32_t fullLen = headLen + bodyLen + 8; - if (headLen <= 0 || bodyLen <= 0) { - terrno = TSDB_CODE_INVALID_PARA; - return -1; - } - taosThreadMutexLock(pQueue->mutex); if (fullLen > pQueue->avail) { taosThreadMutexUnlock(pQueue->mutex); @@ -225,13 +216,14 @@ static int32_t taosProcQueuePush(SProcQueue *pQueue, const char *pHead, int16_t return -1; } + const int32_t pos = pQueue->tail; if (pQueue->tail < pQueue->total) { - *(int16_t *)(pQueue->pBuffer + pQueue->head) = headLen; - *(int8_t *)(pQueue->pBuffer + pQueue->head + 2) = (int8_t)funcType; - *(int32_t *)(pQueue->pBuffer + pQueue->head + 4) = bodyLen; + *(int16_t *)(pQueue->pBuffer + pQueue->tail) = headLen; + *(int8_t *)(pQueue->pBuffer + pQueue->tail + 2) = (int8_t)ftype; + *(int32_t *)(pQueue->pBuffer + pQueue->tail + 4) = bodyLen; } else { *(int16_t *)(pQueue->pBuffer) = headLen; - *(int8_t *)(pQueue->pBuffer + pQueue->head + 2) = (int8_t)funcType; + *(int8_t *)(pQueue->pBuffer + 2) = (int8_t)ftype; *(int32_t *)(pQueue->pBuffer + 4) = bodyLen; } @@ -250,19 +242,19 @@ static int32_t taosProcQueuePush(SProcQueue *pQueue, const char *pHead, int16_t memcpy(pQueue->pBuffer + headLen, pBody, rawBodyLen); pQueue->tail = headLen + bodyLen; } else if (remain < 8 + headLen) { - memcpy(pQueue->pBuffer + pQueue->head + 8, pHead, remain - 8); + memcpy(pQueue->pBuffer + pQueue->tail + 8, pHead, remain - 8); memcpy(pQueue->pBuffer, pHead + remain - 8, rawHeadLen - (remain - 8)); memcpy(pQueue->pBuffer + headLen - (remain - 8), pBody, rawBodyLen); pQueue->tail = headLen - (remain - 8) + bodyLen; - } else if (remain < 8 + bodyLen) { - memcpy(pQueue->pBuffer + pQueue->head + 8, pHead, rawHeadLen); - memcpy(pQueue->pBuffer + pQueue->head + 8 + headLen, pBody, remain - 8 - headLen); + } else if (remain < 8 + headLen + bodyLen) { + memcpy(pQueue->pBuffer + pQueue->tail + 8, pHead, rawHeadLen); + memcpy(pQueue->pBuffer + pQueue->tail + 8 + headLen, pBody, remain - 8 - headLen); memcpy(pQueue->pBuffer, pBody + remain - 8 - headLen, rawBodyLen - (remain - 8 - headLen)); pQueue->tail = bodyLen - (remain - 8 - headLen); } else { - memcpy(pQueue->pBuffer + pQueue->head + 8, pHead, rawHeadLen); - memcpy(pQueue->pBuffer + pQueue->head + headLen + 8, pBody, rawBodyLen); - pQueue->tail = pQueue->head + headLen + bodyLen + 8; + memcpy(pQueue->pBuffer + pQueue->tail + 8, pHead, rawHeadLen); + memcpy(pQueue->pBuffer + pQueue->tail + headLen + 8, pBody, rawBodyLen); + pQueue->tail = pQueue->tail + headLen + bodyLen + 8; } } @@ -271,8 +263,8 @@ static int32_t taosProcQueuePush(SProcQueue *pQueue, const char *pHead, int16_t taosThreadMutexUnlock(pQueue->mutex); tsem_post(&pQueue->sem); - uTrace("proc:%s, push msg to queue:%p remains:%d, head:%d:%p body:%d:%p ftype:%d", pQueue->name, pQueue, pQueue->items, - headLen, pHead, bodyLen, pBody, funcType); + uTrace("proc:%s, push msg at pos:%d ftype:%d remain:%d, head:%d %p body:%d %p", pQueue->name, pos, ftype, + pQueue->items, headLen, pHead, bodyLen, pBody); return 0; } @@ -312,6 +304,7 @@ static int32_t taosProcQueuePop(SProcQueue *pQueue, void **ppHead, int16_t *pHea return -1; } + const int32_t pos = pQueue->head; if (pQueue->head < pQueue->tail) { memcpy(pHead, pQueue->pBuffer + pQueue->head + 8, headLen); memcpy(pBody, pQueue->pBuffer + pQueue->head + 8 + headLen, bodyLen); @@ -331,7 +324,7 @@ static int32_t taosProcQueuePop(SProcQueue *pQueue, void **ppHead, int16_t *pHea memcpy(pHead + remain - 8, pQueue->pBuffer, headLen - (remain - 8)); memcpy(pBody, pQueue->pBuffer + headLen - (remain - 8), bodyLen); pQueue->head = headLen - (remain - 8) + bodyLen; - } else if (remain < 8 + bodyLen) { + } else if (remain < 8 + headLen + bodyLen) { memcpy(pHead, pQueue->pBuffer + pQueue->head + 8, headLen); memcpy(pBody, pQueue->pBuffer + pQueue->head + 8 + headLen, remain - 8 - headLen); memcpy(pBody + remain - 8 - headLen, pQueue->pBuffer, bodyLen - (remain - 8 - headLen)); @@ -353,8 +346,8 @@ static int32_t taosProcQueuePop(SProcQueue *pQueue, void **ppHead, int16_t *pHea *pBodyLen = bodyLen; *pFuncType = (ProcFuncType)ftype; - uTrace("proc:%s, pop msg from queue:%p remains:%d, head:%d:%p body:%d:%p ftype:%d", pQueue->name, pQueue, pQueue->items, - headLen, pHead, bodyLen, pBody, ftype); + uTrace("proc:%s, pop msg at pos:%d ftype:%d remain:%d, head:%d %p body:%d %p", pQueue->name, pos, ftype, + pQueue->items, headLen, pHead, bodyLen, pBody); return 1; } @@ -472,11 +465,11 @@ void taosProcCleanup(SProcObj *pProc) { } int32_t taosProcPutToChildQ(SProcObj *pProc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen, - ProcFuncType funcType) { - return taosProcQueuePush(pProc->pChildQueue, pHead, headLen, pBody, bodyLen, funcType); + ProcFuncType ftype) { + return taosProcQueuePush(pProc->pChildQueue, pHead, headLen, pBody, bodyLen, ftype); } int32_t taosProcPutToParentQ(SProcObj *pProc, const void *pHead, int16_t headLen, const void *pBody, int32_t bodyLen, - ProcFuncType funcType) { - return taosProcQueuePush(pProc->pParentQueue, pHead, headLen, pBody, bodyLen, funcType); + ProcFuncType ftype) { + return taosProcQueuePush(pProc->pParentQueue, pHead, headLen, pBody, bodyLen, ftype); } diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt index 77ee1d9de4..2cad518128 100644 --- a/tests/script/jenkins/basic.txt +++ b/tests/script/jenkins/basic.txt @@ -37,6 +37,6 @@ # ---- tmq ./test.sh -f tsim/tmq/basic.sim -#./test.sh -f tsim/tmq/basic1.sim +./test.sh -f tsim/tmq/basic1.sim #======================b1-end=============== diff --git a/tests/script/sh/deploy.sh b/tests/script/sh/deploy.sh index ea1ad65a5b..1bbfccf989 100755 --- a/tests/script/sh/deploy.sh +++ b/tests/script/sh/deploy.sh @@ -124,7 +124,7 @@ echo "firstEp ${HOSTNAME}:7100" >> $TAOS_CFG echo "secondEp ${HOSTNAME}:7200" >> $TAOS_CFG echo "fqdn ${HOSTNAME}" >> $TAOS_CFG echo "serverPort ${NODE}" >> $TAOS_CFG -echo "supportVnodes 128" >> $TAOS_CFG +echo "supportVnodes 128" >> $TAOS_CFG echo "dataDir $DATA_DIR" >> $TAOS_CFG echo "logDir $LOG_DIR" >> $TAOS_CFG echo "debugFlag 0" >> $TAOS_CFG @@ -133,20 +133,17 @@ echo "dDebugFlag 143" >> $TAOS_CFG echo "vDebugFlag 143" >> $TAOS_CFG echo "tsdbDebugFlag 143" >> $TAOS_CFG echo "cDebugFlag 143" >> $TAOS_CFG -echo "jnidebugFlag 143" >> $TAOS_CFG -echo "qdebugFlag 143" >> $TAOS_CFG +echo "jniDebugFlag 143" >> $TAOS_CFG +echo "qDebugFlag 143" >> $TAOS_CFG echo "rpcDebugFlag 143" >> $TAOS_CFG echo "tmrDebugFlag 131" >> $TAOS_CFG -echo "udebugFlag 143" >> $TAOS_CFG -echo "sdebugFlag 143" >> $TAOS_CFG -echo "wdebugFlag 143" >> $TAOS_CFG -echo "slaveQuery 0" >> $TAOS_CFG -echo "numOfThreadsPerCore 2.0" >> $TAOS_CFG -echo "defaultPass taosdata" >> $TAOS_CFG +echo "uDebugFlag 143" >> $TAOS_CFG +echo "sDebugFlag 143" >> $TAOS_CFG +echo "wDebugFlag 143" >> $TAOS_CFG echo "numOfLogLines 20000000" >> $TAOS_CFG echo "statusInterval 1" >> $TAOS_CFG echo "asyncLog 0" >> $TAOS_CFG echo "locale en_US.UTF-8" >> $TAOS_CFG -echo "fsync 0" >> $TAOS_CFG echo "telemetryReporting 0" >> $TAOS_CFG +echo "multiProcess 0" >> $TAOS_CFG echo " " >> $TAOS_CFG diff --git a/tests/script/sh/exec.sh b/tests/script/sh/exec.sh index 8d7dba2de2..1a9a6a2c52 100755 --- a/tests/script/sh/exec.sh +++ b/tests/script/sh/exec.sh @@ -74,7 +74,7 @@ BUILD_DIR=$TAOS_DIR/$BIN_DIR SIM_DIR=$TAOS_DIR/sim NODE_DIR=$SIM_DIR/$NODE_NAME -EXE_DIR=$BUILD_DIR/source/dnode/mgmt/main +EXE_DIR=$BUILD_DIR/source/dnode/mgmt CFG_DIR=$NODE_DIR/cfg LOG_DIR=$NODE_DIR/log DATA_DIR=$NODE_DIR/data diff --git a/tests/script/tsim/parser/groupby-basic.sim b/tests/script/tsim/parser/groupby-basic.sim index cbd05031df..c0cbfa8aeb 100644 --- a/tests/script/tsim/parser/groupby-basic.sim +++ b/tests/script/tsim/parser/groupby-basic.sim @@ -107,80 +107,54 @@ print rows: $rows print $data00 $data01 $data02 $data03 print $data10 $data11 $data12 $data13 print $data20 $data21 $data22 $data23 -if $row != 20 then - return -1 +print $data80 $data81 $data82 $data83 +print $data90 $data91 $data92 $data93 +if $rows != 10 then + return -1 endi - -if $data00 != 100 then - return -1 -endi - +#if $data00 != 10 then +# return -1 +#endi if $data01 != 0 then return -1 endi - -if $data10 != 100 then - return -1 -endi - +#if $data10 != 10 then +# return -1 +#endi if $data11 != 1 then return -1 endi - -sql select first(ts),c1 from group_tb0 where c1<20 group by c1; -if $row != 20 then - return -1 -endi - -if $data00 != @70-01-01 08:01:40.000@ then - return -1 -endi - -if $data01 != 0 then - return -1 -endi - -if $data90 != @70-01-01 08:01:40.009@ then - return -1 -endi - +#if $data90 != 10 then +# return -1 +#endi if $data91 != 9 then return -1 endi -sql select first(ts), ts, c1 from group_tb0 where c1 < 20 group by c1; -print $row -if $row != 20 then +sql select first(ts),c1 from group_tb0 group by c1; +print rows: $rows +print $data00 $data01 $data02 $data03 +print $data10 $data11 $data12 $data13 +print $data20 $data21 $data22 $data23 +print $data80 $data81 $data82 $data83 +print $data90 $data91 $data92 $data93 +if $row != 10 then return -1 endi -if $data00 != $data01 then +if $data00 != @2022-01-01 00:00:00.000@ then + return -1 +endi +if $data01 != 0 then + return -1 +endi +if $data90 != @2022-01-01 00:00:00.009@ then + return -1 +endi +if $data91 != 9 then return -1 endi -if $data10 != $data11 then - return -1 -endi - -if $data20 != $data21 then - return -1 -endi - -if $data90 != $data91 then - return -1 -endi - -if $data02 != 0 then - return -1 -endi - -if $data12 != 1 then - return -1 -endi - -if $data92 != 9 then - return -1 -endi sql select sum(c1), c1, avg(c1), min(c1), max(c2) from group_tb0 where c1 < 20 group by c1; if $row != 20 then diff --git a/tests/script/tsim/testCaseSuite.sim b/tests/script/tsim/testCaseSuite.sim index 2ed5e5fcf3..bf184f8794 100644 --- a/tests/script/tsim/testCaseSuite.sim +++ b/tests/script/tsim/testCaseSuite.sim @@ -26,4 +26,4 @@ run tsim/show/basic.sim run tsim/table/basic1.sim run tsim/tmq/basic.sim -#run tsim/tmq/basic1.sim +run tsim/tmq/basic1.sim diff --git a/tests/script/tsim/tmq/basic1.sim b/tests/script/tsim/tmq/basic1.sim index a91196d71f..fe6a7a0660 100644 --- a/tests/script/tsim/tmq/basic1.sim +++ b/tests/script/tsim/tmq/basic1.sim @@ -3,9 +3,10 @@ # vgroups=1, multi topics for one consumer, include: columns from stb/ctb/ntb, * from stb/ctb/ntb, Scalar function from stb/ctb/ntb # vgroups=4, one topic for one consumer, include: columns from stb/ctb/ntb, * from stb/ctb/ntb, Scalar function from stb/ctb/ntb # vgroups=4, multi topics for one consumer, include: columns from stb/ctb/ntb, * from stb/ctb/ntb, Scalar function from stb/ctb/ntb +# notes1: Scalar function: ABS/ACOS/ASIN/ATAN/CEIL/COS/FLOOR/LOG/POW/ROUND/SIN/SQRT/TAN # The above use cases are combined with where filter conditions, such as: where ts > "2017-08-12 18:25:58.128Z" and sin(a) > 0.5; # -# notes: not support aggregate functions(such as sum/count/min/max) and time-windows(interval). +# notes2: not support aggregate functions(such as sum/count/min/max) and time-windows(interval). # system sh/stop_dnodes.sh @@ -135,42 +136,42 @@ print inserted totalMsgCnt: $totalMsgCnt print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_stb_column" -k "group.id:tg2" system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_stb_column" -k "group.id:tg2" print cmd result----> $system_content -if $system_content != @{consume success: 20}@ then +if $system_content != @{consume success: 20, 0}@ then return -1 endi #print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_stb_all" -k "group.id:tg2" #system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_stb_all" -k "group.id:tg2" #print cmd result----> $system_content -#if $system_content != @{consume success: 20}@ then +#if $system_content != @{consume success: 20, 0}@ then # return -1 #endi print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ctb_column" -k "group.id:tg2" system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ctb_column" -k "group.id:tg2" print cmd result----> $system_content -if $system_content != @{consume success: 20}@ then +if $system_content != @{consume success: 10, 0}@ then return -1 endi print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ctb_all" -k "group.id:tg2" system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ctb_all" -k "group.id:tg2" print cmd result----> $system_content -if $system_content != @{consume success: 20}@ then +if $system_content != @{consume success: 10, 0}@ then return -1 endi print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ntb_column" -k "group.id:tg2" system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ntb_column" -k "group.id:tg2" print cmd result----> $system_content -if $system_content != @{consume success: 20}@ then +if $system_content != @{consume success: 20, 0}@ then return -1 endi print cmd===> system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ntb_all" -k "group.id:tg2" system_content ../../debug/tests/test/c/tmq_sim -c ../../sim/tsim/cfg -d $dbNamme -t "topic_ntb_all" -k "group.id:tg2" print cmd result----> $system_content -if $system_content != @{consume success: 20}@ then +if $system_content != @{consume success: 20, 0}@ then return -1 endi diff --git a/tests/test/c/tmqSim.c b/tests/test/c/tmqSim.c index 75542bfa71..4d3108500e 100644 --- a/tests/test/c/tmqSim.c +++ b/tests/test/c/tmqSim.c @@ -219,33 +219,33 @@ tmq_list_t* build_topic_list() { return topic_list; } -void perf_loop(tmq_t* tmq, tmq_list_t* topics) { +void loop_consume(tmq_t* tmq) { tmq_resp_err_t err; - if ((err = tmq_subscribe(tmq, topics))) { - printf("tmq_subscribe() fail, reason: %s\n", tmq_err2str(err)); - exit(-1); - } - int32_t totalMsgs = 0; + int32_t totalRows = 0; int32_t skipLogNum = 0; - //int64_t startTime = taosGetTimestampUs(); while (running) { - tmq_message_t* tmqmessage = tmq_consumer_poll(tmq, 1); - if (tmqmessage) { - totalMsgs++; - skipLogNum += tmqGetSkipLogNum(tmqmessage); - if (0 != g_stConfInfo.showMsgFlag) { - msg_process(tmqmessage); + tmq_message_t* tmqMsg = tmq_consumer_poll(tmq, 1); + if (tmqMsg) { + totalMsgs++; + + #if 0 + TAOS_ROW row; + while (NULL != (row = tmq_get_row(tmqMsg))) { + totalRows++; } - tmq_message_destroy(tmqmessage); + #endif + + skipLogNum += tmqGetSkipLogNum(tmqMsg); + if (0 != g_stConfInfo.showMsgFlag) { + msg_process(tmqMsg); + } + tmq_message_destroy(tmqMsg); } else { break; } } - //int64_t endTime = taosGetTimestampUs(); - //double consumeTime = (double)(endTime - startTime) / 1000000; - err = tmq_consumer_close(tmq); if (err) { @@ -253,7 +253,7 @@ void perf_loop(tmq_t* tmq, tmq_list_t* topics) { exit(-1); } - printf("{consume success: %d}", totalMsgs); + printf("{consume success: %d, %d}", totalMsgs, totalRows); } int main(int32_t argc, char *argv[]) { @@ -266,7 +266,21 @@ int main(int32_t argc, char *argv[]) { return -1; } - perf_loop(tmq, topic_list); + tmq_resp_err_t err = tmq_subscribe(tmq, topic_list); + if (err) { + printf("tmq_subscribe() fail, reason: %s\n", tmq_err2str(err)); + exit(-1); + } + + loop_consume(tmq); + + #if 0 + err = tmq_unsubscribe(tmq); + if (err) { + printf("tmq_unsubscribe() fail, reason: %s\n", tmq_err2str(err)); + exit(-1); + } + #endif return 0; }