Merge branch '3.0' into fix/TD-16880

examples/c/CMakeLists.txt

@@ -13,9 +13,15 @@ IF (TD_LINUX)
   #TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread lua)
 
   add_executable(tmq "")
+  add_executable(tmq_taosx "")
   add_executable(stream_demo "")
   add_executable(demoapi "")
 
+  target_sources(tmq_taosx
+      PRIVATE
+      "tmq_taosx.c"
+      )
+
   target_sources(tmq
       PRIVATE
       "tmq.c"
@@ -35,6 +41,10 @@ IF (TD_LINUX)
       taos_static
       )
 
+  target_link_libraries(tmq_taosx
+      taos_static
+      )
+
   target_link_libraries(stream_demo
       taos_static
       )
@@ -47,6 +57,10 @@ IF (TD_LINUX)
       PUBLIC "${TD_SOURCE_DIR}/include/os"
       PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
       )
+  target_include_directories(tmq_taosx
+      PUBLIC "${TD_SOURCE_DIR}/include/os"
+      PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+      )
 
   target_include_directories(stream_demo
       PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
@@ -59,6 +73,7 @@ IF (TD_LINUX)
       )
 
   SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)
+  SET_TARGET_PROPERTIES(tmq_taosx PROPERTIES OUTPUT_NAME tmq_taosx)
   SET_TARGET_PROPERTIES(stream_demo PROPERTIES OUTPUT_NAME stream_demo)
   SET_TARGET_PROPERTIES(demoapi PROPERTIES OUTPUT_NAME demoapi)
 ENDIF ()

examples/c/tmq.c

@@ -302,7 +302,7 @@ int32_t create_topic() {
   }
   taos_free_result(pRes);
 
