From 16a79dd86d1de701a779e551274787d0998d4dd4 Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Wed, 25 Dec 2024 10:59:37 +0800 Subject: [PATCH 01/13] add stmt test case --- source/client/test/CMakeLists.txt | 16 ++ source/client/test/stmt2Test.cpp | 417 ++++++++++++++++++++++++++++++ 2 files changed, 433 insertions(+) create mode 100644 source/client/test/stmt2Test.cpp diff --git a/source/client/test/CMakeLists.txt b/source/client/test/CMakeLists.txt index fecddbbff4..62b7bb3e91 100644 --- a/source/client/test/CMakeLists.txt +++ b/source/client/test/CMakeLists.txt @@ -41,6 +41,12 @@ TARGET_LINK_LIBRARIES( PUBLIC ${TAOS_LIB} ) +ADD_EXECUTABLE(stmt2Test stmt2Test.cpp) +TARGET_LINK_LIBRARIES( + stmt2Test + os util common transport parser catalog scheduler gtest ${TAOS_LIB_STATIC} qcom executor function +) + TARGET_INCLUDE_DIRECTORIES( clientTest PUBLIC "${TD_SOURCE_DIR}/include/client/" @@ -82,6 +88,12 @@ TARGET_INCLUDE_DIRECTORIES( # PRIVATE "${TD_SOURCE_DIR}/source/client/inc" #) +TARGET_INCLUDE_DIRECTORIES( + stmt2Test + PUBLIC "${TD_SOURCE_DIR}/include/client/" + PRIVATE "${TD_SOURCE_DIR}/source/client/inc" +) + add_test( NAME smlTest COMMAND smlTest @@ -97,3 +109,7 @@ add_test( COMMAND userOperTest ) +add_test( + NAME stmt2Test + COMMAND stmt2Test +) diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp new file mode 100644 index 0000000000..c325ed3a38 --- /dev/null +++ b/source/client/test/stmt2Test.cpp @@ -0,0 +1,417 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#include +#include +#include "clientInt.h" +#include "osSemaphore.h" +#include "taoserror.h" +#include "tglobal.h" +#include "thash.h" + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wwrite-strings" +#pragma GCC diagnostic ignored "-Wunused-function" +#pragma GCC diagnostic ignored "-Wunused-variable" +#pragma GCC diagnostic ignored "-Wsign-compare" + +#include "executor.h" +#include "taos.h" + +namespace { +void getFieldsSuccess(TAOS* taos, const char* sql, TAOS_FIELD_ALL* expectedFields, int expectedFieldNum) { + TAOS_STMT2_OPTION option = {0}; + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + int code = taos_stmt2_prepare(stmt, sql, 0); + ASSERT_EQ(code, 0); + + int fieldNum = 0; + TAOS_FIELD_ALL* pFields = NULL; + code = taos_stmt2_get_fields(stmt, &fieldNum, &pFields); + ASSERT_EQ(code, 0); + ASSERT_EQ(fieldNum, expectedFieldNum); + + for (int i = 0; i < fieldNum; i++) { + ASSERT_STREQ(pFields[i].name, expectedFields[i].name); + ASSERT_EQ(pFields[i].type, expectedFields[i].type); + ASSERT_EQ(pFields[i].field_type, expectedFields[i].field_type); + ASSERT_EQ(pFields[i].precision, expectedFields[i].precision); + ASSERT_EQ(pFields[i].bytes, expectedFields[i].bytes); + ASSERT_EQ(pFields[i].scale, expectedFields[i].scale); + } + taos_stmt2_free_fields(stmt, pFields); + taos_stmt2_close(stmt); +} + +void getQueryFields(TAOS* taos, const char* sql) { + TAOS_STMT2_OPTION option = {0}; + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + 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; + } + int fieldNum = 0; + TAOS_FIELD_ALL* pFields = NULL; + code = taos_stmt2_get_fields(stmt, &fieldNum, &pFields); + if (code != 0) { + printf("failed get col,ErrCode: 0x%x, ErrMessage: %s.\n", code, taos_stmt2_error(stmt)); + } else { + printf("bind nums:%d\n", fieldNum); + } + printf("====================================\n"); + taos_stmt2_free_fields(stmt, pFields); + taos_stmt2_close(stmt); +} + +void do_query(TAOS* taos, const char* sql) { + TAOS_RES* result = taos_query(taos, sql); + int code = taos_errno(result); + ASSERT_EQ(code, 0); + + taos_free_result(result); +} + +// void do_stmt(TAOS* taos) { + +// printf("=================error test===================\n"); + +// // case 14 : INSERT INTO db.d0 using db.stb values(?,?) +// // none para for ctbname +// sql = "INSERT INTO db.d0 using db.stb values(?,?)"; +// printf("case 14 (no tags error): %s\n", sql); +// getFields(taos, sql); + +// // case 15 : insert into db.stb(t1,t2,tbname) values(?,?,?) +// // no value +// sql = "insert into db.stb(t1,t2,tbname) values(?,?,?)"; +// printf("case 15 (no PK error): %s\n", sql); +// getFields(taos, sql); + +// // case 16 : insert into db.stb(ts,b,tbname) values(?,?,?,?,?) +// // wrong para nums +// sql = "insert into db.stb(ts,b,tbname) values(?,?,?,?,?)"; +// printf("case 16 (wrong para nums): %s\n", sql); +// getFields(taos, sql); + +// // case 17 : insert into db.? values(?,?) +// // normal table must have tbnam +// sql = "insert into db.? values(?,?)"; +// printf("case 17 (normal table must have tbname): %s\n", sql); +// getFields(taos, sql); + +// // case 18 : INSERT INTO db.stb(t1,t2,ts,b) values(?,?,?,?) +// // no tbname error +// sql = "INSERT INTO db.stb(t1,t2,ts,b) values(?,?,?,?)"; +// printf("case 18 (no tbname error): %s\n", sql); +// getFields(taos, sql); + +// // case 19 : insert into db.ntb(nts,ni) values(?,?,?,?,?) +// // wrong para nums +// sql = "insert into ntb(nts,ni) values(?,?,?,?,?)"; +// printf("case 19 : %s\n", sql); +// getFields(taos, sql); + +// // case 20 : insert into db.stb(t1,t2,ts,b,tbname) values(*,*,*,*,*) +// // wrong simbol +// sql = "insert into db.stb(t1,t2,ts,b,tbname) values(*,*,*,*,*)"; +// printf("=================normal test===================\n"); +// printf("case 20 : %s\n", sql); +// getFields(taos, sql); + +// // case 21 : INSERT INTO ! using db.stb TAGS(?,?) VALUES(?,?) +// // wrong simbol +// sql = "insert into ! using db.stb tags(?, ?) values(?,?)"; +// printf("case 21 : %s\n", sql); +// getFields(taos, sql); + +// // case 22 : INSERT INTO ! using db.stb TAGS(?,?) VALUES(?,?) +// // wrong tbname +// sql = "insert into db.stb values(?,?)"; +// printf("case 22 : %s\n", sql); +// getFields(taos, sql); + +// // case 23 : select * from ? where ts = ? +// // wrong query type +// sql = "select * from ? where ts = ?"; +// printf("case 23 : %s\n", sql); +// getQueryFields(taos, sql); +// } + +} // namespace + +int main(int argc, char** argv) { + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} + +TEST(clientCase, driverInit_Test) { + // taosInitGlobalCfg(); + // taos_init(); +} + +TEST(stmt2Case, insert_stb_get_fields_Test) { + TAOS* taos = taos_connect("localhost", "root", "taosdata", NULL, 0); + ASSERT_NE(taos, nullptr); + + do_query(taos, "drop database if exists db"); + do_query(taos, "create database db PRECISION 'ns'"); + do_query(taos, "use db"); + do_query(taos, + "create table db.stb (ts timestamp, b binary(10)) tags(t1 " + "int, t2 binary(10))"); + do_query( + taos, + "create table if not exists all_stb(ts timestamp, v1 bool, v2 tinyint, v3 smallint, v4 int, v5 bigint, v6 " + "tinyint unsigned, v7 smallint unsigned, v8 int unsigned, v9 bigint unsigned, v10 float, v11 double, v12 " + "binary(20), v13 varbinary(20), v14 geometry(100), v15 nchar(20))tags(tts timestamp, tv1 bool, tv2 tinyint, tv3 " + "smallint, tv4 int, tv5 bigint, tv6 tinyint unsigned, tv7 smallint unsigned, tv8 int unsigned, tv9 bigint " + "unsigned, tv10 float, tv11 double, tv12 binary(20), tv13 varbinary(20), tv14 geometry(100), tv15 nchar(20));"); + + // // case 1 : test super table + // { + // const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(?,?,?,?,?)"; + // TAOS_FIELD_ALL expectedFields[5] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + // {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}}; + // printf("case 1 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 5); + // } + + // case 2 : no tbname + { + const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(1,?,?,'abc',?)"; + TAOS_FIELD_ALL expectedFields[3] = {{"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}}; + printf("case 2 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 3); + } + + { + // case 3 : insert into db.stb(ts,b,tbname) values(?,?,?) + // no tag + const char* sql = "insert into db.stb(ts,b,tbname) values(?,?,?)"; + TAOS_FIELD_ALL expectedFields[3] = { + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + }; + printf("case 5 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 3); + } + + // case 12 : insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) + // values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) + // test all types + { + const char* sql = + "insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[33] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"tts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_TAG}, + {"tv1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_TAG}, + {"tv2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_TAG}, + {"tv3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, + {"tv4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"tv5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_TAG}, + {"tv6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_TAG}, + {"tv7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, + {"tv8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_TAG}, + {"tv9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_TAG}, + {"tv10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_TAG}, + {"tv11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_TAG}, + {"tv12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_TAG}, + {"tv13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_TAG}, + {"tv14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_TAG}, + {"tv15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"v1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_COL}, + {"v2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_COL}, + {"v3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_COL}, + {"v4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}, + {"v5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_COL}, + {"v6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_COL}, + {"v7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_COL}, + {"v8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_COL}, + {"v9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_COL}, + {"v10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_COL}, + {"v11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_COL}, + {"v12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_COL}, + {"v13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_COL}, + {"v14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_COL}, + {"v15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_COL}}; + printf("case 12 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 33); + } + + taos_close(taos); + taos_cleanup(); +} + +TEST(stmt2Case, insert_ctb_using_get_fields_Test) { + // do_query(taos, "CREATE TABLE db.d0 USING db.stb (t1,t2) TAGS (7,'Cali');"); + + // // case 2 : INSERT INTO db.d0 VALUES (?,?) + // // test child table + // { + // const char* sql = "INSERT INTO db.d0(ts,b) VALUES (?,?)"; + // TAOS_FIELD_ALL expectedFields[2] = {{"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + // printf("case 2 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 2); + // } + + // // case 6 : INSERT INTO db.? using db.stb (t1,t2)TAGS(?,?) (ts,b)VALUES(?,?) + // // normal insert clause + // { + // const char* sql = "INSERT INTO db.? using db.stb (t1,t2)TAGS(?,?) (ts,b)VALUES(?,?)"; + // TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + // {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + // printf("case 6 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 5); + // } + + // // case 7 : insert into db.? using db.stb(t2,t1) tags(?, ?) (b,ts)values(?,?) + // // disordered + // { + // const char* sql = "insert into db.? using db.stb(t2,t1) tags(?, ?) (b,ts)values(?,?)"; + // TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + // {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}}; + // printf("case 7 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 5); + // } + + // // case 8 : insert into db.? using db.stb tags(?, ?) values(?,?) + // // no field name + // { + // const char* sql = "insert into db.? using db.stb tags(?, ?) values(?,?)"; + // TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + // {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + // printf("case 8 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 5); + // } + + // // case 9 : insert into db.? using db.stb (t2)tags(?) (ts)values(?) + // // less para + // { + // const char* sql = "insert into db.? using db.stb (t2)tags(?) (ts)values(?)"; + // TAOS_FIELD_ALL expectedFields[3] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}}; + // printf("case 9 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 3); + // } + + // // case 10 : insert into db.d0 (ts)values(?) + // // less para + // { + // const char* sql = "insert into db.d0 (ts)values(?)"; + // TAOS_FIELD_ALL expectedFields[1] = {{"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}}; + // printf("case 10 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 1); + // } + // // case 11 : insert into abc using stb tags(?, ?) values(?,?) + // // insert create table + // { + // const char* sql = "insert into abc using stb tags(?, ?) values(?,?)"; + // TAOS_FIELD_ALL expectedFields[4] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + // printf("case 11 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 4); + // } + + // // // case 13 : insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) + // // values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) + // // // test all types + // // sql = + // // "insert into all_stb " + // // + // "(tbname,tts,tv1,tv2,tv3,tv4,tv5,tv6,tv7,tv8,tv9,tv10,tv11,tv12,tv13,tv14,tv15,ts,v1,v2,v3,v4,v5,v6,v7,v8,v9,v10," + // // "v11,v12,v13,v14,v15) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; + // // printf("case 13 : %s\n", sql); + // // getFields(taos, sql); +} + +TEST(stmt2Case, insert_ntb_get_fields_Test) { + // do_query(taos, "CREATE TABLE db.ntb(nts timestamp, nb binary(10),nvc varchar(16),ni int);"); + + // // // case 3 : INSERT INTO db.ntb VALUES(?,?,?,?) + // // // test normal table + // { + // const char* sql = "INSERT INTO db.ntb VALUES(?,?,?,?)"; + // TAOS_FIELD_ALL expectedFields[4] = {{"nts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + // {"nb", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + // {"nvc", TSDB_DATA_TYPE_BINARY, 0, 0, 18, TAOS_FIELD_COL}, + // {"ni", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}}; + // printf("case 3 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 4); + // } + + // { + // // case 4 : insert into db.stb(t1,tbname,ts,t2,b) values(?,?,?,?,?) + // // test random order + // const char* sql = "insert into db.stb(t1,tbname,ts,t2,b) values(?,?,?,?,?)"; + // TAOS_FIELD_ALL expectedFields[5] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + // {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + // printf("case 4 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 5); + // } +} + +TEST(stmt2Case, select_get_fields_Test) { + // // case 14 : select * from ntb where ts = ? + // // query type + // sql = "select * from ntb where ts = ?"; + // printf("case 14 : %s\n", sql); + // getQueryFields(taos, sql); + + // // case 15 : select * from ntb where ts = ? and b = ? + // // query type + // sql = "select * from ntb where ts = ? and b = ?"; + // printf("case 15 : %s\n", sql); + // getQueryFields(taos, sql); +} + +TEST(stmt2Case, db_get_fields_Test) {} + +TEST(stmt2Case, get_fields_error_Test) { + // { + // const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(1,?,?,'abc',?)"; + // TAOS_FIELD_ALL expectedFields[3] = {{"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + // {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}}; + // printf("case 2 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 3); + // } +} + +#pragma GCC diagnostic pop From 0d1a99d7d07bdf4c5e8a5c5f149e83326dd4e2e4 Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Thu, 26 Dec 2024 16:30:50 +0800 Subject: [PATCH 02/13] remove some unused code --- source/client/inc/clientStmt2.h | 3 - source/client/src/clientMain.c | 82 +++---- source/client/src/clientStmt2.c | 161 -------------- source/client/test/stmt2Test.cpp | 352 ++++++++++++++++++++++--------- 4 files changed, 281 insertions(+), 317 deletions(-) diff --git a/source/client/inc/clientStmt2.h b/source/client/inc/clientStmt2.h index 0fe813473d..05a4c849f8 100644 --- a/source/client/inc/clientStmt2.h +++ b/source/client/inc/clientStmt2.h @@ -221,11 +221,8 @@ 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 stmtGetStbColFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_ALL **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); diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c index f041e4b030..83aff351dd 100644 --- a/source/client/src/clientMain.c +++ b/source/client/src/clientMain.c @@ -24,13 +24,13 @@ #include "query.h" #include "scheduler.h" #include "tcompare.h" +#include "tconv.h" #include "tdatablock.h" #include "tglobal.h" #include "tmsg.h" #include "tref.h" #include "trpc.h" #include "version.h" -#include "tconv.h" #define TSC_VAR_NOT_RELEASE 1 #define TSC_VAR_RELEASED 0 @@ -56,12 +56,12 @@ int taos_options(TSDB_OPTION option, const void *arg, ...) { } #ifndef WINDOWS -static void freeTz(void *p){ +static void freeTz(void *p) { timezone_t tz = *(timezone_t *)p; tzfree(tz); } -int32_t tzInit(){ +int32_t tzInit() { pTimezoneMap = taosHashInit(0, MurmurHash3_32, false, HASH_ENTRY_LOCK); if (pTimezoneMap == NULL) { return terrno; @@ -75,15 +75,15 @@ int32_t tzInit(){ return 0; } -void tzCleanup(){ +void tzCleanup() { taosHashCleanup(pTimezoneMap); taosHashCleanup(pTimezoneNameMap); } -static timezone_t setConnnectionTz(const char* val){ - timezone_t tz = NULL; +static timezone_t setConnnectionTz(const char *val) { + timezone_t tz = NULL; timezone_t *tmp = taosHashGet(pTimezoneMap, val, strlen(val)); - if (tmp != NULL && *tmp != NULL){ + if (tmp != NULL && *tmp != NULL) { tz = *tmp; goto END; } @@ -100,20 +100,20 @@ static timezone_t setConnnectionTz(const char* val){ } } int32_t code = taosHashPut(pTimezoneMap, val, strlen(val), &tz, sizeof(timezone_t)); - if (code != 0){ + if (code != 0) { tscError("%s put timezone to tz map error:%d", __func__, code); tzfree(tz); tz = NULL; goto END; } - time_t tx1 = taosGetTimestampSec(); - char output[TD_TIMEZONE_LEN] = {0}; + time_t tx1 = taosGetTimestampSec(); + char output[TD_TIMEZONE_LEN] = {0}; code = taosFormatTimezoneStr(tx1, val, tz, output); - if (code == 0){ + if (code == 0) { code = taosHashPut(pTimezoneNameMap, &tz, sizeof(timezone_t), output, strlen(output) + 1); } - if (code != 0){ + if (code != 0) { tscError("failed to put timezone %s to map", val); } @@ -122,18 +122,18 @@ END: } #endif -static int32_t setConnectionOption(TAOS *taos, TSDB_OPTION_CONNECTION option, const char* val){ +static int32_t setConnectionOption(TAOS *taos, TSDB_OPTION_CONNECTION option, const char *val) { if (taos == NULL) { return terrno = TSDB_CODE_INVALID_PARA; } #ifdef WINDOWS - if (option == TSDB_OPTION_CONNECTION_TIMEZONE){ + if (option == TSDB_OPTION_CONNECTION_TIMEZONE) { return terrno = TSDB_CODE_NOT_SUPPORTTED_IN_WINDOWS; } #endif - if (option < TSDB_OPTION_CONNECTION_CLEAR || option >= TSDB_MAX_OPTIONS_CONNECTION){ + if (option < TSDB_OPTION_CONNECTION_CLEAR || option >= TSDB_MAX_OPTIONS_CONNECTION) { return terrno = TSDB_CODE_INVALID_PARA; } @@ -149,7 +149,7 @@ static int32_t setConnectionOption(TAOS *taos, TSDB_OPTION_CONNECTION option, co return terrno; } - if (option == TSDB_OPTION_CONNECTION_CLEAR){ + if (option == TSDB_OPTION_CONNECTION_CLEAR) { val = NULL; } @@ -165,19 +165,19 @@ static int32_t setConnectionOption(TAOS *taos, TSDB_OPTION_CONNECTION option, co goto END; } pObj->optionInfo.charsetCxt = tmp; - }else{ + } else { pObj->optionInfo.charsetCxt = NULL; } } if (option == TSDB_OPTION_CONNECTION_TIMEZONE || option == TSDB_OPTION_CONNECTION_CLEAR) { #ifndef WINDOWS - if (val != NULL){ - if (val[0] == 0){ + if (val != NULL) { + if (val[0] == 0) { val = "UTC"; } timezone_t tz = setConnnectionTz(val); - if (tz == NULL){ + if (tz == NULL) { code = terrno; goto END; } @@ -199,7 +199,7 @@ static int32_t setConnectionOption(TAOS *taos, TSDB_OPTION_CONNECTION option, co if (option == TSDB_OPTION_CONNECTION_USER_IP || option == TSDB_OPTION_CONNECTION_CLEAR) { if (val != NULL) { pObj->optionInfo.userIp = taosInetAddr(val); - if (pObj->optionInfo.userIp == INADDR_NONE){ + if (pObj->optionInfo.userIp == INADDR_NONE) { code = TSDB_CODE_INVALID_PARA; goto END; } @@ -213,7 +213,7 @@ END: return terrno = code; } -int taos_options_connection(TAOS *taos, TSDB_OPTION_CONNECTION option, const void *arg, ...){ +int taos_options_connection(TAOS *taos, TSDB_OPTION_CONNECTION option, const void *arg, ...) { return setConnectionOption(taos, option, (const char *)arg); } @@ -2129,6 +2129,11 @@ int taos_stmt_close(TAOS_STMT *stmt) { } TAOS_STMT2 *taos_stmt2_init(TAOS *taos, TAOS_STMT2_OPTION *option) { + if (NULL == taos) { + tscError("NULL parameter for %s", __FUNCTION__); + terrno = TSDB_CODE_INVALID_PARA; + return NULL; + } STscObj *pObj = acquireTscObj(*(int64_t *)taos); if (NULL == pObj) { tscError("invalid parameter for %s", __FUNCTION__); @@ -2257,16 +2262,7 @@ int taos_stmt2_close(TAOS_STMT2 *stmt) { 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__); @@ -2277,28 +2273,6 @@ int taos_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert) { 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 || count == NULL) { -// 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; -// } -// } - int taos_stmt2_get_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_ALL **fields) { if (stmt == NULL || count == NULL) { tscError("NULL parameter for %s", __FUNCTION__); diff --git a/source/client/src/clientStmt2.c b/source/client/src/clientStmt2.c index acd118acc9..f7f4cbb087 100644 --- a/source/client/src/clientStmt2.c +++ b/source/client/src/clientStmt2.c @@ -1036,28 +1036,6 @@ int stmtSetTbTags2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* tags) { 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; @@ -1819,47 +1797,6 @@ 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 stmtParseColFields2(TAOS_STMT2* stmt) { int32_t code = 0; @@ -1902,15 +1839,6 @@ _return: return code; } -int stmtGetColFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_E** fields) { - int32_t code = stmtParseColFields2(stmt); - if (code != TSDB_CODE_SUCCESS) { - return code; - } - - return stmtFetchColFields2(stmt, nums, fields); -} - int stmtGetStbColFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_ALL** fields) { int32_t code = stmtParseColFields2(stmt); if (code != TSDB_CODE_SUCCESS) { @@ -1956,95 +1884,6 @@ int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums) { return TSDB_CODE_SUCCESS; } -int stmtGetParamTbName(TAOS_STMT2* stmt, int* nums) { - STscStmt2* pStmt = (STscStmt2*)stmt; - int32_t code = 0; - int32_t preCode = pStmt->errCode; - - 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_ERRI_JRET(stmtParseSql(pStmt)); - } - - *nums = STMT_TYPE_MULTI_INSERT == pStmt->sql.type ? 1 : 0; - -_return: - if (TSDB_CODE_TSC_STMT_TBNAME_ERROR == code) { - *nums = 1; - code = TSDB_CODE_SUCCESS; - } - - pStmt->errCode = preCode; - return code; -} -/* -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; diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index c325ed3a38..267b777ff3 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -27,10 +27,17 @@ #pragma GCC diagnostic ignored "-Wunused-variable" #pragma GCC diagnostic ignored "-Wsign-compare" +#include "../inc/clientStmt.h" +#include "../inc/clientStmt2.h" #include "executor.h" #include "taos.h" namespace { +void stmtAsyncQueryCb(void* param, TAOS_RES* pRes, int code) { + int affected_rows = taos_affected_rows(pRes); + return; +} + void getFieldsSuccess(TAOS* taos, const char* sql, TAOS_FIELD_ALL* expectedFields, int expectedFieldNum) { TAOS_STMT2_OPTION option = {0}; TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); @@ -55,28 +62,35 @@ void getFieldsSuccess(TAOS* taos, const char* sql, TAOS_FIELD_ALL* expectedField taos_stmt2_close(stmt); } -void getQueryFields(TAOS* taos, const char* sql) { +void getFieldsError(TAOS* taos, const char* sql, int errorCode) { TAOS_STMT2_OPTION option = {0}; TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); 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; - } + ASSERT_EQ(code, 0); + int fieldNum = 0; TAOS_FIELD_ALL* pFields = NULL; code = taos_stmt2_get_fields(stmt, &fieldNum, &pFields); - if (code != 0) { - printf("failed get col,ErrCode: 0x%x, ErrMessage: %s.\n", code, taos_stmt2_error(stmt)); - } else { - printf("bind nums:%d\n", fieldNum); - } - printf("====================================\n"); + ASSERT_EQ(code, errorCode); taos_stmt2_free_fields(stmt, pFields); taos_stmt2_close(stmt); } +void getQueryFields(TAOS* taos, const char* sql, int expectedFieldNum) { + TAOS_STMT2_OPTION option = {0}; + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + int code = taos_stmt2_prepare(stmt, sql, 0); + ASSERT_EQ(code, 0); + + int fieldNum = 0; + TAOS_FIELD_ALL* pFields = NULL; + code = taos_stmt2_get_fields(stmt, &fieldNum, NULL); + ASSERT_EQ(code, 0); + ASSERT_EQ(fieldNum, expectedFieldNum); + taos_stmt2_free_fields(stmt, NULL); + taos_stmt2_close(stmt); +} + void do_query(TAOS* taos, const char* sql) { TAOS_RES* result = taos_query(taos, sql); int code = taos_errno(result); @@ -169,94 +183,134 @@ TEST(stmt2Case, insert_stb_get_fields_Test) { do_query(taos, "drop database if exists db"); do_query(taos, "create database db PRECISION 'ns'"); - do_query(taos, "use db"); do_query(taos, "create table db.stb (ts timestamp, b binary(10)) tags(t1 " "int, t2 binary(10))"); do_query( taos, - "create table if not exists all_stb(ts timestamp, v1 bool, v2 tinyint, v3 smallint, v4 int, v5 bigint, v6 " + "create table if not exists db.all_stb(ts timestamp, v1 bool, v2 tinyint, v3 smallint, v4 int, v5 bigint, v6 " "tinyint unsigned, v7 smallint unsigned, v8 int unsigned, v9 bigint unsigned, v10 float, v11 double, v12 " "binary(20), v13 varbinary(20), v14 geometry(100), v15 nchar(20))tags(tts timestamp, tv1 bool, tv2 tinyint, tv3 " "smallint, tv4 int, tv5 bigint, tv6 tinyint unsigned, tv7 smallint unsigned, tv8 int unsigned, tv9 bigint " "unsigned, tv10 float, tv11 double, tv12 binary(20), tv13 varbinary(20), tv14 geometry(100), tv15 nchar(20));"); + printf("support case \n"); - // // case 1 : test super table - // { - // const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(?,?,?,?,?)"; - // TAOS_FIELD_ALL expectedFields[5] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, - // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, - // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, - // {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}}; - // printf("case 1 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 5); - // } - - // case 2 : no tbname + // case 1 : test super table { - const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(1,?,?,'abc',?)"; - TAOS_FIELD_ALL expectedFields[3] = {{"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(?,?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}}; + printf("case 1 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 5); + } + + { + // case 2 : no tag + const char* sql = "insert into db.stb(ts,b,tbname) values(?,?,?)"; + TAOS_FIELD_ALL expectedFields[3] = {{"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}}; printf("case 2 : %s\n", sql); getFieldsSuccess(taos, sql, expectedFields, 3); } + // case 3 : random order { - // case 3 : insert into db.stb(ts,b,tbname) values(?,?,?) - // no tag - const char* sql = "insert into db.stb(ts,b,tbname) values(?,?,?)"; - TAOS_FIELD_ALL expectedFields[3] = { - {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, - {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, - }; - printf("case 5 : %s\n", sql); - getFieldsSuccess(taos, sql, expectedFields, 3); + const char* sql = "insert into db.stb(tbname,ts,t2,b,t1) values(?,?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}}; + printf("case 3 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 5); } - // case 12 : insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) - // values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) - // test all types + // case 4 : random order { - const char* sql = - "insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; - TAOS_FIELD_ALL expectedFields[33] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, - {"tts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_TAG}, - {"tv1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_TAG}, - {"tv2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_TAG}, - {"tv3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, - {"tv4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, - {"tv5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_TAG}, - {"tv6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_TAG}, - {"tv7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, - {"tv8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_TAG}, - {"tv9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_TAG}, - {"tv10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_TAG}, - {"tv11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_TAG}, - {"tv12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_TAG}, - {"tv13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_TAG}, - {"tv14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_TAG}, - {"tv15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_TAG}, - {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - {"v1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_COL}, - {"v2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_COL}, - {"v3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_COL}, - {"v4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}, - {"v5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_COL}, - {"v6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_COL}, - {"v7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_COL}, - {"v8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_COL}, - {"v9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_COL}, - {"v10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_COL}, - {"v11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_COL}, - {"v12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_COL}, - {"v13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_COL}, - {"v14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_COL}, - {"v15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_COL}}; - printf("case 12 : %s\n", sql); - getFieldsSuccess(taos, sql, expectedFields, 33); + const char* sql = "insert into db.stb(tbname,ts,t2,b,t1) values(?,?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}}; + printf("case 4 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 5); + } + + // case 5 : 'db'.'stb' + { + const char* sql = "insert into 'db'.'stb'(t1,t2,ts,b,tbname) values(?,?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}}; + printf("case 5 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 5); + } + + // case 6 : use db + { + do_query(taos, "use db"); + const char* sql = "insert into stb(t1,t2,ts,b,tbname) values(?,?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}}; + printf("case 6 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 5); + } + + // case 7 : less param + { + const char* sql = "insert into db.stb(ts,tbname) values(?,?)"; + TAOS_FIELD_ALL expectedFields[2] = {{"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}}; + printf("case 7 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 2); + } + + // not support case + printf("not support case \n"); + + // case 5 : add in main TD-33353 + // { + // const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(1,?,?,'abc',?)"; + // printf("case 2 : %s\n", sql); + // getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + // } + + // case 7 : no pk + { + const char* sql = "insert into db.stb(b,tbname) values(?,?)"; + printf("case 7 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + } + + // case 5 : no tbname and tag(not support bind) + { + const char* sql = "insert into db.stb(ts,b) values(?,?)"; + printf("case 5 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + } + + // case 5 : no tbname and tag(not support bind) + { + const char* sql = "insert into db.stb(tbname) values(?)"; + printf("case 5 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + } + + // case 8 : no param + { + const char* sql = "insert into db.stb(?,?,?,?,?)"; + printf("case 8 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_PAR_SYNTAX_ERROR); } taos_close(taos); @@ -356,6 +410,49 @@ TEST(stmt2Case, insert_ctb_using_get_fields_Test) { // // "v11,v12,v13,v14,v15) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; // // printf("case 13 : %s\n", sql); // // getFields(taos, sql); + + // case 12 : insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) + // values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) + // test all types + // { + // const char* sql = + // "insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; + // TAOS_FIELD_ALL expectedFields[33] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + // {"tts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_TAG}, + // {"tv1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_TAG}, + // {"tv2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_TAG}, + // {"tv3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, + // {"tv4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + // {"tv5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_TAG}, + // {"tv6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_TAG}, + // {"tv7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, + // {"tv8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_TAG}, + // {"tv9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_TAG}, + // {"tv10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_TAG}, + // {"tv11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_TAG}, + // {"tv12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_TAG}, + // {"tv13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_TAG}, + // {"tv14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_TAG}, + // {"tv15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_TAG}, + // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + // {"v1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_COL}, + // {"v2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_COL}, + // {"v3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_COL}, + // {"v4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}, + // {"v5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_COL}, + // {"v6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_COL}, + // {"v7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_COL}, + // {"v8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_COL}, + // {"v9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_COL}, + // {"v10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_COL}, + // {"v11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_COL}, + // {"v12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_COL}, + // {"v13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_COL}, + // {"v14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_COL}, + // {"v15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_COL}}; + // printf("case 12 : %s\n", sql); + // getFieldsSuccess(taos, sql, expectedFields, 33); + // } } TEST(stmt2Case, insert_ntb_get_fields_Test) { @@ -388,30 +485,87 @@ TEST(stmt2Case, insert_ntb_get_fields_Test) { } TEST(stmt2Case, select_get_fields_Test) { - // // case 14 : select * from ntb where ts = ? - // // query type - // sql = "select * from ntb where ts = ?"; - // printf("case 14 : %s\n", sql); - // getQueryFields(taos, sql); + TAOS* taos = taos_connect("localhost", "root", "taosdata", NULL, 0); + ASSERT_NE(taos, nullptr); + do_query(taos, "drop database if exists db"); + do_query(taos, "create database db PRECISION 'ns'"); + do_query(taos, "use db"); + do_query(taos, "CREATE TABLE db.ntb(nts timestamp, nb binary(10),nvc varchar(16),ni int);"); + { + // case 1 : select * from ntb where ts = ? + // query type + const char* sql = "select * from ntb where ts = ?"; + printf("case 1 : %s\n", sql); + getQueryFields(taos, sql, 1); + } - // // case 15 : select * from ntb where ts = ? and b = ? - // // query type - // sql = "select * from ntb where ts = ? and b = ?"; - // printf("case 15 : %s\n", sql); - // getQueryFields(taos, sql); + { + // case 2 : select * from ntb where ts = ? and b = ? + // query type + const char* sql = "select * from ntb where ts = ? and b = ?"; + printf("case 2 : %s\n", sql); + getQueryFields(taos, sql, 2); + } } -TEST(stmt2Case, db_get_fields_Test) {} - TEST(stmt2Case, get_fields_error_Test) { - // { - // const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(1,?,?,'abc',?)"; - // TAOS_FIELD_ALL expectedFields[3] = {{"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, - // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - // {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}}; - // printf("case 2 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 3); - // } + // case 1 : + { + printf("case 1 : NULL param \n"); + int code = taos_stmt2_get_fields(NULL, NULL, NULL); + ASSERT_EQ(code, TSDB_CODE_INVALID_PARA); + } } +TEST(stmt2Case, stmt2_init_prepare_Test) { + TAOS* taos = taos_connect("localhost", "root", "taosdata", NULL, 0); + + { + (void)taos_stmt2_init(NULL, NULL); + ASSERT_EQ(terrno, TSDB_CODE_INVALID_PARA); + terrno = 0; + } + + { + (void)taos_stmt2_prepare(NULL, NULL, 0); + ASSERT_EQ(terrno, TSDB_CODE_INVALID_PARA); + terrno = 0; + } + + { + TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL}; + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + ASSERT_EQ(terrno, 0); + ASSERT_NE(stmt, nullptr); + int code = taos_stmt2_prepare(stmt, "wrong sql", 0); + ASSERT_EQ(terrno, 0); + ASSERT_NE(stmt, nullptr); + ASSERT_EQ(((STscStmt2*)stmt)->db, nullptr); + + code = taos_stmt2_prepare(stmt, "insert into 'db'.stb(t1,t2,ts,b,tbname) values(?,?,?,?,?)", 0); + ASSERT_EQ(terrno, 0); + ASSERT_NE(stmt, nullptr); + // ASSERT_STREQ(((STscStmt2*)stmt)->db, "db"); //add in main TD-33332 + taos_stmt2_close(stmt); + } + + { + TAOS_STMT2_OPTION option = {0, true, false, NULL, NULL}; + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + ASSERT_EQ(terrno, 0); + ASSERT_NE(stmt, nullptr); + taos_stmt2_close(stmt); + } + + { + TAOS_STMT2_OPTION option = {0, true, true, stmtAsyncQueryCb, NULL}; + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + ASSERT_EQ(terrno, 0); + ASSERT_NE(stmt, nullptr); + taos_stmt2_close(stmt); + } +} + +TEST(stmt2Case, stmt2_status_Test) {} + #pragma GCC diagnostic pop From 69aac6d778c23a4f93ff517133b6d880e2ecaf5a Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Thu, 26 Dec 2024 18:40:07 +0800 Subject: [PATCH 03/13] finish stmt2 get fiels test --- source/client/test/stmt2Test.cpp | 615 +++++++++++++++++++------------ 1 file changed, 380 insertions(+), 235 deletions(-) diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index 267b777ff3..bf05f7788b 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -103,68 +103,12 @@ void do_query(TAOS* taos, const char* sql) { // printf("=================error test===================\n"); -// // case 14 : INSERT INTO db.d0 using db.stb values(?,?) -// // none para for ctbname -// sql = "INSERT INTO db.d0 using db.stb values(?,?)"; -// printf("case 14 (no tags error): %s\n", sql); -// getFields(taos, sql); - -// // case 15 : insert into db.stb(t1,t2,tbname) values(?,?,?) -// // no value -// sql = "insert into db.stb(t1,t2,tbname) values(?,?,?)"; -// printf("case 15 (no PK error): %s\n", sql); -// getFields(taos, sql); - -// // case 16 : insert into db.stb(ts,b,tbname) values(?,?,?,?,?) -// // wrong para nums -// sql = "insert into db.stb(ts,b,tbname) values(?,?,?,?,?)"; -// printf("case 16 (wrong para nums): %s\n", sql); -// getFields(taos, sql); - -// // case 17 : insert into db.? values(?,?) -// // normal table must have tbnam -// sql = "insert into db.? values(?,?)"; -// printf("case 17 (normal table must have tbname): %s\n", sql); -// getFields(taos, sql); - -// // case 18 : INSERT INTO db.stb(t1,t2,ts,b) values(?,?,?,?) -// // no tbname error -// sql = "INSERT INTO db.stb(t1,t2,ts,b) values(?,?,?,?)"; -// printf("case 18 (no tbname error): %s\n", sql); -// getFields(taos, sql); - -// // case 19 : insert into db.ntb(nts,ni) values(?,?,?,?,?) -// // wrong para nums -// sql = "insert into ntb(nts,ni) values(?,?,?,?,?)"; -// printf("case 19 : %s\n", sql); -// getFields(taos, sql); - -// // case 20 : insert into db.stb(t1,t2,ts,b,tbname) values(*,*,*,*,*) -// // wrong simbol -// sql = "insert into db.stb(t1,t2,ts,b,tbname) values(*,*,*,*,*)"; -// printf("=================normal test===================\n"); -// printf("case 20 : %s\n", sql); -// getFields(taos, sql); - -// // case 21 : INSERT INTO ! using db.stb TAGS(?,?) VALUES(?,?) -// // wrong simbol -// sql = "insert into ! using db.stb tags(?, ?) values(?,?)"; -// printf("case 21 : %s\n", sql); -// getFields(taos, sql); - // // case 22 : INSERT INTO ! using db.stb TAGS(?,?) VALUES(?,?) // // wrong tbname // sql = "insert into db.stb values(?,?)"; // printf("case 22 : %s\n", sql); // getFields(taos, sql); -// // case 23 : select * from ? where ts = ? -// // wrong query type -// sql = "select * from ? where ts = ?"; -// printf("case 23 : %s\n", sql); -// getQueryFields(taos, sql); -// } - } // namespace int main(int argc, char** argv) { @@ -229,13 +173,13 @@ TEST(stmt2Case, insert_stb_get_fields_Test) { getFieldsSuccess(taos, sql, expectedFields, 5); } - // case 4 : random order + // case 4 : random order 2 { - const char* sql = "insert into db.stb(tbname,ts,t2,b,t1) values(?,?,?,?,?)"; - TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, - {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + const char* sql = "insert into db.stb(ts,tbname,b,t2,t1) values(?,?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}}; printf("case 4 : %s\n", sql); getFieldsSuccess(taos, sql, expectedFields, 5); @@ -275,6 +219,50 @@ TEST(stmt2Case, insert_stb_get_fields_Test) { getFieldsSuccess(taos, sql, expectedFields, 2); } + // case 8 : test all types + { + const char* sql = + "insert into " + "all_stb(tbname,tts,tv1,tv2,tv3,tv4,tv5,tv6,tv7,tv8,tv9,tv10,tv11,tv12,tv13,tv14,tv15,ts,v1,v2,v3,v4,v5,v6,v7," + "v8,v9,v10," + "v11,v12,v13,v14,v15) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[33] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"tts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_TAG}, + {"tv1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_TAG}, + {"tv2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_TAG}, + {"tv3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, + {"tv4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"tv5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_TAG}, + {"tv6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_TAG}, + {"tv7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, + {"tv8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_TAG}, + {"tv9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_TAG}, + {"tv10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_TAG}, + {"tv11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_TAG}, + {"tv12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_TAG}, + {"tv13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_TAG}, + {"tv14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_TAG}, + {"tv15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"v1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_COL}, + {"v2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_COL}, + {"v3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_COL}, + {"v4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}, + {"v5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_COL}, + {"v6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_COL}, + {"v7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_COL}, + {"v8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_COL}, + {"v9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_COL}, + {"v10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_COL}, + {"v11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_COL}, + {"v12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_COL}, + {"v13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_COL}, + {"v14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_COL}, + {"v15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_COL}}; + printf("case 8 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 33); + } + // not support case printf("not support case \n"); @@ -285,32 +273,60 @@ TEST(stmt2Case, insert_stb_get_fields_Test) { // getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); // } - // case 7 : no pk + // case 2 : no pk { const char* sql = "insert into db.stb(b,tbname) values(?,?)"; + printf("case 2 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + } + + // case 3 : no tbname and tag(not support bind) + { + const char* sql = "insert into db.stb(ts,b) values(?,?)"; + printf("case 3 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + } + + // case 4 : no col and tag(not support bind) + { + const char* sql = "insert into db.stb(tbname) values(?)"; + printf("case 4 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + } + + // case 5 : no field name + { + const char* sql = "insert into db.stb(?,?,?,?,?)"; + printf("case 5 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_PAR_SYNTAX_ERROR); + } + + // case 6 : test super table not exist + { + const char* sql = "insert into db.nstb(?,?,?,?,?)"; + printf("case 6 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_PAR_SYNTAX_ERROR); + } + + // case 7 : no col + { + const char* sql = "insert into db.stb(t1,t2,tbname) values(?,?,?)"; printf("case 7 : %s\n", sql); getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); } - // case 5 : no tbname and tag(not support bind) + // case 8 : wrong para nums { - const char* sql = "insert into db.stb(ts,b) values(?,?)"; - printf("case 5 : %s\n", sql); - getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); - } - - // case 5 : no tbname and tag(not support bind) - { - const char* sql = "insert into db.stb(tbname) values(?)"; - printf("case 5 : %s\n", sql); - getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); - } - - // case 8 : no param - { - const char* sql = "insert into db.stb(?,?,?,?,?)"; + const char* sql = "insert into db.stb(ts,b,tbname) values(?,?,?,?,?)"; printf("case 8 : %s\n", sql); - getFieldsError(taos, sql, TSDB_CODE_PAR_SYNTAX_ERROR); + getFieldsError(taos, sql, TSDB_CODE_PAR_INVALID_COLUMNS_NUM); + } + + // case 9 : wrong simbol + { + const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(*,*,*,*,*)"; + printf("case 9 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_SQL_SYNTAX_ERROR); } taos_close(taos); @@ -318,170 +334,295 @@ TEST(stmt2Case, insert_stb_get_fields_Test) { } TEST(stmt2Case, insert_ctb_using_get_fields_Test) { - // do_query(taos, "CREATE TABLE db.d0 USING db.stb (t1,t2) TAGS (7,'Cali');"); + TAOS* taos = taos_connect("localhost", "root", "taosdata", NULL, 0); + ASSERT_NE(taos, nullptr); - // // case 2 : INSERT INTO db.d0 VALUES (?,?) - // // test child table - // { - // const char* sql = "INSERT INTO db.d0(ts,b) VALUES (?,?)"; - // TAOS_FIELD_ALL expectedFields[2] = {{"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; - // printf("case 2 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 2); - // } + do_query(taos, "drop database if exists db"); + do_query(taos, "create database db PRECISION 'ns'"); + do_query(taos, + "create table db.stb (ts timestamp, b binary(10)) tags(t1 " + "int, t2 binary(10))"); + do_query( + taos, + "create table if not exists db.all_stb(ts timestamp, v1 bool, v2 tinyint, v3 smallint, v4 int, v5 bigint, v6 " + "tinyint unsigned, v7 smallint unsigned, v8 int unsigned, v9 bigint unsigned, v10 float, v11 double, v12 " + "binary(20), v13 varbinary(20), v14 geometry(100), v15 nchar(20))tags(tts timestamp, tv1 bool, tv2 tinyint, tv3 " + "smallint, tv4 int, tv5 bigint, tv6 tinyint unsigned, tv7 smallint unsigned, tv8 int unsigned, tv9 bigint " + "unsigned, tv10 float, tv11 double, tv12 binary(20), tv13 varbinary(20), tv14 geometry(100), tv15 nchar(20));"); + do_query(taos, "CREATE TABLE db.t0 USING db.stb (t1,t2) TAGS (7,'Cali');"); - // // case 6 : INSERT INTO db.? using db.stb (t1,t2)TAGS(?,?) (ts,b)VALUES(?,?) - // // normal insert clause - // { - // const char* sql = "INSERT INTO db.? using db.stb (t1,t2)TAGS(?,?) (ts,b)VALUES(?,?)"; - // TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, - // {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, - // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, - // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; - // printf("case 6 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 5); - // } + printf("support case \n"); + // case 1 : test child table already exist + { + const char* sql = "INSERT INTO db.t0(ts,b)using db.stb (t1,t2) TAGS(?,?) VALUES (?,?)"; + TAOS_FIELD_ALL expectedFields[4] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + printf("case 1 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 4); + } - // // case 7 : insert into db.? using db.stb(t2,t1) tags(?, ?) (b,ts)values(?,?) - // // disordered - // { - // const char* sql = "insert into db.? using db.stb(t2,t1) tags(?, ?) (b,ts)values(?,?)"; - // TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, - // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, - // {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, - // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, - // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}}; - // printf("case 7 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 5); - // } + // case 2 : insert clause + { + const char* sql = "INSERT INTO db.? using db.stb (t1,t2) TAGS(?,?) (ts,b)VALUES(?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + printf("case 2 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 5); + } - // // case 8 : insert into db.? using db.stb tags(?, ?) values(?,?) - // // no field name - // { - // const char* sql = "insert into db.? using db.stb tags(?, ?) values(?,?)"; - // TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, - // {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, - // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, - // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; - // printf("case 8 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 5); - // } + // case 3 : insert child table not exist + { + const char* sql = "INSERT INTO db.d1 using db.stb (t1,t2)TAGS(?,?) (ts,b)VALUES(?,?)"; + TAOS_FIELD_ALL expectedFields[4] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + printf("case 3 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 4); + } - // // case 9 : insert into db.? using db.stb (t2)tags(?) (ts)values(?) - // // less para - // { - // const char* sql = "insert into db.? using db.stb (t2)tags(?) (ts)values(?)"; - // TAOS_FIELD_ALL expectedFields[3] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, - // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, - // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}}; - // printf("case 9 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 3); - // } + // case 4 : random order + { + const char* sql = "INSERT INTO db.? using db.stb (t2,t1)TAGS(?,?) (b,ts)VALUES(?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}}; + printf("case 4 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 5); + } - // // case 10 : insert into db.d0 (ts)values(?) - // // less para - // { - // const char* sql = "insert into db.d0 (ts)values(?)"; - // TAOS_FIELD_ALL expectedFields[1] = {{"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}}; - // printf("case 10 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 1); - // } - // // case 11 : insert into abc using stb tags(?, ?) values(?,?) - // // insert create table - // { - // const char* sql = "insert into abc using stb tags(?, ?) values(?,?)"; - // TAOS_FIELD_ALL expectedFields[4] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, - // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, - // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; - // printf("case 11 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 4); - // } + // case 5 : less para + { + const char* sql = "insert into db.? using db.stb (t2)tags(?) (ts)values(?)"; + TAOS_FIELD_ALL expectedFields[3] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}}; + printf("case 5 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 3); + } - // // // case 13 : insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) - // // values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) - // // // test all types - // // sql = - // // "insert into all_stb " - // // - // "(tbname,tts,tv1,tv2,tv3,tv4,tv5,tv6,tv7,tv8,tv9,tv10,tv11,tv12,tv13,tv14,tv15,ts,v1,v2,v3,v4,v5,v6,v7,v8,v9,v10," - // // "v11,v12,v13,v14,v15) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; - // // printf("case 13 : %s\n", sql); - // // getFields(taos, sql); + // case 6 : insert into db.? using db.stb tags(?, ?) values(?,?) + // no field name + { + const char* sql = "insert into db.? using db.stb tags(?, ?) values(?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + printf("case 6 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 5); + } - // case 12 : insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) - // values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) - // test all types - // { - // const char* sql = - // "insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; - // TAOS_FIELD_ALL expectedFields[33] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, - // {"tts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_TAG}, - // {"tv1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_TAG}, - // {"tv2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_TAG}, - // {"tv3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, - // {"tv4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, - // {"tv5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_TAG}, - // {"tv6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_TAG}, - // {"tv7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, - // {"tv8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_TAG}, - // {"tv9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_TAG}, - // {"tv10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_TAG}, - // {"tv11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_TAG}, - // {"tv12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_TAG}, - // {"tv13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_TAG}, - // {"tv14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_TAG}, - // {"tv15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_TAG}, - // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - // {"v1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_COL}, - // {"v2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_COL}, - // {"v3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_COL}, - // {"v4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}, - // {"v5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_COL}, - // {"v6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_COL}, - // {"v7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_COL}, - // {"v8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_COL}, - // {"v9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_COL}, - // {"v10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_COL}, - // {"v11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_COL}, - // {"v12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_COL}, - // {"v13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_COL}, - // {"v14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_COL}, - // {"v15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_COL}}; - // printf("case 12 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 33); - // } + // case 7 : insert into db.d0 (ts)values(?) + // less para + { + const char* sql = "insert into db.t0 (ts)values(?)"; + TAOS_FIELD_ALL expectedFields[1] = {{"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}}; + printf("case 7 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 1); + } + + // case 8 : 'db' 'stb' + { + const char* sql = "INSERT INTO 'db'.? using 'db'.'stb' (t1,t2) TAGS(?,?) (ts,b)VALUES(?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + printf("case 8 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 5); + } + + // case 9 : use db + { + do_query(taos, "use db"); + const char* sql = "INSERT INTO ? using stb (t1,t2) TAGS(?,?) (ts,b)VALUES(?,?)"; + TAOS_FIELD_ALL expectedFields[5] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; + printf("case 9 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 5); + } + + // case 10 : test all types + { + const char* sql = + "insert into ? using all_stb tags(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[33] = {{"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, + {"tts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_TAG}, + {"tv1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_TAG}, + {"tv2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_TAG}, + {"tv3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, + {"tv4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, + {"tv5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_TAG}, + {"tv6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_TAG}, + {"tv7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_TAG}, + {"tv8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_TAG}, + {"tv9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_TAG}, + {"tv10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_TAG}, + {"tv11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_TAG}, + {"tv12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_TAG}, + {"tv13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_TAG}, + {"tv14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_TAG}, + {"tv15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_TAG}, + {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, + {"v1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_COL}, + {"v2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_COL}, + {"v3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_COL}, + {"v4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}, + {"v5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_COL}, + {"v6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_COL}, + {"v7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_COL}, + {"v8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_COL}, + {"v9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_COL}, + {"v10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_COL}, + {"v11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_COL}, + {"v12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_COL}, + {"v13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_COL}, + {"v14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_COL}, + {"v15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_COL}}; + printf("case 10 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 33); + } + printf("not support case \n"); + + // case 1 : test super table not exist + { + const char* sql = "INSERT INTO db.?(ts,b)using db.nstb (t1,t2) TAGS(?,?) VALUES (?,?)"; + printf("case 1 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_PAR_SYNTAX_ERROR); + } + + // case 2 : no pk + { + const char* sql = "INSERT INTO db.?(ts,b)using db.nstb (t1,t2) TAGS(?,?) (n)VALUES (?)"; + printf("case 2 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_PAR_SYNTAX_ERROR); + } + + // case 3 : less param and no filed name + { + const char* sql = "INSERT INTO db.?(ts,b)using db.stb TAGS(?)VALUES (?,?)"; + printf("case 3 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_PAR_SYNTAX_ERROR); + } + + // case 4 : none para for ctbname + { + const char* sql = "INSERT INTO db.d0 using db.stb values(?,?)"; + printf("case 4 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_SQL_SYNTAX_ERROR); + } + + // case 5 : none para for ctbname + { + const char* sql = "insert into ! using db.stb tags(?, ?) values(?,?)"; + printf("case 5 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_SQL_SYNTAX_ERROR); + } } TEST(stmt2Case, insert_ntb_get_fields_Test) { - // do_query(taos, "CREATE TABLE db.ntb(nts timestamp, nb binary(10),nvc varchar(16),ni int);"); + TAOS* taos = taos_connect("localhost", "root", "taosdata", NULL, 0); + ASSERT_NE(taos, nullptr); - // // // case 3 : INSERT INTO db.ntb VALUES(?,?,?,?) - // // // test normal table - // { - // const char* sql = "INSERT INTO db.ntb VALUES(?,?,?,?)"; - // TAOS_FIELD_ALL expectedFields[4] = {{"nts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - // {"nb", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, - // {"nvc", TSDB_DATA_TYPE_BINARY, 0, 0, 18, TAOS_FIELD_COL}, - // {"ni", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}}; - // printf("case 3 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 4); - // } + do_query(taos, "drop database if exists db"); + do_query(taos, "create database db PRECISION 'ms'"); + do_query(taos, "CREATE TABLE db.ntb(nts timestamp, nb binary(10),nvc varchar(16),ni int);"); + do_query( + taos, + "create table if not exists db.all_ntb(ts timestamp, v1 bool, v2 tinyint, v3 smallint, v4 int, v5 bigint, v6 " + "tinyint unsigned, v7 smallint unsigned, v8 int unsigned, v9 bigint unsigned, v10 float, v11 double, v12 " + "binary(20), v13 varbinary(20), v14 geometry(100), v15 nchar(20));"); - // { - // // case 4 : insert into db.stb(t1,tbname,ts,t2,b) values(?,?,?,?,?) - // // test random order - // const char* sql = "insert into db.stb(t1,tbname,ts,t2,b) values(?,?,?,?,?)"; - // TAOS_FIELD_ALL expectedFields[5] = {{"t1", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_TAG}, - // {"tbname", TSDB_DATA_TYPE_BINARY, 0, 0, 271, TAOS_FIELD_TBNAME}, - // {"ts", TSDB_DATA_TYPE_TIMESTAMP, 2, 0, 8, TAOS_FIELD_COL}, - // {"t2", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_TAG}, - // {"b", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}}; - // printf("case 4 : %s\n", sql); - // getFieldsSuccess(taos, sql, expectedFields, 5); - // } + printf("support case \n"); + + // case 1 : test normal table no field name + { + const char* sql = "INSERT INTO db.ntb VALUES(?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[4] = {{"nts", TSDB_DATA_TYPE_TIMESTAMP, 0, 0, 8, TAOS_FIELD_COL}, + {"nb", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + {"nvc", TSDB_DATA_TYPE_BINARY, 0, 0, 18, TAOS_FIELD_COL}, + {"ni", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}}; + printf("case 1 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 4); + } + + // case 2 : test random order + { + const char* sql = "INSERT INTO db.ntb (ni,nb,nvc,nts)VALUES(?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[4] = {{"ni", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}, + {"nb", TSDB_DATA_TYPE_BINARY, 0, 0, 12, TAOS_FIELD_COL}, + {"nvc", TSDB_DATA_TYPE_BINARY, 0, 0, 18, TAOS_FIELD_COL}, + {"nts", TSDB_DATA_TYPE_TIMESTAMP, 0, 0, 8, TAOS_FIELD_COL}}; + printf("case 2 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 4); + } + + // case 3 : less param + { + const char* sql = "INSERT INTO db.ntb (nts)VALUES(?)"; + TAOS_FIELD_ALL expectedFields[1] = {{"nts", TSDB_DATA_TYPE_TIMESTAMP, 0, 0, 8, TAOS_FIELD_COL}}; + printf("case 3 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 1); + } + + // case 4 : test all types + { + const char* sql = "insert into db.all_ntb values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; + TAOS_FIELD_ALL expectedFields[16] = {{"ts", TSDB_DATA_TYPE_TIMESTAMP, 0, 0, 8, TAOS_FIELD_COL}, + {"v1", TSDB_DATA_TYPE_BOOL, 0, 0, 1, TAOS_FIELD_COL}, + {"v2", TSDB_DATA_TYPE_TINYINT, 0, 0, 1, TAOS_FIELD_COL}, + {"v3", TSDB_DATA_TYPE_SMALLINT, 0, 0, 2, TAOS_FIELD_COL}, + {"v4", TSDB_DATA_TYPE_INT, 0, 0, 4, TAOS_FIELD_COL}, + {"v5", TSDB_DATA_TYPE_BIGINT, 0, 0, 8, TAOS_FIELD_COL}, + {"v6", TSDB_DATA_TYPE_UTINYINT, 0, 0, 1, TAOS_FIELD_COL}, + {"v7", TSDB_DATA_TYPE_USMALLINT, 0, 0, 2, TAOS_FIELD_COL}, + {"v8", TSDB_DATA_TYPE_UINT, 0, 0, 4, TAOS_FIELD_COL}, + {"v9", TSDB_DATA_TYPE_UBIGINT, 0, 0, 8, TAOS_FIELD_COL}, + {"v10", TSDB_DATA_TYPE_FLOAT, 0, 0, 4, TAOS_FIELD_COL}, + {"v11", TSDB_DATA_TYPE_DOUBLE, 0, 0, 8, TAOS_FIELD_COL}, + {"v12", TSDB_DATA_TYPE_VARCHAR, 0, 0, 22, TAOS_FIELD_COL}, + {"v13", TSDB_DATA_TYPE_VARBINARY, 0, 0, 22, TAOS_FIELD_COL}, + {"v14", TSDB_DATA_TYPE_GEOMETRY, 0, 0, 102, TAOS_FIELD_COL}, + {"v15", TSDB_DATA_TYPE_NCHAR, 0, 0, 82, TAOS_FIELD_COL}}; + printf("case 4 : %s\n", sql); + getFieldsSuccess(taos, sql, expectedFields, 16); + } + + printf("not support case \n"); + + // case 1 : wrong db + { + const char* sql = "insert into ntb values(?,?,?,?)"; + printf("case 1 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + } + + // case 2 : normal table must have tbnam + { + const char* sql = "insert into db.? values(?,?)"; + printf("case 2 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_PAR_TABLE_NOT_EXIST); + } + + // case 3 : wrong para nums + { + const char* sql = "insert into db.ntb(nts,ni) values(?,?,?,?,?)"; + printf("case 3 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_PAR_INVALID_COLUMNS_NUM); + } } TEST(stmt2Case, select_get_fields_Test) { @@ -492,20 +633,25 @@ TEST(stmt2Case, select_get_fields_Test) { do_query(taos, "use db"); do_query(taos, "CREATE TABLE db.ntb(nts timestamp, nb binary(10),nvc varchar(16),ni int);"); { - // case 1 : select * from ntb where ts = ? - // query type + // case 1 : const char* sql = "select * from ntb where ts = ?"; printf("case 1 : %s\n", sql); getQueryFields(taos, sql, 1); } { - // case 2 : select * from ntb where ts = ? and b = ? - // query type + // case 2 : const char* sql = "select * from ntb where ts = ? and b = ?"; printf("case 2 : %s\n", sql); getQueryFields(taos, sql, 2); } + + { + // case 3 : + const char* sql = "select * from ? where ts = ?"; + printf("case 3 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_PAR_SYNTAX_ERROR); + } } TEST(stmt2Case, get_fields_error_Test) { @@ -519,7 +665,6 @@ TEST(stmt2Case, get_fields_error_Test) { TEST(stmt2Case, stmt2_init_prepare_Test) { TAOS* taos = taos_connect("localhost", "root", "taosdata", NULL, 0); - { (void)taos_stmt2_init(NULL, NULL); ASSERT_EQ(terrno, TSDB_CODE_INVALID_PARA); From 7283d54770d52c8bc5a8a09349446f989d30779e Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Thu, 26 Dec 2024 22:22:06 +0800 Subject: [PATCH 04/13] add bind exec test --- source/client/test/stmt2Test.cpp | 111 ++++++++++++++++++++++++++++--- 1 file changed, 103 insertions(+), 8 deletions(-) diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index bf05f7788b..4542f953ab 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -14,7 +14,7 @@ */ #include -#include +#include #include "clientInt.h" #include "osSemaphore.h" #include "taoserror.h" @@ -99,15 +99,100 @@ void do_query(TAOS* taos, const char* sql) { taos_free_result(result); } -// void do_stmt(TAOS* taos) { +void do_stmt(TAOS* taos, const char* sql, int CTB_NUMS, int ROW_NUMS, int CYC_NUMS, bool createTable) { + 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))"); + do_query(taos, "use db"); -// printf("=================error test===================\n"); + TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL}; -// // case 22 : INSERT INTO ! using db.stb TAGS(?,?) VALUES(?,?) -// // wrong tbname -// sql = "insert into db.stb values(?,?)"; -// printf("case 22 : %s\n", sql); -// getFields(taos, sql); + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + ASSERT_NE(stmt, nullptr); + int code = taos_stmt2_prepare(stmt, sql, 0); + ASSERT_EQ(code, 0); + ASSERT_EQ(terrno, 0); + + // tbname + char** tbs = (char**)taosMemoryMalloc(CTB_NUMS * sizeof(char*)); + for (int i = 0; i < CTB_NUMS; i++) { + tbs[i] = (char*)taosMemoryMalloc(sizeof(char) * 20); + sprintf(tbs[i], "ctb_%d", i); + if (createTable) { + char* tmp = (char*)taosMemoryMalloc(sizeof(char) * 100); + sprintf(tmp, "create table db.%s using db.stb tags(0, 'after')", tbs[i]); + do_query(taos, tmp); + } + } + for (int r = 0; r < CYC_NUMS; r++) { + // col params + int64_t** ts = (int64_t**)taosMemoryMalloc(CTB_NUMS * sizeof(int64_t*)); + char** b = (char**)taosMemoryMalloc(CTB_NUMS * sizeof(char*)); + int* ts_len = (int*)taosMemoryMalloc(ROW_NUMS * sizeof(int)); + int* b_len = (int*)taosMemoryMalloc(ROW_NUMS * sizeof(int)); + for (int i = 0; i < ROW_NUMS; i++) { + ts_len[i] = sizeof(int64_t); + b_len[i] = 1; + } + for (int i = 0; i < CTB_NUMS; i++) { + ts[i] = (int64_t*)taosMemoryMalloc(ROW_NUMS * sizeof(int64_t)); + b[i] = (char*)taosMemoryMalloc(ROW_NUMS * sizeof(char)); + for (int j = 0; j < ROW_NUMS; j++) { + ts[i][j] = 1591060628000 + r * 100000 + j; + b[i][j] = 'a' + j; + } + } + // tag params + int t1 = 0; + int t1len = sizeof(int); + int t2len = 3; + // TAOS_STMT2_BIND* tagv[2] = {&tags[0][0], &tags[1][0]}; + + // bind params + TAOS_STMT2_BIND** paramv = (TAOS_STMT2_BIND**)taosMemoryMalloc(CTB_NUMS * sizeof(TAOS_STMT2_BIND*)); + TAOS_STMT2_BIND** tags = (TAOS_STMT2_BIND**)taosMemoryMalloc(CTB_NUMS * sizeof(TAOS_STMT2_BIND*)); + for (int i = 0; i < CTB_NUMS; i++) { + // create tags + tags[i] = (TAOS_STMT2_BIND*)taosMemoryMalloc(2 * sizeof(TAOS_STMT2_BIND)); + tags[i][0] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_INT, &t1, &t1len, NULL, 0}; + tags[i][1] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_BINARY, (void*)"after", &t2len, NULL, 0}; + + // create col params + paramv[i] = (TAOS_STMT2_BIND*)taosMemoryMalloc(2 * sizeof(TAOS_STMT2_BIND)); + paramv[i][0] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_TIMESTAMP, &ts[i][0], &ts_len[0], NULL, ROW_NUMS}; + paramv[i][1] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_BINARY, &b[i][0], &b_len[0], NULL, ROW_NUMS}; + } + // bind + TAOS_STMT2_BINDV bindv = {CTB_NUMS, tbs, tags, paramv}; + code = taos_stmt2_bind_param(stmt, &bindv, -1); + ASSERT_EQ(code, 0); + ASSERT_EQ(errno, 0); + + // exec + code = taos_stmt2_exec(stmt, NULL); + ASSERT_EQ(code, 0); + ASSERT_EQ(errno, 0); + + for (int i = 0; i < CTB_NUMS; i++) { + taosMemoryFree(tags[i]); + taosMemoryFree(paramv[i]); + taosMemoryFree(ts[i]); + taosMemoryFree(b[i]); + } + taosMemoryFree(ts); + taosMemoryFree(b); + taosMemoryFree(ts_len); + taosMemoryFree(b_len); + taosMemoryFree(paramv); + taosMemoryFree(tags); + } + for (int i = 0; i < CTB_NUMS; i++) { + taosMemoryFree(tbs[i]); + } + taosMemoryFree(tbs); + + taos_stmt2_close(stmt); +} } // namespace @@ -665,6 +750,7 @@ TEST(stmt2Case, get_fields_error_Test) { TEST(stmt2Case, stmt2_init_prepare_Test) { TAOS* taos = taos_connect("localhost", "root", "taosdata", NULL, 0); + ASSERT_NE(taos, nullptr); { (void)taos_stmt2_init(NULL, NULL); ASSERT_EQ(terrno, TSDB_CODE_INVALID_PARA); @@ -711,6 +797,15 @@ TEST(stmt2Case, stmt2_init_prepare_Test) { } } +TEST(stmt2Case, stmt2_all) { + TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); + ASSERT_NE(taos, nullptr); + + { do_stmt(taos, "insert into db.stb (tbname,ts,b,t1,t2) values(?,?,?,?,?)", 3, 3, 3, true); } + taos_close(taos); + taos_cleanup(); +} + TEST(stmt2Case, stmt2_status_Test) {} #pragma GCC diagnostic pop From de62d9bb836745035e7d477ddcae0283888fef24 Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Fri, 27 Dec 2024 10:44:02 +0800 Subject: [PATCH 05/13] fix some case --- source/client/test/stmt2Test.cpp | 34 +++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-) diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index 4542f953ab..ada3b66dc9 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -33,6 +33,19 @@ #include "taos.h" namespace { + +void checkRows(TAOS* pConn, const char* sql, int32_t expectedRows) { + TAOS_RES* pRes = taos_query(pConn, sql); + ASSERT_EQ(taos_errno(pRes), TSDB_CODE_SUCCESS); + TAOS_ROW pRow = NULL; + int rows = 0; + while ((pRow = taos_fetch_row(pRes)) != NULL) { + rows++; + } + ASSERT_EQ(rows, expectedRows); + taos_free_result(pRes); +} + void stmtAsyncQueryCb(void* param, TAOS_RES* pRes, int code) { int affected_rows = taos_affected_rows(pRes); return; @@ -186,6 +199,8 @@ void do_stmt(TAOS* taos, const char* sql, int CTB_NUMS, int ROW_NUMS, int CYC_NU taosMemoryFree(paramv); taosMemoryFree(tags); } + + checkRows(taos, "select * from db.stb", CYC_NUMS * ROW_NUMS * CTB_NUMS); for (int i = 0; i < CTB_NUMS; i++) { taosMemoryFree(tbs[i]); } @@ -352,11 +367,11 @@ TEST(stmt2Case, insert_stb_get_fields_Test) { printf("not support case \n"); // case 5 : add in main TD-33353 - // { - // const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(1,?,?,'abc',?)"; - // printf("case 2 : %s\n", sql); - // getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); - // } + { + const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(1,?,?,'abc',?)"; + printf("case 2 : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + } // case 2 : no pk { @@ -411,11 +426,10 @@ TEST(stmt2Case, insert_stb_get_fields_Test) { { const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(*,*,*,*,*)"; printf("case 9 : %s\n", sql); - getFieldsError(taos, sql, TSDB_CODE_TSC_SQL_SYNTAX_ERROR); + getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); } taos_close(taos); - taos_cleanup(); } TEST(stmt2Case, insert_ctb_using_get_fields_Test) { @@ -616,6 +630,7 @@ TEST(stmt2Case, insert_ctb_using_get_fields_Test) { printf("case 5 : %s\n", sql); getFieldsError(taos, sql, TSDB_CODE_TSC_SQL_SYNTAX_ERROR); } + taos_close(taos); } TEST(stmt2Case, insert_ntb_get_fields_Test) { @@ -737,6 +752,7 @@ TEST(stmt2Case, select_get_fields_Test) { printf("case 3 : %s\n", sql); getFieldsError(taos, sql, TSDB_CODE_PAR_SYNTAX_ERROR); } + taos_close(taos); } TEST(stmt2Case, get_fields_error_Test) { @@ -776,7 +792,7 @@ TEST(stmt2Case, stmt2_init_prepare_Test) { code = taos_stmt2_prepare(stmt, "insert into 'db'.stb(t1,t2,ts,b,tbname) values(?,?,?,?,?)", 0); ASSERT_EQ(terrno, 0); ASSERT_NE(stmt, nullptr); - // ASSERT_STREQ(((STscStmt2*)stmt)->db, "db"); //add in main TD-33332 + ASSERT_STREQ(((STscStmt2*)stmt)->db, "db"); // add in main TD-33332 taos_stmt2_close(stmt); } @@ -795,6 +811,7 @@ TEST(stmt2Case, stmt2_init_prepare_Test) { ASSERT_NE(stmt, nullptr); taos_stmt2_close(stmt); } + taos_close(taos); } TEST(stmt2Case, stmt2_all) { @@ -803,7 +820,6 @@ TEST(stmt2Case, stmt2_all) { { do_stmt(taos, "insert into db.stb (tbname,ts,b,t1,t2) values(?,?,?,?,?)", 3, 3, 3, true); } taos_close(taos); - taos_cleanup(); } TEST(stmt2Case, stmt2_status_Test) {} From 42410d6c85034aa18a61ac309ee4afa30cf553e7 Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Fri, 27 Dec 2024 15:25:42 +0800 Subject: [PATCH 06/13] only linux run stmt2Test --- source/client/test/CMakeLists.txt | 11 +++++------ source/client/test/stmt2Test.cpp | 8 ++++---- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/source/client/test/CMakeLists.txt b/source/client/test/CMakeLists.txt index 62b7bb3e91..ce1cc064db 100644 --- a/source/client/test/CMakeLists.txt +++ b/source/client/test/CMakeLists.txt @@ -68,6 +68,10 @@ IF(${TD_LINUX}) NAME connectOptionsTest COMMAND connectOptionsTest ) + add_test( + NAME stmt2Test + COMMAND stmt2Test + ) ENDIF () TARGET_INCLUDE_DIRECTORIES( @@ -107,9 +111,4 @@ add_test( add_test( NAME userOperTest COMMAND userOperTest -) - -add_test( - NAME stmt2Test - COMMAND stmt2Test -) +) \ No newline at end of file diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index ada3b66dc9..4fea2452d0 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -167,13 +167,13 @@ void do_stmt(TAOS* taos, const char* sql, int CTB_NUMS, int ROW_NUMS, int CYC_NU for (int i = 0; i < CTB_NUMS; i++) { // create tags tags[i] = (TAOS_STMT2_BIND*)taosMemoryMalloc(2 * sizeof(TAOS_STMT2_BIND)); - tags[i][0] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_INT, &t1, &t1len, NULL, 0}; - tags[i][1] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_BINARY, (void*)"after", &t2len, NULL, 0}; + tags[i][0] = {TSDB_DATA_TYPE_INT, &t1, &t1len, NULL, 0}; + tags[i][1] = {TSDB_DATA_TYPE_BINARY, (void*)"after", &t2len, NULL, 0}; // create col params paramv[i] = (TAOS_STMT2_BIND*)taosMemoryMalloc(2 * sizeof(TAOS_STMT2_BIND)); - paramv[i][0] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_TIMESTAMP, &ts[i][0], &ts_len[0], NULL, ROW_NUMS}; - paramv[i][1] = (TAOS_STMT2_BIND){TSDB_DATA_TYPE_BINARY, &b[i][0], &b_len[0], NULL, ROW_NUMS}; + paramv[i][0] = {TSDB_DATA_TYPE_TIMESTAMP, &ts[i][0], &ts_len[0], NULL, ROW_NUMS}; + paramv[i][1] = {TSDB_DATA_TYPE_BINARY, &b[i][0], &b_len[0], NULL, ROW_NUMS}; } // bind TAOS_STMT2_BINDV bindv = {CTB_NUMS, tbs, tags, paramv}; From eafbe63683c59ae85cf52bbbf145fcf2959839aa Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Mon, 30 Dec 2024 11:14:05 +0800 Subject: [PATCH 07/13] add case --- source/client/test/stmt2Test.cpp | 160 ++++++++++++++++++++++++++++--- 1 file changed, 146 insertions(+), 14 deletions(-) diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index 4fea2452d0..b31ed9b2e4 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -112,15 +112,14 @@ void do_query(TAOS* taos, const char* sql) { taos_free_result(result); } -void do_stmt(TAOS* taos, const char* sql, int CTB_NUMS, int ROW_NUMS, int CYC_NUMS, bool createTable) { +void do_stmt(TAOS* taos, TAOS_STMT2_OPTION* option, const char* sql, int CTB_NUMS, int ROW_NUMS, int CYC_NUMS, + bool hastags, bool createTable) { 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))"); do_query(taos, "use db"); - TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL}; - - TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + TAOS_STMT2* stmt = taos_stmt2_init(taos, option); ASSERT_NE(stmt, nullptr); int code = taos_stmt2_prepare(stmt, sql, 0); ASSERT_EQ(code, 0); @@ -163,13 +162,18 @@ void do_stmt(TAOS* taos, const char* sql, int CTB_NUMS, int ROW_NUMS, int CYC_NU // bind params TAOS_STMT2_BIND** paramv = (TAOS_STMT2_BIND**)taosMemoryMalloc(CTB_NUMS * sizeof(TAOS_STMT2_BIND*)); - TAOS_STMT2_BIND** tags = (TAOS_STMT2_BIND**)taosMemoryMalloc(CTB_NUMS * sizeof(TAOS_STMT2_BIND*)); - for (int i = 0; i < CTB_NUMS; i++) { - // create tags - tags[i] = (TAOS_STMT2_BIND*)taosMemoryMalloc(2 * sizeof(TAOS_STMT2_BIND)); - tags[i][0] = {TSDB_DATA_TYPE_INT, &t1, &t1len, NULL, 0}; - tags[i][1] = {TSDB_DATA_TYPE_BINARY, (void*)"after", &t2len, NULL, 0}; + TAOS_STMT2_BIND** tags = NULL; + if (hastags) { + tags = (TAOS_STMT2_BIND**)taosMemoryMalloc(CTB_NUMS * sizeof(TAOS_STMT2_BIND*)); + for (int i = 0; i < CTB_NUMS; i++) { + // create tags + tags[i] = (TAOS_STMT2_BIND*)taosMemoryMalloc(2 * sizeof(TAOS_STMT2_BIND)); + tags[i][0] = {TSDB_DATA_TYPE_INT, &t1, &t1len, NULL, 0}; + tags[i][1] = {TSDB_DATA_TYPE_BINARY, (void*)"after", &t2len, NULL, 0}; + } + } + for (int i = 0; i < CTB_NUMS; i++) { // create col params paramv[i] = (TAOS_STMT2_BIND*)taosMemoryMalloc(2 * sizeof(TAOS_STMT2_BIND)); paramv[i][0] = {TSDB_DATA_TYPE_TIMESTAMP, &ts[i][0], &ts_len[0], NULL, ROW_NUMS}; @@ -187,7 +191,9 @@ void do_stmt(TAOS* taos, const char* sql, int CTB_NUMS, int ROW_NUMS, int CYC_NU ASSERT_EQ(errno, 0); for (int i = 0; i < CTB_NUMS; i++) { - taosMemoryFree(tags[i]); + if (hastags) { + taosMemoryFree(tags[i]); + } taosMemoryFree(paramv[i]); taosMemoryFree(ts[i]); taosMemoryFree(b[i]); @@ -197,7 +203,9 @@ void do_stmt(TAOS* taos, const char* sql, int CTB_NUMS, int ROW_NUMS, int CYC_NU taosMemoryFree(ts_len); taosMemoryFree(b_len); taosMemoryFree(paramv); - taosMemoryFree(tags); + if (hastags) { + taosMemoryFree(tags); + } } checkRows(taos, "select * from db.stb", CYC_NUMS * ROW_NUMS * CTB_NUMS); @@ -814,11 +822,135 @@ TEST(stmt2Case, stmt2_init_prepare_Test) { taos_close(taos); } -TEST(stmt2Case, stmt2_all) { +TEST(stmt2Case, stmt2_insert) { TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); ASSERT_NE(taos, nullptr); + TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL}; + { do_stmt(taos, &option, "insert into db.stb (tbname,ts,b,t1,t2) values(?,?,?,?,?)", 3, 3, 3, true, true); } + option = {0, true, true, stmtAsyncQueryCb, NULL}; + { do_stmt(taos, &option, "insert into db.? using db.stb tags(?,?) values(?,?)", 3, 3, 3, true, true); } + option = {0, false, false, NULL, NULL}; + { do_stmt(taos, &option, "insert into stb (tbname,ts,b,t1,t2) values(?,?,?,?,?)", 3, 3, 3, true, false); } + option = {0, true, true, NULL, NULL}; + { do_stmt(taos, &option, "insert into db.stb (tbname,ts,b) values(?,?,?)", 3, 3, 3, false, true); } - { do_stmt(taos, "insert into db.stb (tbname,ts,b,t1,t2) values(?,?,?,?,?)", 3, 3, 3, true); } + taos_close(taos); +} + +TEST(stmt2Case, stmt2_query) { + TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); + ASSERT_NE(taos, nullptr); + 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))"); + do_query(taos, + "insert into db.tb1 using db.stb tags(1,'abc') values(1591060628000, " + "'abc'),(1591060628001,'def'),(1591060628002, 'hij')"); + do_query(taos, + "insert into db.tb2 using db.stb tags(2,'xyz') values(1591060628000, " + "'abc'),(1591060628001,'def'),(1591060628002, 'hij')"); + do_query(taos, "use db"); + + TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL}; + + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + ASSERT_NE(stmt, nullptr); + + const char* sql = "select * from db.stb where ts = ?"; + int code = taos_stmt2_prepare(stmt, sql, 0); + ASSERT_EQ(code, 0); + ASSERT_EQ(terrno, 0); + + int t64_len[2] = {sizeof(int64_t), sizeof(int64_t)}; + int b_len[2] = {5, 5}; + int64_t ts = 1591060628000; + TAOS_STMT2_BIND params[2] = {{TSDB_DATA_TYPE_TIMESTAMP, &ts, t64_len, NULL, 1}, + {TSDB_DATA_TYPE_BINARY, (void*)"tb1", b_len, NULL, 1}}; + TAOS_STMT2_BIND* paramv = ¶ms[0]; + TAOS_STMT2_BINDV bindv = {1, NULL, NULL, ¶mv}; + taos_stmt2_bind_param(stmt, &bindv, -1); + ASSERT_EQ(code, 0); + ASSERT_EQ(errno, 0); + + taos_stmt2_exec(stmt, NULL); + ASSERT_EQ(code, 0); + ASSERT_EQ(errno, 0); + + taos_stmt2_close(stmt); + taos_close(taos); +} + +TEST(stmt2Case, stmt2_interlace) { + TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); + ASSERT_NE(taos, nullptr); + TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL}; + do_query(taos, "drop database if exists db1"); + do_query(taos, "create database db1"); + do_query(taos, "create table db1.ntb(ts timestamp, b binary(10))"); + do_query(taos, "use db1"); + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + ASSERT_NE(stmt, nullptr); + + const char* sql = "insert into db1.ntb values(?,?)"; + int code = taos_stmt2_prepare(stmt, sql, 0); + ASSERT_EQ(code, 0); + ASSERT_EQ(terrno, 0); + + + for (int r = 0; r < 3; r++) { + // col params + int64_t** ts = (int64_t**)taosMemoryMalloc(3 * sizeof(int64_t*)); + char** b = (char**)taosMemoryMalloc(3 * sizeof(char*)); + int* ts_len = (int*)taosMemoryMalloc(3 * sizeof(int)); + int* b_len = (int*)taosMemoryMalloc(3 * sizeof(int)); + for (int i = 0; i < 3; i++) { + ts_len[i] = sizeof(int64_t); + b_len[i] = 1; + } + for (int i = 0; i < 3; i++) { + ts[i] = (int64_t*)taosMemoryMalloc(3 * sizeof(int64_t)); + b[i] = (char*)taosMemoryMalloc(3 * sizeof(char)); + for (int j = 0; j < 3; j++) { + ts[i][j] = 1591060628000 + r * 100000 + j; + b[i][j] = 'a' + j; + } + } + + // bind params + TAOS_STMT2_BIND** paramv = (TAOS_STMT2_BIND**)taosMemoryMalloc(3 * sizeof(TAOS_STMT2_BIND*)); + + for (int i = 0; i < 3; i++) { + // create col params + paramv[i] = (TAOS_STMT2_BIND*)taosMemoryMalloc(2 * sizeof(TAOS_STMT2_BIND)); + paramv[i][0] = {TSDB_DATA_TYPE_TIMESTAMP, &ts[i][0], &ts_len[0], NULL, 3}; + paramv[i][1] = {TSDB_DATA_TYPE_BINARY, &b[i][0], &b_len[0], NULL, 3}; + } + // bind + TAOS_STMT2_BINDV bindv = {1, NULL, NULL, paramv}; + code = taos_stmt2_bind_param(stmt, &bindv, -1); + ASSERT_EQ(code, 0); + ASSERT_EQ(errno, 0); + + // exec + code = taos_stmt2_exec(stmt, NULL); + ASSERT_EQ(code, 0); + ASSERT_EQ(errno, 0); + + for (int i = 0; i < 3; i++) { + taosMemoryFree(paramv[i]); + taosMemoryFree(ts[i]); + taosMemoryFree(b[i]); + } + taosMemoryFree(ts); + taosMemoryFree(b); + taosMemoryFree(ts_len); + taosMemoryFree(b_len); + taosMemoryFree(paramv); + } + + checkRows(taos, "select * from db1.ntb", 9); + + taos_stmt2_close(stmt); taos_close(taos); } From 8d3c0a8d912d117705efc7c777721ced8958135a Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Mon, 30 Dec 2024 17:43:36 +0800 Subject: [PATCH 08/13] refactor stmt2 stb interlace mode --- source/client/src/clientStmt2.c | 208 ++++++++++++++++--------------- source/client/test/stmt2Test.cpp | 69 +++------- 2 files changed, 124 insertions(+), 153 deletions(-) diff --git a/source/client/src/clientStmt2.c b/source/client/src/clientStmt2.c index 820a7a0110..5992493e5b 100644 --- a/source/client/src/clientStmt2.c +++ b/source/client/src/clientStmt2.c @@ -58,13 +58,13 @@ static bool stmtDequeue(STscStmt2* pStmt, SStmtQNode** param) { return true; } -static void stmtEnqueue(STscStmt2* pStmt, SStmtQNode* param) { - pStmt->queue.tail->next = param; - pStmt->queue.tail = param; +// static void stmtEnqueue(STscStmt2* pStmt, SStmtQNode* param) { +// pStmt->queue.tail->next = param; +// pStmt->queue.tail = param; - pStmt->stat.bindDataNum++; - (void)atomic_add_fetch_64((int64_t*)&pStmt->queue.qRemainNum, 1); -} +// pStmt->stat.bindDataNum++; +// (void)atomic_add_fetch_64((int64_t*)&pStmt->queue.qRemainNum, 1); +// } static int32_t stmtCreateRequest(STscStmt2* pStmt) { int32_t code = 0; @@ -76,7 +76,7 @@ static int32_t stmtCreateRequest(STscStmt2* pStmt) { pStmt->reqid++; } if (pStmt->db != NULL) { - taosMemoryFreeClear(pStmt->exec.pRequest->pDb); + taosMemoryFreeClear(pStmt->exec.pRequest->pDb); pStmt->exec.pRequest->pDb = taosStrdup(pStmt->db); } if (TSDB_CODE_SUCCESS == code) { @@ -325,10 +325,10 @@ static int32_t stmtCleanBindInfo(STscStmt2* pStmt) { return TSDB_CODE_SUCCESS; } -static void stmtFreeTableBlkList(STableColsData* pTb) { - (void)qResetStmtColumns(pTb->aCol, true); - taosArrayDestroy(pTb->aCol); -} +// 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); @@ -895,32 +895,32 @@ int stmtPrepare2(TAOS_STMT2* stmt, const char* sql, unsigned long length) { 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 terrno; - } - STableDataCxt* pDst = NULL; +// static int32_t stmtInitStbInterlaceTableInfo(STscStmt2* pStmt) { +// STableDataCxt** pSrc = taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); +// if (!pSrc) { +// return terrno; +// } +// STableDataCxt* pDst = NULL; - STMT_ERR_RET(qCloneStmtDataBlock(&pDst, *pSrc, true)); - pStmt->sql.siInfo.pDataCtx = pDst; +// 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 terrno; - } +// SArray* pTblCols = NULL; +// for (int32_t i = 0; i < STMT_TABLE_COLS_NUM; i++) { +// pTblCols = taosArrayInit(20, POINTER_BYTES); +// if (NULL == pTblCols) { +// return terrno; +// } - if (taosArrayPush(pStmt->sql.siInfo.pTableCols, &pTblCols) == NULL) { - return terrno; - } - } +// if (taosArrayPush(pStmt->sql.siInfo.pTableCols, &pTblCols) == NULL) { +// return terrno; +// } +// } - pStmt->sql.siInfo.boundTags = pStmt->bInfo.boundTags; +// pStmt->sql.siInfo.boundTags = pStmt->bInfo.boundTags; - return TSDB_CODE_SUCCESS; -} +// return TSDB_CODE_SUCCESS; +// } int stmtIsInsert2(TAOS_STMT2* stmt, int* insert) { STscStmt2* pStmt = (STscStmt2*)stmt; @@ -979,7 +979,7 @@ int stmtSetTbName2(TAOS_STMT2* stmt, const char* tbName) { } if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { - STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); + // STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); } int64_t startUs2 = taosGetTimestampUs(); @@ -1009,7 +1009,7 @@ int stmtSetTbTags2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* tags) { STMT_ERR_RET(stmtParseSql(pStmt)); } if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { - STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); + // STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); } SBoundColInfo* tags_info = (SBoundColInfo*)pStmt->bInfo.boundTags; @@ -1037,33 +1037,33 @@ int stmtSetTbTags2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* tags) { 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; - } +// 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); - } +// 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; +// 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); - } - } +// 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)); +// STMT_ERR_RET(qBuildStmtColFields(*pDataBlock, fieldNum, fields)); - return TSDB_CODE_SUCCESS; -} +// return TSDB_CODE_SUCCESS; +// } static int stmtFetchStbColFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIELD_ALL** fields) { if (pStmt->errCode != TSDB_CODE_SUCCESS) { @@ -1117,46 +1117,46 @@ SArray* stmtGetFreeCol(STscStmt2* pStmt, int32_t* idx) { } } */ -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); - } +// 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 (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; +// 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; - } +// 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 (!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]) { - tstrncpy(pStmt->sql.siInfo.firstName, pStmt->bInfo.tbName, TSDB_TABLE_NAME_LEN); - } +// if (0 == pStmt->sql.siInfo.firstName[0]) { +// tstrncpy(pStmt->sql.siInfo.firstName, pStmt->bInfo.tbName, TSDB_TABLE_NAME_LEN); +// } - param->tblData.getFromHash = pStmt->sql.siInfo.tbFromHash; - param->next = NULL; +// param->tblData.getFromHash = pStmt->sql.siInfo.tbFromHash; +// param->next = NULL; - (void)atomic_add_fetch_64(&pStmt->sql.siInfo.tbRemainNum, 1); +// (void)atomic_add_fetch_64(&pStmt->sql.siInfo.tbRemainNum, 1); - stmtEnqueue(pStmt, param); +// stmtEnqueue(pStmt, param); - return TSDB_CODE_SUCCESS; -} +// return TSDB_CODE_SUCCESS; +// } static FORCE_INLINE int32_t stmtGetTableColsFromCache(STscStmt2* pStmt, SArray** pTableCols) { while (true) { @@ -1233,19 +1233,20 @@ static int stmtAddBatch2(TAOS_STMT2* stmt) { STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_ADD_BATCH)); if (pStmt->sql.stbInterlaceMode) { - int64_t startUs2 = taosGetTimestampUs(); - pStmt->stat.addBatchUs += startUs2 - startUs; + // todo:add stb interlace mode + // int64_t startUs2 = taosGetTimestampUs(); + // pStmt->stat.addBatchUs += startUs2 - startUs; - pStmt->sql.siInfo.tableColsReady = false; + // pStmt->sql.siInfo.tableColsReady = false; - SStmtQNode* param = NULL; - STMT_ERR_RET(stmtAllocQNodeFromBuf(&pStmt->sql.siInfo.tbBuf, (void**)¶m)); - param->restoreTbCols = true; - param->next = NULL; + // SStmtQNode* param = NULL; + // STMT_ERR_RET(stmtAllocQNodeFromBuf(&pStmt->sql.siInfo.tbBuf, (void**)¶m)); + // param->restoreTbCols = true; + // param->next = NULL; - stmtEnqueue(pStmt, param); + // stmtEnqueue(pStmt, param); - return TSDB_CODE_SUCCESS; + // return TSDB_CODE_SUCCESS; } STMT_ERR_RET(stmtCacheBlock(pStmt)); @@ -1366,7 +1367,7 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { } if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { - STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); + // STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); } STableDataCxt** pDataBlock = NULL; @@ -1450,7 +1451,8 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { pStmt->stat.bindDataUs3 += startUs4 - startUs3; if (pStmt->sql.stbInterlaceMode) { - STMT_ERR_RET(stmtAppendTablePostHandle(pStmt, param)); + // to do + // STMT_ERR_RET(stmtAppendTablePostHandle(pStmt, param)); } else { STMT_ERR_RET(stmtAddBatch2(pStmt)); } @@ -1876,11 +1878,11 @@ int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums) { 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)); - } + // 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; } diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index b31ed9b2e4..03eed54f77 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -880,75 +880,44 @@ TEST(stmt2Case, stmt2_query) { taos_close(taos); } -TEST(stmt2Case, stmt2_interlace) { +TEST(stmt2Case, stmt2_ntb_insert) { TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); ASSERT_NE(taos, nullptr); TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL}; - do_query(taos, "drop database if exists db1"); - do_query(taos, "create database db1"); - do_query(taos, "create table db1.ntb(ts timestamp, b binary(10))"); - do_query(taos, "use db1"); + do_query(taos, "drop database if exists db"); + do_query(taos, "create database db"); + do_query(taos, "create table db.ntb(ts timestamp, b binary(10))"); + do_query(taos, "use db"); TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); ASSERT_NE(stmt, nullptr); - const char* sql = "insert into db1.ntb values(?,?)"; + const char* sql = "insert into db.ntb values(?,?)"; int code = taos_stmt2_prepare(stmt, sql, 0); ASSERT_EQ(code, 0); ASSERT_EQ(terrno, 0); + for (int i = 0; i < 3; i++) { + int64_t ts[3] = {1591060628000 + i * 3, 1591060628001 + i * 3, 1591060628002 + i * 3}; + int t64_len[3] = {sizeof(int64_t), sizeof(int64_t), sizeof(int64_t)}; + int b_len[3] = {5,5,5}; + TAOS_STMT2_BIND params1 = {TSDB_DATA_TYPE_TIMESTAMP, &ts[0], &t64_len[0], NULL, 3}; + TAOS_STMT2_BIND params2 = {TSDB_DATA_TYPE_BINARY, (void*)"abcdefghijklmnopqrstuvwxyz", &b_len[0], NULL, 3}; + TAOS_STMT2_BIND* paramv1 = ¶ms1; + TAOS_STMT2_BIND* paramv2 = ¶ms2; - for (int r = 0; r < 3; r++) { - // col params - int64_t** ts = (int64_t**)taosMemoryMalloc(3 * sizeof(int64_t*)); - char** b = (char**)taosMemoryMalloc(3 * sizeof(char*)); - int* ts_len = (int*)taosMemoryMalloc(3 * sizeof(int)); - int* b_len = (int*)taosMemoryMalloc(3 * sizeof(int)); - for (int i = 0; i < 3; i++) { - ts_len[i] = sizeof(int64_t); - b_len[i] = 1; - } - for (int i = 0; i < 3; i++) { - ts[i] = (int64_t*)taosMemoryMalloc(3 * sizeof(int64_t)); - b[i] = (char*)taosMemoryMalloc(3 * sizeof(char)); - for (int j = 0; j < 3; j++) { - ts[i][j] = 1591060628000 + r * 100000 + j; - b[i][j] = 'a' + j; - } - } + TAOS_STMT2_BINDV bindv1 = {1, NULL, NULL, ¶mv1}; + TAOS_STMT2_BINDV bindv2 = {1, NULL, NULL, ¶mv2}; - // bind params - TAOS_STMT2_BIND** paramv = (TAOS_STMT2_BIND**)taosMemoryMalloc(3 * sizeof(TAOS_STMT2_BIND*)); - - for (int i = 0; i < 3; i++) { - // create col params - paramv[i] = (TAOS_STMT2_BIND*)taosMemoryMalloc(2 * sizeof(TAOS_STMT2_BIND)); - paramv[i][0] = {TSDB_DATA_TYPE_TIMESTAMP, &ts[i][0], &ts_len[0], NULL, 3}; - paramv[i][1] = {TSDB_DATA_TYPE_BINARY, &b[i][0], &b_len[0], NULL, 3}; - } - // bind - TAOS_STMT2_BINDV bindv = {1, NULL, NULL, paramv}; - code = taos_stmt2_bind_param(stmt, &bindv, -1); + taos_stmt2_bind_param(stmt, &bindv1, 0); + taos_stmt2_bind_param(stmt, &bindv2, 1); ASSERT_EQ(code, 0); ASSERT_EQ(errno, 0); - // exec code = taos_stmt2_exec(stmt, NULL); ASSERT_EQ(code, 0); ASSERT_EQ(errno, 0); - - for (int i = 0; i < 3; i++) { - taosMemoryFree(paramv[i]); - taosMemoryFree(ts[i]); - taosMemoryFree(b[i]); - } - taosMemoryFree(ts); - taosMemoryFree(b); - taosMemoryFree(ts_len); - taosMemoryFree(b_len); - taosMemoryFree(paramv); } - - checkRows(taos, "select * from db1.ntb", 9); + checkRows(taos, "select * from db.ntb", 9); taos_stmt2_close(stmt); taos_close(taos); From 2ca9035b6f1149cfd68cea43243cfa82620f5526 Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Mon, 30 Dec 2024 20:41:44 +0800 Subject: [PATCH 09/13] add test case --- source/client/test/stmt2Test.cpp | 68 ++++++++++++++++++++++---------- 1 file changed, 47 insertions(+), 21 deletions(-) diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index 03eed54f77..45919be726 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -123,7 +123,6 @@ void do_stmt(TAOS* taos, TAOS_STMT2_OPTION* option, const char* sql, int CTB_NUM ASSERT_NE(stmt, nullptr); int code = taos_stmt2_prepare(stmt, sql, 0); ASSERT_EQ(code, 0); - ASSERT_EQ(terrno, 0); // tbname char** tbs = (char**)taosMemoryMalloc(CTB_NUMS * sizeof(char*)); @@ -183,12 +182,10 @@ void do_stmt(TAOS* taos, TAOS_STMT2_OPTION* option, const char* sql, int CTB_NUM TAOS_STMT2_BINDV bindv = {CTB_NUMS, tbs, tags, paramv}; code = taos_stmt2_bind_param(stmt, &bindv, -1); ASSERT_EQ(code, 0); - ASSERT_EQ(errno, 0); // exec code = taos_stmt2_exec(stmt, NULL); ASSERT_EQ(code, 0); - ASSERT_EQ(errno, 0); for (int i = 0; i < CTB_NUMS; i++) { if (hastags) { @@ -793,12 +790,10 @@ TEST(stmt2Case, stmt2_init_prepare_Test) { ASSERT_EQ(terrno, 0); ASSERT_NE(stmt, nullptr); int code = taos_stmt2_prepare(stmt, "wrong sql", 0); - ASSERT_EQ(terrno, 0); ASSERT_NE(stmt, nullptr); ASSERT_EQ(((STscStmt2*)stmt)->db, nullptr); code = taos_stmt2_prepare(stmt, "insert into 'db'.stb(t1,t2,ts,b,tbname) values(?,?,?,?,?)", 0); - ASSERT_EQ(terrno, 0); ASSERT_NE(stmt, nullptr); ASSERT_STREQ(((STscStmt2*)stmt)->db, "db"); // add in main TD-33332 taos_stmt2_close(stmt); @@ -807,7 +802,6 @@ TEST(stmt2Case, stmt2_init_prepare_Test) { { TAOS_STMT2_OPTION option = {0, true, false, NULL, NULL}; TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); - ASSERT_EQ(terrno, 0); ASSERT_NE(stmt, nullptr); taos_stmt2_close(stmt); } @@ -815,7 +809,6 @@ TEST(stmt2Case, stmt2_init_prepare_Test) { { TAOS_STMT2_OPTION option = {0, true, true, stmtAsyncQueryCb, NULL}; TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); - ASSERT_EQ(terrno, 0); ASSERT_NE(stmt, nullptr); taos_stmt2_close(stmt); } @@ -856,25 +849,33 @@ TEST(stmt2Case, stmt2_query) { TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); ASSERT_NE(stmt, nullptr); - const char* sql = "select * from db.stb where ts = ?"; + const char* sql = "select * from db.stb where ts = ? and tbname = ?"; int code = taos_stmt2_prepare(stmt, sql, 0); ASSERT_EQ(code, 0); - ASSERT_EQ(terrno, 0); - int t64_len[2] = {sizeof(int64_t), sizeof(int64_t)}; - int b_len[2] = {5, 5}; + int t64_len[1] = {sizeof(int64_t)}; + int b_len[1] = {3}; int64_t ts = 1591060628000; TAOS_STMT2_BIND params[2] = {{TSDB_DATA_TYPE_TIMESTAMP, &ts, t64_len, NULL, 1}, {TSDB_DATA_TYPE_BINARY, (void*)"tb1", b_len, NULL, 1}}; TAOS_STMT2_BIND* paramv = ¶ms[0]; TAOS_STMT2_BINDV bindv = {1, NULL, NULL, ¶mv}; - taos_stmt2_bind_param(stmt, &bindv, -1); + code = taos_stmt2_bind_param(stmt, &bindv, -1); ASSERT_EQ(code, 0); - ASSERT_EQ(errno, 0); taos_stmt2_exec(stmt, NULL); ASSERT_EQ(code, 0); - ASSERT_EQ(errno, 0); + + TAOS_RES* pRes = taos_stmt2_result(stmt); + ASSERT_NE(pRes, nullptr); + + int getRecordCounts = 0; + TAOS_ROW row; + while ((row = taos_fetch_row(pRes))) { + getRecordCounts++; + } + ASSERT_EQ(getRecordCounts, 1); + taos_free_result(pRes); taos_stmt2_close(stmt); taos_close(taos); @@ -894,11 +895,10 @@ TEST(stmt2Case, stmt2_ntb_insert) { const char* sql = "insert into db.ntb values(?,?)"; int code = taos_stmt2_prepare(stmt, sql, 0); ASSERT_EQ(code, 0); - ASSERT_EQ(terrno, 0); for (int i = 0; i < 3; i++) { int64_t ts[3] = {1591060628000 + i * 3, 1591060628001 + i * 3, 1591060628002 + i * 3}; int t64_len[3] = {sizeof(int64_t), sizeof(int64_t), sizeof(int64_t)}; - int b_len[3] = {5,5,5}; + int b_len[3] = {5, 5, 5}; TAOS_STMT2_BIND params1 = {TSDB_DATA_TYPE_TIMESTAMP, &ts[0], &t64_len[0], NULL, 3}; TAOS_STMT2_BIND params2 = {TSDB_DATA_TYPE_BINARY, (void*)"abcdefghijklmnopqrstuvwxyz", &b_len[0], NULL, 3}; @@ -908,14 +908,12 @@ TEST(stmt2Case, stmt2_ntb_insert) { TAOS_STMT2_BINDV bindv1 = {1, NULL, NULL, ¶mv1}; TAOS_STMT2_BINDV bindv2 = {1, NULL, NULL, ¶mv2}; - taos_stmt2_bind_param(stmt, &bindv1, 0); - taos_stmt2_bind_param(stmt, &bindv2, 1); + code = taos_stmt2_bind_param(stmt, &bindv1, 0); + code = taos_stmt2_bind_param(stmt, &bindv2, 1); ASSERT_EQ(code, 0); - ASSERT_EQ(errno, 0); code = taos_stmt2_exec(stmt, NULL); ASSERT_EQ(code, 0); - ASSERT_EQ(errno, 0); } checkRows(taos, "select * from db.ntb", 9); @@ -923,6 +921,34 @@ TEST(stmt2Case, stmt2_ntb_insert) { taos_close(taos); } -TEST(stmt2Case, stmt2_status_Test) {} +TEST(stmt2Case, stmt2_status_Test) { + TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); + ASSERT_NE(taos, nullptr); + TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL}; + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + + int64_t ts[3] = {1591060628000, 1591060628001, 1591060628002}; + int t64_len[3] = {sizeof(int64_t), sizeof(int64_t), sizeof(int64_t)}; + + TAOS_STMT2_BIND params = {TSDB_DATA_TYPE_TIMESTAMP, &ts[0], &t64_len[0], NULL, 3}; + TAOS_STMT2_BIND* paramv = ¶ms; + TAOS_STMT2_BINDV bindv1 = {1, NULL, NULL, ¶mv}; + + int code = taos_stmt2_bind_param(stmt, &bindv1, 0); + ASSERT_EQ(code, TSDB_CODE_TSC_STMT_BIND_NUMBER_ERROR); + ASSERT_STREQ(taos_stmt2_error(stmt), "bind number out of range or not match"); + + code = taos_stmt2_exec(stmt, NULL); + ASSERT_EQ(code, TSDB_CODE_TSC_STMT_API_ERROR); + ASSERT_STREQ(taos_stmt2_error(stmt), "Stmt API usage error"); + + const char* sql = "insert into db.ntb values(?,?)"; + code = taos_stmt2_prepare(stmt, sql, 0); + ASSERT_EQ(code, TSDB_CODE_TSC_STMT_API_ERROR); + ASSERT_STREQ(taos_stmt2_error(stmt), "Stmt API usage error"); + + taos_stmt2_close(stmt); + taos_close(taos); +} #pragma GCC diagnostic pop From 7c400e85ac422dec96bcc3bd9a60144a4a18becc Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Tue, 31 Dec 2024 14:37:58 +0800 Subject: [PATCH 10/13] reform stmt2 interlace --- include/libs/parser/parser.h | 4 +- source/client/src/clientStmt2.c | 129 ++++++++------- source/client/test/stmt2Test.cpp | 56 ++++++- source/libs/parser/src/parInsertStmt.c | 218 ++++++++++++------------- 4 files changed, 238 insertions(+), 169 deletions(-) diff --git a/include/libs/parser/parser.h b/include/libs/parser/parser.h index 95f522f504..27da0c13d2 100644 --- a/include/libs/parser/parser.h +++ b/include/libs/parser/parser.h @@ -156,8 +156,8 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen, void* charsetCxt); int32_t qStmtBindParams2(SQuery* pQuery, TAOS_STMT2_BIND* pParams, int32_t colIdx, void* charsetCxt); -int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, - STSchema** pTSchema, SBindInfo2* pBindInfos, void *charsetCxt); +// int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, +// STSchema** pTSchema, SBindInfo2* pBindInfos, void *charsetCxt); int32_t qBindStmtColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, void *charsetCxt); int32_t qBindStmtSingleColValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, int32_t colIdx, int32_t rowNum, void *charsetCxt); diff --git a/source/client/src/clientStmt2.c b/source/client/src/clientStmt2.c index 5992493e5b..1d9acc6982 100644 --- a/source/client/src/clientStmt2.c +++ b/source/client/src/clientStmt2.c @@ -284,16 +284,17 @@ static int32_t stmtParseSql(STscStmt2* pStmt) { STableDataCxt* pTableCtx = *pSrc; if (pStmt->sql.stbInterlaceMode) { - int16_t lastIdx = -1; + return TSDB_CODE_TSC_STMT_API_ERROR; + // 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; - } + // 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]; - } + // lastIdx = pTableCtx->boundColsInfo.pColIndex[i]; + // } } if (NULL == pStmt->sql.pBindInfo) { @@ -497,9 +498,10 @@ static int32_t stmtRebuildDataBlock(STscStmt2* pStmt, STableDataCxt* pDataBlock, 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; + return TSDB_CODE_TSC_STMT_API_ERROR; + // pStmt->bInfo.needParse = false; + // pStmt->bInfo.inExecCache = false; + // return TSDB_CODE_SUCCESS; } pStmt->bInfo.needParse = true; @@ -979,6 +981,7 @@ int stmtSetTbName2(TAOS_STMT2* stmt, const char* tbName) { } if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { + return TSDB_CODE_TSC_STMT_API_ERROR; // STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); } @@ -1009,6 +1012,7 @@ int stmtSetTbTags2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* tags) { STMT_ERR_RET(stmtParseSql(pStmt)); } if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { + return TSDB_CODE_TSC_STMT_API_ERROR; // STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); } @@ -1078,7 +1082,8 @@ static int stmtFetchStbColFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIEL STableDataCxt** pDataBlock = NULL; if (pStmt->sql.stbInterlaceMode) { - pDataBlock = &pStmt->sql.siInfo.pDataCtx; + return TSDB_CODE_TSC_STMT_API_ERROR; + // pDataBlock = &pStmt->sql.siInfo.pDataCtx; } else { pDataBlock = (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); @@ -1158,28 +1163,28 @@ SArray* stmtGetFreeCol(STscStmt2* pStmt, int32_t* idx) { // 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 terrno; - } +// 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 terrno; +// } - if (taosArrayPush(pStmt->sql.siInfo.pTableCols, &pTblCols) == NULL) { - return terrno; - } - } - } - } +// if (taosArrayPush(pStmt->sql.siInfo.pTableCols, &pTblCols) == NULL) { +// return terrno; +// } +// } +// } +// } - return TSDB_CODE_SUCCESS; -} +// return TSDB_CODE_SUCCESS; +// } static int32_t stmtCacheBlock(STscStmt2* pStmt) { if (pStmt->sql.type != STMT_TYPE_MULTI_INSERT) { @@ -1233,6 +1238,7 @@ static int stmtAddBatch2(TAOS_STMT2* stmt) { STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_ADD_BATCH)); if (pStmt->sql.stbInterlaceMode) { + return TSDB_CODE_TSC_STMT_API_ERROR; // todo:add stb interlace mode // int64_t startUs2 = taosGetTimestampUs(); // pStmt->stat.addBatchUs += startUs2 - startUs; @@ -1367,6 +1373,7 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { } if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { + return TSDB_CODE_TSC_STMT_API_ERROR; // STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); } @@ -1393,14 +1400,15 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { 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); + return TSDB_CODE_TSC_STMT_API_ERROR; + // 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->tblData.aCol = taosArrayInit(20, POINTER_BYTES); - param->restoreTbCols = false; - tstrncpy(param->tblData.tbName, pStmt->bInfo.tbName, TSDB_TABLE_NAME_LEN); + // param->restoreTbCols = false; + // tstrncpy(param->tblData.tbName, pStmt->bInfo.tbName, TSDB_TABLE_NAME_LEN); } int64_t startUs3 = taosGetTimestampUs(); @@ -1410,12 +1418,15 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { 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, pStmt->taos->optionInfo.charsetCxt); + return TSDB_CODE_TSC_STMT_API_ERROR; + // todo + // (*pDataBlock)->pData->flags = 0; + // code = qBindStmtStbColsValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, + // pStmt->exec.pRequest->msgBufLen, &pStmt->sql.siInfo.pTSchema, + // pStmt->sql.pBindInfo, pStmt->taos->optionInfo.charsetCxt); } else { - code = - qBindStmtColsValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, pStmt->exec.pRequest->msgBufLen, pStmt->taos->optionInfo.charsetCxt); + code = qBindStmtColsValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, + pStmt->exec.pRequest->msgBufLen, pStmt->taos->optionInfo.charsetCxt); } if (code) { @@ -1424,8 +1435,9 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { } } else { if (pStmt->sql.stbInterlaceMode) { - tscError("bind single column not allowed in stb insert mode"); - STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR); + return TSDB_CODE_TSC_STMT_API_ERROR; + // 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) { @@ -1440,7 +1452,8 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { } code = qBindStmtSingleColValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, - pStmt->exec.pRequest->msgBufLen, colIdx, pStmt->bInfo.sBindRowNum, pStmt->taos->optionInfo.charsetCxt); + pStmt->exec.pRequest->msgBufLen, colIdx, pStmt->bInfo.sBindRowNum, + pStmt->taos->optionInfo.charsetCxt); if (code) { tscError("qBindStmtSingleColValue failed, error:%s", tstrerror(code)); STMT_ERR_RET(code); @@ -1451,6 +1464,7 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { pStmt->stat.bindDataUs3 += startUs4 - startUs3; if (pStmt->sql.stbInterlaceMode) { + return TSDB_CODE_TSC_STMT_API_ERROR; // to do // STMT_ERR_RET(stmtAppendTablePostHandle(pStmt, param)); } else { @@ -1660,23 +1674,26 @@ int stmtExec2(TAOS_STMT2* stmt, int* affected_rows) { } if (pStmt->sql.stbInterlaceMode) { - STMT_ERR_RET(stmtAddBatch2(pStmt)); + return TSDB_CODE_TSC_STMT_API_ERROR; + // STMT_ERR_RET(stmtAddBatch2(pStmt)); } 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; + return TSDB_CODE_TSC_STMT_API_ERROR; + // todo:stb interlace mode + // 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; + // 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); diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index 45919be726..ee6fa7a9e1 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -815,7 +815,7 @@ TEST(stmt2Case, stmt2_init_prepare_Test) { taos_close(taos); } -TEST(stmt2Case, stmt2_insert) { +TEST(stmt2Case, stmt2_stb_insert) { TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); ASSERT_NE(taos, nullptr); TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL}; @@ -830,6 +830,58 @@ TEST(stmt2Case, stmt2_insert) { taos_close(taos); } +// TEST(stmt2Case, stmt2_insert_all_types) { +// TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); +// ASSERT_NE(taos, nullptr); +// do_query(taos, "drop database if exists example_all_type_stmt1"); +// do_query(taos, "create database example_all_type_stmt1"); +// do_query(taos, +// "create table example_all_type_stmt1.stb (ts timestamp, int_col int,long_col bigint,double_col " +// "double,bool_col bool,binary_col binary(20),nchar_col nchar(20),varbinary_col varbinary(20),geometry_col " +// "geometry(200)) tags(int_tag int,long_tag bigint,double_tag double,bool_tag bool,binary_tag " +// "binary(20),nchar_tag nchar(20),varbinary_tag varbinary(20),geometry_tag geometry(200));"); + +// TAOS_STMT2_OPTION option = {0, false, false, NULL, NULL}; + +// TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); +// ASSERT_NE(stmt, nullptr); + +// const char* sql = +// "INSERT INTO `example_all_type_stmt1`.`stb1` " +// "(ts,int_col,long_col,double_col,bool_col,binary_col,nchar_col,varbinary_col,geometry_col,int_tag,long_tag," +// "double_tag,bool_tag,binary_tag,nchar_tag,varbinary_tag ,geometry_tag,tbname) VALUES " +// "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; +// int code = taos_stmt2_prepare(stmt, sql, 0); +// ASSERT_EQ(code, 0); + +// int t64_len[1] = {sizeof(int64_t)}; +// int b_len[1] = {3}; +// int64_t ts = 1591060628000; +// TAOS_STMT2_BIND params[18] = {{TSDB_DATA_TYPE_TIMESTAMP, &ts, t64_len, NULL, 1}}; +// TAOS_STMT2_BIND* paramv = ¶ms[0]; +// char* tbname = "tb1"; +// TAOS_STMT2_BINDV bindv = {1, &tbname, NULL, ¶mv}; +// code = taos_stmt2_bind_param(stmt, &bindv, -1); +// ASSERT_EQ(code, 0); + +// taos_stmt2_exec(stmt, NULL); +// ASSERT_EQ(code, 0); + +// TAOS_RES* pRes = taos_stmt2_result(stmt); +// ASSERT_NE(pRes, nullptr); + +// int getRecordCounts = 0; +// TAOS_ROW row; +// while ((row = taos_fetch_row(pRes))) { +// getRecordCounts++; +// } +// ASSERT_EQ(getRecordCounts, 1); +// taos_free_result(pRes); + +// taos_stmt2_close(stmt); +// taos_close(taos); +// } + TEST(stmt2Case, stmt2_query) { TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); ASSERT_NE(taos, nullptr); @@ -875,7 +927,7 @@ TEST(stmt2Case, stmt2_query) { getRecordCounts++; } ASSERT_EQ(getRecordCounts, 1); - taos_free_result(pRes); + // taos_free_result(pRes); taos_stmt2_close(stmt); taos_close(taos); diff --git a/source/libs/parser/src/parInsertStmt.c b/source/libs/parser/src/parInsertStmt.c index 74fac463f1..666892e6f5 100644 --- a/source/libs/parser/src/parInsertStmt.c +++ b/source/libs/parser/src/parInsertStmt.c @@ -636,134 +636,134 @@ end: return code; } -static int32_t convertStmtStbNcharCol2(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_STMT2_BIND* src, TAOS_STMT2_BIND* dst, void *charsetCxt) { - int32_t output = 0; - const int32_t max_buf_len = pSchema->bytes - VARSTR_HEADER_SIZE; +// static int32_t convertStmtStbNcharCol2(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_STMT2_BIND* src, TAOS_STMT2_BIND* dst, void *charsetCxt) { +// 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 terrno; - } +// dst->buffer = taosMemoryCalloc(src->num, max_buf_len); +// if (NULL == dst->buffer) { +// return terrno; +// } - dst->length = taosMemoryCalloc(src->num, sizeof(int32_t)); - if (NULL == dst->length) { - taosMemoryFreeClear(dst->buffer); - return terrno; - } +// dst->length = taosMemoryCalloc(src->num, sizeof(int32_t)); +// if (NULL == dst->length) { +// taosMemoryFreeClear(dst->buffer); +// return terrno; +// } - 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; - } +// 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, charsetCxt)) { - if (terrno == TAOS_SYSTEM_ERROR(E2BIG)) { - return generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name); - } - char buf[512] = {0}; - snprintf(buf, tListLen(buf), "%s", strerror(terrno)); - return buildSyntaxErrMsg(pMsgBuf, buf, NULL); - } +// if (!taosMbsToUcs4(src_buf, src->length[i], (TdUcs4*)dst_buf, max_buf_len, &output, charsetCxt)) { +// if (terrno == TAOS_SYSTEM_ERROR(E2BIG)) { +// return generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name); +// } +// char buf[512] = {0}; +// snprintf(buf, tListLen(buf), "%s", strerror(terrno)); +// return buildSyntaxErrMsg(pMsgBuf, buf, NULL); +// } - dst->length[i] = output; - src_buf += src->length[i]; - dst_buf += output; - } +// 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; +// dst->buffer_type = src->buffer_type; +// dst->is_null = src->is_null; +// dst->num = src->num; - return TSDB_CODE_SUCCESS; -} +// return TSDB_CODE_SUCCESS; +// } -int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, - STSchema** pTSchema, SBindInfo2* pBindInfos, void *charsetCxt) { - 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; - int ncharColNums = 0; +// int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, +// STSchema** pTSchema, SBindInfo2* pBindInfos, void *charsetCxt) { +// 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; +// int ncharColNums = 0; - if (NULL == *pTSchema) { - *pTSchema = tBuildTSchema(pSchema, pDataBlock->pMeta->tableInfo.numOfColumns, pDataBlock->pMeta->sversion); - } +// if (NULL == *pTSchema) { +// *pTSchema = tBuildTSchema(pSchema, pDataBlock->pMeta->tableInfo.numOfColumns, pDataBlock->pMeta->sversion); +// } - for (int c = 0; c < boundInfo->numOfBound; ++c) { - if (TSDB_DATA_TYPE_NCHAR == pSchema[boundInfo->pColIndex[c]].type) { - ncharColNums++; - } - } - if (ncharColNums > 0) { - ncharBinds = taosArrayInit(ncharColNums, sizeof(ncharBind)); - if (!ncharBinds) { - code = terrno; - goto _return; - } - } +// for (int c = 0; c < boundInfo->numOfBound; ++c) { +// if (TSDB_DATA_TYPE_NCHAR == pSchema[boundInfo->pColIndex[c]].type) { +// ncharColNums++; +// } +// } +// if (ncharColNums > 0) { +// ncharBinds = taosArrayInit(ncharColNums, sizeof(ncharBind)); +// if (!ncharBinds) { +// code = terrno; +// goto _return; +// } +// } - for (int c = 0; c < boundInfo->numOfBound; ++c) { - SSchema* pColSchema = &pSchema[boundInfo->pColIndex[c]]; - if (pColSchema->colId <= lastColId) { - colInOrder = false; - } else { - lastColId = pColSchema->colId; - } +// 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 (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 ((!(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, charsetCxt); - if (code) { - goto _return; - } - if (!taosArrayPush(ncharBinds, &ncharBind)) { - code = terrno; - goto _return; - } - pBindInfos[c].bind = taosArrayGetLast(ncharBinds); - } else { - pBindInfos[c].bind = bind + c; - } +// if (TSDB_DATA_TYPE_NCHAR == pColSchema->type) { +// code = convertStmtStbNcharCol2(&pBuf, pColSchema, bind + c, &ncharBind, charsetCxt); +// if (code) { +// goto _return; +// } +// if (!taosArrayPush(ncharBinds, &ncharBind)) { +// code = terrno; +// 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; - } +// pBindInfos[c].columnId = pColSchema->colId; +// pBindInfos[c].type = pColSchema->type; +// pBindInfos[c].bytes = pColSchema->bytes; +// } - code = tRowBuildFromBind2(pBindInfos, boundInfo->numOfBound, colInOrder, *pTSchema, pCols, &pDataBlock->ordered, &pDataBlock->duplicateTs); +// code = tRowBuildFromBind2(pBindInfos, boundInfo->numOfBound, colInOrder, *pTSchema, pCols, &pDataBlock->ordered, &pDataBlock->duplicateTs); - qDebug("stmt all %d columns bind %d rows data", boundInfo->numOfBound, rowNum); +// 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: +// 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; -} +// return code; +// } static int32_t convertStmtNcharCol2(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_STMT2_BIND* src, TAOS_STMT2_BIND* dst, void *charsetCxt) { int32_t output = 0; From a898e90bf4ec4eef50c11a918c7ce6efe1eadce9 Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Tue, 31 Dec 2024 16:30:39 +0800 Subject: [PATCH 11/13] restore refactor --- include/libs/parser/parser.h | 4 +- source/client/src/clientStmt2.c | 337 ++++++++++++------------- source/libs/parser/src/parInsertStmt.c | 218 ++++++++-------- 3 files changed, 270 insertions(+), 289 deletions(-) diff --git a/include/libs/parser/parser.h b/include/libs/parser/parser.h index 27da0c13d2..95f522f504 100644 --- a/include/libs/parser/parser.h +++ b/include/libs/parser/parser.h @@ -156,8 +156,8 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen, void* charsetCxt); int32_t qStmtBindParams2(SQuery* pQuery, TAOS_STMT2_BIND* pParams, int32_t colIdx, void* charsetCxt); -// int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, -// STSchema** pTSchema, SBindInfo2* pBindInfos, void *charsetCxt); +int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, + STSchema** pTSchema, SBindInfo2* pBindInfos, void *charsetCxt); int32_t qBindStmtColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, void *charsetCxt); int32_t qBindStmtSingleColValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, int32_t colIdx, int32_t rowNum, void *charsetCxt); diff --git a/source/client/src/clientStmt2.c b/source/client/src/clientStmt2.c index 1d9acc6982..820a7a0110 100644 --- a/source/client/src/clientStmt2.c +++ b/source/client/src/clientStmt2.c @@ -58,13 +58,13 @@ static bool stmtDequeue(STscStmt2* pStmt, SStmtQNode** param) { return true; } -// static void stmtEnqueue(STscStmt2* pStmt, SStmtQNode* param) { -// pStmt->queue.tail->next = param; -// pStmt->queue.tail = param; +static void stmtEnqueue(STscStmt2* pStmt, SStmtQNode* param) { + pStmt->queue.tail->next = param; + pStmt->queue.tail = param; -// pStmt->stat.bindDataNum++; -// (void)atomic_add_fetch_64((int64_t*)&pStmt->queue.qRemainNum, 1); -// } + pStmt->stat.bindDataNum++; + (void)atomic_add_fetch_64((int64_t*)&pStmt->queue.qRemainNum, 1); +} static int32_t stmtCreateRequest(STscStmt2* pStmt) { int32_t code = 0; @@ -76,7 +76,7 @@ static int32_t stmtCreateRequest(STscStmt2* pStmt) { pStmt->reqid++; } if (pStmt->db != NULL) { - taosMemoryFreeClear(pStmt->exec.pRequest->pDb); + taosMemoryFreeClear(pStmt->exec.pRequest->pDb); pStmt->exec.pRequest->pDb = taosStrdup(pStmt->db); } if (TSDB_CODE_SUCCESS == code) { @@ -284,17 +284,16 @@ static int32_t stmtParseSql(STscStmt2* pStmt) { STableDataCxt* pTableCtx = *pSrc; if (pStmt->sql.stbInterlaceMode) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // int16_t lastIdx = -1; + 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; - // } + 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]; - // } + lastIdx = pTableCtx->boundColsInfo.pColIndex[i]; + } } if (NULL == pStmt->sql.pBindInfo) { @@ -326,10 +325,10 @@ static int32_t stmtCleanBindInfo(STscStmt2* pStmt) { return TSDB_CODE_SUCCESS; } -// static void stmtFreeTableBlkList(STableColsData* pTb) { -// (void)qResetStmtColumns(pTb->aCol, true); -// taosArrayDestroy(pTb->aCol); -// } +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); @@ -498,10 +497,9 @@ static int32_t stmtRebuildDataBlock(STscStmt2* pStmt, STableDataCxt* pDataBlock, static int32_t stmtGetFromCache(STscStmt2* pStmt) { if (pStmt->sql.stbInterlaceMode && pStmt->sql.siInfo.pDataCtx) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // pStmt->bInfo.needParse = false; - // pStmt->bInfo.inExecCache = false; - // return TSDB_CODE_SUCCESS; + pStmt->bInfo.needParse = false; + pStmt->bInfo.inExecCache = false; + return TSDB_CODE_SUCCESS; } pStmt->bInfo.needParse = true; @@ -897,32 +895,32 @@ int stmtPrepare2(TAOS_STMT2* stmt, const char* sql, unsigned long length) { 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 terrno; -// } -// STableDataCxt* pDst = NULL; +static int32_t stmtInitStbInterlaceTableInfo(STscStmt2* pStmt) { + STableDataCxt** pSrc = taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); + if (!pSrc) { + return terrno; + } + STableDataCxt* pDst = NULL; -// STMT_ERR_RET(qCloneStmtDataBlock(&pDst, *pSrc, true)); -// pStmt->sql.siInfo.pDataCtx = pDst; + 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 terrno; -// } + SArray* pTblCols = NULL; + for (int32_t i = 0; i < STMT_TABLE_COLS_NUM; i++) { + pTblCols = taosArrayInit(20, POINTER_BYTES); + if (NULL == pTblCols) { + return terrno; + } -// if (taosArrayPush(pStmt->sql.siInfo.pTableCols, &pTblCols) == NULL) { -// return terrno; -// } -// } + if (taosArrayPush(pStmt->sql.siInfo.pTableCols, &pTblCols) == NULL) { + return terrno; + } + } -// pStmt->sql.siInfo.boundTags = pStmt->bInfo.boundTags; + pStmt->sql.siInfo.boundTags = pStmt->bInfo.boundTags; -// return TSDB_CODE_SUCCESS; -// } + return TSDB_CODE_SUCCESS; +} int stmtIsInsert2(TAOS_STMT2* stmt, int* insert) { STscStmt2* pStmt = (STscStmt2*)stmt; @@ -981,8 +979,7 @@ int stmtSetTbName2(TAOS_STMT2* stmt, const char* tbName) { } if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); + STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); } int64_t startUs2 = taosGetTimestampUs(); @@ -1012,8 +1009,7 @@ int stmtSetTbTags2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* tags) { STMT_ERR_RET(stmtParseSql(pStmt)); } if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); + STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); } SBoundColInfo* tags_info = (SBoundColInfo*)pStmt->bInfo.boundTags; @@ -1041,33 +1037,33 @@ int stmtSetTbTags2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* tags) { 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; -// } +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); -// } + 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; + 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); -// } -// } + 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)); + STMT_ERR_RET(qBuildStmtColFields(*pDataBlock, fieldNum, fields)); -// return TSDB_CODE_SUCCESS; -// } + return TSDB_CODE_SUCCESS; +} static int stmtFetchStbColFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIELD_ALL** fields) { if (pStmt->errCode != TSDB_CODE_SUCCESS) { @@ -1082,8 +1078,7 @@ static int stmtFetchStbColFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIEL STableDataCxt** pDataBlock = NULL; if (pStmt->sql.stbInterlaceMode) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // pDataBlock = &pStmt->sql.siInfo.pDataCtx; + pDataBlock = &pStmt->sql.siInfo.pDataCtx; } else { pDataBlock = (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName)); @@ -1122,69 +1117,69 @@ SArray* stmtGetFreeCol(STscStmt2* pStmt, int32_t* idx) { } } */ -// 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); -// } +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 (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; + 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; -// } + 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 (!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]) { -// tstrncpy(pStmt->sql.siInfo.firstName, pStmt->bInfo.tbName, TSDB_TABLE_NAME_LEN); -// } + if (0 == pStmt->sql.siInfo.firstName[0]) { + tstrncpy(pStmt->sql.siInfo.firstName, pStmt->bInfo.tbName, TSDB_TABLE_NAME_LEN); + } -// param->tblData.getFromHash = pStmt->sql.siInfo.tbFromHash; -// param->next = NULL; + param->tblData.getFromHash = pStmt->sql.siInfo.tbFromHash; + param->next = NULL; -// (void)atomic_add_fetch_64(&pStmt->sql.siInfo.tbRemainNum, 1); + (void)atomic_add_fetch_64(&pStmt->sql.siInfo.tbRemainNum, 1); -// stmtEnqueue(pStmt, param); + stmtEnqueue(pStmt, param); -// return TSDB_CODE_SUCCESS; -// } + 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 terrno; -// } +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 terrno; + } -// if (taosArrayPush(pStmt->sql.siInfo.pTableCols, &pTblCols) == NULL) { -// return terrno; -// } -// } -// } -// } + if (taosArrayPush(pStmt->sql.siInfo.pTableCols, &pTblCols) == NULL) { + return terrno; + } + } + } + } -// return TSDB_CODE_SUCCESS; -// } + return TSDB_CODE_SUCCESS; +} static int32_t stmtCacheBlock(STscStmt2* pStmt) { if (pStmt->sql.type != STMT_TYPE_MULTI_INSERT) { @@ -1238,21 +1233,19 @@ static int stmtAddBatch2(TAOS_STMT2* stmt) { STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_ADD_BATCH)); if (pStmt->sql.stbInterlaceMode) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // todo:add stb interlace mode - // int64_t startUs2 = taosGetTimestampUs(); - // pStmt->stat.addBatchUs += startUs2 - startUs; + int64_t startUs2 = taosGetTimestampUs(); + pStmt->stat.addBatchUs += startUs2 - startUs; - // pStmt->sql.siInfo.tableColsReady = false; + pStmt->sql.siInfo.tableColsReady = false; - // SStmtQNode* param = NULL; - // STMT_ERR_RET(stmtAllocQNodeFromBuf(&pStmt->sql.siInfo.tbBuf, (void**)¶m)); - // param->restoreTbCols = true; - // param->next = NULL; + SStmtQNode* param = NULL; + STMT_ERR_RET(stmtAllocQNodeFromBuf(&pStmt->sql.siInfo.tbBuf, (void**)¶m)); + param->restoreTbCols = true; + param->next = NULL; - // stmtEnqueue(pStmt, param); + stmtEnqueue(pStmt, param); - // return TSDB_CODE_SUCCESS; + return TSDB_CODE_SUCCESS; } STMT_ERR_RET(stmtCacheBlock(pStmt)); @@ -1373,8 +1366,7 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { } if (pStmt->sql.stbInterlaceMode && NULL == pStmt->sql.siInfo.pDataCtx) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); + STMT_ERR_RET(stmtInitStbInterlaceTableInfo(pStmt)); } STableDataCxt** pDataBlock = NULL; @@ -1400,15 +1392,14 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { SStmtQNode* param = NULL; if (pStmt->sql.stbInterlaceMode) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // STMT_ERR_RET(stmtAllocQNodeFromBuf(&pStmt->sql.siInfo.tbBuf, (void**)¶m)); - // STMT_ERR_RET(stmtGetTableColsFromCache(pStmt, ¶m->tblData.aCol)); - // taosArrayClear(param->tblData.aCol); + 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->tblData.aCol = taosArrayInit(20, POINTER_BYTES); - // param->restoreTbCols = false; - // tstrncpy(param->tblData.tbName, pStmt->bInfo.tbName, TSDB_TABLE_NAME_LEN); + param->restoreTbCols = false; + tstrncpy(param->tblData.tbName, pStmt->bInfo.tbName, TSDB_TABLE_NAME_LEN); } int64_t startUs3 = taosGetTimestampUs(); @@ -1418,15 +1409,12 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { if (colIdx < 0) { if (pStmt->sql.stbInterlaceMode) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // todo - // (*pDataBlock)->pData->flags = 0; - // code = qBindStmtStbColsValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, - // pStmt->exec.pRequest->msgBufLen, &pStmt->sql.siInfo.pTSchema, - // pStmt->sql.pBindInfo, pStmt->taos->optionInfo.charsetCxt); + (*pDataBlock)->pData->flags = 0; + code = qBindStmtStbColsValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, + pStmt->exec.pRequest->msgBufLen, &pStmt->sql.siInfo.pTSchema, pStmt->sql.pBindInfo, pStmt->taos->optionInfo.charsetCxt); } else { - code = qBindStmtColsValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, - pStmt->exec.pRequest->msgBufLen, pStmt->taos->optionInfo.charsetCxt); + code = + qBindStmtColsValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, pStmt->exec.pRequest->msgBufLen, pStmt->taos->optionInfo.charsetCxt); } if (code) { @@ -1435,9 +1423,8 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { } } else { if (pStmt->sql.stbInterlaceMode) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // tscError("bind single column not allowed in stb insert mode"); - // STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR); + 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) { @@ -1452,8 +1439,7 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { } code = qBindStmtSingleColValue2(*pDataBlock, pCols, bind, pStmt->exec.pRequest->msgBuf, - pStmt->exec.pRequest->msgBufLen, colIdx, pStmt->bInfo.sBindRowNum, - pStmt->taos->optionInfo.charsetCxt); + pStmt->exec.pRequest->msgBufLen, colIdx, pStmt->bInfo.sBindRowNum, pStmt->taos->optionInfo.charsetCxt); if (code) { tscError("qBindStmtSingleColValue failed, error:%s", tstrerror(code)); STMT_ERR_RET(code); @@ -1464,9 +1450,7 @@ int stmtBindBatch2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* bind, int32_t colIdx) { pStmt->stat.bindDataUs3 += startUs4 - startUs3; if (pStmt->sql.stbInterlaceMode) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // to do - // STMT_ERR_RET(stmtAppendTablePostHandle(pStmt, param)); + STMT_ERR_RET(stmtAppendTablePostHandle(pStmt, param)); } else { STMT_ERR_RET(stmtAddBatch2(pStmt)); } @@ -1674,26 +1658,23 @@ int stmtExec2(TAOS_STMT2* stmt, int* affected_rows) { } if (pStmt->sql.stbInterlaceMode) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // STMT_ERR_RET(stmtAddBatch2(pStmt)); + STMT_ERR_RET(stmtAddBatch2(pStmt)); } STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_EXECUTE)); if (STMT_TYPE_QUERY != pStmt->sql.type) { if (pStmt->sql.stbInterlaceMode) { - return TSDB_CODE_TSC_STMT_API_ERROR; - // todo:stb interlace mode - // int64_t startTs = taosGetTimestampUs(); - // while (atomic_load_64(&pStmt->sql.siInfo.tbRemainNum)) { - // taosUsleep(1); - // } - // pStmt->stat.execWaitUs += taosGetTimestampUs() - startTs; + 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; + 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); @@ -1895,11 +1876,11 @@ int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums) { 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)); - // } + 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; } diff --git a/source/libs/parser/src/parInsertStmt.c b/source/libs/parser/src/parInsertStmt.c index 666892e6f5..74fac463f1 100644 --- a/source/libs/parser/src/parInsertStmt.c +++ b/source/libs/parser/src/parInsertStmt.c @@ -636,134 +636,134 @@ end: return code; } -// static int32_t convertStmtStbNcharCol2(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_STMT2_BIND* src, TAOS_STMT2_BIND* dst, void *charsetCxt) { -// int32_t output = 0; -// const int32_t max_buf_len = pSchema->bytes - VARSTR_HEADER_SIZE; +static int32_t convertStmtStbNcharCol2(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_STMT2_BIND* src, TAOS_STMT2_BIND* dst, void *charsetCxt) { + 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 terrno; -// } + dst->buffer = taosMemoryCalloc(src->num, max_buf_len); + if (NULL == dst->buffer) { + return terrno; + } -// dst->length = taosMemoryCalloc(src->num, sizeof(int32_t)); -// if (NULL == dst->length) { -// taosMemoryFreeClear(dst->buffer); -// return terrno; -// } + dst->length = taosMemoryCalloc(src->num, sizeof(int32_t)); + if (NULL == dst->length) { + taosMemoryFreeClear(dst->buffer); + return terrno; + } -// 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; -// } + 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, charsetCxt)) { -// if (terrno == TAOS_SYSTEM_ERROR(E2BIG)) { -// return generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name); -// } -// char buf[512] = {0}; -// snprintf(buf, tListLen(buf), "%s", strerror(terrno)); -// return buildSyntaxErrMsg(pMsgBuf, buf, NULL); -// } + if (!taosMbsToUcs4(src_buf, src->length[i], (TdUcs4*)dst_buf, max_buf_len, &output, charsetCxt)) { + if (terrno == TAOS_SYSTEM_ERROR(E2BIG)) { + return generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name); + } + char buf[512] = {0}; + snprintf(buf, tListLen(buf), "%s", strerror(terrno)); + return buildSyntaxErrMsg(pMsgBuf, buf, NULL); + } -// dst->length[i] = output; -// src_buf += src->length[i]; -// dst_buf += output; -// } + 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; + dst->buffer_type = src->buffer_type; + dst->is_null = src->is_null; + dst->num = src->num; -// return TSDB_CODE_SUCCESS; -// } + return TSDB_CODE_SUCCESS; +} -// int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, -// STSchema** pTSchema, SBindInfo2* pBindInfos, void *charsetCxt) { -// 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; -// int ncharColNums = 0; +int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bind, char* msgBuf, int32_t msgBufLen, + STSchema** pTSchema, SBindInfo2* pBindInfos, void *charsetCxt) { + 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; + int ncharColNums = 0; -// if (NULL == *pTSchema) { -// *pTSchema = tBuildTSchema(pSchema, pDataBlock->pMeta->tableInfo.numOfColumns, pDataBlock->pMeta->sversion); -// } + if (NULL == *pTSchema) { + *pTSchema = tBuildTSchema(pSchema, pDataBlock->pMeta->tableInfo.numOfColumns, pDataBlock->pMeta->sversion); + } -// for (int c = 0; c < boundInfo->numOfBound; ++c) { -// if (TSDB_DATA_TYPE_NCHAR == pSchema[boundInfo->pColIndex[c]].type) { -// ncharColNums++; -// } -// } -// if (ncharColNums > 0) { -// ncharBinds = taosArrayInit(ncharColNums, sizeof(ncharBind)); -// if (!ncharBinds) { -// code = terrno; -// goto _return; -// } -// } + for (int c = 0; c < boundInfo->numOfBound; ++c) { + if (TSDB_DATA_TYPE_NCHAR == pSchema[boundInfo->pColIndex[c]].type) { + ncharColNums++; + } + } + if (ncharColNums > 0) { + ncharBinds = taosArrayInit(ncharColNums, sizeof(ncharBind)); + if (!ncharBinds) { + code = terrno; + goto _return; + } + } -// for (int c = 0; c < boundInfo->numOfBound; ++c) { -// SSchema* pColSchema = &pSchema[boundInfo->pColIndex[c]]; -// if (pColSchema->colId <= lastColId) { -// colInOrder = false; -// } else { -// lastColId = pColSchema->colId; -// } + 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 (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 ((!(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, charsetCxt); -// if (code) { -// goto _return; -// } -// if (!taosArrayPush(ncharBinds, &ncharBind)) { -// code = terrno; -// goto _return; -// } -// pBindInfos[c].bind = taosArrayGetLast(ncharBinds); -// } else { -// pBindInfos[c].bind = bind + c; -// } + if (TSDB_DATA_TYPE_NCHAR == pColSchema->type) { + code = convertStmtStbNcharCol2(&pBuf, pColSchema, bind + c, &ncharBind, charsetCxt); + if (code) { + goto _return; + } + if (!taosArrayPush(ncharBinds, &ncharBind)) { + code = terrno; + 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; -// } + pBindInfos[c].columnId = pColSchema->colId; + pBindInfos[c].type = pColSchema->type; + pBindInfos[c].bytes = pColSchema->bytes; + } -// code = tRowBuildFromBind2(pBindInfos, boundInfo->numOfBound, colInOrder, *pTSchema, pCols, &pDataBlock->ordered, &pDataBlock->duplicateTs); + code = tRowBuildFromBind2(pBindInfos, boundInfo->numOfBound, colInOrder, *pTSchema, pCols, &pDataBlock->ordered, &pDataBlock->duplicateTs); -// qDebug("stmt all %d columns bind %d rows data", boundInfo->numOfBound, rowNum); + 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: + 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; -// } + return code; +} static int32_t convertStmtNcharCol2(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_STMT2_BIND* src, TAOS_STMT2_BIND* dst, void *charsetCxt) { int32_t output = 0; From 5dcb75d43c6548d286d8cdb365870668cf22dfa5 Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Thu, 2 Jan 2025 20:07:58 +0800 Subject: [PATCH 12/13] fix TD-33417 --- source/client/test/stmt2Test.cpp | 145 +++++++++++++++++-------- source/libs/parser/inc/parInsertUtil.h | 1 + source/libs/parser/src/parInsertSql.c | 71 +++++++++--- 3 files changed, 153 insertions(+), 64 deletions(-) diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index ee6fa7a9e1..e4dc9c3005 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -371,11 +371,11 @@ TEST(stmt2Case, insert_stb_get_fields_Test) { // not support case printf("not support case \n"); - // case 5 : add in main TD-33353 + // case 1 : add in main TD-33353 { const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(1,?,?,'abc',?)"; - printf("case 2 : %s\n", sql); - getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + printf("case 1dif : %s\n", sql); + getFieldsError(taos, sql, TSDB_CODE_PAR_INVALID_COLUMNS_NUM); } // case 2 : no pk @@ -431,7 +431,7 @@ TEST(stmt2Case, insert_stb_get_fields_Test) { { const char* sql = "insert into db.stb(t1,t2,ts,b,tbname) values(*,*,*,*,*)"; printf("case 9 : %s\n", sql); - getFieldsError(taos, sql, TSDB_CODE_TSC_INVALID_OPERATION); + getFieldsError(taos, sql, TSDB_CODE_PAR_INVALID_COLUMNS_NUM); } taos_close(taos); @@ -830,57 +830,108 @@ TEST(stmt2Case, stmt2_stb_insert) { taos_close(taos); } -// TEST(stmt2Case, stmt2_insert_all_types) { -// TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); -// ASSERT_NE(taos, nullptr); -// do_query(taos, "drop database if exists example_all_type_stmt1"); -// do_query(taos, "create database example_all_type_stmt1"); -// do_query(taos, -// "create table example_all_type_stmt1.stb (ts timestamp, int_col int,long_col bigint,double_col " -// "double,bool_col bool,binary_col binary(20),nchar_col nchar(20),varbinary_col varbinary(20),geometry_col " -// "geometry(200)) tags(int_tag int,long_tag bigint,double_tag double,bool_tag bool,binary_tag " -// "binary(20),nchar_tag nchar(20),varbinary_tag varbinary(20),geometry_tag geometry(200));"); +// TD-33417 +TEST(stmt2Case, stmt2_insert_non_statndard) { + TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); + ASSERT_NE(taos, nullptr); + do_query(taos, "drop database if exists example_all_type_stmt1"); + do_query(taos, "create database example_all_type_stmt1"); + do_query(taos, + "create table example_all_type_stmt1.stb1 (ts timestamp, int_col int,long_col bigint,double_col " + "double,bool_col bool,binary_col binary(20),nchar_col nchar(20),varbinary_col varbinary(20),geometry_col " + "geometry(200)) tags(int_tag int,long_tag bigint,double_tag double,bool_tag bool,binary_tag " + "binary(20),nchar_tag nchar(20),varbinary_tag varbinary(20),geometry_tag geometry(200));"); -// TAOS_STMT2_OPTION option = {0, false, false, NULL, NULL}; + TAOS_STMT2_OPTION option = {0, false, false, NULL, NULL}; -// TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); -// ASSERT_NE(stmt, nullptr); + // less cols and tags + { + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + ASSERT_NE(stmt, nullptr); + const char* sql = "INSERT INTO example_all_type_stmt1.stb1 (ts,int_tag,tbname) VALUES (?,?,?)"; + int code = taos_stmt2_prepare(stmt, sql, 0); + ASSERT_EQ(code, 0); -// const char* sql = -// "INSERT INTO `example_all_type_stmt1`.`stb1` " -// "(ts,int_col,long_col,double_col,bool_col,binary_col,nchar_col,varbinary_col,geometry_col,int_tag,long_tag," -// "double_tag,bool_tag,binary_tag,nchar_tag,varbinary_tag ,geometry_tag,tbname) VALUES " -// "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; -// int code = taos_stmt2_prepare(stmt, sql, 0); -// ASSERT_EQ(code, 0); + int t64_len[2] = {sizeof(int64_t), sizeof(int64_t)}; + int tag_i = 0; + int tag_l = sizeof(int); + int64_t ts[2] = {1591060628000, 1591060628100}; + for (int i = 0; i < 3; i++) { + ts[0] += 1000; + ts[1] += 1000; -// int t64_len[1] = {sizeof(int64_t)}; -// int b_len[1] = {3}; -// int64_t ts = 1591060628000; -// TAOS_STMT2_BIND params[18] = {{TSDB_DATA_TYPE_TIMESTAMP, &ts, t64_len, NULL, 1}}; -// TAOS_STMT2_BIND* paramv = ¶ms[0]; -// char* tbname = "tb1"; -// TAOS_STMT2_BINDV bindv = {1, &tbname, NULL, ¶mv}; -// code = taos_stmt2_bind_param(stmt, &bindv, -1); -// ASSERT_EQ(code, 0); + TAOS_STMT2_BIND tags1 = {TSDB_DATA_TYPE_INT, &tag_i, &tag_l, NULL, 1}; + TAOS_STMT2_BIND tags2 = {TSDB_DATA_TYPE_INT, &tag_i, &tag_l, NULL, 1}; + TAOS_STMT2_BIND params1 = {TSDB_DATA_TYPE_TIMESTAMP, &ts, &t64_len[0], NULL, 2}; + TAOS_STMT2_BIND params2 = {TSDB_DATA_TYPE_TIMESTAMP, &ts, &t64_len[0], NULL, 2}; -// taos_stmt2_exec(stmt, NULL); -// ASSERT_EQ(code, 0); + TAOS_STMT2_BIND* tagv[2] = {&tags1, &tags2}; + TAOS_STMT2_BIND* paramv[2] = {¶ms1, ¶ms2}; + char* tbname[2] = {"tb1", "tb2"}; + TAOS_STMT2_BINDV bindv = {2, &tbname[0], &tagv[0], ¶mv[0]}; + code = taos_stmt2_bind_param(stmt, &bindv, -1); + ASSERT_EQ(code, 0); -// TAOS_RES* pRes = taos_stmt2_result(stmt); -// ASSERT_NE(pRes, nullptr); + int affected_rows; + taos_stmt2_exec(stmt, &affected_rows); + ASSERT_EQ(code, 0); + } -// int getRecordCounts = 0; -// TAOS_ROW row; -// while ((row = taos_fetch_row(pRes))) { -// getRecordCounts++; -// } -// ASSERT_EQ(getRecordCounts, 1); -// taos_free_result(pRes); + checkRows(taos, "select * from example_all_type_stmt1.tb1", 6); + checkRows(taos, "select * from example_all_type_stmt1.tb2", 6); + checkRows(taos, "select * from example_all_type_stmt1.stb1", 12); + taos_stmt2_close(stmt); + } -// taos_stmt2_close(stmt); -// taos_close(taos); -// } + // disorder cols and tags + { + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + ASSERT_NE(stmt, nullptr); + const char* sql = + "INSERT INTO example_all_type_stmt1.stb1 (binary_tag,int_col,tbname,ts,int_tag) VALUES (?,?,?,?,?)"; + int code = taos_stmt2_prepare(stmt, sql, 0); + ASSERT_EQ(code, 0); + + int tag_i = 0; + int tag_l = sizeof(int); + int tag_bl = 3; + int64_t ts[2] = {1591060628000, 1591060628100}; + int t64_len[2] = {sizeof(int64_t), sizeof(int64_t)}; + int coli[2] = {1, 2}; + int ilen[2] = {sizeof(int), sizeof(int)}; + for (int i = 0; i < 3; i++) { + ts[0] += 1000; + ts[1] += 1000; + + TAOS_STMT2_BIND tags1[2] = {{TSDB_DATA_TYPE_BINARY, (void*)"abc", &tag_bl, NULL, 1}, + {TSDB_DATA_TYPE_INT, &tag_i, &tag_l, NULL, 1}}; + TAOS_STMT2_BIND tags2[2] = {{TSDB_DATA_TYPE_BINARY, (void*)"abc", &tag_bl, NULL, 1}, + {TSDB_DATA_TYPE_INT, &tag_i, &tag_l, NULL, 1}}; + TAOS_STMT2_BIND params1[2] = {{TSDB_DATA_TYPE_INT, &coli, &ilen[0], NULL, 2}, + {TSDB_DATA_TYPE_TIMESTAMP, &ts, &t64_len[0], NULL, 2}}; + TAOS_STMT2_BIND params2[2] = {{TSDB_DATA_TYPE_INT, &coli, &ilen[0], NULL, 2}, + {TSDB_DATA_TYPE_TIMESTAMP, &ts, &t64_len[0], NULL, 2}}; + + TAOS_STMT2_BIND* tagv[2] = {&tags1[0], &tags2[0]}; + TAOS_STMT2_BIND* paramv[2] = {¶ms1[0], ¶ms2[0]}; + char* tbname[2] = {"tb3", "tb4"}; + TAOS_STMT2_BINDV bindv = {2, &tbname[0], &tagv[0], ¶mv[0]}; + code = taos_stmt2_bind_param(stmt, &bindv, -1); + ASSERT_EQ(code, 0); + + int affected_rows; + taos_stmt2_exec(stmt, &affected_rows); + ASSERT_EQ(code, 0); + } + + checkRows(taos, "select * from example_all_type_stmt1.tb3", 6); + checkRows(taos, "select * from example_all_type_stmt1.tb4", 6); + checkRows(taos, "select * from example_all_type_stmt1.stb1", 24); + taos_stmt2_close(stmt); + } + + taos_close(taos); +} TEST(stmt2Case, stmt2_query) { TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); diff --git a/source/libs/parser/inc/parInsertUtil.h b/source/libs/parser/inc/parInsertUtil.h index c5cce55d9a..b2a585d881 100644 --- a/source/libs/parser/inc/parInsertUtil.h +++ b/source/libs/parser/inc/parInsertUtil.h @@ -50,6 +50,7 @@ int32_t insInitColValues(STableMeta *pTableMeta, SArray *aColValues); void insCheckTableDataOrder(STableDataCxt *pTableCxt, SRowKey *rowKey); int32_t insGetTableDataCxt(SHashObj *pHash, void *id, int32_t idLen, STableMeta *pTableMeta, SVCreateTbReq **pCreateTbReq, STableDataCxt **pTableCxt, bool colMode, bool ignoreColVals); +int32_t initTableColSubmitDataWithBoundInfo(STableDataCxt *pTableCxt, SBoundColInfo pBoundColsInfo); int32_t initTableColSubmitData(STableDataCxt *pTableCxt); int32_t insMergeTableDataCxt(SHashObj *pTableHash, SArray **pVgDataBlocks, bool isRebuild); //int32_t insMergeStmtTableDataCxt(STableDataCxt* pTableCxt, SArray* pTableList, SArray** pVgDataBlocks, bool isRebuild, int32_t tbNum); diff --git a/source/libs/parser/src/parInsertSql.c b/source/libs/parser/src/parInsertSql.c index 128fb50b8f..e39a885529 100644 --- a/source/libs/parser/src/parInsertSql.c +++ b/source/libs/parser/src/parInsertSql.c @@ -1446,6 +1446,27 @@ int32_t initTableColSubmitData(STableDataCxt* pTableCxt) { return TSDB_CODE_SUCCESS; } +int32_t initTableColSubmitDataWithBoundInfo(STableDataCxt* pTableCxt, SBoundColInfo pBoundColsInfo) { + insDestroyBoundColInfo(&(pTableCxt->boundColsInfo)); + pTableCxt->boundColsInfo = pBoundColsInfo; + pTableCxt->boundColsInfo.pColIndex = taosMemoryCalloc(pBoundColsInfo.numOfBound - 1, sizeof(int16_t)); + if (NULL == pTableCxt->boundColsInfo.pColIndex) { + return terrno; + } + (void)memcpy(pTableCxt->boundColsInfo.pColIndex, pBoundColsInfo.pColIndex, + sizeof(int16_t) * pBoundColsInfo.numOfBound - 1); + for (int32_t i = 0; i < pBoundColsInfo.numOfBound; ++i) { + SSchema* pSchema = &pTableCxt->pMeta->schema[pTableCxt->boundColsInfo.pColIndex[i]]; + SColData* pCol = taosArrayReserve(pTableCxt->pData->aCol, 1); + if (NULL == pCol) { + return terrno; + } + tColDataInit(pCol, pSchema->colId, pSchema->type, pSchema->flags); + } + + return TSDB_CODE_SUCCESS; +} + // input pStmt->pSql: // 1. [(tag1_name, ...)] ... // 2. VALUES ... | FILE ... @@ -1815,7 +1836,7 @@ static int32_t processCtbTagsAfterCtbName(SInsertParseContext* pCxt, SVnodeModif static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt, const char** ppSql, SStbRowsDataContext* pStbRowsCxt, SToken* pToken, const SBoundColInfo* pCols, const SSchema* pSchemas, SToken* tagTokens, SSchema** tagSchemas, int* pNumOfTagTokens, - bool* bFoundTbName) { + bool* bFoundTbName, bool* setCtbName, SBoundColInfo* ctbCols) { int32_t code = TSDB_CODE_SUCCESS; SArray* pTagNames = pStbRowsCxt->aTagNames; SArray* pTagVals = pStbRowsCxt->aTagVals; @@ -1824,7 +1845,8 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* int32_t numOfTags = getNumOfTags(pStbRowsCxt->pStbMeta); int32_t tbnameIdx = getTbnameSchemaIndex(pStbRowsCxt->pStbMeta); uint8_t precision = getTableInfo(pStbRowsCxt->pStbMeta).precision; - int idx = 0; + int tag_index = 0; + int col_index = 0; for (int i = 0; i < pCols->numOfBound && (code) == TSDB_CODE_SUCCESS; ++i) { const char* pTmpSql = *ppSql; bool ignoreComma = false; @@ -1847,6 +1869,7 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pCxt->isStmtBind = true; pStmt->usingTableProcessing = true; if (pCols->pColIndex[i] == tbnameIdx) { + *bFoundTbName = true; char* tbName = NULL; if ((*pCxt->pComCxt->pStmtCb->getTbNameFn)(pCxt->pComCxt->pStmtCb->pStmt, &tbName) == TSDB_CODE_SUCCESS) { tstrncpy(pStbRowsCxt->ctbName.tname, tbName, sizeof(pStbRowsCxt->ctbName.tname)); @@ -1855,10 +1878,20 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* tstrncpy(pStmt->usingTableName.dbname, pStmt->targetTableName.dbname, sizeof(pStmt->usingTableName.dbname)); pStmt->usingTableName.type = 1; pStmt->pTableMeta->tableType = TSDB_CHILD_TABLE; // set the table type to child table for parse cache - *bFoundTbName = true; + *setCtbName = true; } } else if (pCols->pColIndex[i] < numOfCols) { // bind column + if (ctbCols->pColIndex == NULL) { + ctbCols->pColIndex = taosMemoryCalloc(numOfCols, sizeof(int16_t)); + if (NULL == ctbCols->pColIndex) { + return terrno; + } + } + ctbCols->pColIndex[col_index++] = pCols->pColIndex[i]; + ctbCols->numOfBound++; + ctbCols->numOfCols++; + } else if (pCols->pColIndex[i] < tbnameIdx) { if (pCxt->tags.pColIndex == NULL) { pCxt->tags.pColIndex = taosMemoryCalloc(numOfTags, sizeof(int16_t)); @@ -1866,10 +1899,10 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* return terrno; } } - if (!(idx < numOfTags)) { + if (!(tag_index < numOfTags)) { return buildInvalidOperationMsg(&pCxt->msg, "not expected numOfTags"); } - pCxt->tags.pColIndex[idx++] = pCols->pColIndex[i] - numOfCols; + pCxt->tags.pColIndex[tag_index++] = pCols->pColIndex[i] - numOfCols; pCxt->tags.mixTagsCols = true; pCxt->tags.numOfBound++; pCxt->tags.numOfCols++; @@ -1927,7 +1960,8 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* } static int32_t getStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt, const char** ppSql, - SStbRowsDataContext* pStbRowsCxt, bool* pGotRow, SToken* pToken, bool* pCtbFirst) { + SStbRowsDataContext* pStbRowsCxt, bool* pGotRow, SToken* pToken, bool* pCtbFirst, + bool* setCtbName, SBoundColInfo* ctbCols) { SBoundColInfo* pCols = &pStbRowsCxt->boundColsInfo; SSchema* pSchemas = getTableColumnSchema(pStbRowsCxt->pStbMeta); @@ -1940,19 +1974,14 @@ static int32_t getStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pS int numOfTagTokens = 0; code = doGetStbRowValues(pCxt, pStmt, ppSql, pStbRowsCxt, pToken, pCols, pSchemas, tagTokens, tagSchemas, - &numOfTagTokens, &bFoundTbName); + &numOfTagTokens, &bFoundTbName, setCtbName, ctbCols); if (code != TSDB_CODE_SUCCESS) { return code; } if (!bFoundTbName) { - if (!pCxt->isStmtBind) { - code = buildSyntaxErrMsg(&pCxt->msg, "tbname value expected", pOrigSql); - } else { - *pGotRow = true; - return TSDB_CODE_TSC_STMT_TBNAME_ERROR; - } + code = buildSyntaxErrMsg(&pCxt->msg, "tbname value expected", pOrigSql); } bool ctbFirst = true; @@ -2079,9 +2108,11 @@ static int32_t parseOneStbRow(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pSt SStbRowsDataContext* pStbRowsCxt, bool* pGotRow, SToken* pToken, STableDataCxt** ppTableDataCxt) { bool bFirstTable = false; - int32_t code = getStbRowValues(pCxt, pStmt, ppSql, pStbRowsCxt, pGotRow, pToken, &bFirstTable); + bool setCtbName = false; + SBoundColInfo ctbCols = {0}; + int32_t code = getStbRowValues(pCxt, pStmt, ppSql, pStbRowsCxt, pGotRow, pToken, &bFirstTable, &setCtbName, &ctbCols); - if (code == TSDB_CODE_TSC_STMT_TBNAME_ERROR && *pGotRow) { + if (!setCtbName && pCxt->isStmtBind) { return parseStbBoundInfo(pStmt, pStbRowsCxt, ppTableDataCxt); } @@ -2108,7 +2139,13 @@ static int32_t parseOneStbRow(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pSt } } if (code == TSDB_CODE_SUCCESS) { - code = initTableColSubmitData(*ppTableDataCxt); + if (pCxt->isStmtBind) { + int32_t tbnameIdx = getTbnameSchemaIndex(pStbRowsCxt->pStbMeta); + code = initTableColSubmitDataWithBoundInfo(*ppTableDataCxt, ctbCols); + insDestroyBoundColInfo(&ctbCols); + } else { + code = initTableColSubmitData(*ppTableDataCxt); + } } if (code == TSDB_CODE_SUCCESS && !pCxt->isStmtBind) { SRow** pRow = taosArrayReserve((*ppTableDataCxt)->pData->aRowP, 1); @@ -3177,7 +3214,7 @@ int32_t parseInsertSql(SParseContext* pCxt, SQuery** pQuery, SCatalogReq* pCatal .forceUpdate = (NULL != pCatalogReq ? pCatalogReq->forceUpdate : false), .isStmtBind = pCxt->isStmtBind}; - int32_t code = initInsertQuery(&context, pCatalogReq, pMetaData, pQuery); + int32_t code = initInsertQuery(&context, pCatalogReq, pMetaData, pQuery); if (TSDB_CODE_SUCCESS == code) { code = parseInsertSqlImpl(&context, (SVnodeModifyOpStmt*)((*pQuery)->pRoot)); } From 8e24c29230c37f821a54098782efa93e25ed21d6 Mon Sep 17 00:00:00 2001 From: "pengrongkun94@qq.com" Date: Fri, 3 Jan 2025 09:11:13 +0800 Subject: [PATCH 13/13] TD33419 --- source/client/test/stmt2Test.cpp | 52 ++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/source/client/test/stmt2Test.cpp b/source/client/test/stmt2Test.cpp index e4dc9c3005..3c63bda398 100644 --- a/source/client/test/stmt2Test.cpp +++ b/source/client/test/stmt2Test.cpp @@ -933,6 +933,58 @@ TEST(stmt2Case, stmt2_insert_non_statndard) { taos_close(taos); } +//TD-33419 +TEST(stmt2Case, stmt2_insert_db) { + TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); + ASSERT_NE(taos, nullptr); + do_query(taos, "drop database if exists example_all_type_stmt1"); + do_query(taos, "create database example_all_type_stmt1"); + do_query(taos, + "create table `example_all_type_stmt1`.`stb1` (ts timestamp, int_col int,long_col bigint,double_col " + "double,bool_col bool,binary_col binary(20),nchar_col nchar(20),varbinary_col varbinary(20),geometry_col " + "geometry(200)) tags(int_tag int,long_tag bigint,double_tag double,bool_tag bool,binary_tag " + "binary(20),nchar_tag nchar(20),varbinary_tag varbinary(20),geometry_tag geometry(200));"); + + TAOS_STMT2_OPTION option = {0, false, false, NULL, NULL}; + + TAOS_STMT2* stmt = taos_stmt2_init(taos, &option); + ASSERT_NE(stmt, nullptr); + const char* sql = "INSERT INTO `example_all_type_stmt1`.`stb1` (ts,int_tag,tbname) VALUES (?,?,?)"; + int code = taos_stmt2_prepare(stmt, sql, 0); + ASSERT_EQ(code, 0); + + int t64_len[2] = {sizeof(int64_t), sizeof(int64_t)}; + int tag_i = 0; + int tag_l = sizeof(int); + int64_t ts[2] = {1591060628000, 1591060628100}; + for (int i = 0; i < 3; i++) { + ts[0] += 1000; + ts[1] += 1000; + + TAOS_STMT2_BIND tags1 = {TSDB_DATA_TYPE_INT, &tag_i, &tag_l, NULL, 1}; + TAOS_STMT2_BIND tags2 = {TSDB_DATA_TYPE_INT, &tag_i, &tag_l, NULL, 1}; + TAOS_STMT2_BIND params1 = {TSDB_DATA_TYPE_TIMESTAMP, &ts, &t64_len[0], NULL, 2}; + TAOS_STMT2_BIND params2 = {TSDB_DATA_TYPE_TIMESTAMP, &ts, &t64_len[0], NULL, 2}; + + TAOS_STMT2_BIND* tagv[2] = {&tags1, &tags2}; + TAOS_STMT2_BIND* paramv[2] = {¶ms1, ¶ms2}; + char* tbname[2] = {"tb1", "tb2"}; + TAOS_STMT2_BINDV bindv = {2, &tbname[0], &tagv[0], ¶mv[0]}; + code = taos_stmt2_bind_param(stmt, &bindv, -1); + ASSERT_EQ(code, 0); + + int affected_rows; + taos_stmt2_exec(stmt, &affected_rows); + ASSERT_EQ(code, 0); + } + + checkRows(taos, "select * from example_all_type_stmt1.tb1", 6); + checkRows(taos, "select * from example_all_type_stmt1.tb2", 6); + checkRows(taos, "select * from example_all_type_stmt1.stb1", 12); + taos_stmt2_close(stmt); + taos_close(taos); +} + TEST(stmt2Case, stmt2_query) { TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0); ASSERT_NE(taos, nullptr);