[TD-1568]merge from develop

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "tests/examples/rust"]
 	path = tests/examples/rust
 	url = https://github.com/songtianyi/tdengine-rust-bindings.git
+[submodule "deps/jemalloc"]
+	path = deps/jemalloc
+	url = https://github.com/jemalloc/jemalloc

cmake/define.inc

@@ -59,6 +59,11 @@ IF (TD_LINUX_64)
   MESSAGE(STATUS "linux64 is defined")
   SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
   ADD_DEFINITIONS(-DUSE_LIBICONV)
+
+  IF (JEMALLOC_ENABLED)
+    ADD_DEFINITIONS(-DTD_JEMALLOC_ENABLED -I${CMAKE_BINARY_DIR}/build/include -L${CMAKE_BINARY_DIR}/build/lib -Wl,-rpath,${CMAKE_BINARY_DIR}/build/lib -ljemalloc)
+  ENDIF ()
+
 ENDIF ()
 
 IF (TD_LINUX_32)

cmake/input.inc

@@ -72,3 +72,8 @@ IF (${RANDOM_NETWORK_FAIL} MATCHES "true")
   SET(TD_RANDOM_NETWORK_FAIL TRUE)
   MESSAGE(STATUS "build with random-network-fail enabled")
 ENDIF ()
+
+IF (${JEMALLOC_ENABLED} MATCHES "true")
+  SET(TD_JEMALLOC_ENABLED TRUE)
+  MESSAGE(STATUS "build with jemalloc enabled")
+ENDIF ()

deps/CMakeLists.txt

@@ -18,3 +18,16 @@ ENDIF ()
 IF (TD_DARWIN AND TD_MQTT)
   ADD_SUBDIRECTORY(MQTT-C)
 ENDIF ()
+
+IF (TD_LINUX_64 AND JEMALLOC_ENABLED)
+  MESSAGE("setup dpes/jemalloc, current source dir:" ${CMAKE_CURRENT_SOURCE_DIR})
+  MESSAGE("binary dir:" ${CMAKE_BINARY_DIR})
+  include(ExternalProject)
+  ExternalProject_Add(jemalloc
+    PREFIX        "jemalloc"
+    SOURCE_DIR    ${CMAKE_CURRENT_SOURCE_DIR}/jemalloc
+    BUILD_IN_SOURCE     1
+    CONFIGURE_COMMAND   ./autogen.sh COMMAND ./configure --prefix=${CMAKE_BINARY_DIR}/build/
+    BUILD_COMMAND       ${MAKE}
+  )
+ENDIF ()

deps/jemalloc

@@ -0,0 +1 @@
+Subproject commit ea6b3e973b477b8061e0076bb257dbd7f3faa756

documentation20/cn/03.architecture/02.replica/docs.md

@@ -107,9 +107,9 @@ TDengine采取的是Master-Slave模式进行同步，与流行的RAFT一致性
 
 ![replica-forward.png](page://images/architecture/replica-forward.png)
 
-1. 应用对写请求做基本的合法性检查，通过，则给改请求包打上一个版本号(version, 单调递增）
+1. 应用对写请求做基本的合法性检查，通过，则给该请求包打上一个版本号(version, 单调递增）
 2. 应用将打上版本号的写请求封装一个WAL Head, 写入WAL(Write Ahead Log)
-3. 应用调用API syncForwardToPeer，如多vnode B是slave状态，sync模块将包含WAL Head的数据包通过Forward消息发送给vnode B，否则就不转发。
+3. 应用调用API syncForwardToPeer，如果vnode B是slave状态，sync模块将包含WAL Head的数据包通过Forward消息发送给vnode B，否则就不转发。
 4. vnode B收到Forward消息后，调用回调函数writeToCache, 交给应用处理
 5. vnode B应用在写入成功后，都需要调用syncAckForward通知sync模块已经写入成功。
 6. 如果quorum大于1，vnode B需要等待应用的回复确认，收到确认后，vnode B发送Forward Response消息给node A。
@@ -219,7 +219,7 @@ Arbitrator的程序tarbitrator.c在复制模块的同一目录, 编译整个系
 
 不同之处：
 
-- 选举流程不一样：Raft里任何一个节点是candidate时，主动向其他节点发出vote request, 如果超过半数回答Yes, 这个candidate就成为Leader,开始一个新的term. 而TDengine的实现里，节点上线、离线或角色改变都会触发状态消息在节点组类传播，等节点组里状态稳定一致之后才触发选举流程，因为状态稳定一致，基于同样的状态信息，每个节点做出的决定会是一致的，一旦某个节点符合成为master的条件，无需其他节点认可，它会自动将自己设为master。TDengine里，任何一个节点检测到其他节点或自己的角色发生改变，就会给节点组内其他节点进行广播的。Raft里不存在这样的机制，因此需要投票来解决。
+- 选举流程不一样：Raft里任何一个节点是candidate时，主动向其他节点发出vote request，如果超过半数回答Yes，这个candidate就成为Leader，开始一个新的term。而TDengine的实现里，节点上线、离线或角色改变都会触发状态消息在节点组内传播，等节点组里状态稳定一致之后才触发选举流程，因为状态稳定一致，基于同样的状态信息，每个节点做出的决定会是一致的，一旦某个节点符合成为master的条件，无需其他节点认可，它会自动将自己设为master。TDengine里，任何一个节点检测到其他节点或自己的角色发生改变，就会向节点组内其他节点进行广播。Raft里不存在这样的机制，因此需要投票来解决。
 - 对WAL的一条记录，Raft用term + index来做唯一标识。但TDengine只用version（类似index)，在TDengine实现里，仅仅用version是完全可行的, 因为TDengine的选举机制，没有term的概念。
 
 如果整个虚拟节点组全部宕机，重启，但不是所有虚拟节点都上线，这个时候TDengine是不会选出master的，因为未上线的节点有可能有最高version的数据。而RAFT协议，只要超过半数上线，就会选出Leader。

documentation20/cn/03.architecture/docs.md

@@ -343,7 +343,7 @@ TDengine采用数据驱动的方式让缓存中的数据写入硬盘进行持久
 
 对于采集的数据，一般有保留时长，这个时长由系统配置参数keep决定。超过这个设置天数的数据文件，将被系统自动删除，释放存储空间。
 
-给定days与keep两个参数，一个vnode总的数据文件数为：keep/days。总的数据文件个数不宜过大，也不宜过小。10到100以内合适。基于这个原则，可以设置合理的days。 目前的版本，参数keep可以修改，但对于参数days，一但设置后，不可修改。
+给定days与keep两个参数，一个典型工作状态的vnode中总的数据文件数为：`向上取整(keep/days)+1`个。总的数据文件个数不宜过大，也不宜过小。10到100以内合适。基于这个原则，可以设置合理的days。 目前的版本，参数keep可以修改，但对于参数days，一但设置后，不可修改。
 
 在每个数据文件里，一张表的数据是一块一块存储的。一张表可以有一到多个数据文件块。在一个文件块里，数据是列式存储的，占用的是一片连续的存储空间，这样大大提高读取速度。文件块的大小由系统参数maxRows（每块最大记录条数）决定，缺省值为4096。这个值不宜过大，也不宜过小。过大，定位具体时间段的数据的搜索时间会变长，影响读取速度；过小，数据块的索引太大，压缩效率偏低，也影响读取速度。
 

documentation20/cn/08.connector/docs.md

@@ -516,7 +516,7 @@ conn.close()
 - _TDengineCursor_ 类
 
   参考python中help(taos.TDengineCursor)。
-  这个类对应客户端进行的写入、查询操作。在客户端多线程的场景下，这个游标实例必须保持线程独享，不能夸线程共享使用，否则会导致返回结果出现错误。
+  这个类对应客户端进行的写入、查询操作。在客户端多线程的场景下，这个游标实例必须保持线程独享，不能跨线程共享使用，否则会导致返回结果出现错误。
 
 - _connect_ 方法
 

documentation20/cn/12.taos-sql/01.error-code/docs.md

@@ -26,7 +26,7 @@
 | TSDB_CODE_COM_OUT_OF_MEMORY             |  0   |       0x0102       | "Out of memory"                              | -2147483390      |
 | TSDB_CODE_COM_INVALID_CFG_MSG           |  0   |       0x0103       | "Invalid config message"                     | -2147483389      |
 | TSDB_CODE_COM_FILE_CORRUPTED            |  0   |       0x0104       | "Data file corrupted"                        | -2147483388      |
-| TSDB_CODE_TSC_INVALID_SQL               |  0   |       0x0200       | "Invalid SQL statement"                      | -2147483136      |
+| TSDB_CODE_TSC_INVALID_OPERATION               |  0   |       0x0200       | "Invalid SQL statement"                      | -2147483136      |
 | TSDB_CODE_TSC_INVALID_QHANDLE           |  0   |       0x0201       | "Invalid qhandle"                            | -2147483135      |
 | TSDB_CODE_TSC_INVALID_TIME_STAMP        |  0   |       0x0202       | "Invalid combination of client/service time" | -2147483134      |
 | TSDB_CODE_TSC_INVALID_VALUE             |  0   |       0x0203       | "Invalid value in client"                    | -2147483133      |

documentation20/cn/12.taos-sql/docs.md

@@ -37,7 +37,7 @@ taos> DESCRIBE meters;
 - Epoch Time：时间戳也可以是一个长整数，表示从 1970-01-01 08:00:00.000 开始的毫秒数
 - 时间可以加减，比如 now-2h，表明查询时刻向前推 2 个小时（最近 2 小时）。数字后面的时间单位可以是 u(微秒)、a(毫秒)、s(秒)、m(分)、h(小时)、d(天)、w(周)。 比如 `select * from t1 where ts > now-2w and ts <= now-1w`，表示查询两周前整整一周的数据。在指定降频操作（down sampling）的时间窗口（interval）时，时间单位还可以使用 n(自然月) 和 y(自然年)。
 
-TDengine 缺省的时间戳是毫秒精度，但通过修改配置参数 enableMicrosecond 就可以支持微秒。
+TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传递的 PRECISION 参数就可以支持微秒。
 
 在TDengine中，普通表的数据模型中可使用以下 10 种数据类型。 
 
@@ -76,7 +76,7 @@ TDengine 缺省的时间戳是毫秒精度，但通过修改配置参数 enableM
  
     4) 一条SQL 语句的最大长度为65480个字符；
  
-    5) 数据库还有更多与存储相关的配置参数，请参见 [服务端配置](https://www.taosdata.com/cn/documentation/taos-sql#management) 章节。
+    5) 数据库还有更多与存储相关的配置参数，请参见 [服务端配置](https://www.taosdata.com/cn/documentation/administrator#config) 章节。
 
 - **显示系统当前参数**
 
@@ -400,6 +400,7 @@ TDengine 缺省的时间戳是毫秒精度，但通过修改配置参数 enableM
                 tb2_name (tb2_field1_name, ...) [USING stb2_name TAGS (tag_value2, ...)] VALUES (field1_value1, ...) (field1_value2, ...) ...;
     ```
     以自动建表的方式，同时向表tb1_name和tb2_name中按列分别插入多条记录。  
+    说明：`(tb1_field1_name, ...)`的部分可以省略掉，这样就是使用全列模式写入——也即在 VALUES 部分提供的数据，必须为数据表的每个列都显式地提供数据。全列写入速度会远快于指定列，因此建议尽可能采用全列写入方式，此时空列可以填入NULL。  
     从 2.0.20.5 版本开始，子表的列名可以不跟在子表名称后面，而是可以放在 TAGS 和 VALUES 之间，例如像下面这样写：
     ```mysql
     INSERT INTO tb1_name [USING stb1_name TAGS (tag_value1, ...)] (tb1_field1_name, ...) VALUES (field1_value1, ...) (field1_value2, ...) ...;
@@ -423,9 +424,9 @@ Query OK, 1 row(s) in set (0.001029s)
 taos> SHOW TABLES;
 Query OK, 0 row(s) in set (0.000946s)
 
-taos> INSERT INTO d1001 USING meters TAGS('Beijing.Chaoyang', 2);
+taos> INSERT INTO d1001 USING meters TAGS('Beijing.Chaoyang', 2) VALUES('a');
 
-DB error: invalid SQL: keyword VALUES or FILE required
+DB error: invalid SQL: 'a' (invalid timestamp) (0.039494s)
 
 taos> SHOW TABLES;
            table_name           |      created_time       | columns |          stable_name           |

packaging/deb/makedeb.sh

@@ -67,7 +67,41 @@ fi
 cp -r ${top_dir}/src/connector/python               ${pkg_dir}${install_home_path}/connector
 cp -r ${top_dir}/src/connector/go                   ${pkg_dir}${install_home_path}/connector
 cp -r ${top_dir}/src/connector/nodejs               ${pkg_dir}${install_home_path}/connector
-cp ${compile_dir}/build/lib/taos-jdbcdriver*dist.*  ${pkg_dir}${install_home_path}/connector ||:
+cp ${compile_dir}/build/lib/taos-jdbcdriver*.*  ${pkg_dir}${install_home_path}/connector ||:
+
+if [ -f ${compile_dir}/build/bin/jemalloc-config ]; then
+    install_user_local_path="/usr/local"
+    mkdir -p ${pkg_dir}${install_user_local_path}/{bin,lib,lib/pkgconfig,include/jemalloc,share/doc/jemalloc,share/man/man3}
+    cp ${compile_dir}/build/bin/jemalloc-config ${pkg_dir}${install_user_local_path}/bin/
+    if [ -f ${compile_dir}/build/bin/jemalloc.sh ]; then
+        cp ${compile_dir}/build/bin/jemalloc.sh ${pkg_dir}${install_user_local_path}/bin/
+    fi
+    if [ -f ${compile_dir}/build/bin/jeprof ]; then
+        cp ${compile_dir}/build/bin/jeprof ${pkg_dir}${install_user_local_path}/bin/
+    fi
+    if [ -f ${compile_dir}/build/include/jemalloc/jemalloc.h ]; then
+        cp ${compile_dir}/build/include/jemalloc/jemalloc.h ${pkg_dir}${install_user_local_path}/include/jemalloc/
+    fi
+    if [ -f ${compile_dir}/build/lib/libjemalloc.so.2 ]; then
+        cp ${compile_dir}/build/lib/libjemalloc.so.2 ${pkg_dir}${install_user_local_path}/lib/
+        ln -sf libjemalloc.so.2 ${pkg_dir}${install_user_local_path}/lib/libjemalloc.so
+    fi
+    if [ -f ${compile_dir}/build/lib/libjemalloc.a ]; then
+        cp ${compile_dir}/build/lib/libjemalloc.a ${pkg_dir}${install_user_local_path}/lib/
+    fi
+    if [ -f ${compile_dir}/build/lib/libjemalloc_pic.a ]; then
+        cp ${compile_dir}/build/lib/libjemalloc_pic.a ${pkg_dir}${install_user_local_path}/lib/
+    fi
+    if [ -f ${compile_dir}/build/lib/pkgconfig/jemalloc.pc ]; then
+        cp ${compile_dir}/build/lib/pkgconfig/jemalloc.pc ${pkg_dir}${install_user_local_path}/lib/pkgconfig/
+    fi
+    if [ -f ${compile_dir}/build/share/doc/jemalloc/jemalloc.html ]; then
+        cp ${compile_dir}/build/share/doc/jemalloc/jemalloc.html ${pkg_dir}${install_user_local_path}/share/doc/jemalloc/
+    fi
+    if [ -f ${compile_dir}/build/share/man/man3/jemalloc.3 ]; then
+        cp ${compile_dir}/build/share/man/man3/jemalloc.3 ${pkg_dir}${install_user_local_path}/share/man/man3/
+    fi
+fi
 
 cp -r ${compile_dir}/../packaging/deb/DEBIAN        ${pkg_dir}/
 chmod 755 ${pkg_dir}/DEBIAN/*

packaging/release.sh

@@ -22,11 +22,12 @@ cpuType=x64      # [aarch32 | aarch64 | x64 | x86 | mips64 ...]
 osType=Linux     # [Linux | Kylin | Alpine | Raspberrypi | Darwin | Windows | Ningsi60 | Ningsi80 |...]
 pagMode=full     # [full | lite]
 soMode=dynamic   # [static | dynamic]
+allocator=glibc  # [glibc | jemalloc]
 dbName=taos      # [taos | power]
 verNumber=""
 verNumberComp="2.0.0.0"
 
-while getopts "hv:V:c:o:l:s:d:n:m:" arg
+while getopts "hv:V:c:o:l:s:d:a:n:m:" arg
 do
   case $arg in
     v)
@@ -53,6 +54,10 @@ do
       #echo "dbName=$OPTARG"
       dbName=$(echo $OPTARG)
       ;;
+    a)
+      #echo "allocator=$OPTARG"
+      allocator=$(echo $OPTARG)
+      ;;
     n)
       #echo "verNumber=$OPTARG"
       verNumber=$(echo $OPTARG)
@@ -71,6 +76,7 @@ do
       echo "                  -o [Linux | Kylin | Alpine | Raspberrypi | Darwin | Windows | Ningsi60 | Ningsi80 |...] "
       echo "                  -V [stable | beta] "
       echo "                  -l [full | lite] "
+      echo "                  -a [glibc | jemalloc] "
       echo "                  -s [static | dynamic] "
       echo "                  -d [taos | power] "
       echo "                  -n [version number] "
@@ -84,7 +90,7 @@ do
   esac
 done
 
-echo "verMode=${verMode} verType=${verType} cpuType=${cpuType} osType=${osType} pagMode=${pagMode} soMode=${soMode} dbName=${dbName} verNumber=${verNumber} verNumberComp=${verNumberComp}"
+echo "verMode=${verMode} verType=${verType} cpuType=${cpuType} osType=${osType} pagMode=${pagMode} soMode=${soMode} dbName=${dbName} allocator=${allocator} verNumber=${verNumber} verNumberComp=${verNumberComp}"
 
 curr_dir=$(pwd)
 
@@ -180,12 +186,18 @@ else
 fi
 cd ${compile_dir}
 
+if [[ "$allocator" == "jemalloc" ]]; then
+    allocator_macro="-DJEMALLOC_ENABLED=true"
+else
+    allocator_macro=""
+fi
+
 # check support cpu type
 if [[ "$cpuType" == "x64" ]] || [[ "$cpuType" == "aarch64" ]] || [[ "$cpuType" == "aarch32" ]] || [[ "$cpuType" == "mips64" ]] ; then
   if [ "$verMode" != "cluster" ]; then
-    cmake ../    -DCPUTYPE=${cpuType} -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} -DPAGMODE=${pagMode}
+    cmake ../    -DCPUTYPE=${cpuType} -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} -DPAGMODE=${pagMode} ${allocator_macro}
   else
-    cmake ../../ -DCPUTYPE=${cpuType} -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp}
+    cmake ../../ -DCPUTYPE=${cpuType} -DOSTYPE=${osType} -DSOMODE=${soMode} -DDBNAME=${dbName} -DVERTYPE=${verType} -DVERDATE="${build_time}" -DGITINFO=${gitinfo} -DGITINFOI=${gitinfoOfInternal} -DVERNUMBER=${verNumber} -DVERCOMPATIBLE=${verNumberComp} ${allocator_macro}
   fi
 else
   echo "input cpuType=${cpuType} error!!!"

packaging/rpm/tdengine.spec

@@ -1,4 +1,5 @@
 %define homepath         /usr/local/taos
+%define userlocalpath    /usr/local
 %define cfg_install_dir  /etc/taos
 %define __strip /bin/true
 
@@ -75,9 +76,53 @@ fi
 cp -r %{_compiledir}/../src/connector/python        %{buildroot}%{homepath}/connector
 cp -r %{_compiledir}/../src/connector/go            %{buildroot}%{homepath}/connector
 cp -r %{_compiledir}/../src/connector/nodejs        %{buildroot}%{homepath}/connector
-cp %{_compiledir}/build/lib/taos-jdbcdriver*dist.*  %{buildroot}%{homepath}/connector ||:
+cp %{_compiledir}/build/lib/taos-jdbcdriver*.*      %{buildroot}%{homepath}/connector ||:
 cp -r %{_compiledir}/../tests/examples/*            %{buildroot}%{homepath}/examples
 
+
+if [ -f %{_compiledir}/build/bin/jemalloc-config ]; then
+    mkdir -p %{buildroot}%{userlocalpath}/bin
+    mkdir -p %{buildroot}%{userlocalpath}/lib
+    mkdir -p %{buildroot}%{userlocalpath}/lib/pkgconfig
+    mkdir -p %{buildroot}%{userlocalpath}/include
+    mkdir -p %{buildroot}%{userlocalpath}/include/jemalloc
+    mkdir -p %{buildroot}%{userlocalpath}/share
+    mkdir -p %{buildroot}%{userlocalpath}/share/doc
+    mkdir -p %{buildroot}%{userlocalpath}/share/doc/jemalloc
+    mkdir -p %{buildroot}%{userlocalpath}/share/man
+    mkdir -p %{buildroot}%{userlocalpath}/share/man/man3
+
+    cp %{_compiledir}/build/bin/jemalloc-config %{buildroot}%{userlocalpath}/bin/
+    if [ -f %{_compiledir}/build/bin/jemalloc.sh ]; then
+        cp %{_compiledir}/build/bin/jemalloc.sh %{buildroot}%{userlocalpath}/bin/
+    fi
+    if [ -f %{_compiledir}/build/bin/jeprof ]; then
+        cp %{_compiledir}/build/bin/jeprof %{buildroot}%{userlocalpath}/bin/
+    fi
+    if [ -f %{_compiledir}/build/include/jemalloc/jemalloc.h ]; then
+        cp %{_compiledir}/build/include/jemalloc/jemalloc.h %{buildroot}%{userlocalpath}/include/jemalloc/
+    fi
+    if [ -f %{_compiledir}/build/lib/libjemalloc.so.2 ]; then
+        cp %{_compiledir}/build/lib/libjemalloc.so.2 %{buildroot}%{userlocalpath}/lib/
+        ln -sf libjemalloc.so.2 %{buildroot}%{userlocalpath}/lib/libjemalloc.so
+    fi
+    if [ -f %{_compiledir}/build/lib/libjemalloc.a ]; then
+        cp %{_compiledir}/build/lib/libjemalloc.a %{buildroot}%{userlocalpath}/lib/
+    fi
+    if [ -f %{_compiledir}/build/lib/libjemalloc_pic.a ]; then
+        cp %{_compiledir}/build/lib/libjemalloc_pic.a %{buildroot}%{userlocalpath}/lib/
+    fi
+    if [ -f %{_compiledir}/build/lib/pkgconfig/jemalloc.pc ]; then
+        cp %{_compiledir}/build/lib/pkgconfig/jemalloc.pc %{buildroot}%{userlocalpath}/lib/pkgconfig/
+    fi
+    if [ -f %{_compiledir}/build/share/doc/jemalloc/jemalloc.html ]; then
+        cp %{_compiledir}/build/share/doc/jemalloc/jemalloc.html %{buildroot}%{userlocalpath}/share/doc/jemalloc/
+    fi
+    if [ -f %{_compiledir}/build/share/man/man3/jemalloc.3 ]; then
+        cp %{_compiledir}/build/share/man/man3/jemalloc.3 %{buildroot}%{userlocalpath}/share/man/man3/
+    fi
+fi
+
 #Scripts executed before installation
 %pre
 csudo=""

packaging/tools/install.sh

@@ -227,6 +227,52 @@ function install_lib() {
     ${csudo} ldconfig
 }
 
+function install_jemalloc() {
+    jemalloc_dir=${script_dir}/jemalloc
+
+    if [ -d ${jemalloc_dir} ]; then
+        ${csudo} /usr/bin/install -c -d /usr/local/bin
+
+        if [ -f ${jemalloc_dir}/bin/jemalloc-config ]; then
+            ${csudo} /usr/bin/install -c -m 755 ${jemalloc_dir}/bin/jemalloc-config /usr/local/bin
+        fi
+        if [ -f ${jemalloc_dir}/bin/jemalloc.sh ]; then
+            ${csudo} /usr/bin/install -c -m 755 ${jemalloc_dir}/bin/jemalloc.sh /usr/local/bin
+        fi
+        if [ -f ${jemalloc_dir}/bin/jeprof ]; then
+            ${csudo} /usr/bin/install -c -m 755 ${jemalloc_dir}/bin/jeprof /usr/local/bin
+        fi
+        if [ -f ${jemalloc_dir}/include/jemalloc/jemalloc.h ]; then
+            ${csudo} /usr/bin/install -c -d /usr/local/include/jemalloc
+            ${csudo} /usr/bin/install -c -m 644 ${jemalloc_dir}/include/jemalloc/jemalloc.h /usr/local/include/jemalloc
+        fi
+        if [ -f ${jemalloc_dir}/lib/libjemalloc.so.2 ]; then
+            ${csudo} /usr/bin/install -c -d /usr/local/lib
+            ${csudo} /usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.so.2 /usr/local/lib
+            ${csudo} ln -sf libjemalloc.so.2 /usr/local/lib/libjemalloc.so
+            ${csudo} /usr/bin/install -c -d /usr/local/lib
+            if [ -f ${jemalloc_dir}/lib/libjemalloc.a ]; then
+                ${csudo} /usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc.a /usr/local/lib
+            fi
+            if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
+                ${csudo} /usr/bin/install -c -m 755 ${jemalloc_dir}/lib/libjemalloc_pic.a /usr/local/lib
+            fi
+            if [ -f ${jemalloc_dir}/lib/libjemalloc_pic.a ]; then
+                ${csudo} /usr/bin/install -c -d /usr/local/lib/pkgconfig
+                ${csudo} /usr/bin/install -c -m 644 ${jemalloc_dir}/lib/pkgconfig/jemalloc.pc /usr/local/lib/pkgconfig
+            fi
+        fi
+        if [ -f ${jemalloc_dir}/share/doc/jemalloc/jemalloc.html ]; then
+            ${csudo} /usr/bin/install -c -d /usr/local/share/doc/jemalloc
+            ${csudo} /usr/bin/install -c -m 644 ${jemalloc_dir}/share/doc/jemalloc/jemalloc.html /usr/local/share/doc/jemalloc
+        fi
+        if [ -f ${jemalloc_dir}/share/man/man3/jemalloc.3 ]; then
+            ${csudo} /usr/bin/install -c -d /usr/local/share/man/man3
+            ${csudo} /usr/bin/install -c -m 644 ${jemalloc_dir}/share/man/man3/jemalloc.3 /usr/local/share/man/man3
+        fi
+    fi
+}
+
 function install_header() {
     ${csudo} rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taoserror.h    || :
     ${csudo} cp -f ${script_dir}/inc/* ${install_main_dir}/include && ${csudo} chmod 644 ${install_main_dir}/include/*
@@ -776,6 +822,7 @@ function update_TDengine() {
     install_log
     install_header
     install_lib
+    install_jemalloc
     if [ "$pagMode" != "lite" ]; then
       install_connector
     fi

packaging/tools/make_install.sh

@@ -6,7 +6,7 @@
 set -e
 # set -x
 
-# -----------------------Variables definition---------------------
+# -----------------------Variables definition
 source_dir=$1
 binary_dir=$2
 osType=$3
@@ -176,6 +176,49 @@ function install_bin() {
         [ -x ${install_main_dir}/bin/remove_client.sh ] && ${csudo} ln -s ${install_main_dir}/bin/remove_client.sh ${bin_link_dir}/rmtaos  || :
     fi
 }
+function install_jemalloc() {
+    if [ "$osType" != "Darwin" ]; then
+        /usr/bin/install -c -d /usr/local/bin
+
+        if [ -f ${binary_dir}/build/bin/jemalloc-config ]; then
+            /usr/bin/install -c -m 755 ${binary_dir}/build/bin/jemalloc-config /usr/local/bin
+        fi
+        if [ -f ${binary_dir}/build/bin/jemalloc.sh ]; then
+            /usr/bin/install -c -m 755 ${binary_dir}/build/bin/jemalloc.sh /usr/local/bin
+        fi
+        if [ -f ${binary_dir}/build/bin/jeprof ]; then
+            /usr/bin/install -c -m 755 ${binary_dir}/build/bin/jeprof /usr/local/bin
+        fi
+        if [ -f ${binary_dir}/build/include/jemalloc/jemalloc.h ]; then
+            /usr/bin/install -c -d /usr/local/include/jemalloc
+            /usr/bin/install -c -m 644 ${binary_dir}/build/include/jemalloc/jemalloc.h /usr/local/include/jemalloc
+        fi
+        if [ -f ${binary_dir}/build/lib/libjemalloc.so.2 ]; then
+            /usr/bin/install -c -d /usr/local/lib
+            /usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc.so.2 /usr/local/lib
+            ln -sf libjemalloc.so.2 /usr/local/lib/libjemalloc.so
+            /usr/bin/install -c -d /usr/local/lib
+            if [ -f ${binary_dir}/build/lib/libjemalloc.a ]; then
+                /usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc.a /usr/local/lib
+            fi
+            if [ -f ${binary_dir}/build/lib/libjemalloc_pic.a ]; then
+                /usr/bin/install -c -m 755 ${binary_dir}/build/lib/libjemalloc_pic.a /usr/local/lib
+            fi
+            if [ -f ${binary_dir}/build/lib/pkgconfig/jemalloc.pc ]; then
+                /usr/bin/install -c -d /usr/local/lib/pkgconfig
+                /usr/bin/install -c -m 644 ${binary_dir}/build/lib/pkgconfig/jemalloc.pc /usr/local/lib/pkgconfig
+            fi
+        fi
+        if [ -f ${binary_dir}/build/share/doc/jemalloc/jemalloc.html ]; then
+            /usr/bin/install -c -d /usr/local/share/doc/jemalloc
+            /usr/bin/install -c -m 644 ${binary_dir}/build/share/doc/jemalloc/jemalloc.html /usr/local/share/doc/jemalloc
+        fi
+        if [ -f ${binary_dir}/build/share/man/man3/jemalloc.3 ]; then
+            /usr/bin/install -c -d /usr/local/share/man/man3
+            /usr/bin/install -c -m 644 ${binary_dir}/build/share/man/man3/jemalloc.3 /usr/local/share/man/man3
+        fi
+    fi
+}
 
 function install_lib() {
     # Remove links
@@ -199,6 +242,8 @@ function install_lib() {
         ${csudo} ln -sf ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib
     fi
 
+    install_jemalloc
+
     if [ "$osType" != "Darwin" ]; then
         ${csudo} ldconfig
     fi

packaging/tools/makepkg.sh

@@ -30,7 +30,7 @@ else
     install_dir="${release_dir}/TDengine-server-${version}"
 fi
 
-# Directories and files.
+# Directories and files
 if [ "$pagMode" == "lite" ]; then
   strip ${build_dir}/bin/taosd
   strip ${build_dir}/bin/taos
@@ -73,6 +73,39 @@ mkdir -p ${install_dir}/init.d && cp ${init_file_rpm} ${install_dir}/init.d/taos
 mkdir -p ${install_dir}/init.d && cp ${init_file_tarbitrator_deb} ${install_dir}/init.d/tarbitratord.deb || :
 mkdir -p ${install_dir}/init.d && cp ${init_file_tarbitrator_rpm} ${install_dir}/init.d/tarbitratord.rpm || :
 
+if [ -f ${build_dir}/bin/jemalloc-config ]; then
+    mkdir -p ${install_dir}/jemalloc/{bin,lib,lib/pkgconfig,include/jemalloc,share/doc/jemalloc,share/man/man3}
+    cp ${build_dir}/bin/jemalloc-config ${install_dir}/jemalloc/bin
+    if [ -f ${build_dir}/bin/jemalloc.sh ]; then
+        cp ${build_dir}/bin/jemalloc.sh ${install_dir}/jemalloc/bin
+    fi
+    if [ -f ${build_dir}/bin/jeprof ]; then
+        cp ${build_dir}/bin/jeprof ${install_dir}/jemalloc/bin
+    fi
+    if [ -f ${build_dir}/include/jemalloc/jemalloc.h ]; then
+        cp ${build_dir}/include/jemalloc/jemalloc.h ${install_dir}/jemalloc/include/jemalloc
+    fi
+    if [ -f ${build_dir}/lib/libjemalloc.so.2 ]; then
+        cp ${build_dir}/lib/libjemalloc.so.2 ${install_dir}/jemalloc/lib
+        ln -sf libjemalloc.so.2 ${install_dir}/jemalloc/lib/libjemalloc.so
+    fi
+    if [ -f ${build_dir}/lib/libjemalloc.a ]; then
+        cp ${build_dir}/lib/libjemalloc.a ${install_dir}/jemalloc/lib
+    fi
+    if [ -f ${build_dir}/lib/libjemalloc_pic.a ]; then
+        cp ${build_dir}/lib/libjemalloc_pic.a ${install_dir}/jemalloc/lib
+    fi
+    if [ -f ${build_dir}/lib/pkgconfig/jemalloc.pc ]; then
+        cp ${build_dir}/lib/pkgconfig/jemalloc.pc ${install_dir}/jemalloc/lib/pkgconfig
+    fi
+    if [ -f ${build_dir}/share/doc/jemalloc/jemalloc.html ]; then
+        cp ${build_dir}/share/doc/jemalloc/jemalloc.html ${install_dir}/jemalloc/share/doc/jemalloc
+    fi
+    if [ -f ${build_dir}/share/man/man3/jemalloc.3 ]; then
+        cp ${build_dir}/share/man/man3/jemalloc.3 ${install_dir}/jemalloc/share/man/man3
+    fi
+fi
+
 if [ "$verMode" == "cluster" ]; then
     sed 's/verMode=edge/verMode=cluster/g' ${install_dir}/bin/remove.sh >> remove_temp.sh
     mv remove_temp.sh ${install_dir}/bin/remove.sh

src/client/inc/tscGlobalmerge.h

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TDENGINE_TSCLOCALMERGE_H
+#ifndef TDENGINE_TSCGLOBALMERGE_H
-#define TDENGINE_TSCLOCALMERGE_H
+#define TDENGINE_TSCGLOBALMERGE_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -24,7 +24,7 @@ extern "C" {
 #include "qFill.h"
 #include "taosmsg.h"
 #include "tlosertree.h"
-#include "tsclient.h"
+#include "qExecutor.h"
 
 #define MAX_NUM_OF_SUBQUERY_RETRY 3
   
@@ -38,40 +38,32 @@ typedef struct SLocalDataSource {
   tFilePage      filePage;
 } SLocalDataSource;
 
-typedef struct SLocalMerger {
+typedef struct SGlobalMerger {
-  SLocalDataSource **    pLocalDataSrc;
+  SLocalDataSource     **pLocalDataSrc;
   int32_t                numOfBuffer;
   int32_t                numOfCompleted;
   int32_t                numOfVnode;
-  SLoserTreeInfo *       pLoserTree;
+  SLoserTreeInfo        *pLoserTree;
-  tFilePage *            pResultBuf;
-  int32_t                nResultBufSize;
-  tFilePage *            pTempBuffer;
-  struct SQLFunctionCtx *pCtx;
   int32_t                rowSize;          // size of each intermediate result.
-  tOrderDescriptor *     pDesc;
+  tOrderDescriptor      *pDesc;
-  SColumnModel *         resColModel;
+  tExtMemBuffer        **pExtMemBuffer;    // disk-based buffer
-  SColumnModel*          finalModel;
+  char                  *buf;              // temp buffer
-  tExtMemBuffer **       pExtMemBuffer;      // disk-based buffer
+} SGlobalMerger;
-  bool                   orderPrjOnSTable;   // projection query on stable
+
-} SLocalMerger;
+struct SSqlObj;
 
 typedef struct SRetrieveSupport {
   tExtMemBuffer **  pExtMemBuffer;     // for build loser tree
   tOrderDescriptor *pOrderDescriptor;
-  SColumnModel*     pFinalColModel;    // colModel for final result
-  SColumnModel*     pFFColModel;
   int32_t           subqueryIndex;     // index of current vnode in vnode list
-  SSqlObj *         pParentSql;
+  struct SSqlObj   *pParentSql;
   tFilePage *       localBuffer;       // temp buffer, there is a buffer for each vnode to
   uint32_t          numOfRetry;        // record the number of retry times
 } SRetrieveSupport;
 
-int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOrderDescriptor **pDesc,
+int32_t tscCreateGlobalMergerEnv(SQueryInfo* pQueryInfo, tExtMemBuffer ***pMemBuffer, int32_t numOfSub, tOrderDescriptor **pDesc, uint32_t nBufferSize, int64_t id);
-                                 SColumnModel **pFinalModel, SColumnModel** pFFModel, uint32_t nBufferSize);
 
-void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDesc, SColumnModel *pFinalModel, SColumnModel* pFFModel,
+void tscDestroyGlobalMergerEnv(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDesc, int32_t numOfVnodes);
-                               int32_t numOfVnodes);
 
 int32_t saveToBuffer(tExtMemBuffer *pMemoryBuf, tOrderDescriptor *pDesc, tFilePage *pPage, void *data,
                      int32_t numOfRows, int32_t orderType);
@@ -81,15 +73,13 @@ int32_t tscFlushTmpBuffer(tExtMemBuffer *pMemoryBuf, tOrderDescriptor *pDesc, tF
 /*
  * create local reducer to launch the second-stage reduce process at client site
  */
-void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrderDescriptor *pDesc,
+int32_t tscCreateGlobalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrderDescriptor *pDesc,
-                           SColumnModel *finalModel, SColumnModel *pFFModel, SSqlObj* pSql);
+                          SQueryInfo *pQueryInfo, SGlobalMerger **pMerger, int64_t id);
 
-void tscDestroyLocalMerger(SSqlObj *pSql);
+void tscDestroyGlobalMerger(SGlobalMerger* pMerger);
-
-//int32_t tscDoLocalMerge(SSqlObj *pSql);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // TDENGINE_TSCLOCALMERGE_H
+#endif  // TDENGINE_TSCGLOBALMERGE_H

src/client/inc/tscUtil.h

@@ -25,7 +25,8 @@ extern "C" {
 #include "qExtbuffer.h"
 #include "taosdef.h"
 #include "tbuffer.h"
-#include "tscLocalMerge.h"
+#include "tscGlobalmerge.h"
+#include "tsched.h"
 #include "tsclient.h"
 
 #define UTIL_TABLE_IS_SUPER_TABLE(metaInfo)  \
@@ -36,6 +37,9 @@ extern "C" {
 #define UTIL_TABLE_IS_NORMAL_TABLE(metaInfo)\
   (!(UTIL_TABLE_IS_SUPER_TABLE(metaInfo) || UTIL_TABLE_IS_CHILD_TABLE(metaInfo)))
 
+#define UTIL_TABLE_IS_TMP_TABLE(metaInfo)  \
+  (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_TEMP_TABLE))
+
 #pragma pack(push,1)
 // this struct is transfered as binary, padding two bytes to avoid
 // an 'uid' whose low bytes is 0xff being recoginized as NULL,
@@ -59,7 +63,7 @@ typedef struct SJoinSupporter {
   SArray*         exprList;
   SFieldInfo      fieldsInfo;
   STagCond        tagCond;
-  SSqlGroupbyExpr groupInfo;       // group by info
+  SGroupbyExpr    groupInfo;       // group by info
   struct STSBuf*  pTSBuf;          // the TSBuf struct that holds the compressed timestamp array
   FILE*           f;               // temporary file in order to create TSBuf
   char            path[PATH_MAX];  // temporary file path, todo dynamic allocate memory
@@ -90,22 +94,14 @@ typedef struct SVgroupTableInfo {
   SArray     *itemList;   // SArray<STableIdInfo>
 } SVgroupTableInfo;
 
-static FORCE_INLINE SQueryInfo* tscGetQueryInfo(SSqlCmd* pCmd, int32_t subClauseIndex) {
+int32_t converToStr(char *str, int type, void *buf, int32_t bufSize, int32_t *len);
-  assert(pCmd != NULL && subClauseIndex >= 0);
-  if (pCmd->pQueryInfo == NULL || subClauseIndex >= pCmd->numOfClause) {
-    return NULL;
-  }
-
-  return pCmd->pQueryInfo[subClauseIndex];
-}
-
-SQueryInfo* tscGetActiveQueryInfo(SSqlCmd* pCmd);
 
 int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOffset, SName* name, STableMeta* pTableMeta, STableDataBlocks** dataBlocks);
 void tscDestroyDataBlock(STableDataBlocks* pDataBlock, bool removeMeta);
 void tscSortRemoveDataBlockDupRows(STableDataBlocks* dataBuf);
 
 void tscDestroyBoundColumnInfo(SParsedDataColInfo* pColInfo);
+void doRetrieveSubqueryData(SSchedMsg *pMsg);
 
 SParamInfo* tscAddParamToDataBlock(STableDataBlocks* pDataBlock, char type, uint8_t timePrec, int16_t bytes,
                                    uint32_t offset);
@@ -114,7 +110,7 @@ void*   tscDestroyBlockArrayList(SArray* pDataBlockList);
 void*   tscDestroyBlockHashTable(SHashObj* pBlockHashTable, bool removeMeta);
 
 int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock);
-int32_t tscMergeTableDataBlocks(SSqlObj* pSql, bool freeBlockMap);
+int32_t tscMergeTableDataBlocks(SInsertStatementParam *pInsertParam, bool freeBlockMap);
 int32_t tscGetDataBlockFromList(SHashObj* pHashList, int64_t id, int32_t size, int32_t startOffset, int32_t rowSize, SName* pName, STableMeta* pTableMeta,
                                 STableDataBlocks** dataBlocks, SArray* pBlockList);
 
@@ -127,7 +123,9 @@ int32_t tscGetDataBlockFromList(SHashObj* pHashList, int64_t id, int32_t size, i
  */
 bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo);
 bool tscIsTWAQuery(SQueryInfo* pQueryInfo);
+bool tscIsSessionWindowQuery(SQueryInfo* pQueryInfo);
 bool tscIsSecondStageQuery(SQueryInfo* pQueryInfo);
+bool tsIsArithmeticQueryOnAggResult(SQueryInfo* pQueryInfo);
 bool tscGroupbyColumn(SQueryInfo* pQueryInfo);
 bool tscIsTopBotQuery(SQueryInfo* pQueryInfo);
 bool hasTagValOutput(SQueryInfo* pQueryInfo);
@@ -136,13 +134,14 @@ bool isStabledev(SQueryInfo* pQueryInfo);
 bool isTsCompQuery(SQueryInfo* pQueryInfo);
 bool isSimpleAggregate(SQueryInfo* pQueryInfo);
 bool isBlockDistQuery(SQueryInfo* pQueryInfo);
-int32_t tscGetTopbotQueryParam(SQueryInfo* pQueryInfo);
+bool isSimpleAggregateRv(SQueryInfo* pQueryInfo);
 
 bool tscNonOrderedProjectionQueryOnSTable(SQueryInfo *pQueryInfo, int32_t tableIndex);
 bool tscOrderedProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex);
 bool tscIsProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex);
 
 bool tscIsProjectionQuery(SQueryInfo* pQueryInfo);
+bool tscHasColumnFilter(SQueryInfo* pQueryInfo);
 
 bool tscIsTwoStageSTableQuery(SQueryInfo* pQueryInfo, int32_t tableIndex);
 bool tscQueryTags(SQueryInfo* pQueryInfo);
@@ -150,9 +149,9 @@ bool tscMultiRoundQuery(SQueryInfo* pQueryInfo, int32_t tableIndex);
 bool tscQueryBlockInfo(SQueryInfo* pQueryInfo);
 
 SExprInfo* tscAddFuncInSelectClause(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId,
-                                       SColumnIndex* pIndex, SSchema* pColSchema, int16_t colType);
+                                       SColumnIndex* pIndex, SSchema* pColSchema, int16_t colType, int16_t colId);
 
-int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pzTableName, SSqlObj* pSql);
+int32_t tscSetTableFullName(SName* pName, SStrToken* pzTableName, SSqlObj* pSql);
 void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
 
 bool tscIsInsertData(char* sqlstr);
@@ -171,36 +170,49 @@ void tscFieldInfoUpdateOffset(SQueryInfo* pQueryInfo);
 
 int16_t tscFieldInfoGetOffset(SQueryInfo* pQueryInfo, int32_t index);
 void    tscFieldInfoClear(SFieldInfo* pFieldInfo);
+void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc, const SArray* pExprList);
 
 static FORCE_INLINE int32_t tscNumOfFields(SQueryInfo* pQueryInfo) { return pQueryInfo->fieldsInfo.numOfOutput; }
 
 int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2, int32_t *diffSize);
-int32_t tscFieldInfoSetSize(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2);
+void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, uint64_t uid);
 
+int32_t tscFieldInfoSetSize(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2);
 void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes);
 
 int32_t   tscGetResRowLength(SArray* pExprList);
 
-SExprInfo* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+SExprInfo* tscExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
     int16_t size, int16_t resColId, int16_t interSize, bool isTagCol);
 
-SExprInfo* tscSqlExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+SExprInfo* tscExprCreate(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+                         int16_t size, int16_t resColId, int16_t interSize, int32_t colType);
+
+void tscExprAddParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes);
+
+SExprInfo* tscExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
                            int16_t size, int16_t resColId, int16_t interSize, bool isTagCol);
 
-SExprInfo* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
+SExprInfo* tscExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
                            int16_t size);
-size_t   tscSqlExprNumOfExprs(SQueryInfo* pQueryInfo);
-void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, uint64_t uid);
 
-SExprInfo* tscSqlExprGet(SQueryInfo* pQueryInfo, int32_t index);
+size_t     tscNumOfExprs(SQueryInfo* pQueryInfo);
-int32_t   tscSqlExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy);
+SExprInfo *tscExprGet(SQueryInfo* pQueryInfo, int32_t index);
-void      tscSqlExprAssign(SExprInfo* dst, const SExprInfo* src);
+int32_t    tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy);
-void      tscSqlExprInfoDestroy(SArray* pExprInfo);
+int32_t    tscExprCopyAll(SArray* dst, const SArray* src, bool deepcopy);
+void       tscExprAssign(SExprInfo* dst, const SExprInfo* src);
+void       tscExprDestroy(SArray* pExprInfo);
+
+int32_t createProjectionExpr(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SExprInfo*** pExpr, int32_t* num);
+
+void clearAllTableMetaInfo(SQueryInfo* pQueryInfo, bool removeMeta);
 
 SColumn* tscColumnClone(const SColumn* src);
 bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid);
 SColumn* tscColumnListInsert(SArray* pColumnList, int32_t columnIndex, uint64_t uid, SSchema* pSchema);
 void tscColumnListDestroy(SArray* pColList);
+void tscColumnListCopy(SArray* dst, const SArray* src, uint64_t tableUid);
+void tscColumnListCopyAll(SArray* dst, const SArray* src);
 
 void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo);
 
@@ -222,14 +234,14 @@ void tscGetSrcColumnInfo(SSrcColumnInfo* pColInfo, SQueryInfo* pQueryInfo);
 
 bool tscShouldBeFreed(SSqlObj* pSql);
 
-STableMetaInfo* tscGetTableMetaInfoFromCmd(SSqlCmd *pCmd, int32_t subClauseIndex, int32_t tableIndex);
+STableMetaInfo* tscGetTableMetaInfoFromCmd(SSqlCmd *pCmd, int32_t tableIndex);
 STableMetaInfo* tscGetMetaInfo(SQueryInfo *pQueryInfo, int32_t tableIndex);
 
 void        tscInitQueryInfo(SQueryInfo* pQueryInfo);
 void        tscClearSubqueryInfo(SSqlCmd* pCmd);
 int32_t     tscAddQueryInfo(SSqlCmd *pCmd);
-SQueryInfo *tscGetQueryInfo(SSqlCmd* pCmd, int32_t subClauseIndex);
+SQueryInfo *tscGetQueryInfo(SSqlCmd* pCmd);
-SQueryInfo *tscGetQueryInfoS(SSqlCmd *pCmd, int32_t subClauseIndex);
+SQueryInfo *tscGetQueryInfoS(SSqlCmd *pCmd);
 
 void tscClearTableMetaInfo(STableMetaInfo* pTableMetaInfo);
 
@@ -243,12 +255,11 @@ SArray* tscVgroupTableInfoDup(SArray* pVgroupTables);
 void tscRemoveVgroupTableGroup(SArray* pVgroupTable, int32_t index);
 void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo);
 
-int  tscGetSTableVgroupInfo(SSqlObj* pSql, int32_t clauseIndex);
+int  tscGetSTableVgroupInfo(SSqlObj* pSql, SQueryInfo* pQueryInfo);
 int  tscGetTableMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
 int  tscGetTableMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
 
 void tscResetForNextRetrieve(SSqlRes* pRes);
-void tscDoQuery(SSqlObj* pSql);
 void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo);
 void doExecuteQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo);
 
@@ -275,11 +286,12 @@ void tscSVgroupInfoCopy(SVgroupInfo* dst, const SVgroupInfo* src);
 SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, int32_t cmd);
 
 void registerSqlObj(SSqlObj* pSql);
+void tscInitResForMerge(SSqlRes* pRes);
 
 SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t fp, void* param, int32_t cmd, SSqlObj* pPrevSql);
 void     addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClauseIndex, int32_t tableIndex);
 
-void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex);
+void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex, SSqlCmd* pCmd);
 
 int16_t tscGetJoinTagColIdByUid(STagCond* pTagCond, uint64_t uid);
 int16_t tscGetTagColIndexById(STableMeta* pTableMeta, int16_t colId);
@@ -295,6 +307,11 @@ void tscTryQueryNextVnode(SSqlObj *pSql, __async_cb_func_t fp);
 void tscAsyncQuerySingleRowForNextVnode(void *param, TAOS_RES *tres, int numOfRows);
 void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp);
 int  tscSetMgmtEpSetFromCfg(const char *first, const char *second, SRpcCorEpSet *corEpSet);
+int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, __async_cb_func_t fp);
+
+int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length, SArray* pNameArray);
+
+bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx);
 
 bool tscSetSqlOwner(SSqlObj* pSql);
 void tscClearSqlOwner(SSqlObj* pSql);
@@ -309,15 +326,20 @@ CChildTableMeta* tscCreateChildMeta(STableMeta* pTableMeta);
 uint32_t tscGetTableMetaMaxSize();
 int32_t tscCreateTableMetaFromSTableMeta(STableMeta* pChild, const char* name, void* buf);
 STableMeta* tscTableMetaDup(STableMeta* pTableMeta);
+SVgroupsInfo* tscVgroupsInfoDup(SVgroupsInfo* pVgroupsInfo);
+
 int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAttr, void* addr);
 
 void tsCreateSQLFunctionCtx(SQueryInfo* pQueryInfo, SQLFunctionCtx* pCtx, SSchema* pSchema);
-void* createQueryInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, STableGroupInfo* pTableGroupInfo, SOperatorInfo* pOperator, char* sql, void* addr, int32_t stage);
+void* createQInfoFromQueryNode(SQueryInfo* pQueryInfo, STableGroupInfo* pTableGroupInfo, SOperatorInfo* pOperator, char* sql, void* addr, int32_t stage);
 
 void* malloc_throw(size_t size);
 void* calloc_throw(size_t nmemb, size_t size);
 char* strdup_throw(const char* str);
 
+bool vgroupInfoIdentical(SNewVgroupInfo *pExisted, SVgroupMsg* src);
+SNewVgroupInfo createNewVgroupInfo(SVgroupMsg *pVgroupMsg);
+
 #ifdef __cplusplus
 }
 #endif

src/client/inc/tschemautil.h

@@ -1,93 +0,0 @@
-/*
- * 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/>.
- */
-
-#ifndef TDENGINE_TSCHEMAUTIL_H
-#define TDENGINE_TSCHEMAUTIL_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "taosmsg.h"
-#include "tsclient.h"
-#include "ttoken.h"
-
-/**
- * get the number of tags of this table
- * @param pTableMeta
- * @return
- */
-int32_t tscGetNumOfTags(const STableMeta* pTableMeta);
-
-/**
- * get the number of columns of this table
- * @param pTableMeta
- * @return
- */
-int32_t tscGetNumOfColumns(const STableMeta* pTableMeta);
-
-/**
- * get the basic info of this table
- * @param pTableMeta
- * @return
- */
-STableComInfo tscGetTableInfo(const STableMeta* pTableMeta);
-
-/**
- * get the schema
- * @param pTableMeta
- * @return
- */
-SSchema* tscGetTableSchema(const STableMeta* pTableMeta);
-
-/**
- * get the tag schema
- * @param pMeta
- * @return
- */
-SSchema *tscGetTableTagSchema(const STableMeta *pMeta);
-
-/**
- * get the column schema according to the column index
- * @param pMeta
- * @param colIndex
- * @return
- */
-SSchema *tscGetTableColumnSchema(const STableMeta *pMeta, int32_t colIndex);
-
-/**
- * get the column schema according to the column id
- * @param pTableMeta
- * @param colId
- * @return
- */
-SSchema* tscGetColumnSchemaById(STableMeta* pTableMeta, int16_t colId);
-
-/**
- * create the table meta from the msg
- * @param pTableMetaMsg
- * @param size size of the table meta
- * @return
- */
-STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg);
-
-bool vgroupInfoIdentical(SNewVgroupInfo *pExisted, SVgroupMsg* src);
-SNewVgroupInfo createNewVgroupInfo(SVgroupMsg *pVgroupMsg);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // TDENGINE_TSCHEMAUTIL_H

src/client/inc/tsclient.h

@@ -40,23 +40,9 @@ extern "C" {
 
 // forward declaration
 struct SSqlInfo;
-struct SLocalMerger;
-
-// data source from sql string or from file
-enum {
-  DATA_FROM_SQL_STRING = 1,
-  DATA_FROM_DATA_FILE  = 2,
-};
 
 typedef void (*__async_cb_func_t)(void *param, TAOS_RES *tres, int32_t numOfRows);
 
-typedef struct STableComInfo {
-  uint8_t numOfTags;
-  uint8_t precision;
-  int16_t numOfColumns;
-  int32_t rowSize;
-} STableComInfo;
-
 typedef struct SNewVgroupInfo {
   int32_t    vgId;
   int8_t     inUse;
@@ -72,34 +58,6 @@ typedef struct CChildTableMeta {
   uint64_t       suid;                              // super table id
 } CChildTableMeta;
 
-typedef struct STableMeta {
-  int32_t        vgId;
-  STableId       id;
-  uint8_t        tableType;
-  char           sTableName[TSDB_TABLE_FNAME_LEN];  // super table name
-  uint64_t       suid;       // super table id
-  int16_t        sversion;
-  int16_t        tversion;
-  STableComInfo  tableInfo;
-  SSchema        schema[];  // if the table is TSDB_CHILD_TABLE, schema is acquired by super table meta info
-} STableMeta;
-
-typedef struct STableMetaInfo {
-  STableMeta   *pTableMeta;      // table meta, cached in client side and acquired by name
-  uint32_t       tableMetaSize;
-  SVgroupsInfo *vgroupList;
-  SArray       *pVgroupTables;   // SArray<SVgroupTableInfo>
-  
-  /*
-   * 1. keep the vgroup index during the multi-vnode super table projection query
-   * 2. keep the vgroup index for multi-vnode insertion
-   */
-  int32_t       vgroupIndex;
-  SName         name;
-  char          aliasName[TSDB_TABLE_NAME_LEN];    // alias name of table specified in query sql
-  SArray       *tagColList;                        // SArray<SColumn*>, involved tag columns
-} STableMetaInfo;
-
 typedef struct SColumnIndex {
   int16_t tableIndex;
   int16_t columnIndex;
@@ -117,44 +75,6 @@ typedef struct SInternalField {
   SExprInfo      *pExpr;
 } SInternalField;
 
-typedef struct SFieldInfo {
-  int16_t      numOfOutput;   // number of column in result
-  TAOS_FIELD*  final;
-  SArray      *internalField; // SArray<SInternalField>
-} SFieldInfo;
-
-typedef struct SCond {
-  uint64_t uid;
-  int32_t  len;  // length of tag query condition data
-  char *   cond;
-} SCond;
-
-typedef struct SJoinNode {
-  uint64_t uid;
-  int16_t  tagColId;
-  SArray*  tsJoin;
-  SArray*  tagJoin;
-} SJoinNode;
-
-typedef struct SJoinInfo {
-  bool      hasJoin;
-  SJoinNode*  joinTables[TSDB_MAX_JOIN_TABLE_NUM];
-} SJoinInfo;
-
-typedef struct STagCond {
-  // relation between tbname list and query condition, including : TK_AND or TK_OR
-  int16_t relType;
-
-  // tbname query condition, only support tbname query condition on one table
-  SCond tbnameCond;
-
-  // join condition, only support two tables join currently
-  SJoinInfo joinInfo;
-
-  // for different table, the query condition must be seperated
-  SArray *pCond;
-} STagCond;
-
 typedef struct SParamInfo {
   int32_t  idx;
   uint8_t  type;
@@ -197,92 +117,48 @@ typedef struct STableDataBlocks {
   SParamInfo *params;
 } STableDataBlocks;
 
-typedef struct SQueryInfo {
+typedef struct {
-  int16_t          command;       // the command may be different for each subclause, so keep it seperately.
+  STableMeta   *pTableMeta;
-  uint32_t         type;          // query/insert type
+  SVgroupsInfo *pVgroupInfo;
-  STimeWindow      window;        // the whole query time window
+} STableMetaVgroupInfo;
 
-  SInterval        interval;      // tumble time window
+typedef struct SInsertStatementParam {
-  SSessionWindow   sessionWindow; // session time window
+  SName      **pTableNameList;          // all involved tableMeta list of current insert sql statement.
+  int32_t      numOfTables;             // number of tables in table name list
+  SHashObj    *pTableBlockHashList;     // data block for each table
+  SArray      *pDataBlocks;             // SArray<STableDataBlocks*>. Merged submit block for each vgroup
+  int8_t       schemaAttached;          // denote if submit block is built with table schema or not
+  STagData     tagData;                 // NOTE: pTagData->data is used as a variant length array
 
-  SSqlGroupbyExpr  groupbyExpr;   // groupby tags info
+  int32_t      batchSize;               // for parameter ('?') binding and batch processing
-  SArray *         colList;       // SArray<SColumn*>
+  int32_t      numOfParams;
-  SFieldInfo       fieldsInfo;
-  SArray *         exprList;      // SArray<SExprInfo*>
-  SLimitVal        limit;
-  SLimitVal        slimit;
-  STagCond         tagCond;
 
-  SOrderVal        order;
+  char         msg[512];                // error message
-  int16_t          fillType;      // final result fill type
+  uint32_t     insertType;              // insert data from [file|sql statement| bound statement]
-  int16_t          numOfTables;
+  uint64_t     objectId;                // sql object id
-  STableMetaInfo **pTableMetaInfo;
+  char        *sql;                     // current sql statement position
-  struct STSBuf   *tsBuf;
+} SInsertStatementParam;
-  int64_t *        fillVal;       // default value for fill
-  char *           msg;           // pointer to the pCmd->payload to keep error message temporarily
-  int64_t          clauseLimit;   // limit for current sub clause
-
-  int64_t          prjOffset;     // offset value in the original sql expression, only applied at client side
-  int64_t          vgroupLimit;    // table limit in case of super table projection query + global order + limit
-
-  int32_t          udColumnId;    // current user-defined constant output field column id, monotonically decreases from TSDB_UD_COLUMN_INDEX
-  int16_t          resColumnId;   // result column id
-  bool             distinctTag;   // distinct tag or not
-  int32_t          round;         // 0/1/....
-  int32_t          bufLen;
-  char*            buf;
-  SQInfo*          pQInfo;      // global merge operator
-  SArray*          pDSOperator;    // data source operator
-  SArray*          pPhyOperator;   // physical query execution plan
-  SQueryAttr*      pQueryAttr;     // query object
-
-  struct SQueryInfo *sibling;     // sibling
-  SArray            *pUpstream;   // SArray<struct SQueryInfo>
-  struct SQueryInfo *pDownstream;
-  int32_t            havingFieldNum;
-} SQueryInfo;
 
+// TODO extract sql parser supporter
 typedef struct {
   int     command;
   uint8_t msgType;
+  SInsertStatementParam insertParam;
   char    reserve1[3];        // fix bus error on arm32
-  bool    autoCreated;        // create table if it is not existed during retrieve table meta in mnode
+  int32_t count;   // todo remove it
 
-  union {
-    int32_t count;
-    int32_t numOfTablesInSubmit;
-  };
-
-  uint32_t     insertType;   // TODO remove it
-  char *       curSql;       // current sql, resume position of sql after parsing paused
-  int8_t       parseFinished;
   char         reserve2[3];        // fix bus error on arm32
-
   int16_t      numOfCols;
   char         reserve3[2];        // fix bus error on arm32
   uint32_t     allocSize;
   char *       payload;
   int32_t      payloadLen;
 
-  SQueryInfo **pQueryInfo;
+  SHashObj    *pTableMetaMap;  // local buffer to keep the queried table meta, before validating the AST
-  int32_t      numOfClause;
+  SQueryInfo  *pQueryInfo;
-  int32_t      clauseIndex;  // index of multiple subclause query
   SQueryInfo  *active;         // current active query info
-
   int32_t      batchSize;      // for parameter ('?') binding and batch processing
-  int32_t      numOfParams;
+  int32_t      resColumnId;
-
-  int8_t       dataSourceType;     // load data from file or not
-  char    reserve4[3];         // fix bus error on arm32
-  int8_t       submitSchema;   // submit block is built with table schema
-  char    reserve5[3];         // fix bus error on arm32
-  STagData     tagData;        // NOTE: pTagData->data is used as a variant length array
-
-  SName      **pTableNameList; // all involved tableMeta list of current insert sql statement.
-  int32_t      numOfTables;
-
-  SHashObj    *pTableBlockHashList;     // data block for each table
-  SArray      *pDataBlocks;             // SArray<STableDataBlocks*>. Merged submit block for each vgroup
 } SSqlCmd;
 
 typedef struct SResRec {
@@ -317,7 +193,7 @@ typedef struct {
 
   TAOS_FIELD*           final;
   SArithmeticSupport   *pArithSup;   // support the arithmetic expression calculation on agg functions
-  struct SLocalMerger  *pLocalMerger;
+  struct SGlobalMerger *pMerger;
 } SSqlRes;
 
 typedef struct {
@@ -443,8 +319,8 @@ int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
 void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo);
 void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBlock);
 
-void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* pQueryInfo);
+void handleDownstreamOperator(SSqlObj** pSqlList, int32_t numOfUpstream, SQueryInfo* px, SSqlRes* pOutput);
-void destroyTableNameList(SSqlCmd* pCmd);
+void destroyTableNameList(SInsertStatementParam* pInsertParam);
 
 void tscResetSqlCmd(SSqlCmd *pCmd, bool removeMeta);
 
@@ -476,7 +352,7 @@ void waitForQueryRsp(void *param, TAOS_RES *tres, int code);
 void doAsyncQuery(STscObj *pObj, SSqlObj *pSql, __async_cb_func_t fp, void *param, const char *sqlstr, size_t sqlLen);
 
 void tscImportDataFromFile(SSqlObj *pSql);
-void tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen);
+struct SGlobalMerger* tscInitResObjForLocalQuery(int32_t numOfRes, int32_t rowLen, uint64_t id);
 bool tscIsUpdateQuery(SSqlObj* pSql);
 char* tscGetSqlStr(SSqlObj* pSql);
 bool tscIsQueryWithLimit(SSqlObj* pSql);
@@ -486,10 +362,10 @@ void tscSetBoundColumnInfo(SParsedDataColInfo *pColInfo, SSchema *pSchema, int32
 
 char *tscGetErrorMsgPayload(SSqlCmd *pCmd);
 
-int32_t tscInvalidSQLErrMsg(char *msg, const char *additionalInfo, const char *sql);
+int32_t tscInvalidOperationMsg(char *msg, const char *additionalInfo, const char *sql);
 int32_t tscSQLSyntaxErrMsg(char* msg, const char* additionalInfo,  const char* sql);
 
-int32_t tscToSQLCmd(SSqlObj *pSql, struct SSqlInfo *pInfo);
+int32_t tscValidateSqlInfo(SSqlObj *pSql, struct SSqlInfo *pInfo);
 
 extern int32_t    sentinel;
 extern SHashObj  *tscVgroupMap;
@@ -505,7 +381,7 @@ extern int   tscNumOfObj;     // number of existed sqlObj in current process.
 extern int (*tscBuildMsg[TSDB_SQL_MAX])(SSqlObj *pSql, SSqlInfo *pInfo);
 
 void tscBuildVgroupTableInfo(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SArray* tables);
-int16_t getNewResColId(SQueryInfo* pQueryInfo);
+int16_t getNewResColId(SSqlCmd* pCmd);
 
 #ifdef __cplusplus
 }

src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h

@@ -218,11 +218,19 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeBatchImp(J
 
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector
- * Method:    executeBatchImp
+ * Method:    closeStmt
  * Signature: (JJ)I
  */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeStmt(JNIEnv *env, jobject jobj, jlong stmt, jlong con);
 
+/**
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    setTableNameTagsImp
+ * Signature: (JLjava/lang/String;I[B[B[B[BJ)I
+ */
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setTableNameTagsImp
+    (JNIEnv *, jobject, jlong, jstring, jint, jbyteArray, jbyteArray, jbyteArray, jbyteArray, jlong);
+
 #ifdef __cplusplus
 }
 #endif

src/client/src/TSDBJNIConnector.c

@@ -749,7 +749,6 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setBindTableNameI
   }
 
   jniDebug("jobj:%p, conn:%p, set stmt bind table name:%s", jobj, tsconn, name);
-
   (*env)->ReleaseStringUTFChars(env, jname, name);
   return JNI_SUCCESS;
 }
@@ -762,7 +761,7 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(J
     return JNI_CONNECTION_NULL;
   }
 
-  TAOS_STMT* pStmt = (TAOS_STMT*) stmt;
+  TAOS_STMT *pStmt = (TAOS_STMT *)stmt;
   if (pStmt == NULL) {
     jniError("jobj:%p, conn:%p, invalid stmt", jobj, tscon);
     return JNI_SQL_NULL;
@@ -777,14 +776,14 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(J
   }
 
   len = (*env)->GetArrayLength(env, lengthList);
-  char *lengthArray = (char*) calloc(1, len);
+  char *lengthArray = (char *)calloc(1, len);
-  (*env)->GetByteArrayRegion(env, lengthList, 0, len, (jbyte*) lengthArray);
+  (*env)->GetByteArrayRegion(env, lengthList, 0, len, (jbyte *)lengthArray);
   if ((*env)->ExceptionCheck(env)) {
   }
 
   len = (*env)->GetArrayLength(env, nullList);
-  char *nullArray = (char*) calloc(1, len);
+  char *nullArray = (char *)calloc(1, len);
-  (*env)->GetByteArrayRegion(env, nullList, 0, len, (jbyte*) nullArray);
+  (*env)->GetByteArrayRegion(env, nullList, 0, len, (jbyte *)nullArray);
   if ((*env)->ExceptionCheck(env)) {
   }
 
@@ -799,23 +798,11 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(J
   b->length        = (int32_t*)lengthArray;
 
   // set the length and is_null array
-  switch(dataType) {
+  if (!IS_VAR_DATA_TYPE(dataType)) {
-    case TSDB_DATA_TYPE_INT:
-    case TSDB_DATA_TYPE_TINYINT:
-    case TSDB_DATA_TYPE_SMALLINT:
-    case TSDB_DATA_TYPE_TIMESTAMP:
-    case TSDB_DATA_TYPE_BIGINT: {
     int32_t bytes = tDataTypes[dataType].bytes;
-      for(int32_t i = 0; i < numOfRows; ++i) {
+    for (int32_t i = 0; i < numOfRows; ++i) {
       b->length[i] = bytes;
     }
-      break;
-    }
-
-    case TSDB_DATA_TYPE_NCHAR:
-    case TSDB_DATA_TYPE_BINARY: {
-      // do nothing
-    }
   }
 
   int32_t code = taos_stmt_bind_single_param_batch(pStmt, b, colIndex);
@@ -878,3 +865,74 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeStmt(JNIEnv
   jniDebug("jobj:%p, conn:%p, stmt closed", jobj, tscon);
   return JNI_SUCCESS;
 }
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setTableNameTagsImp(JNIEnv *env, jobject jobj,
+      jlong stmt, jstring tableName, jint numOfTags, jbyteArray tags, jbyteArray typeList, jbyteArray lengthList, jbyteArray nullList, jlong conn) {
+  TAOS *tsconn = (TAOS *)conn;
+  if (tsconn == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  TAOS_STMT* pStmt = (TAOS_STMT*) stmt;
+  if (pStmt == NULL) {
+    jniError("jobj:%p, conn:%p, invalid stmt handle", jobj, tsconn);
+    return JNI_SQL_NULL;
+  }
+
+  jsize len = (*env)->GetArrayLength(env, tags);
+  char *tagsData = (char *)calloc(1, len);
+  (*env)->GetByteArrayRegion(env, tags, 0, len, (jbyte *)tagsData);
+  if ((*env)->ExceptionCheck(env)) {
+    // todo handle error
+  }
+
+  len = (*env)->GetArrayLength(env, lengthList);
+  int64_t *lengthArray = (int64_t*) calloc(1, len);
+  (*env)->GetByteArrayRegion(env, lengthList, 0, len, (jbyte*) lengthArray);
+  if ((*env)->ExceptionCheck(env)) {
+  }
+
+  len = (*env)->GetArrayLength(env, typeList);
+  char *typeArray = (char*) calloc(1, len);
+  (*env)->GetByteArrayRegion(env, typeList, 0, len, (jbyte*) typeArray);
+  if ((*env)->ExceptionCheck(env)) {
+  }
+
+  len = (*env)->GetArrayLength(env, nullList);
+  int32_t *nullArray = (int32_t*) calloc(1, len);
+  (*env)->GetByteArrayRegion(env, nullList, 0, len, (jbyte*) nullArray);
+  if ((*env)->ExceptionCheck(env)) {
+  }
+
+  const char *name = (*env)->GetStringUTFChars(env, tableName, NULL);
+  char* curTags = tagsData;
+
+  TAOS_BIND *tagsBind = calloc(numOfTags, sizeof(TAOS_BIND));
+  for(int32_t i = 0; i < numOfTags; ++i) {
+    tagsBind[i].buffer_type = typeArray[i];
+    tagsBind[i].buffer  = curTags;
+    tagsBind[i].is_null = &nullArray[i];
+    tagsBind[i].length  = (uintptr_t*) &lengthArray[i];
+
+    curTags += lengthArray[i];
+  }
+
+  int32_t code = taos_stmt_set_tbname_tags((void*)stmt, name, tagsBind);
+
+  int32_t nTags = (int32_t) numOfTags;
+  jniDebug("jobj:%p, conn:%p, set table name:%s, numOfTags:%d", jobj, tsconn, name, nTags);
+
+  tfree(tagsData);
+  tfree(lengthArray);
+  tfree(typeArray);
+  tfree(nullArray);
+  (*env)->ReleaseStringUTFChars(env, tableName, name);
+
+  if (code != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tsconn, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+
+  return JNI_SUCCESS;
+}

src/client/src/tscAsync.c

@@ -22,7 +22,7 @@
 #include "tscSubquery.h"
 #include "tscUtil.h"
 #include "tsched.h"
-#include "tschemautil.h"
+#include "qTableMeta.h"
 #include "tsclient.h"
 
 static void tscAsyncQueryRowsForNextVnode(void *param, TAOS_RES *tres, int numOfRows);
@@ -58,7 +58,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
   strntolower(pSql->sqlstr, sqlstr, (int32_t)sqlLen);
 
   tscDebugL("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
-  pCmd->curSql = pSql->sqlstr;
+  pCmd->resColumnId = TSDB_RES_COL_ID;
 
   int32_t code = tsParseSql(pSql, true);
   if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return;
@@ -69,7 +69,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
     return;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   executeQuery(pSql, pQueryInfo);
 }
 
@@ -127,7 +127,8 @@ static void tscAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOfRows) {
        * all available virtual node has been checked already, now we need to check
        * for the next subclause queries
        */
-      if (pCmd->clauseIndex < pCmd->numOfClause - 1) {
+      if (pCmd->active->sibling != NULL) {
+        pCmd->active = pCmd->active->sibling;
         tscTryQueryNextClause(pSql, tscAsyncQueryRowsForNextVnode);
         return;
       }
@@ -219,7 +220,18 @@ void taos_fetch_rows_a(TAOS_RES *tres, __async_cb_func_t fp, void *param) {
 
   tscResetForNextRetrieve(pRes);
   
-  // handle the sub queries of join query
+  // handle outer query based on the already retrieved nest query results.
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+  if (pQueryInfo->pUpstream != NULL && taosArrayGetSize(pQueryInfo->pUpstream) > 0) {
+    SSchedMsg schedMsg = {0};
+    schedMsg.fp = doRetrieveSubqueryData;
+    schedMsg.ahandle = (void *)pSql;
+    schedMsg.thandle = (void *)1;
+    schedMsg.msg = 0;
+    taosScheduleTask(tscQhandle, &schedMsg);
+    return;
+  }
+
   if (pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE) {
     tscFetchDatablockForSubquery(pSql);
   } else if (pRes->completed) {
@@ -231,7 +243,8 @@ void taos_fetch_rows_a(TAOS_RES *tres, __async_cb_func_t fp, void *param) {
          * all available virtual nodes in current clause has been checked already, now try the
          * next one in the following union subclause
          */
-        if (pCmd->clauseIndex < pCmd->numOfClause - 1) {
+        if (pCmd->active->sibling != NULL) {
+          pCmd->active = pCmd->active->sibling;  // todo refactor
           tscTryQueryNextClause(pSql, tscAsyncQueryRowsForNextVnode);
           return;
         }
@@ -255,7 +268,7 @@ void taos_fetch_rows_a(TAOS_RES *tres, __async_cb_func_t fp, void *param) {
       pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
     }
 
-    SQueryInfo* pQueryInfo1 = tscGetActiveQueryInfo(&pSql->cmd);
+    SQueryInfo* pQueryInfo1 = tscGetQueryInfo(&pSql->cmd);
     tscBuildAndSendRequest(pSql, pQueryInfo1);
   }
 }
@@ -317,27 +330,39 @@ static int32_t updateMetaBeforeRetryQuery(SSqlObj* pSql, STableMetaInfo* pTableM
   // update the pExpr info, colList info, number of table columns
   // TODO Re-parse this sql and issue the corresponding subquery as an alternative for this case.
   if (pSql->retryReason == TSDB_CODE_TDB_INVALID_TABLE_ID) {
-    int32_t numOfExprs = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+    int32_t numOfExprs = (int32_t) tscNumOfExprs(pQueryInfo);
     int32_t numOfCols = tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
     int32_t numOfTags = tscGetNumOfTags(pTableMetaInfo->pTableMeta);
 
     SSchema *pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
+    SSchema *pTagSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
+
     for (int32_t i = 0; i < numOfExprs; ++i) {
-      SSqlExpr *pExpr = &(tscSqlExprGet(pQueryInfo, i)->base);
+      SSqlExpr *pExpr = &(tscExprGet(pQueryInfo, i)->base);
+
+      // update the table uid
       pExpr->uid = pTableMetaInfo->pTableMeta->id.uid;
 
       if (pExpr->colInfo.colIndex >= 0) {
         int32_t index = pExpr->colInfo.colIndex;
 
         if ((TSDB_COL_IS_NORMAL_COL(pExpr->colInfo.flag) && index >= numOfCols) ||
-            (TSDB_COL_IS_TAG(pExpr->colInfo.flag) && (index < numOfCols || index >= (numOfCols + numOfTags)))) {
+            (TSDB_COL_IS_TAG(pExpr->colInfo.flag) && (index < 0 || index >= numOfTags))) {
           return pSql->retryReason;
         }
 
+        if (TSDB_COL_IS_TAG(pExpr->colInfo.flag)) {
+          if ((pTagSchema[pExpr->colInfo.colIndex].colId != pExpr->colInfo.colId) &&
+              strcasecmp(pExpr->colInfo.name, pTagSchema[pExpr->colInfo.colIndex].name) != 0) {
+            return pSql->retryReason;
+          }
+        } else if (TSDB_COL_IS_NORMAL_COL(pExpr->colInfo.flag)) {
           if ((pSchema[pExpr->colInfo.colIndex].colId != pExpr->colInfo.colId) &&
               strcasecmp(pExpr->colInfo.name, pSchema[pExpr->colInfo.colIndex].name) != 0) {
             return pSql->retryReason;
           }
+        } else { // do nothing for udc
+        }
       }
     }
 
@@ -374,12 +399,12 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
 
   tscDebug("0x%"PRIx64" get %s successfully", pSql->self, msg);
   if (pSql->pStream == NULL) {
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+    SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
     // check if it is a sub-query of super table query first, if true, enter another routine
-    if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY|TSDB_QUERY_TYPE_SUBQUERY|TSDB_QUERY_TYPE_TAG_FILTER_QUERY))) {
+    if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY | TSDB_QUERY_TYPE_SUBQUERY |
-      tscDebug("0x%"PRIx64" update local table meta, continue to process sql and send the corresponding query", pSql->self);
+                                               TSDB_QUERY_TYPE_TAG_FILTER_QUERY))) {
-
+      tscDebug("0x%" PRIx64 " update cached table-meta, continue to process sql and send the corresponding query", pSql->self);
       STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
       code = tscGetTableMeta(pSql, pTableMetaInfo);
@@ -401,42 +426,8 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
       taosReleaseRef(tscObjRef, pSql->self);
       return;
     } else {  // continue to process normal async query
-      if (pCmd->parseFinished) {
+      if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT)) {
-        tscDebug("0x%"PRIx64" update local table meta, continue to process sql and send corresponding query", pSql->self);
+        tscDebug("0x%" PRIx64 " continue parse sql after get table-meta", pSql->self);
-
-        STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
-        code = tscGetTableMeta(pSql, pTableMetaInfo);
-
-        assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code == TSDB_CODE_SUCCESS);
-        if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-          taosReleaseRef(tscObjRef, pSql->self);
-          return;
-        }
-
-        assert(pCmd->command != TSDB_SQL_INSERT);
-
-        if (pCmd->command == TSDB_SQL_SELECT) {
-          tscDebug("0x%"PRIx64" redo parse sql string and proceed", pSql->self);
-          pCmd->parseFinished = false;
-          tscResetSqlCmd(pCmd, true);
-
-          code = tsParseSql(pSql, true);
-          if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-            taosReleaseRef(tscObjRef, pSql->self);
-            return;
-          } else if (code != TSDB_CODE_SUCCESS) {
-            goto _error;
-          }
-
-          tscBuildAndSendRequest(pSql, NULL);
-        } else {  // in all other cases, simple retry
-          tscBuildAndSendRequest(pSql, NULL);
-        }
-
-        taosReleaseRef(tscObjRef, pSql->self);
-        return;
-      } else {
-        tscDebug("0x%"PRIx64" continue parse sql after get table meta", pSql->self);
 
         code = tsParseSql(pSql, false);
         if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
@@ -446,8 +437,8 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
           goto _error;
         }
 
-        if (pCmd->insertType == TSDB_QUERY_TYPE_STMT_INSERT) {
+        if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_STMT_INSERT)) {
-          STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+          STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
           code = tscGetTableMeta(pSql, pTableMetaInfo);
           if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
             taosReleaseRef(tscObjRef, pSql->self);
@@ -457,59 +448,52 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
           }
 
           (*pSql->fp)(pSql->param, pSql, code);
-        } else if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT)) {
+        } else {
-          if (pCmd->dataSourceType == DATA_FROM_DATA_FILE) {
+          if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_FILE_INSERT)) {
             tscImportDataFromFile(pSql);
           } else {
             tscHandleMultivnodeInsert(pSql);
           }
+        }
       } else {
-          SQueryInfo* pQueryInfo1 = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+        if (pSql->retryReason != TSDB_CODE_SUCCESS) {
+          tscDebug("0x%" PRIx64 " update cached table-meta, re-validate sql statement and send query again",
+                   pSql->self);
+          tscResetSqlCmd(pCmd, false);
+          pSql->retryReason = TSDB_CODE_SUCCESS;
+        } else {
+          tscDebug("0x%" PRIx64 " cached table-meta, continue validate sql statement and send query", pSql->self);
+        }
+
+        code = tsParseSql(pSql, true);
+        if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+          taosReleaseRef(tscObjRef, pSql->self);
+          return;
+        } else if (code != TSDB_CODE_SUCCESS) {
+          goto _error;
+        }
+
+        SQueryInfo *pQueryInfo1 = tscGetQueryInfo(pCmd);
         executeQuery(pSql, pQueryInfo1);
       }
 
       taosReleaseRef(tscObjRef, pSql->self);
       return;
     }
-    }
-
   } else {  // stream computing
-    STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+    tscDebug("0x%"PRIx64" stream:%p meta is updated, start new query, command:%d", pSql->self, pSql->pStream, pCmd->command);
 
-    code = tscGetTableMeta(pSql, pTableMetaInfo);
+    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
-    if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+    if (tscNumOfExprs(pQueryInfo) == 0) {
-      taosReleaseRef(tscObjRef, pSql->self);
-      return;
-    } else if (code != TSDB_CODE_SUCCESS) {
-      goto _error;
-    }
-
-    if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-      code = tscGetSTableVgroupInfo(pSql, pCmd->clauseIndex);
-      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-        taosReleaseRef(tscObjRef, pSql->self);
-        return;
-      } else if (code != TSDB_CODE_SUCCESS) {
-        goto _error;
-      }
-    }
-
-    tscDebug("0x%"PRIx64" stream:%p meta is updated, start new query, command:%d", pSql->self, pSql->pStream, pSql->cmd.command);
-    if (!pSql->cmd.parseFinished) {
       tsParseSql(pSql, false);
     }
 
     (*pSql->fp)(pSql->param, pSql, code);
-    
     taosReleaseRef(tscObjRef, pSql->self);
-
     return;
   }
 
-//  tscDoQuery(pSql);
-
   taosReleaseRef(tscObjRef, pSql->self);
-  
   return;
 
   _error:

src/client/src/tscGlobalmerge.c

@@ -13,17 +13,19 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "tscLocalMerge.h"
-#include "tscSubquery.h"
 #include "os.h"
 #include "texpr.h"
 #include "tlosertree.h"
+
+#include "tscGlobalmerge.h"
+#include "tscSubquery.h"
 #include "tscLog.h"
-#include "tscUtil.h"
-#include "tschemautil.h"
-#include "tsclient.h"
 #include "qUtil.h"
 
+#define COLMODEL_GET_VAL(data, schema, rowId, colId) \
+  (data + (schema)->pFields[colId].offset * ((schema)->capacity) + (rowId) * (schema)->pFields[colId].field.bytes)
+
+
 typedef struct SCompareParam {
   SLocalDataSource **pLocalData;
   tOrderDescriptor * pDesc;
@@ -31,9 +33,18 @@ typedef struct SCompareParam {
   int32_t            groupOrderType;
 } SCompareParam;
 
-bool needToMergeRv(SSDataBlock* pBlock, SArray* columnIndex, int32_t index, char **buf);
+static bool needToMerge(SSDataBlock* pBlock, SArray* columnIndexList, int32_t index, char **buf) {
+  int32_t ret = 0;
+  size_t  size = taosArrayGetSize(columnIndexList);
+  if (size > 0) {
+    ret = compare_aRv(pBlock, columnIndexList, (int32_t) size, index, buf, TSDB_ORDER_ASC);
+  }
 
-int32_t treeComparator(const void *pLeft, const void *pRight, void *param) {
+  // if ret == 0, means the result belongs to the same group
+  return (ret == 0);
+}
+
+static int32_t treeComparator(const void *pLeft, const void *pRight, void *param) {
   int32_t pLeftIdx = *(int32_t *)pLeft;
   int32_t pRightIdx = *(int32_t *)pRight;
 
@@ -59,77 +70,25 @@ int32_t treeComparator(const void *pLeft, const void *pRight, void *param) {
   }
 }
 
-// todo merge with vnode side function
+int32_t tscCreateGlobalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrderDescriptor *pDesc,
-void tsCreateSQLFunctionCtx(SQueryInfo* pQueryInfo, SQLFunctionCtx* pCtx, SSchema* pSchema) {
+                             SQueryInfo* pQueryInfo, SGlobalMerger **pMerger, int64_t id) {
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
-  
-  for (int32_t i = 0; i < size; ++i) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
-
-    pCtx[i].order = pQueryInfo->order.order;
-    pCtx[i].functionId = pExpr->base.functionId;
-
-    pCtx[i].order = pQueryInfo->order.order;
-    pCtx[i].functionId = pExpr->base.functionId;
-
-    // input data format comes from pModel
-    pCtx[i].inputType = pSchema[i].type;
-    pCtx[i].inputBytes = pSchema[i].bytes;
-
-    pCtx[i].outputBytes = pExpr->base.resBytes;
-    pCtx[i].outputType  = pExpr->base.resType;
-
-    // input buffer hold only one point data
-    pCtx[i].size = 1;
-    pCtx[i].hasNull = true;
-    pCtx[i].currentStage = MERGE_STAGE;
-
-    // for top/bottom function, the output of timestamp is the first column
-    int32_t functionId = pExpr->base.functionId;
-    if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_DIFF) {
-      pCtx[i].ptsOutputBuf = pCtx[0].pOutput;
-      pCtx[i].param[2].i64 = pQueryInfo->order.order;
-      pCtx[i].param[2].nType  = TSDB_DATA_TYPE_BIGINT;
-      pCtx[i].param[1].i64 = pQueryInfo->order.orderColId;
-      pCtx[i].param[0].i64 = pExpr->base.param[0].i64;  // top/bot parameter
-    } else if (functionId == TSDB_FUNC_APERCT) {
-      pCtx[i].param[0].i64 = pExpr->base.param[0].i64;
-      pCtx[i].param[0].nType  = pExpr->base.param[0].nType;
-    } else if (functionId == TSDB_FUNC_BLKINFO) {
-      pCtx[i].param[0].i64 = pExpr->base.param[0].i64;
-      pCtx[i].param[0].nType = pExpr->base.param[0].nType;
-      pCtx[i].numOfParams = 1;
-    }
-
-    pCtx[i].interBufBytes = pExpr->base.interBytes;
-    pCtx[i].stableQuery = true;
-  }
-}
-
-void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrderDescriptor *pDesc,
-                          SColumnModel *finalmodel, SColumnModel *pFFModel, SSqlObj *pSql) {
-  SSqlCmd* pCmd = &pSql->cmd;
-  SSqlRes* pRes = &pSql->res;
-  
   if (pMemBuffer == NULL) {
-    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
+    tscDestroyGlobalMergerEnv(pMemBuffer, pDesc, numOfBuffer);
-    tscError("pMemBuffer:%p is NULL", pMemBuffer);
+    tscError("0x%"PRIx64" %p pMemBuffer is NULL", id, pMemBuffer);
-    pRes->code = TSDB_CODE_TSC_APP_ERROR;
+    return TSDB_CODE_TSC_APP_ERROR;
-    return;
   }
  
   if (pDesc->pColumnModel == NULL) {
-    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
+    tscDestroyGlobalMergerEnv(pMemBuffer, pDesc, numOfBuffer);
-    tscError("0x%"PRIx64" no local buffer or intermediate result format model", pSql->self);
+    tscError("0x%"PRIx64" no local buffer or intermediate result format model", id);
-    pRes->code = TSDB_CODE_TSC_APP_ERROR;
+    return  TSDB_CODE_TSC_APP_ERROR;
-    return;
   }
 
   int32_t numOfFlush = 0;
   for (int32_t i = 0; i < numOfBuffer; ++i) {
     int32_t len = pMemBuffer[i]->fileMeta.flushoutData.nLength;
     if (len == 0) {
-      tscDebug("0x%"PRIx64" no data retrieved from orderOfVnode:%d", pSql->self, i + 1);
+      tscDebug("0x%"PRIx64" no data retrieved from orderOfVnode:%d", id, i + 1);
       continue;
     }
 
@@ -137,41 +96,36 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
   }
 
   if (numOfFlush == 0 || numOfBuffer == 0) {
-    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
+    tscDestroyGlobalMergerEnv(pMemBuffer, pDesc, numOfBuffer);
-    pCmd->command = TSDB_SQL_RETRIEVE_EMPTY_RESULT; // no result, set the result empty
+    tscDebug("0x%"PRIx64" no data to retrieve", id);
-    tscDebug("0x%"PRIx64" retrieved no data", pSql->self);
+    return TSDB_CODE_SUCCESS;
-    return;
   }
 
   if (pDesc->pColumnModel->capacity >= pMemBuffer[0]->pageSize) {
-    tscError("0x%"PRIx64" Invalid value of buffer capacity %d and page size %d ", pSql->self, pDesc->pColumnModel->capacity,
+    tscError("0x%"PRIx64" Invalid value of buffer capacity %d and page size %d ", id, pDesc->pColumnModel->capacity,
              pMemBuffer[0]->pageSize);
 
-    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
+    tscDestroyGlobalMergerEnv(pMemBuffer, pDesc, numOfBuffer);
-    pRes->code = TSDB_CODE_TSC_APP_ERROR;
+    return TSDB_CODE_TSC_APP_ERROR;
-    return;
   }
 
-  size_t size = sizeof(SLocalMerger) + POINTER_BYTES * numOfFlush;
+  *pMerger = (SGlobalMerger *) calloc(1, sizeof(SGlobalMerger));
+  if ((*pMerger) == NULL) {
+    tscError("0x%"PRIx64" failed to create local merge structure, out of memory", id);
 
-  SLocalMerger *pMerger = (SLocalMerger *) calloc(1, size);
+    tscDestroyGlobalMergerEnv(pMemBuffer, pDesc, numOfBuffer);
-  if (pMerger == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    tscError("0x%"PRIx64" failed to create local merge structure, out of memory", pSql->self);
-
-    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    return;
   }
 
-  pMerger->pExtMemBuffer = pMemBuffer;
+  (*pMerger)->pExtMemBuffer = pMemBuffer;
-  pMerger->pLocalDataSrc = (SLocalDataSource **)&pMerger[1];
+  (*pMerger)->pLocalDataSrc = calloc(numOfFlush, POINTER_BYTES);
-  assert(pMerger->pLocalDataSrc != NULL);
+  assert((*pMerger)->pLocalDataSrc != NULL);
 
-  pMerger->numOfBuffer = numOfFlush;
+  (*pMerger)->numOfBuffer = numOfFlush;
-  pMerger->numOfVnode = numOfBuffer;
+  (*pMerger)->numOfVnode = numOfBuffer;
 
-  pMerger->pDesc = pDesc;
+  (*pMerger)->pDesc = pDesc;
-  tscDebug("0x%"PRIx64" the number of merged leaves is: %d", pSql->self, pMerger->numOfBuffer);
+  tscDebug("0x%"PRIx64" the number of merged leaves is: %d", id, (*pMerger)->numOfBuffer);
 
   int32_t idx = 0;
   for (int32_t i = 0; i < numOfBuffer; ++i) {
@@ -180,13 +134,12 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
     for (int32_t j = 0; j < numOfFlushoutInFile; ++j) {
       SLocalDataSource *ds = (SLocalDataSource *)malloc(sizeof(SLocalDataSource) + pMemBuffer[0]->pageSize);
       if (ds == NULL) {
-        tscError("0x%"PRIx64" failed to create merge structure", pSql->self);
+        tscError("0x%"PRIx64" failed to create merge structure", id);
-        pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
         tfree(pMerger);
-        return;
+        return TSDB_CODE_TSC_OUT_OF_MEMORY;
       }
       
-      pMerger->pLocalDataSrc[idx] = ds;
+      (*pMerger)->pLocalDataSrc[idx] = ds;
 
       ds->pMemBuffer = pMemBuffer[i];
       ds->flushoutIdx = j;
@@ -194,12 +147,12 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
       ds->pageId = 0;
       ds->rowIdx = 0;
 
-      tscDebug("0x%"PRIx64" load data from disk into memory, orderOfVnode:%d, total:%d", pSql->self, i + 1, idx + 1);
+      tscDebug("0x%"PRIx64" load data from disk into memory, orderOfVnode:%d, total:%d", id, i + 1, idx + 1);
       tExtMemBufferLoadData(pMemBuffer[i], &(ds->filePage), j, 0);
 #ifdef _DEBUG_VIEW
       printf("load data page into mem for build loser tree: %" PRIu64 " rows\n", ds->filePage.num);
       SSrcColumnInfo colInfo[256] = {0};
-      SQueryInfo *   pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+      SQueryInfo *   pQueryInfo = tscGetQueryInfo(pCmd);
 
       tscGetSrcColumnInfo(colInfo, pQueryInfo);
 
@@ -208,7 +161,7 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
 #endif
       
       if (ds->filePage.num == 0) {  // no data in this flush, the index does not increase
-        tscDebug("0x%"PRIx64" flush data is empty, ignore %d flush record", pSql->self, idx);
+        tscDebug("0x%"PRIx64" flush data is empty, ignore %d flush record", id, idx);
         tfree(ds);
         continue;
       }
@@ -219,115 +172,54 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
   
   // no data actually, no need to merge result.
   if (idx == 0) {
-    tfree(pMerger);
+    tscDebug("0x%"PRIx64" retrieved no data", id);
-    return;
+    tscDestroyGlobalMergerEnv(pMemBuffer, pDesc, numOfBuffer);
+    return TSDB_CODE_SUCCESS;
   }
 
-  pMerger->numOfBuffer = idx;
+  (*pMerger)->numOfBuffer = idx;
 
   SCompareParam *param = malloc(sizeof(SCompareParam));
   if (param == NULL) {
-    tfree(pMerger);
+    tfree((*pMerger));
-    return;
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  param->pLocalData = pMerger->pLocalDataSrc;
+  param->pLocalData = (*pMerger)->pLocalDataSrc;
-  param->pDesc = pMerger->pDesc;
+  param->pDesc = (*pMerger)->pDesc;
-  param->num = pMerger->pLocalDataSrc[0]->pMemBuffer->numOfElemsPerPage;
+  param->num = (*pMerger)->pLocalDataSrc[0]->pMemBuffer->numOfElemsPerPage;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
 
   param->groupOrderType = pQueryInfo->groupbyExpr.orderType;
-  pMerger->orderPrjOnSTable = tscOrderedProjectionQueryOnSTable(pQueryInfo, 0);
 
-  pRes->code = tLoserTreeCreate(&pMerger->pLoserTree, pMerger->numOfBuffer, param, treeComparator);
+  int32_t code = tLoserTreeCreate(&(*pMerger)->pLoserTree, (*pMerger)->numOfBuffer, param, treeComparator);
-  if (pMerger->pLoserTree == NULL || pRes->code != 0) {
+  if ((*pMerger)->pLoserTree == NULL || code != TSDB_CODE_SUCCESS) {
     tfree(param);
-    tfree(pMerger);
+    tfree((*pMerger));
-    return;
+    return code;
   }
 
-  // the input data format follows the old format, but output in a new format.
+  (*pMerger)->rowSize = pMemBuffer[0]->nElemSize;
-  // so, all the input must be parsed as old format
-  pMerger->pCtx = (SQLFunctionCtx *)calloc(tscSqlExprNumOfExprs(pQueryInfo), sizeof(SQLFunctionCtx));
-  pMerger->rowSize = pMemBuffer[0]->nElemSize;
 
-  tscFieldInfoUpdateOffset(pQueryInfo);
+  // todo fixed row size is larger than the minimum page size;
+  assert((*pMerger)->rowSize <= pMemBuffer[0]->pageSize);
 
-  if (pMerger->rowSize > pMemBuffer[0]->pageSize) {
+  if ((*pMerger)->pLoserTree == NULL) {
-    assert(false);  // todo fixed row size is larger than the minimum page size;
+    tfree((*pMerger)->pLoserTree);
-  }
-
-  // used to keep the latest input row
-  pMerger->pTempBuffer = (tFilePage *)calloc(1, pMerger->rowSize + sizeof(tFilePage));
-
-  pMerger->nResultBufSize = pMemBuffer[0]->pageSize * 16;
-  pMerger->pResultBuf = (tFilePage *)calloc(1, pMerger->nResultBufSize + sizeof(tFilePage));
-
-  pMerger->resColModel = finalmodel;
-  pMerger->resColModel->capacity = pMerger->nResultBufSize;
-  pMerger->finalModel = pFFModel;
-
-  if (finalmodel->rowSize > 0) {
-    pMerger->resColModel->capacity /= finalmodel->rowSize;
-  }
-
-  assert(finalmodel->rowSize > 0 && finalmodel->rowSize <= pMerger->rowSize);
-
-  if (pMerger->pTempBuffer == NULL || pMerger->pLoserTree == NULL) {
-    tfree(pMerger->pTempBuffer);
-    tfree(pMerger->pLoserTree);
     tfree(param);
-    tfree(pMerger);
+    tfree((*pMerger));
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    return;
   }
 
-  pMerger->pTempBuffer->num = 0;
-  tscCreateResPointerInfo(pRes, pQueryInfo);
-
-  SSchema* pschema = calloc(pDesc->pColumnModel->numOfCols, sizeof(SSchema));
-  for(int32_t i = 0; i < pDesc->pColumnModel->numOfCols; ++i) {
-    pschema[i] = pDesc->pColumnModel->pFields[i].field;
-  }
-
-  tsCreateSQLFunctionCtx(pQueryInfo, pMerger->pCtx, pschema);
-//  setCtxInputOutputBuffer(pQueryInfo, pMerger->pCtx, pMerger, pDesc);
-
-  tfree(pschema);
-
-  int32_t maxBufSize = 0;
-  for (int32_t k = 0; k < tscSqlExprNumOfExprs(pQueryInfo); ++k) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, k);
-    if (maxBufSize < pExpr->base.resBytes && pExpr->base.functionId == TSDB_FUNC_TAG) {
-      maxBufSize = pExpr->base.resBytes;
-    }
-  }
-
-  // we change the capacity of schema to denote that there is only one row in temp buffer
-  pMerger->pDesc->pColumnModel->capacity = 1;
-
   // restore the limitation value at the last stage
-  if (tscOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
+  if (pQueryInfo->orderProjectQuery) {
     pQueryInfo->limit.limit = pQueryInfo->clauseLimit;
     pQueryInfo->limit.offset = pQueryInfo->prjOffset;
   }
 
-  pRes->pLocalMerger = pMerger;
+  // we change the capacity of schema to denote that there is only one row in temp buffer
-  pRes->numOfGroups = 0;
+  (*pMerger)->pDesc->pColumnModel->capacity = 1;
 
-//  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  return TSDB_CODE_SUCCESS;
-//  STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
-  
-//  TSKEY stime = (pQueryInfo->order.order == TSDB_ORDER_ASC)? pQueryInfo->window.skey : pQueryInfo->window.ekey;
-//  int64_t revisedSTime = taosTimeTruncate(stime, &pQueryInfo->interval, tinfo.precision);
-  
-//  if (pQueryInfo->fillType != TSDB_FILL_NONE) {
-//    SFillColInfo* pFillCol = createFillColInfo(pQueryInfo);
-//    pMerger->pFillInfo =
-//        taosCreateFillInfo(pQueryInfo->order.order, revisedSTime, pQueryInfo->groupbyExpr.numOfGroupCols, 4096,
-//                           (int32_t)pQueryInfo->fieldsInfo.numOfOutput, pQueryInfo->interval.sliding,
-//                           pQueryInfo->interval.slidingUnit, tinfo.precision, pQueryInfo->fillType, pFillCol, pSql);
-//  }
 }
 
 static int32_t tscFlushTmpBufferImpl(tExtMemBuffer *pMemoryBuf, tOrderDescriptor *pDesc, tFilePage *pPage,
@@ -418,51 +310,39 @@ int32_t saveToBuffer(tExtMemBuffer *pMemoryBuf, tOrderDescriptor *pDesc, tFilePa
   return 0;
 }
 
-void tscDestroyLocalMerger(SSqlObj *pSql) {
+void tscDestroyGlobalMerger(SGlobalMerger* pMerger) {
-  if (pSql == NULL) {
+  if (pMerger == NULL) {
     return;
   }
 
-  SSqlRes *pRes = &(pSql->res);
+  for (int32_t i = 0; i < pMerger->numOfBuffer; ++i) {
-  if (pRes->pLocalMerger == NULL) {
+    tfree(pMerger->pLocalDataSrc[i]);
-    return;
   }
 
-  // there is no more result, so we release all allocated resource
+  pMerger->numOfBuffer = 0;
-  SLocalMerger *pLocalMerge = (SLocalMerger *)atomic_exchange_ptr(&pRes->pLocalMerger, NULL);
+  tscDestroyGlobalMergerEnv(pMerger->pExtMemBuffer, pMerger->pDesc, pMerger->numOfVnode);
-  tfree(pLocalMerge->pResultBuf);
-  tfree(pLocalMerge->pCtx);
 
-  if (pLocalMerge->pLoserTree) {
+  pMerger->numOfCompleted = 0;
-    tfree(pLocalMerge->pLoserTree->param);
+
-    tfree(pLocalMerge->pLoserTree);
+  if (pMerger->pLoserTree) {
+    tfree(pMerger->pLoserTree->param);
+    tfree(pMerger->pLoserTree);
   }
 
-  tscLocalReducerEnvDestroy(pLocalMerge->pExtMemBuffer, pLocalMerge->pDesc, pLocalMerge->resColModel,
+  tfree(pMerger->buf);
-                            pLocalMerge->finalModel, pLocalMerge->numOfVnode);
+  tfree(pMerger->pLocalDataSrc);
-  for (int32_t i = 0; i < pLocalMerge->numOfBuffer; ++i) {
+  free(pMerger);
-    tfree(pLocalMerge->pLocalDataSrc[i]);
-  }
-
-  pLocalMerge->numOfBuffer = 0;
-  pLocalMerge->numOfCompleted = 0;
-  tfree(pLocalMerge->pTempBuffer);
-
-  free(pLocalMerge);
-
-  tscDebug("0x%"PRIx64" free local reducer finished", pSql->self);
 }
 
-static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCmd, SColumnModel *pModel) {
+static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SQueryInfo* pQueryInfo, SColumnModel *pModel) {
   int32_t numOfGroupByCols = 0;
-  SQueryInfo *pQueryInfo = tscGetActiveQueryInfo(pCmd);
 
   if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
     numOfGroupByCols = pQueryInfo->groupbyExpr.numOfGroupCols;
   }
 
   // primary timestamp column is involved in final result
-  if (pQueryInfo->interval.interval != 0 || tscOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
+  if (pQueryInfo->interval.interval != 0 || pQueryInfo->orderProjectQuery) {
     numOfGroupByCols++;
   }
 
@@ -474,13 +354,13 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm
   if (numOfGroupByCols > 0) {
 
     if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
-      int32_t numOfInternalOutput = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+      int32_t numOfInternalOutput = (int32_t) tscNumOfExprs(pQueryInfo);
 
       // the last "pQueryInfo->groupbyExpr.numOfGroupCols" columns are order-by columns
       for (int32_t i = 0; i < pQueryInfo->groupbyExpr.numOfGroupCols; ++i) {
         SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, i);
         for(int32_t j = 0; j < numOfInternalOutput; ++j) {
-          SExprInfo* pExprInfo = tscSqlExprGet(pQueryInfo, j);
+          SExprInfo* pExprInfo = tscExprGet(pQueryInfo, j);
 
           int32_t functionId = pExprInfo->base.functionId;
           if (pColIndex->colId == pExprInfo->base.colInfo.colId && (functionId == TSDB_FUNC_PRJ || functionId == TSDB_FUNC_TAG)) {
@@ -502,9 +382,9 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm
       if (pQueryInfo->interval.interval != 0) {
         orderColIndexList[0] = PRIMARYKEY_TIMESTAMP_COL_INDEX;
       } else {
-        size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+        size_t size = tscNumOfExprs(pQueryInfo);
         for (int32_t i = 0; i < size; ++i) {
-          SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
+          SExprInfo *pExpr = tscExprGet(pQueryInfo, i);
           if (pExpr->base.functionId == TSDB_FUNC_PRJ && pExpr->base.colInfo.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
             orderColIndexList[0] = i;
           }
@@ -525,37 +405,30 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm
   }
 }
 
-int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOrderDescriptor **pOrderDesc,
+int32_t tscCreateGlobalMergerEnv(SQueryInfo *pQueryInfo, tExtMemBuffer ***pMemBuffer, int32_t numOfSub,
-                                 SColumnModel **pFinalModel, SColumnModel** pFFModel, uint32_t nBufferSizes) {
+                                 tOrderDescriptor **pOrderDesc, uint32_t nBufferSizes, int64_t id) {
-  SSqlCmd *pCmd = &pSql->cmd;
+  SSchema      *pSchema = NULL;
-  SSqlRes *pRes = &pSql->res;
-
-  SSchema *     pSchema = NULL;
   SColumnModel *pModel = NULL;
-  *pFinalModel = NULL;
 
-  SQueryInfo *    pQueryInfo = tscGetActiveQueryInfo(pCmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
-  (*pMemBuffer) = (tExtMemBuffer **)malloc(POINTER_BYTES * pSql->subState.numOfSub);
+  (*pMemBuffer) = (tExtMemBuffer **)malloc(POINTER_BYTES * numOfSub);
   if (*pMemBuffer == NULL) {
-    tscError("0x%"PRIx64" failed to allocate memory", pSql->self);
+    tscError("0x%"PRIx64" failed to allocate memory", id);
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    return pRes->code;
   }
   
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
   
   pSchema = (SSchema *)calloc(1, sizeof(SSchema) * size);
   if (pSchema == NULL) {
-    tscError("0x%"PRIx64" failed to allocate memory", pSql->self);
+    tscError("0x%"PRIx64" failed to allocate memory", id);
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    return pRes->code;
   }
 
   int32_t rlen = 0;
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo *pExpr = tscExprGet(pQueryInfo, i);
 
     pSchema[i].bytes = pExpr->base.resBytes;
     pSchema[i].type = (int8_t)pExpr->base.resType;
@@ -570,6 +443,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
   }
   
   pModel = createColumnModel(pSchema, (int32_t)size, capacity);
+  tfree(pSchema);
 
   int32_t pg = DEFAULT_PAGE_SIZE;
   int32_t overhead = sizeof(tFilePage);
@@ -577,95 +451,26 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
     pg *= 2;
   }
 
-  size_t numOfSubs = pSql->subState.numOfSub;
+  assert(numOfSub <= pTableMetaInfo->vgroupList->numOfVgroups);
-  assert(numOfSubs <= pTableMetaInfo->vgroupList->numOfVgroups);
+  for (int32_t i = 0; i < numOfSub; ++i) {
-  for (int32_t i = 0; i < numOfSubs; ++i) {
     (*pMemBuffer)[i] = createExtMemBuffer(nBufferSizes, rlen, pg, pModel);
     (*pMemBuffer)[i]->flushModel = MULTIPLE_APPEND_MODEL;
   }
 
-  if (createOrderDescriptor(pOrderDesc, pCmd, pModel) != TSDB_CODE_SUCCESS) {
+  if (createOrderDescriptor(pOrderDesc, pQueryInfo, pModel) != TSDB_CODE_SUCCESS) {
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    tfree(pSchema);
-    return pRes->code;
   }
 
-  // final result depends on the fields number
-  memset(pSchema, 0, sizeof(SSchema) * size);
-
-  for (int32_t i = 0; i < size; ++i) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
-
-    SSchema p1 = {0};
-    if (pExpr->base.colInfo.colIndex == TSDB_TBNAME_COLUMN_INDEX) {
-      p1 = *tGetTbnameColumnSchema();
-    } else if (TSDB_COL_IS_UD_COL(pExpr->base.colInfo.flag)) {
-      p1.bytes = pExpr->base.resBytes;
-      p1.type  = (uint8_t) pExpr->base.resType;
-      tstrncpy(p1.name, pExpr->base.aliasName, tListLen(p1.name));
-    } else {
-      p1 = *tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pExpr->base.colInfo.colIndex);
-    }
-
-    int32_t inter = 0;
-    int16_t type = -1;
-    int16_t bytes = 0;
-
-    // the final result size and type in the same as query on single table.
-    // so here, set the flag to be false;
-    int32_t functionId = pExpr->base.functionId;
-    if (functionId >= TSDB_FUNC_TS && functionId <= TSDB_FUNC_DIFF) {
-      type = pModel->pFields[i].field.type;
-      bytes = pModel->pFields[i].field.bytes;
-    } else {
-      if (functionId == TSDB_FUNC_FIRST_DST) {
-        functionId = TSDB_FUNC_FIRST;
-      } else if (functionId == TSDB_FUNC_LAST_DST) {
-        functionId = TSDB_FUNC_LAST;
-      } else if (functionId == TSDB_FUNC_STDDEV_DST) {
-        functionId = TSDB_FUNC_STDDEV;
-      }
-
-      int32_t ret = getResultDataInfo(p1.type, p1.bytes, functionId, 0, &type, &bytes, &inter, 0, false);
-      assert(ret == TSDB_CODE_SUCCESS);
-    }
-
-    pSchema[i].type = (uint8_t)type;
-    pSchema[i].bytes = bytes;
-    strcpy(pSchema[i].name, pModel->pFields[i].field.name);
-  }
-  
-  *pFinalModel = createColumnModel(pSchema, (int32_t)size, capacity);
-
-  memset(pSchema, 0, sizeof(SSchema) * size);
-  size = tscNumOfFields(pQueryInfo);
-
-  for(int32_t i = 0; i < size; ++i) {
-    SInternalField* pField = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i);
-    pSchema[i].bytes = pField->field.bytes;
-    pSchema[i].type = pField->field.type;
-    tstrncpy(pSchema[i].name, pField->field.name, tListLen(pSchema[i].name));
-  }
-
-  *pFFModel = createColumnModel(pSchema, (int32_t) size, capacity);
-
-   tfree(pSchema);
   return TSDB_CODE_SUCCESS;
 }
 
 /**
  * @param pMemBuffer
  * @param pDesc
- * @param pFinalModel
  * @param numOfVnodes
  */
-void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDesc, SColumnModel *pFinalModel, SColumnModel *pFFModel,
+void tscDestroyGlobalMergerEnv(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDesc, int32_t numOfVnodes) {
-                               int32_t numOfVnodes) {
-  destroyColumnModel(pFinalModel);
-  destroyColumnModel(pFFModel);
-
   tOrderDescDestroy(pDesc);
-
   for (int32_t i = 0; i < numOfVnodes; ++i) {
     pMemBuffer[i] = destoryExtMemBuffer(pMemBuffer[i]);
   }
@@ -675,12 +480,12 @@ void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDe
 
 /**
  *
- * @param pLocalMerge
+ * @param pMerger
  * @param pOneInterDataSrc
  * @param treeList
  * @return the number of remain input source. if ret == 0, all data has been handled
  */
-int32_t loadNewDataFromDiskFor(SLocalMerger *pLocalMerge, SLocalDataSource *pOneInterDataSrc,
+int32_t loadNewDataFromDiskFor(SGlobalMerger *pMerger, SLocalDataSource *pOneInterDataSrc,
                                bool *needAdjustLoserTree) {
   pOneInterDataSrc->rowIdx = 0;
   pOneInterDataSrc->pageId += 1;
@@ -697,17 +502,17 @@ int32_t loadNewDataFromDiskFor(SLocalMerger *pLocalMerge, SLocalDataSource *pOne
 #endif
     *needAdjustLoserTree = true;
   } else {
-    pLocalMerge->numOfCompleted += 1;
+    pMerger->numOfCompleted += 1;
 
     pOneInterDataSrc->rowIdx = -1;
     pOneInterDataSrc->pageId = -1;
     *needAdjustLoserTree = true;
   }
 
-  return pLocalMerge->numOfBuffer;
+  return pMerger->numOfBuffer;
 }
 
-void adjustLoserTreeFromNewData(SLocalMerger *pLocalMerge, SLocalDataSource *pOneInterDataSrc,
+void adjustLoserTreeFromNewData(SGlobalMerger *pMerger, SLocalDataSource *pOneInterDataSrc,
                                 SLoserTreeInfo *pTree) {
   /*
    * load a new data page into memory for intermediate dataset source,
@@ -715,7 +520,7 @@ void adjustLoserTreeFromNewData(SLocalMerger *pLocalMerge, SLocalDataSource *pOn
    */
   bool needToAdjust = true;
   if (pOneInterDataSrc->filePage.num <= pOneInterDataSrc->rowIdx) {
-    loadNewDataFromDiskFor(pLocalMerge, pOneInterDataSrc, &needToAdjust);
+    loadNewDataFromDiskFor(pMerger, pOneInterDataSrc, &needToAdjust);
   }
 
   /*
@@ -723,7 +528,7 @@ void adjustLoserTreeFromNewData(SLocalMerger *pLocalMerge, SLocalDataSource *pOn
    * if the loser tree is rebuild completed, we do not need to adjust
    */
   if (needToAdjust) {
-    int32_t leafNodeIdx = pTree->pNode[0].index + pLocalMerge->numOfBuffer;
+    int32_t leafNodeIdx = pTree->pNode[0].index + pMerger->numOfBuffer;
 
 #ifdef _DEBUG_VIEW
     printf("before adjust:\t");
@@ -775,7 +580,7 @@ static void setTagValueForMultipleRows(SQLFunctionCtx* pCtx, int32_t numOfOutput
   }
 }
 
-static void doExecuteFinalMergeRv(SOperatorInfo* pOperator, int32_t numOfExpr, SSDataBlock* pBlock) {
+static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSDataBlock* pBlock) {
   SMultiwayMergeInfo* pInfo = pOperator->info;
   SQLFunctionCtx* pCtx = pInfo->binfo.pCtx;
 
@@ -787,7 +592,7 @@ static void doExecuteFinalMergeRv(SOperatorInfo* pOperator, int32_t numOfExpr, S
 
   for(int32_t i = 0; i < pBlock->info.rows; ++i) {
     if (pInfo->hasPrev) {
-      if (needToMergeRv(pBlock, pInfo->orderColumnList, i, pInfo->prevRow)) {
+      if (needToMerge(pBlock, pInfo->orderColumnList, i, pInfo->prevRow)) {
         for (int32_t j = 0; j < numOfExpr; ++j) {
           pCtx[j].pInput = add[j] + pCtx[j].inputBytes * i;
         }
@@ -862,45 +667,27 @@ static void doExecuteFinalMergeRv(SOperatorInfo* pOperator, int32_t numOfExpr, S
   tfree(add);
 }
 
-bool needToMergeRv(SSDataBlock* pBlock, SArray* columnIndexList, int32_t index, char **buf) {
+static bool isAllSourcesCompleted(SGlobalMerger *pMerger) {
-  int32_t ret = 0;
+  return (pMerger->numOfBuffer == pMerger->numOfCompleted);
-  size_t  size = taosArrayGetSize(columnIndexList);
-  if (size > 0) {
-    ret = compare_aRv(pBlock, columnIndexList, (int32_t) size, index, buf, TSDB_ORDER_ASC);
-  }
-
-  // if ret == 0, means the result belongs to the same group
-  return (ret == 0);
 }
 
-static bool isAllSourcesCompleted(SLocalMerger *pLocalMerge) {
+SGlobalMerger* tscInitResObjForLocalQuery(int32_t numOfRes, int32_t rowLen, uint64_t id) {
-  return (pLocalMerge->numOfBuffer == pLocalMerge->numOfCompleted);
+  SGlobalMerger *pMerger = calloc(1, sizeof(SGlobalMerger));
-}
+  if (pMerger == NULL) {
-
+    tscDebug("0x%"PRIx64" free local reducer finished", id);
-void tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen) {
+    return NULL;
-  SSqlRes *pRes = &pObj->res;
-  if (pRes->pLocalMerger != NULL) {
-    tscDestroyLocalMerger(pObj);
   }
 
-  pRes->qId = 1;  // hack to pass the safety check in fetch_row function
-  pRes->numOfRows = 0;
-  pRes->row = 0;
-
-  pRes->rspType = 0;  // used as a flag to denote if taos_retrieved() has been called yet
-  pRes->pLocalMerger = (SLocalMerger *)calloc(1, sizeof(SLocalMerger));
-
   /*
-   * we need one additional byte space
+   * One more byte space is required, since the sprintf function needs one additional space to put '\0' at
-   * the sprintf function needs one additional space to put '\0' at the end of string
+   * the end of string
    */
-  size_t allocSize = numOfRes * rowLen + sizeof(tFilePage) + 1;
+  size_t size = numOfRes * rowLen + 1;
-  pRes->pLocalMerger->pResultBuf = (tFilePage *)calloc(1, allocSize);
+  pMerger->buf = calloc(1, size);
-
+  return pMerger;
-  pRes->pLocalMerger->pResultBuf->num = numOfRes;
-  pRes->data = pRes->pLocalMerger->pResultBuf->data;
 }
 
+// todo remove it
 int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_t rowSize, int32_t finalRowSize) {
   int32_t maxRowSize = MAX(rowSize, finalRowSize);
   char* pbuf = calloc(1, (size_t)(pOutput->num * maxRowSize));
@@ -910,12 +697,12 @@ int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_
 
   // todo refactor
   arithSup.offset     = 0;
-  arithSup.numOfCols  = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+  arithSup.numOfCols  = (int32_t) tscNumOfExprs(pQueryInfo);
   arithSup.exprList   = pQueryInfo->exprList;
   arithSup.data       = calloc(arithSup.numOfCols, POINTER_BYTES);
 
   for(int32_t k = 0; k < arithSup.numOfCols; ++k) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, k);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, k);
     arithSup.data[k] = (pOutput->data + pOutput->num* pExpr->base.offset);
   }
 
@@ -944,16 +731,13 @@ int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_
   return offset;
 }
 
-#define COLMODEL_GET_VAL(data, schema, allrow, rowId, colId) \
-  (data + (schema)->pFields[colId].offset * (allrow) + (rowId) * (schema)->pFields[colId].field.bytes)
-
 static void appendOneRowToDataBlock(SSDataBlock *pBlock, char *buf, SColumnModel *pModel, int32_t rowIndex,
                                     int32_t maxRows) {
   for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
     SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);
     char* p = pColInfo->pData + pBlock->info.rows * pColInfo->info.bytes;
 
-    char *src = COLMODEL_GET_VAL(buf, pModel, maxRows, rowIndex, i);
+    char *src = COLMODEL_GET_VAL(buf, pModel, rowIndex, i);
     memmove(p, src, pColInfo->info.bytes);
   }
 
@@ -968,10 +752,8 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
 
   SMultiwayMergeInfo *pInfo = pOperator->info;
 
-  SLocalMerger   *pMerger = pInfo->pMerge;
+  SGlobalMerger   *pMerger = pInfo->pMerge;
   SLoserTreeInfo *pTree   = pMerger->pLoserTree;
-  SColumnModel   *pModel  = pMerger->pDesc->pColumnModel;
-  tFilePage      *tmpBuffer = pMerger->pTempBuffer;
 
   pInfo->binfo.pRes->info.rows = 0;
 
@@ -984,7 +766,7 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
     printf("chosen data in pTree[0] = %d\n", pTree->pNode[0].index);
 #endif
 
-    assert((pTree->pNode[0].index < pMerger->numOfBuffer) && (pTree->pNode[0].index >= 0) && tmpBuffer->num == 0);
+    assert((pTree->pNode[0].index < pMerger->numOfBuffer) && (pTree->pNode[0].index >= 0));
 
     // chosen from loser tree
     SLocalDataSource *pOneDataSrc = pMerger->pLocalDataSrc[pTree->pNode[0].index];
@@ -997,11 +779,10 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
         SColIndex *      pIndex = taosArrayGet(pInfo->orderColumnList, i);
         SColumnInfoData *pColInfo = taosArrayGet(pInfo->binfo.pRes->pDataBlock, pIndex->colIndex);
 
-        char *newRow =
+        char *newRow = COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pOneDataSrc->pMemBuffer->pColumnModel,
-            COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pModel, pOneDataSrc->pMemBuffer->pColumnModel->capacity,
                                         pOneDataSrc->rowIdx, pIndex->colIndex);
 
-        char *  data = pInfo->prevRow[i];
+        char   *data = pInfo->prevRow[i];
         int32_t ret = columnValueAscendingComparator(data, newRow, pColInfo->info.type, pColInfo->info.bytes);
         if (ret == 0) {
           continue;
@@ -1020,8 +801,7 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
         SColIndex *      pIndex = taosArrayGet(pInfo->orderColumnList, i);
         SColumnInfoData *pColInfo = taosArrayGet(pInfo->binfo.pRes->pDataBlock, pIndex->colIndex);
 
-        char *curCol =
+        char *curCol = COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pOneDataSrc->pMemBuffer->pColumnModel,
-            COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pModel, pOneDataSrc->pMemBuffer->pColumnModel->capacity,
                                         pOneDataSrc->rowIdx, pIndex->colIndex);
         memcpy(pInfo->prevRow[i], curCol, pColInfo->info.bytes);
       }
@@ -1033,7 +813,8 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
       return pInfo->binfo.pRes;
     }
 
-    appendOneRowToDataBlock(pInfo->binfo.pRes, pOneDataSrc->filePage.data, pModel, pOneDataSrc->rowIdx, pOneDataSrc->pMemBuffer->pColumnModel->capacity);
+    appendOneRowToDataBlock(pInfo->binfo.pRes, pOneDataSrc->filePage.data, pOneDataSrc->pMemBuffer->pColumnModel,
+        pOneDataSrc->rowIdx, pOneDataSrc->pMemBuffer->pColumnModel->capacity);
 
 #if defined(_DEBUG_VIEW)
     printf("chosen row:\t");
@@ -1055,7 +836,7 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
   return (pInfo->binfo.pRes->info.rows > 0)? pInfo->binfo.pRes:NULL;
 }
 
-static bool isSameGroupRv(SArray* orderColumnList, SSDataBlock* pBlock, char** dataCols) {
+static bool isSameGroup(SArray* orderColumnList, SSDataBlock* pBlock, char** dataCols) {
   int32_t numOfCols = (int32_t) taosArrayGetSize(orderColumnList);
   for (int32_t i = 0; i < numOfCols; ++i) {
     SColIndex *pIndex = taosArrayGet(orderColumnList, i);
@@ -1082,7 +863,7 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
   }
 
   SMultiwayMergeInfo *pAggInfo = pOperator->info;
-  SOperatorInfo      *upstream = pOperator->upstream;
+  SOperatorInfo      *upstream = pOperator->upstream[0];
 
   *newgroup = false;
   bool handleData = false;
@@ -1103,7 +884,7 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
         }
       }
 
-      doExecuteFinalMergeRv(pOperator, pOperator->numOfOutput, pAggInfo->pExistBlock);
+      doExecuteFinalMerge(pOperator, pOperator->numOfOutput, pAggInfo->pExistBlock);
 
       savePrevOrderColumns(pAggInfo->currentGroupColData, pAggInfo->groupColumnList, pAggInfo->pExistBlock, 0,
                            &pAggInfo->hasGroupColData);
@@ -1124,7 +905,7 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
     }
 
     if (pAggInfo->hasGroupColData) {
-      bool sameGroup = isSameGroupRv(pAggInfo->groupColumnList, pBlock, pAggInfo->currentGroupColData);
+      bool sameGroup = isSameGroup(pAggInfo->groupColumnList, pBlock, pAggInfo->currentGroupColData);
       if (!sameGroup) {
         *newgroup = true;
         pAggInfo->hasDataBlockForNewGroup = true;
@@ -1138,7 +919,7 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
     setInputDataBlock(pOperator, pAggInfo->binfo.pCtx, pBlock, TSDB_ORDER_ASC);
     updateOutputBuf(&pAggInfo->binfo, &pAggInfo->bufCapacity, pBlock->info.rows * pAggInfo->resultRowFactor);
 
-    doExecuteFinalMergeRv(pOperator, pOperator->numOfOutput, pBlock);
+    doExecuteFinalMerge(pOperator, pOperator->numOfOutput, pBlock);
     savePrevOrderColumns(pAggInfo->currentGroupColData, pAggInfo->groupColumnList, pBlock, 0, &pAggInfo->hasGroupColData);
     handleData = true;
   }
@@ -1166,7 +947,6 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
     if (pInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP && pRes->info.rows > 0) {
       STimeWindow* w = &pRes->info.window;
 
-      // TODO in case of desc order, swap it
       w->skey = *(int64_t*)pInfoData->pData;
       w->ekey = *(int64_t*)(((char*)pInfoData->pData) + TSDB_KEYSIZE * (pRes->info.rows - 1));
 
@@ -1186,7 +966,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
 
   SSDataBlock* pBlock = NULL;
   if (pInfo->currentGroupOffset == 0) {
-    pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+    pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
     if (pBlock == NULL) {
       setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
       pOperator->status = OP_EXEC_DONE;
@@ -1194,7 +974,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
 
     if (*newgroup == false && pInfo->limit.limit > 0 && pInfo->rowsTotal >= pInfo->limit.limit) {
       while ((*newgroup) == false) {  // ignore the remain blocks
-        pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+        pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
         if (pBlock == NULL) {
           setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
           pOperator->status = OP_EXEC_DONE;
@@ -1206,7 +986,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
     return pBlock;
   }
 
-    pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+    pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
     if (pBlock == NULL) {
       setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
       pOperator->status = OP_EXEC_DONE;
@@ -1220,7 +1000,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
       }
 
       while ((*newgroup) == false) {
-        pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+        pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
         if (pBlock == NULL) {
           setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
           pOperator->status = OP_EXEC_DONE;

src/client/src/tscLocal.c

@@ -20,7 +20,7 @@
 #include "tname.h"
 #include "tscLog.h"
 #include "tscUtil.h"
-#include "tschemautil.h"
+#include "qTableMeta.h"
 #include "tsclient.h"
 #include "taos.h"
 #include "tscSubquery.h"
@@ -53,7 +53,7 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   SSqlRes *pRes = &pSql->res;
 
   // one column for each row
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
@@ -71,7 +71,9 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
     numOfRows = numOfRows + tscGetNumOfTags(pMeta);
   }
 
-  tscInitResObjForLocalQuery(pSql, totalNumOfRows, rowLen);
+  pSql->res.pMerger = tscInitResObjForLocalQuery(totalNumOfRows, rowLen, pSql->self);
+  tscInitResForMerge(&pSql->res);
+
   SSchema *pSchema = tscGetTableSchema(pMeta);
 
   for (int32_t i = 0; i < numOfRows; ++i) {
@@ -154,14 +156,14 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   
   pSql->cmd.numOfCols = numOfCols;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   pQueryInfo->order.order = TSDB_ORDER_ASC;
 
   TAOS_FIELD f = {.type = TSDB_DATA_TYPE_BINARY, .bytes = (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE};
   tstrncpy(f.name, "Field", sizeof(f.name));
   
   SInternalField* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
       (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE, -1000, (TSDB_COL_NAME_LEN - 1), false);
   
   rowLen += ((TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE);
@@ -171,7 +173,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   tstrncpy(f.name, "Type", sizeof(f.name));
   
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(typeColLength + VARSTR_HEADER_SIZE),
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(typeColLength + VARSTR_HEADER_SIZE),
       -1000, typeColLength, false);
   
   rowLen += typeColLength + VARSTR_HEADER_SIZE;
@@ -181,7 +183,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   tstrncpy(f.name, "Length", sizeof(f.name));
   
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_INT, sizeof(int32_t),
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_INT, sizeof(int32_t),
       -1000, sizeof(int32_t), false);
   
   rowLen += sizeof(int32_t);
@@ -191,7 +193,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   tstrncpy(f.name, "Note", sizeof(f.name));
   
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(noteColLength + VARSTR_HEADER_SIZE),
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(noteColLength + VARSTR_HEADER_SIZE),
       -1000, noteColLength, false);
   
   rowLen += noteColLength + VARSTR_HEADER_SIZE;
@@ -199,7 +201,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
 }
 
 static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   assert(tscGetMetaInfo(pQueryInfo, 0)->pTableMeta != NULL);
 
@@ -390,7 +392,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
   SColumnIndex index = {0};
   pSql->cmd.numOfCols = 2;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   pQueryInfo->order.order = TSDB_ORDER_ASC;
 
   TAOS_FIELD f; 
@@ -405,7 +407,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
   } 
 
   SInternalField* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, f.bytes, -1000, f.bytes - VARSTR_HEADER_SIZE, false);
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, f.bytes, -1000, f.bytes - VARSTR_HEADER_SIZE, false);
 
   rowLen += f.bytes; 
 
@@ -418,7 +420,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
   }
 
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
       (int16_t)(ddlLen + VARSTR_HEADER_SIZE), -1000, ddlLen, false);
 
   rowLen += ddlLen + VARSTR_HEADER_SIZE;
@@ -428,12 +430,13 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
 static int32_t tscSCreateSetValueToResObj(SSqlObj *pSql, int32_t rowLen, const char *tableName, const char *ddl) {
   SSqlRes *pRes = &pSql->res;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   int32_t numOfRows = 1;
   if (strlen(ddl) == 0) {
     
   }
-  tscInitResObjForLocalQuery(pSql, numOfRows, rowLen);
+  pSql->res.pMerger = tscInitResObjForLocalQuery(numOfRows, rowLen, pSql->self);
+  tscInitResForMerge(&pSql->res);
 
   TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, 0);
   char* dst = pRes->data + tscFieldInfoGetOffset(pQueryInfo, 0) * numOfRows;
@@ -445,7 +448,7 @@ static int32_t tscSCreateSetValueToResObj(SSqlObj *pSql, int32_t rowLen, const c
   return 0;
 }
 static int32_t tscSCreateBuildResult(SSqlObj *pSql, BuildType type, const char *str, const char *result) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   int32_t rowLen = tscSCreateBuildResultFields(pSql, type, result);
 
   tscFieldInfoUpdateOffset(pQueryInfo);
@@ -532,7 +535,7 @@ static int32_t tscGetTableTagColumnName(SSqlObj *pSql, char **result) {
   }
   buf[0] = 0;
 
-  STableMeta *pMeta = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0)->pTableMeta; 
+  STableMeta *pMeta = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0)->pTableMeta;
   if (pMeta->tableType == TSDB_SUPER_TABLE || pMeta->tableType == TSDB_NORMAL_TABLE ||
       pMeta->tableType == TSDB_STREAM_TABLE) {
     free(buf);
@@ -553,7 +556,7 @@ static int32_t tscGetTableTagColumnName(SSqlObj *pSql, char **result) {
   return TSDB_CODE_SUCCESS;
 }  
 static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, char *ddl) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
@@ -607,7 +610,7 @@ static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, ch
 }
 
 static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName, char *ddl) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
 
@@ -634,7 +637,7 @@ static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName,
 }
 static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName, char *ddl) {
   char *result = ddl;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
 
@@ -675,7 +678,7 @@ static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName,
 }
 
 static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   assert(pTableMetaInfo->pTableMeta != NULL);
 
@@ -704,7 +707,7 @@ static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
 }
 
 static int32_t tscProcessShowCreateDatabase(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
@@ -730,7 +733,7 @@ static int32_t tscProcessShowCreateDatabase(SSqlObj *pSql) {
   return TSDB_CODE_TSC_ACTION_IN_PROGRESS;
 }
 static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resBytes = TSDB_USER_LEN + TSDB_DATA_TYPE_BINARY;
@@ -757,7 +760,7 @@ static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
   extractDBName(pSql->pTscObj->db, db);
   pthread_mutex_unlock(&pSql->pTscObj->mutex);
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resType = TSDB_DATA_TYPE_BINARY;
@@ -784,7 +787,7 @@ static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
 
 static int32_t tscProcessServerVer(SSqlObj *pSql) {
   const char* v = pSql->pTscObj->sversion;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resType = TSDB_DATA_TYPE_BINARY;
@@ -807,7 +810,7 @@ static int32_t tscProcessServerVer(SSqlObj *pSql) {
 }
 
 static int32_t tscProcessClientVer(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resType = TSDB_DATA_TYPE_BINARY;
@@ -859,7 +862,7 @@ static int32_t tscProcessServStatus(SSqlObj *pSql) {
     return pSql->res.code;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
 
   int32_t val = 1;
@@ -873,7 +876,7 @@ void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnNa
 
   pCmd->numOfCols = 1;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   pQueryInfo->order.order = TSDB_ORDER_ASC;
 
   tscFieldInfoClear(&pQueryInfo->fieldsInfo);
@@ -882,7 +885,8 @@ void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnNa
   TAOS_FIELD f = tscCreateField((int8_t)type, columnName, (int16_t)valueLength);
   tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
 
-  tscInitResObjForLocalQuery(pSql, 1, (int32_t)valueLength);
+  pSql->res.pMerger = tscInitResObjForLocalQuery(1, (int32_t)valueLength, pSql->self);
+  tscInitResForMerge(&pSql->res);
 
   SInternalField* pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, 0);
   pInfo->pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
@@ -928,7 +932,7 @@ int tscProcessLocalCmd(SSqlObj *pSql) {
   } else if (pCmd->command == TSDB_SQL_SERV_STATUS) {
     pRes->code = tscProcessServStatus(pSql);
   } else {
-    pRes->code = TSDB_CODE_TSC_INVALID_SQL;
+    pRes->code = TSDB_CODE_TSC_INVALID_OPERATION;
     tscError("0x%"PRIx64" not support command:%d", pSql->self, pCmd->command);
   }
 

src/client/src/tscPrepare.c

@@ -46,9 +46,14 @@ typedef struct SNormalStmt {
 
 typedef struct SMultiTbStmt {
   bool      nameSet;
+  bool      tagSet;
   uint64_t  currentUid;
+  char     *sqlstr;
   uint32_t  tbNum;
   SStrToken tbname;
+  SStrToken stbname;
+  SStrToken values;
+  SArray   *tags;
   SHashObj *pTableHash;
   SHashObj *pTableBlockHashList;     // data block for each table
 } SMultiTbStmt;
@@ -308,7 +313,7 @@ static int fillColumnsNull(STableDataBlocks* pBlock, int32_t rowNum) {
 int32_t fillTablesColumnsNull(SSqlObj* pSql) {
   SSqlCmd* pCmd = &pSql->cmd;
 
-  STableDataBlocks** p = taosHashIterate(pCmd->pTableBlockHashList, NULL);
+  STableDataBlocks** p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, NULL);
 
   STableDataBlocks* pOneTableBlock = *p;
   while(pOneTableBlock) {
@@ -317,7 +322,7 @@ int32_t fillTablesColumnsNull(SSqlObj* pSql) {
       fillColumnsNull(pOneTableBlock, pBlocks->numOfRows);
     }
 
-    p = taosHashIterate(pCmd->pTableBlockHashList, p);
+    p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, p);
     if (p == NULL) {
       break;
     }
@@ -840,12 +845,12 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
   STableDataBlocks* pBlock = NULL;
 
   if (pStmt->multiTbInsert) {
-    if (pCmd->pTableBlockHashList == NULL) {
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
       tscError("0x%"PRIx64" Table block hash list is empty", pStmt->pSql->self);
       return TSDB_CODE_TSC_APP_ERROR;
     }
 
-    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
+    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->insertParam.pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
     if (t1 == NULL) {
       tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pStmt->pSql->self, pStmt->mtb.currentUid);
       return TSDB_CODE_TSC_APP_ERROR;
@@ -853,15 +858,15 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
 
     pBlock = *t1;
   } else {
-    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
 
     STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-    if (pCmd->pTableBlockHashList == NULL) {
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
-      pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+      pCmd->insertParam.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
     }
 
     int32_t ret =
-        tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+        tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
                                 pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
     if (ret != 0) {
       return ret;
@@ -904,12 +909,12 @@ static int insertStmtBindParamBatch(STscStmt* stmt, TAOS_MULTI_BIND* bind, int c
   STableDataBlocks* pBlock = NULL;
 
   if (pStmt->multiTbInsert) {
-    if (pCmd->pTableBlockHashList == NULL) {
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
       tscError("0x%"PRIx64" Table block hash list is empty", pStmt->pSql->self);
       return TSDB_CODE_TSC_APP_ERROR;
     }
 
-    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
+    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->insertParam.pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
     if (t1 == NULL) {
       tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pStmt->pSql->self, pStmt->mtb.currentUid);
       return TSDB_CODE_TSC_APP_ERROR;
@@ -917,15 +922,15 @@ static int insertStmtBindParamBatch(STscStmt* stmt, TAOS_MULTI_BIND* bind, int c
 
     pBlock = *t1;
   } else {
-    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
 
     STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-    if (pCmd->pTableBlockHashList == NULL) {
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
-      pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+      pCmd->insertParam.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
     }
 
     int32_t ret =
-        tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+        tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
                                 pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
     if (ret != 0) {
       return ret;
@@ -991,12 +996,11 @@ static int insertStmtUpdateBatch(STscStmt* stmt) {
     return TSDB_CODE_TSC_APP_ERROR;
   }
 
-  assert(pCmd->numOfClause == 1);
+  if (taosHashGetSize(pCmd->insertParam.pTableBlockHashList) == 0) {
-  if (taosHashGetSize(pCmd->pTableBlockHashList) == 0) {
     return TSDB_CODE_SUCCESS;
   }
 
-  STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->pTableBlockHashList, (const char*)&stmt->mtb.currentUid, sizeof(stmt->mtb.currentUid));
+  STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->insertParam.pTableBlockHashList, (const char*)&stmt->mtb.currentUid, sizeof(stmt->mtb.currentUid));
   if (t1 == NULL) {
     tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pSql->self, stmt->mtb.currentUid);
     return TSDB_CODE_TSC_APP_ERROR;
@@ -1032,9 +1036,9 @@ static int insertStmtReset(STscStmt* pStmt) {
   if (pCmd->batchSize > 2) {
     int32_t alloced = (pCmd->batchSize + 1) / 2;
 
-    size_t size = taosArrayGetSize(pCmd->pDataBlocks);
+    size_t size = taosArrayGetSize(pCmd->insertParam.pDataBlocks);
     for (int32_t i = 0; i < size; ++i) {
-      STableDataBlocks* pBlock = taosArrayGetP(pCmd->pDataBlocks, i);
+      STableDataBlocks* pBlock = taosArrayGetP(pCmd->insertParam.pDataBlocks, i);
 
       uint32_t totalDataSize = pBlock->size - sizeof(SSubmitBlk);
       pBlock->size = sizeof(SSubmitBlk) + totalDataSize / alloced;
@@ -1045,7 +1049,7 @@ static int insertStmtReset(STscStmt* pStmt) {
   }
   pCmd->batchSize = 0;
 
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
   pTableMetaInfo->vgroupIndex = 0;
   return TSDB_CODE_SUCCESS;
 }
@@ -1056,22 +1060,21 @@ static int insertStmtExecute(STscStmt* stmt) {
     return TSDB_CODE_TSC_INVALID_VALUE;
   }
 
-  assert(pCmd->numOfClause == 1);
+  if (taosHashGetSize(pCmd->insertParam.pTableBlockHashList) == 0) {
-  if (taosHashGetSize(pCmd->pTableBlockHashList) == 0) {
     return TSDB_CODE_SUCCESS;
   }
 
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
 
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-  if (pCmd->pTableBlockHashList == NULL) {
+  if (pCmd->insertParam.pTableBlockHashList == NULL) {
-    pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+    pCmd->insertParam.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
   }
 
   STableDataBlocks* pBlock = NULL;
 
   int32_t ret =
-      tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+      tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
                               pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
   assert(ret == 0);
   pBlock->size = sizeof(SSubmitBlk) + pCmd->batchSize * pBlock->rowSize;
@@ -1083,12 +1086,12 @@ static int insertStmtExecute(STscStmt* stmt) {
 
   fillTablesColumnsNull(stmt->pSql);
 
-  int code = tscMergeTableDataBlocks(stmt->pSql, false);
+  int code = tscMergeTableDataBlocks(&stmt->pSql->cmd.insertParam, false);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
 
-  STableDataBlocks* pDataBlock = taosArrayGetP(pCmd->pDataBlocks, 0);
+  STableDataBlocks* pDataBlock = taosArrayGetP(pCmd->insertParam.pDataBlocks, 0);
   code = tscCopyDataBlockToPayload(stmt->pSql, pDataBlock);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
@@ -1106,15 +1109,15 @@ static int insertStmtExecute(STscStmt* stmt) {
 
   // data block reset
   pCmd->batchSize = 0;
-  for(int32_t i = 0; i < pCmd->numOfTables; ++i) {
+  for(int32_t i = 0; i < pCmd->insertParam.numOfTables; ++i) {
-    if (pCmd->pTableNameList && pCmd->pTableNameList[i]) {
+    if (pCmd->insertParam.pTableNameList && pCmd->insertParam.pTableNameList[i]) {
-      tfree(pCmd->pTableNameList[i]);
+      tfree(pCmd->insertParam.pTableNameList[i]);
     }
   }
 
-  pCmd->numOfTables = 0;
+  pCmd->insertParam.numOfTables = 0;
-  tfree(pCmd->pTableNameList);
+  tfree(pCmd->insertParam.pTableNameList);
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
+  pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
 
   return pSql->res.code;
 }
@@ -1122,21 +1125,21 @@ static int insertStmtExecute(STscStmt* stmt) {
 static void insertBatchClean(STscStmt* pStmt) {
   SSqlCmd *pCmd = &pStmt->pSql->cmd;
   SSqlObj *pSql = pStmt->pSql;
-  int32_t size = taosHashGetSize(pCmd->pTableBlockHashList);
+  int32_t size = taosHashGetSize(pCmd->insertParam.pTableBlockHashList);
 
   // data block reset
   pCmd->batchSize = 0;
 
   for(int32_t i = 0; i < size; ++i) {
-    if (pCmd->pTableNameList && pCmd->pTableNameList[i]) {
+    if (pCmd->insertParam.pTableNameList && pCmd->insertParam.pTableNameList[i]) {
-      tfree(pCmd->pTableNameList[i]);
+      tfree(pCmd->insertParam.pTableNameList[i]);
     }
   }
 
-  tfree(pCmd->pTableNameList);
+  tfree(pCmd->insertParam.pTableNameList);
 
 /*
-  STableDataBlocks** p = taosHashIterate(pCmd->pTableBlockHashList, NULL);
+  STableDataBlocks** p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, NULL);
 
   STableDataBlocks* pOneTableBlock = *p;
 
@@ -1147,7 +1150,7 @@ static void insertBatchClean(STscStmt* pStmt) {
 
     pBlocks->numOfRows = 0;
 
-    p = taosHashIterate(pCmd->pTableBlockHashList, p);
+    p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, p);
     if (p == NULL) {
       break;
     }
@@ -1156,10 +1159,10 @@ static void insertBatchClean(STscStmt* pStmt) {
   }
 */
 
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
+  pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
-  pCmd->numOfTables = 0;
+  pCmd->insertParam.numOfTables = 0;
 
-  taosHashEmpty(pCmd->pTableBlockHashList);
+  taosHashEmpty(pCmd->insertParam.pTableBlockHashList);
   tscFreeSqlResult(pSql);
   tscFreeSubobj(pSql);
   tfree(pSql->pSubs);
@@ -1176,14 +1179,14 @@ static int insertBatchStmtExecute(STscStmt* pStmt) {
 
   pStmt->pSql->retry = pStmt->pSql->maxRetry + 1;  //no retry
 
-  if (taosHashGetSize(pStmt->pSql->cmd.pTableBlockHashList) <= 0) { // merge according to vgId
+  if (taosHashGetSize(pStmt->pSql->cmd.insertParam.pTableBlockHashList) <= 0) { // merge according to vgId
     tscError("0x%"PRIx64" no data block to insert", pStmt->pSql->self);
     return TSDB_CODE_TSC_APP_ERROR;
   }
 
   fillTablesColumnsNull(pStmt->pSql);
 
-  if ((code = tscMergeTableDataBlocks(pStmt->pSql, false)) != TSDB_CODE_SUCCESS) {
+  if ((code = tscMergeTableDataBlocks(&pStmt->pSql->cmd.insertParam, false)) != TSDB_CODE_SUCCESS) {
     return code;
   }
 
@@ -1201,6 +1204,184 @@ static int insertBatchStmtExecute(STscStmt* pStmt) {
   return pStmt->pSql->res.code;
 }
 
+int stmtParseInsertTbTags(SSqlObj* pSql, STscStmt* pStmt) {
+  SSqlCmd *pCmd    = &pSql->cmd;
+  int32_t ret = TSDB_CODE_SUCCESS;
+
+  if ((ret = tsInsertInitialCheck(pSql)) != TSDB_CODE_SUCCESS) {
+    return ret;
+  }
+
+  int32_t index = 0;
+  SStrToken sToken = tStrGetToken(pCmd->insertParam.sql, &index, false);
+  if (sToken.n == 0) {
+    return TSDB_CODE_TSC_INVALID_OPERATION;
+  }
+
+  if (sToken.n == 1 && sToken.type == TK_QUESTION) {
+    pStmt->multiTbInsert = true;
+    pStmt->mtb.tbname = sToken;
+    pStmt->mtb.nameSet = false;
+    if (pStmt->mtb.pTableHash == NULL) {
+      pStmt->mtb.pTableHash = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+    }
+
+    if (pStmt->mtb.pTableBlockHashList == NULL) {
+      pStmt->mtb.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+    }
+
+    pStmt->mtb.tagSet = true;
+
+    sToken = tStrGetToken(pCmd->insertParam.sql, &index, false);
+    if (sToken.n > 0 && (sToken.type == TK_VALUES || sToken.type == TK_LP)) {
+      return TSDB_CODE_SUCCESS;
+    }
+
+    if (sToken.n <= 0 || sToken.type != TK_USING) {
+      return tscSQLSyntaxErrMsg(pCmd->payload, "keywords USING is expected", sToken.z);
+    }
+
+    sToken = tStrGetToken(pCmd->insertParam.sql, &index, false);
+    if (sToken.n <= 0 || ((sToken.type != TK_ID) && (sToken.type != TK_STRING))) {
+      return tscSQLSyntaxErrMsg(pCmd->payload, "invalid token", sToken.z);
+    }
+    pStmt->mtb.stbname = sToken;
+
+    sToken = tStrGetToken(pCmd->insertParam.sql, &index, false);
+    if (sToken.n <= 0 || sToken.type != TK_TAGS) {
+      return tscSQLSyntaxErrMsg(pCmd->payload, "keyword TAGS expected", sToken.z);
+    }
+
+    sToken = tStrGetToken(pCmd->insertParam.sql, &index, false);
+    if (sToken.n <= 0 || sToken.type != TK_LP) {
+      return tscSQLSyntaxErrMsg(pCmd->payload, ") expected", sToken.z);
+    }
+
+    pStmt->mtb.tags = taosArrayInit(4, sizeof(SStrToken));
+
+    int32_t loopCont = 1;
+
+    while (loopCont) {
+      sToken = tStrGetToken(pCmd->insertParam.sql, &index, false);
+      if (sToken.n <= 0) {
+        return TSDB_CODE_TSC_INVALID_OPERATION;
+      }
+
+      switch (sToken.type) {
+        case TK_RP:
+          loopCont = 0;
+          break;
+        case TK_VALUES:
+          return TSDB_CODE_TSC_INVALID_OPERATION;
+        case TK_QUESTION:
+          pStmt->mtb.tagSet = false; //continue
+        default:
+          taosArrayPush(pStmt->mtb.tags, &sToken);
+          break;
+      }
+    }
+
+    if (taosArrayGetSize(pStmt->mtb.tags) <= 0) {
+      return TSDB_CODE_TSC_INVALID_OPERATION;
+    }
+
+    sToken = tStrGetToken(pCmd->insertParam.sql, &index, false);
+    if (sToken.n <= 0 || (sToken.type != TK_VALUES && sToken.type != TK_LP)) {
+      return TSDB_CODE_TSC_INVALID_OPERATION;
+    }
+
+    pStmt->mtb.values = sToken;
+
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int stmtGenInsertStatement(SSqlObj* pSql, STscStmt* pStmt, const char* name, TAOS_BIND* tags) {
+  size_t tagNum = taosArrayGetSize(pStmt->mtb.tags);
+  size_t size = 1048576;
+  char *str = calloc(1, size);
+  size_t len = 0;
+  int32_t ret = 0;
+  int32_t j = 0;
+
+  while (1) {
+    len = (size_t)snprintf(str, size - 1, "insert into %s using %.*s tags(", name, pStmt->mtb.stbname.n, pStmt->mtb.stbname.z);
+    if (len >= (size -1)) {
+      size *= 2;
+      free(str);
+      str = calloc(1, size);
+      continue;
+    }
+
+    j = 0;
+
+    for (size_t i = 0; i < tagNum && len < (size - 1); ++i) {
+      SStrToken *t = taosArrayGet(pStmt->mtb.tags, i);
+      if (t->type == TK_QUESTION) {
+        int32_t l = 0;
+        if (i > 0) {
+          str[len++] = ',';
+        }
+
+        if (tags[j].is_null && (*tags[j].is_null)) {
+          ret = converToStr(str + len, TSDB_DATA_TYPE_NULL, NULL, -1, &l);
+        } else {
+          if (tags[j].buffer == NULL) {
+            free(str);
+            tscError("empty");
+            return TSDB_CODE_TSC_APP_ERROR;
+          }
+
+          ret = converToStr(str + len, tags[j].buffer_type, tags[j].buffer, tags[j].length ? (int32_t)*tags[j].length : -1, &l);
+        }
+
+        ++j;
+
+        if (ret) {
+          free(str);
+          return ret;
+        }
+
+        len += l;
+      } else {
+        len += (size_t)snprintf(str + len, size - len - 1, i > 0 ? ",%.*s" : "%.*s", t->n, t->z);
+      }
+    }
+
+    if (len >= (size - 1)) {
+      size *= 2;
+      free(str);
+      str = calloc(1, size);
+      continue;
+    }
+
+    strcat(str, ") ");
+    len += 2;
+
+    if ((len + strlen(pStmt->mtb.values.z)) >= (size - 1)) {
+      size *= 2;
+      free(str);
+      str = calloc(1, size);
+      continue;
+    }
+
+    strcat(str, pStmt->mtb.values.z);
+
+    break;
+  }
+
+  if (pStmt->mtb.sqlstr == NULL) {
+    pStmt->mtb.sqlstr = pSql->sqlstr;
+  } else {
+    tfree(pSql->sqlstr);
+  }
+  
+  pSql->sqlstr = str;
+
+  return TSDB_CODE_SUCCESS;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // interface functions
 
@@ -1221,6 +1402,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
   pStmt->taos = pObj;
 
   SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
+
   if (pSql == NULL) {
     free(pStmt);
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -1263,7 +1445,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   pSql->fp         = waitForQueryRsp;
   pSql->fetchFp    = waitForQueryRsp;
   
-  pCmd->insertType = TSDB_QUERY_TYPE_STMT_INSERT;
+  pCmd->insertParam.insertType = TSDB_QUERY_TYPE_STMT_INSERT;
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE)) {
     tscError("%p failed to malloc payload buffer", pSql);
@@ -1287,39 +1469,20 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   if (tscIsInsertData(pSql->sqlstr)) {
     pStmt->isInsert = true;
 
-    pSql->cmd.numOfParams = 0;
+    pSql->cmd.insertParam.numOfParams = 0;
     pSql->cmd.batchSize   = 0;
 
     registerSqlObj(pSql);
 
-    int32_t ret = TSDB_CODE_SUCCESS;
+    int32_t ret = stmtParseInsertTbTags(pSql, pStmt);
-
+    if (ret != TSDB_CODE_SUCCESS) {
-    if ((ret = tsInsertInitialCheck(pSql)) != TSDB_CODE_SUCCESS) {
       return ret;
     }
 
-    int32_t index = 0;
+    if (pStmt->multiTbInsert) {
-    SStrToken sToken = tStrGetToken(pCmd->curSql, &index, false);
-
-    if (sToken.n == 0) {
-      return TSDB_CODE_TSC_INVALID_SQL;
-    }
-
-    if (sToken.n == 1 && sToken.type == TK_QUESTION) {
-      pStmt->multiTbInsert = true;
-      pStmt->mtb.tbname = sToken;
-      pStmt->mtb.nameSet = false;
-      if (pStmt->mtb.pTableHash == NULL) {
-        pStmt->mtb.pTableHash = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-      }
-      if (pStmt->mtb.pTableBlockHashList == NULL) {
-        pStmt->mtb.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
-      }
-
       return TSDB_CODE_SUCCESS;
     }
 
-    pStmt->multiTbInsert = false;
     memset(&pStmt->mtb, 0, sizeof(pStmt->mtb));
 
     int32_t code = tsParseSql(pSql, true);
@@ -1336,8 +1499,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   return normalStmtPrepare(pStmt);
 }
 
-
+int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags) {
-int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
   STscStmt* pStmt = (STscStmt*)stmt;
   SSqlObj* pSql = pStmt->pSql;
   SSqlCmd* pCmd = &pSql->cmd;
@@ -1379,26 +1541,38 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
     SSubmitBlk* pBlk = (SSubmitBlk*) (*t1)->pData;
     pCmd->batchSize = pBlk->numOfRows;
 
-    taosHashPut(pCmd->pTableBlockHashList, (void *)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid), (void*)t1, POINTER_BYTES);
+    taosHashPut(pCmd->insertParam.pTableBlockHashList, (void *)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid), (void*)t1, POINTER_BYTES);
 
     tscDebug("0x%"PRIx64" table:%s is already prepared, uid:%" PRIu64, pSql->self, name, pStmt->mtb.currentUid);
     return TSDB_CODE_SUCCESS;
   }
 
+  if (pStmt->mtb.tagSet) {
     pStmt->mtb.tbname = tscReplaceStrToken(&pSql->sqlstr, &pStmt->mtb.tbname, name);
+  } else {
+    if (tags == NULL) {
+      tscError("No tags set");
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+
+    int32_t ret = stmtGenInsertStatement(pSql, pStmt, name, tags);
+    if (ret != TSDB_CODE_SUCCESS) {
+      return ret;
+    }
+  }
+
   pStmt->mtb.nameSet = true;
 
   tscDebug("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
 
-  pSql->cmd.parseFinished = 0;
+  pSql->cmd.insertParam.numOfParams = 0;
-  pSql->cmd.numOfParams = 0;
   pSql->cmd.batchSize   = 0;
 
-  if (taosHashGetSize(pCmd->pTableBlockHashList) > 0) {
+  if (taosHashGetSize(pCmd->insertParam.pTableBlockHashList) > 0) {
-    SHashObj* hashList = pCmd->pTableBlockHashList;
+    SHashObj* hashList = pCmd->insertParam.pTableBlockHashList;
-    pCmd->pTableBlockHashList = NULL;
+    pCmd->insertParam.pTableBlockHashList = NULL;
     tscResetSqlCmd(pCmd, true);
-    pCmd->pTableBlockHashList = hashList;
+    pCmd->insertParam.pTableBlockHashList = hashList;
   }
 
   int32_t code = tsParseSql(pStmt->pSql, true);
@@ -1410,10 +1584,11 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
   }
 
   if (code == TSDB_CODE_SUCCESS) {
-    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
+
     STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
     STableDataBlocks* pBlock = NULL;
-    code = tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+    code = tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
                               pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
@@ -1426,7 +1601,6 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
     pStmt->mtb.tbNum++;
 
     taosHashPut(pStmt->mtb.pTableBlockHashList, (void *)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid), (void*)&pBlock, POINTER_BYTES);
-    
     taosHashPut(pStmt->mtb.pTableHash, name, strlen(name), (char*) &pTableMeta->id.uid, sizeof(pTableMeta->id.uid));
 
     tscDebug("0x%"PRIx64" table:%s is prepared, uid:%" PRIx64, pSql->self, name, pStmt->mtb.currentUid);
@@ -1435,6 +1609,12 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
   return code;
 }
 
+
+int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
+  return taos_stmt_set_tbname_tags(stmt, name, NULL);
+}
+
+
 int taos_stmt_close(TAOS_STMT* stmt) {
   STscStmt* pStmt = (STscStmt*)stmt;
   if (!pStmt->isInsert) {
@@ -1451,8 +1631,10 @@ int taos_stmt_close(TAOS_STMT* stmt) {
     if (pStmt->multiTbInsert) {
       taosHashCleanup(pStmt->mtb.pTableHash);
       pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->mtb.pTableBlockHashList, true);
-      taosHashCleanup(pStmt->pSql->cmd.pTableBlockHashList);
+      taosHashCleanup(pStmt->pSql->cmd.insertParam.pTableBlockHashList);
-      pStmt->pSql->cmd.pTableBlockHashList = NULL;
+      pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
+      taosArrayDestroy(pStmt->mtb.tags);
+      tfree(pStmt->mtb.sqlstr);
     }
   }
 
@@ -1617,9 +1799,10 @@ int taos_stmt_execute(TAOS_STMT* stmt) {
       ret = TSDB_CODE_TSC_OUT_OF_MEMORY;
     } else {
       if (pStmt->pSql != NULL) {
-        taos_free_result(pStmt->pSql);
+        tscFreeSqlObj(pStmt->pSql);
         pStmt->pSql = NULL;
       }
+
       pStmt->pSql = taos_query((TAOS*)pStmt->taos, sql);
       ret = taos_errno(pStmt->pSql);
       free(sql);
@@ -1670,7 +1853,7 @@ int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
   if (pStmt->isInsert) {
     SSqlObj* pSql = pStmt->pSql;
     SSqlCmd *pCmd = &pSql->cmd;
-    *nums = pCmd->numOfParams;
+    *nums = pCmd->insertParam.numOfParams;
     return TSDB_CODE_SUCCESS;
   } else {
     SNormalStmt* normal = &pStmt->normal;
@@ -1689,16 +1872,16 @@ int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
 
   if (pStmt->isInsert) {
     SSqlCmd* pCmd = &pStmt->pSql->cmd;
-    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
     STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-    if (pCmd->pTableBlockHashList == NULL) {
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
-      pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+      pCmd->insertParam.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
     }
 
     STableDataBlocks* pBlock = NULL;
 
     int32_t ret =
-      tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+      tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
           pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
     if (ret != 0) {
       // todo handle error

src/client/src/tscSql.c

@@ -373,11 +373,15 @@ int taos_num_fields(TAOS_RES *res) {
   if (pSql == NULL || pSql->signature != pSql) return 0;
 
   int32_t num = 0;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   if (pQueryInfo == NULL) {
     return num;
   }
 
+  while(pQueryInfo->pDownstream != NULL) {
+    pQueryInfo = pQueryInfo->pDownstream;
+  }
+
   size_t numOfCols = tscNumOfFields(pQueryInfo);
   for(int32_t i = 0; i < numOfCols; ++i) {
     SInternalField* pInfo = taosArrayGet(pQueryInfo->fieldsInfo.internalField, i);
@@ -408,7 +412,7 @@ TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
   SSqlRes *pRes = &pSql->res;
   if (pSql == NULL || pSql->signature != pSql) return 0;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   if (pQueryInfo == NULL) {
     return NULL;
   }
@@ -560,7 +564,7 @@ static bool tscKillQueryInDnode(SSqlObj* pSql) {
     return true;
   }
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
   if ((pQueryInfo == NULL) || tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
     return true;
@@ -614,7 +618,7 @@ int taos_errno(TAOS_RES *tres) {
  * why the sql is invalid
  */
 static bool hasAdditionalErrorInfo(int32_t code, SSqlCmd *pCmd) {
-  if (code != TSDB_CODE_TSC_INVALID_SQL
+  if (code != TSDB_CODE_TSC_INVALID_OPERATION
       && code != TSDB_CODE_TSC_SQL_SYNTAX_ERROR) {
     return false;
   }
@@ -623,7 +627,7 @@ static bool hasAdditionalErrorInfo(int32_t code, SSqlCmd *pCmd) {
 
   char *z = NULL;
   if (len > 0) {
-      z = strstr(pCmd->payload, "invalid SQL");
+      z = strstr(pCmd->payload, "invalid operation");
       if (z == NULL) {
         z = strstr(pCmd->payload, "syntax error");
       }
@@ -673,7 +677,7 @@ char *taos_get_client_info() { return version; }
 static void tscKillSTableQuery(SSqlObj *pSql) {
   SSqlCmd* pCmd = &pSql->cmd;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   if (!tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
     return;
@@ -724,7 +728,7 @@ void taos_stop_query(TAOS_RES *res) {
   // set the error code for master pSqlObj firstly
   pSql->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
   if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
     assert(pSql->rpcRid <= 0);
@@ -754,7 +758,7 @@ bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) {
     return true;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   if (pQueryInfo == NULL) {
     return true;
   }
@@ -829,9 +833,9 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
       case TSDB_DATA_TYPE_NCHAR: {
         int32_t charLen = varDataLen((char*)row[i] - VARSTR_HEADER_SIZE);
         if (fields[i].type == TSDB_DATA_TYPE_BINARY) {
-          assert(charLen <= fields[i].bytes);
+          assert(charLen <= fields[i].bytes && charLen >= 0);
         } else {
-          assert(charLen <= fields[i].bytes * TSDB_NCHAR_SIZE);
+          assert(charLen <= fields[i].bytes * TSDB_NCHAR_SIZE && charLen >= 0);
         }
 
         memcpy(str + len, row[i], charLen);
@@ -870,13 +874,9 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
 
   pSql->pTscObj  = taos;
   pSql->signature = pSql;
-
-  SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
   
-  pRes->numOfTotal = 0;
+  pCmd->resColumnId = TSDB_RES_COL_ID;
-  pRes->numOfClauseTotal = 0;
-
 
   tscDebug("0x%"PRIx64" Valid SQL: %s pObj:%p", pSql->self, sql, pObj);
 
@@ -896,10 +896,10 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
 
   strtolower(pSql->sqlstr, sql);
 
-  pCmd->curSql = NULL;
+//  pCmd->curSql = NULL;
-  if (NULL != pCmd->pTableBlockHashList) {
+  if (NULL != pCmd->insertParam.pTableBlockHashList) {
-    taosHashCleanup(pCmd->pTableBlockHashList);
+    taosHashCleanup(pCmd->insertParam.pTableBlockHashList);
-    pCmd->pTableBlockHashList = NULL;
+    pCmd->insertParam.pTableBlockHashList = NULL;
   }
 
   pSql->fp = asyncCallback;
@@ -921,90 +921,19 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
   return code;
 }
 
-static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t tblListLen) {
+void loadMultiTableMetaCallback(void *param, TAOS_RES *res, int code) {
-  // must before clean the sqlcmd object
+  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)param);
-  tscResetSqlCmd(&pSql->cmd, false);
+  if (pSql == NULL) {
-
+    return;
-  SSqlCmd *pCmd = &pSql->cmd;
-
-  pCmd->command = TSDB_SQL_MULTI_META;
-  pCmd->count = 0;
-
-  int   code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-  char *str = (char *)tblNameList;
-
-  SQueryInfo *pQueryInfo = tscGetQueryInfoS(pCmd, pCmd->clauseIndex);
-  if (pQueryInfo == NULL) {
-    pSql->res.code = terrno;
-    return terrno;
   }
 
-  STableMetaInfo *pTableMetaInfo = tscAddEmptyMetaInfo(pQueryInfo);
+  taosReleaseRef(tscObjRef, pSql->self);
+  pSql->res.code = code;
+  tsem_post(&pSql->rspSem);
+}
 
-  if ((code = tscAllocPayload(pCmd, tblListLen + 16)) != TSDB_CODE_SUCCESS) {
+static void freeElem(void* p) {
-    return code;
+  tfree(*(char**)p);
-  }
-
-  char *nextStr;
-  char  tblName[TSDB_TABLE_FNAME_LEN];
-  int   payloadLen = 0;
-  char *pMsg = pCmd->payload;
-  while (1) {
-    nextStr = strchr(str, ',');
-    if (nextStr == NULL) {
-      break;
-    }
-
-    memcpy(tblName, str, nextStr - str);
-    int32_t len = (int32_t)(nextStr - str);
-    tblName[len] = '\0';
-
-    str = nextStr + 1;
-    len = (int32_t)strtrim(tblName);
-
-    SStrToken sToken = {.n = len, .type = TK_ID, .z = tblName};
-    tGetToken(tblName, &sToken.type);
-
-    // Check if the table name available or not
-    if (tscValidateName(&sToken) != TSDB_CODE_SUCCESS) {
-      code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-      sprintf(pCmd->payload, "table name is invalid");
-      return code;
-    }
-
-    if ((code = tscSetTableFullName(pTableMetaInfo, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
-      return code;
-    }
-
-    if (++pCmd->count > TSDB_MULTI_TABLEMETA_MAX_NUM) {
-      code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-      sprintf(pCmd->payload, "tables over the max number");
-      return code;
-    }
-
-    int32_t xlen = tNameLen(&pTableMetaInfo->name);
-    if (payloadLen + xlen + 128 >= pCmd->allocSize) {
-      char *pNewMem = realloc(pCmd->payload, pCmd->allocSize + tblListLen);
-      if (pNewMem == NULL) {
-        code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-        sprintf(pCmd->payload, "failed to allocate memory");
-        return code;
-      }
-
-      pCmd->payload = pNewMem;
-      pCmd->allocSize = pCmd->allocSize + tblListLen;
-      pMsg = pCmd->payload;
-    }
-
-    char n[TSDB_TABLE_FNAME_LEN] = {0};
-    tNameExtractFullName(&pTableMetaInfo->name, n);
-    payloadLen += sprintf(pMsg + payloadLen, "%s,", n);
-  }
-
-  *(pMsg + payloadLen) = '\0';
-  pCmd->payloadLen = payloadLen + 1;
-
-  return TSDB_CODE_SUCCESS;
 }
 
 int taos_load_table_info(TAOS *taos, const char *tableNameList) {
@@ -1020,38 +949,28 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   pSql->pTscObj = taos;
   pSql->signature = pSql;
 
-  SSqlRes *pRes = &pSql->res;
+  pSql->fp = NULL;        // todo set the correct callback function pointer
+  pSql->cmd.pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
 
-  pRes->code = 0;
+  int32_t length = (int32_t)strlen(tableNameList);
-  pRes->numOfTotal = 0;  // the number of getting table meta from server
+  if (length > MAX_TABLE_NAME_LENGTH) {
-  pRes->numOfClauseTotal = 0;
+    tscError("0x%"PRIx64" tableNameList too long, length:%d, maximum allowed:%d", pSql->self, length, MAX_TABLE_NAME_LENGTH);
-
-  assert(pSql->fp == NULL);
-  tscDebug("0x%"PRIx64" tableNameList: %s pObj:%p", pSql->self, tableNameList, pObj);
-
-  int32_t tblListLen = (int32_t)strlen(tableNameList);
-  if (tblListLen > MAX_TABLE_NAME_LENGTH) {
-    tscError("0x%"PRIx64" tableNameList too long, length:%d, maximum allowed:%d", pSql->self, tblListLen, MAX_TABLE_NAME_LENGTH);
     tscFreeSqlObj(pSql);
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
-  char *str = calloc(1, tblListLen + 1);
+  char *str = calloc(1, length + 1);
   if (str == NULL) {
-    tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
+    tscError("0x%"PRIx64" failed to allocate sql string buffer", pSql->self);
     tscFreeSqlObj(pSql);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
   strtolower(str, tableNameList);
-  int32_t code = (uint8_t) tscParseTblNameList(pSql, str, tblListLen);
+  SArray* plist = taosArrayInit(4, POINTER_BYTES);
+  SArray* vgroupList = taosArrayInit(4, POINTER_BYTES);
 
-  /*
+  int32_t code = (uint8_t) tscTransferTableNameList(pSql, str, length, plist);
-   * set the qhandle to 0 before return in order to erase the qhandle value assigned in the previous successful query.
-   * If qhandle is NOT set 0, the function of taos_free_result() will send message to server by calling tscBuildAndSendRequest()
-   * to free connection, which may cause segment fault, when the parse phrase is not even successfully executed.
-   */
-  pRes->qId = 0;
   free(str);
 
   if (code != TSDB_CODE_SUCCESS) {
@@ -1059,12 +978,23 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
     return code;
   }
 
-  tscDoQuery(pSql);
+  registerSqlObj(pSql);
+  tscDebug("0x%"PRIx64" load multiple table meta, tableNameList: %s pObj:%p", pSql->self, tableNameList, pObj);
 
-  tscDebug("0x%"PRIx64" load multi-table meta result:%d %s pObj:%p", pSql->self, pRes->code, taos_errstr(pSql), pObj);
+  code = getMultiTableMetaFromMnode(pSql, plist, vgroupList, loadMultiTableMetaCallback);
-  if ((code = pRes->code) != TSDB_CODE_SUCCESS) {
+  if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-    tscFreeSqlObj(pSql);
+    code = TSDB_CODE_SUCCESS;
   }
 
+  taosArrayDestroyEx(plist, freeElem);
+  taosArrayDestroyEx(vgroupList, freeElem);
+
+  if (code != TSDB_CODE_SUCCESS) {
+    tscFreeRegisteredSqlObj(pSql);
+    return code;
+  }
+
+  tsem_wait(&pSql->rspSem);
+  tscFreeRegisteredSqlObj(pSql);
   return code;
 }

src/client/src/tscStream.c

@@ -13,7 +13,6 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <tschemautil.h>
 #include "os.h"
 #include "taosmsg.h"
 #include "tscLog.h"
@@ -37,7 +36,7 @@ static int64_t getDelayValueAfterTimewindowClosed(SSqlStream* pStream, int64_t l
 
 static bool isProjectStream(SQueryInfo* pQueryInfo) {
   for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo *pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId != TSDB_FUNC_PRJ) {
       return false;
     }
@@ -89,12 +88,12 @@ static void doLaunchQuery(void* param, TAOS_RES* tres, int32_t code) {
     return;
   }
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   code = tscGetTableMeta(pSql, pTableMetaInfo);
   if (code == 0 && UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-    code = tscGetSTableVgroupInfo(pSql, 0);
+    code = tscGetSTableVgroupInfo(pSql, pQueryInfo);
   }
 
   if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
@@ -138,7 +137,7 @@ static void tscProcessStreamTimer(void *handle, void *tmrId) {
 
   pStream->numOfRes = 0;  // reset the numOfRes.
   SSqlObj *pSql = pStream->pSql;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   tscDebug("0x%"PRIx64" timer launch query", pSql->self);
 
   if (pStream->isProject) {
@@ -197,7 +196,7 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
     tscError("0x%"PRIx64" stream:%p, query data failed, code:0x%08x, retry in %" PRId64 "ms", pStream->pSql->self,
         pStream, numOfRows, retryDelay);
 
-    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pStream->pSql->cmd, 0, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pStream->pSql->cmd, 0);
 
     char name[TSDB_TABLE_FNAME_LEN] = {0};
     tNameExtractFullName(&pTableMetaInfo->name, name);
@@ -224,7 +223,7 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
 static void tscStreamFillTimeGap(SSqlStream* pStream, TSKEY ts) {
 #if 0
   SSqlObj *   pSql = pStream->pSql;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   if (pQueryInfo->fillType != TSDB_FILL_SET_VALUE && pQueryInfo->fillType != TSDB_FILL_NULL) {
     return;
@@ -273,7 +272,7 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
     return;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo *pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
 
   if (numOfRows > 0) { // when reaching here the first execution of stream computing is successful.
@@ -444,7 +443,7 @@ static int32_t tscSetSlidingWindowInfo(SSqlObj *pSql, SSqlStream *pStream) {
   int64_t minIntervalTime =
       (pStream->precision == TSDB_TIME_PRECISION_MICRO) ? tsMinIntervalTime * 1000L : tsMinIntervalTime;
   
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   if (!pStream->isProject && pQueryInfo->interval.interval == 0) {
     sprintf(pSql->cmd.payload, "the interval value is 0");
@@ -494,7 +493,7 @@ static int32_t tscSetSlidingWindowInfo(SSqlObj *pSql, SSqlStream *pStream) {
 }
 
 static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, int64_t stime) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   if (pStream->isProject) {
     // no data in table, flush all data till now to destination meter, 10sec delay
@@ -556,7 +555,7 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {
     return;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
   
@@ -619,10 +618,10 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   pStream->callback = callback;
   pStream->param    = param;
   pStream->pSql     = pSql;
+
   pSql->pStream  = pStream;
   pSql->param    = pStream;
   pSql->maxRetry = TSDB_MAX_REPLICA;
-
   pSql->sqlstr   = calloc(1, strlen(sqlstr) + 1);
   if (pSql->sqlstr == NULL) {
     tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
@@ -632,14 +631,14 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   }
 
   strtolower(pSql->sqlstr, sqlstr);
+  pSql->fp      = tscCreateStream;
+  pSql->fetchFp = tscCreateStream;
+  pSql->cmd.resColumnId = TSDB_RES_COL_ID;
 
+  tsem_init(&pSql->rspSem, 0, 0);
   registerSqlObj(pSql);
 
   tscDebugL("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
-  tsem_init(&pSql->rspSem, 0, 0);
-
-  pSql->fp = tscCreateStream;
-  pSql->fetchFp = tscCreateStream;
 
   int32_t code = tsParseSql(pSql, true);
   if (code == TSDB_CODE_SUCCESS) {

src/client/src/tscSub.c

@@ -151,6 +151,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
   strtolower(pSql->sqlstr, pSql->sqlstr);
   pRes->qId = 0;
   pRes->numOfRows = 1;
+  pCmd->resColumnId = TSDB_RES_COL_ID;
 
   code = tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE);
   if (code != TSDB_CODE_SUCCESS) {
@@ -173,7 +174,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
 
   if (pSql->cmd.command != TSDB_SQL_SELECT && pSql->cmd.command != TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
     line = __LINE__;
-    code = TSDB_CODE_TSC_INVALID_SQL;
+    code = TSDB_CODE_TSC_INVALID_OPERATION;
     goto fail;
   }
 
@@ -266,7 +267,7 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
 
   pSub->lastSyncTime = taosGetTimestampMs();
 
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
     STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
     SSubscriptionProgress target = {.uid = pTableMeta->id.uid, .key = 0};
@@ -284,7 +285,7 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
   }
   size_t numOfTables = taosArrayGetSize(tables);
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   SArray* progress = taosArrayInit(numOfTables, sizeof(SSubscriptionProgress));
   for( size_t i = 0; i < numOfTables; i++ ) {
     STidTags* tt = taosArrayGet( tables, i );
@@ -304,7 +305,7 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
   }
   taosArrayDestroy(tables);
 
-  TSDB_QUERY_SET_TYPE(tscGetQueryInfo(pCmd, 0)->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
+  TSDB_QUERY_SET_TYPE(tscGetQueryInfo(pCmd)->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
   return 1;
 }
 
@@ -503,8 +504,8 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
   SSqlObj *pSql = pSub->pSql;
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   if (taosArrayGetSize(pSub->progress) > 0) { // fix crash in single table subscription
 
     size_t size = taosArrayGetSize(pSub->progress);

src/common/inc/tname.h

@@ -44,8 +44,8 @@ typedef struct SResPair {
 // the structure for sql function in select clause
 typedef struct SSqlExpr {
   char      aliasName[TSDB_COL_NAME_LEN];  // as aliasName
+  char      token[TSDB_COL_NAME_LEN];      // original token
   SColIndex colInfo;
-
   uint64_t  uid;            // refactor use the pointer
 
   int16_t   functionId;     // function id in aAgg array
@@ -92,10 +92,6 @@ size_t tableIdPrefix(const char* name, char* prefix, int32_t len);
 
 void extractTableNameFromToken(SStrToken *pToken, SStrToken* pTable);
 
-//SSchema tGetTbnameColumnSchema();
-
-SSchema tGetBlockDistColumnSchema();
-
 SSchema tGetUserSpecifiedColumnSchema(tVariant* pVal, SStrToken* exprStr, const char* name);
 
 bool tscValidateTableNameLength(size_t len);

src/common/src/tarithoperator.c

@@ -2569,6 +2569,7 @@ _arithmetic_operator_fn_t getArithmeticOperatorFn(int32_t arithmeticOptr) {
     case TSDB_BINARY_OP_REMAINDER:
       return vectorRemainder;
     default:
+      assert(0);
       return NULL;
   }
 }

src/common/src/texpr.c

@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <texpr.h>
 #include "os.h"
 
 #include "texpr.h"
@@ -465,27 +466,29 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
   return expr;
 }
 
-tExprNode* exprdup(tExprNode* pTree) {
+tExprNode* exprdup(tExprNode* pNode) {
-  if (pTree == NULL) {
+  if (pNode == NULL) {
     return NULL;
   }
 
-  tExprNode* pNode = calloc(1, sizeof(tExprNode));
+  tExprNode* pCloned = calloc(1, sizeof(tExprNode));
-  if (pTree->nodeType == TSQL_NODE_EXPR) {
+  if (pNode->nodeType == TSQL_NODE_EXPR) {
-    tExprNode* pLeft  = exprdup(pTree->_node.pLeft);
+    tExprNode* pLeft  = exprdup(pNode->_node.pLeft);
-    tExprNode* pRight = exprdup(pTree->_node.pRight);
+    tExprNode* pRight = exprdup(pNode->_node.pRight);
 
-    pNode->nodeType     = TSQL_NODE_EXPR;
+    pCloned->_node.pLeft  = pLeft;
-    pNode->_node.pLeft  = pLeft;
+    pCloned->_node.pRight = pRight;
-    pNode->_node.pRight = pRight;
+    pCloned->_node.optr  = pNode->_node.optr;
-  } else if (pTree->nodeType == TSQL_NODE_VALUE) {
+    pCloned->_node.hasPK = pNode->_node.hasPK;
-    pNode->pVal = calloc(1, sizeof(tVariant));
+  } else if (pNode->nodeType == TSQL_NODE_VALUE) {
-    tVariantAssign(pNode->pVal, pTree->pVal);
+    pCloned->pVal = calloc(1, sizeof(tVariant));
-  } else if (pTree->nodeType == TSQL_NODE_COL) {
+    tVariantAssign(pCloned->pVal, pNode->pVal);
-    pNode->pSchema = calloc(1, sizeof(SSchema));
+  } else if (pNode->nodeType == TSQL_NODE_COL) {
-    *pNode->pSchema = *pTree->pSchema;
+    pCloned->pSchema = calloc(1, sizeof(SSchema));
+    *pCloned->pSchema = *pNode->pSchema;
   }
 
-  return pNode;
+  pCloned->nodeType = pNode->nodeType;
+  return pCloned;
 }
 

src/common/src/tglobal.c

@@ -46,7 +46,7 @@ char     tsEmail[TSDB_FQDN_LEN] = {0};
 int32_t  tsDnodeId = 0;
 
 // common
-int32_t tsRpcTimer       = 1000;
+int32_t tsRpcTimer       = 300;
 int32_t tsRpcMaxTime     = 600;  // seconds;
 int32_t tsRpcForceTcp    = 0;  //disable this, means query, show command use udp protocol as default
 int32_t tsMaxShellConns  = 50000;

src/common/src/tname.c

@@ -33,15 +33,6 @@ size_t tableIdPrefix(const char* name, char* prefix, int32_t len) {
   return strlen(prefix);
 }
 
-SSchema tGetBlockDistColumnSchema() {
-  SSchema s = {0};
-  s.bytes = TSDB_MAX_BINARY_LEN;;
-  s.type  = TSDB_DATA_TYPE_BINARY;
-  s.colId = TSDB_BLOCK_DIST_COLUMN_INDEX;
-  tstrncpy(s.name, TSQL_BLOCK_DIST_L, TSDB_COL_NAME_LEN);
-  return s;
-}
-
 SSchema tGetUserSpecifiedColumnSchema(tVariant* pVal, SStrToken* exprStr, const char* name) {
   SSchema s = {0};
 

src/connector/go

@@ -1 +1 @@
-Subproject commit 8ce6d86558afc8c0b50c10f990fd2b4270cf06fc
+Subproject commit 7a26c432f8b4203e42344ff3290b9b9b01b983d5

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java

@@ -16,13 +16,13 @@
  */
 package com.taosdata.jdbc;
 
-import com.taosdata.jdbc.utils.TaosInfo;
-
 import java.nio.ByteBuffer;
 import java.sql.SQLException;
 import java.sql.SQLWarning;
 import java.util.List;
 
+import com.taosdata.jdbc.utils.TaosInfo;
+
 /**
  * JNI connector
  */
@@ -276,23 +276,14 @@ public class TSDBJNIConnector {
     private native int validateCreateTableSqlImp(long connection, byte[] sqlBytes);
     
 	public long prepareStmt(String sql) throws SQLException {
-    	Long stmt = 0L;
+    	Long stmt = prepareStmtImp(sql.getBytes(), this.taos);
-    	try {
+		if (stmt == TSDBConstants.JNI_TDENGINE_ERROR) {
-    	stmt = prepareStmtImp(sql.getBytes(), this.taos);
+			throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_SQL);
-    	} catch (Exception e) {
+		} else if (stmt == TSDBConstants.JNI_CONNECTION_NULL) {
-            e.printStackTrace();
-            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_ENCODING);
-        }
-    	
-        if (stmt == TSDBConstants.JNI_CONNECTION_NULL) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL);
-        }
+        } else if (stmt == TSDBConstants.JNI_SQL_NULL) {
-        
-        if (stmt == TSDBConstants.JNI_SQL_NULL) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_SQL_NULL);
-        }
+        } else if (stmt == TSDBConstants.JNI_OUT_OF_MEMORY) {
-        
-        if (stmt == TSDBConstants.JNI_OUT_OF_MEMORY) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY);
         }
         
@@ -310,6 +301,16 @@ public class TSDBJNIConnector {
     
     private native int setBindTableNameImp(long stmt, String name, long conn);
     
+    public void setBindTableNameAndTags(long stmt, String tableName, int numOfTags, ByteBuffer tags, ByteBuffer typeList, ByteBuffer lengthList, ByteBuffer nullList) throws SQLException {
+    	int code = setTableNameTagsImp(stmt, tableName, numOfTags, tags.array(), typeList.array(), lengthList.array(), 
+    			nullList.array(), this.taos);
+    	if (code != TSDBConstants.JNI_SUCCESS) {
+    		throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "failed to bind table name and corresponding tags");
+    	}
+    }
+    
+    private native int setTableNameTagsImp(long stmt, String name, int numOfTags, byte[] tags, byte[] typeList, byte[] lengthList, byte[] nullList, long conn);
+    
     public void bindColumnDataArray(long stmt, ByteBuffer colDataList, ByteBuffer lengthList, ByteBuffer isNullList, int type, int bytes, int numOfRows,int columnIndex) throws SQLException {
     	int code = bindColDataImp(stmt, colDataList.array(), lengthList.array(), isNullList.array(), type, bytes, numOfRows, columnIndex, this.taos);
     	if (code != TSDBConstants.JNI_SUCCESS) {

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java

@@ -41,6 +41,9 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
     private boolean isPrepared;
     
     private ArrayList<ColumnInfo> colData;
+    private ArrayList<TableTagInfo> tableTags;
+    private int tagValueLength;
+    
     private String tableName;
     private long nativeStmtHandle = 0;
     
@@ -63,8 +66,8 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
 
 		if (parameterCnt > 1) {
 	        // the table name is also a parameter, so ignore it.
-	        this.colData = new ArrayList<ColumnInfo>(parameterCnt - 1);
+	        this.colData = new ArrayList<ColumnInfo>();
-	        this.colData.addAll(Collections.nCopies(parameterCnt - 1, null));
+	        this.tableTags = new ArrayList<TableTagInfo>();
 		}
     }
 
@@ -562,11 +565,109 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
     	}
     };
     
+    private static class TableTagInfo {
+    	private boolean isNull;
+    	private Object  value;
+    	private int     type;    	
+    	public TableTagInfo(Object value, int type) {
+    		this.value = value;
+    		this.type  = type;
+    	}
+    	
+    	public static TableTagInfo createNullTag(int type) {
+    		TableTagInfo info = new TableTagInfo(null, type);
+    		info.isNull = true;
+    		return info;
+    	}
+    };
+    
     public void setTableName(String name) {
     	this.tableName = name;
     }
     
+    private void ensureTagCapacity(int index) {
+    	if (this.tableTags.size() < index + 1) {
+    		int delta = index + 1 - this.tableTags.size();
+    		this.tableTags.addAll(Collections.nCopies(delta, null));
+    	}
+    }
+    
+    public void setTagNull(int index, int type) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, TableTagInfo.createNullTag(type));
+    }
+    
+    public void setTagBoolean(int index, boolean value) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, new TableTagInfo(value, TSDBConstants.TSDB_DATA_TYPE_BOOL));
+    	this.tagValueLength += Byte.BYTES;
+    }
+    
+    public void setTagInt(int index, int value) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, new TableTagInfo(value, TSDBConstants.TSDB_DATA_TYPE_INT));
+    	this.tagValueLength += Integer.BYTES;
+    }
+    
+    public void setTagByte(int index, byte value) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, new TableTagInfo(value, TSDBConstants.TSDB_DATA_TYPE_TINYINT));
+    	this.tagValueLength += Byte.BYTES;
+    }
+    
+    public void setTagShort(int index, short value) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, new TableTagInfo(value, TSDBConstants.TSDB_DATA_TYPE_SMALLINT));
+    	this.tagValueLength += Short.BYTES;
+    }
+    
+    public void setTagLong(int index, long value) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, new TableTagInfo(value, TSDBConstants.TSDB_DATA_TYPE_BIGINT));
+    	this.tagValueLength += Long.BYTES;
+    }
+    
+    public void setTagTimestamp(int index, long value) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, new TableTagInfo(value, TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP));
+    	this.tagValueLength += Long.BYTES;
+    }
+    
+    public void setTagFloat(int index, float value) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, new TableTagInfo(value, TSDBConstants.TSDB_DATA_TYPE_FLOAT));
+    	this.tagValueLength += Float.BYTES;
+    }
+    
+    public void setTagDouble(int index, double value) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, new TableTagInfo(value, TSDBConstants.TSDB_DATA_TYPE_DOUBLE));
+    	this.tagValueLength += Double.BYTES;
+    }
+    
+    public void setTagString(int index, String value) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, new TableTagInfo(value, TSDBConstants.TSDB_DATA_TYPE_BINARY));
+    	this.tagValueLength += value.getBytes().length;
+    }
+    
+    public void setTagNString(int index, String value) {
+    	ensureTagCapacity(index);
+    	this.tableTags.set(index, new TableTagInfo(value, TSDBConstants.TSDB_DATA_TYPE_NCHAR));
+    	
+		String charset = TaosGlobalConfig.getCharset();
+    	try {
+			this.tagValueLength += value.getBytes(charset).length;
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+		}
+    }
+    
     public <T> void setValueImpl(int columnIndex, ArrayList<T> list, int type, int bytes) throws SQLException {
+    	if (this.colData.size() == 0) {
+	        this.colData.addAll(Collections.nCopies(this.parameters.length - 1 - this.tableTags.size(), null));
+
+    	}
     	ColumnInfo col = (ColumnInfo) this.colData.get(columnIndex);
     	if (col == null) {
     		ColumnInfo p = new ColumnInfo();
@@ -641,7 +742,122 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
 		
 		TSDBJNIConnector connector = ((TSDBConnection) this.getConnection()).getConnector();
 		this.nativeStmtHandle = connector.prepareStmt(rawSql);
+		
+		if (this.tableTags == null) {
 			connector.setBindTableName(this.nativeStmtHandle, this.tableName);
+		} else {
+			int num = this.tableTags.size();
+			ByteBuffer tagDataList = ByteBuffer.allocate(this.tagValueLength);
+			tagDataList.order(ByteOrder.LITTLE_ENDIAN);
+
+			ByteBuffer typeList = ByteBuffer.allocate(num);
+			typeList.order(ByteOrder.LITTLE_ENDIAN);
+
+			ByteBuffer lengthList = ByteBuffer.allocate(num * Long.BYTES);
+			lengthList.order(ByteOrder.LITTLE_ENDIAN);
+
+			ByteBuffer isNullList = ByteBuffer.allocate(num * Integer.BYTES);
+			isNullList.order(ByteOrder.LITTLE_ENDIAN);
+
+			for (int i = 0; i < num; ++i) {
+				TableTagInfo tag = this.tableTags.get(i);
+				if (tag.isNull) {
+					typeList.put((byte) tag.type);
+					isNullList.putInt(1);
+					lengthList.putLong(0);
+					continue;
+				}
+				
+				switch (tag.type) {
+				case TSDBConstants.TSDB_DATA_TYPE_INT: {
+					Integer val = (Integer) tag.value;
+					tagDataList.putInt(val);
+					lengthList.putLong(Integer.BYTES);
+					break;
+				}
+				case TSDBConstants.TSDB_DATA_TYPE_TINYINT: {
+					Byte val = (Byte) tag.value;
+					tagDataList.put(val);
+					lengthList.putLong(Byte.BYTES);
+					break;
+				}
+
+				case TSDBConstants.TSDB_DATA_TYPE_BOOL: {
+					Boolean val = (Boolean) tag.value;
+					tagDataList.put((byte) (val ? 1 : 0));
+					lengthList.putLong(Byte.BYTES);
+					break;
+				}
+
+				case TSDBConstants.TSDB_DATA_TYPE_SMALLINT: {
+					Short val = (Short) tag.value;
+					tagDataList.putShort(val);
+					lengthList.putLong(Short.BYTES);
+
+					break;
+				}
+
+				case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP:
+				case TSDBConstants.TSDB_DATA_TYPE_BIGINT: {
+					Long val = (Long) tag.value;
+					tagDataList.putLong(val == null ? 0 : val);
+					lengthList.putLong(Long.BYTES);
+
+					break;
+				}
+
+				case TSDBConstants.TSDB_DATA_TYPE_FLOAT: {
+					Float val = (Float) tag.value;
+					tagDataList.putFloat(val == null ? 0 : val);
+					lengthList.putLong(Float.BYTES);
+
+					break;
+				}
+
+				case TSDBConstants.TSDB_DATA_TYPE_DOUBLE: {
+					Double val = (Double) tag.value;
+					tagDataList.putDouble(val == null ? 0 : val);
+					lengthList.putLong(Double.BYTES);
+
+					break;
+				}
+
+				case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
+				case TSDBConstants.TSDB_DATA_TYPE_BINARY: {
+					String charset = TaosGlobalConfig.getCharset();
+					String val = (String) tag.value;
+
+						byte[] b = null;
+						try {
+							if (tag.type == TSDBConstants.TSDB_DATA_TYPE_BINARY) {
+								b = val.getBytes();
+							} else {
+								b = val.getBytes(charset);
+							}
+						} catch (UnsupportedEncodingException e) {
+							e.printStackTrace();
+						}
+
+						tagDataList.put(b);
+						lengthList.putLong(b.length);
+					break;
+				}
+
+				case TSDBConstants.TSDB_DATA_TYPE_UTINYINT:
+				case TSDBConstants.TSDB_DATA_TYPE_USMALLINT:
+				case TSDBConstants.TSDB_DATA_TYPE_UINT:
+				case TSDBConstants.TSDB_DATA_TYPE_UBIGINT: {
+					throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "not support data types");
+				}
+				}
+				
+				typeList.put((byte) tag.type);
+				isNullList.putInt(tag.isNull? 1 : 0);
+			}
+
+			connector.setBindTableNameAndTags(this.nativeStmtHandle, this.tableName, this.tableTags.size(), tagDataList,
+					typeList, lengthList, isNullList);
+		}
 		
 		ColumnInfo colInfo = (ColumnInfo) this.colData.get(0);
 		if (colInfo == null) {

src/connector/python/taos/__init__.py

@@ -2,6 +2,10 @@
 from .connection import TDengineConnection
 from .cursor import TDengineCursor
 
+# For some reason, the following is needed for VS Code (through PyLance) to 
+# recognize that "error" is a valid module of the "taos" package.
+from .error import ProgrammingError
+
 # Globals
 threadsafety = 0
 paramstyle = 'pyformat'

src/dnode/CMakeLists.txt

@@ -10,8 +10,15 @@ INCLUDE_DIRECTORIES(${TD_ENTERPRISE_DIR}/src/inc)
 INCLUDE_DIRECTORIES(inc)
 AUX_SOURCE_DIRECTORY(src SRC)
 
+IF (TD_LINUX_64 AND JEMALLOC_ENABLED)
+  ADD_DEFINITIONS(-DTD_JEMALLOC_ENABLED -I${CMAKE_BINARY_DIR}/build/include -L${CMAKE_BINARY_DIR}/build/lib -Wl,-rpath,${CMAKE_BINARY_DIR}/build/lib -ljemalloc)
+  SET(LINK_JEMALLOC "-L${CMAKE_BINARY_DIR}/build/lib -ljemalloc")
+ELSE ()
+  SET(LINK_JEMALLOC "")
+ENDIF ()
+
 ADD_EXECUTABLE(taosd ${SRC})
-TARGET_LINK_LIBRARIES(taosd mnode monitor http tsdb twal vnode cJson lz4 balance sync)
+TARGET_LINK_LIBRARIES(taosd mnode monitor http tsdb twal vnode cJson lz4 balance sync ${LINK_JEMALLOC})
 
 IF (TD_SOMODE_STATIC)
   TARGET_LINK_LIBRARIES(taosd taos_static)

src/dnode/src/dnodeMain.c

@@ -86,6 +86,17 @@ static SStep tsDnodeSteps[] = {
   {"dnode-telemetry", dnodeInitTelemetry,  dnodeCleanupTelemetry},
 };
 
+static SStep tsDnodeCompactSteps[] = {
+  {"dnode-tfile",     tfInit,              tfCleanup},
+  {"dnode-storage",   dnodeInitStorage,    dnodeCleanupStorage},
+  {"dnode-eps",       dnodeInitEps,        dnodeCleanupEps},
+  {"dnode-wal",       walInit,             walCleanUp},
+  {"dnode-mread",     dnodeInitMRead,      NULL},
+  {"dnode-mwrite",    dnodeInitMWrite,     NULL},
+  {"dnode-mpeer",     dnodeInitMPeer,      NULL},
+  {"dnode-modules",   dnodeInitModules,    dnodeCleanupModules},
+};
+
 static int dnodeCreateDir(const char *dir) {
   if (mkdir(dir, 0755) != 0 && errno != EEXIST) {
     return -1;
@@ -95,13 +106,23 @@ static int dnodeCreateDir(const char *dir) {
 }
 
 static void dnodeCleanupComponents() {
+  if (!tsCompactMnodeWal) {
     int32_t stepSize = sizeof(tsDnodeSteps) / sizeof(SStep);
     dnodeStepCleanup(tsDnodeSteps, stepSize);
+  } else {
+    int32_t stepSize = sizeof(tsDnodeCompactSteps) / sizeof(SStep);
+    dnodeStepCleanup(tsDnodeCompactSteps, stepSize);
+  }
 }
 
 static int32_t dnodeInitComponents() {
+  if (!tsCompactMnodeWal) {
     int32_t stepSize = sizeof(tsDnodeSteps) / sizeof(SStep);
     return dnodeStepInit(tsDnodeSteps, stepSize);
+  } else {
+    int32_t stepSize = sizeof(tsDnodeCompactSteps) / sizeof(SStep);
+    return dnodeStepInit(tsDnodeCompactSteps, stepSize);
+  }
 }
 
 static int32_t dnodeInitTmr() {
@@ -219,14 +240,20 @@ static int32_t dnodeInitStorage() {
 
   if (tsCompactMnodeWal == 1) {
     sprintf(tsMnodeTmpDir, "%s/mnode_tmp", tsDataDir);
-    tfsRmdir(tsMnodeTmpDir);
+    if (taosDirExist(tsMnodeTmpDir)) {
+      dError("mnode_tmp dir already exist in %s,quit compact job", tsMnodeTmpDir);
+      return -1;
+    }
     if (dnodeCreateDir(tsMnodeTmpDir) < 0) {
       dError("failed to create dir: %s, reason: %s", tsMnodeTmpDir, strerror(errno));
       return -1;
     }
 
     sprintf(tsMnodeBakDir, "%s/mnode_bak", tsDataDir);
-    //tfsRmdir(tsMnodeBakDir);   
+    if (taosDirExist(tsMnodeBakDir)) {
+      dError("mnode_bak dir already exist in %s,quit compact job", tsMnodeBakDir);
+      return -1;
+    }
   }
   //TODO(dengyihao): no need to init here 
   if (dnodeCreateDir(tsMnodeDir) < 0) {

src/inc/taos.h

@@ -112,6 +112,7 @@ typedef struct TAOS_MULTI_BIND {
 
 TAOS_STMT *taos_stmt_init(TAOS *taos);
 int        taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length);
+int        taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags);
 int        taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name);
 int        taos_stmt_is_insert(TAOS_STMT *stmt, int *insert);
 int        taos_stmt_num_params(TAOS_STMT *stmt, int *nums);

src/inc/taosdef.h

@@ -33,6 +33,8 @@ extern "C" {
 #endif
 
 #define TSWINDOW_INITIALIZER ((STimeWindow) {INT64_MIN, INT64_MAX})
+#define TSWINDOW_DESC_INITIALIZER ((STimeWindow) {INT64_MAX, INT64_MIN})
+
 #define TSKEY_INITIAL_VAL    INT64_MIN
 
 // Bytes for each type.
@@ -242,7 +244,6 @@ do { \
 #define TSDB_MAX_REPLICA          5
 
 #define TSDB_TBNAME_COLUMN_INDEX        (-1)
-#define TSDB_BLOCK_DIST_COLUMN_INDEX    (-2)
 #define TSDB_UD_COLUMN_INDEX            (-1000)
 #define TSDB_RES_COL_ID                 (-5000)
 
@@ -345,6 +346,7 @@ do { \
 #define TSDB_QUERY_TYPE_TAG_FILTER_QUERY       0x400u
 #define TSDB_QUERY_TYPE_INSERT                 0x100u    // insert type
 #define TSDB_QUERY_TYPE_MULTITABLE_QUERY       0x200u
+#define TSDB_QUERY_TYPE_FILE_INSERT            0x400u    // insert data from file
 #define TSDB_QUERY_TYPE_STMT_INSERT            0x800u    // stmt insert type
 
 #define TSDB_QUERY_HAS_TYPE(x, _type)          (((x) & (_type)) != 0)

src/inc/taoserror.h

@@ -74,7 +74,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_REF_NOT_EXIST                 TAOS_DEF_ERROR_CODE(0, 0x010A)  //"Ref is not there")
 
 //client
-#define TSDB_CODE_TSC_INVALID_SQL               TAOS_DEF_ERROR_CODE(0, 0x0200)  //"Invalid SQL statement")
+#define TSDB_CODE_TSC_INVALID_OPERATION         TAOS_DEF_ERROR_CODE(0, 0x0200)  //"Invalid Operation")
 #define TSDB_CODE_TSC_INVALID_QHANDLE           TAOS_DEF_ERROR_CODE(0, 0x0201)  //"Invalid qhandle")
 #define TSDB_CODE_TSC_INVALID_TIME_STAMP        TAOS_DEF_ERROR_CODE(0, 0x0202)  //"Invalid combination of client/service time")
 #define TSDB_CODE_TSC_INVALID_VALUE             TAOS_DEF_ERROR_CODE(0, 0x0203)  //"Invalid value in client")
@@ -215,11 +215,11 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_VND_IS_FLOWCTRL               TAOS_DEF_ERROR_CODE(0, 0x050C)  //"Database memory is full for waiting commit")
 #define TSDB_CODE_VND_IS_DROPPING               TAOS_DEF_ERROR_CODE(0, 0x050D)  //"Database is dropping")
 #define TSDB_CODE_VND_IS_BALANCING              TAOS_DEF_ERROR_CODE(0, 0x050E)  //"Database is balancing")
+#define TSDB_CODE_VND_IS_CLOSING                TAOS_DEF_ERROR_CODE(0, 0x0510)  //"Database is closing")
 #define TSDB_CODE_VND_NOT_SYNCED                TAOS_DEF_ERROR_CODE(0, 0x0511)  //"Database suspended")
 #define TSDB_CODE_VND_NO_WRITE_AUTH             TAOS_DEF_ERROR_CODE(0, 0x0512)  //"Database write operation denied")
 #define TSDB_CODE_VND_IS_SYNCING                TAOS_DEF_ERROR_CODE(0, 0x0513)  //"Database is syncing")
 #define TSDB_CODE_VND_INVALID_TSDB_STATE        TAOS_DEF_ERROR_CODE(0, 0x0514)  //"Invalid tsdb state")
-#define TSDB_CODE_VND_IS_CLOSING                TAOS_DEF_ERROR_CODE(0, 0x0515)  //"Database is closing")
 
 // tsdb
 #define TSDB_CODE_TDB_INVALID_TABLE_ID          TAOS_DEF_ERROR_CODE(0, 0x0600)  //"Invalid table ID")

src/inc/taosmsg.h

@@ -84,7 +84,7 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_TABLE, "drop-table" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_ALTER_TABLE, "alter-table" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_TABLE_META, "table-meta" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_STABLE_VGROUP, "stable-vgroup" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_TABLES_META, "tables-meta" )	  
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_TABLES_META, "multiTable-meta" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_ALTER_STREAM, "alter-stream" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_SHOW, "show" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_RETRIEVE, "retrieve" )     
@@ -294,6 +294,8 @@ typedef struct {
 
 typedef struct {
   char   name[TSDB_TABLE_FNAME_LEN];
+  // if user specify DROP STABLE, this flag will be set. And an error will be returned if it is not a super table
+  int8_t supertable;
   int8_t igNotExists;
 } SCMDropTableMsg;
 
@@ -471,6 +473,7 @@ typedef struct {
   bool        simpleAgg;
   bool        pointInterpQuery; // point interpolation query
   bool        needReverseScan;  // need reverse scan
+  bool        stateWindow;       // state window flag 
 
   STimeWindow window;
   int32_t     numOfTables;
@@ -703,8 +706,9 @@ typedef struct {
 } STableInfoMsg;
 
 typedef struct {
+  int32_t numOfVgroups;
   int32_t numOfTables;
-  char    tableIds[];
+  char    tableNames[];
 } SMultiTableInfoMsg;
 
 typedef struct SSTableVgroupMsg {
@@ -753,8 +757,9 @@ typedef struct STableMetaMsg {
 
 typedef struct SMultiTableMeta {
   int32_t       numOfTables;
+  int32_t       numOfVgroup;
   int32_t       contLen;
-  char          metas[];
+  char          meta[];
 } SMultiTableMeta;
 
 typedef struct {

src/inc/tsdb.h

@@ -215,7 +215,7 @@ typedef struct SDataBlockInfo {
 } SDataBlockInfo;
 
 typedef struct SFileBlockInfo {
-  int32_t numOfRows;
+  int32_t numBlocksOfStep;
 } SFileBlockInfo;
 
 typedef struct {
@@ -229,11 +229,15 @@ typedef struct {
   SHashObj *map;  // speedup acquire the tableQueryInfo by table uid
 } STableGroupInfo;
 
+#define TSDB_BLOCK_DIST_STEP_ROWS 16
 typedef struct {
   uint16_t  rowSize;
   uint16_t  numOfFiles;
   uint32_t  numOfTables;
   uint64_t  totalSize;
+  uint64_t  totalRows;
+  int32_t   maxRows;
+  int32_t   minRows;
   int32_t   firstSeekTimeUs;
   uint32_t  numOfRowsInMemTable;
   SArray   *dataBlockInfos;
@@ -265,6 +269,12 @@ TsdbQueryHandleT *tsdbQueryTables(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
 TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfo, uint64_t qId,
                                   SMemRef *pRef);
 
+
+TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef);
+
+bool isTsdbCacheLastRow(TsdbQueryHandleT* pQueryHandle);
+
+
 /**
  * get the queried table object list
  * @param pHandle

src/inc/ttokendef.h

@@ -136,74 +136,74 @@
 #define TK_VARIABLE                       117
 #define TK_INTERVAL                       118
 #define TK_SESSION                        119
-#define TK_FILL                           120
+#define TK_STATE_WINDOW                   120
-#define TK_SLIDING                        121
+#define TK_FILL                           121
-#define TK_ORDER                          122
+#define TK_SLIDING                        122
-#define TK_BY                             123
+#define TK_ORDER                          123
-#define TK_ASC                            124
+#define TK_BY                             124
-#define TK_DESC                           125
+#define TK_ASC                            125
-#define TK_GROUP                          126
+#define TK_DESC                           126
-#define TK_HAVING                         127
+#define TK_GROUP                          127
-#define TK_LIMIT                          128
+#define TK_HAVING                         128
-#define TK_OFFSET                         129
+#define TK_LIMIT                          129
-#define TK_SLIMIT                         130
+#define TK_OFFSET                         130
-#define TK_SOFFSET                        131
+#define TK_SLIMIT                         131
-#define TK_WHERE                          132
+#define TK_SOFFSET                        132
-#define TK_NOW                            133
+#define TK_WHERE                          133
-#define TK_RESET                          134
+#define TK_NOW                            134
-#define TK_QUERY                          135
+#define TK_RESET                          135
-#define TK_SYNCDB                         136
+#define TK_QUERY                          136
-#define TK_ADD                            137
+#define TK_SYNCDB                         137
-#define TK_COLUMN                         138
+#define TK_ADD                            138
-#define TK_TAG                            139
+#define TK_COLUMN                         139
-#define TK_CHANGE                         140
+#define TK_TAG                            140
-#define TK_SET                            141
+#define TK_CHANGE                         141
-#define TK_KILL                           142
+#define TK_SET                            142
-#define TK_CONNECTION                     143
+#define TK_KILL                           143
-#define TK_STREAM                         144
+#define TK_CONNECTION                     144
-#define TK_COLON                          145
+#define TK_STREAM                         145
-#define TK_ABORT                          146
+#define TK_COLON                          146
-#define TK_AFTER                          147
+#define TK_ABORT                          147
-#define TK_ATTACH                         148
+#define TK_AFTER                          148
-#define TK_BEFORE                         149
+#define TK_ATTACH                         149
-#define TK_BEGIN                          150
+#define TK_BEFORE                         150
-#define TK_CASCADE                        151
+#define TK_BEGIN                          151
-#define TK_CLUSTER                        152
+#define TK_CASCADE                        152
-#define TK_CONFLICT                       153
+#define TK_CLUSTER                        153
-#define TK_COPY                           154
+#define TK_CONFLICT                       154
-#define TK_DEFERRED                       155
+#define TK_COPY                           155
-#define TK_DELIMITERS                     156
+#define TK_DEFERRED                       156
-#define TK_DETACH                         157
+#define TK_DELIMITERS                     157
-#define TK_EACH                           158
+#define TK_DETACH                         158
-#define TK_END                            159
+#define TK_EACH                           159
-#define TK_EXPLAIN                        160
+#define TK_END                            160
-#define TK_FAIL                           161
+#define TK_EXPLAIN                        161
-#define TK_FOR                            162
+#define TK_FAIL                           162
-#define TK_IGNORE                         163
+#define TK_FOR                            163
-#define TK_IMMEDIATE                      164
+#define TK_IGNORE                         164
-#define TK_INITIALLY                      165
+#define TK_IMMEDIATE                      165
-#define TK_INSTEAD                        166
+#define TK_INITIALLY                      166
-#define TK_MATCH                          167
+#define TK_INSTEAD                        167
-#define TK_KEY                            168
+#define TK_MATCH                          168
-#define TK_OF                             169
+#define TK_KEY                            169
-#define TK_RAISE                          170
+#define TK_OF                             170
-#define TK_REPLACE                        171
+#define TK_RAISE                          171
-#define TK_RESTRICT                       172
+#define TK_REPLACE                        172
-#define TK_ROW                            173
+#define TK_RESTRICT                       173
-#define TK_STATEMENT                      174
+#define TK_ROW                            174
-#define TK_TRIGGER                        175
+#define TK_STATEMENT                      175
-#define TK_VIEW                           176
+#define TK_TRIGGER                        176
-#define TK_SEMI                           177
+#define TK_VIEW                           177
-#define TK_NONE                           178
+#define TK_SEMI                           178
-#define TK_PREV                           179
+#define TK_NONE                           179
-#define TK_LINEAR                         180
+#define TK_PREV                           180
-#define TK_IMPORT                         181
+#define TK_LINEAR                         181
-#define TK_TBNAME                         182
+#define TK_IMPORT                         182
-#define TK_JOIN                           183
+#define TK_TBNAME                         183
-#define TK_INSERT                         184
+#define TK_JOIN                           184
-#define TK_INTO                           185
+#define TK_INSERT                         185
-#define TK_VALUES                         186
+#define TK_INTO                           186
-
+#define TK_VALUES                         187
 
 #define TK_SPACE                          300
 #define TK_COMMENT                        301

src/kit/shell/CMakeLists.txt

@@ -11,10 +11,17 @@ IF (TD_LINUX)
   LIST(REMOVE_ITEM SRC ./src/shellDarwin.c)
   ADD_EXECUTABLE(shell ${SRC})
 
+IF (TD_LINUX_64 AND JEMALLOC_ENABLED)
+  ADD_DEFINITIONS(-DTD_JEMALLOC_ENABLED -I${CMAKE_BINARY_DIR}/build/include -L${CMAKE_BINARY_DIR}/build/lib -Wl,-rpath,${CMAKE_BINARY_DIR}/build/lib -ljemalloc)
+  SET(LINK_JEMALLOC "-L${CMAKE_BINARY_DIR}/build/lib -ljemalloc")
+ELSE ()
+  SET(LINK_JEMALLOC "")
+ENDIF ()
+
   IF (TD_SOMODE_STATIC)
-    TARGET_LINK_LIBRARIES(shell taos_static)
+      TARGET_LINK_LIBRARIES(shell taos_static ${LINK_JEMALLOC})
   ELSE ()
-    TARGET_LINK_LIBRARIES(shell taos)
+      TARGET_LINK_LIBRARIES(shell taos ${LINK_JEMALLOC})
   ENDIF ()
 
   SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME taos)

src/kit/taosdemo/CMakeLists.txt

@@ -55,14 +55,21 @@ ENDIF ()
 MESSAGE("TD_VERSION_NUMBER is:" ${TD_VERSION_NUMBER})
 ADD_DEFINITIONS(-DTD_VERNUMBER="${TD_VERSION_NUMBER}")
 
+IF (TD_LINUX_64 AND JEMALLOC_ENABLED)
+  ADD_DEFINITIONS(-DTD_JEMALLOC_ENABLED -I${CMAKE_BINARY_DIR}/build/include -L${CMAKE_BINARY_DIR}/build/lib -Wl,-rpath,${CMAKE_BINARY_DIR}/build/lib -ljemalloc)
+  SET(LINK_JEMALLOC "-L${CMAKE_BINARY_DIR}/build/lib -ljemalloc")
+ELSE ()
+  SET(LINK_JEMALLOC "")
+ENDIF ()
+
 IF (TD_LINUX)
   AUX_SOURCE_DIRECTORY(. SRC)
   ADD_EXECUTABLE(taosdemo ${SRC})
 
   IF (TD_SOMODE_STATIC)
-    TARGET_LINK_LIBRARIES(taosdemo taos_static cJson)
+      TARGET_LINK_LIBRARIES(taosdemo taos_static cJson ${LINK_JEMALLOC})
   ELSE ()
-    TARGET_LINK_LIBRARIES(taosdemo taos cJson)
+      TARGET_LINK_LIBRARIES(taosdemo taos cJson ${LINK_JEMALLOC})
   ENDIF ()
 ELSEIF (TD_WINDOWS)
   AUX_SOURCE_DIRECTORY(. SRC)
@@ -71,7 +78,7 @@ ELSEIF (TD_WINDOWS)
   IF (TD_SOMODE_STATIC)
     TARGET_LINK_LIBRARIES(taosdemo taos_static cJson)
   ELSE ()
-    TARGET_LINK_LIBRARIES(taosdemo taos cJson})
+    TARGET_LINK_LIBRARIES(taosdemo taos cJson)
   ENDIF ()
 ELSEIF (TD_DARWIN)
   # missing a few dependencies, such as <argp.h>

src/mnode/src/mnodeDb.c

@@ -1060,6 +1060,13 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SAlterDbMsg *pAlter) {
     newCfg.partitions = partitions;
   }
 
+// community version can only change daysToKeep
+// but enterprise version can change all daysToKeep options
+#ifndef _STORAGE
+  newCfg.daysToKeep1 = newCfg.daysToKeep;
+  newCfg.daysToKeep2 = newCfg.daysToKeep;
+#endif
+
   return newCfg;
 }
 

src/mnode/src/mnodeMain.c

@@ -121,7 +121,7 @@ int32_t mnodeStartSystem() {
 
 int32_t mnodeInitSystem() {
   mnodeInitTimer();
-  if (mnodeNeedStart()) {
+  if (mnodeNeedStart() || tsCompactMnodeWal) {
     return mnodeStartSystem();
   }
   return 0;

src/mnode/src/mnodeSdb.c

@@ -656,8 +656,6 @@ static int32_t sdbProcessWrite(void *wparam, void *hparam, int32_t qtype, void *
     dnodeReportStep("mnode-sdb", stepDesc, 0);
   }
 
-  if (qtype == TAOS_QTYPE_QUERY) return sdbPerformDeleteAction(pHead, pTable);
-
   pthread_mutex_lock(&tsSdbMgmt.mutex);
   
   if (pHead->version == 0) {
@@ -690,7 +688,7 @@ static int32_t sdbProcessWrite(void *wparam, void *hparam, int32_t qtype, void *
   pthread_mutex_unlock(&tsSdbMgmt.mutex);
 
   // from app, row is created
-  if (pRow != NULL) {
+  if (pRow != NULL && tsCompactMnodeWal != 1) {
     // forward to peers
     pRow->processedCount = 0;
     int32_t syncCode = syncForwardToPeer(tsSdbMgmt.sync, pHead, pRow, TAOS_QTYPE_RPC, false);
@@ -713,19 +711,19 @@ static int32_t sdbProcessWrite(void *wparam, void *hparam, int32_t qtype, void *
            actStr[action], sdbGetKeyStr(pTable, pHead->cont), pHead->version);
 
   // even it is WAL/FWD, it shall be called to update version in sync
+  if (tsCompactMnodeWal != 1) {
     syncForwardToPeer(tsSdbMgmt.sync, pHead, pRow, TAOS_QTYPE_RPC, false);
+  }
 
   // from wal or forward msg, row not created, should add into hash
   if (action == SDB_ACTION_INSERT) {
     return sdbPerformInsertAction(pHead, pTable);
   } else if (action == SDB_ACTION_DELETE) {
-    //if (qtype == TAOS_QTYPE_FWD) {
+    if (qtype == TAOS_QTYPE_FWD) {
-      // Drop database/stable may take a long time and cause a timeout, so we confirm first then reput it into queue
+      // Drop database/stable may take a long time and cause a timeout, so we confirm first
-    //  sdbWriteFwdToQueue(1, hparam, TAOS_QTYPE_QUERY, unused);
+      syncConfirmForward(tsSdbMgmt.sync, pHead->version, TSDB_CODE_SUCCESS, false);
-    //  return TSDB_CODE_SUCCESS;
+    }
-    //} else {
     return sdbPerformDeleteAction(pHead, pTable);
-    //}
   } else if (action == SDB_ACTION_UPDATE) {
     return sdbPerformUpdateAction(pHead, pTable);
   } else {
@@ -1138,8 +1136,11 @@ static void *sdbWorkerFp(void *pWorker) {
         sdbConfirmForward(1, pRow, pRow->code);
       } else {
         if (qtype == TAOS_QTYPE_FWD) {
+          int32_t action = pRow->pHead.msgType % 10;
+          if (action != SDB_ACTION_DELETE) {
             syncConfirmForward(tsSdbMgmt.sync, pRow->pHead.version, pRow->code, false);
           }
+        }
         sdbFreeFromQueue(pRow);
       }
     }

src/mnode/src/mnodeTable.c

@@ -966,6 +966,11 @@ static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg) {
           pMsg->rpcMsg.ahandle, pDrop->name, pSTable->uid, pSTable->numOfTables, taosHashGetSize(pSTable->vgHash));
     return mnodeProcessDropSuperTableMsg(pMsg);
   } else {
+    // user specify the "DROP STABLE" sql statement, but it is actually a normal table, return error msg.
+    if (pDrop->supertable) {
+      return TSDB_CODE_MND_INVALID_TABLE_TYPE;
+    }
+
     SCTableObj *pCTable = (SCTableObj *)pMsg->pTable;
     mInfo("msg:%p, app:%p table:%s, start to drop ctable, vgId:%d tid:%d uid:%" PRIu64, pMsg, pMsg->rpcMsg.ahandle,
           pDrop->name, pCTable->vgId, pCTable->tid, pCTable->uid);
@@ -1674,12 +1679,9 @@ static int32_t mnodeSetSchemaFromSuperTable(SSchema *pSchema, SSTableObj *pTable
   return (pTable->numOfColumns + pTable->numOfTags) * sizeof(SSchema);
 }
 
-static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
+static int32_t mnodeDoGetSuperTableMeta(SMnodeMsg *pMsg, STableMetaMsg* pMeta) {
   SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
-  STableMetaMsg *pMeta   = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16));
+
-  if (pMeta == NULL) {
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
   pMeta->uid          = htobe64(pTable->uid);
   pMeta->sversion     = htons(pTable->sversion);
   pMeta->tversion     = htons(pTable->tversion);
@@ -1690,6 +1692,18 @@ static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
   pMeta->contLen      = sizeof(STableMetaMsg) + mnodeSetSchemaFromSuperTable(pMeta->schema, pTable);
   tstrncpy(pMeta->tableFname, pTable->info.tableId, sizeof(pMeta->tableFname));
 
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
+  SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
+  STableMetaMsg *pMeta   = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16));
+  if (pMeta == NULL) {
+    return TSDB_CODE_MND_OUT_OF_MEMORY;
+  }
+
+  mnodeDoGetSuperTableMeta(pMsg, pMeta);
+
   pMsg->rpcRsp.len = pMeta->contLen;
   pMeta->contLen = htons(pMeta->contLen);
 
@@ -1700,11 +1714,7 @@ static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
+static int32_t calculateVgroupMsgLength(SSTableVgroupMsg* pInfo, int32_t numOfTable) {
-  SSTableVgroupMsg *pInfo = pMsg->rpcMsg.pCont;
-  int32_t numOfTable = htonl(pInfo->numOfTables);
-
-  // reserve space
   int32_t contLen = sizeof(SSTableVgroupRspMsg) + 32 * sizeof(SVgroupMsg) + sizeof(SVgroupsMsg);
   for (int32_t i = 0; i < numOfTable; ++i) {
     char *stableName = (char *)pInfo + sizeof(SSTableVgroupMsg) + (TSDB_TABLE_FNAME_LEN)*i;
@@ -1716,37 +1726,29 @@ static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
     mnodeDecTableRef(pTable);
   }
 
-  SSTableVgroupRspMsg *pRsp = rpcMallocCont(contLen);
+  return contLen;
-  if (pRsp == NULL) {
+}
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
 
-  pRsp->numOfTables = 0;
+static char* serializeVgroupInfo(SSTableObj *pTable, char* name, char* msg, SMnodeMsg* pMsgBody, void* handle) {
-  char *msg = (char *)pRsp + sizeof(SSTableVgroupRspMsg);
+  SName sn = {0};
+  tNameFromString(&sn, name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  const char* tableName = tNameGetTableName(&sn);
+
+  strncpy(msg, tableName, TSDB_TABLE_NAME_LEN);
+  msg += TSDB_TABLE_NAME_LEN;
 
-  for (int32_t i = 0; i < numOfTable; ++i) {
-    char *stableName = (char *)pInfo + sizeof(SSTableVgroupMsg) + (TSDB_TABLE_FNAME_LEN)*i;
-    SSTableObj *pTable = mnodeGetSuperTable(stableName);
-    if (pTable == NULL) {
-      mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, stableName);
-      mnodeDecTableRef(pTable);
-      continue;
-    }
   if (pTable->vgHash == NULL) {
-      mDebug("msg:%p, app:%p stable:%s, no vgroup exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle,
+    mDebug("msg:%p, app:%p stable:%s, no vgroup exist while get stable vgroup info", pMsgBody, handle, name);
-             stableName);
     mnodeDecTableRef(pTable);
 
     // even this super table has no corresponding table, still return
-      pRsp->numOfTables++;
-
     SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
     pVgroupMsg->numOfVgroups = 0;
 
     msg += sizeof(SVgroupsMsg);
   } else {
     SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
-      mDebug("msg:%p, app:%p stable:%s, hash:%p sizeOfVgList:%d will be returned", pMsg, pMsg->rpcMsg.ahandle,
+    mDebug("msg:%p, app:%p stable:%s, hash:%p sizeOfVgList:%d will be returned", pMsgBody, handle,
            pTable->info.tableId, pTable->vgHash, taosHashGetSize(pTable->vgHash));
 
     int32_t *pVgId = taosHashIterate(pTable->vgHash, NULL);
@@ -1754,7 +1756,9 @@ static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
     while (pVgId) {
       SVgObj *pVgroup = mnodeGetVgroup(*pVgId);
       pVgId = taosHashIterate(pTable->vgHash, pVgId);
-        if (pVgroup == NULL) continue;
+      if (pVgroup == NULL) {
+        continue;
+      }
 
       pVgroupMsg->vgroups[vgSize].vgId = htonl(pVgroup->vgId);
       pVgroupMsg->vgroups[vgSize].numOfEps = 0;
@@ -1780,8 +1784,37 @@ static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
 
     // one table is done, try the next table
     msg += sizeof(SVgroupsMsg) + vgSize * sizeof(SVgroupMsg);
-      pRsp->numOfTables++;
   }
+
+  return msg;
+}
+
+static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
+  SSTableVgroupMsg *pInfo = pMsg->rpcMsg.pCont;
+  int32_t numOfTable = htonl(pInfo->numOfTables);
+
+  // calculate the required space.
+  int32_t contLen = calculateVgroupMsgLength(pInfo, numOfTable);
+  SSTableVgroupRspMsg *pRsp = rpcMallocCont(contLen);
+  if (pRsp == NULL) {
+    return TSDB_CODE_MND_OUT_OF_MEMORY;
+  }
+
+  pRsp->numOfTables = 0;
+  char *msg = (char *)pRsp + sizeof(SSTableVgroupRspMsg);
+
+  for (int32_t i = 0; i < numOfTable; ++i) {
+    char *stableName = (char *)pInfo + sizeof(SSTableVgroupMsg) + (TSDB_TABLE_FNAME_LEN)*i;
+
+    SSTableObj *pTable = mnodeGetSuperTable(stableName);
+    if (pTable == NULL) {
+      mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, stableName);
+      mnodeDecTableRef(pTable);
+      continue;
+    }
+
+    msg = serializeVgroupInfo(pTable, stableName, msg, pMsg, pMsg->rpcMsg.ahandle);
+    pRsp->numOfTables++;
   }
 
   if (pRsp->numOfTables != numOfTable) {
@@ -2415,9 +2448,9 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
     pMeta->vgroup.numOfEps++;
     mnodeDecDnodeRef(pDnode);
   }
-  pMeta->vgroup.vgId = htonl(pMsg->pVgroup->vgId);
 
-  mDebug("msg:%p, app:%p table:%s, uid:%" PRIu64 " table meta is retrieved, vgId:%d sid:%d", pMsg, pMsg->rpcMsg.ahandle,
+  pMeta->vgroup.vgId = htonl(pMsg->pVgroup->vgId);
+  mDebug("msg:%p, app:%p table:%s, uid:%" PRIu64 " table meta is retrieved, vgId:%d tid:%d", pMsg, pMsg->rpcMsg.ahandle,
          pTable->info.tableId, pTable->uid, pTable->vgId, pTable->tid);
 
   return TSDB_CODE_SUCCESS;
@@ -2811,56 +2844,137 @@ static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg) {
 
 static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   SMultiTableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
-  pInfo->numOfTables = htonl(pInfo->numOfTables);
 
-  int32_t totalMallocLen = 4 * 1024 * 1024;  // first malloc 4 MB, subsequent reallocation as twice
+  pInfo->numOfTables  = htonl(pInfo->numOfTables);
-  SMultiTableMeta *pMultiMeta = rpcMallocCont(totalMallocLen);
+  pInfo->numOfVgroups = htonl(pInfo->numOfVgroups);
+
+  int32_t contLen = pMsg->rpcMsg.contLen - sizeof(SMultiTableInfoMsg);
+
+  int32_t num      = 0;
+  int32_t code     = TSDB_CODE_SUCCESS;
+  char*   str      = strndup(pInfo->tableNames, contLen);
+  char**  nameList = strsplit(str, ",", &num);
+  SArray* pList    = taosArrayInit(4, POINTER_BYTES);
+  SMultiTableMeta *pMultiMeta = NULL;
+
+  if (num != pInfo->numOfTables + pInfo->numOfVgroups) {
+    mError("msg:%p, app:%p, failed to get multi-tableMeta, msg inconsistent", pMsg, pMsg->rpcMsg.ahandle);
+    code = TSDB_CODE_MND_INVALID_TABLE_NAME;
+    goto _end;
+  }
+
+  // first malloc 80KB, subsequent reallocation will expand the size as twice of the original size
+  int32_t totalMallocLen = sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16);
+  pMultiMeta = rpcMallocCont(totalMallocLen);
   if (pMultiMeta == NULL) {
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
+    code = TSDB_CODE_MND_OUT_OF_MEMORY;
+    goto _end;
   }
 
   pMultiMeta->contLen = sizeof(SMultiTableMeta);
   pMultiMeta->numOfTables = 0;
 
-  for (int32_t t = 0; t < pInfo->numOfTables; ++t) {
+  int32_t t = 0;
-    char * tableId = (char *)(pInfo->tableIds + t * TSDB_TABLE_FNAME_LEN);
+  for (; t < pInfo->numOfTables; ++t) {
-    SCTableObj *pTable = mnodeGetChildTable(tableId);
+    char *fullName = nameList[t];
-    if (pTable == NULL) continue;
 
-    if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableName(tableId);
+    pMsg->pTable = mnodeGetTable(fullName);
-    if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) {
+    if (pMsg->pTable == NULL) {
-      mnodeDecTableRef(pTable);
+      mError("msg:%p, app:%p table:%s, failed to get table meta, table not exist", pMsg, pMsg->rpcMsg.ahandle, fullName);
-      continue;
+      code = TSDB_CODE_MND_INVALID_TABLE_NAME;
+      goto _end;
     }
 
-    int availLen = totalMallocLen - pMultiMeta->contLen;
+    if (pMsg->pDb == NULL) {
-    if (availLen <= sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)) {
+      pMsg->pDb = mnodeGetDbByTableName(fullName);
+    }
+
+    if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) {
+      mnodeDecTableRef(pMsg->pTable);
+      code = TSDB_CODE_APP_NOT_READY;
+      goto _end;
+    }
+
+    int remain = totalMallocLen - pMultiMeta->contLen;
+    if (remain <= sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)) {
       totalMallocLen *= 2;
       pMultiMeta = rpcReallocCont(pMultiMeta, totalMallocLen);
       if (pMultiMeta == NULL) {
-        mnodeDecTableRef(pTable);
+        mnodeDecTableRef(pMsg->pTable);
-        return TSDB_CODE_MND_OUT_OF_MEMORY;
+        code = TSDB_CODE_MND_OUT_OF_MEMORY;
+        goto _end;
+      }
+    }
+
+    STableMetaMsg *pMeta = (STableMetaMsg *)((char*) pMultiMeta + pMultiMeta->contLen);
+
+    if (pMsg->pTable->type == TSDB_SUPER_TABLE) {
+      code = mnodeDoGetSuperTableMeta(pMsg, pMeta);
+      taosArrayPush(pList, &fullName);  // keep the full name for each super table for retrieve vgroup list
     } else {
-        t--;
+      code = mnodeDoGetChildTableMeta(pMsg, pMeta);
-        mnodeDecTableRef(pTable);
+      if (pMsg->pVgroup != NULL) {
-        continue;
+        mnodeDecVgroupRef(pMsg->pVgroup);
+        pMsg->pVgroup = NULL;
       }
     }
 
-    STableMetaMsg *pMeta = (STableMetaMsg *)(pMultiMeta->metas + pMultiMeta->contLen);
+    mnodeDecTableRef(pMsg->pTable);
-    int32_t code = mnodeDoGetChildTableMeta(pMsg, pMeta);
+    pMsg->pTable = NULL;
+
     if (code == TSDB_CODE_SUCCESS) {
-      pMultiMeta->numOfTables ++;
+      pMultiMeta->numOfTables++;
       pMultiMeta->contLen += pMeta->contLen;
+    } else {
+      // ignore error and continue.
+      // Otherwise the client may found that the responding message is inconsistent.
+//      goto _end;
+    }
   }
 
-    mnodeDecTableRef(pTable);
+  char* msg = (char*) pMultiMeta + pMultiMeta->contLen;
+
+  // add the additional super table names that needs the vgroup info
+  for(;t < num; ++t) {
+    taosArrayPush(pList, &nameList[t]);
   }
 
+  // add the pVgroupList into the pList
+  int32_t numOfVgroupList = (int32_t) taosArrayGetSize(pList);
+  pMultiMeta->numOfVgroup = htonl(numOfVgroupList);
+
+  for(int32_t i = 0; i < numOfVgroupList; ++i) {
+    char* name = taosArrayGetP(pList, i);
+
+    SSTableObj *pTable = mnodeGetSuperTable(name);
+    if (pTable == NULL) {
+      mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, name);
+      code = TSDB_CODE_MND_INVALID_TABLE_NAME;
+      goto _end;
+    }
+
+    msg = serializeVgroupInfo(pTable, name, msg, pMsg, pMsg->rpcMsg.ahandle);
+  }
+
+  pMultiMeta->contLen = (int32_t) (msg - (char*) pMultiMeta);
+
+  pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
   pMsg->rpcRsp.rsp = pMultiMeta;
   pMsg->rpcRsp.len = pMultiMeta->contLen;
+  code = TSDB_CODE_SUCCESS;
 
-  return TSDB_CODE_SUCCESS;
+  _end:
+  tfree(str);
+  tfree(nameList);
+  taosArrayDestroy(pList);
+  pMsg->pTable  = NULL;
+  pMsg->pVgroup = NULL;
+
+  if (code != TSDB_CODE_SUCCESS) {
+    rpcFreeCont(pMultiMeta);
+  }
+
+  return code;
 }
 
 static int32_t mnodeGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {
@@ -3261,7 +3375,7 @@ static int32_t mnodeCompactSuperTables() {
       .rowSize = sizeof(SSTableObj) + schemaSize,
     };
 
-    mInfo("compact super %" PRIu64, pTable->uid);
+    //mInfo("compact super %" PRIu64, pTable->uid);
     
     sdbInsertCompactRow(&row);
   }
@@ -3287,7 +3401,7 @@ static int32_t mnodeCompactChildTables() {
       .pTable = tsChildTableSdb,
     };
 
-    mInfo("compact child %" PRIu64 ":%d", pTable->uid, pTable->tid);
+    //mInfo("compact child %" PRIu64 ":%d", pTable->uid, pTable->tid);
     
     sdbInsertCompactRow(&row);
   }

src/os/inc/osDir.h

@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 void    taosRemoveDir(char *rootDir);
+bool    taosDirExist(const char* dirname);
 int32_t taosMkDir(const char *pathname, mode_t mode);
 void    taosRemoveOldLogFiles(char *rootDir, int32_t keepDays);
 int32_t taosRename(char *oldName, char *newName);

src/os/inc/osMemory.h

@@ -22,6 +22,10 @@
 extern "C" {
 #endif
 
+#ifdef TD_JEMALLOC_ENABLED
+#include <jemalloc/jemalloc.h>
+#endif
+
 typedef enum {
   TAOS_ALLOC_MODE_DEFAULT = 0,
   TAOS_ALLOC_MODE_RANDOM_FAIL = 1,

src/os/src/detail/osDir.c

@@ -45,6 +45,10 @@ void taosRemoveDir(char *rootDir) {
   uInfo("dir:%s is removed", rootDir);
 }
 
+bool taosDirExist(const char* dirname) {
+  return access(dirname, F_OK) == 0;
+}
+
 int taosMkDir(const char *path, mode_t mode) {
   int code = mkdir(path, 0755);
   if (code < 0 && errno == EEXIST) code = 0;

src/os/src/detail/osTime.c

@@ -87,12 +87,12 @@ static int32_t (*parseLocaltimeFp[]) (char* timestr, int64_t* time, int32_t time
 
 int32_t taosGetTimestampSec() { return (int32_t)time(NULL); }
 
-int32_t taosParseTime(char* timestr, int64_t* time, int32_t len, int32_t timePrec, int8_t daylight) {
+int32_t taosParseTime(char* timestr, int64_t* time, int32_t len, int32_t timePrec, int8_t day_light) {
   /* parse datatime string in with tz */
   if (strnchr(timestr, 'T', len, false) != NULL) {
     return parseTimeWithTz(timestr, time, timePrec);
   } else {
-    return (*parseLocaltimeFp[daylight])(timestr, time, timePrec);
+    return (*parseLocaltimeFp[day_light])(timestr, time, timePrec);
   }
 }
 

src/plugins/http/src/httpResp.c

@@ -165,7 +165,7 @@ void httpSendTaosdInvalidSqlErrorResp(HttpContext *pContext, char *errMsg) {
     }
   }
 
-  httpSendErrorRespImp(pContext, httpCode, "Bad Request", TSDB_CODE_TSC_INVALID_SQL & 0XFFFF, temp);
+  httpSendErrorRespImp(pContext, httpCode, "Bad Request", TSDB_CODE_TSC_INVALID_OPERATION & 0XFFFF, temp);
 }
 
 void httpSendSuccResp(HttpContext *pContext, char *desc) {

src/plugins/http/src/httpSql.c

@@ -263,7 +263,7 @@ void httpProcessSingleSqlCallBackImp(void *param, TAOS_RES *result, int32_t code
 
   if (code != TSDB_CODE_SUCCESS) {
     SSqlObj *pObj = (SSqlObj *)result;
-    if (code == TSDB_CODE_TSC_INVALID_SQL) {
+    if (code == TSDB_CODE_TSC_INVALID_OPERATION) {
       terrno = code;
       httpError("context:%p, fd:%d, user:%s, query error, code:%s, sqlObj:%p, error:%s", pContext, pContext->fd,
                 pContext->user, tstrerror(code), pObj, taos_errstr(pObj));

src/plugins/http/src/httpUtil.c

@@ -237,6 +237,11 @@ void httpFreeMultiCmds(HttpContext *pContext) {
 JsonBuf *httpMallocJsonBuf(HttpContext *pContext) {
   if (pContext->jsonBuf == NULL) {
     pContext->jsonBuf = (JsonBuf *)malloc(sizeof(JsonBuf));
+    if (pContext->jsonBuf == NULL) {
+      return NULL;
+    }
+
+    memset(pContext->jsonBuf, 0, sizeof(JsonBuf));
   }
 
   if (!pContext->jsonBuf->pContext) {

src/query/inc/qExecutor.h

@@ -22,6 +22,7 @@
 #include "qFill.h"
 #include "qResultbuf.h"
 #include "qSqlparser.h"
+#include "qTableMeta.h"
 #include "qTsbuf.h"
 #include "query.h"
 #include "taosdef.h"
@@ -70,14 +71,6 @@ typedef struct SResultRowPool {
   SArray* pData;    // SArray<void*>
 } SResultRowPool;
 
-typedef struct SSqlGroupbyExpr {
-  int16_t tableIndex;
-  SArray* columnInfo;  // SArray<SColIndex>, group by columns information
-  int16_t numOfGroupCols;
-  int16_t orderIndex;  // order by column index
-  int16_t orderType;   // order by type: asc/desc
-} SSqlGroupbyExpr;
-
 typedef struct SResultRow {
   int32_t       pageId;      // pageId & rowId is the position of current result in disk-based output buffer
   int32_t       offset:29;    // row index in buffer page
@@ -196,6 +189,7 @@ typedef struct SQueryAttr {
   bool             pointInterpQuery; // point interpolation query
   bool             needReverseScan;  // need reverse scan
   bool             distinctTag;      // distinct tag query
+  bool             stateWindow;       // window State on sub/normal table
   int32_t          interBufSize;     // intermediate buffer sizse
 
   int32_t          havingNum;        // having expr number
@@ -216,7 +210,7 @@ typedef struct SQueryAttr {
   int32_t          intermediateResultRowSize; // intermediate result row size, in case of top-k query.
   int32_t          maxTableColumnWidth;
   int32_t          tagLen;           // tag value length of current query
-  SSqlGroupbyExpr* pGroupbyExpr;
+  SGroupbyExpr    *pGroupbyExpr;
 
   SExprInfo*       pExpr1;
   SExprInfo*       pExpr2;
@@ -302,6 +296,8 @@ enum OPERATOR_TYPE_E {
   OP_GlobalAggregate   = 18,   // global merge for the multi-way data sources.
   OP_Filter            = 19,
   OP_Distinct          = 20,
+  OP_Join              = 21,
+  OP_StateWindow       = 22,
 };
 
 typedef struct SOperatorInfo {
@@ -314,7 +310,8 @@ typedef struct SOperatorInfo {
   SExprInfo            *pExpr;
   SQueryRuntimeEnv     *pRuntimeEnv;
 
-  struct SOperatorInfo *upstream;
+  struct SOperatorInfo **upstream;     // upstream pointer list
+  int32_t               numOfUpstream; // number of upstream. The value is always ONE expect for join operator
   __operator_fn_t       exec;
   __optr_cleanup_fn_t   cleanup;
 } SOperatorInfo;
@@ -362,7 +359,7 @@ typedef struct SQueryParam {
 
   SColIndex       *pGroupColIndex;
   SColumnInfo     *pTagColumnInfo;
-  SSqlGroupbyExpr *pGroupbyExpr;
+  SGroupbyExpr *pGroupbyExpr;
   int32_t          tableScanOperator;
   SArray          *pOperator;
 } SQueryParam;
@@ -465,6 +462,16 @@ typedef struct SSWindowOperatorInfo {
   int32_t        start;      // start row index
 } SSWindowOperatorInfo;
 
+typedef struct SStateWindowOperatorInfo {
+  SOptrBasicInfo binfo;
+  STimeWindow    curWindow;  // current time window
+  int32_t        numOfRows;  // number of rows
+  int32_t        colIndex;      // start row index
+  int32_t        start;
+  char*          prevData;    // previous data 
+   
+} SStateWindowOperatorInfo ;
+
 typedef struct SDistinctOperatorInfo {
   SHashObj         *pSet;
   SSDataBlock      *pRes;
@@ -473,10 +480,10 @@ typedef struct SDistinctOperatorInfo {
   int64_t           outputCapacity;
 } SDistinctOperatorInfo;
 
-struct SLocalMerger;
+struct SGlobalMerger;
 
 typedef struct SMultiwayMergeInfo {
-  struct SLocalMerger *pMerge;
+  struct SGlobalMerger *pMerge;
   SOptrBasicInfo       binfo;
   int32_t              bufCapacity;
   int64_t              seed;
@@ -494,6 +501,8 @@ typedef struct SMultiwayMergeInfo {
   bool                 groupMix;
 } SMultiwayMergeInfo;
 
+void appendUpstream(SOperatorInfo* p, SOperatorInfo* pUpstream);
+
 SOperatorInfo* createDataBlocksOptScanInfo(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv, int32_t repeatTime, int32_t reverseTime);
 SOperatorInfo* createTableScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv, int32_t repeatTime);
 SOperatorInfo* createTableSeqScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
@@ -512,14 +521,23 @@ SOperatorInfo* createDistinctOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperat
 SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
 SOperatorInfo* createMultiwaySortOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInfo* pExpr, int32_t numOfOutput,
                                               int32_t numOfRows, void* merger, bool groupMix);
+SOperatorInfo* createStatewindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param);
 SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* merger);
-SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
+                                        int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter);
+
+SOperatorInfo* createJoinOperatorInfo(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput);
 
 SSDataBlock* doGlobalAggregate(void* param, bool* newgroup);
 SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup);
 SSDataBlock* doSLimit(void* param, bool* newgroup);
 
+int32_t doCreateFilterInfo(SColumnInfo* pCols, int32_t numOfCols, int32_t numOfFilterCols, SSingleColumnFilterInfo** pFilterInfo, uint64_t qId);
+void doSetFilterColumnInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, SSDataBlock* pBlock);
+bool doFilterDataBlock(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, int32_t numOfRows, int8_t* p);
+void doCompactSDataBlock(SSDataBlock* pBlock, int32_t numOfRows, int8_t* p);
+
 SSDataBlock* createOutputBuf(SExprInfo* pExpr, int32_t numOfOutput, int32_t numOfRows);
 void* destroyOutputBuf(SSDataBlock* pBlock);
 
@@ -536,16 +554,19 @@ int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExp
 int32_t createIndirectQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t numOfOutput, SExprInfo **pExprInfo,
                                            SSqlExpr **pExpr, SExprInfo *prevExpr);
 
-SSqlGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code);
+SGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code);
-SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
+SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
                         SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, int32_t vgId, char* sql, uint64_t *qId);
 
 int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo* pQInfo, SQueryParam* param, char* start,
                   int32_t prevResultLen, void* merger);
 
+int32_t createFilterInfo(SQueryAttr* pQueryAttr, uint64_t qId);
 void freeColumnFilterInfo(SColumnFilterInfo* pFilter, int32_t numOfFilters);
 
 STableQueryInfo *createTableQueryInfo(SQueryAttr* pQueryAttr, void* pTable, bool groupbyColumn, STimeWindow win, void* buf);
+STableQueryInfo* createTmpTableQueryInfo(STimeWindow win);
+
 int32_t buildArithmeticExprFromMsg(SExprInfo *pArithExprInfo, void *pQueryMsg);
 
 bool isQueryKilled(SQInfo *pQInfo);

src/query/inc/qFill.h

@@ -62,7 +62,7 @@ typedef struct SFillInfo {
 
   SFillColInfo* pFillCol;         // column info for fill operations
   SFillTagColInfo* pTags;         // tags value for filling gap
-  void*     handle;               // for dubug purpose
+  void*     handle;               // for debug purpose
 } SFillInfo;
 
 typedef struct SPoint {
@@ -82,8 +82,6 @@ void taosFillSetStartInfo(SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey)
 
 void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const struct SSDataBlock* pInput);
 
-void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, const tFilePage* pInput);
-
 bool taosFillHasMoreResults(SFillInfo* pFillInfo);
 
 int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, int64_t ekey, int32_t maxNumOfRows);

src/query/inc/qPlan.h

@@ -16,7 +16,40 @@
 #ifndef TDENGINE_QPLAN_H
 #define TDENGINE_QPLAN_H
 
-//TODO refactor
+#include "qExecutor.h"
+
+struct SQueryInfo;
+
+typedef struct SQueryNodeBasicInfo {
+  int32_t type;
+  char   *name;
+} SQueryNodeBasicInfo;
+
+typedef struct SQueryTableInfo {
+  char     *tableName;
+  STableId  id;
+} SQueryTableInfo;
+
+typedef struct SQueryNode {
+  SQueryNodeBasicInfo info;
+  SQueryTableInfo    tableInfo;
+  SSchema           *pSchema;      // the schema of the input SSDatablock
+  int32_t            numOfCols;    // number of input columns
+  SExprInfo         *pExpr;        // the query functions or sql aggregations
+  int32_t            numOfOutput;  // number of result columns, which is also the number of pExprs
+
+  void              *pExtInfo;     // additional information
+  // previous operator to generated result for current node to process
+  // in case of join, multiple prev nodes exist.
+  SArray            *pPrevNodes;// upstream nodes
+  struct SQueryNode *nextNode;
+} SQueryNode;
+
+SQueryNode* qCreateQueryPlan(struct SQueryInfo* pQueryInfo);
+void* qDestroyQueryPlan(SQueryNode* pQueryNode);
+
+char* queryPlanToString(SQueryNode* pQueryNode);
+
 SArray* createTableScanPlan(SQueryAttr* pQueryAttr);
 SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr);
 SArray* createGlobalMergePlan(SQueryAttr* pQueryAttr);

src/query/inc/qSqlparser.h

@@ -89,6 +89,10 @@ typedef struct SSessionWindowVal {
   SStrToken          gap;
 } SSessionWindowVal;
 
+typedef struct SWindowStateVal {
+  SStrToken          col;
+} SWindowStateVal;
+
 struct SRelationInfo;
 
 typedef struct SSqlNode {
@@ -100,6 +104,7 @@ typedef struct SSqlNode {
   SArray            *fillType;     // fill type[optional], SArray<tVariantListItem>
   SIntervalVal       interval;     // (interval, interval_offset) [optional]
   SSessionWindowVal  sessionVal;   // session window [optional]
+  SWindowStateVal    windowstateVal; // window_state(col) [optional]
   SStrToken          sliding;      // sliding window [optional]
   SLimitVal          limit;        // limit offset [optional]
   SLimitVal          slimit;       // group limit offset [optional]
@@ -107,14 +112,18 @@ typedef struct SSqlNode {
   struct tSqlExpr   *pHaving;      // having clause [optional]
 } SSqlNode;
 
-typedef struct STableNamePair {
+typedef struct SRelElementPair {
-  SStrToken name;
+  union {
+    SStrToken  tableName;
+    SArray    *pSubquery;
+  };
+
   SStrToken aliasName;
-} STableNamePair;
+} SRelElementPair;
 
 typedef struct SRelationInfo {
   int32_t       type;        // nested query|table name list
-  SArray       *list;        // SArray<STableNamePair>|SArray<SSqlNode*>
+  SArray       *list;        // SArray<SRelElementPair>
 } SRelationInfo;
 
 typedef struct SCreatedTableInfo {
@@ -254,8 +263,8 @@ SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int
 SArray *tVariantListAppendToken(SArray *pList, SStrToken *pAliasToken, uint8_t sortOrder);
 
 SRelationInfo *setTableNameList(SRelationInfo* pFromInfo, SStrToken *pName, SStrToken* pAlias);
-SRelationInfo *setSubquery(SRelationInfo* pFromInfo, SArray* pSqlNode);
 void          *destroyRelationInfo(SRelationInfo* pFromInfo);
+SRelationInfo *addSubqueryElem(SRelationInfo* pRelationInfo, SArray* pSub, SStrToken* pAlias);
 
 // sql expr leaf node
 tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType);
@@ -271,7 +280,7 @@ SArray   *tSqlExprListAppend(SArray *pList, tSqlExpr *pNode, SStrToken *pDistinc
 void      tSqlExprListDestroy(SArray *pList);
 
 SSqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelNodeList, SRelationInfo *pFrom, tSqlExpr *pWhere,
-                                SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval, SSessionWindowVal *ps,
+                                SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval, SSessionWindowVal *ps, SWindowStateVal *pw,
                                 SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pgLimit, tSqlExpr *pHaving);
 int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right);
 

src/query/inc/qTableMeta.h

@@ -0,0 +1,203 @@
+#ifndef TDENGINE_QTABLEUTIL_H
+#define TDENGINE_QTABLEUTIL_H
+
+#include "tsdb.h"  //todo tsdb should not be here
+#include "qSqlparser.h"
+
+typedef struct SFieldInfo {
+  int16_t      numOfOutput;   // number of column in result
+  TAOS_FIELD*  final;
+  SArray      *internalField; // SArray<SInternalField>
+} SFieldInfo;
+
+typedef struct SCond {
+  uint64_t uid;
+  int32_t  len;  // length of tag query condition data
+  char *   cond;
+} SCond;
+
+typedef struct SJoinNode {
+  uint64_t uid;
+  int16_t  tagColId;
+  SArray*  tsJoin;
+  SArray*  tagJoin;
+} SJoinNode;
+
+typedef struct SJoinInfo {
+  bool       hasJoin;
+  SJoinNode *joinTables[TSDB_MAX_JOIN_TABLE_NUM];
+} SJoinInfo;
+
+typedef struct STagCond {
+  // relation between tbname list and query condition, including : TK_AND or TK_OR
+  int16_t relType;
+
+  // tbname query condition, only support tbname query condition on one table
+  SCond tbnameCond;
+
+  // join condition, only support two tables join currently
+  SJoinInfo joinInfo;
+
+  // for different table, the query condition must be seperated
+  SArray *pCond;
+} STagCond;
+
+typedef struct SGroupbyExpr {
+  int16_t tableIndex;
+  SArray* columnInfo;  // SArray<SColIndex>, group by columns information
+  int16_t numOfGroupCols;  // todo remove it
+  int16_t orderIndex;  // order by column index
+  int16_t orderType;   // order by type: asc/desc
+} SGroupbyExpr;
+
+typedef struct STableComInfo {
+  uint8_t numOfTags;
+  uint8_t precision;
+  int16_t numOfColumns;
+  int32_t rowSize;
+} STableComInfo;
+
+typedef struct STableMeta {
+  int32_t        vgId;
+  STableId       id;
+  uint8_t        tableType;
+  char           sTableName[TSDB_TABLE_FNAME_LEN];  // super table name
+  uint64_t       suid;       // super table id
+  int16_t        sversion;
+  int16_t        tversion;
+  STableComInfo  tableInfo;
+  SSchema        schema[];  // if the table is TSDB_CHILD_TABLE, schema is acquired by super table meta info
+} STableMeta;
+
+typedef struct STableMetaInfo {
+  STableMeta    *pTableMeta;      // table meta, cached in client side and acquired by name
+  uint32_t       tableMetaSize;
+  SVgroupsInfo  *vgroupList;
+  SArray        *pVgroupTables;   // SArray<SVgroupTableInfo>
+
+  /*
+   * 1. keep the vgroup index during the multi-vnode super table projection query
+   * 2. keep the vgroup index for multi-vnode insertion
+   */
+  int32_t       vgroupIndex;
+  SName         name;
+  char          aliasName[TSDB_TABLE_NAME_LEN];    // alias name of table specified in query sql
+  SArray       *tagColList;                        // SArray<SColumn*>, involved tag columns
+} STableMetaInfo;
+
+struct   SQInfo;      // global merge operator
+struct   SQueryAttr;     // query object
+
+typedef struct SQueryInfo {
+  int16_t          command;       // the command may be different for each subclause, so keep it seperately.
+  uint32_t         type;          // query/insert type
+  STimeWindow      window;        // the whole query time window
+
+  SInterval        interval;      // tumble time window
+  SSessionWindow   sessionWindow; // session time window
+
+  SGroupbyExpr     groupbyExpr;   // groupby tags info
+  SArray *         colList;       // SArray<SColumn*>
+  SFieldInfo       fieldsInfo;
+  SArray *         exprList;      // SArray<SExprInfo*>
+  SArray *         exprList1;     // final exprlist in case of arithmetic expression exists
+  SLimitVal        limit;
+  SLimitVal        slimit;
+  STagCond         tagCond;
+
+  SOrderVal        order;
+  int16_t          fillType;      // final result fill type
+  int16_t          numOfTables;
+  STableMetaInfo **pTableMetaInfo;
+  struct STSBuf   *tsBuf;
+  int64_t *        fillVal;       // default value for fill
+  char *           msg;           // pointer to the pCmd->payload to keep error message temporarily
+  int64_t          clauseLimit;   // limit for current sub clause
+
+  int64_t          prjOffset;     // offset value in the original sql expression, only applied at client side
+  int64_t          vgroupLimit;    // table limit in case of super table projection query + global order + limit
+
+  int32_t          udColumnId;    // current user-defined constant output field column id, monotonically decreases from TSDB_UD_COLUMN_INDEX
+  int16_t          resColumnId;   // result column id
+  bool             distinctTag;   // distinct tag or not
+  int32_t          round;         // 0/1/....
+  int32_t          bufLen;
+  char*            buf;
+  struct SQInfo*          pQInfo;      // global merge operator
+  struct SQueryAttr*      pQueryAttr;     // query object
+
+  struct SQueryInfo *sibling;     // sibling
+  SArray            *pUpstream;   // SArray<struct SQueryInfo>
+  struct SQueryInfo *pDownstream;
+  int32_t            havingFieldNum;
+  bool               stableQuery;
+  bool               groupbyColumn;
+  bool               simpleAgg;
+  bool               arithmeticOnAgg;
+  bool               projectionQuery;
+  bool               hasFilter;
+  bool               onlyTagQuery;
+  bool               orderProjectQuery;
+  bool               stateWindow;
+} SQueryInfo;
+
+/**
+ * get the number of tags of this table
+ * @param pTableMeta
+ * @return
+ */
+int32_t tscGetNumOfTags(const STableMeta* pTableMeta);
+
+/**
+ * get the number of columns of this table
+ * @param pTableMeta
+ * @return
+ */
+int32_t tscGetNumOfColumns(const STableMeta* pTableMeta);
+
+/**
+ * get the basic info of this table
+ * @param pTableMeta
+ * @return
+ */
+STableComInfo tscGetTableInfo(const STableMeta* pTableMeta);
+
+/**
+ * get the schema
+ * @param pTableMeta
+ * @return
+ */
+SSchema* tscGetTableSchema(const STableMeta* pTableMeta);
+
+/**
+ * get the tag schema
+ * @param pMeta
+ * @return
+ */
+SSchema *tscGetTableTagSchema(const STableMeta *pMeta);
+
+/**
+ * get the column schema according to the column index
+ * @param pMeta
+ * @param colIndex
+ * @return
+ */
+SSchema *tscGetTableColumnSchema(const STableMeta *pMeta, int32_t colIndex);
+
+/**
+ * get the column schema according to the column id
+ * @param pTableMeta
+ * @param colId
+ * @return
+ */
+SSchema* tscGetColumnSchemaById(STableMeta* pTableMeta, int16_t colId);
+
+/**
+ * create the table meta from the msg
+ * @param pTableMetaMsg
+ * @param size size of the table meta
+ * @return
+ */
+STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg);
+
+#endif  // TDENGINE_QTABLEUTIL_H

src/query/inc/qUtil.h

@@ -47,6 +47,9 @@ void    clearResultRow(SQueryRuntimeEnv* pRuntimeEnv, SResultRow* pResultRow, in
 
 SResultRowCellInfo* getResultCell(const SResultRow* pRow, int32_t index, int32_t* offset);
 
+void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr);
+void* freeColumnInfo(SColumnInfo* pColumnInfo, int32_t numOfCols);
+
 static FORCE_INLINE SResultRow *getResultRow(SResultRowInfo *pResultRowInfo, int32_t slot) {
   assert(pResultRowInfo != NULL && slot >= 0 && slot < pResultRowInfo->size);
   return pResultRowInfo->pResult[slot];

src/query/inc/sql.y

@@ -28,7 +28,7 @@
 #include <stdbool.h>
 #include "qSqlparser.h"
 #include "tcmdtype.h"
-#include "tstoken.h"
+#include "ttoken.h"
 #include "ttokendef.h"
 #include "tutil.h"
 #include "tvariant.h"
@@ -456,8 +456,8 @@ tagitem(A) ::= PLUS(X) FLOAT(Y).  {
 //////////////////////// The SELECT statement /////////////////////////////////
 %type select {SSqlNode*}
 %destructor select {destroySqlNode($$);}
-select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_opt(K) session_option(H) fill_opt(F) sliding_opt(S) groupby_opt(P) orderby_opt(Z) having_opt(N) slimit_opt(G) limit_opt(L). {
+select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_opt(K) session_option(H) windowstate_option(D) fill_opt(F) sliding_opt(S) groupby_opt(P) orderby_opt(Z) having_opt(N) slimit_opt(G) limit_opt(L). {
-  A = tSetQuerySqlNode(&T, W, X, Y, P, Z, &K, &H, &S, F, &L, &G, N);
+  A = tSetQuerySqlNode(&T, W, X, Y, P, Z, &K, &H, &D, &S, F, &L, &G, N);
 }
 
 select(A) ::= LP select(B) RP. {A = B;}
@@ -475,7 +475,7 @@ cmd ::= union(X). { setSqlInfo(pInfo, X, NULL, TSDB_SQL_SELECT); }
 // select client_version()
 // select server_state()
 select(A) ::= SELECT(T) selcollist(W). {
-  A = tSetQuerySqlNode(&T, W, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  A = tSetQuerySqlNode(&T, W, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 // selcollist is a list of expressions that are to become the return
@@ -512,7 +512,13 @@ distinct(X) ::= .            { X.n = 0;}
 %type from {SRelationInfo*}
 %destructor from {destroyRelationInfo($$);}
 from(A) ::= FROM tablelist(X).                 {A = X;}
-from(A) ::= FROM LP union(Y) RP.               {A = setSubquery(NULL, Y);}
+from(A) ::= FROM sub(X).                       {A = X;}
+
+%type sub {SRelationInfo*}
+%destructor sub {destroyRelationInfo($$);}
+sub(A)  ::= LP union(Y) RP.                    {A = addSubqueryElem(NULL, Y, NULL);}
+sub(A)  ::= LP union(Y) RP ids(Z).             {A = addSubqueryElem(NULL, Y, &Z);}
+sub(A)  ::= sub(X) COMMA LP union(Y) RP ids(Z).{A = addSubqueryElem(X, Y, &Z);}
 
 %type tablelist {SRelationInfo*}
 %destructor tablelist {destroyRelationInfo($$);}
@@ -552,6 +558,11 @@ session_option(X) ::= SESSION LP ids(V) cpxName(Z) COMMA tmvar(Y) RP.    {
    X.col = V;
    X.gap = Y;
 }
+%type windowstate_option {SWindowStateVal}
+windowstate_option(X) ::= .                                                  {X.col.n = 0;}
+windowstate_option(X) ::= STATE_WINDOW LP ids(V) RP.                       {
+   X.col = V;
+}  
 
 %type fill_opt {SArray*}
 %destructor fill_opt {taosArrayDestroy($$);}

src/query/src/qAggMain.c

@@ -19,6 +19,7 @@
 #include "texpr.h"
 #include "ttype.h"
 #include "tsdb.h"
+#include "tglobal.h"
 
 #include "qAggMain.h"
 #include "qFill.h"
@@ -166,7 +167,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
                           int16_t *bytes, int32_t *interBytes, int16_t extLength, bool isSuperTable) {
   if (!isValidDataType(dataType)) {
     qError("Illegal data type %d or data type length %d", dataType, dataBytes);
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
   
   if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TS_DUMMY || functionId == TSDB_FUNC_TAG_DUMMY ||
@@ -353,7 +354,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
     *interBytes = (*bytes);
 
   } else {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
   
   return TSDB_CODE_SUCCESS;
@@ -2489,7 +2490,6 @@ static void buildTopBotStruct(STopBotInfo *pTopBotInfo, SQLFunctionCtx *pCtx) {
   tmp += POINTER_BYTES * pCtx->param[0].i64;
   
   size_t size = sizeof(tValuePair) + pCtx->tagInfo.tagsLen;
-//  assert(pCtx->param[0].i64 > 0);
 
   for (int32_t i = 0; i < pCtx->param[0].i64; ++i) {
     pTopBotInfo->res[i] = (tValuePair*) tmp;
@@ -2498,7 +2498,6 @@ static void buildTopBotStruct(STopBotInfo *pTopBotInfo, SQLFunctionCtx *pCtx) {
   }
 }
 
-
 bool topbot_datablock_filter(SQLFunctionCtx *pCtx, const char *minval, const char *maxval) {
   SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
   if (pResInfo == NULL) {
@@ -2578,13 +2577,14 @@ static void top_function(SQLFunctionCtx *pCtx) {
   
   for (int32_t i = 0; i < pCtx->size; ++i) {
     char *data = GET_INPUT_DATA(pCtx, i);
-    TSKEY ts = GET_TS_DATA(pCtx, i);
-
     if (pCtx->hasNull && isNull(data, pCtx->inputType)) {
       continue;
     }
     
     notNullElems++;
+
+    // NOTE: Set the default timestamp if it is missing [todo refactor]
+    TSKEY ts = (pCtx->ptsList != NULL)? GET_TS_DATA(pCtx, i):0;
     do_top_function_add(pRes, (int32_t)pCtx->param[0].i64, data, ts, pCtx->inputType, &pCtx->tagInfo, NULL, 0);
   }
   
@@ -2657,13 +2657,13 @@ static void bottom_function(SQLFunctionCtx *pCtx) {
 
   for (int32_t i = 0; i < pCtx->size; ++i) {
     char *data = GET_INPUT_DATA(pCtx, i);
-    TSKEY ts = GET_TS_DATA(pCtx, i);
-
     if (pCtx->hasNull && isNull(data, pCtx->inputType)) {
       continue;
     }
 
     notNullElems++;
+    // NOTE: Set the default timestamp if it is missing [todo refactor]
+    TSKEY ts = (pCtx->ptsList != NULL)? GET_TS_DATA(pCtx, i):0;
     do_bottom_function_add(pRes, (int32_t)pCtx->param[0].i64, data, ts, pCtx->inputType, &pCtx->tagInfo, NULL, 0);
   }
   
@@ -2741,7 +2741,7 @@ static void top_bottom_func_finalizer(SQLFunctionCtx *pCtx) {
   if (pCtx->param[1].i64 == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
     __compar_fn_t comparator = (pCtx->param[2].i64 == TSDB_ORDER_ASC) ? resAscComparFn : resDescComparFn;
     qsort(tvp, (size_t)pResInfo->numOfRes, POINTER_BYTES, comparator);
-  } else if (pCtx->param[1].i64 > PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+  } else /*if (pCtx->param[1].i64 > PRIMARYKEY_TIMESTAMP_COL_INDEX)*/ {
     __compar_fn_t comparator = (pCtx->param[2].i64 == TSDB_ORDER_ASC) ? resDataAscComparFn : resDataDescComparFn;
     qsort(tvp, (size_t)pResInfo->numOfRes, POINTER_BYTES, comparator);
   }
@@ -3298,8 +3298,12 @@ static void col_project_function(SQLFunctionCtx *pCtx) {
   if (pCtx->numOfParams == 2) {
     return;
   }
-
+  if (pCtx->param[0].i64 == 1) {
+    SET_VAL(pCtx, pCtx->size, 1);
+  } else {
     INC_INIT_VAL(pCtx, pCtx->size);
+  }
+
 
   char *pData = GET_INPUT_DATA_LIST(pCtx);
   if (pCtx->order == TSDB_ORDER_ASC) {
@@ -3700,7 +3704,7 @@ char *getArithColumnData(void *param, const char* name, int32_t colId) {
     }
   }
   
-  assert(index >= 0 /*&& colId >= 0*/);
+  assert(index >= 0);
   return pSupport->data[index] + pSupport->offset * pSupport->colList[index].bytes;
 }
 
@@ -4828,51 +4832,81 @@ void blockInfo_func(SQLFunctionCtx* pCtx) {
   pResInfo->hasResult = DATA_SET_FLAG;
 }
 
-static void mergeTableBlockDist(STableBlockDist* pDist, const STableBlockDist* pSrc) {
+static void mergeTableBlockDist(SResultRowCellInfo* pResInfo, const STableBlockDist* pSrc) {
+  STableBlockDist* pDist = (STableBlockDist*) GET_ROWCELL_INTERBUF(pResInfo);
   assert(pDist != NULL && pSrc != NULL);
+
   pDist->numOfTables += pSrc->numOfTables;
   pDist->numOfRowsInMemTable += pSrc->numOfRowsInMemTable;
   pDist->numOfFiles += pSrc->numOfFiles;
   pDist->totalSize += pSrc->totalSize;
+  pDist->totalRows += pSrc->totalRows;
 
-  if (pDist->dataBlockInfos == NULL) {
+  if (pResInfo->hasResult == DATA_SET_FLAG) {
-    pDist->dataBlockInfos = taosArrayInit(4, sizeof(SFileBlockInfo));
+    pDist->maxRows = MAX(pDist->maxRows, pSrc->maxRows);
+    pDist->minRows = MIN(pDist->minRows, pSrc->minRows);
+  } else {
+    pDist->maxRows = pSrc->maxRows;
+    pDist->minRows = pSrc->minRows;
+    
+    int32_t numSteps = tsMaxRowsInFileBlock/TSDB_BLOCK_DIST_STEP_ROWS;
+    pDist->dataBlockInfos = taosArrayInit(numSteps, sizeof(SFileBlockInfo));
+    taosArraySetSize(pDist->dataBlockInfos, numSteps);
   }
 
-  taosArrayPushBatch(pDist->dataBlockInfos, pSrc->dataBlockInfos->pData, (int32_t) taosArrayGetSize(pSrc->dataBlockInfos));
+  size_t steps = taosArrayGetSize(pDist->dataBlockInfos);
+  for (int32_t i = 0; i < steps; ++i) {
+    int32_t srcNumBlocks = ((SFileBlockInfo*)taosArrayGet(pSrc->dataBlockInfos, i))->numBlocksOfStep;
+    SFileBlockInfo* blockInfo = (SFileBlockInfo*)taosArrayGet(pDist->dataBlockInfos, i);
+    blockInfo->numBlocksOfStep += srcNumBlocks;
+  }
 }
 
 void block_func_merge(SQLFunctionCtx* pCtx) {
-  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
-
-  STableBlockDist* pDist = (STableBlockDist*) GET_ROWCELL_INTERBUF(pResInfo);
   STableBlockDist info = {0};
-
   int32_t len = *(int32_t*) pCtx->pInput;
   blockDistInfoFromBinary(((char*)pCtx->pInput) + sizeof(int32_t), len, &info);
 
-  mergeTableBlockDist(pDist, &info);
+  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
+  mergeTableBlockDist(pResInfo, &info);
+
+  pResInfo->numOfRes = 1;
+  pResInfo->hasResult = DATA_SET_FLAG;
 }
 
-static int32_t doGetPercentile(const SArray* pArray, double rate) {
+void getPercentiles(STableBlockDist *pTableBlockDist, int64_t totalBlocks, int32_t numOfPercents,
-  int32_t len = (int32_t)taosArrayGetSize(pArray);
+                    double* percents, int32_t* percentiles) {
-  if (len <= 0) {
+  if (totalBlocks == 0) {
-    return 0;
+    for (int32_t i = 0; i < numOfPercents; ++i) {
+      percentiles[i] = 0;
+    }
+    return;
   }
 
-  assert(rate >= 0 && rate <= 1.0);
+  SArray *blocksInfos = pTableBlockDist->dataBlockInfos;
-  int idx = (int32_t)((len - 1) * rate);
+  size_t  numSteps = taosArrayGetSize(blocksInfos);
+  size_t  cumulativeBlocks = 0;
 
-  return ((SFileBlockInfo *)(taosArrayGet(pArray, idx)))->numOfRows;
+  int percentIndex = 0;
-}
+  for (int32_t indexStep = 0; indexStep < numSteps; ++indexStep) {
+    int32_t numStepBlocks = ((SFileBlockInfo *)taosArrayGet(blocksInfos, indexStep))->numBlocksOfStep;
+    if (numStepBlocks == 0) continue;
+    cumulativeBlocks += numStepBlocks;
 
-static int compareBlockInfo(const void *pLeft, const void *pRight) {
+    while (percentIndex < numOfPercents) {
-  int32_t left  = ((SFileBlockInfo *)pLeft)->numOfRows;
+      double blockRank = totalBlocks * percents[percentIndex];
-  int32_t right = ((SFileBlockInfo *)pRight)->numOfRows;
+      if (blockRank <= cumulativeBlocks) {
+        percentiles[percentIndex] = indexStep;
+        ++percentIndex;
+      } else {
+        break;
+      }
+    }
+  }
 
-  if (left > right) return 1;
+  for (int32_t i = 0; i < numOfPercents; ++i) {
-  if (left < right) return -1;
+    percentiles[i] = (percentiles[i]+1) * TSDB_BLOCK_DIST_STEP_ROWS - TSDB_BLOCK_DIST_STEP_ROWS/2;
-  return 0;
+  }
 }
 
 void generateBlockDistResult(STableBlockDist *pTableBlockDist, char* result) {
@@ -4880,40 +4914,41 @@ void generateBlockDistResult(STableBlockDist *pTableBlockDist, char* result) {
     return;
   }
 
-  int64_t min = INT64_MAX, max = INT64_MIN, avg = 0;
+  SArray* blockInfos = pTableBlockDist->dataBlockInfos;
-  SArray* blockInfos= pTableBlockDist->dataBlockInfos;
+  uint64_t totalRows = pTableBlockDist->totalRows;
-  int64_t totalRows = 0, totalBlocks = taosArrayGetSize(blockInfos);
+  size_t   numSteps = taosArrayGetSize(blockInfos);
+  int64_t totalBlocks = 0;
+  int64_t min = -1, max = -1, avg = 0;
 
-  for (size_t i = 0; i < taosArrayGetSize(blockInfos); i++) {
+  for (int32_t i = 0; i < numSteps; i++) {
     SFileBlockInfo *blockInfo = taosArrayGet(blockInfos, i);
-    int64_t rows = blockInfo->numOfRows;
+    int64_t blocks = blockInfo->numBlocksOfStep;
-
+    totalBlocks += blocks;
-    min = MIN(min, rows);
-    max = MAX(max, rows);
-    totalRows += rows;
   }
 
   avg = totalBlocks > 0 ? (int64_t)(totalRows/totalBlocks) : 0;
-  taosArraySort(blockInfos, compareBlockInfo);
+  min = totalBlocks > 0 ? pTableBlockDist->minRows : 0;
+  max = totalBlocks > 0 ? pTableBlockDist->maxRows : 0;
+
+  double percents[] = {0.05, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 0.95, 0.99};
+  int32_t percentiles[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+  assert(sizeof(percents)/sizeof(double) == sizeof(percentiles)/sizeof(int32_t));
+  getPercentiles(pTableBlockDist, totalBlocks, sizeof(percents)/sizeof(double), percents, percentiles);
 
   uint64_t totalLen = pTableBlockDist->totalSize;
   int32_t rowSize = pTableBlockDist->rowSize;
-
+  double compRatio = (totalRows>0) ? ((double)(totalLen)/(rowSize*totalRows)) : 1;
   int sz = sprintf(result + VARSTR_HEADER_SIZE,
                    "summary: \n\t "
                    "5th=[%d], 10th=[%d], 20th=[%d], 30th=[%d], 40th=[%d], 50th=[%d]\n\t "
                    "60th=[%d], 70th=[%d], 80th=[%d], 90th=[%d], 95th=[%d], 99th=[%d]\n\t "
                    "Min=[%"PRId64"(Rows)] Max=[%"PRId64"(Rows)] Avg=[%"PRId64"(Rows)] Stddev=[%.2f] \n\t "
-                   "Rows=[%"PRId64"], Blocks=[%"PRId64"], Size=[%.3f(Kb)] Comp=[%.2f%%]\n\t "
+                   "Rows=[%"PRIu64"], Blocks=[%"PRId64"], Size=[%.3f(Kb)] Comp=[%.2f]\n\t "
                    "RowsInMem=[%d] \n\t SeekHeaderTime=[%d(us)]",
-                   doGetPercentile(blockInfos, 0.05), doGetPercentile(blockInfos, 0.10),
+                   percentiles[0], percentiles[1], percentiles[2], percentiles[3], percentiles[4], percentiles[5],
-                   doGetPercentile(blockInfos, 0.20), doGetPercentile(blockInfos, 0.30),
+                   percentiles[6], percentiles[7], percentiles[8], percentiles[9], percentiles[10], percentiles[11],
-                   doGetPercentile(blockInfos, 0.40), doGetPercentile(blockInfos, 0.50),
-                   doGetPercentile(blockInfos, 0.60), doGetPercentile(blockInfos, 0.70),
-                   doGetPercentile(blockInfos, 0.80), doGetPercentile(blockInfos, 0.90),
-                   doGetPercentile(blockInfos, 0.95), doGetPercentile(blockInfos, 0.99),
                    min, max, avg, 0.0,
-                   totalRows, totalBlocks, totalLen/1024.0, (double)(totalLen*100.0)/(rowSize*totalRows),
+                   totalRows, totalBlocks, totalLen/1024.0, compRatio,
                    pTableBlockDist->numOfRowsInMemTable, pTableBlockDist->firstSeekTimeUs);
   varDataSetLen(result, sz);
   UNUSED(sz);

src/query/src/qFill.c

@@ -363,10 +363,6 @@ SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int3
   pFillInfo->rowSize = setTagColumnInfo(pFillInfo, pFillInfo->numOfCols, pFillInfo->alloc);
   assert(pFillInfo->rowSize > 0);
 
-  for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
-    pFillInfo->pData[i] = malloc(pFillInfo->pFillCol[i].col.bytes * pFillInfo->alloc);
-  }
-
   return pFillInfo;
 }
 
@@ -392,10 +388,6 @@ void* taosDestroyFillInfo(SFillInfo* pFillInfo) {
     tfree(pFillInfo->pTags[i].tagVal);
   }
 
-  for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
-    tfree(pFillInfo->pData[i]);
-  }
-
   tfree(pFillInfo->pTags);
   
   tfree(pFillInfo->pData);
@@ -417,17 +409,6 @@ void taosFillSetStartInfo(SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey)
 
   pFillInfo->index     = 0;
   pFillInfo->numOfRows = numOfRows;
-  
-  // ensure the space
-  if (pFillInfo->alloc < numOfRows) {
-    for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
-      char* tmp = realloc(pFillInfo->pData[i], numOfRows*pFillInfo->pFillCol[i].col.bytes);
-      assert(tmp != NULL); // todo handle error
-      
-      memset(tmp, 0, numOfRows*pFillInfo->pFillCol[i].col.bytes);
-      pFillInfo->pData[i] = tmp;
-    }
-  }
 }
 
 void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput) {
@@ -435,16 +416,7 @@ void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput)
     SFillColInfo* pCol = &pFillInfo->pFillCol[i];
 
     SColumnInfoData* pColData = taosArrayGet(pInput->pDataBlock, i);
-//    pFillInfo->pData[i] = pColData->pData;
+    pFillInfo->pData[i] = pColData->pData;
-    if (pInput->info.rows > pFillInfo->alloc) {
-      char* t = realloc(pFillInfo->pData[i], pColData->info.bytes * pInput->info.rows);
-      assert(t != NULL);
-
-      pFillInfo->pData[i] = t;
-      pFillInfo->alloc = pInput->info.rows;
-    }
-
-    memcpy(pFillInfo->pData[i], pColData->pData, pColData->info.bytes * pInput->info.rows);
 
     if (TSDB_COL_IS_TAG(pCol->flag)/* || IS_VAR_DATA_TYPE(pCol->col.type)*/) {  // copy the tag value to tag value buffer
       SFillTagColInfo* pTag = &pFillInfo->pTags[pCol->tagIndex];
@@ -454,31 +426,6 @@ void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput)
   }
 }
 
-void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, const tFilePage* pInput) {
-  assert(pFillInfo->numOfRows == pInput->num);
-
-  for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
-    SFillColInfo* pCol = &pFillInfo->pFillCol[i];
-
-    const char* data = pInput->data + pCol->col.offset * pInput->num;
-    if (pInput->num > pFillInfo->alloc) {
-      char* t = realloc(pFillInfo->pData[i], (size_t)(pCol->col.bytes * pInput->num));
-      assert(t != NULL);
-
-      pFillInfo->pData[i] = t;
-      pFillInfo->alloc = (int32_t)pInput->num;
-    }
-
-    memcpy(pFillInfo->pData[i], data, (size_t)(pCol->col.bytes * pInput->num));
-
-    if (TSDB_COL_IS_TAG(pCol->flag)/* || IS_VAR_DATA_TYPE(pCol->col.type)*/) {  // copy the tag value to tag value buffer
-      SFillTagColInfo* pTag = &pFillInfo->pTags[pCol->tagIndex];
-      assert (pTag->col.colId == pCol->col.colId);
-      memcpy(pTag->tagVal, data, pCol->col.bytes);  // TODO not memcpy??
-    }
-  }
-}
-
 bool taosFillHasMoreResults(SFillInfo* pFillInfo) {
   int32_t remain = taosNumOfRemainRows(pFillInfo);
   if (remain > 0) {

src/query/src/qPlan.c

@@ -1,42 +1,521 @@
 #include "os.h"
-#include "tsclient.h"
+#include "qTableMeta.h"
+#include "qPlan.h"
+#include "qExecutor.h"
 #include "qUtil.h"
 #include "texpr.h"
+#include "tscUtil.h"
+#include "tsclient.h"
 
-#define QNODE_PROJECT    1
+#define QNODE_TAGSCAN       1
-#define QNODE_FILTER     2
+#define QNODE_TABLESCAN     2
-#define QNODE_RELATION   3
+#define QNODE_PROJECT       3
 #define QNODE_AGGREGATE     4
 #define QNODE_GROUPBY       5
 #define QNODE_LIMIT         6
 #define QNODE_JOIN          7
-#define QNODE_DIST       8
+#define QNODE_DISTINCT      8
 #define QNODE_SORT          9
 #define QNODE_UNIONALL      10
 #define QNODE_TIMEWINDOW    11
+#define QNODE_SESSIONWINDOW 12
+#define QNODE_FILL          13
 
-typedef struct SQueryNode {
+typedef struct SFillEssInfo {
-  int32_t    type;         // the type of logic node
+  int32_t  fillType;  // fill type
-  char      *name;         // the name of logic node
+  int64_t *val;       // fill value
+} SFillEssInfo;
 
-  SSchema   *pSchema;      // the schema of the input SSDatablock
+typedef struct SJoinCond {
-  int32_t    numOfCols;    // number of input columns
+  bool     tagExists; // denote if tag condition exists or not
-  SExprInfo *pExpr;        // the query functions or sql aggregations
+  SColumn *tagCond[2];
-  int32_t    numOfOutput;  // number of result columns, which is also the number of pExprs
+  SColumn *colCond[2];
+} SJoinCond;
 
-  // previous operator to generated result for current node to process
+static SQueryNode* createQueryNode(int32_t type, const char* name, SQueryNode** prev,
-  // in case of join, multiple prev nodes exist.
+                                   int32_t numOfPrev, SExprInfo** pExpr, int32_t numOfOutput, SQueryTableInfo* pTableInfo,
-  struct SQueryNode* prevNode;
+                                   void* pExtInfo) {
-  struct SQueryNode* nextNode;
+  SQueryNode* pNode = calloc(1, sizeof(SQueryNode));
-} SQueryNode;
+
+  pNode->info.type = type;
+  pNode->info.name = strdup(name);
+
+  if (pTableInfo->id.uid != 0) { // it is a true table
+    pNode->tableInfo.id = pTableInfo->id;
+    pNode->tableInfo.tableName = strdup(pTableInfo->tableName);
+  }
+
+  pNode->numOfOutput = numOfOutput;
+  pNode->pExpr = calloc(numOfOutput, sizeof(SExprInfo));
+  for(int32_t i = 0; i < numOfOutput; ++i) {
+    tscExprAssign(&pNode->pExpr[i], pExpr[i]);
+  }
+
+  pNode->pPrevNodes = taosArrayInit(4, POINTER_BYTES);
+  for(int32_t i = 0; i < numOfPrev; ++i) {
+    taosArrayPush(pNode->pPrevNodes, &prev[i]);
+  }
+
+  switch(type) {
+    case QNODE_TABLESCAN: {
+      STimeWindow* window = calloc(1, sizeof(STimeWindow));
+      memcpy(window, pExtInfo, sizeof(STimeWindow));
+      pNode->pExtInfo = window;
+      break;
+    }
+
+    case QNODE_TIMEWINDOW: {
+      SInterval* pInterval = calloc(1, sizeof(SInterval));
+      pNode->pExtInfo = pInterval;
+      memcpy(pInterval, pExtInfo, sizeof(SInterval));
+      break;
+    }
+
+    case QNODE_GROUPBY: {
+      SGroupbyExpr* p = (SGroupbyExpr*) pExtInfo;
+      SGroupbyExpr* pGroupbyExpr = calloc(1, sizeof(SGroupbyExpr));
+
+      pGroupbyExpr->tableIndex = p->tableIndex;
+      pGroupbyExpr->orderType  = p->orderType;
+      pGroupbyExpr->orderIndex = p->orderIndex;
+      pGroupbyExpr->numOfGroupCols = p->numOfGroupCols;
+      pGroupbyExpr->columnInfo = taosArrayDup(p->columnInfo);
+      pNode->pExtInfo = pGroupbyExpr;
+      break;
+    }
+
+    case QNODE_FILL: { // todo !!
+      pNode->pExtInfo = pExtInfo;
+      break;
+    }
+
+    case QNODE_LIMIT: {
+      pNode->pExtInfo = calloc(1, sizeof(SLimitVal));
+      memcpy(pNode->pExtInfo, pExtInfo, sizeof(SLimitVal));
+      break;
+    }
+  }
+  return pNode;
+}
+
+static SQueryNode* doAddTableColumnNode(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SQueryTableInfo* info,
+                                        SArray* pExprs, SArray* tableCols) {
+  if (pQueryInfo->onlyTagQuery) {
+    int32_t     num = (int32_t) taosArrayGetSize(pExprs);
+    SQueryNode* pNode = createQueryNode(QNODE_TAGSCAN, "TableTagScan", NULL, 0, pExprs->pData, num, info, NULL);
+
+    if (pQueryInfo->distinctTag) {
+      pNode = createQueryNode(QNODE_DISTINCT, "Distinct", &pNode, 1, pExprs->pData, num, info, NULL);
+    }
+
+    return pNode;
+  }
+
+  STimeWindow* window = &pQueryInfo->window;
+  SQueryNode*  pNode = createQueryNode(QNODE_TABLESCAN, "TableScan", NULL, 0, NULL, 0,
+      info, window);
+  if (pQueryInfo->projectionQuery) {
+    int32_t numOfOutput = (int32_t) taosArrayGetSize(pExprs);
+    pNode = createQueryNode(QNODE_PROJECT, "Projection", &pNode, 1, pExprs->pData, numOfOutput, info, NULL);
+  } else {
+    // table source column projection, generate the projection expr
+    int32_t     numOfCols = (int32_t) taosArrayGetSize(tableCols);
+    SExprInfo** pExpr = calloc(numOfCols, POINTER_BYTES);
+    SSchema*    pSchema = pTableMetaInfo->pTableMeta->schema;
+
+    for (int32_t i = 0; i < numOfCols; ++i) {
+      SColumn* pCol = taosArrayGetP(tableCols, i);
+
+      SColumnIndex index = {.tableIndex = 0, .columnIndex = pCol->columnIndex};
+      SExprInfo*   p = tscExprCreate(pQueryInfo, TSDB_FUNC_PRJ, &index, pCol->info.type, pCol->info.bytes,
+                                     pCol->info.colId, 0, TSDB_COL_NORMAL);
+      strncpy(p->base.aliasName, pSchema[pCol->columnIndex].name, tListLen(p->base.aliasName));
+
+      pExpr[i] = p;
+    }
+
+    pNode = createQueryNode(QNODE_PROJECT, "Projection", &pNode, 1, pExpr, numOfCols, info, NULL);
+    for (int32_t i = 0; i < numOfCols; ++i) {
+      destroyQueryFuncExpr(pExpr[i], 1);
+    }
+    tfree(pExpr);
+  }
+
+  return pNode;
+}
+
+static SQueryNode* doCreateQueryPlanForOneTableImpl(SQueryInfo* pQueryInfo, SQueryNode* pNode, SQueryTableInfo* info,
+    SArray* pExprs) {
+    // check for aggregation
+    if (pQueryInfo->interval.interval > 0) {
+      int32_t numOfOutput = (int32_t) taosArrayGetSize(pExprs);
+
+      pNode = createQueryNode(QNODE_TIMEWINDOW, "TimeWindowAgg", &pNode, 1, pExprs->pData, numOfOutput, info,
+                              &pQueryInfo->interval);
+    } else if (pQueryInfo->groupbyColumn) {
+      int32_t numOfOutput = (int32_t) taosArrayGetSize(pExprs);
+      pNode = createQueryNode(QNODE_GROUPBY, "Groupby", &pNode, 1, pExprs->pData, numOfOutput, info,
+                              &pQueryInfo->groupbyExpr);
+    } else if (pQueryInfo->sessionWindow.gap > 0) {
+      pNode = createQueryNode(QNODE_SESSIONWINDOW, "SessionWindowAgg", &pNode, 1, NULL, 0, info, NULL);
+    } else if (pQueryInfo->simpleAgg) {
+      int32_t numOfOutput = (int32_t) taosArrayGetSize(pExprs);
+      pNode = createQueryNode(QNODE_AGGREGATE, "Aggregate", &pNode, 1, pExprs->pData, numOfOutput, info, NULL);
+    }
+
+    if (pQueryInfo->havingFieldNum > 0 || pQueryInfo->arithmeticOnAgg) {
+      int32_t numOfExpr = (int32_t) taosArrayGetSize(pQueryInfo->exprList1);
+      pNode =
+          createQueryNode(QNODE_PROJECT, "Projection", &pNode, 1, pQueryInfo->exprList1->pData, numOfExpr, info, NULL);
+    }
+
+    if (pQueryInfo->fillType != TSDB_FILL_NONE) {
+      SFillEssInfo* pInfo = calloc(1, sizeof(SFillEssInfo));
+      pInfo->fillType = pQueryInfo->fillType;
+      pInfo->val = calloc(pNode->numOfOutput, sizeof(int64_t));
+      memcpy(pInfo->val, pQueryInfo->fillVal, pNode->numOfOutput);
+
+      pNode = createQueryNode(QNODE_FILL, "Fill", &pNode, 1, NULL, 0, info, pInfo);
+    }
+
+
+  if (pQueryInfo->limit.limit != -1 || pQueryInfo->limit.offset != 0) {
+    pNode = createQueryNode(QNODE_LIMIT, "Limit", &pNode, 1, NULL, 0, info, &pQueryInfo->limit);
+  }
+
+  return pNode;
+}
+
+static SQueryNode* doCreateQueryPlanForOneTable(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SArray* pExprs,
+                                                SArray* tableCols) {
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+  tNameExtractFullName(&pTableMetaInfo->name, name);
+
+  SQueryTableInfo info = {.tableName = strdup(name), .id = pTableMetaInfo->pTableMeta->id,};
+
+  // handle the only tag query
+  SQueryNode* pNode = doAddTableColumnNode(pQueryInfo, pTableMetaInfo, &info, pExprs, tableCols);
+  if (pQueryInfo->onlyTagQuery) {
+    tfree(info.tableName);
+    return pNode;
+  }
+
+  SQueryNode* pNode1 = doCreateQueryPlanForOneTableImpl(pQueryInfo, pNode, &info, pExprs);
+  tfree(info.tableName);
+  return pNode1;
+}
+
+SArray* createQueryPlanImpl(SQueryInfo* pQueryInfo) {
+  SArray* upstream = NULL;
+
+  if (pQueryInfo->pUpstream != NULL && taosArrayGetSize(pQueryInfo->pUpstream) > 0) {  // subquery in the from clause
+    upstream = taosArrayInit(4, POINTER_BYTES);
+
+    size_t size = taosArrayGetSize(pQueryInfo->pUpstream);
+    for(int32_t i = 0; i < size; ++i) {
+      SQueryInfo* pq = taosArrayGet(pQueryInfo->pUpstream, i);
+      SArray* p = createQueryPlanImpl(pq);
+      taosArrayAddBatch(upstream, p->pData, (int32_t) taosArrayGetSize(p));
+    }
+  }
+
+  if (pQueryInfo->numOfTables > 1) {  // it is a join query
+    // 1. separate the select clause according to table
+    upstream = taosArrayInit(5, POINTER_BYTES);
+
+    for(int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
+      STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[i];
+      uint64_t        uid = pTableMetaInfo->pTableMeta->id.uid;
+
+      SArray* exprList = taosArrayInit(4, POINTER_BYTES);
+      if (tscExprCopy(exprList, pQueryInfo->exprList, uid, true) != 0) {
+        terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+        exit(-1);
+      }
+
+      // 2. create the query execution node
+      char name[TSDB_TABLE_FNAME_LEN] = {0};
+      tNameExtractFullName(&pTableMetaInfo->name, name);
+      SQueryTableInfo info = {.tableName = strdup(name), .id = pTableMetaInfo->pTableMeta->id,};
+
+      // 3. get the required table column list
+      SArray* tableColumnList = taosArrayInit(4, sizeof(SColumn));
+      tscColumnListCopy(tableColumnList, pQueryInfo->colList, uid);
+
+      // 4. add the projection query node
+      SQueryNode* pNode = doAddTableColumnNode(pQueryInfo, pTableMetaInfo, &info, exprList, tableColumnList);
+      taosArrayPush(upstream, &pNode);
+    }
+
+    // 3. add the join node here
+    SQueryTableInfo info = {0};
+    int32_t num = (int32_t) taosArrayGetSize(pQueryInfo->exprList);
+    SQueryNode* pNode = createQueryNode(QNODE_JOIN, "Join", upstream->pData, pQueryInfo->numOfTables,
+        pQueryInfo->exprList->pData, num, &info, NULL);
+
+    // 4. add the aggregation or projection execution node
+    pNode = doCreateQueryPlanForOneTableImpl(pQueryInfo, pNode, &info, pQueryInfo->exprList);
+    upstream = taosArrayInit(5, POINTER_BYTES);
+    taosArrayPush(upstream, &pNode);
+  } else { // only one table, normal query process
+    STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
+    SQueryNode* pNode = doCreateQueryPlanForOneTable(pQueryInfo, pTableMetaInfo, pQueryInfo->exprList, pQueryInfo->colList);
+    upstream = taosArrayInit(5, POINTER_BYTES);
+    taosArrayPush(upstream, &pNode);
+  }
+
+  return upstream;
+}
 
-// TODO create the query plan
 SQueryNode* qCreateQueryPlan(SQueryInfo* pQueryInfo) {
+  SArray* upstream = createQueryPlanImpl(pQueryInfo);
+  assert(taosArrayGetSize(upstream) == 1);
+
+  SQueryNode* p = taosArrayGetP(upstream, 0);
+  taosArrayDestroy(upstream);
+
+  return p;
+}
+
+static void doDestroyQueryNode(SQueryNode* pQueryNode) {
+  tfree(pQueryNode->pExtInfo);
+  tfree(pQueryNode->pSchema);
+  tfree(pQueryNode->info.name);
+
+  tfree(pQueryNode->tableInfo.tableName);
+
+  pQueryNode->pExpr = destroyQueryFuncExpr(pQueryNode->pExpr, pQueryNode->numOfOutput);
+
+  if (pQueryNode->pPrevNodes != NULL) {
+    int32_t size = (int32_t) taosArrayGetSize(pQueryNode->pPrevNodes);
+    for(int32_t i = 0; i < size; ++i) {
+      SQueryNode* p = taosArrayGetP(pQueryNode->pPrevNodes, i);
+      doDestroyQueryNode(p);
+    }
+
+    taosArrayDestroy(pQueryNode->pPrevNodes);
+  }
+
+  tfree(pQueryNode);
+}
+
+void* qDestroyQueryPlan(SQueryNode* pQueryNode) {
+  if (pQueryNode == NULL) {
+    return NULL;
+  }
+
+  doDestroyQueryNode(pQueryNode);
   return NULL;
 }
 
-char* queryPlanToString() {
+bool hasAliasName(SExprInfo* pExpr) {
-  return NULL;
+  assert(pExpr != NULL);
+  return strncmp(pExpr->base.token, pExpr->base.aliasName, tListLen(pExpr->base.aliasName)) != 0;
+}
+
+static int32_t doPrintPlan(char* buf, SQueryNode* pQueryNode, int32_t level, int32_t totalLen) {
+  if (level > 0) {
+    sprintf(buf + totalLen, "%*c", level, ' ');
+    totalLen += level;
+  }
+
+  int32_t len1 = sprintf(buf + totalLen, "%s(", pQueryNode->info.name);
+  int32_t len = len1 + totalLen;
+
+  switch(pQueryNode->info.type) {
+    case QNODE_TABLESCAN: {
+      STimeWindow* win = (STimeWindow*)pQueryNode->pExtInfo;
+      len1 = sprintf(buf + len, "%s #0x%" PRIx64 ") time_range: %" PRId64 " - %" PRId64 "\n",
+                     pQueryNode->tableInfo.tableName, pQueryNode->tableInfo.id.uid, win->skey, win->ekey);
+      len += len1;
+      break;
+    }
+
+    case QNODE_PROJECT: {
+      len1 = sprintf(buf + len, "cols: ");
+      len += len1;
+
+      for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+        SSqlExpr* p = &pQueryNode->pExpr[i].base;
+        len1 = sprintf(buf + len, "[%s #%d]", p->aliasName, p->resColId);
+        len += len1;
+
+        if (i < pQueryNode->numOfOutput - 1) {
+          len1 = sprintf(buf + len, ", ");
+          len += len1;
+        }
+      }
+
+      len1 = sprintf(buf + len, ")");
+      len += len1;
+
+      //todo print filter info
+      len1 = sprintf(buf + len, " filters:(nil)\n");
+      len += len1;
+      break;
+    }
+
+    case QNODE_AGGREGATE: {
+      for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+        SSqlExpr* pExpr = &pQueryNode->pExpr[i].base;
+        if (hasAliasName(&pQueryNode->pExpr[i])) {
+          len1 = sprintf(buf + len,"[%s #%s]", pExpr->token, pExpr->aliasName);
+        } else {
+          len1 = sprintf(buf + len,"[%s]", pExpr->token);
+        }
+
+        len += len1;
+        if (i < pQueryNode->numOfOutput - 1) {
+          len1 = sprintf(buf + len, ", ");
+          len += len1;
+        }
+      }
+
+      len1 = sprintf(buf + len, ")\n");
+      len += len1;
+      break;
+    }
+
+    case QNODE_TIMEWINDOW: {
+      for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+        SSqlExpr* pExpr = &pQueryNode->pExpr[i].base;
+        if (hasAliasName(&pQueryNode->pExpr[i])) {
+          len1 = sprintf(buf + len,"[%s #%s]", pExpr->token, pExpr->aliasName);
+        } else {
+          len1 = sprintf(buf + len,"[%s]", pExpr->token);
+        }
+
+        len += len1;
+        if (i < pQueryNode->numOfOutput - 1) {
+          len1 = sprintf(buf + len,", ");
+          len += len1;
+        }
+      }
+
+      len1 = sprintf(buf + len,") ");
+      len += len1;
+
+      SInterval* pInterval = pQueryNode->pExtInfo;
+      len1 = sprintf(buf + len, "interval:%" PRId64 "(%c), sliding:%" PRId64 "(%c), offset:%" PRId64 "\n",
+                     pInterval->interval, pInterval->intervalUnit, pInterval->sliding, pInterval->slidingUnit,
+                     pInterval->offset);
+      len += len1;
+
+      break;
+    }
+
+    case QNODE_GROUPBY: {  // todo hide the invisible column
+      for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+        SSqlExpr* pExpr = &pQueryNode->pExpr[i].base;
+
+        if (hasAliasName(&pQueryNode->pExpr[i])) {
+          len1 = sprintf(buf + len,"[%s #%s]", pExpr->token, pExpr->aliasName);
+        } else {
+          len1 = sprintf(buf + len,"[%s]", pExpr->token);
+        }
+
+        len += len1;
+        if (i < pQueryNode->numOfOutput - 1) {
+          len1 = sprintf(buf + len,", ");
+          len += len1;
+        }
+      }
+
+      SGroupbyExpr* pGroupbyExpr = pQueryNode->pExtInfo;
+      SColIndex* pIndex = taosArrayGet(pGroupbyExpr->columnInfo, 0);
+
+      len1 = sprintf(buf + len,") groupby_col: [%s #%d]\n", pIndex->name, pIndex->colId);
+      len += len1;
+
+      break;
+    }
+
+    case QNODE_FILL: {
+      SFillEssInfo* pEssInfo = pQueryNode->pExtInfo;
+      len1 = sprintf(buf + len,"%d", pEssInfo->fillType);
+      len += len1;
+
+      if (pEssInfo->fillType == TSDB_FILL_SET_VALUE) {
+        len1 = sprintf(buf + len,", val:");
+        len += len1;
+
+        // todo get the correct fill data type
+        for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+          len1 = sprintf(buf + len,"%"PRId64, pEssInfo->val[i]);
+          len += len1;
+
+          if (i < pQueryNode->numOfOutput - 1) {
+            len1 = sprintf(buf + len,", ");
+            len += len1;
+          }
+        }
+      }
+
+      len1 = sprintf(buf + len,")\n");
+      len += len1;
+      break;
+    }
+
+    case QNODE_LIMIT: {
+      SLimitVal* pVal = pQueryNode->pExtInfo;
+      len1 = sprintf(buf + len,"limit: %"PRId64", offset: %"PRId64")\n", pVal->limit, pVal->offset);
+      len += len1;
+      break;
+    }
+
+    case QNODE_DISTINCT:
+    case QNODE_TAGSCAN: {
+      len1 = sprintf(buf + len,"cols: ");
+      len += len1;
+
+      for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+        SSqlExpr* p = &pQueryNode->pExpr[i].base;
+        len1 = sprintf(buf + len,"[%s #%d]", p->aliasName, p->resColId);
+        len += len1;
+
+        if (i < pQueryNode->numOfOutput - 1) {
+          len1 = sprintf(buf + len,", ");
+          len += len1;
+        }
+      }
+
+      len1 = sprintf(buf + len,")\n");
+      len += len1;
+
+      break;
+    }
+
+    case QNODE_JOIN: {
+      //  print join condition
+      len1 = sprintf(buf + len, ")\n");
+      len += len1;
+      break;
+    }
+  }
+
+  return len;
+}
+
+int32_t queryPlanToStringImpl(char* buf, SQueryNode* pQueryNode, int32_t level, int32_t totalLen) {
+  int32_t len = doPrintPlan(buf, pQueryNode, level, totalLen);
+
+  for(int32_t i = 0; i < taosArrayGetSize(pQueryNode->pPrevNodes); ++i) {
+    SQueryNode* p1 = taosArrayGetP(pQueryNode->pPrevNodes, i);
+    int32_t len1 = queryPlanToStringImpl(buf, p1, level + 1, len);
+    len = len1;
+  }
+
+  return len;
+}
+
+char* queryPlanToString(SQueryNode* pQueryNode) {
+  assert(pQueryNode);
+
+  char* buf = calloc(1, 4096);
+
+  int32_t len = sprintf(buf, "===== logic plan =====\n");
+  queryPlanToStringImpl(buf, pQueryNode, 0, len);
+  return buf;
 }
 
 SQueryNode* queryPlanFromString() {
@@ -113,6 +592,14 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
     op = OP_SessionWindow;
     taosArrayPush(plan, &op);
 
+    if (pQueryAttr->pExpr2 != NULL) {
+      op = OP_Arithmetic;
+      taosArrayPush(plan, &op);
+    }
+  } else if (pQueryAttr->stateWindow) {
+    op =  OP_StateWindow;
+    taosArrayPush(plan, &op);
+
     if (pQueryAttr->pExpr2 != NULL) {
       op = OP_Arithmetic;
       taosArrayPush(plan, &op);
@@ -136,9 +623,14 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
       taosArrayPush(plan, &op);
     }
   } else {  // diff/add/multiply/subtract/division
+    if (pQueryAttr->numOfFilterCols > 0 && pQueryAttr->vgId == 0) { // todo refactor
+      op = OP_Filter;
+      taosArrayPush(plan, &op);
+    } else {
       op = OP_Arithmetic;
       taosArrayPush(plan, &op);
     }
+  }
 
   if (pQueryAttr->limit.limit > 0 || pQueryAttr->limit.offset > 0) {
     op = OP_Limit;

src/query/src/qSqlParser.c

@@ -229,7 +229,6 @@ tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType) {
         pExpr->flags &= ~(1 << EXPR_FLAG_TS_ERROR);
       }
 
-
       switch (optrType) {
         case TK_PLUS: {
           pExpr->value.i64 = pLeft->value.i64 + pRight->value.i64;
@@ -325,7 +324,6 @@ static FORCE_INLINE int32_t tStrTokenCompare(SStrToken* left, SStrToken* right)
   return (left->type == right->type && left->n == right->n && strncasecmp(left->z, right->z, left->n) == 0) ? 0 : 1;
 }
 
-
 int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right) {
   if ((left == NULL && right) || (left && right == NULL)) {
     return 1;
@@ -389,8 +387,6 @@ int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right) {
   return 0;
 }
 
-
-
 tSqlExpr *tSqlExprClone(tSqlExpr *pSrc) {
   tSqlExpr *pExpr = calloc(1, sizeof(tSqlExpr));
 
@@ -536,11 +532,11 @@ SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int
 SRelationInfo *setTableNameList(SRelationInfo* pRelationInfo, SStrToken *pName, SStrToken* pAlias) {
   if (pRelationInfo == NULL) {
     pRelationInfo = calloc(1, sizeof(SRelationInfo));
-    pRelationInfo->list = taosArrayInit(4, sizeof(STableNamePair));
+    pRelationInfo->list = taosArrayInit(4, sizeof(SRelElementPair));
   }
 
   pRelationInfo->type = SQL_NODE_FROM_TABLELIST;
-  STableNamePair p = {.name = *pName};
+  SRelElementPair p = {.tableName = *pName};
   if (pAlias != NULL) {
     p.aliasName = *pAlias;
   } else {
@@ -551,18 +547,6 @@ SRelationInfo *setTableNameList(SRelationInfo* pRelationInfo, SStrToken *pName,
   return pRelationInfo;
 }
 
-SRelationInfo* setSubquery(SRelationInfo* pRelationInfo, SArray* pList) {
-  if (pRelationInfo == NULL) {
-    pRelationInfo = calloc(1, sizeof(SRelationInfo));
-    pRelationInfo->list = taosArrayInit(4, POINTER_BYTES);
-  }
-
-  pRelationInfo->type = SQL_NODE_FROM_SUBQUERY;
-  taosArrayPush(pRelationInfo->list, &pList);
-
-  return pRelationInfo;
-}
-
 void* destroyRelationInfo(SRelationInfo* pRelationInfo) {
   if (pRelationInfo == NULL) {
     return NULL;
@@ -573,7 +557,7 @@ void* destroyRelationInfo(SRelationInfo* pRelationInfo) {
   } else {
     size_t size = taosArrayGetSize(pRelationInfo->list);
     for(int32_t i = 0; i < size; ++i) {
-      SArray* pa = taosArrayGetP(pRelationInfo->list, 0);
+      SArray* pa = taosArrayGetP(pRelationInfo->list, i);
       destroyAllSqlNode(pa);
     }
     taosArrayDestroy(pRelationInfo->list);
@@ -583,6 +567,24 @@ void* destroyRelationInfo(SRelationInfo* pRelationInfo) {
   return NULL;
 }
 
+SRelationInfo* addSubqueryElem(SRelationInfo* pRelationInfo, SArray* pSub, SStrToken* pAlias) {
+  if (pRelationInfo == NULL) {
+    pRelationInfo = calloc(1, sizeof(SRelationInfo));
+    pRelationInfo->list = taosArrayInit(4, sizeof(SRelElementPair));
+  }
+
+  pRelationInfo->type = SQL_NODE_FROM_SUBQUERY;
+
+  SRelElementPair p = {.pSubquery = pSub};
+  if (pAlias != NULL) {
+    p.aliasName = *pAlias;
+  } else {
+    TPARSER_SET_NONE_TOKEN(p.aliasName);
+  }
+
+  taosArrayPush(pRelationInfo->list, &p);
+  return pRelationInfo;
+}
 
 void tSetDbName(SStrToken *pCpxName, SStrToken *pDb) {
   pCpxName->type = pDb->type;
@@ -725,7 +727,7 @@ void tSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
  */
 SSqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelNodeList, SRelationInfo *pFrom, tSqlExpr *pWhere,
                                 SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
-                                SSessionWindowVal *pSession, SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit,
+                                SSessionWindowVal *pSession, SWindowStateVal *pWindowStateVal, SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit,
                                 SLimitVal *psLimit, tSqlExpr *pHaving) {
   assert(pSelNodeList != NULL);
 
@@ -777,6 +779,12 @@ SSqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelNodeList, SRelat
     TPARSER_SET_NONE_TOKEN(pSqlNode->sessionVal.col);
   }
 
+  if (pWindowStateVal != NULL) {
+    pSqlNode->windowstateVal = *pWindowStateVal;
+  } else {
+    TPARSER_SET_NONE_TOKEN(pSqlNode->windowstateVal.col);
+  }
+
   return pSqlNode;
 }
 

src/query/src/qTableMeta.c

@@ -1,25 +1,10 @@
-/*
- * 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 "os.h"
 #include "taosmsg.h"
-#include "tschemautil.h"
+#include "qTableMeta.h"
 #include "ttokendef.h"
 #include "taosdef.h"
 #include "tutil.h"
-#include "tsclient.h"
 
 int32_t tscGetNumOfTags(const STableMeta* pTableMeta) {
   assert(pTableMeta != NULL);
@@ -120,58 +105,3 @@ STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg) {
   return pTableMeta;
 }
 
-bool vgroupInfoIdentical(SNewVgroupInfo *pExisted, SVgroupMsg* src) {
-  assert(pExisted != NULL && src != NULL);
-  if (pExisted->numOfEps != src->numOfEps) {
-    return false;
-  }
-
-  for(int32_t i = 0; i < pExisted->numOfEps; ++i) {
-    if (pExisted->ep[i].port != src->epAddr[i].port) {
-      return false;
-    }
-
-    if (strncmp(pExisted->ep[i].fqdn, src->epAddr[i].fqdn, tListLen(pExisted->ep[i].fqdn)) != 0) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-SNewVgroupInfo createNewVgroupInfo(SVgroupMsg *pVgroupMsg) {
-  assert(pVgroupMsg != NULL);
-
-  SNewVgroupInfo info = {0};
-  info.numOfEps = pVgroupMsg->numOfEps;
-  info.vgId     = pVgroupMsg->vgId;
-  info.inUse    = 0;   // 0 is the default value of inUse in case of multiple replica
-
-  assert(info.numOfEps >= 1 && info.vgId >= 1);
-  for(int32_t i = 0; i < pVgroupMsg->numOfEps; ++i) {
-    tstrncpy(info.ep[i].fqdn, pVgroupMsg->epAddr[i].fqdn, TSDB_FQDN_LEN);
-    info.ep[i].port = pVgroupMsg->epAddr[i].port;
-  }
-
-  return info;
-}
-
-// todo refactor
-UNUSED_FUNC static FORCE_INLINE char* skipSegments(char* input, char delim, int32_t num) {
-  for (int32_t i = 0; i < num; ++i) {
-    while (*input != 0 && *input++ != delim) {
-    };
-  }
-  return input;
-}
-
-UNUSED_FUNC static FORCE_INLINE size_t copy(char* dst, const char* src, char delimiter) {
-  size_t len = 0;
-  while (*src != delimiter && *src != 0) {
-    *dst++ = *src++;
-    len++;
-  }
-  
-  return len;
-}
-

src/query/src/qUtil.c

@@ -581,6 +581,9 @@ void blockDistInfoToBinary(STableBlockDist* pDist, struct SBufferWriter* bw) {
   tbufWriteUint32(bw, pDist->numOfTables);
   tbufWriteUint16(bw, pDist->numOfFiles);
   tbufWriteUint64(bw, pDist->totalSize);
+  tbufWriteUint64(bw, pDist->totalRows);
+  tbufWriteInt32(bw, pDist->maxRows);
+  tbufWriteInt32(bw, pDist->minRows);
   tbufWriteUint32(bw, pDist->numOfRowsInMemTable);
   tbufWriteUint64(bw, taosArrayGetSize(pDist->dataBlockInfos));
 
@@ -616,13 +619,16 @@ void blockDistInfoFromBinary(const char* data, int32_t len, STableBlockDist* pDi
   pDist->numOfTables = tbufReadUint32(&br);
   pDist->numOfFiles  = tbufReadUint16(&br);
   pDist->totalSize   = tbufReadUint64(&br);
+  pDist->totalRows   = tbufReadUint64(&br);
+  pDist->maxRows     = tbufReadInt32(&br);
+  pDist->minRows     = tbufReadInt32(&br);
   pDist->numOfRowsInMemTable = tbufReadUint32(&br);
-  int64_t numOfBlocks = tbufReadUint64(&br);
+  int64_t numSteps = tbufReadUint64(&br);
 
   bool comp = tbufReadUint8(&br);
   uint32_t compLen = tbufReadUint32(&br);
 
-  size_t originalLen = (size_t) (numOfBlocks*sizeof(SFileBlockInfo));
+  size_t originalLen = (size_t) (numSteps *sizeof(SFileBlockInfo));
 
   char* outputBuf = NULL;
   if (comp) {
@@ -633,12 +639,12 @@ void blockDistInfoFromBinary(const char* data, int32_t len, STableBlockDist* pDi
 
     int32_t orignalLen = tsDecompressString(compStr, compLen, 1, outputBuf,
                                             (int32_t)originalLen , ONE_STAGE_COMP, NULL, 0);
-    assert(orignalLen == numOfBlocks*sizeof(SFileBlockInfo));
+    assert(orignalLen == numSteps *sizeof(SFileBlockInfo));
   } else {
     outputBuf = (char*) tbufReadBinary(&br, &originalLen);
   }
 
-  pDist->dataBlockInfos = taosArrayFromList(outputBuf, (uint32_t) numOfBlocks, sizeof(SFileBlockInfo));
+  pDist->dataBlockInfos = taosArrayFromList(outputBuf, (uint32_t)numSteps, sizeof(SFileBlockInfo));
   if (comp) {
     tfree(outputBuf);
   }

src/query/tests/unitTest.cpp

@@ -99,47 +99,47 @@ TEST(testCase, db_table_name) {
   EXPECT_EQ(testValidateName(t4), TSDB_CODE_SUCCESS);
 
   char t5[] = "table.'def'";
-  EXPECT_EQ(testValidateName(t5), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t5), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t6[] = "'table'.'def'";
-  EXPECT_EQ(testValidateName(t6), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t6), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t7[] = "'_ab1234'.'def'";
   EXPECT_EQ(testValidateName(t7), TSDB_CODE_SUCCESS);
   printf("%s\n", t7);
 
   char t8[] = "'_ab&^%1234'.'def'";
-  EXPECT_EQ(testValidateName(t8), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t8), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t9[] = "'_123'.'gtest中文'";
-  EXPECT_EQ(testValidateName(t9), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t9), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t10[] = "abc.'gtest中文'";
-  EXPECT_EQ(testValidateName(t10), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t10), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t10_1[] = "abc.'中文gtest'";
-  EXPECT_EQ(testValidateName(t10_1), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t10_1), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t11[] = "'192.168.0.1'.abc";
-  EXPECT_EQ(testValidateName(t11), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t11), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t12[] = "192.168.0.1.abc";
-  EXPECT_EQ(testValidateName(t12), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t12), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t13[] = "abc.";
-  EXPECT_EQ(testValidateName(t13), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t13), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t14[] = ".abc";
-  EXPECT_EQ(testValidateName(t14), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t14), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t15[] = ".'abc'";
-  EXPECT_EQ(testValidateName(t15), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t15), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t16[] = ".abc'";
-  EXPECT_EQ(testValidateName(t16), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t16), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t17[] = "123a.\"abc\"";
-  EXPECT_EQ(testValidateName(t17), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t17), TSDB_CODE_TSC_INVALID_OPERATION);
   printf("%s\n", t17);
 
   char t18[] = "a.\"abc\"";
@@ -147,13 +147,13 @@ TEST(testCase, db_table_name) {
   printf("%s\n", t18);
 
   char t19[] = "'_ab1234'.'def'.'ab123'";
-  EXPECT_EQ(testValidateName(t19), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t19), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t20[] = "'_ab1234*&^'";
-  EXPECT_EQ(testValidateName(t20), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t20), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t21[] = "'1234_abc'";
-  EXPECT_EQ(testValidateName(t21), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t21), TSDB_CODE_TSC_INVALID_OPERATION);
 
 
   // =======Containing capital letters=================
@@ -167,10 +167,10 @@ TEST(testCase, db_table_name) {
   EXPECT_EQ(testValidateName(t32), TSDB_CODE_SUCCESS);
 
   char t33[] = "'ABC.def";
-  EXPECT_EQ(testValidateName(t33), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t33), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t33_0[] = "abc.DEF'";
-  EXPECT_EQ(testValidateName(t33_0), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t33_0), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t34[] = "'ABC.def'";
   //int32_t tmp0 = testValidateName(t34);
@@ -193,136 +193,136 @@ TEST(testCase, db_table_name) {
 
   // do not use key words 
   char t39[] = "table.'DEF'";
-  EXPECT_EQ(testValidateName(t39), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t39), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t40[] = "'table'.'DEF'";
-  EXPECT_EQ(testValidateName(t40), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t40), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t41[] = "'_abXYZ1234'.'deFF'";
   EXPECT_EQ(testValidateName(t41), TSDB_CODE_SUCCESS);
 
   char t42[] = "'_abDEF&^%1234'.'DIef'";
-  EXPECT_EQ(testValidateName(t42), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t42), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t43[] = "'_123'.'Gtest中文'";
-  EXPECT_EQ(testValidateName(t43), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t43), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t44[] = "'aABC'.'Gtest中文'";
-  EXPECT_EQ(testValidateName(t44), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t44), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t45[] = "'ABC'.";
-  EXPECT_EQ(testValidateName(t45), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t45), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t46[] = ".'ABC'";
-  EXPECT_EQ(testValidateName(t46), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t46), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t47[] = "a.\"aTWc\"";
   EXPECT_EQ(testValidateName(t47), TSDB_CODE_SUCCESS);
 
  // ================has space =================
   char t60[] = " ABC ";
-  EXPECT_EQ(testValidateName(t60), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t60), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t60_1[] = "   ABC ";
-  EXPECT_EQ(testValidateName(t60_1), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t60_1), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t61[] = "' ABC '";
-  EXPECT_EQ(testValidateName(t61), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t61), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t61_1[] = "'  ABC '";
-  EXPECT_EQ(testValidateName(t61_1), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t61_1), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t62[] = " ABC . def ";
-  EXPECT_EQ(testValidateName(t62), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t62), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t63[] = "' ABC . def ";
-  EXPECT_EQ(testValidateName(t63), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t63), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t63_0[] = "  abc . DEF ' ";
-  EXPECT_EQ(testValidateName(t63_0), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t63_0), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t64[] = " '  ABC .  def ' ";
   //int32_t tmp1 = testValidateName(t64);
-  EXPECT_EQ(testValidateName(t64), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t64), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t65[] = " ' ABC  '. def ";
-  EXPECT_EQ(testValidateName(t65), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t65), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t66[] = "' ABC '.'  DEF '";
-  EXPECT_EQ(testValidateName(t66), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t66), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t67[] = "abc . '  DEF  '";
-  EXPECT_EQ(testValidateName(t67), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t67), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t68[] = "'  abc '.'   DEF '";
-  EXPECT_EQ(testValidateName(t68), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t68), TSDB_CODE_TSC_INVALID_OPERATION);
 
   // do not use key words 
   char t69[] = "table.'DEF'";
-  EXPECT_EQ(testValidateName(t69), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t69), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t70[] = "'table'.'DEF'";
-  EXPECT_EQ(testValidateName(t70), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t70), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t71[] = "'_abXYZ1234  '.' deFF  '";
-  EXPECT_EQ(testValidateName(t71), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t71), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t72[] = "'_abDEF&^%1234'.'  DIef'";
-  EXPECT_EQ(testValidateName(t72), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t72), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t73[] = "'_123'.'  Gtest中文'";
-  EXPECT_EQ(testValidateName(t73), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t73), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t74[] = "' aABC'.'Gtest中文'";
-  EXPECT_EQ(testValidateName(t74), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t74), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t75[] = "' ABC '.";
-  EXPECT_EQ(testValidateName(t75), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t75), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t76[] = ".' ABC'";
-  EXPECT_EQ(testValidateName(t76), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t76), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t77[] = " a . \"aTWc\" ";
-  EXPECT_EQ(testValidateName(t77), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t77), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t78[] = "  a.\"aTWc  \"";
-  EXPECT_EQ(testValidateName(t78), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t78), TSDB_CODE_TSC_INVALID_OPERATION);
 
 
   // ===============muti string by space ===================
   // There's no such case.
   //char t160[] = "A BC";
-  //EXPECT_EQ(testValidateName(t160), TSDB_CODE_TSC_INVALID_SQL);
+  //EXPECT_EQ(testValidateName(t160), TSDB_CODE_TSC_INVALID_OPERATION);
   //printf("end:%s\n", t160);
 
   // There's no such case.
   //char t161[] = "' A BC '";
-  //EXPECT_EQ(testValidateName(t161), TSDB_CODE_TSC_INVALID_SQL);
+  //EXPECT_EQ(testValidateName(t161), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t162[] = " AB C . de f ";
-  EXPECT_EQ(testValidateName(t162), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t162), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t163[] = "' AB C . de f ";
-  EXPECT_EQ(testValidateName(t163), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t163), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t163_0[] = "  ab c . DE F ' ";
-  EXPECT_EQ(testValidateName(t163_0), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t163_0), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t164[] = " '  AB C .  de f ' ";
   //int32_t tmp2 = testValidateName(t164);
-  EXPECT_EQ(testValidateName(t164), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t164), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t165[] = " ' A BC  '. de f ";
-  EXPECT_EQ(testValidateName(t165), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t165), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t166[] = "' AB C '.'  DE  F '";
-  EXPECT_EQ(testValidateName(t166), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t166), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t167[] = "ab  c . '  D  EF  '";
-  EXPECT_EQ(testValidateName(t167), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t167), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t168[] = "'  a bc '.'   DE  F '";
-  EXPECT_EQ(testValidateName(t168), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t168), TSDB_CODE_TSC_INVALID_OPERATION);
   
 }
 

src/tsdb/inc/tsdbCommit.h

@@ -40,6 +40,7 @@ int tsdbWriteBlockInfoImpl(SDFile *pHeadf, STable *pTable, SArray *pSupA, SArray
 int tsdbWriteBlockIdx(SDFile *pHeadf, SArray *pIdxA, void **ppBuf);
 int tsdbWriteBlockImpl(STsdbRepo *pRepo, STable *pTable, SDFile *pDFile, SDataCols *pDataCols, SBlock *pBlock,
                        bool isLast, bool isSuper, void **ppBuf, void **ppCBuf);
+int   tsdbApplyRtn(STsdbRepo *pRepo);
 
 static FORCE_INLINE int tsdbGetFidLevel(int fid, SRtn *pRtn) {
   if (fid >= pRtn->maxFid) {

src/tsdb/inc/tsdbint.h

@@ -88,6 +88,7 @@ struct STsdbRepo {
   SMemTable*      mem;
   SMemTable*      imem;
   STsdbFS*        fs;
+  SRtn            rtn;
   tsem_t          readyToCommit;
   pthread_mutex_t mutex;
   bool            repoLocked;

src/tsdb/src/tsdbCommit.c

@@ -85,7 +85,6 @@ static void tsdbCloseCommitFile(SCommitH *pCommith, bool hasError);
 static bool tsdbCanAddSubBlock(SCommitH *pCommith, SBlock *pBlock, SMergeInfo *pInfo);
 static void tsdbLoadAndMergeFromCache(SDataCols *pDataCols, int *iter, SCommitIter *pCommitIter, SDataCols *pTarget,
                                       TSKEY maxKey, int maxRows, int8_t update);
-static int  tsdbApplyRtn(STsdbRepo *pRepo);
 
 void *tsdbCommitData(STsdbRepo *pRepo) {
   if (pRepo->imem == NULL) {
@@ -1210,7 +1209,7 @@ static int tsdbCommitAddBlock(SCommitH *pCommith, const SBlock *pSupBlock, const
     return -1;
   }
 
-  if (pSubBlocks && taosArrayPushBatch(pCommith->aSubBlk, pSubBlocks, nSubBlocks) == NULL) {
+  if (pSubBlocks && taosArrayAddBatch(pCommith->aSubBlk, pSubBlocks, nSubBlocks) == NULL) {
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
     return -1;
   }
@@ -1489,7 +1488,7 @@ static bool tsdbCanAddSubBlock(SCommitH *pCommith, SBlock *pBlock, SMergeInfo *p
   return false;
 }
 
-static int tsdbApplyRtn(STsdbRepo *pRepo) {
+int tsdbApplyRtn(STsdbRepo *pRepo) {
   SRtn       rtn;
   SFSIter    fsiter;
   STsdbFS *  pfs = REPO_FS(pRepo);

src/tsdb/src/tsdbFS.c

@@ -33,7 +33,9 @@ static int  tsdbScanDataDir(STsdbRepo *pRepo);
 static bool tsdbIsTFileInFS(STsdbFS *pfs, const TFILE *pf);
 static int  tsdbRestoreCurrent(STsdbRepo *pRepo);
 static int  tsdbComparTFILE(const void *arg1, const void *arg2);
-static void tsdbScanAndTryFixDFilesHeader(STsdbRepo *pRepo);
+static void tsdbScanAndTryFixDFilesHeader(STsdbRepo *pRepo, int32_t *nExpired);
+static int  tsdbProcessExpiredFS(STsdbRepo *pRepo);
+static int  tsdbCreateMeta(STsdbRepo *pRepo);
 
 // ================== CURRENT file header info
 static int tsdbEncodeFSHeader(void **buf, SFSHeader *pHeader) {
@@ -212,6 +214,8 @@ STsdbFS *tsdbNewFS(STsdbCfg *pCfg) {
     return NULL;
   }
 
+  pfs->intxn = false;
+
   pfs->nstatus = tsdbNewFSStatus(maxFSet);
   if (pfs->nstatus == NULL) {
     tsdbFreeFS(pfs);
@@ -234,22 +238,84 @@ void *tsdbFreeFS(STsdbFS *pfs) {
   return NULL;
 }
 
+static int tsdbProcessExpiredFS(STsdbRepo *pRepo) {
+  tsdbStartFSTxn(pRepo, 0, 0);
+  if (tsdbCreateMeta(pRepo) < 0) {
+    tsdbError("vgId:%d failed to create meta since %s", REPO_ID(pRepo), tstrerror(terrno));
+    return -1;
+  }
+
+  if (tsdbApplyRtn(pRepo) < 0) {
+    tsdbEndFSTxnWithError(REPO_FS(pRepo));
+    tsdbError("vgId:%d failed to apply rtn since %s", REPO_ID(pRepo), tstrerror(terrno));
+    return -1;
+  }
+  if (tsdbEndFSTxn(pRepo) < 0) {
+    tsdbError("vgId:%d failed to end fs txn since %s", REPO_ID(pRepo), tstrerror(terrno));
+    return -1;
+  }
+  return 0;
+}
+
+static int tsdbCreateMeta(STsdbRepo *pRepo) {
+  STsdbFS *pfs = REPO_FS(pRepo);
+  SMFile * pOMFile = pfs->cstatus->pmf;
+  SMFile   mf;
+  SDiskID  did;
+
+  if (pOMFile != NULL) {
+    // keep the old meta file
+    tsdbUpdateMFile(pfs, pOMFile);
+    return 0;
+  }
+
+  // Create a new meta file
+  did.level = TFS_PRIMARY_LEVEL;
+  did.id = TFS_PRIMARY_ID;
+  tsdbInitMFile(&mf, did, REPO_ID(pRepo), FS_TXN_VERSION(REPO_FS(pRepo)));
+
+  if (tsdbCreateMFile(&mf, true) < 0) {
+    tsdbError("vgId:%d failed to create META file since %s", REPO_ID(pRepo), tstrerror(terrno));
+    return -1;
+  }
+
+  tsdbInfo("vgId:%d meta file %s is created", REPO_ID(pRepo), TSDB_FILE_FULL_NAME(&mf));
+
+  if (tsdbUpdateMFileHeader(&mf) < 0) {
+    tsdbError("vgId:%d failed to update META file header since %s, revert it", REPO_ID(pRepo), tstrerror(terrno));
+    tsdbApplyMFileChange(&mf, pOMFile);
+    return -1;
+  }
+
+  TSDB_FILE_FSYNC(&mf);
+  tsdbCloseMFile(&mf);
+  tsdbUpdateMFile(pfs, &mf);
+
+  return 0;
+}
+
 int tsdbOpenFS(STsdbRepo *pRepo) {
   STsdbFS *pfs = REPO_FS(pRepo);
   char     current[TSDB_FILENAME_LEN] = "\0";
+  int      nExpired = 0;
 
   ASSERT(pfs != NULL);
 
   tsdbGetTxnFname(REPO_ID(pRepo), TSDB_TXN_CURR_FILE, current);
 
+  tsdbGetRtnSnap(pRepo, &pRepo->rtn);
   if (access(current, F_OK) == 0) {
     if (tsdbOpenFSFromCurrent(pRepo) < 0) {
       tsdbError("vgId:%d failed to open FS since %s", REPO_ID(pRepo), tstrerror(terrno));
       return -1;
     }
 
-    tsdbScanAndTryFixDFilesHeader(pRepo);
+    tsdbScanAndTryFixDFilesHeader(pRepo, &nExpired);
+    if (nExpired > 0) {
+      tsdbProcessExpiredFS(pRepo);
+    }
   } else {
+    // should skip expired fileset inside of the function
     if (tsdbRestoreCurrent(pRepo) < 0) {
       tsdbError("vgId:%d failed to restore current file since %s", REPO_ID(pRepo), tstrerror(terrno));
       return -1;
@@ -1110,6 +1176,11 @@ static int tsdbRestoreDFileSet(STsdbRepo *pRepo) {
 
       ASSERT(tvid == REPO_ID(pRepo));
 
+      if (tfid < pRepo->rtn.minFid) {  // skip file expired
+        ++index;
+        continue;
+      }
+
       if (ftype == 0) {
         fset.fid = tfid;
       } else {
@@ -1206,7 +1277,7 @@ static int tsdbComparTFILE(const void *arg1, const void *arg2) {
   }
 }
 
-static void tsdbScanAndTryFixDFilesHeader(STsdbRepo *pRepo) {
+static void tsdbScanAndTryFixDFilesHeader(STsdbRepo *pRepo, int32_t *nExpired) {
   STsdbFS *  pfs = REPO_FS(pRepo);
   SFSStatus *pStatus = pfs->cstatus;
   SDFInfo    info;
@@ -1214,7 +1285,9 @@ static void tsdbScanAndTryFixDFilesHeader(STsdbRepo *pRepo) {
   for (size_t i = 0; i < taosArrayGetSize(pStatus->df); i++) {
     SDFileSet fset;
     tsdbInitDFileSetEx(&fset, (SDFileSet *)taosArrayGet(pStatus->df, i));
-
+    if (fset.fid < pRepo->rtn.minFid) {
+      ++*nExpired;
+    }
     tsdbDebug("vgId:%d scan DFileSet %d header", REPO_ID(pRepo), fset.fid);
 
     if (tsdbOpenDFileSet(&fset, O_RDWR) < 0) {

src/tsdb/src/tsdbMeta.c

@@ -68,7 +68,7 @@ int tsdbCreateTable(STsdbRepo *repo, STableCfg *pCfg) {
                 TABLE_CHAR_NAME(pMeta->tables[tid]), TABLE_TID(pMeta->tables[tid]), TABLE_UID(pMeta->tables[tid]));
       return 0;
     } else {
-      tsdbError("vgId:%d table %s at tid %d uid %" PRIu64
+      tsdbInfo("vgId:%d table %s at tid %d uid %" PRIu64
                 " exists, replace it with new table, this can be not reasonable",
                 REPO_ID(pRepo), TABLE_CHAR_NAME(pMeta->tables[tid]), TABLE_TID(pMeta->tables[tid]),
                 TABLE_UID(pMeta->tables[tid]));
@@ -1055,10 +1055,7 @@ static int tsdbRemoveTableFromIndex(STsdbMeta *pMeta, STable *pTable) {
   STable *pSTable = pTable->pSuper;
   ASSERT(pSTable != NULL);
 
-  STSchema *pSchema = tsdbGetTableTagSchema(pTable);
+  char* key = getTagIndexKey(pTable);
-  STColumn *pCol = schemaColAt(pSchema, DEFAULT_TAG_INDEX_COLUMN);
-
-  char *  key = tdGetKVRowValOfCol(pTable->tagVal, pCol->colId);
   SArray *res = tSkipListGet(pSTable->pIndex, key);
 
   size_t size = taosArrayGetSize(res);

src/tsdb/src/tsdbRead.c

@@ -62,6 +62,7 @@ typedef struct SLoadCompBlockInfo {
   int32_t fileId;
 } SLoadCompBlockInfo;
 
+
 typedef struct STableCheckInfo {
   STableId      tableId;
   TSKEY         lastKey;
@@ -107,7 +108,7 @@ typedef struct STsdbQueryHandle {
   SArray*        pTableCheckInfo;  // SArray<STableCheckInfo>
   int32_t        activeIndex;
   bool           checkFiles;       // check file stage
-  bool           cachelastrow;     // check if last row cached
+  int8_t         cachelastrow;     // check if last row cached
   bool           loadExternalRow;  // load time window external data rows
   bool           currentLoadExternalRows; // current load external rows
   int32_t        loadType;         // block load type
@@ -117,7 +118,6 @@ typedef struct STsdbQueryHandle {
   SFSIter        fileIter;
   SReadH         rhelper;
   STableBlockInfo* pDataBlockInfo;
-
   SDataCols     *pDataCols;        // in order to hold current file data block
   int32_t        allocSize;        // allocated data block size
   SMemRef       *pMemRef;
@@ -138,6 +138,7 @@ typedef struct STableGroupSupporter {
 
 static STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList);
 static int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
+static int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle);
 static int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey);
 
 static void    changeQueryHandleForInterpQuery(TsdbQueryHandleT pHandle);
@@ -367,20 +368,21 @@ static STsdbQueryHandle* tsdbQueryTablesImpl(STsdbRepo* tsdb, STsdbQueryCond* pC
     goto out_of_memory;
   }
 
-  assert(pCond != NULL && pCond->numOfCols > 0 && pMemRef != NULL);
+  assert(pCond != NULL && pMemRef != NULL);
   if (ASCENDING_TRAVERSE(pCond->order)) {
     assert(pQueryHandle->window.skey <= pQueryHandle->window.ekey);
   } else {
     assert(pQueryHandle->window.skey >= pQueryHandle->window.ekey);
   }
-
+  if (pCond->numOfCols > 0) {
     // allocate buffer in order to load data blocks from file
     pQueryHandle->statis = calloc(pCond->numOfCols, sizeof(SDataStatis));
     if (pQueryHandle->statis == NULL) {
       goto out_of_memory;
     }
 
-  pQueryHandle->pColumns = taosArrayInit(pCond->numOfCols, sizeof(SColumnInfoData));  // todo: use list instead of array?
+    pQueryHandle->pColumns =
+        taosArrayInit(pCond->numOfCols, sizeof(SColumnInfoData));  // todo: use list instead of array?
     if (pQueryHandle->pColumns == NULL) {
       goto out_of_memory;
     }
@@ -397,10 +399,8 @@ static STsdbQueryHandle* tsdbQueryTablesImpl(STsdbRepo* tsdb, STsdbQueryCond* pC
       pQueryHandle->statis[i].colId = colInfo.info.colId;
     }
 
-  if (pCond->numOfCols > 0) {
     pQueryHandle->defaultLoadColumn = getDefaultLoadColumns(pQueryHandle, true);
   }
-
   STsdbMeta* pMeta = tsdbGetMeta(tsdb);
   assert(pMeta != NULL);
 
@@ -512,6 +512,8 @@ void tsdbResetQueryHandleForNewTable(TsdbQueryHandleT queryHandle, STsdbQueryCon
   pQueryHandle->next = doFreeColumnInfoData(pQueryHandle->next);
 }
 
+
+
 TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef) {
   pCond->twindow = updateLastrowForEachGroup(groupList);
 
@@ -528,10 +530,30 @@ TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
   }
 
   assert(pCond->order == TSDB_ORDER_ASC && pCond->twindow.skey <= pCond->twindow.ekey);
+  if (pQueryHandle->cachelastrow) {
     pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  }
+  
   return pQueryHandle;
 }
 
+
+TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef) {
+  STsdbQueryHandle *pQueryHandle = (STsdbQueryHandle*) tsdbQueryTables(tsdb, pCond, groupList, qId, pMemRef);
+  int32_t code = checkForCachedLast(pQueryHandle);
+  if (code != TSDB_CODE_SUCCESS) { // set the numOfTables to be 0
+    terrno = code;
+    return NULL;
+  }
+
+  if (pQueryHandle->cachelastrow) {
+    pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  }
+  
+  return pQueryHandle;
+}
+
+
 SArray* tsdbGetQueriedTableList(TsdbQueryHandleT *pHandle) {
   assert(pHandle != NULL);
 
@@ -2105,6 +2127,7 @@ int32_t tsdbGetFileBlocksDistInfo(TsdbQueryHandleT* queryHandle, STableBlockDist
   STsdbQueryHandle* pQueryHandle = (STsdbQueryHandle*) queryHandle;
 
   pTableBlockInfo->totalSize = 0;
+  pTableBlockInfo->totalRows = 0;
   STsdbFS* pFileHandle = REPO_FS(pQueryHandle->pTsdb);
 
   // find the start data block in file
@@ -2178,7 +2201,12 @@ int32_t tsdbGetFileBlocksDistInfo(TsdbQueryHandleT* queryHandle, STableBlockDist
         pTableBlockInfo->totalSize += pBlock[j].len;
 
         int32_t numOfRows = pBlock[j].numOfRows;
-        taosArrayPush(pTableBlockInfo->dataBlockInfos, &numOfRows);
+        pTableBlockInfo->totalRows += numOfRows;
+        if (numOfRows > pTableBlockInfo->maxRows) pTableBlockInfo->maxRows = numOfRows;
+        if (numOfRows < pTableBlockInfo->minRows) pTableBlockInfo->minRows = numOfRows;
+        int32_t  stepIndex = (numOfRows-1)/TSDB_BLOCK_DIST_STEP_ROWS;
+        SFileBlockInfo *blockInfo = (SFileBlockInfo*)taosArrayGet(pTableBlockInfo->dataBlockInfos, stepIndex);
+        blockInfo->numBlocksOfStep++;
       }
     }
   }
@@ -2460,6 +2488,159 @@ static bool loadCachedLastRow(STsdbQueryHandle* pQueryHandle) {
   return false;
 }
 
+
+
+static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
+  // the last row is cached in buffer, return it directly.
+  // here note that the pQueryHandle->window must be the TS_INITIALIZER
+  int32_t tgNumOfCols = (int32_t)QH_GET_NUM_OF_COLS(pQueryHandle);
+  size_t  numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
+  int32_t numOfRows = 0;
+  assert(numOfTables > 0 && tgNumOfCols > 0);
+  SQueryFilePos* cur = &pQueryHandle->cur;
+  TSKEY priKey = TSKEY_INITIAL_VAL;
+  int32_t priIdx = -1;
+  SColumnInfoData* pColInfo = NULL;
+
+  while (++pQueryHandle->activeIndex < numOfTables) {
+    STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
+    STable* pTable = pCheckInfo->pTableObj;  
+    char* pData = NULL;
+
+    int32_t numOfCols = pTable->maxColNum;
+    
+    if (pTable->lastCols == NULL || pTable->maxColNum <= 0) {
+      tsdbWarn("no last cached for table, uid:%" PRIu64 ",tid:%d", pTable->tableId.uid, pTable->tableId.tid);
+      continue;
+    }
+    
+    int32_t i = 0, j = 0;
+    while(i < tgNumOfCols && j < numOfCols) {
+      pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+      if (pTable->lastCols[j].colId < pColInfo->info.colId) {
+        j++;
+        continue;
+      } else if (pTable->lastCols[j].colId > pColInfo->info.colId) {
+        i++;
+        continue;
+      }
+    
+      pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
+    
+      if (pTable->lastCols[j].bytes > 0) {        
+        void* value = pTable->lastCols[j].pData;
+        switch (pColInfo->info.type) {
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR:
+            memcpy(pData, value, varDataTLen(value));
+            break;
+          case TSDB_DATA_TYPE_NULL:
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_UTINYINT:  
+            *(uint8_t *)pData = *(uint8_t *)value;
+            break;
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_USMALLINT:
+            *(uint16_t *)pData = *(uint16_t *)value;
+            break;
+          case TSDB_DATA_TYPE_INT:
+          case TSDB_DATA_TYPE_UINT:
+            *(uint32_t *)pData = *(uint32_t *)value;
+            break;
+          case TSDB_DATA_TYPE_BIGINT:
+          case TSDB_DATA_TYPE_UBIGINT:
+            *(uint64_t *)pData = *(uint64_t *)value;
+            break;
+          case TSDB_DATA_TYPE_FLOAT:
+            SET_FLOAT_PTR(pData, value);
+            break;
+          case TSDB_DATA_TYPE_DOUBLE:
+            SET_DOUBLE_PTR(pData, value);
+            break;
+          case TSDB_DATA_TYPE_TIMESTAMP:
+            if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+              priKey = tdGetKey(*(TKEY *)value);
+              priIdx = i;
+
+              i++;
+              j++;
+              continue;
+            } else {
+              *(TSKEY *)pData = *(TSKEY *)value;
+            }
+            break;
+          default:
+            memcpy(pData, value, pColInfo->info.bytes);
+        }
+    
+        for (int32_t n = 0; n < tgNumOfCols; ++n) {
+          if (n == i) {
+            continue;
+          }
+
+          pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
+          pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
+
+          if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+            *(TSKEY *)pData = pTable->lastCols[j].ts;
+            continue;
+          }
+          
+          if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
+            setVardataNull(pData, pColInfo->info.type);
+          } else {
+            setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
+          }
+        }
+
+        numOfRows++;
+        assert(numOfRows < pQueryHandle->outputCapacity);
+      } 
+    
+      i++;
+      j++;
+    }
+
+    // leave the real ts column as the last row, because last function only (not stable) use the last row as res
+    if (priKey != TSKEY_INITIAL_VAL) {
+      pColInfo = taosArrayGet(pQueryHandle->pColumns, priIdx);
+      pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
+    
+      *(TSKEY *)pData = priKey;
+
+      for (int32_t n = 0; n < tgNumOfCols; ++n) {
+        if (n == priIdx) {
+          continue;
+        }
+      
+        pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
+        pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
+      
+        assert (pColInfo->info.colId != PRIMARYKEY_TIMESTAMP_COL_INDEX);
+        
+        if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(pData, pColInfo->info.type);
+        } else {
+          setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
+        }
+      }
+
+      numOfRows++;
+    }
+    
+    if (numOfRows > 0) {
+      cur->rows     = numOfRows;
+      cur->mixBlock = true;
+      
+      return true;
+    }    
+  }
+
+  return false;
+}
+
+
 static bool loadDataBlockFromTableSeq(STsdbQueryHandle* pQueryHandle) {
   size_t numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
   assert(numOfTables > 0);
@@ -2496,8 +2677,12 @@ bool tsdbNextDataBlock(TsdbQueryHandleT pHandle) {
   int64_t stime = taosGetTimestampUs();
   int64_t elapsedTime = stime;
 
-  if (pQueryHandle->type == TSDB_QUERY_TYPE_LAST && pQueryHandle->cachelastrow) {
+  if (pQueryHandle->type == TSDB_QUERY_TYPE_LAST) {
+    if (pQueryHandle->cachelastrow == 1) {
       return loadCachedLastRow(pQueryHandle);
+    } else if (pQueryHandle->cachelastrow == 2) {
+      return loadCachedLast(pQueryHandle);
+    }
   }
 
   if (pQueryHandle->loadType == BLOCK_LOAD_TABLE_SEQ_ORDER) {
@@ -2695,6 +2880,10 @@ int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey) {
   return TSDB_CODE_SUCCESS;
 }
 
+bool isTsdbCacheLastRow(TsdbQueryHandleT* pQueryHandle) {
+  return ((STsdbQueryHandle *)pQueryHandle)->cachelastrow > 0;
+}
+
 int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList) {
   assert(pQueryHandle != NULL && groupList != NULL);
 
@@ -2706,11 +2895,15 @@ int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *g
 
   STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(group, 0);
 
-  int32_t code = tsdbGetCachedLastRow(pInfo->pTable, &pRow, &key);
+  int32_t code = 0;
+  
+  if (((STable*)pInfo->pTable)->lastRow) {
+    code = tsdbGetCachedLastRow(pInfo->pTable, &pRow, &key);
     if (code != TSDB_CODE_SUCCESS) {
-    pQueryHandle->cachelastrow = false;
+      pQueryHandle->cachelastrow = 0;
     } else {
-    pQueryHandle->cachelastrow = (pRow != NULL);
+      pQueryHandle->cachelastrow = 1;
+    }
   }
 
   // update the tsdb query time range
@@ -2724,6 +2917,26 @@ int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *g
   return code;
 }
 
+int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle) {
+  assert(pQueryHandle != NULL);
+
+  int32_t code = 0;
+  
+  if (pQueryHandle->pTsdb && atomic_load_8(&pQueryHandle->pTsdb->hasCachedLastColumn)){
+    pQueryHandle->cachelastrow = 2;
+  }
+
+  // update the tsdb query time range
+  if (pQueryHandle->cachelastrow) {
+    pQueryHandle->window      = TSWINDOW_INITIALIZER;
+    pQueryHandle->checkFiles  = false;
+    pQueryHandle->activeIndex = -1;  // start from -1
+  }
+
+  return code;
+}
+
+
 STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList) {
   STimeWindow window = {INT64_MAX, INT64_MIN};
 

src/tsdb/src/tsdbSync.c

@@ -424,24 +424,42 @@ static int32_t tsdbSyncRecvDFileSetArray(SSyncH *pSynch) {
         }
 
         if (tsdbSendDecision(pSynch, false) < 0) {
-          tsdbError("vgId:%d, filed to send decision since %s", REPO_ID(pRepo), tstrerror(terrno));
+          tsdbError("vgId:%d, failed to send decision since %s", REPO_ID(pRepo), tstrerror(terrno));
           return -1;
         }
       } else {
         // Need to copy from remote
+        int fidLevel = tsdbGetFidLevel(pSynch->pdf->fid, &(pSynch->rtn));
+        if (fidLevel < 0) {  // expired fileset
+          tsdbInfo("vgId:%d, fileset:%d will be skipped as expired", REPO_ID(pRepo), pSynch->pdf->fid);
+          if (tsdbSendDecision(pSynch, false) < 0) {
+            tsdbError("vgId:%d, failed to send decision since %s", REPO_ID(pRepo), tstrerror(terrno));
+            return -1;
+          }
+          // Move forward
+          if (tsdbRecvDFileSetInfo(pSynch) < 0) {
+            tsdbError("vgId:%d, failed to recv fileset since %s", REPO_ID(pRepo), tstrerror(terrno));
+            return -1;
+          }
+          if (pLSet) {
+            pLSet = tsdbFSIterNext(&fsiter);
+          }
+          // Next loop
+          continue;
+        } else {
           tsdbInfo("vgId:%d, fileset:%d will be received", REPO_ID(pRepo), pSynch->pdf->fid);
-
           // Notify remote to send there file here
           if (tsdbSendDecision(pSynch, true) < 0) {
             tsdbError("vgId:%d, failed to send decision since %s", REPO_ID(pRepo), tstrerror(terrno));
             return -1;
           }
+        }
 
         // Create local files and copy from remote
         SDiskID   did;
         SDFileSet fset;
 
-        tfsAllocDisk(tsdbGetFidLevel(pSynch->pdf->fid, &(pSynch->rtn)), &(did.level), &(did.id));
+        tfsAllocDisk(fidLevel, &(did.level), &(did.id));
         if (did.level == TFS_UNDECIDED_LEVEL) {
           terrno = TSDB_CODE_TDB_NO_AVAIL_DISK;
           tsdbError("vgId:%d, failed allc disk since %s", REPO_ID(pRepo), tstrerror(terrno));
@@ -548,6 +566,13 @@ static int32_t tsdbSyncSendDFileSet(SSyncH *pSynch, SDFileSet *pSet) {
   STsdbRepo *pRepo = pSynch->pRepo;
   bool toSend = false;
 
+  // skip expired fileset
+  if (pSet && tsdbGetFidLevel(pSet->fid, &(pSynch->rtn)) < 0) {
+    tsdbInfo("vgId:%d, don't sync send since fileset:%d smaller than minFid:%d", REPO_ID(pRepo), pSet->fid,
+             pSynch->rtn.minFid);
+    return 0;
+  }
+
   if (tsdbSendDFileSetInfo(pSynch, pSet) < 0) {
     tsdbError("vgId:%d, failed to send fileset:%d info since %s", REPO_ID(pRepo), pSet ? pSet->fid : -1, tstrerror(terrno));
     return -1;

src/util/inc/hash.h

@@ -148,6 +148,7 @@ int32_t taosHashGetMaxOverflowLinkLength(const SHashObj *pHashObj);
 size_t taosHashGetMemSize(const SHashObj *pHashObj);
 
 void *taosHashIterate(SHashObj *pHashObj, void *p);
+
 void  taosHashCancelIterate(SHashObj *pHashObj, void *p);
 
 #ifdef __cplusplus

src/util/inc/tarray.h

@@ -50,7 +50,15 @@ void* taosArrayInit(size_t size, size_t elemSize);
  * @param nEles
  * @return
  */
-void *taosArrayPushBatch(SArray *pArray, const void *pData, int nEles);
+void *taosArrayAddBatch(SArray *pArray, const void *pData, int nEles);
+
+/**
+ *  add all element from the source array list into the destination
+ * @param pArray
+ * @param pInput
+ * @return
+ */
+void* taosArrayAddAll(SArray* pArray, const SArray* pInput);
 
 /**
  *
@@ -59,7 +67,7 @@ void *taosArrayPushBatch(SArray *pArray, const void *pData, int nEles);
  * @return
  */
 static FORCE_INLINE void* taosArrayPush(SArray* pArray, const void* pData) {
-  return taosArrayPushBatch(pArray, pData, 1);
+  return taosArrayAddBatch(pArray, pData, 1);
 }
 
 /**
@@ -98,6 +106,14 @@ void* taosArrayGetLast(const SArray* pArray);
  */
 size_t taosArrayGetSize(const SArray* pArray);
 
+/**
+ * set the size of array
+ * @param pArray
+ * @param size size of the array
+ * @return
+ */
+void taosArraySetSize(SArray* pArray, size_t size);
+
 /**
  * insert data into array
  * @param pArray

src/util/inc/ttoken.h

@@ -37,8 +37,6 @@ typedef struct SStrToken {
   char    *z;
 } SStrToken;
 
-extern const char escapeChar[];
-
 /**
  * check if it is a number or not
  * @param pToken
@@ -47,8 +45,6 @@ extern const char escapeChar[];
 #define isNumber(tk) \
 ((tk)->type == TK_INTEGER || (tk)->type == TK_FLOAT || (tk)->type == TK_HEX || (tk)->type == TK_BIN)
 
-#define GET_ESCAPE_CHAR(c) (escapeChar[(uint8_t)(c)])
-
 /**
  * tokenizer for sql string
  * @param z
@@ -187,6 +183,7 @@ void taosCleanupKeywordsTable();
 
 SStrToken tscReplaceStrToken(char **str, SStrToken *token, const char* newToken);
 
+SStrToken taosTokenDup(SStrToken* pToken, char* buf, int32_t len);
 
 #ifdef __cplusplus
 }

src/util/src/tarray.c

@@ -56,7 +56,7 @@ static int32_t taosArrayResize(SArray* pArray) {
   return 0;
 }
 
-void* taosArrayPushBatch(SArray* pArray, const void* pData, int nEles) {
+void* taosArrayAddBatch(SArray* pArray, const void* pData, int nEles) {
   if (pArray == NULL || pData == NULL) {
     return NULL;
   }
@@ -82,6 +82,10 @@ void* taosArrayPushBatch(SArray* pArray, const void* pData, int nEles) {
   return dst;
 }
 
+void* taosArrayAddAll(SArray* pArray, const SArray* pInput) {
+  return taosArrayAddBatch(pArray, pInput->pData, (int32_t) taosArrayGetSize(pInput));
+}
+
 void* taosArrayPop(SArray* pArray) {
   assert( pArray != NULL );
 
@@ -111,6 +115,11 @@ void* taosArrayGetLast(const SArray* pArray) {
 
 size_t taosArrayGetSize(const SArray* pArray) { return pArray->size; }
 
+void taosArraySetSize(SArray* pArray, size_t size) {
+  assert(size <= pArray->capacity);
+  pArray->size = size;
+}
+
 void* taosArrayInsert(SArray* pArray, size_t index, void* pData) {
   if (pArray == NULL || pData == NULL) {
     return NULL;

src/util/src/terror.c

@@ -83,7 +83,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_REF_ALREADY_EXIST,            "Ref is already there"
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_NOT_EXIST,                "Ref is not there")
 
 //client
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_SQL,              "Invalid SQL statement")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_OPERATION,        "Invalid operation")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_QHANDLE,          "Invalid qhandle")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TIME_STAMP,       "Invalid combination of client/service time")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_VALUE,            "Invalid value in client")
@@ -224,6 +224,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_VND_IS_FULL,                  "Database memory is fu
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_IS_FLOWCTRL,              "Database memory is full for waiting commit")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_IS_DROPPING,              "Database is dropping")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_IS_BALANCING,             "Database is balancing")
+TAOS_DEFINE_ERROR(TSDB_CODE_VND_IS_CLOSING,               "Database is closing")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_NOT_SYNCED,               "Database suspended")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_NO_WRITE_AUTH,            "Database write operation denied")
 TAOS_DEFINE_ERROR(TSDB_CODE_VND_IS_SYNCING,               "Database is syncing")

src/util/src/ttokenizer.c

@@ -141,6 +141,7 @@ static SKeyword keywordTable[] = {
     {"VARIABLE",     TK_VARIABLE},
     {"INTERVAL",     TK_INTERVAL},
     {"SESSION",      TK_SESSION},
+    {"STATE_WINDOW", TK_STATE_WINDOW},
     {"FILL",         TK_FILL},
     {"SLIDING",      TK_SLIDING},
     {"ORDER",        TK_ORDER},
@@ -232,18 +233,6 @@ static const char isIdChar[] = {
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */
 };
 
-const char escapeChar[] = {
-    /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, /* 0x */
-    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, /* 1x */
-    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, /* 2x */
-    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, /* 3x */
-    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,/* 4x */
-    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,/* 5x */
-    0x60, 0x07, 0x08, 0x63, 0x64, 0x65, 0x0C, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x0A, 0x6F,/* 6x */
-    0x70, 0x71, 0x0D, 0x73, 0x09, 0x75, 0x0B, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,/* 7x */
-};
-
 static void* keywordHashTable = NULL;
 
 static void doInitKeywordsTable(void) {
@@ -593,7 +582,6 @@ SStrToken tscReplaceStrToken(char **str, SStrToken *token, const char* newToken)
   return ntoken;
 }
 
-
 SStrToken tStrGetToken(char* str, int32_t* i, bool isPrevOptr) {
   SStrToken t0 = {0};
 
@@ -686,3 +674,15 @@ void taosCleanupKeywordsTable() {
     taosHashCleanup(m);
   }
 }
+
+SStrToken taosTokenDup(SStrToken* pToken, char* buf, int32_t len) {
+  assert(pToken != NULL && buf != NULL);
+  SStrToken token = *pToken;
+  token.z = buf;
+
+  assert(len > token.n);
+  strncpy(token.z, pToken->z, pToken->n);
+  token.z[token.n] = 0;
+
+  return token;
+}

src/vnode/src/vnodeMgmt.c

@@ -91,18 +91,18 @@ static void vnodeIncRef(void *ptNode) {
 }
 
 void *vnodeAcquire(int32_t vgId) {
-  SVnodeObj **ppVnode = NULL;
+  SVnodeObj *pVnode = NULL;
   if (tsVnodesHash != NULL) {
-    ppVnode = taosHashGetClone(tsVnodesHash, &vgId, sizeof(int32_t), vnodeIncRef, NULL, sizeof(void *));
+    taosHashGetClone(tsVnodesHash, &vgId, sizeof(int32_t), vnodeIncRef, &pVnode, sizeof(void *));
   }
 
-  if (ppVnode == NULL || *ppVnode == NULL) {
+  if (pVnode == NULL) {
     terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
     vDebug("vgId:%d, not exist", vgId);
     return NULL;
   }
 
-  return *ppVnode;
+  return pVnode;
 }
 
 void vnodeRelease(void *vparam) {

src/vnode/src/vnodeRead.c

@@ -357,7 +357,7 @@ static int32_t vnodeProcessFetchMsg(SVnodeObj *pVnode, SVReadMsg *pRead) {
 
   // kill current query and free corresponding resources.
   if (pRetrieve->free == 1) {
-    vWarn("vgId:%d, QInfo:%"PRIu64 "-%p, retrieve msg received to kill query and free qhandle", pVnode->vgId, pRetrieve->qId, *handle);
+    vWarn("vgId:%d, QInfo:%"PRIx64 "-%p, retrieve msg received to kill query and free qhandle", pVnode->vgId, pRetrieve->qId, *handle);
     qKillQuery(*handle);
     qReleaseQInfo(pVnode->qMgmt, (void **)&handle, true);
 

src/vnode/src/vnodeWrite.c

@@ -303,6 +303,17 @@ static int32_t vnodeWriteToWQueueImp(SVWriteMsg *pWrite) {
 }
 
 int32_t vnodeWriteToWQueue(void *vparam, void *wparam, int32_t qtype, void *rparam) {
+  SVnodeObj *pVnode = vparam;
+  if (qtype == TAOS_QTYPE_RPC) {
+   if (!vnodeInReadyStatus(pVnode)) {
+      return TSDB_CODE_APP_NOT_READY;  // it may be in deleting or closing state
+    }
+
+    if (pVnode->role != TAOS_SYNC_ROLE_MASTER) {
+      return TSDB_CODE_APP_NOT_READY;
+    }
+  }
+
   SVWriteMsg *pWrite = vnodeBuildVWriteMsg(vparam, wparam, qtype, rparam);
   if (pWrite == NULL) {
     assert(terrno != 0);

src/wal/src/walWrite.c

@@ -430,6 +430,8 @@ static int32_t walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp, ch
            pWal->vgId, fileId, pHead->version, pWal->version, pHead->len, offset);
 
     pWal->version = pHead->version;
+
+    //wInfo("writeFp: %ld", offset);
     (*writeFp)(pVnode, pHead, TAOS_QTYPE_WAL, NULL);
   }
 

tests/Jenkinsfile

@@ -29,8 +29,8 @@ pipeline {
   agent none
   environment{
     
-      WK = '/var/lib/jenkins/workspace/TDinternal'
+      WK = '/data/lib/jenkins/workspace/TDinternal'
-      WKC= '/var/lib/jenkins/workspace/TDinternal/community'
+      WKC= '/data/lib/jenkins/workspace/TDinternal/community'
   }
 
   stages {

tests/examples/c/CMakeLists.txt

@@ -5,6 +5,8 @@ IF (TD_LINUX)
   AUX_SOURCE_DIRECTORY(. SRC)
   ADD_EXECUTABLE(demo apitest.c)
   TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread )
+  ADD_EXECUTABLE(subscribe subscribe.c)
+  TARGET_LINK_LIBRARIES(subscribe taos_static trpc tutil pthread )
   ADD_EXECUTABLE(epoll epoll.c)
   TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread )
 ENDIF ()