Merge branch '3.0' into enh/TD-20043

examples/c/CMakeLists.txt

@@ -15,6 +15,7 @@ IF (TD_LINUX)
   add_executable(tmq "")
   add_executable(stream_demo "")
   add_executable(demoapi "")
+  add_executable(api_reqid "")
 
   target_sources(tmq
       PRIVATE
@@ -31,6 +32,12 @@ IF (TD_LINUX)
       "demoapi.c"
       )
 
+  target_sources(api_reqid
+    PRIVATE 
+    "api_with_reqid_test.c"
+    )
+    
+
   target_link_libraries(tmq
       taos_static
       )
@@ -43,6 +50,11 @@ IF (TD_LINUX)
       taos_static
       )
 
+  target_link_libraries(api_reqid
+      taos_static
+      )
+  
+
   target_include_directories(tmq
       PUBLIC "${TD_SOURCE_DIR}/include/os"
       PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
@@ -58,9 +70,16 @@ IF (TD_LINUX)
       PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
       )
 
+  target_include_directories(api_reqid
+      PUBLIC "${TD_SOURCE_DIR}/include/client"
+      PUBLIC "${TD_SOURCE_DIR}/include/os"
+      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+      )
+
   SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)
   SET_TARGET_PROPERTIES(stream_demo PROPERTIES OUTPUT_NAME stream_demo)
   SET_TARGET_PROPERTIES(demoapi PROPERTIES OUTPUT_NAME demoapi)
+  SET_TARGET_PROPERTIES(api_reqid PROPERTIES OUTPUT_NAME api_reqid)
 ENDIF ()
 IF (TD_DARWIN)
   INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc  ${TD_SOURCE_DIR}/inc)

examples/c/api_with_reqid_test.c

@@ -0,0 +1,449 @@
+// sample code to verify all TDengine API
+// to compile: gcc -o apitest apitest.c -ltaos
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "taos.h"
+static int64_t count = 10000;
+
+int64_t genReqid() {
+  count += 100;
+  return count;
+}
+static void prepare_data(TAOS* taos) {
+  TAOS_RES* result;
+  result = taos_query_with_reqid(taos, "drop database if exists test;", genReqid());
+  taos_free_result(result);
+  usleep(100000);
+  result = taos_query_with_reqid(taos, "create database test precision 'us';", genReqid());
+  taos_free_result(result);
+  usleep(100000);
+  taos_select_db(taos, "test");
+
+  result = taos_query_with_reqid(taos, "create table meters(ts timestamp, a int) tags(area int);", genReqid());
+  taos_free_result(result);
+
+  result = taos_query_with_reqid(taos, "create table t0 using meters tags(0);", genReqid());
+  taos_free_result(result);
+  result = taos_query_with_reqid(taos, "create table t1 using meters tags(1);", genReqid());
+  taos_free_result(result);
+  result = taos_query_with_reqid(taos, "create table t2 using meters tags(2);", genReqid());
+  taos_free_result(result);
+  result = taos_query_with_reqid(taos, "create table t3 using meters tags(3);", genReqid());
+  taos_free_result(result);
+  result = taos_query_with_reqid(taos, "create table t4 using meters tags(4);", genReqid());
+  taos_free_result(result);
+  result = taos_query_with_reqid(taos, "create table t5 using meters tags(5);", genReqid());
+  taos_free_result(result);
+  result = taos_query_with_reqid(taos, "create table t6 using meters tags(6);", genReqid());
+  taos_free_result(result);
+  result = taos_query_with_reqid(taos, "create table t7 using meters tags(7);", genReqid());
+  taos_free_result(result);
+  result = taos_query_with_reqid(taos, "create table t8 using meters tags(8);", genReqid());
+  taos_free_result(result);
+  result = taos_query(taos, "create table t9 using meters tags(9);");
+  taos_free_result(result);
+
+  result = taos_query_with_reqid(taos,
+                                 "insert into t0 values('2020-01-01 00:00:00.000', 0)"
+                                 " ('2020-01-01 00:01:00.000', 0)"
+                                 " ('2020-01-01 00:02:00.000', 0)"
+                                 " t1 values('2020-01-01 00:00:00.000', 0)"
+                                 " ('2020-01-01 00:01:00.000', 0)"
+                                 " ('2020-01-01 00:02:00.000', 0)"
+                                 " ('2020-01-01 00:03:00.000', 0)"
+                                 " t2 values('2020-01-01 00:00:00.000', 0)"
+                                 " ('2020-01-01 00:01:00.000', 0)"
+                                 " ('2020-01-01 00:01:01.000', 0)"
+                                 " ('2020-01-01 00:01:02.000', 0)"
+                                 " t3 values('2020-01-01 00:01:02.000', 0)"
+                                 " t4 values('2020-01-01 00:01:02.000', 0)"
+                                 " t5 values('2020-01-01 00:01:02.000', 0)"
+                                 " t6 values('2020-01-01 00:01:02.000', 0)"
+                                 " t7 values('2020-01-01 00:01:02.000', 0)"
+                                 " t8 values('2020-01-01 00:01:02.000', 0)"
+                                 " t9 values('2020-01-01 00:01:02.000', 0)",
+                                 genReqid());
+  int affected = taos_affected_rows(result);
+  if (affected != 18) {
+    printf("\033[31m%d rows affected by last insert statement, but it should be 18\033[0m\n", affected);
+  }
+  taos_free_result(result);
+  // super tables subscription
+  usleep(1000000);
+}
+
+static int print_result(TAOS_RES* res, int blockFetch) {
+  TAOS_ROW    row = NULL;
+  int         num_fields = taos_num_fields(res);
+  TAOS_FIELD* fields = taos_fetch_fields(res);
+  int         nRows = 0;
+
+  if (blockFetch) {
+    int rows = 0;
+    while ((rows = taos_fetch_block(res, &row))) {
+      // for (int i = 0; i < rows; i++) {
+      //   char temp[256];
+      //   taos_print_row(temp, row + i, fields, num_fields);
+      //   puts(temp);
+      // }
+      nRows += rows;
+    }
+  } else {
+    while ((row = taos_fetch_row(res))) {
+      char temp[256] = {0};
+      taos_print_row(temp, row, fields, num_fields);
+      puts(temp);
+      nRows++;
+    }
+  }
+
+  printf("%d rows consumed.\n", nRows);
+  return nRows;
+}
+
+static void check_row_count(int line, TAOS_RES* res, int expected) {
+  int actual = print_result(res, expected % 2);
+  if (actual != expected) {
+    printf("\033[31mline %d: row count mismatch, expected: %d, actual: %d\033[0m\n", line, expected, actual);
+  } else {
+    printf("line %d: %d rows consumed as expected\n", line, actual);
+  }
+}
+
+static void verify_query(TAOS* taos) {
+  prepare_data(taos);
+
+  int code = taos_load_table_info(taos, "t0,t1,t2,t3,t4,t5,t6,t7,t8,t9");
+  if (code != 0) {
+    printf("\033[31mfailed to load table info: 0x%08x\033[0m\n", code);
+  }
+
+  code = taos_validate_sql(taos, "select * from nonexisttable");
+  if (code == 0) {
+    printf("\033[31mimpossible, the table does not exists\033[0m\n");
+  }
+
+  code = taos_validate_sql(taos, "select * from meters");
+  if (code != 0) {
+    printf("\033[31mimpossible, the table does exists: 0x%08x\033[0m\n", code);
+  }
+
+  TAOS_RES* res = taos_query_with_reqid(taos, "select * from meters", genReqid());
+  check_row_count(__LINE__, res, 18);
+  printf("result precision is: %d\n", taos_result_precision(res));
+  int c = taos_field_count(res);
+  printf("field count is: %d\n", c);
+  int* lengths = taos_fetch_lengths(res);
+  for (int i = 0; i < c; i++) {
+    printf("length of column %d is %d\n", i, lengths[i]);
+  }
+  taos_free_result(res);
+
+  res = taos_query_with_reqid(taos, "select * from t0", genReqid());
+  check_row_count(__LINE__, res, 3);
+  taos_free_result(res);
+
+  res = taos_query_with_reqid(taos, "select * from nonexisttable", genReqid());
+  code = taos_errno(res);
+  printf("code=%d, error msg=%s\n", code, taos_errstr(res));
+  taos_free_result(res);
+
+  res = taos_query_with_reqid(taos, "select * from meters", genReqid());
+  taos_stop_query(res);
+  taos_free_result(res);
+}
+
+void retrieve_callback(void* param, TAOS_RES* tres, int numOfRows) {
+  if (numOfRows > 0) {
+    printf("%d rows async retrieved\n", numOfRows);
+    taos_fetch_rows_a(tres, retrieve_callback, param);
+  } else {
+    if (numOfRows < 0) {
+      printf("\033[31masync retrieve failed, code: %d\033[0m\n", numOfRows);
+    } else {
+      printf("async retrieve completed\n");
+    }
+    taos_free_result(tres);
+  }
+}
+
+void select_callback(void* param, TAOS_RES* tres, int code) {
+  if (code == 0 && tres) {
+    taos_fetch_rows_a(tres, retrieve_callback, param);
+  } else {
+    printf("\033[31masync select failed, code: %d\033[0m\n", code);
+  }
+}
+
+void verify_async(TAOS* taos) {
+  prepare_data(taos);
+  taos_query_a_with_reqid(taos, "select * from meters", select_callback, NULL, genReqid());
+  usleep(1000000);
+}
+
+int32_t verify_schema_less(TAOS* taos) {
+  TAOS_RES* result;
+  result = taos_query_with_reqid(taos, "drop database if exists test;", genReqid());
+  taos_free_result(result);
+  usleep(100000);
+  result = taos_query_with_reqid(taos, "create database test precision 'us' update 1;", genReqid());
+  taos_free_result(result);
+  usleep(100000);
+
+  taos_select_db(taos, "test");
+  result = taos_query_with_reqid(taos, "create stable ste(ts timestamp, f int) tags(t1 bigint)", genReqid());
+  taos_free_result(result);
+  usleep(100000);
+
+  int code = 0;
+
+  char* lines[] = {
+      "st,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
+      "st,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833640000000ns",
+      "ste,t2=5f64,t3=L\"ste\" c1=true,c2=4i64,c3=\"iam\" 1626056811823316532ns",
+      "st,t1=4i64,t2=5f64,t3=\"t4\" c1=3i64,c3=L\"passitagain\",c2=true,c4=5f64 1626006833642000000ns",
+      "ste,t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532ns",
+      "ste,t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32i8,c6=64i16,c7=32i32,c8=88.88f32 1626056812843316532ns",
+      "st,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 "
+      "1626006933640000000ns",
+      "stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 "
+      "1626006933640000000ns",
+      "stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 "
+      "1626006933641000000ns"};
+
+  taos_select_db(taos, "test");
+
+  TAOS_RES* res = taos_schemaless_insert_with_reqid(taos, lines, sizeof(lines) / sizeof(char*), TSDB_SML_LINE_PROTOCOL,
+                                                    TSDB_SML_TIMESTAMP_NOT_CONFIGURED, genReqid());
+  if (taos_errno(res) != 0) {
+    printf("failed to insert schema-less data, reason: %s\n", taos_errstr(res));
+  } else {
+    int affectedRow = taos_affected_rows(res);
+    printf("successfully inserted %d rows\n", affectedRow);
+  }
+  taos_free_result(res);
+
+  return (code);
+}
+
+void veriry_stmt(TAOS* taos) {
+  TAOS_RES* result = taos_query(taos, "drop database if exists test;");
+  taos_free_result(result);
+  usleep(100000);
+  result = taos_query(taos, "create database test;");
+
+  int code = taos_errno(result);
+  if (code != 0) {
+    printf("\033[31mfailed to create database, reason:%s\033[0m\n", taos_errstr(result));
+    taos_free_result(result);
+    return;
+  }
+  taos_free_result(result);
+
+  usleep(100000);
+  taos_select_db(taos, "test");
+
+  // create table
+  const char* sql =
+      "create table m1 (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin "
+      "binary(40), blob nchar(10))";
+  result = taos_query(taos, sql);
+  code = taos_errno(result);
+  if (code != 0) {
+    printf("\033[31mfailed to create table, reason:%s\033[0m\n", taos_errstr(result));
+    taos_free_result(result);
+    return;
+  }
+  taos_free_result(result);
+
+  // insert 10 records
+  struct {
+    int64_t ts[10];
+    int8_t  b[10];
+    int8_t  v1[10];
+    int16_t v2[10];
+    int32_t v4[10];
+    int64_t v8[10];
+    float   f4[10];
+    double  f8[10];
+    char    bin[10][40];
+    char    blob[10][80];
+  } v;
+
+  int32_t* t8_len = malloc(sizeof(int32_t) * 10);
+  int32_t* t16_len = malloc(sizeof(int32_t) * 10);
+  int32_t* t32_len = malloc(sizeof(int32_t) * 10);
+  int32_t* t64_len = malloc(sizeof(int32_t) * 10);
+  int32_t* float_len = malloc(sizeof(int32_t) * 10);
+  int32_t* double_len = malloc(sizeof(int32_t) * 10);
+  int32_t* bin_len = malloc(sizeof(int32_t) * 10);
+  int32_t* blob_len = malloc(sizeof(int32_t) * 10);
+
+  TAOS_STMT*      stmt = taos_stmt_init_with_reqid(taos, genReqid());
+  TAOS_MULTI_BIND params[10];
+  char            is_null[10] = {0};
+
+  params[0].buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+  params[0].buffer_length = sizeof(v.ts[0]);
+  params[0].buffer = v.ts;
+  params[0].length = t64_len;
+  params[0].is_null = is_null;
+  params[0].num = 10;
+
+  params[1].buffer_type = TSDB_DATA_TYPE_BOOL;
+  params[1].buffer_length = sizeof(v.b[0]);
+  params[1].buffer = v.b;
+  params[1].length = t8_len;
+  params[1].is_null = is_null;
+  params[1].num = 10;
+
+  params[2].buffer_type = TSDB_DATA_TYPE_TINYINT;
+  params[2].buffer_length = sizeof(v.v1[0]);
+  params[2].buffer = v.v1;
+  params[2].length = t8_len;
+  params[2].is_null = is_null;
+  params[2].num = 10;
+
+  params[3].buffer_type = TSDB_DATA_TYPE_SMALLINT;
+  params[3].buffer_length = sizeof(v.v2[0]);
+  params[3].buffer = v.v2;
+  params[3].length = t16_len;
+  params[3].is_null = is_null;
+  params[3].num = 10;
+
+  params[4].buffer_type = TSDB_DATA_TYPE_INT;
+  params[4].buffer_length = sizeof(v.v4[0]);
+  params[4].buffer = v.v4;
+  params[4].length = t32_len;
+  params[4].is_null = is_null;
+  params[4].num = 10;
+
+  params[5].buffer_type = TSDB_DATA_TYPE_BIGINT;
+  params[5].buffer_length = sizeof(v.v8[0]);
+  params[5].buffer = v.v8;
+  params[5].length = t64_len;
+  params[5].is_null = is_null;
+  params[5].num = 10;
+
+  params[6].buffer_type = TSDB_DATA_TYPE_FLOAT;
+  params[6].buffer_length = sizeof(v.f4[0]);
+  params[6].buffer = v.f4;
+  params[6].length = float_len;
+  params[6].is_null = is_null;
+  params[6].num = 10;
+
+  params[7].buffer_type = TSDB_DATA_TYPE_DOUBLE;
+  params[7].buffer_length = sizeof(v.f8[0]);
+  params[7].buffer = v.f8;
+  params[7].length = double_len;
+  params[7].is_null = is_null;
+  params[7].num = 10;
+
+  params[8].buffer_type = TSDB_DATA_TYPE_BINARY;
+  params[8].buffer_length = sizeof(v.bin[0]);
+  params[8].buffer = v.bin;
+  params[8].length = bin_len;
+  params[8].is_null = is_null;
+  params[8].num = 10;
+
+  params[9].buffer_type = TSDB_DATA_TYPE_NCHAR;
+  params[9].buffer_length = sizeof(v.blob[0]);
+  params[9].buffer = v.blob;
+  params[9].length = blob_len;
+  params[9].is_null = is_null;
+  params[9].num = 10;
+
+  sql = "insert into ? (ts, b, v1, v2, v4, v8, f4, f8, bin, blob) values(?,?,?,?,?,?,?,?,?,?)";
+  code = taos_stmt_prepare(stmt, sql, 0);
+  if (code != 0) {
+    printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
+    taos_stmt_close(stmt);
+    return;
+  }
+
+  code = taos_stmt_set_tbname(stmt, "m1");
+  if (code != 0) {
+    printf("\033[31mfailed to execute taos_stmt_prepare. error:%s\033[0m\n", taos_stmt_errstr(stmt));
+    taos_stmt_close(stmt);
+    return;
+  }
+
+  int64_t ts = 1591060628000;
+  for (int i = 0; i < 10; ++i) {
+    v.ts[i] = ts++;
+    is_null[i] = 0;
+
+    v.b[i] = (int8_t)i % 2;
+    v.v1[i] = (int8_t)i;
+    v.v2[i] = (int16_t)(i * 2);
+    v.v4[i] = (int32_t)(i * 4);
+    v.v8[i] = (int64_t)(i * 8);
+    v.f4[i] = (float)(i * 40);
+    v.f8[i] = (double)(i * 80);
+    for (int j = 0; j < sizeof(v.bin[0]); ++j) {
+      v.bin[i][j] = (char)(i + '0');
+    }
+    strcpy(v.blob[i], "一二三四五六七八九十");
+
+    t8_len[i] = sizeof(int8_t);
+    t16_len[i] = sizeof(int16_t);
+    t32_len[i] = sizeof(int32_t);
+    t64_len[i] = sizeof(int64_t);
+    float_len[i] = sizeof(float);
+    double_len[i] = sizeof(double);
+    bin_len[i] = sizeof(v.bin[0]);
+    blob_len[i] = (int32_t)strlen(v.blob[i]);
+  }
+
+  taos_stmt_bind_param_batch(stmt, params);
+  taos_stmt_add_batch(stmt);
+
+  if (taos_stmt_execute(stmt) != 0) {
+    printf("\033[31mfailed to execute insert statement.error:%s\033[0m\n", taos_stmt_errstr(stmt));
+    taos_stmt_close(stmt);
+    return;
+  }
+
+  taos_stmt_close(stmt);
+
+  free(t8_len);
+  free(t16_len);
+  free(t32_len);
+  free(t64_len);
+  free(float_len);
+  free(double_len);
+  free(bin_len);
+  free(blob_len);
+}
+
+int main(int argc, char* argv[]) {
+  const char* host = "127.0.0.1";
+  const char* user = "root";
+  const char* passwd = "taosdata";
+
+  taos_options(TSDB_OPTION_TIMEZONE, "GMT-8");
+  TAOS* taos = taos_connect(host, user, passwd, "", 0);
+  if (taos == NULL) {
+    printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(taos));
+    exit(1);
+  }
+
+  printf("************  verify schema-less  *************\n");
+  verify_schema_less(taos);
+
+  printf("************  verify query  *************\n");
+  verify_query(taos);
+
+  printf("*********  verify async query  **********\n");
+  verify_async(taos);
+
+  printf("*********  verify stmt query  **********\n");
+  veriry_stmt(taos);
+
+  printf("done\n");
+  taos_close(taos);
+  taos_cleanup();
+}

include/client/taos.h

@@ -130,17 +130,16 @@ typedef struct TAOS_VGROUP_HASH_INFO {
   int32_t  vgId;
   uint32_t hashBegin;
   uint32_t hashEnd;
-} TAOS_VGROUP_HASH_INFO ;
+} TAOS_VGROUP_HASH_INFO;
 
 typedef struct TAOS_DB_ROUTE_INFO {
-  int32_t   routeVersion;  
+  int32_t                routeVersion;
-  int16_t   hashPrefix;
+  int16_t                hashPrefix;
-  int16_t   hashSuffix;
+  int16_t                hashSuffix;
-  int8_t    hashMethod;
+  int8_t                 hashMethod;
-  int32_t   vgNum;
+  int32_t                vgNum;
   TAOS_VGROUP_HASH_INFO *vgHash;
-} TAOS_DB_ROUTE_INFO ;
+} TAOS_DB_ROUTE_INFO;
-
 
 DLL_EXPORT void       taos_cleanup(void);
 DLL_EXPORT int        taos_options(TSDB_OPTION option, const void *arg, ...);
@@ -153,6 +152,7 @@ DLL_EXPORT void  taos_close(TAOS *taos);
 const char *taos_data_type(int type);
 
 DLL_EXPORT TAOS_STMT *taos_stmt_init(TAOS *taos);
+DLL_EXPORT TAOS_STMT *taos_stmt_init_with_reqid(TAOS *taos, int64_t reqid);
 DLL_EXPORT int        taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length);
 DLL_EXPORT int        taos_stmt_set_tbname_tags(TAOS_STMT *stmt, const char *name, TAOS_MULTI_BIND *tags);
 DLL_EXPORT int        taos_stmt_set_tbname(TAOS_STMT *stmt, const char *name);
@@ -176,6 +176,7 @@ DLL_EXPORT int       taos_stmt_affected_rows(TAOS_STMT *stmt);
 DLL_EXPORT int       taos_stmt_affected_rows_once(TAOS_STMT *stmt);
 
 DLL_EXPORT TAOS_RES *taos_query(TAOS *taos, const char *sql);
+DLL_EXPORT TAOS_RES *taos_query_with_reqid(TAOS *taos, const char *sql, int64_t reqId);
 
 DLL_EXPORT TAOS_ROW taos_fetch_row(TAOS_RES *res);
 DLL_EXPORT int      taos_result_precision(TAOS_RES *res);  // get the time precision of result
@@ -207,17 +208,23 @@ DLL_EXPORT const char *taos_get_client_info();
 DLL_EXPORT const char *taos_errstr(TAOS_RES *res);
 DLL_EXPORT int         taos_errno(TAOS_RES *res);
 
-DLL_EXPORT void        taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param);
+DLL_EXPORT void taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param);
-DLL_EXPORT void        taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param);
+DLL_EXPORT void taos_query_a_with_reqid(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param, int64_t reqid);
-DLL_EXPORT void        taos_fetch_raw_block_a(TAOS_RES *res, __taos_async_fn_t fp, void *param);
+DLL_EXPORT void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param);
+DLL_EXPORT void taos_fetch_raw_block_a(TAOS_RES *res, __taos_async_fn_t fp, void *param);
 DLL_EXPORT const void *taos_get_raw_block(TAOS_RES *res);
 
-DLL_EXPORT int       taos_get_db_route_info(TAOS* taos, const char* db, TAOS_DB_ROUTE_INFO* dbInfo);
+DLL_EXPORT int taos_get_db_route_info(TAOS *taos, const char *db, TAOS_DB_ROUTE_INFO *dbInfo);
-DLL_EXPORT int       taos_get_table_vgId(TAOS* taos, const char* db, const char* table, int* vgId);
+DLL_EXPORT int taos_get_table_vgId(TAOS *taos, const char *db, const char *table, int *vgId);
 
 DLL_EXPORT int       taos_load_table_info(TAOS *taos, const char *tableNameList);
 DLL_EXPORT TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision);
-DLL_EXPORT TAOS_RES *taos_schemaless_insert_raw(TAOS* taos, char* lines, int len, int32_t *totalRows, int protocol, int precision);
+DLL_EXPORT TAOS_RES *taos_schemaless_insert_with_reqid(TAOS *taos, char *lines[], int numLines, int protocol,
+                                                       int precision, int64_t reqid);
+DLL_EXPORT TAOS_RES *taos_schemaless_insert_raw(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol,
+                                                int precision);
+DLL_EXPORT TAOS_RES *taos_schemaless_insert_raw_with_reqid(TAOS *taos, char *lines, int len, int32_t *totalRows,
+                                                           int protocol, int precision, int64_t reqid);
 
 /* --------------------------TMQ INTERFACE------------------------------- */
 

include/common/tmsg.h

@@ -216,14 +216,9 @@ typedef struct SEp {
   uint16_t port;
 } SEp;
 
-#define SHOW_REWRITE_MASK() (1 << 0)
-
-#define TEST_SHOW_REWRITE_MASK(m) (((m) & SHOW_REWRITE_MASK()) != 0)
-
 typedef struct {
   int32_t contLen;
   int32_t vgId;
-  int32_t msgMask;
 } SMsgHead;
 
 // Submit message for one table
@@ -1616,6 +1611,7 @@ typedef struct SSubQueryMsg {
   int8_t   needFetch;
   uint32_t sqlLen;  // the query sql,
   uint32_t phyLen;
+  int32_t  msgMask;
   char     msg[];
 } SSubQueryMsg;
 

include/libs/catalog/catalog.h

