diff --git a/docs/zh/14-reference/03-taos-sql/03-table.md b/docs/zh/14-reference/03-taos-sql/03-table.md index 80aad0718a..2f0ae7100a 100644 --- a/docs/zh/14-reference/03-taos-sql/03-table.md +++ b/docs/zh/14-reference/03-taos-sql/03-table.md @@ -41,15 +41,13 @@ table_option: { **使用说明** +1. 表（列）名命名规则参见[名称命名规则](./19-limit.md#名称命名规则)。 +1. 表名最大长度为 192。 1. 表的第一个字段必须是 TIMESTAMP，并且系统自动将其设为主键。 -2. 除时间戳主键列之外，还可以通过 PRIMARY KEY 关键字指定第二列为额外的主键列。被指定为主键列的第二列必须为整型或字符串类型（varchar）。 -3. 表名最大长度为 192。 -4. 表的每行长度不能超过 48KB（从 3.0.5.0 版本开始为 64KB）;（注意：每个 BINARY/NCHAR/GEOMETRY 类型的列还会额外占用 2 个字节的存储位置）。 -5. 子表名只能由字母、数字和下划线组成，且不能以数字开头，不区分大小写。 -6. 使用数据类型 BINARY/NCHAR/GEOMETRY，需指定其最长的字节数，如 BINARY(20)，表示 20 字节。 -7. 为了兼容支持更多形式的表名，TDengine 引入新的转义符 "\`"，可以让表名与关键词不冲突，同时不受限于上述表名称合法性约束检查。但是同样具有长度限制要求。使用转义字符以后，不再对转义字符中的内容进行大小写统一， - 例如：\`aBc\` 和 \`abc\` 是不同的表名，但是 abc 和 aBc 是相同的表名。 -8. 关于 `ENCODE` 和 `COMPRESS` 的使用，请参考[按列压缩](../compress) +1. 除时间戳主键列之外，还可以通过 PRIMARY KEY 关键字指定第二列为额外的主键列。被指定为主键列的第二列必须为整型或字符串类型（varchar）。 +1. 表的每行长度不能超过 48KB（从 3.0.5.0 版本开始为 64KB）;（注意：每个 BINARY/NCHAR/GEOMETRY 类型的列还会额外占用 2 个字节的存储位置）。 +1. 使用数据类型 BINARY/NCHAR/GEOMETRY，需指定其最长的字节数，如 BINARY(20)，表示 20 字节。 +1. 关于 `ENCODE` 和 `COMPRESS` 的使用，请参考[按列压缩](../compress) **参数说明** diff --git a/docs/zh/14-reference/03-taos-sql/19-limit.md b/docs/zh/14-reference/03-taos-sql/19-limit.md index 73107bf3ba..4e2fa69a14 100644 --- a/docs/zh/14-reference/03-taos-sql/19-limit.md +++ b/docs/zh/14-reference/03-taos-sql/19-limit.md @@ -6,13 +6,16 @@ description: 合法字符集和命名中的限制规则 ## 名称命名规则 -1. 合法字符：英文字符、数字和下划线 -2. 允许英文字符或下划线开头，不允许以数字开头 -3. 不区分大小写 -4. 转义后表（列）名规则： - 为了兼容支持更多形式的表（列）名，TDengine 引入新的转义符 "`"。使用转义字符以后，不再对转义字符中的内容进行大小写统一，即可以保留用户指定表名中的大小写属性。 - - 例如：\`aBc\` 和 \`abc\` 是不同的表（列）名，但是 abc 和 aBc 是相同的表（列）名。 +1. 合法字符：英文字符、数字和下划线。 +1. 允许英文字符或下划线开头，不允许以数字开头。 +1. 不区分大小写。 +1. 不能是[保留关键字](./20-keywords.md)。 +1. 转义后表（列）名规则： + 为了兼容支持更多形式的表（列）名，TDengine 引入新的转义符 "`"。使用转义字符以后： + - 不再对转义字符中的内容进行大小写统一，即可以保留用户指定表名中的大小写属性，例如：\`aBc\` 和 \`abc\` 是不同的表（列）名，但是 abc 和 aBc 是相同的表（列）名。 + - 可以创建包含字母、数字和下划线以外字符的表（列）名，例如：\`abc@TD\`，但是转义后名称中仍然不能包含`.`，否则会提示`The table name cannot contain '.'`。 + - 可以创建以数字开头的表（列）名，例如\`1970\`。 + - 可以创建以[保留关键字](./20-keywords.md)命名的表（列）名，例如\`select\`。 ## 密码合法字符集 @@ -37,22 +40,3 @@ description: 合法字符集和命名中的限制规则 - 用户密码的最大长度是 31 字节 - 总数据行数取决于可用资源 - 单个数据库的虚拟结点数上限为 1024 - -## 表(列)名合法性说明 - -### TDengine 中的表（列）名命名规则如下： - -只能由字母、数字、下划线构成，数字不能在首位，长度不能超过 192 字节，不区分大小写。这里表名称不包括数据库名的前缀和分隔符。 - -### 转义后表（列）名规则： - -为了兼容支持更多形式的表（列）名，TDengine 引入新的转义符 "`"，可以避免表名与关键词的冲突，转义符不计入表名的长度。 -转义后的表（列）名同样受到长度限制要求，且长度计算的时候不计算转义符。使用转义字符以后，不再对转义字符中的内容进行大小写统一。 - -例如： -\`aBc\` 和 \`abc\` 是不同的表（列）名，但是 abc 和 aBc 是相同的表（列）名。 - -:::note -转义字符中的内容必须符合命名规则中的字符约束。 - -::: diff --git a/include/client/taos.h b/include/client/taos.h index 55b24c8721..11785dc40c 100644 --- a/include/client/taos.h +++ b/include/client/taos.h @@ -51,7 +51,7 @@ typedef void TAOS_SUB; #define TSDB_DATA_TYPE_BLOB 18 // binary #define TSDB_DATA_TYPE_MEDIUMBLOB 19 #define TSDB_DATA_TYPE_BINARY TSDB_DATA_TYPE_VARCHAR // string -#define TSDB_DATA_TYPE_GEOMETRY 20 // geometry +#define TSDB_DATA_TYPE_GEOMETRY 20 // geometry #define TSDB_DATA_TYPE_MAX 21 typedef enum { @@ -168,7 +168,7 @@ DLL_EXPORT const char *taos_data_type(int type); DLL_EXPORT TAOS_STMT *taos_stmt_init(TAOS *taos); DLL_EXPORT TAOS_STMT *taos_stmt_init_with_reqid(TAOS *taos, int64_t reqid); -DLL_EXPORT TAOS_STMT *taos_stmt_init_with_options(TAOS *taos, TAOS_STMT_OPTIONS* options); +DLL_EXPORT TAOS_STMT *taos_stmt_init_with_options(TAOS *taos, TAOS_STMT_OPTIONS *options); DLL_EXPORT int taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length); DLL_EXPORT int taos_stmt_set_tbname_tags(TAOS_STMT *stmt, const char *name, TAOS_MULTI_BIND *tags); DLL_EXPORT int taos_stmt_set_tbname(TAOS_STMT *stmt, const char *name); @@ -193,6 +193,49 @@ DLL_EXPORT char *taos_stmt_errstr(TAOS_STMT *stmt); DLL_EXPORT int taos_stmt_affected_rows(TAOS_STMT *stmt); DLL_EXPORT int taos_stmt_affected_rows_once(TAOS_STMT *stmt); +typedef void TAOS_STMT2; + +typedef enum { + TAOS_FIELD_COL = 1, + TAOS_FIELD_TAG, + TAOS_FIELD_QUERY, + TAOS_FIELD_TBNAME, +} TAOS_FIELD_T; + +typedef struct { + int64_t reqid; + bool singleStbInsert; + bool singleTableBindOnce; + __taos_async_fn_t asyncExecFn; + void *userdata; +} TAOS_STMT2_OPTION; + +typedef struct { + int buffer_type; + void *buffer; + int32_t *length; + char *is_null; + int num; +} TAOS_STMT2_BIND; + +typedef struct { + int count; + char **tbnames; + TAOS_STMT2_BIND **tags; + TAOS_STMT2_BIND **bind_cols; +} TAOS_STMT2_BINDV; + +DLL_EXPORT TAOS_STMT2 *taos_stmt2_init(TAOS *taos, TAOS_STMT2_OPTION *option); +DLL_EXPORT int taos_stmt2_prepare(TAOS_STMT2 *stmt, const char *sql, unsigned long length); +DLL_EXPORT int taos_stmt2_bind_param(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col_idx); +DLL_EXPORT int taos_stmt2_exec(TAOS_STMT2 *stmt, int *affected_rows); +DLL_EXPORT int taos_stmt2_close(TAOS_STMT2 *stmt); +DLL_EXPORT int taos_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert); +DLL_EXPORT int taos_stmt2_get_fields(TAOS_STMT2 *stmt, TAOS_FIELD_T field_type, int *count, TAOS_FIELD_E **fields); +DLL_EXPORT void taos_stmt2_free_fields(TAOS_STMT2 *stmt, TAOS_FIELD_E *fields); +DLL_EXPORT TAOS_RES *taos_stmt2_result(TAOS_STMT2 *stmt); +DLL_EXPORT char *taos_stmt2_error(TAOS_STMT2 *stmt); + DLL_EXPORT TAOS_RES *taos_query(TAOS *taos, const char *sql); DLL_EXPORT TAOS_RES *taos_query_with_reqid(TAOS *taos, const char *sql, int64_t reqId); @@ -246,14 +289,15 @@ DLL_EXPORT void taos_set_hb_quit(int8_t quitByKill); DLL_EXPORT int taos_set_notify_cb(TAOS *taos, __taos_notify_fn_t fp, void *param, int type); -typedef void (*__taos_async_whitelist_fn_t)(void *param, int code, TAOS *taos, int numOfWhiteLists, uint64_t* pWhiteLists); +typedef void (*__taos_async_whitelist_fn_t)(void *param, int code, TAOS *taos, int numOfWhiteLists, + uint64_t *pWhiteLists); DLL_EXPORT void taos_fetch_whitelist_a(TAOS *taos, __taos_async_whitelist_fn_t fp, void *param); typedef enum { TAOS_CONN_MODE_BI = 0, } TAOS_CONN_MODE; -DLL_EXPORT int taos_set_conn_mode(TAOS* taos, int mode, int value); +DLL_EXPORT int taos_set_conn_mode(TAOS *taos, int mode, int value); /* --------------------------schemaless INTERFACE------------------------------- */ DLL_EXPORT TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision); @@ -271,10 +315,13 @@ DLL_EXPORT TAOS_RES *taos_schemaless_insert_raw_ttl(TAOS *taos, char *lines, int int precision, int32_t ttl); DLL_EXPORT TAOS_RES *taos_schemaless_insert_raw_ttl_with_reqid(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol, int precision, int32_t ttl, int64_t reqid); -DLL_EXPORT TAOS_RES *taos_schemaless_insert_raw_ttl_with_reqid_tbname_key(TAOS *taos, char *lines, int len, int32_t *totalRows, - int protocol, int precision, int32_t ttl, int64_t reqid, char *tbnameKey); -DLL_EXPORT TAOS_RES *taos_schemaless_insert_ttl_with_reqid_tbname_key(TAOS *taos, char *lines[], int numLines, int protocol, - int precision, int32_t ttl, int64_t reqid, char *tbnameKey); +DLL_EXPORT TAOS_RES *taos_schemaless_insert_raw_ttl_with_reqid_tbname_key(TAOS *taos, char *lines, int len, + int32_t *totalRows, int protocol, + int precision, int32_t ttl, int64_t reqid, + char *tbnameKey); +DLL_EXPORT TAOS_RES *taos_schemaless_insert_ttl_with_reqid_tbname_key(TAOS *taos, char *lines[], int numLines, + int protocol, int precision, int32_t ttl, + int64_t reqid, char *tbnameKey); /* --------------------------TMQ INTERFACE------------------------------- */ typedef struct tmq_t tmq_t; @@ -320,14 +367,17 @@ DLL_EXPORT int32_t tmq_unsubscribe(tmq_t *tmq); DLL_EXPORT int32_t tmq_subscription(tmq_t *tmq, tmq_list_t **topics); DLL_EXPORT TAOS_RES *tmq_consumer_poll(tmq_t *tmq, int64_t timeout); DLL_EXPORT int32_t tmq_consumer_close(tmq_t *tmq); -DLL_EXPORT int32_t tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg); //Commit the msg’s offset + 1 +DLL_EXPORT int32_t tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg); // Commit the msg’s offset + 1 DLL_EXPORT void tmq_commit_async(tmq_t *tmq, const TAOS_RES *msg, tmq_commit_cb *cb, void *param); DLL_EXPORT int32_t tmq_commit_offset_sync(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset); -DLL_EXPORT void tmq_commit_offset_async(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset, tmq_commit_cb *cb, void *param); -DLL_EXPORT int32_t tmq_get_topic_assignment(tmq_t *tmq, const char *pTopicName, tmq_topic_assignment **assignment,int32_t *numOfAssignment); -DLL_EXPORT void tmq_free_assignment(tmq_topic_assignment* pAssignment); +DLL_EXPORT void tmq_commit_offset_async(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset, + tmq_commit_cb *cb, void *param); +DLL_EXPORT int32_t tmq_get_topic_assignment(tmq_t *tmq, const char *pTopicName, tmq_topic_assignment **assignment, + int32_t *numOfAssignment); +DLL_EXPORT void tmq_free_assignment(tmq_topic_assignment *pAssignment); DLL_EXPORT int32_t tmq_offset_seek(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset); -DLL_EXPORT int64_t tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId); // The current offset is the offset of the last consumed message + 1 +DLL_EXPORT int64_t tmq_position(tmq_t *tmq, const char *pTopicName, + int32_t vgId); // The current offset is the offset of the last consumed message + 1 DLL_EXPORT int64_t tmq_committed(tmq_t *tmq, const char *pTopicName, int32_t vgId); DLL_EXPORT TAOS *tmq_get_connect(tmq_t *tmq); @@ -336,7 +386,7 @@ DLL_EXPORT tmq_res_t tmq_get_res_type(TAOS_RES *res); DLL_EXPORT const char *tmq_get_topic_name(TAOS_RES *res); DLL_EXPORT const char *tmq_get_db_name(TAOS_RES *res); DLL_EXPORT int32_t tmq_get_vgroup_id(TAOS_RES *res); -DLL_EXPORT int64_t tmq_get_vgroup_offset(TAOS_RES* res); +DLL_EXPORT int64_t tmq_get_vgroup_offset(TAOS_RES *res); DLL_EXPORT const char *tmq_err2str(int32_t code); /* ------------------------------ TAOSX -----------------------------------*/ @@ -346,15 +396,16 @@ typedef struct tmq_raw_data { uint16_t raw_type; } tmq_raw_data; -DLL_EXPORT int32_t tmq_get_raw(TAOS_RES *res, tmq_raw_data *raw); -DLL_EXPORT int32_t tmq_write_raw(TAOS *taos, tmq_raw_data raw); -DLL_EXPORT int taos_write_raw_block(TAOS *taos, int numOfRows, char *pData, const char *tbname); -DLL_EXPORT int taos_write_raw_block_with_reqid(TAOS *taos, int numOfRows, char *pData, const char *tbname, int64_t reqid); -DLL_EXPORT int taos_write_raw_block_with_fields(TAOS *taos, int rows, char *pData, const char *tbname, - TAOS_FIELD *fields, int numFields); -DLL_EXPORT int taos_write_raw_block_with_fields_with_reqid(TAOS *taos, int rows, char *pData, const char *tbname, - TAOS_FIELD *fields, int numFields, int64_t reqid); -DLL_EXPORT void tmq_free_raw(tmq_raw_data raw); +DLL_EXPORT int32_t tmq_get_raw(TAOS_RES *res, tmq_raw_data *raw); +DLL_EXPORT int32_t tmq_write_raw(TAOS *taos, tmq_raw_data raw); +DLL_EXPORT int taos_write_raw_block(TAOS *taos, int numOfRows, char *pData, const char *tbname); +DLL_EXPORT int taos_write_raw_block_with_reqid(TAOS *taos, int numOfRows, char *pData, const char *tbname, + int64_t reqid); +DLL_EXPORT int taos_write_raw_block_with_fields(TAOS *taos, int rows, char *pData, const char *tbname, + TAOS_FIELD *fields, int numFields); +DLL_EXPORT int taos_write_raw_block_with_fields_with_reqid(TAOS *taos, int rows, char *pData, const char *tbname, + TAOS_FIELD *fields, int numFields, int64_t reqid); +DLL_EXPORT void tmq_free_raw(tmq_raw_data raw); // Returning null means error. Returned result need to be freed by tmq_free_json_meta DLL_EXPORT char *tmq_get_json_meta(TAOS_RES *res); @@ -370,7 +421,7 @@ typedef enum { } TSDB_SERVER_STATUS; DLL_EXPORT TSDB_SERVER_STATUS taos_check_server_status(const char *fqdn, int port, char *details, int maxlen); -DLL_EXPORT char* getBuildInfo(); +DLL_EXPORT char *getBuildInfo(); #ifdef __cplusplus } #endif diff --git a/include/common/tdatablock.h b/include/common/tdatablock.h index b4dd6d61e4..22a43012c5 100644 --- a/include/common/tdatablock.h +++ b/include/common/tdatablock.h @@ -41,7 +41,7 @@ typedef struct SBlockOrderInfo { #define BMCharPos(bm_, r_) ((bm_)[(r_) >> NBIT]) #define colDataIsNull_f(bm_, r_) ((BMCharPos(bm_, r_) & (1u << (7u - BitPos(r_)))) == (1u << (7u - BitPos(r_)))) -#define QRY_OPTR_CHECK(_o) \ +#define QRY_PARAM_CHECK(_o) \ do { \ if ((_o) == NULL) { \ return TSDB_CODE_INVALID_PARA; \ diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h index 4d6d69b178..1179e710cd 100644 --- a/include/common/tdataformat.h +++ b/include/common/tdataformat.h @@ -378,6 +378,19 @@ typedef struct { int32_t tRowBuildFromBind(SBindInfo *infos, int32_t numOfInfos, bool infoSorted, const STSchema *pTSchema, SArray *rowArray); +// stmt2 binding +int32_t tColDataAddValueByBind2(SColData *pColData, TAOS_STMT2_BIND *pBind, int32_t buffMaxLen); + +typedef struct { + int32_t columnId; + int32_t type; + int32_t bytes; + TAOS_STMT2_BIND *bind; +} SBindInfo2; + +int32_t tRowBuildFromBind2(SBindInfo2 *infos, int32_t numOfInfos, bool infoSorted, const STSchema *pTSchema, + SArray *rowArray); + #endif #ifdef __cplusplus diff --git a/include/libs/executor/executor.h b/include/libs/executor/executor.h index 09143dde29..ed56b7e6b2 100644 --- a/include/libs/executor/executor.h +++ b/include/libs/executor/executor.h @@ -166,6 +166,8 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pBlock, uint64_t* useconds); +void qResetTaskCode(qTaskInfo_t tinfo); + void qCleanExecTaskBlockBuf(qTaskInfo_t tinfo); /** diff --git a/include/libs/parser/parser.h b/include/libs/parser/parser.h index a808fccc4a..7271da8ff6 100644 --- a/include/libs/parser/parser.h +++ b/include/libs/parser/parser.h @@ -20,9 +20,9 @@ extern "C" { #endif +#include "catalog.h" #include "query.h" #include "querynodes.h" -#include "catalog.h" typedef struct SStmtCallback { TAOS_STMT* pStmt; @@ -37,15 +37,15 @@ typedef enum { } SParseResType; typedef struct SParseSchemaRes { - int8_t precision; - int32_t numOfCols; - SSchema* pSchema; + int8_t precision; + int32_t numOfCols; + SSchema* pSchema; } SParseSchemaRes; typedef struct SParseQueryRes { - SNode* pQuery; - SCatalogReq* pCatalogReq; - SMetaData meta; + SNode* pQuery; + SCatalogReq* pCatalogReq; + SMetaData meta; } SParseQueryRes; typedef struct SParseSqlRes { @@ -124,11 +124,13 @@ int32_t qSetSTableIdForRsma(SNode* pStmt, int64_t uid); int32_t qInitKeywordsTable(); void qCleanupKeywordsTable(); -int32_t qAppendStmtTableOutput(SQuery* pQuery, SHashObj* pAllVgHash, STableColsData* pTbData, STableDataCxt* pTbCtx, SStbInterlaceInfo* pBuildInfo); -int32_t qBuildStmtFinOutput(SQuery* pQuery, SHashObj* pAllVgHash, SArray* pVgDataBlocks); -//int32_t qBuildStmtOutputFromTbList(SQuery* pQuery, SHashObj* pVgHash, SArray* pBlockList, STableDataCxt* pTbCtx, int32_t tbNum); +int32_t qAppendStmtTableOutput(SQuery* pQuery, SHashObj* pAllVgHash, STableColsData* pTbData, STableDataCxt* pTbCtx, + SStbInterlaceInfo* pBuildInfo); +int32_t qBuildStmtFinOutput(SQuery* pQuery, SHashObj* pAllVgHash, SArray* pVgDataBlocks); +// int32_t qBuildStmtOutputFromTbList(SQuery* pQuery, SHashObj* pVgHash, SArray* pBlockList, STableDataCxt* pTbCtx, +// int32_t tbNum); int32_t qBuildStmtOutput(SQuery* pQuery, SHashObj* pVgHash, SHashObj* pBlockHash); -int32_t qResetStmtColumns(SArray* pCols, bool deepClear); +int32_t qResetStmtColumns(SArray* pCols, bool deepClear); int32_t qResetStmtDataBlock(STableDataCxt* block, bool keepBuf); int32_t qCloneStmtDataBlock(STableDataCxt** pDst, STableDataCxt* pSrc, bool reset); int32_t qRebuildStmtDataBlock(STableDataCxt** pDst, STableDataCxt* pSrc, uint64_t uid, uint64_t suid, int32_t vgId, @@ -139,39 +141,51 @@ int32_t qCloneCurrentTbData(STableDataCxt* pDataBlock, SSubmitTbData** pData int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx); int32_t qStmtParseQuerySql(SParseContext* pCxt, SQuery* pQuery); -int32_t qBindStmtStbColsValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen, STSchema** pTSchema, SBindInfo* pBindInfos); +int32_t qBindStmtStbColsValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen, + STSchema** pTSchema, SBindInfo* pBindInfos); int32_t qBindStmtColsValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen); -int32_t qBindStmtSingleColValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen, int32_t colIdx, - int32_t rowNum); +int32_t qBindStmtSingleColValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen, + int32_t colIdx, int32_t rowNum); int32_t qBuildStmtColFields(void* pDataBlock, int32_t* fieldNum, TAOS_FIELD_E** fields); int32_t qBuildStmtTagFields(void* pBlock, void* boundTags, int32_t* fieldNum, TAOS_FIELD_E** fields); int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const char* sTableName, char* tName, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen); + +int32_t qStmtBindParams2(SQuery* pQuery, TAOS_STMT2_BIND* pParams, int32_t colIdx); +int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, + STSchema** pTSchema, SBindInfo2* pBindInfos); +int32_t qBindStmtColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen); +int32_t qBindStmtSingleColValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, + int32_t colIdx, int32_t rowNum); +int32_t qBindStmtTagsValue2(void* pBlock, void* boundTags, int64_t suid, const char* sTableName, char* tName, + TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen); + void destroyBoundColumnInfo(void* pBoundInfo); int32_t qCreateSName(SName* pName, const char* pTableName, int32_t acctId, char* dbName, char* msgBuf, int32_t msgBufLen); void qDestroyBoundColInfo(void* pInfo); -int32_t smlInitHandle(SQuery** query); -int32_t smlBuildRow(STableDataCxt* pTableCxt); -int32_t smlBuildCol(STableDataCxt* pTableCxt, SSchema* schema, void* kv, int32_t index); -int32_t smlInitTableDataCtx(SQuery* query, STableMeta* pTableMeta, STableDataCxt** cxt); +int32_t smlInitHandle(SQuery** query); +int32_t smlBuildRow(STableDataCxt* pTableCxt); +int32_t smlBuildCol(STableDataCxt* pTableCxt, SSchema* schema, void* kv, int32_t index); +int32_t smlInitTableDataCtx(SQuery* query, STableMeta* pTableMeta, STableDataCxt** cxt); void clearColValArraySml(SArray* pCols); int32_t smlBindData(SQuery* handle, bool dataFormat, SArray* tags, SArray* colsSchema, SArray* cols, STableMeta* pTableMeta, char* tableName, const char* sTableName, int32_t sTableNameLen, int32_t ttl, char* msgBuf, int32_t msgBufLen); int32_t smlBuildOutput(SQuery* handle, SHashObj* pVgHash); -int rawBlockBindData(SQuery *query, STableMeta* pTableMeta, void* data, SVCreateTbReq** pCreateTb, TAOS_FIELD *fields, - int numFields, bool needChangeLength, char* errstr, int32_t errstrLen); +int rawBlockBindData(SQuery* query, STableMeta* pTableMeta, void* data, SVCreateTbReq** pCreateTb, TAOS_FIELD* fields, + int numFields, bool needChangeLength, char* errstr, int32_t errstrLen); int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray); int32_t serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap, SArray** pOut); int32_t serializeVgroupsDropTableBatch(SHashObj* pVgroupHashmap, SArray** pOut); -void destoryCatalogReq(SCatalogReq *pCatalogReq); +void destoryCatalogReq(SCatalogReq* pCatalogReq); bool isPrimaryKeyImpl(SNode* pExpr); -int32_t insAppendStmtTableDataCxt(SHashObj* pAllVgHash, STableColsData* pTbData, STableDataCxt* pTbCtx, SStbInterlaceInfo* pBuildInfo); +int32_t insAppendStmtTableDataCxt(SHashObj* pAllVgHash, STableColsData* pTbData, STableDataCxt* pTbCtx, + SStbInterlaceInfo* pBuildInfo); #ifdef __cplusplus } diff --git a/source/client/inc/clientStmt2.h b/source/client/inc/clientStmt2.h new file mode 100644 index 0000000000..74eb198930 --- /dev/null +++ b/source/client/inc/clientStmt2.h @@ -0,0 +1,235 @@ +/* + * 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 TDENGINE_CLIENTSTMT2_H +#define TDENGINE_CLIENTSTMT2_H + +#ifdef __cplusplus +extern "C" { +#endif +#include "catalog.h" +/* +typedef enum { +STMT_TYPE_INSERT = 1, +STMT_TYPE_MULTI_INSERT, +STMT_TYPE_QUERY, +} STMT_TYPE; + +typedef enum { +STMT_INIT = 1, +STMT_PREPARE, +STMT_SETTBNAME, +STMT_SETTAGS, +STMT_FETCH_FIELDS, +STMT_BIND, +STMT_BIND_COL, +STMT_ADD_BATCH, +STMT_EXECUTE, +STMT_MAX, +} STMT_STATUS; + +#define STMT_TABLE_COLS_NUM 1000 + +typedef struct SStmtTableCache { +STableDataCxt *pDataCtx; +void *boundTags; +} SStmtTableCache; + +typedef struct SStmtQueryResInfo { +TAOS_FIELD *fields; +TAOS_FIELD *userFields; +uint32_t numOfCols; +int32_t precision; +} SStmtQueryResInfo; + +typedef struct SStmtBindInfo { +bool needParse; +bool inExecCache; +uint64_t tbUid; +uint64_t tbSuid; +int32_t tbVgId; +int32_t sBindRowNum; +int32_t sBindLastIdx; +int8_t tbType; +bool tagsCached; +void *boundTags; +char tbName[TSDB_TABLE_FNAME_LEN]; +char tbFName[TSDB_TABLE_FNAME_LEN]; +char stbFName[TSDB_TABLE_FNAME_LEN]; +SName sname; + +char statbName[TSDB_TABLE_FNAME_LEN]; +} SStmtBindInfo; + +typedef struct SStmtAsyncParam { +STableColsData *pTbData; +void* pStmt; +} SStmtAsyncParam; + +typedef struct SStmtExecInfo { +int32_t affectedRows; +SRequestObj *pRequest; +SHashObj *pBlockHash; +STableDataCxt *pCurrBlock; +SSubmitTbData *pCurrTbData; +} SStmtExecInfo; +*/ +typedef struct { + bool stbInterlaceMode; + STMT_TYPE type; + STMT_STATUS status; + uint64_t suid; + uint64_t runTimes; + SHashObj *pTableCache; // SHash + SQuery *pQuery; + char *sqlStr; + int32_t sqlLen; + SArray *nodeList; + SStmtQueryResInfo queryRes; + bool autoCreateTbl; + SHashObj *pVgHash; + SBindInfo2 *pBindInfo; + + SStbInterlaceInfo siInfo; +} SStmtSQLInfo2; +/* +typedef struct SStmtStatInfo { +int64_t ctgGetTbMetaNum; +int64_t getCacheTbInfo; +int64_t parseSqlNum; +int64_t bindDataNum; +int64_t setTbNameUs; +int64_t bindDataUs1; +int64_t bindDataUs2; +int64_t bindDataUs3; +int64_t bindDataUs4; +int64_t addBatchUs; +int64_t execWaitUs; +int64_t execUseUs; +} SStmtStatInfo; + +typedef struct SStmtQNode { +bool restoreTbCols; +STableColsData tblData; +struct SStmtQNode* next; +} SStmtQNode; + +typedef struct SStmtQueue { +bool stopQueue; +SStmtQNode* head; +SStmtQNode* tail; +uint64_t qRemainNum; +} SStmtQueue; +*/ + +typedef struct { + STscObj *taos; + SCatalog *pCatalog; + int32_t affectedRows; + uint32_t seqId; + uint32_t seqIds[STMT_MAX]; + bool bindThreadInUse; + TdThread bindThread; + TAOS_STMT2_OPTION options; + bool stbInterlaceMode; + SStmtQueue queue; + + SStmtSQLInfo2 sql; + SStmtExecInfo exec; + SStmtBindInfo bInfo; + + int64_t reqid; + int32_t errCode; + tsem_t asyncQuerySem; + + SStmtStatInfo stat; +} STscStmt2; +/* +extern char *gStmtStatusStr[]; + +#define STMT_LOG_SEQ(n) \ +do { \ + (pStmt)->seqId++; \ + (pStmt)->seqIds[n]++; \ + STMT_DLOG("the %dth:%d %s", (pStmt)->seqIds[n], (pStmt)->seqId, gStmtStatusStr[n]); \ +} while (0) + +#define STMT_STATUS_NE(S) (pStmt->sql.status != STMT_##S) +#define STMT_STATUS_EQ(S) (pStmt->sql.status == STMT_##S) + +#define STMT_ERR_RET(c) \ +do { \ + int32_t _code = c; \ + if (_code != TSDB_CODE_SUCCESS) { \ + terrno = _code; \ + pStmt->errCode = _code; \ + return _code; \ + } \ +} while (0) +#define STMT_RET(c) \ +do { \ + int32_t _code = c; \ + if (_code != TSDB_CODE_SUCCESS) { \ + terrno = _code; \ + pStmt->errCode = _code; \ + } \ + return _code; \ +} while (0) +#define STMT_ERR_JRET(c) \ +do { \ + code = c; \ + if (code != TSDB_CODE_SUCCESS) { \ + terrno = code; \ + pStmt->errCode = code; \ + goto _return; \ + } \ +} while (0) +#define STMT_ERRI_JRET(c) \ +do { \ + code = c; \ + if (code != TSDB_CODE_SUCCESS) { \ + terrno = code; \ + goto _return; \ + } \ +} while (0) + + +#define STMT_FLOG(param, ...) qFatal("stmt:%p " param, pStmt, __VA_ARGS__) +#define STMT_ELOG(param, ...) qError("stmt:%p " param, pStmt, __VA_ARGS__) +#define STMT_DLOG(param, ...) qDebug("stmt:%p " param, pStmt, __VA_ARGS__) + +#define STMT_ELOG_E(param) qError("stmt:%p " param, pStmt) +#define STMT_DLOG_E(param) qDebug("stmt:%p " param, pStmt) +*/ +TAOS_STMT2 *stmtInit2(STscObj *taos, TAOS_STMT2_OPTION *pOptions); +int stmtClose2(TAOS_STMT2 *stmt); +int stmtExec2(TAOS_STMT2 *stmt, int *affected_rows); +int stmtPrepare2(TAOS_STMT2 *stmt, const char *sql, unsigned long length); +int stmtSetTbName2(TAOS_STMT2 *stmt, const char *tbName); +int stmtSetTbTags2(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *tags); +int stmtBindBatch2(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind, int32_t colIdx); +int stmtGetTagFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_E **fields); +int stmtGetColFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_E **fields); +int stmtGetParamNum2(TAOS_STMT2 *stmt, int *nums); +int stmtGetParamTbName(TAOS_STMT2 *stmt, int *nums); +int stmtIsInsert2(TAOS_STMT2 *stmt, int *insert); +TAOS_RES *stmtUseResult2(TAOS_STMT2 *stmt); +const char *stmtErrstr2(TAOS_STMT2 *stmt); + +#ifdef __cplusplus +} +#endif + +#endif // TDENGINE_CLIENTSTMT2_H diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c index 3c2729c029..fec1060042 100644 --- a/source/client/src/clientEnv.c +++ b/source/client/src/clientEnv.c @@ -687,7 +687,9 @@ void doDestroyRequest(void *p) { taosMemoryFreeClear(pRequest->msgBuf); doFreeReqResultInfo(&pRequest->body.resInfo); - (void)tsem_destroy(&pRequest->body.rspSem); + if (TSDB_CODE_SUCCESS != tsem_destroy(&pRequest->body.rspSem)) { + tscError("failed to destroy semaphore"); + } taosArrayDestroy(pRequest->tableList); taosArrayDestroy(pRequest->targetTableList); @@ -700,7 +702,9 @@ void doDestroyRequest(void *p) { taosMemoryFreeClear(pRequest->pDb); taosArrayDestroy(pRequest->dbList); if (pRequest->body.interParam) { - (void)tsem_destroy(&((SSyncQueryParam *)pRequest->body.interParam)->sem); + if (TSDB_CODE_SUCCESS != tsem_destroy(&((SSyncQueryParam *)pRequest->body.interParam)->sem)) { + tscError("failed to destroy semaphore in pRequest"); + } } taosMemoryFree(pRequest->body.interParam); diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c index 5d3892d5e0..47b80c03d1 100644 --- a/source/client/src/clientHb.c +++ b/source/client/src/clientHb.c @@ -1636,7 +1636,9 @@ void hbDeregisterConn(STscObj *pTscObj, SClientHbKey connKey) { SClientHbReq *pReq = taosHashAcquire(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey)); if (pReq) { tFreeClientHbReq(pReq); - (void)taosHashRemove(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey)); + if (TSDB_CODE_SUCCESS != taosHashRemove(pAppHbMgr->activeInfo, &connKey, sizeof(SClientHbKey))) { + tscError("failed to remove connKey from activeInfo"); + } taosHashRelease(pAppHbMgr->activeInfo, pReq); (void)atomic_sub_fetch_32(&pAppHbMgr->connKeyCnt, 1); } diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c index a208cedd65..34a82d4c42 100644 --- a/source/client/src/clientImpl.c +++ b/source/client/src/clientImpl.c @@ -209,7 +209,9 @@ _return: void freeQueryParam(SSyncQueryParam* param) { if (param == NULL) return; - (void)tsem_destroy(¶m->sem); + if (TSDB_CODE_SUCCESS != tsem_destroy(¶m->sem)) { + tscError("failed to destroy semaphore in freeQueryParam"); + } taosMemoryFree(param); } @@ -351,7 +353,7 @@ int32_t execDdlQuery(SRequestObj* pRequest, SQuery* pQuery) { // int64_t transporterId = 0; TSC_ERR_RET(asyncSendMsgToServer(pTscObj->pAppInfo->pTransporter, &pMsgInfo->epSet, NULL, pSendMsg)); - (void)tsem_wait(&pRequest->body.rspSem); + TSC_ERR_RET(tsem_wait(&pRequest->body.rspSem)); return TSDB_CODE_SUCCESS; } @@ -1165,14 +1167,18 @@ void schedulerExecCb(SExecResult* pResult, void* param, int32_t code) { if (code != TSDB_CODE_SUCCESS && NEED_CLIENT_HANDLE_ERROR(code) && pRequest->sqlstr != NULL) { tscDebug("0x%" PRIx64 " client retry to handle the error, code:%s, tryCount:%d,QID:0x%" PRIx64, pRequest->self, tstrerror(code), pRequest->retry, pRequest->requestId); - (void)removeMeta(pTscObj, pRequest->targetTableList, IS_VIEW_REQUEST(pRequest->type)); + if (TSDB_CODE_SUCCESS != removeMeta(pTscObj, pRequest->targetTableList, IS_VIEW_REQUEST(pRequest->type))) { + tscError("0x%" PRIx64 " remove meta failed,QID:0x%" PRIx64, pRequest->self, pRequest->requestId); + } restartAsyncQuery(pRequest, code); return; } tscDebug("schedulerExecCb request type %s", TMSG_INFO(pRequest->type)); if (NEED_CLIENT_RM_TBLMETA_REQ(pRequest->type) && NULL == pRequest->body.resInfo.execRes.res) { - (void)removeMeta(pTscObj, pRequest->targetTableList, IS_VIEW_REQUEST(pRequest->type)); + if (TSDB_CODE_SUCCESS != removeMeta(pTscObj, pRequest->targetTableList, IS_VIEW_REQUEST(pRequest->type))) { + tscError("0x%" PRIx64 " remove meta failed,QID:0x%" PRIx64, pRequest->self, pRequest->requestId); + } } pRequest->metric.execCostUs = taosGetTimestampUs() - pRequest->metric.execStart; @@ -1266,7 +1272,10 @@ SRequestObj* launchQueryImpl(SRequestObj* pRequest, SQuery* pQuery, bool keepQue } if (NEED_CLIENT_RM_TBLMETA_REQ(pRequest->type) && NULL == pRequest->body.resInfo.execRes.res) { - (void)removeMeta(pRequest->pTscObj, pRequest->targetTableList, IS_VIEW_REQUEST(pRequest->type)); + code = removeMeta(pRequest->pTscObj, pRequest->targetTableList, IS_VIEW_REQUEST(pRequest->type)); + if (TSDB_CODE_SUCCESS != code) { + tscError("0x%" PRIx64 " remove meta failed,QID:0x%" PRIx64, pRequest->self, pRequest->requestId); + } } if (TSDB_CODE_SUCCESS == code) { @@ -1479,12 +1488,12 @@ int32_t removeMeta(STscObj* pTscObj, SArray* tbList, bool isView) { continue; } (void)tNameGetFullDbName(pViewName, dbFName); - (void)catalogRemoveViewMeta(pCatalog, dbFName, 0, pViewName->tname, 0); + TSC_ERR_RET(catalogRemoveViewMeta(pCatalog, dbFName, 0, pViewName->tname, 0)); } } else { for (int32_t i = 0; i < tbNum; ++i) { SName* pTbName = taosArrayGet(tbList, i); - (void)catalogRemoveTableMeta(pCatalog, pTbName); + TSC_ERR_RET(catalogRemoveTableMeta(pCatalog, pTbName)); } } @@ -1584,7 +1593,11 @@ int32_t taosConnectImpl(const char* user, const char* auth, const char* db, __ta tscError("failed to send connect msg to server, code:%s", tstrerror(code)); return code; } - (void)tsem_wait(&pRequest->body.rspSem); + if (TSDB_CODE_SUCCESS != tsem_wait(&pRequest->body.rspSem)) { + destroyTscObj(*pTscObj); + tscError("failed to wait sem, code:%s", terrstr()); + return terrno; + } if (pRequest->code != TSDB_CODE_SUCCESS) { const char* errorMsg = (code == TSDB_CODE_RPC_FQDN_ERROR) ? taos_errstr(pRequest) : tstrerror(pRequest->code); tscError("failed to connect to server, reason: %s", errorMsg); @@ -1736,7 +1749,9 @@ int32_t doProcessMsgFromServer(void* param) { tscError("doProcessMsgFromServer pRequest->self:%" PRId64 " != pSendInfo->requestObjRefId:%" PRId64, pRequest->self, pSendInfo->requestObjRefId); - (void)taosReleaseRef(clientReqRefPool, pSendInfo->requestObjRefId); + if (TSDB_CODE_SUCCESS != taosReleaseRef(clientReqRefPool, pSendInfo->requestObjRefId)) { + tscError("doProcessMsgFromServer taosReleaseRef failed"); + } taosMemoryFree(arg->pEpset); rpcFreeCont(pMsg->pCont); destroySendMsgInfo(pSendInfo); @@ -1769,7 +1784,12 @@ int32_t doProcessMsgFromServer(void* param) { (void)pSendInfo->fp(pSendInfo->param, &buf, pMsg->code); if (pTscObj) { - (void)taosReleaseRef(clientReqRefPool, pSendInfo->requestObjRefId); + int32_t code = taosReleaseRef(clientReqRefPool, pSendInfo->requestObjRefId); + if (TSDB_CODE_SUCCESS != code) { + tscError("doProcessMsgFromServer taosReleaseRef failed"); + terrno = code; + pMsg->code = code; + } } rpcFreeCont(pMsg->pCont); @@ -1946,7 +1966,9 @@ void* doFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4) static void syncFetchFn(void* param, TAOS_RES* res, int32_t numOfRows) { tsem_t* sem = param; - (void)tsem_post(sem); + if (TSDB_CODE_SUCCESS != tsem_post(sem)) { + tscError("failed to post sem, code:%s", terrstr()); + } } void* doAsyncFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertUcs4) { @@ -1965,10 +1987,16 @@ void* doAsyncFetchRows(SRequestObj* pRequest, bool setupOneRowPtr, bool convertU // convert ucs4 to native multi-bytes string pResultInfo->convertUcs4 = convertUcs4; tsem_t sem; - (void)tsem_init(&sem, 0, 0); + if (TSDB_CODE_SUCCESS != tsem_init(&sem, 0, 0)) { + tscError("failed to init sem, code:%s", terrstr()); + } taos_fetch_rows_a(pRequest, syncFetchFn, &sem); - (void)tsem_wait(&sem); - (void)tsem_destroy(&sem); + if (TSDB_CODE_SUCCESS != tsem_wait(&sem)) { + tscError("failed to wait sem, code:%s", terrstr()); + } + if (TSDB_CODE_SUCCESS != tsem_destroy(&sem)) { + tscError("failed to destroy sem, code:%s", terrstr()); + } pRequest->inCallback = false; } @@ -2742,7 +2770,9 @@ void syncCatalogFn(SMetaData* pResult, void* param, int32_t code) { SSyncQueryParam* pParam = param; pParam->pRequest->code = code; - (void)tsem_post(&pParam->sem); + if (TSDB_CODE_SUCCESS != tsem_post(&pParam->sem)) { + tscError("failed to post semaphore since %s", tstrerror(terrno)); + } } void syncQueryFn(void* param, void* res, int32_t code) { @@ -2753,7 +2783,9 @@ void syncQueryFn(void* param, void* res, int32_t code) { pParam->pRequest->code = code; } - (void)tsem_post(&pParam->sem); + if (TSDB_CODE_SUCCESS != tsem_post(&pParam->sem)) { + tscError("failed to post semaphore since %s", tstrerror(terrno)); + } } void taosAsyncQueryImpl(uint64_t connId, const char* sql, __taos_async_fn_t fp, void* param, bool validateOnly, @@ -2831,10 +2863,20 @@ TAOS_RES* taosQueryImpl(TAOS* taos, const char* sql, bool validateOnly, int8_t s terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - (void)tsem_init(¶m->sem, 0, 0); + int32_t code = tsem_init(¶m->sem, 0, 0); + if (TSDB_CODE_SUCCESS != code) { + terrno = code; + taosMemoryFree(param); + return NULL; + } taosAsyncQueryImpl(*(int64_t*)taos, sql, syncQueryFn, param, validateOnly, source); - (void)tsem_wait(¶m->sem); + code = tsem_wait(¶m->sem); + if (TSDB_CODE_SUCCESS != code) { + terrno = code; + taosMemoryFree(param); + return NULL; + } SRequestObj* pRequest = NULL; if (param->pRequest != NULL) { @@ -2860,10 +2902,20 @@ TAOS_RES* taosQueryImplWithReqid(TAOS* taos, const char* sql, bool validateOnly, terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - (void)tsem_init(¶m->sem, 0, 0); + int32_t code = tsem_init(¶m->sem, 0, 0); + if (TSDB_CODE_SUCCESS != code) { + terrno = code; + taosMemoryFree(param); + return NULL; + } taosAsyncQueryImplWithReqid(*(int64_t*)taos, sql, syncQueryFn, param, validateOnly, reqid); - (void)tsem_wait(¶m->sem); + code = tsem_wait(¶m->sem); + if (TSDB_CODE_SUCCESS != code) { + terrno = code; + taosMemoryFree(param); + return NULL; + } SRequestObj* pRequest = NULL; if (param->pRequest != NULL) { param->pRequest->syncQuery = true; diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c index 27c1878dc8..02435022f8 100644 --- a/source/client/src/clientMain.c +++ b/source/client/src/clientMain.c @@ -18,6 +18,7 @@ #include "clientLog.h" #include "clientMonitor.h" #include "clientStmt.h" +#include "clientStmt2.h" #include "functionMgt.h" #include "os.h" #include "query.h" @@ -312,7 +313,9 @@ void taos_close_internal(void *taos) { STscObj *pTscObj = (STscObj *)taos; tscDebug("0x%" PRIx64 " try to close connection, numOfReq:%d", pTscObj->id, pTscObj->numOfReqs); - (void)taosRemoveRef(clientConnRefPool, pTscObj->id); + if (TSDB_CODE_SUCCESS != taosRemoveRef(clientConnRefPool, pTscObj->id)) { + tscError("0x%" PRIx64 " failed to remove ref from conn pool", pTscObj->id); + } } void taos_close(TAOS *taos) { @@ -1313,7 +1316,10 @@ void doAsyncQuery(SRequestObj *pRequest, bool updateMetaForce) { if (NEED_CLIENT_HANDLE_ERROR(code)) { tscDebug("0x%" PRIx64 " client retry to handle the error, code:%d - %s, tryCount:%d,QID:0x%" PRIx64, pRequest->self, code, tstrerror(code), pRequest->retry, pRequest->requestId); - (void)refreshMeta(pRequest->pTscObj, pRequest); // ignore return code,try again + if (TSDB_CODE_SUCCESS != refreshMeta(pRequest->pTscObj, pRequest)) { + tscWarn("0x%" PRIx64 " refresh meta failed, code:%d - %s,QID:0x%" PRIx64, pRequest->self, code, + tstrerror(code), pRequest->requestId); + } pRequest->prevCode = code; doAsyncQuery(pRequest, true); return; @@ -1614,8 +1620,11 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) { } SSyncQueryParam *pParam = pRequest->body.interParam; - (void)tsem_wait(&pParam->sem); - + code = tsem_wait(&pParam->sem); + if (code) { + tscError("tsem wait failed, code:%d - %s", code, tstrerror(code)); + goto _return; + } _return: destoryCatalogReq(&catalogReq); destroyRequest(pRequest); @@ -1915,6 +1924,160 @@ int taos_stmt_close(TAOS_STMT *stmt) { return stmtClose(stmt); } +TAOS_STMT2 *taos_stmt2_init(TAOS *taos, TAOS_STMT2_OPTION *option) { + STscObj *pObj = acquireTscObj(*(int64_t *)taos); + if (NULL == pObj) { + tscError("invalid parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_TSC_DISCONNECTED; + return NULL; + } + + TAOS_STMT2 *pStmt = stmtInit2(pObj, option); + + releaseTscObj(*(int64_t *)taos); + + return pStmt; +} + +int taos_stmt2_prepare(TAOS_STMT2 *stmt, const char *sql, unsigned long length) { + if (stmt == NULL || sql == NULL) { + tscError("NULL parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + + return stmtPrepare2(stmt, sql, length); +} + +int taos_stmt2_bind_param(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col_idx) { + if (stmt == NULL) { + tscError("NULL parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + + int32_t code = 0; + for (int i = 0; i < bindv->count; ++i) { + if (bindv->tbnames && bindv->tbnames[i]) { + code = stmtSetTbName2(stmt, bindv->tbnames[i]); + if (code) { + return code; + } + } + + if (bindv->tags && bindv->tags[i]) { + code = stmtSetTbTags2(stmt, bindv->tags[i]); + if (code) { + return code; + } + } + + if (bindv->bind_cols && bindv->bind_cols[i]) { + TAOS_STMT2_BIND *bind = bindv->bind_cols[i]; + + if (bind->num <= 0 || bind->num > INT16_MAX) { + tscError("invalid bind num %d", bind->num); + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + + int32_t insert = 0; + (void)stmtIsInsert2(stmt, &insert); + if (0 == insert && bind->num > 1) { + tscError("only one row data allowed for query"); + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + + code = stmtBindBatch2(stmt, bind, col_idx); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } + } + + return TSDB_CODE_SUCCESS; +} + +int taos_stmt2_exec(TAOS_STMT2 *stmt, int *affected_rows) { + if (stmt == NULL) { + tscError("NULL parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + + return stmtExec2(stmt, affected_rows); +} + +int taos_stmt2_close(TAOS_STMT2 *stmt) { + if (stmt == NULL) { + tscError("NULL parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + + return stmtClose2(stmt); +} +/* +int taos_stmt2_param_count(TAOS_STMT2 *stmt, int *nums) { + if (stmt == NULL || nums == NULL) { + tscError("NULL parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + return stmtGetParamNum2(stmt, nums); +} +*/ +int taos_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert) { + if (stmt == NULL || insert == NULL) { + tscError("NULL parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + + return stmtIsInsert2(stmt, insert); +} + +int taos_stmt2_get_fields(TAOS_STMT2 *stmt, TAOS_FIELD_T field_type, int *count, TAOS_FIELD_E **fields) { + if (stmt == NULL || NULL == count) { + tscError("NULL parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + + if (field_type == TAOS_FIELD_COL) { + return stmtGetColFields2(stmt, count, fields); + } else if (field_type == TAOS_FIELD_TAG) { + return stmtGetTagFields2(stmt, count, fields); + } else if (field_type == TAOS_FIELD_QUERY) { + return stmtGetParamNum2(stmt, count); + } else if (field_type == TAOS_FIELD_TBNAME) { + return stmtGetParamTbName(stmt, count); + } else { + tscError("invalid parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } +} + +void taos_stmt2_free_fields(TAOS_STMT2 *stmt, TAOS_FIELD_E *fields) { + (void)stmt; + if (!fields) return; + taosMemoryFree(fields); +} + +TAOS_RES *taos_stmt2_result(TAOS_STMT2 *stmt) { + if (stmt == NULL) { + tscError("NULL parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_INVALID_PARA; + return NULL; + } + + return stmtUseResult2(stmt); +} + +char *taos_stmt2_error(TAOS_STMT2 *stmt) { return (char *)stmtErrstr2(stmt); } + int taos_set_conn_mode(TAOS *taos, int mode, int value) { if (taos == NULL) { terrno = TSDB_CODE_INVALID_PARA; diff --git a/source/client/src/clientStmt2.c b/source/client/src/clientStmt2.c new file mode 100644 index 0000000000..e7e08c0982 --- /dev/null +++ b/source/client/src/clientStmt2.c @@ -0,0 +1,1956 @@ +#include "clientInt.h" +#include "clientLog.h" +#include "tdef.h" + +#include "clientStmt.h" +#include "clientStmt2.h" +/* +char* gStmtStatusStr[] = {"unknown", "init", "prepare", "settbname", "settags", + "fetchFields", "bind", "bindCol", "addBatch", "exec"}; +*/ +static FORCE_INLINE int32_t stmtAllocQNodeFromBuf(STableBufInfo* pTblBuf, void** pBuf) { + if (pTblBuf->buffOffset < pTblBuf->buffSize) { + *pBuf = (char*)pTblBuf->pCurBuff + pTblBuf->buffOffset; + pTblBuf->buffOffset += pTblBuf->buffUnit; + } else if (pTblBuf->buffIdx < taosArrayGetSize(pTblBuf->pBufList)) { + pTblBuf->pCurBuff = taosArrayGetP(pTblBuf->pBufList, pTblBuf->buffIdx++); + if (NULL == pTblBuf->pCurBuff) { + return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); + } + *pBuf = pTblBuf->pCurBuff; + pTblBuf->buffOffset = pTblBuf->buffUnit; + } else { + void* buff = taosMemoryMalloc(pTblBuf->buffSize); + if (NULL == buff) { + return terrno; + } + + if (taosArrayPush(pTblBuf->pBufList, &buff) == NULL) { + return terrno; + } + + pTblBuf->buffIdx++; + pTblBuf->pCurBuff = buff; + *pBuf = buff; + pTblBuf->buffOffset = pTblBuf->buffUnit; + } + + return TSDB_CODE_SUCCESS; +} + +static bool stmtDequeue(STscStmt2* pStmt, SStmtQNode** param) { + while (0 == atomic_load_64(&pStmt->queue.qRemainNum)) { + taosUsleep(1); + return false; + } + + SStmtQNode* orig = pStmt->queue.head; + + SStmtQNode* node = pStmt->queue.head->next; + pStmt->queue.head = pStmt->queue.head->next; + + // taosMemoryFreeClear(orig); + + *param = node; + + (void)atomic_sub_fetch_64(&pStmt->queue.qRemainNum, 1); + + return true; +} + +static void stmtEnqueue(STscStmt2* pStmt, SStmtQNode* param) { + pStmt->queue.tail->next = param; + pStmt->queue.tail = param; + + pStmt->stat.bindDataNum++; + (void)atomic_add_fetch_64(&pStmt->queue.qRemainNum, 1); +} + +static int32_t stmtCreateRequest(STscStmt2* pStmt) { + int32_t code = 0; + + if (pStmt->exec.pRequest == NULL) { + code = buildRequest(pStmt->taos->id, pStmt->sql.sqlStr, pStmt->sql.sqlLen, NULL, false, &pStmt->exec.pRequest, + pStmt->reqid); + if (pStmt->reqid != 0) { + pStmt->reqid++; + } + if (TSDB_CODE_SUCCESS == code) { + pStmt->exec.pRequest->syncQuery = true; + pStmt->exec.pRequest->isStmtBind = true; + } + } + + return code; +} + +static int32_t stmtSwitchStatus(STscStmt2* pStmt, STMT_STATUS newStatus) { + int32_t code = 0; + + if (newStatus >= STMT_INIT && newStatus < STMT_MAX) { + STMT_LOG_SEQ(newStatus); + } + + if (pStmt->errCode && newStatus != STMT_PREPARE) { + STMT_DLOG("stmt already failed with err: %s", tstrerror(pStmt->errCode)); + return pStmt->errCode; + } + + switch (newStatus) { + case STMT_PREPARE: + pStmt->errCode = 0; + break; + case STMT_SETTBNAME: + if (STMT_STATUS_EQ(INIT)) { + code = TSDB_CODE_TSC_STMT_API_ERROR; + } + if (!pStmt->sql.stbInterlaceMode && (STMT_STATUS_EQ(BIND) || STMT_STATUS_EQ(BIND_COL))) { + code = TSDB_CODE_TSC_STMT_API_ERROR; + } + break; + case STMT_SETTAGS: + if (STMT_STATUS_NE(SETTBNAME) && STMT_STATUS_NE(FETCH_FIELDS)) { + code = TSDB_CODE_TSC_STMT_API_ERROR; + } + break; + case STMT_FETCH_FIELDS: + if (STMT_STATUS_EQ(INIT)) { + code = TSDB_CODE_TSC_STMT_API_ERROR; + } + break; + case STMT_BIND: + if (STMT_STATUS_EQ(INIT) || STMT_STATUS_EQ(BIND_COL)) { + code = TSDB_CODE_TSC_STMT_API_ERROR; + } + /* + if ((pStmt->sql.type == STMT_TYPE_MULTI_INSERT) && ()) { + code = TSDB_CODE_TSC_STMT_API_ERROR; + } + */ + break; + case STMT_BIND_COL: + if (STMT_STATUS_EQ(INIT) || STMT_STATUS_EQ(BIND)) { + code = TSDB_CODE_TSC_STMT_API_ERROR; + } + break; + case STMT_ADD_BATCH: + if (STMT_STATUS_NE(BIND) && STMT_STATUS_NE(BIND_COL) && STMT_STATUS_NE(FETCH_FIELDS)) { + code = TSDB_CODE_TSC_STMT_API_ERROR; + } + break; + case STMT_EXECUTE: + if (STMT_TYPE_QUERY == pStmt->sql.type) { + if (STMT_STATUS_NE(ADD_BATCH) && STMT_STATUS_NE(FETCH_FIELDS) && STMT_STATUS_NE(BIND) && + STMT_STATUS_NE(BIND_COL)) { + code = TSDB_CODE_TSC_STMT_API_ERROR; + } + } else { + if (STMT_STATUS_NE(ADD_BATCH) && STMT_STATUS_NE(FETCH_FIELDS)) { + code = TSDB_CODE_TSC_STMT_API_ERROR; + } + } + break; + default: + code = TSDB_CODE_APP_ERROR; + break; + } + + STMT_ERR_RET(code); + + pStmt->sql.status = newStatus; + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtGetTbName(TAOS_STMT2* stmt, char** tbName) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + pStmt->sql.type = STMT_TYPE_MULTI_INSERT; + + if ('\0' == pStmt->bInfo.tbName[0]) { + tscError("no table name set"); + STMT_ERR_RET(TSDB_CODE_TSC_STMT_TBNAME_ERROR); + } + + *tbName = pStmt->bInfo.tbName; + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtUpdateBindInfo(TAOS_STMT2* stmt, STableMeta* pTableMeta, void* tags, SName* tbName, + const char* sTableName, bool autoCreateTbl) { + STscStmt2* pStmt = (STscStmt2*)stmt; + char tbFName[TSDB_TABLE_FNAME_LEN]; + int32_t code = tNameExtractFullName(tbName, tbFName); + if (code != 0) { + return code; + } + + (void)memcpy(&pStmt->bInfo.sname, tbName, sizeof(*tbName)); + (void)strncpy(pStmt->bInfo.tbFName, tbFName, sizeof(pStmt->bInfo.tbFName) - 1); + pStmt->bInfo.tbFName[sizeof(pStmt->bInfo.tbFName) - 1] = 0; + + pStmt->bInfo.tbUid = autoCreateTbl ? 0 : pTableMeta->uid; + pStmt->bInfo.tbSuid = pTableMeta->suid; + pStmt->bInfo.tbVgId = pTableMeta->vgId; + pStmt->bInfo.tbType = pTableMeta->tableType; + pStmt->bInfo.boundTags = tags; + pStmt->bInfo.tagsCached = false; + tstrncpy(pStmt->bInfo.stbFName, sTableName, sizeof(pStmt->bInfo.stbFName)); + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtUpdateExecInfo(TAOS_STMT2* stmt, SHashObj* pVgHash, SHashObj* pBlockHash) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + pStmt->sql.pVgHash = pVgHash; + pStmt->exec.pBlockHash = pBlockHash; + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtUpdateInfo(TAOS_STMT2* stmt, STableMeta* pTableMeta, void* tags, SName* tbName, bool autoCreateTbl, + SHashObj* pVgHash, SHashObj* pBlockHash, const char* sTableName) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + STMT_ERR_RET(stmtUpdateBindInfo(stmt, pTableMeta, tags, tbName, sTableName, autoCreateTbl)); + STMT_ERR_RET(stmtUpdateExecInfo(stmt, pVgHash, pBlockHash)); + + pStmt->sql.autoCreateTbl = autoCreateTbl; + if (pStmt->sql.autoCreateTbl) { + pStmt->sql.stbInterlaceMode = false; + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtGetExecInfo(TAOS_STMT2* stmt, SHashObj** pVgHash, SHashObj** pBlockHash) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + *pVgHash = pStmt->sql.pVgHash; + pStmt->sql.pVgHash = NULL; + + *pBlockHash = pStmt->exec.pBlockHash; + pStmt->exec.pBlockHash = NULL; + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtParseSql(STscStmt2* pStmt) { + pStmt->exec.pCurrBlock = NULL; + + SStmtCallback stmtCb = { + .pStmt = pStmt, + .getTbNameFn = stmtGetTbName, + .setInfoFn = stmtUpdateInfo, + .getExecInfoFn = stmtGetExecInfo, + }; + + STMT_ERR_RET(stmtCreateRequest(pStmt)); + + pStmt->stat.parseSqlNum++; + STMT_ERR_RET(parseSql(pStmt->exec.pRequest, false, &pStmt->sql.pQuery, &stmtCb)); + pStmt->sql.siInfo.pQuery = pStmt->sql.pQuery; + + pStmt->bInfo.needParse = false; + + if (pStmt->sql.pQuery->pRoot && 0 == pStmt->sql.type) { + pStmt->sql.type = STMT_TYPE_INSERT; + pStmt->sql.stbInterlaceMode = false; + } else if (pStmt->sql.pQuery->pPrepareRoot) { + pStmt->sql.type = STMT_TYPE_QUERY; + pStmt->sql.stbInterlaceMode = false; + + return TSDB_CODE_SUCCESS; + } + + STableDataCxt** pSrc = + (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); + if (NULL == pSrc || NULL == *pSrc) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + STableDataCxt* pTableCtx = *pSrc; + if (pStmt->sql.stbInterlaceMode) { + int16_t lastIdx = -1; + + for (int32_t i = 0; i < pTableCtx->boundColsInfo.numOfBound; ++i) { + if (pTableCtx->boundColsInfo.pColIndex[i] < lastIdx) { + pStmt->sql.stbInterlaceMode = false; + break; + } + + lastIdx = pTableCtx->boundColsInfo.pColIndex[i]; + } + } + + if (NULL == pStmt->sql.pBindInfo) { + pStmt->sql.pBindInfo = taosMemoryMalloc(pTableCtx->boundColsInfo.numOfBound * sizeof(*pStmt->sql.pBindInfo)); + if (NULL == pStmt->sql.pBindInfo) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtCleanBindInfo(STscStmt2* pStmt) { + pStmt->bInfo.tbUid = 0; + pStmt->bInfo.tbSuid = 0; + pStmt->bInfo.tbVgId = -1; + pStmt->bInfo.tbType = 0; + pStmt->bInfo.needParse = true; + pStmt->bInfo.inExecCache = false; + + pStmt->bInfo.tbName[0] = 0; + pStmt->bInfo.tbFName[0] = 0; + if (!pStmt->bInfo.tagsCached) { + qDestroyBoundColInfo(pStmt->bInfo.boundTags); + taosMemoryFreeClear(pStmt->bInfo.boundTags); + } + pStmt->bInfo.stbFName[0] = 0; + + return TSDB_CODE_SUCCESS; +} + +static void stmtFreeTableBlkList(STableColsData* pTb) { + (void)qResetStmtColumns(pTb->aCol, true); + taosArrayDestroy(pTb->aCol); +} + +static void stmtResetQueueTableBuf(STableBufInfo* pTblBuf, SStmtQueue* pQueue) { + pTblBuf->pCurBuff = taosArrayGetP(pTblBuf->pBufList, 0); + if (NULL == pTblBuf->pCurBuff) { + tscError("QInfo:%p, failed to get buffer from list", pTblBuf); + return; + } + pTblBuf->buffIdx = 1; + pTblBuf->buffOffset = sizeof(*pQueue->head); + + pQueue->head = pQueue->tail = pTblBuf->pCurBuff; + pQueue->qRemainNum = 0; + pQueue->head->next = NULL; +} + +static int32_t stmtCleanExecInfo(STscStmt2* pStmt, bool keepTable, bool deepClean) { + if (pStmt->sql.stbInterlaceMode) { + if (deepClean) { + taosHashCleanup(pStmt->exec.pBlockHash); + pStmt->exec.pBlockHash = NULL; + + if (NULL != pStmt->exec.pCurrBlock) { + taosMemoryFreeClear(pStmt->exec.pCurrBlock->pData); + qDestroyStmtDataBlock(pStmt->exec.pCurrBlock); + } + } else { + pStmt->sql.siInfo.pTableColsIdx = 0; + stmtResetQueueTableBuf(&pStmt->sql.siInfo.tbBuf, &pStmt->queue); + } + } else { + if (STMT_TYPE_QUERY != pStmt->sql.type || deepClean) { + // if (!pStmt->options.asyncExecFn) { + taos_free_result(pStmt->exec.pRequest); + pStmt->exec.pRequest = NULL; + //} + } + + size_t keyLen = 0; + void* pIter = taosHashIterate(pStmt->exec.pBlockHash, NULL); + while (pIter) { + STableDataCxt* pBlocks = *(STableDataCxt**)pIter; + char* key = taosHashGetKey(pIter, &keyLen); + STableMeta* pMeta = qGetTableMetaInDataBlock(pBlocks); + + if (keepTable && pBlocks == pStmt->exec.pCurrBlock) { + TSWAP(pBlocks->pData, pStmt->exec.pCurrTbData); + STMT_ERR_RET(qResetStmtDataBlock(pBlocks, false)); + + pIter = taosHashIterate(pStmt->exec.pBlockHash, pIter); + continue; + } + + qDestroyStmtDataBlock(pBlocks); + STMT_ERR_RET(taosHashRemove(pStmt->exec.pBlockHash, key, keyLen)); + + pIter = taosHashIterate(pStmt->exec.pBlockHash, pIter); + } + + if (keepTable) { + return TSDB_CODE_SUCCESS; + } + + taosHashCleanup(pStmt->exec.pBlockHash); + pStmt->exec.pBlockHash = NULL; + + tDestroySubmitTbData(pStmt->exec.pCurrTbData, TSDB_MSG_FLG_ENCODE); + taosMemoryFreeClear(pStmt->exec.pCurrTbData); + } + + STMT_ERR_RET(stmtCleanBindInfo(pStmt)); + + return TSDB_CODE_SUCCESS; +} + +static void stmtFreeTbBuf(void* buf) { + void* pBuf = *(void**)buf; + taosMemoryFree(pBuf); +} + +static void stmtFreeTbCols(void* buf) { + SArray* pCols = *(SArray**)buf; + taosArrayDestroy(pCols); +} + +static int32_t stmtCleanSQLInfo(STscStmt2* pStmt) { + STMT_DLOG_E("start to free SQL info"); + + taosMemoryFree(pStmt->sql.pBindInfo); + taosMemoryFree(pStmt->sql.queryRes.fields); + taosMemoryFree(pStmt->sql.queryRes.userFields); + taosMemoryFree(pStmt->sql.sqlStr); + qDestroyQuery(pStmt->sql.pQuery); + taosArrayDestroy(pStmt->sql.nodeList); + taosHashCleanup(pStmt->sql.pVgHash); + pStmt->sql.pVgHash = NULL; + + void* pIter = taosHashIterate(pStmt->sql.pTableCache, NULL); + while (pIter) { + SStmtTableCache* pCache = (SStmtTableCache*)pIter; + + qDestroyStmtDataBlock(pCache->pDataCtx); + qDestroyBoundColInfo(pCache->boundTags); + taosMemoryFreeClear(pCache->boundTags); + + pIter = taosHashIterate(pStmt->sql.pTableCache, pIter); + } + taosHashCleanup(pStmt->sql.pTableCache); + pStmt->sql.pTableCache = NULL; + + STMT_ERR_RET(stmtCleanExecInfo(pStmt, false, true)); + STMT_ERR_RET(stmtCleanBindInfo(pStmt)); + + taos_free_result(pStmt->sql.siInfo.pRequest); + taosHashCleanup(pStmt->sql.siInfo.pVgroupHash); + tSimpleHashCleanup(pStmt->sql.siInfo.pTableHash); + taosArrayDestroyEx(pStmt->sql.siInfo.tbBuf.pBufList, stmtFreeTbBuf); + taosMemoryFree(pStmt->sql.siInfo.pTSchema); + qDestroyStmtDataBlock(pStmt->sql.siInfo.pDataCtx); + taosArrayDestroyEx(pStmt->sql.siInfo.pTableCols, stmtFreeTbCols); + + (void)memset(&pStmt->sql, 0, sizeof(pStmt->sql)); + pStmt->sql.siInfo.tableColsReady = true; + + STMT_DLOG_E("end to free SQL info"); + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtTryAddTableVgroupInfo(STscStmt2* pStmt, int32_t* vgId) { + if (*vgId >= 0 && taosHashGet(pStmt->sql.pVgHash, (const char*)vgId, sizeof(*vgId))) { + return TSDB_CODE_SUCCESS; + } + + SVgroupInfo vgInfo = {0}; + SRequestConnInfo conn = {.pTrans = pStmt->taos->pAppInfo->pTransporter, + .requestId = pStmt->exec.pRequest->requestId, + .requestObjRefId = pStmt->exec.pRequest->self, + .mgmtEps = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp)}; + + int32_t code = catalogGetTableHashVgroup(pStmt->pCatalog, &conn, &pStmt->bInfo.sname, &vgInfo); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + + code = + taosHashPut(pStmt->sql.pVgHash, (const char*)&vgInfo.vgId, sizeof(vgInfo.vgId), (char*)&vgInfo, sizeof(vgInfo)); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + + *vgId = vgInfo.vgId; + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtRebuildDataBlock(STscStmt2* pStmt, STableDataCxt* pDataBlock, STableDataCxt** newBlock, uint64_t uid, + uint64_t suid, int32_t vgId) { + STMT_ERR_RET(stmtTryAddTableVgroupInfo(pStmt, &vgId)); + STMT_ERR_RET(qRebuildStmtDataBlock(newBlock, pDataBlock, uid, suid, vgId, pStmt->sql.autoCreateTbl)); + + STMT_DLOG("tableDataCxt rebuilt, uid:%" PRId64 ", vgId:%d", uid, vgId); + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtGetFromCache(STscStmt2* pStmt) { + if (pStmt->sql.stbInterlaceMode && pStmt->sql.siInfo.pDataCtx) { + pStmt->bInfo.needParse = false; + pStmt->bInfo.inExecCache = false; + return TSDB_CODE_SUCCESS; + } + + pStmt->bInfo.needParse = true; + pStmt->bInfo.inExecCache = false; + + STableDataCxt** pCxtInExec = taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); + if (pCxtInExec) { + pStmt->bInfo.needParse = false; + pStmt->bInfo.inExecCache = true; + + pStmt->exec.pCurrBlock = *pCxtInExec; + + if (pStmt->sql.autoCreateTbl) { + tscDebug("reuse stmt block for tb %s in execBlock", pStmt->bInfo.tbFName); + return TSDB_CODE_SUCCESS; + } + } + + if (NULL == pStmt->pCatalog) { + STMT_ERR_RET(catalogGetHandle(pStmt->taos->pAppInfo->clusterId, &pStmt->pCatalog)); + pStmt->sql.siInfo.pCatalog = pStmt->pCatalog; + } + + if (NULL == pStmt->sql.pTableCache || taosHashGetSize(pStmt->sql.pTableCache) <= 0) { + if (pStmt->bInfo.inExecCache) { + pStmt->bInfo.needParse = false; + tscDebug("reuse stmt block for tb %s in execBlock", pStmt->bInfo.tbFName); + return TSDB_CODE_SUCCESS; + } + + tscDebug("no stmt block cache for tb %s", pStmt->bInfo.tbFName); + return TSDB_CODE_SUCCESS; + } + + if (pStmt->sql.autoCreateTbl) { + SStmtTableCache* pCache = taosHashGet(pStmt->sql.pTableCache, &pStmt->bInfo.tbSuid, sizeof(pStmt->bInfo.tbSuid)); + if (pCache) { + pStmt->bInfo.needParse = false; + pStmt->bInfo.tbUid = 0; + + STableDataCxt* pNewBlock = NULL; + STMT_ERR_RET(stmtRebuildDataBlock(pStmt, pCache->pDataCtx, &pNewBlock, 0, pStmt->bInfo.tbSuid, -1)); + + if (taosHashPut(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName), &pNewBlock, + POINTER_BYTES)) { + STMT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + + pStmt->exec.pCurrBlock = pNewBlock; + + tscDebug("reuse stmt block for tb %s in sqlBlock, suid:0x%" PRIx64, pStmt->bInfo.tbFName, pStmt->bInfo.tbSuid); + + return TSDB_CODE_SUCCESS; + } + + STMT_RET(stmtCleanBindInfo(pStmt)); + } + + uint64_t uid, suid; + int32_t vgId; + int8_t tableType; + + STableMeta* pTableMeta = NULL; + SRequestConnInfo conn = {.pTrans = pStmt->taos->pAppInfo->pTransporter, + .requestId = pStmt->exec.pRequest->requestId, + .requestObjRefId = pStmt->exec.pRequest->self, + .mgmtEps = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp)}; + int32_t code = catalogGetTableMeta(pStmt->pCatalog, &conn, &pStmt->bInfo.sname, &pTableMeta); + + pStmt->stat.ctgGetTbMetaNum++; + + if (TSDB_CODE_PAR_TABLE_NOT_EXIST == code) { + tscDebug("tb %s not exist", pStmt->bInfo.tbFName); + STMT_ERR_RET(stmtCleanBindInfo(pStmt)); + + STMT_ERR_RET(code); + } + + STMT_ERR_RET(code); + + uid = pTableMeta->uid; + suid = pTableMeta->suid; + tableType = pTableMeta->tableType; + pStmt->bInfo.tbVgId = pTableMeta->vgId; + vgId = pTableMeta->vgId; + + taosMemoryFree(pTableMeta); + + uint64_t cacheUid = (TSDB_CHILD_TABLE == tableType) ? suid : uid; + + if (uid == pStmt->bInfo.tbUid) { + pStmt->bInfo.needParse = false; + + tscDebug("tb %s is current table", pStmt->bInfo.tbFName); + + return TSDB_CODE_SUCCESS; + } + + if (pStmt->bInfo.inExecCache) { + SStmtTableCache* pCache = taosHashGet(pStmt->sql.pTableCache, &cacheUid, sizeof(cacheUid)); + if (NULL == pCache) { + tscError("table [%s, %" PRIx64 ", %" PRIx64 "] found in exec blockHash, but not in sql blockHash", + pStmt->bInfo.tbFName, uid, cacheUid); + + STMT_ERR_RET(TSDB_CODE_APP_ERROR); + } + + pStmt->bInfo.needParse = false; + + pStmt->bInfo.tbUid = uid; + pStmt->bInfo.tbSuid = suid; + pStmt->bInfo.tbType = tableType; + pStmt->bInfo.boundTags = pCache->boundTags; + pStmt->bInfo.tagsCached = true; + + tscDebug("tb %s in execBlock list, set to current", pStmt->bInfo.tbFName); + + return TSDB_CODE_SUCCESS; + } + + SStmtTableCache* pCache = taosHashGet(pStmt->sql.pTableCache, &cacheUid, sizeof(cacheUid)); + if (pCache) { + pStmt->bInfo.needParse = false; + + pStmt->bInfo.tbUid = uid; + pStmt->bInfo.tbSuid = suid; + pStmt->bInfo.tbType = tableType; + pStmt->bInfo.boundTags = pCache->boundTags; + pStmt->bInfo.tagsCached = true; + + STableDataCxt* pNewBlock = NULL; + STMT_ERR_RET(stmtRebuildDataBlock(pStmt, pCache->pDataCtx, &pNewBlock, uid, suid, vgId)); + + if (taosHashPut(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName), &pNewBlock, + POINTER_BYTES)) { + STMT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + + pStmt->exec.pCurrBlock = pNewBlock; + + tscDebug("tb %s in sqlBlock list, set to current", pStmt->bInfo.tbFName); + + return TSDB_CODE_SUCCESS; + } + + STMT_ERR_RET(stmtCleanBindInfo(pStmt)); + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtResetStmt(STscStmt2* pStmt) { + STMT_ERR_RET(stmtCleanSQLInfo(pStmt)); + + pStmt->sql.pTableCache = taosHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); + if (NULL == pStmt->sql.pTableCache) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + STMT_ERR_RET(terrno); + } + + pStmt->sql.status = STMT_INIT; + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtAsyncOutput(STscStmt2* pStmt, void* param) { + SStmtQNode* pParam = (SStmtQNode*)param; + + if (pParam->restoreTbCols) { + for (int32_t i = 0; i < pStmt->sql.siInfo.pTableColsIdx; ++i) { + SArray** p = (SArray**)TARRAY_GET_ELEM(pStmt->sql.siInfo.pTableCols, i); + *p = taosArrayInit(20, POINTER_BYTES); + if (*p == NULL) { + STMT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + } + + atomic_store_8((int8_t*)&pStmt->sql.siInfo.tableColsReady, true); + } else { + STMT_ERR_RET(qAppendStmtTableOutput(pStmt->sql.pQuery, pStmt->sql.pVgHash, &pParam->tblData, pStmt->exec.pCurrBlock, + &pStmt->sql.siInfo)); + + // taosMemoryFree(pParam->pTbData); + + (void)atomic_sub_fetch_64(&pStmt->sql.siInfo.tbRemainNum, 1); + } + return TSDB_CODE_SUCCESS; +} + +static void* stmtBindThreadFunc(void* param) { + setThreadName("stmtBind"); + + qInfo("stmt bind thread started"); + + STscStmt2* pStmt = (STscStmt2*)param; + + while (true) { + if (atomic_load_8((int8_t*)&pStmt->queue.stopQueue)) { + break; + } + + SStmtQNode* asyncParam = NULL; + if (!stmtDequeue(pStmt, &asyncParam)) { + continue; + } + + (void)stmtAsyncOutput(pStmt, asyncParam); + } + + qInfo("stmt bind thread stopped"); + + return NULL; +} + +static int32_t stmtStartBindThread(STscStmt2* pStmt) { + TdThreadAttr thAttr; + if (taosThreadAttrInit(&thAttr) != 0) { + return TSDB_CODE_TSC_INTERNAL_ERROR; + } + if (taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE) != 0) { + return TSDB_CODE_TSC_INTERNAL_ERROR; + } + + if (taosThreadCreate(&pStmt->bindThread, &thAttr, stmtBindThreadFunc, pStmt) != 0) { + terrno = TAOS_SYSTEM_ERROR(errno); + STMT_ERR_RET(terrno); + } + + pStmt->bindThreadInUse = true; + + (void)taosThreadAttrDestroy(&thAttr); + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtInitQueue(STscStmt2* pStmt) { + STMT_ERR_RET(stmtAllocQNodeFromBuf(&pStmt->sql.siInfo.tbBuf, (void**)&pStmt->queue.head)); + pStmt->queue.tail = pStmt->queue.head; + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtInitTableBuf(STableBufInfo* pTblBuf) { + pTblBuf->buffUnit = sizeof(SStmtQNode); + pTblBuf->buffSize = pTblBuf->buffUnit * 1000; + pTblBuf->pBufList = taosArrayInit(100, POINTER_BYTES); + if (NULL == pTblBuf->pBufList) { + return TSDB_CODE_OUT_OF_MEMORY; + } + void* buff = taosMemoryMalloc(pTblBuf->buffSize); + if (NULL == buff) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + if (taosArrayPush(pTblBuf->pBufList, &buff) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + pTblBuf->pCurBuff = buff; + pTblBuf->buffIdx = 1; + pTblBuf->buffOffset = 0; + + return TSDB_CODE_SUCCESS; +} + +TAOS_STMT2* stmtInit2(STscObj* taos, TAOS_STMT2_OPTION* pOptions) { + STscObj* pObj = (STscObj*)taos; + STscStmt2* pStmt = NULL; + int32_t code = 0; + + pStmt = taosMemoryCalloc(1, sizeof(STscStmt2)); + if (NULL == pStmt) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } + + pStmt->sql.pTableCache = taosHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); + if (NULL == pStmt->sql.pTableCache) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + taosMemoryFree(pStmt); + return NULL; + } + + pStmt->taos = pObj; + pStmt->bInfo.needParse = true; + pStmt->sql.status = STMT_INIT; + pStmt->errCode = TSDB_CODE_SUCCESS; + + if (NULL != pOptions) { + (void)memcpy(&pStmt->options, pOptions, sizeof(pStmt->options)); + if (pOptions->singleStbInsert && pOptions->singleTableBindOnce) { + pStmt->stbInterlaceMode = true; + } + + pStmt->reqid = pOptions->reqid; + } + + if (pStmt->stbInterlaceMode) { + pStmt->sql.siInfo.transport = taos->pAppInfo->pTransporter; + pStmt->sql.siInfo.acctId = taos->acctId; + pStmt->sql.siInfo.dbname = taos->db; + pStmt->sql.siInfo.mgmtEpSet = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp); + pStmt->sql.siInfo.pTableHash = tSimpleHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY)); + if (NULL == pStmt->sql.siInfo.pTableHash) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + (void)stmtClose(pStmt); + return NULL; + } + pStmt->sql.siInfo.pTableCols = taosArrayInit(STMT_TABLE_COLS_NUM, POINTER_BYTES); + if (NULL == pStmt->sql.siInfo.pTableCols) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + (void)stmtClose(pStmt); + return NULL; + } + + code = stmtInitTableBuf(&pStmt->sql.siInfo.tbBuf); + if (TSDB_CODE_SUCCESS == code) { + code = stmtInitQueue(pStmt); + } + if (TSDB_CODE_SUCCESS == code) { + code = stmtStartBindThread(pStmt); + } + if (TSDB_CODE_SUCCESS != code) { + terrno = code; + (void)stmtClose(pStmt); + return NULL; + } + } + + pStmt->sql.siInfo.tableColsReady = true; + if (pStmt->options.asyncExecFn) { + (void)tsem_init(&pStmt->asyncQuerySem, 0, 1); + } + + STMT_LOG_SEQ(STMT_INIT); + + tscDebug("stmt:%p initialized", pStmt); + + return pStmt; +} + +static int stmtSetDbName2(TAOS_STMT2* stmt, const char* dbName) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + STMT_DLOG("start to set dbName: %s", dbName); + + STMT_ERR_RET(stmtCreateRequest(pStmt)); + + // The SQL statement specifies a database name, overriding the previously specified database + taosMemoryFreeClear(pStmt->exec.pRequest->pDb); + pStmt->exec.pRequest->pDb = taosStrdup(dbName); + if (pStmt->exec.pRequest->pDb == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + return TSDB_CODE_SUCCESS; +} + +int stmtPrepare2(TAOS_STMT2* stmt, const char* sql, unsigned long length) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + STMT_DLOG_E("start to prepare"); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + if (pStmt->sql.status >= STMT_PREPARE) { + STMT_ERR_RET(stmtResetStmt(pStmt)); + } + + STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_PREPARE)); + + if (length <= 0) { + length = strlen(sql); + } + + pStmt->sql.sqlStr = strndup(sql, length); + pStmt->sql.sqlLen = length; + pStmt->sql.stbInterlaceMode = pStmt->stbInterlaceMode; + + char* dbName = NULL; + if (qParseDbName(sql, length, &dbName)) { + STMT_ERR_RET(stmtSetDbName2(stmt, dbName)); + taosMemoryFreeClear(dbName); + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtInitStbInterlaceTableInfo(STscStmt2* pStmt) { + STableDataCxt** pSrc = taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); + if (!pSrc) { + return TSDB_CODE_OUT_OF_MEMORY; + } + STableDataCxt* pDst = NULL; + + STMT_ERR_RET(qCloneStmtDataBlock(&pDst, *pSrc, true)); + pStmt->sql.siInfo.pDataCtx = pDst; + + SArray* pTblCols = NULL; + for (int32_t i = 0; i < STMT_TABLE_COLS_NUM; i++) { + pTblCols = taosArrayInit(20, POINTER_BYTES); + if (NULL == pTblCols) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + if (taosArrayPush(pStmt->sql.siInfo.pTableCols, &pTblCols) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + pStmt->sql.siInfo.boundTags = pStmt->bInfo.boundTags; + + return TSDB_CODE_SUCCESS; +} + +int stmtIsInsert2(TAOS_STMT2* stmt, int* insert) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + STMT_DLOG_E("start is insert"); + + if (pStmt->sql.type) { + *insert = (STMT_TYPE_INSERT == pStmt->sql.type || STMT_TYPE_MULTI_INSERT == pStmt->sql.type); + } else { + *insert = qIsInsertValuesSql(pStmt->sql.sqlStr, pStmt->sql.sqlLen); + } + + return TSDB_CODE_SUCCESS; +} + +int stmtSetTbName2(TAOS_STMT2* stmt, const char* tbName) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + int64_t startUs = taosGetTimestampUs(); + + STMT_DLOG("start to set tbName: %s", tbName); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_SETTBNAME)); + + int32_t insert = 0; + STMT_ERR_RET(stmtIsInsert2(stmt, &insert)); + if (0 == insert) { + tscError("set tb name not available for none insert statement"); + STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR); + } + + if (!pStmt->sql.stbInterlaceMode || NULL == pStmt->sql.siInfo.pDataCtx) { + STMT_ERR_RET(stmtCreateRequest(pStmt)); + + STMT_ERR_RET(qCreateSName(&pStmt->bInfo.sname, tbName, pStmt->taos->acctId, pStmt->exec.pRequest->pDb, + pStmt->exec.pRequest->msgBuf, pStmt->exec.pRequest->msgBufLen)); + STMT_ERR_RET(tNameExtractFullName(&pStmt->bInfo.sname, pStmt->bInfo.tbFName)); + + STMT_ERR_RET(stmtGetFromCache(pStmt)); + + if (pStmt->bInfo.needParse) { + (void)strncpy(pStmt->bInfo.tbName, tbName, sizeof(pStmt->bInfo.tbName) - 1); + pStmt->bInfo.tbName[sizeof(pStmt->bInfo.tbName) - 1] = 0; + + STMT_ERR_RET(stmtParseSql(pStmt)); + } + } else { + (void)strncpy(pStmt->bInfo.tbName, tbName, sizeof(pStmt->bInfo.tbName) - 1); + pStmt->bInfo.tbName[sizeof(pStmt->bInfo.tbName) - 1] = 0; + pStmt->exec.pRequest->requestId++; + pStmt->bInfo.needParse = false; + } + + if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { + STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); + } + + int64_t startUs2 = taosGetTimestampUs(); + pStmt->stat.setTbNameUs += startUs2 - startUs; + + return TSDB_CODE_SUCCESS; +} + +int stmtSetTbTags2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* tags) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + STMT_DLOG_E("start to set tbTags"); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_SETTAGS)); + + SBoundColInfo* tags_info = (SBoundColInfo*)pStmt->bInfo.boundTags; + if (tags_info->numOfBound <= 0 || tags_info->numOfCols <= 0) { + tscWarn("no tags or cols bound in sql, will not bound tags"); + return TSDB_CODE_SUCCESS; + } + + if (pStmt->bInfo.inExecCache) { + return TSDB_CODE_SUCCESS; + } + + STableDataCxt** pDataBlock = + (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); + if (NULL == pDataBlock) { + tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName); + STMT_ERR_RET(TSDB_CODE_APP_ERROR); + } + + tscDebug("start to bind stmt tag values"); + STMT_ERR_RET(qBindStmtTagsValue2(*pDataBlock, pStmt->bInfo.boundTags, pStmt->bInfo.tbSuid, pStmt->bInfo.stbFName, + pStmt->bInfo.sname.tname, tags, pStmt->exec.pRequest->msgBuf, + pStmt->exec.pRequest->msgBufLen)); + + return TSDB_CODE_SUCCESS; +} + +static int stmtFetchTagFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIELD_E** fields) { + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + if (STMT_TYPE_QUERY == pStmt->sql.type) { + tscError("invalid operation to get query tag fileds"); + STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR); + } + + STableDataCxt** pDataBlock = + (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); + if (NULL == pDataBlock) { + tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName); + STMT_ERR_RET(TSDB_CODE_APP_ERROR); + } + + STMT_ERR_RET(qBuildStmtTagFields(*pDataBlock, pStmt->bInfo.boundTags, fieldNum, fields)); + + return TSDB_CODE_SUCCESS; +} + +static int stmtFetchColFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIELD_E** fields) { + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + if (STMT_TYPE_QUERY == pStmt->sql.type) { + tscError("invalid operation to get query column fileds"); + STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR); + } + + STableDataCxt** pDataBlock = NULL; + + if (pStmt->sql.stbInterlaceMode) { + pDataBlock = &pStmt->sql.siInfo.pDataCtx; + } else { + pDataBlock = + (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); + if (NULL == pDataBlock) { + tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName); + STMT_ERR_RET(TSDB_CODE_APP_ERROR); + } + } + + STMT_ERR_RET(qBuildStmtColFields(*pDataBlock, fieldNum, fields)); + + return TSDB_CODE_SUCCESS; +} +/* +SArray* stmtGetFreeCol(STscStmt2* pStmt, int32_t* idx) { + while (true) { + if (pStmt->exec.smInfo.pColIdx >= STMT_COL_BUF_SIZE) { + pStmt->exec.smInfo.pColIdx = 0; + } + + if ((pStmt->exec.smInfo.pColIdx + 1) == atomic_load_32(&pStmt->exec.smInfo.pColFreeIdx)) { + taosUsleep(1); + continue; + } + + *idx = pStmt->exec.smInfo.pColIdx; + return pStmt->exec.smInfo.pCols[pStmt->exec.smInfo.pColIdx++]; + } +} +*/ +static int32_t stmtAppendTablePostHandle(STscStmt2* pStmt, SStmtQNode* param) { + if (NULL == pStmt->sql.siInfo.pVgroupHash) { + pStmt->sql.siInfo.pVgroupHash = + taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_ENTRY_LOCK); + } + if (NULL == pStmt->sql.siInfo.pVgroupList) { + pStmt->sql.siInfo.pVgroupList = taosArrayInit(64, POINTER_BYTES); + } + + if (NULL == pStmt->sql.siInfo.pRequest) { + STMT_ERR_RET(buildRequest(pStmt->taos->id, pStmt->sql.sqlStr, pStmt->sql.sqlLen, NULL, false, + (SRequestObj**)&pStmt->sql.siInfo.pRequest, pStmt->reqid)); + + if (pStmt->reqid != 0) { + pStmt->reqid++; + } + pStmt->exec.pRequest->syncQuery = true; + + pStmt->sql.siInfo.requestId = ((SRequestObj*)pStmt->sql.siInfo.pRequest)->requestId; + pStmt->sql.siInfo.requestSelf = ((SRequestObj*)pStmt->sql.siInfo.pRequest)->self; + } + + if (!pStmt->sql.siInfo.tbFromHash && pStmt->sql.siInfo.firstName[0] && + 0 == strcmp(pStmt->sql.siInfo.firstName, pStmt->bInfo.tbName)) { + pStmt->sql.siInfo.tbFromHash = true; + } + + if (0 == pStmt->sql.siInfo.firstName[0]) { + (void)strcpy(pStmt->sql.siInfo.firstName, pStmt->bInfo.tbName); + } + + param->tblData.getFromHash = pStmt->sql.siInfo.tbFromHash; + param->next = NULL; + + (void)atomic_add_fetch_64(&pStmt->sql.siInfo.tbRemainNum, 1); + + stmtEnqueue(pStmt, param); + + return TSDB_CODE_SUCCESS; +} + +static FORCE_INLINE int32_t stmtGetTableColsFromCache(STscStmt2* pStmt, SArray** pTableCols) { + while (true) { + if (pStmt->sql.siInfo.pTableColsIdx < taosArrayGetSize(pStmt->sql.siInfo.pTableCols)) { + *pTableCols = (SArray*)taosArrayGetP(pStmt->sql.siInfo.pTableCols, pStmt->sql.siInfo.pTableColsIdx++); + break; + } else { + SArray* pTblCols = NULL; + for (int32_t i = 0; i < 100; i++) { + pTblCols = taosArrayInit(20, POINTER_BYTES); + if (NULL == pTblCols) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + if (taosArrayPush(pStmt->sql.siInfo.pTableCols, &pTblCols) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + } + } + } + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtCacheBlock(STscStmt2* pStmt) { + if (pStmt->sql.type != STMT_TYPE_MULTI_INSERT) { + return TSDB_CODE_SUCCESS; + } + + uint64_t uid = pStmt->bInfo.tbUid; + uint64_t cacheUid = (TSDB_CHILD_TABLE == pStmt->bInfo.tbType) ? pStmt->bInfo.tbSuid : uid; + + if (taosHashGet(pStmt->sql.pTableCache, &cacheUid, sizeof(cacheUid))) { + return TSDB_CODE_SUCCESS; + } + + STableDataCxt** pSrc = taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); + if (!pSrc) { + return TSDB_CODE_OUT_OF_MEMORY; + } + STableDataCxt* pDst = NULL; + + STMT_ERR_RET(qCloneStmtDataBlock(&pDst, *pSrc, true)); + + SStmtTableCache cache = { + .pDataCtx = pDst, + .boundTags = pStmt->bInfo.boundTags, + }; + + if (taosHashPut(pStmt->sql.pTableCache, &cacheUid, sizeof(cacheUid), &cache, sizeof(cache))) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + if (pStmt->sql.autoCreateTbl) { + pStmt->bInfo.tagsCached = true; + } else { + pStmt->bInfo.boundTags = NULL; + } + + return TSDB_CODE_SUCCESS; +} + +static int stmtAddBatch2(TAOS_STMT2* stmt) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + int64_t startUs = taosGetTimestampUs(); + + STMT_DLOG_E("start to add batch"); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_ADD_BATCH)); + + if (pStmt->sql.stbInterlaceMode) { + int64_t startUs2 = taosGetTimestampUs(); + pStmt->stat.addBatchUs += startUs2 - startUs; + + pStmt->sql.siInfo.tableColsReady = false; + + SStmtQNode* param = NULL; + STMT_ERR_RET(stmtAllocQNodeFromBuf(&pStmt->sql.siInfo.tbBuf, (void**)¶m)); + param->restoreTbCols = true; + param->next = NULL; + + stmtEnqueue(pStmt, param); + + return TSDB_CODE_SUCCESS; + } + + STMT_ERR_RET(stmtCacheBlock(pStmt)); + + return TSDB_CODE_SUCCESS; +} +/* +static int32_t stmtBackupQueryFields(STscStmt2* pStmt) { + SStmtQueryResInfo* pRes = &pStmt->sql.queryRes; + pRes->numOfCols = pStmt->exec.pRequest->body.resInfo.numOfCols; + pRes->precision = pStmt->exec.pRequest->body.resInfo.precision; + + int32_t size = pRes->numOfCols * sizeof(TAOS_FIELD); + pRes->fields = taosMemoryMalloc(size); + pRes->userFields = taosMemoryMalloc(size); + if (NULL == pRes->fields || NULL == pRes->userFields) { + STMT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + (void)memcpy(pRes->fields, pStmt->exec.pRequest->body.resInfo.fields, size); + (void)memcpy(pRes->userFields, pStmt->exec.pRequest->body.resInfo.userFields, size); + + return TSDB_CODE_SUCCESS; +} + +static int32_t stmtRestoreQueryFields(STscStmt2* pStmt) { + SStmtQueryResInfo* pRes = &pStmt->sql.queryRes; + int32_t size = pRes->numOfCols * sizeof(TAOS_FIELD); + + pStmt->exec.pRequest->body.resInfo.numOfCols = pRes->numOfCols; + pStmt->exec.pRequest->body.resInfo.precision = pRes->precision; + + if (NULL == pStmt->exec.pRequest->body.resInfo.fields) { + pStmt->exec.pRequest->body.resInfo.fields = taosMemoryMalloc(size); + if (NULL == pStmt->exec.pRequest->body.resInfo.fields) { + STMT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + (void)memcpy(pStmt->exec.pRequest->body.resInfo.fields, pRes->fields, size); + } + + if (NULL == pStmt->exec.pRequest->body.resInfo.userFields) { + pStmt->exec.pRequest->body.resInfo.userFields = taosMemoryMalloc(size); + if (NULL == pStmt->exec.pRequest->body.resInfo.userFields) { + STMT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + (void)memcpy(pStmt->exec.pRequest->body.resInfo.userFields, pRes->userFields, size); + } + + return TSDB_CODE_SUCCESS; +} +*/ +int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { + STscStmt2* pStmt = (STscStmt2*)stmt; + int32_t code = 0; + + int64_t startUs = taosGetTimestampUs(); + + STMT_DLOG("start to bind stmt data, colIdx: %d", colIdx); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_BIND)); + + if (pStmt->options.asyncExecFn) { + (void)tsem_wait(&pStmt->asyncQuerySem); + } + + if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 && + STMT_TYPE_MULTI_INSERT != pStmt->sql.type) { + pStmt->bInfo.needParse = false; + } + + if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) { + taos_free_result(pStmt->exec.pRequest); + pStmt->exec.pRequest = NULL; + } + + STMT_ERR_RET(stmtCreateRequest(pStmt)); + + if (pStmt->bInfo.needParse) { + STMT_ERR_RET(stmtParseSql(pStmt)); + } + + if (STMT_TYPE_QUERY == pStmt->sql.type) { + STMT_ERR_RET(qStmtBindParams2(pStmt->sql.pQuery, bind, colIdx)); + + SParseContext ctx = {.requestId = pStmt->exec.pRequest->requestId, + .acctId = pStmt->taos->acctId, + .db = pStmt->exec.pRequest->pDb, + .topicQuery = false, + .pSql = pStmt->sql.sqlStr, + .sqlLen = pStmt->sql.sqlLen, + .pMsg = pStmt->exec.pRequest->msgBuf, + .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE, + .pTransporter = pStmt->taos->pAppInfo->pTransporter, + .pStmtCb = NULL, + .pUser = pStmt->taos->user}; + ctx.mgmtEpSet = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp); + STMT_ERR_RET(catalogGetHandle(pStmt->taos->pAppInfo->clusterId, &ctx.pCatalog)); + + STMT_ERR_RET(qStmtParseQuerySql(&ctx, pStmt->sql.pQuery)); + + if (pStmt->sql.pQuery->haveResultSet) { + STMT_ERR_RET(setResSchemaInfo(&pStmt->exec.pRequest->body.resInfo, pStmt->sql.pQuery->pResSchema, + pStmt->sql.pQuery->numOfResCols)); + taosMemoryFreeClear(pStmt->sql.pQuery->pResSchema); + setResPrecision(&pStmt->exec.pRequest->body.resInfo, pStmt->sql.pQuery->precision); + } + + TSWAP(pStmt->exec.pRequest->dbList, pStmt->sql.pQuery->pDbList); + TSWAP(pStmt->exec.pRequest->tableList, pStmt->sql.pQuery->pTableList); + TSWAP(pStmt->exec.pRequest->targetTableList, pStmt->sql.pQuery->pTargetTableList); + + // if (STMT_TYPE_QUERY == pStmt->sql.queryRes) { + // STMT_ERR_RET(stmtRestoreQueryFields(pStmt)); + // } + + // STMT_ERR_RET(stmtBackupQueryFields(pStmt)); + + return TSDB_CODE_SUCCESS; + } + + if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { + STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); + } + + STableDataCxt** pDataBlock = NULL; + + if (pStmt->exec.pCurrBlock) { + pDataBlock = &pStmt->exec.pCurrBlock; + } else { + pDataBlock = + (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); + if (NULL == pDataBlock) { + tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName); + STMT_ERR_RET(TSDB_CODE_TSC_STMT_CACHE_ERROR); + } + pStmt->exec.pCurrBlock = *pDataBlock; + if (pStmt->sql.stbInterlaceMode) { + taosArrayDestroy(pStmt->exec.pCurrBlock->pData->aCol); + pStmt->exec.pCurrBlock->pData->aCol = NULL; + } + } + + int64_t startUs2 = taosGetTimestampUs(); + pStmt->stat.bindDataUs1 += startUs2 - startUs; + + SStmtQNode* param = NULL; + if (pStmt->sql.stbInterlaceMode) { + STMT_ERR_RET(stmtAllocQNodeFromBuf(&pStmt->sql.siInfo.tbBuf, (void**)¶m)); + STMT_ERR_RET(stmtGetTableColsFromCache(pStmt, ¶m->tblData.aCol)); + taosArrayClear(param->tblData.aCol); + + // param->tblData.aCol = taosArrayInit(20, POINTER_BYTES); + + param->restoreTbCols = false; + (void)strcpy(param->tblData.tbName, pStmt->bInfo.tbName); + } + + int64_t startUs3 = taosGetTimestampUs(); + pStmt->stat.bindDataUs2 += startUs3 - startUs2; + + SArray* pCols = pStmt->sql.stbInterlaceMode ? param->tblData.aCol : (*pDataBlock)->pData->aCol; + + if (colIdx < 0) { + if (pStmt->sql.stbInterlaceMode) { + (*pDataBlock)->pData->flags = 0; + code = qBindStmtStbColsValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, + pStmt->exec.pRequest->msgBufLen, &pStmt->sql.siInfo.pTSchema, pStmt->sql.pBindInfo); + } else { + code = + qBindStmtColsValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, pStmt->exec.pRequest->msgBufLen); + } + + if (code) { + tscError("qBindStmtColsValue failed, error:%s", tstrerror(code)); + STMT_ERR_RET(code); + } + } else { + if (pStmt->sql.stbInterlaceMode) { + tscError("bind single column not allowed in stb insert mode"); + STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR); + } + + if (colIdx != (pStmt->bInfo.sBindLastIdx + 1) && colIdx != 0) { + tscError("bind column index not in sequence"); + STMT_ERR_RET(TSDB_CODE_APP_ERROR); + } + + pStmt->bInfo.sBindLastIdx = colIdx; + + if (0 == colIdx) { + pStmt->bInfo.sBindRowNum = bind->num; + } + + code = qBindStmtSingleColValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, + pStmt->exec.pRequest->msgBufLen, colIdx, pStmt->bInfo.sBindRowNum); + if (code) { + tscError("qBindStmtSingleColValue failed, error:%s", tstrerror(code)); + STMT_ERR_RET(code); + } + } + + int64_t startUs4 = taosGetTimestampUs(); + pStmt->stat.bindDataUs3 += startUs4 - startUs3; + + if (pStmt->sql.stbInterlaceMode) { + STMT_ERR_RET(stmtAppendTablePostHandle(pStmt, param)); + } + + STMT_ERR_RET(stmtAddBatch2(pStmt)); + + pStmt->stat.bindDataUs4 += taosGetTimestampUs() - startUs4; + + return TSDB_CODE_SUCCESS; +} +/* +int stmtUpdateTableUid(STscStmt2* pStmt, SSubmitRsp* pRsp) { + tscDebug("stmt start to update tbUid, blockNum: %d", pRsp->nBlocks); + + int32_t code = 0; + int32_t finalCode = 0; + size_t keyLen = 0; + void* pIter = taosHashIterate(pStmt->exec.pBlockHash, NULL); + while (pIter) { + STableDataCxt* pBlock = *(STableDataCxt**)pIter; + char* key = taosHashGetKey(pIter, &keyLen); + + STableMeta* pMeta = qGetTableMetaInDataBlock(pBlock); + if (pMeta->uid) { + pIter = taosHashIterate(pStmt->exec.pBlockHash, pIter); + continue; + } + + SSubmitBlkRsp* blkRsp = NULL; + int32_t i = 0; + for (; i < pRsp->nBlocks; ++i) { + blkRsp = pRsp->pBlocks + i; + if (strlen(blkRsp->tblFName) != keyLen) { + continue; + } + + if (strncmp(blkRsp->tblFName, key, keyLen)) { + continue; + } + + break; + } + + if (i < pRsp->nBlocks) { + tscDebug("auto created table %s uid updated from %" PRIx64 " to %" PRIx64, blkRsp->tblFName, pMeta->uid, + blkRsp->uid); + + pMeta->uid = blkRsp->uid; + pStmt->bInfo.tbUid = blkRsp->uid; + } else { + tscDebug("table %s not found in submit rsp, will update from catalog", pStmt->bInfo.tbFName); + if (NULL == pStmt->pCatalog) { + code = catalogGetHandle(pStmt->taos->pAppInfo->clusterId, &pStmt->pCatalog); + if (code) { + pIter = taosHashIterate(pStmt->exec.pBlockHash, pIter); + finalCode = code; + continue; + } + } + + code = stmtCreateRequest(pStmt); + if (code) { + pIter = taosHashIterate(pStmt->exec.pBlockHash, pIter); + finalCode = code; + continue; + } + + STableMeta* pTableMeta = NULL; + SRequestConnInfo conn = {.pTrans = pStmt->taos->pAppInfo->pTransporter, + .requestId = pStmt->exec.pRequest->requestId, + .requestObjRefId = pStmt->exec.pRequest->self, + .mgmtEps = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp)}; + code = catalogGetTableMeta(pStmt->pCatalog, &conn, &pStmt->bInfo.sname, &pTableMeta); + + pStmt->stat.ctgGetTbMetaNum++; + + taos_free_result(pStmt->exec.pRequest); + pStmt->exec.pRequest = NULL; + + if (code || NULL == pTableMeta) { + pIter = taosHashIterate(pStmt->exec.pBlockHash, pIter); + finalCode = code; + taosMemoryFree(pTableMeta); + continue; + } + + pMeta->uid = pTableMeta->uid; + pStmt->bInfo.tbUid = pTableMeta->uid; + taosMemoryFree(pTableMeta); + } + + pIter = taosHashIterate(pStmt->exec.pBlockHash, pIter); + } + + return finalCode; +} +*/ +/* +int stmtStaticModeExec(TAOS_STMT* stmt) { + STscStmt2* pStmt = (STscStmt2*)stmt; + int32_t code = 0; + SSubmitRsp* pRsp = NULL; + if (pStmt->sql.staticMode) { + return TSDB_CODE_TSC_STMT_API_ERROR; + } + + STMT_DLOG_E("start to exec"); + + STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_EXECUTE)); + + STMT_ERR_RET(qBuildStmtOutputFromTbList(pStmt->sql.pQuery, pStmt->sql.pVgHash, pStmt->exec.pTbBlkList, +pStmt->exec.pCurrBlock, pStmt->exec.tbBlkNum)); + + launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, true, NULL); + + if (pStmt->exec.pRequest->code && NEED_CLIENT_HANDLE_ERROR(pStmt->exec.pRequest->code)) { + code = refreshMeta(pStmt->exec.pRequest->pTscObj, pStmt->exec.pRequest); + if (code) { + pStmt->exec.pRequest->code = code; + } else { + tFreeSSubmitRsp(pRsp); + STMT_ERR_RET(stmtResetStmt(pStmt)); + STMT_ERR_RET(TSDB_CODE_NEED_RETRY); + } + } + + STMT_ERR_JRET(pStmt->exec.pRequest->code); + + pStmt->exec.affectedRows = taos_affected_rows(pStmt->exec.pRequest); + pStmt->affectedRows += pStmt->exec.affectedRows; + +_return: + + stmtCleanExecInfo(pStmt, (code ? false : true), false); + + tFreeSSubmitRsp(pRsp); + + ++pStmt->sql.runTimes; + + STMT_RET(code); +} +*/ + +static int32_t createParseContext(const SRequestObj* pRequest, SParseContext** pCxt, SSqlCallbackWrapper* pWrapper) { + const STscObj* pTscObj = pRequest->pTscObj; + + *pCxt = taosMemoryCalloc(1, sizeof(SParseContext)); + if (*pCxt == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + **pCxt = (SParseContext){.requestId = pRequest->requestId, + .requestRid = pRequest->self, + .acctId = pTscObj->acctId, + .db = pRequest->pDb, + .topicQuery = false, + .pSql = pRequest->sqlstr, + .sqlLen = pRequest->sqlLen, + .pMsg = pRequest->msgBuf, + .msgLen = ERROR_MSG_BUF_DEFAULT_SIZE, + .pTransporter = pTscObj->pAppInfo->pTransporter, + .pStmtCb = NULL, + .pUser = pTscObj->user, + .pEffectiveUser = pRequest->effectiveUser, + .isSuperUser = (0 == strcmp(pTscObj->user, TSDB_DEFAULT_USER)), + .enableSysInfo = pTscObj->sysInfo, + .async = true, + .svrVer = pTscObj->sVer, + .nodeOffline = (pTscObj->pAppInfo->onlineDnodes < pTscObj->pAppInfo->totalDnodes), + .allocatorId = pRequest->allocatorRefId, + .parseSqlFp = clientParseSql, + .parseSqlParam = pWrapper}; + int8_t biMode = atomic_load_8(&((STscObj*)pTscObj)->biMode); + (*pCxt)->biMode = biMode; + return TSDB_CODE_SUCCESS; +} + +static void asyncQueryCb(void* userdata, TAOS_RES* res, int code) { + STscStmt2* pStmt = userdata; + __taos_async_fn_t fp = pStmt->options.asyncExecFn; + + pStmt->exec.affectedRows = taos_affected_rows(pStmt->exec.pRequest); + pStmt->affectedRows += pStmt->exec.affectedRows; + + fp(pStmt->options.userdata, res, code); + + while (0 == atomic_load_8((int8_t*)&pStmt->sql.siInfo.tableColsReady)) { + taosUsleep(1); + } + (void)stmtCleanExecInfo(pStmt, (code ? false : true), false); + ++pStmt->sql.runTimes; + + (void)tsem_post(&pStmt->asyncQuerySem); +} + +int stmtExec2(TAOS_STMT2* stmt, int* affected_rows) { + STscStmt2* pStmt = (STscStmt2*)stmt; + int32_t code = 0; + int64_t startUs = taosGetTimestampUs(); + + STMT_DLOG_E("start to exec"); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_EXECUTE)); + + if (STMT_TYPE_QUERY != pStmt->sql.type) { + if (pStmt->sql.stbInterlaceMode) { + int64_t startTs = taosGetTimestampUs(); + while (atomic_load_64(&pStmt->sql.siInfo.tbRemainNum)) { + taosUsleep(1); + } + pStmt->stat.execWaitUs += taosGetTimestampUs() - startTs; + + STMT_ERR_RET(qBuildStmtFinOutput(pStmt->sql.pQuery, pStmt->sql.pVgHash, pStmt->sql.siInfo.pVgroupList)); + taosHashCleanup(pStmt->sql.siInfo.pVgroupHash); + pStmt->sql.siInfo.pVgroupHash = NULL; + pStmt->sql.siInfo.pVgroupList = NULL; + } else { + tDestroySubmitTbData(pStmt->exec.pCurrTbData, TSDB_MSG_FLG_ENCODE); + taosMemoryFreeClear(pStmt->exec.pCurrTbData); + + STMT_ERR_RET(qCloneCurrentTbData(pStmt->exec.pCurrBlock, &pStmt->exec.pCurrTbData)); + + STMT_ERR_RET(qBuildStmtOutput(pStmt->sql.pQuery, pStmt->sql.pVgHash, pStmt->exec.pBlockHash)); + } + } + + SRequestObj* pRequest = pStmt->exec.pRequest; + __taos_async_fn_t fp = pStmt->options.asyncExecFn; + + if (!fp) { + (void)launchQueryImpl(pStmt->exec.pRequest, pStmt->sql.pQuery, true, NULL); + + if (pStmt->exec.pRequest->code && NEED_CLIENT_HANDLE_ERROR(pStmt->exec.pRequest->code)) { + code = refreshMeta(pStmt->exec.pRequest->pTscObj, pStmt->exec.pRequest); + if (code) { + pStmt->exec.pRequest->code = code; + } else { + STMT_ERR_RET(stmtResetStmt(pStmt)); + STMT_ERR_RET(TSDB_CODE_NEED_RETRY); + } + } + + STMT_ERR_JRET(pStmt->exec.pRequest->code); + + pStmt->exec.affectedRows = taos_affected_rows(pStmt->exec.pRequest); + if (affected_rows) { + *affected_rows = pStmt->exec.affectedRows; + } + pStmt->affectedRows += pStmt->exec.affectedRows; + + while (0 == atomic_load_8((int8_t*)&pStmt->sql.siInfo.tableColsReady)) { + taosUsleep(1); + } + + STMT_ERR_RET(stmtCleanExecInfo(pStmt, (code ? false : true), false)); + + ++pStmt->sql.runTimes; + + } else { + SSqlCallbackWrapper* pWrapper = taosMemoryCalloc(1, sizeof(SSqlCallbackWrapper)); + if (pWrapper == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + } else { + pWrapper->pRequest = pRequest; + pRequest->pWrapper = pWrapper; + } + if (TSDB_CODE_SUCCESS == code) { + code = createParseContext(pRequest, &pWrapper->pParseCtx, pWrapper); + } + pRequest->syncQuery = false; + pRequest->body.queryFp = asyncQueryCb; + ((SSyncQueryParam*)(pRequest)->body.interParam)->userParam = pStmt; + + launchAsyncQuery(pRequest, pStmt->sql.pQuery, NULL, pWrapper); + } + +_return: + pStmt->stat.execUseUs += taosGetTimestampUs() - startUs; + + STMT_RET(code); +} + +int stmtClose2(TAOS_STMT2* stmt) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + STMT_DLOG_E("start to free stmt"); + + pStmt->queue.stopQueue = true; + + if (pStmt->bindThreadInUse) { + (void)taosThreadJoin(pStmt->bindThread, NULL); + pStmt->bindThreadInUse = false; + } + + STMT_DLOG("stmt %p closed, stbInterlaceMode: %d, statInfo: ctgGetTbMetaNum=>%" PRId64 ", getCacheTbInfo=>%" PRId64 + ", parseSqlNum=>%" PRId64 ", pStmt->stat.bindDataNum=>%" PRId64 + ", settbnameAPI:%u, bindAPI:%u, addbatchAPI:%u, execAPI:%u" + ", setTbNameUs:%" PRId64 ", bindDataUs:%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 " addBatchUs:%" PRId64 + ", execWaitUs:%" PRId64 ", execUseUs:%" PRId64, + pStmt, pStmt->sql.stbInterlaceMode, pStmt->stat.ctgGetTbMetaNum, pStmt->stat.getCacheTbInfo, + pStmt->stat.parseSqlNum, pStmt->stat.bindDataNum, pStmt->seqIds[STMT_SETTBNAME], pStmt->seqIds[STMT_BIND], + pStmt->seqIds[STMT_ADD_BATCH], pStmt->seqIds[STMT_EXECUTE], pStmt->stat.setTbNameUs, + pStmt->stat.bindDataUs1, pStmt->stat.bindDataUs2, pStmt->stat.bindDataUs3, pStmt->stat.bindDataUs4, + pStmt->stat.addBatchUs, pStmt->stat.execWaitUs, pStmt->stat.execUseUs); + + STMT_ERR_RET(stmtCleanSQLInfo(pStmt)); + + if (pStmt->options.asyncExecFn) { + (void)tsem_destroy(&pStmt->asyncQuerySem); + } + taosMemoryFree(stmt); + + return TSDB_CODE_SUCCESS; +} + +const char* stmtErrstr2(TAOS_STMT2* stmt) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + if (stmt == NULL || NULL == pStmt->exec.pRequest) { + return (char*)tstrerror(terrno); + } + + pStmt->exec.pRequest->code = terrno; + + return taos_errstr(pStmt->exec.pRequest); +} +/* +int stmtAffectedRows(TAOS_STMT* stmt) { return ((STscStmt2*)stmt)->affectedRows; } + +int stmtAffectedRowsOnce(TAOS_STMT* stmt) { return ((STscStmt2*)stmt)->exec.affectedRows; } +*/ +int stmtGetTagFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_E** fields) { + int32_t code = 0; + STscStmt2* pStmt = (STscStmt2*)stmt; + int32_t preCode = pStmt->errCode; + + STMT_DLOG_E("start to get tag fields"); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + if (STMT_TYPE_QUERY == pStmt->sql.type) { + STMT_ERRI_JRET(TSDB_CODE_TSC_STMT_API_ERROR); + } + + STMT_ERRI_JRET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS)); + + if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 && + STMT_TYPE_MULTI_INSERT != pStmt->sql.type) { + pStmt->bInfo.needParse = false; + } + + if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) { + taos_free_result(pStmt->exec.pRequest); + pStmt->exec.pRequest = NULL; + } + + STMT_ERRI_JRET(stmtCreateRequest(pStmt)); + + if (pStmt->bInfo.needParse) { + STMT_ERRI_JRET(stmtParseSql(pStmt)); + } + + STMT_ERRI_JRET(stmtFetchTagFields2(stmt, nums, fields)); + +_return: + + pStmt->errCode = preCode; + + return code; +} + +int stmtGetColFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_E** fields) { + int32_t code = 0; + STscStmt2* pStmt = (STscStmt2*)stmt; + int32_t preCode = pStmt->errCode; + + STMT_DLOG_E("start to get col fields"); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + if (STMT_TYPE_QUERY == pStmt->sql.type) { + STMT_ERRI_JRET(TSDB_CODE_TSC_STMT_API_ERROR); + } + + STMT_ERRI_JRET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS)); + + if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 && + STMT_TYPE_MULTI_INSERT != pStmt->sql.type) { + pStmt->bInfo.needParse = false; + } + + if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) { + taos_free_result(pStmt->exec.pRequest); + pStmt->exec.pRequest = NULL; + STMT_ERR_RET(stmtCreateRequest(pStmt)); + } + + STMT_ERRI_JRET(stmtCreateRequest(pStmt)); + + if (pStmt->bInfo.needParse) { + STMT_ERRI_JRET(stmtParseSql(pStmt)); + } + + STMT_ERRI_JRET(stmtFetchColFields2(stmt, nums, fields)); + +_return: + + pStmt->errCode = preCode; + + return code; +} + +int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + STMT_DLOG_E("start to get param num"); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS)); + + if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 && + STMT_TYPE_MULTI_INSERT != pStmt->sql.type) { + pStmt->bInfo.needParse = false; + } + + if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) { + taos_free_result(pStmt->exec.pRequest); + pStmt->exec.pRequest = NULL; + } + + STMT_ERR_RET(stmtCreateRequest(pStmt)); + + if (pStmt->bInfo.needParse) { + STMT_ERR_RET(stmtParseSql(pStmt)); + } + + if (STMT_TYPE_QUERY == pStmt->sql.type) { + *nums = taosArrayGetSize(pStmt->sql.pQuery->pPlaceholderValues); + } else { + STMT_ERR_RET(stmtFetchColFields2(stmt, nums, NULL)); + } + + return TSDB_CODE_SUCCESS; +} + +int stmtGetParamTbName(TAOS_STMT2* stmt, int* nums) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + STMT_DLOG_E("start to get param num"); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS)); + + if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 && + STMT_TYPE_MULTI_INSERT != pStmt->sql.type) { + pStmt->bInfo.needParse = false; + } + + if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) { + taos_free_result(pStmt->exec.pRequest); + pStmt->exec.pRequest = NULL; + } + + STMT_ERR_RET(stmtCreateRequest(pStmt)); + + if (pStmt->bInfo.needParse) { + STMT_ERR_RET(stmtParseSql(pStmt)); + } + + *nums = STMT_TYPE_MULTI_INSERT == pStmt->sql.type ? 1 : 0; + + return TSDB_CODE_SUCCESS; +} +/* +int stmtGetParam(TAOS_STMT* stmt, int idx, int* type, int* bytes) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + STMT_DLOG_E("start to get param"); + + if (pStmt->errCode != TSDB_CODE_SUCCESS) { + return pStmt->errCode; + } + + if (STMT_TYPE_QUERY == pStmt->sql.type) { + STMT_RET(TSDB_CODE_TSC_STMT_API_ERROR); + } + + STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS)); + + if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 && + STMT_TYPE_MULTI_INSERT != pStmt->sql.type) { + pStmt->bInfo.needParse = false; + } + + if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) { + taos_free_result(pStmt->exec.pRequest); + pStmt->exec.pRequest = NULL; + } + + STMT_ERR_RET(stmtCreateRequest(pStmt)); + + if (pStmt->bInfo.needParse) { + STMT_ERR_RET(stmtParseSql(pStmt)); + } + + int32_t nums = 0; + TAOS_FIELD_E* pField = NULL; + STMT_ERR_RET(stmtFetchColFields(stmt, &nums, &pField)); + if (idx >= nums) { + tscError("idx %d is too big", idx); + taosMemoryFree(pField); + STMT_ERR_RET(TSDB_CODE_INVALID_PARA); + } + + *type = pField[idx].type; + *bytes = pField[idx].bytes; + + taosMemoryFree(pField); + + return TSDB_CODE_SUCCESS; +} +*/ +TAOS_RES* stmtUseResult2(TAOS_STMT2* stmt) { + STscStmt2* pStmt = (STscStmt2*)stmt; + + STMT_DLOG_E("start to use result"); + + if (STMT_TYPE_QUERY != pStmt->sql.type) { + tscError("useResult only for query statement"); + return NULL; + } + + return pStmt->exec.pRequest; +} diff --git a/source/common/src/tdatablock.c b/source/common/src/tdatablock.c index 816bf3a757..ea3e88919b 100644 --- a/source/common/src/tdatablock.c +++ b/source/common/src/tdatablock.c @@ -849,7 +849,7 @@ int32_t blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startInd int32_t blockDataExtractBlock(SSDataBlock* pBlock, int32_t startIndex, int32_t rowCount, SSDataBlock** pResBlock) { int32_t code = 0; - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); if (pBlock == NULL || startIndex < 0 || rowCount > pBlock->info.rows || rowCount + startIndex > pBlock->info.rows) { return TSDB_CODE_INVALID_PARA; @@ -1263,18 +1263,19 @@ static void blockDataAssign(SColumnInfoData* pCols, const SSDataBlock* pDataBloc } static int32_t createHelpColInfoData(const SSDataBlock* pDataBlock, SColumnInfoData** ppCols) { - *ppCols = NULL; - int32_t code = 0; int32_t rows = pDataBlock->info.capacity; size_t numOfCols = taosArrayGetSize(pDataBlock->pDataBlock); + int32_t i = 0; + + *ppCols = NULL; SColumnInfoData* pCols = taosMemoryCalloc(numOfCols, sizeof(SColumnInfoData)); if (pCols == NULL) { return terrno; } - for (int32_t i = 0; i < numOfCols; ++i) { + for (i = 0; i < numOfCols; ++i) { SColumnInfoData* pColInfoData = taosArrayGet(pDataBlock->pDataBlock, i); if (pColInfoData == NULL) { continue; @@ -1309,6 +1310,10 @@ static int32_t createHelpColInfoData(const SSDataBlock* pDataBlock, SColumnInfoD return code; _error: + for(int32_t j = 0; j < i; ++j) { + colDataDestroy(&pCols[j]); + } + taosMemoryFree(pCols); return code; } @@ -1753,7 +1758,7 @@ int32_t copyDataBlock(SSDataBlock* pDst, const SSDataBlock* pSrc) { } int32_t createSpecialDataBlock(EStreamType type, SSDataBlock** pBlock) { - QRY_OPTR_CHECK(pBlock); + QRY_PARAM_CHECK(pBlock); int32_t code = 0; SSDataBlock* p = taosMemoryCalloc(1, sizeof(SSDataBlock)); @@ -1846,7 +1851,7 @@ _err: } int32_t blockCopyOneRow(const SSDataBlock* pDataBlock, int32_t rowIdx, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); if (pDataBlock == NULL) { return TSDB_CODE_INVALID_PARA; @@ -1946,7 +1951,7 @@ _end: } int32_t createOneDataBlock(const SSDataBlock* pDataBlock, bool copyData, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); if (pDataBlock == NULL) { return TSDB_CODE_INVALID_PARA; } @@ -2029,7 +2034,7 @@ int32_t createOneDataBlock(const SSDataBlock* pDataBlock, bool copyData, SSDataB } int32_t createDataBlock(SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock)); if (pBlock == NULL) { return terrno; @@ -2080,7 +2085,7 @@ SColumnInfoData createColumnInfoData(int16_t type, int32_t bytes, int16_t colId) int32_t bdGetColumnInfoData(const SSDataBlock* pBlock, int32_t index, SColumnInfoData** pColInfoData) { int32_t code = 0; - QRY_OPTR_CHECK(pColInfoData); + QRY_PARAM_CHECK(pColInfoData); if (index >= taosArrayGetSize(pBlock->pDataBlock)) { return TSDB_CODE_INVALID_PARA; @@ -2402,10 +2407,18 @@ void* tDecodeDataBlock(const void* buf, SSDataBlock* pBlock) { } else { buf = taosDecodeBinary(buf, (void**)&data.nullbitmap, BitmapLen(pBlock->info.rows)); } + if(buf == NULL) { + uError("failed to decode null bitmap/offset, type:%d", data.info.type); + goto _error; + } int32_t len = 0; buf = taosDecodeFixedI32(buf, &len); buf = taosDecodeBinary(buf, (void**)&data.pData, len); + if (buf == NULL) { + uError("failed to decode data, type:%d", data.info.type); + goto _error; + } if (IS_VAR_DATA_TYPE(data.info.type)) { data.varmeta.length = len; data.varmeta.allocLen = len; @@ -2418,6 +2431,15 @@ void* tDecodeDataBlock(const void* buf, SSDataBlock* pBlock) { } return (void*)buf; +_error: + for (int32_t i = 0; i < sz; ++i) { + SColumnInfoData* pColInfoData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i); + if (pColInfoData == NULL) { + break; + } + colDataDestroy(pColInfoData); + } + return NULL; } static char* formatTimestamp(char* buf, int64_t val, int precision) { @@ -2854,7 +2876,7 @@ bool alreadyAddGroupId(char* ctbName, int64_t groupId) { } int32_t buildCtbNameByGroupId(const char* stbFullName, uint64_t groupId, char** pName) { - QRY_OPTR_CHECK(pName); + QRY_PARAM_CHECK(pName); char* pBuf = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN + 1); if (!pBuf) { diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index b831860512..24e669577a 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -3124,6 +3124,198 @@ _exit: return code; } +int32_t tColDataAddValueByBind2(SColData *pColData, TAOS_STMT2_BIND *pBind, int32_t buffMaxLen) { + int32_t code = 0; + + if (!(pBind->num == 1 && pBind->is_null && *pBind->is_null)) { + if (!(pColData->type == pBind->buffer_type)) { + return TSDB_CODE_INVALID_PARA; + } + } + + if (IS_VAR_DATA_TYPE(pColData->type)) { // var-length data type + uint8_t *buf = pBind->buffer; + for (int32_t i = 0; i < pBind->num; ++i) { + if (pBind->is_null && pBind->is_null[i]) { + if (pColData->cflag & COL_IS_KEY) { + code = TSDB_CODE_PAR_PRIMARY_KEY_IS_NULL; + goto _exit; + } + if (pBind->is_null[i] == 1) { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0); + if (code) goto _exit; + } else { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); + if (code) goto _exit; + } + } else if (pBind->length[i] > buffMaxLen) { + uError("var data length too big, len:%d, max:%d", pBind->length[i], buffMaxLen); + return TSDB_CODE_INVALID_PARA; + } else { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, buf, pBind->length[i]); + buf += pBind->length[i]; + } + } + } else { // fixed-length data type + bool allValue; + bool allNull; + bool allNone; + if (pBind->is_null) { + bool same = (memcmp(pBind->is_null, pBind->is_null + 1, pBind->num - 1) == 0); + allNull = (same && pBind->is_null[0] == 1); + allNone = (same && pBind->is_null[0] > 1); + allValue = (same && pBind->is_null[0] == 0); + } else { + allNull = false; + allNone = false; + allValue = true; + } + + if ((pColData->cflag & COL_IS_KEY) && !allValue) { + code = TSDB_CODE_PAR_PRIMARY_KEY_IS_NULL; + goto _exit; + } + + if (allValue) { + // optimize (todo) + for (int32_t i = 0; i < pBind->num; ++i) { + uint8_t *val = (uint8_t *)pBind->buffer + TYPE_BYTES[pColData->type] * i; + if (TSDB_DATA_TYPE_BOOL == pColData->type && *val > 1) { + *val = 1; + } + + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, val, TYPE_BYTES[pColData->type]); + } + } else if (allNull) { + // optimize (todo) + for (int32_t i = 0; i < pBind->num; ++i) { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0); + if (code) goto _exit; + } + } else if (allNone) { + // optimize (todo) + for (int32_t i = 0; i < pBind->num; ++i) { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); + if (code) goto _exit; + } + } else { + for (int32_t i = 0; i < pBind->num; ++i) { + if (pBind->is_null[i]) { + if (pBind->is_null[i] == 1) { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0); + if (code) goto _exit; + } else { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); + if (code) goto _exit; + } + } else { + uint8_t *val = (uint8_t *)pBind->buffer + TYPE_BYTES[pColData->type] * i; + if (TSDB_DATA_TYPE_BOOL == pColData->type && *val > 1) { + *val = 1; + } + + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, val, TYPE_BYTES[pColData->type]); + } + } + } + } + +_exit: + return code; +} + +/* build rows to `rowArray` from bind + * `infos` is the bind information array + * `numOfInfos` is the number of bind information + * `infoSorted` is whether the bind information is sorted by column id + * `pTSchema` is the schema of the table + * `rowArray` is the array to store the rows + */ +int32_t tRowBuildFromBind2(SBindInfo2 *infos, int32_t numOfInfos, bool infoSorted, const STSchema *pTSchema, + SArray *rowArray) { + if (infos == NULL || numOfInfos <= 0 || numOfInfos > pTSchema->numOfCols || pTSchema == NULL || rowArray == NULL) { + return TSDB_CODE_INVALID_PARA; + } + + if (!infoSorted) { + taosqsort_r(infos, numOfInfos, sizeof(SBindInfo), NULL, tBindInfoCompare); + } + + int32_t code = 0; + int32_t numOfRows = infos[0].bind->num; + SArray *colValArray, *bufArray; + SColVal colVal; + + if ((colValArray = taosArrayInit(numOfInfos, sizeof(SColVal))) == NULL) { + return terrno; + } + if ((bufArray = taosArrayInit(numOfInfos, sizeof(uint8_t *))) == NULL) { + taosArrayDestroy(colValArray); + return TSDB_CODE_OUT_OF_MEMORY; + } + for (int i = 0; i < numOfInfos; ++i) { + if (!taosArrayPush(bufArray, &infos[i].bind->buffer)) { + taosArrayDestroy(colValArray); + taosArrayDestroy(bufArray); + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + for (int32_t iRow = 0; iRow < numOfRows; iRow++) { + taosArrayClear(colValArray); + + for (int32_t iInfo = 0; iInfo < numOfInfos; iInfo++) { + if (infos[iInfo].bind->is_null && infos[iInfo].bind->is_null[iRow]) { + if (infos[iInfo].bind->is_null[iRow] == 1) { + colVal = COL_VAL_NULL(infos[iInfo].columnId, infos[iInfo].type); + } else { + colVal = COL_VAL_NONE(infos[iInfo].columnId, infos[iInfo].type); + } + } else { + SValue value = { + .type = infos[iInfo].type, + }; + if (IS_VAR_DATA_TYPE(infos[iInfo].type)) { + int32_t length = infos[iInfo].bind->length[iRow]; + uint8_t **data = &((uint8_t **)TARRAY_DATA(bufArray))[iInfo]; + value.nData = length; + value.pData = *data; + *data += length; + // value.pData = (uint8_t *)infos[iInfo].bind->buffer + infos[iInfo].bind->buffer_length * iRow; + } else { + uint8_t *val = (uint8_t *)infos[iInfo].bind->buffer + infos[iInfo].bytes * iRow; + if (TSDB_DATA_TYPE_BOOL == value.type && *val > 1) { + *val = 1; + } + (void)memcpy(&value.val, val, + /*(uint8_t *)infos[iInfo].bind->buffer + infos[iInfo].bind->buffer_length * iRow,*/ + infos[iInfo].bytes /*bind->buffer_length*/); + } + colVal = COL_VAL_VALUE(infos[iInfo].columnId, value); + } + if (taosArrayPush(colValArray, &colVal) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _exit; + } + } + + SRow *row; + if ((code = tRowBuild(colValArray, pTSchema, &row))) { + goto _exit; + } + + if ((taosArrayPush(rowArray, &row)) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _exit; + } + } + +_exit: + taosArrayDestroy(colValArray); + taosArrayDestroy(bufArray); + return code; +} + static int32_t tColDataCopyRowCell(SColData *pFromColData, int32_t iFromRow, SColData *pToColData, int32_t iToRow) { int32_t code = TSDB_CODE_SUCCESS; diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c index 367eb68865..5b67e1267b 100644 --- a/source/common/src/tglobal.c +++ b/source/common/src/tglobal.c @@ -615,7 +615,7 @@ static int32_t taosAddClientCfg(SConfig *pCfg) { tsKeepAliveIdle = TRANGE(tsKeepAliveIdle, 1, 72000); TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "keepAliveIdle", tsKeepAliveIdle, 1, 7200000, CFG_SCOPE_BOTH, CFG_DYN_ENT_BOTH)); - tsNumOfTaskQueueThreads = tsNumOfCores; + tsNumOfTaskQueueThreads = tsNumOfCores * 2; tsNumOfTaskQueueThreads = TMAX(tsNumOfTaskQueueThreads, 16); TAOS_CHECK_RETURN( diff --git a/source/dnode/mgmt/exe/dmMain.c b/source/dnode/mgmt/exe/dmMain.c index 9b0cd7d5a5..9f5db9b0eb 100644 --- a/source/dnode/mgmt/exe/dmMain.c +++ b/source/dnode/mgmt/exe/dmMain.c @@ -147,12 +147,14 @@ static void dmSetSignalHandle() { (void)taosSetSignal(SIGQUIT, dmStopDnode); #endif +#if 0 #ifndef WINDOWS (void)taosSetSignal(SIGBUS, dmLogCrash); #endif (void)taosSetSignal(SIGABRT, dmLogCrash); (void)taosSetSignal(SIGFPE, dmLogCrash); (void)taosSetSignal(SIGSEGV, dmLogCrash); +#endif } static int32_t dmParseArgs(int32_t argc, char const *argv[]) { diff --git a/source/dnode/mnode/impl/src/mndStreamUtil.c b/source/dnode/mnode/impl/src/mndStreamUtil.c index 839e00f922..5df0219ede 100644 --- a/source/dnode/mnode/impl/src/mndStreamUtil.c +++ b/source/dnode/mnode/impl/src/mndStreamUtil.c @@ -1860,4 +1860,74 @@ int32_t setTaskAttrInResBlock(SStreamObj *pStream, SStreamTask *pTask, SSDataBlo mError("error happens during build task attr result blocks, lino:%d, code:%s", lino, tstrerror(code)); } return code; +} + +uint32_t seed = 0; +static SRpcMsg createRpcMsg(STransAction* pAction, int64_t traceId, int64_t signature) { + SRpcMsg rpcMsg = {.msgType = pAction->msgType, .contLen = pAction->contLen, .info.ahandle = (void *)signature}; + rpcMsg.pCont = rpcMallocCont(pAction->contLen); + if (rpcMsg.pCont == NULL) { + return rpcMsg; + } + + rpcMsg.info.traceId.rootId = traceId; + rpcMsg.info.notFreeAhandle = 1; + + memcpy(rpcMsg.pCont, pAction->pCont, pAction->contLen); + return rpcMsg; +} + +void streamTransRandomErrorGen(STransAction *pAction, STrans *pTrans, int64_t signature) { + if ((pAction->msgType == TDMT_STREAM_TASK_UPDATE_CHKPT && pAction->id > 2) || + (pAction->msgType == TDMT_STREAM_CONSEN_CHKPT) || + (pAction->msgType == TDMT_VND_STREAM_CHECK_POINT_SOURCE && pAction->id > 2)) { + if (seed == 0) { + seed = taosGetTimestampSec(); + } + + uint32_t v = taosRandR(&seed); + int32_t choseItem = v % 5; + + if (choseItem == 0) { + // 1. one of update-checkpoint not send, restart and send it again + taosMsleep(5000); + if (pAction->msgType == TDMT_STREAM_TASK_UPDATE_CHKPT) { + mError( + "***sleep 5s and core dump, following tasks will not recv update-checkpoint info, so the checkpoint will " + "rollback***"); + exit(-1); + } else if (pAction->msgType == TDMT_STREAM_CONSEN_CHKPT) { // pAction->msgType == TDMT_STREAM_CONSEN_CHKPT + mError( + "***sleep 5s and core dump, following tasks will not recv consen-checkpoint info, so the tasks will " + "not started***"); + } else { // pAction->msgType == TDMT_VND_STREAM_CHECK_POINT_SOURCE + mError( + "***sleep 5s and core dump, following tasks will not recv checkpoint-source info, so the tasks will " + "started after restart***"); + exit(-1); + } + } else if (choseItem == 1) { + // 2. repeat send update chkpt msg + mError("***repeat send update-checkpoint/consensus/checkpoint trans msg 3times to vnode***"); + + mError("***repeat 1***"); + SRpcMsg rpcMsg1 = createRpcMsg(pAction, pTrans->mTraceId, signature); + int32_t code = tmsgSendReq(&pAction->epSet, &rpcMsg1); + + mError("***repeat 2***"); + SRpcMsg rpcMsg2 = createRpcMsg(pAction, pTrans->mTraceId, signature); + code = tmsgSendReq(&pAction->epSet, &rpcMsg2); + + mError("***repeat 3***"); + SRpcMsg rpcMsg3 = createRpcMsg(pAction, pTrans->mTraceId, signature); + code = tmsgSendReq(&pAction->epSet, &rpcMsg3); + } else if (choseItem == 2) { + // 3. sleep 40s and then send msg + mError("***idle for 30s, and then send msg***"); + taosMsleep(30000); + } else { + // do nothing + // mInfo("no error triggered"); + } + } } \ No newline at end of file diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c index 2a321289d1..2b76e8841d 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCache.c +++ b/source/dnode/vnode/src/tsdb/tsdbCache.c @@ -2158,6 +2158,11 @@ static int32_t loadTombFromBlk(const TTombBlkArray *pTombBlkArray, SCacheRowsRea uint64_t uid = uidList[j]; STableLoadInfo *pInfo = getTableLoadInfo(pReader, uid); + if (!pInfo) { + (void)tTombBlockDestroy(&block); + TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY); + } + if (pInfo->pTombData == NULL) { pInfo->pTombData = taosArrayInit(4, sizeof(SDelData)); } @@ -2200,8 +2205,18 @@ static int32_t loadTombFromBlk(const TTombBlkArray *pTombBlkArray, SCacheRowsRea if (newTable) { pInfo = getTableLoadInfo(pReader, uid); + if (!pInfo) { + code = TSDB_CODE_OUT_OF_MEMORY; + finished = true; + break; + } if (pInfo->pTombData == NULL) { pInfo->pTombData = taosArrayInit(4, sizeof(SDelData)); + if (!pInfo->pTombData) { + code = TSDB_CODE_OUT_OF_MEMORY; + finished = true; + break; + } } } @@ -2998,6 +3013,8 @@ static int32_t nextRowIterGet(CacheNextRowIter *pIter, TSDBROW **ppRow, bool *pI uint64_t uid = pIter->idx.uid; STableLoadInfo *pInfo = getTableLoadInfo(pIter->pr, uid); + TSDB_CHECK_NULL(pInfo, code, lino, _err, TSDB_CODE_OUT_OF_MEMORY); + if (pInfo->pTombData == NULL) { pInfo->pTombData = taosArrayInit(4, sizeof(SDelData)); TSDB_CHECK_NULL(pInfo->pTombData, code, lino, _err, TSDB_CODE_OUT_OF_MEMORY); @@ -3204,6 +3221,10 @@ static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SC break; } // high version's column value + if (slotIds[iCol] > pTSchema->numOfCols - 1) { + continue; + } + SLastCol *lastColVal = (SLastCol *)taosArrayGet(pColArray, iCol); if (lastColVal->colVal.cid != pTSchema->columns[slotIds[iCol]].colId) { continue; diff --git a/source/dnode/vnode/src/tsdb/tsdbFSet2.c b/source/dnode/vnode/src/tsdb/tsdbFSet2.c index de62ce63a0..f5dd2a3768 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFSet2.c +++ b/source/dnode/vnode/src/tsdb/tsdbFSet2.c @@ -50,7 +50,11 @@ static int32_t tsdbSttLvlInitEx(STsdb *pTsdb, const SSttLvl *lvl1, SSttLvl **lvl } code = TARRAY2_APPEND(lvl[0]->fobjArr, fobj); - if (code) return code; + if (code) { + (void)tsdbSttLvlClear(lvl); + taosMemoryFree(fobj); + return code; + } } return 0; } diff --git a/source/dnode/vnode/src/tsdb/tsdbMergeTree.c b/source/dnode/vnode/src/tsdb/tsdbMergeTree.c index fc2b873054..ed67bfca3e 100644 --- a/source/dnode/vnode/src/tsdb/tsdbMergeTree.c +++ b/source/dnode/vnode/src/tsdb/tsdbMergeTree.c @@ -408,9 +408,7 @@ static int32_t loadSttStatisticsBlockData(SSttFileReader *pSttFileReader, SSttBl for (int32_t k = startIndex; k < endIndex; ++k) { code = tsdbSttFileReadStatisBlock(pSttFileReader, &pStatisBlkArray->data[k], &block); - if (code) { - return code; - } + QUERY_CHECK_CODE(code, lino, _end); int32_t i = 0; int32_t rows = block.numOfRecords; @@ -536,12 +534,15 @@ static int32_t loadSttStatisticsBlockData(SSttFileReader *pSttFileReader, SSttBl } _end: - (void)tStatisBlockDestroy(&block); + (void) tStatisBlockDestroy(&block); + if (code != 0) { + tsdbError("%s error happens at:%s line number: %d, code:%s", id, __func__, lino, tstrerror(code)); + } else { + double el = (taosGetTimestampUs() - st) / 1000.0; + pBlockLoadInfo->cost.statisElapsedTime += el; - double el = (taosGetTimestampUs() - st) / 1000.0; - pBlockLoadInfo->cost.statisElapsedTime += el; - - tsdbDebug("%s load %d statis blocks into buf, elapsed time:%.2fms", id, num, el); + tsdbDebug("%s load %d statis blocks into buf, elapsed time:%.2fms", id, num, el); + } return code; } @@ -953,6 +954,7 @@ int32_t tMergeTreeOpen2(SMergeTree *pMTree, SMergeTreeConf *pConf, SSttDataInfoF pMTree->pIter = NULL; pMTree->backward = pConf->backward; pMTree->idStr = pConf->idstr; + int32_t lino = 0; if (!pMTree->backward) { // asc tRBTreeCreate(&pMTree->rbt, tLDataIterCmprFn); @@ -1027,9 +1029,8 @@ int32_t tMergeTreeOpen2(SMergeTree *pMTree, SMergeTreeConf *pConf, SSttDataInfoF // let's record the time window for current table of uid in the stt files if (pSttDataInfo != NULL && numOfRows > 0) { void *px = taosArrayPush(pSttDataInfo->pKeyRangeList, &range); - if (px == NULL) { - return terrno; - } + QUERY_CHECK_NULL(px, code, lino, _end, terrno); + pSttDataInfo->numOfRows += numOfRows; } } else { diff --git a/source/dnode/vnode/src/tsdb/tsdbRead2.c b/source/dnode/vnode/src/tsdb/tsdbRead2.c index 0c61366513..cc4c3d318a 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead2.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead2.c @@ -403,7 +403,7 @@ static void initReaderStatus(SReaderStatus* pStatus) { } static int32_t createResBlock(SQueryTableDataCond* pCond, int32_t capacity, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); SSDataBlock* pBlock = NULL; int32_t code = createDataBlock(&pBlock); diff --git a/source/dnode/vnode/src/vnd/vnodeQuery.c b/source/dnode/vnode/src/vnd/vnodeQuery.c index 23bc6b607c..dedb473df6 100644 --- a/source/dnode/vnode/src/vnd/vnodeQuery.c +++ b/source/dnode/vnode/src/vnd/vnodeQuery.c @@ -396,15 +396,21 @@ int32_t vnodeGetBatchMeta(SVnode *pVnode, SRpcMsg *pMsg) { switch (req->msgType) { case TDMT_VND_TABLE_META: // error code has been set into reqMsg, no need to handle it here. - (void)vnodeGetTableMeta(pVnode, &reqMsg, false); + if (TSDB_CODE_SUCCESS != vnodeGetTableMeta(pVnode, &reqMsg, false)) { + qWarn("vnodeGetBatchMeta failed, msgType:%d", req->msgType); + } break; case TDMT_VND_TABLE_CFG: // error code has been set into reqMsg, no need to handle it here. - (void)vnodeGetTableCfg(pVnode, &reqMsg, false); + if (TSDB_CODE_SUCCESS != vnodeGetTableCfg(pVnode, &reqMsg, false)) { + qWarn("vnodeGetBatchMeta failed, msgType:%d", req->msgType); + } break; case TDMT_VND_GET_STREAM_PROGRESS: // error code has been set into reqMsg, no need to handle it here. - (void)vnodeGetStreamProgress(pVnode, &reqMsg, false); + if (TSDB_CODE_SUCCESS != vnodeGetStreamProgress(pVnode, &reqMsg, false)) { + qWarn("vnodeGetBatchMeta failed, msgType:%d", req->msgType); + } break; default: qError("invalid req msgType %d", req->msgType); diff --git a/source/libs/command/src/command.c b/source/libs/command/src/command.c index 138782495f..80766855cf 100644 --- a/source/libs/command/src/command.c +++ b/source/libs/command/src/command.c @@ -78,7 +78,7 @@ static int32_t getSchemaBytes(const SSchema* pSchema) { } static int32_t buildDescResultDataBlock(SSDataBlock** pOutput) { - QRY_OPTR_CHECK(pOutput); + QRY_PARAM_CHECK(pOutput); SSDataBlock* pBlock = NULL; int32_t code = createDataBlock(&pBlock); @@ -236,7 +236,7 @@ static int32_t execDescribe(bool sysInfoUser, SNode* pStmt, SRetrieveTableRsp** static int32_t execResetQueryCache() { return catalogClearCache(); } static int32_t buildCreateDBResultDataBlock(SSDataBlock** pOutput) { - QRY_OPTR_CHECK(pOutput); + QRY_PARAM_CHECK(pOutput); SSDataBlock* pBlock = NULL; int32_t code = createDataBlock(&pBlock); @@ -475,7 +475,7 @@ static int32_t execShowCreateDatabase(SShowCreateDatabaseStmt* pStmt, SRetrieveT } static int32_t buildCreateTbResultDataBlock(SSDataBlock** pOutput) { - QRY_OPTR_CHECK(pOutput); + QRY_PARAM_CHECK(pOutput); SSDataBlock* pBlock = NULL; int32_t code = createDataBlock(&pBlock); @@ -499,7 +499,7 @@ static int32_t buildCreateTbResultDataBlock(SSDataBlock** pOutput) { } static int32_t buildCreateViewResultDataBlock(SSDataBlock** pOutput) { - QRY_OPTR_CHECK(pOutput); + QRY_PARAM_CHECK(pOutput); SSDataBlock* pBlock = NULL; int32_t code = createDataBlock(&pBlock); @@ -929,7 +929,7 @@ static int32_t execShowLocalVariables(SRetrieveTableRsp** pRsp) { } static int32_t createSelectResultDataBlock(SNodeList* pProjects, SSDataBlock** pOutput) { - QRY_OPTR_CHECK(pOutput); + QRY_PARAM_CHECK(pOutput); SSDataBlock* pBlock = NULL; int32_t code = createDataBlock(&pBlock); diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c index d9af279813..4605d19464 100644 --- a/source/libs/executor/src/aggregateoperator.c +++ b/source/libs/executor/src/aggregateoperator.c @@ -70,7 +70,7 @@ static void functionCtxRestore(SqlFunctionCtx* pCtx, SFunctionCtxStatus* pStatus int32_t createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t lino = 0; int32_t code = 0; diff --git a/source/libs/executor/src/cachescanoperator.c b/source/libs/executor/src/cachescanoperator.c index fdf20b4613..b575613efe 100644 --- a/source/libs/executor/src/cachescanoperator.c +++ b/source/libs/executor/src/cachescanoperator.c @@ -97,7 +97,7 @@ _end: int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandle* readHandle, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; diff --git a/source/libs/executor/src/countwindowoperator.c b/source/libs/executor/src/countwindowoperator.c index 713116d605..2233d58ef8 100644 --- a/source/libs/executor/src/countwindowoperator.c +++ b/source/libs/executor/src/countwindowoperator.c @@ -295,7 +295,7 @@ _end: int32_t createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; diff --git a/source/libs/executor/src/dataDispatcher.c b/source/libs/executor/src/dataDispatcher.c index fb3ed06224..9bbc5a94eb 100644 --- a/source/libs/executor/src/dataDispatcher.c +++ b/source/libs/executor/src/dataDispatcher.c @@ -204,6 +204,7 @@ static int32_t putDataBlock(SDataSinkHandle* pHandle, const SInputData* pInput, _return: + taosMemoryFreeClear(pBuf->pData); taosFreeQitem(pBuf); return code; } diff --git a/source/libs/executor/src/dynqueryctrloperator.c b/source/libs/executor/src/dynqueryctrloperator.c index 8058fa9afe..44e8a3cb8a 100644 --- a/source/libs/executor/src/dynqueryctrloperator.c +++ b/source/libs/executor/src/dynqueryctrloperator.c @@ -889,7 +889,7 @@ int32_t seqStableJoin(SOperatorInfo* pOperator, SSDataBlock** pRes) { SDynQueryCtrlOperatorInfo* pInfo = pOperator->info; SStbJoinDynCtrlInfo* pStbJoin = (SStbJoinDynCtrlInfo*)&pInfo->stbJoin; - QRY_OPTR_CHECK(pRes); + QRY_PARAM_CHECK(pRes); if (pOperator->status == OP_EXEC_DONE) { return code; } @@ -958,7 +958,7 @@ int32_t initSeqStbJoinTableHash(SStbJoinPrevJoinCtx* pPrev, bool batchFetch) { int32_t createDynQueryCtrlOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SDynQueryCtrlPhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; __optr_fn_t nextFp = NULL; diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c index a4be2ddf7d..0f3a08c14b 100644 --- a/source/libs/executor/src/eventwindowoperator.c +++ b/source/libs/executor/src/eventwindowoperator.c @@ -61,7 +61,7 @@ static void doKeepTuple(SWindowRowsSup* pRowSup, int64_t ts, uint64_t groupId) { int32_t createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c index d43f37ca9e..457aa8ff2b 100644 --- a/source/libs/executor/src/exchangeoperator.c +++ b/source/libs/executor/src/exchangeoperator.c @@ -401,7 +401,7 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo* int32_t createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = 0; int32_t lino = 0; diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index d469afb269..f3f421628d 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -1924,7 +1924,7 @@ SExprInfo* createExpr(SNodeList* pNodeList, int32_t* numOfExprs) { } int32_t createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, SExprInfo** pExprInfo, int32_t* numOfExprs) { - QRY_OPTR_CHECK(pExprInfo); + QRY_PARAM_CHECK(pExprInfo); int32_t code = 0; int32_t numOfFuncs = LIST_LENGTH(pNodeList); diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index 352ff4e66d..cc2ddf4225 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -1649,3 +1649,11 @@ int32_t qStreamOperatorReloadState(qTaskInfo_t tInfo) { pTaskInfo->pRoot->fpSet.reloadStreamStateFn(pTaskInfo->pRoot); return 0; } + +void qResetTaskCode(qTaskInfo_t tinfo) { + SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; + + int32_t code = pTaskInfo->code; + pTaskInfo->code = 0; + qDebug("0x%" PRIx64 " reset task code to be success, prev:%s", pTaskInfo->id.taskId, tstrerror(code)); +} diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c index a1bf64a10d..00138d6871 100644 --- a/source/libs/executor/src/executorInt.c +++ b/source/libs/executor/src/executorInt.c @@ -1280,7 +1280,7 @@ void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType FORCE_INLINE int32_t getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, bool clearParam, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); int32_t code = 0; if (pOperator->pDownstreamGetParams && pOperator->pDownstreamGetParams[idx]) { diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c index 21b67c8ffb..76b41ca99a 100644 --- a/source/libs/executor/src/filloperator.c +++ b/source/libs/executor/src/filloperator.c @@ -423,7 +423,7 @@ static int32_t createPrimaryTsExprIfNeeded(SFillOperatorInfo* pInfo, SFillPhysiN int32_t createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFillNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = 0; int32_t lino = 0; diff --git a/source/libs/executor/src/groupcacheoperator.c b/source/libs/executor/src/groupcacheoperator.c index 6a9482e31c..1796aa7b64 100644 --- a/source/libs/executor/src/groupcacheoperator.c +++ b/source/libs/executor/src/groupcacheoperator.c @@ -1444,7 +1444,7 @@ static int32_t groupCacheTableCacheEnd(SOperatorInfo* pOperator, SOperatorParam* int32_t createGroupCacheOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SGroupCachePhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; SGroupCacheOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupCacheOperatorInfo)); diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index 47b35fe9f3..e4ace6b83a 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -353,38 +353,6 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SSDataBlock* pBlock) { } } -static SSDataBlock* buildGroupResultDataBlock(SOperatorInfo* pOperator) { - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; - SGroupbyOperatorInfo* pInfo = pOperator->info; - SSDataBlock* pRes = pInfo->binfo.pRes; - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - - while (1) { - doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); - QUERY_CHECK_CODE(code, lino, _end); - - if (!hasRemainResults(&pInfo->groupResInfo)) { - setOperatorCompleted(pOperator); - break; - } - - if (pRes->info.rows > 0) { - break; - } - } - - pOperator->resultInfo.totalRows += pRes->info.rows; - -_end: - if (code != TSDB_CODE_SUCCESS) { - qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); - T_LONG_JMP(pTaskInfo->env, code); - } - return (pRes->info.rows == 0) ? NULL : pRes; -} - bool hasRemainResultByHash(SOperatorInfo* pOperator) { SGroupbyOperatorInfo* pInfo = pOperator->info; SSHashObj* pHashmap = pInfo->aggSup.pResultRowHashTable; @@ -463,25 +431,23 @@ _end: } static int32_t hashGroupbyAggregateNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SGroupbyOperatorInfo* pInfo = pOperator->info; + SGroupResInfo* pGroupResInfo = &pInfo->groupResInfo; + int32_t order = pInfo->binfo.inputTsOrder; + int64_t st = taosGetTimestampUs(); + + QRY_PARAM_CHECK(ppRes); if (pOperator->status == OP_EXEC_DONE) { - (*ppRes) = NULL; return TSDB_CODE_SUCCESS; } - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - - SGroupbyOperatorInfo* pInfo = pOperator->info; if (pOperator->status == OP_RES_TO_RETURN) { (*ppRes) = buildGroupResultDataBlockByHash(pOperator); return code; } - SGroupResInfo* pGroupResInfo = &pInfo->groupResInfo; - - int32_t order = pInfo->binfo.inputTsOrder; - int64_t st = taosGetTimestampUs(); - SOperatorInfo* downstream = pOperator->pDownstream[0]; while (1) { SSDataBlock* pBlock = getNextBlockFromDownstream(pOperator, 0); @@ -511,10 +477,12 @@ static int32_t hashGroupbyAggregateNext(SOperatorInfo* pOperator, SSDataBlock** if (pGroupResInfo->pRows != NULL) { taosArrayDestroy(pGroupResInfo->pRows); } + if (pGroupResInfo->pBuf) { taosMemoryFree(pGroupResInfo->pBuf); pGroupResInfo->pBuf = NULL; } + pGroupResInfo->index = 0; pGroupResInfo->iter = 0; pGroupResInfo->dataPos = NULL; @@ -525,15 +493,16 @@ _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); + } else { + (*ppRes) = buildGroupResultDataBlockByHash(pOperator); } - (*ppRes) = buildGroupResultDataBlockByHash(pOperator); + return code; } int32_t createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -1127,7 +1096,7 @@ static void destroyPartitionOperatorInfo(void* param) { int32_t createPartitionOperatorInfo(SOperatorInfo* downstream, SPartitionPhysiNode* pPartNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -1668,7 +1637,7 @@ void freePartItem(void* ptr) { int32_t createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStreamPartitionPhysiNode* pPartNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; diff --git a/source/libs/executor/src/hashjoinoperator.c b/source/libs/executor/src/hashjoinoperator.c index 4e630dbd18..7f13608653 100644 --- a/source/libs/executor/src/hashjoinoperator.c +++ b/source/libs/executor/src/hashjoinoperator.c @@ -996,7 +996,7 @@ static int32_t hJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** p SSDataBlock* pRes = pJoin->finBlk; int64_t st = 0; - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); if (pOperator->cost.openCost == 0) { st = taosGetTimestampUs(); } @@ -1182,7 +1182,7 @@ int32_t hJoinInitResBlocks(SHJoinOperatorInfo* pJoin, SHashJoinPhysiNode* pJoinN int32_t createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SHashJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; SHJoinOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SHJoinOperatorInfo)); diff --git a/source/libs/executor/src/mergejoinoperator.c b/source/libs/executor/src/mergejoinoperator.c index 30cc596a44..90c2248c12 100644 --- a/source/libs/executor/src/mergejoinoperator.c +++ b/source/libs/executor/src/mergejoinoperator.c @@ -1867,7 +1867,7 @@ int32_t mJoinSetImplFp(SMJoinOperatorInfo* pJoin) { int32_t createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SSortMergeJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t oldNum = numOfDownstream; bool newDownstreams = false; diff --git a/source/libs/executor/src/mergeoperator.c b/source/libs/executor/src/mergeoperator.c index 93bddb0787..7357329ca6 100644 --- a/source/libs/executor/src/mergeoperator.c +++ b/source/libs/executor/src/mergeoperator.c @@ -336,7 +336,7 @@ int32_t openNonSortMergeOperator(SOperatorInfo* pOperator) { } int32_t doNonSortMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SMultiwayMergeOperatorInfo* pInfo = pOperator->info; @@ -419,7 +419,7 @@ int32_t copyColumnsValue(SNodeList* pNodeList, uint64_t targetBlkId, SSDataBlock } int32_t doColsMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SMultiwayMergeOperatorInfo* pInfo = pOperator->info; @@ -499,7 +499,7 @@ int32_t openMultiwayMergeOperator(SOperatorInfo* pOperator) { } int32_t doMultiwayMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); if (pOperator->status == OP_EXEC_DONE) { return 0; @@ -556,7 +556,7 @@ int32_t getMultiwayMergeExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplai int32_t createMultiwayMergeOperatorInfo(SOperatorInfo** downStreams, size_t numStreams, SMergePhysiNode* pMergePhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); SPhysiNode* pPhyNode = (SPhysiNode*)pMergePhyNode; int32_t lino = 0; diff --git a/source/libs/executor/src/operator.c b/source/libs/executor/src/operator.c index 2605a1ceeb..766623eb7f 100644 --- a/source/libs/executor/src/operator.c +++ b/source/libs/executor/src/operator.c @@ -180,7 +180,7 @@ ERetType extractOperatorInfo(SOperatorInfo* pOperator, STraverParam* pParam, con // QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN int32_t extractOperatorInTree(SOperatorInfo* pOperator, int32_t type, const char* id, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); if (pOperator == NULL) { qError("invalid operator, failed to find tableScanOperator %s", id); @@ -282,7 +282,7 @@ int32_t stopTableScanOperator(SOperatorInfo* pOperator, const char* pIdStr, SSto int32_t createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SNode* pTagCond, SNode* pTagIndexCond, const char* pUser, const char* dbname, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = 0; int32_t type = nodeType(pPhyNode); @@ -880,7 +880,7 @@ SSDataBlock* getNextBlockFromDownstreamRemain(struct SOperatorInfo* pOperator, i } int32_t optrDefaultGetNextExtFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam, SSDataBlock** pRes) { - QRY_OPTR_CHECK(pRes); + QRY_PARAM_CHECK(pRes); int32_t code = setOperatorParams(pOperator, pParam, OP_GET_PARAM); if (TSDB_CODE_SUCCESS != code) { diff --git a/source/libs/executor/src/projectoperator.c b/source/libs/executor/src/projectoperator.c index 633eda6bf9..790e97b27c 100644 --- a/source/libs/executor/src/projectoperator.c +++ b/source/libs/executor/src/projectoperator.c @@ -93,7 +93,7 @@ void streamOperatorReloadState(SOperatorInfo* pOperator) { int32_t createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhysiNode* pProjPhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; SProjectOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SProjectOperatorInfo)); @@ -262,7 +262,7 @@ static int32_t doIngroupLimitOffset(SLimitInfo* pLimitInfo, uint64_t groupId, SS } int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); SProjectOperatorInfo* pProjectInfo = pOperator->info; SOptrBasicInfo* pInfo = &pProjectInfo->binfo; @@ -441,7 +441,7 @@ int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { int32_t createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = 0; int32_t lino = 0; int32_t numOfRows = 4096; @@ -572,7 +572,7 @@ SSDataBlock* doApplyIndefinitFunction1(SOperatorInfo* pOperator) { } int32_t doApplyIndefinitFunction(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); SIndefOperatorInfo* pIndefInfo = pOperator->info; SOptrBasicInfo* pInfo = &pIndefInfo->binfo; @@ -717,7 +717,7 @@ int32_t setFunctionResultOutput(SOperatorInfo* pOperator, SOptrBasicInfo* pInfo, } int32_t setRowTsColumnOutputInfo(SqlFunctionCtx* pCtx, int32_t numOfCols, SArray** pResList) { - QRY_OPTR_CHECK(pResList); + QRY_PARAM_CHECK(pResList); SArray* pList = taosArrayInit(4, sizeof(int32_t)); if (pList == NULL) { return terrno; diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 523d236751..46beb9f113 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -67,7 +67,7 @@ typedef struct STableCountScanOperatorInfo { SArray* stbUidList; // when group by db_name and/or stable_name } STableCountScanOperatorInfo; -static bool processBlockWithProbability(const SSampleExecInfo* pInfo); +static bool processBlockWithProbability(const SSampleExecInfo* pInfo); static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes); bool processBlockWithProbability(const SSampleExecInfo* pInfo) { @@ -937,13 +937,13 @@ static int32_t doTableScanImplNext(SOperatorInfo* pOperator, SSDataBlock** ppRes STableScanInfo* pTableScanInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; + SSDataBlock* pBlock = pTableScanInfo->pResBlock; + bool hasNext = false; + int64_t st = taosGetTimestampUs(); - SSDataBlock* pBlock = pTableScanInfo->pResBlock; - bool hasNext = false; + QRY_PARAM_CHECK(ppRes); pBlock->info.dataLoad = false; - int64_t st = taosGetTimestampUs(); - while (true) { code = pAPI->tsdReader.tsdNextDataBlock(pTableScanInfo->base.dataReader, &hasNext); if (code != TSDB_CODE_SUCCESS) { @@ -957,7 +957,7 @@ static int32_t doTableScanImplNext(SOperatorInfo* pOperator, SSDataBlock** ppRes if (isTaskKilled(pTaskInfo)) { pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->base.dataReader); - T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + return pTaskInfo->code; } if (pOperator->status == OP_EXEC_DONE) { @@ -993,6 +993,7 @@ static int32_t doTableScanImplNext(SOperatorInfo* pOperator, SSDataBlock** ppRes pOperator->cost.totalCost = pTableScanInfo->base.readRecorder.elapsedTime; pBlock->info.scanFlag = pTableScanInfo->base.scanFlag; + (*ppRes) = pBlock; return code; } @@ -1001,9 +1002,7 @@ _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); } - (*ppRes) = NULL; return code; } @@ -1014,7 +1013,7 @@ static int32_t doGroupedTableScan(SOperatorInfo* pOperator, SSDataBlock** pBlock SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; - QRY_OPTR_CHECK(pBlock); + QRY_PARAM_CHECK(pBlock); // The read handle is not initialized yet, since no qualified tables exists if (pTableScanInfo->base.dataReader == NULL || pOperator->status == OP_EXEC_DONE) { @@ -1194,7 +1193,7 @@ static int32_t startNextGroupScan(SOperatorInfo* pOperator, SSDataBlock** pResul SStorageAPI* pAPI = &pTaskInfo->storageAPI; int32_t numOfTables = 0; - QRY_OPTR_CHECK(pResult); + QRY_PARAM_CHECK(pResult); code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables); QUERY_CHECK_CODE(code, lino, _end); @@ -1242,7 +1241,7 @@ _end: return code; } -static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { +static int32_t groupSeqTableScan(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; STableScanInfo* pInfo = pOperator->info; @@ -1250,12 +1249,14 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { SStorageAPI* pAPI = &pTaskInfo->storageAPI; int32_t num = 0; STableKeyInfo* pList = NULL; - SSDataBlock* result = NULL; + SSDataBlock* pResult = NULL; + + QRY_PARAM_CHECK(pResBlock); if (pInfo->currentGroupId == -1) { if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) { setOperatorCompleted(pOperator); - return NULL; + return code; } taosRLockLatch(&pTaskInfo->lock); @@ -1273,28 +1274,32 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { if (pInfo->filesetDelimited) { pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader); } + if (pInfo->pResBlock->info.capacity > pOperator->resultInfo.capacity) { pOperator->resultInfo.capacity = pInfo->pResBlock->info.capacity; } } - result = NULL; - code = doGroupedTableScan(pOperator, &result); + pResult = NULL; + code = doGroupedTableScan(pOperator, &pResult); QUERY_CHECK_CODE(code, lino, _end); - if (result != NULL) { + if (pResult != NULL) { if (pOperator->dynamicTask) { - result->info.id.groupId = result->info.id.uid; + pResult->info.id.groupId = pResult->info.id.uid; } - return result; + + *pResBlock = pResult; + return code; } while (true) { - code = startNextGroupScan(pOperator, &result); + code = startNextGroupScan(pOperator, &pResult); QUERY_CHECK_CODE(code, lino, _end); - if (result || pOperator->status == OP_EXEC_DONE) { - return result; + if (pResult || pOperator->status == OP_EXEC_DONE) { + *pResBlock = pResult; + return code; } } @@ -1302,9 +1307,9 @@ _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); } - return result; + + return code; } static int32_t doTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { @@ -1313,7 +1318,7 @@ static int32_t doTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { STableScanInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; - QRY_OPTR_CHECK(ppRes); + QRY_PARAM_CHECK(ppRes); if (pOperator->pOperatorGetParam) { pOperator->dynamicTask = true; @@ -1394,8 +1399,7 @@ static int32_t doTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { pInfo->scanTimes = 0; } } else { // scan table group by group sequentially - (*ppRes) = groupSeqTableScan(pOperator); - return code; + code = groupSeqTableScan(pOperator, ppRes); } _end: @@ -1447,7 +1451,7 @@ static void destroyTableScanOperatorInfo(void* param) { int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -1547,7 +1551,7 @@ _error: } int32_t createTableSeqScanOperatorInfo(void* pReadHandle, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = 0; STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo)); @@ -3899,7 +3903,7 @@ static int32_t doRawScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { if (pInfo->dataReader && hasNext) { if (isTaskKilled(pTaskInfo)) { pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->dataReader); - T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + return code; } SSDataBlock* pBlock = NULL; @@ -4001,6 +4005,7 @@ static int32_t doRawScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { QUERY_CHECK_NULL(tmp, code, lino, _end, terrno); } } + (*ppRes) = NULL; return code; } @@ -4009,8 +4014,8 @@ _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); } + (*ppRes) = NULL; return code; } @@ -4032,7 +4037,7 @@ int32_t createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo // create meta reader // create tq reader - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -4224,7 +4229,7 @@ _end: int32_t createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -4459,7 +4464,7 @@ _error: return code; } -static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, int32_t count, SMetaReader* mr, +static int32_t doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, int32_t count, SMetaReader* mr, SStorageAPI* pAPI) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -4473,7 +4478,7 @@ static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, GET_TASKID(pTaskInfo)); tDecoderClear(&(*mr).coder); pAPI->metaReaderFn.clearReader(mr); - T_LONG_JMP(pTaskInfo->env, terrno); + goto _end; } code = pAPI->metaReaderFn.getTableEntryByUid(mr, item->uid); @@ -4482,7 +4487,7 @@ static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno), GET_TASKID(pTaskInfo)); pAPI->metaReaderFn.clearReader(mr); - T_LONG_JMP(pTaskInfo->env, terrno); + goto _end; } char str[512]; @@ -4511,12 +4516,13 @@ static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, } else { data = (char*)p; } + code = colDataSetVal(pDst, (count), data, (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data))); QUERY_CHECK_CODE(code, lino, _end); - if (pDst->info.type != TSDB_DATA_TYPE_JSON && p != NULL && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) && - data != NULL) { + if ((pDst->info.type != TSDB_DATA_TYPE_JSON) && (p != NULL) && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) && + (data != NULL)) { taosMemoryFree(data); } } @@ -4526,8 +4532,9 @@ _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); } + + return code; } static void tagScanFreeUidTag(void* p) { @@ -4755,10 +4762,6 @@ _end: } static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { - if (pOperator->status == OP_EXEC_DONE) { - (*ppRes) = NULL; - return TSDB_CODE_SUCCESS; - } int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -4766,6 +4769,12 @@ static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** p STagScanInfo* pInfo = pOperator->info; SSDataBlock* pRes = pInfo->pRes; + + QRY_PARAM_CHECK(ppRes); + + if (pOperator->status == OP_EXEC_DONE) { + return TSDB_CODE_SUCCESS; + } blockDataCleanup(pRes); if (pInfo->pCtbCursor == NULL) { @@ -4832,28 +4841,23 @@ static int32_t doTagScanFromCtbIdxNext(SOperatorInfo* pOperator, SSDataBlock** p pInfo->pCtbCursor = NULL; setOperatorCompleted(pOperator); } - pRes->info.rows = count; + pRes->info.rows = count; bool bLimitReached = applyLimitOffset(&pInfo->limitInfo, pRes, pTaskInfo); if (bLimitReached) { setOperatorCompleted(pOperator); } + pOperator->resultInfo.totalRows += pRes->info.rows; + (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes; + _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); } - pOperator->resultInfo.totalRows += pRes->info.rows; - (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes; - return code; -} -static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) { - SSDataBlock* pRes = NULL; - int32_t code = doTagScanFromCtbIdxNext(pOperator, &pRes); - return pRes; + return code; } static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { @@ -4884,18 +4888,18 @@ static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock* return code; } - char str[512] = {0}; int32_t count = 0; SMetaReader mr = {0}; pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn); while (pInfo->curPos < size && count < pOperator->resultInfo.capacity) { - doTagScanOneTable(pOperator, pRes, count, &mr, &pTaskInfo->storageAPI); + code = doTagScanOneTable(pOperator, pRes, count, &mr, &pTaskInfo->storageAPI); ++count; if (++pInfo->curPos >= size) { setOperatorCompleted(pOperator); } } + pRes->info.rows = count; pAPI->metaReaderFn.clearReader(&mr); @@ -4903,6 +4907,7 @@ static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock* if (bLimitReached) { setOperatorCompleted(pOperator); } + // qDebug("QInfo:0x%"PRIx64" create tag values results completed, rows:%d", GET_TASKID(pRuntimeEnv), count); if (pOperator->status == OP_EXEC_DONE) { setTaskStatus(pTaskInfo, TASK_COMPLETED); @@ -4942,7 +4947,7 @@ static void destroyTagScanOperatorInfo(void* param) { int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode, STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -5110,7 +5115,7 @@ static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSu code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock, (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL); if (code != 0) { - T_LONG_JMP(pTaskInfo->env, code); + return code; } } @@ -5118,18 +5123,20 @@ static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSu while (true) { bool hasNext = false; - int32_t code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext); + code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext); if (code != 0) { pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader); pInfo->base.dataReader = NULL; - T_LONG_JMP(pTaskInfo->env, code); + return code; } + if (!hasNext || isTaskKilled(pTaskInfo)) { if (isTaskKilled(pTaskInfo)) { pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader); pInfo->base.dataReader = NULL; - T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + return code; } + *pSubTableHasBlock = false; break; } @@ -5144,8 +5151,9 @@ static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSu code = loadDataBlock(pOperator, &pInfo->base, pInput->pReaderBlock, &status); if (code != 0) { pInfo->base.dataReader = NULL; - T_LONG_JMP(pTaskInfo->env, code); + return code; } + if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) { *pSubTableHasBlock = false; break; @@ -5412,49 +5420,56 @@ _end: return code; } -static SSDataBlock* getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pResBlock, int32_t capacity) { +static int32_t getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t capacity, SSDataBlock** pResBlock) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; STableMergeScanInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo; + bool finished = false; + + QRY_PARAM_CHECK(pResBlock); + + blockDataCleanup(pBlock); - blockDataCleanup(pResBlock); - bool finished = false; while (true) { - while (1) { + while (true) { if (pSubTblsInfo->numSubTablesCompleted >= pSubTblsInfo->numSubTables) { finished = true; break; } - code = appendChosenRowToDataBlock(pSubTblsInfo, pResBlock); + code = appendChosenRowToDataBlock(pSubTblsInfo, pBlock); QUERY_CHECK_CODE(code, lino, _end); + code = adjustSubTableForNextRow(pOperator, pSubTblsInfo); QUERY_CHECK_CODE(code, lino, _end); - if (pResBlock->info.rows >= capacity) { + if (pBlock->info.rows >= capacity) { break; } } if (isTaskKilled(pTaskInfo)) { - T_LONG_JMP(pOperator->pTaskInfo->env, pTaskInfo->code); + return pTaskInfo->code; } - bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo); - if (finished || limitReached || pResBlock->info.rows > 0) { + bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo); + if (finished || limitReached || pBlock->info.rows > 0) { break; } } + if (pBlock->info.rows > 0) { + *pResBlock = pBlock; + } + _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); } - return (pResBlock->info.rows > 0) ? pResBlock : NULL; + return code; } static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) { @@ -5504,23 +5519,22 @@ static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) { } int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { - if (pOperator->status == OP_EXEC_DONE) { - (*ppRes) = NULL; - return TSDB_CODE_SUCCESS; - } + QRY_PARAM_CHECK(ppRes); + + int32_t lino = 0; + int32_t tableListSize = 0; + int64_t st = taosGetTimestampUs(); SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; STableMergeScanInfo* pInfo = pOperator->info; - int32_t lino = 0; - int32_t code = pOperator->fpSet._openFn(pOperator); - if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, code); + if (pOperator->status == OP_EXEC_DONE) { + return TSDB_CODE_SUCCESS; } - int64_t st = taosGetTimestampUs(); + int32_t code = pOperator->fpSet._openFn(pOperator); + QUERY_CHECK_CODE(code, lino, _end); - int32_t tableListSize = 0; code = tableListGetSize(pInfo->base.pTableListInfo, &tableListSize); QUERY_CHECK_CODE(code, lino, _end); @@ -5532,6 +5546,7 @@ int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock* (*ppRes) = NULL; return code; } + pInfo->tableStartIndex = 0; STableKeyInfo* pTmpGpId = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex); QUERY_CHECK_NULL(pTmpGpId, code, lino, _end, terrno); @@ -5543,15 +5558,19 @@ int32_t doTableMergeScanParaSubTablesNext(SOperatorInfo* pOperator, SSDataBlock* SSDataBlock* pBlock = NULL; while (pInfo->tableStartIndex < tableListSize) { if (isTaskKilled(pTaskInfo)) { - T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + break; } - pBlock = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity); + code = getSubTablesSortedBlock(pOperator, pInfo->pResBlock, pOperator->resultInfo.capacity, &pBlock); + QUERY_CHECK_CODE(code, lino, _end); + if (pBlock == NULL && !pInfo->bGroupProcessed && pInfo->needCountEmptyTable) { STableKeyInfo* tbInfo = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex); QUERY_CHECK_NULL(tbInfo, code, lino, _end, terrno); + pBlock = getOneRowResultBlock(pTaskInfo, &pInfo->base, pInfo->pResBlock, tbInfo); } + if (pBlock != NULL) { pBlock->info.id.groupId = pInfo->groupId; pOperator->resultInfo.totalRows += pBlock->info.rows; @@ -5582,16 +5601,11 @@ _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); + } else { + (*ppRes) = pBlock; } - (*ppRes) = pBlock; - return code; -} -static SSDataBlock* doTableMergeScanParaSubTables(SOperatorInfo* pOperator) { - SSDataBlock* pRes = NULL; - int32_t code = doTableMergeScanParaSubTablesNext(pOperator, &pRes); - return pRes; + return code; } static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) { @@ -5623,7 +5637,7 @@ _end: } } -static void doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) { +static int32_t doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) { STableMergeScanInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; @@ -5636,7 +5650,8 @@ static void doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinishe if (code != 0) { pAPI->tsdReader.tsdReaderReleaseDataBlock(reader); qError("table merge scan fetch next data block error code: %d, %s", code, GET_TASKID(pTaskInfo)); - T_LONG_JMP(pTaskInfo->env, code); + pTaskInfo->code = code; + return code; } if (!hasNext || isTaskKilled(pTaskInfo)) { @@ -5645,7 +5660,7 @@ static void doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinishe pAPI->tsdReader.tsdReaderReleaseDataBlock(reader); } *pFinished = true; - return; + return code; } uint32_t status = 0; @@ -5653,21 +5668,22 @@ static void doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinishe if (code != TSDB_CODE_SUCCESS) { qInfo("table merge scan load datablock code %d, %s", code, GET_TASKID(pTaskInfo)); - T_LONG_JMP(pTaskInfo->env, code); + pTaskInfo->code = code; + return code; } if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) { *pFinished = true; - return; + return code; } // current block is filter out according to filter condition, continue load the next block if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) { *pSkipped = true; - return; + return code; } - return; + return code; } static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) { @@ -5678,7 +5694,7 @@ static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) { SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SSDataBlock* pBlock = NULL; int64_t st = taosGetTimestampUs(); - int32_t code = TSDB_CODE_SUCCESS; + int32_t code = TSDB_CODE_SUCCESS; while (true) { if (pInfo->rtnNextDurationBlocks) { @@ -5702,7 +5718,12 @@ static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) { } else { bool bFinished = false; bool bSkipped = false; - doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped); + + code = doGetBlockForTableMergeScan(pOperator, &bFinished, &bSkipped); + if (code != 0) { + return code; + } + pBlock = pInfo->pReaderBlock; qDebug("%s table merge scan fetch block. finished %d skipped %d next-duration-block %d new-fileset %d", GET_TASKID(pTaskInfo), bFinished, bSkipped, pInfo->bNextDurationBlockEvent, pInfo->bNewFilesetEvent); @@ -5715,7 +5736,6 @@ static int32_t getBlockForTableMergeScan(void* param, SSDataBlock** ppBlock) { if (!bSkipped) { code = createOneDataBlock(pBlock, true, &pInfo->nextDurationBlocks[pInfo->numNextDurationBlocks]); if (code) { - terrno = code; *ppBlock = NULL; return code; } @@ -5854,7 +5874,11 @@ int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) { param->pOperator = pOperator; SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource)); - QUERY_CHECK_NULL(ps, code, lino, _end, terrno); + if (ps == NULL) { + taosMemoryFree(param); + QUERY_CHECK_NULL(ps, code, lino, _end, terrno); + } + ps->param = param; ps->onlyRef = false; code = tsortAddSource(pInfo->pSortHandle, ps); @@ -6049,7 +6073,7 @@ int32_t doTableMergeScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { SSDataBlock* pBlock = NULL; while (pInfo->tableStartIndex < tableListSize) { if (isTaskKilled(pTaskInfo)) { - T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + goto _end; } pBlock = getSortedTableMergeScanBlockData(pInfo->pSortHandle, pInfo->pResBlock, pOperator->resultInfo.capacity, @@ -6093,9 +6117,10 @@ _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); + } else { + (*ppRes) = pBlock; } - (*ppRes) = pBlock; + return code; } @@ -6168,7 +6193,7 @@ int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExpla int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -6303,11 +6328,11 @@ static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI); static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI); -static void buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, +static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName); -static void buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, +static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName); -static SSDataBlock* buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, +static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes); static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum, @@ -6410,7 +6435,7 @@ int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -6593,23 +6618,29 @@ static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRe STableCountScanOperatorInfo* pInfo = pOperator->info; STableCountScanSupp* pSupp = &pInfo->supp; SSDataBlock* pRes = pInfo->pRes; + blockDataCleanup(pRes); + QRY_PARAM_CHECK(ppRes); if (pOperator->status == OP_EXEC_DONE) { - (*ppRes) = NULL; return code; } + if (pInfo->readHandle.mnd != NULL) { (*ppRes) = buildSysDbTableCount(pOperator, pInfo); return code; } - (*ppRes) = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes); + code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes); + if ((pRes->info.rows > 0) && (code == 0)) { + *ppRes = pRes; + } + return code; } -static SSDataBlock* buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, - STableCountScanSupp* pSupp, SSDataBlock* pRes) { +static int32_t buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, + STableCountScanSupp* pSupp, SSDataBlock* pRes) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; const char* db = NULL; @@ -6621,27 +6652,29 @@ static SSDataBlock* buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCount // get dbname pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL); SName sn = {0}; + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); QUERY_CHECK_CODE(code, lino, _end); + code = tNameGetDbName(&sn, dbName); QUERY_CHECK_CODE(code, lino, _end); if (pSupp->groupByDbName || pSupp->groupByStbName) { - buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName); + code = buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName); } else { - buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName); + code = buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName); } _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); } - return pRes->info.rows > 0 ? pRes : NULL; + + return code; } -static void buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, +static int32_t buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -6655,6 +6688,7 @@ static void buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountSca code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList); QUERY_CHECK_CODE(code, lino, _end); } + if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) { tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx); code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI); @@ -6684,11 +6718,11 @@ _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); pTaskInfo->code = code; - T_LONG_JMP(pTaskInfo->env, code); } + return code; } -static void buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, +static int32_t buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -6724,9 +6758,10 @@ _end: if (code != TSDB_CODE_SUCCESS) { pTaskInfo->code = code; qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); - T_LONG_JMP(pTaskInfo->env, code); } + setOperatorCompleted(pOperator); + return code; } static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, diff --git a/source/libs/executor/src/sortoperator.c b/source/libs/executor/src/sortoperator.c index bb494cacfa..9b659ac761 100644 --- a/source/libs/executor/src/sortoperator.c +++ b/source/libs/executor/src/sortoperator.c @@ -55,7 +55,7 @@ static void destroySortOpGroupIdCalc(SSortOpGroupIdCalc* pCalc); // todo add limit/offset impl int32_t createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* pSortNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = 0; int32_t lino = 0; @@ -252,7 +252,7 @@ static STupleHandle* nextTupleWithGroupId(SSortHandle* pHandle, SSortOperatorInf static int32_t getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity, SArray* pColMatchInfo, SSortOperatorInfo* pInfo, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); blockDataCleanup(pDataBlock); int32_t lino = 0; int32_t code = 0; @@ -355,25 +355,26 @@ int32_t doOpenSortOperator(SOperatorInfo* pOperator) { pInfo->startTs = taosGetTimestampUs(); // pInfo->binfo.pRes is not equalled to the input datablock. pInfo->pSortHandle = NULL; - int32_t code = tsortCreateSortHandle(pInfo->pSortInfo, SORT_SINGLESOURCE_SORT, -1, -1, NULL, pTaskInfo->id.str, - pInfo->maxRows, pInfo->maxTupleLength, tsPQSortMemThreshold * 1024 * 1024, &pInfo->pSortHandle); + int32_t code = + tsortCreateSortHandle(pInfo->pSortInfo, SORT_SINGLESOURCE_SORT, -1, -1, NULL, pTaskInfo->id.str, pInfo->maxRows, + pInfo->maxTupleLength, tsPQSortMemThreshold * 1024 * 1024, &pInfo->pSortHandle); if (code) { return code; } tsortSetFetchRawDataFp(pInfo->pSortHandle, loadNextDataBlock, applyScalarFunction, pOperator); - SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource)); - if (ps == NULL) { + SSortSource* pSource = taosMemoryCalloc(1, sizeof(SSortSource)); + if (pSource == NULL) { return terrno; } - ps->param = pOperator->pDownstream[0]; - ps->onlyRef = true; + pSource->param = pOperator->pDownstream[0]; + pSource->onlyRef = true; - code = tsortAddSource(pInfo->pSortHandle, ps); + code = tsortAddSource(pInfo->pSortHandle, pSource); if (code) { - taosMemoryFree(ps); + taosMemoryFree(pSource); return code; } @@ -390,7 +391,7 @@ int32_t doOpenSortOperator(SOperatorInfo* pOperator) { } int32_t doSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); if (pOperator->status == OP_EXEC_DONE) { return 0; } @@ -400,7 +401,7 @@ int32_t doSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { int32_t code = pOperator->fpSet._openFn(pOperator); if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, code); + return code; } // multi-group case not handle here @@ -408,7 +409,7 @@ int32_t doSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { while (1) { if (tsortIsClosed(pInfo->pSortHandle)) { code = TSDB_CODE_TSC_QUERY_CANCELLED; - T_LONG_JMP(pOperator->pTaskInfo->env, code); + T_LONG_JMP(pTaskInfo->env, code); } code = getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity, @@ -516,7 +517,7 @@ typedef struct SGroupSortOperatorInfo { int32_t getGroupSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity, SArray* pColMatchInfo, SGroupSortOperatorInfo* pInfo, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); blockDataCleanup(pDataBlock); int32_t code = blockDataEnsureCapacity(pDataBlock, capacity); @@ -598,7 +599,7 @@ int32_t fetchNextGroupSortDataBlock(void* param, SSDataBlock** ppBlock) { SGroupSortOperatorInfo* grpSortOpInfo = source->grpSortOpInfo; SSDataBlock* block = NULL; - QRY_OPTR_CHECK(ppBlock); + QRY_PARAM_CHECK(ppBlock); if (grpSortOpInfo->prefetchedSortInput) { block = grpSortOpInfo->prefetchedSortInput; @@ -648,23 +649,22 @@ int32_t beginSortGroup(SOperatorInfo* pOperator) { SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource)); SGroupSortSourceParam* param = taosMemoryCalloc(1, sizeof(SGroupSortSourceParam)); if (ps == NULL || param == NULL) { - T_LONG_JMP(pTaskInfo->env, terrno); + taosMemoryFree(ps); + taosMemoryFree(param); + return terrno; } param->childOpInfo = pOperator->pDownstream[0]; param->grpSortOpInfo = pInfo; + ps->param = param; ps->onlyRef = false; code = tsortAddSource(pInfo->pCurrSortHandle, ps); - if (code) { - T_LONG_JMP(pTaskInfo->env, code); + if (code != 0) { + return code; } code = tsortOpen(pInfo->pCurrSortHandle); - if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, code); - } - return code; } @@ -686,7 +686,7 @@ int32_t finishSortGroup(SOperatorInfo* pOperator) { } int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { - QRY_OPTR_CHECK(pResBlock); + QRY_PARAM_CHECK(pResBlock); SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SGroupSortOperatorInfo* pInfo = pOperator->info; @@ -696,7 +696,7 @@ int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { int32_t code = pOperator->fpSet._openFn(pOperator); if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, code); + return code; } if (!pInfo->hasGroupId) { @@ -720,15 +720,14 @@ int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { while (pInfo->pCurrSortHandle != NULL) { if (tsortIsClosed(pInfo->pCurrSortHandle)) { code = TSDB_CODE_TSC_QUERY_CANCELLED; - T_LONG_JMP(pOperator->pTaskInfo->env, code); + T_LONG_JMP(pTaskInfo->env, code); } // beginSortGroup would fetch all child blocks of pInfo->currGroupId; if (pInfo->childOpStatus == CHILD_OP_SAME_GROUP) { - code = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR; - pOperator->pTaskInfo->code = code; + pTaskInfo->code = code = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR; qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); - T_LONG_JMP(pOperator->pTaskInfo->env, code); + return code; } code = getGroupSortedBlockData(pInfo->pCurrSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity, @@ -777,7 +776,7 @@ void destroyGroupSortOperatorInfo(void* param) { int32_t createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSortPhysiNode* pSortPhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = 0; int32_t lino = 0; diff --git a/source/libs/executor/src/streamcountwindowoperator.c b/source/libs/executor/src/streamcountwindowoperator.c index e2ac909b8b..16c6775335 100644 --- a/source/libs/executor/src/streamcountwindowoperator.c +++ b/source/libs/executor/src/streamcountwindowoperator.c @@ -807,7 +807,7 @@ _end: int32_t createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); SCountWinodwPhysiNode* pCountNode = (SCountWinodwPhysiNode*)pPhyNode; int32_t numOfCols = 0; diff --git a/source/libs/executor/src/streameventwindowoperator.c b/source/libs/executor/src/streameventwindowoperator.c index 5ae0aa861e..1230638cff 100644 --- a/source/libs/executor/src/streameventwindowoperator.c +++ b/source/libs/executor/src/streameventwindowoperator.c @@ -858,7 +858,7 @@ _end: int32_t createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); SStreamEventWinodwPhysiNode* pEventNode = (SStreamEventWinodwPhysiNode*)pPhyNode; int32_t tsSlotId = ((SColumnNode*)pEventNode->window.pTspk)->slotId; diff --git a/source/libs/executor/src/streamfilloperator.c b/source/libs/executor/src/streamfilloperator.c index 5e3c4561b4..3fcba5fb6c 100644 --- a/source/libs/executor/src/streamfilloperator.c +++ b/source/libs/executor/src/streamfilloperator.c @@ -1364,7 +1364,7 @@ static void setValueForFillInfo(SStreamFillSupporter* pFillSup, SStreamFillInfo* int32_t createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFillPhysiNode* pPhyFillNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c index 455de4e5ce..90261a9f8e 100644 --- a/source/libs/executor/src/streamtimewindowoperator.c +++ b/source/libs/executor/src/streamtimewindowoperator.c @@ -1898,7 +1898,7 @@ _end: int32_t createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, int32_t numOfChild, SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -3772,7 +3772,7 @@ _end: int32_t createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); SSessionWinodwPhysiNode* pSessionNode = (SSessionWinodwPhysiNode*)pPhyNode; int32_t numOfCols = 0; @@ -4100,7 +4100,7 @@ static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) { int32_t createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, int32_t numOfChild, SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -4950,7 +4950,7 @@ _end: int32_t createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = 0; int32_t lino = 0; @@ -5268,7 +5268,7 @@ _end: int32_t createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c index 42fc5b7f7d..bf1153f412 100644 --- a/source/libs/executor/src/sysscanoperator.c +++ b/source/libs/executor/src/sysscanoperator.c @@ -2233,7 +2233,7 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca int32_t createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNode* pScanPhyNode, const char* pUser, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -2864,7 +2864,7 @@ static int32_t initTableblockDistQueryCond(uint64_t uid, SQueryTableDataCond* pC int32_t createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanPhysiNode* pBlockScanNode, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = 0; int32_t lino = 0; diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c index c6c8e6db35..9309546fe0 100644 --- a/source/libs/executor/src/timesliceoperator.c +++ b/source/libs/executor/src/timesliceoperator.c @@ -1104,7 +1104,7 @@ static int32_t extractPkColumnFromFuncs(SNodeList* pFuncs, bool* pHasPk, SColumn } int32_t createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = 0; int32_t lino = 0; diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index 1999694057..59883d2b80 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -1320,7 +1320,7 @@ _end: int32_t createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -1616,7 +1616,7 @@ _end: // todo make this as an non-blocking operator int32_t createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhysiNode* pStateNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -1727,7 +1727,7 @@ void destroySWindowOperatorInfo(void* param) { int32_t createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPhysiNode* pSessionNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -2027,7 +2027,7 @@ static int32_t mergeAlignedIntervalAggNext(SOperatorInfo* pOperator, SSDataBlock int32_t createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMergeAlignedIntervalPhysiNode* pNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -2366,7 +2366,7 @@ _end: int32_t createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeIntervalPhysiNode* pIntervalPhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { - QRY_OPTR_CHECK(pOptrInfo); + QRY_PARAM_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; diff --git a/source/libs/executor/src/tsort.c b/source/libs/executor/src/tsort.c index 2792e6a197..796ebbeb84 100644 --- a/source/libs/executor/src/tsort.c +++ b/source/libs/executor/src/tsort.c @@ -79,9 +79,8 @@ struct SSortHandle { bool forceUsePQSort; BoundedQueue* pBoundedQueue; uint32_t tmpRowIdx; - - int64_t mergeLimit; - int64_t currMergeLimitTs; + int64_t mergeLimit; + int64_t currMergeLimitTs; int32_t sourceId; SSDataBlock* pDataBlock; @@ -288,7 +287,7 @@ int32_t tsortCreateSortHandle(SArray* pSortInfo, int32_t type, int32_t pageSize, int32_t code = 0; int32_t lino = 0; - QRY_OPTR_CHECK(pHandle); + QRY_PARAM_CHECK(pHandle); SSortHandle* pSortHandle = taosMemoryCalloc(1, sizeof(SSortHandle)); QUERY_CHECK_NULL(pSortHandle, code, lino, _err, terrno); @@ -367,7 +366,7 @@ static int32_t sortComparCleanup(SMsortComparParam* cmpParam) { return TSDB_CODE_SUCCESS; } -void tsortClearOrderdSource(SArray* pOrderedSource, int64_t *fetchUs, int64_t *fetchNum) { +void tsortClearOrderedSource(SArray* pOrderedSource, int64_t *fetchUs, int64_t *fetchNum) { for (size_t i = 0; i < taosArrayGetSize(pOrderedSource); i++) { SSortSource** pSource = taosArrayGet(pOrderedSource, i); if (NULL == *pSource) { @@ -413,10 +412,11 @@ void tsortDestroySortHandle(SSortHandle* pSortHandle) { destroyDiskbasedBuf(pSortHandle->pBuf); taosMemoryFreeClear(pSortHandle->idStr); blockDataDestroy(pSortHandle->pDataBlock); + if (pSortHandle->pBoundedQueue) destroyBoundedQueue(pSortHandle->pBoundedQueue); int64_t fetchUs = 0, fetchNum = 0; - tsortClearOrderdSource(pSortHandle->pOrderedSource, &fetchUs, &fetchNum); + tsortClearOrderedSource(pSortHandle->pOrderedSource, &fetchUs, &fetchNum); qDebug("all source fetch time: %" PRId64 "us num:%" PRId64 " %s", fetchUs, fetchNum, pSortHandle->idStr); taosArrayDestroy(pSortHandle->pOrderedSource); @@ -465,7 +465,13 @@ static int32_t doAddNewExternalMemSource(SDiskbasedBuf* pBuf, SArray* pAllSource return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR; } - return blockDataEnsureCapacity(pSource->src.pBlock, numOfRows); + int32_t code = blockDataEnsureCapacity(pSource->src.pBlock, numOfRows); + if (code != 0) { + qError("sort failed at: %s:%d", __func__, __LINE__); + taosArrayDestroy(pPageIdList); + } + + return code; } static int32_t doAddToBuf(SSDataBlock* pDataBlock, SSortHandle* pHandle) { @@ -935,9 +941,99 @@ int32_t msortComparFn(const void* pLeft, const void* pRight, void* param) { } } } + return 0; } +static int32_t doSortForEachGroup(SSortHandle* pHandle, int32_t sortTimes, int32_t numOfSorted, + int32_t numOfInputSources, SArray* pResList, int32_t sortGroup, int32_t numOfRows) { + int32_t code = 0; + int32_t lino = 0; + SArray* pPageIdList = NULL; + + for (int32_t i = 0; i < sortGroup; ++i) { + qDebug("internal merge sort pass %d group %d. num input sources %d ", sortTimes, i, numOfInputSources); + pHandle->sourceId += 1; + + int32_t end = (i + 1) * numOfInputSources - 1; + if (end > numOfSorted - 1) { + end = numOfSorted - 1; + } + + pHandle->cmpParam.numOfSources = end - i * numOfInputSources + 1; + + code = sortComparInit(&pHandle->cmpParam, pHandle->pOrderedSource, i * numOfInputSources, end, pHandle); + QUERY_CHECK_CODE(code, lino, _err); + + code = + tMergeTreeCreate(&pHandle->pMergeTree, pHandle->cmpParam.numOfSources, &pHandle->cmpParam, pHandle->comparFn); + QUERY_CHECK_CODE(code, lino, _err); + + int32_t nMergedRows = 0; + pPageIdList = taosArrayInit(4, sizeof(int32_t)); + QUERY_CHECK_NULL(pPageIdList, code, lino, _err, terrno); + + while (1) { + if (tsortIsClosed(pHandle) || (pHandle->abortCheckFn && pHandle->abortCheckFn(pHandle->abortCheckParam))) { + code = TSDB_CODE_TSC_QUERY_CANCELLED; + goto _err; + } + + SSDataBlock* pDataBlock = NULL; + code = getSortedBlockDataInner(pHandle, &pHandle->cmpParam, numOfRows, &pDataBlock); + if (pDataBlock == NULL || code != 0) { + break; + } + + int32_t pageId = -1; + void* pPage = getNewBufPage(pHandle->pBuf, &pageId); + QUERY_CHECK_NULL(pPage, code, lino, _err, terrno); + + void* px = taosArrayPush(pPageIdList, &pageId); + QUERY_CHECK_NULL(px, code, lino, _err, terrno); + + int32_t size = + blockDataGetSize(pDataBlock) + sizeof(int32_t) + taosArrayGetSize(pDataBlock->pDataBlock) * sizeof(int32_t); + if (size > getBufPageSize(pHandle->pBuf)) { + code = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR; + goto _err; + } + + code = blockDataToBuf(pPage, pDataBlock); + QUERY_CHECK_CODE(code, lino, _err); + + setBufPageDirty(pPage, true); + releaseBufPage(pHandle->pBuf, pPage); + nMergedRows += pDataBlock->info.rows; + + blockDataCleanup(pDataBlock); + if ((pHandle->mergeLimit != -1) && (nMergedRows >= pHandle->mergeLimit)) { + break; + } + } + + code = sortComparCleanup(&pHandle->cmpParam); + QUERY_CHECK_CODE(code, lino, _err); + + tMergeTreeDestroy(&pHandle->pMergeTree); + pHandle->numOfCompletedSources = 0; + + SSDataBlock* pBlock = NULL; + code = createOneDataBlock(pHandle->pDataBlock, false, &pBlock); + QUERY_CHECK_CODE(code, lino, _err); + + code = doAddNewExternalMemSource(pHandle->pBuf, pResList, pBlock, &pHandle->sourceId, pPageIdList); + QUERY_CHECK_CODE(code, lino, _err); + } + + return code; + +_err: + taosArrayDestroy(pPageIdList); + qError("%s error happens:%s line:%d, code:%s", pHandle->idStr, __func__, lino, tstrerror(code)); + return code; +} + static int32_t doInternalMergeSort(SSortHandle* pHandle) { size_t numOfSources = taosArrayGetSize(pHandle->pOrderedSource); if (numOfSources == 0) { @@ -959,8 +1055,8 @@ static int32_t doInternalMergeSort(SSortHandle* pHandle) { pHandle->numOfPages); } - int32_t numOfRows = blockDataGetCapacityInRow(pHandle->pDataBlock, pHandle->pageSize, - blockDataGetSerialMetaSize(taosArrayGetSize(pHandle->pDataBlock->pDataBlock))); + int32_t size = (int32_t) blockDataGetSerialMetaSize(taosArrayGetSize(pHandle->pDataBlock->pDataBlock)); + int32_t numOfRows = blockDataGetCapacityInRow(pHandle->pDataBlock, pHandle->pageSize, size); if (numOfRows < 0) { return terrno; } @@ -985,117 +1081,22 @@ static int32_t doInternalMergeSort(SSortHandle* pHandle) { int32_t sortGroup = (numOfSorted + numOfInputSources - 1) / numOfInputSources; // Only *numOfInputSources* can be loaded into buffer to perform the external sort. - for (int32_t i = 0; i < sortGroup; ++i) { - qDebug("internal merge sort pass %d group %d. num input sources %d ", t, i, numOfInputSources); - pHandle->sourceId += 1; - - int32_t end = (i + 1) * numOfInputSources - 1; - if (end > numOfSorted - 1) { - end = numOfSorted - 1; - } - - pHandle->cmpParam.numOfSources = end - i * numOfInputSources + 1; - - code = sortComparInit(&pHandle->cmpParam, pHandle->pOrderedSource, i * numOfInputSources, end, pHandle); - if (code != TSDB_CODE_SUCCESS) { - taosArrayDestroy(pResList); - return code; - } - - code = - tMergeTreeCreate(&pHandle->pMergeTree, pHandle->cmpParam.numOfSources, &pHandle->cmpParam, pHandle->comparFn); - if (code != TSDB_CODE_SUCCESS) { - taosArrayDestroy(pResList); - return code; - } - - int32_t nMergedRows = 0; - SArray* pPageIdList = taosArrayInit(4, sizeof(int32_t)); - if (pPageIdList == NULL) { - taosArrayDestroy(pResList); - return terrno; - } - - while (1) { - if (tsortIsClosed(pHandle) || (pHandle->abortCheckFn && pHandle->abortCheckFn(pHandle->abortCheckParam))) { - code = terrno = TSDB_CODE_TSC_QUERY_CANCELLED; - return code; - } - - SSDataBlock* pDataBlock = NULL; - code = getSortedBlockDataInner(pHandle, &pHandle->cmpParam, numOfRows, &pDataBlock); - if (pDataBlock == NULL || code != 0) { - break; - } - - int32_t pageId = -1; - void* pPage = getNewBufPage(pHandle->pBuf, &pageId); - if (pPage == NULL) { - taosArrayDestroy(pResList); - taosArrayDestroy(pPageIdList); - return terrno; - } - - void* px = taosArrayPush(pPageIdList, &pageId); - if (px == NULL) { - taosArrayDestroy(pResList); - taosArrayDestroy(pPageIdList); - return terrno; - } - - int32_t size = - blockDataGetSize(pDataBlock) + sizeof(int32_t) + taosArrayGetSize(pDataBlock->pDataBlock) * sizeof(int32_t); - if (size > getBufPageSize(pHandle->pBuf)) { - qError("sort failed at: %s:%d", __func__, __LINE__); - return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR; - } - - code= blockDataToBuf(pPage, pDataBlock); - if (code) { - return code; - } - - setBufPageDirty(pPage, true); - releaseBufPage(pHandle->pBuf, pPage); - nMergedRows += pDataBlock->info.rows; - - blockDataCleanup(pDataBlock); - if ((pHandle->mergeLimit != -1) && (nMergedRows >= pHandle->mergeLimit)) { - break; - } - } - - code = sortComparCleanup(&pHandle->cmpParam); - if (code) { - return code; - } - - tMergeTreeDestroy(&pHandle->pMergeTree); - pHandle->numOfCompletedSources = 0; - - SSDataBlock* pBlock = NULL; - - code = createOneDataBlock(pHandle->pDataBlock, false, &pBlock); - if (code) { - taosArrayDestroy(pResList); - return code; - } - - code = doAddNewExternalMemSource(pHandle->pBuf, pResList, pBlock, &pHandle->sourceId, pPageIdList); - if (code != TSDB_CODE_SUCCESS) { - taosArrayDestroy(pResList); - return code; - } + code = doSortForEachGroup(pHandle, t, numOfSorted, numOfInputSources, pResList, sortGroup, numOfRows); + if (code != 0) { + tsortClearOrderedSource(pResList, NULL, NULL); + taosArrayDestroy(pResList); + return code; } - tsortClearOrderdSource(pHandle->pOrderedSource, NULL, NULL); + tsortClearOrderedSource(pHandle->pOrderedSource, NULL, NULL); void* px = taosArrayAddAll(pHandle->pOrderedSource, pResList); if (px == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + tsortClearOrderedSource(pResList, NULL, NULL); + taosArrayDestroy(pResList); + return terrno; } taosArrayDestroy(pResList); - numOfSorted = taosArrayGetSize(pHandle->pOrderedSource); int64_t el = taosGetTimestampUs() - st; @@ -2346,7 +2347,7 @@ static int32_t createBlocksMergeSortInitialSources(SSortHandle* pHandle) { } } - tsortClearOrderdSource(pHandle->pOrderedSource, NULL, NULL); + tsortClearOrderedSource(pHandle->pOrderedSource, NULL, NULL); if (!tsortIsClosed(pHandle)) { void* px = taosArrayAddAll(pHandle->pOrderedSource, aExtSrc); QUERY_CHECK_NULL(px, code, lino, _err, terrno); @@ -2378,37 +2379,44 @@ static int32_t createBlocksMergeSortInitialSources(SSortHandle* pHandle) { return code; } -static void freeSSortSource(SSortSource* source) { - if (NULL == source) { +static void freeSortSource(SSortSource* pSource) { + if (NULL == pSource) { return; } - if (source->param && !source->onlyRef) { - taosMemoryFree(source->param); + if (!pSource->onlyRef && pSource->param) { + taosMemoryFree(pSource->param); } - if (!source->onlyRef && source->src.pBlock) { - blockDataDestroy(source->src.pBlock); - source->src.pBlock = NULL; + + if (!pSource->onlyRef && pSource->src.pBlock) { + blockDataDestroy(pSource->src.pBlock); + pSource->src.pBlock = NULL; } - taosMemoryFree(source); + + taosMemoryFree(pSource); } static int32_t createBlocksQuickSortInitialSources(SSortHandle* pHandle) { int32_t code = 0; size_t sortBufSize = pHandle->numOfPages * pHandle->pageSize; - SSortSource** pSource = taosArrayGet(pHandle->pOrderedSource, 0); - if (pSource == NULL) { + SSortSource** p = taosArrayGet(pHandle->pOrderedSource, 0); + if (p == NULL) { return terrno; } - SSortSource* source = *pSource; - *pSource = NULL; + SSortSource* pSource = *p; - tsortClearOrderdSource(pHandle->pOrderedSource, NULL, NULL); + taosArrayRemove(pHandle->pOrderedSource, 0); + tsortClearOrderedSource(pHandle->pOrderedSource, NULL, NULL); while (1) { SSDataBlock* pBlock = NULL; - TAOS_CHECK_RETURN(pHandle->fetchfp(source->param, &pBlock)); + code = pHandle->fetchfp(pSource->param, &pBlock); + if (code != 0) { + freeSortSource(pSource); + return code; + } + if (pBlock == NULL) { break; } @@ -2422,7 +2430,7 @@ static int32_t createBlocksQuickSortInitialSources(SSortHandle* pHandle) { sortBufSize = pHandle->numOfPages * pHandle->pageSize; code = createOneDataBlock(pBlock, false, &pHandle->pDataBlock); if (code) { - freeSSortSource(source); + freeSortSource(pSource); return code; } } @@ -2433,47 +2441,45 @@ static int32_t createBlocksQuickSortInitialSources(SSortHandle* pHandle) { code = blockDataMerge(pHandle->pDataBlock, pBlock); if (code != TSDB_CODE_SUCCESS) { - freeSSortSource(source); + freeSortSource(pSource); return code; } size_t size = blockDataGetSize(pHandle->pDataBlock); if (size > sortBufSize) { // Perform the in-memory sort and then flush data in the buffer into disk. - int64_t p = taosGetTimestampUs(); + int64_t st = taosGetTimestampUs(); code = blockDataSort(pHandle->pDataBlock, pHandle->pSortInfo); if (code != 0) { - freeSSortSource(source); + freeSortSource(pSource); return code; } - int64_t el = taosGetTimestampUs() - p; - pHandle->sortElapsed += el; + pHandle->sortElapsed += (taosGetTimestampUs() - st); + if (pHandle->pqMaxRows > 0) blockDataKeepFirstNRows(pHandle->pDataBlock, pHandle->pqMaxRows); code = doAddToBuf(pHandle->pDataBlock, pHandle); if (code != TSDB_CODE_SUCCESS) { - freeSSortSource(source); + freeSortSource(pSource); return code; } } } - freeSSortSource(source); + freeSortSource(pSource); if (pHandle->pDataBlock != NULL && pHandle->pDataBlock->info.rows > 0) { size_t size = blockDataGetSize(pHandle->pDataBlock); // Perform the in-memory sort and then flush data in the buffer into disk. - int64_t p = taosGetTimestampUs(); - + int64_t st = taosGetTimestampUs(); code = blockDataSort(pHandle->pDataBlock, pHandle->pSortInfo); if (code != 0) { return code; } if (pHandle->pqMaxRows > 0) blockDataKeepFirstNRows(pHandle->pDataBlock, pHandle->pqMaxRows); - int64_t el = taosGetTimestampUs() - p; - pHandle->sortElapsed += el; + pHandle->sortElapsed += (taosGetTimestampUs() - st); // All sorted data can fit in memory, external memory sort is not needed. Return to directly if (size <= sortBufSize && pHandle->pBuf == NULL) { @@ -2488,6 +2494,7 @@ static int32_t createBlocksQuickSortInitialSources(SSortHandle* pHandle) { code = doAddToBuf(pHandle->pDataBlock, pHandle); } } + return code; } @@ -2500,7 +2507,7 @@ static int32_t createInitialSources(SSortHandle* pHandle) { code = createBlocksMergeSortInitialSources(pHandle); } - qDebug("%zu sources created", taosArrayGetSize(pHandle->pOrderedSource)); + qDebug("%s %zu sources created", pHandle->idStr, taosArrayGetSize(pHandle->pOrderedSource)); return code; } diff --git a/source/libs/function/src/functionMgt.c b/source/libs/function/src/functionMgt.c index 2f71ab8e24..1a927a1576 100644 --- a/source/libs/function/src/functionMgt.c +++ b/source/libs/function/src/functionMgt.c @@ -431,7 +431,9 @@ static int32_t createPartialFunction(const SFunctionNode* pSrcFunc, SFunctionNod (*pPartialFunc)->originalFuncId = pSrcFunc->hasOriginalFunc ? pSrcFunc->originalFuncId : pSrcFunc->funcId; char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0}; int32_t len = snprintf(name, sizeof(name) - 1, "%s.%p", (*pPartialFunc)->functionName, pSrcFunc); - (void)taosHashBinary(name, len); + if (taosHashBinary(name, len) < 0) { + return TSDB_CODE_FAILED; + } (void)strncpy((*pPartialFunc)->node.aliasName, name, TSDB_COL_NAME_LEN - 1); (*pPartialFunc)->hasPk = pSrcFunc->hasPk; (*pPartialFunc)->pkBytes = pSrcFunc->pkBytes; diff --git a/source/libs/function/src/udfd.c b/source/libs/function/src/udfd.c index adcce879eb..b17af44260 100644 --- a/source/libs/function/src/udfd.c +++ b/source/libs/function/src/udfd.c @@ -524,7 +524,12 @@ void udfdDeinitScriptPlugins() { void udfdProcessRequest(uv_work_t *req) { SUvUdfWork *uvUdf = (SUvUdfWork *)(req->data); SUdfRequest request = {0}; - if(decodeUdfRequest(uvUdf->input.base, &request) == NULL) return; + if(decodeUdfRequest(uvUdf->input.base, &request) == NULL) + { + taosMemoryFree(uvUdf->input.base); + fnError("udf request decode failed"); + return; + } switch (request.type) { case UDF_TASK_SETUP: { diff --git a/source/libs/parser/src/parInsertSql.c b/source/libs/parser/src/parInsertSql.c index a8db514ee3..9412735ded 100644 --- a/source/libs/parser/src/parInsertSql.c +++ b/source/libs/parser/src/parInsertSql.c @@ -2254,10 +2254,16 @@ static int32_t parseDataFromFileImpl(SInsertParseContext* pCxt, SVnodeModifyOpSt static int32_t parseDataFromFile(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt, SToken* pFilePath, SRowsDataContext rowsDataCxt) { - char filePathStr[PATH_MAX] = {0}; + char filePathStr[PATH_MAX + 16] = {0}; if (TK_NK_STRING == pFilePath->type) { (void)trimString(pFilePath->z, pFilePath->n, filePathStr, sizeof(filePathStr)); + if (strlen(filePathStr) >= PATH_MAX) { + return buildSyntaxErrMsg(&pCxt->msg, "file path is too long, max length is 4096", pFilePath->z); + } } else { + if (pFilePath->n >= PATH_MAX) { + return buildSyntaxErrMsg(&pCxt->msg, "file path is too long, max length is 4096", pFilePath->z); + } strncpy(filePathStr, pFilePath->z, pFilePath->n); } pStmt->fp = taosOpenFile(filePathStr, TD_FILE_READ | TD_FILE_STREAM); diff --git a/source/libs/parser/src/parInsertStmt.c b/source/libs/parser/src/parInsertStmt.c index 025459a8c9..5b459243a4 100644 --- a/source/libs/parser/src/parInsertStmt.c +++ b/source/libs/parser/src/parInsertStmt.c @@ -448,7 +448,407 @@ int32_t qBindStmtSingleColValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bi pBind = bind; } - code = tColDataAddValueByBind(pCol, pBind, IS_VAR_DATA_TYPE(pColSchema->type) ? pColSchema->bytes - VARSTR_HEADER_SIZE : -1); + code = tColDataAddValueByBind(pCol, pBind, + IS_VAR_DATA_TYPE(pColSchema->type) ? pColSchema->bytes - VARSTR_HEADER_SIZE : -1); + + qDebug("stmt col %d bind %d rows data", colIdx, rowNum); + +_return: + + taosMemoryFree(ncharBind.buffer); + taosMemoryFree(ncharBind.length); + + return code; +} + +int32_t qBindStmtTagsValue2(void* pBlock, void* boundTags, int64_t suid, const char* sTableName, char* tName, + TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen) { + STableDataCxt* pDataBlock = (STableDataCxt*)pBlock; + SMsgBuf pBuf = {.buf = msgBuf, .len = msgBufLen}; + int32_t code = TSDB_CODE_SUCCESS; + SBoundColInfo* tags = (SBoundColInfo*)boundTags; + if (NULL == tags) { + return TSDB_CODE_APP_ERROR; + } + + SArray* pTagArray = taosArrayInit(tags->numOfBound, sizeof(STagVal)); + if (!pTagArray) { + return buildInvalidOperationMsg(&pBuf, "out of memory"); + } + + SArray* tagName = taosArrayInit(8, TSDB_COL_NAME_LEN); + if (!tagName) { + code = buildInvalidOperationMsg(&pBuf, "out of memory"); + goto end; + } + + SSchema* pSchema = getTableTagSchema(pDataBlock->pMeta); + + bool isJson = false; + STag* pTag = NULL; + + for (int c = 0; c < tags->numOfBound; ++c) { + if (bind[c].is_null && bind[c].is_null[0]) { + continue; + } + + SSchema* pTagSchema = &pSchema[tags->pColIndex[c]]; + int32_t colLen = pTagSchema->bytes; + if (IS_VAR_DATA_TYPE(pTagSchema->type)) { + colLen = bind[c].length[0]; + if ((colLen + VARSTR_HEADER_SIZE) > pTagSchema->bytes) { + code = buildInvalidOperationMsg(&pBuf, "tag length is too big"); + goto end; + } + } + if (NULL == taosArrayPush(tagName, pTagSchema->name)) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto end; + } + if (pTagSchema->type == TSDB_DATA_TYPE_JSON) { + if (colLen > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) { + code = buildSyntaxErrMsg(&pBuf, "json string too long than 4095", bind[c].buffer); + goto end; + } + + isJson = true; + char* tmp = taosMemoryCalloc(1, colLen + 1); + memcpy(tmp, bind[c].buffer, colLen); + code = parseJsontoTagData(tmp, pTagArray, &pTag, &pBuf); + taosMemoryFree(tmp); + if (code != TSDB_CODE_SUCCESS) { + goto end; + } + } else { + STagVal val = {.cid = pTagSchema->colId, .type = pTagSchema->type}; + // strcpy(val.colName, pTagSchema->name); + if (pTagSchema->type == TSDB_DATA_TYPE_BINARY || pTagSchema->type == TSDB_DATA_TYPE_VARBINARY || + pTagSchema->type == TSDB_DATA_TYPE_GEOMETRY) { + val.pData = (uint8_t*)bind[c].buffer; + val.nData = colLen; + } else if (pTagSchema->type == TSDB_DATA_TYPE_NCHAR) { + int32_t output = 0; + void* p = taosMemoryCalloc(1, colLen * TSDB_NCHAR_SIZE); + if (p == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto end; + } + if (!taosMbsToUcs4(bind[c].buffer, colLen, (TdUcs4*)(p), colLen * TSDB_NCHAR_SIZE, &output)) { + if (errno == E2BIG) { + taosMemoryFree(p); + code = generateSyntaxErrMsg(&pBuf, TSDB_CODE_PAR_VALUE_TOO_LONG, pTagSchema->name); + goto end; + } + char buf[512] = {0}; + snprintf(buf, tListLen(buf), " taosMbsToUcs4 error:%s", strerror(errno)); + taosMemoryFree(p); + code = buildSyntaxErrMsg(&pBuf, buf, bind[c].buffer); + goto end; + } + val.pData = p; + val.nData = output; + } else { + memcpy(&val.i64, bind[c].buffer, colLen); + } + if (NULL == taosArrayPush(pTagArray, &val)) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto end; + } + } + } + + if (!isJson && (code = tTagNew(pTagArray, 1, false, &pTag)) != TSDB_CODE_SUCCESS) { + goto end; + } + + if (NULL == pDataBlock->pData->pCreateTbReq) { + pDataBlock->pData->pCreateTbReq = taosMemoryCalloc(1, sizeof(SVCreateTbReq)); + if (NULL == pDataBlock->pData->pCreateTbReq) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto end; + } + } + + insBuildCreateTbReq(pDataBlock->pData->pCreateTbReq, tName, pTag, suid, sTableName, tagName, + pDataBlock->pMeta->tableInfo.numOfTags, TSDB_DEFAULT_TABLE_TTL); + pTag = NULL; + +end: + for (int i = 0; i < taosArrayGetSize(pTagArray); ++i) { + STagVal* p = (STagVal*)taosArrayGet(pTagArray, i); + if (p->type == TSDB_DATA_TYPE_NCHAR) { + taosMemoryFreeClear(p->pData); + } + } + taosArrayDestroy(pTagArray); + taosArrayDestroy(tagName); + taosMemoryFree(pTag); + + return code; +} + +static int32_t convertStmtStbNcharCol2(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_STMT2_BIND* src, TAOS_STMT2_BIND* dst) { + int32_t output = 0; + const int32_t max_buf_len = pSchema->bytes - VARSTR_HEADER_SIZE; + + dst->buffer = taosMemoryCalloc(src->num, max_buf_len); + if (NULL == dst->buffer) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + dst->length = taosMemoryCalloc(src->num, sizeof(int32_t)); + if (NULL == dst->length) { + taosMemoryFreeClear(dst->buffer); + return TSDB_CODE_OUT_OF_MEMORY; + } + + char* src_buf = src->buffer; + char* dst_buf = dst->buffer; + for (int32_t i = 0; i < src->num; ++i) { + if (src->is_null && src->is_null[i]) { + continue; + } + + if (!taosMbsToUcs4(src_buf, src->length[i], (TdUcs4*)dst_buf, max_buf_len, &output)) { + if (errno == E2BIG) { + return generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name); + } + char buf[512] = {0}; + snprintf(buf, tListLen(buf), "%s", strerror(errno)); + return buildSyntaxErrMsg(pMsgBuf, buf, NULL); + } + + dst->length[i] = output; + src_buf += src->length[i]; + dst_buf += output; + } + + dst->buffer_type = src->buffer_type; + dst->is_null = src->is_null; + dst->num = src->num; + + return TSDB_CODE_SUCCESS; +} + +int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, + STSchema** pTSchema, SBindInfo2* pBindInfos) { + STableDataCxt* pDataBlock = (STableDataCxt*)pBlock; + SSchema* pSchema = getTableColumnSchema(pDataBlock->pMeta); + SBoundColInfo* boundInfo = &pDataBlock->boundColsInfo; + SMsgBuf pBuf = {.buf = msgBuf, .len = msgBufLen}; + int32_t rowNum = bind->num; + SArray* ncharBinds = NULL; + TAOS_STMT2_BIND ncharBind = {0}; + int32_t code = 0; + int16_t lastColId = -1; + bool colInOrder = true; + + if (NULL == *pTSchema) { + *pTSchema = tBuildTSchema(pSchema, pDataBlock->pMeta->tableInfo.numOfColumns, pDataBlock->pMeta->sversion); + } + + for (int c = 0; c < boundInfo->numOfBound; ++c) { + SSchema* pColSchema = &pSchema[boundInfo->pColIndex[c]]; + if (pColSchema->colId <= lastColId) { + colInOrder = false; + } else { + lastColId = pColSchema->colId; + } + + if (bind[c].num != rowNum) { + code = buildInvalidOperationMsg(&pBuf, "row number in each bind param should be the same"); + goto _return; + } + + if ((!(rowNum == 1 && bind[c].is_null && *bind[c].is_null)) && + bind[c].buffer_type != pColSchema->type) { // for rowNum ==1 , connector may not set buffer_type + code = buildInvalidOperationMsg(&pBuf, "column type mis-match with buffer type"); + goto _return; + } + + if (TSDB_DATA_TYPE_NCHAR == pColSchema->type) { + code = convertStmtStbNcharCol2(&pBuf, pColSchema, bind + c, &ncharBind); + if (code) { + goto _return; + } + if (!ncharBinds) { + ncharBinds = taosArrayInit(1, sizeof(ncharBind)); + if (!ncharBinds) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _return; + } + } + if (!taosArrayPush(ncharBinds, &ncharBind)) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _return; + } + pBindInfos[c].bind = taosArrayGetLast(ncharBinds); + } else { + pBindInfos[c].bind = bind + c; + } + + pBindInfos[c].columnId = pColSchema->colId; + pBindInfos[c].type = pColSchema->type; + pBindInfos[c].bytes = pColSchema->bytes; + } + + code = tRowBuildFromBind2(pBindInfos, boundInfo->numOfBound, colInOrder, *pTSchema, pCols); + + qDebug("stmt all %d columns bind %d rows data", boundInfo->numOfBound, rowNum); + +_return: + if (ncharBinds) { + for (int i = 0; i < TARRAY_SIZE(ncharBinds); ++i) { + TAOS_STMT2_BIND* ncBind = TARRAY_DATA(ncharBinds); + taosMemoryFree(ncBind[i].buffer); + taosMemoryFree(ncBind[i].length); + } + taosArrayDestroy(ncharBinds); + } + + return code; +} + +static int32_t convertStmtNcharCol2(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_STMT2_BIND* src, TAOS_STMT2_BIND* dst) { + int32_t output = 0; + const int32_t max_buf_len = pSchema->bytes - VARSTR_HEADER_SIZE; + + int32_t newBuflen = (pSchema->bytes - VARSTR_HEADER_SIZE) * src->num; + // if (dst->buffer_length < newBuflen) { + dst->buffer = taosMemoryRealloc(dst->buffer, newBuflen); + if (NULL == dst->buffer) { + return TSDB_CODE_OUT_OF_MEMORY; + } + //} + + if (NULL == dst->length) { + dst->length = taosMemoryRealloc(dst->length, sizeof(int32_t) * src->num); + if (NULL == dst->length) { + taosMemoryFreeClear(dst->buffer); + return TSDB_CODE_OUT_OF_MEMORY; + } + } + + // dst->buffer_length = pSchema->bytes - VARSTR_HEADER_SIZE; + char* src_buf = src->buffer; + char* dst_buf = dst->buffer; + for (int32_t i = 0; i < src->num; ++i) { + if (src->is_null && src->is_null[i]) { + continue; + } + + /*if (!taosMbsToUcs4(((char*)src->buffer) + src->buffer_length * i, src->length[i], + (TdUcs4*)(((char*)dst->buffer) + dst->buffer_length * i), dst->buffer_length, &output)) {*/ + if (!taosMbsToUcs4(src_buf, src->length[i], (TdUcs4*)dst_buf, max_buf_len, &output)) { + if (errno == E2BIG) { + return generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name); + } + char buf[512] = {0}; + snprintf(buf, tListLen(buf), "%s", strerror(errno)); + return buildSyntaxErrMsg(pMsgBuf, buf, NULL); + } + + dst->length[i] = output; + src_buf += src->length[i]; + dst_buf += output; + } + + dst->buffer_type = src->buffer_type; + dst->is_null = src->is_null; + dst->num = src->num; + + return TSDB_CODE_SUCCESS; +} + +int32_t qBindStmtColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen) { + STableDataCxt* pDataBlock = (STableDataCxt*)pBlock; + SSchema* pSchema = getTableColumnSchema(pDataBlock->pMeta); + SBoundColInfo* boundInfo = &pDataBlock->boundColsInfo; + SMsgBuf pBuf = {.buf = msgBuf, .len = msgBufLen}; + int32_t rowNum = bind->num; + TAOS_STMT2_BIND ncharBind = {0}; + TAOS_STMT2_BIND* pBind = NULL; + int32_t code = 0; + + for (int c = 0; c < boundInfo->numOfBound; ++c) { + SSchema* pColSchema = &pSchema[boundInfo->pColIndex[c]]; + SColData* pCol = taosArrayGet(pCols, c); + + if (bind[c].num != rowNum) { + code = buildInvalidOperationMsg(&pBuf, "row number in each bind param should be the same"); + goto _return; + } + + if ((!(rowNum == 1 && bind[c].is_null && *bind[c].is_null)) && + bind[c].buffer_type != pColSchema->type) { // for rowNum ==1 , connector may not set buffer_type + code = buildInvalidOperationMsg(&pBuf, "column type mis-match with buffer type"); + goto _return; + } + + if (TSDB_DATA_TYPE_NCHAR == pColSchema->type) { + code = convertStmtNcharCol2(&pBuf, pColSchema, bind + c, &ncharBind); + if (code) { + goto _return; + } + pBind = &ncharBind; + } else { + pBind = bind + c; + } + + code = tColDataAddValueByBind2(pCol, pBind, + IS_VAR_DATA_TYPE(pColSchema->type) ? pColSchema->bytes - VARSTR_HEADER_SIZE : -1); + if (code) { + goto _return; + } + } + + qDebug("stmt all %d columns bind %d rows data", boundInfo->numOfBound, rowNum); + +_return: + + taosMemoryFree(ncharBind.buffer); + taosMemoryFree(ncharBind.length); + + return code; +} + +int32_t qBindStmtSingleColValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, + int32_t colIdx, int32_t rowNum) { + STableDataCxt* pDataBlock = (STableDataCxt*)pBlock; + SSchema* pSchema = getTableColumnSchema(pDataBlock->pMeta); + SBoundColInfo* boundInfo = &pDataBlock->boundColsInfo; + SMsgBuf pBuf = {.buf = msgBuf, .len = msgBufLen}; + SSchema* pColSchema = &pSchema[boundInfo->pColIndex[colIdx]]; + SColData* pCol = taosArrayGet(pCols, colIdx); + TAOS_STMT2_BIND ncharBind = {0}; + TAOS_STMT2_BIND* pBind = NULL; + int32_t code = 0; + + if (bind->num != rowNum) { + return buildInvalidOperationMsg(&pBuf, "row number in each bind param should be the same"); + } + + // Column index exceeds the number of columns + if (colIdx >= pCols->size && pCol == NULL) { + return buildInvalidOperationMsg(&pBuf, "column index exceeds the number of columns"); + } + + if (bind->buffer_type != pColSchema->type) { + return buildInvalidOperationMsg(&pBuf, "column type mis-match with buffer type"); + } + + if (TSDB_DATA_TYPE_NCHAR == pColSchema->type) { + code = convertStmtNcharCol2(&pBuf, pColSchema, bind, &ncharBind); + if (code) { + goto _return; + } + pBind = &ncharBind; + } else { + pBind = bind; + } + + code = tColDataAddValueByBind2(pCol, pBind, + IS_VAR_DATA_TYPE(pColSchema->type) ? pColSchema->bytes - VARSTR_HEADER_SIZE : -1); qDebug("stmt col %d bind %d rows data", colIdx, rowNum); @@ -533,7 +933,7 @@ int32_t qResetStmtColumns(SArray* pCols, bool deepClear) { for (int32_t i = 0; i < colNum; ++i) { SColData* pCol = (SColData*)taosArrayGet(pCols, i); - if (pCol == NULL){ + if (pCol == NULL) { qError("qResetStmtColumns column is NULL"); return TSDB_CODE_OUT_OF_MEMORY; } @@ -553,7 +953,7 @@ int32_t qResetStmtDataBlock(STableDataCxt* block, bool deepClear) { for (int32_t i = 0; i < colNum; ++i) { SColData* pCol = (SColData*)taosArrayGet(pBlock->pData->aCol, i); - if (pCol == NULL){ + if (pCol == NULL) { qError("qResetStmtDataBlock column is NULL"); return TSDB_CODE_OUT_OF_MEMORY; } diff --git a/source/libs/parser/src/parser.c b/source/libs/parser/src/parser.c index e96aaf52ed..b78cd36f0e 100644 --- a/source/libs/parser/src/parser.c +++ b/source/libs/parser/src/parser.c @@ -76,33 +76,33 @@ bool qIsCreateTbFromFileSql(const char* pStr, size_t length) { } bool qParseDbName(const char* pStr, size_t length, char** pDbName) { - (void) length; + (void)length; int32_t index = 0; - SToken t; + SToken t; if (NULL == pStr) { *pDbName = NULL; return false; } - t = tStrGetToken((char *) pStr, &index, false, NULL); + t = tStrGetToken((char*)pStr, &index, false, NULL); if (TK_INSERT != t.type && TK_IMPORT != t.type) { *pDbName = NULL; return false; } - t = tStrGetToken((char *) pStr, &index, false, NULL); + t = tStrGetToken((char*)pStr, &index, false, NULL); if (TK_INTO != t.type) { *pDbName = NULL; return false; } - t = tStrGetToken((char *) pStr, &index, false, NULL); + t = tStrGetToken((char*)pStr, &index, false, NULL); if (t.n == 0 || t.z == NULL) { *pDbName = NULL; return false; } - char *dotPos = strnchr(t.z, '.', t.n, true); + char* dotPos = strnchr(t.z, '.', t.n, true); if (dotPos != NULL) { int dbNameLen = dotPos - t.z; *pDbName = taosMemoryMalloc(dbNameLen + 1); @@ -331,13 +331,12 @@ int32_t qContinueParsePostQuery(SParseContext* pCxt, SQuery* pQuery, SSDataBlock return code; } - -static void destoryTablesReq(void *p) { - STablesReq *pRes = (STablesReq *)p; +static void destoryTablesReq(void* p) { + STablesReq* pRes = (STablesReq*)p; taosArrayDestroy(pRes->pTables); } -void destoryCatalogReq(SCatalogReq *pCatalogReq) { +void destoryCatalogReq(SCatalogReq* pCatalogReq) { if (NULL == pCatalogReq) { return; } @@ -369,7 +368,6 @@ void destoryCatalogReq(SCatalogReq *pCatalogReq) { taosArrayDestroy(pCatalogReq->pTableTag); } - void tfreeSParseQueryRes(void* p) { if (NULL == p) { return; @@ -410,9 +408,7 @@ int32_t qSetSTableIdForRsma(SNode* pStmt, int64_t uid) { return TSDB_CODE_FAILED; } -int32_t qInitKeywordsTable() { - return taosInitKeywordsTable(); -} +int32_t qInitKeywordsTable() { return taosInitKeywordsTable(); } void qCleanupKeywordsTable() { taosCleanupKeywordsTable(); } @@ -445,6 +441,98 @@ int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx return code; } +static int32_t setValueByBindParam2(SValueNode* pVal, TAOS_STMT2_BIND* pParam) { + if (IS_VAR_DATA_TYPE(pVal->node.resType.type)) { + taosMemoryFreeClear(pVal->datum.p); + } + + if (pParam->is_null && 1 == *(pParam->is_null)) { + pVal->node.resType.type = TSDB_DATA_TYPE_NULL; + pVal->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_NULL].bytes; + return TSDB_CODE_SUCCESS; + } + + int32_t inputSize = (NULL != pParam->length ? *(pParam->length) : tDataTypes[pParam->buffer_type].bytes); + pVal->node.resType.type = pParam->buffer_type; + pVal->node.resType.bytes = inputSize; + + switch (pParam->buffer_type) { + case TSDB_DATA_TYPE_VARBINARY: + pVal->datum.p = taosMemoryCalloc(1, pVal->node.resType.bytes + VARSTR_HEADER_SIZE + 1); + if (NULL == pVal->datum.p) { + return TSDB_CODE_OUT_OF_MEMORY; + } + varDataSetLen(pVal->datum.p, pVal->node.resType.bytes); + memcpy(varDataVal(pVal->datum.p), pParam->buffer, pVal->node.resType.bytes); + pVal->node.resType.bytes += VARSTR_HEADER_SIZE; + break; + case TSDB_DATA_TYPE_VARCHAR: + case TSDB_DATA_TYPE_GEOMETRY: + pVal->datum.p = taosMemoryCalloc(1, pVal->node.resType.bytes + VARSTR_HEADER_SIZE + 1); + if (NULL == pVal->datum.p) { + return TSDB_CODE_OUT_OF_MEMORY; + } + varDataSetLen(pVal->datum.p, pVal->node.resType.bytes); + strncpy(varDataVal(pVal->datum.p), (const char*)pParam->buffer, pVal->node.resType.bytes); + pVal->node.resType.bytes += VARSTR_HEADER_SIZE; + break; + case TSDB_DATA_TYPE_NCHAR: { + pVal->node.resType.bytes *= TSDB_NCHAR_SIZE; + pVal->datum.p = taosMemoryCalloc(1, pVal->node.resType.bytes + VARSTR_HEADER_SIZE + 1); + if (NULL == pVal->datum.p) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + int32_t output = 0; + if (!taosMbsToUcs4(pParam->buffer, inputSize, (TdUcs4*)varDataVal(pVal->datum.p), pVal->node.resType.bytes, + &output)) { + return errno; + } + varDataSetLen(pVal->datum.p, output); + pVal->node.resType.bytes = output + VARSTR_HEADER_SIZE; + break; + } + default: { + int32_t code = nodesSetValueNodeValue(pVal, pParam->buffer); + if (code) { + return code; + } + break; + } + } + pVal->translate = true; + return TSDB_CODE_SUCCESS; +} + +int32_t qStmtBindParams2(SQuery* pQuery, TAOS_STMT2_BIND* pParams, int32_t colIdx) { + int32_t code = TSDB_CODE_SUCCESS; + + if (colIdx < 0) { + int32_t size = taosArrayGetSize(pQuery->pPlaceholderValues); + for (int32_t i = 0; i < size; ++i) { + code = setValueByBindParam2((SValueNode*)taosArrayGetP(pQuery->pPlaceholderValues, i), pParams + i); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } + } else { + code = setValueByBindParam2((SValueNode*)taosArrayGetP(pQuery->pPlaceholderValues, colIdx), pParams); + } + + if (TSDB_CODE_SUCCESS == code && (colIdx < 0 || colIdx + 1 == pQuery->placeholderNum)) { + nodesDestroyNode(pQuery->pRoot); + pQuery->pRoot = NULL; + code = nodesCloneNode(pQuery->pPrepareRoot, &pQuery->pRoot); + if (NULL == pQuery->pRoot) { + code = code; + } + } + if (TSDB_CODE_SUCCESS == code) { + rewriteExprAlias(pQuery->pRoot); + } + return code; +} + int32_t qStmtParseQuerySql(SParseContext* pCxt, SQuery* pQuery) { int32_t code = translate(pCxt, pQuery, NULL); if (TSDB_CODE_SUCCESS == code) { diff --git a/source/libs/scalar/src/filter.c b/source/libs/scalar/src/filter.c index f03eaf2f75..ec48dd50ae 100644 --- a/source/libs/scalar/src/filter.c +++ b/source/libs/scalar/src/filter.c @@ -2249,7 +2249,7 @@ int32_t fltInitValFieldData(SFilterInfo *info) { return TSDB_CODE_SCALAR_CONVERT_ERROR; } varDataSetLen(newValData, len); - (void)varDataCopy(fi->data, newValData); + varDataCopy(fi->data, newValData); } } @@ -4592,7 +4592,7 @@ int32_t filterConverNcharColumns(SFilterInfo *info, int32_t rows, bool *gotNchar if (k == varSrcLen) { /* NULL */ varDataLen(dst) = (VarDataLenT)varSrcLen; - (void)varDataCopy(dst, src); + varDataCopy(dst, src); continue; } bool ret = taosMbsToUcs4(varDataVal(src), varDataLen(src), (TdUcs4 *)varDataVal(dst), bufSize, &len); diff --git a/source/libs/scalar/src/scalar.c b/source/libs/scalar/src/scalar.c index 84f5e1de0a..f4f4780a01 100644 --- a/source/libs/scalar/src/scalar.c +++ b/source/libs/scalar/src/scalar.c @@ -1585,7 +1585,10 @@ EDealRes sclWalkTarget(SNode *pNode, SScalarCtx *ctx) { block->info.rows = res->numOfRows; sclFreeParam(res); - (void)taosHashRemove(ctx->pRes, (void *)&target->pExpr, POINTER_BYTES); + ctx->code = taosHashRemove(ctx->pRes, (void *)&target->pExpr, POINTER_BYTES); + if (TSDB_CODE_SUCCESS != ctx->code) { + return DEAL_RES_ERROR; + } return DEAL_RES_CONTINUE; } @@ -1811,7 +1814,7 @@ int32_t scalarCalculate(SNode *pNode, SArray *pBlockList, SScalarParam *pDst) { } sclFreeParam(res); - (void)taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES); + SCL_ERR_JRET(taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES)); } _return: diff --git a/source/libs/scalar/test/filter/filterTests.cpp b/source/libs/scalar/test/filter/filterTests.cpp index b970bf5297..70d6f7d0ae 100644 --- a/source/libs/scalar/test/filter/filterTests.cpp +++ b/source/libs/scalar/test/filter/filterTests.cpp @@ -76,7 +76,7 @@ int32_t flttMakeValueNode(SNode **pNode, int32_t dataType, void *value) { if (NULL == vnode->datum.p) { FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - (void)varDataCopy(vnode->datum.p, value); + varDataCopy(vnode->datum.p, value); vnode->node.resType.bytes = varDataLen(value); } else { vnode->node.resType.bytes = tDataTypes[dataType].bytes; diff --git a/source/libs/scalar/test/scalar/scalarTests.cpp b/source/libs/scalar/test/scalar/scalarTests.cpp index c29f7b8a5b..e14b772ea8 100644 --- a/source/libs/scalar/test/scalar/scalarTests.cpp +++ b/source/libs/scalar/test/scalar/scalarTests.cpp @@ -120,7 +120,9 @@ int32_t scltAppendReservedSlot(SArray *pBlockList, int16_t *dataBlockId, int16_t SCL_ERR_RET(TSDB_CODE_APP_ERROR); } - (void)taosArrayPush(pBlockList, &res); + if (NULL == taosArrayPush(pBlockList, &res)) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } *dataBlockId = taosArrayGetSize(pBlockList) - 1; res->info.id.blockId = *dataBlockId; *slotId = 0; @@ -161,7 +163,7 @@ int32_t scltMakeValueNode(SNode **pNode, int32_t dataType, void *value) { if (NULL == vnode->datum.p) { SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - (void)varDataCopy(vnode->datum.p, value); + varDataCopy(vnode->datum.p, value); vnode->node.resType.bytes = varDataTLen(value); } else { vnode->node.resType.bytes = tDataTypes[dataType].bytes; @@ -1382,7 +1384,9 @@ int32_t makeCalculate(void *json, void *key, int32_t rightType, void *rightData, SNode *opNode = NULL; SCL_ERR_RET(makeJsonArrow(&src, &opNode, json, (char *)key)); - (void)taosArrayPush(blockList, &src); + if (NULL == taosArrayPush(blockList, &src)) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SCL_ERR_RET(makeOperator(&opNode, blockList, opType, rightType, rightData, isReverse)); @@ -1909,7 +1913,7 @@ TEST(columnTest, bigint_column_multi_binary_column) { SArray *blockList = taosArrayInit(1, POINTER_BYTES); ASSERT_NE(blockList, nullptr); - (void)taosArrayPush(blockList, &src); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_DOUBLE, sizeof(double)); int16_t dataBlockId = 0, slotId = 0; diff --git a/source/libs/scheduler/src/schRemote.c b/source/libs/scheduler/src/schRemote.c index 4e34a47902..bf88248259 100644 --- a/source/libs/scheduler/src/schRemote.c +++ b/source/libs/scheduler/src/schRemote.c @@ -144,7 +144,6 @@ int32_t schProcessExplainRsp(SSchJob *pJob, SSchTask *pTask, SExplainRsp *rsp) { int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SDataBuf *pMsg, int32_t rspCode) { int32_t code = 0; - char *msg = pMsg->pData; int32_t msgSize = pMsg->len; int32_t msgType = pMsg->msgType; @@ -158,9 +157,9 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD } case TDMT_VND_CREATE_TABLE_RSP: { SVCreateTbBatchRsp batchRsp = {0}; - if (msg) { + if (pMsg->pData) { SDecoder coder = {0}; - tDecoderInit(&coder, msg, msgSize); + tDecoderInit(&coder, pMsg->pData, msgSize); code = tDecodeSVCreateTbBatchRsp(&coder, &batchRsp); if (TSDB_CODE_SUCCESS == code && batchRsp.nRsps > 0) { SCH_LOCK(SCH_WRITE, &pJob->resLock); @@ -206,16 +205,16 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD } SCH_ERR_JRET(rspCode); - taosMemoryFreeClear(msg); + taosMemoryFreeClear(pMsg->pData); SCH_ERR_JRET(schProcessOnTaskSuccess(pJob, pTask)); break; } case TDMT_VND_DROP_TABLE_RSP: { SVDropTbBatchRsp batchRsp = {0}; - if (msg) { + if (pMsg->pData) { SDecoder coder = {0}; - tDecoderInit(&coder, msg, msgSize); + tDecoderInit(&coder, pMsg->pData, msgSize); code = tDecodeSVDropTbBatchRsp(&coder, &batchRsp); if (TSDB_CODE_SUCCESS == code && batchRsp.nRsps > 0) { for (int32_t i = 0; i < batchRsp.nRsps; ++i) { @@ -232,16 +231,16 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD } SCH_ERR_JRET(rspCode); - taosMemoryFreeClear(msg); + taosMemoryFreeClear(pMsg->pData); SCH_ERR_JRET(schProcessOnTaskSuccess(pJob, pTask)); break; } case TDMT_VND_ALTER_TABLE_RSP: { SVAlterTbRsp rsp = {0}; - if (msg) { + if (pMsg->pData) { SDecoder coder = {0}; - tDecoderInit(&coder, msg, msgSize); + tDecoderInit(&coder, pMsg->pData, msgSize); code = tDecodeSVAlterTbRsp(&coder, &rsp); tDecoderClear(&coder); SCH_ERR_JRET(code); @@ -253,11 +252,11 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD SCH_ERR_JRET(rspCode); - if (NULL == msg) { + if (NULL == pMsg->pData) { SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT); } - taosMemoryFreeClear(msg); + taosMemoryFreeClear(pMsg->pData); SCH_ERR_JRET(schProcessOnTaskSuccess(pJob, pTask)); break; @@ -265,10 +264,10 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD case TDMT_VND_SUBMIT_RSP: { SCH_ERR_JRET(rspCode); - if (msg) { + if (pMsg->pData) { SDecoder coder = {0}; SSubmitRsp2 *rsp = taosMemoryMalloc(sizeof(*rsp)); - tDecoderInit(&coder, msg, msgSize); + tDecoderInit(&coder, pMsg->pData, msgSize); code = tDecodeSSubmitRsp2(&coder, rsp); tDecoderClear(&coder); if (code) { @@ -319,7 +318,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD } } - taosMemoryFreeClear(msg); + taosMemoryFreeClear(pMsg->pData); SCH_ERR_JRET(schProcessOnTaskSuccess(pJob, pTask)); @@ -328,10 +327,10 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD case TDMT_VND_DELETE_RSP: { SCH_ERR_JRET(rspCode); - if (msg) { + if (pMsg->pData) { SDecoder coder = {0}; SVDeleteRsp rsp = {0}; - tDecoderInit(&coder, msg, msgSize); + tDecoderInit(&coder, pMsg->pData, msgSize); if (tDecodeSVDeleteRsp(&coder, &rsp) < 0) { code = terrno; tDecoderClear(&coder); @@ -343,7 +342,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD SCH_TASK_DLOG("delete succeed, affectedRows:%" PRId64, rsp.affectedRows); } - taosMemoryFreeClear(msg); + taosMemoryFreeClear(pMsg->pData); SCH_ERR_JRET(schProcessOnTaskSuccess(pJob, pTask)); @@ -352,7 +351,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD case TDMT_SCH_QUERY_RSP: case TDMT_SCH_MERGE_QUERY_RSP: { SCH_ERR_JRET(rspCode); - if (NULL == msg) { + if (NULL == pMsg->pData) { SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT); } @@ -365,7 +364,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD } SQueryTableRsp rsp = {0}; - if (tDeserializeSQueryTableRsp(msg, msgSize, &rsp) < 0) { + if (tDeserializeSQueryTableRsp(pMsg->pData, msgSize, &rsp) < 0) { SCH_TASK_ELOG("tDeserializeSQueryTableRsp failed, msgSize:%d", msgSize); SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_MSG); } @@ -376,7 +375,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD (void)atomic_add_fetch_64(&pJob->resNumOfRows, rsp.affectedRows); - taosMemoryFreeClear(msg); + taosMemoryFreeClear(pMsg->pData); SCH_ERR_JRET(schProcessOnTaskSuccess(pJob, pTask)); @@ -384,7 +383,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD } case TDMT_SCH_EXPLAIN_RSP: { SCH_ERR_JRET(rspCode); - if (NULL == msg) { + if (NULL == pMsg->pData) { SCH_ERR_JRET(TSDB_CODE_QRY_INVALID_INPUT); } @@ -399,20 +398,20 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD } SExplainRsp rsp = {0}; - if (tDeserializeSExplainRsp(msg, msgSize, &rsp)) { + if (tDeserializeSExplainRsp(pMsg->pData, msgSize, &rsp)) { tFreeSExplainRsp(&rsp); SCH_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); } SCH_ERR_JRET(schProcessExplainRsp(pJob, pTask, &rsp)); - taosMemoryFreeClear(msg); + taosMemoryFreeClear(pMsg->pData); break; } case TDMT_SCH_FETCH_RSP: case TDMT_SCH_MERGE_FETCH_RSP: { - code = schProcessFetchRsp(pJob, pTask, msg, rspCode); - msg = NULL; + code = schProcessFetchRsp(pJob, pTask, pMsg->pData, rspCode); + pMsg->pData = NULL; SCH_ERR_JRET(code); break; } @@ -435,7 +434,7 @@ int32_t schProcessResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SD _return: - taosMemoryFreeClear(msg); + taosMemoryFreeClear(pMsg->pData); SCH_RET(schProcessOnTaskFailure(pJob, pTask, code)); } @@ -445,7 +444,6 @@ _return: int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SDataBuf *pMsg, int32_t rspCode) { int32_t code = 0; int32_t msgType = pMsg->msgType; - char *msg = pMsg->pData; bool dropExecNode = (msgType == TDMT_SCH_LINK_BROKEN || SCH_NETWORK_ERR(rspCode)); if (SCH_IS_QUERY_JOB(pJob)) { @@ -467,7 +465,7 @@ int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SDa _return: - taosMemoryFreeClear(msg); + taosMemoryFreeClear(pMsg->pData); SCH_RET(schProcessOnTaskFailure(pJob, pTask, code)); } diff --git a/source/libs/stream/src/streamExec.c b/source/libs/stream/src/streamExec.c index 5bb9c993de..bf4567a273 100644 --- a/source/libs/stream/src/streamExec.c +++ b/source/libs/stream/src/streamExec.c @@ -244,9 +244,10 @@ static void streamScanHistoryDataImpl(SStreamTask* pTask, SArray* pRes, int32_t* SSDataBlock* output = NULL; uint64_t ts = 0; code = qExecTask(exec, &output, &ts); - if (code != TSDB_CODE_TSC_QUERY_KILLED && code != TSDB_CODE_SUCCESS) { + if (code != TSDB_CODE_TSC_QUERY_KILLED && code != TSDB_CODE_SUCCESS) { // if out of memory occurs, quit stError("s-task:%s scan-history data error occurred code:%s, continue scan-history", pTask->id.idStr, tstrerror(code)); + qResetTaskCode(exec); continue; } diff --git a/source/libs/stream/src/streamMeta.c b/source/libs/stream/src/streamMeta.c index 81061cd06d..36d0086ac6 100644 --- a/source/libs/stream/src/streamMeta.c +++ b/source/libs/stream/src/streamMeta.c @@ -1224,7 +1224,7 @@ void streamMetaWUnLock(SStreamMeta* pMeta) { } int32_t streamMetaSendMsgBeforeCloseTasks(SStreamMeta* pMeta, SArray** pList) { - QRY_OPTR_CHECK(pList); + QRY_PARAM_CHECK(pList); int32_t code = 0; SArray* pTaskList = taosArrayDup(pMeta->pTaskList, NULL); diff --git a/source/libs/stream/src/streamUpdate.c b/source/libs/stream/src/streamUpdate.c index 3f7210d3c9..58ed50da65 100644 --- a/source/libs/stream/src/streamUpdate.c +++ b/source/libs/stream/src/streamUpdate.c @@ -231,7 +231,7 @@ _end: static int32_t getSBf(SUpdateInfo* pInfo, TSKEY ts, SScalableBf** ppSBf) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; - if (ts <= 0) { + if (ts < 0) { code = TSDB_CODE_FAILED; QUERY_CHECK_CODE(code, lino, _end); } diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c index a0236c38b8..8e709f8809 100644 --- a/source/libs/sync/src/syncMain.c +++ b/source/libs/sync/src/syncMain.c @@ -1421,12 +1421,12 @@ int32_t syncNodeRestore(SSyncNode* pSyncNode) { if (lastVer != -1 && endIndex != lastVer + 1) { code = TSDB_CODE_WAL_LOG_INCOMPLETE; - sError("vgId:%d, failed to restore sync node since %s. expected lastLogIndex:%" PRId64 ", lastVer:%" PRId64 "", - pSyncNode->vgId, terrstr(), endIndex - 1, lastVer); - TAOS_RETURN(code); + sWarn("vgId:%d, failed to restore sync node since %s. expected lastLogIndex:%" PRId64 ", lastVer:%" PRId64 "", + pSyncNode->vgId, terrstr(), endIndex - 1, lastVer); + // TAOS_RETURN(code); } - if (endIndex != lastVer + 1) return TSDB_CODE_SYN_INTERNAL_ERROR; + // if (endIndex != lastVer + 1) return TSDB_CODE_SYN_INTERNAL_ERROR; pSyncNode->commitIndex = TMAX(pSyncNode->commitIndex, commitIndex); sInfo("vgId:%d, restore sync until commitIndex:%" PRId64, pSyncNode->vgId, pSyncNode->commitIndex); diff --git a/source/util/src/tcompare.c b/source/util/src/tcompare.c index 11997d089c..afa048f0ac 100644 --- a/source/util/src/tcompare.c +++ b/source/util/src/tcompare.c @@ -1227,7 +1227,11 @@ static void checkRegexCache(void* param, void* tmrId) { if(sRegexCache.exit) { goto _exit; } - (void)taosTmrReset(checkRegexCache, REGEX_CACHE_CLEAR_TIME * 1000, param, sRegexCache.regexCacheTmr, &tmrId); + bool ret = taosTmrReset(checkRegexCache, REGEX_CACHE_CLEAR_TIME * 1000, param, sRegexCache.regexCacheTmr, &tmrId); + if (!ret) { + uError("failed to reset regex cache timer"); + goto _exit; + } if (taosHashGetSize(sRegexCache.regexHash) < MAX_REGEX_CACHE_SIZE) { goto _exit; } @@ -1238,7 +1242,10 @@ static void checkRegexCache(void* param, void* tmrId) { if (taosGetTimestampSec() - (*ppUsingRegex)->lastUsedTime > REGEX_CACHE_CLEAR_TIME) { size_t len = 0; char* key = (char*)taosHashGetKey(ppUsingRegex, &len); - (void)taosHashRemove(sRegexCache.regexHash, key, len); + if (TSDB_CODE_SUCCESS != taosHashRemove(sRegexCache.regexHash, key, len)) { + uError("failed to remove regex pattern %s from cache", key); + goto _exit; + } } ppUsingRegex = taosHashIterate(sRegexCache.regexHash, ppUsingRegex); } @@ -1285,7 +1292,10 @@ void DestroyRegexCache(){ #endif int32_t code = 0; uInfo("[regex cache] destory regex cache"); - (void)taosTmrStopA(&sRegexCache.timer); + bool ret = taosTmrStopA(&sRegexCache.timer); + if (!ret) { + uError("failed to stop regex cache timer"); + } taosWLockLatch(&sRegexCache.mutex); sRegexCache.exit = true; taosHashCleanup(sRegexCache.regexHash); diff --git a/tests/parallel_test/cases.task b/tests/parallel_test/cases.task index 0e2add50a6..6a57c7bc83 100644 --- a/tests/parallel_test/cases.task +++ b/tests/parallel_test/cases.task @@ -24,7 +24,7 @@ ,,y,army,./pytest.sh python3 ./test.py -f query/fill/fill_desc.py -N 3 -L 3 -D 2 ,,y,army,./pytest.sh python3 ./test.py -f query/fill/fill_null.py ,,y,army,./pytest.sh python3 ./test.py -f cluster/incSnapshot.py -N 3 -,,y,army,./pytest.sh python3 ./test.py -f cluster/clusterBasic.py -N 3 +#,,y,army,./pytest.sh python3 ./test.py -f cluster/clusterBasic.py -N 3 ,,y,army,./pytest.sh python3 ./test.py -f query/query_basic.py -N 3 ,,y,army,./pytest.sh python3 ./test.py -f query/accuracy/test_query_accuracy.py ,,y,army,./pytest.sh python3 ./test.py -f insert/insert_basic.py -N 3 @@ -351,7 +351,7 @@ ,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/splitVGroupWal.py -N 3 -n 3 ,,n,system-test,python3 ./test.py -f 0-others/timeRangeWise.py -N 3 ,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/delete_check.py -,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/test_hot_refresh_configurations.py +#,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/test_hot_refresh_configurations.py ,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/subscribe_stream_privilege.py ,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/empty_identifier.py @@ -1270,7 +1270,7 @@ ,,y,script,./test.sh -f tsim/snode/basic1.sim ,,y,script,./test.sh -f tsim/mnode/basic1.sim ,,y,script,./test.sh -f tsim/mnode/basic2.sim -,,y,script,./test.sh -f tsim/mnode/basic3.sim +#,,y,script,./test.sh -f tsim/mnode/basic3.sim ,,y,script,./test.sh -f tsim/mnode/basic4.sim ,,y,script,./test.sh -f tsim/mnode/basic5.sim ,,y,script,./test.sh -f tsim/show/basic.sim diff --git a/tests/script/api/makefile b/tests/script/api/makefile index d848dca194..d8a4e19218 100644 --- a/tests/script/api/makefile +++ b/tests/script/api/makefile @@ -7,11 +7,13 @@ LFLAGS = '-Wl,-rpath,/usr/local/taos/driver/' -ltaos -lpthread -lm -lrt CFLAGS = -O0 -g -Wno-deprecated -fPIC -Wno-unused-result -Wconversion \ -Wno-char-subscripts -D_REENTRANT -Wno-format -D_REENTRANT -DLINUX \ -Wno-unused-function -D_M_X64 -I/usr/local/taos/include -std=gnu99 -Wno-sign-conversion +#CFLAGS += -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment all: $(TARGET) exe: gcc $(CFLAGS) ./batchprepare.c -o $(ROOT)batchprepare $(LFLAGS) + gcc $(CFLAGS) ./stmt2-test.c -o $(ROOT)stmt2-test $(LFLAGS) gcc $(CFLAGS) ./stopquery.c -o $(ROOT)stopquery $(LFLAGS) gcc $(CFLAGS) ./dbTableRoute.c -o $(ROOT)dbTableRoute $(LFLAGS) gcc $(CFLAGS) ./insertSameTs.c -o $(ROOT)insertSameTs $(LFLAGS) @@ -20,9 +22,15 @@ exe: gcc $(CFLAGS) ./insert_stb.c -o $(ROOT)insert_stb $(LFLAGS) gcc $(CFLAGS) ./tmqViewTest.c -o $(ROOT)tmqViewTest $(LFLAGS) gcc $(CFLAGS) ./stmtQuery.c -o $(ROOT)stmtQuery $(LFLAGS) + gcc $(CFLAGS) ./stmt.c -o $(ROOT)stmt $(LFLAGS) + gcc $(CFLAGS) ./stmt2.c -o $(ROOT)stmt2 $(LFLAGS) + gcc $(CFLAGS) ./stmt2-example.c -o $(ROOT)stmt2-example $(LFLAGS) + gcc $(CFLAGS) ./stmt2-nohole.c -o $(ROOT)stmt2-nohole $(LFLAGS) + gcc $(CFLAGS) ./stmt-crash.c -o $(ROOT)stmt-crash $(LFLAGS) clean: rm $(ROOT)batchprepare + rm $(ROOT)stmt2-test rm $(ROOT)stopquery rm $(ROOT)dbTableRoute rm $(ROOT)insertSameTs @@ -31,3 +39,8 @@ clean: rm $(ROOT)insert_stb rm $(ROOT)tmqViewTest rm $(ROOT)stmtQuery + rm $(ROOT)stmt + rm $(ROOT)stmt2 + rm $(ROOT)stmt2-example + rm $(ROOT)stmt2-nohole + rm $(ROOT)stmt-crash diff --git a/tests/script/api/stmt-crash.c b/tests/script/api/stmt-crash.c new file mode 100644 index 0000000000..310e7c4910 --- /dev/null +++ b/tests/script/api/stmt-crash.c @@ -0,0 +1,289 @@ +// TAOS standard API example. The same syntax as MySQL, but only a subet +// to compile: gcc -o prepare prepare.c -ltaos + +#include +#include +#include +#include "taos.h" + +void taosMsleep(int mseconds); + +int main(int argc, char *argv[]) { + TAOS *taos; + TAOS_RES *result; + int code; + TAOS_STMT *stmt; + + // connect to server + if (argc < 2) { + printf("please input server ip \n"); + return 0; + } + + // taos = taos_connect(argv[1], "root", "Taosdata.1234", NULL, 0); + taos = taos_connect(argv[1], "root", "taosdata", NULL, 0); + if (taos == NULL) { + printf("failed to connect to db, reason:%s\n", taos_errstr(taos)); + exit(1); + } + + result = taos_query(taos, "drop database demo"); + taos_free_result(result); + + result = taos_query(taos, "create database demo"); + code = taos_errno(result); + if (code != 0) { + printf("failed to create database, reason:%s\n", taos_errstr(result)); + taos_free_result(result); + exit(1); + } + taos_free_result(result); + + result = taos_query(taos, "use demo"); + taos_free_result(result); + + // create table + const char *sql = + "create stable s1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin " + "binary(40), blob nchar(10), varbin varbinary(16)) tags(groupId INT);"; + result = taos_query(taos, sql); + code = taos_errno(result); + if (code != 0) { + printf("failed to create table, reason:%s\n", taos_errstr(result)); + taos_free_result(result); + exit(1); + } + taos_free_result(result); + + // sleep for one second to make sure table is created on data node + // taosMsleep(1000); + + // insert 10 records + struct { + int64_t ts; + int8_t b; + int8_t v1; + int16_t v2; + int32_t v4; + int64_t v8; + float f4; + double f8; + char bin[40]; + char blob[80]; + int8_t varbin[16]; + } v = {0}; + + int32_t boolLen = sizeof(int8_t); + int32_t sintLen = sizeof(int16_t); + int32_t intLen = sizeof(int32_t); + int32_t bintLen = sizeof(int64_t); + int32_t floatLen = sizeof(float); + int32_t doubleLen = sizeof(double); + int32_t binLen = sizeof(v.bin); + int32_t ncharLen = 30; + + stmt = taos_stmt_init(taos); + TAOS_MULTI_BIND params[11]; + params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP; + params[0].buffer_length = sizeof(v.ts); + params[0].buffer = &v.ts; + params[0].length = &bintLen; + params[0].is_null = NULL; + params[0].num = 1; + + params[1].buffer_type = TSDB_DATA_TYPE_BOOL; + params[1].buffer_length = sizeof(v.b); + params[1].buffer = &v.b; + params[1].length = &boolLen; + params[1].is_null = NULL; + params[1].num = 1; + + params[2].buffer_type = TSDB_DATA_TYPE_TINYINT; + params[2].buffer_length = sizeof(v.v1); + params[2].buffer = &v.v1; + params[2].length = &boolLen; + params[2].is_null = NULL; + params[2].num = 1; + + params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT; + params[3].buffer_length = sizeof(v.v2); + params[3].buffer = &v.v2; + params[3].length = &sintLen; + params[3].is_null = NULL; + params[3].num = 1; + + params[4].buffer_type = TSDB_DATA_TYPE_INT; + params[4].buffer_length = sizeof(v.v4); + params[4].buffer = &v.v4; + params[4].length = &intLen; + params[4].is_null = NULL; + params[4].num = 1; + + params[5].buffer_type = TSDB_DATA_TYPE_BIGINT; + params[5].buffer_length = sizeof(v.v8); + params[5].buffer = &v.v8; + params[5].length = &bintLen; + params[5].is_null = NULL; + params[5].num = 1; + + params[6].buffer_type = TSDB_DATA_TYPE_FLOAT; + params[6].buffer_length = sizeof(v.f4); + params[6].buffer = &v.f4; + params[6].length = &floatLen; + params[6].is_null = NULL; + params[6].num = 1; + + params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE; + params[7].buffer_length = sizeof(v.f8); + params[7].buffer = &v.f8; + params[7].length = &doubleLen; + params[7].is_null = NULL; + params[7].num = 1; + + params[8].buffer_type = TSDB_DATA_TYPE_BINARY; + params[8].buffer_length = sizeof(v.bin); + params[8].buffer = v.bin; + params[8].length = &binLen; + params[8].is_null = NULL; + params[8].num = 1; + + strcpy(v.blob, "一二三四五六七八九十"); + params[9].buffer_type = TSDB_DATA_TYPE_NCHAR; + params[9].buffer_length = sizeof(v.blob); + params[9].buffer = v.blob; + params[9].length = &ncharLen; + params[9].is_null = NULL; + params[9].num = 1; + + int8_t tmp[16] = {'a', 0, 1, 13, '1'}; + int32_t vbinLen = 5; + memcpy(v.varbin, tmp, sizeof(v.varbin)); + params[10].buffer_type = TSDB_DATA_TYPE_VARBINARY; + params[10].buffer_length = sizeof(v.varbin); + params[10].buffer = v.varbin; + params[10].length = &vbinLen; + params[10].is_null = NULL; + params[10].num = 1; + + TAOS_MULTI_BIND tags[1]; + + int32_t id1 = 0; + + tags[0].buffer_type = TSDB_DATA_TYPE_INT; + tags[0].buffer_length = sizeof(int); + tags[0].buffer = &id1; + tags[0].length = NULL; + tags[0].is_null = NULL; + tags[0].num = 1; + + char is_null = 1; + + sql = "insert into ? using s1 tags(?) values(?,?,?,?,?,?,?,?,?,?,?)"; + code = taos_stmt_prepare(stmt, sql, 0); + if (code != 0) { + printf("failed to execute taos_stmt_prepare. code:0x%x\n", code); + } + + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt_close(stmt); + exit(EXIT_FAILURE); + } + code = taos_stmt_set_tbname_tags(stmt, "m1", tags); + v.ts = 1591060628000; + v.b = (int8_t)0 % 2; + v.v1 = (int8_t)0; + v.v2 = (int16_t)(0 * 2); + v.v4 = (int32_t)(0 * 4); + v.v8 = (int64_t)(0 * 8); + v.f4 = (float)(0 * 40); + v.f8 = (double)(0 * 80); + for (int j = 0; j < sizeof(v.bin); ++j) { + v.bin[j] = (char)(0 + '0'); + } + taos_stmt_bind_param(stmt, params); + taos_stmt_add_batch(stmt); + + code = taos_stmt_set_tbname_tags(stmt, "m2", tags); + v.ts = 1591060628000 + 1; + v.b = (int8_t)1 % 2; + v.v1 = (int8_t)1; + v.v2 = (int16_t)(1 * 2); + v.v4 = (int32_t)(1 * 4); + v.v8 = (int64_t)(1 * 8); + v.f4 = (float)(1 * 40); + v.f8 = (double)(1 * 80); + for (int j = 0; j < sizeof(v.bin); ++j) { + v.bin[j] = (char)(1 + '0'); + } + taos_stmt_bind_param(stmt, params); + taos_stmt_add_batch(stmt); + /* + for (int i = 0; i < 10; ++i) { + if(i % 2 != 0) { + code = taos_stmt_set_tbname(stmt, "m1"); + } else { + code = taos_stmt_set_tbname(stmt, "m2"); + } + v.ts += 1; + for (int j = 1; j < 11; ++j) { + params[j].is_null = ((i == j) ? &is_null : 0); + } + v.b = (int8_t)i % 2; + v.v1 = (int8_t)i; + v.v2 = (int16_t)(i * 2); + v.v4 = (int32_t)(i * 4); + v.v8 = (int64_t)(i * 8); + v.f4 = (float)(i * 40); + v.f8 = (double)(i * 80); + for (int j = 0; j < sizeof(v.bin); ++j) { + v.bin[j] = (char)(i + '0'); + } + + taos_stmt_bind_param(stmt, params); + taos_stmt_add_batch(stmt); + } + */ + // printf("taos multi bind num:%d\n", params[1].num); + if (taos_stmt_execute(stmt) != 0) { + printf("failed to execute insert statement.\n"); + exit(1); + } + taos_stmt_close(stmt); + + // query the records + stmt = taos_stmt_init(taos); + taos_stmt_prepare(stmt, "SELECT * FROM m1 WHERE v1 > ? AND v2 < ?", 0); + v.v1 = 5; + v.v2 = 15; + taos_stmt_bind_param(stmt, params + 2); + if (taos_stmt_execute(stmt) != 0) { + printf("failed to execute select statement.\n"); + exit(1); + } + + result = taos_stmt_use_result(stmt); + + TAOS_ROW row; + int rows = 0; + int num_fields = taos_num_fields(result); + TAOS_FIELD *fields = taos_fetch_fields(result); + + // fetch the records row by row + while ((row = taos_fetch_row(result))) { + char temp[256] = {0}; + rows++; + taos_print_row(temp, row, fields, num_fields); + printf("%s\n", temp); + } + if (rows == 2) { + printf("two rows are fetched as expectation\n"); + } else { + printf("expect two rows, but %d rows are fetched\n", rows); + } + + // taos_free_result(result); + taos_stmt_close(stmt); + + return 0; +} diff --git a/tests/script/api/stmt2-example.c b/tests/script/api/stmt2-example.c new file mode 100644 index 0000000000..803e54c156 --- /dev/null +++ b/tests/script/api/stmt2-example.c @@ -0,0 +1,87 @@ +#include +#include +#include +#include "taos.h" + +void do_query(TAOS* taos, const char* sql) { + TAOS_RES* result = taos_query(taos, sql); + int code = taos_errno(result); + if (code) { + printf("failed to query: %s, reason:%s\n", sql, taos_errstr(result)); + taos_free_result(result); + return; + } + taos_free_result(result); +} + +void do_stmt(TAOS* taos) { + do_query(taos, "drop database if exists db"); + do_query(taos, "create database db"); + do_query(taos, "create table db.stb (ts timestamp, b binary(10)) tags(t1 int, t2 binary(10))"); + + struct { + int64_t ts[2]; + char b[16]; + } v; + + int32_t b_len[2], t64_len[2]; + char is_null[2] = {0}; + char is_null2[2] = {0, 2}; + // TAOS_STMT2_OPTION option = {0}; + // TAOS_STMT2_OPTION option = {0, true, true, stmtAsyncQueryCb, NULL}; + TAOS_STMT2_OPTION option = {0, true, false, NULL, NULL}; + + char* tbs[2] = {"tb", "tb2"}; + int t1_val[2] = {0, 1}; + int t2_len[2] = {3, 3}; + TAOS_STMT2_BIND tags[2][2] = {{{0, &t1_val[0], NULL, NULL, 0}, {0, "a1", &t2_len[0], NULL, 0}}, + {{0, &t1_val[1], NULL, NULL, 0}, {0, "a2", &t2_len[1], NULL, 0}}}; + TAOS_STMT2_BIND params[2][2] = { + {{TSDB_DATA_TYPE_TIMESTAMP, v.ts, NULL, is_null, 2}, {TSDB_DATA_TYPE_BINARY, v.b, b_len, is_null2, 2}}, + {{TSDB_DATA_TYPE_TIMESTAMP, v.ts, NULL, is_null, 2}, {TSDB_DATA_TYPE_BINARY, v.b, b_len, is_null2, 2}}}; + TAOS_STMT2_BIND* tagv[2] = {&tags[0][0], &tags[1][0]}; + TAOS_STMT2_BIND* paramv[2] = {¶ms[0][0], ¶ms[1][0]}; + TAOS_STMT2_BINDV bindv = {2, &tbs[0], &tagv[0], ¶mv[0]}; + + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + const char* sql = "insert into db.? using db.stb tags(?, ?) values(?,?)"; + int code = taos_stmt2_prepare(stmt, sql, 0); + if (code != 0) { + printf("failed to execute taos_stmt2_prepare. error:%s\n", taos_stmt2_error(stmt)); + taos_stmt2_close(stmt); + return; + } + + int64_t ts = 1591060628000; + for (int i = 0; i < 2; ++i) { + // v.ts[i] = ts++; + v.ts[i] = ts; + // t64_len[i] = sizeof(int64_t); + } + strcpy(v.b, "abcdefg"); + b_len[0] = (int)strlen(v.b); + strcpy(v.b + b_len[0], "xyz"); + b_len[1] = 3; + + taos_stmt2_bind_param(stmt, &bindv, -1); + + if (taos_stmt2_exec(stmt, NULL)) { + printf("failed to execute insert statement.error:%s\n", taos_stmt2_error(stmt)); + taos_stmt2_close(stmt); + return; + } + + taos_stmt2_close(stmt); +} + +int main() { + TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); + if (!taos) { + printf("failed to connect to db, reason:%s\n", taos_errstr(taos)); + exit(1); + } + + do_stmt(taos); + taos_close(taos); + taos_cleanup(); +} diff --git a/tests/script/api/stmt2-nohole.c b/tests/script/api/stmt2-nohole.c new file mode 100644 index 0000000000..b29dd3e826 --- /dev/null +++ b/tests/script/api/stmt2-nohole.c @@ -0,0 +1,369 @@ +// sample code to verify all TDengine API +// to compile: gcc -o apitest apitest.c -ltaos + +#include +#include +#include +#include +#include +#include "taos.h" +static int64_t count = 10000; + +int64_t genReqid() { + count += 100; + return count; +} + +sem_t sem; + +void stmtAsyncQueryCb(void* param, TAOS_RES* pRes, int code) { + int affected_rows = taos_affected_rows(pRes); + printf("\033[31maffected rows:%d\033[0m\n", affected_rows); + (void)sem_post(&sem); + return; + /* + SSP_CB_PARAM* qParam = (SSP_CB_PARAM*)param; + if (code == 0 && pRes) { + if (qParam->fetch) { + taos_fetch_rows_a(pRes, sqAsyncFetchCb, param); + } else { + if (qParam->free) { + taos_free_result(pRes); + } + *qParam->end = 1; + } + } else { + sqError("select", taos_errstr(pRes)); + *qParam->end = 1; + taos_free_result(pRes); + } + */ +} + +void veriry_stmt(TAOS* taos) { + TAOS_RES* result = taos_query(taos, "drop database if exists test;"); + taos_free_result(result); + usleep(100000); + result = taos_query(taos, "create database test;"); + + int code = taos_errno(result); + if (code != 0) { + printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result)); + taos_free_result(result); + return; + } + taos_free_result(result); + + usleep(100000); + taos_select_db(taos, "test"); + + // create table + /* + const char* sql = + "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin " + "binary(40), blob nchar(10))"; + */ + const char* sql = + "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, blob2 " + "nchar(10), blob nchar(10))"; + result = taos_query(taos, sql); + code = taos_errno(result); + if (code != 0) { + printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result)); + taos_free_result(result); + return; + } + taos_free_result(result); + + sql = + "create table m2 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, blob2 " + "nchar(10), blob nchar(10))"; + result = taos_query(taos, sql); + code = taos_errno(result); + if (code != 0) { + printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result)); + taos_free_result(result); + return; + } + taos_free_result(result); + + // insert 10 records + struct { + int64_t ts[10]; + int8_t b[10]; + int8_t v1[10]; + int16_t v2[10]; + int32_t v4[10]; + int64_t v8[10]; + float f4[10]; + double f8[10]; + char bin[10][40]; + // char blob[10][80]; + // char blob2[10][80]; + char blob[1024]; + char blob2[1024]; + } v; + + int32_t* t8_len = malloc(sizeof(int32_t) * 10); + int32_t* t16_len = malloc(sizeof(int32_t) * 10); + int32_t* t32_len = malloc(sizeof(int32_t) * 10); + int32_t* t64_len = malloc(sizeof(int32_t) * 10); + int32_t* float_len = malloc(sizeof(int32_t) * 10); + int32_t* double_len = malloc(sizeof(int32_t) * 10); + int32_t* bin_len = malloc(sizeof(int32_t) * 10); + int32_t* blob_len = malloc(sizeof(int32_t) * 10); + int32_t* blob_len2 = malloc(sizeof(int32_t) * 10); + +#include "time.h" + clock_t start, end; + TAOS_STMT2_OPTION option = {0, true, false, stmtAsyncQueryCb, NULL}; + + start = clock(); + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + end = clock(); + printf("init time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + // TAOS_MULTI_BIND params[10]; + TAOS_STMT2_BIND params[10]; + char is_null2[10] = {0}; + char is_null[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 2}; + + params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP; + // params[0].buffer_length = sizeof(v.ts[0]); + params[0].buffer = v.ts; + params[0].length = NULL; // t64_len; + params[0].is_null = is_null2; + params[0].num = 10; + + params[1].buffer_type = TSDB_DATA_TYPE_BOOL; + // params[1].buffer_length = sizeof(v.b[0]); + params[1].buffer = v.b; + params[1].length = NULL; // t8_len; + params[1].is_null = is_null; + params[1].num = 10; + + params[2].buffer_type = TSDB_DATA_TYPE_TINYINT; + // params[2].buffer_length = sizeof(v.v1[0]); + params[2].buffer = v.v1; + params[2].length = NULL; // t8_len; + params[2].is_null = is_null; + params[2].num = 10; + + params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT; + // params[3].buffer_length = sizeof(v.v2[0]); + params[3].buffer = v.v2; + params[3].length = NULL; // t16_len; + params[3].is_null = is_null; + params[3].num = 10; + + params[4].buffer_type = TSDB_DATA_TYPE_INT; + // params[4].buffer_length = sizeof(v.v4[0]); + params[4].buffer = v.v4; + params[4].length = NULL; // t32_len; + params[4].is_null = is_null; + params[4].num = 10; + + params[5].buffer_type = TSDB_DATA_TYPE_BIGINT; + // params[5].buffer_length = sizeof(v.v8[0]); + params[5].buffer = v.v8; + params[5].length = NULL; // t64_len; + params[5].is_null = is_null; + params[5].num = 10; + + params[6].buffer_type = TSDB_DATA_TYPE_FLOAT; + // params[6].buffer_length = sizeof(v.f4[0]); + params[6].buffer = v.f4; + params[6].length = NULL; // float_len; + params[6].is_null = is_null; + params[6].num = 10; + + params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE; + // params[7].buffer_length = sizeof(v.f8[0]); + params[7].buffer = v.f8; + params[7].length = NULL; // double_len; + params[7].is_null = is_null; + params[7].num = 10; + /* + params[8].buffer_type = TSDB_DATA_TYPE_BINARY; + //params[8].buffer_length = sizeof(v.bin[0]); + params[8].buffer = v.bin; + params[8].length = bin_len; + params[8].is_null = is_null; + params[8].num = 10; + */ + params[8].buffer_type = TSDB_DATA_TYPE_NCHAR; + // params[8].buffer_length = sizeof(v.blob2[0]); + params[8].buffer = v.blob2; + params[8].length = blob_len2; + params[8].is_null = is_null; + params[8].num = 10; + + params[9].buffer_type = TSDB_DATA_TYPE_NCHAR; + // params[9].buffer_length = sizeof(v.blob[0]); + params[9].buffer = v.blob; + params[9].length = blob_len; + params[9].is_null = is_null; + params[9].num = 10; + + sql = "insert into ? (ts, b, v1, v2, v4, v8, f4, f8, blob2, blob) values(?,?,?,?,?,?,?,?,?,?)"; + start = clock(); + code = taos_stmt2_prepare(stmt, sql, 0); + end = clock(); + printf("prepare time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt_close(stmt); + return; + } + /* + code = taos_stmt_set_tbname(stmt, "m1"); + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt_close(stmt); + return; + } + */ + + int64_t ts = 1591060628000; + char* blob2_buffer = v.blob2; + char* blob_buffer = v.blob; + const char* blob2_str[] = { + "一二三四五六七十九八", "一二三四五六七十九", "一二三四五六七十", "一二三四五六七", "一二三四五六", + "一二三四五", "一二三四", "一二三", "一二", "一", + }; + const char* blob_str[] = { + "一", "一二", "一二三", "一二三四", "一二三四五", + "一二三四五六", "一二三四五六七", "一二三四五六七八", "一二三四五六七八九", "一二三四五六七八九十", + }; + for (int i = 0; i < 10; ++i) { + // is_null[i] = 0; + + v.ts[i] = ts++; + // v.b[i] = (int8_t)i % 2; + v.b[i] = (int8_t)i % 10; + v.v1[i] = (int8_t)i; + v.v2[i] = (int16_t)(i * 2); + v.v4[i] = (int32_t)(i * 4); + v.v8[i] = (int64_t)(i * 8); + v.f4[i] = (float)(i * 40); + v.f8[i] = (double)(i * 80); + for (int j = 0; j < sizeof(v.bin[0]); ++j) { + v.bin[i][j] = (char)(i + '0'); + } + // strcpy(v.blob2[i], "一二三四五六七十九八"); + // strcpy(v.blob[i], "一二三四五六七八九十"); + // const char* blob2_str = "一二三四五六七十九八"; + // const char* blob_str = "一二三四五六七八九十"; + strcpy(blob2_buffer, blob2_str[i]); + strcpy(blob_buffer, blob_str[i]); + + t8_len[i] = sizeof(int8_t); + t16_len[i] = sizeof(int16_t); + t32_len[i] = sizeof(int32_t); + t64_len[i] = sizeof(int64_t); + float_len[i] = sizeof(float); + double_len[i] = sizeof(double); + bin_len[i] = sizeof(v.bin[0]); + // blob_len[i] = (int32_t)strlen(v.blob[i]); + // blob_len2[i] = (int32_t)strlen(v.blob2[i]); + blob_len[i] = (int32_t)strlen(blob_str[i]); + blob_len2[i] = (int32_t)strlen(blob2_str[i]); + blob_buffer += blob_len[i]; + blob2_buffer += blob_len2[i]; + } + int run_time = 0; + char* tbname = "m2"; + TAOS_STMT2_BIND* bind_cols[1] = {¶ms[0]}; + TAOS_STMT2_BINDV bindv = {1, &tbname, NULL, &bind_cols[0]}; +_bind_again: + start = clock(); + // taos_stmt2_bind_param(stmt, "m1", NULL, params, -1); + taos_stmt2_bind_param(stmt, &bindv, -1); + end = clock(); + printf("bind time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + // taos_stmt_bind_param_batch(stmt, params); + // taos_stmt_add_batch(stmt); + /* + int param_count = -1; + code = taos_stmt2_param_count(stmt, ¶m_count); + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_param_count. error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt_close(stmt); + return; + } + printf("param_count: %d\n", param_count); + */ + TAOS_FIELD_E* fields = NULL; + int field_count = -1; + start = clock(); + code = taos_stmt2_get_fields(stmt, TAOS_FIELD_TBNAME, &field_count, NULL); + end = clock(); + printf("get fields time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_param_count. error:%s\033[0m\n", taos_stmt2_error(stmt)); + taos_stmt2_close(stmt); + return; + } + printf("col field_count: %d\n", field_count); + start = clock(); + taos_stmt2_free_fields(stmt, fields); + end = clock(); + printf("free time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + /* + code = taos_stmt2_get_fields(stmt, TAOS_FIELD_TAG, &field_count, &fields); + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_param_count. error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt_close(stmt); + return; + } + printf("tag field_count: %d\n", field_count); + taos_stmt2_free_fields(stmt, fields); + */ + // if (taos_stmt_execute(stmt) != 0) { + (void)sem_init(&sem, 0, 0); + start = clock(); + // if (taos_stmt2_exec(stmt, NULL, stmtAsyncQueryCb, NULL) != 0) { + if (taos_stmt2_exec(stmt, NULL) != 0) { + printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt2_close(stmt); + return; + } + end = clock(); + printf("exec time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + + sem_wait(&sem); + (void)sem_destroy(&sem); + if (++run_time < 2) { + goto _bind_again; + } + taos_stmt2_close(stmt); + + free(t8_len); + free(t16_len); + free(t32_len); + free(t64_len); + free(float_len); + free(double_len); + free(bin_len); + free(blob_len); + free(blob_len2); +} + +int main(int argc, char* argv[]) { + const char* host = "127.0.0.1"; + const char* user = "root"; + const char* passwd = "taosdata"; + + taos_options(TSDB_OPTION_TIMEZONE, "GMT-8"); + TAOS* taos = taos_connect(host, user, passwd, "", 0); + if (taos == NULL) { + printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(taos)); + exit(1); + } + + printf("********* verify stmt query **********\n"); + veriry_stmt(taos); + + printf("done\n"); + taos_close(taos); + taos_cleanup(); +} diff --git a/tests/script/api/stmt2-test.c b/tests/script/api/stmt2-test.c new file mode 100644 index 0000000000..2bbceec92e --- /dev/null +++ b/tests/script/api/stmt2-test.c @@ -0,0 +1,3201 @@ +// TAOS standard API example. The same syntax as MySQL, but only a subet +// to compile: gcc -o prepare prepare.c -ltaos + +#include +#include +#include +#include +#include +#include +#include "../../../include/client/taos.h" + +#define FUNCTION_TEST_IDX 1 +#define TIME_PRECISION_MILLI 0 +#define TIME_PRECISION_MICRO 1 +#define TIME_PRECISION_NANO 2 + +int32_t shortColList[] = {TSDB_DATA_TYPE_TIMESTAMP, TSDB_DATA_TYPE_INT}; +int32_t fullColList[] = {TSDB_DATA_TYPE_TIMESTAMP, TSDB_DATA_TYPE_BOOL, TSDB_DATA_TYPE_TINYINT, + TSDB_DATA_TYPE_UTINYINT, TSDB_DATA_TYPE_SMALLINT, TSDB_DATA_TYPE_USMALLINT, + TSDB_DATA_TYPE_INT, TSDB_DATA_TYPE_UINT, TSDB_DATA_TYPE_BIGINT, + TSDB_DATA_TYPE_UBIGINT, TSDB_DATA_TYPE_FLOAT, TSDB_DATA_TYPE_DOUBLE, + TSDB_DATA_TYPE_BINARY, TSDB_DATA_TYPE_NCHAR}; +int32_t bindColTypeList[] = {TSDB_DATA_TYPE_TIMESTAMP, TSDB_DATA_TYPE_NCHAR}; +int32_t optrIdxList[] = {5, 11}; + +typedef struct { + char *oper; + int32_t paramNum; + bool enclose; +} OperInfo; + +typedef struct { + char *funcName; + int32_t paramNum; +} FuncInfo; + +typedef enum { + BP_BIND_TAG = 1, + BP_BIND_COL, +} BP_BIND_TYPE; + +#define BP_BIND_TYPE_STR(t) (((t) == BP_BIND_COL) ? "column" : "tag") + +OperInfo operInfo[] = { + {">", 2, false}, {">=", 2, false}, {"<", 2, false}, {"<=", 2, false}, + {"=", 2, false}, {"<>", 2, false}, {"in", 2, true}, {"not in", 2, true}, + + {"like", 2, false}, {"not like", 2, false}, {"match", 2, false}, {"nmatch", 2, false}, +}; + +int32_t operatorList[] = {0, 1, 2, 3, 4, 5, 6, 7}; +int32_t varoperatorList[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; + +FuncInfo funcInfo[] = { + {"count", 1}, + {"sum", 1}, + {"min", 1}, +}; + +#define BP_STARTUP_TS 1591060628000 + +char *bpStbPrefix = "st"; +char *bpTbPrefix = "t"; +int32_t bpDefaultStbId = 1; +int64_t bpTs; + +// char *operatorList[] = {">", ">=", "<", "<=", "=", "<>", "in", "not in"}; +// char *varoperatorList[] = {">", ">=", "<", "<=", "=", "<>", "in", "not in", "like", "not like", "match", "nmatch"}; + +#define tListLen(x) (sizeof(x) / sizeof((x)[0])) +#define IS_SIGNED_NUMERIC_TYPE(_t) ((_t) >= TSDB_DATA_TYPE_TINYINT && (_t) <= TSDB_DATA_TYPE_BIGINT) +#define IS_UNSIGNED_NUMERIC_TYPE(_t) ((_t) >= TSDB_DATA_TYPE_UTINYINT && (_t) <= TSDB_DATA_TYPE_UBIGINT) +#define IS_FLOAT_TYPE(_t) ((_t) == TSDB_DATA_TYPE_FLOAT || (_t) == TSDB_DATA_TYPE_DOUBLE) +#define IS_NUMERIC_TYPE(_t) ((IS_SIGNED_NUMERIC_TYPE(_t)) || (IS_UNSIGNED_NUMERIC_TYPE(_t)) || (IS_FLOAT_TYPE(_t))) + +typedef struct { + bool singleTbInsert; + int32_t singleTbIdx; + + int64_t *tsData; + bool *boolData; + int8_t *tinyData; + uint8_t *utinyData; + int16_t *smallData; + uint16_t *usmallData; + int32_t *intData; + uint32_t *uintData; + int64_t *bigData; + uint64_t *ubigData; + float *floatData; + double *doubleData; + char *binaryData; + char *isNull; + int32_t *binaryLen; + TAOS_STMT2_BIND *pBind; + TAOS_STMT2_BIND *pTags; + char *sql; + int32_t *colTypes; + int32_t colNum; +} BindData; + +int32_t gVarCharSize = 10; +int32_t gVarCharLen = 5; + +int32_t gExecLoopTimes = 1; // no change +int32_t gFullColNum = tListLen(fullColList); + +int insertMBSETest1(TAOS_STMT2 *stmt, TAOS *taos); +int insertMBSETest2(TAOS_STMT2 *stmt, TAOS *taos); +int insertMBMETest1(TAOS_STMT2 *stmt, TAOS *taos); +int insertMBMETest2(TAOS_STMT2 *stmt, TAOS *taos); +int insertMBMETest3(TAOS_STMT2 *stmt, TAOS *taos); +int insertMBMETest4(TAOS_STMT2 *stmt, TAOS *taos); +int insertMPMETest1(TAOS_STMT2 *stmt, TAOS *taos); +int insertAUTOTest1(TAOS_STMT2 *stmt, TAOS *taos); +int insertAUTOTest2(TAOS_STMT2 *stmt, TAOS *taos); +int insertAUTOTest3(TAOS_STMT2 *stmt, TAOS *taos); +int queryColumnTest(TAOS_STMT2 *stmt, TAOS *taos); +int queryMiscTest(TAOS_STMT2 *stmt, TAOS *taos); +int insertNonExistsTb(TAOS_STMT2 *stmt, TAOS *taos); +int insertVarLenErr(TAOS_STMT2 *stmt, TAOS *taos); +int insertStbTest(TAOS_STMT2 *stmt, TAOS *taos); + +enum { + TTYPE_INSERT = 1, + TTYPE_INSERT_NG, + TTYPE_QUERY, +}; + +typedef struct { + char caseDesc[128]; + int32_t colNum; + int32_t *colList; // full table column list + int32_t testType; + int32_t autoCreateTbl; + bool duplicateValue; + bool fullCol; + int32_t (*runFn)(TAOS_STMT2 *, TAOS *); + int32_t tblNum; + int32_t rowNum; + int32_t bindRowNum; + int32_t bindColNum; // equal colNum in full column case + int32_t bindTagNum; // equal colNum in full column case + int32_t bindNullNum; + int32_t runTimes; + int32_t preCaseIdx; + bool stbInsert; +} CaseCfg; + +CaseCfg gCase[] = { + {"insert:MBSE0-FULL", tListLen(shortColList), shortColList, TTYPE_INSERT, 0, false, true, insertMBSETest1, 1, 10, + 10, 0, 0, 0, 1, -1, false}, + {"insert:MBSE0-FULL", tListLen(shortColList), shortColList, TTYPE_INSERT, 0, false, true, insertMBSETest1, 10, 100, + 10, 0, 0, 0, 1, -1, false}, + + {"insert:MBSE1-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBSETest1, 10, 10, 2, + 0, 0, 0, 1, -1, false}, + {"insert:MBSE1-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBSETest1, 10, 10, 2, + 12, 0, 0, 1, -1, false}, + {"insert:MBSE1-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBSETest1, 10, 10, 2, + 2, 0, 0, 1, -1, false}, + + {"insert:MBSE2-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBSETest2, 10, 10, 2, + 0, 0, 0, 1, -1, false}, + {"insert:MBSE2-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBSETest2, 10, 10, 2, + 12, 0, 0, 1, -1, false}, + {"insert:MBSE2-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBSETest2, 10, 10, 2, + 2, 0, 0, 1, -1, false}, + + {"insert:MBME1-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBMETest1, 10, 10, 2, + 0, 0, 0, 1, -1, false}, + {"insert:MBME1-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest1, 10, 10, 2, + 12, 0, 0, 1, -1, false}, + {"insert:MBME1-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest1, 10, 10, 2, + 2, 0, 0, 1, -1, false}, + + // 11 + {"insert:MBME2-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBMETest2, 10, 10, 2, + 0, 0, 0, 1, -1, false}, + {"insert:MBME2-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest2, 10, 10, 2, + 12, 0, 0, 1, -1, false}, + {"insert:MBME2-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest2, 10, 10, 2, + 2, 0, 0, 1, -1, false}, + + {"insert:MBME3-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBMETest3, 10, 10, 2, + 0, 0, 0, 1, -1, false}, + {"insert:MBME3-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest3, 10, 10, 2, + 12, 0, 0, 1, -1, false}, + {"insert:MBME3-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest3, 10, 10, 2, + 2, 0, 0, 1, -1, false}, + + {"insert:MBME4-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMBMETest4, 10, 10, 2, + 0, 0, 0, 1, -1, false}, + {"insert:MBME4-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest4, 10, 10, 2, + 12, 0, 0, 1, -1, false}, + {"insert:MBME4-C002", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMBMETest4, 10, 10, 2, + 2, 0, 0, 1, -1, false}, + + {"insert:MPME1-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertMPMETest1, 10, 10, 2, + 0, 0, 0, 1, -1, false}, + {"insert:MPME1-C012", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, false, insertMPMETest1, 10, 10, 2, + 12, 0, 0, 1, -1, false}, + + {"insert:STBI-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, false, true, insertStbTest, 10, 10, 2, 0, + 0, 0, 1, -1, true}, + + // 23 + {"insert:AUTO1-FULL", tListLen(fullColList), fullColList, TTYPE_INSERT, 1, false, true, insertAUTOTest1, 10, 10, 2, + 0, 0, 0, 1, -1, false}, + {"insert:AUTO2-TBEXISTS", tListLen(fullColList), fullColList, TTYPE_INSERT, 3, false, true, insertAUTOTest2, 10, 10, + 2, 0, 0, 0, 1, -1, false}, + // {"insert:AUTO3-NTB", tListLen(fullColList), fullColList, TTYPE_INSERT, 0, true, true, insertAUTOTest3, 10, 10, + // 2, 0, 0, 0, 1, -1, false}, + + {"query:SUBT-COLUMN", tListLen(fullColList), fullColList, TTYPE_QUERY, 0, false, false, queryColumnTest, 10, 10, 1, + 3, 0, 0, 1, 2, false}, + {"query:SUBT-MISC", tListLen(fullColList), fullColList, TTYPE_QUERY, 0, false, false, queryMiscTest, 10, 10, 1, 3, + 0, 0, 1, 2, false}, + + {"query:NG-TBNEXISTS", tListLen(fullColList), fullColList, TTYPE_INSERT_NG, 0, false, false, insertNonExistsTb, 10, + 10, 1, 3, 0, 0, 1, -1, false}, + {"query:NG-VARLENERR", tListLen(fullColList), fullColList, TTYPE_INSERT_NG, 0, false, true, insertVarLenErr, 10, 10, + 1, 3, 0, 0, 1, -1, false}, + + // {"query:SUBT-COLUMN", tListLen(fullColList), fullColList, TTYPE_QUERY, 0, false, false, queryColumnTest, 1, 10, + // 1, 1, 0, 0, 1, 2, false}, + // {"query:SUBT-MISC", tListLen(fullColList), fullColList, TTYPE_QUERY, 0, false, false, queryMiscTest, 2, 10, 1, + // 1, 0, 0, 1, 2, false}, + +}; + +CaseCfg *gCurCase = NULL; + +typedef struct { + char caseCatalog[255]; + int32_t bindNullNum; + bool checkParamNum; + bool printRes; + bool printCreateTblSql; + bool printQuerySql; + bool printStmtSql; + bool printVerbose; + bool autoCreateTbl; + bool numericParam; + uint8_t precision; + int32_t rowNum; // row num for one table + int32_t bindColNum; + int32_t bindTagNum; + int32_t bindRowNum; // row num for once bind + int32_t bindColTypeNum; + int32_t *bindColTypeList; + int32_t bindTagTypeNum; + int32_t *bindTagTypeList; + int32_t optrIdxListNum; + int32_t *optrIdxList; + int32_t funcIdxListNum; + int32_t *funcIdxList; + int32_t runTimes; + int32_t caseIdx; // static case idx + int32_t caseNum; // num in static case list + int32_t caseRunIdx; // runtime case idx + int32_t caseRunNum; // total run case num +} CaseCtrl; + +#if 0 +CaseCtrl gCaseCtrl = { + .precision = TIME_PRECISION_MILLI, + .bindNullNum = 0, + .printCreateTblSql = true, + .printQuerySql = true, + .printStmtSql = true, + .printVerbose = true, + .printRes = true, + .autoCreateTbl = false, + .numericParam = false, + .rowNum = 0, + .bindColNum = 0, + .bindTagNum = 0, + .bindRowNum = 0, + .bindColTypeNum = 0, + .bindColTypeList = NULL, + .bindTagTypeNum = 0, + .bindTagTypeList = NULL, + .optrIdxListNum = 0, + .optrIdxList = NULL, + .funcIdxListNum = 0, + .funcIdxList = NULL, + .checkParamNum = false, + .runTimes = 0, + .caseIdx = 20, + .caseNum = 1, + .caseRunIdx = -1, + .caseRunNum = -1, +}; +#endif + +#if 1 +CaseCtrl gCaseCtrl = { + // default + .precision = TIME_PRECISION_MILLI, + .bindNullNum = 0, + .printCreateTblSql = true, + .printQuerySql = true, + .printStmtSql = true, + .printVerbose = false, + .printRes = true, + .autoCreateTbl = false, + .numericParam = false, + .rowNum = 0, + .bindColNum = 0, + .bindTagNum = 0, + .bindRowNum = 0, + .bindColTypeNum = 0, + .bindColTypeList = NULL, + .bindTagTypeNum = 0, + .bindTagTypeList = NULL, + .optrIdxListNum = 0, + .optrIdxList = NULL, + .funcIdxListNum = 0, + .funcIdxList = NULL, + .checkParamNum = false, + .runTimes = 0, + .caseIdx = -1, + .caseNum = -1, + .caseRunIdx = -1, + .caseRunNum = -1, +}; +#endif + +#if 0 +CaseCtrl gCaseCtrl = { // query case with specified col&oper + .bindNullNum = 1, + .printCreateTblSql = false, + .printQuerySql = true, + .printStmtSql = true, + .rowNum = 0, + .bindColNum = 0, + .bindRowNum = 0, + .optrIdxListNum = tListLen(optrIdxList), + .optrIdxList = optrIdxList, + .bindColTypeNum = tListLen(bindColTypeList), + .bindColTypeList = bindColTypeList, + .checkParamNum = false, + .printRes = true, + .runTimes = 0, + .caseRunIdx = -1, + .caseIdx = 5, + .caseNum = 1, + .caseRunNum = 1, +}; +#endif + +#if 0 +CaseCtrl gCaseCtrl = { // query case with specified col&oper + .bindNullNum = 0, + .printCreateTblSql = true, + .printQuerySql = true, + .printStmtSql = true, + .autoCreateTbl = true, + .rowNum = 0, + .bindColNum = 0, + .bindTagNum = 0, + .bindRowNum = 0, + .bindColTypeNum = 0, + .bindColTypeList = bindColTypeList, + .optrIdxListNum = 0, + .optrIdxList = optrIdxList, + .checkParamNum = false, + .printRes = true, + .runTimes = 0, + .caseRunIdx = -1, + .optrIdxListNum = tListLen(optrIdxList), + .optrIdxList = optrIdxList, + .bindColTypeNum = tListLen(bindColTypeList), + .bindColTypeList = bindColTypeList, + .caseRunIdx = -1, + .caseIdx = 24, + .caseNum = 1, + .caseRunNum = 1, +}; +#endif + +int32_t taosGetTimeOfDay(struct timeval *tv) { return gettimeofday(tv, NULL); } +void *taosMemoryMalloc(uint64_t size) { return malloc(size); } + +void *taosMemoryCalloc(int32_t num, int32_t size) { return calloc(num, size); } +void taosMemoryFree(const void *ptr) { + if (ptr == NULL) return; + + return free((void *)ptr); +} + +static int64_t taosGetTimestampMs() { + struct timeval systemTime; + taosGetTimeOfDay(&systemTime); + return (int64_t)systemTime.tv_sec * 1000LL + (int64_t)systemTime.tv_usec / 1000; +} + +static int64_t taosGetTimestampUs() { + struct timeval systemTime; + taosGetTimeOfDay(&systemTime); + return (int64_t)systemTime.tv_sec * 1000000LL + (int64_t)systemTime.tv_usec; +} + +bool colExists(TAOS_STMT2_BIND *pBind, int32_t dataType) { + int32_t i = 0; + while (true) { + if (0 == pBind[i].buffer_type) { + return false; + } + + if (pBind[i].buffer_type == dataType) { + return true; + } + + ++i; + } +} + +void generateInsertSQL(BindData *data) { + int32_t len = 0; + if (gCurCase->tblNum > 1) { + if (data->singleTbInsert) { + len = sprintf(data->sql, "insert into %s%d ", bpTbPrefix, data->singleTbIdx); + } else { + len = sprintf(data->sql, "insert into ? "); + } + } else { + len = sprintf(data->sql, "insert into %s0 ", bpTbPrefix); + } + + if (gCurCase->bindTagNum > 0) { + len += sprintf(data->sql + len, "using %s%d ", bpStbPrefix, bpDefaultStbId); + + if (!gCurCase->fullCol) { + len += sprintf(data->sql + len, "("); + for (int c = 0; c < gCurCase->bindTagNum; ++c) { + if (c) { + len += sprintf(data->sql + len, ","); + } + switch (data->pTags[c].buffer_type) { + case TSDB_DATA_TYPE_BOOL: + len += sprintf(data->sql + len, "tbooldata"); + break; + case TSDB_DATA_TYPE_TINYINT: + len += sprintf(data->sql + len, "ttinydata"); + break; + case TSDB_DATA_TYPE_SMALLINT: + len += sprintf(data->sql + len, "tsmalldata"); + break; + case TSDB_DATA_TYPE_INT: + len += sprintf(data->sql + len, "tintdata"); + break; + case TSDB_DATA_TYPE_BIGINT: + len += sprintf(data->sql + len, "tbigdata"); + break; + case TSDB_DATA_TYPE_FLOAT: + len += sprintf(data->sql + len, "tfloatdata"); + break; + case TSDB_DATA_TYPE_DOUBLE: + len += sprintf(data->sql + len, "tdoubledata"); + break; + case TSDB_DATA_TYPE_VARCHAR: + len += sprintf(data->sql + len, "tbinarydata"); + break; + case TSDB_DATA_TYPE_TIMESTAMP: + len += sprintf(data->sql + len, "tts"); + break; + case TSDB_DATA_TYPE_NCHAR: + len += sprintf(data->sql + len, "tnchardata"); + break; + case TSDB_DATA_TYPE_UTINYINT: + len += sprintf(data->sql + len, "tutinydata"); + break; + case TSDB_DATA_TYPE_USMALLINT: + len += sprintf(data->sql + len, "tusmalldata"); + break; + case TSDB_DATA_TYPE_UINT: + len += sprintf(data->sql + len, "tuintdata"); + break; + case TSDB_DATA_TYPE_UBIGINT: + len += sprintf(data->sql + len, "tubigdata"); + break; + default: + printf("!!!invalid tag type:%d", data->pTags[c].buffer_type); + exit(1); + } + } + + len += sprintf(data->sql + len, ") "); + } + + len += sprintf(data->sql + len, "tags ("); + for (int c = 0; c < gCurCase->bindTagNum; ++c) { + if (c) { + len += sprintf(data->sql + len, ","); + } + len += sprintf(data->sql + len, "?"); + } + len += sprintf(data->sql + len, ") "); + } + + if (!gCurCase->fullCol) { + len += sprintf(data->sql + len, "("); + for (int c = 0; c < gCurCase->bindColNum; ++c) { + if (c) { + len += sprintf(data->sql + len, ","); + } + switch (data->pBind[c].buffer_type) { + case TSDB_DATA_TYPE_BOOL: + len += sprintf(data->sql + len, "booldata"); + break; + case TSDB_DATA_TYPE_TINYINT: + len += sprintf(data->sql + len, "tinydata"); + break; + case TSDB_DATA_TYPE_SMALLINT: + len += sprintf(data->sql + len, "smalldata"); + break; + case TSDB_DATA_TYPE_INT: + len += sprintf(data->sql + len, "intdata"); + break; + case TSDB_DATA_TYPE_BIGINT: + len += sprintf(data->sql + len, "bigdata"); + break; + case TSDB_DATA_TYPE_FLOAT: + len += sprintf(data->sql + len, "floatdata"); + break; + case TSDB_DATA_TYPE_DOUBLE: + len += sprintf(data->sql + len, "doubledata"); + break; + case TSDB_DATA_TYPE_VARCHAR: + len += sprintf(data->sql + len, "binarydata"); + break; + case TSDB_DATA_TYPE_TIMESTAMP: + len += sprintf(data->sql + len, "ts"); + break; + case TSDB_DATA_TYPE_NCHAR: + len += sprintf(data->sql + len, "nchardata"); + break; + case TSDB_DATA_TYPE_UTINYINT: + len += sprintf(data->sql + len, "utinydata"); + break; + case TSDB_DATA_TYPE_USMALLINT: + len += sprintf(data->sql + len, "usmalldata"); + break; + case TSDB_DATA_TYPE_UINT: + len += sprintf(data->sql + len, "uintdata"); + break; + case TSDB_DATA_TYPE_UBIGINT: + len += sprintf(data->sql + len, "ubigdata"); + break; + default: + printf("!!!invalid col type:%d", data->pBind[c].buffer_type); + exit(1); + } + } + + len += sprintf(data->sql + len, ") "); + } + + len += sprintf(data->sql + len, "values ("); + for (int c = 0; c < gCurCase->bindColNum; ++c) { + if (c) { + len += sprintf(data->sql + len, ","); + } + len += sprintf(data->sql + len, "?"); + } + len += sprintf(data->sql + len, ")"); + + if (gCaseCtrl.printStmtSql) { + printf("\tSQL: %s\n", data->sql); + } +} + +void bpAppendOperatorParam(BindData *data, int32_t *len, int32_t dataType, int32_t idx) { + OperInfo *pInfo = NULL; + + if (gCaseCtrl.optrIdxListNum > 0) { + pInfo = &operInfo[gCaseCtrl.optrIdxList[idx]]; + } else { + if (TSDB_DATA_TYPE_VARCHAR == dataType || TSDB_DATA_TYPE_NCHAR == dataType || TSDB_DATA_TYPE_GEOMETRY == dataType) { +#if 1 + pInfo = &operInfo[varoperatorList[rand() % tListLen(varoperatorList)]]; +#else + pInfo = &operInfo[11]; +#endif + } else { + pInfo = &operInfo[operatorList[rand() % tListLen(operatorList)]]; + } + } + + switch (pInfo->paramNum) { + case 2: + if (pInfo->enclose) { + *len += sprintf(data->sql + *len, " %s (?)", pInfo->oper); + } else { + *len += sprintf(data->sql + *len, " %s ?", pInfo->oper); + } + break; + default: + printf("!!!invalid operator paramNum:%d\n", pInfo->paramNum); + exit(1); + } +} + +void bpAppendFunctionParam(BindData *data, int32_t *len, int32_t dataType, int32_t idx) { + FuncInfo *pInfo = NULL; + + if (gCaseCtrl.funcIdxListNum > 0) { + pInfo = &funcInfo[gCaseCtrl.funcIdxList[idx]]; + } else { + pInfo = &funcInfo[rand() % tListLen(funcInfo)]; + } + + switch (pInfo->paramNum) { + case 1: + *len += sprintf(data->sql + *len, " %s(?)", pInfo->funcName); + break; + default: + printf("!!!invalid function paramNum:%d\n", pInfo->paramNum); + exit(1); + } +} + +int32_t bpAppendColumnName(BindData *data, int32_t type, int32_t len) { + switch (type) { + case TSDB_DATA_TYPE_BOOL: + return sprintf(data->sql + len, "booldata"); + break; + case TSDB_DATA_TYPE_TINYINT: + return sprintf(data->sql + len, "tinydata"); + break; + case TSDB_DATA_TYPE_SMALLINT: + return sprintf(data->sql + len, "smalldata"); + break; + case TSDB_DATA_TYPE_INT: + return sprintf(data->sql + len, "intdata"); + break; + case TSDB_DATA_TYPE_BIGINT: + return sprintf(data->sql + len, "bigdata"); + break; + case TSDB_DATA_TYPE_FLOAT: + return sprintf(data->sql + len, "floatdata"); + break; + case TSDB_DATA_TYPE_DOUBLE: + return sprintf(data->sql + len, "doubledata"); + break; + case TSDB_DATA_TYPE_VARCHAR: + return sprintf(data->sql + len, "binarydata"); + break; + case TSDB_DATA_TYPE_TIMESTAMP: + return sprintf(data->sql + len, "ts"); + break; + case TSDB_DATA_TYPE_NCHAR: + return sprintf(data->sql + len, "nchardata"); + break; + case TSDB_DATA_TYPE_UTINYINT: + return sprintf(data->sql + len, "utinydata"); + break; + case TSDB_DATA_TYPE_USMALLINT: + return sprintf(data->sql + len, "usmalldata"); + break; + case TSDB_DATA_TYPE_UINT: + return sprintf(data->sql + len, "uintdata"); + break; + case TSDB_DATA_TYPE_UBIGINT: + return sprintf(data->sql + len, "ubigdata"); + break; + default: + printf("!!!invalid col type:%d", type); + exit(1); + } + + return 0; +} + +void generateQueryCondSQL(BindData *data, int32_t tblIdx) { + int32_t len = sprintf(data->sql, "select * from %s%d where ", bpTbPrefix, tblIdx); + if (!gCurCase->fullCol) { + for (int c = 0; c < gCurCase->bindColNum; ++c) { + if (c) { + len += sprintf(data->sql + len, " and "); + } + len += bpAppendColumnName(data, data->pBind[c].buffer_type, len); + + bpAppendOperatorParam(data, &len, data->pBind[c].buffer_type, c); + } + } + + if (gCaseCtrl.printStmtSql) { + printf("\tSTMT SQL: %s\n", data->sql); + } +} + +void bpGenerateConstInOpSQL(BindData *data, int32_t tblIdx) { + int32_t len = 0; + len = sprintf(data->sql, "select "); + + for (int c = 0; c < gCurCase->bindColNum; ++c) { + if (c) { + len += sprintf(data->sql + len, ", "); + } + + len += bpAppendColumnName(data, data->pBind[c].buffer_type, len); + + bpAppendOperatorParam(data, &len, data->pBind[c].buffer_type, c); + } + + len += sprintf(data->sql + len, " from %s%d", bpTbPrefix, tblIdx); +} + +void bpGenerateConstInFuncSQL(BindData *data, int32_t tblIdx) { + int32_t len = 0; + len = sprintf(data->sql, "select "); + + for (int c = 0; c < gCurCase->bindColNum; ++c) { + if (c) { + len += sprintf(data->sql + len, ", "); + } + + bpAppendFunctionParam(data, &len, data->pBind[c].buffer_type, c); + } + + len += sprintf(data->sql + len, " from %s%d", bpTbPrefix, tblIdx); +} + +void generateQueryMiscSQL(BindData *data, int32_t tblIdx) { + if (tblIdx == FUNCTION_TEST_IDX && gCurCase->bindNullNum <= 0) { + bpGenerateConstInFuncSQL(data, tblIdx); + } else { + switch (tblIdx) { + case 0: + // TODO FILL TEST + default: + bpGenerateConstInOpSQL(data, tblIdx); + break; + } + } + + if (gCaseCtrl.printStmtSql) { + printf("\tSTMT SQL: %s\n", data->sql); + } +} + +void generateErrorSQL(BindData *data, int32_t tblIdx) { + int32_t len = 0; + data->sql = taosMemoryCalloc(1, 1024); + + switch (tblIdx) { + case 0: + len = sprintf(data->sql, "insert into %s%d values (?, 1)", bpTbPrefix, tblIdx); + break; + case 1: + len = sprintf(data->sql, "select * from ?"); + break; + case 2: + len = sprintf(data->sql, "select * from %s%d where ? = ?", bpTbPrefix, tblIdx); + break; + default: + len = sprintf(data->sql, "select count(*) from %s%d group by ?", bpTbPrefix, tblIdx); + break; + } + + if (gCaseCtrl.printStmtSql) { + printf("\tSTMT SQL: %s\n", data->sql); + } +} + +void generateColDataType(bool isQuery, BindData *data, int32_t bindIdx, int32_t colIdx, int32_t *dataType) { + if (bindIdx < gCurCase->bindColNum) { + if (gCaseCtrl.bindColTypeNum) { + *dataType = gCaseCtrl.bindColTypeList[colIdx]; + return; + } else if (gCurCase->fullCol) { + *dataType = gCurCase->colList[bindIdx]; + return; + } else if (gCaseCtrl.numericParam) { + while (true) { + *dataType = rand() % (TSDB_DATA_TYPE_MAX - 1) + 1; + if (!IS_NUMERIC_TYPE(*dataType)) { + continue; + } + + break; + } + return; + } else if (0 == colIdx && !isQuery) { + *dataType = TSDB_DATA_TYPE_TIMESTAMP; + return; + } else { + while (true) { +#if 1 + *dataType = rand() % (TSDB_DATA_TYPE_MAX - 1) + 1; +#else + if (!colExists(data->pBind, TSDB_DATA_TYPE_NCHAR)) { + *dataType = TSDB_DATA_TYPE_NCHAR; + } else { + *dataType = rand() % (TSDB_DATA_TYPE_MAX - 1) + 1; + } +#endif + if (*dataType == TSDB_DATA_TYPE_JSON || *dataType == TSDB_DATA_TYPE_DECIMAL || + *dataType == TSDB_DATA_TYPE_BLOB || *dataType == TSDB_DATA_TYPE_MEDIUMBLOB || + *dataType == TSDB_DATA_TYPE_VARBINARY || *dataType == TSDB_DATA_TYPE_GEOMETRY) { + continue; + } + + if (colExists(data->pBind, *dataType)) { + continue; + } + + break; + } + } + } else { + *dataType = data->pBind[bindIdx % gCurCase->bindColNum].buffer_type; + } +} + +void generateTagDataType(BindData *data, int32_t bindIdx, int32_t colIdx, int32_t *dataType) { + if (bindIdx < gCurCase->bindTagNum) { + if (gCaseCtrl.bindTagTypeNum) { + *dataType = gCaseCtrl.bindTagTypeList[colIdx]; + return; + } else if (gCurCase->fullCol) { + *dataType = gCurCase->colList[bindIdx]; + return; + } else { + while (true) { + *dataType = rand() % (TSDB_DATA_TYPE_MAX - 1) + 1; + if (*dataType == TSDB_DATA_TYPE_JSON || *dataType == TSDB_DATA_TYPE_DECIMAL || + *dataType == TSDB_DATA_TYPE_BLOB || *dataType == TSDB_DATA_TYPE_MEDIUMBLOB || + *dataType == TSDB_DATA_TYPE_VARBINARY || *dataType == TSDB_DATA_TYPE_GEOMETRY) { + continue; + } + + if (colExists(data->pTags, *dataType)) { + continue; + } + + break; + } + } + } else { + *dataType = data->pTags[bindIdx % gCurCase->bindTagNum].buffer_type; + } +} + +int32_t prepareColData(bool isQuery, BP_BIND_TYPE bType, BindData *data, int32_t bindIdx, int32_t rowIdx, + int32_t colIdx) { + int32_t dataType = TSDB_DATA_TYPE_TIMESTAMP; + TAOS_STMT2_BIND *pBase = NULL; + + if (bType == BP_BIND_TAG) { + pBase = data->pTags; + generateTagDataType(data, bindIdx, colIdx, &dataType); + } else { + pBase = data->pBind; + generateColDataType(isQuery, data, bindIdx, colIdx, &dataType); + } + + switch (dataType) { + case TSDB_DATA_TYPE_BOOL: + // pBase[bindIdx].buffer_length = sizeof(bool); + pBase[bindIdx].buffer = data->boolData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_TINYINT: + // pBase[bindIdx].buffer_length = sizeof(int8_t); + pBase[bindIdx].buffer = data->tinyData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_SMALLINT: + // pBase[bindIdx].buffer_length = sizeof(int16_t); + pBase[bindIdx].buffer = data->smallData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_INT: + // pBase[bindIdx].buffer_length = sizeof(int32_t); + pBase[bindIdx].buffer = data->intData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_BIGINT: + // pBase[bindIdx].buffer_length = sizeof(int64_t); + pBase[bindIdx].buffer = data->bigData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_FLOAT: + // pBase[bindIdx].buffer_length = sizeof(float); + pBase[bindIdx].buffer = data->floatData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_DOUBLE: + // pBase[bindIdx].buffer_length = sizeof(double); + pBase[bindIdx].buffer = data->doubleData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_VARCHAR: + case TSDB_DATA_TYPE_GEOMETRY: + // pBase[bindIdx].buffer_length = gVarCharSize; + // pBase[bindIdx].buffer = data->binaryData + rowIdx * gVarCharSize; + pBase[bindIdx].buffer = data->binaryData + rowIdx * gVarCharLen; + pBase[bindIdx].length = data->binaryLen; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_TIMESTAMP: + // pBase[bindIdx].buffer_length = sizeof(int64_t); + pBase[bindIdx].buffer = data->tsData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = NULL; + break; + case TSDB_DATA_TYPE_NCHAR: + // pBase[bindIdx].buffer_length = gVarCharSize; + // pBase[bindIdx].buffer = data->binaryData + rowIdx * gVarCharSize; + pBase[bindIdx].buffer = data->binaryData + rowIdx * gVarCharLen; + pBase[bindIdx].length = data->binaryLen; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_UTINYINT: + // pBase[bindIdx].buffer_length = sizeof(uint8_t); + pBase[bindIdx].buffer = data->utinyData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_USMALLINT: + // pBase[bindIdx].buffer_length = sizeof(uint16_t); + pBase[bindIdx].buffer = data->usmallData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_UINT: + // pBase[bindIdx].buffer_length = sizeof(uint32_t); + pBase[bindIdx].buffer = data->uintData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + case TSDB_DATA_TYPE_UBIGINT: + // pBase[bindIdx].buffer_length = sizeof(uint64_t); + pBase[bindIdx].buffer = data->ubigData + rowIdx; + pBase[bindIdx].length = NULL; + pBase[bindIdx].is_null = data->isNull ? (data->isNull + rowIdx) : NULL; + break; + default: + printf("!!!invalid col type:%d", dataType); + exit(1); + } + + pBase[bindIdx].buffer_type = dataType; + pBase[bindIdx].num = gCurCase->bindRowNum; + + if (bType == BP_BIND_TAG) { + pBase[bindIdx].num = 1; + } + + return 0; +} + +int32_t prepareInsertData(BindData *data) { + uint64_t allRowNum = gCurCase->rowNum * gCurCase->tblNum; + + data->colNum = 0; + data->colTypes = taosMemoryCalloc(30, sizeof(int32_t)); + data->sql = taosMemoryCalloc(1, 1024); + data->pBind = + taosMemoryCalloc((int32_t)(allRowNum / gCurCase->bindRowNum) * gCurCase->bindColNum, sizeof(TAOS_STMT2_BIND)); + data->pTags = taosMemoryCalloc(gCurCase->tblNum * gCurCase->bindTagNum, sizeof(TAOS_STMT2_BIND)); + data->tsData = taosMemoryMalloc(allRowNum * sizeof(int64_t)); + data->boolData = taosMemoryMalloc(allRowNum * sizeof(bool)); + data->tinyData = taosMemoryMalloc(allRowNum * sizeof(int8_t)); + data->utinyData = taosMemoryMalloc(allRowNum * sizeof(uint8_t)); + data->smallData = taosMemoryMalloc(allRowNum * sizeof(int16_t)); + data->usmallData = taosMemoryMalloc(allRowNum * sizeof(uint16_t)); + data->intData = taosMemoryMalloc(allRowNum * sizeof(int32_t)); + data->uintData = taosMemoryMalloc(allRowNum * sizeof(uint32_t)); + data->bigData = taosMemoryMalloc(allRowNum * sizeof(int64_t)); + data->ubigData = taosMemoryMalloc(allRowNum * sizeof(uint64_t)); + data->floatData = taosMemoryMalloc(allRowNum * sizeof(float)); + data->doubleData = taosMemoryMalloc(allRowNum * sizeof(double)); + data->binaryData = taosMemoryMalloc(allRowNum * gVarCharSize); + data->binaryLen = taosMemoryMalloc(allRowNum * sizeof(int32_t)); + if (gCurCase->bindNullNum) { + data->isNull = taosMemoryCalloc((int32_t)allRowNum, sizeof(char)); + } + + for (int32_t i = 0; i < allRowNum; ++i) { + if (gCurCase->duplicateValue) { + data->tsData[i] = bpTs; + if (i % 2 == 1) { + bpTs++; + } + } else { + data->tsData[i] = bpTs++; + } + data->boolData[i] = (bool)(i % 2); + data->tinyData[i] = (int8_t)i; + data->utinyData[i] = (uint8_t)(i + 1); + data->smallData[i] = (int16_t)i; + data->usmallData[i] = (uint16_t)(i + 1); + data->intData[i] = (int32_t)i; + data->uintData[i] = (uint32_t)(i + 1); + data->bigData[i] = (int64_t)i; + data->ubigData[i] = (uint64_t)(i + 1); + data->floatData[i] = (float)i; + data->doubleData[i] = (double)(i + 1); + // memset(data->binaryData + gVarCharSize * i, 'a' + i % 26, gVarCharLen); + memset(data->binaryData + gVarCharLen * i, 'a' + i % 26, gVarCharLen); + if (gCurCase->bindNullNum) { + data->isNull[i] = (char)(i % 2); + } + data->binaryLen[i] = gVarCharLen; + } + + for (int b = 0; b < (allRowNum / gCurCase->bindRowNum); b++) { + for (int c = 0; c < gCurCase->bindColNum; ++c) { + prepareColData(false, BP_BIND_COL, data, b * gCurCase->bindColNum + c, b * gCurCase->bindRowNum, c); + } + } + + for (int b = 0; b < gCurCase->tblNum; b++) { + for (int c = 0; c < gCurCase->bindTagNum; ++c) { + prepareColData(false, BP_BIND_TAG, data, b * gCurCase->bindTagNum + c, b, c); + } + } + + generateInsertSQL(data); + + return 0; +} + +int32_t prepareQueryCondData(BindData *data, int32_t tblIdx) { + uint64_t bindNum = gCurCase->rowNum / gCurCase->bindRowNum; + + data->colNum = 0; + data->colTypes = taosMemoryCalloc(30, sizeof(int32_t)); + data->sql = taosMemoryCalloc(1, 1024); + data->pBind = taosMemoryCalloc((int32_t)bindNum * gCurCase->bindColNum, sizeof(TAOS_STMT2_BIND)); + data->tsData = taosMemoryMalloc(bindNum * sizeof(int64_t)); + data->boolData = taosMemoryMalloc(bindNum * sizeof(bool)); + data->tinyData = taosMemoryMalloc(bindNum * sizeof(int8_t)); + data->utinyData = taosMemoryMalloc(bindNum * sizeof(uint8_t)); + data->smallData = taosMemoryMalloc(bindNum * sizeof(int16_t)); + data->usmallData = taosMemoryMalloc(bindNum * sizeof(uint16_t)); + data->intData = taosMemoryMalloc(bindNum * sizeof(int32_t)); + data->uintData = taosMemoryMalloc(bindNum * sizeof(uint32_t)); + data->bigData = taosMemoryMalloc(bindNum * sizeof(int64_t)); + data->ubigData = taosMemoryMalloc(bindNum * sizeof(uint64_t)); + data->floatData = taosMemoryMalloc(bindNum * sizeof(float)); + data->doubleData = taosMemoryMalloc(bindNum * sizeof(double)); + data->binaryData = taosMemoryMalloc(bindNum * gVarCharSize); + data->binaryLen = taosMemoryMalloc(bindNum * sizeof(int32_t)); + if (gCurCase->bindNullNum) { + data->isNull = taosMemoryCalloc((int32_t)bindNum, sizeof(char)); + } + + for (int32_t i = 0; i < bindNum; ++i) { + data->tsData[i] = bpTs + tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum; + data->boolData[i] = (bool)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->tinyData[i] = (int8_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->utinyData[i] = (uint8_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->smallData[i] = (int16_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->usmallData[i] = (uint16_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->intData[i] = (int32_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->uintData[i] = (uint32_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->bigData[i] = (int64_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->ubigData[i] = (uint64_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->floatData[i] = (float)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->doubleData[i] = (double)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + // memset(data->binaryData + gVarCharSize * i, 'a' + i % 26, gVarCharLen); + memset(data->binaryData + gVarCharLen * i, 'a' + i % 26, gVarCharLen); + if (gCurCase->bindNullNum) { + data->isNull[i] = (char)(i % 2); + } + data->binaryLen[i] = gVarCharLen; + } + + for (int b = 0; b < bindNum; b++) { + for (int c = 0; c < gCurCase->bindColNum; ++c) { + prepareColData(true, BP_BIND_COL, data, b * gCurCase->bindColNum + c, b * gCurCase->bindRowNum, c); + } + } + + generateQueryCondSQL(data, tblIdx); + + return 0; +} + +int32_t prepareQueryMiscData(BindData *data, int32_t tblIdx) { + uint64_t bindNum = gCurCase->rowNum / gCurCase->bindRowNum; + + data->colNum = 0; + data->colTypes = taosMemoryCalloc(30, sizeof(int32_t)); + data->sql = taosMemoryCalloc(1, 1024); + data->pBind = taosMemoryCalloc((int32_t)bindNum * gCurCase->bindColNum, sizeof(TAOS_STMT2_BIND)); + data->tsData = taosMemoryMalloc(bindNum * sizeof(int64_t)); + data->boolData = taosMemoryMalloc(bindNum * sizeof(bool)); + data->tinyData = taosMemoryMalloc(bindNum * sizeof(int8_t)); + data->utinyData = taosMemoryMalloc(bindNum * sizeof(uint8_t)); + data->smallData = taosMemoryMalloc(bindNum * sizeof(int16_t)); + data->usmallData = taosMemoryMalloc(bindNum * sizeof(uint16_t)); + data->intData = taosMemoryMalloc(bindNum * sizeof(int32_t)); + data->uintData = taosMemoryMalloc(bindNum * sizeof(uint32_t)); + data->bigData = taosMemoryMalloc(bindNum * sizeof(int64_t)); + data->ubigData = taosMemoryMalloc(bindNum * sizeof(uint64_t)); + data->floatData = taosMemoryMalloc(bindNum * sizeof(float)); + data->doubleData = taosMemoryMalloc(bindNum * sizeof(double)); + data->binaryData = taosMemoryMalloc(bindNum * gVarCharSize); + data->binaryLen = taosMemoryMalloc(bindNum * sizeof(int32_t)); + if (gCurCase->bindNullNum) { + data->isNull = taosMemoryCalloc((int32_t)bindNum, sizeof(char)); + } + + for (int32_t i = 0; i < bindNum; ++i) { + data->tsData[i] = bpTs + tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum; + data->boolData[i] = (bool)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->tinyData[i] = (int8_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->utinyData[i] = (uint8_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->smallData[i] = (int16_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->usmallData[i] = (uint16_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->intData[i] = (int32_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->uintData[i] = (uint32_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->bigData[i] = (int64_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->ubigData[i] = (uint64_t)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->floatData[i] = (float)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + data->doubleData[i] = (double)(tblIdx * gCurCase->rowNum + rand() % gCurCase->rowNum); + // memset(data->binaryData + gVarCharSize * i, 'a' + i % 26, gVarCharLen); + memset(data->binaryData + gVarCharLen * i, 'a' + i % 26, gVarCharLen); + if (gCurCase->bindNullNum) { + data->isNull[i] = (char)(i % 2); + } + data->binaryLen[i] = gVarCharLen; + } + + if (tblIdx == FUNCTION_TEST_IDX) { + gCaseCtrl.numericParam = true; + } else { + gCaseCtrl.numericParam = false; + } + + for (int b = 0; b < bindNum; b++) { + for (int c = 0; c < gCurCase->bindColNum; ++c) { + prepareColData(true, BP_BIND_COL, data, b * gCurCase->bindColNum + c, b * gCurCase->bindRowNum, c); + } + } + + gCaseCtrl.numericParam = false; + + generateQueryMiscSQL(data, tblIdx); + + return 0; +} + +void destroyData(BindData *data) { + taosMemoryFree(data->tsData); + taosMemoryFree(data->boolData); + taosMemoryFree(data->tinyData); + taosMemoryFree(data->utinyData); + taosMemoryFree(data->smallData); + taosMemoryFree(data->usmallData); + taosMemoryFree(data->intData); + taosMemoryFree(data->uintData); + taosMemoryFree(data->bigData); + taosMemoryFree(data->ubigData); + taosMemoryFree(data->floatData); + taosMemoryFree(data->doubleData); + taosMemoryFree(data->binaryData); + taosMemoryFree(data->binaryLen); + taosMemoryFree(data->isNull); + taosMemoryFree(data->pBind); + taosMemoryFree(data->pTags); + taosMemoryFree(data->colTypes); + taosMemoryFree(data->sql); +} + +void bpFetchRows(TAOS_RES *result, bool printr, int32_t *rows) { + TAOS_ROW row; + int num_fields = taos_num_fields(result); + TAOS_FIELD *fields = taos_fetch_fields(result); + char temp[256]; + + // fetch the records row by row + while ((row = taos_fetch_row(result))) { + (*rows)++; + if (printr) { + memset(temp, 0, sizeof(temp)); + taos_print_row(temp, row, fields, num_fields); + printf("\t[%s]\n", temp); + } + } +} + +void bpExecQuery(TAOS *taos, char *sql, bool printr, int32_t *rows) { + TAOS_RES *result = taos_query(taos, sql); + int code = taos_errno(result); + if (code != 0) { + printf("!!!failed to query table, reason:%s\n", taos_errstr(result)); + taos_free_result(result); + exit(1); + } + + bpFetchRows(result, printr, rows); + + taos_free_result(result); +} + +int32_t bpAppendValueString(char *buf, int type, void *value, int32_t valueLen, int32_t *len) { + switch (type) { + case TSDB_DATA_TYPE_NULL: + *len += sprintf(buf + *len, "null"); + break; + + case TSDB_DATA_TYPE_BOOL: + *len += sprintf(buf + *len, (*(bool *)value) ? "true" : "false"); + break; + + case TSDB_DATA_TYPE_TINYINT: + *len += sprintf(buf + *len, "%d", *(int8_t *)value); + break; + + case TSDB_DATA_TYPE_SMALLINT: + *len += sprintf(buf + *len, "%d", *(int16_t *)value); + break; + + case TSDB_DATA_TYPE_INT: + *len += sprintf(buf + *len, "%d", *(int32_t *)value); + break; + + case TSDB_DATA_TYPE_BIGINT: + case TSDB_DATA_TYPE_TIMESTAMP: + *len += sprintf(buf + *len, "%ld", *(int64_t *)value); + break; + + case TSDB_DATA_TYPE_FLOAT: + *len += sprintf(buf + *len, "%e", *(float *)value); + break; + + case TSDB_DATA_TYPE_DOUBLE: + *len += sprintf(buf + *len, "%e", *(double *)value); + break; + + case TSDB_DATA_TYPE_BINARY: + case TSDB_DATA_TYPE_VARBINARY: + case TSDB_DATA_TYPE_NCHAR: + case TSDB_DATA_TYPE_GEOMETRY: + buf[*len] = '\''; + ++(*len); + memcpy(buf + *len, value, valueLen); + *len += valueLen; + buf[*len] = '\''; + ++(*len); + break; + + case TSDB_DATA_TYPE_UTINYINT: + *len += sprintf(buf + *len, "%d", *(uint8_t *)value); + break; + + case TSDB_DATA_TYPE_USMALLINT: + *len += sprintf(buf + *len, "%d", *(uint16_t *)value); + break; + + case TSDB_DATA_TYPE_UINT: + *len += sprintf(buf + *len, "%u", *(uint32_t *)value); + break; + + case TSDB_DATA_TYPE_UBIGINT: + *len += sprintf(buf + *len, "%lu", *(uint64_t *)value); + break; + + default: + printf("!!!invalid data type:%d\n", type); + exit(1); + } +} + +static TAOS_STMT2 *st_stmt2_init(TAOS *taos, bool stb_insert) { + TAOS_STMT2_OPTION option = {0}; + if (stb_insert) { + option.singleStbInsert = true; + option.singleTableBindOnce = true; + } + + return taos_stmt2_init(taos, &option); +} + +static int st_stmt2_close(TAOS_STMT2 *stmt) { return taos_stmt2_close(stmt); } + +static char *st_stmt2_error(TAOS_STMT2 *stmt) { return taos_stmt2_error(stmt); } + +static int st_stmt2_prepare(TAOS_STMT2 *stmt, const char *sql, unsigned long length) { + return taos_stmt2_prepare(stmt, sql, length); +} + +static int st_stmt2_bind(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col_idx) { + return taos_stmt2_bind_param(stmt, bindv, col_idx); +} + +static int st_stmt2_exec(TAOS_STMT2 *stmt, int *affected_rows) { return taos_stmt2_exec(stmt, affected_rows); } + +static int st_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert) { return taos_stmt2_is_insert(stmt, insert); } + +static int st_stmt2_num_params(TAOS_STMT2 *stmt, int *count) { + return taos_stmt2_get_fields(stmt, TAOS_FIELD_QUERY, count, NULL); +} + +static int st_stmt2_get_tag_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_E **fields) { + return taos_stmt2_get_fields(stmt, TAOS_FIELD_TAG, count, fields); +} + +static int st_stmt2_get_col_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_E **fields) { + return taos_stmt2_get_fields(stmt, TAOS_FIELD_COL, count, fields); +} + +static int st_stmt2_get_param(TAOS_STMT2 *stmt, int idx, int *type, int *bytes) { + int32_t code = 0, nums = 0; + TAOS_FIELD_E *fields = NULL; + + code = taos_stmt2_get_fields(stmt, TAOS_FIELD_COL, &nums, &fields); + if (code) { + return code; + } + + if (idx > nums) { + taosMemoryFree(fields); + return -1; + } + + *type = fields[idx].type; + *bytes = fields[idx].bytes; + + taosMemoryFree(fields); + return 0; +} + +static int st_stmt2_set_tbname(TAOS_STMT2 *stmt, char *name) { + TAOS_STMT2_BINDV bindv = {0}; + bindv.count = 1; + bindv.tbnames = &name; + return taos_stmt2_bind_param(stmt, &bindv, -1); +} + +static int st_stmt2_set_tags(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *tags) { + TAOS_STMT2_BINDV bindv = {0}; + bindv.count = 1; + bindv.tags = &tags; + return taos_stmt2_bind_param(stmt, &bindv, -1); +} + +static int st_stmt2_set_tbname_tags(TAOS_STMT2 *stmt, char *name, TAOS_STMT2_BIND *tags) { + TAOS_STMT2_BINDV bindv = {0}; + bindv.count = 1; + bindv.tbnames = &name; + bindv.tags = &tags; + return taos_stmt2_bind_param(stmt, &bindv, -1); +} + +static int st_stmt2_bind_param_batch(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind) { + TAOS_STMT2_BINDV bindv = {0}; + bindv.count = 1; + bindv.bind_cols = &bind; + return taos_stmt2_bind_param(stmt, &bindv, -1); +} + +static int st_stmt2_bind_single_param_batch(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind, int col_idx) { + TAOS_STMT2_BINDV bindv = {0}; + bindv.count = 1; + bindv.bind_cols = &bind; + return taos_stmt2_bind_param(stmt, &bindv, col_idx); +} + +static int st_stmt2_bind_param(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind) { + TAOS_STMT2_BINDV bindv = {0}; + bindv.count = 1; + bindv.bind_cols = &bind; + return taos_stmt2_bind_param(stmt, &bindv, -1); +} + +static int st_stmt2_add_batch(TAOS_STMT2 *stmt) { return 0; } + +static TAOS_RES *st_stmt2_use_result(TAOS_STMT2 *stmt) { return taos_stmt2_result(stmt); } + +void bpCheckIsInsert(TAOS_STMT2 *stmt, int32_t insert) { + int32_t isInsert = 0; + if (st_stmt2_is_insert(stmt, &isInsert)) { + printf("!!!st_stmt2_is_insert error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + if (insert != isInsert) { + printf("!!!is insert failed\n"); + exit(1); + } +} + +void bpCheckParamNum(TAOS_STMT2 *stmt) { + int32_t num = 0; + if (st_stmt2_num_params(stmt, &num)) { + printf("!!!st_stmt2_num_params error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + if (gCurCase->bindColNum != num) { + printf("!!!is insert failed\n"); + exit(1); + } +} + +void bpCheckAffectedRows(TAOS_STMT2 *stmt, int32_t times) { + /* TODO: affected rows from exec + int32_t rows = taos_stmt_affected_rows(stmt); + int32_t insertNum = gCurCase->rowNum * gCurCase->tblNum * times; + if (gCurCase->duplicateValue) { + insertNum /= 2; + } + if (insertNum != rows) { + printf("!!!affected rows %d mis-match with insert num %d\n", rows, insertNum); + exit(1); + } + */ +} + +void bpCheckQueryResult(TAOS_STMT2 *stmt, TAOS *taos, char *stmtSql, TAOS_STMT2_BIND *bind) { + // query using sql + char sql[1024]; + int32_t len = 0; + char *p = stmtSql; + char *s = NULL; + int32_t sqlResNum = 0; + + for (int32_t i = 0; true; ++i, p = s + 1) { + s = strchr(p, '?'); + if (NULL == s) { + strcpy(&sql[len], p); + break; + } + + memcpy(&sql[len], p, (int64_t)s - (int64_t)p); + len += (int32_t)((int64_t)s - (int64_t)p); + + if (bind[i].is_null && bind[i].is_null[0]) { + bpAppendValueString(sql, TSDB_DATA_TYPE_NULL, NULL, 0, &len); + continue; + } + + bpAppendValueString(sql, bind[i].buffer_type, bind[i].buffer, (bind[i].length ? bind[i].length[0] : 0), &len); + } + + if (gCaseCtrl.printQuerySql) { + printf("\tQuery SQL: %s\n", sql); + } + + bpExecQuery(taos, sql, gCaseCtrl.printRes, &sqlResNum); + + // query using stmt + TAOS_RES *res = st_stmt2_use_result(stmt); + int32_t stmtResNum = 0; + bpFetchRows(res, gCaseCtrl.printRes, &stmtResNum); + + if (sqlResNum != stmtResNum) { + printf("!!!sql res num %d mis-match stmt res num %d\n", sqlResNum, stmtResNum); + exit(1); + } + + printf("***sql res num match stmt res num %d\n", stmtResNum); +} + +void bpCheckColTagFields(TAOS_STMT2 *stmt, int32_t fieldNum, TAOS_FIELD_E *pFields, int32_t expecteNum, + TAOS_STMT2_BIND *pBind, BP_BIND_TYPE type) { + int32_t code = 0; + + if (fieldNum != expecteNum) { + printf("!!!%s field num %d mis-match expect num %d\n", BP_BIND_TYPE_STR(type), fieldNum, expecteNum); + exit(1); + } + + if (type == BP_BIND_COL) { + if (pFields[0].precision != gCaseCtrl.precision) { + printf("!!!db precision %d mis-match expect %d\n", pFields[0].precision, gCaseCtrl.precision); + exit(1); + } + } + + for (int32_t i = 0; i < fieldNum; ++i) { + if (pFields[i].type != pBind[i].buffer_type) { + printf("!!!%s %dth field type %d mis-match expect type %d\n", BP_BIND_TYPE_STR(type), i, pFields[i].type, + pBind[i].buffer_type); + exit(1); + } + + if (pFields[i].type == TSDB_DATA_TYPE_BINARY || pFields[i].type == TSDB_DATA_TYPE_VARBINARY || + pFields[i].type == TSDB_DATA_TYPE_GEOMETRY) { + /* + if (pFields[i].bytes != (pBind[i].buffer_length + 2)) { + printf("!!!%s %dth field len %d mis-match expect len %d\n", BP_BIND_TYPE_STR(type), i, pFields[i].bytes, + (pBind[i].buffer_length + 2)); + exit(1); + } + */ + } else if (pFields[i].type == TSDB_DATA_TYPE_NCHAR) { + /* + if (pFields[i].bytes != (pBind[i].buffer_length * 4 + 2)) { + printf("!!!%s %dth field len %d mis-match expect len %d\n", BP_BIND_TYPE_STR(type), i, pFields[i].bytes, + (pBind[i].buffer_length + 2)); + exit(1); + } + */ + /*} else if (pFields[i].bytes != pBind[i].buffer_length) { + printf("!!!%s %dth field len %d mis-match expect len %d\n", BP_BIND_TYPE_STR(type), i, pFields[i].bytes, + pBind[i].buffer_length); + exit(1);*/ + } + } + + if (type == BP_BIND_COL) { + int fieldType = 0; + int fieldBytes = 0; + for (int32_t i = 0; i < fieldNum; ++i) { + code = st_stmt2_get_param(stmt, i, &fieldType, &fieldBytes); + if (code) { + printf("!!!st_stmt2_get_param error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + if (pFields[i].type != fieldType) { + printf("!!!%s %dth field type %d mis-match expect type %d\n", BP_BIND_TYPE_STR(type), i, fieldType, + pFields[i].type); + exit(1); + } + + if (pFields[i].bytes != fieldBytes) { + printf("!!!%s %dth field len %d mis-match expect len %d\n", BP_BIND_TYPE_STR(type), i, fieldBytes, + pFields[i].bytes); + exit(1); + } + } + } + + if (gCaseCtrl.printVerbose) { + printf("%s fields check passed\n", BP_BIND_TYPE_STR(type)); + } +} + +void bpCheckTagFields(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *pBind) { + int32_t code = 0; + int fieldNum = 0; + TAOS_FIELD_E *pFields = NULL; + code = st_stmt2_get_tag_fields(stmt, &fieldNum, &pFields); + if (code != 0) { + printf("!!!st_stmt2_get_tag_fields error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckColTagFields(stmt, fieldNum, pFields, gCurCase->bindTagNum, pBind, BP_BIND_TAG); + taosMemoryFree(pFields); +} + +void bpCheckColFields(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *pBind) { + if (gCurCase->testType == TTYPE_QUERY) { + return; + } + + int32_t code = 0; + int fieldNum = 0; + TAOS_FIELD_E *pFields = NULL; + code = st_stmt2_get_col_fields(stmt, &fieldNum, &pFields); + if (code != 0) { + printf("!!!st_stmt2_get_col_fields error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckColTagFields(stmt, fieldNum, pFields, gCurCase->bindColNum, pBind, BP_BIND_COL); + taosMemoryFree(pFields); +} + +void bpShowBindParam(TAOS_STMT2_BIND *bind, int32_t num) { + for (int32_t i = 0; i < num; ++i) { + TAOS_STMT2_BIND *b = &bind[i]; + printf("Bind %d: type[%d],buf[%p],len[%d],null[%d],num[%d]\n", i, b->buffer_type, b->buffer, + /*b->buffer_length,*/ b->length ? *b->length : 0, b->is_null ? *b->is_null : 0, b->num); + } +} + +int32_t bpBindParam(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind, bool expectFail) { + static int32_t n = 0; + + if (!expectFail) { + bpCheckColFields(stmt, bind); + } + + if (gCurCase->bindRowNum > 1) { + if (0 == (n++ % 2) || gCurCase->stbInsert) { + if (st_stmt2_bind_param_batch(stmt, bind)) { + if (expectFail) return 0; + printf("!!!st_stmt2_bind_param_batch error:%s\n", st_stmt2_error(stmt)); + bpShowBindParam(bind, gCurCase->bindColNum); + exit(1); + } + } else { + for (int32_t i = 0; i < gCurCase->bindColNum; ++i) { + if (st_stmt2_bind_single_param_batch(stmt, bind + i, i)) { + if (expectFail) continue; + printf("!!!st_stmt2_bind_single_param_batch %d error:%s\n", i, st_stmt2_error(stmt)); + bpShowBindParam(bind, gCurCase->bindColNum); + exit(1); + } + } + } + } else { + if (0 == (n++ % 2)) { + if (st_stmt2_bind_param_batch(stmt, bind)) { + if (expectFail) return 0; + printf("!!!st_stmt2_bind_param_batch error:%s\n", st_stmt2_error(stmt)); + bpShowBindParam(bind, gCurCase->bindColNum); + exit(1); + } + } else { + if (st_stmt2_bind_param(stmt, bind)) { + if (expectFail) return 0; + printf("!!!st_stmt2_bind_param error:%s\n", st_stmt2_error(stmt)); + bpShowBindParam(bind, gCurCase->bindColNum); + exit(1); + } + } + } + + return 0; +} + +int32_t bpSetTableNameTags(BindData *data, int32_t tblIdx, char *tblName, TAOS_STMT2 *stmt) { + int32_t code = 0; + if (gCurCase->bindTagNum > 0) { + if ((rand() % 2) == 0) { + code = st_stmt2_set_tbname(stmt, tblName); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckTagFields(stmt, data->pTags + tblIdx * gCurCase->bindTagNum); + + return st_stmt2_set_tags(stmt, data->pTags + tblIdx * gCurCase->bindTagNum); + } else { + return st_stmt2_set_tbname_tags(stmt, tblName, data->pTags + tblIdx * gCurCase->bindTagNum); + } + } else { + return st_stmt2_set_tbname(stmt, tblName); + } +} + +/* prepare [settbname [bind add]] exec */ +int insertMBSETest1(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + for (int32_t b = 0; b < bindTimes; ++b) { + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + bpCheckAffectedRows(stmt, 1); + + destroyData(&data); + + return 0; +} + +/* prepare [settbname bind add] exec */ +int insertMBSETest2(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + + for (int32_t b = 0; b < bindTimes; ++b) { + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + bpCheckAffectedRows(stmt, 1); + + destroyData(&data); + + return 0; +} + +/* prepare [settbname [bind add] exec] */ +int insertMBMETest1(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + for (int32_t b = 0; b < bindTimes; ++b) { + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + bpCheckIsInsert(stmt, 1); + bpCheckAffectedRows(stmt, 1); + + destroyData(&data); + + return 0; +} + +/* prepare [settbname [bind add exec]] */ +int insertMBMETest2(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + for (int32_t b = 0; b < bindTimes; ++b) { + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + } + + bpCheckIsInsert(stmt, 1); + bpCheckAffectedRows(stmt, 1); + + destroyData(&data); + + return 0; +} + +/* prepare [settbname [settbname bind add exec]] */ +int insertMBMETest3(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + for (int32_t b = 0; b < bindTimes; ++b) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + } + + bpCheckIsInsert(stmt, 1); + bpCheckAffectedRows(stmt, 1); + + destroyData(&data); + + return 0; +} + +/* prepare [settbname bind add exec] */ +int insertMBMETest4(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + + for (int32_t b = 0; b < bindTimes; ++b) { + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + } + + bpCheckIsInsert(stmt, 1); + bpCheckAffectedRows(stmt, 1); + + destroyData(&data); + + return 0; +} + +/* [prepare [settbname [bind add] exec]] */ +int insertMPMETest1(TAOS_STMT2 *stmt, TAOS *taos) { + int32_t loop = 0; + + while (gCurCase->bindColNum >= 2) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + for (int32_t b = 0; b < bindTimes; ++b) { + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + bpCheckIsInsert(stmt, 1); + + destroyData(&data); + + gCurCase->bindColNum -= 2; + gCurCase->fullCol = false; + loop++; + } + + bpCheckAffectedRows(stmt, loop); + + gExecLoopTimes = loop; + + return 0; +} + +/* prepare [settbname [bind] exec] */ +int insertStbTest(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + for (int32_t b = 0; b < bindTimes; ++b) { + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + bpCheckIsInsert(stmt, 1); + + destroyData(&data); + + bpCheckAffectedRows(stmt, 1); + + return 0; +} + +/* [prepare [settbnametag [bind add] exec]] */ +int insertAUTOTest1(TAOS_STMT2 *stmt, TAOS *taos) { + int32_t loop = 0; + + while (gCurCase->bindTagNum > 0 && gCurCase->bindColNum > 0) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname_tags error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + for (int32_t b = 0; b < bindTimes; ++b) { + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + bpCheckIsInsert(stmt, 1); + + destroyData(&data); + + gCurCase->bindColNum -= 2; + gCurCase->bindTagNum -= 2; + gCurCase->fullCol = false; + loop++; + } + + bpCheckAffectedRows(stmt, loop); + + gExecLoopTimes = loop; + + return 0; +} + +/* [prepare [settbnametag [bind add exec]]] */ +int insertAUTOTest2(TAOS_STMT2 *stmt, TAOS *taos) { + int32_t loop = 0; + + while (gCurCase->bindTagNum > 0 && gCurCase->bindColNum > 0) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + for (int32_t b = 0; b < bindTimes; ++b) { + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + char buf[32]; + sprintf(buf, "t%d", t); + code = bpSetTableNameTags(&data, t, buf, stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname_tags error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + } + + bpCheckIsInsert(stmt, 1); + + destroyData(&data); + + gCurCase->bindColNum -= 2; + gCurCase->bindTagNum -= 2; + gCurCase->fullCol = false; + loop++; + } + + bpCheckAffectedRows(stmt, loop); + + gExecLoopTimes = loop; + + return 0; +} + +/* normal table [prepare [bind add exec]] */ +int insertAUTOTest3(TAOS_STMT2 *stmt, TAOS *taos) { + int32_t loop = 0; + + while (gCurCase->bindColNum > 0) { + BindData data = {0}; + data.singleTbInsert = true; + prepareInsertData(&data); + + int32_t bindTimes = gCurCase->rowNum / gCurCase->bindRowNum; + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + data.singleTbIdx = t; + generateInsertSQL(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + for (int32_t b = 0; b < bindTimes; ++b) { + bpCheckIsInsert(stmt, 1); + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + if (bpBindParam(stmt, data.pBind + t * bindTimes * gCurCase->bindColNum + b * gCurCase->bindColNum, false)) { + exit(1); + } + + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + } + + bpCheckIsInsert(stmt, 1); + + destroyData(&data); + + gCurCase->bindColNum -= 2; + gCurCase->fullCol = false; + loop++; + } + + bpCheckAffectedRows(stmt, loop); + + gExecLoopTimes = loop; + + return 0; +} + +/* select * from table */ +int queryColumnTest(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + memset(&data, 0, sizeof(data)); + prepareQueryCondData(&data, t); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + for (int32_t n = 0; n < (gCurCase->rowNum / gCurCase->bindRowNum); ++n) { + bpCheckIsInsert(stmt, 0); + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + if (bpBindParam(stmt, data.pBind + n * gCurCase->bindColNum, false)) { + exit(1); + } + + if (rand() % 2 == 0) { + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckQueryResult(stmt, taos, data.sql, data.pBind + n * gCurCase->bindColNum); + } + + bpCheckIsInsert(stmt, 0); + + destroyData(&data); + } + + return 0; +} + +/* value in query sql */ +int queryMiscTest(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + memset(&data, 0, sizeof(data)); + prepareQueryMiscData(&data, t); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + for (int32_t n = 0; n < (gCurCase->rowNum / gCurCase->bindRowNum); ++n) { + bpCheckIsInsert(stmt, 0); + + if (gCaseCtrl.checkParamNum) { + bpCheckParamNum(stmt); + } + + if (bpBindParam(stmt, data.pBind + n * gCurCase->bindColNum, false)) { + exit(1); + } + + if (rand() % 2 == 0) { + if (st_stmt2_add_batch(stmt)) { + printf("!!!st_stmt2_add_batch error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + } + + if (st_stmt2_exec(stmt, NULL) != 0) { + printf("!!!st_stmt2_exec error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckQueryResult(stmt, taos, data.sql, data.pBind + n * gCurCase->bindColNum); + } + + bpCheckIsInsert(stmt, 0); + + destroyData(&data); + } + + return 0; +} + +int insertNonExistsTb(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + char *buf = "tbnexist"; + code = bpSetTableNameTags(&data, 0, buf, stmt); + if (code == 0) { + printf("!!!st_stmt2_set_tbname expected error not occurred\n"); + exit(1); + } + + if (0 == st_stmt2_bind_param_batch(stmt, data.pBind)) { + printf("!!!st_stmt2_bind_param_batch expected error not occurred\n"); + exit(1); + } + + if (0 == st_stmt2_exec(stmt, NULL)) { + printf("!!!st_stmt2_execute expected error not occurred\n"); + exit(1); + } + + destroyData(&data); + + return 0; +} + +void bpAddWrongVarBuffLen(TAOS_STMT2_BIND *pBind) { + for (int32_t i = 0; i < gCurCase->bindColNum; ++i) { + if (pBind[i].buffer_type == TSDB_DATA_TYPE_BINARY || pBind[i].buffer_type == TSDB_DATA_TYPE_VARBINARY || + pBind[i].buffer_type == TSDB_DATA_TYPE_NCHAR) { + *pBind[i].length += 100; + } + } +} + +int insertVarLenErr(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + prepareInsertData(&data); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("!!!failed to execute st_stmt2_prepare. error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpCheckIsInsert(stmt, 1); + + code = bpSetTableNameTags(&data, 0, "t0", stmt); + if (code != 0) { + printf("!!!st_stmt2_set_tbname error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + bpAddWrongVarBuffLen(data.pBind); + + if (bpBindParam(stmt, data.pBind, true)) { + exit(1); + } + + destroyData(&data); + + return 0; +} + +int errorSQLTest1(TAOS_STMT2 *stmt, TAOS *taos) { + BindData data = {0}; + + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + memset(&data, 0, sizeof(data)); + generateErrorSQL(&data, t); + + int code = st_stmt2_prepare(stmt, data.sql, 0); + if (code != 0) { + printf("*st_stmt2_prepare error as expected, error:%s\n", st_stmt2_error(stmt)); + } else { + printf("!!!st_stmt2_prepare succeed, which should be error\n"); + exit(1); + } + + destroyData(&data); + } + + return 0; +} + +void prepareCheckResultImpl(TAOS *taos, char *tname, bool printr, int expected, bool silent) { + if (TTYPE_INSERT_NG == gCurCase->testType) { + return; + } + + char sql[255] = "SELECT * FROM "; + int32_t rows = 0; + + strcat(sql, tname); + bpExecQuery(taos, sql, printr, &rows); + + if (rows == expected) { + if (!silent) { + printf("***%d rows are fetched as expected from %s\n", rows, tname); + } + } else { + printf("!!!expect rows %d mis-match rows %d fetched from %s\n", expected, rows, tname); + exit(1); + } +} + +void prepareCheckResult(TAOS *taos, bool silent) { + char buf[32]; + for (int32_t t = 0; t < gCurCase->tblNum; ++t) { + if (gCurCase->tblNum > 1) { + sprintf(buf, "%s%d", bpTbPrefix, t); + } else { + sprintf(buf, "%s%d", bpTbPrefix, 0); + } + + prepareCheckResultImpl( + taos, buf, gCaseCtrl.printRes, + gCurCase->duplicateValue ? (gCurCase->rowNum * gExecLoopTimes / 2) : (gCurCase->rowNum * gExecLoopTimes), + silent); + } + + gExecLoopTimes = 1; +} + +// 120table 60 record each table +int sql_perf1(TAOS *taos) { + char *sql[3000] = {0}; + TAOS_RES *result; + + for (int i = 0; i < 3000; i++) { + sql[i] = taosMemoryCalloc(1, 1048576); + } + + int len = 0; + int tss = 0; + for (int l = 0; l < 3000; ++l) { + len = sprintf(sql[l], "insert into "); + for (int t = 0; t < 120; ++t) { + len += sprintf(sql[l] + len, "m%d values ", t); + for (int m = 0; m < 60; ++m) { + len += sprintf(sql[l] + len, + "(%d, %d, %d, %d, %d, %d, %f, %f, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", " + "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\") ", + tss++, m, m, m, m, m, m + 1.0, m + 1.0); + } + } + } + + int64_t starttime = taosGetTimestampUs(); + for (int i = 0; i < 3000; ++i) { + result = taos_query(taos, sql[i]); + int code = taos_errno(result); + if (code != 0) { + printf("%d failed to query table, reason:%s\n", taos_errstr(result)); + taos_free_result(result); + exit(1); + } + + taos_free_result(result); + } + int64_t endtime = taosGetTimestampUs(); + printf("insert total %d records, used %u seconds, avg:%.1f useconds\n", 3000 * 120 * 60, + (endtime - starttime) / 1000000UL, (endtime - starttime) / (3000 * 120 * 60)); + + for (int i = 0; i < 3000; i++) { + taosMemoryFree(sql[i]); + } + + return 0; +} + +// one table 60 records one time +int sql_perf_s1(TAOS *taos) { + char **sql = calloc(1, sizeof(char *) * 360000); + TAOS_RES *result; + + for (int i = 0; i < 360000; i++) { + sql[i] = taosMemoryCalloc(1, 9000); + } + + int len = 0; + int tss = 0; + int id = 0; + for (int t = 0; t < 120; ++t) { + for (int l = 0; l < 3000; ++l) { + len = sprintf(sql[id], "insert into m%d values ", t); + for (int m = 0; m < 60; ++m) { + len += sprintf(sql[id] + len, + "(%d, %d, %d, %d, %d, %d, %f, %f, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", " + "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\") ", + tss++, m, m, m, m, m, m + 1.0, m + 1.0); + } + if (len >= 9000) { + printf("sql:%s,len:%d\n", sql[id], len); + exit(1); + } + ++id; + } + } + + unsigned long long starttime = taosGetTimestampUs(); + for (int i = 0; i < 360000; ++i) { + result = taos_query(taos, sql[i]); + int code = taos_errno(result); + if (code != 0) { + printf("failed to query table, reason:%s\n", taos_errstr(result)); + taos_free_result(result); + exit(1); + } + + taos_free_result(result); + } + unsigned long long endtime = taosGetTimestampUs(); + printf("insert total %d records, used %u seconds, avg:%.1f useconds\n", 3000 * 120 * 60, + (endtime - starttime) / 1000000UL, (endtime - starttime) / (3000 * 120 * 60)); + + for (int i = 0; i < 360000; i++) { + taosMemoryFree(sql[i]); + } + + taosMemoryFree(sql); + + return 0; +} + +// small record size +int sql_s_perf1(TAOS *taos) { + char *sql[3000] = {0}; + TAOS_RES *result; + + for (int i = 0; i < 3000; i++) { + sql[i] = taosMemoryCalloc(1, 1048576); + } + + int len = 0; + int tss = 0; + for (int l = 0; l < 3000; ++l) { + len = sprintf(sql[l], "insert into "); + for (int t = 0; t < 120; ++t) { + len += sprintf(sql[l] + len, "m%d values ", t); + for (int m = 0; m < 60; ++m) { + len += sprintf(sql[l] + len, "(%d, %d) ", tss++, m % 2); + } + } + } + + unsigned long long starttime = taosGetTimestampUs(); + for (int i = 0; i < 3000; ++i) { + result = taos_query(taos, sql[i]); + int code = taos_errno(result); + if (code != 0) { + printf("failed to query table, reason:%s\n", taos_errstr(result)); + taos_free_result(result); + exit(1); + } + + taos_free_result(result); + } + unsigned long long endtime = taosGetTimestampUs(); + printf("insert total %d records, used %u seconds, avg:%.1f useconds\n", 3000 * 120 * 60, + (endtime - starttime) / 1000000UL, (endtime - starttime) / (3000 * 120 * 60)); + + for (int i = 0; i < 3000; i++) { + taosMemoryFree(sql[i]); + } + + return 0; +} + +void generateCreateTableSQL(char *buf, int32_t tblIdx, int32_t colNum, int32_t *colList, int32_t tableType) { + int32_t blen = 0; + blen = sprintf(buf, "create table %s%d ", (1 == tableType ? bpStbPrefix : bpTbPrefix), tblIdx); + + if (tableType == 3) { + blen += sprintf(buf + blen, "using %s%d", bpStbPrefix, bpDefaultStbId); + } + + if (tableType == 0 || tableType == 1) { + blen += sprintf(buf + blen, " ("); + + for (int c = 0; c < colNum; ++c) { + if (c > 0) { + blen += sprintf(buf + blen, ","); + } + + switch (colList[c]) { + case TSDB_DATA_TYPE_BOOL: + blen += sprintf(buf + blen, "booldata bool"); + break; + case TSDB_DATA_TYPE_TINYINT: + blen += sprintf(buf + blen, "tinydata tinyint"); + break; + case TSDB_DATA_TYPE_SMALLINT: + blen += sprintf(buf + blen, "smalldata smallint"); + break; + case TSDB_DATA_TYPE_INT: + blen += sprintf(buf + blen, "intdata int"); + break; + case TSDB_DATA_TYPE_BIGINT: + blen += sprintf(buf + blen, "bigdata bigint"); + break; + case TSDB_DATA_TYPE_FLOAT: + blen += sprintf(buf + blen, "floatdata float"); + break; + case TSDB_DATA_TYPE_DOUBLE: + blen += sprintf(buf + blen, "doubledata double"); + break; + case TSDB_DATA_TYPE_VARCHAR: + blen += sprintf(buf + blen, "binarydata binary(%d)", gVarCharSize); + break; + case TSDB_DATA_TYPE_TIMESTAMP: + blen += sprintf(buf + blen, "ts timestamp"); + break; + case TSDB_DATA_TYPE_NCHAR: + blen += sprintf(buf + blen, "nchardata nchar(%d)", gVarCharSize); + break; + case TSDB_DATA_TYPE_UTINYINT: + blen += sprintf(buf + blen, "utinydata tinyint unsigned"); + break; + case TSDB_DATA_TYPE_USMALLINT: + blen += sprintf(buf + blen, "usmalldata smallint unsigned"); + break; + case TSDB_DATA_TYPE_UINT: + blen += sprintf(buf + blen, "uintdata int unsigned"); + break; + case TSDB_DATA_TYPE_UBIGINT: + blen += sprintf(buf + blen, "ubigdata bigint unsigned"); + break; + default: + printf("invalid col type:%d", colList[c]); + exit(1); + } + } + + blen += sprintf(buf + blen, ")"); + } + + if (1 == tableType) { + blen += sprintf(buf + blen, " tags ("); + for (int c = 0; c < colNum; ++c) { + if (c > 0) { + blen += sprintf(buf + blen, ","); + } + switch (colList[c]) { + case TSDB_DATA_TYPE_BOOL: + blen += sprintf(buf + blen, "tbooldata bool"); + break; + case TSDB_DATA_TYPE_TINYINT: + blen += sprintf(buf + blen, "ttinydata tinyint"); + break; + case TSDB_DATA_TYPE_SMALLINT: + blen += sprintf(buf + blen, "tsmalldata smallint"); + break; + case TSDB_DATA_TYPE_INT: + blen += sprintf(buf + blen, "tintdata int"); + break; + case TSDB_DATA_TYPE_BIGINT: + blen += sprintf(buf + blen, "tbigdata bigint"); + break; + case TSDB_DATA_TYPE_FLOAT: + blen += sprintf(buf + blen, "tfloatdata float"); + break; + case TSDB_DATA_TYPE_DOUBLE: + blen += sprintf(buf + blen, "tdoubledata double"); + break; + case TSDB_DATA_TYPE_VARCHAR: + blen += sprintf(buf + blen, "tbinarydata binary(%d)", gVarCharSize); + break; + case TSDB_DATA_TYPE_TIMESTAMP: + blen += sprintf(buf + blen, "tts timestamp"); + break; + case TSDB_DATA_TYPE_NCHAR: + blen += sprintf(buf + blen, "tnchardata nchar(%d)", gVarCharSize); + break; + case TSDB_DATA_TYPE_UTINYINT: + blen += sprintf(buf + blen, "tutinydata tinyint unsigned"); + break; + case TSDB_DATA_TYPE_USMALLINT: + blen += sprintf(buf + blen, "tusmalldata smallint unsigned"); + break; + case TSDB_DATA_TYPE_UINT: + blen += sprintf(buf + blen, "tuintdata int unsigned"); + break; + case TSDB_DATA_TYPE_UBIGINT: + blen += sprintf(buf + blen, "tubigdata bigint unsigned"); + break; + default: + printf("invalid col type:%d", colList[c]); + exit(1); + } + } + + blen += sprintf(buf + blen, ")"); + } + + if (3 == tableType) { + blen += sprintf(buf + blen, " tags ("); + for (int c = 0; c < colNum; ++c) { + if (c > 0) { + blen += sprintf(buf + blen, ","); + } + switch (colList[c]) { + case TSDB_DATA_TYPE_BOOL: + blen += sprintf(buf + blen, "%s", rand() % 2 ? "true" : "false"); + break; + case TSDB_DATA_TYPE_TINYINT: + blen += sprintf(buf + blen, "%d", rand() % 128); + break; + case TSDB_DATA_TYPE_SMALLINT: + blen += sprintf(buf + blen, "%d", rand() % 128); + break; + case TSDB_DATA_TYPE_INT: + blen += sprintf(buf + blen, "%d", rand() % 128); + break; + case TSDB_DATA_TYPE_BIGINT: + blen += sprintf(buf + blen, "%d", rand() % 128); + break; + case TSDB_DATA_TYPE_FLOAT: + blen += sprintf(buf + blen, "%f", rand() % 128); + break; + case TSDB_DATA_TYPE_DOUBLE: + blen += sprintf(buf + blen, "%f", rand() % 128); + break; + case TSDB_DATA_TYPE_VARCHAR: + blen += sprintf(buf + blen, "'var%d'", rand() % 128); + break; + case TSDB_DATA_TYPE_TIMESTAMP: + blen += sprintf(buf + blen, "%lld", bpTs); + break; + case TSDB_DATA_TYPE_NCHAR: + blen += sprintf(buf + blen, "'nch%d'", rand() % 128); + break; + case TSDB_DATA_TYPE_UTINYINT: + blen += sprintf(buf + blen, "%d", rand() % 128); + break; + case TSDB_DATA_TYPE_USMALLINT: + blen += sprintf(buf + blen, "%d", rand() % 128); + break; + case TSDB_DATA_TYPE_UINT: + blen += sprintf(buf + blen, "%d", rand() % 128); + break; + case TSDB_DATA_TYPE_UBIGINT: + blen += sprintf(buf + blen, "%d", rand() % 128); + break; + default: + printf("invalid col type:%d", colList[c]); + exit(1); + } + } + + blen += sprintf(buf + blen, ")"); + } + + if (gCaseCtrl.printCreateTblSql) { + printf("\tCreate Table SQL:%s\n", buf); + } +} + +char *bpPrecisionStr(uint8_t precision) { + switch (precision) { + case TIME_PRECISION_MILLI: + return "ms"; + case TIME_PRECISION_MICRO: + return "us"; + case TIME_PRECISION_NANO: + return "ns"; + default: + return "unknwon"; + } +} + +void bpSetStartupTs() { + switch (gCaseCtrl.precision) { + case TIME_PRECISION_MILLI: + bpTs = BP_STARTUP_TS; + break; + case TIME_PRECISION_MICRO: + bpTs = BP_STARTUP_TS * 1000; + break; + case TIME_PRECISION_NANO: + bpTs = BP_STARTUP_TS * 1000000; + break; + default: + bpTs = BP_STARTUP_TS; + break; + } +} + +void prepare(TAOS *taos, int32_t colNum, int32_t *colList, int prepareStb) { + TAOS_RES *result; + int code; + char createDbSql[128] = {0}; + + result = taos_query(taos, "drop database demo"); + taos_free_result(result); + + sprintf(createDbSql, "create database demo keep 36500 precision \"%s\"", bpPrecisionStr(gCaseCtrl.precision)); + printf("\tCreate Database SQL:%s\n", createDbSql); + + result = taos_query(taos, createDbSql); + code = taos_errno(result); + if (code != 0) { + printf("!!!failed to create database, reason:%s\n", taos_errstr(result)); + taos_free_result(result); + exit(1); + } + taos_free_result(result); + + result = taos_query(taos, "use demo"); + taos_free_result(result); + + if (0 == prepareStb) { + // create table + for (int i = 0; i < 10; i++) { + char buf[1024]; + generateCreateTableSQL(buf, i, colNum, colList, 0); + result = taos_query(taos, buf); + code = taos_errno(result); + if (code != 0) { + printf("!!!failed to create table, reason:%s\n", taos_errstr(result)); + taos_free_result(result); + exit(1); + } + taos_free_result(result); + } + } else { + if (1 == prepareStb || 3 == prepareStb) { + char buf[1024]; + generateCreateTableSQL(buf, bpDefaultStbId, colNum, colList, 1); + + result = taos_query(taos, buf); + code = taos_errno(result); + if (code != 0) { + printf("!!!failed to create table, reason:%s\n", taos_errstr(result)); + taos_free_result(result); + exit(1); + } + taos_free_result(result); + } + + if (3 == prepareStb) { + for (int i = 0; i < 10; i++) { + char buf[1024]; + generateCreateTableSQL(buf, i, colNum, colList, 3); + result = taos_query(taos, buf); + code = taos_errno(result); + if (code != 0) { + printf("!!!failed to create table, reason:%s\n", taos_errstr(result)); + taos_free_result(result); + exit(1); + } + taos_free_result(result); + } + } + } +} + +int32_t runCase(TAOS *taos, int32_t caseIdx, int32_t caseRunIdx, bool silent) { + TAOS_STMT2 *stmt = NULL; + int64_t beginUs, endUs, totalUs; + CaseCfg cfg = gCase[caseIdx]; + CaseCfg cfgBk; + gCurCase = &cfg; + + bpSetStartupTs(); + + if ((gCaseCtrl.bindColTypeNum || gCaseCtrl.bindColNum) && (gCurCase->colNum != gFullColNum)) { + return 1; + } + + if (gCurCase->preCaseIdx >= 0) { + bool printRes = gCaseCtrl.printRes; + bool printStmtSql = gCaseCtrl.printStmtSql; + gCaseCtrl.printRes = false; + gCaseCtrl.printStmtSql = false; + runCase(taos, gCurCase->preCaseIdx, caseRunIdx, true); + gCaseCtrl.printRes = printRes; + gCaseCtrl.printStmtSql = printStmtSql; + + gCurCase = &cfg; + } + + if (gCaseCtrl.runTimes) { + gCurCase->runTimes = gCaseCtrl.runTimes; + } + + if (gCaseCtrl.rowNum) { + gCurCase->rowNum = gCaseCtrl.rowNum; + } + + if (gCaseCtrl.autoCreateTbl) { + if (gCurCase->testType == TTYPE_INSERT && gCurCase->tblNum > 1) { + gCurCase->autoCreateTbl = 1; + if (gCurCase->bindTagNum <= 0) { + gCurCase->bindTagNum = gCurCase->colNum; + } + } else { + return 1; + } + } + + if (gCurCase->fullCol) { + gCurCase->bindColNum = gCurCase->colNum; + if (gCurCase->autoCreateTbl) { + gCurCase->bindTagNum = gCurCase->colNum; + } + } + + gCurCase->bindNullNum = gCaseCtrl.bindNullNum; + if (gCaseCtrl.bindColNum) { + gCurCase->bindColNum = gCaseCtrl.bindColNum; + gCurCase->fullCol = false; + } + if (gCaseCtrl.bindTagNum) { + gCurCase->bindTagNum = gCaseCtrl.bindTagNum; + gCurCase->fullCol = false; + } + if (gCaseCtrl.bindRowNum) { + gCurCase->bindRowNum = gCaseCtrl.bindRowNum; + } + if (gCaseCtrl.bindColTypeNum) { + gCurCase->bindColNum = gCaseCtrl.bindColTypeNum; + gCurCase->fullCol = false; + } + if (gCaseCtrl.bindTagTypeNum) { + gCurCase->bindTagNum = gCaseCtrl.bindTagTypeNum; + gCurCase->fullCol = false; + } + + if (!silent) { + printf("* Case %d - [%s]%s Begin *\n", caseRunIdx, gCaseCtrl.caseCatalog, gCurCase->caseDesc); + } + + totalUs = 0; + cfgBk = cfg; + for (int32_t n = 0; n < gCurCase->runTimes; ++n) { + if (gCurCase->preCaseIdx < 0) { + prepare(taos, gCurCase->colNum, gCurCase->colList, gCurCase->autoCreateTbl); + } + + beginUs = taosGetTimestampUs(); + + stmt = st_stmt2_init(taos, gCurCase->stbInsert); + if (!stmt) { + printf("!!!st_stmt2_init failed, error:%s\n", st_stmt2_error(stmt)); + exit(1); + } + + (*gCurCase->runFn)(stmt, taos); + + (void)st_stmt2_close(stmt); + + endUs = taosGetTimestampUs(); + totalUs += (endUs - beginUs); + + prepareCheckResult(taos, silent); + + cfg = cfgBk; + } + + if (!silent) { + printf("* Case %d - [%s]%s [AvgTime:%.3fms] End *\n", caseRunIdx, gCaseCtrl.caseCatalog, gCurCase->caseDesc, + ((double)totalUs) / 1000 / gCurCase->runTimes); + } + + return 0; +} + +void *runCaseList(TAOS *taos) { + static int32_t caseRunIdx = 0; + static int32_t caseRunNum = 0; + int32_t caseNum = 0; + int32_t caseIdx = (gCaseCtrl.caseIdx >= 0) ? gCaseCtrl.caseIdx : 0; + + for (int32_t i = caseIdx; i < sizeof(gCase) / sizeof(gCase[0]); ++i) { + if (gCaseCtrl.caseNum > 0 && caseNum >= gCaseCtrl.caseNum) { + break; + } + + if (gCaseCtrl.caseRunNum > 0 && caseRunNum >= gCaseCtrl.caseRunNum) { + break; + } + + if (gCaseCtrl.caseRunIdx >= 0 && caseRunIdx < gCaseCtrl.caseRunIdx) { + caseRunIdx++; + continue; + } + + if (runCase(taos, i, caseRunIdx, false)) { + continue; + } + + caseRunIdx++; + caseNum++; + caseRunNum++; + } + + return NULL; +} + +void runAll(TAOS *taos) { + strcpy(gCaseCtrl.caseCatalog, "Default Test"); + printf("%s Begin\n", gCaseCtrl.caseCatalog); + runCaseList(taos); + +#if 1 + strcpy(gCaseCtrl.caseCatalog, "Micro DB precision Test"); + printf("%s Begin\n", gCaseCtrl.caseCatalog); + gCaseCtrl.precision = TIME_PRECISION_MICRO; + runCaseList(taos); + gCaseCtrl.precision = TIME_PRECISION_MILLI; + + strcpy(gCaseCtrl.caseCatalog, "Nano DB precision Test"); + printf("%s Begin\n", gCaseCtrl.caseCatalog); + gCaseCtrl.precision = TIME_PRECISION_NANO; + runCaseList(taos); + gCaseCtrl.precision = TIME_PRECISION_MILLI; + + strcpy(gCaseCtrl.caseCatalog, "Auto Create Table Test"); + gCaseCtrl.autoCreateTbl = true; + printf("%s Begin\n", gCaseCtrl.caseCatalog); + runCaseList(taos); + gCaseCtrl.autoCreateTbl = false; + + strcpy(gCaseCtrl.caseCatalog, "Null Test"); + printf("%s Begin\n", gCaseCtrl.caseCatalog); + gCaseCtrl.bindNullNum = 1; + runCaseList(taos); + gCaseCtrl.bindNullNum = 0; + + strcpy(gCaseCtrl.caseCatalog, "Bind Row Test"); + printf("%s Begin\n", gCaseCtrl.caseCatalog); + gCaseCtrl.bindRowNum = 1; + runCaseList(taos); + gCaseCtrl.bindRowNum = 0; + + strcpy(gCaseCtrl.caseCatalog, "Row Num Test"); + printf("%s Begin\n", gCaseCtrl.caseCatalog); + gCaseCtrl.rowNum = 1000; + gCaseCtrl.printRes = false; + runCaseList(taos); + gCaseCtrl.rowNum = 0; + gCaseCtrl.printRes = true; + + strcpy(gCaseCtrl.caseCatalog, "Runtimes Test"); + printf("%s Begin\n", gCaseCtrl.caseCatalog); + gCaseCtrl.runTimes = 2; + runCaseList(taos); + gCaseCtrl.runTimes = 0; + + strcpy(gCaseCtrl.caseCatalog, "Check Param Test"); + printf("%s Begin\n", gCaseCtrl.caseCatalog); + gCaseCtrl.checkParamNum = true; + runCaseList(taos); + gCaseCtrl.checkParamNum = false; + + strcpy(gCaseCtrl.caseCatalog, "Bind Col Num Test"); + printf("%s Begin\n", gCaseCtrl.caseCatalog); + gCaseCtrl.bindColNum = 6; + runCaseList(taos); + gCaseCtrl.bindColNum = 0; + +#endif + + /* + strcpy(gCaseCtrl.caseCatalog, "Bind Col Type Test"); + printf("%s Begin\n", gCaseCtrl.caseCatalog); + gCaseCtrl.bindColTypeNum = tListLen(bindColTypeList); + gCaseCtrl.bindColTypeList = bindColTypeList; + runCaseList(taos); + */ + + printf("All Test End\n"); +} + +int main(int argc, char *argv[]) { + TAOS *taos = NULL; + + srand((unsigned int)time(NULL)); + + // connect to server + if (argc < 2) { + printf("please input server ip \n"); + return 0; + } + + taos = taos_connect(argv[1], "root", "taosdata", NULL, 0); + if (taos == NULL) { + printf("failed to connect to db, reason:%s\n", taos_errstr(taos)); + exit(1); + } + + runAll(taos); + + taos_close(taos); + + return 0; +} diff --git a/tests/script/api/stmt2.c b/tests/script/api/stmt2.c new file mode 100644 index 0000000000..82537905dc --- /dev/null +++ b/tests/script/api/stmt2.c @@ -0,0 +1,323 @@ +// sample code to verify all TDengine API +// to compile: gcc -o apitest apitest.c -ltaos + +#include +#include +#include +#include +#include "taos.h" +static int64_t count = 10000; + +int64_t genReqid() { + count += 100; + return count; +} + +void stmtAsyncQueryCb(void* param, TAOS_RES* pRes, int code) { + int affected_rows = taos_affected_rows(pRes); + return; + /* + SSP_CB_PARAM* qParam = (SSP_CB_PARAM*)param; + if (code == 0 && pRes) { + if (qParam->fetch) { + taos_fetch_rows_a(pRes, sqAsyncFetchCb, param); + } else { + if (qParam->free) { + taos_free_result(pRes); + } + *qParam->end = 1; + } + } else { + sqError("select", taos_errstr(pRes)); + *qParam->end = 1; + taos_free_result(pRes); + } + */ +} + +void veriry_stmt(TAOS* taos) { + TAOS_RES* result = taos_query(taos, "drop database if exists test;"); + taos_free_result(result); + usleep(100000); + result = taos_query(taos, "create database test;"); + + int code = taos_errno(result); + if (code != 0) { + printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result)); + taos_free_result(result); + return; + } + taos_free_result(result); + + usleep(100000); + taos_select_db(taos, "test"); + + // create table + /* + const char* sql = + "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin " + "binary(40), blob nchar(10))"; + */ + const char* sql = + "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, blob2 " + "nchar(10), blob nchar(10))"; + result = taos_query(taos, sql); + code = taos_errno(result); + if (code != 0) { + printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result)); + taos_free_result(result); + return; + } + taos_free_result(result); + + // insert 10 records + struct { + int64_t ts[10]; + int8_t b[10]; + int8_t v1[10]; + int16_t v2[10]; + int32_t v4[10]; + int64_t v8[10]; + float f4[10]; + double f8[10]; + char bin[10][40]; + char blob[10][80]; + char blob2[10][80]; + } v; + + int32_t* t8_len = malloc(sizeof(int32_t) * 10); + int32_t* t16_len = malloc(sizeof(int32_t) * 10); + int32_t* t32_len = malloc(sizeof(int32_t) * 10); + int32_t* t64_len = malloc(sizeof(int32_t) * 10); + int32_t* float_len = malloc(sizeof(int32_t) * 10); + int32_t* double_len = malloc(sizeof(int32_t) * 10); + int32_t* bin_len = malloc(sizeof(int32_t) * 10); + int32_t* blob_len = malloc(sizeof(int32_t) * 10); + int32_t* blob_len2 = malloc(sizeof(int32_t) * 10); + +#include "time.h" + clock_t start, end; + TAOS_STMT2_OPTION option = {0, true, true, stmtAsyncQueryCb, NULL}; + + start = clock(); + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + end = clock(); + printf("init time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + // TAOS_MULTI_BIND params[10]; + TAOS_STMT2_BIND params[10]; + char is_null[10] = {0}; + + params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP; + // params[0].buffer_length = sizeof(v.ts[0]); + params[0].buffer = v.ts; + params[0].length = t64_len; + params[0].is_null = is_null; + params[0].num = 10; + + params[1].buffer_type = TSDB_DATA_TYPE_BOOL; + // params[1].buffer_length = sizeof(v.b[0]); + params[1].buffer = v.b; + params[1].length = t8_len; + params[1].is_null = is_null; + params[1].num = 10; + + params[2].buffer_type = TSDB_DATA_TYPE_TINYINT; + // params[2].buffer_length = sizeof(v.v1[0]); + params[2].buffer = v.v1; + params[2].length = t8_len; + params[2].is_null = is_null; + params[2].num = 10; + + params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT; + // params[3].buffer_length = sizeof(v.v2[0]); + params[3].buffer = v.v2; + params[3].length = t16_len; + params[3].is_null = is_null; + params[3].num = 10; + + params[4].buffer_type = TSDB_DATA_TYPE_INT; + // params[4].buffer_length = sizeof(v.v4[0]); + params[4].buffer = v.v4; + params[4].length = t32_len; + params[4].is_null = is_null; + params[4].num = 10; + + params[5].buffer_type = TSDB_DATA_TYPE_BIGINT; + // params[5].buffer_length = sizeof(v.v8[0]); + params[5].buffer = v.v8; + params[5].length = t64_len; + params[5].is_null = is_null; + params[5].num = 10; + + params[6].buffer_type = TSDB_DATA_TYPE_FLOAT; + // params[6].buffer_length = sizeof(v.f4[0]); + params[6].buffer = v.f4; + params[6].length = float_len; + params[6].is_null = is_null; + params[6].num = 10; + + params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE; + // params[7].buffer_length = sizeof(v.f8[0]); + params[7].buffer = v.f8; + params[7].length = double_len; + params[7].is_null = is_null; + params[7].num = 10; + /* + params[8].buffer_type = TSDB_DATA_TYPE_BINARY; + //params[8].buffer_length = sizeof(v.bin[0]); + params[8].buffer = v.bin; + params[8].length = bin_len; + params[8].is_null = is_null; + params[8].num = 10; + */ + params[8].buffer_type = TSDB_DATA_TYPE_NCHAR; + // params[8].buffer_length = sizeof(v.blob2[0]); + params[8].buffer = v.blob2; + params[8].length = blob_len2; + params[8].is_null = is_null; + params[8].num = 10; + + params[9].buffer_type = TSDB_DATA_TYPE_NCHAR; + // params[9].buffer_length = sizeof(v.blob[0]); + params[9].buffer = v.blob; + params[9].length = blob_len; + params[9].is_null = is_null; + params[9].num = 10; + + sql = "insert into ? (ts, b, v1, v2, v4, v8, f4, f8, blob2, blob) values(?,?,?,?,?,?,?,?,?,?)"; + start = clock(); + code = taos_stmt2_prepare(stmt, sql, 0); + end = clock(); + printf("prepare time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt_close(stmt); + return; + } + /* + code = taos_stmt_set_tbname(stmt, "m1"); + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt_close(stmt); + return; + } + */ + + int64_t ts = 1591060628000; + for (int i = 0; i < 10; ++i) { + is_null[i] = 0; + + v.ts[i] = ts++; + v.b[i] = (int8_t)i % 2; + v.v1[i] = (int8_t)i; + v.v2[i] = (int16_t)(i * 2); + v.v4[i] = (int32_t)(i * 4); + v.v8[i] = (int64_t)(i * 8); + v.f4[i] = (float)(i * 40); + v.f8[i] = (double)(i * 80); + for (int j = 0; j < sizeof(v.bin[0]); ++j) { + v.bin[i][j] = (char)(i + '0'); + } + strcpy(v.blob2[i], "一二三四五六七十九八"); + strcpy(v.blob[i], "一二三四五六七八九十"); + + t8_len[i] = sizeof(int8_t); + t16_len[i] = sizeof(int16_t); + t32_len[i] = sizeof(int32_t); + t64_len[i] = sizeof(int64_t); + float_len[i] = sizeof(float); + double_len[i] = sizeof(double); + bin_len[i] = sizeof(v.bin[0]); + blob_len[i] = (int32_t)strlen(v.blob[i]); + blob_len2[i] = (int32_t)strlen(v.blob2[i]); + } + + char* tbname = "m1"; + TAOS_STMT2_BIND* bind_cols[1] = {¶ms[0]}; + TAOS_STMT2_BINDV bindv = {1, &tbname, NULL, &bind_cols[0]}; + start = clock(); + // taos_stmt2_bind_param(stmt, "m1", NULL, params, -1); + taos_stmt2_bind_param(stmt, &bindv, -1); + end = clock(); + printf("bind time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + // taos_stmt_bind_param_batch(stmt, params); + // taos_stmt_add_batch(stmt); + /* + int param_count = -1; + code = taos_stmt2_param_count(stmt, ¶m_count); + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_param_count. error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt_close(stmt); + return; + } + printf("param_count: %d\n", param_count); + */ + TAOS_FIELD_E* fields = NULL; + int field_count = -1; + start = clock(); + code = taos_stmt2_get_fields(stmt, TAOS_FIELD_COL, &field_count, NULL); + end = clock(); + printf("get fields time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_param_count. error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt_close(stmt); + return; + } + printf("col field_count: %d\n", field_count); + start = clock(); + taos_stmt2_free_fields(stmt, fields); + end = clock(); + printf("free time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + /* + code = taos_stmt2_get_fields(stmt, TAOS_FIELD_TAG, &field_count, &fields); + if (code != 0) { + printf("\033[31mfailed to execute taos_stmt_param_count. error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt_close(stmt); + return; + } + printf("tag field_count: %d\n", field_count); + taos_stmt2_free_fields(stmt, fields); + */ + // if (taos_stmt_execute(stmt) != 0) { + start = clock(); + // if (taos_stmt2_exec(stmt, NULL, stmtAsyncQueryCb, NULL) != 0) { + if (taos_stmt2_exec(stmt, NULL) != 0) { + printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt)); + taos_stmt2_close(stmt); + return; + } + end = clock(); + printf("exec time:%f\n", (double)(end - start) / CLOCKS_PER_SEC); + + taos_stmt2_close(stmt); + + free(t8_len); + free(t16_len); + free(t32_len); + free(t64_len); + free(float_len); + free(double_len); + free(bin_len); + free(blob_len); + free(blob_len2); +} + +int main(int argc, char* argv[]) { + const char* host = "127.0.0.1"; + const char* user = "root"; + const char* passwd = "taosdata"; + + taos_options(TSDB_OPTION_TIMEZONE, "GMT-8"); + TAOS* taos = taos_connect(host, user, passwd, "", 0); + if (taos == NULL) { + printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(taos)); + exit(1); + } + + printf("********* verify stmt query **********\n"); + veriry_stmt(taos); + + printf("done\n"); + taos_close(taos); + taos_cleanup(); +} diff --git a/tools/shell/src/shellEngine.c b/tools/shell/src/shellEngine.c index 7fdfd29542..84da746afd 100644 --- a/tools/shell/src/shellEngine.c +++ b/tools/shell/src/shellEngine.c @@ -48,15 +48,15 @@ static char *shellFormatTimestamp(char *buf, int64_t val, int32_t precision); static int64_t shellDumpResultToFile(const char *fname, TAOS_RES *tres); static void shellPrintNChar(const char *str, int32_t length, int32_t width); static void shellPrintGeometry(const unsigned char *str, int32_t length, int32_t width); -static void shellVerticalPrintResult(TAOS_RES *tres, tsDumpInfo* dump_info); -static void shellHorizontalPrintResult(TAOS_RES *tres, tsDumpInfo* dump_info); +static void shellVerticalPrintResult(TAOS_RES *tres, tsDumpInfo *dump_info); +static void shellHorizontalPrintResult(TAOS_RES *tres, tsDumpInfo *dump_info); static int64_t shellDumpResult(TAOS_RES *tres, char *fname, int32_t *error_no, bool vertical, const char *sql); static void shellReadHistory(); static void shellWriteHistory(); static void shellPrintError(TAOS_RES *tres, int64_t st); static bool shellIsCommentLine(char *line); static void shellSourceFile(const char *file); -static bool shellGetGrantInfo(char* buf); +static bool shellGetGrantInfo(char *buf); static void shellCleanup(void *arg); static void *shellCancelHandler(void *arg); @@ -165,12 +165,12 @@ int32_t shellRunCommand(char *command, bool recordHistory) { // add help or help; if (strncasecmp(command, "help", 4) == 0) { - if(command[4] == ';' || command[4] == ' ' || command[4] == 0) { - showHelp(); - return 0; + if (command[4] == ';' || command[4] == ' ' || command[4] == 0) { + showHelp(); + return 0; } } - + if (recordHistory) shellRecordCommandToHistory(command); char quote = 0, *cmd = command; @@ -197,19 +197,18 @@ int32_t shellRunCommand(char *command, bool recordHistory) { return shellRunSingleCommand(cmd); } - -char * strendG(const char* pstr) { - if(pstr == NULL) { +char *strendG(const char *pstr) { + if (pstr == NULL) { return NULL; } size_t len = strlen(pstr); - if(len < 4) { + if (len < 4) { return NULL; } - char * p = (char *)pstr + len - 2; - if (strcmp(p, "\\G") == 0 ){ + char *p = (char *)pstr + len - 2; + if (strcmp(p, "\\G") == 0) { return p; } @@ -285,10 +284,11 @@ void shellRunSingleCommandImp(char *command) { et = taosGetTimestampUs(); if (error_no == 0) { - printf("Query OK, %"PRId64 " row(s) in set (%.6fs)\r\n", numOfRows, (et - st) / 1E6); + printf("Query OK, %" PRId64 " row(s) in set (%.6fs)\r\n", numOfRows, (et - st) / 1E6); } else { terrno = error_no; - printf("Query interrupted (%s), %"PRId64 " row(s) in set (%.6fs)\r\n", taos_errstr(NULL), numOfRows, (et - st) / 1E6); + printf("Query interrupted (%s), %" PRId64 " row(s) in set (%.6fs)\r\n", taos_errstr(NULL), numOfRows, + (et - st) / 1E6); } taos_free_result(pSql); } else { @@ -366,10 +366,10 @@ void shellDumpFieldToFile(TdFilePtr pFile, const char *val, TAOS_FIELD *field, i return; } - char quotationStr[2] ={'"', 0}; + char quotationStr[2] = {'"', 0}; int32_t width; - int n = 0; + int n = 0; #define LENGTH 64 char buf[LENGTH] = {0}; switch (field->type) { @@ -431,8 +431,8 @@ void shellDumpFieldToFile(TdFilePtr pFile, const char *val, TAOS_FIELD *field, i case TSDB_DATA_TYPE_NCHAR: case TSDB_DATA_TYPE_JSON: { int32_t bufIndex = 0; - char* tmp = (char*)taosMemoryCalloc(length * 2 + 1, 1); - if(tmp == NULL) break; + char *tmp = (char *)taosMemoryCalloc(length * 2 + 1, 1); + if (tmp == NULL) break; for (int32_t i = 0; i < length; i++) { tmp[bufIndex] = val[i]; bufIndex++; @@ -446,19 +446,19 @@ void shellDumpFieldToFile(TdFilePtr pFile, const char *val, TAOS_FIELD *field, i taosFprintfFile(pFile, "%s%s%s", quotationStr, tmp, quotationStr); taosMemoryFree(tmp); } break; - case TSDB_DATA_TYPE_VARBINARY:{ - void* tmp = NULL; + case TSDB_DATA_TYPE_VARBINARY: { + void *tmp = NULL; uint32_t size = 0; - if(taosAscii2Hex(val, length, &tmp, &size) < 0){ + if (taosAscii2Hex(val, length, &tmp, &size) < 0) { break; } taosFprintfFile(pFile, "%s%s%s", quotationStr, tmp, quotationStr); taosMemoryFree(tmp); break; } - case TSDB_DATA_TYPE_GEOMETRY:{ - char* tmp = (char*)taosMemoryCalloc(length * 2 + 1, 1); - if(tmp == NULL) break; + case TSDB_DATA_TYPE_GEOMETRY: { + char *tmp = (char *)taosMemoryCalloc(length * 2 + 1, 1); + if (tmp == NULL) break; shellDumpHexValue(tmp, val, length); taosFprintfFile(pFile, "%s", buf); taosMemoryFree(tmp); @@ -635,12 +635,12 @@ void shellPrintField(const char *val, TAOS_FIELD *field, int32_t width, int32_t return; } - int n = 0; -#define LENGTH 64 + int n = 0; +#define LENGTH 64 char buf[LENGTH] = {0}; switch (field->type) { case TSDB_DATA_TYPE_BOOL: - shellPrintString(((((int32_t)(*((char *)val))) == 1) ? "true" : "false"), width); + shellPrintString(((((int32_t)(*((char *)val))) == TSDB_FALSE) ? "false" : "true"), width); break; case TSDB_DATA_TYPE_TINYINT: printf("%*d", width, *((int8_t *)val)); @@ -680,7 +680,7 @@ void shellPrintField(const char *val, TAOS_FIELD *field, int32_t width, int32_t break; case TSDB_DATA_TYPE_DOUBLE: if (tsEnableScience) { - snprintf(buf, LENGTH, "%*.15e", width,GET_DOUBLE_VAL(val)); + snprintf(buf, LENGTH, "%*.15e", width, GET_DOUBLE_VAL(val)); printf("%s", buf); } else { n = snprintf(buf, LENGTH, "%*.15f", width, GET_DOUBLE_VAL(val)); @@ -691,10 +691,10 @@ void shellPrintField(const char *val, TAOS_FIELD *field, int32_t width, int32_t } } break; - case TSDB_DATA_TYPE_VARBINARY:{ - void* data = NULL; + case TSDB_DATA_TYPE_VARBINARY: { + void *data = NULL; uint32_t size = 0; - if(taosAscii2Hex(val, length, &data, &size) < 0){ + if (taosAscii2Hex(val, length, &data, &size) < 0) { break; } shellPrintNChar(data, size, width); @@ -867,7 +867,7 @@ int32_t shellCalcColWidth(TAOS_FIELD *field, int32_t precision) { } else { return TMAX(field->bytes + 2, width); } - case TSDB_DATA_TYPE_VARBINARY:{ + case TSDB_DATA_TYPE_VARBINARY: { int32_t bytes = field->bytes * 2 + 2; if (bytes > shell.args.displayWidth) { return TMAX(shell.args.displayWidth, width); @@ -1121,8 +1121,9 @@ void shellSourceFile(const char *file) { char *line = taosMemoryMalloc(TSDB_MAX_ALLOWED_SQL_LEN + 1); while ((read_len = taosGetsFile(pFile, TSDB_MAX_ALLOWED_SQL_LEN, line)) > 0) { - if ( cmd_len + read_len >= TSDB_MAX_ALLOWED_SQL_LEN) { - printf("read command line too long over 1M, ignore this line. cmd_len = %d read_len=%d \n", (int32_t)cmd_len, read_len); + if (cmd_len + read_len >= TSDB_MAX_ALLOWED_SQL_LEN) { + printf("read command line too long over 1M, ignore this line. cmd_len = %d read_len=%d \n", (int32_t)cmd_len, + read_len); cmd_len = 0; memset(line, 0, TSDB_MAX_ALLOWED_SQL_LEN + 1); continue; @@ -1156,7 +1157,7 @@ void shellSourceFile(const char *file) { taosCloseFile(&pFile); } -bool shellGetGrantInfo(char* buf) { +bool shellGetGrantInfo(char *buf) { bool community = true; char sinfo[256] = {0}; tstrncpy(sinfo, taos_get_server_info(shell.conn), sizeof(sinfo)); @@ -1207,8 +1208,7 @@ bool shellGetGrantInfo(char* buf) { sprintf(buf, "Server is %s, %s and will never expire.\r\n", serverVersion, sinfo); } else { community = false; - sprintf(buf, "Server is %s, %s and will expire at %s.\r\n", serverVersion, sinfo, - expiretime); + sprintf(buf, "Server is %s, %s and will expire at %s.\r\n", serverVersion, sinfo, expiretime); } taos_free_result(tres); @@ -1324,13 +1324,13 @@ int32_t shellExecute() { shellSetConn(shell.conn, runOnce); shellReadHistory(); - if(shell.args.is_bi_mode) { - // need set bi mode - printf("Set BI mode is true.\n"); + if (shell.args.is_bi_mode) { + // need set bi mode + printf("Set BI mode is true.\n"); #ifndef WEBSOCKET taos_set_conn_mode(shell.conn, TAOS_CONN_MODE_BI, 1); #endif - } + } if (runOnce) { if (pArgs->commands != NULL) { @@ -1373,22 +1373,22 @@ int32_t shellExecute() { #ifdef WEBSOCKET if (!shell.args.restful && !shell.args.cloud) { #endif -char* buf = taosMemoryMalloc(512); -bool community = shellGetGrantInfo(buf); + char *buf = taosMemoryMalloc(512); + bool community = shellGetGrantInfo(buf); #ifndef WINDOWS printfIntroduction(community); #else #ifndef WEBSOCKET - if(community) { + if (community) { showAD(false); } -#endif #endif -// printf version -if(!community) { - printf("%s\n", buf); -} -taosMemoryFree(buf); +#endif + // printf version + if (!community) { + printf("%s\n", buf); + } + taosMemoryFree(buf); #ifdef WEBSOCKET } @@ -1407,7 +1407,7 @@ taosMemoryFree(buf); if (community) { showAD(true); } -#endif +#endif taosThreadJoin(spid, NULL); diff --git a/tools/shell/src/shellMain.c b/tools/shell/src/shellMain.c index d3ca60ab87..71acf23e41 100644 --- a/tools/shell/src/shellMain.c +++ b/tools/shell/src/shellMain.c @@ -50,12 +50,14 @@ int main(int argc, char *argv[]) { shell.args.local = false; #endif +#if 0 #if !defined(WINDOWS) taosSetSignal(SIGBUS, shellCrashHandler); #endif taosSetSignal(SIGABRT, shellCrashHandler); taosSetSignal(SIGFPE, shellCrashHandler); taosSetSignal(SIGSEGV, shellCrashHandler); +#endif if (shellCheckIntSize() != 0) { return -1;