-  /*pRes = taos_query(pConn, "create topic topic_ctb_column with meta as database abc1");*/
+//  pRes = taos_query(pConn, "create topic topic_ctb_column with meta as database abc1");
   pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1, c2, c3 from st1");
   if (taos_errno(pRes) != 0) {
     printf("failed to create topic topic_ctb_column, reason:%s\n", taos_errstr(pRes));

examples/c/tmq_taosx.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "taos.h"
+
+static int  running = 1;
+
+static TAOS* use_db(){
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  if (pConn == NULL) {
+    return NULL;
+  }
+
+  TAOS_RES* pRes = taos_query(pConn, "use db_taosx");
+  if (taos_errno(pRes) != 0) {
+    printf("error in use db_taosx, reason:%s\n", taos_errstr(pRes));
+    return NULL;
+  }
+  taos_free_result(pRes);
+  return pConn;
+}
+
+static void msg_process(TAOS_RES* msg) {
+  /*memset(buf, 0, 1024);*/
+  printf("-----------topic-------------: %s\n", tmq_get_topic_name(msg));
+  printf("db: %s\n", tmq_get_db_name(msg));
+  printf("vg: %d\n", tmq_get_vgroup_id(msg));
+  TAOS *pConn = use_db();
+  if (tmq_get_res_type(msg) == TMQ_RES_TABLE_META) {
+    char* result = tmq_get_json_meta(msg);
+    if (result) {
+      printf("meta result: %s\n", result);
+    }
+    tmq_free_json_meta(result);
+
+
+    tmq_raw_data raw = {0};
+    tmq_get_raw_meta(msg, &raw);
+    int32_t ret = taos_write_raw_meta(pConn, raw);
+    printf("write raw meta: %s\n", tmq_err2str(ret));
+  }
+
+  if(tmq_get_res_type(msg) == TMQ_RES_DATA){
+    int32_t ret =taos_write_raw_data(pConn, msg);
+    printf("write raw data: %s\n", tmq_err2str(ret));
+  }
+  taos_close(pConn);
+}
+
+int32_t init_env() {
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  if (pConn == NULL) {
+    return -1;
+  }
+
+  TAOS_RES* pRes = taos_query(pConn, "drop database if exists db_taosx");
+  if (taos_errno(pRes) != 0) {
+    printf("error in drop db_taosx, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create database if not exists db_taosx vgroups 4");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create db_taosx, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "drop database if exists abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in drop db, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create database if not exists abc1 vgroups 3");
+  if (taos_errno(pRes) != 0) {
+    printf("error in create db, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn,
+                    "create stable if not exists st1 (ts timestamp, c1 int, c2 float, c3 binary(16)) tags(t1 int, t3 "
+                    "nchar(8), t4 bool)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table st1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table if not exists ct0 using st1 tags(1000, \"ttt\", true)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create child table tu1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "insert into ct0 values(now, 1, 2, 'a')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to insert into ct0, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table if not exists ct1 using st1(t1) tags(2000)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create child table ct1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table if not exists ct2 using st1(t1) tags(NULL)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create child table ct2, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "insert into ct1 values(now, 3, 4, 'b')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to insert into ct1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table if not exists ct3 using st1(t1) tags(3000)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create child table ct3, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "insert into ct3 values(now, 5, 6, 'c') ct1 values(now+1s, 2, 3, 'sds') (now+2s, 4, 5, 'ddd') ct0 values(now+1s, 4, 3, 'hwj') ct1 values(now+5s, 23, 32, 's21ds')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to insert into ct3, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "alter table st1 add column c4 bigint");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to alter super table st1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "alter table st1 modify column c3 binary(64)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to alter super table st1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "insert into ct3 values(now+7s, 53, 63, 'cffffffffffffffffffffffffffff', 8989898899999) (now+9s, 51, 62, 'c333', 940)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to insert into ct3, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "alter table st1 add tag t2 binary(64)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to alter super table st1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "alter table ct3 set tag t1=5000");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to slter child table ct3, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+//  pRes = taos_query(pConn, "drop table ct3 ct1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to drop child table ct3, reason:%s\n", taos_errstr(pRes));
+//    return -1;
+//  }
+//  taos_free_result(pRes);
+//
+//  pRes = taos_query(pConn, "drop table st1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to drop super table st1, reason:%s\n", taos_errstr(pRes));
+//    return -1;
+//  }
+//  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table if not exists n1(ts timestamp, c1 int, c2 nchar(4))");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create normal table n1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "alter table n1 add column c3 bigint");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "alter table n1 modify column c2 nchar(8)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "alter table n1 rename column c3 cc3");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "alter table n1 comment 'hello'");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "alter table n1 drop column c1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "insert into n1 values(now, 'eeee', 8989898899999) (now+9s, 'c333', 940)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to insert into n1, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+//  pRes = taos_query(pConn, "drop table n1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to drop normal table n1, reason:%s\n", taos_errstr(pRes));
+//    return -1;
+//  }
+//  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table jt(ts timestamp, i int) tags(t json)");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table jt, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table jt1 using jt tags('{\"k1\":1, \"k2\":\"hello\"}')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table jt, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create table jt2 using jt tags('')");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create super table jt2, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+//  pRes = taos_query(pConn,
+//                    "create stable if not exists st1 (ts timestamp, c1 int, c2 float, c3 binary(16)) tags(t1 int, t3 "
+//                    "nchar(8), t4 bool)");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to create super table st1, reason:%s\n", taos_errstr(pRes));
+//    return -1;
+//  }
+//  taos_free_result(pRes);
+//
+//  pRes = taos_query(pConn, "drop table st1");
+//  if (taos_errno(pRes) != 0) {
+//    printf("failed to drop super table st1, reason:%s\n", taos_errstr(pRes));
+//    return -1;
+//  }
+//  taos_free_result(pRes);
+
+  taos_close(pConn);
+  return 0;
+}
+
+int32_t create_topic() {
+  printf("create topic\n");
+  TAOS_RES* pRes;
+  TAOS*     pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  if (pConn == NULL) {
+    return -1;
+  }
+
+  pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  pRes = taos_query(pConn, "create topic topic_ctb_column with meta as database abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("failed to create topic topic_ctb_column, reason:%s\n", taos_errstr(pRes));
+    return -1;
+  }
+  taos_free_result(pRes);
+
+  taos_close(pConn);
+  return 0;
+}
+
+void tmq_commit_cb_print(tmq_t* tmq, int32_t code, void* param) {
+  printf("commit %d tmq %p param %p\n", code, tmq, param);
+}
+
+tmq_t* build_consumer() {
+#if 0
+  TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
+  assert(pConn != NULL);
+
+  TAOS_RES* pRes = taos_query(pConn, "use abc1");
+  if (taos_errno(pRes) != 0) {
+    printf("error in use db, reason:%s\n", taos_errstr(pRes));
+  }
+  taos_free_result(pRes);
+#endif
+
+  tmq_conf_t* conf = tmq_conf_new();
+  tmq_conf_set(conf, "group.id", "tg2");
+  tmq_conf_set(conf, "client.id", "my app 1");
+  tmq_conf_set(conf, "td.connect.user", "root");
+  tmq_conf_set(conf, "td.connect.pass", "taosdata");
+  tmq_conf_set(conf, "msg.with.table.name", "true");
+  tmq_conf_set(conf, "enable.auto.commit", "true");
+
+  /*tmq_conf_set(conf, "experimental.snapshot.enable", "true");*/
+
+  tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL);
+  tmq_t* tmq = tmq_consumer_new(conf, NULL, 0);
+  assert(tmq);
+  tmq_conf_destroy(conf);
+  return tmq;
+}
+
+tmq_list_t* build_topic_list() {
+  tmq_list_t* topic_list = tmq_list_new();
+  tmq_list_append(topic_list, "topic_ctb_column");
+  /*tmq_list_append(topic_list, "tmq_test_db_multi_insert_topic");*/
+  return topic_list;
+}
+
+void basic_consume_loop(tmq_t* tmq, tmq_list_t* topics) {
+  int32_t code;
+
+  if ((code = tmq_subscribe(tmq, topics))) {
+    fprintf(stderr, "%% Failed to start consuming topics: %s\n", tmq_err2str(code));
+    printf("subscribe err\n");
+    return;
+  }
+  int32_t cnt = 0;
+  while (running) {
+    TAOS_RES* tmqmessage = tmq_consumer_poll(tmq, -1);
+    if (tmqmessage) {
+      cnt++;
+      msg_process(tmqmessage);
+      /*if (cnt >= 2) break;*/
+      /*printf("get data\n");*/
+      taos_free_result(tmqmessage);
+      /*} else {*/
+      /*break;*/
+      /*tmq_commit_sync(tmq, NULL);*/
+    }
+  }
+
+  code = tmq_consumer_close(tmq);
+  if (code)
+    fprintf(stderr, "%% Failed to close consumer: %s\n", tmq_err2str(code));
+  else
+    fprintf(stderr, "%% Consumer closed\n");
+}
+
+void sync_consume_loop(tmq_t* tmq, tmq_list_t* topics) {
+  static const int MIN_COMMIT_COUNT = 1;
+
+  int     msg_count = 0;
+  int32_t code;
+
+  if ((code = tmq_subscribe(tmq, topics))) {
+    fprintf(stderr, "%% Failed to start consuming topics: %s\n", tmq_err2str(code));
+    return;
+  }
+
+  tmq_list_t* subList = NULL;
+  tmq_subscription(tmq, &subList);
+  char**  subTopics = tmq_list_to_c_array(subList);
+  int32_t sz = tmq_list_get_size(subList);
+  printf("subscribed topics: ");
+  for (int32_t i = 0; i < sz; i++) {
+    printf("%s, ", subTopics[i]);
+  }
+  printf("\n");
+  tmq_list_destroy(subList);
+
+  while (running) {
+    TAOS_RES* tmqmessage = tmq_consumer_poll(tmq, 1000);
+    if (tmqmessage) {
+      msg_process(tmqmessage);
+      taos_free_result(tmqmessage);
+
+      /*tmq_commit_sync(tmq, NULL);*/
+      /*if ((++msg_count % MIN_COMMIT_COUNT) == 0) tmq_commit(tmq, NULL, 0);*/
+    }
+  }
+
+  code = tmq_consumer_close(tmq);
+  if (code)
+    fprintf(stderr, "%% Failed to close consumer: %s\n", tmq_err2str(code));
+  else
+    fprintf(stderr, "%% Consumer closed\n");
+}
+
+int main(int argc, char* argv[]) {
+  printf("env init\n");
+  if (init_env() < 0) {
+    return -1;
+  }
+  create_topic();
+
+  tmq_t*      tmq = build_consumer();
+  tmq_list_t* topic_list = build_topic_list();
+  basic_consume_loop(tmq, topic_list);
+  /*sync_consume_loop(tmq, topic_list);*/
+}

include/client/taos.h

@@ -270,6 +270,7 @@ typedef enum tmq_res_t tmq_res_t;
 DLL_EXPORT tmq_res_t     tmq_get_res_type(TAOS_RES *res);
 DLL_EXPORT int32_t       tmq_get_raw_meta(TAOS_RES *res, tmq_raw_data *raw_meta);
 DLL_EXPORT int32_t       taos_write_raw_meta(TAOS *taos, tmq_raw_data raw_meta);
+DLL_EXPORT int32_t       taos_write_raw_data(TAOS *taos, TAOS_RES *res);
 DLL_EXPORT char         *tmq_get_json_meta(TAOS_RES *res);   // Returning null means error. Returned result need to be freed by tmq_free_json_meta
 DLL_EXPORT void          tmq_free_json_meta(char* jsonMeta);
 DLL_EXPORT const char   *tmq_get_topic_name(TAOS_RES *res);

include/common/tgrant.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 #include "os.h"
+#include "taoserror.h"
 
 typedef enum {
   TSDB_GRANT_ALL,

include/common/tmsg.h

@@ -1977,6 +1977,7 @@ typedef struct SVCreateTbReq {
   union {
     struct {
       char*    name;  // super table name
+      uint8_t tagNum;
       tb_uid_t suid;
       SArray*  tagName;
       uint8_t* pTag;

include/libs/sync/sync.h

@@ -26,7 +26,7 @@ extern "C" {
 
 extern bool gRaftDetailLog;
 
-#define SYNC_RESP_TTL_MS 10000
+#define SYNC_RESP_TTL_MS 10000000
 
 #define SYNC_MAX_BATCH_SIZE 500
 #define SYNC_INDEX_BEGIN 0

include/libs/wal/wal.h

@@ -135,6 +135,7 @@ typedef struct {
   int64_t        curVersion;
   int64_t        capacity;
   int8_t         curInvalid;
+  int8_t         curStopped;
   TdThreadMutex  mutex;
   SWalFilterCond cond;
   SWalCkHead    *pHead;

source/client/src/clientEnv.c

@@ -244,6 +244,7 @@ void *createRequest(uint64_t connId, int32_t type) {
 
   STscObj *pTscObj = acquireTscObj(connId);
   if (pTscObj == NULL) {
+    taosMemoryFree(pRequest);
     terrno = TSDB_CODE_TSC_DISCONNECTED;
     return NULL;
   }

source/client/src/clientImpl.c

@@ -834,7 +834,7 @@ void schedulerExecCb(SExecResult* pResult, void* param, int32_t code) {
            tstrerror(code), pRequest->requestId);
 
   STscObj* pTscObj = pRequest->pTscObj;
-  if (code != TSDB_CODE_SUCCESS && NEED_CLIENT_HANDLE_ERROR(code)) {
+  if (code != TSDB_CODE_SUCCESS && NEED_CLIENT_HANDLE_ERROR(code) && pRequest->sqlstr != NULL) {
     tscDebug("0x%" PRIx64 " client retry to handle the error, code:%d - %s, tryCount:%d, reqId:0x%" PRIx64,
              pRequest->self, code, tstrerror(code), pRequest->retry, pRequest->requestId);
     pRequest->prevCode = code;

source/client/src/clientSml.c

@@ -499,7 +499,7 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
 
     code = catalogGetSTableMeta(info->pCatalog, &conn, &pName, &pTableMeta);
 
-    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST || code == TSDB_CODE_MND_INVALID_STB) {
+    if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST || code == TSDB_CODE_MND_STB_NOT_EXIST) {
       SSchemaAction schemaAction;
       schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
       memset(&schemaAction.createSTable, 0, sizeof(SCreateSTableActionInfo));
@@ -1489,7 +1489,7 @@ static SSmlHandle* smlBuildSmlInfo(STscObj* pTscObj, SRequestObj* request, SMLPr
   }
   info->id = smlGenId();
 
-  info->pQuery = (SQuery *)taosMemoryCalloc(1, sizeof(SQuery));
+  info->pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
   if (NULL == info->pQuery) {
     uError("SML:0x%" PRIx64 " create info->pQuery error", info->id);
     goto cleanup;

source/client/src/tmq.c

@@ -2128,7 +2128,7 @@ _err:
   return string;
 }
 
-static char* buildCreateCTableJson(STag* pTag, char* sname, char* name, SArray* tagName, int64_t id) {
+static char* buildCreateCTableJson(STag* pTag, char* sname, char* name, SArray* tagName, int64_t id, uint8_t tagNum) {
   char*   string = NULL;
   SArray* pTagVals = NULL;
   cJSON*  json = cJSON_CreateObject();
@@ -2148,6 +2148,8 @@ static char* buildCreateCTableJson(STag* pTag, char* sname, char* name, SArray*
   cJSON_AddItemToObject(json, "tableType", tableType);
   cJSON* using = cJSON_CreateString(sname);
   cJSON_AddItemToObject(json, "using", using);
+  cJSON* tagNumJson = cJSON_CreateNumber(tagNum);
+  cJSON_AddItemToObject(json, "tagNum", tagNumJson);
   //  cJSON* version = cJSON_CreateNumber(1);
   //  cJSON_AddItemToObject(json, "version", version);
 
@@ -2236,7 +2238,7 @@ static char* processCreateTable(SMqMetaRsp* metaRsp) {
     pCreateReq = req.pReqs + iReq;
     if (pCreateReq->type == TSDB_CHILD_TABLE) {
       string = buildCreateCTableJson((STag*)pCreateReq->ctb.pTag, pCreateReq->ctb.name, pCreateReq->name,
-                                     pCreateReq->ctb.tagName, pCreateReq->uid);
+                                     pCreateReq->ctb.tagName, pCreateReq->uid, pCreateReq->ctb.tagNum);
     } else if (pCreateReq->type == TSDB_NORMAL_TABLE) {
       string =
           buildCreateTableJson(&pCreateReq->ntb.schemaRow, NULL, pCreateReq->name, pCreateReq->uid, TSDB_NORMAL_TABLE);
@@ -2952,9 +2954,243 @@ int32_t taos_write_raw_meta(TAOS *taos, tmq_raw_data raw_meta){
   return TSDB_CODE_INVALID_PARA;
 }
 
-void tmq_free_raw_meta(tmq_raw_data* rawMeta) {
-  //
-  taosMemoryFreeClear(rawMeta);
+typedef struct{
+  SVgroupInfo vg;
+  void *data;
+}VgData;
+
+static void destroyVgHash(void* data) {
+  VgData* vgData = (VgData*)data;
+  taosMemoryFreeClear(vgData->data);
+}
+
+int32_t taos_write_raw_data(TAOS *taos, TAOS_RES *msg){
+  if (!TD_RES_TMQ(msg)) {
+    uError("WriteRaw:msg is not tmq : %d", *(int8_t*)msg);
+    return TSDB_CODE_TMQ_INVALID_MSG;
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+  SHashObj *pVgHash = NULL;
+  SQuery *pQuery = NULL;
+
+  terrno = TSDB_CODE_SUCCESS;
+  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT);
+  if(!pRequest){
+    uError("WriteRaw:createRequest error request is null");
+    return terrno;
+  }
+
+  if (!pRequest->pDb) {
+    uError("WriteRaw:not use db");
+    code = TSDB_CODE_PAR_DB_NOT_SPECIFIED;
+    goto end;
+  }
+
+  pVgHash = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
+  taosHashSetFreeFp(pVgHash, destroyVgHash);
+  struct SCatalog *pCatalog = NULL;
+  code = catalogGetHandle(pRequest->pTscObj->pAppInfo->clusterId, &pCatalog);
+  if(code != TSDB_CODE_SUCCESS){
+    uError("WriteRaw: get gatlog error");
+    goto end;
+  }
+
+  SRequestConnInfo conn = {0};
+  conn.pTrans = pRequest->pTscObj->pAppInfo->pTransporter;
+  conn.requestId = pRequest->requestId;
+  conn.requestObjRefId = pRequest->self;
+  conn.mgmtEps = getEpSet_s(&pRequest->pTscObj->pAppInfo->mgmtEp);
+  SMqRspObj *rspObj = ((SMqRspObj*)msg);
+  printf("raw data block num:%d\n", rspObj->rsp.blockNum);
+  while (++rspObj->resIter < rspObj->rsp.blockNum) {
+    SRetrieveTableRsp* pRetrieve = (SRetrieveTableRsp*)taosArrayGetP(rspObj->rsp.blockData, rspObj->resIter);
+    if (!rspObj->rsp.withSchema) {
+      uError("WriteRaw:no schema, iter:%d", rspObj->resIter);
+      goto end;
+    }
+    SSchemaWrapper* pSW = (SSchemaWrapper*)taosArrayGetP(rspObj->rsp.blockSchema, rspObj->resIter);
+    setResSchemaInfo(&rspObj->resInfo, pSW->pSchema, pSW->nCols);
+
+    code = setQueryResultFromRsp(&rspObj->resInfo, pRetrieve, false, false);
+    if(code != TSDB_CODE_SUCCESS){
+      uError("WriteRaw: setQueryResultFromRsp error");
+      goto end;
+    }
+
+    uint16_t fLen = 0;
+    int32_t rowSize = 0;
+    int16_t nVar = 0;
+    for (int i = 0; i < pSW->nCols; i++) {
+      SSchema *schema = pSW->pSchema + i;
+      fLen += TYPE_BYTES[schema->type];
+      rowSize += schema->bytes;
+      if(IS_VAR_DATA_TYPE(schema->type)){
+        nVar ++;
+      }
+    }
+
+    int32_t rows = rspObj->resInfo.numOfRows;
+    int32_t extendedRowSize = rowSize + TD_ROW_HEAD_LEN - sizeof(TSKEY) + nVar * sizeof(VarDataOffsetT) +
+                              (int32_t)TD_BITMAP_BYTES(pSW->nCols - 1);
+    int32_t schemaLen = 0;
+    int32_t submitLen = sizeof(SSubmitBlk) + schemaLen + rows * extendedRowSize;
+
+    const char* tbName = tmq_get_table_name(msg);
+    if(!tbName){
+      uError("WriteRaw: tbname is null");
+      code = TSDB_CODE_TMQ_INVALID_MSG;
+      goto end;
+    }
+
+    printf("raw data tbname:%s\n", tbName);
+    SName pName = {TSDB_TABLE_NAME_T, pRequest->pTscObj->acctId, {0}, {0}};
+    strcpy(pName.dbname, pRequest->pDb);
+    strcpy(pName.tname, tbName);
+
+    VgData vgData = {0};
+    code = catalogGetTableHashVgroup(pCatalog, &conn, &pName, &(vgData.vg));
+    if (code != TSDB_CODE_SUCCESS) {
+      uError("WriteRaw:catalogGetTableHashVgroup failed. table name: %s", tbName);
+      goto end;
+    }
+
+    SSubmitReq* subReq = NULL;
+    SSubmitBlk* blk = NULL;
+    void *hData = taosHashGet(pVgHash, &vgData.vg.vgId, sizeof(vgData.vg.vgId));
+    if(hData){
+      vgData = *(VgData*)hData;
+
+      int32_t totalLen = ((SSubmitReq*)(vgData.data))->length + submitLen;
+      void *tmp = taosMemoryRealloc(vgData.data, totalLen);
+      if (tmp == NULL) {
+        code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+        goto end;
+      }
+      vgData.data = tmp;
+      ((VgData*)hData)->data = tmp;
+      subReq = (SSubmitReq*)(vgData.data);
+      blk = POINTER_SHIFT(vgData.data, subReq->length);
+    }else{
+      int32_t totalLen = sizeof(SSubmitReq) + submitLen;
+      void *tmp = taosMemoryCalloc(1, totalLen);
+      if (tmp == NULL) {
+        code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+        goto end;
+      }
+      vgData.data = tmp;
+      taosHashPut(pVgHash, (const char *)&vgData.vg.vgId, sizeof(vgData.vg.vgId), (char *)&vgData, sizeof(vgData));
+      subReq = (SSubmitReq*)(vgData.data);
+      subReq->length = sizeof(SSubmitReq);
+      subReq->numOfBlocks = 0;
+
+      blk = POINTER_SHIFT(vgData.data, sizeof(SSubmitReq));
+    }
+
+    STableMeta* pTableMeta = NULL;
+    code = catalogGetTableMeta(pCatalog, &conn, &pName, &pTableMeta);
+    if (code != TSDB_CODE_SUCCESS) {
+      uError("WriteRaw:catalogGetTableMeta failed. table name: %s", tbName);
+      goto end;
+    }
+    uint64_t suid = (TSDB_NORMAL_TABLE == pTableMeta->tableType ? 0 : pTableMeta->suid);
+    uint64_t uid = pTableMeta->uid;
+    taosMemoryFreeClear(pTableMeta);
+
+    void* blkSchema = POINTER_SHIFT(blk, sizeof(SSubmitBlk));
+    STSRow* rowData = POINTER_SHIFT(blkSchema, schemaLen);
+
+    SRowBuilder rb = {0};
+    tdSRowInit(&rb, pSW->version);
+    tdSRowSetTpInfo(&rb, pSW->nCols, fLen);
+    int32_t dataLen = 0;
+
+    for (int32_t j = 0; j < rows; j++) {
+      tdSRowResetBuf(&rb, rowData);
+
+      doSetOneRowPtr(&rspObj->resInfo);
+      rspObj->resInfo.current += 1;
+
+      int32_t offset = 0;
+      for (int32_t k = 0; k < pSW->nCols; k++) {
+        const SSchema*  pColumn = &pSW->pSchema[k];
+        char *data = rspObj->resInfo.row[k];
+        if (!data) {
+          tdAppendColValToRow(&rb, pColumn->colId, pColumn->type, TD_VTYPE_NULL, NULL, false, offset, k);
+        } else {
+          if(IS_VAR_DATA_TYPE(pColumn->type)){
+            data -= VARSTR_HEADER_SIZE;
+          }
+          tdAppendColValToRow(&rb, pColumn->colId, pColumn->type, TD_VTYPE_NORM, data, true, offset, k);
+        }
+        offset += TYPE_BYTES[pColumn->type];
+      }
+      int32_t rowLen = TD_ROW_LEN(rowData);
+      rowData = POINTER_SHIFT(rowData, rowLen);
+      dataLen += rowLen;
+    }
+
+    blk->uid = htobe64(uid);
+    blk->suid = htobe64(suid);
+    blk->padding = htonl(blk->padding);
+    blk->sversion = htonl(pSW->version);
+    blk->schemaLen = htonl(schemaLen);
+    blk->numOfRows = htons(rows);
+    blk->dataLen = htonl(dataLen);
+    subReq->length += sizeof(SSubmitBlk) + schemaLen + dataLen;
+    subReq->numOfBlocks++;
+  }
+
+  pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
+  if (NULL == pQuery) {
+    uError("create SQuery error");
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto end;
+  }
+  pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
+  pQuery->haveResultSet = false;
+  pQuery->msgType = TDMT_VND_SUBMIT;
+  pQuery->pRoot = (SNode *)nodesMakeNode(QUERY_NODE_VNODE_MODIF_STMT);
+  if (NULL == pQuery->pRoot) {
+    uError("create pQuery->pRoot error");
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto end;
+  }
+  SVnodeModifOpStmt *nodeStmt = (SVnodeModifOpStmt *)(pQuery->pRoot);
+  nodeStmt->payloadType = PAYLOAD_TYPE_KV;
+
+  int32_t numOfVg = taosHashGetSize(pVgHash);
+  nodeStmt->pDataBlocks = taosArrayInit(numOfVg, POINTER_BYTES);
+
+  VgData *vData = (VgData *)taosHashIterate(pVgHash, NULL);
+  while (vData) {
+    SVgDataBlocks *dst = taosMemoryCalloc(1, sizeof(SVgDataBlocks));
+    if (NULL == dst) {
+      code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+      goto end;
+    }
+    dst->vg = vData->vg;
+    SSubmitReq* subReq = (SSubmitReq*)(vData->data);
+    dst->numOfTables = subReq->numOfBlocks;
+    dst->size = subReq->length;
+    dst->pData = (char*)subReq;
+    vData->data = NULL;    // no need free
+    subReq->header.vgId = htonl(dst->vg.vgId);
+    subReq->version = htonl(1);
+    subReq->header.contLen = htonl(subReq->length);
+    subReq->length = htonl(subReq->length);
+    subReq->numOfBlocks = htonl(subReq->numOfBlocks);
+    taosArrayPush(nodeStmt->pDataBlocks, &dst);
+    vData = (VgData *)taosHashIterate(pVgHash, vData);
+  }
+
+  launchQueryImpl(pRequest, pQuery, true, NULL);
+  code = pRequest->code;
+end:
+  qDestroyQuery(pQuery);
+  destroyRequest(pRequest);
+  taosHashCleanup(pVgHash);
+  return code;
 }
 
 void tmq_commit_async(tmq_t* tmq, const TAOS_RES* msg, tmq_commit_cb* cb, void* param) {

source/common/src/systable.c

@@ -158,7 +158,7 @@ static const SSysDbTableSchema userTagsSchema[] = {
     {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR},
     {.name = "stable_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR},
     {.name = "tag_name", .bytes = TSDB_COL_NAME_LEN - 1 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
-    {.name = "tag_type", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT},
+    {.name = "tag_type", .bytes = 32 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
     {.name = "tag_value", .bytes = TSDB_MAX_TAGS_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR},
 };
 

source/common/src/tgrant.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "tgrant.h"
+
+#ifndef _GRANT
+
+int32_t grantCheck(EGrantType grant) { return TSDB_CODE_SUCCESS; }
+
+#endif
\ No newline at end of file

source/common/src/tmsg.c

@@ -4981,6 +4981,7 @@ int tEncodeSVCreateTbReq(SEncoder *pCoder, const SVCreateTbReq *pReq) {
 
   if (pReq->type == TSDB_CHILD_TABLE) {
     if (tEncodeCStr(pCoder, pReq->ctb.name) < 0) return -1;
+    if (tEncodeU8(pCoder, pReq->ctb.tagNum) < 0) return -1;
     if (tEncodeI64(pCoder, pReq->ctb.suid) < 0) return -1;
     if (tEncodeTag(pCoder, (const STag *)pReq->ctb.pTag) < 0) return -1;
     int32_t len = taosArrayGetSize(pReq->ctb.tagName);
@@ -5017,6 +5018,7 @@ int tDecodeSVCreateTbReq(SDecoder *pCoder, SVCreateTbReq *pReq) {
 
   if (pReq->type == TSDB_CHILD_TABLE) {
     if (tDecodeCStr(pCoder, &pReq->ctb.name) < 0) return -1;
+    if (tDecodeU8(pCoder, &pReq->ctb.tagNum) < 0) return -1;
     if (tDecodeI64(pCoder, &pReq->ctb.suid) < 0) return -1;
     if (tDecodeTag(pCoder, (STag **)&pReq->ctb.pTag) < 0) return -1;
     int32_t len = 0;

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

@@ -190,6 +190,10 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre
   int32_t code = -1;
   STrans *pTrans = NULL;
 
+  if ((terrno = grantCheck(TSDB_GRANT_USER)) < 0) {
+    return code;
+  }
+
   SFuncObj func = {0};
   memcpy(func.name, pCreate->name, TSDB_FUNC_NAME_LEN);
   func.createdTime = taosGetTimestampMs();

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

@@ -128,7 +128,6 @@ int32_t mndInitGrant(SMnode *pMnode) {
 
 void    mndCleanupGrant() {}
 void    grantParseParameter() { mError("can't parsed parameter k"); }
-int32_t grantCheck(EGrantType grant) { return TSDB_CODE_SUCCESS; }
 void    grantReset(SMnode *pMnode, EGrantType grant, uint64_t value) {}
 void    grantAdd(EGrantType grant, uint64_t value) {}
 void    grantRestore(EGrantType grant, uint64_t value) {}

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

@@ -66,7 +66,7 @@ static int32_t mndInsInitMeta(SHashObj *hash) {
 
 int32_t mndBuildInsTableSchema(SMnode *pMnode, const char *dbFName, const char *tbName, STableMetaRsp *pRsp) {
   if (NULL == pMnode->infosMeta) {
-    terrno = TSDB_CODE_MND_NOT_READY;
+    terrno = TSDB_CODE_APP_NOT_READY;
     return -1;
   }
 
@@ -92,7 +92,7 @@ int32_t mndBuildInsTableSchema(SMnode *pMnode, const char *dbFName, const char *
 
 int32_t mndBuildInsTableCfg(SMnode *pMnode, const char *dbFName, const char *tbName, STableCfgRsp *pRsp) {
   if (NULL == pMnode->infosMeta) {
-    terrno = TSDB_CODE_MND_NOT_READY;
+    terrno = TSDB_CODE_APP_NOT_READY;
     return -1;
   }
 

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

@@ -68,7 +68,7 @@ int32_t mndPerfsInitMeta(SHashObj *hash) {
 
 int32_t mndBuildPerfsTableSchema(SMnode *pMnode, const char *dbFName, const char *tbName, STableMetaRsp *pRsp) {
   if (NULL == pMnode->perfsMeta) {
-    terrno = TSDB_CODE_MND_NOT_READY;
+    terrno = TSDB_CODE_APP_NOT_READY;
     return -1;
   }
 
@@ -94,7 +94,7 @@ int32_t mndBuildPerfsTableSchema(SMnode *pMnode, const char *dbFName, const char
 
 int32_t mndBuildPerfsTableCfg(SMnode *pMnode, const char *dbFName, const char *tbName, STableCfgRsp *pRsp) {
   if (NULL == pMnode->perfsMeta) {
-    terrno = TSDB_CODE_MND_NOT_READY;
+    terrno = TSDB_CODE_APP_NOT_READY;
     return -1;
   }
 

source/dnode/vnode/inc/vnode.h

@@ -27,8 +27,8 @@
 #include "wal.h"
 
 #include "tcommon.h"
-#include "tgrant.h"
 #include "tfs.h"
+#include "tgrant.h"
 #include "tmsg.h"
 #include "trow.h"
 
@@ -101,7 +101,7 @@ typedef struct SMetaFltParam {
 
 } SMetaFltParam;
 
-int32_t metaFilteTableIds(SMeta *pMeta, SMetaFltParam *param, SArray *results);
+int32_t metaFilterTableIds(SMeta *pMeta, SMetaFltParam *param, SArray *results);
 
 #if 1  // refact APIs below (TODO)
 typedef SVCreateTbReq   STbCfg;
@@ -118,11 +118,11 @@ int32_t     metaTbCursorNext(SMTbCursor *pTbCur);
 // typedef struct STsdb STsdb;
 typedef struct STsdbReader STsdbReader;
 
-#define BLOCK_LOAD_OFFSET_ORDER 1
+#define BLOCK_LOAD_OFFSET_ORDER   1
 #define BLOCK_LOAD_TABLESEQ_ORDER 2
-#define BLOCK_LOAD_EXTERN_ORDER 3
+#define BLOCK_LOAD_EXTERN_ORDER   3
 
-#define LASTROW_RETRIEVE_TYPE_ALL 0x1
+#define LASTROW_RETRIEVE_TYPE_ALL    0x1
 #define LASTROW_RETRIEVE_TYPE_SINGLE 0x2
 
 int32_t tsdbSetTableId(STsdbReader *pReader, int64_t uid);
@@ -238,8 +238,8 @@ typedef struct {
   uint64_t groupId;
 } STableKeyInfo;
 
-#define TABLE_ROLLUP_ON ((int8_t)0x1)
-#define TABLE_IS_ROLLUP(FLG) (((FLG) & (TABLE_ROLLUP_ON)) != 0)
+#define TABLE_ROLLUP_ON       ((int8_t)0x1)
+#define TABLE_IS_ROLLUP(FLG)  (((FLG) & (TABLE_ROLLUP_ON)) != 0)
 #define TABLE_SET_ROLLUP(FLG) ((FLG) |= TABLE_ROLLUP_ON)
 struct SMetaEntry {
   int64_t  version;

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

@@ -765,12 +765,14 @@ typedef struct {
   int32_t  vLen;
 } SIdxCursor;
 
-int32_t metaFilteTableIds(SMeta *pMeta, SMetaFltParam *param, SArray *pUids) {
-  SIdxCursor *pCursor = NULL;
-  char       *buf = NULL;
-  int32_t     maxSize = 0;
+int32_t metaFilterTableIds(SMeta *pMeta, SMetaFltParam *param, SArray *pUids) {
+  int32_t ret = 0;
+  char   *buf = NULL;
 
-  int32_t ret = 0, valid = 0;
+  STagIdxKey *pKey = NULL;
+  int32_t     nKey = 0;
+
+  SIdxCursor *pCursor = NULL;
   pCursor = (SIdxCursor *)taosMemoryCalloc(1, sizeof(SIdxCursor));
   pCursor->pMeta = pMeta;
   pCursor->suid = param->suid;
@@ -782,9 +784,8 @@ int32_t metaFilteTableIds(SMeta *pMeta, SMetaFltParam *param, SArray *pUids) {
   if (ret < 0) {
     goto END;
   }
-  STagIdxKey *pKey = NULL;
-  int32_t     nKey = 0;
 
+  int32_t maxSize = 0;
   int32_t nTagData = 0;
   void   *tagData = NULL;
 
@@ -822,10 +823,12 @@ int32_t metaFilteTableIds(SMeta *pMeta, SMetaFltParam *param, SArray *pUids) {
     goto END;
   }
 
-  void   *entryKey = NULL, *entryVal = NULL;
-  int32_t nEntryKey, nEntryVal;
   bool    first = true;
+  int32_t valid = 0;
   while (1) {
+    void   *entryKey = NULL, *entryVal = NULL;
+    int32_t nEntryKey, nEntryVal;
+
     valid = tdbTbcGet(pCursor->pCur, (const void **)&entryKey, &nEntryKey, (const void **)&entryVal, &nEntryVal);
     if (valid < 0) {
       break;
@@ -864,10 +867,12 @@ int32_t metaFilteTableIds(SMeta *pMeta, SMetaFltParam *param, SArray *pUids) {
       break;
     }
   }
+
 END:
   if (pCursor->pMeta) metaULock(pCursor->pMeta);
   if (pCursor->pCur) tdbTbcClose(pCursor->pCur);
   taosMemoryFree(buf);
+  taosMemoryFree(pKey);
 
   taosMemoryFree(pCursor);
 

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

@@ -358,6 +358,14 @@ int metaCreateTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq) {
     goto _err;
   }
 
+  if (pReq->type == TSDB_CHILD_TABLE) {
+    tb_uid_t suid = metaGetTableEntryUidByName(pMeta, pReq->ctb.name);
+    if (suid != pReq->ctb.suid) {
+      terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST;
+      return -1;
+    }
+  }
+
   // validate req
   metaReaderInit(&mr, pMeta, 0);
   if (metaGetTableEntryByName(&mr, pReq->name) == 0) {
@@ -371,13 +379,6 @@ int metaCreateTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq) {
   }
   metaReaderClear(&mr);
 
-  if (pReq->type == TSDB_CHILD_TABLE) {
-    tb_uid_t suid = metaGetTableEntryUidByName(pMeta, pReq->ctb.name);
-    if (suid == 0) {
-      terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST;
-      return -1;
-    }
-  }
   // build SMetaEntry
   me.version = version;
   me.type = pReq->type;
@@ -442,7 +443,7 @@ int metaTtlDropTable(SMeta *pMeta, int64_t ttl, SArray *tbUids) {
   if (ret != 0) {
     return ret;
   }
-  if (taosArrayGetSize(tbUids) == 0){
+  if (taosArrayGetSize(tbUids) == 0) {
     return 0;
   }
 
@@ -811,6 +812,9 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
     for (int32_t i = 0; i < pTagSchema->nCols; i++) {
       SSchema *pCol = &pTagSchema->pSchema[i];
       if (iCol == i) {
+        if (pAlterTbReq->isNull) {
+          continue;
+        }
         STagVal val = {0};
         val.type = pCol->type;
         val.cid = pCol->colId;

source/dnode/vnode/src/tq/tq.c

@@ -138,6 +138,14 @@ int32_t tqSendDataRsp(STQ* pTq, const SRpcMsg* pMsg, const SMqPollReq* pReq, con
     ASSERT(taosArrayGetSize(pRsp->blockSchema) == 0);
   }
 
+  if (pRsp->reqOffset.type == TMQ_OFFSET__LOG) {
+    if (pRsp->blockNum > 0) {
+      ASSERT(pRsp->rspOffset.version > pRsp->reqOffset.version);
+    } else {
+      ASSERT(pRsp->rspOffset.version >= pRsp->reqOffset.version);
+    }
+  }
+
   int32_t len;
   int32_t code;
   tEncodeSize(tEncodeSMqDataRsp, pRsp, len, code);

source/dnode/vnode/src/tq/tqExec.c

@@ -65,12 +65,14 @@ int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVa
   qTaskInfo_t          task = pExec->execCol.task;
 
   if (qStreamPrepareScan(task, pOffset) < 0) {
+    tqDebug("prepare scan failed, return");
     if (pOffset->type == TMQ_OFFSET__LOG) {
       pRsp->rspOffset = *pOffset;
       return 0;
     } else {
       tqOffsetResetToLog(pOffset, pHandle->snapshotVer);
       if (qStreamPrepareScan(task, pOffset) < 0) {
+        tqDebug("prepare scan failed, return");
         pRsp->rspOffset = *pOffset;
         return 0;
       }
@@ -126,9 +128,16 @@ int64_t tqScan(STQ* pTq, const STqHandle* pHandle, SMqDataRsp* pRsp, STqOffsetVa
 
     ASSERT(pRsp->rspOffset.type != 0);
 
+#if 0
     if (pRsp->reqOffset.type == TMQ_OFFSET__LOG) {
-      ASSERT(pRsp->rspOffset.version + 1 >= pRsp->reqOffset.version);
+      if (pRsp->blockNum > 0) {
+        ASSERT(pRsp->rspOffset.version > pRsp->reqOffset.version);
+      } else {
+        ASSERT(pRsp->rspOffset.version >= pRsp->reqOffset.version);
+      }
     }
+#endif
+
     tqDebug("task exec exited");
     break;
   }

source/dnode/vnode/src/tq/tqMeta.c

@@ -43,16 +43,12 @@ static int32_t tDecodeSTqHandle(SDecoder* pDecoder, STqHandle* pHandle) {
   return 0;
 }
 
-int tqExecKeyCompare(const void* pKey1, int32_t kLen1, const void* pKey2, int32_t kLen2) {
-  return strcmp(pKey1, pKey2);
-}
-
 int32_t tqMetaOpen(STQ* pTq) {
   if (tdbOpen(pTq->path, 16 * 1024, 1, &pTq->pMetaStore) < 0) {
     ASSERT(0);
   }
 
-  if (tdbTbOpen("handles", -1, -1, tqExecKeyCompare, pTq->pMetaStore, &pTq->pExecStore) < 0) {
+  if (tdbTbOpen("handles", -1, -1, 0, pTq->pMetaStore, &pTq->pExecStore) < 0) {
     ASSERT(0);
   }
 
@@ -67,10 +63,10 @@ int32_t tqMetaOpen(STQ* pTq) {
     ASSERT(0);
   }
 
-  void* pKey;
-  int   kLen;
-  void* pVal;
-  int   vLen;
+  void* pKey = NULL;
+  int   kLen = 0;
+  void* pVal = NULL;
+  int   vLen = 0;
 
   tdbTbcMoveToFirst(pCur);
   SDecoder decoder;
@@ -101,7 +97,7 @@ int32_t tqMetaOpen(STQ* pTq) {
       handle.execHandle.execDb.pFilterOutTbUid =
           taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
     }
-    tqDebug("tq restore %s consumer %ld", handle.subKey, handle.consumerId);
+    tqDebug("tq restore %s consumer %ld vgId:%d", handle.subKey, handle.consumerId, TD_VID(pTq->pVnode));
     taosHashPut(pTq->handles, pKey, kLen, &handle, sizeof(STqHandle));
   }
 
@@ -126,6 +122,9 @@ int32_t tqMetaSaveHandle(STQ* pTq, const char* key, const STqHandle* pHandle) {
   tEncodeSize(tEncodeSTqHandle, pHandle, vlen, code);
   ASSERT(code == 0);
 
+  tqDebug("tq save %s(%d) consumer %ld vgId:%d", pHandle->subKey, strlen(pHandle->subKey), pHandle->consumerId,
+          TD_VID(pTq->pVnode));
+
   void* buf = taosMemoryCalloc(1, vlen);
   if (buf == NULL) {
     ASSERT(0);

source/dnode/vnode/src/tq/tqRead.c

@@ -132,10 +132,12 @@ int32_t tqNextBlock(STqReader* pReader, SFetchRet* ret) {
   while (1) {
     if (!fromProcessedMsg) {
       if (walNextValidMsg(pReader->pWalReader) < 0) {
-        pReader->ver = pReader->pWalReader->curVersion - pReader->pWalReader->curInvalid;
+        pReader->ver =
+            pReader->pWalReader->curVersion - (pReader->pWalReader->curInvalid | pReader->pWalReader->curStopped);
         ret->offset.type = TMQ_OFFSET__LOG;
         ret->offset.version = pReader->ver;
         ret->fetchType = FETCH_TYPE__NONE;
+        tqDebug("return offset %ld, no more valid", ret->offset.version);
         ASSERT(ret->offset.version >= 0);
         return -1;
       }
@@ -167,6 +169,7 @@ int32_t tqNextBlock(STqReader* pReader, SFetchRet* ret) {
       ret->offset.version = pReader->ver;
       ASSERT(pReader->ver >= 0);
       ret->fetchType = FETCH_TYPE__NONE;
+      tqDebug("return offset %ld, processed finish", ret->offset.version);
       return 0;
     }
   }

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

@@ -477,6 +477,11 @@ static int32_t vnodeProcessCreateTbReq(SVnode *pVnode, int64_t version, void *pR
   for (int32_t iReq = 0; iReq < req.nReqs; iReq++) {
     pCreateReq = req.pReqs + iReq;
 
+    if ((terrno = grantCheck(TSDB_GRANT_TIMESERIES)) < 0) {
+      rcode = -1;
+      goto _exit;
+    }
+    
     // validate hash
     sprintf(tbName, "%s.%s", pVnode->config.dbname, pCreateReq->name);
     if (vnodeValidateTableHash(pVnode, tbName) < 0) {
@@ -821,6 +826,13 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t version, void *pReq
         goto _exit;
       }
 
+      if ((terrno = grantCheck(TSDB_GRANT_TIMESERIES)) < 0) {
+        pRsp->code = terrno;
+        tDecoderClear(&decoder);
+        taosArrayDestroy(createTbReq.ctb.tagName);
+        goto _exit;
+      }
+
       if (metaCreateTable(pVnode->pMeta, version, &createTbReq) < 0) {
         if (terrno != TSDB_CODE_TDB_TABLE_ALREADY_EXIST) {
           submitBlkRsp.code = terrno;

source/libs/command/inc/commandInt.h

@@ -28,6 +28,7 @@ extern "C" {
 //newline area
 #define EXPLAIN_TAG_SCAN_FORMAT "Tag Scan on %s"
 #define EXPLAIN_TBL_SCAN_FORMAT "Table Scan on %s"
+#define EXPLAIN_TBL_MERGE_SCAN_FORMAT "Table Merge Scan on %s"
 #define EXPLAIN_SYSTBL_SCAN_FORMAT "System Table Scan on %s"
 #define EXPLAIN_DISTBLK_SCAN_FORMAT "Block Dist Scan on %s"
 #define EXPLAIN_LASTROW_SCAN_FORMAT "Last Row Scan on %s"

source/libs/command/src/explain.c

@@ -433,7 +433,9 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:
     case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: {
       STableScanPhysiNode *pTblScanNode = (STableScanPhysiNode *)pNode;
-      EXPLAIN_ROW_NEW(level, EXPLAIN_TBL_SCAN_FORMAT, pTblScanNode->scan.tableName.tname);
+      EXPLAIN_ROW_NEW(level,
+                      QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN == pNode->type ? EXPLAIN_TBL_MERGE_SCAN_FORMAT : EXPLAIN_TBL_SCAN_FORMAT,
+                      pTblScanNode->scan.tableName.tname);
       EXPLAIN_ROW_APPEND(EXPLAIN_LEFT_PARENTHESIS_FORMAT);
       if (pResNode->pExecInfo) {
         QRY_ERR_RET(qExplainBufAppendExecInfo(pResNode->pExecInfo, tbuf, &tlen));

source/libs/executor/src/scanoperator.c

@@ -948,7 +948,7 @@ static int32_t generateSessionScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSr
   }
   blockDataCleanup(pDestBlock);
   int32_t code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows);
-    if (code != TSDB_CODE_SUCCESS) {
+  if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
   ASSERT(taosArrayGetSize(pSrcBlock->pDataBlock) >= 3);
@@ -996,16 +996,16 @@ static int32_t generateIntervalScanRange(SStreamScanInfo* pInfo, SSDataBlock* pS
 
   SColumnInfoData* pTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, START_TS_COLUMN_INDEX);
   SColumnInfoData* pUidCol = taosArrayGet(pSrcBlock->pDataBlock, UID_COLUMN_INDEX);
-  uint64_t* uidCol = (uint64_t*)pUidCol->pData;
+  uint64_t*        uidCol = (uint64_t*)pUidCol->pData;
   ASSERT(pTsCol->info.type == TSDB_DATA_TYPE_TIMESTAMP);
-  TSKEY* tsCol = (TSKEY*)pTsCol->pData;
+  TSKEY*           tsCol = (TSKEY*)pTsCol->pData;
   SColumnInfoData* pStartTsCol = taosArrayGet(pDestBlock->pDataBlock, START_TS_COLUMN_INDEX);
   SColumnInfoData* pEndTsCol = taosArrayGet(pDestBlock->pDataBlock, END_TS_COLUMN_INDEX);
   SColumnInfoData* pGpCol = taosArrayGet(pDestBlock->pDataBlock, GROUPID_COLUMN_INDEX);
   SColumnInfoData* pCalStartTsCol = taosArrayGet(pDestBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX);
   SColumnInfoData* pCalEndTsCol = taosArrayGet(pDestBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX);
-  uint64_t groupId = getGroupId(pInfo->pTableScanOp, uidCol[0]);
-  for (int32_t i = 0; i < rows; ) {
+  uint64_t         groupId = getGroupId(pInfo->pTableScanOp, uidCol[0]);
+  for (int32_t i = 0; i < rows;) {
     colDataAppend(pCalStartTsCol, pDestBlock->info.rows, (const char*)(tsCol + i), false);
     STimeWindow win = getSlidingWindow(tsCol, &pInfo->interval, &pSrcBlock->info, &i);
     colDataAppend(pCalEndTsCol, pDestBlock->info.rows, (const char*)(tsCol + i - 1), false);
@@ -1169,8 +1169,11 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
         return NULL;
       } else if (ret.fetchType == FETCH_TYPE__NONE) {
         pTaskInfo->streamInfo.lastStatus = ret.offset;
-        ASSERT(pTaskInfo->streamInfo.lastStatus.version + 1 >= pTaskInfo->streamInfo.prepareStatus.version);
-        qDebug("stream scan log return null");
+        ASSERT(pTaskInfo->streamInfo.lastStatus.version >= pTaskInfo->streamInfo.prepareStatus.version);
+        ASSERT(pTaskInfo->streamInfo.lastStatus.version + 1 == pInfo->tqReader->pWalReader->curVersion);
+        char formatBuf[80];
+        tFormatOffset(formatBuf, 80, &ret.offset);
+        qDebug("stream scan log return null, offset %s", formatBuf);
         return NULL;
       } else {
         ASSERT(0);
@@ -1274,7 +1277,7 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) {
       default:
         break;
     }
-    
+
     SStreamAggSupporter* pSup = pInfo->sessionSup.pStreamAggSup;
     if (isStateWindow(pInfo) && pSup->pScanBlock->info.rows > 0) {
       pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE;
@@ -1674,6 +1677,87 @@ static SSDataBlock* buildInfoSchemaTableMetaBlock(char* tableName) {
   return pBlock;
 }
 
+int32_t convertTagDataToStr(char* str, int type, void* buf, int32_t bufSize, int32_t* len) {
+  int32_t n = 0;
+
+  switch (type) {
+    case TSDB_DATA_TYPE_NULL:
+      n = sprintf(str, "null");
+      break;
+
+    case TSDB_DATA_TYPE_BOOL:
+      n = sprintf(str, (*(int8_t*)buf) ? "true" : "false");
+      break;
+
+    case TSDB_DATA_TYPE_TINYINT:
+      n = sprintf(str, "%d", *(int8_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_SMALLINT:
+      n = sprintf(str, "%d", *(int16_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_INT:
+      n = sprintf(str, "%d", *(int32_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_BIGINT:
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      n = sprintf(str, "%" PRId64, *(int64_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_FLOAT:
+      n = sprintf(str, "%.5f", GET_FLOAT_VAL(buf));
+      break;
+
+    case TSDB_DATA_TYPE_DOUBLE:
+      n = sprintf(str, "%.9f", GET_DOUBLE_VAL(buf));
+      break;
+
+    case TSDB_DATA_TYPE_BINARY:
+      if (bufSize < 0) {
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      }
+
+      memcpy(str, buf, bufSize);
+      n = bufSize;
+      break;
+    case TSDB_DATA_TYPE_NCHAR:
+      if (bufSize < 0) {
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      }
+
+      int32_t length = taosUcs4ToMbs((TdUcs4*)buf, bufSize, str);
+      if (length <= 0) {
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      }
+      n = length;
+      break;
+    case TSDB_DATA_TYPE_UTINYINT:
+      n = sprintf(str, "%u", *(uint8_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_USMALLINT:
+      n = sprintf(str, "%u", *(uint16_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_UINT:
+      n = sprintf(str, "%u", *(uint32_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_UBIGINT:
+      n = sprintf(str, "%" PRIu64, *(uint64_t*)buf);
+      break;
+
+    default:
+      return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  if (len) *len = n;
+
+  return TSDB_CODE_SUCCESS;
+}
+
 static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
   SExecTaskInfo*     pTaskInfo = pOperator->pTaskInfo;
   SSysTableScanInfo* pInfo = pOperator->info;
@@ -1744,14 +1828,24 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
       pColInfoData = taosArrayGet(p->pDataBlock, 2);
       colDataAppend(pColInfoData, numOfRows, stableName, false);
 
+      // tag name
       char tagName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
       STR_TO_VARSTR(tagName, smr.me.stbEntry.schemaTag.pSchema[i].name);
       pColInfoData = taosArrayGet(p->pDataBlock, 3);
       colDataAppend(pColInfoData, numOfRows, tagName, false);
 
+      // tag type
       int8_t tagType = smr.me.stbEntry.schemaTag.pSchema[i].type;
       pColInfoData = taosArrayGet(p->pDataBlock, 4);
-      colDataAppend(pColInfoData, numOfRows, (char*)&tagType, false);
+      char tagTypeStr[VARSTR_HEADER_SIZE + 32];
+      int tagTypeLen = sprintf(varDataVal(tagTypeStr), "%s", tDataTypes[tagType].name);
+      if (tagType == TSDB_DATA_TYPE_VARCHAR) {
+        tagTypeLen += sprintf(varDataVal(tagTypeStr) + tagTypeLen, "(%d)", (int32_t)(smr.me.stbEntry.schemaTag.pSchema[i].bytes - VARSTR_HEADER_SIZE));
+      } else if (tagType == TSDB_DATA_TYPE_NCHAR) {
+        tagTypeLen += sprintf(varDataVal(tagTypeStr) + tagTypeLen, "(%d)", (int32_t)((smr.me.stbEntry.schemaTag.pSchema[i].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));
+      }
+      varDataSetLen(tagTypeStr, tagTypeLen);
+      colDataAppend(pColInfoData, numOfRows, (char*)tagTypeStr, false);
 
       STagVal tagVal = {0};
       tagVal.cid = smr.me.stbEntry.schemaTag.pSchema[i].colId;
@@ -1786,7 +1880,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
                                                       : (3 + DBL_MANT_DIG - DBL_MIN_EXP + VARSTR_HEADER_SIZE);
           tagVarChar = taosMemoryMalloc(bufSize);
           int32_t len = -1;
-          dataConverToStr(varDataVal(tagVarChar), tagType, tagData, tagLen, &len);
+          convertTagDataToStr(varDataVal(tagVarChar), tagType, tagData, tagLen, &len);
           varDataSetLen(tagVarChar, len);
         }
       }

source/libs/executor/src/timewindowoperator.c

@@ -772,6 +772,41 @@ int32_t binarySearch(void* keyList, int num, TSKEY key, int order, __get_value_f
   return midPos;
 }
 
+int32_t comparePullWinKey(void* pKey, void* data, int32_t index) {
+  SArray*     res = (SArray*)data;
+  SPullWindowInfo* pos = taosArrayGet(res, index);
+  SPullWindowInfo* pData = (SPullWindowInfo*) pKey;
+  if (pData->window.skey == pos->window.skey) {
+    if (pData->groupId > pos->groupId) {
+      return 1;
+    } else if (pData->groupId < pos->groupId) {
+      return -1;
+    }
+    return 0;
+  } else if (pData->window.skey > pos->window.skey) {
+    return 1;
+  }
+  return -1;
+}
+
+static int32_t savePullWindow(SPullWindowInfo* pPullInfo, SArray* pPullWins) {
+  int32_t size = taosArrayGetSize(pPullWins);
+  int32_t index = binarySearchCom(pPullWins, size, pPullInfo, TSDB_ORDER_DESC, comparePullWinKey);
+  if (index == -1) {
+    index = 0;
+  } else {
+    if (comparePullWinKey(pPullInfo, pPullWins, index) > 0) {
+      index++;
+    } else {
+      return TSDB_CODE_SUCCESS;
+    }
+  }
+  if (taosArrayInsert(pPullWins, index, pPullInfo) == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t compareResKey(void* pKey, void* data, int32_t index) {
   SArray*     res = (SArray*)data;
   SResKeyPos* pos = taosArrayGetP(res, index);
@@ -2589,7 +2624,7 @@ static void doHashInterval(SOperatorInfo* pOperatorInfo, SSDataBlock* pSDataBloc
       if (isDeletedWindow(&nextWin, tableGroupId, &pInfo->aggSup) && !chIds) {
         SPullWindowInfo pull = {.window = nextWin, .groupId = tableGroupId};
         // add pull data request
-        taosArrayPush(pInfo->pPullWins, &pull);
+        savePullWindow(&pull, pInfo->pPullWins);
         int32_t size = taosArrayGetSize(pInfo->pChildren);
         addPullWindow(pInfo->pPullDataMap, &winRes, size);
         qDebug("===stream===prepare retrive %" PRId64 ", size:%d", winRes.ts, size);
@@ -2678,14 +2713,6 @@ void copyUpdateDataBlock(SSDataBlock* pDest, SSDataBlock* pSource, int32_t tsCol
   blockDataUpdateTsWindow(pDest, 0);
 }
 
-static bool needBreak(SStreamFinalIntervalOperatorInfo* pInfo) {
-  int32_t size = taosArrayGetSize(pInfo->pPullWins);
-  if (pInfo->pullIndex < size) {
-    return true;
-  }
-  return false;
-}
-
 static void doBuildPullDataBlock(SArray* array, int32_t* pIndex, SSDataBlock* pBlock) {
   clearSpecialDataBlock(pBlock);
   int32_t size = taosArrayGetSize(array);
@@ -2752,6 +2779,14 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
   if (pOperator->status == OP_EXEC_DONE) {
     return NULL;
   } else if (pOperator->status == OP_RES_TO_RETURN) {
+    doBuildPullDataBlock(pInfo->pPullWins, &pInfo->pullIndex, pInfo->pPullDataRes);
+    if (pInfo->pPullDataRes->info.rows != 0) {
+      // process the rest of the data
+      ASSERT(IS_FINAL_OP(pInfo));
+      printDataBlock(pInfo->pPullDataRes, IS_FINAL_OP(pInfo) ? "interval Final" : "interval Semi");
+      return pInfo->pPullDataRes;
+    }
+
     doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
     if (pInfo->binfo.pRes->info.rows == 0) {
       pOperator->status = OP_EXEC_DONE;
@@ -2780,13 +2815,13 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
       // process the rest of the data
       return pInfo->pUpdateRes;
     }
-    doBuildPullDataBlock(pInfo->pPullWins, &pInfo->pullIndex, pInfo->pPullDataRes);
-    if (pInfo->pPullDataRes->info.rows != 0) {
-      // process the rest of the data
-      ASSERT(IS_FINAL_OP(pInfo));
-      printDataBlock(pInfo->pPullDataRes, IS_FINAL_OP(pInfo) ? "interval Final" : "interval Semi");
-      return pInfo->pPullDataRes;
-    }
+    // doBuildPullDataBlock(pInfo->pPullWins, &pInfo->pullIndex, pInfo->pPullDataRes);
+    // if (pInfo->pPullDataRes->info.rows != 0) {
+    //   // process the rest of the data
+    //   ASSERT(IS_FINAL_OP(pInfo));
+    //   printDataBlock(pInfo->pPullDataRes, IS_FINAL_OP(pInfo) ? "interval Final" : "interval Semi");
+    //   return pInfo->pPullDataRes;
+    // }
     doBuildDeleteResult(pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
     if (pInfo->pDelRes->info.rows != 0) {
       // process the rest of the data
@@ -2886,10 +2921,6 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
       SStreamFinalIntervalOperatorInfo* pChInfo = pChildOp->info;
       setInputDataBlock(pChildOp, pChildOp->exprSupp.pCtx, pBlock, pChInfo->order, MAIN_SCAN, true);
       doHashInterval(pChildOp, pBlock, pBlock->info.groupId, NULL);
-
-      if (needBreak(pInfo)) {
-        break;
-      }
     }
   }
 
@@ -2903,6 +2934,15 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
   finalizeUpdatedResult(pOperator->exprSupp.numOfExprs, pInfo->aggSup.pResultBuf, pUpdated, pSup->rowEntryInfoOffset);
   initMultiResInfoFromArrayList(&pInfo->groupResInfo, pUpdated);
   blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+
+  doBuildPullDataBlock(pInfo->pPullWins, &pInfo->pullIndex, pInfo->pPullDataRes);
+  if (pInfo->pPullDataRes->info.rows != 0) {
+    // process the rest of the data
+    ASSERT(IS_FINAL_OP(pInfo));
+    printDataBlock(pInfo->pPullDataRes, IS_FINAL_OP(pInfo) ? "interval Final" : "interval Semi");
+    return pInfo->pPullDataRes;
+  }
+
   doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
   if (pInfo->binfo.pRes->info.rows != 0) {
     printDataBlock(pInfo->binfo.pRes, IS_FINAL_OP(pInfo) ? "interval Final" : "interval Semi");
@@ -2917,14 +2957,6 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
     return pInfo->pUpdateRes;
   }
 
-  doBuildPullDataBlock(pInfo->pPullWins, &pInfo->pullIndex, pInfo->pPullDataRes);
-  if (pInfo->pPullDataRes->info.rows != 0) {
-    // process the rest of the data
-    ASSERT(IS_FINAL_OP(pInfo));
-    printDataBlock(pInfo->pPullDataRes, IS_FINAL_OP(pInfo) ? "interval Final" : "interval Semi");
-    return pInfo->pPullDataRes;
-  }
-
   doBuildDeleteResult(pInfo->pDelWins, &pInfo->delIndex, pInfo->pDelRes);
   if (pInfo->pDelRes->info.rows != 0) {
     // process the rest of the data

source/libs/index/src/indexFilter.c

@@ -86,7 +86,9 @@ static void sifFreeParam(SIFParam *param) {
 
   taosArrayDestroy(param->result);
   taosMemoryFree(param->condValue);
+  param->condValue = NULL;
   taosHashCleanup(param->pFilter);
+  param->pFilter = NULL;
 }
 
 static int32_t sifGetOperParamNum(EOperatorType ty) {
@@ -180,6 +182,7 @@ static int32_t sifInitJsonParam(SNode *node, SIFParam *param, SIFCtx *ctx) {
   param->colId = l->colId;
   param->colValType = l->node.resType.type;
   memcpy(param->dbName, l->dbName, sizeof(l->dbName));
+  if (r->literal == NULL) return TSDB_CODE_QRY_INVALID_INPUT;
   memcpy(param->colName, r->literal, strlen(r->literal));
   param->colValType = r->typeData;
   param->status = SFLT_COARSE_INDEX;
@@ -281,6 +284,7 @@ static int32_t sifInitOperParams(SIFParam **params, SOperatorNode *node, SIFCtx
     return TSDB_CODE_SUCCESS;
   }
 _return:
+  for (int i = 0; i < nParam; i++) sifFreeParam(&paramList[i]);
   taosMemoryFree(paramList);
   SIF_RET(code);
 }
@@ -381,7 +385,7 @@ static int32_t sifDoIndex(SIFParam *left, SIFParam *right, int8_t operType, SIFP
                            .reverse = reverse,
                            .filterFunc = filterFunc};
 
-    ret = metaFilteTableIds(arg->metaEx, &param, output->result);
+    ret = metaFilterTableIds(arg->metaEx, &param, output->result);
   }
   return ret;
 }
@@ -536,6 +540,7 @@ static int32_t sifExecOper(SOperatorNode *node, SIFCtx *ctx, SIFParam *output) {
   SIF_ERR_RET(sifInitOperParams(&params, node, ctx));
 
   if (params[0].status == SFLT_NOT_INDEX && (nParam > 1 && params[1].status == SFLT_NOT_INDEX)) {
+    for (int i = 0; i < nParam; i++) sifFreeParam(&params[i]);
     output->status = SFLT_NOT_INDEX;
     return code;
   }
@@ -545,17 +550,18 @@ static int32_t sifExecOper(SOperatorNode *node, SIFCtx *ctx, SIFParam *output) {
   sif_func_t operFn = sifNullFunc;
 
   if (!ctx->noExec) {
-    SIF_ERR_RET(sifGetOperFn(node->opType, &operFn, &output->status));
-    SIF_ERR_RET(operFn(&params[0], nParam > 1 ? &params[1] : NULL, output));
+    SIF_ERR_JRET(sifGetOperFn(node->opType, &operFn, &output->status));
+    SIF_ERR_JRET(operFn(&params[0], nParam > 1 ? &params[1] : NULL, output));
   } else {
     // ugly code, refactor later
     if (nParam > 1 && params[1].status == SFLT_NOT_INDEX) {
       output->status = SFLT_NOT_INDEX;
       return code;
     }
-    SIF_ERR_RET(sifGetOperFn(node->opType, &operFn, &output->status));
+    SIF_ERR_JRET(sifGetOperFn(node->opType, &operFn, &output->status));
   }
-
+_return:
+  for (int i = 0; i < nParam; i++) sifFreeParam(&params[i]);
   taosMemoryFree(params);
   return code;
 }
@@ -738,6 +744,7 @@ static int32_t sifGetFltHint(SNode *pNode, SIdxFltStatus *status) {
 
   sifFreeParam(res);
   taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES);
+  taosHashCleanup(ctx.pRes);
 
   SIF_RET(code);
 }

source/libs/parser/src/parAstCreater.c

@@ -523,7 +523,7 @@ SNode* createTempTableNode(SAstCreateContext* pCxt, SNode* pSubquery, const STok
   if (NULL != pTableAlias && TK_NK_NIL != pTableAlias->type) {
     COPY_STRING_FORM_ID_TOKEN(tempTable->table.tableAlias, pTableAlias);
   } else {
-    sprintf(tempTable->table.tableAlias, "%p", tempTable);
+    taosRandStr(tempTable->table.tableAlias, 8);
   }
   if (QUERY_NODE_SELECT_STMT == nodeType(pSubquery)) {
     strcpy(((SSelectStmt*)pSubquery)->stmtName, tempTable->table.tableAlias);

source/libs/parser/src/parInsert.c

@@ -739,12 +739,12 @@ static int32_t parseBoundColumns(SInsertParseContext* pCxt, SParsedDataColInfo*
   return TSDB_CODE_SUCCESS;
 }
 
-static void buildCreateTbReq(SVCreateTbReq* pTbReq, const char* tname, STag* pTag, int64_t suid, const char* sname,
-                             SArray* tagName) {
+static void buildCreateTbReq(SVCreateTbReq* pTbReq, const char* tname, STag* pTag, int64_t suid, const char* sname, SArray* tagName, uint8_t tagNum) {
   pTbReq->type = TD_CHILD_TABLE;
   pTbReq->name = strdup(tname);
   pTbReq->ctb.suid = suid;
-  if (sname) pTbReq->ctb.name = strdup(sname);
+  pTbReq->ctb.tagNum = tagNum;
+  if(sname) pTbReq->ctb.name = strdup(sname);
   pTbReq->ctb.pTag = (uint8_t*)pTag;
   pTbReq->ctb.tagName = taosArrayDup(tagName);
   pTbReq->commentLen = -1;
@@ -903,7 +903,7 @@ static int32_t parseTagToken(char** end, SToken* pToken, SSchema* pSchema, int16
       if (pToken->n + VARSTR_HEADER_SIZE > pSchema->bytes) {
         return generateSyntaxErrMsg(pMsgBuf, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name);
       }
-      val->pData = pToken->z;
+      val->pData = strdup(pToken->z);
       val->nData = pToken->n;
       break;
     }
@@ -969,10 +969,9 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
     }
 
     SSchema* pTagSchema = &pSchema[pCxt->tags.boundColumns[i]];
-    char*    tmpTokenBuf = taosMemoryCalloc(1, sToken.n);  // todo this can be optimize with parse column
+    char     tmpTokenBuf[TSDB_MAX_BYTES_PER_ROW] = {0}; // todo this can be optimize with parse column
     code = checkAndTrimValue(&sToken, tmpTokenBuf, &pCxt->msg);
     if (code != TSDB_CODE_SUCCESS) {
-      taosMemoryFree(tmpTokenBuf);
       goto end;
     }
 
@@ -982,7 +981,6 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
     if (pTagSchema->type == TSDB_DATA_TYPE_JSON) {
       if (sToken.n > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) {
         code = buildSyntaxErrMsg(&pCxt->msg, "json string too long than 4095", sToken.z);
-        taosMemoryFree(tmpTokenBuf);
         goto end;
       }
       if (isNullValue(pTagSchema->type, &sToken)) {
@@ -990,7 +988,6 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
       } else {
         code = parseJsontoTagData(sToken.z, pTagVals, &pTag, &pCxt->msg);
       }
-      taosMemoryFree(tmpTokenBuf);
       if (code != TSDB_CODE_SUCCESS) {
         goto end;
       }
@@ -999,12 +996,9 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
       STagVal val = {0};
       code = parseTagToken(&pCxt->pSql, &sToken, pTagSchema, precision, &val, &pCxt->msg);
       if (TSDB_CODE_SUCCESS != code) {
-        taosMemoryFree(tmpTokenBuf);
         goto end;
       }
-      if (pTagSchema->type != TSDB_DATA_TYPE_BINARY) {
-        taosMemoryFree(tmpTokenBuf);
-      }
+
       taosArrayPush(pTagVals, &val);
     }
   }
@@ -1018,12 +1012,12 @@ static int32_t parseTagsClause(SInsertParseContext* pCxt, SSchema* pSchema, uint
     goto end;
   }
 
-  buildCreateTbReq(&pCxt->createTblReq, tName, pTag, pCxt->pTableMeta->suid, pCxt->sTableName, tagName);
+  buildCreateTbReq(&pCxt->createTblReq, tName, pTag, pCxt->pTableMeta->suid, pCxt->sTableName, tagName, pCxt->pTableMeta->tableInfo.numOfTags);
 
 end:
   for (int i = 0; i < taosArrayGetSize(pTagVals); ++i) {
     STagVal* p = (STagVal*)taosArrayGet(pTagVals, i);
-    if (p->type == TSDB_DATA_TYPE_NCHAR) {
+    if (IS_VAR_DATA_TYPE(p->type)) {
       taosMemoryFree(p->pData);
     }
   }
@@ -1902,7 +1896,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch
   }
 
   SVCreateTbReq tbReq = {0};
-  buildCreateTbReq(&tbReq, tName, pTag, suid, sTableName, tagName);
+  buildCreateTbReq(&tbReq, tName, pTag, suid, sTableName, tagName, pDataBlock->pTableMeta->tableInfo.numOfTags);
   code = buildCreateTbMsg(pDataBlock, &tbReq);
   tdDestroySVCreateTbReq(&tbReq);
 
@@ -2338,7 +2332,7 @@ int32_t smlBindData(void* handle, SArray* tags, SArray* colsSchema, SArray* cols
     return ret;
   }
 
-  buildCreateTbReq(&smlHandle->tableExecHandle.createTblReq, tableName, pTag, pTableMeta->suid, NULL, tagName);
+  buildCreateTbReq(&smlHandle->tableExecHandle.createTblReq, tableName, pTag, pTableMeta->suid, NULL, tagName, pTableMeta->tableInfo.numOfTags);
   taosArrayDestroy(tagName);
 
   smlHandle->tableExecHandle.createTblReq.ctb.name = taosMemoryMalloc(sTableNameLen + 1);

source/libs/parser/src/parTranslater.c

@@ -1220,6 +1220,14 @@ static int32_t translateMultiResFunc(STranslateContext* pCxt, SFunctionNode* pFu
   }
   return TSDB_CODE_SUCCESS;
 }
+
+static int32_t getMultiResFuncNum(SNodeList* pParameterList) {
+  if (1 == LIST_LENGTH(pParameterList)) {
+    return isStar(nodesListGetNode(pParameterList, 0)) ? 2 : 1;
+  }
+  return LIST_LENGTH(pParameterList);
+}
+
 static void setFuncClassification(SNode* pCurrStmt, SFunctionNode* pFunc) {
   if (NULL != pCurrStmt && QUERY_NODE_SELECT_STMT == nodeType(pCurrStmt)) {
     SSelectStmt* pSelect = (SSelectStmt*)pCurrStmt;
@@ -1229,7 +1237,9 @@ static void setFuncClassification(SNode* pCurrStmt, SFunctionNode* pFunc) {
     pSelect->hasMultiRowsFunc = pSelect->hasMultiRowsFunc ? true : fmIsMultiRowsFunc(pFunc->funcId);
     if (fmIsSelectFunc(pFunc->funcId)) {
       pSelect->hasSelectFunc = true;
-      ++(pSelect->selectFuncNum);
+      pSelect->selectFuncNum += (fmIsMultiResFunc(pFunc->funcId) && !fmIsLastRowFunc(pFunc->funcId))
+                                    ? getMultiResFuncNum(pFunc->pParameterList)
+                                    : 1;
     } else if (fmIsVectorFunc(pFunc->funcId)) {
       pSelect->hasOtherVectorFunc = true;
     }
@@ -2134,6 +2144,15 @@ static int32_t translateOrderBy(STranslateContext* pCxt, SSelectStmt* pSelect) {
   return code;
 }
 
+static int32_t translateFillValues(STranslateContext* pCxt, SSelectStmt* pSelect) {
+  if (NULL == pSelect->pWindow || QUERY_NODE_INTERVAL_WINDOW != nodeType(pSelect->pWindow) ||
+      NULL == ((SIntervalWindowNode*)pSelect->pWindow)->pFill) {
+    return TSDB_CODE_SUCCESS;
+  }
+  SFillNode* pFill = (SFillNode*)((SIntervalWindowNode*)pSelect->pWindow)->pFill;
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t translateSelectList(STranslateContext* pCxt, SSelectStmt* pSelect) {
   pCxt->currClause = SQL_CLAUSE_SELECT;
   int32_t code = translateExprList(pCxt, pSelect->pProjectionList);
@@ -2143,6 +2162,9 @@ static int32_t translateSelectList(STranslateContext* pCxt, SSelectStmt* pSelect
   if (TSDB_CODE_SUCCESS == code) {
     code = checkExprListForGroupBy(pCxt, pSelect, pSelect->pProjectionList);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = translateFillValues(pCxt, pSelect);
+  }
   return code;
 }
 
@@ -5537,7 +5559,7 @@ static int32_t rewriteCreateTable(STranslateContext* pCxt, SQuery* pQuery) {
 
 static void addCreateTbReqIntoVgroup(int32_t acctId, SHashObj* pVgroupHashmap, SCreateSubTableClause* pStmt,
                                      const STag* pTag, uint64_t suid, const char* sTableNmae, SVgroupInfo* pVgInfo,
-                                     SArray* tagName) {
+                                     SArray* tagName, uint8_t tagNum) {
   //  char  dbFName[TSDB_DB_FNAME_LEN] = {0};
   //  SName name = {.type = TSDB_DB_NAME_T, .acctId = acctId};
   //  strcpy(name.dbname, pStmt->dbName);
@@ -5554,6 +5576,7 @@ static void addCreateTbReqIntoVgroup(int32_t acctId, SHashObj* pVgroupHashmap, S
     req.commentLen = -1;
   }
   req.ctb.suid = suid;
+  req.ctb.tagNum = tagNum;
   req.ctb.name = strdup(sTableNmae);
   req.ctb.pTag = (uint8_t*)pTag;
   req.ctb.tagName = taosArrayDup(tagName);
@@ -5805,7 +5828,7 @@ static int32_t rewriteCreateSubTable(STranslateContext* pCxt, SCreateSubTableCla
   }
   if (TSDB_CODE_SUCCESS == code) {
     addCreateTbReqIntoVgroup(pCxt->pParseCxt->acctId, pVgroupHashmap, pStmt, pTag, pSuperTableMeta->uid,
-                             pStmt->useTableName, &info, tagName);
+                             pStmt->useTableName, &info, tagName, pSuperTableMeta->tableInfo.numOfTags);
   }
 
   taosArrayDestroy(tagName);
@@ -6053,7 +6076,7 @@ static int32_t buildUpdateTagValReq(STranslateContext* pCxt, SAlterTableStmt* pS
     pReq->pTagVal = (uint8_t*)pTag;
     pStmt->pVal->datum.p = (char*)pTag;  // for free
   } else {
-    pReq->isNull = (TSDB_DATA_TYPE_NULL == pStmt->pVal->node.resType.type);
+    pReq->isNull = pStmt->pVal->isNull;
     pReq->nTagVal = pStmt->pVal->node.resType.bytes;
     pReq->pTagVal = nodesGetValueFromNode(pStmt->pVal);
 

source/libs/planner/src/planLogicCreater.c

@@ -713,7 +713,7 @@ static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SInterva
       (NULL != pInterval->pSliding ? ((SValueNode*)pInterval->pSliding)->unit : pWindow->intervalUnit);
   pWindow->windowAlgo = pCxt->pPlanCxt->streamQuery ? INTERVAL_ALGO_STREAM_SINGLE : INTERVAL_ALGO_HASH;
   pWindow->node.groupAction = GROUP_ACTION_KEEP;
-  pWindow->node.requireDataOrder = DATA_ORDER_LEVEL_IN_BLOCK;
+  pWindow->node.requireDataOrder = pSelect->hasTimeLineFunc ? DATA_ORDER_LEVEL_IN_GROUP : DATA_ORDER_LEVEL_IN_BLOCK;
   pWindow->node.resultDataOrder = DATA_ORDER_LEVEL_IN_GROUP;
 
   pWindow->pTspk = nodesCloneNode(pInterval->pCol);

source/libs/qworker/src/qwMsg.c

@@ -231,7 +231,6 @@ int32_t qwBuildAndSendCQueryMsg(QW_FPARAMS_DEF, SRpcHandleInfo *pConn) {
   int32_t code = tmsgPutToQueue(&mgmt->msgCb, QUERY_QUEUE, &pNewMsg);
   if (TSDB_CODE_SUCCESS != code) {
     QW_SCH_TASK_ELOG("put query continue msg to queue failed, vgId:%d, code:%s", mgmt->nodeId, tstrerror(code));
-    rpcFreeCont(req);
     QW_ERR_RET(code);
   }
 

source/libs/scalar/src/scalar.c

@@ -735,15 +735,13 @@ EDealRes sclRewriteFunction(SNode** pNode, SScalarCtx *ctx) {
 
   res->translate = true;
 
+  res->node.resType.type = output.columnData->info.type;
+  res->node.resType.bytes = output.columnData->info.bytes;
+  res->node.resType.scale = output.columnData->info.scale;
+  res->node.resType.precision = output.columnData->info.precision;
   if (colDataIsNull_s(output.columnData, 0)) {
     res->isNull = true;
-    //res->node.resType.type = TSDB_DATA_TYPE_NULL;
-    //res->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_NULL].bytes;
   } else {
-    res->node.resType.type = output.columnData->info.type;
-    res->node.resType.bytes = output.columnData->info.bytes;
-    res->node.resType.scale = output.columnData->info.scale;
-    res->node.resType.precision = output.columnData->info.precision;
     int32_t type = output.columnData->info.type;
     if (type == TSDB_DATA_TYPE_JSON){
       int32_t len = getJsonValueLen(output.columnData->pData);
@@ -826,16 +824,11 @@ EDealRes sclRewriteOperator(SNode** pNode, SScalarCtx *ctx) {
 
   res->translate = true;
 
+  res->node.resType = node->node.resType;
   if (colDataIsNull_s(output.columnData, 0)) {
-    if(node->node.resType.type != TSDB_DATA_TYPE_JSON){
-      res->node.resType.type = TSDB_DATA_TYPE_NULL;
-      res->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_NULL].bytes;
-    }else{
-      res->node.resType = node->node.resType;
-      res->isNull = true;
-    }
-  } else {
+    res->isNull = true;
     res->node.resType = node->node.resType;
+  } else {
     int32_t type = output.columnData->info.type;
     if (IS_VAR_DATA_TYPE(type)) {  // todo refactor
       res->datum.p = output.columnData->pData;

source/libs/sync/inc/syncRaftEntry.h

@@ -36,6 +36,7 @@ typedef struct SSyncRaftEntry {
   bool      isWeak;
   SyncTerm  term;
   SyncIndex index;
+  int64_t   rid;
   uint32_t  dataLen;  // origin RpcMsg.contLen
   char      data[];   // origin RpcMsg.pCont
 } SSyncRaftEntry;

source/libs/sync/src/syncRaftEntry.c

@@ -137,6 +137,8 @@ cJSON* syncEntry2Json(const SSyncRaftEntry* pEntry) {
     cJSON_AddStringToObject(pRoot, "term", u64buf);
     snprintf(u64buf, sizeof(u64buf), "%" PRIu64, pEntry->index);
     cJSON_AddStringToObject(pRoot, "index", u64buf);
+    snprintf(u64buf, sizeof(u64buf), "%" PRIu64, pEntry->rid);
+    cJSON_AddStringToObject(pRoot, "rid", u64buf);
     cJSON_AddNumberToObject(pRoot, "dataLen", pEntry->dataLen);
 
     char* s;

source/libs/sync/src/syncTimeout.c

@@ -19,11 +19,14 @@
 #include "syncRespMgr.h"
 
 int32_t syncNodeTimerRoutine(SSyncNode* ths) {
-  syncNodeEventLog(ths, "timer routines ... ");
+  syncNodeEventLog(ths, "timer routines");
 
+#if 0
   if (ths->vgId != 1) {
     syncRespClean(ths->pSyncRespMgr);
   }
+#endif
+
   return 0;
 }
 

source/libs/sync/test/syncEntryCacheTest.cpp

@@ -6,6 +6,7 @@
 #include "syncRaftStore.h"
 #include "syncUtil.h"
 #include "tskiplist.h"
+#include "tref.h"
 
 void logTest() {
   sTrace("--- sync log test: trace");
@@ -121,6 +122,37 @@ void test3() {
   raftEntryCacheLog2((char*)"==test3 write 10 entries==", pCache);
 }
 
+
+
+static void freeObj(void* param) {
+  SSyncRaftEntry* pEntry = (SSyncRaftEntry*)param;
+  syncEntryLog2((char*)"freeObj: ", pEntry);
+  syncEntryDestory(pEntry);
+}
+
+void test4() {
+  int32_t testRefId = taosOpenRef(200, freeObj);
+
+  SSyncRaftEntry* pEntry = createEntry(10);
+  ASSERT(pEntry != NULL);
+
+  int64_t rid = taosAddRef(testRefId, pEntry);
+  sTrace("rid: %ld", rid);
+  
+  do {
+    SSyncRaftEntry* pAcquireEntry = (SSyncRaftEntry*)taosAcquireRef(testRefId, rid);
+    syncEntryLog2((char*)"acquire: ", pAcquireEntry);
+
+    taosAcquireRef(testRefId, rid);
+    taosAcquireRef(testRefId, rid);
+
+    taosReleaseRef(testRefId, rid);
+    //taosReleaseRef(testRefId, rid);
+  } while (0);
+
+  taosRemoveRef(testRefId, rid);
+}
+
 int main(int argc, char** argv) {
   gRaftDetailLog = true;
   tsAsyncLog = 0;
@@ -130,5 +162,7 @@ int main(int argc, char** argv) {
   test2();
   test3();
 
+  //test4();
+
   return 0;
 }

source/libs/transport/src/tmsgcb.c

@@ -52,4 +52,4 @@ void tmsgRegisterBrokenLinkArg(SRpcMsg* pMsg) { (*defaultMsgCb.registerBrokenLin
 
 void tmsgReleaseHandle(SRpcHandleInfo* pHandle, int8_t type) { (*defaultMsgCb.releaseHandleFp)(pHandle, type); }
 
-void tmsgReportStartup(const char* name, const char* desc) { (*defaultMsgCb.reportStartupFp)(name, desc); }
+void tmsgReportStartup(const char* name, const char* desc) { (*defaultMsgCb.reportStartupFp)(name, desc); }
\ No newline at end of file

source/libs/wal/src/walRead.c

@@ -21,7 +21,7 @@ static int32_t walFetchBodyNew(SWalReader *pRead);
 static int32_t walSkipFetchBodyNew(SWalReader *pRead);
 
 SWalReader *walOpenReader(SWal *pWal, SWalFilterCond *cond) {
-  SWalReader *pRead = taosMemoryMalloc(sizeof(SWalReader));
+  SWalReader *pRead = taosMemoryCalloc(1, sizeof(SWalReader));
   if (pRead == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -75,6 +75,7 @@ int32_t walNextValidMsg(SWalReader *pRead) {
 
   wDebug("vgId:%d wal start to fetch, ver %ld, last ver %ld commit ver %ld, applied ver %ld, end ver %ld",
          pRead->pWal->cfg.vgId, fetchVer, lastVer, committedVer, appliedVer, endVer);
+  pRead->curStopped = 0;
   while (fetchVer <= endVer) {
     if (walFetchHeadNew(pRead, fetchVer) < 0) {
       return -1;
@@ -93,6 +94,7 @@ int32_t walNextValidMsg(SWalReader *pRead) {
       ASSERT(fetchVer == pRead->curVersion);
     }
   }
+  pRead->curStopped = 1;
   return -1;
 }
 
@@ -221,6 +223,8 @@ static int32_t walFetchHeadNew(SWalReader *pRead, int64_t fetchVer) {
   int64_t contLen;
   bool    seeked = false;
 
+  wDebug("vgId:%d, wal starts to fetch head %d", pRead->pWal->cfg.vgId, fetchVer);
+
   if (pRead->curInvalid || pRead->curVersion != fetchVer) {
     if (walReadSeekVer(pRead, fetchVer) < 0) {
       ASSERT(0);
@@ -257,6 +261,8 @@ static int32_t walFetchBodyNew(SWalReader *pRead) {
   SWalCont *pReadHead = &pRead->pHead->head;
   int64_t   ver = pReadHead->version;
 
+  wDebug("vgId:%d, wal starts to fetch body %ld", pRead->pWal->cfg.vgId, ver);
+
   if (pRead->capacity < pReadHead->bodyLen) {
     void *ptr = taosMemoryRealloc(pRead->pHead, sizeof(SWalCkHead) + pReadHead->bodyLen);
     if (ptr == NULL) {
@@ -300,8 +306,8 @@ static int32_t walFetchBodyNew(SWalReader *pRead) {
     return -1;
   }
 
+  wDebug("version %ld is fetched, cursor advance", ver);
   pRead->curVersion = ver + 1;
-  wDebug("version advance to %ld, fetch body", pRead->curVersion);
   return 0;
 }
 

tests/script/jenkins/basic.txt

@@ -113,8 +113,8 @@
 # TD-17659 ./test.sh -f tsim/parser/function.sim
 ./test.sh -f tsim/parser/groupby-basic.sim
 ./test.sh -f tsim/parser/groupby.sim
-# TD-17622 ./test.sh -f tsim/parser/having_child.sim
-# TD-17622 ./test.sh -f tsim/parser/having.sim
+./test.sh -f tsim/parser/having_child.sim
+./test.sh -f tsim/parser/having.sim
 ./test.sh -f tsim/parser/import_commit1.sim
 ./test.sh -f tsim/parser/import_commit2.sim
 ./test.sh -f tsim/parser/import_commit3.sim
@@ -129,7 +129,8 @@
 # TD-17707 ./test.sh -f tsim/parser/join.sim
 ./test.sh -f tsim/parser/last_cache.sim
 ./test.sh -f tsim/parser/last_groupby.sim
-# TD-17722 ./test.sh -f tsim/parser/lastrow.sim
+./test.sh -f tsim/parser/lastrow.sim
+./test.sh -f tsim/parser/lastrow2.sim
 ./test.sh -f tsim/parser/like.sim
 # TD-17464 ./test.sh -f tsim/parser/limit.sim
 # TD-17464 ./test.sh -f tsim/parser/limit1.sim
@@ -137,7 +138,7 @@
 ./test.sh -f tsim/parser/mixed_blocks.sim
 ./test.sh -f tsim/parser/nchar.sim
 # TD-17703 ./test.sh -f tsim/parser/nestquery.sim
-# TD-17685 ./test.sh -f tsim/parser/null_char.sim
+./test.sh -f tsim/parser/null_char.sim
 ./test.sh -f tsim/parser/precision_ns.sim
 ./test.sh -f tsim/parser/projection_limit_offset.sim
 ./test.sh -f tsim/parser/regex.sim
@@ -146,12 +147,12 @@
 ./test.sh -f tsim/parser/select_from_cache_disk.sim
 # TD-17659 ./test.sh -f tsim/parser/select_with_tags.sim
 ./test.sh -f tsim/parser/selectResNum.sim
-# TD-17685 ./test.sh -f tsim/parser/set_tag_vals.sim
+./test.sh -f tsim/parser/set_tag_vals.sim
 ./test.sh -f tsim/parser/single_row_in_tb.sim
-# TD-17684 ./test.sh -f tsim/parser/sliding.sim
-# TD-17722 ./test.sh -f tsim/parser/slimit_alter_tags.sim
-# TD-17722 ./test.sh -f tsim/parser/slimit.sim
-# TD-17722 ./test.sh -f tsim/parser/slimit1.sim
+./test.sh -f tsim/parser/sliding.sim
+./test.sh -f tsim/parser/slimit_alter_tags.sim
+./test.sh -f tsim/parser/slimit.sim
+./test.sh -f tsim/parser/slimit1.sim
 ./test.sh -f tsim/parser/stableOp.sim
 # TD-17661 ./test.sh -f tsim/parser/tags_dynamically_specifiy.sim
 # TD-17661 ./test.sh -f tsim/parser/tags_filter.sim

tests/script/tsim/mnode/basic4.sim

@@ -63,10 +63,14 @@ print $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4]
 print $data[1][0] $data[1][1] $data[1][2] $data[1][3] $data[1][4] 
 print $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4]
 
-if $data(1)[2] != leader then
-  goto step3
+$leaderNum = 0
+if $data(1)[2] == leader then
+  $leaderNum = 1
+endi
+if $data(2)[2] == leader then
+  $leaderNum = 1
 endi
-if $data(2)[2] != follower then
+if  $leaderNum == 0 then
   goto step3
 endi
 if $data(3)[2] != offline then
@@ -97,10 +101,14 @@ print $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4]
 print $data[1][0] $data[1][1] $data[1][2] $data[1][3] $data[1][4] 
 print $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4]
 
-if $data(1)[2] != leader then
-  goto step4
+$leaderNum = 0
+if $data(1)[2] == leader then
+  $leaderNum = 1
+endi
+if $data(2)[2] == leader then
+  $leaderNum = 1
 endi
-if $data(2)[2] != follower then
+if  $leaderNum == 0 then
   goto step4
 endi
 if $data(3)[2] != follower then
@@ -132,10 +140,14 @@ print $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4]
 print $data[1][0] $data[1][1] $data[1][2] $data[1][3] $data[1][4] 
 print $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4]
 
-if $data(1)[2] != leader then
-  goto step5
+$leaderNum = 0
+if $data(1)[2] == leader then
+  $leaderNum = 1
+endi
+if $data(2)[2] == leader then
+  $leaderNum = 1
 endi
-if $data(2)[2] != follower then
+if  $leaderNum == 0 then
   goto step5
 endi
 if $data(3)[2] != offline then
@@ -169,10 +181,14 @@ print $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4]
 if $rows != 2 then 
   goto step6
 endi
-if $data(1)[2] != leader then
-  goto step6
+$leaderNum = 0
+if $data(1)[2] == leader then
+  $leaderNum = 1
+endi
+if $data(2)[2] == leader then
+  $leaderNum = 1
 endi
-if $data(2)[2] != follower then
+if  $leaderNum == 0 then
   goto step6
 endi
 if $data(3)[2] != null then

tests/script/tsim/mnode/basic5.sim

@@ -68,13 +68,17 @@ step31:
 		return -1
 	endi
 sql show mnodes
-if $data(1)[2] != leader then
-  goto step31
+$leaderNum = 0
+if $data(1)[2] == leader then
+  $leaderNum = 1
 endi
-if $data(2)[2] != follower then
-  goto step31
+if $data(2)[2] == leader then
+  $leaderNum = 1
 endi
-if $data(3)[2] != follower then
+if $data(3)[2] == leader then
+  $leaderNum = 1
+endi
+if  $leaderNum == 0 then
   goto step31
 endi
 
@@ -302,10 +306,10 @@ print ===> $data00 $data01 $data02 $data03 $data04 $data05
 print ===> $data10 $data11 $data12 $data13 $data14 $data15
 print ===> $data20 $data21 $data22 $data23 $data24 $data25
 $leaderNum = 0
-if $data(2)[2] == leader then
+if $data(1)[2] == leader then
   $leaderNum = 1
 endi
-if $data(3)[2] == leader then
+if $data(2)[2] == leader then
   $leaderNum = 1
 endi
 if $data(3)[2] == leader then

tests/script/tsim/parser/gendata.bat

+
+echo '2020-1-1 1:1:1','abc','device',123,'9876', 'abc', 'net', 'mno', 'province', 'city', 'al' >  C:\\Windows\\Temp\\data.sql
+echo '2020-1-2 1:1:1','abc','device',123,'9876', 'abc', 'net', 'mno', 'province', 'city', 'al' >> C:\\Windows\\Temp\\data.sql
+echo '2020-1-3 1:1:1','abc','device',123,'9876', 'abc', 'net', 'mno', 'province', 'city', 'al' >> C:\\Windows\\Temp\\data.sql

tests/script/tsim/parser/having_child.sim

@@ -26,7 +26,6 @@ sql insert into tb1 values (now+50s ,3,3.0,3.0,3,3,3,false,"3","3")
 sql insert into tb1 values (now+100s,4,4.0,4.0,4,4,4,true ,"4","4")
 sql insert into tb1 values (now+150s,4,4.0,4.0,4,4,4,false,"4","4")
 
-
 sql select count(*),f1 from tb1 group by f1 having count(f1) > 0 order by f1;
 if $rows != 4 then
   return -1
@@ -56,7 +55,6 @@ if $data31 != 4 then
   return -1
 endi
 
-
 sql select count(*),f1 from tb1 group by f1 having count(*) > 0 order by f1;
 if $rows != 4 then
   return -1
@@ -299,13 +297,13 @@ if $data12 != 4 then
   return -1
 endi
 
-sql_error select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by tbname having twa(f1) > 0;
+sql select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by tbname having twa(f1) > 0;
 
-sql_error select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by f1 having twa(f1) > 3;
+sql select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by f1 having twa(f1) > 3;
 
-sql_error select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by tbname having sum(f1) > 0;
+sql select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by tbname having sum(f1) > 0;
 
-sql_error select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by f1 having sum(f1) = 4;
+sql select avg(f1),count(f1),sum(f1),twa(f1) from tb1 group by f1 having sum(f1) = 4;
 
 sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 0 order by f1;
 if $rows != 4 then
@@ -381,7 +379,7 @@ if $data22 != 8 then
 endi
 
 ###########and issue
-sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 3 and sum(f1) > 1 order by f1;
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 1 order by f1;
 if $rows != 4 then
   return -1
 endi
@@ -422,7 +420,6 @@ if $data32 != 8 then
   return -1
 endi
 
-
 sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 3 or sum(f1) > 1 order by f1;
 if $rows != 4 then 
   return -1
@@ -497,7 +494,7 @@ if $data22 != 8 then
 endi
 
 ############or issue
-sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 3 or avg(f1) > 4 order by f1;
+sql select avg(f1),count(f1),sum(f1) from tb1 group by f1 having sum(f1) > 3 and avg(f1) > 4 order by f1;
 if $rows != 0 then                                                                                                                                                                             
   return -1
 endi
@@ -728,11 +725,11 @@ sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 ha
 
 sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having LEASTSQUARES(f1) < 1;
 
-sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having LEASTSQUARES(f1,1,1) < 1;
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having LEASTSQUARES(f1,1,1) < 1;
 
-sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having LEASTSQUARES(f1,1,1) > 2;
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1) from tb1 group by f1 having LEASTSQUARES(f1,1,1) > 2;
 
-sql_error select avg(f1),count(tb1.*),sum(f1),stddev(f1),LEASTSQUARES(f1,1,1) from tb1 group by f1 having LEASTSQUARES(f1,1,1) > 2;
+sql select avg(f1),count(tb1.*),sum(f1),stddev(f1),LEASTSQUARES(f1,1,1) from tb1 group by f1 having LEASTSQUARES(f1,1,1) > 2;
 
 sql select avg(f1),count(tb1.*),sum(f1),stddev(f1),LEASTSQUARES(f1,1,1) from tb1 group by f1 having sum(f1) > 2 order by f1;
 if $rows != 3 then
@@ -1149,9 +1146,9 @@ sql_error select aPERCENTILE(f1,20) from tb1 group by f1 having apercentile(1) >
 
 sql_error select aPERCENTILE(f1,20),LAST_ROW(f1) from tb1 group by f1 having apercentile(1) > 1;
 
-sql_error select aPERCENTILE(f1,20),LAST_ROW(f1) from tb1 group by f1 having apercentile(f1,1) > 1;
+sql select aPERCENTILE(f1,20),LAST_ROW(f1) from tb1 group by f1 having apercentile(f1,1) > 1;
 
-sql_error select sum(f1) from tb1 group by f1 having last_row(f1) > 1;
+sql select sum(f1) from tb1 group by f1 having last_row(f1) > 1;
 
 sql_error select avg(f1) from tb1 group by f1 having diff(f1) > 0;
 
@@ -1210,7 +1207,7 @@ if $data31 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) = 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) = 0 order by f1;
 if $rows != 4 then
   return -1
 endi
@@ -1263,48 +1260,47 @@ if $data33 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) != 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) != 0 order by f1;
 if $rows != 0 then                                                                                                                                                                             
   return -1                                                                                                                                                                                    
 endi 
 
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) + 1 > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) + 1 > 0;
-
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) + 1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) + 1;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) + sum(f1);
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) + sum(f1);
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) + sum(f1) > 0;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) + sum(f1) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) - sum(f1) > 0;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) - sum(f1) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) * sum(f1) > 0;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) * sum(f1) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) / sum(f1) > 0;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) / sum(f1) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) > sum(f1);
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) > sum(f1);
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) and sum(f1);
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) and sum(f1);
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) 0 and sum(f1);
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) 0 and sum(f1);
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) + 0 and sum(f1);
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) + 0 and sum(f1);
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) - f1 and sum(f1);
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) - f1 and sum(f1);
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) - id1 and sum(f1);
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) - id1 and sum(f1);
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) > id1 and sum(f1);
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) > id1 and sum(f1);
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) > id1 and sum(f1) > 1;
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) > id1 and sum(f1) > 1;
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) > 2 and sum(f1) > 1 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) > 2 and sum(f1) > 1 order by f1;
 if $rows != 0 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) = 0 and sum(f1) > 1 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) = 0 and sum(f1) > 1 order by f1;
 if $rows != 4 then
   return -1
 endi
@@ -1357,7 +1353,7 @@ if $data33 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having spread(f1) = 0 and avg(f1) > 1 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having spread(f1) = 0 and avg(f1) > 1 order by f1;
 if $rows != 3 then
   return -1
 endi
@@ -1398,17 +1394,17 @@ if $data23 != 0.000000000 then
   return -1
 endi
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by c1 having spread(f1) = 0 and avg(f1) > 1;
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by c1 having spread(f1) = 0 and avg(f1) > 1;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(id1) > 0;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by id1 having avg(id1) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f1) > id1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by id1 having avg(f1) > id1;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1),avg(id1) from tb1 group by id1 having avg(f1) > id1;
+sql select avg(f1),spread(f1),spread(f2),spread(tb1.f1),avg(id1) from tb1 group by id1 having avg(f1) > id1;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f1) > 0;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by id1 having avg(f1) > 0;
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having avg(f1) > 0 and avg(f1) = 3 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having avg(f1) > 0 and avg(f1) = 3 order by f1;
 if $rows != 1 then
   return -1
 endi
@@ -1425,10 +1421,10 @@ if $data03 != 0.000000000 then
   return -1
 endi
 
-#sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by f1 having avg(f1) < 0 and avg(f1) = 3;
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 group by id1 having avg(f1) < 2;
+#sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by f1 having avg(f1) < 0 and avg(f1) = 3;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 group by id1 having avg(f1) < 2;
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f1 > 0 group by f1 having avg(f1) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f1 > 0 group by f1 having avg(f1) > 0 order by f1;
 if $rows != 4 then
   return -1
 endi
@@ -1481,7 +1477,7 @@ if $data33 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f1 > 2 group by f1 having avg(f1) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f1 > 2 group by f1 having avg(f1) > 0 order by f1;
 if $rows != 2 then
   return -1
 endi
@@ -1510,7 +1506,7 @@ if $data13 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 2 group by f1 having avg(f1) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 2 group by f1 having avg(f1) > 0 order by f1;
 if $rows != 2 then                                                                                                                                                                             
   return -1
 endi
@@ -1539,7 +1535,7 @@ if $data13 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f3 > 2 group by f1 having avg(f1) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f3 > 2 group by f1 having avg(f1) > 0 order by f1;
 if $rows != 2 then                                                                                                                                                                             
   return -1
 endi
@@ -1568,7 +1564,7 @@ if $data13 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f1) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f1) > 0 order by f1;
 if $rows != 1 then
   return -1
 endi
@@ -1585,15 +1581,15 @@ if $data03 != 0.000000000 then
   return -1
 endi
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having avg(ts) > 0;
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 3 group by f1 having avg(ts) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f7) > 0;
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f7) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f8) > 0;
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f8) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f9) > 0;
+sql_error select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 3 group by f1 having avg(f9) > 0;
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having count(f9) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 3 group by f1 having count(f9) > 0 order by f1;
 if $rows != 1 then
   return -1
 endi
@@ -1610,9 +1606,9 @@ if $data03 != 0.000000000 then
   return -1
 endi
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having last(f9) > 0;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 3 group by f1 having last(f9) > 0;
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having last(f2) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 3 group by f1 having last(f2) > 0 order by f1;
 if $rows != 1 then
   return -1
 endi
@@ -1629,7 +1625,7 @@ if $data03 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 3 group by f1 having last(f3) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 3 group by f1 having last(f3) > 0 order by f1;
 if $rows != 1 then
   return -1
 endi
@@ -1646,7 +1642,7 @@ if $data03 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 group by f1 having last(f3) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 1 group by f1 having last(f3) > 0 order by f1;
 if $rows != 3 then
   return -1
 endi
@@ -1687,7 +1683,7 @@ if $data23 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 group by f1 having last(f4) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 1 group by f1 having last(f4) > 0 order by f1;
 if $rows != 3 then
   return -1
 endi
@@ -1728,7 +1724,7 @@ if $data23 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 group by f1 having last(f5) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 1 group by f1 having last(f5) > 0 order by f1;
 if $rows != 3 then
   return -1
 endi
@@ -1769,7 +1765,7 @@ if $data23 != 0.000000000 then
   return -1
 endi
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 group by f1 having last(f6) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 1 group by f1 having last(f6) > 0 order by f1;
 if $rows != 3 then
   return -1
 endi
@@ -1811,17 +1807,17 @@ if $data23 != 0.000000000 then
 endi
 
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f2 from tb1 where f2 > 1 group by f1 having last(f6) > 0;
+sql_error select avg(f1),spread(f1),spread(f2),spread(tb1.f1),f1,f2 from tb1 where f2 > 1 group by f1 having last(f6) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f6 from tb1 where f2 > 1 group by f1 having last(f6) > 0;
+sql_error select avg(f1),spread(f1),spread(f2),spread(tb1.f1),f1,f6 from tb1 where f2 > 1 group by f1 having last(f6) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f6 from tb1 where f2 > 1 group by f1,f2 having last(f6) > 0;
+sql_error select avg(f1),spread(f1),spread(f2),spread(tb1.f1),f1,f6 from tb1 where f2 > 1 group by f1,f2 having last(f6) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f6 from tb1 where f2 > 1 group by f1,id1 having last(f6) > 0;
+sql_error select avg(f1),spread(f1),spread(f2),spread(tb1.f1),f1,f6 from tb1 where f2 > 1 group by f1,id1 having last(f6) > 0;
 
-sql_error select avg(f1),spread(f1,f2,tb1.f1),f1,f6 from tb1 where f2 > 1 group by id1 having last(f6) > 0;
+sql_error select avg(f1),spread(f1),spread(f2),spread(tb1.f1),f1,f6 from tb1 where f2 > 1 group by id1 having last(f6) > 0;
 
-sql select avg(f1),spread(f1,f2,tb1.f1) from tb1 where f2 > 1 and f2 < 4 group by f1 having last(f6) > 0 order by f1;
+sql select avg(f1), spread(f1), spread(f2), spread(tb1.f1) from tb1 where f2 > 1 and f2 < 4 group by f1 having last(f6) > 0 order by f1;
 if $rows != 2 then
   return -1
 endi

tests/script/tsim/parser/import_file.sim

@@ -7,8 +7,11 @@ sql drop database if exists indb
 sql create database if not exists indb
 sql use indb
 
-$inFileName = '/tmp/data.csv'
-$numOfRows = 10000
+$inFileName = '/tmp/data.sql'
+system_content printf %OS%
+if $system_content == Windows_NT then
+  $inFileName = 'C:\\Windows\\Temp\\data.sql'
+endi
 system tsim/parser/gendata.sh
 
 sql create table stbx (ts TIMESTAMP, collect_area NCHAR(12), device_id BINARY(16), imsi BINARY(16),  imei BINARY(16),  mdn BINARY(10), net_type BINARY(4), mno NCHAR(4), province NCHAR(10), city NCHAR(16), alarm BINARY(2)) tags(a int, b binary(12));
@@ -16,8 +19,8 @@ sql create table stbx (ts TIMESTAMP, collect_area NCHAR(12), device_id BINARY(16
 sql create table tbx (ts TIMESTAMP, collect_area NCHAR(12), device_id BINARY(16), imsi BINARY(16),  imei BINARY(16),  mdn BINARY(10), net_type BINARY(4), mno NCHAR(4), province NCHAR(10), city NCHAR(16), alarm BINARY(2))
 print ====== create tables success, starting insert data
 
-sql insert into tbx file '/tmp/data.sql'
-sql import into tbx file '/tmp/data.sql'
+sql insert into tbx file $inFileName
+sql import into tbx file $inFileName
 
 sql select count(*) from tbx
 if $rows != 1 then
@@ -31,8 +34,8 @@ endi
 
 sql drop table tbx;
 
-sql insert into tbx using stbx tags(1,'abc') file '/tmp/data.sql';
-sql insert into tbx using stbx tags(1,'abc') file '/tmp/data.sql';
+sql insert into tbx using stbx tags(1,'abc') file $inFileName ;
+sql insert into tbx using stbx tags(1,'abc') file $inFileName ;
 
 sql select count(*) from tbx
 if $rows != 1 then
@@ -44,7 +47,7 @@ if $data00 != 3 then
 endi
 
 sql drop table tbx;
-sql insert into tbx using stbx(b) tags('abcf') file '/tmp/data.sql';
+sql insert into tbx using stbx(b) tags('abcf') file $inFileName ;
 
 sql select ts,a,b from tbx;
 if $rows != 3 then
@@ -64,6 +67,6 @@ if $data02 != @abcf@ then
   return -1
 endi
 
-system rm -f /tmp/data.sql
+system rm -f $inFileName
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

tests/script/tsim/parser/lastrow.sim

@@ -64,21 +64,4 @@ sql connect
 
 run tsim/parser/lastrow_query.sim
 
-print =================== last_row + nested query
-sql use $db
-sql create table lr_nested(ts timestamp, f int)
-sql insert into lr_nested values(now, 1)
-sql insert into lr_nested values(now+1s, null)
-sql select last_row(*) from (select * from lr_nested)
-if $rows != 1 then
-  return -1
-endi
-if $data01 != NULL then
-  return -1
-endi
-sql select last_row(*) from (select f from lr_nested)
-if $rows != 1 then
-  return -1
-endi
-
 system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/tsim/parser/lastrow2.sim

+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/exec.sh -n dnode1 -s start
+sql connect
+
+sql create database d1;
+sql use d1;
+
+print ========>td-1317, empty table last_row query crashed
+sql drop table if exists m1;
+sql create table m1(ts timestamp, k int) tags (a int);
+sql create table t1 using m1 tags(1);
+sql create table t2 using m1 tags(2);
+
+sql select last_row(*) from t1
+if $rows != 0 then
+  return -1
+endi
+sql select last_row(*) from m1
+if $rows != 0 then
+  return -1
+endi
+sql select last_row(*) from m1 where tbname in ('t1')
+if $rows != 0 then
+  return -1
+endi
+
+sql insert into t1 values('2019-1-1 1:1:1', 1);
+print ===================> last_row query against normal table along with ts/tbname
+sql select last_row(*),ts,'k' from t1;
+if $rows != 1 then
+  return -1
+endi
+
+print ===================> last_row + user-defined column + normal tables
+sql select last_row(ts), 'abc', 1234.9384, ts from t1
+if $rows != 1 then
+  return -1
+endi
+if $data01 != @abc@ then
+  print expect abc, actual $data02
+  return -1
+endi
+if $data02 !=  1234.938400000 then
+  return -1
+endi
+if $data03 != @19-01-01 01:01:01.000@ then
+  print expect 19-01-01 01:01:01.000, actual:$data03
+  return -1
+endi
+
+print ===================> last_row + stable + ts/tag column + condition + udf
+sql select last_row(*), ts, 'abc', 123.981, tbname from m1
+if $rows != 1 then
+  return -1
+endi
+if $data02 != @19-01-01 01:01:01.000@ then
+    return -1
+endi
+if $data03 != @abc@ then
+    return -1
+endi
+if $data04 != 123.981000000 then
+    print expect 123.981000000, actual: $data04
+    return -1
+endi
+
+sql create table tu(ts timestamp, k int)
+sql select last_row(*) from tu
+if $row != 0 then
+  return -1
+endi
+
+print =================== last_row + nested query
+sql create table lr_nested(ts timestamp, f int)
+sql insert into lr_nested values(now, 1)
+sql insert into lr_nested values(now+1s, null)
+sql select last_row(*) from (select * from lr_nested)
+if $rows != 1 then
+  return -1
+endi
+if $data01 != NULL then
+  return -1
+endi
+
+#sql select last_row(*) from (select f from lr_nested)
+#if $rows != 1 then
+#  return -1
+#endi
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/tsim/parser/lastrow_query.sim

@@ -79,19 +79,6 @@ endi
 if  $data03 != NULL then
   return -1
 endi
-if $data11 != 7 then
-  return -1
-endi
-if $data12 != 7 then
-  return -1
-endi
-if $data13 != 59 then
-  print expect 59, actual: $data03
-  return -1
-endi
-if $data14 != 7 then
-  return -1
-endi
 
 sql select t1,t1,count(*),t1,t1 from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by t1 interval(1h) fill(NULL) limit 9
 if $rows != 18 then
@@ -129,43 +116,41 @@ if $rows != 1 then
 endi
 
 sql select count(*),tbname,t1,t1,tbname from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by tbname, t1 interval(1d) fill(NULL) slimit 1 soffset 1
-if $rows != 0 then
+if $rows != 1 then
   return -1
 endi
 
 sql select count(*),tbname,t1,t1,tbname from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by tbname, t1 interval(1d) fill(NULL) slimit 1 soffset 0
-if $rows != 0 then
+if $rows != 1 then
   return -1
 endi
 
-return
-
 sql select t1,t1,count(*),tbname,t1,t1,tbname from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by tbname, t1 interval(1s) fill(NULL) slimit 2 soffset 0 limit 250000 offset 1
-if $rows != 172799 then
+if $rows != 172798 then
   return -1
 endi
 
 sql select t1,t1,count(*),tbname,t1,t1,tbname from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by tbname, t1 interval(1s) fill(NULL) slimit 1 soffset 0 limit 250000 offset 1
-if $rows != 86399 then
+if $rows != 85648 then
   return -1
 endi
 
-sql select t1,t1,count(*),t1,t1 from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by t1 interval(1h) fill(NULL) order by ts DESC limit 30
-if $rows != 30 then
+sql select t1,t1,count(*),t1,t1 from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by t1 interval(1h) fill(NULL) limit 30
+if $rows != 48 then
   return -1
 endi
 
 sql select t1,t1,count(*),t1,t1 from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by t1 interval(1h) fill(NULL) limit 2
-if $rows != 2 then
+if $rows != 4 then
   return -1
 endi
 
 sql select t1,t1,count(*),tbname,t1,t1,tbname from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by tbname, t1 interval(1s) fill(NULL) slimit 1 soffset 1 limit 250000 offset 1
-if $rows != 86399 then
+if $rows != 87150 then
   return -1
 endi
 
-sql select t1,t1,count(*),t1,t1 from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by t1 interval(1h) fill(NULL) order by ts desc limit 1
+sql select t1,t1,count(*),t1,t1 from lr_stb0 where ts>'2018-09-24 00:00:00.000' and ts<'2018-09-25 00:00:00.000' partition by t1 interval(1h) fill(NULL) limit 1
 if $rows != 2 then
   return -1
 endi
@@ -174,68 +159,3 @@ sql select t1,t1,count(*),t1,t1 from lr_stb0 where ts>'2018-09-24 00:00:00.000'
 if $rows != 46 then
   return -1
 endi
-
-print ========>td-1317, empty table last_row query crashed
-sql drop table if exists m1;
-sql create table m1(ts timestamp, k int) tags (a int);
-sql create table t1 using m1 tags(1);
-sql create table t2 using m1 tags(2);
-
-sql select last_row(*) from t1
-if $rows != 0 then
-  return -1
-endi
-sql select last_row(*) from m1
-if $rows != 0 then
-  return -1
-endi
-sql select last_row(*) from m1 where tbname in ('t1')
-if $rows != 0 then
-  return -1
-endi
-
-sql insert into t1 values('2019-1-1 1:1:1', 1);
-print ===================> last_row query against normal table along with ts/tbname
-sql select last_row(*),ts,'k' from t1;
-if $rows != 1 then
-  return -1
-endi
-
-print ===================> last_row + user-defined column + normal tables
-sql select last_row(ts), 'abc', 1234.9384, ts from t1
-if $rows != 1 then
-  return -1
-endi
-if $data01 != @abc@ then
-  print expect abc, actual $data02
-  return -1
-endi
-if $data02 !=  1234.938400000 then
-  return -1
-endi
-if $data03 != @19-01-01 01:01:01.000@ then
-  print expect 19-01-01 01:01:01.000, actual:$data03
-  return -1
-endi
-
-print ===================> last_row + stable + ts/tag column + condition + udf
-sql select last_row(*), ts, 'abc', 123.981, tbname from m1
-if $rows != 1 then
-  return -1
-endi
-if $data02 != @19-01-01 01:01:01.000@ then
-    return -1
-endi
-if $data03 != @abc@ then
-    return -1
-endi
-if $data04 != 123.981000000 then
-    print expect 123.981000000, actual: $data04
-    return -1
-endi
-
-sql create table tu(ts timestamp, k int)
-sql select last_row(*) from tu
-if $row != 0 then
-  return -1
-endi

tests/script/tsim/parser/null_char.sim

@@ -285,7 +285,7 @@ if $data02 != 2147483647 then
   return -1
 endi
 
-sql_error alter table st41 set tag tag_int = -2147483648
+sql alter table st41 set tag tag_int = -2147483648
 sql_error alter table st41 set tag tag_int = 2147483648
 
 sql alter table st41 set tag tag_int = '-379'
@@ -304,8 +304,8 @@ if $data02 != NULL then
   print ==10== expect: NULL, actually: $data02
   return -1
 endi
-sql alter table st41 set tag tag_int = 'NULL'
-sql_error alter table st41 set tag tag_int = ''
+sql_error alter table st41 set tag tag_int = 'NULL'
+sql alter table st41 set tag tag_int = ''
 sql_error alter table st41 set tag tag_int = abc379
 
 ################### bool
@@ -331,8 +331,8 @@ if $data03 != 1 then
 endi
 sql alter table st41 set tag tag_bool = 'NULL'
 sql select tag_binary, tag_nchar, tag_int, tag_bool, tag_float, tag_double from  st41
-if $data03 != NULL then
-  print ==14== expect: NULL, actually: $data03
+if $data03 != 0 then
+  print ==14== expect: 0, actually: $data03
   return -1
 endi
 sql alter table st41 set tag tag_bool = NULL
@@ -341,8 +341,8 @@ if $data03 != NULL then
   return -1
 endi
 
-sql_error alter table st41 set tag tag_bool = '123'
-sql_error alter table st41 set tag tag_bool = ''
+sql alter table st41 set tag tag_bool = '123'
+sql alter table st41 set tag tag_bool = ''
 sql_error alter table st41 set tag tag_bool = abc379
 
 ################### float
@@ -378,8 +378,8 @@ if $data04 != NULL then
 endi
 sql alter table st41 set tag tag_float = 'NULL'
 sql select tag_binary, tag_nchar, tag_int, tag_bool, tag_float, tag_double from  st41
-if $data04 != NULL then
-  print ==17== expect: NULL, actually : $data04
+if $data04 != 0.00000 then
+  print ==17== expect: 0.00000, actually : $data04
   return -1
 endi
 sql alter table st41 set tag tag_float = '54.123456'
@@ -394,10 +394,10 @@ if $data04 != -54.12346 then
   print ==19== expect: -54.12346, actually : $data04
   return -1
 endi
-sql_error alter table st41 set tag tag_float = ''
+sql alter table st41 set tag tag_float = ''
 
-sql_error alter table st41 set tag tag_float = 'abc'
-sql_error alter table st41 set tag tag_float = '123abc'
+sql alter table st41 set tag tag_float = 'abc'
+sql alter table st41 set tag tag_float = '123abc'
 sql_error alter table st41 set tag tag_float = abc
 
 ################### double
@@ -426,20 +426,20 @@ if $data05 != NULL then
 endi
 sql alter table st41 set tag tag_double = 'NULL'
 sql select tag_binary, tag_nchar, tag_int, tag_bool, tag_float, tag_double from  st41
-if $data05 != NULL then
-  print ==20== expect: NULL, actually : $data05
+if $data05 != 0.000000000 then
+  print ==20== expect: 0.000000000, actually : $data05
   return -1
 endi
-sql_error alter table st41 set tag tag_double = ''
 
-
-sql_error alter table st41 set tag tag_double = 'abc'
-sql_error alter table st41 set tag tag_double = '123abc' 
+sql alter table st41 set tag tag_double = ''
+sql alter table st41 set tag tag_double = 'abc'
+sql alter table st41 set tag tag_double = '123abc' 
 sql_error alter table st41 set tag tag_double = abc
 
 ################### bigint smallint tinyint
 sql create table mt5 (ts timestamp, c1 int) tags (tag_bigint bigint, tag_smallint smallint, tag_tinyint tinyint)
 sql create table st51 using mt5 tags (1, 2, 3)
+sql insert into st51 values(now, 1)
 sql alter table st51 set tag tag_bigint = '-379'
 sql alter table st51 set tag tag_bigint = -2000
 sql alter table st51 set tag tag_bigint = NULL
@@ -455,10 +455,10 @@ sql select tag_bigint, tag_smallint, tag_tinyint from st51
 if $data00 != -9223372036854775807 then
   return -1
 endi
-sql_error alter table st51 set tag tag_bigint = -9223372036854775808
+sql alter table st51 set tag tag_bigint = -9223372036854775808
 
-sql alter table st51 set tag tag_bigint = 'NULL'
-sql_error alter table st51 set tag tag_bigint = ''
+sql_error alter table st51 set tag tag_bigint = 'NULL'
+sql alter table st51 set tag tag_bigint = ''
 sql_error alter table st51 set tag tag_bigint = abc379
 
 ####
@@ -476,10 +476,10 @@ sql select tag_bigint, tag_smallint, tag_tinyint from st51
 if $data01 != -32767 then
   return -1
 endi
-sql_error alter table st51 set tag tag_smallint = -32768
+sql alter table st51 set tag tag_smallint = -32768
 
-sql alter table st51 set tag tag_smallint = 'NULL'
-sql_error alter table st51 set tag tag_smallint = ''
+sql_error alter table st51 set tag tag_smallint = 'NULL'
+sql alter table st51 set tag tag_smallint = ''
 sql_error alter table st51 set tag tag_smallint = abc379
 
 ####
@@ -495,15 +495,13 @@ sql select tag_bigint, tag_smallint, tag_tinyint from st51
 if $data02 != -127 then
   return -1
 endi
-sql_error alter table st51 set tag tag_tinyint = '-128'
+sql alter table st51 set tag tag_tinyint = '-128'
 sql_error alter table st51 set tag tag_tinyint = 128
-sql alter table st51 set tag tag_tinyint = 'NULL'
-sql_error alter table st51 set tag tag_tinyint = ''
+sql_error alter table st51 set tag tag_tinyint = 'NULL'
+sql alter table st51 set tag tag_tinyint = ''
 sql_error alter table st51 set tag tag_tinyint = abc379
 
-
 # test end   
 #sql drop database $db
 
-
 system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/tsim/parser/sliding.sim

@@ -356,9 +356,6 @@ if $data03 != 0.000000000 then
  return -1
 endi
 
-#TODO
-return
-
 sql select count(c2),last(c4),stddev(c3),spread(c3) from sliding_tb0 where c2 = 0 interval(30s) sliding(20s) order by _wstart desc limit 1 offset 15;
 if $row != 1 then
  return -1

tests/script/tsim/parser/slimit1_query.sim

@@ -11,82 +11,54 @@ $db = $dbPrefix
 
 sql use $db
 
-#### group by t2,t1 + slimit
-sql select count(*) from stb group by t2,t1 order by t2 asc slimit 5 soffset 6
+#### partition by t2,t1 + slimit
+sql select count(*) from stb partition by t2,t1 slimit 5 soffset 6
 if $rows != 3 then
   return -1
 endi
-if $data00 != $rowNum then
-  return -1
-endi
-if $data01 != 2 then
-  return -1
-endi
-if $data02 != 6 then
-  return -1
-endi
-if $data10 != $rowNum then
-  return -1
-endi
-if $data11 != 2 then
-  return -1
-endi
-if $data12 != 7 then
-  return -1
-endi
-$res = 2 * $rowNum
-if $data20 != $res then
-  return -1
-endi
-if $data21 != 2 then
-  return -1
-endi
-if $data22 != 8 then
-  return -1
-endi
+
 ## desc
-sql select count(*) from stb group by t2,t1 order by t2 desc slimit 5 soffset 0
-if $rows != 5 then
+sql select count(*),t2,t1 from stb partition by t2,t1 order by t2,t1 asc  slimit 5 soffset 0
+if $rows != 9 then
   return -1
 endi
-$res = 2 * $rowNum
-if $data00 != $res then
+if $data00 != 300 then
   return -1
 endi
-if $data01 != 2 then
+if $data01 != 0 then
   return -1
 endi
-if $data02 != 8 then
+if $data02 != 0 then
   return -1
 endi
-if $data10 != $rowNum then
+if $data10 != 300 then
   return -1
 endi
-if $data11 != 2 then
+if $data11 != 0 then
   return -1
 endi
-if $data12 != 7 then
+if $data12 != 1 then
   return -1
 endi
-if $data20 != $rowNum then
+if $data20 != 300 then
   return -1
 endi
-if $data21 != 2 then
+if $data21 != 0 then
   return -1
 endi
-if $data22 != 6 then
+if $data22 != 2 then
   return -1
 endi
-if $data30 != $rowNum then
+if $data30 != 300 then
   return -1
 endi
 if $data31 != 1 then
   return -1
 endi
-if $data32 != 5 then
+if $data32 != 3 then
   return -1
 endi
-if $data40 != $rowNum then
+if $data40 != 300 then
   return -1
 endi
 if $data41 != 1 then
@@ -97,87 +69,70 @@ if $data42 != 4 then
 endi
 
 ### empty result set
-#sql select count(*) from stb group by t2,t1 order by t2 asc slimit 0 soffset 0
-#if $rows != 0 then
-#  return -1
-#endi
-#sql select count(*) from stb group by t2,t1 order by t2 asc slimit 5 soffset 10
-#if $rows != 0 then
-#  return -1
-#endi
-
-#### group by t2 + slimit
-sql select count(*) from stb group by t2 order by t2 asc slimit 2 soffset 0
-if $rows != 2 then
+sql select count(*) from stb partition by t2,t1 order by t2 asc slimit 0 soffset 0
+if $rows != 9 then
   return -1
 endi
-$res = 3 * $rowNum
-if $data00 != $res then
+
+sql select count(*) from stb partition by t2,t1 order by t2 asc slimit 5 soffset 10
+if $rows != 0 then
   return -1
 endi
-if $data10 != $res then
+
+#### partition by t2 + slimit
+sql select t2, count(*) from stb partition by t2 order by t2 asc slimit 2 soffset 0
+if $rows != 3 then
   return -1
 endi
-if $data01 != 0 then
+if $data00 != 0 then
   return -1
 endi
-if $data11 != 1 then
-  return -1 
-endi
-
-sql select count(*) from stb group by t2 order by t2 desc slimit 2 soffset 0
-if $rows != 2 then
+if $data10 != 1 then
   return -1
 endi
-$res = 4 * $rowNum
-if $data00 != $res then
+if $data20 != 2 then
   return -1
 endi
-$res = 3 * $rowNum
-if $data10 != $res then
+if $data01 != 900 then
   return -1
 endi
-if $data01 != 2 then
-  return -1
+if $data11 != 900 then
+  return -1 
 endi
-if $data11 != 1 then
+if $data21 != 1200 then
   return -1 
 endi
 
-sql select count(*) from stb group by t2 order by t2 asc slimit 2 soffset 1
-if $rows != 2 then
+sql select t2, count(*) from stb partition by t2 order by t2 desc slimit 2 soffset 0
+if $rows != 3 then
   return -1
 endi
-$res = 3 * $rowNum
-if $data00 != $res then
+if $data00 != 2 then
   return -1
 endi
-$res = 4 * $rowNum
-if $data10 != $res then
+if $data10 != 1 then
   return -1
 endi
-if $data01 != 1 then
+if $data20 != 0 then
   return -1
 endi
-if $data11 != 2 then
-  return -1 
-endi
-
-sql select count(*) from stb group by t2 order by t2 desc slimit 2 soffset 1
-if $rows != 2 then
+if $data01 != 1200 then
   return -1
 endi
-$res = 3 * $rowNum
-if $data00 != $res then
-  return -1
+if $data11 != 900 then
+  return -1 
 endi
-if $data10 != $res then
-  return -1
+if $data21 != 900 then
+  return -1 
 endi
-if $data01 != 1 then
+
+sql select count(*) from stb partition by t2 order by t2 asc slimit 2 soffset 1
+if $rows != 0 then
   return -1
 endi
-if $data11 != 0 then
-  return -1 
+
+sql select count(*) from stb partition by t2 order by t2 desc slimit 2 soffset 1
+if $rows != 0 then
+  return -1
 endi
 

tests/script/tsim/query/scalarNull.sim

@@ -89,10 +89,4 @@ endi
 #TODO: MOVE IT TO NORMAL CASE
 sql_error select * from tb1 where not (null);
 
-sql select sum(1/0) from tb1;
-if $rows != 1 then
-  return -1
-endi
-
-
 system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/tsim/valgrind/checkError6.sim

@@ -50,7 +50,6 @@ sql select avg(tbcol) from tb1
 sql select avg(tbcol) from tb1 where ts <= 1601481840000
 sql select avg(tbcol) as b from tb1
 sql select avg(tbcol) as b from tb1 interval(1d)
-goto _OVER
 sql select avg(tbcol) as b from tb1 where ts <= 1601481840000s interval(1m)
 sql select avg(tbcol) as c from stb
 sql select avg(tbcol) as c from stb where ts <= 1601481840000

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

@@ -253,6 +253,9 @@ class TDTestCase:
         tdSql.execute(f'alter table {self.stbname}_{tb_no} set tag {tag} = {values}')
         tdSql.query(f'select {tag} from {self.stbname}_{tb_no}')
         tdSql.checkData(0,0,values)
+        tdSql.execute(f'alter table {self.stbname}_{tb_no} set tag {tag} = null')
+        tdSql.query(f'select {tag} from {self.stbname}_{tb_no}')
+        tdSql.checkData(0,0,None)
     def alter_check_stb(self):
         tdSql.prepare()
         tdSql.execute(self.setsql.set_create_stable_sql(self.stbname,self.column_dict,self.tag_dict))

tests/system-test/fulltest.sh

@@ -189,7 +189,7 @@ python3 ./test.py -f 7-tmq/subscribeStb3.py
 python3 ./test.py -f 7-tmq/subscribeStb4.py
 python3 ./test.py -f 7-tmq/db.py
 python3 ./test.py -f 7-tmq/tmqError.py
-#python3 ./test.py -f 7-tmq/schema.py
+python3 ./test.py -f 7-tmq/schema.py
 python3 ./test.py -f 7-tmq/stbFilter.py
 python3 ./test.py -f 7-tmq/tmqCheckData.py
 python3 ./test.py -f 7-tmq/tmqCheckData1.py

tests/system-test/test-all.bat

@@ -91,4 +91,6 @@ goto :eof
 :CheckSkipCase
 set skipCase=false
 if "%*" == "python3 ./test.py -f 1-insert/insertWithMoreVgroup.py" ( set skipCase=true )
+if "%*" == "python3 ./test.py -f 2-query/queryQnode.py" ( set skipCase=true )
+echo %* | grep "\-R" && set skipCase=true
 :goto eof
\ No newline at end of file

tests/system-test/test.py

@@ -328,7 +328,7 @@ if __name__ == "__main__":
                 conn = taos.connect(host,config=tdDnodes.getSimCfgPath())
             else:
                 conn = taosrest.connect(url=f"http://{host}:6041")
-            tdLog.info(tdDnodes.getSimCfgPath(),host)
+            # tdLog.info(tdDnodes.getSimCfgPath(),host)
             if createDnodeNums == 1:
                 createDnodeNums=dnodeNums
             else:

tools/CMakeLists.txt

 IF (TD_WEBSOCKET)
     MESSAGE("${Green} use libtaos-ws${ColourReset}")
-    IF (TD_LINUX)
-        IF (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/taosws-rs/target/release/libtaosws.so" OR "${CMAKE_CURRENT_SOURCE_DIR}/taosws-rs/target/release/libtaosws.so" IS_NEWER_THAN "${CMAKE_SOURCE_DIR}/.git/modules/tools/taosws-rs/FETCH_HEAD")
-            include(ExternalProject)
-            ExternalProject_Add(taosws-rs
-                    PREFIX        "taosws-rs"
-                    SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR}/taosws-rs
-                    BUILD_ALWAYS         off
-                    DEPENDS             taos
-                    BUILD_IN_SOURCE     1
-                    CONFIGURE_COMMAND cmake -E echo "taosws-rs no need cmake to config"
-                    PATCH_COMMAND
-                    COMMAND     git clean -f -d
-                    BUILD_COMMAND
-                    COMMAND cargo build --release -p taos-ws-sys
-                    COMMAND ./taos-ws-sys/ci/package.sh
-                    INSTALL_COMMAND
-                    COMMAND cmake -E copy target/libtaosws/libtaosws.so ${CMAKE_BINARY_DIR}/build/lib
-                    COMMAND cmake -E make_directory ${CMAKE_BINARY_DIR}/build/include
-                    COMMAND cmake -E copy target/libtaosws/taosws.h ${CMAKE_BINARY_DIR}/build/include
-                    )
-        ELSE()
-            include(ExternalProject)
-            ExternalProject_Add(taosws-rs
-                    PREFIX        "taosws-rs"
-                    SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR}/taosws-rs
-                    BUILD_ALWAYS         on
-                    DEPENDS             taos
-                    BUILD_IN_SOURCE     1
-                    CONFIGURE_COMMAND cmake -E echo "taosws-rs no need cmake to config"
-                    PATCH_COMMAND
-                    COMMAND     git clean -f -d
-                    BUILD_COMMAND
-                    COMMAND cargo build --release -p taos-ws-sys
-                    COMMAND ./taos-ws-sys/ci/package.sh
-                    INSTALL_COMMAND
-                    COMMAND cmake -E copy target/libtaosws/libtaosws.so ${CMAKE_BINARY_DIR}/build/lib
-                    COMMAND cmake -E make_directory ${CMAKE_BINARY_DIR}/build/include
-                    COMMAND cmake -E copy target/libtaosws/taosws.h ${CMAKE_BINARY_DIR}/build/include
-                    )
-        ENDIF ()
-    ENDIF()
+    IF (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/taosws-rs/target/release/libtaosws.so" OR "${CMAKE_CURRENT_SOURCE_DIR}/taosws-rs/target/release/libtaosws.so" IS_NEWER_THAN "${CMAKE_SOURCE_DIR}/.git/modules/tools/taosws-rs/FETCH_HEAD")
+        include(ExternalProject)
+        ExternalProject_Add(taosws-rs
+            PREFIX        "taosws-rs"
+            SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR}/taosws-rs
+            BUILD_ALWAYS         off
+            DEPENDS             taos
+            BUILD_IN_SOURCE     1
+            CONFIGURE_COMMAND cmake -E echo "taosws-rs no need cmake to config"
+            PATCH_COMMAND
+            COMMAND     git clean -f -d
+            BUILD_COMMAND
+            COMMAND cargo build --release -p taos-ws-sys
+            COMMAND ./taos-ws-sys/ci/package.sh
+            INSTALL_COMMAND
+            COMMAND cmake -E copy target/libtaosws/libtaosws.so ${CMAKE_BINARY_DIR}/build/lib
+            COMMAND cmake -E make_directory ${CMAKE_BINARY_DIR}/build/include
+            COMMAND cmake -E copy target/libtaosws/taosws.h ${CMAKE_BINARY_DIR}/build/include
+            )
+    ELSE()
+        include(ExternalProject)
+        ExternalProject_Add(taosws-rs
+            PREFIX        "taosws-rs"
+            SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR}/taosws-rs
+            BUILD_ALWAYS         on
+            DEPENDS             taos
+            BUILD_IN_SOURCE     1
+            CONFIGURE_COMMAND cmake -E echo "taosws-rs no need cmake to config"
+            PATCH_COMMAND
+            COMMAND     git clean -f -d
+            BUILD_COMMAND
+            COMMAND cargo build --release -p taos-ws-sys
+            COMMAND ./taos-ws-sys/ci/package.sh
+            INSTALL_COMMAND
+            COMMAND cmake -E copy target/libtaosws/libtaosws.so ${CMAKE_BINARY_DIR}/build/lib
+            COMMAND cmake -E make_directory ${CMAKE_BINARY_DIR}/build/include
+            COMMAND cmake -E copy target/libtaosws/taosws.h ${CMAKE_BINARY_DIR}/build/include
+            )
+    ENDIF ()
 ENDIF ()
 
 IF (TD_TAOS_TOOLS)

taos-tools @ 9cfa1957

-Subproject commit 0b8a3373bb7548f8106d13e7d3b0a988d3c4d48a
+Subproject commit 9cfa195713d1cae9edf417a8d49bde87dd971016