@@ -207,7 +207,7 @@ int32_t catalogGetCachedTableMeta(SCatalog* pCtg, const SName* pTableName, STabl
 
 int32_t catalogGetCachedSTableMeta(SCatalog* pCtg, const SName* pTableName, STableMeta** pTableMeta);
 
-int32_t catalogGetCachedTableHashVgroup(SCatalog* pCtg, const SName* pTableName,           SVgroupInfo* pVgroup, bool* exists);
+int32_t catalogGetCachedTableHashVgroup(SCatalog* pCtg, const SName* pTableName, SVgroupInfo* pVgroup, bool* exists);
 
 /**
  * Force refresh DB's local cached vgroup info.
@@ -307,8 +307,8 @@ int32_t catalogGetUdfInfo(SCatalog* pCtg, SRequestConnInfo* pConn, const char* f
 int32_t catalogChkAuth(SCatalog* pCtg, SRequestConnInfo* pConn, const char* user, const char* dbFName, AUTH_TYPE type,
                        bool* pass);
 
-int32_t catalogChkAuthFromCache(SCatalog* pCtg, const char* user, const char* dbFName, AUTH_TYPE type,
+int32_t catalogChkAuthFromCache(SCatalog* pCtg, const char* user, const char* dbFName, AUTH_TYPE type, bool* pass,
-                                       bool* pass, bool* exists);
+                                bool* exists);
 
 int32_t catalogUpdateUserAuthInfo(SCatalog* pCtg, SGetUserAuthRsp* pAuth);
 
@@ -324,9 +324,9 @@ SMetaData* catalogCloneMetaData(SMetaData* pData);
 
 void catalogFreeMetaData(SMetaData* pData);
 
-int32_t ctgdEnableDebug(char *option, bool enable);
+int32_t ctgdEnableDebug(char* option, bool enable);
 
-int32_t ctgdHandleDbgCommand(char *command);
+int32_t ctgdHandleDbgCommand(char* command);
 
 /**
  * Destroy catalog and relase all resources

include/libs/nodes/querynodes.h

@@ -354,12 +354,33 @@ typedef struct SVgDataBlocks {
   void*       pData;  // SMsgDesc + SSubmitReq + SSubmitBlk + ...
 } SVgDataBlocks;
 
+typedef void (*FFreeDataBlockHash)(SHashObj*);
+typedef void (*FFreeDataBlockArray)(SArray*);
+
 typedef struct SVnodeModifOpStmt {
-  ENodeType   nodeType;
+  ENodeType           nodeType;
-  ENodeType   sqlNodeType;
+  ENodeType           sqlNodeType;
-  SArray*     pDataBlocks;  // data block for each vgroup, SArray<SVgDataBlocks*>.
+  SArray*             pDataBlocks;  // data block for each vgroup, SArray<SVgDataBlocks*>.
-  uint32_t    insertType;   // insert data from [file|sql statement| bound statement]
+  uint32_t            insertType;   // insert data from [file|sql statement| bound statement]
-  const char* sql;          // current sql statement position
+  const char*         pSql;         // current sql statement position
+  int32_t             totalRowsNum;
+  int32_t             totalTbNum;
+  SName               targetTableName;
+  SName               usingTableName;
+  const char*         pBoundCols;
+  struct STableMeta*  pTableMeta;
+  SHashObj*           pVgroupsHashObj;
+  SHashObj*           pTableBlockHashObj;
+  SHashObj*           pSubTableHashObj;
+  SHashObj*           pTableNameHashObj;
+  SHashObj*           pDbFNameHashObj;
+  SArray*             pVgDataBlocks;
+  SVCreateTbReq       createTblReq;
+  TdFilePtr           fp;
+  FFreeDataBlockHash  freeHashFunc;
+  FFreeDataBlockArray freeArrayFunc;
+  bool                usingTableProcessing;
+  bool                fileProcessing;
 } SVnodeModifOpStmt;
 
 typedef struct SExplainOptions {
@@ -389,24 +410,32 @@ typedef enum EQueryExecMode {
   QUERY_EXEC_MODE_EMPTY_RESULT
 } EQueryExecMode;
 
+typedef enum EQueryExecStage {
+  QUERY_EXEC_STAGE_PARSE = 1,
+  QUERY_EXEC_STAGE_ANALYSE,
+  QUERY_EXEC_STAGE_SCHEDULE,
+  QUERY_EXEC_STAGE_END
+} EQueryExecStage;
+
 typedef struct SQuery {
-  ENodeType      type;
+  ENodeType       type;
-  EQueryExecMode execMode;
+  EQueryExecStage execStage;
-  bool           haveResultSet;
+  EQueryExecMode  execMode;
-  SNode*         pRoot;
+  bool            haveResultSet;
-  int32_t        numOfResCols;
+  SNode*          pRoot;
-  SSchema*       pResSchema;
+  int32_t         numOfResCols;
-  int8_t         precision;
+  SSchema*        pResSchema;
-  SCmdMsgInfo*   pCmdMsg;
+  int8_t          precision;
-  int32_t        msgType;
+  SCmdMsgInfo*    pCmdMsg;
-  SArray*        pTargetTableList;
+  int32_t         msgType;
-  SArray*        pTableList;
+  SArray*         pTargetTableList;
-  SArray*        pDbList;
+  SArray*         pTableList;
-  bool           showRewrite;
+  SArray*         pDbList;
-  int32_t        placeholderNum;
+  bool            showRewrite;
-  SArray*        pPlaceholderValues;
+  int32_t         placeholderNum;
-  SNode*         pPrepareRoot;
+  SArray*         pPlaceholderValues;
-  bool           stableQuery;
+  SNode*          pPrepareRoot;
+  bool            stableQuery;
 } SQuery;
 
 void nodesWalkSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeWalker walker, void* pContext);

include/libs/parser/parser.h

@@ -64,8 +64,6 @@ typedef struct SParseContext {
   SArray*          pTableMetaPos;    // sql table pos => catalog data pos
   SArray*          pTableVgroupPos;  // sql table pos => catalog data pos
   int64_t          allocatorId;
-  bool             needMultiParse;
-  SParseCsvCxt     csvCxt;
 } SParseContext;
 
 int32_t qParseSql(SParseContext* pCxt, SQuery** pQuery);
@@ -75,6 +73,8 @@ bool    qIsInsertValuesSql(const char* pStr, size_t length);
 int32_t qParseSqlSyntax(SParseContext* pCxt, SQuery** pQuery, struct SCatalogReq* pCatalogReq);
 int32_t qAnalyseSqlSemantic(SParseContext* pCxt, const struct SCatalogReq* pCatalogReq,
                             const struct SMetaData* pMetaData, SQuery* pQuery);
+int32_t qContinueParseSql(SParseContext* pCxt, struct SCatalogReq* pCatalogReq, const struct SMetaData* pMetaData,
+                          SQuery* pQuery);
 
 void qDestroyParseContext(SParseContext* pCxt);
 

include/libs/qcom/query.h

@@ -57,6 +57,10 @@ typedef enum {
 #define QUERY_RSP_POLICY_DELAY 0
 #define QUERY_RSP_POLICY_QUICK 1
 
+#define QUERY_MSG_MASK_SHOW_REWRITE() (1 << 0)
+#define TEST_SHOW_REWRITE_MASK(m) (((m) & QUERY_MSG_MASK_SHOW_REWRITE()) != 0)
+
+
 typedef struct STableComInfo {
   uint8_t  numOfTags;     // the number of tags in schema
   uint8_t  precision;     // the number of precision

include/libs/qworker/qworker.h

@@ -76,7 +76,7 @@ int32_t qWorkerInit(int8_t nodeType, int32_t nodeId, void **qWorkerMgmt, const S
 
 int32_t qWorkerAbortPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg);
 
-int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg);
+int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg, bool chkGrant);
 
 int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts);
 

include/libs/sync/sync.h

@@ -138,6 +138,7 @@ typedef struct SSyncFSM {
   void (*FpRestoreFinishCb)(const struct SSyncFSM* pFsm);
   void (*FpReConfigCb)(const struct SSyncFSM* pFsm, const SRpcMsg* pMsg, const SReConfigCbMeta* pMeta);
   void (*FpLeaderTransferCb)(const struct SSyncFSM* pFsm, const SRpcMsg* pMsg, const SFsmCbMeta* pMeta);
+  bool (*FpApplyQueueEmptyCb)(const struct SSyncFSM* pFsm);
 
   void (*FpBecomeLeaderCb)(const struct SSyncFSM* pFsm);
   void (*FpBecomeFollowerCb)(const struct SSyncFSM* pFsm);

source/client/inc/clientInt.h

@@ -271,7 +271,11 @@ int32_t transferTableNameList(const char* tbList, int32_t acctId, char* dbName,
 void    syncCatalogFn(SMetaData* pResult, void* param, int32_t code);
 
 TAOS_RES* taosQueryImpl(TAOS* taos, const char* sql, bool validateOnly);
-void      taosAsyncQueryImpl(uint64_t connId, const char* sql, __taos_async_fn_t fp, void* param, bool validateOnly);
+TAOS_RES* taosQueryImplWithReqid(TAOS* taos, const char* sql, bool validateOnly, int64_t reqid);
+
+void taosAsyncQueryImpl(uint64_t connId, const char* sql, __taos_async_fn_t fp, void* param, bool validateOnly);
+void taosAsyncQueryImplWithReqid(uint64_t connId, const char* sql, __taos_async_fn_t fp, void* param, bool validateOnly,
+                                 int64_t reqid);
 
 int32_t getVersion1BlockMetaSize(const char* p, int32_t numOfCols);
 
@@ -318,11 +322,11 @@ void*    createTscObj(const char* user, const char* auth, const char* db, int32_
 void     destroyTscObj(void* pObj);
 STscObj* acquireTscObj(int64_t rid);
 int32_t  releaseTscObj(int64_t rid);
-void destroyAppInst(SAppInstInfo *pAppInfo);
+void     destroyAppInst(SAppInstInfo* pAppInfo);
 
 uint64_t generateRequestId();
 
-void*        createRequest(uint64_t connId, int32_t type);
+void*        createRequest(uint64_t connId, int32_t type, int64_t reqid);
 void         destroyRequest(SRequestObj* pRequest);
 SRequestObj* acquireRequest(int64_t rid);
 int32_t      releaseRequest(int64_t rid);
@@ -353,7 +357,7 @@ int32_t parseSql(SRequestObj* pRequest, bool topicQuery, SQuery** pQuery, SStmtC
 int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArray* pNodeList);
 
 int32_t buildRequest(uint64_t connId, const char* sql, int sqlLen, void* param, bool validateSql,
-                     SRequestObj** pRequest);
+                     SRequestObj** pRequest, int64_t reqid);
 
 void taos_close_internal(void* taos);
 
@@ -380,7 +384,6 @@ void hbMgrInitMqHbRspHandle();
 typedef struct SSqlCallbackWrapper {
   SParseContext* pParseCtx;
   SCatalogReq*   pCatalogReq;
-  SMetaData*     pResultMeta;
   SRequestObj*   pRequest;
 } SSqlCallbackWrapper;
 
@@ -394,7 +397,7 @@ int32_t removeMeta(STscObj* pTscObj, SArray* tbList);
 int32_t handleAlterTbExecRes(void* res, struct SCatalog* pCatalog);
 int32_t handleCreateTbExecRes(void* res, SCatalog* pCatalog);
 bool    qnodeRequired(SRequestObj* pRequest);
-int32_t continueInsertFromCsv(SSqlCallbackWrapper* pWrapper, SRequestObj* pRequest);
+void    continueInsertFromCsv(SSqlCallbackWrapper* pWrapper, SRequestObj* pRequest);
 void    destorySqlCallbackWrapper(SSqlCallbackWrapper* pWrapper);
 
 #ifdef __cplusplus

source/client/inc/clientStmt.h

@@ -101,11 +101,18 @@ typedef struct STscStmt {
   SStmtSQLInfo  sql;
   SStmtExecInfo exec;
   SStmtBindInfo bInfo;
+
+  int64_t reqid;
 } STscStmt;
 
 extern char *gStmtStatusStr[];
 
-#define STMT_LOG_SEQ(n) do { (pStmt)->seqId++; (pStmt)->seqIds[n]++; STMT_DLOG("the %dth:%d %s", (pStmt)->seqIds[n], (pStmt)->seqId, gStmtStatusStr[n]); } while (0)
+#define STMT_LOG_SEQ(n)                                                                 \
+  do {                                                                                  \
+    (pStmt)->seqId++;                                                                   \
+    (pStmt)->seqIds[n]++;                                                               \
+    STMT_DLOG("the %dth:%d %s", (pStmt)->seqIds[n], (pStmt)->seqId, gStmtStatusStr[n]); \
+  } while (0)
 
 #define STMT_STATUS_NE(S) (pStmt->sql.status != STMT_##S)
 #define STMT_STATUS_EQ(S) (pStmt->sql.status == STMT_##S)
@@ -141,7 +148,7 @@ extern char *gStmtStatusStr[];
 #define STMT_ELOG_E(param) qError("stmt:%p " param, pStmt)
 #define STMT_DLOG_E(param) qDebug("stmt:%p " param, pStmt)
 
-TAOS_STMT  *stmtInit(STscObj *taos);
+TAOS_STMT  *stmtInit(STscObj *taos, int64_t reqid);
 int         stmtClose(TAOS_STMT *stmt);
 int         stmtExec(TAOS_STMT *stmt);
 const char *stmtErrstr(TAOS_STMT *stmt);

source/client/src/clientEnv.c

@@ -77,19 +77,19 @@ static void deregisterRequest(SRequestObj *pRequest) {
            pRequest->self, pTscObj->id, pRequest->requestId, duration / 1000.0, num, currentInst);
 
   if (QUERY_NODE_VNODE_MODIF_STMT == pRequest->stmtType) {
-//    tscPerf("insert duration %" PRId64 "us: syntax:%" PRId64 "us, ctg:%" PRId64 "us, semantic:%" PRId64
+    //    tscPerf("insert duration %" PRId64 "us: syntax:%" PRId64 "us, ctg:%" PRId64 "us, semantic:%" PRId64
-//            "us, exec:%" PRId64 "us",
+    //            "us, exec:%" PRId64 "us",
-//            duration, pRequest->metric.syntaxEnd - pRequest->metric.syntaxStart,
+    //            duration, pRequest->metric.syntaxEnd - pRequest->metric.syntaxStart,
-//            pRequest->metric.ctgEnd - pRequest->metric.ctgStart, pRequest->metric.semanticEnd - pRequest->metric.ctgEnd,
+    //            pRequest->metric.ctgEnd - pRequest->metric.ctgStart, pRequest->metric.semanticEnd -
-//            pRequest->metric.execEnd - pRequest->metric.semanticEnd);
+    //            pRequest->metric.ctgEnd, pRequest->metric.execEnd - pRequest->metric.semanticEnd);
     atomic_add_fetch_64((int64_t *)&pActivity->insertElapsedTime, duration);
   } else if (QUERY_NODE_SELECT_STMT == pRequest->stmtType) {
-//    tscPerf("select duration %" PRId64 "us: syntax:%" PRId64 "us, ctg:%" PRId64 "us, semantic:%" PRId64
+    //    tscPerf("select duration %" PRId64 "us: syntax:%" PRId64 "us, ctg:%" PRId64 "us, semantic:%" PRId64
-//            "us, planner:%" PRId64 "us, exec:%" PRId64 "us, reqId:0x%" PRIx64,
+    //            "us, planner:%" PRId64 "us, exec:%" PRId64 "us, reqId:0x%" PRIx64,
-//            duration, pRequest->metric.syntaxEnd - pRequest->metric.syntaxStart,
+    //            duration, pRequest->metric.syntaxEnd - pRequest->metric.syntaxStart,
-//            pRequest->metric.ctgEnd - pRequest->metric.ctgStart, pRequest->metric.semanticEnd - pRequest->metric.ctgEnd,
+    //            pRequest->metric.ctgEnd - pRequest->metric.ctgStart, pRequest->metric.semanticEnd -
-//            pRequest->metric.planEnd - pRequest->metric.semanticEnd,
+    //            pRequest->metric.ctgEnd, pRequest->metric.planEnd - pRequest->metric.semanticEnd,
-//            pRequest->metric.resultReady - pRequest->metric.planEnd, pRequest->requestId);
+    //            pRequest->metric.resultReady - pRequest->metric.planEnd, pRequest->requestId);
 
     atomic_add_fetch_64((int64_t *)&pActivity->queryElapsedTime, duration);
   }
@@ -271,7 +271,7 @@ STscObj *acquireTscObj(int64_t rid) { return (STscObj *)taosAcquireRef(clientCon
 
 int32_t releaseTscObj(int64_t rid) { return taosReleaseRef(clientConnRefPool, rid); }
 
-void *createRequest(uint64_t connId, int32_t type) {
+void *createRequest(uint64_t connId, int32_t type, int64_t reqid) {
   SRequestObj *pRequest = (SRequestObj *)taosMemoryCalloc(1, sizeof(SRequestObj));
   if (NULL == pRequest) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -286,7 +286,7 @@ void *createRequest(uint64_t connId, int32_t type) {
   }
 
   pRequest->resType = RES_TYPE__QUERY;
-  pRequest->requestId = generateRequestId();
+  pRequest->requestId = reqid == 0 ? generateRequestId() : reqid;
   pRequest->metric.start = taosGetTimestampUs();
 
   pRequest->body.resInfo.convertUcs4 = true;  // convert ucs4 by default

source/client/src/clientImpl.c

@@ -154,8 +154,8 @@ STscObj* taos_connect_internal(const char* ip, const char* user, const char* pas
 }
 
 int32_t buildRequest(uint64_t connId, const char* sql, int sqlLen, void* param, bool validateSql,
-                     SRequestObj** pRequest) {
+                     SRequestObj** pRequest, int64_t reqid) {
-  *pRequest = createRequest(connId, TSDB_SQL_SELECT);
+  *pRequest = createRequest(connId, TSDB_SQL_SELECT, reqid);
   if (*pRequest == NULL) {
     tscError("failed to malloc sqlObj, %s", sql);
     return terrno;
@@ -873,6 +873,10 @@ int32_t handleQueryExecRsp(SRequestObj* pRequest) {
   return code;
 }
 
+static bool incompletaFileParsing(SNode* pStmt) {
+  return QUERY_NODE_VNODE_MODIF_STMT != nodeType(pStmt) ? false : ((SVnodeModifOpStmt*)pStmt)->fileProcessing;
+}
+
 // todo refacto the error code  mgmt
 void schedulerExecCb(SExecResult* pResult, void* param, int32_t code) {
   SSqlCallbackWrapper* pWrapper = param;
@@ -927,11 +931,10 @@ void schedulerExecCb(SExecResult* pResult, void* param, int32_t code) {
     pRequest->code = code1;
   }
 
-  if (pRequest->code == TSDB_CODE_SUCCESS && NULL != pWrapper->pParseCtx && pWrapper->pParseCtx->needMultiParse) {
+  if (pRequest->code == TSDB_CODE_SUCCESS && NULL != pRequest->pQuery &&
-    code = continueInsertFromCsv(pWrapper, pRequest);
+      incompletaFileParsing(pRequest->pQuery->pRoot)) {
-    if (TSDB_CODE_SUCCESS == code) {
+    continueInsertFromCsv(pWrapper, pRequest);
-      return;
+    return;
-    }
   }
 
   destorySqlCallbackWrapper(pWrapper);
@@ -1055,7 +1058,9 @@ static int32_t asyncExecSchQuery(SRequestObj* pRequest, SQuery* pQuery, SMetaDat
   }
   if (TSDB_CODE_SUCCESS == code && !pRequest->validateOnly) {
     SArray* pNodeList = NULL;
-    buildAsyncExecNodeList(pRequest, &pNodeList, pMnodeList, pResultMeta);
+    if (QUERY_NODE_VNODE_MODIF_STMT != nodeType(pQuery->pRoot)) {
+      buildAsyncExecNodeList(pRequest, &pNodeList, pMnodeList, pResultMeta);
+    }
 
     SRequestConnInfo conn = {.pTrans = getAppInfo(pRequest)->pTransporter,
                              .requestId = pRequest->requestId,
@@ -1230,7 +1235,7 @@ STscObj* taosConnectImpl(const char* user, const char* auth, const char* db, __t
     return pTscObj;
   }
 
-  SRequestObj* pRequest = createRequest(pTscObj->id, TDMT_MND_CONNECT);
+  SRequestObj* pRequest = createRequest(pTscObj->id, TDMT_MND_CONNECT, 0);
   if (pRequest == NULL) {
     destroyTscObj(pTscObj);
     return NULL;
@@ -2234,7 +2239,37 @@ void taosAsyncQueryImpl(uint64_t connId, const char* sql, __taos_async_fn_t fp,
   }
 
   SRequestObj* pRequest = NULL;
-  int32_t      code = buildRequest(connId, sql, sqlLen, param, validateOnly, &pRequest);
+  int32_t      code = buildRequest(connId, sql, sqlLen, param, validateOnly, &pRequest, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    terrno = code;
+    fp(param, NULL, terrno);
+    return;
+  }
+
+  pRequest->body.queryFp = fp;
+  doAsyncQuery(pRequest, false);
+}
+void taosAsyncQueryImplWithReqid(uint64_t connId, const char* sql, __taos_async_fn_t fp, void* param, bool validateOnly,
+                                 int64_t reqid) {
+  if (sql == NULL || NULL == fp) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    if (fp) {
+      fp(param, NULL, terrno);
+    }
+
+    return;
+  }
+
+  size_t sqlLen = strlen(sql);
+  if (sqlLen > (size_t)TSDB_MAX_ALLOWED_SQL_LEN) {
+    tscError("sql string exceeds max length:%d", TSDB_MAX_ALLOWED_SQL_LEN);
+    terrno = TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
+    fp(param, NULL, terrno);
+    return;
+  }
+
+  SRequestObj* pRequest = NULL;
+  int32_t      code = buildRequest(connId, sql, sqlLen, param, validateOnly, &pRequest, reqid);
   if (code != TSDB_CODE_SUCCESS) {
     terrno = code;
     fp(param, NULL, terrno);
@@ -2261,3 +2296,20 @@ TAOS_RES* taosQueryImpl(TAOS* taos, const char* sql, bool validateOnly) {
   }
   return param->pRequest;
 }
+
+TAOS_RES* taosQueryImplWithReqid(TAOS* taos, const char* sql, bool validateOnly, int64_t reqid) {
+  if (NULL == taos) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return NULL;
+  }
+
+  SSyncQueryParam* param = taosMemoryCalloc(1, sizeof(SSyncQueryParam));
+  tsem_init(&param->sem, 0, 0);
+
+  taosAsyncQueryImplWithReqid(*(int64_t*)taos, sql, syncQueryFn, param, validateOnly, reqid);
+  tsem_wait(&param->sem);
+  if (param->pRequest != NULL) {
+    param->pRequest->syncQuery = true;
+  }
+  return param->pRequest;
+}

source/client/src/clientMain.c

@@ -248,6 +248,9 @@ TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
 }
 
 TAOS_RES *taos_query(TAOS *taos, const char *sql) { return taosQueryImpl(taos, sql, false); }
+TAOS_RES *taos_query_with_reqid(TAOS *taos, const char *sql, int64_t reqid) {
+  return taosQueryImplWithReqid(taos, sql, false, reqid);
+}
 
 TAOS_ROW taos_fetch_row(TAOS_RES *res) {
   if (res == NULL) {
@@ -683,11 +686,10 @@ void destorySqlCallbackWrapper(SSqlCallbackWrapper *pWrapper) {
   }
   destoryCatalogReq(pWrapper->pCatalogReq);
   qDestroyParseContext(pWrapper->pParseCtx);
-  catalogFreeMetaData(pWrapper->pResultMeta);
   taosMemoryFree(pWrapper);
 }
 
-void retrieveMetaCallback(SMetaData *pResultMeta, void *param, int32_t code) {
+static void doAsyncQueryFromAnalyse(SMetaData *pResultMeta, void *param, int32_t code) {
   SSqlCallbackWrapper *pWrapper = (SSqlCallbackWrapper *)param;
   SRequestObj         *pRequest = pWrapper->pRequest;
   SQuery              *pQuery = pRequest->pQuery;
@@ -705,13 +707,6 @@ void retrieveMetaCallback(SMetaData *pResultMeta, void *param, int32_t code) {
 
   pRequest->metric.semanticEnd = taosGetTimestampUs();
 
-  if (code == TSDB_CODE_SUCCESS && pWrapper->pParseCtx->needMultiParse) {
-    pWrapper->pResultMeta = catalogCloneMetaData(pResultMeta);
-    if (NULL == pWrapper->pResultMeta) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
-    }
-  }
-
   if (code == TSDB_CODE_SUCCESS) {
     if (pQuery->haveResultSet) {
       setResSchemaInfo(&pRequest->body.resInfo, pQuery->pResSchema, pQuery->numOfResCols);
@@ -748,14 +743,83 @@ void retrieveMetaCallback(SMetaData *pResultMeta, void *param, int32_t code) {
   }
 }
 
-int32_t continueInsertFromCsv(SSqlCallbackWrapper *pWrapper, SRequestObj *pRequest) {
+static int32_t getAllMetaAsync(SSqlCallbackWrapper *pWrapper, catalogCallback fp) {
-  qDestroyQuery(pRequest->pQuery);
+  SRequestConnInfo conn = {.pTrans = pWrapper->pParseCtx->pTransporter,
-  pRequest->pQuery = (SQuery *)nodesMakeNode(QUERY_NODE_QUERY);
+                           .requestId = pWrapper->pParseCtx->requestId,
-  if (NULL == pRequest->pQuery) {
+                           .requestObjRefId = pWrapper->pParseCtx->requestRid,
-    return TSDB_CODE_OUT_OF_MEMORY;
+                           .mgmtEps = pWrapper->pParseCtx->mgmtEpSet};
+
+  pWrapper->pRequest->metric.ctgStart = taosGetTimestampUs();
+
+  return catalogAsyncGetAllMeta(pWrapper->pParseCtx->pCatalog, &conn, pWrapper->pCatalogReq, fp, pWrapper,
+                                &pWrapper->pRequest->body.queryJob);
+}
+
+static void doAsyncQueryFromParse(SMetaData *pResultMeta, void *param, int32_t code);
+
+static int32_t phaseAsyncQuery(SSqlCallbackWrapper *pWrapper) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  switch (pWrapper->pRequest->pQuery->execStage) {
+    case QUERY_EXEC_STAGE_PARSE: {
+      // continue parse after get metadata
+      code = getAllMetaAsync(pWrapper, doAsyncQueryFromParse);
+      break;
+    }
+    case QUERY_EXEC_STAGE_ANALYSE: {
+      // analysis after get metadata
+      code = getAllMetaAsync(pWrapper, doAsyncQueryFromAnalyse);
+      break;
+    }
+    case QUERY_EXEC_STAGE_SCHEDULE: {
+      launchAsyncQuery(pWrapper->pRequest, pWrapper->pRequest->pQuery, NULL, pWrapper);
+      break;
+    }
+    default:
+      break;
+  }
+  return code;
+}
+
+static void doAsyncQueryFromParse(SMetaData *pResultMeta, void *param, int32_t code) {
+  SSqlCallbackWrapper *pWrapper = (SSqlCallbackWrapper *)param;
+  SRequestObj         *pRequest = pWrapper->pRequest;
+  SQuery              *pQuery = pRequest->pQuery;
+
+  pRequest->metric.ctgEnd = taosGetTimestampUs();
+  qDebug("0x%" PRIx64 " start to continue parse, reqId:0x%" PRIx64, pRequest->self, pRequest->requestId);
+
+  if (code == TSDB_CODE_SUCCESS) {
+    code = qContinueParseSql(pWrapper->pParseCtx, pWrapper->pCatalogReq, pResultMeta, pQuery);
+  }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    code = phaseAsyncQuery(pWrapper);
+  }
+
+  if (TSDB_CODE_SUCCESS != code) {
+    tscError("0x%" PRIx64 " error happens, code:%d - %s, reqId:0x%" PRIx64, pWrapper->pRequest->self, code,
+             tstrerror(code), pWrapper->pRequest->requestId);
+    destorySqlCallbackWrapper(pWrapper);
+    terrno = code;
+    pRequest->code = code;
+    pRequest->body.queryFp(pRequest->body.param, pRequest, code);
+  }
+}
+
+void continueInsertFromCsv(SSqlCallbackWrapper *pWrapper, SRequestObj *pRequest) {
+  int32_t code = qParseSqlSyntax(pWrapper->pParseCtx, &pRequest->pQuery, pWrapper->pCatalogReq);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = phaseAsyncQuery(pWrapper);
+  }
+
+  if (TSDB_CODE_SUCCESS != code) {
+    tscError("0x%" PRIx64 " error happens, code:%d - %s, reqId:0x%" PRIx64, pWrapper->pRequest->self, code,
+             tstrerror(code), pWrapper->pRequest->requestId);
+    destorySqlCallbackWrapper(pWrapper);
+    terrno = code;
+    pWrapper->pRequest->code = code;
+    pWrapper->pRequest->body.queryFp(pWrapper->pRequest->body.param, pWrapper->pRequest, code);
   }
-  retrieveMetaCallback(pWrapper->pResultMeta, pWrapper, TSDB_CODE_SUCCESS);
-  return TSDB_CODE_SUCCESS;
 }
 
 void taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param) {
@@ -763,6 +827,11 @@ void taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param
   taosAsyncQueryImpl(connId, sql, fp, param, false);
 }
 
+void taos_query_a_with_reqid(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param, int64_t reqid) {
+  int64_t connId = *(int64_t *)taos;
+  taosAsyncQueryImplWithReqid(connId, sql, fp, param, false, reqid);
+}
+
 int32_t createParseContext(const SRequestObj *pRequest, SParseContext **pCxt) {
   const STscObj *pTscObj = pRequest->pTscObj;
 
@@ -837,26 +906,16 @@ void doAsyncQuery(SRequestObj *pRequest, bool updateMetaForce) {
 
   if (TSDB_CODE_SUCCESS == code && !updateMetaForce) {
     SAppClusterSummary *pActivity = &pTscObj->pAppInfo->summary;
-    if (NULL == pRequest->pQuery->pRoot) {
+    if (QUERY_NODE_INSERT_STMT == nodeType(pRequest->pQuery->pRoot)) {
       atomic_add_fetch_64((int64_t *)&pActivity->numOfInsertsReq, 1);
-    } else if (QUERY_NODE_SELECT_STMT == pRequest->pQuery->pRoot->type) {
+    } else if (QUERY_NODE_SELECT_STMT == nodeType(pRequest->pQuery->pRoot)) {
       atomic_add_fetch_64((int64_t *)&pActivity->numOfQueryReq, 1);
     }
   }
 
   if (TSDB_CODE_SUCCESS == code) {
-    SRequestConnInfo conn = {.pTrans = pWrapper->pParseCtx->pTransporter,
+    phaseAsyncQuery(pWrapper);
-                             .requestId = pWrapper->pParseCtx->requestId,
+  } else {
-                             .requestObjRefId = pWrapper->pParseCtx->requestRid,
-                             .mgmtEps = pWrapper->pParseCtx->mgmtEpSet};
-
-    pRequest->metric.ctgStart = taosGetTimestampUs();
-
-    code = catalogAsyncGetAllMeta(pWrapper->pParseCtx->pCatalog, &conn, pWrapper->pCatalogReq, retrieveMetaCallback,
-                                  pWrapper, &pRequest->body.queryJob);
-  }
-
-  if (TSDB_CODE_SUCCESS != code) {
     tscError("0x%" PRIx64 " error happens, code:%d - %s, reqId:0x%" PRIx64, pRequest->self, code, tstrerror(code),
              pRequest->requestId);
     destorySqlCallbackWrapper(pWrapper);
@@ -992,7 +1051,7 @@ int taos_get_db_route_info(TAOS *taos, const char *db, TAOS_DB_ROUTE_INFO *dbInf
   int64_t      connId = *(int64_t *)taos;
   SRequestObj *pRequest = NULL;
   char        *sql = "taos_get_db_route_info";
-  int32_t      code = buildRequest(connId, sql, strlen(sql), NULL, false, &pRequest);
+  int32_t      code = buildRequest(connId, sql, strlen(sql), NULL, false, &pRequest, 0);
   if (code != TSDB_CODE_SUCCESS) {
     terrno = code;
     return terrno;
@@ -1041,7 +1100,7 @@ int taos_get_table_vgId(TAOS *taos, const char *db, const char *table, int *vgId
   int64_t      connId = *(int64_t *)taos;
   SRequestObj *pRequest = NULL;
   char        *sql = "taos_get_table_vgId";
-  int32_t      code = buildRequest(connId, sql, strlen(sql), NULL, false, &pRequest);
+  int32_t      code = buildRequest(connId, sql, strlen(sql), NULL, false, &pRequest, 0);
   if (code != TSDB_CODE_SUCCESS) {
     return terrno;
   }
@@ -1102,7 +1161,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   }
 
   char *sql = "taos_load_table_info";
-  code = buildRequest(connId, sql, strlen(sql), NULL, false, &pRequest);
+  code = buildRequest(connId, sql, strlen(sql), NULL, false, &pRequest, 0);
   if (code != TSDB_CODE_SUCCESS) {
     terrno = code;
     goto _return;
@@ -1147,7 +1206,22 @@ TAOS_STMT *taos_stmt_init(TAOS *taos) {
     return NULL;
   }
 
-  TAOS_STMT *pStmt = stmtInit(pObj);
+  TAOS_STMT *pStmt = stmtInit(pObj, 0);
+
+  releaseTscObj(*(int64_t *)taos);
+
+  return pStmt;
+}
+
+TAOS_STMT *taos_stmt_init_with_reqid(TAOS *taos, int64_t reqid) {
+  STscObj *pObj = acquireTscObj(*(int64_t *)taos);
+  if (NULL == pObj) {
+    tscError("invalid parameter for %s", __FUNCTION__);
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return NULL;
+  }
+
+  TAOS_STMT *pStmt = stmtInit(pObj, reqid);
 
   releaseTscObj(*(int64_t *)taos);
 

source/client/src/clientRawBlockWrite.c

@@ -410,7 +410,7 @@ static char* processAlterTable(SMqMetaRsp* metaRsp) {
   SDecoder     decoder = {0};
   SVAlterTbReq vAlterTbReq = {0};
   char*        string = NULL;
-  cJSON*       json   = NULL;
+  cJSON*       json = NULL;
 
   // decode
   void*   data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
@@ -525,7 +525,7 @@ static char* processDropSTable(SMqMetaRsp* metaRsp) {
   SDecoder     decoder = {0};
   SVDropStbReq req = {0};
   char*        string = NULL;
-  cJSON*       json   = NULL;
+  cJSON*       json = NULL;
 
   // decode
   void*   data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
@@ -558,7 +558,7 @@ static char* processDropTable(SMqMetaRsp* metaRsp) {
   SDecoder         decoder = {0};
   SVDropTbBatchReq req = {0};
   char*            string = NULL;
-  cJSON*           json   = NULL;
+  cJSON*           json = NULL;
 
   // decode
   void*   data = POINTER_SHIFT(metaRsp->metaRsp, sizeof(SMsgHead));
@@ -603,7 +603,7 @@ static int32_t taosCreateStb(TAOS* taos, void* meta, int32_t metaLen) {
   int32_t        code = TSDB_CODE_SUCCESS;
   SRequestObj*   pRequest = NULL;
 
-  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest);
+  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest, 0);
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
   }
@@ -692,7 +692,7 @@ static int32_t taosDropStb(TAOS* taos, void* meta, int32_t metaLen) {
   int32_t      code = TSDB_CODE_SUCCESS;
   SRequestObj* pRequest = NULL;
 
-  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest);
+  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest, 0);
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
   }
@@ -773,7 +773,7 @@ static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) {
   SQuery*            pQuery = NULL;
   SHashObj*          pVgroupHashmap = NULL;
 
-  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest);
+  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest, 0);
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
   }
@@ -926,7 +926,7 @@ static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) {
   SQuery*          pQuery = NULL;
   SHashObj*        pVgroupHashmap = NULL;
 
-  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest);
+  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest, 0);
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
   }
@@ -1097,7 +1097,7 @@ static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
   SArray*        pArray = NULL;
   SVgDataBlocks* pVgData = NULL;
 
-  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest);
+  code = buildRequest(*(int64_t*)taos, "", 0, NULL, false, &pRequest, 0);
 
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
@@ -1217,7 +1217,7 @@ int taos_write_raw_block(TAOS* taos, int rows, char* pData, const char* tbname)
   SQuery*     pQuery = NULL;
   SSubmitReq* subReq = NULL;
 
-  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT);
+  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, 0);
   if (!pRequest) {
     uError("WriteRaw:createRequest error request is null");
     code = terrno;
@@ -1281,7 +1281,7 @@ int taos_write_raw_block(TAOS* taos, int rows, char* pData, const char* tbname)
   int32_t schemaLen = 0;
   int32_t submitLen = sizeof(SSubmitBlk) + schemaLen + rows * extendedRowSize;
 
-  int32_t     totalLen = sizeof(SSubmitReq) + submitLen;
+  int32_t totalLen = sizeof(SSubmitReq) + submitLen;
   subReq = taosMemoryCalloc(1, totalLen);
   SSubmitBlk* blk = POINTER_SHIFT(subReq, sizeof(SSubmitReq));
   void*       blkSchema = POINTER_SHIFT(blk, sizeof(SSubmitBlk));
@@ -1407,7 +1407,7 @@ static int32_t tmqWriteRawDataImpl(TAOS* taos, void* data, int32_t dataLen) {
   STableMeta* pTableMeta = NULL;
 
   terrno = TSDB_CODE_SUCCESS;
-  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT);
+  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, 0);
   if (!pRequest) {
     uError("WriteRaw:createRequest error request is null");
     return terrno;
@@ -1674,7 +1674,7 @@ static int32_t tmqWriteRawMetaDataImpl(TAOS* taos, void* data, int32_t dataLen)
   STableMeta*    pTableMeta = NULL;
 
   terrno = TSDB_CODE_SUCCESS;
-  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT);
+  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, 0);
   if (!pRequest) {
     uError("WriteRaw:createRequest error request is null");
     return terrno;

source/client/src/clientSml.c

@@ -28,12 +28,12 @@
 #define QUOTE '"'
 #define SLASH '\\'
 
-#define JUMP_SPACE(sql, sqlEnd)  \
+#define JUMP_SPACE(sql, sqlEnd) \
-  while (sql < sqlEnd) { \
+  while (sql < sqlEnd) {        \
-    if (*sql == SPACE)   \
+    if (*sql == SPACE)          \
-      sql++;             \
+      sql++;                    \
-    else                 \
+    else                        \
-      break;             \
+      break;                    \
   }
 // comma ,
 #define IS_SLASH_COMMA(sql) (*(sql) == COMMA && *((sql)-1) == SLASH)
@@ -353,7 +353,7 @@ static int32_t smlSendMetaMsg(SSmlHandle *info, SName *pName, SArray *pColumns,
   pReq.numOfTags = taosArrayGetSize(pTags);
   pReq.pTags = pTags;
 
-  code = buildRequest(info->taos->id, "", 0, NULL, false, &pRequest);
+  code = buildRequest(info->taos->id, "", 0, NULL, false, &pRequest, 0);
   if (code != TSDB_CODE_SUCCESS) {
     goto end;
   }
@@ -1010,9 +1010,9 @@ static void smlParseTelnetElement(const char **sql, const char *sqlEnd, const ch
   }
 }
 
-static int32_t smlParseTelnetTags(const char *data, const char *sqlEnd, SArray *cols, char *childTableName, SHashObj *dumplicateKey,
+static int32_t smlParseTelnetTags(const char *data, const char *sqlEnd, SArray *cols, char *childTableName,
-                                  SSmlMsgBuf *msg) {
+                                  SHashObj *dumplicateKey, SSmlMsgBuf *msg) {
-  if(!cols) return TSDB_CODE_OUT_OF_MEMORY;
+  if (!cols) return TSDB_CODE_OUT_OF_MEMORY;
   const char *sql = data;
   size_t      childTableNameLen = strlen(tsSmlChildTableName);
   while (sql < sqlEnd) {
@@ -1093,7 +1093,8 @@ static int32_t smlParseTelnetTags(const char *data, const char *sqlEnd, SArray *
 }
 
 // format: <metric> <timestamp> <value> <tagk_1>=<tagv_1>[ <tagk_n>=<tagv_n>]
-static int32_t smlParseTelnetString(SSmlHandle *info, const char *sql, const char *sqlEnd, SSmlTableInfo *tinfo, SArray *cols) {
+static int32_t smlParseTelnetString(SSmlHandle *info, const char *sql, const char *sqlEnd, SSmlTableInfo *tinfo,
+                                    SArray *cols) {
   if (!sql) return TSDB_CODE_SML_INVALID_DATA;
 
   // parse metric
@@ -1372,19 +1373,19 @@ static int32_t smlKvTimeArrayCompare(const void *key1, const void *key2) {
 static int32_t smlKvTimeHashCompare(const void *key1, const void *key2) {
   SHashObj *s1 = *(SHashObj **)key1;
   SHashObj *s2 = *(SHashObj **)key2;
-  SSmlKv   **kv1pp = (SSmlKv **)taosHashGet(s1, TS, TS_LEN);
+  SSmlKv  **kv1pp = (SSmlKv **)taosHashGet(s1, TS, TS_LEN);
-  SSmlKv   **kv2pp = (SSmlKv **)taosHashGet(s2, TS, TS_LEN);
+  SSmlKv  **kv2pp = (SSmlKv **)taosHashGet(s2, TS, TS_LEN);
-  if(!kv1pp || !kv2pp){
+  if (!kv1pp || !kv2pp) {
     uError("smlKvTimeHashCompare kv is null");
     return -1;
   }
-  SSmlKv   *kv1 = *kv1pp;
+  SSmlKv *kv1 = *kv1pp;
-  SSmlKv   *kv2 = *kv2pp;
+  SSmlKv *kv2 = *kv2pp;
-  if(!kv1 || kv1->type != TSDB_DATA_TYPE_TIMESTAMP){
+  if (!kv1 || kv1->type != TSDB_DATA_TYPE_TIMESTAMP) {
     uError("smlKvTimeHashCompare kv1");
     return -1;
   }
-  if(!kv2 || kv2->type != TSDB_DATA_TYPE_TIMESTAMP){
+  if (!kv2 || kv2->type != TSDB_DATA_TYPE_TIMESTAMP) {
     uError("smlKvTimeHashCompare kv2");
     return -1;
   }
@@ -1947,7 +1948,7 @@ static int32_t smlParseValueFromJSON(cJSON *root, SSmlKv *kv) {
 }
 
 static int32_t smlParseColsFromJSON(cJSON *root, SArray *cols) {
-  if(!cols) return TSDB_CODE_OUT_OF_MEMORY;
+  if (!cols) return TSDB_CODE_OUT_OF_MEMORY;
   cJSON *metricVal = cJSON_GetObjectItem(root, "value");
   if (metricVal == NULL) {
     return TSDB_CODE_TSC_INVALID_JSON;
@@ -1971,7 +1972,7 @@ static int32_t smlParseColsFromJSON(cJSON *root, SArray *cols) {
 static int32_t smlParseTagsFromJSON(cJSON *root, SArray *pKVs, char *childTableName, SHashObj *dumplicateKey,
                                     SSmlMsgBuf *msg) {
   int32_t ret = TSDB_CODE_SUCCESS;
-  if (!pKVs){
+  if (!pKVs) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
   cJSON *tags = cJSON_GetObjectItem(root, "tags");
@@ -2204,7 +2205,7 @@ static int32_t smlParseTelnetLine(SSmlHandle *info, void *data, const int len) {
   }
 
   if (info->protocol == TSDB_SML_TELNET_PROTOCOL) {
-    ret = smlParseTelnetString(info, (const char *)data, (char*)data + len, tinfo, cols);
+    ret = smlParseTelnetString(info, (const char *)data, (char *)data + len, tinfo, cols);
   } else if (info->protocol == TSDB_SML_JSON_PROTOCOL) {
     ret = smlParseJSONString(info, (cJSON *)data, tinfo, cols);
   } else {
@@ -2384,16 +2385,16 @@ static void smlPrintStatisticInfo(SSmlHandle *info) {
          info->cost.endTime - info->cost.insertRpcTime, info->cost.endTime - info->cost.parseTime);
 }
 
-static int32_t smlParseLine(SSmlHandle *info, char *lines[], char* rawLine, char* rawLineEnd, int numLines) {
+static int32_t smlParseLine(SSmlHandle *info, char *lines[], char *rawLine, char *rawLineEnd, int numLines) {
   int32_t code = TSDB_CODE_SUCCESS;
   if (info->protocol == TSDB_SML_JSON_PROTOCOL) {
-    if(lines){
+    if (lines) {
       code = smlParseJSON(info, *lines);
-    }else if(rawLine){
+    } else if (rawLine) {
       code = smlParseJSON(info, rawLine);
     }
     if (code != TSDB_CODE_SUCCESS) {
-      uError("SML:0x%" PRIx64 " smlParseJSON failed:%s", info->id, lines?*lines:rawLine);
+      uError("SML:0x%" PRIx64 " smlParseJSON failed:%s", info->id, lines ? *lines : rawLine);
       return code;
     }
     return code;
@@ -2401,19 +2402,19 @@ static int32_t smlParseLine(SSmlHandle *info, char *lines[], char* rawLine, char
 
   for (int32_t i = 0; i < numLines; ++i) {
     char *tmp = NULL;
-    int  len  = 0;
+    int   len = 0;
-    if(lines){
+    if (lines) {
       tmp = lines[i];
       len = strlen(tmp);
-    }else if(rawLine){
+    } else if (rawLine) {
       tmp = rawLine;
-      while(rawLine < rawLineEnd){
+      while (rawLine < rawLineEnd) {
-        if(*(rawLine++) == '\n'){
+        if (*(rawLine++) == '\n') {
           break;
         }
         len++;
       }
-      if(info->protocol == TSDB_SML_LINE_PROTOCOL && tmp[0] == '#'){ // this line is comment
+      if (info->protocol == TSDB_SML_LINE_PROTOCOL && tmp[0] == '#') {  // this line is comment
         continue;
       }
     }
@@ -2433,7 +2434,7 @@ static int32_t smlParseLine(SSmlHandle *info, char *lines[], char* rawLine, char
   return code;
 }
 
-static int smlProcess(SSmlHandle *info, char *lines[], char* rawLine, char* rawLineEnd, int numLines) {
+static int smlProcess(SSmlHandle *info, char *lines[], char *rawLine, char *rawLineEnd, int numLines) {
   int32_t code = TSDB_CODE_SUCCESS;
   int32_t retryNum = 0;
 
@@ -2532,8 +2533,8 @@ static void smlInsertCallback(void *param, void *res, int32_t code) {
   smlDestroyInfo(info);
 }
 
-
+TAOS_RES *taos_schemaless_insert_inner(SRequestObj *request, char *lines[], char *rawLine, char *rawLineEnd,
-TAOS_RES *taos_schemaless_insert_inner(SRequestObj *request, char *lines[], char *rawLine, char *rawLineEnd, int numLines, int protocol, int precision) {
+                                       int numLines, int protocol, int precision) {
   int      batchs = 0;
   STscObj *pTscObj = request->pTscObj;
 
@@ -2581,7 +2582,7 @@ TAOS_RES *taos_schemaless_insert_inner(SRequestObj *request, char *lines[], char
   batchs = ceil(((double)numLines) / LINE_BATCH);
   params.total = batchs;
   for (int i = 0; i < batchs; ++i) {
-    SRequestObj *req = (SRequestObj *)createRequest(pTscObj->id, TSDB_SQL_INSERT);
+    SRequestObj *req = (SRequestObj *)createRequest(pTscObj->id, TSDB_SQL_INSERT, 0);
     if (!req) {
       request->code = TSDB_CODE_OUT_OF_MEMORY;
       uError("SML:taos_schemaless_insert error request is null");
@@ -2608,16 +2609,16 @@ TAOS_RES *taos_schemaless_insert_inner(SRequestObj *request, char *lines[], char
     info->pRequest->body.queryFp = smlInsertCallback;
     info->pRequest->body.param = info;
     int32_t code = smlProcess(info, lines, rawLine, rawLineEnd, perBatch);
-    if(lines){
+    if (lines) {
       lines += perBatch;
     }
-    if(rawLine){
+    if (rawLine) {
       int num = 0;
-      while(rawLine < rawLineEnd){
+      while (rawLine < rawLineEnd) {
-        if(*(rawLine++) == '\n'){
+        if (*(rawLine++) == '\n') {
           num++;
         }
-        if(num == perBatch){
+        if (num == perBatch) {
           break;
         }
       }
@@ -2628,7 +2629,7 @@ TAOS_RES *taos_schemaless_insert_inner(SRequestObj *request, char *lines[], char
   }
   tsem_wait(&params.sem);
 
-  end:
+end:
   taosThreadSpinDestroy(&params.lock);
   tsem_destroy(&params.sem);
   //  ((STscObj *)taos)->schemalessType = 0;
@@ -2653,9 +2654,7 @@ TAOS_RES *taos_schemaless_insert_inner(SRequestObj *request, char *lines[], char
  *                  0 - influxDB line protocol
  *                  1 - OpenTSDB telnet line protocol
  *                  2 - OpenTSDB JSON format protocol
- * @return return zero for successful insertion. Otherwise return none-zero error code of
+ * @return TAOS_RES
- *         failure reason.
- *
  */
 
 TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision) {
@@ -2664,7 +2663,7 @@ TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int pr
     return NULL;
   }
 
-  SRequestObj *request = (SRequestObj *)createRequest(*(int64_t *)taos, TSDB_SQL_INSERT);
+  SRequestObj *request = (SRequestObj *)createRequest(*(int64_t *)taos, TSDB_SQL_INSERT, 0);
   if (!request) {
     uError("SML:taos_schemaless_insert error request is null");
     return NULL;
@@ -2680,13 +2679,37 @@ TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int pr
   return taos_schemaless_insert_inner(request, lines, NULL, NULL, numLines, protocol, precision);
 }
 
-TAOS_RES *taos_schemaless_insert_raw(TAOS* taos, char* lines, int len, int32_t *totalRows, int protocol, int precision){
+TAOS_RES *taos_schemaless_insert_with_reqid(TAOS *taos, char *lines[], int numLines, int protocol, int precision,
+                                            int64_t reqid) {
   if (NULL == taos) {
     terrno = TSDB_CODE_TSC_DISCONNECTED;
     return NULL;
   }
 
-  SRequestObj *request = (SRequestObj *)createRequest(*(int64_t *)taos, TSDB_SQL_INSERT);
+  SRequestObj *request = (SRequestObj *)createRequest(*(int64_t *)taos, TSDB_SQL_INSERT, reqid);
+  if (!request) {
+    uError("SML:taos_schemaless_insert error request is null");
+    return NULL;
+  }
+
+  if (!lines) {
+    SSmlMsgBuf msg = {ERROR_MSG_BUF_DEFAULT_SIZE, request->msgBuf};
+    request->code = TSDB_CODE_SML_INVALID_DATA;
+    smlBuildInvalidDataMsg(&msg, "lines is null", NULL);
+    return (TAOS_RES *)request;
+  }
+
+  return taos_schemaless_insert_inner(request, lines, NULL, NULL, numLines, protocol, precision);
+}
+
+TAOS_RES *taos_schemaless_insert_raw(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol,
+                                     int precision) {
+  if (NULL == taos) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return NULL;
+  }
+
+  SRequestObj *request = (SRequestObj *)createRequest(*(int64_t *)taos, TSDB_SQL_INSERT, 0);
   if (!request) {
     uError("SML:taos_schemaless_insert error request is null");
     return NULL;
@@ -2702,10 +2725,45 @@ TAOS_RES *taos_schemaless_insert_raw(TAOS* taos, char* lines, int len, int32_t *
   int numLines = 0;
   *totalRows = 0;
   char *tmp = lines;
-  for(int i = 0; i < len; i++){
+  for (int i = 0; i < len; i++) {
-    if(lines[i] == '\n' || i == len - 1){
+    if (lines[i] == '\n' || i == len - 1) {
       numLines++;
-      if(tmp[0] != '#' || protocol != TSDB_SML_LINE_PROTOCOL){    //ignore comment
+      if (tmp[0] != '#' || protocol != TSDB_SML_LINE_PROTOCOL) {  // ignore comment
+        (*totalRows)++;
+      }
+      tmp = lines + i + 1;
+    }
+  }
+  return taos_schemaless_insert_inner(request, NULL, lines, lines + len, numLines, protocol, precision);
+}
+
+TAOS_RES *taos_schemaless_insert_raw_with_reqid(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol,
+                                                int precision, int64_t reqid) {
+  if (NULL == taos) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return NULL;
+  }
+
+  SRequestObj *request = (SRequestObj *)createRequest(*(int64_t *)taos, TSDB_SQL_INSERT, reqid);
+  if (!request) {
+    uError("SML:taos_schemaless_insert error request is null");
+    return NULL;
+  }
+
+  if (!lines || len <= 0) {
+    SSmlMsgBuf msg = {ERROR_MSG_BUF_DEFAULT_SIZE, request->msgBuf};
+    request->code = TSDB_CODE_SML_INVALID_DATA;
+    smlBuildInvalidDataMsg(&msg, "lines is null", NULL);
+    return (TAOS_RES *)request;
+  }
+
+  int numLines = 0;
+  *totalRows = 0;
+  char *tmp = lines;
+  for (int i = 0; i < len; i++) {
+    if (lines[i] == '\n' || i == len - 1) {
+      numLines++;
+      if (tmp[0] != '#' || protocol != TSDB_SML_LINE_PROTOCOL) {  // ignore comment
         (*totalRows)++;
       }
       tmp = lines + i + 1;

source/client/src/clientStmt.c

@@ -5,13 +5,18 @@
 
 #include "clientStmt.h"
 
-char *gStmtStatusStr[] = {"unknown", "init", "prepare", "settbname", "settags", "fetchFields", "bind", "bindCol", "addBatch", "exec"};
+char* gStmtStatusStr[] = {"unknown",     "init", "prepare", "settbname", "settags",
+                          "fetchFields", "bind", "bindCol", "addBatch",  "exec"};
 
 static int32_t stmtCreateRequest(STscStmt* pStmt) {
   int32_t code = 0;
 
   if (pStmt->exec.pRequest == NULL) {
-    code = buildRequest(pStmt->taos->id, pStmt->sql.sqlStr, pStmt->sql.sqlLen, NULL, false, &pStmt->exec.pRequest);
+    code = buildRequest(pStmt->taos->id, pStmt->sql.sqlStr, pStmt->sql.sqlLen, NULL, false, &pStmt->exec.pRequest,
+                        pStmt->reqid);
+    if (pStmt->reqid != 0) {
+      pStmt->reqid++;
+    }
     if (TSDB_CODE_SUCCESS == code) {
       pStmt->exec.pRequest->syncQuery = true;
     }
@@ -207,10 +212,10 @@ int32_t stmtCacheBlock(STscStmt* pStmt) {
   }
 
   STableDataBlocks** pSrc = taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
-  if(!pSrc){
+  if (!pSrc) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
-  STableDataBlocks*  pDst = NULL;
+  STableDataBlocks* pDst = NULL;
 
   STMT_ERR_RET(qCloneStmtDataBlock(&pDst, *pSrc));
 
@@ -513,7 +518,7 @@ int32_t stmtResetStmt(STscStmt* pStmt) {
   return TSDB_CODE_SUCCESS;
 }
 
-TAOS_STMT* stmtInit(STscObj* taos) {
+TAOS_STMT* stmtInit(STscObj* taos, int64_t reqid) {
   STscObj*  pObj = (STscObj*)taos;
   STscStmt* pStmt = NULL;
 
@@ -533,9 +538,10 @@ TAOS_STMT* stmtInit(STscObj* taos) {
   pStmt->taos = pObj;
   pStmt->bInfo.needParse = true;
   pStmt->sql.status = STMT_INIT;
+  pStmt->reqid = reqid;
 
   STMT_LOG_SEQ(STMT_INIT);
-  
+
   tscDebug("stmt:%p initialized", pStmt);
 
   return pStmt;

source/common/src/tdatablock.c

@@ -1172,11 +1172,7 @@ static int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo*
     pColumn->nullbitmap = tmp;
     memset(&pColumn->nullbitmap[oldLen], 0, BitmapLen(numOfRows) - oldLen);
 
-    if (pColumn->info.type == TSDB_DATA_TYPE_NULL) {
+    ASSERT(pColumn->info.bytes);
-      return TSDB_CODE_SUCCESS;
-    }
-
-    assert(pColumn->info.bytes);
     tmp = taosMemoryRealloc(pColumn->pData, numOfRows * pColumn->info.bytes);
     if (tmp == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;

source/dnode/mgmt/mgmt_vnode/src/vmWorker.c

@@ -145,7 +145,6 @@ static int32_t vmPutMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg, EQueueType qtyp
 
   pHead->contLen = ntohl(pHead->contLen);
   pHead->vgId = ntohl(pHead->vgId);
-  pHead->msgMask = ntohl(pHead->msgMask);
 
   SVnodeObj *pVnode = vmAcquireVnode(pMgmt, pHead->vgId);
   if (pVnode == NULL) {
@@ -156,15 +155,9 @@ static int32_t vmPutMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg, EQueueType qtyp
 
   switch (qtype) {
     case QUERY_QUEUE:
-      if ((pMsg->msgType == TDMT_SCH_QUERY) && (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS) && !TEST_SHOW_REWRITE_MASK(pHead->msgMask)) {
+      vnodePreprocessQueryMsg(pVnode->pImpl, pMsg);
-        terrno = TSDB_CODE_GRANT_EXPIRED;
+      dGTrace("vgId:%d, msg:%p put into vnode-query queue", pVnode->vgId, pMsg);
-        code = terrno;
+      taosWriteQitem(pVnode->pQueryQ, pMsg);
-        dDebug("vgId:%d, msg:%p put into vnode-query queue failed since %s", pVnode->vgId, pMsg, terrstr(code));
-      } else {
-        vnodePreprocessQueryMsg(pVnode->pImpl, pMsg);
-        dGTrace("vgId:%d, msg:%p put into vnode-query queue", pVnode->vgId, pMsg);
-        taosWriteQitem(pVnode->pQueryQ, pMsg);
-      }
       break;
     case STREAM_QUEUE:
       dGTrace("vgId:%d, msg:%p put into vnode-stream queue", pVnode->vgId, pMsg);

source/dnode/mnode/impl/src/mndQuery.c

@@ -21,7 +21,7 @@
 int32_t mndPreProcessQueryMsg(SRpcMsg *pMsg) {
   if (TDMT_SCH_QUERY != pMsg->msgType && TDMT_SCH_MERGE_QUERY != pMsg->msgType) return 0;
   SMnode *pMnode = pMsg->info.node;
-  return qWorkerPreprocessQueryMsg(pMnode->pQuery, pMsg);
+  return qWorkerPreprocessQueryMsg(pMnode->pQuery, pMsg, false);
 }
 
 void mndPostProcessQueryMsg(SRpcMsg *pMsg) {

source/dnode/mnode/impl/src/mndStb.c

@@ -519,7 +519,6 @@ static void *mndBuildVDropStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb,
 
   pHead->contLen = htonl(contLen);
   pHead->vgId = htonl(pVgroup->vgId);
-  pHead->msgMask = htonl(0);
 
   void *pBuf = POINTER_SHIFT(pHead, sizeof(SMsgHead));
 

source/dnode/mnode/impl/src/mndSync.c

@@ -202,6 +202,13 @@ static void mndBecomeLeader(const SSyncFSM *pFsm) {
   SMnode *pMnode = pFsm->data;
 }
 
+static bool mndApplyQueueEmpty(const SSyncFSM *pFsm) {
+  SMnode *pMnode = pFsm->data;
+
+  int32_t itemSize = tmsgGetQueueSize(&pMnode->msgCb, 1, APPLY_QUEUE);
+  return (itemSize == 0);
+}
+
 SSyncFSM *mndSyncMakeFsm(SMnode *pMnode) {
   SSyncFSM *pFsm = taosMemoryCalloc(1, sizeof(SSyncFSM));
   pFsm->data = pMnode;
@@ -210,6 +217,7 @@ SSyncFSM *mndSyncMakeFsm(SMnode *pMnode) {
   pFsm->FpRollBackCb = NULL;
   pFsm->FpRestoreFinishCb = mndRestoreFinish;
   pFsm->FpLeaderTransferCb = NULL;
+  pFsm->FpApplyQueueEmptyCb = mndApplyQueueEmpty;
   pFsm->FpReConfigCb = NULL;
   pFsm->FpBecomeLeaderCb = mndBecomeLeader;
   pFsm->FpBecomeFollowerCb = mndBecomeFollower;

source/dnode/qnode/src/qnode.c

@@ -69,7 +69,7 @@ int32_t qndPreprocessQueryMsg(SQnode *pQnode, SRpcMsg *pMsg) {
     return 0;
   }
 
-  return qWorkerPreprocessQueryMsg(pQnode->pQuery, pMsg);
+  return qWorkerPreprocessQueryMsg(pQnode->pQuery, pMsg, false);
 }
 
 int32_t qndProcessQueryMsg(SQnode *pQnode, int64_t ts, SRpcMsg *pMsg) {

source/dnode/vnode/src/meta/metaQuery.c

@@ -153,7 +153,7 @@ bool metaIsTableExist(SMeta *pMeta, tb_uid_t uid) {
 
 int metaGetTableEntryByUid(SMetaReader *pReader, tb_uid_t uid) {
   SMeta  *pMeta = pReader->pMeta;
-  int64_t version;
+  int64_t version1;
 
   // query uid.idx
   if (tdbTbGet(pMeta->pUidIdx, &uid, sizeof(uid), &pReader->pBuf, &pReader->szBuf) < 0) {
@@ -161,8 +161,8 @@ int metaGetTableEntryByUid(SMetaReader *pReader, tb_uid_t uid) {
     return -1;
   }
 
-  version = ((SUidIdxVal *)pReader->pBuf)[0].version;
+  version1 = ((SUidIdxVal *)pReader->pBuf)[0].version;
-  return metaGetTableEntryByVersion(pReader, version, uid);
+  return metaGetTableEntryByVersion(pReader, version1, uid);
 }
 
 int metaGetTableEntryByName(SMetaReader *pReader, const char *name) {

source/dnode/vnode/src/vnd/vnodeSvr.c

@@ -329,7 +329,7 @@ int32_t vnodePreprocessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg) {
     return 0;
   }
 
-  return qWorkerPreprocessQueryMsg(pVnode->pQuery, pMsg);
+  return qWorkerPreprocessQueryMsg(pVnode->pQuery, pMsg, TDMT_SCH_QUERY == pMsg->msgType);
 }
 
 int32_t vnodeProcessQueryMsg(SVnode *pVnode, SRpcMsg *pMsg) {

source/dnode/vnode/src/vnd/vnodeSync.c

@@ -436,6 +436,12 @@ static void vnodeBecomeLeader(const SSyncFSM *pFsm) {
   vDebug("vgId:%d, become leader", pVnode->config.vgId);
 }
 
+static bool vnodeApplyQueueEmpty(const SSyncFSM *pFsm) {
+  SVnode *pVnode = pFsm->data;
+  int32_t itemSize = tmsgGetQueueSize(&pVnode->msgCb, pVnode->config.vgId, APPLY_QUEUE);
+  return (itemSize == 0);
+}
+
 static SSyncFSM *vnodeSyncMakeFsm(SVnode *pVnode) {
   SSyncFSM *pFsm = taosMemoryCalloc(1, sizeof(SSyncFSM));
   pFsm->data = pVnode;
@@ -445,6 +451,7 @@ static SSyncFSM *vnodeSyncMakeFsm(SVnode *pVnode) {
   pFsm->FpGetSnapshotInfo = vnodeSyncGetSnapshot;
   pFsm->FpRestoreFinishCb = vnodeRestoreFinish;
   pFsm->FpLeaderTransferCb = NULL;
+  pFsm->FpApplyQueueEmptyCb = vnodeApplyQueueEmpty;
   pFsm->FpBecomeLeaderCb = vnodeBecomeLeader;
   pFsm->FpBecomeFollowerCb = vnodeBecomeFollower;
   pFsm->FpReConfigCb = NULL;

source/libs/executor/inc/executorimpl.h

@@ -298,6 +298,12 @@ typedef struct {
   SExprSupp*     pExprSup;  // expr supporter of aggregate operator
 } SAggOptrPushDownInfo;
 
+typedef struct STableMetaCacheInfo {
+  SLRUCache*             pTableMetaEntryCache; // 100 by default
+  uint64_t               metaFetch;
+  uint64_t               cacheHit;
+} STableMetaCacheInfo;
+
 typedef struct STableScanInfo {
   STsdbReader*           dataReader;
   SReadHandle            readHandle;
@@ -305,7 +311,6 @@ typedef struct STableScanInfo {
   SFileBlockLoadRecorder readRecorder;
   SScanInfo              scanInfo;
   int32_t                scanTimes;
-  SNode*                 pFilterNode;  // filter info, which is push down by optimizer
   SSDataBlock*           pResBlock;
   SColMatchInfo          matchInfo;
   SExprSupp              pseudoSup;
@@ -318,6 +323,7 @@ typedef struct STableScanInfo {
   int8_t                 scanMode;
   SAggOptrPushDownInfo   pdInfo;
   int8_t                 assignBlockUid;
+  STableMetaCacheInfo    metaCache;
 } STableScanInfo;
 
 typedef struct STableMergeScanInfo {
@@ -326,7 +332,6 @@ typedef struct STableMergeScanInfo {
   int32_t                tableEndIndex;
   bool                   hasGroupId;
   uint64_t               groupId;
-  SArray*                dataReaders;  // array of tsdbReaderT*
   SArray*                queryConds;   // array of queryTableDataCond
   STsdbReader*           pReader;
   SReadHandle            readHandle;
@@ -342,7 +347,6 @@ typedef struct STableMergeScanInfo {
   int64_t                numOfRows;
   SScanInfo              scanInfo;
   int32_t                scanTimes;
-  SNode*                 pFilterNode;  // filter info, which is push down by optimizer
   SqlFunctionCtx*        pCtx;         // which belongs to the direct upstream operator operator query context
   SResultRowInfo*        pResultRowInfo;
   int32_t*               rowEntryInfoOffset;
@@ -460,7 +464,6 @@ typedef struct SStreamScanInfo {
   SReadHandle   readHandle;
   SInterval     interval;  // if the upstream is an interval operator, the interval info is also kept here.
   SColMatchInfo matchInfo;
-  SNode*        pCondition;
 
   SArray*      pBlockLists;  // multiple SSDatablock.
   SSDataBlock* pRes;         // result SSDataBlock
@@ -564,7 +567,6 @@ typedef struct SIntervalAggOperatorInfo {
   EOPTR_EXEC_MODEL   execModel;          // operator execution model [batch model|stream model]
   STimeWindowAggSupp twAggSup;
   SArray*            pPrevValues;  //  SArray<SGroupKeys> used to keep the previous not null value for interpolation.
-  SNode*             pCondition;
 } SIntervalAggOperatorInfo;
 
 typedef struct SMergeAlignedIntervalAggOperatorInfo {
@@ -573,12 +575,10 @@ typedef struct SMergeAlignedIntervalAggOperatorInfo {
   uint64_t     groupId;  // current groupId
   int64_t      curTs;    // current ts
   SSDataBlock* prefetchedBlock;
-  SNode*       pCondition;
   SResultRow*  pResultRow;
 } SMergeAlignedIntervalAggOperatorInfo;
 
 typedef struct SStreamIntervalOperatorInfo {
-  // SOptrBasicInfo should be first, SAggSupporter should be second for stream encode
   SOptrBasicInfo     binfo;           // basic info
   SAggSupporter      aggSup;          // aggregate supporter
   SExprSupp          scalarSupp;      // supporter for perform scalar function
@@ -604,26 +604,21 @@ typedef struct SStreamIntervalOperatorInfo {
 } SStreamIntervalOperatorInfo;
 
 typedef struct SAggOperatorInfo {
-  // SOptrBasicInfo should be first, SAggSupporter should be second for stream encode
+  SOptrBasicInfo   binfo;
-  SOptrBasicInfo binfo;
+  SAggSupporter    aggSup;
-  SAggSupporter  aggSup;
-
   STableQueryInfo* current;
   uint64_t         groupId;
   SGroupResInfo    groupResInfo;
   SExprSupp        scalarExprSup;
-  SNode*           pCondition;
 } SAggOperatorInfo;
 
 typedef struct SProjectOperatorInfo {
   SOptrBasicInfo binfo;
   SAggSupporter  aggSup;
-  SNode*         pFilterNode;  // filter info, which is push down by optimizer
   SArray*        pPseudoColInfo;
   SLimitInfo     limitInfo;
   bool           mergeDataBlocks;
   SSDataBlock*   pFinalRes;
-  SNode*         pCondition;
 } SProjectOperatorInfo;
 
 typedef struct SIndefOperatorInfo {
@@ -631,10 +626,8 @@ typedef struct SIndefOperatorInfo {
   SAggSupporter  aggSup;
   SArray*        pPseudoColInfo;
   SExprSupp      scalarSup;
-  SNode*         pCondition;
   uint64_t       groupId;
-
+  SSDataBlock*   pNextGroupRes;
-  SSDataBlock* pNextGroupRes;
 } SIndefOperatorInfo;
 
 typedef struct SFillOperatorInfo {
@@ -645,7 +638,6 @@ typedef struct SFillOperatorInfo {
   void**            p;
   SSDataBlock*      existNewGroupBlock;
   STimeWindow       win;
-  SNode*            pCondition;
   SColMatchInfo     matchInfo;
   int32_t           primaryTsCol;
   int32_t           primarySrcSlotId;
@@ -660,7 +652,6 @@ typedef struct SGroupbyOperatorInfo {
   SAggSupporter  aggSup;
   SArray*        pGroupCols;     // group by columns, SArray<SColumn>
   SArray*        pGroupColVals;  // current group column values, SArray<SGroupKeys>
-  SNode*         pCondition;
   bool           isInit;       // denote if current val is initialized or not
   char*          keyBuf;       // group by keys for hash
   int32_t        groupKeyLen;  // total group by column width
@@ -710,7 +701,6 @@ typedef struct SSessionAggOperatorInfo {
   int64_t            gap;       // session window gap
   int32_t            tsSlotId;  // primary timestamp slot id
   STimeWindowAggSupp twAggSup;
-  const SNode*       pCondition;
 } SSessionAggOperatorInfo;
 
 typedef struct SResultWindowInfo {
@@ -784,7 +774,6 @@ typedef struct SStreamFillOperatorInfo {
   SSDataBlock*          pSrcDelBlock;
   int32_t               srcDelRowIndex;
   SSDataBlock*          pDelRes;
-  SNode*                pCondition;
   SColMatchInfo         matchInfo;
   int32_t               primaryTsCol;
   int32_t               primarySrcSlotId;
@@ -821,7 +810,6 @@ typedef struct SStateWindowOperatorInfo {
   SStateKeys         stateKey;
   int32_t            tsSlotId;  // primary timestamp column slot id
   STimeWindowAggSupp twAggSup;
-  const SNode*       pCondition;
 } SStateWindowOperatorInfo;
 
 typedef struct SSortOperatorInfo {
@@ -834,7 +822,6 @@ typedef struct SSortOperatorInfo {
   int64_t        startTs;      // sort start time
   uint64_t       sortElapsed;  // sort elapsed time, time to flush to disk not included.
   SLimitInfo     limitInfo;
-  SNode*         pCondition;
 } SSortOperatorInfo;
 
 typedef struct SJoinOperatorInfo {
@@ -895,9 +882,9 @@ int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scan
 int32_t getBufferPgSize(int32_t rowSize, uint32_t* defaultPgsz, uint32_t* defaultBufsz);
 
 void    doSetOperatorCompleted(SOperatorInfo* pOperator);
-void    doFilter(const SNode* pFilterNode, SSDataBlock* pBlock, SColMatchInfo* pColMatchInfo, SFilterInfo* pFilterInfo);
+void    doFilter(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SColMatchInfo* pColMatchInfo);
-int32_t addTagPseudoColumnData(SReadHandle* pHandle, SExprInfo* pPseudoExpr, int32_t numOfPseudoExpr,
+int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int32_t numOfExpr,
-                               SSDataBlock* pBlock, int32_t rows, const char* idStr);
+                               SSDataBlock* pBlock, int32_t rows, const char* idStr, STableMetaCacheInfo * pCache);
 
 void cleanupAggSup(SAggSupporter* pAggSup);
 void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle);

source/libs/executor/src/cachescanoperator.c

@@ -172,7 +172,7 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
 
       SExprSupp* pSup = &pInfo->pseudoExprSup;
       int32_t code = addTagPseudoColumnData(&pInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pRes,
-                                            pRes->info.rows, GET_TASKID(pTaskInfo));
+                                            pRes->info.rows, GET_TASKID(pTaskInfo), NULL);
       if (code != TSDB_CODE_SUCCESS) {
         pTaskInfo->code = code;
         return NULL;
@@ -221,7 +221,7 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
 
             pInfo->pRes->info.uid = *(tb_uid_t*)taosArrayGet(pInfo->pUidList, 0);
             code = addTagPseudoColumnData(&pInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pInfo->pRes, pInfo->pRes->info.rows,
-                                          GET_TASKID(pTaskInfo));
+                                          GET_TASKID(pTaskInfo), NULL);
             if (code != TSDB_CODE_SUCCESS) {
               pTaskInfo->code = code;
               return NULL;

source/libs/executor/src/executorimpl.c

@@ -1039,39 +1039,24 @@ void setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numO
 static void extractQualifiedTupleByFilterResult(SSDataBlock* pBlock, const SColumnInfoData* p, bool keep,
                                                 int32_t status);
 
-void doFilter(const SNode* pFilterNode, SSDataBlock* pBlock, SColMatchInfo* pColMatchInfo, SFilterInfo* pFilterInfo) {
+void doFilter(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SColMatchInfo* pColMatchInfo) {
-  if (pFilterNode == NULL || pBlock->info.rows == 0) {
+  if (pFilterInfo == NULL || pBlock->info.rows == 0) {
     return;
   }
 
-  SFilterInfo* filter = pFilterInfo;
-  int64_t      st = taosGetTimestampUs();
-
-  // todo move to the initialization function
-  int32_t code = 0;
-  bool    needFree = false;
-  if (filter == NULL) {
-    needFree = true;
-    code = filterInitFromNode((SNode*)pFilterNode, &filter, 0);
-  }
-
   SFilterColumnParam param1 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock};
-  code = filterSetDataFromSlotId(filter, &param1);
+  int32_t code = filterSetDataFromSlotId(pFilterInfo, &param1);
 
   SColumnInfoData* p = NULL;
   int32_t          status = 0;
 
   // todo the keep seems never to be True??
-  bool keep = filterExecute(filter, pBlock, &p, NULL, param1.numOfCols, &status);
+  bool keep = filterExecute(pFilterInfo, pBlock, &p, NULL, param1.numOfCols, &status);
-
-  if (needFree) {
-    filterFreeInfo(filter);
-  }
-
   extractQualifiedTupleByFilterResult(pBlock, p, keep, status);
 
   if (pColMatchInfo != NULL) {
-    for (int32_t i = 0; i < taosArrayGetSize(pColMatchInfo->pList); ++i) {
+    size_t  size = taosArrayGetSize(pColMatchInfo->pList);
+    for (int32_t i = 0; i < size; ++i) {
       SColMatchItem* pInfo = taosArrayGet(pColMatchInfo->pList, i);
       if (pInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
         SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, pInfo->dstSlotId);
@@ -2393,7 +2378,7 @@ static SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) {
   blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
   while (1) {
     doBuildResultDatablock(pOperator, pInfo, &pAggInfo->groupResInfo, pAggInfo->aggSup.pResultBuf);
-    doFilter(pAggInfo->pCondition, pInfo->pRes, NULL, NULL);
+    doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
 
     if (!hasRemainResults(&pAggInfo->groupResInfo)) {
       doSetOperatorCompleted(pOperator);
@@ -2726,7 +2711,7 @@ static SSDataBlock* doFill(SOperatorInfo* pOperator) {
       break;
     }
 
-    doFilter(pInfo->pCondition, fillResult, &pInfo->matchInfo, NULL);
+    doFilter(fillResult, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo );
     if (fillResult->info.rows > 0) {
       break;
     }
@@ -2945,9 +2930,13 @@ SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiN
     goto _error;
   }
 
+  code = filterInitFromNode((SNode*)pAggNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   pInfo->binfo.mergeResultBlock = pAggNode->mergeDataBlock;
   pInfo->groupId = UINT64_MAX;
-  pInfo->pCondition = pAggNode->node.pConditions;
   pOperator->name = "TableAggregate";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_HASH_AGG;
   pOperator->blocking = true;
@@ -3173,7 +3162,11 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode*
   pInfo->pFinalRes = createOneDataBlock(pInfo->pRes, false);
   blockDataEnsureCapacity(pInfo->pFinalRes, pOperator->resultInfo.capacity);
 
-  pInfo->pCondition = pPhyFillNode->node.pConditions;
+  code = filterInitFromNode((SNode*)pPhyFillNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   pOperator->name = "FillOperator";
   pOperator->blocking = false;
   pOperator->status = OP_NOT_OPENED;

source/libs/executor/src/groupoperator.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "filter.h"
 #include "function.h"
 #include "os.h"
 #include "tname.h"
@@ -312,7 +313,7 @@ static SSDataBlock* buildGroupResultDataBlock(SOperatorInfo* pOperator) {
   SSDataBlock* pRes = pInfo->binfo.pRes;
   while (1) {
     doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-    doFilter(pInfo->pCondition, pRes, NULL, NULL);
+    doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
 
     if (!hasRemainResults(&pInfo->groupResInfo)) {
       doSetOperatorCompleted(pOperator);
@@ -411,8 +412,6 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode*
   }
 
   pInfo->pGroupCols = extractColumnInfo(pAggNode->pGroupKeys);
-  pInfo->pCondition = pAggNode->node.pConditions;
-
   int32_t code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, numOfScalarExpr);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
@@ -433,6 +432,11 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode*
     goto _error;
   }
 
+  code = filterInitFromNode((SNode*)pAggNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   initResultRowInfo(&pInfo->binfo.resultRowInfo);
 
   pOperator->name = "GroupbyAggOperator";

source/libs/executor/src/joinoperator.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "filter.h"
 #include "executorimpl.h"
 #include "function.h"
 #include "os.h"
@@ -108,6 +109,11 @@ SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t
     pInfo->pCondAfterMerge = NULL;
   }
 
+  code = filterInitFromNode(pInfo->pCondAfterMerge, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   pInfo->inputOrder = TSDB_ORDER_ASC;
   if (pJoinNode->inputTsOrder == ORDER_ASC) {
     pInfo->inputOrder = TSDB_ORDER_ASC;
@@ -400,8 +406,8 @@ SSDataBlock* doMergeJoin(struct SOperatorInfo* pOperator) {
     if (numOfNewRows == 0) {
       break;
     }
-    if (pJoinInfo->pCondAfterMerge != NULL) {
+    if (pOperator->exprSupp.pFilterInfo != NULL) {
-      doFilter(pJoinInfo->pCondAfterMerge, pRes, NULL, NULL);
+      doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
     }
     if (pRes->info.rows >= pOperator->resultInfo.threshold) {
       break;

source/libs/executor/src/projectoperator.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "filter.h"
 #include "executorimpl.h"
 #include "functionMgt.h"
 
@@ -71,13 +72,7 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhys
 
   pInfo->binfo.pRes = pResBlock;
   pInfo->pFinalRes = createOneDataBlock(pResBlock, false);
-  pInfo->pFilterNode = pProjPhyNode->node.pConditions;
+  pInfo->mergeDataBlocks = (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM)? false:pProjPhyNode->mergeDataBlock;
-
-  if (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM) {
-    pInfo->mergeDataBlocks = false;
-  } else {
-    pInfo->mergeDataBlocks = pProjPhyNode->mergeDataBlock;
-  }
 
   int32_t numOfRows = 4096;
   size_t  keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
@@ -97,6 +92,11 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhys
   initBasicInfo(&pInfo->binfo, pResBlock);
   setFunctionResultOutput(pOperator, &pInfo->binfo, &pInfo->aggSup, MAIN_SCAN, numOfCols);
 
+  code = filterInitFromNode((SNode*)pProjPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   pInfo->pPseudoColInfo = setRowTsColumnOutputInfo(pOperator->exprSupp.pCtx, numOfCols);
   pOperator->name = "ProjectOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_PROJECT;
@@ -313,7 +313,7 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
       }
 
       // do apply filter
-      doFilter(pProjectInfo->pFilterNode, pFinalRes, NULL, NULL);
+      doFilter(pFinalRes, pOperator->exprSupp.pFilterInfo, NULL);
 
       // when apply the limit/offset for each group, pRes->info.rows may be 0, due to limit constraint.
       if (pFinalRes->info.rows > 0 || (pOperator->status == OP_EXEC_DONE)) {
@@ -323,7 +323,7 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
     } else {
       // do apply filter
       if (pRes->info.rows > 0) {
-        doFilter(pProjectInfo->pFilterNode, pRes, NULL, NULL);
+        doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
         if (pRes->info.rows == 0) {
           continue;
         }
@@ -392,7 +392,12 @@ SOperatorInfo* createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhy
   }
 
   setFunctionResultOutput(pOperator, &pInfo->binfo, &pInfo->aggSup, MAIN_SCAN, numOfExpr);
-  pInfo->pCondition = pPhyNode->node.pConditions;
+  code = filterInitFromNode((SNode*)pPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
+  pInfo->binfo.pRes = pResBlock;
   pInfo->pPseudoColInfo = setRowTsColumnOutputInfo(pSup->pCtx, numOfExpr);
 
   pOperator->name = "IndefinitOperator";
@@ -515,7 +520,7 @@ SSDataBlock* doApplyIndefinitFunction(SOperatorInfo* pOperator) {
       }
     }
 
-    doFilter(pIndefInfo->pCondition, pInfo->pRes, NULL, NULL);
+    doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
     size_t rows = pInfo->pRes->info.rows;
     if (rows > 0 || pOperator->status == OP_EXEC_DONE) {
       break;
@@ -617,7 +622,7 @@ SSDataBlock* doGenerateSourceData(SOperatorInfo* pOperator) {
   }
 
   pRes->info.rows = 1;
-  doFilter(pProjectInfo->pFilterNode, pRes, NULL, NULL);
+  doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
 
   /*int32_t status = */ doIngroupLimitOffset(&pProjectInfo->limitInfo, 0, pRes, pOperator);
 

source/libs/executor/src/scanoperator.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <vnode.h>
 #include "executorimpl.h"
 #include "filter.h"
 #include "function.h"
@@ -115,8 +116,10 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo,
                                                 SMetaReader* smrChildTable, const char* dbname, const char* tableName,
                                                 int32_t* pNumOfRows, const SSDataBlock* dataBlock);
 
-static void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock);
+static void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock,
-bool        processBlockWithProbability(const SSampleExecInfo* pInfo) {
+                                               SFilterInfo* pFilterInfo);
+
+bool processBlockWithProbability(const SSampleExecInfo* pInfo) {
 #if 0
   if (pInfo->sampleRatio == 1) {
     return true;
@@ -280,19 +283,13 @@ static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo*
   return TSDB_CODE_SUCCESS;
 }
 
-static bool doFilterByBlockSMA(const SNode* pFilterNode, SColumnDataAgg** pColsAgg, int32_t numOfCols,
+static bool doFilterByBlockSMA(SFilterInfo* pFilterInfo, SColumnDataAgg** pColsAgg, int32_t numOfCols,
                                             int32_t numOfRows) {
-  if (pColsAgg == NULL || pFilterNode == NULL) {
+  if (pColsAgg == NULL || pFilterInfo == NULL) {
     return true;
   }
 
-  SFilterInfo* filter = NULL;
+  bool keep = filterRangeExecute(pFilterInfo, pColsAgg, numOfCols, numOfRows);
-
-  // todo move to the initialization function
-  int32_t code = filterInitFromNode((SNode*)pFilterNode, &filter, 0);
-  bool    keep = filterRangeExecute(filter, pColsAgg, numOfCols, numOfRows);
-
-  filterFreeInfo(filter);
   return keep;
 }
 
@@ -339,7 +336,7 @@ static void doSetTagColumnData(STableScanInfo* pTableScanInfo, SSDataBlock* pBlo
     SExprSupp* pSup = &pTableScanInfo->pseudoSup;
 
     int32_t code = addTagPseudoColumnData(&pTableScanInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pBlock, rows,
-                                          GET_TASKID(pTaskInfo));
+                                          GET_TASKID(pTaskInfo), &pTableScanInfo->metaCache);
     if (code != TSDB_CODE_SUCCESS) {
       T_LONG_JMP(pTaskInfo->env, code);
     }
@@ -386,7 +383,7 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableSca
   bool loadSMA = false;
 
   *status = pInfo->dataBlockLoadFlag;
-  if (pTableScanInfo->pFilterNode != NULL ||
+  if (pOperator->exprSupp.pFilterInfo != NULL ||
       overlapWithTimeWindow(&pTableScanInfo->pdInfo.interval, &pBlock->info, pTableScanInfo->cond.order)) {
     (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;
   }
@@ -424,11 +421,11 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableSca
   ASSERT(*status == FUNC_DATA_REQUIRED_DATA_LOAD);
 
   // try to filter data block according to sma info
-  if (pTableScanInfo->pFilterNode != NULL && (!loadSMA)) {
+  if (pOperator->exprSupp.pFilterInfo != NULL && (!loadSMA)) {
     bool success = doLoadBlockSMA(pTableScanInfo, pBlock, pTaskInfo);
     if (success) {
       size_t size = taosArrayGetSize(pBlock->pDataBlock);
-      bool   keep = doFilterByBlockSMA(pTableScanInfo->pFilterNode, pBlock->pBlockAgg, size, pBlockInfo->rows);
+      bool   keep = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows);
       if (!keep) {
         qDebug("%s data block filter out by block SMA, brange:%" PRId64 "-%" PRId64 ", rows:%d", GET_TASKID(pTaskInfo),
                pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
@@ -468,9 +465,9 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanInfo* pTableSca
   // restore the previous value
   pCost->totalRows -= pBlock->info.rows;
 
-  if (pTableScanInfo->pFilterNode != NULL) {
+  if (pOperator->exprSupp.pFilterInfo != NULL) {
     int64_t st = taosGetTimestampUs();
-    doFilter(pTableScanInfo->pFilterNode, pBlock, &pTableScanInfo->matchInfo, pOperator->exprSupp.pFilterInfo);
+    doFilter(pBlock, pOperator->exprSupp.pFilterInfo, &pTableScanInfo->matchInfo);
 
     double el = (taosGetTimestampUs() - st) / 1000.0;
     pTableScanInfo->readRecorder.filterTime += el;
@@ -495,51 +492,128 @@ static void prepareForDescendingScan(STableScanInfo* pTableScanInfo, SqlFunction
   SET_REVERSE_SCAN_FLAG(pTableScanInfo);
 
   switchCtxOrder(pCtx, numOfOutput);
-  //  setupQueryRangeForReverseScan(pTableScanInfo);
-
   pTableScanInfo->cond.order = TSDB_ORDER_DESC;
   STimeWindow* pTWindow = &pTableScanInfo->cond.twindows;
   TSWAP(pTWindow->skey, pTWindow->ekey);
 }
 
-int32_t addTagPseudoColumnData(SReadHandle* pHandle, SExprInfo* pPseudoExpr, int32_t numOfPseudoExpr,
+typedef struct STableCachedVal {
-                               SSDataBlock* pBlock, int32_t rows, const char* idStr) {
+  const char* pName;
+  STag* pTags;
+} STableCachedVal;
+
+static void freeTableCachedVal(void* param) {
+  if (param == NULL) {
+    return;
+  }
+
+  STableCachedVal* pVal = param;
+  taosMemoryFree((void*)pVal->pName);
+  taosMemoryFree(pVal->pTags);
+  taosMemoryFree(pVal);
+}
+
+//const void *key, size_t keyLen, void *value
+static void freeCachedMetaItem(const void *key, size_t keyLen, void *value) {
+  freeTableCachedVal(value);
+}
+
+int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int32_t numOfExpr,
+                               SSDataBlock* pBlock, int32_t rows, const char* idStr, STableMetaCacheInfo* pCache) {
   // currently only the tbname pseudo column
-  if (numOfPseudoExpr <= 0) {
+  if (numOfExpr <= 0) {
     return TSDB_CODE_SUCCESS;
   }
 
+  int32_t code = 0;
+
   // backup the rows
   int32_t backupRows = pBlock->info.rows;
   pBlock->info.rows = rows;
 
-  SMetaReader mr = {0};
+  bool freeReader = false;
-  metaReaderInit(&mr, pHandle->meta, 0);
+  STableCachedVal val = {0};
-  int32_t code = metaGetTableEntryByUid(&mr, pBlock->info.uid);
-  metaReaderReleaseLock(&mr);
 
-  if (code != TSDB_CODE_SUCCESS) {
+  SMetaReader mr = {0};
-    qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", pBlock->info.uid, tstrerror(terrno), idStr);
+  LRUHandle* h = NULL;
-    metaReaderClear(&mr);
+
-    return terrno;
+  // 1. check if it is existed in meta cache
+  if (pCache == NULL) {
+    metaReaderInit(&mr, pHandle->meta, 0);
+    code = metaGetTableEntryByUid(&mr, pBlock->info.uid);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", pBlock->info.uid, tstrerror(terrno), idStr);
+      metaReaderClear(&mr);
+      return terrno;
+    }
+
+    metaReaderReleaseLock(&mr);
+
+    val.pName = mr.me.name;
+    val.pTags = (STag*)mr.me.ctbEntry.pTags;
+
+    freeReader = true;
+  } else {
+    pCache->metaFetch += 1;
+
+    h = taosLRUCacheLookup(pCache->pTableMetaEntryCache, &pBlock->info.uid, sizeof(pBlock->info.uid));
+    if (h == NULL) {
+      metaReaderInit(&mr, pHandle->meta, 0);
+      code = metaGetTableEntryByUid(&mr, pBlock->info.uid);
+      if (code != TSDB_CODE_SUCCESS) {
+        qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", pBlock->info.uid, tstrerror(terrno), idStr);
+        metaReaderClear(&mr);
+        return terrno;
+      }
+
+      metaReaderReleaseLock(&mr);
+
+      STableCachedVal* pVal = taosMemoryMalloc(sizeof(STableCachedVal));
+      pVal->pName = strdup(mr.me.name);
+      pVal->pTags = NULL;
+
+      // only child table has tag value
+      if (mr.me.type == TSDB_CHILD_TABLE) {
+        STag* pTag = (STag*)mr.me.ctbEntry.pTags;
+        pVal->pTags = taosMemoryMalloc(pTag->len);
+        memcpy(pVal->pTags, mr.me.ctbEntry.pTags, pTag->len);
+      }
+
+      val = *pVal;
+      freeReader = true;
+
+      int32_t ret = taosLRUCacheInsert(pCache->pTableMetaEntryCache, &pBlock->info.uid, sizeof(uint64_t), pVal, sizeof(STableCachedVal), freeCachedMetaItem, NULL, TAOS_LRU_PRIORITY_LOW);
+      if (ret != TAOS_LRU_STATUS_OK) {
+        qError("failed to put meta into lru cache, code:%d, %s", ret, idStr);
+        freeTableCachedVal(pVal);
+      }
+    } else {
+      pCache->cacheHit += 1;
+      STableCachedVal* pVal = taosLRUCacheValue(pCache->pTableMetaEntryCache, h);
+      val = *pVal;
+      taosLRUCacheRelease(pCache->pTableMetaEntryCache, h, false);
+    }
+
+    qDebug("retrieve table meta from cache:%"PRIu64", hit:%"PRIu64 " miss:%"PRIu64", %s", pCache->metaFetch, pCache->cacheHit,
+        (pCache->metaFetch - pCache->cacheHit), idStr);
   }
 
-  for (int32_t j = 0; j < numOfPseudoExpr; ++j) {
+  for (int32_t j = 0; j < numOfExpr; ++j) {
-    SExprInfo* pExpr = &pPseudoExpr[j];
+    const SExprInfo* pExpr1 = &pExpr[j];
-    int32_t    dstSlotId = pExpr->base.resSchema.slotId;
+    int32_t    dstSlotId = pExpr1->base.resSchema.slotId;
 
     SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, dstSlotId);
     colInfoDataCleanup(pColInfoData, pBlock->info.rows);
 
-    int32_t functionId = pExpr->pExpr->_function.functionId;
+    int32_t functionId = pExpr1->pExpr->_function.functionId;
 
     // this is to handle the tbname
     if (fmIsScanPseudoColumnFunc(functionId)) {
-      setTbNameColData(pBlock, pColInfoData, functionId, mr.me.name);
+      setTbNameColData(pBlock, pColInfoData, functionId, val.pName);
     } else {  // these are tags
       STagVal tagVal = {0};
-      tagVal.cid = pExpr->base.pParam[0].pCol->colId;
+      tagVal.cid = pExpr1->base.pParam[0].pCol->colId;
-      const char* p = metaGetTableTagVal(mr.me.ctbEntry.pTags, pColInfoData->info.type, &tagVal);
+      const char* p = metaGetTableTagVal(val.pTags, pColInfoData->info.type, &tagVal);
 
       char* data = NULL;
       if (pColInfoData->info.type != TSDB_DATA_TYPE_JSON && p != NULL) {
@@ -564,10 +638,12 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, SExprInfo* pPseudoExpr, int
     }
   }
 
-  metaReaderClear(&mr);
-
   // restore the rows
   pBlock->info.rows = backupRows;
+  if (freeReader) {
+    metaReaderClear(&mr);
+  }
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -815,6 +891,7 @@ static void destroyTableScanOperatorInfo(void* param) {
     taosArrayDestroy(pTableScanInfo->matchInfo.pList);
   }
 
+  taosLRUCacheCleanup(pTableScanInfo->metaCache.pTableMetaEntryCache);
   cleanupExprSupp(&pTableScanInfo->pseudoSup);
   taosMemoryFreeClear(param);
 }
@@ -861,12 +938,9 @@ SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode,
   pInfo->pResBlock = createResDataBlock(pDescNode);
   blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity);
 
-  pInfo->pFilterNode = pScanNode->node.pConditions;
+  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
-  if (pInfo->pFilterNode != NULL) {
+  if (code != TSDB_CODE_SUCCESS) {
-    code = filterInitFromNode((SNode*)pInfo->pFilterNode, &pOperator->exprSupp.pFilterInfo, 0);
+    goto _error;
-    if (code != TSDB_CODE_SUCCESS) {
-      goto _error;
-    }
   }
 
   pInfo->scanFlag = MAIN_SCAN;
@@ -881,6 +955,9 @@ SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode,
   pOperator->exprSupp.numOfExprs = numOfCols;
   pOperator->pTaskInfo = pTaskInfo;
 
+  pInfo->metaCache.pTableMetaEntryCache = taosLRUCacheInit(1024*128, -1, .5);
+  taosLRUCacheSetStrictCapacity(pInfo->metaCache.pTableMetaEntryCache, false);
+
   pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doTableScan, NULL, NULL, destroyTableScanOperatorInfo,
                                          getTableScannerExecInfo);
 
@@ -1295,7 +1372,7 @@ static SSDataBlock* doRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32
       return NULL;
     }
 
-    doFilter(pInfo->pCondition, pResult, NULL, NULL);
+    doFilter(pResult, pInfo->pTableScanOp->exprSupp.pFilterInfo, NULL);
     if (pResult->info.rows == 0) {
       continue;
     }
@@ -1631,7 +1708,7 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
   // currently only the tbname pseudo column
   if (pInfo->numOfPseudoExpr > 0) {
     int32_t code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes,
-                                          pInfo->pRes->info.rows, GET_TASKID(pTaskInfo));
+                                          pInfo->pRes->info.rows, GET_TASKID(pTaskInfo), NULL);
     if (code != TSDB_CODE_SUCCESS) {
       blockDataFreeRes((SSDataBlock*)pBlock);
       T_LONG_JMP(pTaskInfo->env, code);
@@ -1639,7 +1716,7 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
   }
 
   if (filter) {
-    doFilter(pInfo->pCondition, pInfo->pRes, NULL, NULL);
+    doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
   }
 
   blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);
@@ -2091,7 +2168,7 @@ FETCH_NEXT_BLOCK:
           }
         }
 
-        doFilter(pInfo->pCondition, pInfo->pRes, NULL, NULL);
+        doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
         blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex);
 
         if (pBlockInfo->rows > 0 || pInfo->pUpdateDataRes->info.rows > 0) {
@@ -2456,9 +2533,13 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
     pInfo->pPseudoExpr = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pInfo->numOfPseudoExpr);
   }
 
+  code = filterInitFromNode((SNode*)pScanPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   pInfo->pRes = createResDataBlock(pDescNode);
   pInfo->pUpdateRes = createSpecialDataBlock(STREAM_CLEAR);
-  pInfo->pCondition = pScanPhyNode->node.pConditions;
   pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;
   pInfo->windowSup = (SWindowSupporter){.pStreamAggSup = NULL, .gap = -1, .parentType = QUERY_NODE_PHYSICAL_PLAN};
   pInfo->groupId = 0;
@@ -2599,13 +2680,13 @@ static int32_t loadSysTableCallback(void* param, SDataBuf* pMsg, int32_t code) {
   return TSDB_CODE_SUCCESS;
 }
 
-static SSDataBlock* doFilterResult(SSysTableScanInfo* pInfo) {
+static SSDataBlock* doFilterResult(SSDataBlock* pDataBlock, SFilterInfo* pFilterInfo) {
-  if (pInfo->pCondition == NULL) {
+  if (pFilterInfo == NULL) {
-    return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes;
+    return pDataBlock->info.rows == 0 ? NULL : pDataBlock;
   }
 
-  doFilter(pInfo->pCondition, pInfo->pRes, NULL, NULL);
+  doFilter(pDataBlock, pFilterInfo, NULL);
-  return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes;
+  return pDataBlock->info.rows == 0 ? NULL : pDataBlock;
 }
 
 static SSDataBlock* buildInfoSchemaTableMetaBlock(char* tableName) {
@@ -2810,7 +2891,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
     metaReaderClear(&smrSuperTable);
     metaReaderClear(&smrChildTable);
     if (numOfRows > 0) {
-      relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock);
+      relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo);
       numOfRows = 0;
     }
     blockDataDestroy(dataBlock);
@@ -2850,7 +2931,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
     metaReaderClear(&smrSuperTable);
 
     if (numOfRows >= pOperator->resultInfo.capacity) {
-      relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock);
+      relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo);
       numOfRows = 0;
 
       if (pInfo->pRes->info.rows > 0) {
@@ -2860,7 +2941,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
   }
 
   if (numOfRows > 0) {
-    relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock);
+    relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo);
     numOfRows = 0;
   }
 
@@ -2875,13 +2956,13 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
   return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes;
 }
 
-static void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock) {
+void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock,
+                                        SFilterInfo* pFilterInfo) {
   dataBlock->info.rows = numOfRows;
   pInfo->pRes->info.rows = numOfRows;
 
   relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, dataBlock->pDataBlock, false);
-  doFilterResult(pInfo);
+  doFilterResult(pInfo->pRes, pFilterInfo);
-
   blockDataCleanup(dataBlock);
 }
 
@@ -3635,7 +3716,7 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
       pInfo->pRes->info.rows = numOfRows;
 
       relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
-      doFilterResult(pInfo);
+      doFilterResult(pInfo->pRes, pOperator->exprSupp.pFilterInfo);
 
       blockDataCleanup(p);
       numOfRows = 0;
@@ -3651,7 +3732,7 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
     pInfo->pRes->info.rows = numOfRows;
 
     relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
-    doFilterResult(pInfo);
+    doFilterResult(pInfo->pRes, pOperator->exprSupp.pFilterInfo);
 
     blockDataCleanup(p);
     numOfRows = 0;
@@ -3668,6 +3749,7 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
   pInfo->loadInfo.totalRows += pInfo->pRes->info.rows;
   return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes;
 }
+
 static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
 
@@ -3811,7 +3893,7 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
       pInfo->pRes->info.rows = numOfRows;
 
       relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
-      doFilterResult(pInfo);
+      doFilterResult(pInfo->pRes, pOperator->exprSupp.pFilterInfo);
 
       blockDataCleanup(p);
       numOfRows = 0;
@@ -3827,7 +3909,7 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
     pInfo->pRes->info.rows = numOfRows;
 
     relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false);
-    doFilterResult(pInfo);
+    doFilterResult(pInfo->pRes, pOperator->exprSupp.pFilterInfo);
 
     blockDataCleanup(p);
     numOfRows = 0;
@@ -3858,8 +3940,7 @@ static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) {
   // the retrieve is executed on the mnode, so return tables that belongs to the information schema database.
   if (pInfo->readHandle.mnd != NULL) {
     buildSysDbTableInfo(pInfo, pOperator->resultInfo.capacity);
-
+    doFilterResult(pInfo->pRes, pOperator->exprSupp.pFilterInfo);
-    doFilterResult(pInfo);
     pInfo->loadInfo.totalRows += pInfo->pRes->info.rows;
 
     doSetOperatorCompleted(pOperator);
@@ -3994,7 +4075,7 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) {
       updateLoadRemoteInfo(&pInfo->loadInfo, pRsp->numOfRows, pRsp->compLen, startTs, pOperator);
 
       // todo log the filter info
-      doFilterResult(pInfo);
+      doFilterResult(pInfo->pRes, pOperator->exprSupp.pFilterInfo);
       taosMemoryFree(pRsp);
       if (pInfo->pRes->info.rows > 0) {
         return pInfo->pRes;
@@ -4092,9 +4173,15 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan
   pInfo->sysInfo = pScanPhyNode->sysInfo;
   pInfo->showRewrite = pScanPhyNode->showRewrite;
   pInfo->pRes = createResDataBlock(pDescNode);
+
   pInfo->pCondition = pScanNode->node.pConditions;
+  code = filterInitFromNode(pScanNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
 
   initResultSizeInfo(&pOperator->resultInfo, 4096);
+  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
 
   tNameAssign(&pInfo->name, &pScanNode->tableName);
   const char* name = tNameGetTableName(&pInfo->name);
@@ -4102,7 +4189,6 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan
   if (strncasecmp(name, TSDB_INS_TABLE_TABLES, TSDB_TABLE_FNAME_LEN) == 0 ||
       strncasecmp(name, TSDB_INS_TABLE_TAGS, TSDB_TABLE_FNAME_LEN) == 0) {
     pInfo->readHandle = *(SReadHandle*)readHandle;
-    blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
   } else {
     tsem_init(&pInfo->ready, 0, 0);
     pInfo->epSet = pScanPhyNode->mgmtEpSet;
@@ -4118,7 +4204,6 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan
   pOperator->pTaskInfo = pTaskInfo;
 
   pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doSysTableScan, NULL, NULL, destroySysScanOperator, NULL);
-
   return pOperator;
 
 _error:
@@ -4126,7 +4211,7 @@ _error:
     destroySysScanOperator(pInfo);
   }
   taosMemoryFreeClear(pOperator);
-  terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
+  pTaskInfo->code = code;
   return NULL;
 }
 
@@ -4280,7 +4365,7 @@ static int32_t loadDataBlockFromOneTable(SOperatorInfo* pOperator, STableMergeSc
   pCost->totalRows += pBlock->info.rows;
 
   *status = pInfo->dataBlockLoadFlag;
-  if (pTableScanInfo->pFilterNode != NULL ||
+  if (pOperator->exprSupp.pFilterInfo != NULL ||
       overlapWithTimeWindow(&pTableScanInfo->interval, &pBlock->info, pTableScanInfo->cond.order)) {
     (*status) = FUNC_DATA_REQUIRED_DATA_LOAD;
   }
@@ -4361,14 +4446,14 @@ static int32_t loadDataBlockFromOneTable(SOperatorInfo* pOperator, STableMergeSc
   SExprSupp* pSup = &pTableScanInfo->pseudoSup;
 
   int32_t code = addTagPseudoColumnData(&pTableScanInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pBlock,
-                                        pBlock->info.rows, GET_TASKID(pTaskInfo));
+                                        pBlock->info.rows, GET_TASKID(pTaskInfo), NULL);
   if (code != TSDB_CODE_SUCCESS) {
     T_LONG_JMP(pTaskInfo->env, code);
   }
 
-  if (pTableScanInfo->pFilterNode != NULL) {
+  if (pOperator->exprSupp.pFilterInfo!= NULL) {
     int64_t st = taosGetTimestampMs();
-    doFilter(pTableScanInfo->pFilterNode, pBlock, &pTableScanInfo->matchInfo, NULL);
+    doFilter(pBlock, pOperator->exprSupp.pFilterInfo, &pTableScanInfo->matchInfo);
 
     double el = (taosGetTimestampUs() - st) / 1000.0;
     pTableScanInfo->readRecorder.filterTime += el;
@@ -4741,7 +4826,13 @@ SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanN
   pInfo->sample.sampleRatio = pTableScanNode->ratio;
   pInfo->sample.seed = taosGetTimestampSec();
   pInfo->dataBlockLoadFlag = pTableScanNode->dataRequired;
-  pInfo->pFilterNode = pTableScanNode->scan.node.pConditions;
+
+
+  code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   pInfo->tableListInfo = pTableListInfo;
   pInfo->scanFlag = MAIN_SCAN;
 

source/libs/executor/src/sortoperator.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "filter.h"
 #include "executorimpl.h"
 #include "tdatablock.h"
 
@@ -42,12 +43,14 @@ SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode*
       extractColMatchInfo(pSortNode->pTargets, pDescNode, &numOfOutputCols, COL_MATCH_FROM_SLOT_ID, &pInfo->matchInfo);
 
   pOperator->exprSupp.pCtx = createSqlFunctionCtx(pExprInfo, numOfCols, &pOperator->exprSupp.rowEntryInfoOffset);
-
   initResultSizeInfo(&pOperator->resultInfo, 1024);
+  code = filterInitFromNode((SNode*)pSortNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
 
   pInfo->binfo.pRes = pResBlock;
   pInfo->pSortInfo = createSortInfo(pSortNode->pSortKeys);
-  pInfo->pCondition = pSortNode->node.pConditions;
   initLimitInfo(pSortNode->node.pLimit, pSortNode->node.pSlimit, &pInfo->limitInfo);
 
   pOperator->name = "SortOperator";
@@ -215,7 +218,7 @@ SSDataBlock* doSort(SOperatorInfo* pOperator) {
       return NULL;
     }
 
-    doFilter(pInfo->pCondition, pBlock, &pInfo->matchInfo, NULL);
+    doFilter(pBlock, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo);
     if (blockDataGetNumOfRows(pBlock) == 0) {
       continue;
     }
@@ -479,24 +482,31 @@ SOperatorInfo* createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSort
                                            SExecTaskInfo* pTaskInfo) {
   SGroupSortOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupSortOperatorInfo));
   SOperatorInfo*          pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
-  if (pInfo == NULL || pOperator == NULL /* || rowSize > 100 * 1024 * 1024*/) {
+  if (pInfo == NULL || pOperator == NULL) {
     goto _error;
   }
 
+  SExprSupp* pSup = &pOperator->exprSupp;
   SDataBlockDescNode* pDescNode = pSortPhyNode->node.pOutputDataBlockDesc;
 
   int32_t      numOfCols = 0;
-  SSDataBlock* pResBlock = createResDataBlock(pDescNode);
   SExprInfo*   pExprInfo = createExprInfo(pSortPhyNode->pExprs, NULL, &numOfCols);
 
+  pSup->pExprInfo = pExprInfo;
+  pSup->numOfExprs = numOfCols;
+
+  initResultSizeInfo(&pOperator->resultInfo, 1024);
+  pOperator->exprSupp.pCtx = createSqlFunctionCtx(pExprInfo, numOfCols, &pOperator->exprSupp.rowEntryInfoOffset);
+
+  pInfo->binfo.pRes = createResDataBlock(pDescNode);
+  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+
   int32_t numOfOutputCols = 0;
   int32_t code = extractColMatchInfo(pSortPhyNode->pTargets, pDescNode, &numOfOutputCols, COL_MATCH_FROM_SLOT_ID,
                                      &pInfo->matchInfo);
-
+  if (code != TSDB_CODE_SUCCESS) {
-  pOperator->exprSupp.pCtx = createSqlFunctionCtx(pExprInfo, numOfCols, &pOperator->exprSupp.rowEntryInfoOffset);
+    goto  _error;
-  pInfo->binfo.pRes = pResBlock;
+  }
-
-  initResultSizeInfo(&pOperator->resultInfo, 1024);
 
   pInfo->pSortInfo = createSortInfo(pSortPhyNode->pSortKeys);
 
@@ -505,8 +515,6 @@ SOperatorInfo* createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSort
   pOperator->blocking = false;
   pOperator->status = OP_NOT_OPENED;
   pOperator->info = pInfo;
-  pOperator->exprSupp.pExprInfo = pExprInfo;
-  pOperator->exprSupp.numOfExprs = numOfCols;
   pOperator->pTaskInfo = pTaskInfo;
 
   pOperator->fpSet = createOperatorFpSet(operatorDummyOpenFn, doGroupSort, NULL, NULL, destroyGroupSortOperatorInfo,
@@ -520,8 +528,10 @@ SOperatorInfo* createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSort
   return pOperator;
 
 _error:
-  pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY;
+  pTaskInfo->code = code;
-  taosMemoryFree(pInfo);
+  if (pInfo != NULL) {
+    destroyGroupSortOperatorInfo(pInfo);
+  }
   taosMemoryFree(pOperator);
   return NULL;
 }

source/libs/executor/src/tfill.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "filter.h"
 #include "os.h"
 #include "query.h"
 #include "taosdef.h"
@@ -1499,7 +1500,7 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) {
     }
 
     doStreamFillImpl(pOperator);
-    doFilter(pInfo->pCondition, pInfo->pRes, &pInfo->matchInfo, NULL);
+    doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo);
     memcpy(pInfo->pRes->info.parTbName, pInfo->pSrcBlock->info.parTbName, TSDB_TABLE_NAME_LEN);
     pOperator->resultInfo.totalRows += pInfo->pRes->info.rows;
     if (pInfo->pRes->info.rows > 0) {
@@ -1677,7 +1678,12 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi
   int32_t numOfOutputCols = 0;
   int32_t code = extractColMatchInfo(pPhyFillNode->pFillExprs, pPhyFillNode->node.pOutputDataBlockDesc,
                                      &numOfOutputCols, COL_MATCH_FROM_SLOT_ID, &pInfo->matchInfo);
-  pInfo->pCondition = pPhyFillNode->node.pConditions;
+
+  code = filterInitFromNode((SNode*)pPhyFillNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   code = initExprSupp(&pOperator->exprSupp, pFillExprInfo, numOfFillCols);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;

source/libs/executor/src/timewindowoperator.c

@@ -12,6 +12,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
+#include "filter.h"
 #include "executorimpl.h"
 #include "function.h"
 #include "functionMgt.h"
@@ -1227,7 +1228,7 @@ static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator) {
   blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
   while (1) {
     doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-    doFilter(pInfo->pCondition, pBInfo->pRes, NULL, NULL);
+    doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
 
     bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
     if (!hasRemain) {
@@ -1265,7 +1266,7 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) {
     blockDataEnsureCapacity(pBlock, pOperator->resultInfo.capacity);
     while (1) {
       doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-      doFilter(pInfo->pCondition, pBlock, NULL, NULL);
+      doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
 
       bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
       if (!hasRemain) {
@@ -1747,7 +1748,6 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh
   pInfo->interval = interval;
   pInfo->execModel = pTaskInfo->execModel;
   pInfo->twAggSup = as;
-  pInfo->pCondition = pPhyNode->window.node.pConditions;
   pInfo->binfo.mergeResultBlock = pPhyNode->window.mergeDataBlock;
 
   if (pPhyNode->window.pExprs != NULL) {
@@ -1759,6 +1759,11 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh
     }
   }
 
+  code = filterInitFromNode((SNode*)pPhyNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   if (isStream) {
     ASSERT(num > 0);
     initStreamFunciton(pSup->pCtx, pSup->numOfExprs);
@@ -1883,7 +1888,7 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
   if (pOperator->status == OP_RES_TO_RETURN) {
     while (1) {
       doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-      doFilter(pInfo->pCondition, pBInfo->pRes, NULL, NULL);
+      doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
 
       bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
       if (!hasRemain) {
@@ -1926,7 +1931,7 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
   blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
   while (1) {
     doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-    doFilter(pInfo->pCondition, pBInfo->pRes, NULL, NULL);
+    doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
 
     bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
     if (!hasRemain) {
@@ -2600,17 +2605,22 @@ SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWi
   pInfo->stateKey.type = pInfo->stateCol.type;
   pInfo->stateKey.bytes = pInfo->stateCol.bytes;
   pInfo->stateKey.pData = taosMemoryCalloc(1, pInfo->stateCol.bytes);
-  pInfo->pCondition = pStateNode->window.node.pConditions;
   if (pInfo->stateKey.pData == NULL) {
     goto _error;
   }
 
+  int32_t code = filterInitFromNode((SNode*)pStateNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
 
   int32_t    num = 0;
   SExprInfo* pExprInfo = createExprInfo(pStateNode->window.pFuncs, NULL, &num);
   initResultSizeInfo(&pOperator->resultInfo, 4096);
-  int32_t code = initAggInfo(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str);
+
+  code = initAggInfo(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
   }
@@ -2698,7 +2708,10 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW
   pInfo->binfo.pRes = pResBlock;
   pInfo->winSup.prevTs = INT64_MIN;
   pInfo->reptScan = false;
-  pInfo->pCondition = pSessionNode->window.node.pConditions;
+  code = filterInitFromNode((SNode*)pSessionNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
 
   pOperator->name = "SessionWindowAggOperator";
   pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION;
@@ -4877,7 +4890,7 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
     setInputDataBlock(pSup, pBlock, pIaInfo->inputOrder, scanFlag, true);
     doMergeAlignedIntervalAggImpl(pOperator, &pIaInfo->binfo.resultRowInfo, pBlock, pRes);
 
-    doFilter(pMiaInfo->pCondition, pRes, NULL, NULL);
+    doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
     if (pRes->info.rows >= pOperator->resultInfo.capacity) {
       break;
     }
@@ -4940,7 +4953,11 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream,
   SIntervalAggOperatorInfo* iaInfo = miaInfo->intervalAggOperatorInfo;
   SExprSupp*                pSup = &pOperator->exprSupp;
 
-  miaInfo->pCondition = pNode->window.node.pConditions;
+  int32_t code = filterInitFromNode((SNode*)pNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _error;
+  }
+
   miaInfo->curTs = INT64_MIN;
   iaInfo->win = pTaskInfo->window;
   iaInfo->inputOrder = TSDB_ORDER_ASC;
@@ -4954,7 +4971,8 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream,
 
   int32_t    num = 0;
   SExprInfo* pExprInfo = createExprInfo(pNode->window.pFuncs, NULL, &num);
-  int32_t    code = initAggInfo(&pOperator->exprSupp, &iaInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str);
+
+  code = initAggInfo(&pOperator->exprSupp, &iaInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
   }

source/libs/nodes/src/nodesUtilFuncs.c

@@ -792,9 +792,24 @@ void nodesDestroyNode(SNode* pNode) {
       nodesDestroyNode((SNode*)pStmt->pSlimit);
       break;
     }
-    case QUERY_NODE_VNODE_MODIF_STMT:
+    case QUERY_NODE_VNODE_MODIF_STMT: {
-      destroyVgDataBlockArray(((SVnodeModifOpStmt*)pNode)->pDataBlocks);
+      SVnodeModifOpStmt* pStmt = (SVnodeModifOpStmt*)pNode;
+      destroyVgDataBlockArray(pStmt->pDataBlocks);
+      taosMemoryFreeClear(pStmt->pTableMeta);
+      taosHashCleanup(pStmt->pVgroupsHashObj);
+      taosHashCleanup(pStmt->pSubTableHashObj);
+      taosHashCleanup(pStmt->pTableNameHashObj);
+      taosHashCleanup(pStmt->pDbFNameHashObj);
+      if (pStmt->freeHashFunc) {
+        pStmt->freeHashFunc(pStmt->pTableBlockHashObj);
+      }
+      if (pStmt->freeArrayFunc) {
+        pStmt->freeArrayFunc(pStmt->pVgDataBlocks);
+      }
+      tdDestroySVCreateTbReq(&pStmt->createTblReq);
+      taosCloseFile(&pStmt->fp);
       break;
+    }
     case QUERY_NODE_CREATE_DATABASE_STMT:
       nodesDestroyNode((SNode*)((SCreateDatabaseStmt*)pNode)->pOptions);
       break;

source/libs/parser/inc/parInsertUtil.h

@@ -79,29 +79,6 @@ typedef struct SInsertParseBaseContext {
   SMsgBuf        msg;
 } SInsertParseBaseContext;
 
-typedef struct SInsertParseContext {
-  SParseContext     *pComCxt;             // input
-  char              *pSql;                // input
-  SMsgBuf            msg;                 // input
-  STableMeta        *pTableMeta;          // each table
-  SParsedDataColInfo tags;                // each table
-  SVCreateTbReq      createTblReq;        // each table
-  SHashObj          *pVgroupsHashObj;     // global
-  SHashObj          *pTableBlockHashObj;  // global
-  SHashObj          *pSubTableHashObj;    // global
-  SArray            *pVgDataBlocks;       // global
-  SHashObj          *pTableNameHashObj;   // global
-  SHashObj          *pDbFNameHashObj;     // global
-  int32_t            totalNum;
-  SVnodeModifOpStmt *pOutput;
-  SStmtCallback     *pStmtCb;
-  SParseMetaCache   *pMetaCache;
-  char               sTableName[TSDB_TABLE_NAME_LEN];
-  char               tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW];
-  int64_t            memElapsed;
-  int64_t            parRowElapsed;
-} SInsertParseContext;
-
 typedef struct SInsertParseSyntaxCxt {
   SParseContext   *pComCxt;
   char            *pSql;
@@ -142,7 +119,7 @@ typedef struct STableDataBlocks {
 
 int32_t insGetExtendedRowSize(STableDataBlocks *pBlock);
 void insGetSTSRowAppendInfo(uint8_t rowType, SParsedDataColInfo *spd, col_id_t idx, int32_t *toffset, col_id_t *colIdx);
-int32_t insSetBlockInfo(SSubmitBlk *pBlocks, STableDataBlocks *dataBuf, int32_t numOfRows);
+int32_t insSetBlockInfo(SSubmitBlk *pBlocks, STableDataBlocks *dataBuf, int32_t numOfRows, SMsgBuf *pMsg);
 int32_t insSchemaIdxCompar(const void *lhs, const void *rhs);
 int32_t insBoundIdxCompar(const void *lhs, const void *rhs);
 void    insSetBoundColumnInfo(SParsedDataColInfo *pColList, SSchema *pSchema, col_id_t numOfCols);
@@ -161,7 +138,7 @@ void    insBuildCreateTbReq(SVCreateTbReq *pTbReq, const char *tname, STag *pTag
                             SArray *tagName, uint8_t tagNum);
 int32_t insMemRowAppend(SMsgBuf *pMsgBuf, const void *value, int32_t len, void *param);
 int32_t insCheckTimestamp(STableDataBlocks *pDataBlocks, const char *start);
-int32_t insBuildOutput(SInsertParseContext *pCxt);
+int32_t insBuildOutput(SHashObj *pVgroupsHashObj, SArray *pVgDataBlocks, SArray **pDataBlocks);
 void    insDestroyDataBlock(STableDataBlocks *pDataBlock);
 
 #endif  // TDENGINE_PAR_INSERT_UTIL_H

source/libs/parser/inc/parInt.h

@@ -27,8 +27,7 @@ extern "C" {
 #define QUERY_SMA_OPTIMIZE_DISABLE 0
 #define QUERY_SMA_OPTIMIZE_ENABLE  1
 
-int32_t parseInsertSyntax(SParseContext* pContext, SQuery** pQuery, SParseMetaCache* pMetaCache);
+int32_t parseInsertSql(SParseContext* pCxt, SQuery** pQuery, SCatalogReq* pCatalogReq, const SMetaData* pMetaData);
-int32_t parseInsertSql(SParseContext* pContext, SQuery** pQuery, SParseMetaCache* pMetaCache);
 int32_t parse(SParseContext* pParseCxt, SQuery** pQuery);
 int32_t collectMetaKey(SParseContext* pParseCxt, SQuery* pQuery, SParseMetaCache* pMetaCache);
 int32_t authenticate(SParseContext* pParseCxt, SQuery* pQuery, SParseMetaCache* pMetaCache);

source/libs/parser/inc/parUtil.h

@@ -60,22 +60,17 @@ typedef struct SInsertTablesMetaReq {
 } SInsertTablesMetaReq;
 
 typedef struct SParseMetaCache {
-  SHashObj*     pTableMeta;    // key is tbFName, element is STableMeta*
+  SHashObj* pTableMeta;    // key is tbFName, element is STableMeta*
-  SHashObj*     pDbVgroup;     // key is dbFName, element is SArray<SVgroupInfo>*
+  SHashObj* pDbVgroup;     // key is dbFName, element is SArray<SVgroupInfo>*
-  SHashObj*     pTableVgroup;  // key is tbFName, element is SVgroupInfo*
+  SHashObj* pTableVgroup;  // key is tbFName, element is SVgroupInfo*
-  SHashObj*     pDbCfg;        // key is tbFName, element is SDbCfgInfo*
+  SHashObj* pDbCfg;        // key is tbFName, element is SDbCfgInfo*
-  SHashObj*     pDbInfo;       // key is tbFName, element is SDbInfo*
+  SHashObj* pDbInfo;       // key is tbFName, element is SDbInfo*
-  SHashObj*     pUserAuth;  // key is SUserAuthInfo serialized string, element is bool indicating whether or not to pass
+  SHashObj* pUserAuth;     // key is SUserAuthInfo serialized string, element is bool indicating whether or not to pass
-  SHashObj*     pUdf;       // key is funcName, element is SFuncInfo*
+  SHashObj* pUdf;          // key is funcName, element is SFuncInfo*
-  SHashObj*     pTableIndex;  // key is tbFName, element is SArray<STableIndexInfo>*
+  SHashObj* pTableIndex;   // key is tbFName, element is SArray<STableIndexInfo>*
-  SHashObj*     pTableCfg;    // key is tbFName, element is STableCfg*
+  SHashObj* pTableCfg;     // key is tbFName, element is STableCfg*
-  SArray*       pDnodes;      // element is SEpSet
+  SArray*   pDnodes;       // element is SEpSet
-  bool          dnodeRequired;
+  bool      dnodeRequired;
-  SHashObj*     pInsertTables;  // key is dbName, element is SInsertTablesMetaReq*, for insert
-  const char*   pUser;
-  const SArray* pTableMetaData;    // pRes = STableMeta*
-  const SArray* pTableVgroupData;  // pRes = SVgroupInfo*
-  int32_t       sqlTableNum;
 } SParseMetaCache;
 
 int32_t generateSyntaxErrMsg(SMsgBuf* pBuf, int32_t errCode, ...);
@@ -93,9 +88,8 @@ STableMeta*   tableMetaDup(const STableMeta* pTableMeta);
 int32_t trimString(const char* src, int32_t len, char* dst, int32_t dlen);
 int32_t getInsTagsTableTargetName(int32_t acctId, SNode* pWhere, SName* pName);
 
-int32_t buildCatalogReq(SParseContext* pCxt, const SParseMetaCache* pMetaCache, SCatalogReq* pCatalogReq);
+int32_t buildCatalogReq(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalogReq);
-int32_t putMetaDataToCache(const SCatalogReq* pCatalogReq, const SMetaData* pMetaData, SParseMetaCache* pMetaCache,
+int32_t putMetaDataToCache(const SCatalogReq* pCatalogReq, const SMetaData* pMetaData, SParseMetaCache* pMetaCache);
-                           bool insertValuesStmt);
 int32_t reserveTableMetaInCache(int32_t acctId, const char* pDb, const char* pTable, SParseMetaCache* pMetaCache);
 int32_t reserveTableMetaInCacheExt(const SName* pName, SParseMetaCache* pMetaCache);
 int32_t reserveDbVgInfoInCache(int32_t acctId, const char* pDb, SParseMetaCache* pMetaCache);
@@ -122,12 +116,6 @@ int32_t getUdfInfoFromCache(SParseMetaCache* pMetaCache, const char* pFunc, SFun
 int32_t getTableIndexFromCache(SParseMetaCache* pMetaCache, const SName* pName, SArray** pIndexes);
 int32_t getTableCfgFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableCfg** pOutput);
 int32_t getDnodeListFromCache(SParseMetaCache* pMetaCache, SArray** pDnodes);
-int32_t reserveTableMetaInCacheForInsert(const SName* pName, ECatalogReqType reqType, int32_t tableNo,
-                                         SParseMetaCache* pMetaCache);
-int32_t getTableMetaFromCacheForInsert(SArray* pTableMetaPos, SParseMetaCache* pMetaCache, int32_t tableNo,
-                                       STableMeta** pMeta);
-int32_t getTableVgroupFromCacheForInsert(SArray* pTableVgroupPos, SParseMetaCache* pMetaCache, int32_t tableNo,
-                                         SVgroupInfo* pVgroup);
 void    destoryParseMetaCache(SParseMetaCache* pMetaCache, bool request);
 
 #ifdef __cplusplus

source/libs/parser/src/parAstParser.c

@@ -84,6 +84,7 @@ abort_parse:
     (*pQuery)->pRoot = cxt.pRootNode;
     (*pQuery)->placeholderNum = cxt.placeholderNo;
     TSWAP((*pQuery)->pPlaceholderValues, cxt.pPlaceholderValues);
+    (*pQuery)->execStage = QUERY_EXEC_STAGE_ANALYSE;
   }
   taosArrayDestroy(cxt.pPlaceholderValues);
   return cxt.errCode;

source/libs/parser/src/parInsertSml.c

@@ -333,11 +333,7 @@ int32_t smlBindData(void* handle, SArray* tags, SArray* colsSchema, SArray* cols
   }
 
   SSubmitBlk* pBlocks = (SSubmitBlk*)(pDataBlock->pData);
-  if (TSDB_CODE_SUCCESS != insSetBlockInfo(pBlocks, pDataBlock, rowNum)) {
+  return insSetBlockInfo(pBlocks, pDataBlock, rowNum, &pBuf);
-    return buildInvalidOperationMsg(&pBuf, "too many rows in sql, total number of rows should be less than INT32_MAX");
-  }
-
-  return TSDB_CODE_SUCCESS;
 }
 
 void* smlInitHandle(SQuery* pQuery) {

source/libs/parser/src/parInsertStmt.c

@@ -30,23 +30,17 @@ typedef struct SKvParam {
 } SKvParam;
 
 int32_t qBuildStmtOutput(SQuery* pQuery, SHashObj* pVgHash, SHashObj* pBlockHash) {
-  SVnodeModifOpStmt*  modifyNode = (SVnodeModifOpStmt*)pQuery->pRoot;
+  int32_t code = TSDB_CODE_SUCCESS;
-  int32_t             code = 0;
+  SArray* pVgDataBlocks = NULL;
-  SInsertParseContext insertCtx = {
-      .pVgroupsHashObj = pVgHash,
-      .pTableBlockHashObj = pBlockHash,
-      .pOutput = (SVnodeModifOpStmt*)pQuery->pRoot,
-  };
-
   // merge according to vgId
-  if (taosHashGetSize(insertCtx.pTableBlockHashObj) > 0) {
+  if (taosHashGetSize(pBlockHash) > 0) {
-    CHECK_CODE(insMergeTableDataBlocks(insertCtx.pTableBlockHashObj, &insertCtx.pVgDataBlocks));
+    code = insMergeTableDataBlocks(pBlockHash, &pVgDataBlocks);
   }
-
+  if (TSDB_CODE_SUCCESS == code) {
-  CHECK_CODE(insBuildOutput(&insertCtx));
+    code = insBuildOutput(pVgHash, pVgDataBlocks, &((SVnodeModifOpStmt*)pQuery->pRoot)->pDataBlocks);
-
+  }
-  insDestroyBlockArrayList(insertCtx.pVgDataBlocks);
+  insDestroyBlockArrayList(pVgDataBlocks);
-  return TSDB_CODE_SUCCESS;
+  return code;
 }
 
 int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const char* sTableName, char* tName,
@@ -222,11 +216,7 @@ int32_t qBindStmtColsValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBuf, in
   }
 
   SSubmitBlk* pBlocks = (SSubmitBlk*)(pDataBlock->pData);
-  if (TSDB_CODE_SUCCESS != insSetBlockInfo(pBlocks, pDataBlock, bind->num)) {
+  return insSetBlockInfo(pBlocks, pDataBlock, bind->num, &pBuf);
-    return buildInvalidOperationMsg(&pBuf, "too many rows in sql, total number of rows should be less than INT32_MAX");
-  }
-
-  return TSDB_CODE_SUCCESS;
 }
 
 int32_t qBindStmtSingleColValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBuf, int32_t msgBufLen, int32_t colIdx,
@@ -308,10 +298,7 @@ int32_t qBindStmtSingleColValue(void* pBlock, TAOS_MULTI_BIND* bind, char* msgBu
     pDataBlock->size += extendedRowSize * bind->num;
 
     SSubmitBlk* pBlocks = (SSubmitBlk*)(pDataBlock->pData);
-    if (TSDB_CODE_SUCCESS != insSetBlockInfo(pBlocks, pDataBlock, bind->num)) {
+    CHECK_CODE(insSetBlockInfo(pBlocks, pDataBlock, bind->num, &pBuf));
-      return buildInvalidOperationMsg(&pBuf,
-                                      "too many rows in sql, total number of rows should be less than INT32_MAX");
-    }
   }
 
   return TSDB_CODE_SUCCESS;

source/libs/parser/src/parInsertUtil.c

@@ -110,18 +110,17 @@ void insGetSTSRowAppendInfo(uint8_t rowType, SParsedDataColInfo* spd, col_id_t i
   }
 }
 
-int32_t insSetBlockInfo(SSubmitBlk* pBlocks, STableDataBlocks* dataBuf, int32_t numOfRows) {
+int32_t insSetBlockInfo(SSubmitBlk* pBlocks, STableDataBlocks* dataBuf, int32_t numOfRows, SMsgBuf* pMsg) {
   pBlocks->suid = (TSDB_NORMAL_TABLE == dataBuf->pTableMeta->tableType ? 0 : dataBuf->pTableMeta->suid);
   pBlocks->uid = dataBuf->pTableMeta->uid;
   pBlocks->sversion = dataBuf->pTableMeta->sversion;
   pBlocks->schemaLen = dataBuf->createTbReqLen;
 
   if (pBlocks->numOfRows + numOfRows >= INT32_MAX) {
-    return TSDB_CODE_TSC_INVALID_OPERATION;
+    return buildInvalidOperationMsg(pMsg, "too many rows in sql, total number of rows should be less than INT32_MAX");
-  } else {
-    pBlocks->numOfRows += numOfRows;
-    return TSDB_CODE_SUCCESS;
   }
+  pBlocks->numOfRows += numOfRows;
+  return TSDB_CODE_SUCCESS;
 }
 
 void insSetBoundColumnInfo(SParsedDataColInfo* pColList, SSchema* pSchema, col_id_t numOfCols) {
@@ -271,12 +270,8 @@ void insDestroyDataBlock(STableDataBlocks* pDataBlock) {
   }
 
   taosMemoryFreeClear(pDataBlock->pData);
-  //  if (!pDataBlock->cloned) {
-  // free the refcount for metermeta
   taosMemoryFreeClear(pDataBlock->pTableMeta);
-
   destroyBoundColumnInfo(&pDataBlock->boundColumnInfo);
-  //  }
   taosMemoryFreeClear(pDataBlock);
 }
 
@@ -312,20 +307,6 @@ int32_t insGetDataBlockFromList(SHashObj* pHashList, void* id, int32_t idLen, in
 
   return TSDB_CODE_SUCCESS;
 }
-#if 0
-static int32_t getRowExpandSize(STableMeta* pTableMeta) {
-  int32_t  result = TD_ROW_HEAD_LEN - sizeof(TSKEY);
-  int32_t  columns = getNumOfColumns(pTableMeta);
-  SSchema* pSchema = getTableColumnSchema(pTableMeta);
-  for (int32_t i = 0; i < columns; ++i) {
-    if (IS_VAR_DATA_TYPE((pSchema + i)->type)) {
-      result += TYPE_BYTES[TSDB_DATA_TYPE_BINARY];
-    }
-  }
-  result += (int32_t)TD_BITMAP_BYTES(columns - 1);
-  return result;
-}
-#endif
 
 void insDestroyBlockArrayList(SArray* pDataBlockList) {
   if (pDataBlockList == NULL) {
@@ -357,51 +338,6 @@ void insDestroyBlockHashmap(SHashObj* pDataBlockHash) {
   taosHashCleanup(pDataBlockHash);
 }
 
-#if 0
-// data block is disordered, sort it in ascending order
-void sortRemoveDataBlockDupRowsRaw(STableDataBlocks* dataBuf) {
-  SSubmitBlk* pBlocks = (SSubmitBlk*)dataBuf->pData;
-
-  // size is less than the total size, since duplicated rows may be removed yet.
-  assert(pBlocks->numOfRows * dataBuf->rowSize + sizeof(SSubmitBlk) == dataBuf->size);
-
-  if (!dataBuf->ordered) {
-    char* pBlockData = pBlocks->data;
-
-    // todo. qsort is unstable, if timestamp is same, should get the last one
-    taosSort(pBlockData, pBlocks->numOfRows, dataBuf->rowSize, rowDataCompar);
-
-    int32_t i = 0;
-    int32_t j = 1;
-
-    // delete rows with timestamp conflicts
-    while (j < pBlocks->numOfRows) {
-      TSKEY ti = *(TSKEY*)(pBlockData + dataBuf->rowSize * i);
-      TSKEY tj = *(TSKEY*)(pBlockData + dataBuf->rowSize * j);
-
-      if (ti == tj) {
-        ++j;
-        continue;
-      }
-
-      int32_t nextPos = (++i);
-      if (nextPos != j) {
-        memmove(pBlockData + dataBuf->rowSize * nextPos, pBlockData + dataBuf->rowSize * j, dataBuf->rowSize);
-      }
-
-      ++j;
-    }
-
-    dataBuf->ordered = true;
-
-    pBlocks->numOfRows = i + 1;
-    dataBuf->size = sizeof(SSubmitBlk) + dataBuf->rowSize * pBlocks->numOfRows;
-  }
-
-  dataBuf->prevTS = INT64_MIN;
-}
-#endif
-
 // data block is disordered, sort it in ascending order
 static int sortRemoveDataBlockDupRows(STableDataBlocks* dataBuf, SBlockKeyInfo* pBlkKeyInfo) {
   SSubmitBlk* pBlocks = (SSubmitBlk*)dataBuf->pData;
@@ -896,6 +832,10 @@ int32_t insCreateSName(SName* pName, SToken* pTableName, int32_t acctId, const c
     }
   }
 
+  if (NULL != strchr(pName->tname, '.')) {
+    code = generateSyntaxErrMsgExt(pMsgBuf, TSDB_CODE_PAR_INVALID_IDENTIFIER_NAME, "The table name cannot contain '.'");
+  }
+
   return code;
 }
 
@@ -994,24 +934,24 @@ static void buildMsgHeader(STableDataBlocks* src, SVgDataBlocks* blocks) {
   }
 }
 
-int32_t insBuildOutput(SInsertParseContext* pCxt) {
+int32_t insBuildOutput(SHashObj* pVgroupsHashObj, SArray* pVgDataBlocks, SArray** pDataBlocks) {
-  size_t numOfVg = taosArrayGetSize(pCxt->pVgDataBlocks);
+  size_t numOfVg = taosArrayGetSize(pVgDataBlocks);
-  pCxt->pOutput->pDataBlocks = taosArrayInit(numOfVg, POINTER_BYTES);
+  *pDataBlocks = taosArrayInit(numOfVg, POINTER_BYTES);
-  if (NULL == pCxt->pOutput->pDataBlocks) {
+  if (NULL == *pDataBlocks) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
   for (size_t i = 0; i < numOfVg; ++i) {
-    STableDataBlocks* src = taosArrayGetP(pCxt->pVgDataBlocks, i);
+    STableDataBlocks* src = taosArrayGetP(pVgDataBlocks, i);
     SVgDataBlocks*    dst = taosMemoryCalloc(1, sizeof(SVgDataBlocks));
     if (NULL == dst) {
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
-    taosHashGetDup(pCxt->pVgroupsHashObj, (const char*)&src->vgId, sizeof(src->vgId), &dst->vg);
+    taosHashGetDup(pVgroupsHashObj, (const char*)&src->vgId, sizeof(src->vgId), &dst->vg);
     dst->numOfTables = src->numOfTables;
     dst->size = src->size;
     TSWAP(dst->pData, src->pData);
     buildMsgHeader(src, dst);
-    taosArrayPush(pCxt->pOutput->pDataBlocks, &dst);
+    taosArrayPush(*pDataBlocks, &dst);
   }
   return TSDB_CODE_SUCCESS;
 }

source/libs/parser/src/parUtil.c

@@ -612,62 +612,7 @@ static int32_t buildUdfReq(SHashObj* pUdfHash, SArray** pUdf) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t buildCatalogReqForInsert(SParseContext* pCxt, const SParseMetaCache* pMetaCache,
+int32_t buildCatalogReq(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalogReq) {
-                                        SCatalogReq* pCatalogReq) {
-  int32_t ndbs = taosHashGetSize(pMetaCache->pInsertTables);
-  pCatalogReq->pTableMeta = taosArrayInit(ndbs, sizeof(STablesReq));
-  if (NULL == pCatalogReq->pTableMeta) {
-    return TSDB_CODE_OUT_OF_MEMORY;
-  }
-  pCatalogReq->pTableHash = taosArrayInit(ndbs, sizeof(STablesReq));
-  if (NULL == pCatalogReq->pTableHash) {
-    return TSDB_CODE_OUT_OF_MEMORY;
-  }
-  pCatalogReq->pUser = taosArrayInit(ndbs, sizeof(SUserAuthInfo));
-  if (NULL == pCatalogReq->pUser) {
-    return TSDB_CODE_OUT_OF_MEMORY;
-  }
-
-  pCxt->pTableMetaPos = taosArrayInit(pMetaCache->sqlTableNum, sizeof(int32_t));
-  pCxt->pTableVgroupPos = taosArrayInit(pMetaCache->sqlTableNum, sizeof(int32_t));
-
-  int32_t               metaReqNo = 0;
-  int32_t               vgroupReqNo = 0;
-  SInsertTablesMetaReq* p = taosHashIterate(pMetaCache->pInsertTables, NULL);
-  while (NULL != p) {
-    STablesReq req = {0};
-    strcpy(req.dbFName, p->dbFName);
-    TSWAP(req.pTables, p->pTableMetaReq);
-    taosArrayPush(pCatalogReq->pTableMeta, &req);
-
-    req.pTables = NULL;
-    TSWAP(req.pTables, p->pTableVgroupReq);
-    taosArrayPush(pCatalogReq->pTableHash, &req);
-
-    int32_t ntables = taosArrayGetSize(p->pTableMetaPos);
-    for (int32_t i = 0; i < ntables; ++i) {
-      taosArrayInsert(pCxt->pTableMetaPos, *(int32_t*)taosArrayGet(p->pTableMetaPos, i), &metaReqNo);
-      ++metaReqNo;
-    }
-
-    ntables = taosArrayGetSize(p->pTableVgroupPos);
-    for (int32_t i = 0; i < ntables; ++i) {
-      taosArrayInsert(pCxt->pTableVgroupPos, *(int32_t*)taosArrayGet(p->pTableVgroupPos, i), &vgroupReqNo);
-      ++vgroupReqNo;
-    }
-
-    SUserAuthInfo auth = {0};
-    snprintf(auth.user, sizeof(auth.user), "%s", pCxt->pUser);
-    snprintf(auth.dbFName, sizeof(auth.dbFName), "%s", p->dbFName);
-    auth.type = AUTH_TYPE_WRITE;
-    taosArrayPush(pCatalogReq->pUser, &auth);
-
-    p = taosHashIterate(pMetaCache->pInsertTables, p);
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t buildCatalogReqForQuery(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalogReq) {
   int32_t code = buildTableReqFromDb(pMetaCache->pTableMeta, &pCatalogReq->pTableMeta);
   if (TSDB_CODE_SUCCESS == code) {
     code = buildDbReq(pMetaCache->pDbVgroup, &pCatalogReq->pDbVgroup);
@@ -697,13 +642,6 @@ int32_t buildCatalogReqForQuery(const SParseMetaCache* pMetaCache, SCatalogReq*
   return code;
 }
 
-int32_t buildCatalogReq(SParseContext* pCxt, const SParseMetaCache* pMetaCache, SCatalogReq* pCatalogReq) {
-  if (NULL != pMetaCache->pInsertTables) {
-    return buildCatalogReqForInsert(pCxt, pMetaCache, pCatalogReq);
-  }
-  return buildCatalogReqForQuery(pMetaCache, pCatalogReq);
-}
-
 static int32_t putMetaDataToHash(const char* pKey, int32_t len, const SArray* pData, int32_t index, SHashObj** pHash) {
   if (NULL == *pHash) {
     *pHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
@@ -791,8 +729,7 @@ static int32_t putUdfToCache(const SArray* pUdfReq, const SArray* pUdfData, SHas
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t putMetaDataToCacheForQuery(const SCatalogReq* pCatalogReq, const SMetaData* pMetaData,
+int32_t putMetaDataToCache(const SCatalogReq* pCatalogReq, const SMetaData* pMetaData, SParseMetaCache* pMetaCache) {
-                                   SParseMetaCache* pMetaCache) {
   int32_t code = putDbTableDataToCache(pCatalogReq->pTableMeta, pMetaData->pTableMeta, &pMetaCache->pTableMeta);
   if (TSDB_CODE_SUCCESS == code) {
     code = putDbDataToCache(pCatalogReq->pDbVgroup, pMetaData->pDbVgroup, &pMetaCache->pDbVgroup);
@@ -822,30 +759,6 @@ int32_t putMetaDataToCacheForQuery(const SCatalogReq* pCatalogReq, const SMetaDa
   return code;
 }
 
-int32_t putMetaDataToCacheForInsert(const SMetaData* pMetaData, SParseMetaCache* pMetaCache) {
-  int32_t ndbs = taosArrayGetSize(pMetaData->pUser);
-  for (int32_t i = 0; i < ndbs; ++i) {
-    SMetaRes* pRes = taosArrayGet(pMetaData->pUser, i);
-    if (TSDB_CODE_SUCCESS != pRes->code) {
-      return pRes->code;
-    }
-    if (!(*(bool*)pRes->pRes)) {
-      return TSDB_CODE_PAR_PERMISSION_DENIED;
-    }
-  }
-  pMetaCache->pTableMetaData = pMetaData->pTableMeta;
-  pMetaCache->pTableVgroupData = pMetaData->pTableHash;
-  return TSDB_CODE_SUCCESS;
-}
-
-int32_t putMetaDataToCache(const SCatalogReq* pCatalogReq, const SMetaData* pMetaData, SParseMetaCache* pMetaCache,
-                           bool insertValuesStmt) {
-  if (insertValuesStmt) {
-    return putMetaDataToCacheForInsert(pMetaData, pMetaCache);
-  }
-  return putMetaDataToCacheForQuery(pCatalogReq, pMetaData, pMetaCache);
-}
-
 static int32_t reserveTableReqInCacheImpl(const char* pTbFName, int32_t len, SHashObj** pTables) {
   if (NULL == *pTables) {
     *pTables = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
@@ -1146,82 +1059,6 @@ int32_t getDnodeListFromCache(SParseMetaCache* pMetaCache, SArray** pDnodes) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t reserveTableReqInCacheForInsert(const SName* pName, ECatalogReqType reqType, int32_t tableNo,
-                                               SInsertTablesMetaReq* pReq) {
-  switch (reqType) {
-    case CATALOG_REQ_TYPE_META:
-      taosArrayPush(pReq->pTableMetaReq, pName);
-      taosArrayPush(pReq->pTableMetaPos, &tableNo);
-      break;
-    case CATALOG_REQ_TYPE_VGROUP:
-      taosArrayPush(pReq->pTableVgroupReq, pName);
-      taosArrayPush(pReq->pTableVgroupPos, &tableNo);
-      break;
-    case CATALOG_REQ_TYPE_BOTH:
-      taosArrayPush(pReq->pTableMetaReq, pName);
-      taosArrayPush(pReq->pTableMetaPos, &tableNo);
-      taosArrayPush(pReq->pTableVgroupReq, pName);
-      taosArrayPush(pReq->pTableVgroupPos, &tableNo);
-      break;
-    default:
-      break;
-  }
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t reserveTableReqInDbCacheForInsert(const SName* pName, ECatalogReqType reqType, int32_t tableNo,
-                                                 SHashObj* pDbs) {
-  SInsertTablesMetaReq req = {.pTableMetaReq = taosArrayInit(4, sizeof(SName)),
-                              .pTableMetaPos = taosArrayInit(4, sizeof(int32_t)),
-                              .pTableVgroupReq = taosArrayInit(4, sizeof(SName)),
-                              .pTableVgroupPos = taosArrayInit(4, sizeof(int32_t))};
-  tNameGetFullDbName(pName, req.dbFName);
-  int32_t code = reserveTableReqInCacheForInsert(pName, reqType, tableNo, &req);
-  if (TSDB_CODE_SUCCESS == code) {
-    code = taosHashPut(pDbs, pName->dbname, strlen(pName->dbname), &req, sizeof(SInsertTablesMetaReq));
-  }
-  return code;
-}
-
-int32_t reserveTableMetaInCacheForInsert(const SName* pName, ECatalogReqType reqType, int32_t tableNo,
-                                         SParseMetaCache* pMetaCache) {
-  if (NULL == pMetaCache->pInsertTables) {
-    pMetaCache->pInsertTables = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
-    if (NULL == pMetaCache->pInsertTables) {
-      return TSDB_CODE_OUT_OF_MEMORY;
-    }
-  }
-  pMetaCache->sqlTableNum = tableNo;
-  SInsertTablesMetaReq* pReq = taosHashGet(pMetaCache->pInsertTables, pName->dbname, strlen(pName->dbname));
-  if (NULL == pReq) {
-    return reserveTableReqInDbCacheForInsert(pName, reqType, tableNo, pMetaCache->pInsertTables);
-  }
-  return reserveTableReqInCacheForInsert(pName, reqType, tableNo, pReq);
-}
-
-int32_t getTableMetaFromCacheForInsert(SArray* pTableMetaPos, SParseMetaCache* pMetaCache, int32_t tableNo,
-                                       STableMeta** pMeta) {
-  int32_t   reqIndex = *(int32_t*)taosArrayGet(pTableMetaPos, tableNo);
-  SMetaRes* pRes = taosArrayGet(pMetaCache->pTableMetaData, reqIndex);
-  if (TSDB_CODE_SUCCESS == pRes->code) {
-    *pMeta = tableMetaDup((const STableMeta*)pRes->pRes);
-    if (NULL == *pMeta) {
-      return TSDB_CODE_OUT_OF_MEMORY;
-    }
-  }
-  return pRes->code;
-}
-
-int32_t getTableVgroupFromCacheForInsert(SArray* pTableVgroupPos, SParseMetaCache* pMetaCache, int32_t tableNo,
-                                         SVgroupInfo* pVgroup) {
-  int32_t   reqIndex = *(int32_t*)taosArrayGet(pTableVgroupPos, tableNo);
-  SMetaRes* pRes = taosArrayGet(pMetaCache->pTableVgroupData, reqIndex);
-  if (TSDB_CODE_SUCCESS == pRes->code) {
-    memcpy(pVgroup, pRes->pRes, sizeof(SVgroupInfo));
-  }
-  return pRes->code;
-}
-
 void destoryParseTablesMetaReqHash(SHashObj* pHash) {
   SParseTablesMetaReq* p = taosHashIterate(pHash, NULL);
   while (NULL != p) {
@@ -1239,16 +1076,6 @@ void destoryParseMetaCache(SParseMetaCache* pMetaCache, bool request) {
     taosHashCleanup(pMetaCache->pTableMeta);
     taosHashCleanup(pMetaCache->pTableVgroup);
   }
-  SInsertTablesMetaReq* p = taosHashIterate(pMetaCache->pInsertTables, NULL);
-  while (NULL != p) {
-    taosArrayDestroy(p->pTableMetaPos);
-    taosArrayDestroy(p->pTableMetaReq);
-    taosArrayDestroy(p->pTableVgroupPos);
-    taosArrayDestroy(p->pTableVgroupReq);
-
-    p = taosHashIterate(pMetaCache->pInsertTables, p);
-  }
-  taosHashCleanup(pMetaCache->pInsertTables);
   taosHashCleanup(pMetaCache->pDbVgroup);
   taosHashCleanup(pMetaCache->pDbCfg);
   taosHashCleanup(pMetaCache->pDbInfo);

source/libs/parser/src/parser.c

@@ -167,7 +167,7 @@ static void rewriteExprAlias(SNode* pRoot) {
 int32_t qParseSql(SParseContext* pCxt, SQuery** pQuery) {
   int32_t code = TSDB_CODE_SUCCESS;
   if (qIsInsertValuesSql(pCxt->pSql, pCxt->sqlLen)) {
-    code = parseInsertSql(pCxt, pQuery, NULL);
+    code = parseInsertSql(pCxt, pQuery, NULL, NULL);
   } else {
     code = parseSqlIntoAst(pCxt, pQuery);
   }
@@ -175,21 +175,26 @@ int32_t qParseSql(SParseContext* pCxt, SQuery** pQuery) {
   return code;
 }
 
-int32_t qParseSqlSyntax(SParseContext* pCxt, SQuery** pQuery, struct SCatalogReq* pCatalogReq) {
+static int32_t parseQuerySyntax(SParseContext* pCxt, SQuery** pQuery, struct SCatalogReq* pCatalogReq) {
   SParseMetaCache metaCache = {0};
-  int32_t         code = nodesAcquireAllocator(pCxt->allocatorId);
+  int32_t         code = parseSqlSyntax(pCxt, pQuery, &metaCache);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = buildCatalogReq(&metaCache, pCatalogReq);
+  }
+  destoryParseMetaCache(&metaCache, true);
+  return code;
+}
+
+int32_t qParseSqlSyntax(SParseContext* pCxt, SQuery** pQuery, struct SCatalogReq* pCatalogReq) {
+  int32_t code = nodesAcquireAllocator(pCxt->allocatorId);
   if (TSDB_CODE_SUCCESS == code) {
     if (qIsInsertValuesSql(pCxt->pSql, pCxt->sqlLen)) {
-      code = parseInsertSyntax(pCxt, pQuery, &metaCache);
+      code = parseInsertSql(pCxt, pQuery, pCatalogReq, NULL);
     } else {
-      code = parseSqlSyntax(pCxt, pQuery, &metaCache);
+      code = parseQuerySyntax(pCxt, pQuery, pCatalogReq);
     }
   }
-  if (TSDB_CODE_SUCCESS == code) {
-    code = buildCatalogReq(pCxt, &metaCache, pCatalogReq);
-  }
   nodesReleaseAllocator(pCxt->allocatorId);
-  destoryParseMetaCache(&metaCache, true);
   terrno = code;
   return code;
 }
@@ -199,14 +204,10 @@ int32_t qAnalyseSqlSemantic(SParseContext* pCxt, const struct SCatalogReq* pCata
   SParseMetaCache metaCache = {0};
   int32_t         code = nodesAcquireAllocator(pCxt->allocatorId);
   if (TSDB_CODE_SUCCESS == code) {
-    code = putMetaDataToCache(pCatalogReq, pMetaData, &metaCache, NULL == pQuery->pRoot);
+    code = putMetaDataToCache(pCatalogReq, pMetaData, &metaCache);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    if (NULL == pQuery->pRoot) {
+    code = analyseSemantic(pCxt, pQuery, &metaCache);
-      code = parseInsertSql(pCxt, &pQuery, &metaCache);
-    } else {
-      code = analyseSemantic(pCxt, pQuery, &metaCache);
-    }
   }
   nodesReleaseAllocator(pCxt->allocatorId);
   destoryParseMetaCache(&metaCache, false);
@@ -214,6 +215,11 @@ int32_t qAnalyseSqlSemantic(SParseContext* pCxt, const struct SCatalogReq* pCata
   return code;
 }
 
+int32_t qContinueParseSql(SParseContext* pCxt, struct SCatalogReq* pCatalogReq, const struct SMetaData* pMetaData,
+                          SQuery* pQuery) {
+  return parseInsertSql(pCxt, &pQuery, pCatalogReq, pMetaData);
+}
+
 void qDestroyParseContext(SParseContext* pCxt) {
   if (NULL == pCxt) {
     return;

source/libs/parser/test/mockCatalog.cpp

@@ -228,11 +228,21 @@ int32_t __catalogGetTableMeta(struct SCatalog* pCatalog, SRequestConnInfo* pConn
   return g_mockCatalogService->catalogGetTableMeta(pTableName, pTableMeta);
 }
 
+int32_t __catalogGetCachedTableMeta(SCatalog* pCtg, const SName* pTableName, STableMeta** pTableMeta) {
+  return g_mockCatalogService->catalogGetTableMeta(pTableName, pTableMeta, true);
+}
+
 int32_t __catalogGetTableHashVgroup(struct SCatalog* pCatalog, SRequestConnInfo* pConn, const SName* pTableName,
                                     SVgroupInfo* vgInfo) {
   return g_mockCatalogService->catalogGetTableHashVgroup(pTableName, vgInfo);
 }
 
+int32_t __catalogGetCachedTableHashVgroup(SCatalog* pCtg, const SName* pTableName, SVgroupInfo* pVgroup, bool* exists) {
+  int32_t code = g_mockCatalogService->catalogGetTableHashVgroup(pTableName, pVgroup, true);
+  *exists = 0 != pVgroup->vgId;
+  return code;
+}
+
 int32_t __catalogGetTableDistVgInfo(SCatalog* pCtg, SRequestConnInfo* pConn, const SName* pTableName,
                                     SArray** pVgList) {
   return g_mockCatalogService->catalogGetTableDistVgInfo(pTableName, pVgList);
@@ -257,6 +267,13 @@ int32_t __catalogChkAuth(SCatalog* pCtg, SRequestConnInfo* pConn, const char* us
   return 0;
 }
 
+int32_t __catalogChkAuthFromCache(SCatalog* pCtg, const char* user, const char* dbFName, AUTH_TYPE type, bool* pass,
+                                  bool* exists) {
+  *pass = true;
+  *exists = true;
+  return 0;
+}
+
 int32_t __catalogGetUdfInfo(SCatalog* pCtg, SRequestConnInfo* pConn, const char* funcName, SFuncInfo* pInfo) {
   return g_mockCatalogService->catalogGetUdfInfo(funcName, pInfo);
 }
@@ -289,13 +306,17 @@ void initMetaDataEnv() {
   static Stub stub;
   stub.set(catalogGetHandle, __catalogGetHandle);
   stub.set(catalogGetTableMeta, __catalogGetTableMeta);
+  stub.set(catalogGetCachedTableMeta, __catalogGetCachedTableMeta);
   stub.set(catalogGetSTableMeta, __catalogGetTableMeta);
+  stub.set(catalogGetCachedSTableMeta, __catalogGetCachedTableMeta);
   stub.set(catalogGetTableHashVgroup, __catalogGetTableHashVgroup);
+  stub.set(catalogGetCachedTableHashVgroup, __catalogGetCachedTableHashVgroup);
   stub.set(catalogGetTableDistVgInfo, __catalogGetTableDistVgInfo);
   stub.set(catalogGetDBVgVersion, __catalogGetDBVgVersion);
   stub.set(catalogGetDBVgList, __catalogGetDBVgList);
   stub.set(catalogGetDBCfg, __catalogGetDBCfg);
   stub.set(catalogChkAuth, __catalogChkAuth);
+  stub.set(catalogChkAuthFromCache, __catalogChkAuthFromCache);
   stub.set(catalogGetUdfInfo, __catalogGetUdfInfo);
   stub.set(catalogRefreshGetTableMeta, __catalogRefreshGetTableMeta);
   stub.set(catalogRemoveTableMeta, __catalogRemoveTableMeta);

source/libs/parser/test/mockCatalogService.cpp

@@ -91,7 +91,7 @@ class MockCatalogServiceImpl {
  public:
   static const int32_t numOfDataTypes = sizeof(tDataTypes) / sizeof(tDataTypes[0]);
 
-  MockCatalogServiceImpl() : id_(1) {}
+  MockCatalogServiceImpl() : id_(1), havaCache_(true) {}
 
   ~MockCatalogServiceImpl() {
     for (auto& cfg : dbCfg_) {
@@ -106,7 +106,11 @@ class MockCatalogServiceImpl {
 
   int32_t catalogGetHandle() const { return 0; }
 
-  int32_t catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta) const {
+  int32_t catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta, bool onlyCache = false) const {
+    if (onlyCache && !havaCache_) {
+      return TSDB_CODE_SUCCESS;
+    }
+
     std::unique_ptr<STableMeta> table;
 
     char db[TSDB_DB_NAME_LEN] = {0};
@@ -121,7 +125,12 @@ class MockCatalogServiceImpl {
     return TSDB_CODE_SUCCESS;
   }
 
-  int32_t catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo) const {
+  int32_t catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo, bool onlyCache = false) const {
+    if (onlyCache && !havaCache_) {
+      vgInfo->vgId = 0;
+      return TSDB_CODE_SUCCESS;
+    }
+
     vgInfo->vgId = 1;
     return TSDB_CODE_SUCCESS;
   }
@@ -618,6 +627,7 @@ class MockCatalogServiceImpl {
   IndexMetaCache                index_;
   DnodeCache                    dnode_;
   DbCfgCache                    dbCfg_;
+  bool                          havaCache_;
 };
 
 MockCatalogService::MockCatalogService() : impl_(new MockCatalogServiceImpl()) {}
@@ -651,12 +661,14 @@ void MockCatalogService::createDatabase(const std::string& db, bool rollup, int8
   impl_->createDatabase(db, rollup, cacheLast);
 }
 
-int32_t MockCatalogService::catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta) const {
+int32_t MockCatalogService::catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta,
-  return impl_->catalogGetTableMeta(pTableName, pTableMeta);
+                                                bool onlyCache) const {
+  return impl_->catalogGetTableMeta(pTableName, pTableMeta, onlyCache);
 }
 
-int32_t MockCatalogService::catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo) const {
+int32_t MockCatalogService::catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo,
-  return impl_->catalogGetTableHashVgroup(pTableName, vgInfo);
+                                                      bool onlyCache) const {
+  return impl_->catalogGetTableHashVgroup(pTableName, vgInfo, onlyCache);
 }
 
 int32_t MockCatalogService::catalogGetTableDistVgInfo(const SName* pTableName, SArray** pVgList) const {

source/libs/parser/test/mockCatalogService.h

@@ -67,8 +67,8 @@ class MockCatalogService {
   void createDnode(int32_t dnodeId, const std::string& host, int16_t port);
   void createDatabase(const std::string& db, bool rollup = false, int8_t cacheLast = 0);
 
-  int32_t catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta) const;
+  int32_t catalogGetTableMeta(const SName* pTableName, STableMeta** pTableMeta, bool onlyCache = false) const;
-  int32_t catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo) const;
+  int32_t catalogGetTableHashVgroup(const SName* pTableName, SVgroupInfo* vgInfo, bool onlyCache = false) const;
   int32_t catalogGetTableDistVgInfo(const SName* pTableName, SArray** pVgList) const;
   int32_t catalogGetDBVgList(const char* pDbFName, SArray** pVgList) const;
   int32_t catalogGetDBCfg(const char* pDbFName, SDbCfgInfo* pDbCfg) const;

source/libs/parser/test/parTestUtil.cpp

@@ -233,16 +233,15 @@ class ParserTestBaseImpl {
   }
 
   void doBuildCatalogReq(SParseContext* pCxt, const SParseMetaCache* pMetaCache, SCatalogReq* pCatalogReq) {
-    DO_WITH_THROW(buildCatalogReq, pCxt, pMetaCache, pCatalogReq);
+    DO_WITH_THROW(buildCatalogReq, pMetaCache, pCatalogReq);
   }
 
   void doGetAllMeta(const SCatalogReq* pCatalogReq, SMetaData* pMetaData) {
     DO_WITH_THROW(g_mockCatalogService->catalogGetAllMeta, pCatalogReq, pMetaData);
   }
 
-  void doPutMetaDataToCache(const SCatalogReq* pCatalogReq, const SMetaData* pMetaData, SParseMetaCache* pMetaCache,
+  void doPutMetaDataToCache(const SCatalogReq* pCatalogReq, const SMetaData* pMetaData, SParseMetaCache* pMetaCache) {
-                            bool isInsertValues) {
+    DO_WITH_THROW(putMetaDataToCache, pCatalogReq, pMetaData, pMetaCache);
-    DO_WITH_THROW(putMetaDataToCache, pCatalogReq, pMetaData, pMetaCache, isInsertValues);
   }
 
   void doAuthenticate(SParseContext* pCxt, SQuery* pQuery, SParseMetaCache* pMetaCache) {
@@ -280,15 +279,14 @@ class ParserTestBaseImpl {
     res_.calcConstAst_ = toString(pQuery->pRoot);
   }
 
-  void doParseInsertSql(SParseContext* pCxt, SQuery** pQuery, SParseMetaCache* pMetaCache) {
+  void doParseInsertSql(SParseContext* pCxt, SQuery** pQuery, SCatalogReq* pCatalogReq, const SMetaData* pMetaData) {
-    DO_WITH_THROW(parseInsertSql, pCxt, pQuery, pMetaCache);
+    DO_WITH_THROW(parseInsertSql, pCxt, pQuery, pCatalogReq, pMetaData);
     ASSERT_NE(*pQuery, nullptr);
     res_.parsedAst_ = toString((*pQuery)->pRoot);
   }
 
-  void doParseInsertSyntax(SParseContext* pCxt, SQuery** pQuery, SParseMetaCache* pMetaCache) {
+  void doContinueParseSql(SParseContext* pCxt, SCatalogReq* pCatalogReq, const SMetaData* pMetaData, SQuery* pQuery) {
-    DO_WITH_THROW(parseInsertSyntax, pCxt, pQuery, pMetaCache);
+    DO_WITH_THROW(qContinueParseSql, pCxt, pCatalogReq, pMetaData, pQuery);
-    ASSERT_NE(*pQuery, nullptr);
   }
 
   string toString(const SNode* pRoot) {
@@ -314,7 +312,7 @@ class ParserTestBaseImpl {
 
       if (qIsInsertValuesSql(cxt.pSql, cxt.sqlLen)) {
         unique_ptr<SQuery*, void (*)(SQuery**)> query((SQuery**)taosMemoryCalloc(1, sizeof(SQuery*)), destroyQuery);
-        doParseInsertSql(&cxt, query.get(), nullptr);
+        doParseInsertSql(&cxt, query.get(), nullptr, nullptr);
       } else {
         unique_ptr<SQuery*, void (*)(SQuery**)> query((SQuery**)taosMemoryCalloc(1, sizeof(SQuery*)), destroyQuery);
         doParse(&cxt, query.get());
@@ -360,61 +358,102 @@ class ParserTestBaseImpl {
     }
   }
 
+  void runQueryAsyncInternalFuncs(SParseContext* pParCxt) {
+    unique_ptr<SQuery*, void (*)(SQuery**)> query((SQuery**)taosMemoryCalloc(1, sizeof(SQuery*)), destroyQuery);
+    bool                                    request = true;
+    unique_ptr<SParseMetaCache, function<void(SParseMetaCache*)> > metaCache(
+        new SParseMetaCache(), bind(destoryParseMetaCacheWarpper, _1, cref(request)));
+    doParse(pParCxt, query.get());
+    doCollectMetaKey(pParCxt, *(query.get()), metaCache.get());
+
+    SQuery* pQuery = *(query.get());
+
+    unique_ptr<SCatalogReq, void (*)(SCatalogReq*)> catalogReq(new SCatalogReq(),
+                                                               MockCatalogService::destoryCatalogReq);
+    doBuildCatalogReq(pParCxt, metaCache.get(), catalogReq.get());
+
+    string err;
+    thread t1([&]() {
+      try {
+        unique_ptr<SMetaData, void (*)(SMetaData*)> metaData(new SMetaData(), MockCatalogService::destoryMetaData);
+        doGetAllMeta(catalogReq.get(), metaData.get());
+
+        metaCache.reset(new SParseMetaCache());
+        request = false;
+        doPutMetaDataToCache(catalogReq.get(), metaData.get(), metaCache.get());
+
+        doAuthenticate(pParCxt, pQuery, metaCache.get());
+
+        doTranslate(pParCxt, pQuery, metaCache.get());
+
+        doCalculateConstant(pParCxt, pQuery);
+      } catch (const TerminateFlag& e) {
+        // success and terminate
+      } catch (const runtime_error& e) {
+        err = e.what();
+      } catch (...) {
+        err = "unknown error";
+      }
+    });
+
+    t1.join();
+    if (!err.empty()) {
+      throw runtime_error(err);
+    }
+  }
+
+  void runInsertAsyncInternalFuncsImpl(SParseContext* pParCxt, SQuery** pQuery, SCatalogReq* pCatalogReq,
+                                       SMetaData* pMetaData) {
+    doParseInsertSql(pParCxt, pQuery, pCatalogReq, pMetaData);
+
+    if (QUERY_EXEC_STAGE_SCHEDULE == (*pQuery)->execStage) {
+      return;
+    }
+
+    string err;
+    thread t1([&]() {
+      try {
+        doGetAllMeta(pCatalogReq, pMetaData);
+
+        doParseInsertSql(pParCxt, pQuery, pCatalogReq, pMetaData);
+
+        if (QUERY_EXEC_STAGE_SCHEDULE != (*pQuery)->execStage) {
+          runInsertAsyncInternalFuncsImpl(pParCxt, pQuery, pCatalogReq, pMetaData);
+        }
+      } catch (const TerminateFlag& e) {
+        // success and terminate
+      } catch (const runtime_error& e) {
+        err = e.what();
+      } catch (...) {
+        err = "unknown error";
+      }
+    });
+
+    t1.join();
+    if (!err.empty()) {
+      throw runtime_error(err);
+    }
+  }
+
+  void runInsertAsyncInternalFuncs(SParseContext* pParCxt) {
+    unique_ptr<SQuery*, void (*)(SQuery**)>         query((SQuery**)taosMemoryCalloc(1, sizeof(SQuery*)), destroyQuery);
+    unique_ptr<SCatalogReq, void (*)(SCatalogReq*)> catalogReq(new SCatalogReq(),
+                                                               MockCatalogService::destoryCatalogReq);
+    unique_ptr<SMetaData, void (*)(SMetaData*)>     metaData(new SMetaData(), MockCatalogService::destoryMetaData);
+    runInsertAsyncInternalFuncsImpl(pParCxt, query.get(), catalogReq.get(), metaData.get());
+  }
+
   void runAsyncInternalFuncs(const string& sql, int32_t expect, ParserStage checkStage) {
     reset(expect, checkStage, TEST_INTERFACE_ASYNC_INTERNAL);
     try {
       unique_ptr<SParseContext, function<void(SParseContext*)> > cxt(new SParseContext(), destoryParseContext);
       setParseContext(sql, cxt.get(), true);
 
-      unique_ptr<SQuery*, void (*)(SQuery**)> query((SQuery**)taosMemoryCalloc(1, sizeof(SQuery*)), destroyQuery);
-      bool                                    request = true;
-      unique_ptr<SParseMetaCache, function<void(SParseMetaCache*)> > metaCache(
-          new SParseMetaCache(), bind(destoryParseMetaCacheWarpper, _1, cref(request)));
       bool isInsertValues = qIsInsertValuesSql(cxt->pSql, cxt->sqlLen);
       if (isInsertValues) {
-        doParseInsertSyntax(cxt.get(), query.get(), metaCache.get());
+        runInsertAsyncInternalFuncs(cxt.get());
       } else {
-        doParse(cxt.get(), query.get());
+        runQueryAsyncInternalFuncs(cxt.get());
-        doCollectMetaKey(cxt.get(), *(query.get()), metaCache.get());
-      }
-
-      SQuery* pQuery = *(query.get());
-
-      unique_ptr<SCatalogReq, void (*)(SCatalogReq*)> catalogReq(new SCatalogReq(),
-                                                                 MockCatalogService::destoryCatalogReq);
-      doBuildCatalogReq(cxt.get(), metaCache.get(), catalogReq.get());
-
-      string err;
-      thread t1([&]() {
-        try {
-          unique_ptr<SMetaData, void (*)(SMetaData*)> metaData(new SMetaData(), MockCatalogService::destoryMetaData);
-          doGetAllMeta(catalogReq.get(), metaData.get());
-
-          metaCache.reset(new SParseMetaCache());
-          request = false;
-          doPutMetaDataToCache(catalogReq.get(), metaData.get(), metaCache.get(), isInsertValues);
-
-          if (isInsertValues) {
-            doParseInsertSql(cxt.get(), query.get(), metaCache.get());
-          } else {
-            doAuthenticate(cxt.get(), pQuery, metaCache.get());
-
-            doTranslate(cxt.get(), pQuery, metaCache.get());
-
-            doCalculateConstant(cxt.get(), pQuery);
-          }
-        } catch (const TerminateFlag& e) {
-          // success and terminate
-        } catch (const runtime_error& e) {
-          err = e.what();
-        } catch (...) {
-          err = "unknown error";
-        }
-      });
-
-      t1.join();
-      if (!err.empty()) {
-        throw runtime_error(err);
       }
 
       if (g_dump) {
@@ -441,25 +480,39 @@ class ParserTestBaseImpl {
       doParseSqlSyntax(cxt.get(), query.get(), catalogReq.get());
       SQuery* pQuery = *(query.get());
 
-      string err;
+      switch (pQuery->execStage) {
-      thread t1([&]() {
+        case QUERY_EXEC_STAGE_PARSE:
-        try {
+        case QUERY_EXEC_STAGE_ANALYSE: {
-          unique_ptr<SMetaData, void (*)(SMetaData*)> metaData(new SMetaData(), MockCatalogService::destoryMetaData);
+          string err;
-          doGetAllMeta(catalogReq.get(), metaData.get());
+          thread t1([&]() {
+            try {
+              unique_ptr<SMetaData, void (*)(SMetaData*)> metaData(new SMetaData(),
+                                                                   MockCatalogService::destoryMetaData);
+              doGetAllMeta(catalogReq.get(), metaData.get());
+              if (QUERY_EXEC_STAGE_PARSE == pQuery->execStage) {
+                doContinueParseSql(cxt.get(), catalogReq.get(), metaData.get(), pQuery);
+              } else {
+                doAnalyseSqlSemantic(cxt.get(), catalogReq.get(), metaData.get(), pQuery);
+              }
+            } catch (const TerminateFlag& e) {
+              // success and terminate
+            } catch (const runtime_error& e) {
+              err = e.what();
+            } catch (...) {
+              err = "unknown error";
+            }
+          });
 
-          doAnalyseSqlSemantic(cxt.get(), catalogReq.get(), metaData.get(), pQuery);
+          t1.join();
-        } catch (const TerminateFlag& e) {
+          if (!err.empty()) {
-          // success and terminate
+            throw runtime_error(err);
-        } catch (const runtime_error& e) {
+          }
-          err = e.what();
+          break;
-        } catch (...) {
-          err = "unknown error";
         }
-      });
+        case QUERY_EXEC_STAGE_SCHEDULE:
-
+          break;
-      t1.join();
+        default:
-      if (!err.empty()) {
+          break;
-        throw runtime_error(err);
       }
 
       if (g_dump) {

source/libs/qworker/src/qwMsg.c

@@ -8,6 +8,7 @@
 #include "tcommon.h"
 #include "tmsg.h"
 #include "tname.h"
+#include "tgrant.h"
 
 int32_t qwMallocFetchRsp(int8_t rpcMalloc, int32_t length, SRetrieveTableRsp **rsp) {
   int32_t msgSize = sizeof(SRetrieveTableRsp) + length;
@@ -305,7 +306,7 @@ int32_t qwRegisterHbBrokenLinkArg(SQWorker *mgmt, uint64_t sId, SRpcHandleInfo *
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg) {
+int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg, bool chkGrant) {
   if (NULL == qWorkerMgmt || NULL == pMsg) {
     QW_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
   }
@@ -326,6 +327,12 @@ int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg) {
   msg->execId = ntohl(msg->execId);
   msg->phyLen = ntohl(msg->phyLen);
   msg->sqlLen = ntohl(msg->sqlLen);
+  msg->msgMask = ntohl(msg->msgMask);
+
+  if (chkGrant && (!TEST_SHOW_REWRITE_MASK(msg->msgMask)) && (grantCheck(TSDB_GRANT_TIME) != TSDB_CODE_SUCCESS)) {
+    QW_ELOG("query failed cause of grant expired, msgMask:%d", msg->msgMask);
+    QW_ERR_RET(TSDB_CODE_GRANT_EXPIRED);
+  }
 
   uint64_t sId = msg->sId;
   uint64_t qId = msg->queryId;

source/libs/scalar/src/filter.c

@@ -3994,9 +3994,12 @@ int32_t filterSetDataFromColId(SFilterInfo *info, void *param) {
 }
 
 int32_t filterInitFromNode(SNode *pNode, SFilterInfo **pInfo, uint32_t options) {
-  int32_t      code = 0;
   SFilterInfo *info = NULL;
+  if (pNode == NULL) {
+    return TSDB_CODE_SUCCESS;
+  }
 
+  int32_t code = 0;
   if (pNode == NULL || pInfo == NULL) {
     fltError("invalid param");
     FLT_ERR_RET(TSDB_CODE_QRY_APP_ERROR);
@@ -4034,9 +4037,7 @@ int32_t filterInitFromNode(SNode *pNode, SFilterInfo **pInfo, uint32_t options)
 _return:
 
   filterFreeInfo(*pInfo);
-
   *pInfo = NULL;
-
   FLT_RET(code);
 }
 

source/libs/scheduler/src/schRemote.c

@@ -1047,7 +1047,6 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
 
       SSubQueryMsg *pMsg = msg;
       pMsg->header.vgId = htonl(addr->nodeId);
-      pMsg->header.msgMask = htonl((pTask->plan->showRewrite) ? SHOW_REWRITE_MASK() : 0);
       pMsg->sId = htobe64(schMgmt.sId);
       pMsg->queryId = htobe64(pJob->queryId);
       pMsg->taskId = htobe64(pTask->taskId);
@@ -1058,6 +1057,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
       pMsg->needFetch = SCH_TASK_NEED_FETCH(pTask);
       pMsg->phyLen = htonl(pTask->msgLen);
       pMsg->sqlLen = htonl(len);
+      pMsg->msgMask = htonl((pTask->plan->showRewrite) ? QUERY_MSG_MASK_SHOW_REWRITE() : 0);
 
       memcpy(pMsg->msg, pJob->sql, len);
       memcpy(pMsg->msg + len, pTask->msg, pTask->msgLen);
@@ -1157,6 +1157,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr,
       SCH_ERR_RET(schAppendTaskExecNode(pJob, pTask, addr, pTask->execId));
     }
   } else {
+    taosMemoryFree(msg);
     SCH_ERR_RET(schProcessOnTaskSuccess(pJob, pTask));
   }
 #endif

source/libs/sync/src/syncMain.c

@@ -420,16 +420,22 @@ bool syncIsReadyForRead(int64_t rid) {
 
   bool ready = false;
   if (pSyncNode->state == TAOS_SYNC_STATE_LEADER && !pSyncNode->restoreFinish) {
-    if (!pSyncNode->pLogStore->syncLogIsEmpty(pSyncNode->pLogStore)) {
+    if (!pSyncNode->pFsm->FpApplyQueueEmptyCb(pSyncNode->pFsm)) {
-      SSyncRaftEntry* pEntry = NULL;
+      // apply queue not empty
-      int32_t         code = pSyncNode->pLogStore->syncLogGetEntry(
+      ready = false;
-                  pSyncNode->pLogStore, pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore), &pEntry);
-      if (code == 0 && pEntry != NULL) {
-        if (pEntry->originalRpcType == TDMT_SYNC_NOOP && pEntry->term == pSyncNode->pRaftStore->currentTerm) {
-          ready = true;
-        }
 
-        syncEntryDestory(pEntry);
+    } else {
+      if (!pSyncNode->pLogStore->syncLogIsEmpty(pSyncNode->pLogStore)) {
+        SSyncRaftEntry* pEntry = NULL;
+        int32_t         code = pSyncNode->pLogStore->syncLogGetEntry(
+            pSyncNode->pLogStore, pSyncNode->pLogStore->syncLogLastIndex(pSyncNode->pLogStore), &pEntry);
+        if (code == 0 && pEntry != NULL) {
+          if (pEntry->originalRpcType == TDMT_SYNC_NOOP && pEntry->term == pSyncNode->pRaftStore->currentTerm) {
+            ready = true;
+          }
+
+          syncEntryDestory(pEntry);
+        }
       }
     }
   }

source/libs/sync/src/syncRaftEntry.c

@@ -72,7 +72,6 @@ SSyncRaftEntry* syncEntryBuildNoop(SyncTerm term, SyncIndex index, int32_t vgId)
   SMsgHead head;
   head.vgId = vgId;
   head.contLen = sizeof(SMsgHead);
-  head.msgMask = 0;
   SRpcMsg rpcMsg;
   memset(&rpcMsg, 0, sizeof(SRpcMsg));
   rpcMsg.contLen = head.contLen;

tests/system-test/1-insert/delete_data.py

@@ -1,312 +1,313 @@
-###################################################################
+
-#           Copyright (c) 2016 by TAOS Technologies, Inc.
+###################################################################
-#                     All rights reserved.
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
-#
+#                     All rights reserved.
-#  This file is proprietary and confidential to TAOS Technologies.
+#
-#  No part of this file may be reproduced, stored, transmitted,
+#  This file is proprietary and confidential to TAOS Technologies.
-#  disclosed or used in any form or by any means other than as
+#  No part of this file may be reproduced, stored, transmitted,
-#  expressly provided by the written permission from Jianhui Tao
+#  disclosed or used in any form or by any means other than as
-#
+#  expressly provided by the written permission from Jianhui Tao
-###################################################################
+#
-
+###################################################################
-# -*- coding: utf-8 -*-
+
-
+# -*- coding: utf-8 -*-
-import random
+
-import string
+import random
-
+import string
-from numpy import logspace
+
-from util import constant
+from numpy import logspace
-from util.log import *
+from util import constant
-from util.cases import *
+from util.log import *
-from util.sql import *
+from util.cases import *
-from util.common import *
+from util.sql import *
-from util.sqlset import TDSetSql
+from util.common import *
-
+from util.sqlset import TDSetSql
-class TDTestCase:
+
-    def init(self, conn, logSql, replicaVar=1):
+class TDTestCase:
-        self.replicaVar = int(replicaVar)
+    def init(self, conn, logSql, replicaVar=1):
-        tdLog.debug("start to execute %s" % __file__)
+        self.replicaVar = int(replicaVar)
-        tdSql.init(conn.cursor(), True)
+        tdLog.debug("start to execute %s" % __file__)
-        self.dbname = 'db_test'
+        tdSql.init(conn.cursor(), True)
-        self.setsql = TDSetSql()
+        self.dbname = 'db_test'
-        self.stbname = 'stb'
+        self.setsql = TDSetSql()
-        self.ntbname = 'ntb'
+        self.stbname = 'stb'
-        self.rowNum = 10
+        self.ntbname = 'ntb'
-        self.tbnum = 3
+        self.rowNum = 10
-        self.ts = 1537146000000
+        self.tbnum = 3
-        self.binary_str = 'taosdata'
+        self.ts = 1537146000000
-        self.nchar_str = '涛思数据'
+        self.binary_str = 'taosdata'
-        self.str_length = 20
+        self.nchar_str = '涛思数据'
-        self.column_dict = {
+        self.str_length = 20
-            'col1': 'tinyint',
+        self.column_dict = {
-            'col2': 'smallint',
+            'col1': 'tinyint',
-            'col3': 'int',
+            'col2': 'smallint',
-            'col4': 'bigint',
+            'col3': 'int',
-            'col5': 'tinyint unsigned',
+            'col4': 'bigint',
-            'col6': 'smallint unsigned',
+            'col5': 'tinyint unsigned',
-            'col7': 'int unsigned',
+            'col6': 'smallint unsigned',
-            'col8': 'bigint unsigned',
+            'col7': 'int unsigned',
-            'col9': 'float',
+            'col8': 'bigint unsigned',
-            'col10': 'double',
+            'col9': 'float',
-            'col11': 'bool',
+            'col10': 'double',
-            'col12': f'binary({self.str_length})',
+            'col11': 'bool',
-            'col13': f'nchar({self.str_length})',
+            'col12': f'binary({self.str_length})',
-
+            'col13': f'nchar({self.str_length})',
-        }
+
-
+        }
-        self.tinyint_val = random.randint(constant.TINYINT_MIN,constant.TINYINT_MAX)
+
-        self.smallint_val = random.randint(constant.SMALLINT_MIN,constant.SMALLINT_MAX)
+        self.tinyint_val = random.randint(constant.TINYINT_MIN,constant.TINYINT_MAX)
-        self.int_val = random.randint(constant.INT_MIN,constant.INT_MAX)
+        self.smallint_val = random.randint(constant.SMALLINT_MIN,constant.SMALLINT_MAX)
-        self.bigint_val = random.randint(constant.BIGINT_MIN,constant.BIGINT_MAX)
+        self.int_val = random.randint(constant.INT_MIN,constant.INT_MAX)
-        self.untingint_val = random.randint(constant.TINYINT_UN_MIN,constant.TINYINT_UN_MAX)
+        self.bigint_val = random.randint(constant.BIGINT_MIN,constant.BIGINT_MAX)
-        self.unsmallint_val = random.randint(constant.SMALLINT_UN_MIN,constant.SMALLINT_UN_MAX)
+        self.untingint_val = random.randint(constant.TINYINT_UN_MIN,constant.TINYINT_UN_MAX)
-        self.unint_val = random.randint(constant.INT_UN_MIN,constant.INT_MAX)
+        self.unsmallint_val = random.randint(constant.SMALLINT_UN_MIN,constant.SMALLINT_UN_MAX)
-        self.unbigint_val = random.randint(constant.BIGINT_UN_MIN,constant.BIGINT_UN_MAX)
+        self.unint_val = random.randint(constant.INT_UN_MIN,constant.INT_MAX)
-        self.float_val = random.uniform(constant.FLOAT_MIN,constant.FLOAT_MAX)
+        self.unbigint_val = random.randint(constant.BIGINT_UN_MIN,constant.BIGINT_UN_MAX)
-        self.double_val = random.uniform(constant.DOUBLE_MIN*(1E-300),constant.DOUBLE_MAX*(1E-300))
+        self.float_val = random.uniform(constant.FLOAT_MIN,constant.FLOAT_MAX)
-        self.bool_val = random.randint(0,100)%2
+        self.double_val = random.uniform(constant.DOUBLE_MIN*(1E-300),constant.DOUBLE_MAX*(1E-300))
-        self.binary_val = tdCom.getLongName(random.randint(0,self.str_length))
+        self.bool_val = random.randint(0,100)%2
-        self.nchar_val = tdCom.getLongName(random.randint(0,self.str_length))
+        self.binary_val = tdCom.getLongName(random.randint(0,self.str_length))
-        self.base_data = {
+        self.nchar_val = tdCom.getLongName(random.randint(0,self.str_length))
-            'tinyint':self.tinyint_val,
+        self.base_data = {
-            'smallint':self.smallint_val,
+            'tinyint':self.tinyint_val,
-            'int':self.int_val,
+            'smallint':self.smallint_val,
-            'bigint':self.bigint_val,
+            'int':self.int_val,
-            'tinyint unsigned':self.untingint_val,
+            'bigint':self.bigint_val,
-            'smallint unsigned':self.unsmallint_val,
+            'tinyint unsigned':self.untingint_val,
-            'int unsigned':self.unint_val,
+            'smallint unsigned':self.unsmallint_val,
-            'bigint unsigned':self.unbigint_val,
+            'int unsigned':self.unint_val,
-            'bool':self.bool_val,
+            'bigint unsigned':self.unbigint_val,
-            'float':self.float_val,
+            'bool':self.bool_val,
-            'double':self.double_val,
+            'float':self.float_val,
-            'binary':self.binary_val,
+            'double':self.double_val,
-            'nchar':self.nchar_val
+            'binary':self.binary_val,
-                    }
+            'nchar':self.nchar_val
-        
+                    }
-    def insert_base_data(self,col_type,tbname,rows,base_data):
+        
-        for i in range(rows):
+    def insert_base_data(self,col_type,tbname,rows,base_data):
-            if col_type.lower() == 'tinyint':
+        for i in range(rows):
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["tinyint"]})')
+            if col_type.lower() == 'tinyint':
-            elif col_type.lower() == 'smallint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["tinyint"]})')
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["smallint"]})')
+            elif col_type.lower() == 'smallint':
-            elif col_type.lower() == 'int':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["smallint"]})')
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["int"]})')
+            elif col_type.lower() == 'int':
-            elif col_type.lower() == 'bigint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["int"]})')
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bigint"]})')
+            elif col_type.lower() == 'bigint':
-            elif col_type.lower() == 'tinyint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bigint"]})')
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["tinyint unsigned"]})')
+            elif col_type.lower() == 'tinyint unsigned':
-            elif col_type.lower() == 'smallint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["tinyint unsigned"]})')
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["smallint unsigned"]})')
+            elif col_type.lower() == 'smallint unsigned':
-            elif col_type.lower() == 'int unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["smallint unsigned"]})')
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["int unsigned"]})')
+            elif col_type.lower() == 'int unsigned':
-            elif col_type.lower() == 'bigint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["int unsigned"]})')
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bigint unsigned"]})')
+            elif col_type.lower() == 'bigint unsigned':
-            elif col_type.lower() == 'bool':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bigint unsigned"]})')
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bool"]})')
+            elif col_type.lower() == 'bool':
-            elif col_type.lower() == 'float':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bool"]})')
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["float"]})')
+            elif col_type.lower() == 'float':
-            elif col_type.lower() == 'double':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["float"]})')
-                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["double"]})')
+            elif col_type.lower() == 'double':
-            elif 'binary' in col_type.lower():
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["double"]})')
-                tdSql.execute(f'''insert into {tbname} values({self.ts+i},"{base_data['binary']}")''')
+            elif 'binary' in col_type.lower():
-            elif 'nchar' in col_type.lower():
+                tdSql.execute(f'''insert into {tbname} values({self.ts+i},"{base_data['binary']}")''')
-                tdSql.execute(f'''insert into {tbname} values({self.ts+i},"{base_data['nchar']}")''')
+            elif 'nchar' in col_type.lower():
-    def delete_all_data(self,tbname,col_type,row_num,base_data,dbname,tb_type,tb_num=1,stbname=''):
+                tdSql.execute(f'''insert into {tbname} values({self.ts+i},"{base_data['nchar']}")''')
-        tdSql.query(f'select count(*) from {tbname}')
+    def delete_all_data(self,tbname,col_type,row_num,base_data,dbname,tb_type,tb_num=1,stbname=''):
-        tdSql.execute(f'delete from {tbname}')
+        tdSql.query(f'select count(*) from {tbname}')
-        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute(f'delete from {tbname}')
-        tdSql.execute('reset query cache')
+        tdSql.execute(f'flush database {dbname}')
-        tdSql.query(f'select * from {tbname}')
+        tdSql.execute('reset query cache')
-        tdSql.checkRows(0)
+        tdSql.query(f'select * from {tbname}')
-        if tb_type == 'ntb' or tb_type == 'ctb':
+        tdSql.checkRows(0)
-            if tb_type == 'ctb':
+        if tb_type == 'ntb' or tb_type == 'ctb':
-                tdSql.query(f'select count(*) from {stbname}')
+            if tb_type == 'ctb':
-                if tb_num <= 1:
+                tdSql.query(f'select count(*) from {stbname}')
-                    if len(tdSql.queryResult) != 0:
+                if tb_num <= 1:
-                        tdLog.exit('delete case failure!')
+                    if len(tdSql.queryResult) != 0:
-                else:
+                        tdLog.exit('delete case failure!')
-                    tdSql.checkEqual(tdSql.queryResult[0][0],(tb_num-1)*row_num)
+                else:
-
+                    tdSql.checkEqual(tdSql.queryResult[0][0],(tb_num-1)*row_num)
-            self.insert_base_data(col_type,tbname,row_num,base_data)
+
-        elif tb_type == 'stb':
+            self.insert_base_data(col_type,tbname,row_num,base_data)
-            for i in range(tb_num):
+        elif tb_type == 'stb':
-                self.insert_base_data(col_type,f'{tbname}_{i}',row_num,base_data)
+            for i in range(tb_num):
-        tdSql.execute(f'flush database {dbname}')
+                self.insert_base_data(col_type,f'{tbname}_{i}',row_num,base_data)
-        tdSql.execute('reset query cache')
+        tdSql.execute(f'flush database {dbname}')
-        tdSql.query(f'select * from {tbname}')
+        tdSql.execute('reset query cache')
-        if tb_type == 'ntb' or tb_type == 'ctb':
+        tdSql.query(f'select * from {tbname}')
-            tdSql.checkRows(row_num)
+        if tb_type == 'ntb' or tb_type == 'ctb':
-        elif tb_type =='stb':
+            tdSql.checkRows(row_num)
-            tdSql.checkRows(row_num*tb_num)
+        elif tb_type =='stb':
-    def delete_one_row(self,tbname,column_type,column_name,base_data,row_num,dbname,tb_type,tb_num=1):
+            tdSql.checkRows(row_num*tb_num)
-        tdSql.execute(f'delete from {tbname} where ts={self.ts}')
+    def delete_one_row(self,tbname,column_type,column_name,base_data,row_num,dbname,tb_type,tb_num=1):
-        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute(f'delete from {tbname} where ts={self.ts}')
-        tdSql.execute('reset query cache')
+        tdSql.execute(f'flush database {dbname}')
-        tdSql.query(f'select {column_name} from {tbname}')
+        tdSql.execute('reset query cache')
-        if tb_type == 'ntb' or tb_type == 'ctb':
+        tdSql.query(f'select {column_name} from {tbname}')
-            tdSql.checkRows(row_num-1)
+        if tb_type == 'ntb' or tb_type == 'ctb':
-        elif tb_type == 'stb':
+            tdSql.checkRows(row_num-1)
-            tdSql.checkRows((row_num-1)*tb_num)
+        elif tb_type == 'stb':
-        tdSql.query(f'select {column_name} from {tbname} where ts={self.ts}')
+            tdSql.checkRows((row_num-1)*tb_num)
-        tdSql.checkRows(0)
+        tdSql.query(f'select {column_name} from {tbname} where ts={self.ts}')
-        if tb_type == 'ntb' or tb_type == 'ctb':
+        tdSql.checkRows(0)
-            if 'binary' in column_type.lower():
+        if tb_type == 'ntb' or tb_type == 'ctb':
-                tdSql.execute(f'''insert into {tbname} values({self.ts},"{base_data['binary']}")''')
+            if 'binary' in column_type.lower():
-            elif 'nchar' in column_type.lower():
+                tdSql.execute(f'''insert into {tbname} values({self.ts},"{base_data['binary']}")''')
-                tdSql.execute(f'''insert into {tbname} values({self.ts},"{base_data['nchar']}")''')
+            elif 'nchar' in column_type.lower():
-            else:
+                tdSql.execute(f'''insert into {tbname} values({self.ts},"{base_data['nchar']}")''')
-                tdSql.execute(f'insert into {tbname} values({self.ts},{base_data[column_type]})')
+            else:
-        elif tb_type == 'stb':
+                tdSql.execute(f'insert into {tbname} values({self.ts},{base_data[column_type]})')
-            for i in range(tb_num):
+        elif tb_type == 'stb':
-                if 'binary' in column_type.lower():
+            for i in range(tb_num):
-                    tdSql.execute(f'''insert into {tbname}_{i} values({self.ts},"{base_data['binary']}")''')
+                if 'binary' in column_type.lower():
-                elif 'nchar' in column_type.lower():
+                    tdSql.execute(f'''insert into {tbname}_{i} values({self.ts},"{base_data['binary']}")''')
-                    tdSql.execute(f'''insert into {tbname}_{i} values({self.ts},"{base_data['nchar']}")''')
+                elif 'nchar' in column_type.lower():
-                else:
+                    tdSql.execute(f'''insert into {tbname}_{i} values({self.ts},"{base_data['nchar']}")''')
-                    tdSql.execute(f'insert into {tbname}_{i} values({self.ts},{base_data[column_type]})')
+                else:
-        tdSql.query(f'select {column_name} from {tbname} where ts={self.ts}')
+                    tdSql.execute(f'insert into {tbname}_{i} values({self.ts},{base_data[column_type]})')
-        if column_type.lower() == 'float' or column_type.lower() == 'double':
+        tdSql.query(f'select {column_name} from {tbname} where ts={self.ts}')
-            if abs(tdSql.queryResult[0][0] - base_data[column_type]) / base_data[column_type] <= 0.0001:
+        if column_type.lower() == 'float' or column_type.lower() == 'double':
-                tdSql.checkEqual(tdSql.queryResult[0][0],tdSql.queryResult[0][0])
+            if abs(tdSql.queryResult[0][0] - base_data[column_type]) / base_data[column_type] <= 0.0001:
-            else:
+                tdSql.checkEqual(tdSql.queryResult[0][0],tdSql.queryResult[0][0])
-                tdLog.exit(f'{column_type} data check failure')
+            else:
-        elif 'binary' in column_type.lower():
+                tdLog.exit(f'{column_type} data check failure')
-            tdSql.checkEqual(tdSql.queryResult[0][0],base_data['binary'])
+        elif 'binary' in column_type.lower():
-        elif 'nchar' in column_type.lower():
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data['binary'])
-            tdSql.checkEqual(tdSql.queryResult[0][0],base_data['nchar'])
+        elif 'nchar' in column_type.lower():
-        else:
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data['nchar'])
-            tdSql.checkEqual(tdSql.queryResult[0][0],base_data[column_type])
+        else:
-    def delete_rows(self,dbname,tbname,col_name,col_type,base_data,row_num,tb_type,tb_num=1):
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data[column_type])
-        for i in range(row_num):
+    def delete_rows(self,dbname,tbname,col_name,col_type,base_data,row_num,tb_type,tb_num=1):
-            tdSql.execute(f'delete from {tbname} where ts>{self.ts+i}')
+        for i in range(row_num):
-            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute(f'delete from {tbname} where ts>{self.ts+i}')
-            tdSql.execute('reset query cache')
+            tdSql.execute(f'flush database {dbname}')
-            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.execute('reset query cache')
-            if tb_type == 'ntb' or tb_type == 'ctb':
+            tdSql.query(f'select {col_name} from {tbname}')
-                tdSql.checkRows(i+1)
+            if tb_type == 'ntb' or tb_type == 'ctb':
-                self.insert_base_data(col_type,tbname,row_num,base_data)
+                tdSql.checkRows(i+1)
-            elif tb_type == 'stb':
+                self.insert_base_data(col_type,tbname,row_num,base_data)
-                tdSql.checkRows((i+1)*tb_num)
+            elif tb_type == 'stb':
-                for j in range(tb_num):
+                tdSql.checkRows((i+1)*tb_num)
-                    self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
+                for j in range(tb_num):
-        for i in range(row_num):
+                    self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
-            tdSql.execute(f'delete from {tbname} where ts>={self.ts+i}')
+        for i in range(row_num):
-            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute(f'delete from {tbname} where ts>={self.ts+i}')
-            tdSql.execute('reset query cache')
+            tdSql.execute(f'flush database {dbname}')
-            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.execute('reset query cache')
-            if tb_type == 'ntb' or tb_type == 'ctb':
+            tdSql.query(f'select {col_name} from {tbname}')
-                tdSql.checkRows(i)
+            if tb_type == 'ntb' or tb_type == 'ctb':
-                self.insert_base_data(col_type,tbname,row_num,base_data)
+                tdSql.checkRows(i)
-            elif tb_type == 'stb':
+                self.insert_base_data(col_type,tbname,row_num,base_data)
-                tdSql.checkRows(i*tb_num)
+            elif tb_type == 'stb':
-                for j in range(tb_num):
+                tdSql.checkRows(i*tb_num)
-                    self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
+                for j in range(tb_num):
-        for i in range(row_num):
+                    self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
-            tdSql.execute(f'delete from {tbname} where ts<={self.ts+i}')
+        for i in range(row_num):
-            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute(f'delete from {tbname} where ts<={self.ts+i}')
-            tdSql.execute('reset query cache')
+            tdSql.execute(f'flush database {dbname}')
-            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.execute('reset query cache')
-            if tb_type == 'ntb' or tb_type == 'ctb':
+            tdSql.query(f'select {col_name} from {tbname}')
-                tdSql.checkRows(row_num-i-1)
+            if tb_type == 'ntb' or tb_type == 'ctb':
-                self.insert_base_data(col_type,tbname,row_num,base_data)
+                tdSql.checkRows(row_num-i-1)
-            elif tb_type == 'stb':
+                self.insert_base_data(col_type,tbname,row_num,base_data)
-                tdSql.checkRows((row_num-i-1)*tb_num)
+            elif tb_type == 'stb':
-                for j in range(tb_num):
+                tdSql.checkRows((row_num-i-1)*tb_num)
-                    self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
+                for j in range(tb_num):
-        for i in range(row_num):
+                    self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
-            tdSql.execute(f'delete from {tbname} where ts<{self.ts+i}')
+        for i in range(row_num):
-            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute(f'delete from {tbname} where ts<{self.ts+i}')
-            tdSql.execute('reset query cache')
+            tdSql.execute(f'flush database {dbname}')
-            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.execute('reset query cache')
-            if tb_type == 'ntb' or tb_type == 'ctb':
+            tdSql.query(f'select {col_name} from {tbname}')
-                tdSql.checkRows(row_num-i)
+            if tb_type == 'ntb' or tb_type == 'ctb':
-                self.insert_base_data(col_type,tbname,row_num,base_data)
+                tdSql.checkRows(row_num-i)
-            elif tb_type == 'stb':
+                self.insert_base_data(col_type,tbname,row_num,base_data)
-                tdSql.checkRows((row_num-i)*tb_num)
+            elif tb_type == 'stb':
-                for j in range(tb_num):
+                tdSql.checkRows((row_num-i)*tb_num)
-                    self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
+                for j in range(tb_num):
-        for i in range(row_num):
+                    self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
-            tdSql.execute(f'delete from {tbname} where ts between {self.ts} and {self.ts+i}')
+        for i in range(row_num):
-            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute(f'delete from {tbname} where ts between {self.ts} and {self.ts+i}')
-            tdSql.execute('reset query cache')
+            tdSql.execute(f'flush database {dbname}')
-            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.execute('reset query cache')
-            if tb_type == 'ntb' or tb_type == 'ctb':
+            tdSql.query(f'select {col_name} from {tbname}')
-                tdSql.checkRows(row_num - i-1)
+            if tb_type == 'ntb' or tb_type == 'ctb':
-                self.insert_base_data(col_type,tbname,row_num,base_data)
+                tdSql.checkRows(row_num - i-1)
-            elif tb_type == 'stb':
+                self.insert_base_data(col_type,tbname,row_num,base_data)
-                tdSql.checkRows(tb_num*(row_num - i-1))
+            elif tb_type == 'stb':
-                for j in range(tb_num):
+                tdSql.checkRows(tb_num*(row_num - i-1))
-                    self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
+                for j in range(tb_num):
-            tdSql.execute(f'delete from {tbname} where ts between {self.ts+i+1} and {self.ts}')
+                    self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
-            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.execute(f'delete from {tbname} where ts between {self.ts+i+1} and {self.ts}')
-            if tb_type == 'ntb' or tb_type == 'ctb':
+            tdSql.query(f'select {col_name} from {tbname}')
-                tdSql.checkRows(row_num)
+            if tb_type == 'ntb' or tb_type == 'ctb':
-            elif tb_type == 'stb':
+                tdSql.checkRows(row_num)
-                tdSql.checkRows(tb_num*row_num)
+            elif tb_type == 'stb':
-    def delete_error(self,tbname,column_name,column_type,base_data):
+                tdSql.checkRows(tb_num*row_num)
-        for error_list in ['',f'ts = {self.ts} and',f'ts = {self.ts} or']:
+    def delete_error(self,tbname,column_name,column_type,base_data):
-            if 'binary' in column_type.lower():
+        for error_list in ['',f'ts = {self.ts} and',f'ts = {self.ts} or']:
-                tdSql.error(f'''delete from {tbname} where {error_list} {column_name} ="{base_data['binary']}"''')
+            if 'binary' in column_type.lower():
-            elif 'nchar' in column_type.lower():
+                tdSql.error(f'''delete from {tbname} where {error_list} {column_name} ="{base_data['binary']}"''')
-                tdSql.error(f'''delete from {tbname} where {error_list} {column_name} ="{base_data['nchar']}"''')
+            elif 'nchar' in column_type.lower():
-            else:
+                tdSql.error(f'''delete from {tbname} where {error_list} {column_name} ="{base_data['nchar']}"''')
-                tdSql.error(f'delete from {tbname} where {error_list} {column_name} = {base_data[column_type]}')
+            else:
-
+                tdSql.error(f'delete from {tbname} where {error_list} {column_name} = {base_data[column_type]}')
-    def delete_data_ntb(self):
+
-        tdSql.execute(f'create database if not exists {self.dbname}')
+    def delete_data_ntb(self):
-        tdSql.execute(f'use {self.dbname}')
+        tdSql.execute(f'create database if not exists {self.dbname}')
-        for col_name,col_type in self.column_dict.items():
+        tdSql.execute(f'use {self.dbname}')
-            tdSql.execute(f'create table {self.ntbname} (ts timestamp,{col_name} {col_type})')
+        for col_name,col_type in self.column_dict.items():
-            self.insert_base_data(col_type,self.ntbname,self.rowNum,self.base_data)
+            tdSql.execute(f'create table {self.ntbname} (ts timestamp,{col_name} {col_type})')
-            self.delete_one_row(self.ntbname,col_type,col_name,self.base_data,self.rowNum,self.dbname,'ntb')
+            self.insert_base_data(col_type,self.ntbname,self.rowNum,self.base_data)
-            self.delete_all_data(self.ntbname,col_type,self.rowNum,self.base_data,self.dbname,'ntb')
+            self.delete_one_row(self.ntbname,col_type,col_name,self.base_data,self.rowNum,self.dbname,'ntb')
-            self.delete_error(self.ntbname,col_name,col_type,self.base_data)
+            self.delete_all_data(self.ntbname,col_type,self.rowNum,self.base_data,self.dbname,'ntb')
-            self.delete_rows(self.dbname,self.ntbname,col_name,col_type,self.base_data,self.rowNum,'ntb')
+            self.delete_error(self.ntbname,col_name,col_type,self.base_data)
-            for func in ['first','last']:
+            self.delete_rows(self.dbname,self.ntbname,col_name,col_type,self.base_data,self.rowNum,'ntb')
-                tdSql.query(f'select {func}(*) from {self.ntbname}')
+            for func in ['first','last']:
-            tdSql.execute(f'drop table {self.ntbname}')
+                tdSql.query(f'select {func}(*) from {self.ntbname}')
-        tdSql.execute(f'drop database {self.dbname}')
+            tdSql.execute(f'drop table {self.ntbname}')
-    def delete_data_ctb(self):
+        tdSql.execute(f'drop database {self.dbname}')
-        tdSql.execute(f'create database if not exists {self.dbname}')
+    def delete_data_ctb(self):
-        tdSql.execute(f'use {self.dbname}')
+        tdSql.execute(f'create database if not exists {self.dbname}')
-        for col_name,col_type in self.column_dict.items():
+        tdSql.execute(f'use {self.dbname}')
-            tdSql.execute(f'create table {self.stbname} (ts timestamp,{col_name} {col_type}) tags(t1 int)')
+        for col_name,col_type in self.column_dict.items():
-            for i in range(self.tbnum):
+            tdSql.execute(f'create table {self.stbname} (ts timestamp,{col_name} {col_type}) tags(t1 int)')
-                tdSql.execute(f'create table {self.stbname}_{i} using {self.stbname} tags(1)')
+            for i in range(self.tbnum):
-                self.insert_base_data(col_type,f'{self.stbname}_{i}',self.rowNum,self.base_data)
+                tdSql.execute(f'create table {self.stbname}_{i} using {self.stbname} tags(1)')
-                self.delete_one_row(f'{self.stbname}_{i}',col_type,col_name,self.base_data,self.rowNum,self.dbname,'ctb')
+                self.insert_base_data(col_type,f'{self.stbname}_{i}',self.rowNum,self.base_data)
-                self.delete_all_data(f'{self.stbname}_{i}',col_type,self.rowNum,self.base_data,self.dbname,'ctb',i+1,self.stbname)
+                self.delete_one_row(f'{self.stbname}_{i}',col_type,col_name,self.base_data,self.rowNum,self.dbname,'ctb')
-                self.delete_error(f'{self.stbname}_{i}',col_name,col_type,self.base_data)
+                self.delete_all_data(f'{self.stbname}_{i}',col_type,self.rowNum,self.base_data,self.dbname,'ctb',i+1,self.stbname)
-                self.delete_rows(self.dbname,f'{self.stbname}_{i}',col_name,col_type,self.base_data,self.rowNum,'ctb')
+                self.delete_error(f'{self.stbname}_{i}',col_name,col_type,self.base_data)
-                for func in ['first','last']:
+                self.delete_rows(self.dbname,f'{self.stbname}_{i}',col_name,col_type,self.base_data,self.rowNum,'ctb')
-                    tdSql.query(f'select {func}(*) from {self.stbname}_{i}')
+                for func in ['first','last']:
-            tdSql.execute(f'drop table {self.stbname}')
+                    tdSql.query(f'select {func}(*) from {self.stbname}_{i}')
-    def delete_data_stb(self):
+            tdSql.execute(f'drop table {self.stbname}')
-        tdSql.execute(f'create database if not exists {self.dbname}')
+    def delete_data_stb(self):
-        tdSql.execute(f'use {self.dbname}')
+        tdSql.execute(f'create database if not exists {self.dbname}')
-        for col_name,col_type in self.column_dict.items():
+        tdSql.execute(f'use {self.dbname}')
-            tdSql.execute(f'create table {self.stbname} (ts timestamp,{col_name} {col_type}) tags(t1 int)')
+        for col_name,col_type in self.column_dict.items():
-            for i in range(self.tbnum):
+            tdSql.execute(f'create table {self.stbname} (ts timestamp,{col_name} {col_type}) tags(t1 int)')
-                tdSql.execute(f'create table {self.stbname}_{i} using {self.stbname} tags(1)')
+            for i in range(self.tbnum):
-                self.insert_base_data(col_type,f'{self.stbname}_{i}',self.rowNum,self.base_data)
+                tdSql.execute(f'create table {self.stbname}_{i} using {self.stbname} tags(1)')
-            self.delete_error(self.stbname,col_name,col_type,self.base_data)
+                self.insert_base_data(col_type,f'{self.stbname}_{i}',self.rowNum,self.base_data)
-            self.delete_one_row(self.stbname,col_type,col_name,self.base_data,self.rowNum,self.dbname,'stb',self.tbnum)
+            self.delete_error(self.stbname,col_name,col_type,self.base_data)
-            self.delete_all_data(self.stbname,col_type,self.rowNum,self.base_data,self.dbname,'stb',self.tbnum)
+            self.delete_one_row(self.stbname,col_type,col_name,self.base_data,self.rowNum,self.dbname,'stb',self.tbnum)
-            self.delete_rows(self.dbname,self.stbname,col_name,col_type,self.base_data,self.rowNum,'stb',self.tbnum)
+            self.delete_all_data(self.stbname,col_type,self.rowNum,self.base_data,self.dbname,'stb',self.tbnum)
-            for func in ['first','last']:
+            self.delete_rows(self.dbname,self.stbname,col_name,col_type,self.base_data,self.rowNum,'stb',self.tbnum)
-                tdSql.query(f'select {func}(*) from {self.stbname}')
+            for func in ['first','last']:
-            tdSql.execute(f'drop table {self.stbname}')
+                tdSql.query(f'select {func}(*) from {self.stbname}')
-        tdSql.execute(f'drop database {self.dbname}')
+            tdSql.execute(f'drop table {self.stbname}')
-    def run(self):
+        tdSql.execute(f'drop database {self.dbname}')
-        self.delete_data_ntb()
+    def run(self):
-        self.delete_data_ctb()
+        self.delete_data_ntb()
-        self.delete_data_stb()
+        self.delete_data_ctb()
-        tdDnodes.stoptaosd(1)
+        self.delete_data_stb()
-        tdDnodes.starttaosd(1)
+        tdDnodes.stoptaosd(1)
-        self.delete_data_ntb()
+        tdDnodes.starttaosd(1)
-    def stop(self):
+        self.delete_data_ntb()
-        tdSql.close()
+    def stop(self):
-        tdLog.success("%s successfully executed" % __file__)
+        tdSql.close()
-
+        tdLog.success("%s successfully executed" % __file__)
-tdCases.addWindows(__file__, TDTestCase())
+
-tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/system-test/fulltest.sh

@@ -76,8 +76,8 @@ python3 ./test.py -f 2-query/count_partition.py
 python3 ./test.py -f 2-query/count_partition.py -R
 python3 ./test.py -f 2-query/count.py
 python3 ./test.py -f 2-query/count.py -R
-python3 ./test.py -f 2-query/countAlwaysReturnValue.py
+# python3 ./test.py -f 2-query/countAlwaysReturnValue.py
-python3 ./test.py -f 2-query/countAlwaysReturnValue.py -R
+# python3 ./test.py -f 2-query/countAlwaysReturnValue.py -R
 python3 ./test.py -f 2-query/db.py
 python3 ./test.py -f 2-query/db.py -R
 python3 ./test.py -f 2-query/diff.py
@@ -387,7 +387,7 @@ python3 ./test.py -f 2-query/Today.py -Q 2
 python3 ./test.py -f 2-query/max.py -Q 2
 python3 ./test.py -f 2-query/min.py -Q 2
 python3 ./test.py -f 2-query/count.py -Q 2
-python3 ./test.py -f 2-query/countAlwaysReturnValue.py -Q 2
+# python3 ./test.py -f 2-query/countAlwaysReturnValue.py -Q 2
 python3 ./test.py -f 2-query/last.py -Q 2
 python3 ./test.py -f 2-query/first.py -Q 2
 python3 ./test.py -f 2-query/To_iso8601.py -Q 2
@@ -483,7 +483,7 @@ python3 ./test.py -f 2-query/Today.py -Q  3
 python3 ./test.py -f 2-query/max.py -Q  3
 python3 ./test.py -f 2-query/min.py -Q  3
 python3 ./test.py -f 2-query/count.py -Q  3
-python3 ./test.py -f 2-query/countAlwaysReturnValue.py -Q 3
+# python3 ./test.py -f 2-query/countAlwaysReturnValue.py -Q 3
 python3 ./test.py -f 2-query/last.py -Q  3
 python3 ./test.py -f 2-query/first.py -Q  3
 python3 ./test.py -f 2-query/To_iso8601.py -Q  3
@@ -581,7 +581,7 @@ python3 ./test.py -f 2-query/Today.py -Q  4
 python3 ./test.py -f 2-query/max.py -Q  4
 python3 ./test.py -f 2-query/min.py -Q  4
 python3 ./test.py -f 2-query/count.py -Q  4
-python3 ./test.py -f 2-query/countAlwaysReturnValue.py -Q 4
+# python3 ./test.py -f 2-query/countAlwaysReturnValue.py -Q 4
 python3 ./test.py -f 2-query/last.py -Q  4
 python3 ./test.py -f 2-query/first.py -Q  4
 python3 ./test.py -f 2-query/To_iso8601.py -Q  4