Merge branch '3.0' into feat/sangshuduo/TD-14141-update-taostools-for3.0

2022-07-14 10:27:32 +08:00 · 2022-07-14 10:27:32 +08:00 · f19642f8b6
parent 4d602138ab 5b1cb74c99
commit f19642f8b6
786 changed files with 71081 additions and 37575 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -19,3 +19,6 @@
 [submodule "tools/taosadapter"]
 	path = tools/taosadapter
 	url = https://github.com/taosdata/taosadapter.git
 [submodule "tools/taosws-rs"]
 	path = tools/taosws-rs
 	url = https://github.com/taosdata/taosws-rs.git
--- a/30
+++ b/30
@ -127,6 +127,25 @@ def pre_test(){
    '''
    return 1
 }
 def pre_test_build_mac() {
    sh '''
        hostname
        date
    '''
    sh '''
        cd ${WK}
        rm -rf debug
        mkdir debug
    '''
    sh '''
        cd ${WK}/debug
        cmake ..
        make -j8
    '''
    sh '''
        date
    '''
 }
 def pre_test_win(){
    bat '''
        hostname
@ -334,6 +353,17 @@ pipeline {
                        }
                    }
                }
                stage('mac test') {
                    agent{label " Mac_catalina "}
                    steps {
                        catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
                            timeout(time: 20, unit: 'MINUTES'){
                                pre_test()
                                pre_test_build_mac()
                            }
                        }
                    }
                }
                stage('linux test') {
                    agent{label " worker03 || slave215 || slave217 || slave219 "}
                    options { skipDefaultCheckout() } 
--- a/README-CN.md
+++ b/README-CN.md
@ -1,38 +1,59 @@
 <p>
 <p align="center">
  <a href="https://tdengine.com" target="_blank">
  <img
    src="docs/assets/tdengine.svg"
    alt="TDengine"
    width="500"
  />
  </a>
 </p>
 <p>
 [![Build Status](https://travis-ci.org/taosdata/TDengine.svg?branch=master)](https://travis-ci.org/taosdata/TDengine)
 [![Build status](https://ci.appveyor.com/api/projects/status/kf3pwh2or5afsgl9/branch/master?svg=true)](https://ci.appveyor.com/project/sangshuduo/tdengine-2n8ge/branch/master)
 [![Coverage Status](https://coveralls.io/repos/github/taosdata/TDengine/badge.svg?branch=develop)](https://coveralls.io/github/taosdata/TDengine?branch=develop)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4201/badge)](https://bestpractices.coreinfrastructure.org/projects/4201)
 [![tdengine](https://snapcraft.io//tdengine/badge.svg)](https://snapcraft.io/tdengine)
-[![TDengine](TDenginelogo.png)](https://www.taosdata.com)
+简体中文 | [English](README.md) | 很多职位正在热招中，请看[这里](https://www.taosdata.com/cn/careers/)
 简体中文 | [English](./README.md) 
 # TDengine 简介
-TDengine是涛思数据专为物联网、车联网、工业互联网、IT运维等设计和优化的大数据平台。除核心的快10倍以上的时序数据库功能外，还提供缓存、数据订阅、流式计算等功能，最大程度减少研发和运维的复杂度，且核心代码，包括集群功能全部开源（开源协议，AGPL v3.0）。
+TDengine 是一款高性能、分布式、支持 SQL 的时序数据库（Time-Series Database）。而且除时序数据库功能外，它还提供缓存、数据订阅、流式计算等功能，最大程度减少研发和运维的复杂度，且核心代码，包括集群功能全部开源（开源协议，AGPL v3.0）。与其他时序数据数据库相比，TDengine 有以下特点：
- 10 倍以上性能提升。定义了创新的数据存储结构，单核每秒就能处理至少2万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快了十倍以上。
+- **高性能**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，而且存储空间也大为节省。
- 硬件或云服务成本降至1/5。由于超强性能，计算资源不到通用大数据方案的1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的1/10。
+
- 全栈时序数据处理引擎。将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成Kafka/Redis/HBase/Spark等软件，大幅降低应用开发和维护成本。
+- **分布式**：通过原生分布式的设计，TDengine 提供了水平扩展的能力，只需要增加节点就能获得更强的数据处理能力，同时通过多副本机制保证了系统的高可用。
- 强大的分析功能。无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过Shell/Python/R/Matlab随时进行。
+
- 与第三方工具无缝连接。不用一行代码，即可与Telegraf, Grafana, EMQ X, Prometheus, Matlab, R集成。后续还将支持MQTT, OPC, Hadoop，Spark等, BI工具也将无缝连接。
+- **支持 SQL**：TDengine 采用 SQL 作为数据查询语言，减少学习和迁移成本，同时提供 SQL 扩展来处理时序数据特有的分析，而且支持方便灵活的 schemaless 数据写入。
- 零运维成本、零学习成本。安装、集群一秒搞定，无需分库分表，实时备份。标准SQL，支持JDBC,RESTful，支持Python/Java/C/C++/Go/Node.JS, 与MySQL相似，零学习成本。
+
 - **All in One**：将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低应用开发和维护成本。
 - **零管理**：安装、集群几秒搞定，无任何依赖，不用分库分表，系统运行状态监测能与 Grafana 或其他运维工具无缝集成。
 - **零学习成本**：采用 SQL 查询语言，支持 Python、Java、C/C++、Go、Rust、Node.js 等多种编程语言，与 MySQL 相似，零学习成本。
 - **无缝集成**：不用一行代码，即可与 Telegraf、Grafana、EMQX、Prometheus、StatsD、collectd、Matlab、R 等第三方工具无缝集成。
 - **互动 Console**: 通过命令行 console，不用编程，执行 SQL 语句就能做即席查询、各种数据库的操作、管理以及集群的维护.
 TDengine 可以广泛应用于物联网、工业互联网、车联网、IT 运维、能源、金融等领域，让大量设备、数据采集器每天产生的高达 TB 甚至 PB 级的数据能得到高效实时的处理，对业务的运行状态进行实时的监测、预警，从大数据中挖掘出商业价值。
 # 文档
-TDengine是一个高效的存储、查询、分析时序大数据的平台，专为物联网、车联网、工业互联网、运维监测等优化而设计。您可以像使用关系型数据库MySQL一样来使用它，但建议您在使用前仔细阅读一遍下面的文档，特别是 [数据模型](https://www.taosdata.com/cn/documentation/architecture) 与 [数据建模](https://www.taosdata.com/cn/documentation/model)。除本文档之外，欢迎 [下载产品白皮书](https://www.taosdata.com/downloads/TDengine%20White%20Paper.pdf)。
+TDengine 采用传统的关系数据库模型，您可以像使用关系型数据库 MySQL 一样来使用它。但由于引入了超级表，一个采集点一张表的概念，建议您在使用前仔细阅读一遍下面的文档，特别是 [数据模型](https://www.taosdata.com/cn/documentation/architecture) 与 [数据建模](https://www.taosdata.com/cn/documentation/model)。除本文档之外，欢迎 [下载产品白皮书](https://www.taosdata.com/downloads/TDengine%20White%20Paper.pdf)。
 # 构建
-TDengine目前2.0版服务器仅能在Linux系统上安装和运行，后续会支持Windows、macOS等系统。客户端可以在Windows或Linux上安装和运行。任何OS的应用也可以选择RESTful接口连接服务器taosd。CPU支持X64/ARM64/MIPS64/Alpha64，后续会支持ARM32、RISC-V等CPU架构。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。本快速指南仅适用于通过源码安装。
+TDengine 目前 2.0 版服务器仅能在 Linux 系统上安装和运行，后续会支持 Windows、macOS 等系统。客户端可以在 Windows 或 Linux 上安装和运行。任何 OS 的应用也可以选择 RESTful 接口连接服务器 taosd。CPU 支持 X64/ARM64/MIPS64/Alpha64，后续会支持 ARM32、RISC-V 等 CPU 架构。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。本快速指南仅适用于通过源码安装。
 ## 安装工具
 ### Ubuntu 16.04 及以上版本 & Debian：
 ```bash
-sudo apt-get install -y gcc cmake build-essential git
+sudo apt-get install -y gcc cmake build-essential git libssl-dev
 ```
 ### Ubuntu 14.04：
@ -56,10 +77,22 @@ sudo apt-get install -y openjdk-8-jdk
 sudo apt-get install -y  maven
 ```
 #### 为 taos-tools 安装编译需要的软件
 taosTools 是用于 TDengine 的辅助工具软件集合。目前它包含 taosBenchmark（曾命名为 taosdemo）和 taosdump 两个软件。
 默认 TDengine 编译不包含 taosTools。您可以在编译 TDengine 时使用`cmake .. -DBUILD_TOOLS=true` 来同时编译 taosTools。
 为了在 Ubuntu/Debian 系统上编译 [taos-tools](https://github.com/taosdata/taos-tools) 需要安装如下软件：
 ```bash
 sudo apt install build-essential libjansson-dev libsnappy-dev liblzma-dev libz-dev pkg-config
 ```
 ### CentOS 7：
 ```bash
-sudo yum install -y gcc gcc-c++ make cmake git
+sudo yum install -y gcc gcc-c++ make cmake git openssl-devel
 ```
 安装 OpenJDK 8：
@ -74,10 +107,10 @@ sudo yum install -y java-1.8.0-openjdk
 sudo yum install -y maven
 ```
-### CentOS 8 & Fedora:
+### CentOS 8 & Fedora
 ```bash
-sudo dnf install -y gcc gcc-c++ make cmake epel-release git
+sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel
 ```
 安装 OpenJDK 8：
@ -92,6 +125,33 @@ sudo dnf install -y java-1.8.0-openjdk
 sudo dnf install -y maven
 ```
 #### 在 CentOS 上构建 taosTools 安装依赖软件
 为了在 CentOS 上构建 [taosTools](https://github.com/taosdata/taos-tools) 需要安装如下依赖软件
 ```bash
 sudo yum install zlib-devel xz-devel snappy-devel jansson jansson-devel pkgconfig libatomic libstdc++-static openssl-devel
 ```
 注意：由于 snappy 缺乏 pkg-config 支持
 （参考 [链接](https://github.com/google/snappy/pull/86)），会导致
 cmake 提示无法发现 libsnappy，实际上工作正常。
 ### 设置 golang 开发环境
 TDengine 包含数个使用 Go 语言开发的组件，请参考 golang.org 官方文档设置 go 开发环境。
 请使用 1.14 及以上版本。对于中国用户，我们建议使用代理来加速软件包下载。
 ```
 go env -w GO111MODULE=on
 go env -w GOPROXY=https://goproxy.cn,direct
 ```
 ### 设置 rust 开发环境
 TDengine 包含数个使用 Rust 语言开发的组件. 请参考 rust-lang.org 官方文档设置 rust 开发环境。
 ## 获取源码
 首先，你需要从 GitHub 克隆源码：
@ -107,22 +167,41 @@ Go 连接器和 Grafana 插件在其他独立仓库，如果安装它们的话
 git submodule update --init --recursive
 ```
 如果使用 https 协议下载比较慢，可以通过修改 ~/.gitconfig 文件添加以下两行设置使用 ssh 协议下载。需要首先上传 ssh 密钥到 GitHub，详细方法请参考 GitHub 官方文档。
 ```
 [url "git@github.com:"]
    insteadOf = https://github.com/
 ```
 ## 构建 TDengine
 ### Linux 系统
 可以运行代码仓库中的 `build.sh` 脚本编译出 TDengine 和 taosTools（包含 taosBenchmark 和 taosdump）。
 ```bash
-mkdir debug && cd debug
+./build.sh
 cmake .. && cmake --build .
 ```
-您可以选择使用 Jemalloc 作为内存分配器，替代默认的 glibc：
+这个脚本等价于执行如下命令：
 ```bash
 git submodule update --init --recursive
 mkdir debug
 cd debug
 cmake .. -DBUILD_TOOLS=true
 make
 ```
 您也可以选择使用 jemalloc 作为内存分配器，替代默认的 glibc：
 ```bash
 apt install autoconf
 cmake .. -DJEMALLOC_ENABLED=true
 ```
-在X86-64、X86、arm64、arm32 和 mips64 平台上，TDengine 生成脚本可以自动检测机器架构。也可以手动配置 CPUTYPE 参数来指定 CPU 类型，如 aarch64 或 aarch32 等。
+在 X86-64、X86、arm64、arm32 和 mips64 平台上，TDengine 生成脚本可以自动检测机器架构。也可以手动配置 CPUTYPE 参数来指定 CPU 类型，如 aarch64 或 aarch32 等。
 aarch64：
@ -157,7 +236,7 @@ nmake
 如果你使用的是 Visual Studio 2019 或 2017 版本：
-打开cmd.exe，执行 vcvarsall.bat 时，为 64 位操作系统指定“x64”，为 32 位操作系统指定“x86”。
+打开 cmd.exe，执行 vcvarsall.bat 时，为 64 位操作系统指定“x64”，为 32 位操作系统指定“x86”。
 ```bash
 mkdir debug && cd debug
@ -174,7 +253,7 @@ cmake .. -G "NMake Makefiles"
 nmake
 ```
-### Mac OS X 系统
+### macOS 系统
 安装 Xcode 命令行工具和 cmake. 在 Catalina 和 Big Sur 操作系统上，需要安装 XCode 11.4+ 版本。
@ -185,13 +264,17 @@ cmake .. && cmake --build .
 # 安装
-生成完成后，安装 TDengine（下文给出的指令以 Linux 为例，如果是在 Windows 下，那么对应的指令会是 `nmake install`）：
+## Linux 系统
 生成完成后，安装 TDengine：
 ```bash
 sudo make install
 ```
 用户可以在[文件目录结构](https://www.taosdata.com/cn/documentation/administrator#directories)中了解更多在操作系统中生成的目录或文件。
 从 2.0 版本开始, 从源代码安装也会为 TDengine 配置服务管理。
 用户也可以选择[从安装包中安装](https://www.taosdata.com/en/getting-started/#Install-from-Package)。
 安装成功后，在终端中启动 TDengine 服务：
@ -207,6 +290,40 @@ taos
 如果 TDengine Shell 连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印出错误消息。
 ## Windows 系统
 生成完成后，安装 TDengine：
 ```cmd
 nmake install
 ```
 ## macOS 系统
 生成完成后，安装 TDengine：
 ```bash
 sudo make install
 ```
 安装成功后，如果想以服务形式启动，先配置 `.plist` 文件，在终端中执行：
 ```bash
 sudo cp ../packaging/macOS/com.taosdata.tdengine.plist /Library/LaunchDaemons
 ```
 在终端中启动 TDengine 服务：
 ```bash
 sudo launchctl load /Library/LaunchDaemons/com.taosdata.tdengine.plist
 ```
 在终端中停止 TDengine 服务：
 ```bash
 sudo launchctl unload /Library/LaunchDaemons/com.taosdata.tdengine.plist
 ```
 ## 快速运行
 如果不希望以服务方式运行 TDengine，也可以在终端中直接运行它。也即在生成完成后，执行以下命令（在 Windows 下，生成的可执行文件会带有 .exe 后缀，例如会名为 taosd.exe ）：
@ -225,15 +342,15 @@ taos
 # 体验 TDengine
-在TDengine终端中，用户可以通过SQL命令来创建/删除数据库、表等，并进行插入查询操作。
+在 TDengine 终端中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行插入查询操作。
-```bash
+```sql
-create database demo;
+CREATE DATABASE demo;
-use demo;
+USE demo;
-create table t (ts timestamp, speed int);
+CREATE TABLE t (ts TIMESTAMP, speed INT);
-insert into t values ('2019-07-15 00:00:00', 10);
+INSERT INTO t VALUES('2019-07-15 00:00:00', 10);
-insert into t values ('2019-07-15 01:00:00', 20);
+INSERT INTO t VALUES('2019-07-15 01:00:00', 20);
-select * from t;
+SELECT * FROM t;
          ts          |   speed   |
 ===================================
 19-07-15 00:00:00.000|         10|
@ -245,33 +362,35 @@ Query OK, 2 row(s) in set (0.001700s)
 ## 官方连接器
-TDengine 提供了丰富的应用程序开发接口，其中包括C/C++、Java、Python、Go、Node.js、C# 、RESTful 等，便于用户快速开发应用：
+TDengine 提供了丰富的应用程序开发接口，其中包括 C/C++、Java、Python、Go、Node.js、C# 、RESTful 等，便于用户快速开发应用：
- Java
+- [Java](https://www.taosdata.com/cn/documentation/connector/java)
- C/C++
+- [C/C++](https://www.taosdata.com/cn/documentation/connector#c-cpp)
- Python
+- [Python](https://www.taosdata.com/cn/documentation/connector#python)
- Go
+- [Go](https://www.taosdata.com/cn/documentation/connector#go)
- RESTful API
+- [RESTful API](https://www.taosdata.com/cn/documentation/connector#restful)
- Node.js
+- [Node.js](https://www.taosdata.com/cn/documentation/connector#nodejs)
 - [Rust](https://www.taosdata.com/cn/documentation/connector/rust)
 ## 第三方连接器
 TDengine 社区生态中也有一些非常友好的第三方连接器，可以通过以下链接访问它们的源码。
- [Rust Connector](https://github.com/taosdata/TDengine/tree/master/tests/examples/rust)
+- [Rust Bindings](https://github.com/songtianyi/tdengine-rust-bindings/tree/master/examples)
 - [.Net Core Connector](https://github.com/maikebing/Maikebing.EntityFrameworkCore.Taos)
- [Lua Connector](https://github.com/taosdata/TDengine/tree/develop/tests/examples/lua)
+- [Lua Connector](https://github.com/taosdata/TDengine/tree/develop/examples/lua)
 # 运行和添加测试例
 TDengine 的测试框架和所有测试例全部开源。
-点击 [这里](tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md)，了解如何运行测试例和添加新的测试例。
+点击 [这里](https://github.com/taosdata/TDengine/blob/develop/tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md)，了解如何运行测试例和添加新的测试例。
 # 成为社区贡献者
@ -279,8 +398,8 @@ TDengine 的测试框架和所有测试例全部开源。
 # 加入技术交流群
-TDengine 官方社群「物联网大数据群」对外开放，欢迎您加入讨论。搜索微信号 "tdengine"，加小T为好友，即可入群。
+TDengine 官方社群「物联网大数据群」对外开放，欢迎您加入讨论。搜索微信号 "tdengine"，加小 T 为好友，即可入群。
-# [谁在使用TDengine](https://github.com/taosdata/TDengine/issues/2432)
+# [谁在使用 TDengine](https://github.com/taosdata/TDengine/issues/2432)
-欢迎所有 TDengine 用户及贡献者在 [这里](https://github.com/taosdata/TDengine/issues/2432) 分享您在当前工作中开发/使用 TDengine 的故事。 
+欢迎所有 TDengine 用户及贡献者在 [这里](https://github.com/taosdata/TDengine/issues/2432) 分享您在当前工作中开发/使用 TDengine 的故事。
--- a/README.md
+++ b/README.md
@ -1,116 +1,218 @@
 <p>
 <p align="center">
  <a href="https://tdengine.com" target="_blank">
  <img
    src="docs/assets/tdengine.svg"
    alt="TDengine"
    width="500"
  />
  </a>
 </p>
 <p>
 [![Build Status](https://cloud.drone.io/api/badges/taosdata/TDengine/status.svg?ref=refs/heads/master)](https://cloud.drone.io/taosdata/TDengine)
 [![Build status](https://ci.appveyor.com/api/projects/status/kf3pwh2or5afsgl9/branch/master?svg=true)](https://ci.appveyor.com/project/sangshuduo/tdengine-2n8ge/branch/master)
 [![Coverage Status](https://coveralls.io/repos/github/taosdata/TDengine/badge.svg?branch=develop)](https://coveralls.io/github/taosdata/TDengine?branch=develop)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4201/badge)](https://bestpractices.coreinfrastructure.org/projects/4201)
 [![tdengine](https://snapcraft.io//tdengine/badge.svg)](https://snapcraft.io/tdengine)
-[![TDengine](TDenginelogo.png)](https://www.taosdata.com)
+English | [简体中文](README-CN.md) | We are hiring, check [here](https://tdengine.com/careers)
 English | [简体中文](./README-CN.md) 
 # What is TDengine？
-TDengine is an open-sourced big data platform under [GNU AGPL v3.0](http://www.gnu.org/licenses/agpl-3.0.html), designed and optimized for the Internet of Things (IoT), Connected Cars, Industrial IoT, and IT Infrastructure and Application Monitoring. Besides the 10x faster time-series database, it provides caching, stream computing, message queuing and other functionalities to reduce the complexity and cost of development and operation.
+TDengine is a high-performance, scalable time-series database with SQL support. Its code including cluster feature is open source under [GNU AGPL v3.0](http://www.gnu.org/licenses/agpl-3.0.html). Besides the database, it provides caching, stream processing, data subscription and other functionalities to reduce the complexity and cost of development and operation. TDengine differentiates itself from other TSDBs with the following advantages.
- **10x Faster on Insert/Query Speeds**: Through the innovative design on storage, on a single-core machine, over 20K requests can be processed, millions of data points can be ingested, and over 10 million data points can be retrieved in a second. It is 10 times faster than other databases.
+- **High Performance**: TDengine outperforms other time series databases in data ingestion and querying while significantly reducing storage cost and compute costs, with an innovatively designed and purpose-built storage engine.
- **1/5 Hardware/Cloud Service Costs**: Compared with typical big data solutions, less than 1/5 of computing resources are required. Via column-based storage and tuned compression algorithms for different data types, less than 1/10 of storage space is needed.
+- **Scalable**: TDengine provides out-of-box scalability and high-availability through its native distributed design. Nodes can be added through simple configuration to achieve greater data processing power. In addition, this feature is open source.
- **Full Stack for Time-Series Data**: By integrating a database with message queuing, caching, and stream computing features together, it is no longer necessary to integrate Kafka/Redis/HBase/Spark or other software. It makes the system architecture much simpler and more robust.
+- **SQL Support**: TDengine uses SQL as the query language, thereby reducing learning and migration costs, while adding SQL extensions to handle time-series data better, and supporting convenient and flexible schemaless data ingestion.
- **Powerful Data Analysis**: Whether it is 10 years or one minute ago, data can be queried just by specifying the time range. Data can be aggregated over time, multiple time streams or both. Ad Hoc queries or analyses can be executed via TDengine shell, Python, R or Matlab.
+- **All in One**: TDengine has built-in caching, stream processing and data subscription functions, it is no longer necessary to integrate Kafka/Redis/HBase/Spark or other software in some scenarios. It makes the system architecture much simpler and easy to maintain.
- **Seamless Integration with Other Tools**: Telegraf, Grafana, Matlab, R, and other tools can be integrated with TDengine without a line of code. MQTT, OPC, Hadoop, Spark, and many others will be integrated soon.
+- **Seamless Integration**: Without a single line of code, TDengine provide seamless integration with third-party tools such as Telegraf, Grafana, EMQX, Prometheus, StatsD, collectd, etc. More will be integrated.
- **Zero Management, No Learning Curve**: It takes only seconds to download, install, and run it successfully; there are no other dependencies. Automatic partitioning on tables or DBs. Standard SQL is used, with C/C++, Python, JDBC, Go and RESTful connectors.
+- **Zero Management**: Installation and cluster setup can be done in seconds. Data partitioning and sharding are executed automatically. TDengine’s running status can be monitored via Grafana or other DevOps tools.
 - **Zero Learning Cost**: With SQL as the query language, support for ubiquitous tools like Python, Java, C/C++, Go, Rust, Node.js connectors, there is zero learning cost.
 - **Interactive Console**: TDengine provides convenient console access to the database to run ad hoc queries, maintain the database, or manage the cluster without any programming.
 TDengine can be widely applied to Internet of Things (IoT), Connected Vehicles, Industrial IoT, DevOps, energy, finance and many other scenarios.
 # Documentation
 For user manual, system design and architecture, engineering blogs, refer to [TDengine Documentation](https://www.taosdata.com/en/documentation/)(中文版请点击[这里](https://www.taosdata.com/cn/documentation20/))
- for details. The documentation from our website can also be downloaded locally from *documentation/tdenginedocs-en* or *documentation/tdenginedocs-cn*.
+for details. The documentation from our website can also be downloaded locally from _documentation/tdenginedocs-en_ or _documentation/tdenginedocs-cn_.
 # Building
 At the moment, TDengine only supports building and running on Linux systems. You can choose to [install from packages](https://www.taosdata.com/en/getting-started/#Install-from-Package) or from the source code. This quick guide is for installation from the source only.
-To build TDengine, use [CMake](https://cmake.org/) 2.8.12.x or higher versions in the project directory. 
+At the moment, TDengine server only supports running on Linux systems. You can choose to [install from packages](https://www.taosdata.com/en/getting-started/#Install-from-Package) or build it from the source code. This quick guide is for installation from the source only.
-## Install tools
+To build TDengine, use [CMake](https://cmake.org/) 3.0.2 or higher versions in the project directory.
 ## Install build dependencies
 ### Ubuntu 16.04 and above or Debian
 ### Ubuntu 16.04 and above & Debian:
 ```bash
-sudo apt-get install -y gcc cmake build-essential git
+sudo apt-get install -y gcc cmake build-essential git libssl-dev
 ```
-### Ubuntu 14.04:
+### Ubuntu 14.04
 ```bash
 sudo apt-get install -y gcc cmake3 build-essential git binutils-2.26
 export PATH=/usr/lib/binutils-2.26/bin:$PATH
 ```
-To compile and package the JDBC driver source code, you should have a Java jdk-8 or higher and Apache Maven 2.7 or higher installed. 
+To compile and package the JDBC driver source code, you should have a Java jdk-8 or higher and Apache Maven 2.7 or higher installed.
 To install openjdk-8:
 ```bash
 sudo apt-get install -y openjdk-8-jdk
 ```
 To install Apache Maven:
 ```bash
-sudo apt-get install -y  maven
+sudo apt-get install -y maven
 ```
-### Centos 7:
+#### Install build dependencies for taosTools
 We provide a few useful tools such as taosBenchmark (was named taosdemo) and taosdump. They were part of TDengine. From TDengine 2.4.0.0, taosBenchmark and taosdump were not released together with TDengine.
 By default, TDengine compiling does not include taosTools. You can use 'cmake .. -DBUILD_TOOLS=true' to make them be compiled with TDengine.
 To build the [taosTools](https://github.com/taosdata/taos-tools) on Ubuntu/Debian, the following packages need to be installed.
 ```bash
-sudo yum install -y gcc gcc-c++ make cmake git
+sudo apt install build-essential libjansson-dev libsnappy-dev liblzma-dev libz-dev pkg-config
 ```
 ### CentOS 7
 ```bash
 sudo yum install epel-release
 sudo yum update
 sudo yum install -y gcc gcc-c++ make cmake3 git openssl-devel
 sudo ln -sf /usr/bin/cmake3 /usr/bin/cmake
 ```
 To install openjdk-8:
 ```bash
 sudo yum install -y java-1.8.0-openjdk
 ```
 To install Apache Maven:
 ```bash
 sudo yum install -y maven
 ```
-### Centos 8 & Fedora:
+### CentOS 8 & Fedora
 ```bash
-sudo dnf install -y gcc gcc-c++ make cmake epel-release git
+sudo dnf install -y gcc gcc-c++ make cmake epel-release git openssl-devel
 ```
 To install openjdk-8:
 ```bash
 sudo dnf install -y java-1.8.0-openjdk
 ```
 To install Apache Maven:
 ```bash
 sudo dnf install -y maven
 ```
 #### Install build dependencies for taosTools on CentOS
 To build the [taosTools](https://github.com/taosdata/taos-tools) on CentOS, the following packages need to be installed.
 ```bash
 sudo yum install zlib-devel xz-devel snappy-devel jansson jansson-devel pkgconfig libatomic libstdc++-static openssl-devel
 ```
 Note: Since snappy lacks pkg-config support (refer to [link](https://github.com/google/snappy/pull/86)), it lead a cmake prompt libsnappy not found. But snappy will works well.
 ### Setup golang environment
 TDengine includes few components developed by Go language. Please refer to golang.org official documentation for golang environment setup.
 Please use version 1.14+. For the user in China, we recommend using a proxy to accelerate package downloading.
 ```
 go env -w GO111MODULE=on
 go env -w GOPROXY=https://goproxy.cn,direct
 ```
 ### Setup rust environment
 TDengine includees few compoments developed by Rust language. Please refer to rust-lang.org official documentation for rust environment setup.
 ## Get the source codes
 First of all, you may clone the source codes from github:
 ```bash
 git clone https://github.com/taosdata/TDengine.git
 cd TDengine
 ```
-The connectors for go & grafana have been moved to separated repositories,
+The connectors for go & Grafana and some tools have been moved to separated repositories,
 so you should run this command in the TDengine directory to install them:
 ```bash
 git submodule update --init --recursive
 ```
 You can modify the file ~/.gitconfig to use ssh protocol instead of https for better download speed. You need to upload ssh public key to GitHub first. Please refer to GitHub official documentation for detail.
 ```
 [url "git@github.com:"]
    insteadOf = https://github.com/
 ```
 ## Build TDengine
 ### On Linux platform
 You can run the bash script `build.sh` to build both TDengine and taosTools including taosBenchmark and taosdump as below:
 ```bash
-mkdir debug && cd debug
+./build.sh
-cmake .. && cmake --build .
+```
 It equals to execute following commands:
 ```bash
 git submodule update --init --recursive
 mkdir debug
 cd debug
 cmake .. -DBUILD_TOOLS=true
 make
 ```
 Note TDengine 2.3.x.0 and later use a component named 'taosAdapter' to play http daemon role by default instead of the http daemon embedded in the early version of TDengine. The taosAdapter is programmed by go language. If you pull TDengine source code to the latest from an existing codebase, please execute 'git submodule update --init --recursive' to pull taosAdapter source code. Please install go language version 1.14 or above for compiling taosAdapter. If you meet difficulties regarding 'go mod', especially you are from China, you can use a proxy to solve the problem.
 ```
 go env -w GO111MODULE=on
 go env -w GOPROXY=https://goproxy.cn,direct
 ```
 The embedded http daemon still be built from TDengine source code by default. Or you can use the following command to choose to build taosAdapter.
 ```
 cmake .. -DBUILD_HTTP=false
 ```
 You can use Jemalloc as memory allocator instead of glibc:
 ```
 apt install autoconf
 cmake .. -DJEMALLOC_ENABLED=true
@ -120,16 +222,19 @@ TDengine build script can detect the host machine's architecture on X86-64, X86,
 You can also specify CPUTYPE option like aarch64 or aarch32 too if the detection result is not correct:
 aarch64:
 ```bash
 cmake .. -DCPUTYPE=aarch64 && cmake --build .
 ```
 aarch32:
 ```bash
 cmake .. -DCPUTYPE=aarch32 && cmake --build .
 ```
 mips64:
 ```bash
 cmake .. -DCPUTYPE=mips64 && cmake --build .
 ```
@ -138,6 +243,7 @@ cmake .. -DCPUTYPE=mips64 && cmake --build .
 If you use the Visual Studio 2013, please open a command window by executing "cmd.exe".
 Please specify "amd64" for 64 bits Windows or specify "x86" is for 32 bits Windows when you execute vcvarsall.bat.
 ```cmd
 mkdir debug && cd debug
 "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat" < amd64 | x86 >
@ -158,13 +264,14 @@ nmake
 ```
 Or, you can simply open a command window by clicking Windows Start -> "Visual Studio < 2019 | 2017 >" folder -> "x64 Native Tools Command Prompt for VS < 2019 | 2017 >" or "x86 Native Tools Command Prompt for VS < 2019 | 2017 >" depends what architecture your Windows is, then execute commands as follows:
 ```cmd
 mkdir debug && cd debug
 cmake .. -G "NMake Makefiles"
 nmake
 ```
-### On Mac OS X platform
+### On macOS platform
 Please install XCode command line tools and cmake. Verified with XCode 11.4+ on Catalina and Big Sur.
@ -175,7 +282,10 @@ cmake .. && cmake --build .
 # Installing
-After building successfully, TDengine can be installed by: (On Windows platform, the following command should be `nmake install`)
+## On Linux platform
 After building successfully, TDengine can be installed by
 ```bash
 sudo make install
 ```
@ -184,68 +294,129 @@ Users can find more information about directories installed on the system in the
 Users can also choose to [install from packages](https://www.taosdata.com/en/getting-started/#Install-from-Package) for it.
 To start the service after installation, in a terminal, use:
 ```bash
 sudo systemctl start taosd
 ```
 Then users can use the [TDengine shell](https://www.taosdata.com/en/getting-started/#TDengine-Shell) to connect the TDengine server. In a terminal, use:
 ```bash
 taos
 ```
 If TDengine shell connects the server successfully, welcome messages and version info are printed. Otherwise, an error message is shown.
 ### Install TDengine by apt-get
 If you use Debian or Ubuntu system, you can use 'apt-get' command to install TDengine from official repository. Please use following commands to setup:
 ```
 wget -qO - http://repos.taosdata.com/tdengine.key | sudo apt-key add -
 echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-stable stable main" | sudo tee /etc/apt/sources.list.d/tdengine-stable.list
 [Optional] echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-beta beta main" | sudo tee /etc/apt/sources.list.d/tdengine-beta.list
 sudo apt-get update
 apt-cache policy tdengine
 sudo apt-get install tdengine
 ```
 ## On Windows platform
 After building successfully, TDengine can be installed by:
 ```cmd
 nmake install
 ```
 ## On macOS platform
 After building successfully, TDengine can be installed by:
 ```bash
 sudo make install
 ```
 To start the service after installation, config `.plist` file first, in a terminal, use:
 ```bash
 sudo cp ../packaging/macOS/com.taosdata.tdengine.plist /Library/LaunchDaemons
 ```
 To start the service, in a terminal, use:
 ```bash
 sudo launchctl load /Library/LaunchDaemons/com.taosdata.tdengine.plist
 ```
 To stop the service, in a terminal, use:
 ```bash
 sudo launchctl unload /Library/LaunchDaemons/com.taosdata.tdengine.plist
 ```
 ## Quick Run
 If you don't want to run TDengine as a service, you can run it in current shell. For example, to quickly start a TDengine server after building, run the command below in terminal: (We take Linux as an example, command on Windows will be `taosd.exe`)
 ```bash
 ./build/bin/taosd -c test/cfg
 ```
 In another terminal, use the TDengine shell to connect the server:
 ```bash
 ./build/bin/taos -c test/cfg
 ```
-option "-c test/cfg" specifies the system configuration file directory. 
+option "-c test/cfg" specifies the system configuration file directory.
 # Try TDengine
 It is easy to run SQL commands from TDengine shell which is the same as other SQL databases.
 ```sql
-create database db;
+CREATE DATABASE demo;
-use db;
+USE demo;
-create table t (ts timestamp, a int);
+CREATE TABLE t (ts TIMESTAMP, speed INT);
-insert into t values ('2019-07-15 00:00:00', 1);
+INSERT INTO t VALUES('2019-07-15 00:00:00', 10);
-insert into t values ('2019-07-15 01:00:00', 2);
+INSERT INTO t VALUES('2019-07-15 01:00:00', 20);
-select * from t;
+SELECT * FROM t;
-drop database db;
+          ts          |   speed   |
 ===================================
 19-07-15 00:00:00.000|         10|
 19-07-15 01:00:00.000|         20|
 Query OK, 2 row(s) in set (0.001700s)
 ```
 # Developing with TDengine
-### Official Connectors
+
 ## Official Connectors
 TDengine provides abundant developing tools for users to develop on TDengine. Follow the links below to find your desired connectors and relevant documentation.
- [Java](https://www.taosdata.com/en/documentation/connector/#Java-Connector)
+- [Java](https://www.taosdata.com/en/documentation/connector/java)
- [C/C++](https://www.taosdata.com/en/documentation/connector/#C/C++-Connector)
+- [C/C++](https://www.taosdata.com/en/documentation/connector#c-cpp)
- [Python](https://www.taosdata.com/en/documentation/connector/#Python-Connector)
+- [Python](https://www.taosdata.com/en/documentation/connector#python)
- [Go](https://www.taosdata.com/en/documentation/connector/#Go-Connector)
+- [Go](https://www.taosdata.com/en/documentation/connector#go)
- [RESTful API](https://www.taosdata.com/en/documentation/connector/#RESTful-Connector)
+- [RESTful API](https://www.taosdata.com/en/documentation/connector#restful)
- [Node.js](https://www.taosdata.com/en/documentation/connector/#Node.js-Connector)
+- [Node.js](https://www.taosdata.com/en/documentation/connector#nodejs)
 - [Rust](https://www.taosdata.com/en/documentation/connector/rust)
-### Third Party Connectors
+## Third Party Connectors
 The TDengine community has also kindly built some of their own connectors! Follow the links below to find the source code for them.
- [Rust Connector](https://github.com/taosdata/TDengine/tree/master/tests/examples/rust)
+- [Rust Bindings](https://github.com/songtianyi/tdengine-rust-bindings/tree/master/examples)
 - [.Net Core Connector](https://github.com/maikebing/Maikebing.EntityFrameworkCore.Taos)
 - [Lua Connector](https://github.com/taosdata/TDengine/tree/develop/tests/examples/lua)
-# How to run the test cases and how to add a new test case?
+# How to run the test cases and how to add a new test case
-  TDengine's test framework and all test cases are fully open source.
+
-  Please refer to [this document](tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md) for how to run test and develop new test case.
+TDengine's test framework and all test cases are fully open source.
 Please refer to [this document](https://github.com/taosdata/TDengine/blob/develop/tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md) for how to run test and develop new test case.
 # TDengine Roadmap
 - Support event-driven stream computing
 - Support user defined functions
 - Support MQTT connection
--- a/cmake/cmake.define
+++ b/cmake/cmake.define
@ -18,6 +18,14 @@ if (NOT DEFINED TD_GRANT)
  SET(TD_GRANT FALSE)
 endif()
 IF ("${WEBSOCKET}" MATCHES "true")
    SET(TD_WEBSOCKET TRUE)
    MESSAGE("Enable websocket")
    ADD_DEFINITIONS(-DWEBSOCKET)
 ELSE ()
    SET(TD_WEBSOCKET FALSE)
 ENDIF ()
 IF ("${BUILD_HTTP}" STREQUAL "")
  IF (TD_LINUX)
    IF (TD_ARM_32)
@ -97,13 +105,13 @@ ELSE ()
        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GCC_COVERAGE_COMPILE_FLAGS} ${GCC_COVERAGE_LINK_FLAGS}")
    ENDIF ()
-    IF (${SANITIZER} MATCHES "true")
+    IF (${BUILD_SANITIZER})
-        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}     -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3")
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}     -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
-	MESSAGE(STATUS "Will compile with Address Sanitizer!")
+	      MESSAGE(STATUS "Will compile with Address Sanitizer!")
    ELSE ()
-        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3")
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=0")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -g3")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=0")
    ENDIF ()
    MESSAGE("System processor ID: ${CMAKE_SYSTEM_PROCESSOR}")
--- a/cmake/cmake.options
+++ b/cmake/cmake.options
@ -51,6 +51,13 @@ IF(${TD_WINDOWS})
        "If build unit tests using googletest" 
        ON
    )
 ELSEIF (TD_DARWIN_64)
    add_definitions(-DCOMPILER_SUPPORTS_CXX13)
    option(
        BUILD_TEST
        "If build unit tests using googletest"
        ON
    )
 ELSE ()
    include(CheckCXXCompilerFlag)
    CHECK_CXX_COMPILER_FLAG("-std=c++13" COMPILER_SUPPORTS_CXX13)
@ -70,6 +77,12 @@ ELSE ()
    ENDIF ()
 ENDIF ()
 option(
    BUILD_SANITIZER
    "If build addr2line"
    OFF
    )
 option(
    BUILD_ADDR2LINE
    "If build addr2line"
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@ -118,6 +118,7 @@ execute_process(COMMAND "${CMAKE_COMMAND}" --build .
 # ================================================================================================
 # googletest
 if(${BUILD_TEST})
    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
    add_subdirectory(googletest EXCLUDE_FROM_ALL)
    target_include_directories(
        gtest
@ -259,7 +260,7 @@ if(${BUILD_MSVCREGEX})
    SET_TARGET_PROPERTIES(msvcregex PROPERTIES OUTPUT_NAME msvcregex)
 endif(${BUILD_MSVCREGEX})
-# msvcregex
+# wcwidth
 if(${BUILD_WCWIDTH})
    add_library(wcwidth STATIC "")
    target_sources(wcwidth
--- a/contrib/test/CMakeLists.txt
+++ b/contrib/test/CMakeLists.txt
@ -24,3 +24,4 @@ if(${BUILD_WITH_TRAFT})
 endif(${BUILD_WITH_TRAFT})
 add_subdirectory(tdev)
 add_subdirectory(lz4)
--- a/contrib/test/lz4/CMakeLists.txt
+++ b/contrib/test/lz4/CMakeLists.txt
@ -0,0 +1,6 @@
 add_executable(lz4_test "")
 target_sources(lz4_test
    PRIVATE
    "main.c"
 )
 target_link_libraries(lz4_test lz4_static)
--- a/contrib/test/lz4/main.c
+++ b/contrib/test/lz4/main.c
@ -0,0 +1,8 @@
 #include <stdio.h>
 #include "lz4.h"
 int main(int argc, char const *argv[]) {
  printf("%d\n", LZ4_compressBound(1024));
  return 0;
 }
--- a/docs/en/07-develop/02-model/index.mdx
+++ b/docs/en/07-develop/02-model/index.mdx
@ -9,15 +9,15 @@ The data model employed by TDengine is similar to that of a relational database.
 The [characteristics of time-series data](https://www.taosdata.com/blog/2019/07/09/86.html) from different data collection points may be different. Characteristics include collection frequency, retention policy and others which determine how you create and configure the database. For e.g. days to keep, number of replicas, data block size, whether data updates are allowed and other configurable parameters would be determined by the characteristics of your data and your business requirements. For TDengine to operate with the best performance, we strongly recommend that you create and configure different databases for data with different characteristics. This allows you, for example, to set up different storage and retention policies. When creating a database, there are a lot of parameters that can be configured such as, the days to keep data, the number of replicas, the number of memory blocks, time precision, the minimum and maximum number of rows in each data block, whether compression is enabled, the time range of the data in single data file and so on. Below is an example of the SQL statement to create a database.
 ```sql
-CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 6 UPDATE 1;
+CREATE DATABASE power KEEP 365 DURATION 10 BUFFER 16 VGROUPS 100 WAL 1;
 ```
 In the above SQL statement:
 - a database named "power" will be created
 - the data in it will be kept for 365 days, which means that data older than 365 days will be deleted automatically
 - a new data file will be created every 10 days
- the number of memory blocks is 6
+- the size of memory cache for writing is 16 MB
- data is allowed to be updated
+- data will be firstly written to WAL without FSYNC
 For more details please refer to [Database](/taos-sql/database).
@ -30,7 +30,6 @@ USE power;
 :::note
 - Any table or STable must belong to a database. To create a table or STable, the database it belongs to must be ready.
 - JOIN operations can't be performed on tables from two different databases.
 - Timestamp needs to be specified when inserting rows or querying historical rows.
 :::
@ -52,7 +51,7 @@ Similar to creating a regular table, when creating a STable, the name and schema
 For each kind of data collection point, a corresponding STable must be created. There may be many STables in an application. For electrical power system, we need to create a STable respectively for meters, transformers, busbars, switches. There may be multiple kinds of data collection points on a single device, for example there may be one data collection point for electrical data like current and voltage and another data collection point for environmental data like temperature, humidity and wind direction. Multiple STables are required for these kinds of devices.
-At most 4096 (or 1024 prior to version 2.1.7.0) columns are allowed in a STable. If there are more than 4096 of metrics to be collected for a data collection point, multiple STables are required. There can be multiple databases in a system, while one or more STables can exist in a database.
+At most 4096 columns are allowed in a STable. If there are more than 4096 of metrics to be collected for a data collection point, multiple STables are required. There can be multiple databases in a system, while one or more STables can exist in a database.
 ## Create Table
@ -66,12 +65,11 @@ In the above SQL statement, "d1001" is the table name, "meters" is the STable na
 In the TDengine system, it's recommended to create a table for a data collection point via STable. A table created via STable is called subtable in some parts of the TDengine documentation. All SQL commands applied on regular tables can be applied on subtables.
 :::warning
 It's not recommended to create a table in a database while using a STable from another database as template.
 :::tip
 It's suggested to use the globally unique ID of a data collection point as the table name. For example the device serial number could be used as a unique ID. If a unique ID doesn't exist, multiple IDs that are not globally unique can be combined to form a globally unique ID. It's not recommended to use a globally unique ID as tag value.
 :::
 ## Create Table Automatically
 In some circumstances, it's unknown whether the table already exists when inserting rows. The table can be created automatically using the SQL statement below, and nothing will happen if the table already exists.
--- a/docs/en/07-develop/03-insert-data/01-sql-writing.mdx
+++ b/docs/en/07-develop/03-insert-data/01-sql-writing.mdx
@ -42,7 +42,7 @@ INSERT INTO d1001 VALUES (1538548684000, 10.2, 220, 0.23) (1538548696650, 10.3,
 ### Insert into Multiple Tables
-Data can be inserted into multiple tables in the same SQL statement. The example below inserts 2 rows into table "d1001" and 1 row into table "d1002".
+Data can be inserted into multiple tables in single SQL statement. The example below inserts 2 rows into table "d1001" and 1 row into table "d1002".
 ```sql
 INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) d1002 VALUES (1538548696800, 12.3, 221, 0.31);
@ -52,15 +52,15 @@ For more details about `INSERT` please refer to [INSERT](/taos-sql/insert).
 :::info
- Inserting in batches can improve performance. Normally, the higher the batch size, the better the performance. Please note that a single row can't exceed 48K bytes and each SQL statement can't exceed 1MB.
+- Inserting in batches can improve performance. Normally, the higher the batch size, the better the performance. Please note that a single row can't exceed 48 KB bytes and each SQL statement can't exceed 1 MB.
- Inserting with multiple threads can also improve performance. However, depending on the system resources on the application side and the server side, when the number of inserting threads grows beyond a specific point the performance may drop instead of improving. The proper number of threads needs to be tested in a specific environment to find the best number.
+- Inserting with multiple threads can also improve performance. However, depending on the system resources on the application side and the server side, when the number of inserting threads grows beyond a specific point the performance may drop instead of improving. The proper number of threads needs to be tested in a specific environment to find the best number. The proper number of threads may be impacted by the system resources on the server side, the system resources on the client side, the table schemas, etc. 
 :::
 :::warning
- If the timestamp for the row to be inserted already exists in the table, the behavior depends on the value of parameter `UPDATE`. If it's set to 0 (the default value), the row will be discarded. If it's set to 1, the new values will override the old values for the same row.
+- If the timestamp for the row to be inserted already exists in the table, the old data will be overritten by the new values for the columns for which new values are provided, columns for which no new values are provided are not impacted.
- The timestamp to be inserted must be newer than the timestamp of subtracting current time by the parameter `KEEP`. If `KEEP` is set to 3650 days, then the data older than 3650 days ago can't be inserted. The timestamp to be inserted can't be newer than the timestamp of current time plus parameter `DAYS`. If `DAYS` is set to 2, the data newer than 2 days later can't be inserted.
+- The timestamp to be inserted must be newer than the timestamp of subtracting current time by the parameter `KEEP`. If `KEEP` is set to 3650 days, then the data older than 3650 days ago can't be inserted. The timestamp to be inserted can't be newer than the timestamp of current time plus parameter `DURATION`. If `DAYS` is set to 2, the data newer than 2 days later can't be inserted.
 :::
@ -101,7 +101,7 @@ For more details about `INSERT` please refer to [INSERT](/taos-sql/insert).
 ### Insert with Parameter Binding
-TDengine also provides API support for parameter binding. Similar to MySQL, only `?` can be used in these APIs to represent the parameters to bind. From version 2.1.1.0 and 2.1.2.0, parameter binding support for inserting data has improved significantly to improve the insert performance by avoiding the cost of parsing SQL statements.
+TDengine also provides API support for parameter binding. Similar to MySQL, only `?` can be used in these APIs to represent the parameters to bind. Parameter binding support for inserting data has improved significantly to improve the insert performance by avoiding the cost of parsing SQL statements.
 Parameter binding is available only with native connection.
--- a/docs/en/12-taos-sql/02-database.md
+++ b/docs/en/12-taos-sql/02-database.md
@ -32,7 +32,6 @@ CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep] [DAYS days] [UPDATE 1];
   - cacheLast: [Description](/reference/config/#cachelast)
   - replica: [Description](/reference/config/#replica)
   - quorum: [Description](/reference/config/#quorum)
   - maxVgroupsPerDb: [Description](/reference/config/#maxvgroupsperdb)
   - comp: [Description](/reference/config/#comp)
   - precision: [Description](/reference/config/#precision)
 6. Please note that all of the parameters mentioned in this section are configured in configuration file `taos.cfg` on the TDengine server. If not specified in the `create database` statement, the values from taos.cfg are used by default. To override default parameters, they must be specified in the `create database` statement.
--- a/docs/en/25-application/03-immigrate.md
+++ b/docs/en/25-application/03-immigrate.md
@ -379,11 +379,11 @@ We still use the hypothetical environment from Chapter 4. There are three measur
 ### Storage resource estimation
-Assuming that the number of sensor devices that generate data and need to be stored is `n`, the frequency of data generation is `t` per second, and the length of each record is `L` bytes, the scale of data generated per day is `n * t * L` bytes. Assuming the compression ratio is `C`, the daily data size is `(n * t * L)/C` bytes. The storage resources are estimated to accommodate the data scale for 1.5 years. In the production environment, the compression ratio C of TDengine is generally between 5 and 7.
+Assuming that the number of sensor devices that generate data and need to be stored is `n`, the frequency of data generation is `t` per second, and the length of each record is `L` bytes, the scale of data generated per day is `86400 * n * t * L` bytes. Assuming the compression ratio is `C`, the daily data size is `(86400 * n * t * L)/C` bytes. The storage resources are estimated to accommodate the data scale for 1.5 years. In the production environment, the compression ratio C of TDengine is generally between 5 and 7.
 With additional 20% redundancy, you can calculate the required storage resources:
 ```matlab
-(n * t * L) * (365 * 1.5) * (1+20%)/C
+(86400 * n * t * L) * (365 * 1.5) * (1+20%)/C
 ````
 Substituting in the above formula, the raw data generated every year is 11.8TB without considering the label information. Note that tag information is associated with each timeline in TDengine, not every record. The amount of data to be recorded is somewhat reduced relative to the generated data, and label data can be ignored as a whole. Assuming a compression ratio of 5, the size of the retained data ends up being 2.56 TB.
--- a/docs/zh/07-develop/02-model/index.mdx
+++ b/docs/zh/07-develop/02-model/index.mdx
@ -8,13 +8,13 @@ TDengine 采用类关系型数据模型，需要建库、建表。因此对于
 ## 创建库
-不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为了在各种场景下 TDengine 都能最大效率的工作，TDengine 建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除 SQL 标准的选项外，还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
+不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为了在各种场景下 TDengine 都能最大效率的工作，TDengine 建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除 SQL 标准的选项外，还可以指定保留时长、副本数、缓存大小、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
 ```sql
-CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 6 UPDATE 1;
+CREATE DATABASE power KEEP 365 DURATION 10 BUFFER 16 VGROUPS 100 WAL 1;
 ```
-上述语句将创建一个名为 power 的库，这个库的数据将保留 365 天（超过 365 天将被自动删除），每 10 天一个数据文件，内存块数为 6，允许更新数据。详细的语法及参数请见 [数据库管理](/taos-sql/database) 章节。
+上述语句将创建一个名为 power 的库，这个库的数据将保留 365 天（超过 365 天将被自动删除），每 10 天一个数据文件，每个 VNODE 的写入内存池的大小为 16 MB，数据库的 VGROUPS 数量，对该数据库入会写 WAL 但不执行 FSYNC。详细的语法及参数请见 [数据库管理](/taos-sql/database) 章节。
 创建库之后，需要使用 SQL 命令 `USE` 将当前库切换过来，例如：
@ -27,7 +27,6 @@ USE power;
 :::note
 - 任何一张表或超级表必须属于某个库，在创建表之前，必须先创建库。
 - 处于两个不同库的表是不能进行 JOIN 操作的。
 - 创建并插入记录、查询历史记录的时候，均需要指定时间戳。
 :::
@ -40,15 +39,11 @@ USE power;
 CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);
 ```
 :::note
 这一指令中的 STABLE 关键字，在 2.0.15 之前的版本中需写作 TABLE 。
 :::
 与创建普通表一样，创建超级表时，需要提供表名（示例中为 meters），表结构 Schema，即数据列的定义。第一列必须为时间戳（示例中为 ts)，其他列为采集的物理量（示例中为 current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的 schema (示例中为 location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组 ID、管理员 ID 等等。标签的 schema 可以事后增加、删除、修改。具体定义以及细节请见 [TAOS SQL 的超级表管理](/taos-sql/stable) 章节。
 每一种类型的数据采集点需要建立一个超级表，因此一个物联网系统，往往会有多个超级表。对于电网，我们就需要对智能电表、变压器、母线、开关等都建立一个超级表。在物联网中，一个设备就可能有多个数据采集点（比如一台风力发电的风机，有的采集点采集电流、电压等电参数，有的采集点采集温度、湿度、风向等环境参数），这个时候，对这一类型的设备，需要建立多张超级表。
-一张超级表最多容许 4096 列 （在 2.1.7.0 版本之前，列数限制为 1024 列），如果一个采集点采集的物理量个数超过 4096，需要建多张超级表来处理。一个系统可以有多个 DB，一个 DB 里可以有一到多个超级表。
+一张超级表最多容许 4096 列，如果一个采集点采集的物理量个数超过 4096，需要建多张超级表来处理。一个系统可以有多个 DB，一个 DB 里可以有一到多个超级表。
 ## 创建表
@ -60,11 +55,6 @@ CREATE TABLE d1001 USING meters TAGS ("California.SanFrancisco", 2);
 其中 d1001 是表名，meters 是超级表的表名，后面紧跟标签 Location 的具体标签值 "California.SanFrancisco"，标签 groupId 的具体标签值 2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 [TAOS SQL 的表管理](/taos-sql/table) 章节。
 :::warning
 目前 TDengine 没有从技术层面限制使用一个 database (db1) 的超级表作为模板建立另一个 database (db2) 的子表，后续会禁止这种用法，不建议使用这种方法建表。
 :::
 TDengine 建议将数据采集点的全局唯一 ID 作为表名(比如设备序列号）。但对于有的场景，并没有唯一的 ID，可以将多个 ID 组合成一个唯一的 ID。不建议将具有唯一性的 ID 作为标签值。
 ### 自动建表
--- a/docs/zh/07-develop/03-insert-data/01-sql-writing.mdx
+++ b/docs/zh/07-develop/03-insert-data/01-sql-writing.mdx
@ -52,15 +52,15 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 :::info
- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过 48K，一条 SQL 语句总长度不能超过 1M 。
+- 要提高写入效率，需要批量写入。一般来说一批写入的记录条数越多，插入效率就越高。但一条记录不能超过 48K，一条 SQL 语句总长度不能超过 1M 。
- TDengine 支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开 20 个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程频繁切换，带来额外开销。
+- TDengine 支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开多个同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程频繁切换，会带来额外开销，合适的线程数量与服务端的处理能力，服务端的具体配置，数据库的参数，数据定义的 Schema，写入数据的 Batch Size 等很多因素相关。一般来说，服务端和客户端处理能力越强，所能支持的并发写入的线程可以越多；数据库配置时的 vgroups 越多（但仍然要在服务端的处理能力以内）则所能支持的并发写入越多；数据定义的 Schema 越简单，所能支持的并发写入越多。
 :::
 :::warning
- 对同一张表，如果新插入记录的时间戳已经存在，默认情形下（UPDATE=0）新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。如果在创建数据库时使用了 UPDATE 1 选项，插入相同时间戳的新记录将覆盖原有记录。
+- 对同一张表，如果新插入记录的时间戳已经存在，则指定了新值的列会用新值覆盖旧值，而没有指定新值的列则不受影响。
- 写入的数据的时间戳必须大于当前时间减去配置参数 keep 的时间。如果 keep 配置为 3650 天，那么无法写入比 3650 天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数 days。如果 days 为 2，那么无法写入比当前时间还晚 2 天的数据。
+- 写入的数据的时间戳必须大于当前时间减去配置参数 keep 的时间。如果 keep 配置为 3650 天，那么无法写入比 3650 天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数 duration。如果 duration 为 2，那么无法写入比当前时间还晚 2 天的数据。
 :::
@ -104,7 +104,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 ### 参数绑定写入
-TDengine 也提供了支持参数绑定的 Prepare API，与 MySQL 类似，这些 API 目前也仅支持用问号 `?` 来代表待绑定的参数。从 2.1.1.0 和 2.1.2.0 版本开始，TDengine 大幅改进了参数绑定接口对数据写入（INSERT）场景的支持。这样在通过参数绑定接口写入数据时，就避免了 SQL 语法解析的资源消耗，从而在绝大多数情况下显著提升写入性能。
+TDengine 也提供了支持参数绑定的 Prepare API，与 MySQL 类似，这些 API 目前也仅支持用问号 `?` 来代表待绑定的参数。在通过参数绑定接口写入数据时，就避免了 SQL 语法解析的资源消耗，从而在绝大多数情况下显著提升写入性能。
 需要注意的是，只有使用原生连接的连接器，才能使用参数绑定功能。
--- a/docs/zh/12-taos-sql/02-database.md
+++ b/docs/zh/12-taos-sql/02-database.md
@ -32,7 +32,6 @@ CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep] [DAYS days] [UPDATE 1];
   - cacheLast: [详细说明](/reference/config/#cachelast)
   - replica: [详细说明](/reference/config/#replica)
   - quorum: [详细说明](/reference/config/#quorum)
   - maxVgroupsPerDb: [详细说明](/reference/config/#maxvgroupsperdb)
   - comp: [详细说明](/reference/config/#comp)
   - precision: [详细说明](/reference/config/#precision)
 6. 请注意上面列出的所有参数都可以配置在配置文件 `taosd.cfg` 中作为创建数据库时使用的默认配置， `create database` 的参数中明确指定的会覆盖配置文件中的设置。
--- a/docs/zh/25-application/03-immigrate.md
+++ b/docs/zh/25-application/03-immigrate.md
@ -367,10 +367,10 @@ WHERE ts>=1510560000 AND ts<=1515000009
 ### 存储资源估算
-假设产生数据并需要存储的传感器设备数量为 `n`，数据生成的频率为`t`条/秒，每条记录的长度为 `L` bytes，则每天产生的数据规模为 `n×t×L` bytes。假设压缩比为 C，则每日产生数据规模为 `(n×t×L)/C` bytes。存储资源预估为能够容纳 1.5 年的数据规模，生产环境下 TDengine 的压缩比 C 一般在 5 ~ 7 之间，同时为最后结果增加 20% 的冗余，可计算得到需要存储资源：
+假设产生数据并需要存储的传感器设备数量为 `n`，数据生成的频率为`t`条/秒，每条记录的长度为 `L` bytes，则每天产生的数据规模为 `86400×n×t×L` bytes。假设压缩比为 C，则每日产生数据规模为 `(86400×n×t×L)/C` bytes。存储资源预估为能够容纳 1.5 年的数据规模，生产环境下 TDengine 的压缩比 C 一般在 5 ~ 7 之间，同时为最后结果增加 20% 的冗余，可计算得到需要存储资源：
 ```matlab
-(n×t×L)×(365×1.5)×(1+20%)/C
+(86400×n×t×L)×(365×1.5)×(1+20%)/C
 ```
 结合以上的计算公式，将参数带入计算公式，在不考虑标签信息的情况下，每年产生的原始数据规模是 11.8TB。需要注意的是，由于标签信息在 TDengine 中关联到每个时间线，并不是每条记录。所以需要记录的数据量规模相对于产生的数据有一定的降低，而这部分标签数据整体上可以忽略不记。假设压缩比为 5，则保留的数据规模最终为 2.56 TB。
--- a/examples/c/stream_demo.c
+++ b/examples/c/stream_demo.c
@ -98,10 +98,10 @@ int32_t create_stream() {
  /*const char* sql = "select min(k), max(k), sum(k) as sum_of_k from st1";*/
  /*const char* sql = "select sum(k) from tu1 interval(10m)";*/
  /*pRes = tmq_create_stream(pConn, "stream1", "out1", sql);*/
-  pRes = taos_query(
+  pRes =
-      pConn,
+      taos_query(pConn,
-      "create stream stream1 trigger max_delay 10s into outstb as select _wstartts, sum(k) from st1 partition "
+                 "create stream stream1 trigger max_delay 10s into outstb as select _wstart, sum(k) from st1 partition "
-      "by tbname session(ts, 10s) ");
+                 "by tbname session(ts, 10s) ");
  if (taos_errno(pRes) != 0) {
    printf("failed to create stream stream1, reason:%s\n", taos_errstr(pRes));
    return -1;
--- a/examples/c/tmq.c
+++ b/examples/c/tmq.c
@ -18,6 +18,7 @@
 #include <string.h>
 #include <time.h>
 #include "taos.h"
 #include <stdlib.h>
 static int  running = 1;
 static void msg_process(TAOS_RES* msg) {
@ -27,11 +28,23 @@ static void msg_process(TAOS_RES* msg) {
  printf("db: %s\n", tmq_get_db_name(msg));
  printf("vg: %d\n", tmq_get_vgroup_id(msg));
  if (tmq_get_res_type(msg) == TMQ_RES_TABLE_META) {
-    void*   meta;
+    tmq_raw_data *raw = tmq_get_raw_meta(msg);
-    int32_t metaLen;
+    if(raw){
-    tmq_get_raw_meta(msg, &meta, &metaLen);
+      TAOS* pConn = taos_connect("192.168.1.86", "root", "taosdata", "abc1", 0);
-
+      if (pConn == NULL) {
-    printf("meta, len is %d\n", metaLen);
+        return;
      }
      int32_t ret = taos_write_raw_meta(pConn, raw);
      printf("write raw data: %s\n", tmq_err2str(ret));
      free(raw);
      taos_close(pConn);
    }
    char* result = tmq_get_json_meta(msg);
    if(result){
      printf("meta result: %s\n", result);
      free(result);
    }
    printf("meta:%p\n", raw);
    return;
  }
  while (1) {
@ -119,6 +132,104 @@ int32_t init_env() {
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "alter table st1 add column c4 bigint");
  if (taos_errno(pRes) != 0) {
    printf("failed to alter super table st1, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "alter table st1 modify column c3 binary(64)");
  if (taos_errno(pRes) != 0) {
    printf("failed to alter super table st1, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "alter table st1 add tag t2 binary(64)");
  if (taos_errno(pRes) != 0) {
    printf("failed to alter super table st1, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "alter table ct3 set tag t1=5000");
  if (taos_errno(pRes) != 0) {
    printf("failed to slter child table ct3, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "drop table ct3 ct1");
  if (taos_errno(pRes) != 0) {
    printf("failed to drop child table ct3, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "drop table st1");
  if (taos_errno(pRes) != 0) {
    printf("failed to drop super table st1, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "create table if not exists n1(ts timestamp, c1 int, c2 nchar(4))");
  if (taos_errno(pRes) != 0) {
    printf("failed to create normal table n1, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "alter table n1 add column c3 bigint");
  if (taos_errno(pRes) != 0) {
    printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "alter table n1 modify column c2 nchar(8)");
  if (taos_errno(pRes) != 0) {
    printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "alter table n1 rename column c3 cc3");
  if (taos_errno(pRes) != 0) {
    printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "alter table n1 drop column c1");
  if (taos_errno(pRes) != 0) {
    printf("failed to alter normal table n1, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "drop table n1");
  if (taos_errno(pRes) != 0) {
    printf("failed to drop normal table n1, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "create table jt(ts timestamp, i int) tags(t json)");
  if (taos_errno(pRes) != 0) {
    printf("failed to create super table jt, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  pRes = taos_query(pConn, "create table jt1 using jt tags('{\"k1\":1, \"k2\":\"hello\"}')");
  if (taos_errno(pRes) != 0) {
    printf("failed to create super table jt, reason:%s\n", taos_errstr(pRes));
    return -1;
  }
  taos_free_result(pRes);
  return 0;
 }
@ -137,8 +248,8 @@ int32_t create_topic() {
  }
  taos_free_result(pRes);
-  /*pRes = taos_query(pConn, "create topic topic_ctb_column with meta as database abc1");*/
+  pRes = taos_query(pConn, "create topic topic_ctb_column with meta as database abc1");
-  pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1, c2, c3 from st1");
+  /*pRes = taos_query(pConn, "create topic topic_ctb_column as select ts, c1, c2, c3 from st1");*/
  if (taos_errno(pRes) != 0) {
    printf("failed to create topic topic_ctb_column, reason:%s\n", taos_errstr(pRes));
    return -1;
@ -199,7 +310,7 @@ tmq_t* build_consumer() {
  tmq_conf_set(conf, "msg.with.table.name", "true");
  tmq_conf_set(conf, "enable.auto.commit", "true");
-  tmq_conf_set(conf, "experimental.snapshot.enable", "true");
+  /*tmq_conf_set(conf, "experimental.snapshot.enable", "true");*/
  tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL);
  tmq_t* tmq = tmq_consumer_new(conf, NULL, 0);
--- a/examples/rust
+++ b/examples/rust
@ -1 +1 @@
-Subproject commit 1c8924dc668e6aa848214c2fc54e3ace3f5bf8df
+Subproject commit 7ed7a97715388fa144718764d6bf20f9bfc29a12
--- a/include/client/taos.h
+++ b/include/client/taos.h
@ -260,13 +260,16 @@ enum tmq_res_t {
 };
 typedef enum tmq_res_t tmq_res_t;
 typedef struct tmq_raw_data tmq_raw_data;
-DLL_EXPORT tmq_res_t   tmq_get_res_type(TAOS_RES *res);
+DLL_EXPORT tmq_res_t     tmq_get_res_type(TAOS_RES *res);
-DLL_EXPORT int32_t     tmq_get_raw_meta(TAOS_RES *res, void **raw_meta, int32_t *raw_meta_len);
+DLL_EXPORT tmq_raw_data *tmq_get_raw_meta(TAOS_RES *res);
-DLL_EXPORT const char *tmq_get_topic_name(TAOS_RES *res);
+DLL_EXPORT int32_t       taos_write_raw_meta(TAOS *taos, tmq_raw_data *raw_meta);
-DLL_EXPORT const char *tmq_get_db_name(TAOS_RES *res);
+DLL_EXPORT char         *tmq_get_json_meta(TAOS_RES *res);   // Returning null means error. Returned result need to be freed.
-DLL_EXPORT int32_t     tmq_get_vgroup_id(TAOS_RES *res);
+DLL_EXPORT const char   *tmq_get_topic_name(TAOS_RES *res);
-DLL_EXPORT const char *tmq_get_table_name(TAOS_RES *res);
+DLL_EXPORT const char   *tmq_get_db_name(TAOS_RES *res);
 DLL_EXPORT int32_t       tmq_get_vgroup_id(TAOS_RES *res);
 DLL_EXPORT const char   *tmq_get_table_name(TAOS_RES *res);
 /* ------------------------------ TMQ END -------------------------------- */
--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@ -32,6 +32,18 @@ enum {
  TMQ_CONF__RESET_OFFSET__LATEST = -1,
 };
 // clang-format off
 #define IS_META_MSG(x) ( \
     x == TDMT_VND_CREATE_STB     \
  || x == TDMT_VND_ALTER_STB      \
  || x == TDMT_VND_DROP_STB       \
  || x == TDMT_VND_CREATE_TABLE   \
  || x == TDMT_VND_ALTER_TABLE    \
  || x == TDMT_VND_DROP_TABLE     \
  || x == TDMT_VND_DROP_TTL_TABLE \
 )
 // clang-format on
 enum {
  TMQ_MSG_TYPE__DUMMY = 0,
  TMQ_MSG_TYPE__POLL_RSP,
@ -43,7 +55,8 @@ enum {
 enum {
  STREAM_INPUT__DATA_SUBMIT = 1,
  STREAM_INPUT__DATA_BLOCK,
-  STREAM_INPUT__DATA_SCAN,
+  // STREAM_INPUT__TABLE_SCAN,
  STREAM_INPUT__TQ_SCAN,
  STREAM_INPUT__DATA_RETRIEVE,
  STREAM_INPUT__TRIGGER,
  STREAM_INPUT__CHECKPOINT,
@ -56,7 +69,8 @@ typedef enum EStreamType {
  STREAM_CLEAR,
  STREAM_INVALID,
  STREAM_GET_ALL,
-  STREAM_DELETE,
+  STREAM_DELETE_RESULT,
  STREAM_DELETE_DATA,
  STREAM_RETRIEVE,
  STREAM_PULL_DATA,
  STREAM_PULL_OVER,
@ -72,15 +86,15 @@ typedef struct {
  uint64_t  suid;
 } STableListInfo;
 #pragma pack(push, 1)
 typedef struct SColumnDataAgg {
  int16_t colId;
  int16_t maxIndex;
  int16_t minIndex;
  int16_t numOfNull;
  int64_t sum;
  int64_t max;
  int64_t min;
 } SColumnDataAgg;
 #pragma pack(pop)
 typedef struct SDataBlockInfo {
  STimeWindow window;
@ -94,6 +108,7 @@ typedef struct SDataBlockInfo {
  // TODO: optimize and remove following
  int32_t     childId;  // used for stream, do not serialize
  EStreamType type;     // used for stream, do not serialize
  STimeWindow calWin;   // used for stream, do not serialize
 } SDataBlockInfo;
 typedef struct SSDataBlock {
@ -102,6 +117,21 @@ typedef struct SSDataBlock {
  SDataBlockInfo   info;
 } SSDataBlock;
 enum {
  FETCH_TYPE__DATA = 1,
  FETCH_TYPE__META,
  FETCH_TYPE__NONE,
 };
 typedef struct {
  int8_t       fetchType;
  STqOffsetVal offset;
  union {
    SSDataBlock data;
    void*       meta;
  };
 } SFetchRet;
 typedef struct SVarColAttr {
  int32_t* offset;    // start position for each entry in the list
  uint32_t length;    // used buffer size that contain the valid data
@ -121,15 +151,13 @@ typedef struct SColumnInfoData {
 } SColumnInfoData;
 typedef struct SQueryTableDataCond {
  // STimeWindow  twindow;
  uint64_t     suid;
  int32_t      order;  // desc|asc order to iterate the data block
  int32_t      numOfCols;
  SColumnInfo* colList;
-  bool         loadExternalRows;  // load external rows or not
+  int32_t      type;  // data block load type:
-  int32_t      type;              // data block load type:
+//  int32_t      numOfTWindows;
-  int32_t      numOfTWindows;
+  STimeWindow  twindows;
  STimeWindow* twindows;
  int64_t      startVersion;
  int64_t      endVersion;
 } SQueryTableDataCond;
--- a/include/common/tdatablock.h
+++ b/include/common/tdatablock.h
@ -231,7 +231,7 @@ SSDataBlock* createDataBlock();
 int32_t      blockDataAppendColInfo(SSDataBlock* pBlock, SColumnInfoData* pColInfoData);
 SColumnInfoData  createColumnInfoData(int16_t type, int32_t bytes, int16_t colId);
-SColumnInfoData* bdGetColumnInfoData(SSDataBlock* pBlock, int32_t index);
+SColumnInfoData* bdGetColumnInfoData(const SSDataBlock* pBlock, int32_t index);
 void blockEncode(const SSDataBlock* pBlock, char* data, int32_t* dataLen, int32_t numOfCols, int8_t needCompress);
 const char* blockDecode(SSDataBlock* pBlock, int32_t numOfCols, int32_t numOfRows, const char* pData);
--- a/include/common/tdataformat.h
+++ b/include/common/tdataformat.h
@ -34,21 +34,44 @@ typedef struct SValue        SValue;
 typedef struct SColVal       SColVal;
 typedef struct STSRow2       STSRow2;
 typedef struct STSRowBuilder STSRowBuilder;
 typedef struct SColData      SColData;
 typedef struct STagVal       STagVal;
 typedef struct STag          STag;
 // bitmap
 #define N1(n)        ((1 << (n)) - 1)
 #define BIT1_SIZE(n) (((n)-1) / 8 + 1)
 #define BIT2_SIZE(n) (((n)-1) / 4 + 1)
 #define SET_BIT1(p, i, v)                            \
  do {                                               \
    (p)[(i) / 8] &= N1((i) % 8);                     \
    (p)[(i) / 8] |= (((uint8_t)(v)) << (((i) % 8))); \
  } while (0)
 #define GET_BIT1(p, i) (((p)[(i) / 8] >> ((i) % 8)) & ((uint8_t)1))
 #define SET_BIT2(p, i, v)                                \
  do {                                                   \
    p[(i) / 4] &= N1((i) % 4 * 2);                       \
    (p)[(i) / 4] |= (((uint8_t)(v)) << (((i) % 4) * 2)); \
  } while (0)
 #define GET_BIT2(p, i) (((p)[(i) / 4] >> (((i) % 4) * 2)) & ((uint8_t)3))
 // STSchema
 int32_t tTSchemaCreate(int32_t sver, SSchema *pSchema, int32_t nCols, STSchema **ppTSchema);
 void    tTSchemaDestroy(STSchema *pTSchema);
 // SValue
-int tValueCmprFn(const SValue *pValue1, const SValue *pValue2, int8_t type);
+int32_t tPutValue(uint8_t *p, SValue *pValue, int8_t type);
 int32_t tGetValue(uint8_t *p, SValue *pValue, int8_t type);
 int     tValueCmprFn(const SValue *pValue1, const SValue *pValue2, int8_t type);
 // SColVal
 #define COL_VAL_NONE(CID, TYPE)     ((SColVal){.cid = (CID), .type = (TYPE), .isNone = 1})
 #define COL_VAL_NULL(CID, TYPE)     ((SColVal){.cid = (CID), .type = (TYPE), .isNull = 1})
 #define COL_VAL_VALUE(CID, TYPE, V) ((SColVal){.cid = (CID), .type = (TYPE), .value = (V)})
 // STSRow2
-#define COL_VAL_NONE(CID)     ((SColVal){.cid = (CID), .isNone = 1})
+#define TSROW_LEN(PROW, V)  tGetI32v((uint8_t *)(PROW)->data, (V) ? &(V) : NULL)
-#define COL_VAL_NULL(CID)     ((SColVal){.cid = (CID), .isNull = 1})
+#define TSROW_SVER(PROW, V) tGetI32v((PROW)->data + TSROW_LEN(PROW, NULL), (V) ? &(V) : NULL)
 #define COL_VAL_VALUE(CID, V) ((SColVal){.cid = (CID), .value = (V)})
 int32_t tTSRowNew(STSRowBuilder *pBuilder, SArray *pArray, STSchema *pTSchema, STSRow2 **ppRow);
 int32_t tTSRowClone(const STSRow2 *pRow, STSRow2 **ppRow);
@ -56,7 +79,7 @@ void    tTSRowFree(STSRow2 *pRow);
 void    tTSRowGet(STSRow2 *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal);
 int32_t tTSRowToArray(STSRow2 *pRow, STSchema *pTSchema, SArray **ppArray);
 int32_t tPutTSRow(uint8_t *p, STSRow2 *pRow);
-int32_t tGetTSRow(uint8_t *p, STSRow2 *pRow);
+int32_t tGetTSRow(uint8_t *p, STSRow2 **ppRow);
 // STSRowBuilder
 #define tsRowBuilderInit() ((STSRowBuilder){0})
@ -78,7 +101,7 @@ int32_t tEncodeTag(SEncoder *pEncoder, const STag *pTag);
 int32_t tDecodeTag(SDecoder *pDecoder, STag **ppTag);
 int32_t tTagToValArray(const STag *pTag, SArray **ppArray);
 void    debugPrintSTag(STag *pTag, const char *tag, int32_t ln);  // TODO: remove
-int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, void* pMsgBuf);
+int32_t parseJsontoTagData(const char *json, SArray *pTagVals, STag **ppTag, void *pMsgBuf);
 // STRUCT =================
 struct STColumn {
@ -104,16 +127,16 @@ struct STSchema {
 #define TSROW_KV_SMALL ((uint8_t)0x10U)
 #define TSROW_KV_MID   ((uint8_t)0x20U)
 #define TSROW_KV_BIG   ((uint8_t)0x40U)
 #pragma pack(push, 1)
 struct STSRow2 {
-  TSKEY    ts;
+  TSKEY   ts;
-  uint8_t  flags;
+  uint8_t flags;
-  int32_t  sver;
+  uint8_t data[];
  uint32_t nData;
  uint8_t *pData;
 };
 #pragma pack(pop)
 struct STSRowBuilder {
-  STSRow2  tsRow;
+  // STSRow2  tsRow;
  int32_t  szBuf;
  uint8_t *pBuf;
 };
@ -140,6 +163,7 @@ struct SValue {
 struct SColVal {
  int16_t cid;
  int8_t  type;
  int8_t  isNone;
  int8_t  isNull;
  SValue  value;
@ -172,12 +196,6 @@ struct STag {
 };
 #pragma pack(pop)
 struct SColData {
  int16_t  cid;
  uint32_t nData;
  uint8_t *pData;
 };
 #if 1  //================================================================================================================================================
 // Imported since 3.0 and use bitmap to demonstrate None/Null/Norm, while use Null/Norm below 3.0 without of bitmap.
 #define TD_SUPPORT_BITMAP
@ -212,50 +230,6 @@ struct SColData {
    memcpy(varDataVal(x), (str), (_size));      \
  } while (0);
 // ----------------- TSDB COLUMN DEFINITION
 #define colType(col)   ((col)->type)
 #define colFlags(col)  ((col)->flags)
 #define colColId(col)  ((col)->colId)
 #define colBytes(col)  ((col)->bytes)
 #define colOffset(col) ((col)->offset)
 #define colSetType(col, t)   (colType(col) = (t))
 #define colSetFlags(col, f)  (colFlags(col) = (f))
 #define colSetColId(col, id) (colColId(col) = (id))
 #define colSetBytes(col, b)  (colBytes(col) = (b))
 #define colSetOffset(col, o) (colOffset(col) = (o))
 // ----------------- TSDB SCHEMA DEFINITION
 #define schemaNCols(s)    ((s)->numOfCols)
 #define schemaVersion(s)  ((s)->version)
 #define schemaTLen(s)     ((s)->tlen)
 #define schemaFLen(s)     ((s)->flen)
 #define schemaVLen(s)     ((s)->vlen)
 #define schemaColAt(s, i) ((s)->columns + i)
 #define tdFreeSchema(s)   taosMemoryFreeClear((s))
 STSchema *tdDupSchema(const STSchema *pSchema);
 int32_t   tdEncodeSchema(void **buf, STSchema *pSchema);
 void     *tdDecodeSchema(void *buf, STSchema **pRSchema);
 static FORCE_INLINE int32_t comparColId(const void *key1, const void *key2) {
  if (*(int16_t *)key1 > ((STColumn *)key2)->colId) {
    return 1;
  } else if (*(int16_t *)key1 < ((STColumn *)key2)->colId) {
    return -1;
  } else {
    return 0;
  }
 }
 static FORCE_INLINE STColumn *tdGetColOfID(STSchema *pSchema, int16_t colId) {
  void *ptr = bsearch(&colId, (void *)pSchema->columns, schemaNCols(pSchema), sizeof(STColumn), comparColId);
  if (ptr == NULL) return NULL;
  return (STColumn *)ptr;
 }
 // ----------------- SCHEMA BUILDER DEFINITION
 typedef struct {
  int32_t      tCols;
@ -285,141 +259,6 @@ void      tdResetTSchemaBuilder(STSchemaBuilder *pBuilder, schema_ver_t version)
 int32_t   tdAddColToSchema(STSchemaBuilder *pBuilder, int8_t type, int8_t flags, col_id_t colId, col_bytes_t bytes);
 STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder);
 // ----------------- Semantic timestamp key definition
 // typedef uint64_t TKEY;
 #define TKEY TSKEY
 #define TKEY_INVALID       UINT64_MAX
 #define TKEY_NULL          TKEY_INVALID
 #define TKEY_NEGATIVE_FLAG (((TKEY)1) << 63)
 #define TKEY_VALUE_FILTER  (~(TKEY_NEGATIVE_FLAG))
 #define TKEY_IS_NEGATIVE(tkey) (((tkey)&TKEY_NEGATIVE_FLAG) != 0)
 #define TKEY_IS_DELETED(tkey)  (false)
 #define tdGetTKEY(key)  (key)
 #define tdGetKey(tskey) (tskey)
 #define MIN_TS_KEY ((TSKEY)0x8000000000000001)
 #define MAX_TS_KEY ((TSKEY)0x7fffffffffffffff)
 #define TD_TO_TKEY(key) tdGetTKEY(((key) < MIN_TS_KEY) ? MIN_TS_KEY : (((key) > MAX_TS_KEY) ? MAX_TS_KEY : key))
 static FORCE_INLINE TKEY keyToTkey(TSKEY key) {
  TSKEY lkey = key;
  if (key > MAX_TS_KEY) {
    lkey = MAX_TS_KEY;
  } else if (key < MIN_TS_KEY) {
    lkey = MIN_TS_KEY;
  }
  return tdGetTKEY(lkey);
 }
 static FORCE_INLINE int32_t tkeyComparFn(const void *tkey1, const void *tkey2) {
  TSKEY key1 = tdGetKey(*(TKEY *)tkey1);
  TSKEY key2 = tdGetKey(*(TKEY *)tkey2);
  if (key1 < key2) {
    return -1;
  } else if (key1 > key2) {
    return 1;
  } else {
    return 0;
  }
 }
 // ----------------- Data column structure
 // SDataCol arrangement: data => bitmap => dataOffset
 typedef struct SDataCol {
  int8_t          type;        // column type
  uint8_t         bitmap : 1;  // 0: no bitmap if all rows are NORM, 1: has bitmap if has NULL/NORM rows
  uint8_t         reserve : 7;
  int16_t         colId;      // column ID
  int32_t         bytes;      // column data bytes defined
  int32_t         offset;     // data offset in a SDataRow (including the header size)
  int32_t         spaceSize;  // Total space size for this column
  int32_t         len;        // column data length
  VarDataOffsetT *dataOff;    // For binary and nchar data, the offset in the data column
  void           *pData;      // Actual data pointer
  void           *pBitmap;    // Bitmap pointer
  TSKEY           ts;         // only used in last NULL column
 } SDataCol;
 #define isAllRowsNull(pCol) ((pCol)->len == 0)
 #define isAllRowsNone(pCol) ((pCol)->len == 0)
 static FORCE_INLINE void dataColReset(SDataCol *pDataCol) { pDataCol->len = 0; }
 int32_t tdAllocMemForCol(SDataCol *pCol, int32_t maxPoints);
 void    dataColInit(SDataCol *pDataCol, STColumn *pCol, int32_t maxPoints);
 int32_t dataColAppendVal(SDataCol *pCol, const void *value, int32_t numOfRows, int32_t maxPoints);
 void   *dataColSetOffset(SDataCol *pCol, int32_t nEle);
 bool isNEleNull(SDataCol *pCol, int32_t nEle);
 typedef struct {
  col_id_t  maxCols;    // max number of columns
  col_id_t  numOfCols;  // Total number of cols
  int32_t   maxPoints;  // max number of points
  int32_t   numOfRows;
  int32_t   bitmapMode : 1;  // default is 0(2 bits), otherwise 1(1 bit)
  int32_t   sversion : 31;   // TODO: set sversion(not used yet)
  SDataCol *cols;
 } SDataCols;
 static FORCE_INLINE bool tdDataColsIsBitmapI(SDataCols *pCols) { return pCols->bitmapMode != TSDB_BITMODE_DEFAULT; }
 static FORCE_INLINE void tdDataColsSetBitmapI(SDataCols *pCols) { pCols->bitmapMode = TSDB_BITMODE_ONE_BIT; }
 static FORCE_INLINE bool tdIsBitmapModeI(int8_t bitmapMode) { return bitmapMode != TSDB_BITMODE_DEFAULT; }
 #define keyCol(pCols)              (&((pCols)->cols[0]))                    // Key column
 #define dataColsTKeyAt(pCols, idx) ((TKEY *)(keyCol(pCols)->pData))[(idx)]  // the idx row of column-wised data
 #define dataColsKeyAt(pCols, idx)  tdGetKey(dataColsTKeyAt(pCols, idx))
 static FORCE_INLINE TKEY dataColsTKeyFirst(SDataCols *pCols) {
  if (pCols->numOfRows) {
    return dataColsTKeyAt(pCols, 0);
  } else {
    return TKEY_INVALID;
  }
 }
 static FORCE_INLINE TSKEY dataColsKeyAtRow(SDataCols *pCols, int32_t row) {
  assert(row < pCols->numOfRows);
  return dataColsKeyAt(pCols, row);
 }
 static FORCE_INLINE TSKEY dataColsKeyFirst(SDataCols *pCols) {
  if (pCols->numOfRows) {
    return dataColsKeyAt(pCols, 0);
  } else {
    return TSDB_DATA_TIMESTAMP_NULL;
  }
 }
 static FORCE_INLINE TKEY dataColsTKeyLast(SDataCols *pCols) {
  if (pCols->numOfRows) {
    return dataColsTKeyAt(pCols, pCols->numOfRows - 1);
  } else {
    return TKEY_INVALID;
  }
 }
 static FORCE_INLINE TSKEY dataColsKeyLast(SDataCols *pCols) {
  if (pCols->numOfRows) {
    return dataColsKeyAt(pCols, pCols->numOfRows - 1);
  } else {
    return TSDB_DATA_TIMESTAMP_NULL;
  }
 }
 SDataCols *tdNewDataCols(int32_t maxCols, int32_t maxRows);
 void       tdResetDataCols(SDataCols *pCols);
 int32_t    tdInitDataCols(SDataCols *pCols, STSchema *pSchema);
 SDataCols *tdDupDataCols(SDataCols *pCols, bool keepData);
 SDataCols *tdFreeDataCols(SDataCols *pCols);
 int32_t    tdMergeDataCols(SDataCols *target, SDataCols *source, int32_t rowsToMerge, int32_t *pOffset, bool update,
                           TDRowVerT maxVer);
 #endif
 #ifdef __cplusplus
--- a/include/common/tglobal.h
+++ b/include/common/tglobal.h
@ -64,10 +64,10 @@ extern int32_t tsNumOfMnodeQueryThreads;
 extern int32_t tsNumOfMnodeFetchThreads;
 extern int32_t tsNumOfMnodeReadThreads;
 extern int32_t tsNumOfVnodeQueryThreads;
 extern int32_t tsNumOfVnodeStreamThreads;
 extern int32_t tsNumOfVnodeFetchThreads;
 extern int32_t tsNumOfVnodeWriteThreads;
 extern int32_t tsNumOfVnodeSyncThreads;
 extern int32_t tsNumOfVnodeMergeThreads;
 extern int32_t tsNumOfQnodeQueryThreads;
 extern int32_t tsNumOfQnodeFetchThreads;
 extern int32_t tsNumOfSnodeSharedThreads;
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@ -55,8 +55,13 @@ extern int32_t tMsgDict[];
 #define TMSG_SEG_CODE(TYPE) (((TYPE)&0xff00) >> 8)
 #define TMSG_SEG_SEQ(TYPE)  ((TYPE)&0xff)
-#define TMSG_INFO(TYPE)     tMsgInfo[tMsgDict[TMSG_SEG_CODE(TYPE)] + TMSG_SEG_SEQ(TYPE)]
+#define TMSG_INFO(TYPE)                                                                                      \
-#define TMSG_INDEX(TYPE)    (tMsgDict[TMSG_SEG_CODE(TYPE)] + TMSG_SEG_SEQ(TYPE))
+  ((TYPE) >= 0 && ((TYPE) < TDMT_DND_MAX_MSG || (TYPE) < TDMT_MND_MAX_MSG || (TYPE) < TDMT_VND_MAX_MSG ||    \
                   (TYPE) < TDMT_SCH_MAX_MSG || (TYPE) < TDMT_STREAM_MAX_MSG || (TYPE) < TDMT_MON_MAX_MSG || \
                   (TYPE) < TDMT_SYNC_MAX_MSG))                                                              \
      ? tMsgInfo[tMsgDict[TMSG_SEG_CODE(TYPE)] + TMSG_SEG_SEQ(TYPE)]                                         \
      : 0
 #define TMSG_INDEX(TYPE) (tMsgDict[TMSG_SEG_CODE(TYPE)] + TMSG_SEG_SEQ(TYPE))
 typedef uint16_t tmsg_t;
@ -164,6 +169,9 @@ typedef enum _mgmt_table {
 #define TD_CHILD_TABLE  TSDB_CHILD_TABLE
 #define TD_NORMAL_TABLE TSDB_NORMAL_TABLE
 #define TD_REQ_FROM_APP  0
 #define TD_REQ_FROM_TAOX 1
 typedef struct {
  int32_t vgId;
  char*   dbFName;
@ -427,25 +435,30 @@ static FORCE_INLINE int32_t tDecodeSSchemaWrapperEx(SDecoder* pDecoder, SSchemaW
 STSchema* tdGetSTSChemaFromSSChema(SSchema** pSchema, int32_t nCols);
 typedef struct {
-  char    name[TSDB_TABLE_FNAME_LEN];
+  char     name[TSDB_TABLE_FNAME_LEN];
-  int8_t  igExists;
+  int8_t   igExists;
-  int64_t delay1;
+  int8_t   source;  // 1-taosX or 0-taosClient
-  int64_t delay2;
+  int8_t   reserved[6];
-  int64_t watermark1;
+  tb_uid_t suid;
-  int64_t watermark2;
+  int64_t  delay1;
-  int32_t ttl;
+  int64_t  delay2;
-  int32_t numOfColumns;
+  int64_t  watermark1;
-  int32_t numOfTags;
+  int64_t  watermark2;
-  int32_t numOfFuncs;
+  int32_t  ttl;
-  int32_t commentLen;
+  int32_t  colVer;
-  int32_t ast1Len;
+  int32_t  tagVer;
-  int32_t ast2Len;
+  int32_t  numOfColumns;
-  SArray* pColumns;  // array of SField
+  int32_t  numOfTags;
-  SArray* pTags;     // array of SField
+  int32_t  numOfFuncs;
-  SArray* pFuncs;
+  int32_t  commentLen;
-  char*   pComment;
+  int32_t  ast1Len;
-  char*   pAst1;
+  int32_t  ast2Len;
-  char*   pAst2;
+  SArray*  pColumns;  // array of SField
  SArray*  pTags;     // array of SField
  SArray*  pFuncs;
  char*    pComment;
  char*    pAst1;
  char*    pAst2;
 } SMCreateStbReq;
 int32_t tSerializeSMCreateStbReq(void* buf, int32_t bufLen, SMCreateStbReq* pReq);
@ -453,8 +466,11 @@ int32_t tDeserializeSMCreateStbReq(void* buf, int32_t bufLen, SMCreateStbReq* pR
 void    tFreeSMCreateStbReq(SMCreateStbReq* pReq);
 typedef struct {
-  char   name[TSDB_TABLE_FNAME_LEN];
+  char     name[TSDB_TABLE_FNAME_LEN];
-  int8_t igNotExists;
+  int8_t   igNotExists;
  int8_t   source;  // 1-taosX or 0-taosClient
  int8_t   reserved[6];
  tb_uid_t suid;
 } SMDropStbReq;
 int32_t tSerializeSMDropStbReq(void* buf, int32_t bufLen, SMDropStbReq* pReq);
@ -463,8 +479,6 @@ int32_t tDeserializeSMDropStbReq(void* buf, int32_t bufLen, SMDropStbReq* pReq);
 typedef struct {
  char    name[TSDB_TABLE_FNAME_LEN];
  int8_t  alterType;
  int32_t tagVer;
  int32_t colVer;
  int32_t numOfFields;
  SArray* pFields;
  int32_t ttl;
@ -660,6 +674,7 @@ typedef struct {
  char    tbFName[TSDB_TABLE_FNAME_LEN];
  int32_t sversion;
  int32_t tversion;
  int64_t affectedRows;
 } SQueryTableRsp;
 int32_t tSerializeSQueryTableRsp(void* buf, int32_t bufLen, SQueryTableRsp* pRsp);
@ -708,6 +723,7 @@ typedef struct {
  int32_t buffer;        // MB
  int32_t pageSize;
  int32_t pages;
  int32_t cacheLastSize;
  int32_t daysPerFile;
  int32_t daysToKeep0;
  int32_t daysToKeep1;
@ -720,7 +736,7 @@ typedef struct {
  int8_t  compression;
  int8_t  replications;
  int8_t  strict;
-  int8_t  cacheLastRow;
+  int8_t  cacheLast;
  int8_t  schemaless;
  int8_t  ignoreExist;
  int32_t numOfRetensions;
@ -736,6 +752,7 @@ typedef struct {
  int32_t buffer;
  int32_t pageSize;
  int32_t pages;
  int32_t cacheLastSize;
  int32_t daysPerFile;
  int32_t daysToKeep0;
  int32_t daysToKeep1;
@ -743,7 +760,7 @@ typedef struct {
  int32_t fsyncPeriod;
  int8_t  walLevel;
  int8_t  strict;
-  int8_t  cacheLastRow;
+  int8_t  cacheLast;
  int8_t  replications;
 } SAlterDbReq;
@ -798,6 +815,27 @@ typedef struct {
 int32_t tSerializeSDbCfgReq(void* buf, int32_t bufLen, SDbCfgReq* pReq);
 int32_t tDeserializeSDbCfgReq(void* buf, int32_t bufLen, SDbCfgReq* pReq);
 typedef struct {
  char db[TSDB_DB_FNAME_LEN];
 } STrimDbReq;
 int32_t tSerializeSTrimDbReq(void* buf, int32_t bufLen, STrimDbReq* pReq);
 int32_t tDeserializeSTrimDbReq(void* buf, int32_t bufLen, STrimDbReq* pReq);
 typedef struct {
  int32_t timestamp;
 } SVTrimDbReq;
 int32_t tSerializeSVTrimDbReq(void* buf, int32_t bufLen, SVTrimDbReq* pReq);
 int32_t tDeserializeSVTrimDbReq(void* buf, int32_t bufLen, SVTrimDbReq* pReq);
 typedef struct {
  int32_t timestamp;
 } SVDropTtlTableReq;
 int32_t tSerializeSVDropTtlTableReq(void* buf, int32_t bufLen, SVDropTtlTableReq* pReq);
 int32_t tDeserializeSVDropTtlTableReq(void* buf, int32_t bufLen, SVDropTtlTableReq* pReq);
 typedef struct {
  int32_t numOfVgroups;
  int32_t numOfStables;
@ -816,7 +854,7 @@ typedef struct {
  int8_t  compression;
  int8_t  replications;
  int8_t  strict;
-  int8_t  cacheLastRow;
+  int8_t  cacheLast;
  int32_t numOfRetensions;
  SArray* pRetensions;
  int8_t  schemaless;
@ -1023,8 +1061,10 @@ typedef struct {
  int64_t     clusterId;
  int64_t     rebootTime;
  int64_t     updateTime;
-  int32_t     numOfCores;
+  float       numOfCores;
  int32_t     numOfSupportVnodes;
  int64_t     memTotal;
  int64_t     memAvail;
  char        dnodeEp[TSDB_EP_LEN];
  SMnodeLoad  mload;
  SQnodeLoad  qload;
@ -1079,6 +1119,7 @@ typedef struct {
  int32_t  buffer;
  int32_t  pageSize;
  int32_t  pages;
  int32_t  cacheLastSize;
  int32_t  daysPerFile;
  int32_t  daysToKeep0;
  int32_t  daysToKeep1;
@ -1093,7 +1134,7 @@ typedef struct {
  int8_t   precision;
  int8_t   compression;
  int8_t   strict;
-  int8_t   cacheLastRow;
+  int8_t   cacheLast;
  int8_t   isTsma;
  int8_t   standby;
  int8_t   replica;
@ -1131,6 +1172,7 @@ typedef struct {
  int32_t  buffer;
  int32_t  pageSize;
  int32_t  pages;
  int32_t  cacheLastSize;
  int32_t  daysPerFile;
  int32_t  daysToKeep0;
  int32_t  daysToKeep1;
@ -1138,7 +1180,7 @@ typedef struct {
  int32_t  fsyncPeriod;
  int8_t   walLevel;
  int8_t   strict;
-  int8_t   cacheLastRow;
+  int8_t   cacheLast;
  int8_t   selfIndex;
  int8_t   replica;
  SReplica replicas[TSDB_MAX_REPLICA];
@ -1499,6 +1541,7 @@ typedef struct SSubQueryMsg {
  int32_t  execId;
  int8_t   taskType;
  int8_t   explain;
  int8_t   needFetch;
  uint32_t sqlLen;  // the query sql,
  uint32_t phyLen;
  char     msg[];
@ -2815,8 +2858,8 @@ typedef struct {
 static FORCE_INLINE int32_t tEncodeSMqMetaRsp(void** buf, const SMqMetaRsp* pRsp) {
  int32_t tlen = 0;
-  tlen += taosEncodeFixedI64(buf, pRsp->reqOffset);
+  // tlen += taosEncodeFixedI64(buf, pRsp->reqOffset);
-  tlen += taosEncodeFixedI64(buf, pRsp->rspOffset);
+  // tlen += taosEncodeFixedI64(buf, pRsp->rspOffset);
  tlen += taosEncodeFixedI16(buf, pRsp->resMsgType);
  tlen += taosEncodeFixedI32(buf, pRsp->metaRspLen);
  tlen += taosEncodeBinary(buf, pRsp->metaRsp, pRsp->metaRspLen);
@ -2824,8 +2867,8 @@ static FORCE_INLINE int32_t tEncodeSMqMetaRsp(void** buf, const SMqMetaRsp* pRsp
 }
 static FORCE_INLINE void* tDecodeSMqMetaRsp(const void* buf, SMqMetaRsp* pRsp) {
-  buf = taosDecodeFixedI64(buf, &pRsp->reqOffset);
+  // buf = taosDecodeFixedI64(buf, &pRsp->reqOffset);
-  buf = taosDecodeFixedI64(buf, &pRsp->rspOffset);
+  // buf = taosDecodeFixedI64(buf, &pRsp->rspOffset);
  buf = taosDecodeFixedI16(buf, &pRsp->resMsgType);
  buf = taosDecodeFixedI32(buf, &pRsp->metaRspLen);
  buf = taosDecodeBinary(buf, &pRsp->metaRsp, pRsp->metaRspLen);
@ -3013,6 +3056,17 @@ typedef struct {
 int32_t tEncodeSVDeleteRsp(SEncoder* pCoder, const SVDeleteRsp* pReq);
 int32_t tDecodeSVDeleteRsp(SDecoder* pCoder, SVDeleteRsp* pReq);
 typedef struct SDeleteRes {
  uint64_t suid;
  SArray*  uidList;
  int64_t  skey;
  int64_t  ekey;
  int64_t  affectedRows;
 } SDeleteRes;
 int32_t tEncodeDeleteRes(SEncoder* pCoder, const SDeleteRes* pRes);
 int32_t tDecodeDeleteRes(SDecoder* pCoder, SDeleteRes* pRes);
 #pragma pack(pop)
 #ifdef __cplusplus
--- a/include/common/tmsgcb.h
+++ b/include/common/tmsgcb.h
@ -34,6 +34,7 @@ typedef enum {
  WRITE_QUEUE,
  APPLY_QUEUE,
  SYNC_QUEUE,
  STREAM_QUEUE,
  QUEUE_MAX,
 } EQueueType;
--- a/include/common/tmsgdef.h
+++ b/include/common/tmsgdef.h
@ -82,6 +82,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_DND_NET_TEST, "net-test", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_DND_CONFIG_DNODE, "config-dnode", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_DND_SYSTABLE_RETRIEVE, "dnode-retrieve", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_DND_MAX_MSG, "dnd-max", NULL, NULL)
  TD_NEW_MSG_SEG(TDMT_MND_MSG)
  TD_DEF_MSG_TYPE(TDMT_MND_CONNECT, "connect", NULL, NULL)
@ -115,6 +116,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_MND_ALTER_DB, "alter-db", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_SYNC_DB, "sync-db", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_COMPACT_DB, "compact-db", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_TRIM_DB, "trim-db", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_GET_DB_CFG, "get-db-cfg", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_VGROUP_LIST, "vgroup-list", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_CREATE_FUNC, "create-func", NULL, NULL)
@ -164,6 +166,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_MND_SPLIT_VGROUP, "split-vgroup", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_SHOW_VARIABLES, "show-variables", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_SERVER_VERSION, "server-version", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MND_MAX_MSG, "mnd-max", NULL, NULL)
  TD_NEW_MSG_SEG(TDMT_VND_MSG)
  TD_DEF_MSG_TYPE(TDMT_VND_SUBMIT, "submit", SSubmitReq, SSubmitRsp)
@ -196,8 +199,11 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_REPLICA, "alter-replica", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_CONFIRM, "alter-confirm", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_ALTER_HASHRANGE, "alter-hashrange", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_COMPACT, "compact", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_COMPACT, "vnode-compact", NULL, NULL)
-  TD_DEF_MSG_TYPE(TDMT_VND_DROP_TTL_TABLE, "drop-ttl-stb", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_VND_DROP_TTL_TABLE, "vnode-drop-ttl-stb", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_TRIM, "vnode-trim", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_COMMIT, "vnode-commit", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_VND_MAX_MSG, "vnd-max", NULL, NULL)
  TD_NEW_MSG_SEG(TDMT_SCH_MSG)
  TD_DEF_MSG_TYPE(TDMT_SCH_QUERY, "query", NULL, NULL)
@ -205,10 +211,12 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_SCH_QUERY_CONTINUE, "query-continue", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SCH_QUERY_HEARTBEAT, "query-heartbeat", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SCH_FETCH, "fetch", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SCH_MERGE_FETCH, "merge-fetch", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SCH_CANCEL_TASK, "cancel-task", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SCH_DROP_TASK, "drop-task", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SCH_EXPLAIN, "explain", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SCH_LINK_BROKEN, "link-broken", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SCH_MAX_MSG, "sch-max", NULL, NULL)
  TD_NEW_MSG_SEG(TDMT_STREAM_MSG)
  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_DEPLOY, "stream-task-deploy", SStreamTaskDeployReq, SStreamTaskDeployRsp)
@ -217,6 +225,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_DISPATCH, "stream-task-dispatch", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_STREAM_TASK_RECOVER, "stream-task-recover", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_STREAM_RETRIEVE, "stream-retrieve", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_STREAM_MAX_MSG, "stream-max", NULL, NULL)
  TD_NEW_MSG_SEG(TDMT_MON_MSG)
  TD_DEF_MSG_TYPE(TDMT_MON_MM_INFO, "monitor-minfo", NULL, NULL)
@ -227,6 +236,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_MON_VM_LOAD, "monitor-vload", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MON_MM_LOAD, "monitor-mload", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MON_QM_LOAD, "monitor-qload", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_MON_MAX_MSG, "monitor-max", NULL, NULL)
  TD_NEW_MSG_SEG(TDMT_SYNC_MSG)
  TD_DEF_MSG_TYPE(TDMT_SYNC_TIMEOUT, "sync-timer", NULL, NULL)
@ -251,6 +261,7 @@ enum {
  TD_DEF_MSG_TYPE(TDMT_SYNC_LEADER_TRANSFER, "sync-leader-transfer", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SYNC_SET_MNODE_STANDBY, "set-mnode-standby", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SYNC_SET_VNODE_STANDBY, "set-vnode-standby", NULL, NULL)
  TD_DEF_MSG_TYPE(TDMT_SYNC_MAX_MSG, "sync-max", NULL, NULL)
 #if defined(TD_MSG_NUMBER_)
  TDMT_MAX
--- a/include/common/tname.h
+++ b/include/common/tname.h
@ -37,6 +37,8 @@ typedef struct SName {
  char    tname[TSDB_TABLE_NAME_LEN];
 } SName;
 SName* toName(int32_t acctId, const char* pDbName, const char* pTableName, SName* pName);
 int32_t tNameExtractFullName(const SName* name, char* dst);
 int32_t tNameLen(const SName* name);
--- a/include/common/trow.h
+++ b/include/common/trow.h
@ -168,7 +168,7 @@ typedef struct {
 // N.B. If without STSchema, getExtendedRowSize() is used to get the rowMaxBytes and
 // (int32_t)ceil((double)nCols/TD_VTYPE_PARTS) should be added if TD_SUPPORT_BITMAP defined.
-#define TD_ROW_MAX_BYTES_FROM_SCHEMA(s) (schemaTLen(s) + TD_ROW_HEAD_LEN)
+#define TD_ROW_MAX_BYTES_FROM_SCHEMA(s) ((s)->tlen + TD_ROW_HEAD_LEN)
 #define TD_ROW_SET_INFO(r, i)  (TD_ROW_INFO(r) = (i))
 #define TD_ROW_SET_TYPE(r, t)  (TD_ROW_TYPE(r) = (t))
@ -223,9 +223,10 @@ int32_t                     tdSetBitmapValTypeN(void *pBitmap, int16_t nEle, TDR
 static FORCE_INLINE int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValType,
                                               int8_t bitmapMode);
 bool                        tdIsBitmapBlkNorm(const void *pBitmap, int32_t numOfBits, int8_t bitmapMode);
-int32_t tdAppendValToDataCol(SDataCol *pCol, TDRowValT valType, const void *val, int32_t numOfRows, int32_t maxPoints,
+// int32_t tdAppendValToDataCol(SDataCol *pCol, TDRowValT valType, const void *val, int32_t numOfRows, int32_t
-                             int8_t bitmapMode, bool isMerge);
+// maxPoints,
-int32_t tdAppendSTSRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols *pCols, bool isMerge);
+//                              int8_t bitmapMode, bool isMerge);
 // int32_t tdAppendSTSRowToDataCol(STSRow *pRow, STSchema *pSchema, SDataCols *pCols, bool isMerge);
 int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pValType);
 int32_t tdSetBitmapValTypeI(void *pBitmap, int16_t colIdx, TDRowValT valType);
@ -299,6 +300,7 @@ int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colTyp
 int32_t tdGetTpRowValOfCol(SCellVal *output, STSRow *pRow, void *pBitmap, int8_t colType, int32_t offset,
                           int16_t colIdx);
 int32_t tdGetKvRowValOfCol(SCellVal *output, STSRow *pRow, void *pBitmap, int32_t offset, int16_t colIdx);
 void    tTSRowGetVal(STSRow *pRow, STSchema *pTSchema, int16_t iCol, SColVal *pColVal);
 typedef struct {
  STSchema *pSchema;
@ -312,16 +314,14 @@ typedef struct {
 void    tdSTSRowIterReset(STSRowIter *pIter, STSRow *pRow);
 void    tdSTSRowIterInit(STSRowIter *pIter, STSchema *pSchema);
 int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow);
 bool    tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal);
 bool    tdGetTpRowDataOfCol(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal);
 bool    tdGetKvRowValOfColEx(STSRowIter *pIter, col_id_t colId, col_type_t colType, col_id_t *nIdx, SCellVal *pVal);
 bool    tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal);
 STSRow *mergeTwoRows(void *buffer, STSRow *row1, STSRow *row2, STSchema *pSchema1, STSchema *pSchema2);
 int32_t tdGetColDataOfRow(SCellVal *pVal, SDataCol *pCol, int32_t row, int8_t bitmapMode);
 bool    tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t colType, int32_t flen, uint32_t offset, col_id_t colIdx,
                       SCellVal *pVal);
-bool    tdSKvRowGetVal(STSRow *pRow, col_id_t colId, uint32_t offset, col_id_t colIdx, SCellVal *pVal);
+bool    tdSKvRowGetVal(STSRow *pRow, col_id_t colId, col_id_t colIdx, SCellVal *pVal);
 int32_t dataColGetNEleLen(SDataCol *pDataCol, int32_t rows, int8_t bitmapMode);
 void    tdSCellValPrint(SCellVal *pVal, int8_t colType);
 void    tdSRowPrint(STSRow *row, STSchema *pSchema, const char *tag);
--- a/include/common/ttime.h
+++ b/include/common/ttime.h
@ -72,6 +72,8 @@ static FORCE_INLINE int64_t taosGetTimestampToday(int32_t precision) {
 }
 int64_t taosTimeAdd(int64_t t, int64_t duration, char unit, int32_t precision);
 int64_t taosTimeSub(int64_t t, int64_t duration, char unit, int32_t precision);
 int64_t taosTimeTruncate(int64_t t, const SInterval* pInterval, int32_t precision);
 int32_t taosTimeCountInterval(int64_t skey, int64_t ekey, int64_t interval, char unit, int32_t precision);
--- a/include/common/ttokendef.h
+++ b/include/common/ttokendef.h
@ -73,200 +73,204 @@
 #define TK_MNODE          55
 #define TK_DATABASE       56
 #define TK_USE            57
-#define TK_IF             58
+#define TK_FLUSH          58
-#define TK_NOT            59
+#define TK_TRIM           59
-#define TK_EXISTS         60
+#define TK_IF             60
-#define TK_BUFFER         61
+#define TK_NOT            61
-#define TK_CACHELAST      62
+#define TK_EXISTS         62
-#define TK_COMP           63
+#define TK_BUFFER         63
-#define TK_DURATION       64
+#define TK_CACHELAST      64
-#define TK_NK_VARIABLE    65
+#define TK_CACHELASTSIZE  65
-#define TK_FSYNC          66
+#define TK_COMP           66
-#define TK_MAXROWS        67
+#define TK_DURATION       67
-#define TK_MINROWS        68
+#define TK_NK_VARIABLE    68
-#define TK_KEEP           69
+#define TK_FSYNC          69
-#define TK_PAGES          70
+#define TK_MAXROWS        70
-#define TK_PAGESIZE       71
+#define TK_MINROWS        71
-#define TK_PRECISION      72
+#define TK_KEEP           72
-#define TK_REPLICA        73
+#define TK_PAGES          73
-#define TK_STRICT         74
+#define TK_PAGESIZE       74
-#define TK_WAL            75
+#define TK_PRECISION      75
-#define TK_VGROUPS        76
+#define TK_REPLICA        76
-#define TK_SINGLE_STABLE  77
+#define TK_STRICT         77
-#define TK_RETENTIONS     78
+#define TK_WAL            78
-#define TK_SCHEMALESS     79
+#define TK_VGROUPS        79
-#define TK_NK_COLON       80
+#define TK_SINGLE_STABLE  80
-#define TK_TABLE          81
+#define TK_RETENTIONS     81
-#define TK_NK_LP          82
+#define TK_SCHEMALESS     82
-#define TK_NK_RP          83
+#define TK_NK_COLON       83
-#define TK_STABLE         84
+#define TK_TABLE          84
-#define TK_ADD            85
+#define TK_NK_LP          85
-#define TK_COLUMN         86
+#define TK_NK_RP          86
-#define TK_MODIFY         87
+#define TK_STABLE         87
-#define TK_RENAME         88
+#define TK_ADD            88
-#define TK_TAG            89
+#define TK_COLUMN         89
-#define TK_SET            90
+#define TK_MODIFY         90
-#define TK_NK_EQ          91
+#define TK_RENAME         91
-#define TK_USING          92
+#define TK_TAG            92
-#define TK_TAGS           93
+#define TK_SET            93
-#define TK_COMMENT        94
+#define TK_NK_EQ          94
-#define TK_BOOL           95
+#define TK_USING          95
-#define TK_TINYINT        96
+#define TK_TAGS           96
-#define TK_SMALLINT       97
+#define TK_COMMENT        97
-#define TK_INT            98
+#define TK_BOOL           98
-#define TK_INTEGER        99
+#define TK_TINYINT        99
-#define TK_BIGINT         100
+#define TK_SMALLINT       100
-#define TK_FLOAT          101
+#define TK_INT            101
-#define TK_DOUBLE         102
+#define TK_INTEGER        102
-#define TK_BINARY         103
+#define TK_BIGINT         103
-#define TK_TIMESTAMP      104
+#define TK_FLOAT          104
-#define TK_NCHAR          105
+#define TK_DOUBLE         105
-#define TK_UNSIGNED       106
+#define TK_BINARY         106
-#define TK_JSON           107
+#define TK_TIMESTAMP      107
-#define TK_VARCHAR        108
+#define TK_NCHAR          108
-#define TK_MEDIUMBLOB     109
+#define TK_UNSIGNED       109
-#define TK_BLOB           110
+#define TK_JSON           110
-#define TK_VARBINARY      111
+#define TK_VARCHAR        111
-#define TK_DECIMAL        112
+#define TK_MEDIUMBLOB     112
-#define TK_MAX_DELAY      113
+#define TK_BLOB           113
-#define TK_WATERMARK      114
+#define TK_VARBINARY      114
-#define TK_ROLLUP         115
+#define TK_DECIMAL        115
-#define TK_TTL            116
+#define TK_MAX_DELAY      116
-#define TK_SMA            117
+#define TK_WATERMARK      117
-#define TK_FIRST          118
+#define TK_ROLLUP         118
-#define TK_LAST           119
+#define TK_TTL            119
-#define TK_SHOW           120
+#define TK_SMA            120
-#define TK_DATABASES      121
+#define TK_FIRST          121
-#define TK_TABLES         122
+#define TK_LAST           122
-#define TK_STABLES        123
+#define TK_SHOW           123
-#define TK_MNODES         124
+#define TK_DATABASES      124
-#define TK_MODULES        125
+#define TK_TABLES         125
-#define TK_QNODES         126
+#define TK_STABLES        126
-#define TK_FUNCTIONS      127
+#define TK_MNODES         127
-#define TK_INDEXES        128
+#define TK_MODULES        128
-#define TK_ACCOUNTS       129
+#define TK_QNODES         129
-#define TK_APPS           130
+#define TK_FUNCTIONS      130
-#define TK_CONNECTIONS    131
+#define TK_INDEXES        131
-#define TK_LICENCE        132
+#define TK_ACCOUNTS       132
-#define TK_GRANTS         133
+#define TK_APPS           133
-#define TK_QUERIES        134
+#define TK_CONNECTIONS    134
-#define TK_SCORES         135
+#define TK_LICENCE        135
-#define TK_TOPICS         136
+#define TK_GRANTS         136
-#define TK_VARIABLES      137
+#define TK_QUERIES        137
-#define TK_BNODES         138
+#define TK_SCORES         138
-#define TK_SNODES         139
+#define TK_TOPICS         139
-#define TK_CLUSTER        140
+#define TK_VARIABLES      140
-#define TK_TRANSACTIONS   141
+#define TK_BNODES         141
-#define TK_DISTRIBUTED    142
+#define TK_SNODES         142
-#define TK_CONSUMERS      143
+#define TK_CLUSTER        143
-#define TK_SUBSCRIPTIONS  144
+#define TK_TRANSACTIONS   144
-#define TK_LIKE           145
+#define TK_DISTRIBUTED    145
-#define TK_INDEX          146
+#define TK_CONSUMERS      146
-#define TK_FUNCTION       147
+#define TK_SUBSCRIPTIONS  147
-#define TK_INTERVAL       148
+#define TK_LIKE           148
-#define TK_TOPIC          149
+#define TK_INDEX          149
-#define TK_AS             150
+#define TK_FUNCTION       150
-#define TK_WITH           151
+#define TK_INTERVAL       151
-#define TK_META           152
+#define TK_TOPIC          152
-#define TK_CONSUMER       153
+#define TK_AS             153
-#define TK_GROUP          154
+#define TK_WITH           154
-#define TK_DESC           155
+#define TK_META           155
-#define TK_DESCRIBE       156
+#define TK_CONSUMER       156
-#define TK_RESET          157
+#define TK_GROUP          157
-#define TK_QUERY          158
+#define TK_DESC           158
-#define TK_CACHE          159
+#define TK_DESCRIBE       159
-#define TK_EXPLAIN        160
+#define TK_RESET          160
-#define TK_ANALYZE        161
+#define TK_QUERY          161
-#define TK_VERBOSE        162
+#define TK_CACHE          162
-#define TK_NK_BOOL        163
+#define TK_EXPLAIN        163
-#define TK_RATIO          164
+#define TK_ANALYZE        164
-#define TK_NK_FLOAT       165
+#define TK_VERBOSE        165
-#define TK_COMPACT        166
+#define TK_NK_BOOL        166
-#define TK_VNODES         167
+#define TK_RATIO          167
-#define TK_IN             168
+#define TK_NK_FLOAT       168
-#define TK_OUTPUTTYPE     169
+#define TK_COMPACT        169
-#define TK_AGGREGATE      170
+#define TK_VNODES         170
-#define TK_BUFSIZE        171
+#define TK_IN             171
-#define TK_STREAM         172
+#define TK_OUTPUTTYPE     172
-#define TK_INTO           173
+#define TK_AGGREGATE      173
-#define TK_TRIGGER        174
+#define TK_BUFSIZE        174
-#define TK_AT_ONCE        175
+#define TK_STREAM         175
-#define TK_WINDOW_CLOSE   176
+#define TK_INTO           176
-#define TK_IGNORE         177
+#define TK_TRIGGER        177
-#define TK_EXPIRED        178
+#define TK_AT_ONCE        178
-#define TK_KILL           179
+#define TK_WINDOW_CLOSE   179
-#define TK_CONNECTION     180
+#define TK_IGNORE         180
-#define TK_TRANSACTION    181
+#define TK_EXPIRED        181
-#define TK_BALANCE        182
+#define TK_KILL           182
-#define TK_VGROUP         183
+#define TK_CONNECTION     183
-#define TK_MERGE          184
+#define TK_TRANSACTION    184
-#define TK_REDISTRIBUTE   185
+#define TK_BALANCE        185
-#define TK_SPLIT          186
+#define TK_VGROUP         186
-#define TK_SYNCDB         187
+#define TK_MERGE          187
-#define TK_DELETE         188
+#define TK_REDISTRIBUTE   188
-#define TK_NULL           189
+#define TK_SPLIT          189
-#define TK_NK_QUESTION    190
+#define TK_SYNCDB         190
-#define TK_NK_ARROW       191
+#define TK_DELETE         191
-#define TK_ROWTS          192
+#define TK_INSERT         192
-#define TK_TBNAME         193
+#define TK_NULL           193
-#define TK_QSTARTTS       194
+#define TK_NK_QUESTION    194
-#define TK_QENDTS         195
+#define TK_NK_ARROW       195
-#define TK_WSTARTTS       196
+#define TK_ROWTS          196
-#define TK_WENDTS         197
+#define TK_TBNAME         197
-#define TK_WDURATION      198
+#define TK_QSTART         198
-#define TK_CAST           199
+#define TK_QEND           199
-#define TK_NOW            200
+#define TK_QDURATION      200
-#define TK_TODAY          201
+#define TK_WSTART         201
-#define TK_TIMEZONE       202
+#define TK_WEND           202
-#define TK_CLIENT_VERSION 203
+#define TK_WDURATION      203
-#define TK_SERVER_VERSION 204
+#define TK_CAST           204
-#define TK_SERVER_STATUS  205
+#define TK_NOW            205
-#define TK_CURRENT_USER   206
+#define TK_TODAY          206
-#define TK_COUNT          207
+#define TK_TIMEZONE       207
-#define TK_LAST_ROW       208
+#define TK_CLIENT_VERSION 208
-#define TK_BETWEEN        209
+#define TK_SERVER_VERSION 209
-#define TK_IS             210
+#define TK_SERVER_STATUS  210
-#define TK_NK_LT          211
+#define TK_CURRENT_USER   211
-#define TK_NK_GT          212
+#define TK_COUNT          212
-#define TK_NK_LE          213
+#define TK_LAST_ROW       213
-#define TK_NK_GE          214
+#define TK_BETWEEN        214
-#define TK_NK_NE          215
+#define TK_IS             215
-#define TK_MATCH          216
+#define TK_NK_LT          216
-#define TK_NMATCH         217
+#define TK_NK_GT          217
-#define TK_CONTAINS       218
+#define TK_NK_LE          218
-#define TK_JOIN           219
+#define TK_NK_GE          219
-#define TK_INNER          220
+#define TK_NK_NE          220
-#define TK_SELECT         221
+#define TK_MATCH          221
-#define TK_DISTINCT       222
+#define TK_NMATCH         222
-#define TK_WHERE          223
+#define TK_CONTAINS       223
-#define TK_PARTITION      224
+#define TK_JOIN           224
-#define TK_BY             225
+#define TK_INNER          225
-#define TK_SESSION        226
+#define TK_SELECT         226
-#define TK_STATE_WINDOW   227
+#define TK_DISTINCT       227
-#define TK_SLIDING        228
+#define TK_WHERE          228
-#define TK_FILL           229
+#define TK_PARTITION      229
-#define TK_VALUE          230
+#define TK_BY             230
-#define TK_NONE           231
+#define TK_SESSION        231
-#define TK_PREV           232
+#define TK_STATE_WINDOW   232
-#define TK_LINEAR         233
+#define TK_SLIDING        233
-#define TK_NEXT           234
+#define TK_FILL           234
-#define TK_HAVING         235
+#define TK_VALUE          235
-#define TK_RANGE          236
+#define TK_NONE           236
-#define TK_EVERY          237
+#define TK_PREV           237
-#define TK_ORDER          238
+#define TK_LINEAR         238
-#define TK_SLIMIT         239
+#define TK_NEXT           239
-#define TK_SOFFSET        240
+#define TK_HAVING         240
-#define TK_LIMIT          241
+#define TK_RANGE          241
-#define TK_OFFSET         242
+#define TK_EVERY          242
-#define TK_ASC            243
+#define TK_ORDER          243
-#define TK_NULLS          244
+#define TK_SLIMIT         244
-#define TK_ID             245
+#define TK_SOFFSET        245
-#define TK_NK_BITNOT      246
+#define TK_LIMIT          246
-#define TK_INSERT         247
+#define TK_OFFSET         247
-#define TK_VALUES         248
+#define TK_ASC            248
-#define TK_IMPORT         249
+#define TK_NULLS          249
-#define TK_NK_SEMI        250
+#define TK_ID             250
-#define TK_FILE           251
+#define TK_NK_BITNOT      251
 #define TK_VALUES         252
 #define TK_IMPORT         253
 #define TK_NK_SEMI        254
 #define TK_FILE           255
 #define TK_NK_SPACE   300
 #define TK_NK_COMMENT 301
--- a/include/dnode/mnode/mnode.h
+++ b/include/dnode/mnode/mnode.h
@ -52,6 +52,7 @@ SMnode *mndOpen(const char *path, const SMnodeOpt *pOption);
 * @param pMnode The mnode object to close.
 */
 void mndClose(SMnode *pMnode);
 void mndPreClose(SMnode *pMnode);
 /**
 * @brief Start mnode
--- a/include/libs/command/command.h
+++ b/include/libs/command/command.h
@ -13,6 +13,9 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 #ifndef TDENGINE_COMMAND_H
 #define TDENGINE_COMMAND_H
 #include "cmdnodes.h"
 #include "tmsg.h"
 #include "plannodes.h"
@ -27,4 +30,4 @@ int32_t qExecExplainEnd(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp);
 int32_t qExplainUpdateExecInfo(SExplainCtx *pCtx, SExplainRsp *pRspMsg, int32_t groupId, SRetrieveTableRsp **pRsp);
 void    qExplainFreeCtx(SExplainCtx *pCtx);
-
+#endif
--- a/include/libs/executor/dataSinkMgt.h
+++ b/include/libs/executor/dataSinkMgt.h
@ -45,6 +45,10 @@ typedef struct SDeleterParam {
  SArray*  pUidList;
 } SDeleterParam;
 typedef struct SInserterParam {
  SReadHandle* readHandle;
 } SInserterParam;
 typedef struct SDataSinkStat {
  uint64_t cachedSize;
 } SDataSinkStat;
@ -96,7 +100,7 @@ void dsEndPut(DataSinkHandle handle, uint64_t useconds);
 * @param handle
 * @param pLen data length
 */
-void dsGetDataLength(DataSinkHandle handle, int32_t* pLen, bool* pQueryEnd);
+void dsGetDataLength(DataSinkHandle handle, int64_t* pLen, bool* pQueryEnd);
 /**
 * Get data, the caller needs to allocate data memory.
--- a/include/libs/executor/executor.h
+++ b/include/libs/executor/executor.h
@ -30,34 +30,40 @@ struct SRpcMsg;
 struct SSubplan;
 typedef struct SReadHandle {
-  void*   reader;
+  void*   tqReader;
  void*   meta;
  void*   config;
  void*   vnode;
  void*   mnd;
  SMsgCb* pMsgCb;
-  bool    tqReader;
+  int64_t version;
  bool    initMetaReader;
  bool    initTableReader;
  bool    initTqReader;
 } SReadHandle;
 // in queue mode, data streams are seperated by msg
 typedef enum {
  OPTR_EXEC_MODEL_BATCH = 0x1,
  OPTR_EXEC_MODEL_STREAM = 0x2,
  OPTR_EXEC_MODEL_QUEUE = 0x3,
 } EOPTR_EXEC_MODEL;
 /**
- * Create the exec task for streaming mode
+ * Create the exec task for stream mode
 * @param pMsg
- * @param streamReadHandle
+ * @param SReadHandle
 * @return
 */
-qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, void* streamReadHandle);
+qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers);
 /**
- * Switch the stream scan to snapshot mode
+ * Create the exec task for queue mode
- * @param tinfo
+ * @param pMsg
 * @param SReadHandle
 * @return
 */
-int32_t qStreamScanSnapshot(qTaskInfo_t tinfo);
+qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* readers);
 /**
 * Set the input data block for the stream scan.
@ -107,8 +113,8 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
 * @param tversion
 * @return
 */
-int32_t qGetQueriedTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* tableName, int32_t* sversion,
+int32_t qGetQueryTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* tableName, int32_t* sversion,
-                                      int32_t* tversion);
+                                    int32_t* tversion);
 /**
 * The main task execution function, including query on both table and multiple tables,
@ -155,7 +161,7 @@ int64_t qGetQueriedTableUid(qTaskInfo_t tinfo);
 */
 int32_t qGetQualifiedTableIdList(void* pTableList, const char* tagCond, int32_t tagCondLen, SArray* pTableIdList);
-void qProcessFetchRsp(void* parent, struct SRpcMsg* pMsg, struct SEpSet* pEpSet);
+void qProcessRspMsg(void* parent, struct SRpcMsg* pMsg, struct SEpSet* pEpSet);
 int32_t qGetExplainExecInfo(qTaskInfo_t tinfo, int32_t* resNum, SExplainExecInfo** pRes);
@ -172,7 +178,19 @@ int32_t qDeserializeTaskStatus(qTaskInfo_t tinfo, const char* pInput, int32_t le
 */
 int32_t qGetStreamScanStatus(qTaskInfo_t tinfo, uint64_t* uid, int64_t* ts);
-int32_t qStreamPrepareScan(qTaskInfo_t tinfo, uint64_t uid, int64_t ts);
+int32_t qStreamPrepareTsdbScan(qTaskInfo_t tinfo, uint64_t uid, int64_t ts);
 int32_t qStreamPrepareScan(qTaskInfo_t tinfo, const STqOffsetVal* pOffset);
 int32_t qStreamExtractOffset(qTaskInfo_t tinfo, STqOffsetVal* pOffset);
 void* qStreamExtractMetaMsg(qTaskInfo_t tinfo);
 void* qExtractReaderFromStreamScanner(void* scanner);
 int32_t qExtractStreamScanner(qTaskInfo_t tinfo, void** scanner);
 int32_t qStreamInput(qTaskInfo_t tinfo, void* pItem);
 #ifdef __cplusplus
 }
--- a/include/libs/function/function.h
+++ b/include/libs/function/function.h
@ -172,7 +172,13 @@ typedef struct tExprNode {
 void tExprTreeDestroy(tExprNode *pNode, void (*fp)(void *));
 typedef enum {
  SHOULD_FREE_COLDATA    = 0x1,   // the newly created column data needs to be destroyed.
  DELEGATED_MGMT_COLDATA = 0x2,   // input column data should not be released.
 } ECOLDATA_MGMT_TYPE_E;
 struct SScalarParam {
  ECOLDATA_MGMT_TYPE_E type;
  SColumnInfoData *columnData;
  SHashObj        *pHashFilter;
  int32_t          hashValueType;
--- a/include/libs/function/functionMgt.h
+++ b/include/libs/function/functionMgt.h
@ -34,7 +34,7 @@ typedef enum EFunctionType {
  FUNCTION_TYPE_ELAPSED,
  FUNCTION_TYPE_IRATE,
  FUNCTION_TYPE_LAST_ROW,
-  FUNCTION_TYPE_LAST_ROWT, //TODO: removed
+  FUNCTION_TYPE_LAST_ROWT,  // TODO: removed
  FUNCTION_TYPE_MAX,
  FUNCTION_TYPE_MIN,
  FUNCTION_TYPE_MODE,
@ -114,10 +114,11 @@ typedef enum EFunctionType {
  // pseudo column function
  FUNCTION_TYPE_ROWTS = 3500,
  FUNCTION_TYPE_TBNAME,
-  FUNCTION_TYPE_QSTARTTS,
+  FUNCTION_TYPE_QSTART,
-  FUNCTION_TYPE_QENDTS,
+  FUNCTION_TYPE_QEND,
-  FUNCTION_TYPE_WSTARTTS,
+  FUNCTION_TYPE_QDURATION,
-  FUNCTION_TYPE_WENDTS,
+  FUNCTION_TYPE_WSTART,
  FUNCTION_TYPE_WEND,
  FUNCTION_TYPE_WDURATION,
  // internal function
@ -196,6 +197,8 @@ bool fmIsIntervalInterpoFunc(int32_t funcId);
 bool fmIsInterpFunc(int32_t funcId);
 bool fmIsLastRowFunc(int32_t funcId);
 bool fmIsSystemInfoFunc(int32_t funcId);
 bool fmIsImplicitTsFunc(int32_t funcId);
 bool fmIsClientPseudoColumnFunc(int32_t funcId);
 int32_t fmGetDistMethod(const SFunctionNode* pFunc, SFunctionNode** pPartialFunc, SFunctionNode** pMergeFunc);
--- a/include/libs/index/index.h
+++ b/include/libs/index/index.h
@ -127,7 +127,7 @@ int indexSearch(SIndex* index, SIndexMultiTermQuery* query, SArray* result);
 * @parma opt   (input, rebuild index opts)
 * @return error code
 */
-int indexRebuild(SIndex* index, SIndexOpts* opt);
+// int indexRebuild(SIndex* index, SIndexOpts* opt);
 /*
 * open index
@ -185,6 +185,25 @@ SIndexTerm* indexTermCreate(int64_t suid, SIndexOperOnColumn operType, uint8_t c
                            int32_t nColName, const char* colVal, int32_t nColVal);
 void        indexTermDestroy(SIndexTerm* p);
 /*
 * rebuild index
 */
 void indexRebuild(SIndexJson* idx, void* iter);
 /*
 * check index json status
 **/
 bool indexIsRebuild(SIndex* idx);
 /*
 * rebuild index json
 */
 void indexJsonRebuild(SIndexJson* idx, void* iter);
 /*
 * check index json status
 **/
 bool indexJsonIsRebuild(SIndexJson* idx);
 /*
 * init index env
 *
@ -203,12 +222,12 @@ typedef enum { SFLT_NOT_INDEX, SFLT_COARSE_INDEX, SFLT_ACCURATE_INDEX } SIdxFltS
 SIdxFltStatus idxGetFltStatus(SNode* pFilterNode);
-int32_t doFilterTag(const SNode* pFilterNode, SIndexMetaArg* metaArg, SArray* result);
+int32_t doFilterTag(SNode* pFilterNode, SIndexMetaArg* metaArg, SArray* result, SIdxFltStatus* status);
 /*
 * destory index env
 *
 */
-void indexCleanUp();
+void indexCleanup();
 #ifdef __cplusplus
 }
--- a/include/libs/nodes/cmdnodes.h
+++ b/include/libs/nodes/cmdnodes.h
@ -51,7 +51,8 @@ extern "C" {
 typedef struct SDatabaseOptions {
  ENodeType   type;
  int32_t     buffer;
-  int8_t      cachelast;
+  int8_t      cacheLast;
  int32_t     cacheLastSize;
  int8_t      compressionLevel;
  int32_t     daysPerFile;
  SValueNode* pDaysPerFile;
@ -97,6 +98,16 @@ typedef struct SAlterDatabaseStmt {
  SDatabaseOptions* pOptions;
 } SAlterDatabaseStmt;
 typedef struct SFlushDatabaseStmt {
  ENodeType type;
  char      dbName[TSDB_DB_NAME_LEN];
 } SFlushDatabaseStmt;
 typedef struct STrimDatabaseStmt {
  ENodeType type;
  char      dbName[TSDB_DB_NAME_LEN];
 } STrimDatabaseStmt;
 typedef struct STableOptions {
  ENodeType  type;
  bool       commentNull;
--- a/include/libs/nodes/nodes.h
+++ b/include/libs/nodes/nodes.h
@ -22,8 +22,8 @@ extern "C" {
 #include "tdef.h"
-#define nodeType(nodeptr)          (((const SNode*)(nodeptr))->type)
+#define nodeType(nodeptr)              (((const SNode*)(nodeptr))->type)
-#define setNodeType(nodeptr, type) (((SNode*)(nodeptr))->type = (type))
+#define setNodeType(nodeptr, nodetype) (((SNode*)(nodeptr))->type = (nodetype))
 #define LIST_LENGTH(l) (NULL != (l) ? (l)->length : 0)
@ -111,6 +111,8 @@ typedef enum ENodeType {
  QUERY_NODE_CREATE_DATABASE_STMT,
  QUERY_NODE_DROP_DATABASE_STMT,
  QUERY_NODE_ALTER_DATABASE_STMT,
  QUERY_NODE_FLUSH_DATABASE_STMT,
  QUERY_NODE_TRIM_DATABASE_STMT,
  QUERY_NODE_CREATE_TABLE_STMT,
  QUERY_NODE_CREATE_SUBTABLE_CLAUSE,
  QUERY_NODE_CREATE_MULTI_TABLE_STMT,
@ -118,6 +120,7 @@ typedef enum ENodeType {
  QUERY_NODE_DROP_TABLE_STMT,
  QUERY_NODE_DROP_SUPER_TABLE_STMT,
  QUERY_NODE_ALTER_TABLE_STMT,
  QUERY_NODE_ALTER_SUPER_TABLE_STMT,
  QUERY_NODE_CREATE_USER_STMT,
  QUERY_NODE_ALTER_USER_STMT,
  QUERY_NODE_DROP_USER_STMT,
@ -193,6 +196,7 @@ typedef enum ENodeType {
  QUERY_NODE_KILL_QUERY_STMT,
  QUERY_NODE_KILL_TRANSACTION_STMT,
  QUERY_NODE_DELETE_STMT,
  QUERY_NODE_INSERT_STMT,
  QUERY_NODE_QUERY,
  // logic plan node
@ -246,6 +250,7 @@ typedef enum ENodeType {
  QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC,
  QUERY_NODE_PHYSICAL_PLAN_DISPATCH,
  QUERY_NODE_PHYSICAL_PLAN_INSERT,
  QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT,
  QUERY_NODE_PHYSICAL_PLAN_DELETE,
  QUERY_NODE_PHYSICAL_SUBPLAN,
  QUERY_NODE_PHYSICAL_PLAN
--- a/include/libs/nodes/plannodes.h
+++ b/include/libs/nodes/plannodes.h
@ -82,6 +82,7 @@ typedef struct SScanLogicNode {
 typedef struct SJoinLogicNode {
  SLogicNode node;
  EJoinType  joinType;
  SNode*     pMergeCondition;
  SNode*     pOnConditions;
  bool       isSingleTableJoin;
 } SJoinLogicNode;
@ -104,6 +105,7 @@ typedef struct SIndefRowsFuncLogicNode {
  SNodeList* pFuncs;
  bool       isTailFunc;
  bool       isUniqueFunc;
  bool       isTimeLineFunc;
 } SIndefRowsFuncLogicNode;
 typedef struct SInterpFuncLogicNode {
@ -126,9 +128,12 @@ typedef struct SVnodeModifyLogicNode {
  SVgDataBlocks*   pVgDataBlocks;
  SNode*           pAffectedRows;  // SColumnNode
  uint64_t         tableId;
  uint64_t         stableId;
  int8_t           tableType;  // table type
  char             tableFName[TSDB_TABLE_FNAME_LEN];
  STimeWindow      deleteTimeRange;
  SVgroupsInfo*    pVgroupList;
  SNodeList*       pInsertCols;
 } SVnodeModifyLogicNode;
 typedef struct SExchangeLogicNode {
@ -319,6 +324,7 @@ typedef struct SInterpFuncPhysiNode {
  SNodeList*  pFuncs;
  STimeWindow timeRange;
  int64_t     interval;
  int8_t      intervalUnit;
  EFillMode   fillMode;
  SNode*      pFillValues;  // SNodeListNode
  SNode*      pTimeSeries;  // SColumnNode
@ -327,6 +333,7 @@ typedef struct SInterpFuncPhysiNode {
 typedef struct SJoinPhysiNode {
  SPhysiNode node;
  EJoinType  joinType;
  SNode*     pMergeCondition;
  SNode*     pOnConditions;
  SNodeList* pTargets;
 } SJoinPhysiNode;
@ -346,6 +353,7 @@ typedef struct SDownstreamSourceNode {
  uint64_t       taskId;
  uint64_t       schedId;
  int32_t        execId;
  int32_t        fetchMsgType;
 } SDownstreamSourceNode;
 typedef struct SExchangePhysiNode {
@ -452,6 +460,17 @@ typedef struct SDataInserterNode {
  char*         pData;
 } SDataInserterNode;
 typedef struct SQueryInserterNode {
  SDataSinkNode sink;
  SNodeList*    pCols;
  uint64_t      tableId;
  uint64_t      stableId;
  int8_t        tableType;  // table type
  char          tableFName[TSDB_TABLE_FNAME_LEN];
  int32_t       vgId;
  SEpSet        epSet;
 } SQueryInserterNode;
 typedef struct SDataDeleterNode {
  SDataSinkNode sink;
  uint64_t      tableId;
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@ -228,7 +228,7 @@ typedef struct SFillNode {
  ENodeType   type;  // QUERY_NODE_FILL
  EFillMode   mode;
  SNode*      pValues;    // SNodeListNode
-  SNode*      pWStartTs;  // _wstartts pseudo column
+  SNode*      pWStartTs;  // _wstart pseudo column
  STimeWindow timeRange;
 } SFillNode;
@ -248,19 +248,23 @@ typedef struct SSelectStmt {
  SNodeList*  pOrderByList;  // SOrderByExprNode
  SLimitNode* pLimit;
  SLimitNode* pSlimit;
  STimeWindow timeRange;
  char        stmtName[TSDB_TABLE_NAME_LEN];
  uint8_t     precision;
  int32_t     selectFuncNum;
  bool        isEmptyResult;
-  bool        isTimeOrderQuery;
+  bool        isTimeLineResult;
  bool        hasAggFuncs;
  bool        hasRepeatScanFuncs;
  bool        hasIndefiniteRowsFunc;
  bool        hasSelectFunc;
  bool        hasSelectValFunc;
  bool        hasOtherVectorFunc;
  bool        hasUniqueFunc;
  bool        hasTailFunc;
  bool        hasInterpFunc;
  bool        hasLastRowFunc;
  bool        hasTimeLineFunc;
  bool        groupSort;
 } SSelectStmt;
@ -301,6 +305,14 @@ typedef struct SDeleteStmt {
  bool        deleteZeroRows;
 } SDeleteStmt;
 typedef struct SInsertStmt {
  ENodeType  type;  // QUERY_NODE_INSERT_STMT
  SNode*     pTable;
  SNodeList* pCols;
  SNode*     pQuery;
  uint8_t    precision;
 } SInsertStmt;
 typedef enum {
  PAYLOAD_TYPE_KV = 0,
  PAYLOAD_TYPE_RAW = 1,
@ -375,6 +387,7 @@ void nodesRewriteSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeRewrit
 typedef enum ECollectColType { COLLECT_COL_TYPE_COL = 1, COLLECT_COL_TYPE_TAG, COLLECT_COL_TYPE_ALL } ECollectColType;
 int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char* pTableAlias, ECollectColType type,
                            SNodeList** pCols);
 int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, ECollectColType type, SNodeList** pCols);
 typedef bool (*FFuncClassifier)(int32_t funcId);
 int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, FFuncClassifier classifier, SNodeList** pFuncs);
--- a/include/libs/parser/parser.h
+++ b/include/libs/parser/parser.h
@ -56,7 +56,7 @@ typedef struct SParseContext {
 } SParseContext;
 int32_t qParseSql(SParseContext* pCxt, SQuery** pQuery);
-bool    qIsInsertSql(const char* pStr, size_t length);
+bool    qIsInsertValuesSql(const char* pStr, size_t length);
 // for async mode
 int32_t qParseSqlSyntax(SParseContext* pCxt, SQuery** pQuery, struct SCatalogReq* pCatalogReq);
@ -96,6 +96,9 @@ int32_t smlBindData(void* handle, SArray* tags, SArray* colsSchema, SArray* cols
                    char* tableName, char* msgBuf, int16_t msgBufLen);
 int32_t smlBuildOutput(void* handle, SHashObj* pVgHash);
 int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray);
 SArray* serializeVgroupsCreateTableBatch(SHashObj* pVgroupHashmap);
 SArray* serializeVgroupsDropTableBatch(SHashObj* pVgroupHashmap);
 #ifdef __cplusplus
 }
 #endif
--- a/include/libs/qcom/query.h
+++ b/include/libs/qcom/query.h
@ -29,12 +29,13 @@ extern "C" {
 typedef enum {
  JOB_TASK_STATUS_NULL = 0,
-  JOB_TASK_STATUS_NOT_START = 1,
+  JOB_TASK_STATUS_INIT,
-  JOB_TASK_STATUS_EXECUTING,
+  JOB_TASK_STATUS_EXEC,
-  JOB_TASK_STATUS_PARTIAL_SUCCEED,
+  JOB_TASK_STATUS_PART_SUCC,
-  JOB_TASK_STATUS_SUCCEED,
+  JOB_TASK_STATUS_SUCC,
-  JOB_TASK_STATUS_FAILED,
+  JOB_TASK_STATUS_FAIL,
-  JOB_TASK_STATUS_DROPPING,
+  JOB_TASK_STATUS_DROP,
  JOB_TASK_STATUS_MAX,
 } EJobTaskType;
 typedef enum {
@ -59,18 +60,21 @@ typedef struct STableComInfo {
  int32_t  rowSize;       // row size of the schema
 } STableComInfo;
 typedef struct SQueryExecRes {
  int32_t msgType;
  void*   res;
 } SQueryExecRes;
 typedef struct SIndexMeta {
-#ifdef WINDOWS
+#if defined(WINDOWS) || defined(_TD_DARWIN_64)
  size_t avoidCompilationErrors;
 #endif
 } SIndexMeta;
 typedef struct SExecResult {
  int32_t         code;
  uint64_t        numOfRows;
  int32_t         msgType;
  void*           res;
 } SExecResult;
 typedef struct STbVerInfo {
  char    tbFName[TSDB_TABLE_FNAME_LEN];
  int32_t sversion;
@ -210,7 +214,7 @@ char*   jobTaskStatusStr(int32_t status);
 SSchema createSchema(int8_t type, int32_t bytes, col_id_t colId, const char* name);
-void    destroyQueryExecRes(SQueryExecRes* pRes);
+void    destroyQueryExecRes(SExecResult* pRes);
 int32_t dataConverToStr(char* str, int type, void* buf, int32_t bufSize, int32_t* len);
 char*   parseTagDatatoJson(void* p);
 int32_t cloneTableMeta(STableMeta* pSrc, STableMeta** pDst);
@ -249,13 +253,6 @@ extern int32_t (*queryProcessMsgRsp[TDMT_MAX])(void* output, char* msg, int32_t
  ((_code) == TSDB_CODE_RPC_REDIRECT || (_code) == TSDB_CODE_NODE_NOT_DEPLOYED ||                 \
   (_code) == TSDB_CODE_SYN_NOT_LEADER || (_code) == TSDB_CODE_APP_NOT_READY)
 #define NEED_SCHEDULER_RETRY_ERROR(_code)                                                         \
  (NEED_SCHEDULER_REDIRECT_ERROR(_code) || (_code) == TSDB_CODE_RPC_NETWORK_UNAVAIL ||            \
   (_code) == TSDB_CODE_SCH_TIMEOUT_ERROR || (_code) == TSDB_CODE_RPC_BROKEN_LINK)
 #define REQUEST_TOTAL_EXEC_TIMES 2
 #define qFatal(...)                                                                           \
--- a/include/libs/qworker/qworker.h
+++ b/include/libs/qworker/qworker.h
@ -20,9 +20,9 @@
 extern "C" {
 #endif
 #include "executor.h"
 #include "tmsgcb.h"
 #include "trpc.h"
 #include "executor.h"
 enum {
  NODE_TYPE_VNODE = 1,
@ -31,13 +31,6 @@ enum {
  NODE_TYPE_MNODE,
 };
 typedef struct SDeleteRes {
  uint64_t suid;
  SArray*  uidList;
  int64_t  skey;
  int64_t  ekey;
 } SDeleteRes;
 typedef struct SQWorkerCfg {
  uint32_t maxSchedulerNum;
  uint32_t maxTaskNum;
@ -46,19 +39,19 @@ typedef struct SQWorkerCfg {
 typedef struct {
  uint64_t cacheDataSize;
-  
+
  uint64_t queryProcessed;
  uint64_t cqueryProcessed;
  uint64_t fetchProcessed;
  uint64_t dropProcessed;
  uint64_t hbProcessed;
  uint64_t deleteProcessed;
-  
+
  uint64_t numOfQueryInQueue;
  uint64_t numOfFetchInQueue;
  uint64_t timeInQueryQueue;
  uint64_t timeInFetchQueue;
-  
+
  uint64_t numOfErrors;
 } SQWorkerStat;
@ -74,7 +67,7 @@ int32_t qWorkerProcessCQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, in
 int32_t qWorkerProcessFetchMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts);
-int32_t qWorkerProcessFetchRsp(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts);
+int32_t qWorkerProcessRspMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts);
 int32_t qWorkerProcessCancelMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts);
@ -82,7 +75,7 @@ int32_t qWorkerProcessDropMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int6
 int32_t qWorkerProcessHbMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int64_t ts);
-int32_t qWorkerProcessDeleteMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SRpcMsg *pRsp, SDeleteRes *pRes);
+int32_t qWorkerProcessDeleteMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, SDeleteRes *pRes);
 void qWorkerDestroy(void **qWorkerMgmt);
--- a/include/libs/scalar/scalar.h
+++ b/include/libs/scalar/scalar.h
@ -25,11 +25,14 @@ extern "C" {
 typedef struct SFilterInfo SFilterInfo;
 int32_t scalarGetOperatorResultType(SOperatorNode* pOp);
 /*
 pNode will be freed in API;
 *pRes need to freed in caller
 */
 int32_t scalarCalculateConstants(SNode *pNode, SNode **pRes);
 int32_t scalarCalculateConstantsFromDual(SNode *pNode, SNode **pRes);
 /*
 pDst need to freed in caller
@ -40,7 +43,7 @@ int32_t scalarGetOperatorParamNum(EOperatorType type);
 int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type);
 int32_t vectorGetConvertType(int32_t type1, int32_t type2);
-int32_t vectorConvertImpl(const SScalarParam* pIn, SScalarParam* pOut);
+int32_t vectorConvertImpl(const SScalarParam* pIn, SScalarParam* pOut, int32_t* overflow);
 /* Math functions */
 int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput);
--- a/include/libs/scheduler/scheduler.h
+++ b/include/libs/scheduler/scheduler.h
@ -53,12 +53,6 @@ typedef struct SQueryProfileSummary {
  uint64_t resultSize;   // generated result size in Kb.
 } SQueryProfileSummary;
 typedef struct SQueryResult {
  int32_t         code;
  uint64_t        numOfRows;
  SQueryExecRes   res;
 } SQueryResult;
 typedef struct STaskInfo {
  SQueryNodeAddr addr;
  SSubQueryMsg  *msg;
@ -69,50 +63,34 @@ typedef struct SSchdFetchParam {
  int32_t* code;
 } SSchdFetchParam;
-typedef void (*schedulerExecFp)(SQueryResult* pResult, void* param, int32_t code);
+typedef void (*schedulerExecFp)(SExecResult* pResult, void* param, int32_t code);
 typedef void (*schedulerFetchFp)(void* pResult, void* param, int32_t code);
 typedef bool (*schedulerChkKillFp)(void* param);
 typedef struct SSchedulerReq {
  bool                  syncReq;
  SRequestConnInfo     *pConn;
  SArray               *pNodeList;
  SQueryPlan           *pDag;
  const char           *sql;
  int64_t               startTs;
  schedulerExecFp       execFp;
-  void*                 execParam;
+  schedulerFetchFp      fetchFp;
  void*                 cbParam;
  schedulerChkKillFp    chkKillFp;
  void*                 chkKillParam;
  SExecResult*          pExecRes;
  void**                pFetchRes;
 } SSchedulerReq;
 int32_t schedulerInit(SSchedulerCfg *cfg);
-/**
+int32_t schedulerExecJob(SSchedulerReq *pReq, int64_t *pJob);
 * Process the query job, generated according to the query physical plan.
 * This is a synchronized API, and is also thread-safety.
 * @param nodeList  Qnode/Vnode address list, element is SQueryNodeAddr
 * @return
 */
 int32_t schedulerExecJob(SSchedulerReq *pReq, int64_t *pJob, SQueryResult *pRes);
-/**
+int32_t schedulerFetchRows(int64_t jobId, SSchedulerReq *pReq);
 * Process the query job, generated according to the query physical plan.
 * This is a asynchronized API, and is also thread-safety.
 * @param pNodeList  Qnode/Vnode address list, element is SQueryNodeAddr
 * @return
 */
  int32_t schedulerAsyncExecJob(SSchedulerReq *pReq, int64_t *pJob);
-/**
+void schedulerFetchRowsA(int64_t job, schedulerFetchFp fp, void* param);
 * Fetch query result from the remote query executor
 * @param pJob
 * @param data
 * @return
 */
 int32_t schedulerFetchRows(int64_t job, void **data);
 void schedulerAsyncFetchRows(int64_t job, schedulerFetchFp fp, void* param);
 int32_t schedulerGetTasksStatus(int64_t job, SArray *pSub);
@ -130,11 +108,11 @@ void schedulerStopQueryHb(void *pTrans);
 * Free the query job
 * @param pJob
 */
-void schedulerFreeJob(int64_t job, int32_t errCode);
+void schedulerFreeJob(int64_t* job, int32_t errCode);
 void schedulerDestroy(void);
-void schdExecCallback(SQueryResult* pResult, void* param, int32_t code);
+void schdExecCallback(SExecResult* pResult, void* param, int32_t code);
 #ifdef __cplusplus
 }
--- a/include/libs/stream/tstream.h
+++ b/include/libs/stream/tstream.h
@ -13,7 +13,9 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 #include "executor.h"
 #include "os.h"
 #include "query.h"
 #include "tdatablock.h"
 #include "tmsg.h"
 #include "tmsgcb.h"
@ -223,7 +225,7 @@ typedef struct {
  SEpSet  epSet;
 } SStreamChildEpInfo;
-struct SStreamTask {
+typedef struct SStreamTask {
  int64_t streamId;
  int32_t taskId;
  int8_t  isDataScan;
@ -277,7 +279,7 @@ struct SStreamTask {
  // msg handle
  SMsgCb* pMsgCb;
-};
+} SStreamTask;
 int32_t tEncodeStreamEpInfo(SEncoder* pEncoder, const SStreamChildEpInfo* pInfo);
 int32_t tDecodeStreamEpInfo(SDecoder* pDecoder, SStreamChildEpInfo* pInfo);
@ -288,6 +290,7 @@ int32_t      tDecodeSStreamTask(SDecoder* pDecoder, SStreamTask* pTask);
 void         tFreeSStreamTask(SStreamTask* pTask);
 static FORCE_INLINE int32_t streamTaskInput(SStreamTask* pTask, SStreamQueueItem* pItem) {
 #if 0
  while (1) {
    int8_t inputStatus =
        atomic_val_compare_exchange_8(&pTask->inputStatus, TASK_INPUT_STATUS__NORMAL, TASK_INPUT_STATUS__PROCESSING);
@ -296,6 +299,7 @@ static FORCE_INLINE int32_t streamTaskInput(SStreamTask* pTask, SStreamQueueItem
    }
    ASSERT(0);
  }
 #endif
  if (pItem->type == STREAM_INPUT__DATA_SUBMIT) {
    SStreamDataSubmit* pSubmitClone = streamSubmitRefClone((SStreamDataSubmit*)pItem);
@ -303,21 +307,28 @@ static FORCE_INLINE int32_t streamTaskInput(SStreamTask* pTask, SStreamQueueItem
      atomic_store_8(&pTask->inputStatus, TASK_INPUT_STATUS__FAILED);
      return -1;
    }
    qDebug("task %d %p submit enqueue %p %p %p", pTask->taskId, pTask, pItem, pSubmitClone, pSubmitClone->data);
    taosWriteQitem(pTask->inputQueue->queue, pSubmitClone);
    // qStreamInput(pTask->exec.executor, pSubmitClone);
  } else if (pItem->type == STREAM_INPUT__DATA_BLOCK || pItem->type == STREAM_INPUT__DATA_RETRIEVE) {
    taosWriteQitem(pTask->inputQueue->queue, pItem);
    // qStreamInput(pTask->exec.executor, pItem);
  } else if (pItem->type == STREAM_INPUT__CHECKPOINT) {
    taosWriteQitem(pTask->inputQueue->queue, pItem);
    // qStreamInput(pTask->exec.executor, pItem);
  } else if (pItem->type == STREAM_INPUT__TRIGGER) {
    taosWriteQitem(pTask->inputQueue->queue, pItem);
    // qStreamInput(pTask->exec.executor, pItem);
  }
  if (pItem->type != STREAM_INPUT__TRIGGER && pItem->type != STREAM_INPUT__CHECKPOINT && pTask->triggerParam != 0) {
    atomic_val_compare_exchange_8(&pTask->triggerStatus, TASK_TRIGGER_STATUS__IN_ACTIVE, TASK_TRIGGER_STATUS__ACTIVE);
  }
 #if 0
  // TODO: back pressure
  atomic_store_8(&pTask->inputStatus, TASK_INPUT_STATUS__NORMAL);
 #endif
  return 0;
 }
--- a/include/libs/sync/sync.h
+++ b/include/libs/sync/sync.h
@ -26,11 +26,19 @@ extern "C" {
 extern bool gRaftDetailLog;
-#define SYNC_MAX_BATCH_SIZE 100
+#define SYNC_RESP_TTL_MS 5000
 #define SYNC_MAX_BATCH_SIZE 500
 #define SYNC_INDEX_BEGIN 0
 #define SYNC_INDEX_INVALID -1
 #define SYNC_TERM_INVALID 0xFFFFFFFFFFFFFFFF
 typedef enum {
  SYNC_STRATEGY_NO_SNAPSHOT = 0,
  SYNC_STRATEGY_STANDARD_SNAPSHOT = 1,
  SYNC_STRATEGY_WAL_FIRST = 2,
 } ESyncStrategy;
 typedef uint64_t SyncNodeId;
 typedef int32_t  SyncGroupId;
 typedef int64_t  SyncIndex;
@ -48,11 +56,6 @@ typedef enum {
  TAOS_SYNC_STATE_ERROR = 103,
 } ESyncState;
 typedef enum {
  TAOS_SYNC_FSM_CB_SUCCESS = 0,
  TAOS_SYNC_FSM_CB_OTHER_ERROR = 1,
 } ESyncFsmCbCode;
 typedef struct SNodeInfo {
  uint16_t nodePort;
  char     nodeFqdn[TSDB_FQDN_LEN];
@ -96,6 +99,11 @@ typedef struct SReConfigCbMeta {
 } SReConfigCbMeta;
 typedef struct SSnapshotParam {
  SyncIndex start;
  SyncIndex end;
 } SSnapshotParam;
 typedef struct SSnapshot {
  void*     data;
  SyncIndex lastApplyIndex;
@ -125,7 +133,7 @@ typedef struct SSyncFSM {
  int32_t (*FpSnapshotStopRead)(struct SSyncFSM* pFsm, void* pReader);
  int32_t (*FpSnapshotDoRead)(struct SSyncFSM* pFsm, void* pReader, void** ppBuf, int32_t* len);
-  int32_t (*FpSnapshotStartWrite)(struct SSyncFSM* pFsm, void** ppWriter);
+  int32_t (*FpSnapshotStartWrite)(struct SSyncFSM* pFsm, void* pWriterParam, void** ppWriter);
  int32_t (*FpSnapshotStopWrite)(struct SSyncFSM* pFsm, void* pWriter, bool isApply);
  int32_t (*FpSnapshotDoWrite)(struct SSyncFSM* pFsm, void* pWriter, void* pBuf, int32_t len);
@ -157,9 +165,6 @@ typedef struct SSyncLogStore {
  // return commit index of log
  SyncIndex (*getCommitIndex)(struct SSyncLogStore* pLogStore);
  // refactor, log[0 .. n] ==> log[m .. n]
  // int32_t (*syncLogSetBeginIndex)(struct SSyncLogStore* pLogStore, SyncIndex beginIndex);
  SyncIndex (*syncLogBeginIndex)(struct SSyncLogStore* pLogStore);
  SyncIndex (*syncLogEndIndex)(struct SSyncLogStore* pLogStore);
  bool (*syncLogIsEmpty)(struct SSyncLogStore* pLogStore);
@ -178,15 +183,15 @@ typedef struct SSyncLogStore {
 } SSyncLogStore;
 typedef struct SSyncInfo {
-  bool        isStandBy;
+  bool          isStandBy;
-  bool        snapshotEnable;
+  ESyncStrategy snapshotStrategy;
-  SyncGroupId vgId;
+  SyncGroupId   vgId;
-  int32_t     batchSize;
+  int32_t       batchSize;
-  SSyncCfg    syncCfg;
+  SSyncCfg      syncCfg;
-  char        path[TSDB_FILENAME_LEN];
+  char          path[TSDB_FILENAME_LEN];
-  SWal*       pWal;
+  SWal*         pWal;
-  SSyncFSM*   pFsm;
+  SSyncFSM*     pFsm;
-  SMsgCb*     msgcb;
+  SMsgCb*       msgcb;
  int32_t (*FpSendMsg)(const SEpSet* pEpSet, SRpcMsg* pMsg);
  int32_t (*FpEqMsg)(const SMsgCb* msgcb, SRpcMsg* pMsg);
 } SSyncInfo;
@ -205,10 +210,11 @@ SyncGroupId syncGetVgId(int64_t rid);
 void        syncGetEpSet(int64_t rid, SEpSet* pEpSet);
 void        syncGetRetryEpSet(int64_t rid, SEpSet* pEpSet);
 int32_t     syncPropose(int64_t rid, SRpcMsg* pMsg, bool isWeak);
-// int32_t     syncProposeBatch(int64_t rid, SRpcMsg* pMsgArr, bool* pIsWeakArr, int32_t arrSize);
+int32_t     syncProposeBatch(int64_t rid, SRpcMsg* pMsgArr, bool* pIsWeakArr, int32_t arrSize);
 bool        syncEnvIsStart();
 const char* syncStr(ESyncState state);
 bool        syncIsRestoreFinish(int64_t rid);
 int32_t     syncGetSnapshotByIndex(int64_t rid, SyncIndex index, SSnapshot* pSnapshot);
 int32_t syncReconfig(int64_t rid, const SSyncCfg* pNewCfg);
--- a/include/libs/sync/syncTools.h
+++ b/include/libs/sync/syncTools.h
@ -191,12 +191,12 @@ void syncTimeoutLog2(char* s, const SyncTimeout* pMsg);
 typedef struct SyncClientRequest {
  uint32_t bytes;
  int32_t  vgId;
-  uint32_t msgType;          // SyncClientRequest msgType
+  uint32_t msgType;          // TDMT_SYNC_CLIENT_REQUEST
-  uint32_t originalRpcType;  // user RpcMsg msgType
+  uint32_t originalRpcType;  // origin RpcMsg msgType
  uint64_t seqNum;
  bool     isWeak;
-  uint32_t dataLen;  // user RpcMsg.contLen
+  uint32_t dataLen;  // origin RpcMsg.contLen
-  char     data[];   // user RpcMsg.pCont
+  char     data[];   // origin RpcMsg.pCont
 } SyncClientRequest;
 SyncClientRequest* syncClientRequestBuild(uint32_t dataLen);
@ -220,11 +220,6 @@ void syncClientRequestLog(const SyncClientRequest* pMsg);
 void syncClientRequestLog2(char* s, const SyncClientRequest* pMsg);
 // ---------------------------------------------
 typedef struct SOffsetAndContLen {
  int32_t offset;
  int32_t contLen;
 } SOffsetAndContLen;
 typedef struct SRaftMeta {
  uint64_t seqNum;
  bool     isWeak;
@ -232,20 +227,33 @@ typedef struct SRaftMeta {
 // block1:
 // block2: SRaftMeta array
-// block3: rpc msg array (with pCont)
+// block3: rpc msg array (with pCont pointer)
 typedef struct SyncClientRequestBatch {
  uint32_t bytes;
  int32_t  vgId;
-  uint32_t msgType;  // SyncClientRequestBatch msgType
+  uint32_t msgType;  // TDMT_SYNC_CLIENT_REQUEST_BATCH
  uint32_t dataCount;
-  uint32_t dataLen;  // user RpcMsg.contLen
+  uint32_t dataLen;
-  char     data[];   // user RpcMsg.pCont
+  char     data[];  // block2, block3
 } SyncClientRequestBatch;
 SyncClientRequestBatch* syncClientRequestBatchBuild(SRpcMsg* rpcMsgArr, SRaftMeta* raftArr, int32_t arrSize,
                                                    int32_t vgId);
 void                    syncClientRequestBatch2RpcMsg(const SyncClientRequestBatch* pSyncMsg, SRpcMsg* pRpcMsg);
 void                    syncClientRequestBatchDestroy(SyncClientRequestBatch* pMsg);
 void                    syncClientRequestBatchDestroyDeep(SyncClientRequestBatch* pMsg);
 SRaftMeta*              syncClientRequestBatchMetaArr(const SyncClientRequestBatch* pSyncMsg);
 SRpcMsg*                syncClientRequestBatchRpcMsgArr(const SyncClientRequestBatch* pSyncMsg);
 SyncClientRequestBatch* syncClientRequestBatchFromRpcMsg(const SRpcMsg* pRpcMsg);
 cJSON*                  syncClientRequestBatch2Json(const SyncClientRequestBatch* pMsg);
 char*                   syncClientRequestBatch2Str(const SyncClientRequestBatch* pMsg);
 // for debug ----------------------
 void syncClientRequestBatchPrint(const SyncClientRequestBatch* pMsg);
 void syncClientRequestBatchPrint2(char* s, const SyncClientRequestBatch* pMsg);
 void syncClientRequestBatchLog(const SyncClientRequestBatch* pMsg);
 void syncClientRequestBatchLog2(char* s, const SyncClientRequestBatch* pMsg);
 // ---------------------------------------------
 typedef struct SyncClientRequestReply {
@ -318,12 +326,15 @@ void syncRequestVoteReplyLog(const SyncRequestVoteReply* pMsg);
 void syncRequestVoteReplyLog2(char* s, const SyncRequestVoteReply* pMsg);
 // ---------------------------------------------
 // data: entry
 typedef struct SyncAppendEntries {
  uint32_t bytes;
  int32_t  vgId;
  uint32_t msgType;
  SRaftId  srcId;
  SRaftId  destId;
  // private data
  SyncTerm  term;
  SyncIndex prevLogIndex;
@ -354,13 +365,14 @@ void syncAppendEntriesLog2(char* s, const SyncAppendEntries* pMsg);
 // ---------------------------------------------
 // define ahead
 /*
 typedef struct SOffsetAndContLen {
  int32_t offset;
  int32_t contLen;
 } SOffsetAndContLen;
-*/
+
 // data:
 // block1: SOffsetAndContLen Array
 // block2: entry Array
 typedef struct SyncAppendEntriesBatch {
  uint32_t bytes;
@ -377,10 +389,11 @@ typedef struct SyncAppendEntriesBatch {
  SyncTerm  privateTerm;
  int32_t   dataCount;
  uint32_t  dataLen;
-  char      data[];
+  char      data[];  // block1, block2
 } SyncAppendEntriesBatch;
-SyncAppendEntriesBatch* syncAppendEntriesBatchBuild(SRpcMsg* rpcMsgArr, int32_t arrSize, int32_t vgId);
+SyncAppendEntriesBatch* syncAppendEntriesBatchBuild(SSyncRaftEntry** entryPArr, int32_t arrSize, int32_t vgId);
 SOffsetAndContLen*      syncAppendEntriesBatchMetaTableArray(SyncAppendEntriesBatch* pMsg);
 void                    syncAppendEntriesBatchDestroy(SyncAppendEntriesBatch* pMsg);
 void                    syncAppendEntriesBatchSerialize(const SyncAppendEntriesBatch* pMsg, char* buf, uint32_t bufLen);
 void                    syncAppendEntriesBatchDeserialize(const char* buf, uint32_t len, SyncAppendEntriesBatch* pMsg);
@ -391,8 +404,6 @@ void                    syncAppendEntriesBatchFromRpcMsg(const SRpcMsg* pRpcMsg,
 SyncAppendEntriesBatch* syncAppendEntriesBatchFromRpcMsg2(const SRpcMsg* pRpcMsg);
 cJSON*                  syncAppendEntriesBatch2Json(const SyncAppendEntriesBatch* pMsg);
 char*                   syncAppendEntriesBatch2Str(const SyncAppendEntriesBatch* pMsg);
 void syncAppendEntriesBatch2RpcMsgArray(SyncAppendEntriesBatch* pSyncMsg, SRpcMsg* rpcMsgArr, int32_t maxArrSize,
                                        int32_t* pRetArrSize);
 // for debug ----------------------
 void syncAppendEntriesBatchPrint(const SyncAppendEntriesBatch* pMsg);
@ -472,9 +483,10 @@ typedef struct SyncSnapshotSend {
  SRaftId  destId;
  SyncTerm  term;
-  SyncIndex lastIndex;  // lastIndex of snapshot
+  SyncIndex beginIndex;       // snapshot.beginIndex
-  SyncTerm  lastTerm;   // lastTerm of snapshot
+  SyncIndex lastIndex;        // snapshot.lastIndex
-  SyncIndex lastConfigIndex;
+  SyncTerm  lastTerm;         // snapshot.lastTerm
  SyncIndex lastConfigIndex;  // snapshot.lastConfigIndex
  SSyncCfg  lastConfig;
  SyncTerm  privateTerm;
  int32_t   seq;
@ -612,6 +624,9 @@ int32_t syncNodeOnRequestVoteReplySnapshotCb(SSyncNode* ths, SyncRequestVoteRepl
 int32_t syncNodeOnAppendEntriesSnapshotCb(SSyncNode* ths, SyncAppendEntries* pMsg);
 int32_t syncNodeOnAppendEntriesReplySnapshotCb(SSyncNode* ths, SyncAppendEntriesReply* pMsg);
 int32_t syncNodeOnAppendEntriesSnapshot2Cb(SSyncNode* ths, SyncAppendEntriesBatch* pMsg);
 int32_t syncNodeOnAppendEntriesReplySnapshot2Cb(SSyncNode* ths, SyncAppendEntriesReply* pMsg);
 int32_t syncNodeOnSnapshotSendCb(SSyncNode* ths, SyncSnapshotSend* pMsg);
 int32_t syncNodeOnSnapshotRspCb(SSyncNode* ths, SyncSnapshotRsp* pMsg);
@ -628,7 +643,8 @@ typedef int32_t (*FpOnSnapshotSendCb)(SSyncNode* ths, SyncSnapshotSend* pMsg);
 typedef int32_t (*FpOnSnapshotRspCb)(SSyncNode* ths, SyncSnapshotRsp* pMsg);
 // option ----------------------------------
-bool syncNodeSnapshotEnable(SSyncNode* pSyncNode);
+bool          syncNodeSnapshotEnable(SSyncNode* pSyncNode);
 ESyncStrategy syncNodeStrategy(SSyncNode* pSyncNode);
 // ---------------------------------------------
--- a/include/libs/transport/trpc.h
+++ b/include/libs/transport/trpc.h
@ -35,12 +35,13 @@ typedef struct {
  uint32_t clientIp;
  uint16_t clientPort;
  int64_t  applyIndex;
  uint64_t applyTerm;
  char     user[TSDB_USER_LEN];
 } SRpcConnInfo;
 typedef struct SRpcHandleInfo {
  // rpc info
-  void *   handle;         // rpc handle returned to app
+  void    *handle;         // rpc handle returned to app
  int64_t  refId;          // refid, used by server
  int32_t  noResp;         // has response or not(default 0, 0: resp, 1: no resp);
  int32_t  persistHandle;  // persist handle or not
@ -53,7 +54,7 @@ typedef struct SRpcHandleInfo {
  void *node;     // node mgmt handle
  // resp info
-  void *  rsp;
+  void   *rsp;
  int32_t rspLen;
  // conn info
@ -62,7 +63,7 @@ typedef struct SRpcHandleInfo {
 typedef struct SRpcMsg {
  tmsg_t         msgType;
-  void *         pCont;
+  void          *pCont;
  int32_t        contLen;
  int32_t        code;
  SRpcHandleInfo info;
@ -74,7 +75,7 @@ typedef bool (*RpcRfp)(int32_t code, tmsg_t msgType);
 typedef struct SRpcInit {
  char     localFqdn[TSDB_FQDN_LEN];
  uint16_t localPort;     // local port
-  char *   label;         // for debug purpose
+  char    *label;         // for debug purpose
  int32_t  numOfThreads;  // number of threads to handle connections
  int32_t  sessions;      // number of sessions allowed
  int8_t   connType;      // TAOS_CONN_UDP, TAOS_CONN_TCPC, TAOS_CONN_TCPS
@ -99,23 +100,26 @@ typedef struct {
 typedef struct {
  int32_t msgType;
-  void *  val;
+  void   *val;
  int32_t (*clone)(void *src, void **dst);
 } SRpcBrokenlinkVal;
 typedef struct {
-  SHashObj *        args;
+  SHashObj         *args;
  SRpcBrokenlinkVal brokenVal;
  void (*freeFunc)(const void *arg);
 } SRpcCtx;
 int32_t rpcInit();
-void    rpcCleanup();
+
-void *  rpcOpen(const SRpcInit *pRpc);
+void  rpcCleanup();
-void    rpcClose(void *);
+void *rpcOpen(const SRpcInit *pRpc);
-void *  rpcMallocCont(int32_t contLen);
+
-void    rpcFreeCont(void *pCont);
+void  rpcClose(void *);
-void *  rpcReallocCont(void *ptr, int32_t contLen);
+void  rpcCloseImpl(void *);
 void *rpcMallocCont(int32_t contLen);
 void  rpcFreeCont(void *pCont);
 void *rpcReallocCont(void *ptr, int32_t contLen);
 // Because taosd supports multi-process mode
 // These functions should not be used on the server side
--- a/include/libs/wal/wal.h
+++ b/include/libs/wal/wal.h
@ -24,42 +24,14 @@
 extern "C" {
 #endif
-#define wFatal(...)                                              \
+// clang-format off
-  {                                                              \
+#define wFatal(...) { if (wDebugFlag & DEBUG_FATAL) { taosPrintLog("WAL FATAL ", DEBUG_FATAL, 255,        __VA_ARGS__); }}
-    if (wDebugFlag & DEBUG_FATAL) {                              \
+#define wError(...) { if (wDebugFlag & DEBUG_ERROR) { taosPrintLog("WAL ERROR ", DEBUG_ERROR, 255,        __VA_ARGS__); }}
-      taosPrintLog("WAL FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); \
+#define wWarn(...)  { if (wDebugFlag & DEBUG_WARN)  { taosPrintLog("WAL WARN ",  DEBUG_WARN, 255,         __VA_ARGS__); }}
-    }                                                            \
+#define wInfo(...)  { if (wDebugFlag & DEBUG_INFO)  { taosPrintLog("WAL ",       DEBUG_INFO, 255,         __VA_ARGS__); }}
-  }
+#define wDebug(...) { if (wDebugFlag & DEBUG_DEBUG) { taosPrintLog("WAL ",       DEBUG_DEBUG, wDebugFlag, __VA_ARGS__); }}
-#define wError(...)                                              \
+#define wTrace(...) { if (wDebugFlag & DEBUG_TRACE) { taosPrintLog("WAL ",       DEBUG_TRACE, wDebugFlag, __VA_ARGS__); }}
-  {                                                              \
+// clang-format on
    if (wDebugFlag & DEBUG_ERROR) {                              \
      taosPrintLog("WAL ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); \
    }                                                            \
  }
 #define wWarn(...)                                             \
  {                                                            \
    if (wDebugFlag & DEBUG_WARN) {                             \
      taosPrintLog("WAL WARN ", DEBUG_WARN, 255, __VA_ARGS__); \
    }                                                          \
  }
 #define wInfo(...)                                        \
  {                                                       \
    if (wDebugFlag & DEBUG_INFO) {                        \
      taosPrintLog("WAL ", DEBUG_INFO, 255, __VA_ARGS__); \
    }                                                     \
  }
 #define wDebug(...)                                               \
  {                                                               \
    if (wDebugFlag & DEBUG_DEBUG) {                               \
      taosPrintLog("WAL ", DEBUG_DEBUG, wDebugFlag, __VA_ARGS__); \
    }                                                             \
  }
 #define wTrace(...)                                               \
  {                                                               \
    if (wDebugFlag & DEBUG_TRACE) {                               \
      taosPrintLog("WAL ", DEBUG_TRACE, wDebugFlag, __VA_ARGS__); \
    }                                                             \
  }
 #define WAL_PROTO_VER    0
 #define WAL_NOSUFFIX_LEN 20
@ -73,7 +45,6 @@ extern "C" {
 #define WAL_MAGIC        0xFAFBFCFDULL
 typedef enum {
  TAOS_WAL_NOLOG = 0,
  TAOS_WAL_WRITE = 1,
  TAOS_WAL_FSYNC = 2,
 } EWalType;
@ -88,7 +59,7 @@ typedef struct {
  EWalType level;  // wal level
 } SWalCfg;
-typedef struct SWalVer {
+typedef struct {
  int64_t firstVer;
  int64_t verInSnapshotting;
  int64_t snapshotVer;
@ -102,7 +73,7 @@ typedef struct {
  int8_t   isWeek;
  uint64_t seqNum;
  uint64_t term;
-} SSyncLogMeta;
+} SWalSyncInfo;
 typedef struct {
  int8_t  protoVer;
@ -112,7 +83,7 @@ typedef struct {
  int64_t ingestTs;  // not implemented
  // sync meta
-  SSyncLogMeta syncMeta;
+  SWalSyncInfo syncMeta;
  char body[];
 } SWalCont;
@ -149,17 +120,24 @@ typedef struct SWal {
  SWalCkHead writeHead;
 } SWal;  // WAL HANDLE
-typedef struct SWalReadHandle {
+typedef struct {
-  SWal         *pWal;
+  int8_t scanUncommited;
-  TdFilePtr     pReadLogTFile;
+  int8_t scanMeta;
-  TdFilePtr     pReadIdxTFile;
+  int8_t enableRef;
-  int64_t       curFileFirstVer;
+} SWalFilterCond;
-  int64_t       curVersion;
+
-  int64_t       capacity;
+typedef struct {
-  int64_t       status;  // if cursor valid
+  SWal          *pWal;
-  TdThreadMutex mutex;
+  TdFilePtr      pLogFile;
-  SWalCkHead   *pHead;
+  TdFilePtr      pIdxFile;
-} SWalReadHandle;
+  int64_t        curFileFirstVer;
  int64_t        curVersion;
  int64_t        capacity;
  int8_t         curInvalid;
  TdThreadMutex  mutex;
  SWalFilterCond cond;
  SWalCkHead    *pHead;
 } SWalReader;
 // module initialization
 int32_t walInit();
@ -170,15 +148,25 @@ SWal   *walOpen(const char *path, SWalCfg *pCfg);
 int32_t walAlter(SWal *, SWalCfg *pCfg);
 void    walClose(SWal *);
-// write
+// write interfaces
-int32_t walWriteWithSyncInfo(SWal *, int64_t index, tmsg_t msgType, SSyncLogMeta syncMeta, const void *body,
+
-                             int32_t bodyLen);
+// By assigning index by the caller, wal gurantees linearizability
 int32_t walWrite(SWal *, int64_t index, tmsg_t msgType, const void *body, int32_t bodyLen);
-void    walFsync(SWal *, bool force);
+int32_t walWriteWithSyncInfo(SWal *, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body,
                             int32_t bodyLen);
 // This interface assign version automatically and return to caller.
 // When using this interface with concurrent writes,
 // wal will write all logs atomically,
 // but not sure which one will be actually write first,
 // and then the unique index of successful writen is returned.
 // -1 will be returned for failed writes
 int64_t walAppendLog(SWal *, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body, int32_t bodyLen);
 void walFsync(SWal *, bool force);
 // apis for lifecycle management
 int32_t walCommit(SWal *, int64_t ver);
 // truncate after
 int32_t walRollback(SWal *, int64_t ver);
 // notify that previous logs can be pruned safely
 int32_t walBeginSnapshot(SWal *, int64_t ver);
@ -187,15 +175,17 @@ int32_t walRestoreFromSnapshot(SWal *, int64_t ver);
 // int32_t  walDataCorrupted(SWal*);
 // read
-SWalReadHandle *walOpenReadHandle(SWal *);
+SWalReader *walOpenReader(SWal *, SWalFilterCond *pCond);
-void            walCloseReadHandle(SWalReadHandle *);
+void        walCloseReader(SWalReader *pRead);
-int32_t         walReadWithHandle(SWalReadHandle *pRead, int64_t ver);
+int32_t     walReadVer(SWalReader *pRead, int64_t ver);
 int32_t     walReadSeekVer(SWalReader *pRead, int64_t ver);
 int32_t     walNextValidMsg(SWalReader *pRead);
 // only for tq usage
-void    walSetReaderCapacity(SWalReadHandle *pRead, int32_t capacity);
+void    walSetReaderCapacity(SWalReader *pRead, int32_t capacity);
-int32_t walFetchHead(SWalReadHandle *pRead, int64_t ver, SWalCkHead *pHead);
+int32_t walFetchHead(SWalReader *pRead, int64_t ver, SWalCkHead *pHead);
-int32_t walFetchBody(SWalReadHandle *pRead, SWalCkHead **ppHead);
+int32_t walFetchBody(SWalReader *pRead, SWalCkHead **ppHead);
-int32_t walSkipFetchBody(SWalReadHandle *pRead, const SWalCkHead *pHead);
+int32_t walSkipFetchBody(SWalReader *pRead, const SWalCkHead *pHead);
 typedef struct {
  int64_t refId;
@ -207,10 +197,11 @@ void     walCloseRef(SWalRef *);
 int32_t  walRefVer(SWalRef *, int64_t ver);
 int32_t  walUnrefVer(SWal *);
 // help function for raft
 bool walLogExist(SWal *, int64_t ver);
 bool walIsEmpty(SWal *);
 // lifecycle check
 bool    walIsEmpty(SWal *);
 int64_t walGetFirstVer(SWal *);
 int64_t walGetSnapshotVer(SWal *);
 int64_t walGetLastVer(SWal *);
--- a/include/os/os.h
+++ b/include/os/os.h
@ -41,7 +41,6 @@ extern "C" {
 #include <sys/types.h>
 #include <termios.h>
 #include <sys/statvfs.h>
 #include <sys/prctl.h>
 #include <sys/shm.h>
 #include <sys/wait.h>
--- a/include/os/osAtomic.h
+++ b/include/os/osAtomic.h
@ -63,7 +63,7 @@ int8_t  atomic_add_fetch_8(int8_t volatile *ptr, int8_t val);
 int16_t atomic_add_fetch_16(int16_t volatile *ptr, int16_t val);
 int32_t atomic_add_fetch_32(int32_t volatile *ptr, int32_t val);
 int64_t atomic_add_fetch_64(int64_t volatile *ptr, int64_t val);
-void   *atomic_add_fetch_ptr(void *ptr, void *val);
+void   *atomic_add_fetch_ptr(void *ptr, int64_t val);
 int8_t  atomic_fetch_add_8(int8_t volatile *ptr, int8_t val);
 int16_t atomic_fetch_add_16(int16_t volatile *ptr, int16_t val);
 int32_t atomic_fetch_add_32(int32_t volatile *ptr, int32_t val);
@ -73,7 +73,7 @@ int8_t  atomic_sub_fetch_8(int8_t volatile *ptr, int8_t val);
 int16_t atomic_sub_fetch_16(int16_t volatile *ptr, int16_t val);
 int32_t atomic_sub_fetch_32(int32_t volatile *ptr, int32_t val);
 int64_t atomic_sub_fetch_64(int64_t volatile *ptr, int64_t val);
-void   *atomic_sub_fetch_ptr(void *ptr, void *val);
+void   *atomic_sub_fetch_ptr(void *ptr, int64_t val);
 int8_t  atomic_fetch_sub_8(int8_t volatile *ptr, int8_t val);
 int16_t atomic_fetch_sub_16(int16_t volatile *ptr, int16_t val);
 int32_t atomic_fetch_sub_32(int32_t volatile *ptr, int32_t val);
--- a/include/os/osMath.h
+++ b/include/os/osMath.h
@ -20,6 +20,12 @@
 extern "C" {
 #endif
 // If the error is in a third-party library, place this header file under the third-party library header file.
 // When you want to use this feature, you should find or add the same function in the following sectio
 #ifndef ALLOW_FORBID_FUNC
 #define qsort  QSORT_FUNC_TAOS_FORBID
 #endif
 #define TPOW2(x) ((x) * (x))
 #define TABS(x) ((x) > 0 ? (x) : -(x))
--- a/include/os/osMemory.h
+++ b/include/os/osMemory.h
@ -32,7 +32,7 @@ extern "C" {
 void *taosMemoryMalloc(int32_t size);
 void *taosMemoryCalloc(int32_t num, int32_t size);
 void *taosMemoryRealloc(void *ptr, int32_t size);
-void *taosMemoryStrDup(void *ptr);
+void *taosMemoryStrDup(const char *ptr);
 void taosMemoryFree(void *ptr);
 int32_t taosMemorySize(void *ptr);
 void taosPrintBackTrace();
--- a/include/os/osSemaphore.h
+++ b/include/os/osSemaphore.h
@ -24,7 +24,9 @@ extern "C" {
 #if defined(_TD_DARWIN_64)
-typedef struct tsem_s *tsem_t;
+// typedef struct tsem_s *tsem_t;
 typedef struct bosal_sem_t *tsem_t;
 int tsem_init(tsem_t *sem, int pshared, unsigned int value);
 int tsem_wait(tsem_t *sem);
@ -51,11 +53,11 @@ int tsem_timewait(tsem_t *sim, int64_t nanosecs);
 //  #define taosThreadRwlockRdlock(lock) taosThreadMutexLock(lock)
 //  #define taosThreadRwlockUnlock(lock) taosThreadMutexUnlock(lock)
-#define TdThreadSpinlock               TdThreadMutex
+// #define TdThreadSpinlock               TdThreadMutex
-#define taosThreadSpinInit(lock, NULL) taosThreadMutexInit(lock, NULL)
+// #define taosThreadSpinInit(lock, NULL) taosThreadMutexInit(lock, NULL)
-#define taosThreadSpinDestroy(lock)    taosThreadMutexDestroy(lock)
+// #define taosThreadSpinDestroy(lock)    taosThreadMutexDestroy(lock)
-#define taosThreadSpinLock(lock)       taosThreadMutexLock(lock)
+// #define taosThreadSpinLock(lock)       taosThreadMutexLock(lock)
-#define taosThreadSpinUnlock(lock)     taosThreadMutexUnlock(lock)
+// #define taosThreadSpinUnlock(lock)     taosThreadMutexUnlock(lock)
 #endif
 bool    taosCheckPthreadValid(TdThread thread);
--- a/include/os/osSocket.h
+++ b/include/os/osSocket.h
@ -64,7 +64,6 @@
 #include <osEok.h>
 #else
 #include <netinet/in.h>
 #include <sys/epoll.h>
 #endif
 #endif
@ -77,15 +76,12 @@ typedef int socklen_t;
 #define TAOS_EPOLL_WAIT_TIME 100
 typedef SOCKET eventfd_t;
 #define eventfd(a, b)      -1
 #define EpollClose(pollFd) epoll_close(pollFd)
 #ifndef EPOLLWAKEUP
 #define EPOLLWAKEUP (1u << 29)
 #endif
 #elif defined(_TD_DARWIN_64)
 #define TAOS_EPOLL_WAIT_TIME 500
 typedef int32_t SOCKET;
 typedef SOCKET  EpollFd;
 #define EpollClose(pollFd)   epoll_close(pollFd)
 #else
 #define TAOS_EPOLL_WAIT_TIME 500
 typedef int32_t SOCKET;
@ -122,14 +118,6 @@ typedef SOCKET  EpollFd;
 typedef int32_t  SocketFd;
 typedef SocketFd EpollFd;
 typedef struct TdSocket {
 #if SOCKET_WITH_LOCK
  TdThreadRwlock rwlock;
 #endif
  int      refId;
  SocketFd fd;
 } * TdSocketPtr, TdSocket;
 typedef struct TdSocketServer *TdSocketServerPtr;
 typedef struct TdSocket *      TdSocketPtr;
 typedef struct TdEpoll *       TdEpollPtr;
@ -181,11 +169,6 @@ void        taosSetMaskSIGPIPE();
 uint32_t    taosInetAddr(const char *ipAddr);
 const char *taosInetNtoa(struct in_addr ipInt);
 TdEpollPtr taosCreateEpoll(int32_t size);
 int32_t    taosCtlEpoll(TdEpollPtr pEpoll, int32_t epollOperate, TdSocketPtr pSocket, struct epoll_event *event);
 int32_t    taosWaitEpoll(TdEpollPtr pEpoll, struct epoll_event *event, int32_t maxEvents, int32_t timeout);
 int32_t    taosCloseEpoll(TdEpollPtr *ppEpoll);
 #ifdef __cplusplus
 }
 #endif
--- a/include/os/osString.h
+++ b/include/os/osString.h
@ -67,7 +67,7 @@ bool    taosMbsToUcs4(const char *mbs, size_t mbs_len, TdUcs4 *ucs4, int32_t ucs
 int32_t tasoUcs4Compare(TdUcs4 *f1_ucs4, TdUcs4 *f2_ucs4, int32_t bytes);
 TdUcs4* tasoUcs4Copy(TdUcs4 *target_ucs4, TdUcs4 *source_ucs4, int32_t len_ucs4);
 bool    taosValidateEncodec(const char *encodec);
-int32_t taosHexEncode(const char *src, char *dst, int32_t len);
+int32_t taosHexEncode(const unsigned char *src, char *dst, int32_t len);
 int32_t taosHexDecode(const char *src, char *dst, int32_t len);
 int32_t taosWcharWidth(TdWchar wchar);
--- a/include/os/osThread.h
+++ b/include/os/osThread.h
@ -188,27 +188,27 @@ int32_t taosThreadJoin(TdThread thread, void **valuePtr);
 int32_t taosThreadKeyCreate(TdThreadKey * key, void(*destructor)(void *));
 int32_t taosThreadKeyDelete(TdThreadKey key);
 int32_t taosThreadKill(TdThread thread, int32_t sig);
-int32_t taosThreadMutexConsistent(TdThreadMutex* mutex);
+// int32_t taosThreadMutexConsistent(TdThreadMutex* mutex);
 int32_t taosThreadMutexDestroy(TdThreadMutex * mutex);
 int32_t taosThreadMutexInit(TdThreadMutex * mutex, const TdThreadMutexAttr * attr);
 int32_t taosThreadMutexLock(TdThreadMutex * mutex);
-int32_t taosThreadMutexTimedLock(TdThreadMutex * mutex, const struct timespec *abstime);
+// int32_t taosThreadMutexTimedLock(TdThreadMutex * mutex, const struct timespec *abstime);
 int32_t taosThreadMutexTryLock(TdThreadMutex * mutex);
 int32_t taosThreadMutexUnlock(TdThreadMutex * mutex);
 int32_t taosThreadMutexAttrDestroy(TdThreadMutexAttr * attr);
 int32_t taosThreadMutexAttrGetPshared(const TdThreadMutexAttr * attr, int32_t *pshared);
-int32_t taosThreadMutexAttrGetRobust(const TdThreadMutexAttr * attr, int32_t * robust);
+// int32_t taosThreadMutexAttrGetRobust(const TdThreadMutexAttr * attr, int32_t * robust);
 int32_t taosThreadMutexAttrGetType(const TdThreadMutexAttr * attr, int32_t *kind);
 int32_t taosThreadMutexAttrInit(TdThreadMutexAttr * attr);
 int32_t taosThreadMutexAttrSetPshared(TdThreadMutexAttr * attr, int32_t pshared);
-int32_t taosThreadMutexAttrSetRobust(TdThreadMutexAttr * attr, int32_t robust);
+// int32_t taosThreadMutexAttrSetRobust(TdThreadMutexAttr * attr, int32_t robust);
 int32_t taosThreadMutexAttrSetType(TdThreadMutexAttr * attr, int32_t kind);
 int32_t taosThreadOnce(TdThreadOnce * onceControl, void(*initRoutine)(void));
 int32_t taosThreadRwlockDestroy(TdThreadRwlock * rwlock);
 int32_t taosThreadRwlockInit(TdThreadRwlock * rwlock, const TdThreadRwlockAttr * attr);
 int32_t taosThreadRwlockRdlock(TdThreadRwlock * rwlock);
-int32_t taosThreadRwlockTimedRdlock(TdThreadRwlock * rwlock, const struct timespec *abstime);
+// int32_t taosThreadRwlockTimedRdlock(TdThreadRwlock * rwlock, const struct timespec *abstime);
-int32_t taosThreadRwlockTimedWrlock(TdThreadRwlock * rwlock, const struct timespec *abstime);
+// int32_t taosThreadRwlockTimedWrlock(TdThreadRwlock * rwlock, const struct timespec *abstime);
 int32_t taosThreadRwlockTryRdlock(TdThreadRwlock * rwlock);
 int32_t taosThreadRwlockTryWrlock(TdThreadRwlock * rwlock);
 int32_t taosThreadRwlockUnlock(TdThreadRwlock * rwlock);
--- a/include/util/tRealloc.h
+++ b/include/util/tRealloc.h
@ -0,0 +1,65 @@
 /*
 * 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 _TD_UTIL_TREALLOC_H_
 #define _TD_UTIL_TREALLOC_H_
 #include "os.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
 static FORCE_INLINE int32_t tRealloc(uint8_t **ppBuf, int64_t size) {
  int32_t  code = 0;
  int64_t  bsize = 0;
  uint8_t *pBuf = NULL;
  if (*ppBuf) {
    pBuf = (*ppBuf) - sizeof(int64_t);
    bsize = *(int64_t *)pBuf;
  }
  if (bsize >= size) goto _exit;
  if (bsize == 0) bsize = 64;
  while (bsize < size) {
    bsize *= 2;
  }
  pBuf = (uint8_t *)taosMemoryRealloc(pBuf, bsize + sizeof(int64_t));
  if (pBuf == NULL) {
    code = TSDB_CODE_OUT_OF_MEMORY;
    goto _exit;
  }
  *(int64_t *)pBuf = bsize;
  *ppBuf = pBuf + sizeof(int64_t);
 _exit:
  return code;
 }
 static FORCE_INLINE void tFree(uint8_t *pBuf) {
  if (pBuf) {
    taosMemoryFree(pBuf - sizeof(int64_t));
  }
 }
 #ifdef __cplusplus
 }
 #endif
 #endif /*_TD_UTIL_TREALLOC_H_*/
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@ -72,6 +72,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_INVALID_TIMESTAMP             TAOS_DEF_ERROR_CODE(0, 0x0030)
 #define TSDB_CODE_MSG_DECODE_ERROR              TAOS_DEF_ERROR_CODE(0, 0x0031)
 #define TSDB_CODE_NO_AVAIL_DISK                 TAOS_DEF_ERROR_CODE(0, 0x0032)
 #define TSDB_CODE_NOT_FOUND                     TAOS_DEF_ERROR_CODE(0, 0x0033)
 #define TSDB_CODE_REF_NO_MEMORY                 TAOS_DEF_ERROR_CODE(0, 0x0040)
 #define TSDB_CODE_REF_FULL                      TAOS_DEF_ERROR_CODE(0, 0x0041)
@ -173,11 +174,12 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_DNODE_NOT_EXIST           TAOS_DEF_ERROR_CODE(0, 0x0341)
 #define TSDB_CODE_MND_TOO_MANY_DNODES           TAOS_DEF_ERROR_CODE(0, 0x0342)
 #define TSDB_CODE_MND_NO_ENOUGH_DNODES          TAOS_DEF_ERROR_CODE(0, 0x0343)
-#define TSDB_CODE_MND_INVALID_CLUSTER_CFG       TAOS_DEF_ERROR_CODE(0, 0x0344)
+#define TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE    TAOS_DEF_ERROR_CODE(0, 0x0344)
-#define TSDB_CODE_MND_INVALID_CLUSTER_ID        TAOS_DEF_ERROR_CODE(0, 0x0345)
+#define TSDB_CODE_MND_INVALID_CLUSTER_CFG       TAOS_DEF_ERROR_CODE(0, 0x0345)
-#define TSDB_CODE_MND_INVALID_DNODE_CFG         TAOS_DEF_ERROR_CODE(0, 0x0346)
+#define TSDB_CODE_MND_INVALID_CLUSTER_ID        TAOS_DEF_ERROR_CODE(0, 0x0346)
-#define TSDB_CODE_MND_INVALID_DNODE_EP          TAOS_DEF_ERROR_CODE(0, 0x0347)
+#define TSDB_CODE_MND_INVALID_DNODE_CFG         TAOS_DEF_ERROR_CODE(0, 0x0347)
-#define TSDB_CODE_MND_INVALID_DNODE_ID          TAOS_DEF_ERROR_CODE(0, 0x0348)
+#define TSDB_CODE_MND_INVALID_DNODE_EP          TAOS_DEF_ERROR_CODE(0, 0x0348)
 #define TSDB_CODE_MND_INVALID_DNODE_ID          TAOS_DEF_ERROR_CODE(0, 0x0349)
 // mnode-node
 #define TSDB_CODE_MND_MNODE_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x0350)
@ -245,9 +247,11 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_COLUMN_NOT_EXIST          TAOS_DEF_ERROR_CODE(0, 0x03AE)
 #define TSDB_CODE_MND_FIELD_CONFLICT_WITH_TOPIC TAOS_DEF_ERROR_CODE(0, 0x03AF)
 #define TSDB_CODE_MND_SINGLE_STB_MODE_DB        TAOS_DEF_ERROR_CODE(0, 0x03B0)
 #define TSDB_CODE_MND_INVALID_SCHEMA_VER        TAOS_DEF_ERROR_CODE(0, 0x03B1)
 #define TSDB_CODE_MND_STABLE_UID_NOT_MATCH      TAOS_DEF_ERROR_CODE(0, 0x03B2)
 // mnode-infoSchema
-#define TSDB_CODE_MND_INVALID_SYS_TABLENAME         TAOS_DEF_ERROR_CODE(0, 0x03BA)
+#define TSDB_CODE_MND_INVALID_SYS_TABLENAME     TAOS_DEF_ERROR_CODE(0, 0x03BA)
 // mnode-func
 #define TSDB_CODE_MND_FUNC_ALREADY_EXIST        TAOS_DEF_ERROR_CODE(0, 0x03C0)
@ -388,10 +392,10 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_QRY_TASK_MSG_ERROR            TAOS_DEF_ERROR_CODE(0, 0x0719)
 #define TSDB_CODE_QRY_JOB_FREED                 TAOS_DEF_ERROR_CODE(0, 0x071A)
 #define TSDB_CODE_QRY_TASK_STATUS_ERROR         TAOS_DEF_ERROR_CODE(0, 0x071B)
 //json
 #define TSDB_CODE_QRY_JSON_IN_ERROR             TAOS_DEF_ERROR_CODE(0, 0x071C)
 #define TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR    TAOS_DEF_ERROR_CODE(0, 0x071D)
 #define TSDB_CODE_QRY_JSON_IN_GROUP_ERROR       TAOS_DEF_ERROR_CODE(0, 0x071E)
 #define TSDB_CODE_QRY_JOB_NOT_EXIST             TAOS_DEF_ERROR_CODE(0, 0x071F)
 // grant
 #define TSDB_CODE_GRANT_EXPIRED                 TAOS_DEF_ERROR_CODE(0, 0x0800)
@ -428,6 +432,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_SYN_PROPOSE_NOT_READY         TAOS_DEF_ERROR_CODE(0, 0x0911)
 #define TSDB_CODE_SYN_STANDBY_NOT_READY         TAOS_DEF_ERROR_CODE(0, 0x0912)
 #define TSDB_CODE_SYN_BATCH_ERROR               TAOS_DEF_ERROR_CODE(0, 0x0913)
 #define TSDB_CODE_SYN_TIMEOUT                   TAOS_DEF_ERROR_CODE(0, 0x0914)
 #define TSDB_CODE_SYN_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x09FF)
 // tq
@ -577,6 +582,10 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_PAR_GROUP_BY_NOT_ALLOWED_FUNC TAOS_DEF_ERROR_CODE(0, 0x265B)
 #define TSDB_CODE_PAR_INVALID_TABLE_OPTION      TAOS_DEF_ERROR_CODE(0, 0x265C)
 #define TSDB_CODE_PAR_INVALID_INTERP_CLAUSE     TAOS_DEF_ERROR_CODE(0, 0x265D)
 #define TSDB_CODE_PAR_NO_VALID_FUNC_IN_WIN      TAOS_DEF_ERROR_CODE(0, 0x265E)
 #define TSDB_CODE_PAR_ONLY_SUPPORT_SINGLE_TABLE TAOS_DEF_ERROR_CODE(0, 0x265F)
 #define TSDB_CODE_PAR_INVALID_SMA_INDEX         TAOS_DEF_ERROR_CODE(0, 0x2660)
 #define TSDB_CODE_PAR_INVALID_SELECTED_EXPR     TAOS_DEF_ERROR_CODE(0, 0x2661)
 //planner
 #define TSDB_CODE_PLAN_INTERNAL_ERROR           TAOS_DEF_ERROR_CODE(0, 0x2700)
@ -622,9 +631,12 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_RSMA_INVALID_ENV               TAOS_DEF_ERROR_CODE(0, 0x3150)
 #define TSDB_CODE_RSMA_INVALID_STAT              TAOS_DEF_ERROR_CODE(0, 0x3151)
 #define TSDB_CODE_RSMA_QTASKINFO_CREATE          TAOS_DEF_ERROR_CODE(0, 0x3152)
 #define TSDB_CODE_RSMA_FILE_CORRUPTED            TAOS_DEF_ERROR_CODE(0, 0x3153)
 //index
 #define TSDB_CODE_INDEX_REBUILDING               TAOS_DEF_ERROR_CODE(0, 0x3200)
 #define TSDB_CODE_INDEX_INVALID_FILE             TAOS_DEF_ERROR_CODE(0, 0x3201)
 //tmq
 #define TSDB_CODE_TMQ_INVALID_MSG                TAOS_DEF_ERROR_CODE(0, 0x4000)
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@ -287,7 +287,7 @@ typedef enum ELogicConditionType {
 #define TSDB_MULTI_TABLEMETA_MAX_NUM 100000  // maximum batch size allowed to load table meta
 #define TSDB_MIN_VNODES_PER_DB          1
-#define TSDB_MAX_VNODES_PER_DB          4096
+#define TSDB_MAX_VNODES_PER_DB          1024
 #define TSDB_DEFAULT_VN_PER_DB          2
 #define TSDB_MIN_BUFFER_PER_VNODE       3      // unit MB
 #define TSDB_MAX_BUFFER_PER_VNODE       16384  // unit MB
@ -331,9 +331,12 @@ typedef enum ELogicConditionType {
 #define TSDB_DB_STRICT_OFF              0
 #define TSDB_DB_STRICT_ON               1
 #define TSDB_DEFAULT_DB_STRICT          0
-#define TSDB_MIN_DB_CACHE_LAST_ROW      0
+#define TSDB_MIN_DB_CACHE_LAST          0
-#define TSDB_MAX_DB_CACHE_LAST_ROW      3
+#define TSDB_MAX_DB_CACHE_LAST          3
-#define TSDB_DEFAULT_CACHE_LAST_ROW     0
+#define TSDB_DEFAULT_CACHE_LAST         0
 #define TSDB_MIN_DB_CACHE_LAST_SIZE     1  // MB
 #define TSDB_MAX_DB_CACHE_LAST_SIZE     65536
 #define TSDB_DEFAULT_CACHE_LAST_SIZE    1
 #define TSDB_DB_STREAM_MODE_OFF         0
 #define TSDB_DB_STREAM_MODE_ON          1
 #define TSDB_DEFAULT_DB_STREAM_MODE     0
--- a/include/util/tencode.h
+++ b/include/util/tencode.h
@ -477,22 +477,6 @@ static FORCE_INLINE void* tDecoderMalloc(SDecoder* pCoder, int32_t size) {
    return n;                          \
  } while (0)
 #define tGetV(p, v)                              \
  do {                                           \
    int32_t n = 0;                               \
    if (v) *v = 0;                               \
    for (;;) {                                   \
      if (p[n] <= 0x7f) {                        \
        if (v) (*v) |= (p[n] << (7 * n));        \
        n++;                                     \
        break;                                   \
      }                                          \
      if (v) (*v) |= ((p[n] & 0x7f) << (7 * n)); \
      n++;                                       \
    }                                            \
    return n;                                    \
  } while (0)
 // PUT
 static FORCE_INLINE int32_t tPutU8(uint8_t* p, uint8_t v) {
  if (p) ((uint8_t*)p)[0] = v;
@ -607,7 +591,22 @@ static FORCE_INLINE int32_t tGetI64(uint8_t* p, int64_t* v) {
  return sizeof(int64_t);
 }
-static FORCE_INLINE int32_t tGetU16v(uint8_t* p, uint16_t* v) { tGetV(p, v); }
+static FORCE_INLINE int32_t tGetU16v(uint8_t* p, uint16_t* v) {
  int32_t n = 0;
  if (v) *v = 0;
  for (;;) {
    if (p[n] <= 0x7f) {
      if (v) (*v) |= (((uint16_t)p[n]) << (7 * n));
      n++;
      break;
    }
    if (v) (*v) |= (((uint16_t)(p[n] & 0x7f)) << (7 * n));
    n++;
  }
  return n;
 }
 static FORCE_INLINE int32_t tGetI16v(uint8_t* p, int16_t* v) {
  int32_t  n;
@ -619,7 +618,22 @@ static FORCE_INLINE int32_t tGetI16v(uint8_t* p, int16_t* v) {
  return n;
 }
-static FORCE_INLINE int32_t tGetU32v(uint8_t* p, uint32_t* v) { tGetV(p, v); }
+static FORCE_INLINE int32_t tGetU32v(uint8_t* p, uint32_t* v) {
  int32_t n = 0;
  if (v) *v = 0;
  for (;;) {
    if (p[n] <= 0x7f) {
      if (v) (*v) |= (((uint32_t)p[n]) << (7 * n));
      n++;
      break;
    }
    if (v) (*v) |= (((uint32_t)(p[n] & 0x7f)) << (7 * n));
    n++;
  }
  return n;
 }
 static FORCE_INLINE int32_t tGetI32v(uint8_t* p, int32_t* v) {
  int32_t  n;
@ -631,7 +645,22 @@ static FORCE_INLINE int32_t tGetI32v(uint8_t* p, int32_t* v) {
  return n;
 }
-static FORCE_INLINE int32_t tGetU64v(uint8_t* p, uint64_t* v) { tGetV(p, v); }
+static FORCE_INLINE int32_t tGetU64v(uint8_t* p, uint64_t* v) {
  int32_t n = 0;
  if (v) *v = 0;
  for (;;) {
    if (p[n] <= 0x7f) {
      if (v) (*v) |= (((uint64_t)p[n]) << (7 * n));
      n++;
      break;
    }
    if (v) (*v) |= (((uint64_t)(p[n] & 0x7f)) << (7 * n));
    n++;
  }
  return n;
 }
 static FORCE_INLINE int32_t tGetI64v(uint8_t* p, int64_t* v) {
  int32_t  n;
--- a/include/util/thash.h
+++ b/include/util/thash.h
@ -188,7 +188,7 @@ void *taosHashGetKey(void *data, size_t* keyLen);
 void *taosHashAcquire(SHashObj *pHashObj, const void *key, size_t keyLen);
 /**
- * release the prevous acquired obj
+ * release the previous acquired obj
 *
 * @param pHashObj
 * @param data
--- a/include/util/tlockfree.h
+++ b/include/util/tlockfree.h
@ -71,11 +71,11 @@ typedef void (*_ref_fn_t)(const void *pObj);
 // single writer multiple reader lock
 typedef volatile int32_t SRWLatch;
-void taosInitRWLatch(SRWLatch *pLatch);
+void    taosInitRWLatch(SRWLatch *pLatch);
-void taosWLockLatch(SRWLatch *pLatch);
+void    taosWLockLatch(SRWLatch *pLatch);
-void taosWUnLockLatch(SRWLatch *pLatch);
+void    taosWUnLockLatch(SRWLatch *pLatch);
-void taosRLockLatch(SRWLatch *pLatch);
+void    taosRLockLatch(SRWLatch *pLatch);
-void taosRUnLockLatch(SRWLatch *pLatch);
+void    taosRUnLockLatch(SRWLatch *pLatch);
 int32_t taosWTryLockLatch(SRWLatch *pLatch);
 // copy on read
--- a/include/util/tlog.h
+++ b/include/util/tlog.h
@ -60,7 +60,7 @@ extern int32_t tsdbDebugFlag;
 extern int32_t tqDebugFlag;
 extern int32_t fsDebugFlag;
 extern int32_t metaDebugFlag;
-extern int32_t fnDebugFlag;
+extern int32_t udfDebugFlag;
 extern int32_t smaDebugFlag;
 extern int32_t idxDebugFlag;
@ -94,7 +94,7 @@ void taosPrintLongString(const char *flags, ELogLevel level, int32_t dflag, cons
 #define pError(...) { taosPrintLog("APP ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }
 #define pPrint(...) { taosPrintLog("APP ", DEBUG_INFO, 255, __VA_ARGS__); }
 // clang-format on
-
+//#define BUF_PAGE_DEBUG
 #ifdef __cplusplus
 }
 #endif
--- a/include/util/tmallocator.h
+++ b/include/util/tmallocator.h
@ -1,55 +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 _TD_UTIL_MALLOCATOR_H_
 #define _TD_UTIL_MALLOCATOR_H_
 #include "os.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
 // Memory allocator
 #define TD_MEM_ALCT(TYPE)                           \
  struct {                                          \
    void *(*malloc_)(struct TYPE *, uint64_t size); \
    void (*free_)(struct TYPE *, void *ptr);        \
  }
 #define TD_MA_MALLOC_FUNC(TMA) (TMA)->malloc_
 #define TD_MA_FREE_FUNC(TMA)   (TMA)->free_
 #define TD_MA_MALLOC(TMA, SIZE) (*((TMA)->malloc_))(TMA, (SIZE))
 #define TD_MA_FREE(TMA, PTR)    (*((TMA)->free_))(TMA, (PTR))
 typedef struct SMemAllocator {
  void *impl;
  TD_MEM_ALCT(SMemAllocator);
 } SMemAllocator;
 #define tMalloc(pMA, SIZE) TD_MA_MALLOC(PMA, SIZE)
 #define tFree(pMA, PTR)    TD_MA_FREE(PMA, PTR)
 typedef struct SMemAllocatorFactory {
  void *impl;
  SMemAllocator *(*create)(struct SMemAllocatorFactory *);
  void (*destroy)(struct SMemAllocatorFactory *, SMemAllocator *);
 } SMemAllocatorFactory;
 #ifdef __cplusplus
 }
 #endif
 #endif /*_TD_UTIL_MALLOCATOR_H_*/
--- a/include/util/tqueue.h
+++ b/include/util/tqueue.h
@ -44,6 +44,8 @@ typedef struct STaosQset  STaosQset;
 typedef struct STaosQall  STaosQall;
 typedef struct {
  void   *ahandle;
  void   *fp;
  void   *queue;
  int32_t workerId;
  int32_t threadNum;
  int64_t timestamp;
@ -65,6 +67,7 @@ void        taosFreeQitem(void *pItem);
 void        taosWriteQitem(STaosQueue *queue, void *pItem);
 int32_t     taosReadQitem(STaosQueue *queue, void **ppItem);
 bool        taosQueueEmpty(STaosQueue *queue);
 void        taosUpdateItemSize(STaosQueue *queue, int32_t items);
 int32_t     taosQueueItemSize(STaosQueue *queue);
 int64_t     taosQueueMemorySize(STaosQueue *queue);
@ -81,8 +84,8 @@ int32_t    taosAddIntoQset(STaosQset *qset, STaosQueue *queue, void *ahandle);
 void       taosRemoveFromQset(STaosQset *qset, STaosQueue *queue);
 int32_t    taosGetQueueNumber(STaosQset *qset);
-int32_t taosReadQitemFromQset(STaosQset *qset, void **ppItem, int64_t *ts, void **ahandle, FItem *itemFp);
+int32_t taosReadQitemFromQset(STaosQset *qset, void **ppItem, SQueueInfo *qinfo);
-int32_t taosReadAllQitemsFromQset(STaosQset *qset, STaosQall *qall, void **ahandle, FItems *itemsFp);
+int32_t taosReadAllQitemsFromQset(STaosQset *qset, STaosQall *qall, SQueueInfo *qinfo);
 void    taosResetQsetThread(STaosQset *qset, void *pItem);
 extern int64_t tsRpcQueueMemoryAllowed;
--- a/include/util/tutil.h
+++ b/include/util/tutil.h
@ -45,6 +45,7 @@ void     taosIp2String(uint32_t ip, char *str);
 void     taosIpPort2String(uint32_t ip, uint16_t port, char *str);
 void *tmemmem(const char *haystack, int hlen, const char *needle, int nlen);
 char *strDupUnquo(const char *src);
 static FORCE_INLINE void taosEncryptPass(uint8_t *inBuf, size_t inLen, char *target) {
  T_MD5_CTX context;
--- a/include/util/types.h
+++ b/include/util/types.h
@ -83,6 +83,7 @@ typedef uint16_t VarDataLenT;  // maxVarDataLen: 32767
 #define varDataLen(v) ((VarDataLenT *)(v))[0]
 #define varDataVal(v) ((char *)(v) + VARSTR_HEADER_SIZE)
 #define varDataTLen(v) (sizeof(VarDataLenT) + varDataLen(v))
 #define NCHAR_WIDTH_TO_BYTES(n)  ((n) * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE)
--- a/packaging/deb/DEBIAN/preinst
+++ b/packaging/deb/DEBIAN/preinst
@ -37,4 +37,5 @@ if [ -f "${install_main_dir}/taosadapter.service" ]; then
 fi
 # there can not libtaos.so*, otherwise ln -s  error
-${csudo}rm -f ${install_main_dir}/driver/libtaos*   || :
+${csudo}rm -f ${install_main_dir}/driver/libtaos.*   || :
 ${csudo}rm -f ${install_main_dir}/driver/libtaosws.*   || :
--- a/packaging/deb/DEBIAN/prerm
+++ b/packaging/deb/DEBIAN/prerm
@ -29,8 +29,12 @@ else
    ${csudo}rm -f ${bin_link_dir}/taosdemo   || :
    ${csudo}rm -f ${cfg_link_dir}/*          || :
    ${csudo}rm -f ${inc_link_dir}/taos.h     || :
    ${csudo}rm -f ${inc_link_dir}/taosdef.h     || :
    ${csudo}rm -f ${inc_link_dir}/taoserror.h     || :
    ${csudo}rm -f ${inc_link_dir}/taosudf.h     || :
    ${csudo}rm -f ${inc_link_dir}/taosws.h     || :
    ${csudo}rm -f ${lib_link_dir}/libtaos.*  || :
    ${csudo}rm -f ${lib_link_dir}/libtaosws.*  || :
    ${csudo}rm -f ${log_link_dir}            || :
    ${csudo}rm -f ${data_link_dir}           || :
--- a/packaging/deb/makedeb.sh
+++ b/packaging/deb/makedeb.sh
@ -30,6 +30,7 @@ mkdir -p ${pkg_dir}
 cd ${pkg_dir}
 libfile="libtaos.so.${tdengine_ver}"
 wslibfile="libtaosws.so"
 # create install dir
 install_home_path="/usr/local/taos"
@ -67,10 +68,12 @@ fi
 cp ${compile_dir}/build/bin/taos                    ${pkg_dir}${install_home_path}/bin
 cp ${compile_dir}/build/lib/${libfile}              ${pkg_dir}${install_home_path}/driver
 cp ${compile_dir}/build/lib/${wslibfile}            ${pkg_dir}${install_home_path}/driver ||:
 cp ${compile_dir}/../include/client/taos.h          ${pkg_dir}${install_home_path}/include
 cp ${compile_dir}/../include/common/taosdef.h       ${pkg_dir}${install_home_path}/include
 cp ${compile_dir}/../include/util/taoserror.h       ${pkg_dir}${install_home_path}/include
 cp ${compile_dir}/../include/libs/function/taosudf.h       ${pkg_dir}${install_home_path}/include
 cp ${compile_dir}/../src/inc/taosws.h               ${pkg_dir}${install_home_path}/include ||:
 cp -r ${top_dir}/examples/*                         ${pkg_dir}${install_home_path}/examples
 #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
--- a/packaging/rpm/tdengine.spec
+++ b/packaging/rpm/tdengine.spec
@ -42,6 +42,7 @@ echo version: %{_version}
 echo buildroot: %{buildroot}
 libfile="libtaos.so.%{_version}"
 wslibfile="libtaosws.so"
 # create install path, and cp file
 mkdir -p %{buildroot}%{homepath}/bin
@ -74,10 +75,12 @@ if [ -f %{_compiledir}/build/bin/taosadapter ]; then
    cp %{_compiledir}/build/bin/taosadapter                    %{buildroot}%{homepath}/bin ||:
 fi
 cp %{_compiledir}/build/lib/${libfile}              %{buildroot}%{homepath}/driver
 cp %{_compiledir}/build/lib/${wslibfile}            %{buildroot}%{homepath}/driver ||:
 cp %{_compiledir}/../include/client/taos.h          %{buildroot}%{homepath}/include
 cp %{_compiledir}/../include/common/taosdef.h       %{buildroot}%{homepath}/include
 cp %{_compiledir}/../include/util/taoserror.h       %{buildroot}%{homepath}/include
 cp %{_compiledir}/../include/libs/function/taosudf.h       %{buildroot}%{homepath}/include
 cp %{_compiledir}/../src/inc/taosws.h               %{buildroot}%{homepath}/include ||:
 #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
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@ -30,6 +30,7 @@ configDir="/etc/taos"
 installDir="/usr/local/taos"
 adapterName="taosadapter"
 benchmarkName="taosBenchmark"
 tmqName="tmq_sim"
 dumpName="taosdump"
 demoName="taosdemo"
@ -205,6 +206,7 @@ function install_bin() {
  [ -x ${install_main_dir}/bin/${adapterName} ] && ${csudo}ln -s ${install_main_dir}/bin/${adapterName} ${bin_link_dir}/${adapterName} || :
  [ -x ${install_main_dir}/bin/${benchmarkName} ] && ${csudo}ln -s ${install_main_dir}/bin/${benchmarkName} ${bin_link_dir}/${demoName} || :
  [ -x ${install_main_dir}/bin/${benchmarkName} ] && ${csudo}ln -s ${install_main_dir}/bin/${benchmarkName} ${bin_link_dir}/${benchmarkName} || :
  [ -x ${install_main_dir}/bin/${tmqName} ] && ${csudo}ln -s ${install_main_dir}/bin/${tmqName} ${bin_link_dir}/${tmqName} || :
  [ -x ${install_main_dir}/bin/${dumpName} ] && ${csudo}ln -s ${install_main_dir}/bin/${dumpName} ${bin_link_dir}/${dumpName} || :
  [ -x ${install_main_dir}/bin/TDinsight.sh ] && ${csudo}ln -s ${install_main_dir}/bin/TDinsight.sh ${bin_link_dir}/TDinsight.sh || :
  [ -x ${install_main_dir}/bin/remove.sh ] && ${csudo}ln -s ${install_main_dir}/bin/remove.sh ${bin_link_dir}/${uninstallScript} || :
@ -227,9 +229,13 @@ function install_lib() {
  ${csudo}ln -s ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.so.1
  ${csudo}ln -s ${lib_link_dir}/libtaos.so.1 ${lib_link_dir}/libtaos.so
  ${csudo}ln -s ${lib_link_dir}/libtaosws.so ${lib_link_dir}/libtaosws.so || :
  if [[ -d ${lib64_link_dir} && ! -e ${lib64_link_dir}/libtaos.so ]]; then
    ${csudo}ln -s ${install_main_dir}/driver/libtaos.* ${lib64_link_dir}/libtaos.so.1 || :
    ${csudo}ln -s ${lib64_link_dir}/libtaos.so.1 ${lib64_link_dir}/libtaos.so || :
    ${csudo}ln -s ${lib64_link_dir}/libtaosws.so ${lib64_link_dir}/libtaosws.so || :
  fi
  ${csudo}ldconfig
@ -313,11 +319,16 @@ function install_jemalloc() {
 function install_header() {
  ${csudo}rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taosdef.h ${inc_link_dir}/taoserror.h ${inc_link_dir}/taosudf.h || :
  ${csudo}rm -f ${inc_link_dir}/taosws.h || :
  ${csudo}cp -f ${script_dir}/inc/* ${install_main_dir}/include && ${csudo}chmod 644 ${install_main_dir}/include/*
  ${csudo}ln -s ${install_main_dir}/include/taos.h ${inc_link_dir}/taos.h
  ${csudo}ln -s ${install_main_dir}/include/taosdef.h ${inc_link_dir}/taosdef.h
  ${csudo}ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
  ${csudo}ln -s ${install_main_dir}/include/taosudf.h ${inc_link_dir}/taosudf.h  
  [ -f ${install_main_dir}/include/taosws.h ] && ${csudo}ln -s ${install_main_dir}/include/taosws.h ${inc_link_dir}/taosws.h || :
 }
 function add_newHostname_to_hosts() {
--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@ -294,21 +294,34 @@ function install_avro() {
 function install_lib() {
  # Remove links
  ${csudo}rm -f ${lib_link_dir}/libtaos.* || :
  ${csudo}rm -f ${lib_link_dir}/libtaosws.* || :
  if [ "$osType" != "Darwin" ]; then
    ${csudo}rm -f ${lib64_link_dir}/libtaos.* || :
    ${csudo}rm -f ${lib64_link_dir}/libtaosws.* || :
  fi
  if [ "$osType" != "Darwin" ]; then
    ${csudo}cp ${binary_dir}/build/lib/libtaos.so.${verNumber} \
      ${install_main_dir}/driver &&
-      ${csudo}chmod 777 ${install_main_dir}/driver/*
+      ${csudo}chmod 777 ${install_main_dir}/driver/libtaos.so.${verNumber}
    ${csudo}ln -sf ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.so.1
    ${csudo}ln -sf ${lib_link_dir}/libtaos.so.1 ${lib_link_dir}/libtaos.so
    if [ -d "${lib64_link_dir}" ]; then
-      ${csudo}ln -sf ${install_main_dir}/driver/libtaos.* ${lib64_link_dir}/libtaos.so.1
+        ${csudo}ln -sf ${install_main_dir}/driver/libtaos.* ${lib64_link_dir}/libtaos.so.1
-      ${csudo}ln -sf ${lib64_link_dir}/libtaos.so.1 ${lib64_link_dir}/libtaos.so
+        ${csudo}ln -sf ${lib64_link_dir}/libtaos.so.1 ${lib64_link_dir}/libtaos.so
    fi
    if [ -f ${binary_dir}/build/lib/libtaosws.so ]; then
        ${csudo}cp ${binary_dir}/build/lib/libtaosws.so \
            ${install_main_dir}/driver &&
            ${csudo}chmod 777 ${install_main_dir}/driver/libtaosws.so ||:
        ${csudo}ln -sf ${install_main_dir}/driver/libtaosws.so ${lib_link_dir}/libtaosws.so || :
        if [ -d "${lib64_link_dir}" ]; then
            ${csudo}ln -sf ${lib64_link_dir}/libtaosws.so ${lib64_link_dir}/libtaosws.so || :
        fi
    fi
  else
    ${csudo}cp -Rf ${binary_dir}/build/lib/libtaos.${verNumber}.dylib \
@ -337,8 +350,8 @@ function install_lib() {
  fi
  install_jemalloc
-  install_avro lib
+  #install_avro lib
-  install_avro lib64
+  #install_avro lib64
  if [ "$osType" != "Darwin" ]; then
    ${csudo}ldconfig
@ -349,18 +362,26 @@ function install_header() {
  if [ "$osType" != "Darwin" ]; then
    ${csudo}rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taosdef.h ${inc_link_dir}/taoserror.h ${inc_link_dir}/taosudf.h || :
    ${csudo}rm -f ${inc_link_dir}/taosws.h ||:
    ${csudo}cp -f ${source_dir}/include/client/taos.h ${source_dir}/include/common/taosdef.h ${source_dir}/include/util/taoserror.h ${source_dir}/include/libs/function/taosudf.h \
      ${install_main_dir}/include && ${csudo}chmod 644 ${install_main_dir}/include/*
    if [ -f ${binary_dir}/build/include/taosws.h ]; then
      ${csudo}cp -f ${binary_dir}/build/include/taosws.h ${install_main_dir}/include && ${csudo}chmod 644 ${install_main_dir}/include/taosws.h ||:
      ${csudo}ln -s ${install_main_dir}/include/taosws.h ${inc_link_dir}/taosws.h ||:
    fi
    ${csudo}ln -s ${install_main_dir}/include/taos.h ${inc_link_dir}/taos.h
    ${csudo}ln -s ${install_main_dir}/include/taosdef.h ${inc_link_dir}/taosdef.h
    ${csudo}ln -s ${install_main_dir}/include/taoserror.h ${inc_link_dir}/taoserror.h
    ${csudo}ln -s ${install_main_dir}/include/taosudf.h ${inc_link_dir}/taosudf.h
  else
    ${csudo}cp -f ${source_dir}/include/client/taos.h ${source_dir}/include/common/taosdef.h ${source_dir}/include/util/taoserror.h ${source_dir}/include/libs/function/taosudf.h \
      ${install_main_dir}/include ||
      ${csudo}cp -f ${source_dir}/include/client/taos.h ${source_dir}/include/common/taosdef.h ${source_dir}/include/util/taoserror.h ${source_dir}/include/libs/function/taosudf.h \
        ${install_main_2_dir}/include &&
-      ${csudo}chmod 644 ${install_main_dir}/include/* ||
+      ${csudo}chmod 644 ${install_main_dir}/include/* ||:
      ${csudo}chmod 644 ${install_main_2_dir}/include/*
  fi
 }
--- a/packaging/tools/makeclient.sh
+++ b/packaging/tools/makeclient.sh
@ -161,13 +161,11 @@ if [[ $productName == "TDengine" ]]; then
      mkdir -p ${install_dir}/connector
      if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
          if [ "$osType" != "Darwin" ]; then
-              cp ${build_dir}/lib/*.jar ${install_dir}/connector || :
+              [ -f ${build_dir}/lib/*.jar ] && cp ${build_dir}/lib/*.jar ${install_dir}/connector || :
          fi
          if find ${connector_dir}/go -mindepth 1 -maxdepth 1 | read; then
              cp -r ${connector_dir}/go ${install_dir}/connector
          else
              echo "WARNING: go connector not found, please check if want to use it!"
          fi
          git clone --depth 1 https://github.com/taosdata/driver-go ${install_dir}/connector/go
          rm -rf ${install_dir}/connector/go/.git ||:
          git clone --depth 1 https://github.com/taosdata/taos-connector-python ${install_dir}/connector/python
          rm -rf ${install_dir}/connector/python/.git ||:
 #          cp -r ${connector_dir}/python ${install_dir}/connector
--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@ -60,7 +60,7 @@ if [ "$pagMode" == "lite" ]; then
  strip ${build_dir}/bin/${serverName}
  strip ${build_dir}/bin/${clientName}
  # lite version doesn't include taosadapter,  which will lead to no restful interface
-  bin_files="${build_dir}/bin/${serverName} ${build_dir}/bin/${clientName} ${script_dir}/remove.sh ${script_dir}/startPre.sh ${build_dir}/bin/taosBenchmark"
+  bin_files="${build_dir}/bin/${serverName} ${build_dir}/bin/${clientName} ${script_dir}/remove.sh ${script_dir}/startPre.sh ${build_dir}/bin/taosBenchmark  ${build_dir}/bin/tmq_sim"
  taostools_bin_files=""
 else
@ -78,6 +78,7 @@ else
  taostools_bin_files=" ${build_dir}/bin/taosdump \
      ${build_dir}/bin/taosBenchmark \
      ${build_dir}/bin/tmq_sim \
      ${build_dir}/bin/TDinsight.sh \
      $tdinsight_caches"
@ -92,8 +93,11 @@ else
 fi
 lib_files="${build_dir}/lib/libtaos.so.${version}"
 wslib_files="${build_dir}/lib/libtaosws.so."
 header_files="${code_dir}/include/client/taos.h ${code_dir}/include/common/taosdef.h ${code_dir}/include/util/taoserror.h ${code_dir}/include/libs/function/taosudf.h"
 wsheader_files="${code_dir}/inc/taosws.h"
 if [ "$dbName" != "taos" ]; then
  cfg_dir="${top_dir}/../enterprise/packaging/cfg"
 else
@ -109,6 +113,9 @@ init_file_rpm=${script_dir}/../rpm/taosd
 # make directories.
 mkdir -p ${install_dir}
 mkdir -p ${install_dir}/inc && cp ${header_files} ${install_dir}/inc
 ${wsheader_files} ${install_dir}/inc || :
 mkdir -p ${install_dir}/cfg && cp ${cfg_dir}/${configFile} ${install_dir}/cfg/${configFile}
 if [ -f "${compile_dir}/test/cfg/taosadapter.toml" ]; then
@ -283,18 +290,17 @@ fi
 # Copy driver
 mkdir -p ${install_dir}/driver && cp ${lib_files} ${install_dir}/driver && echo "${versionComp}" >${install_dir}/driver/vercomp.txt
 [ -f ${wslib_files} ] && cp ${wslib_files} ${install_dir}/driver || :
 # Copy connector
 if [ "$verMode" == "cluster" ]; then
    connector_dir="${code_dir}/connector"
    mkdir -p ${install_dir}/connector
    if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
-        cp ${build_dir}/lib/*.jar ${install_dir}/connector || :
+        [ -f ${build_dir}/lib/*.jar ] && cp ${build_dir}/lib/*.jar ${install_dir}/connector || :
-        if find ${connector_dir}/go -mindepth 1 -maxdepth 1 | read; then
+        git clone --depth 1 https://github.com/taosdata/driver-go ${install_dir}/connector/go
-            cp -r ${connector_dir}/go ${install_dir}/connector
+        rm -rf ${install_dir}/connector/go/.git ||:
-        else
+
            echo "WARNING: go connector not found, please check if want to use it!"
        fi
        git clone --depth 1 https://github.com/taosdata/taos-connector-python ${install_dir}/connector/python
        rm -rf ${install_dir}/connector/python/.git ||:
@ -306,6 +312,7 @@ if [ "$verMode" == "cluster" ]; then
        git clone --depth 1 https://github.com/taosdata/libtaos-rs ${install_dir}/connector/rust
        rm -rf ${install_dir}/connector/rust/.git ||:
        # cp -r ${connector_dir}/python ${install_dir}/connector
        # cp -r ${connector_dir}/nodejs ${install_dir}/connector
    fi
--- a/packaging/tools/remove.sh
+++ b/packaging/tools/remove.sh
@ -102,7 +102,10 @@ function clean_local_bin() {
 function clean_lib() {
  # Remove link
  ${csudo}rm -f ${lib_link_dir}/libtaos.* || :
  ${csudo}rm -f ${lib_link_dir}/libtaosws.* || :
  ${csudo}rm -f ${lib64_link_dir}/libtaos.* || :
  ${csudo}rm -f ${lib64_link_dir}/libtaosws.* || :
  #${csudo}rm -rf ${v15_java_app_dir}           || :
 }
@ -111,6 +114,9 @@ function clean_header() {
  ${csudo}rm -f ${inc_link_dir}/taos.h || :
  ${csudo}rm -f ${inc_link_dir}/taosdef.h || :
  ${csudo}rm -f ${inc_link_dir}/taoserror.h || :
  ${csudo}rm -f ${inc_link_dir}/taosudf.h || :
  ${csudo}rm -f ${inc_link_dir}/taosws.h || :
 }
 function clean_config() {
--- a/source/client/CMakeLists.txt
+++ b/source/client/CMakeLists.txt
@ -1,9 +1,13 @@
 aux_source_directory(src CLIENT_SRC)
 if(TD_WINDOWS)
    add_library(taos SHARED ${CLIENT_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/src/taos.rc.in)
 else()
    add_library(taos SHARED ${CLIENT_SRC})
-endif ()
+endif()
 INCLUDE_DIRECTORIES(jni)
 target_include_directories(
    taos
    PUBLIC "${TD_SOURCE_DIR}/include/client"
@ -14,13 +18,19 @@ target_link_libraries(
    INTERFACE api
    PRIVATE os util common transport nodes parser command planner catalog scheduler function qcom
 )
 if(TD_WINDOWS)
-    set_target_properties(taos 
+    set_target_properties(taos
-        PROPERTIES 
+        PROPERTIES
-        LINK_FLAGS 
+        LINK_FLAGS
        /DEF:${CMAKE_CURRENT_SOURCE_DIR}/src/taos.def
    )
-endif ()
+    INCLUDE_DIRECTORIES(jni/windows)
    INCLUDE_DIRECTORIES(jni/windows/win32)
    INCLUDE_DIRECTORIES(jni/windows/win32/bridge)
 else()
    INCLUDE_DIRECTORIES(jni/linux)
 endif()
 set_target_properties(
    taos
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@ -65,7 +65,7 @@ enum {
 typedef struct SAppInstInfo SAppInstInfo;
 typedef struct {
-  char*   key;
+  char* key;
  // statistics
  int32_t reportCnt;
  int32_t connKeyCnt;
@ -156,7 +156,7 @@ typedef struct SResultColumn {
 } SResultColumn;
 typedef struct SReqResultInfo {
-  SQueryExecRes  execRes;
+  SExecResult    execRes;
  const char*    pRspMsg;
  const char*    pData;
  TAOS_FIELD*    fields;      // todo, column names are not needed.
@ -169,6 +169,7 @@ typedef struct SReqResultInfo {
  uint32_t       numOfRows;
  uint64_t       totalRows;
  uint32_t       current;
  bool           localResultFetched;
  bool           completed;
  int32_t        precision;
  bool           convertUcs4;
@ -177,14 +178,15 @@ typedef struct SReqResultInfo {
 } SReqResultInfo;
 typedef struct SRequestSendRecvBody {
-  tsem_t             rspSem;  // not used now
+  tsem_t            rspSem;  // not used now
-  __taos_async_fn_t  queryFp;
+  __taos_async_fn_t queryFp;
-  __taos_async_fn_t  fetchFp;
+  __taos_async_fn_t fetchFp;
-  void*              param;
+  EQueryExecMode    execMode;
-  SDataBuf           requestMsg;
+  void*             param;
-  int64_t            queryJob;  // query job, created according to sql query DAG.
+  SDataBuf          requestMsg;
-  int32_t            subplanNum;
+  int64_t           queryJob;  // query job, created according to sql query DAG.
-  SReqResultInfo     resInfo;
+  int32_t           subplanNum;
  SReqResultInfo    resInfo;
 } SRequestSendRecvBody;
 typedef struct {
@ -222,8 +224,8 @@ typedef struct SRequestObj {
  SArray*              tableList;
  SQueryExecMetric     metric;
  SRequestSendRecvBody body;
-  bool                 stableQuery;
+  bool                 stableQuery;   // todo refactor
-  bool                 validateOnly;
+  bool                 validateOnly;  // todo refactor
  bool     killed;
  uint32_t prevCode;  // previous error code: todo refactor, add update flag for catalog
@ -247,9 +249,9 @@ void    doFreeReqResultInfo(SReqResultInfo* pResInfo);
 int32_t transferTableNameList(const char* tbList, int32_t acctId, char* dbName, SArray** pReq);
 void    syncCatalogFn(SMetaData* pResult, void* param, int32_t code);
-SRequestObj* execQuery(STscObj* pTscObj, const char* sql, int sqlLen, bool validateOnly);
+SRequestObj* execQuery(uint64_t connId, const char* sql, int sqlLen, bool validateOnly);
 TAOS_RES*    taosQueryImpl(TAOS* taos, const char* sql, bool validateOnly);
-void         taosAsyncQueryImpl(TAOS* taos, const char* sql, __taos_async_fn_t fp, void* param, bool validateOnly);
+void         taosAsyncQueryImpl(uint64_t connId, const char* sql, __taos_async_fn_t fp, void* param, bool validateOnly);
 static FORCE_INLINE SReqResultInfo* tmqGetCurResInfo(TAOS_RES* res) {
  SMqRspObj* msg = (SMqRspObj*)res;
@ -284,6 +286,7 @@ static FORCE_INLINE SReqResultInfo* tscGetCurResInfo(TAOS_RES* res) {
 extern SAppInfo appInfo;
 extern int32_t  clientReqRefPool;
 extern int32_t  clientConnRefPool;
 extern void*    tscQhandle;
 __async_send_cb_fn_t getMsgRspHandle(int32_t msgType);
@ -296,12 +299,12 @@ int32_t  releaseTscObj(int64_t rid);
 uint64_t generateRequestId();
-void*        createRequest(STscObj* pObj, int32_t type);
+void*        createRequest(uint64_t connId, int32_t type);
 void         destroyRequest(SRequestObj* pRequest);
 SRequestObj* acquireRequest(int64_t rid);
 int32_t      releaseRequest(int64_t rid);
 int32_t      removeRequest(int64_t rid);
-void         doDestroyRequest(void *p);
+void         doDestroyRequest(void* p);
 char* getDbOfConnection(STscObj* pObj);
 void  setConnectionDB(STscObj* pTscObj, const char* db);
@ -317,13 +320,14 @@ void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet);
 STscObj* taos_connect_internal(const char* ip, const char* user, const char* pass, const char* auth, const char* db,
                               uint16_t port, int connType);
-SRequestObj* launchQuery(STscObj* pTscObj, const char* sql, int sqlLen, bool validateOnly);
+SRequestObj* launchQuery(uint64_t connId, const char* sql, int sqlLen, bool validateOnly);
 int32_t parseSql(SRequestObj* pRequest, bool topicQuery, SQuery** pQuery, SStmtCallback* pStmtCb);
 int32_t getPlan(SRequestObj* pRequest, SQuery* pQuery, SQueryPlan** pPlan, SArray* pNodeList);
-int32_t buildRequest(STscObj* pTscObj, const char* sql, int sqlLen, SRequestObj** pRequest);
+int32_t buildRequest(uint64_t connId, const char* sql, int sqlLen, void* param, bool validateSql,
                     SRequestObj** pRequest);
 void taos_close_internal(void* taos);
@ -336,8 +340,9 @@ int  hbHandleRsp(SClientHbBatchRsp* hbRsp);
 // cluster level
 SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo, char* key);
 void       appHbMgrCleanup(void);
-void       hbRemoveAppHbMrg(SAppHbMgr **pAppHbMgr);
+void       hbRemoveAppHbMrg(SAppHbMgr** pAppHbMgr);
-void       closeAllRequests(SHashObj *pRequests);
+void       destroyAllRequests(SHashObj* pRequests);
 void       stopAllRequests(SHashObj* pRequests);
 // conn level
 int  hbRegisterConn(SAppHbMgr* pAppHbMgr, int64_t tscRefId, int64_t clusterId, int8_t connType);
--- a/source/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h
+++ b/source/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h
@ -0,0 +1,266 @@
 /*
 * 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 <jni.h>
 /* Header for class com_taosdata_jdbc_TSDBJNIConnector */
 #ifndef _Included_com_taosdata_jdbc_TSDBJNIConnector
 #define _Included_com_taosdata_jdbc_TSDBJNIConnector
 #ifdef __cplusplus
 extern "C" {
 #endif
 #undef com_taosdata_jdbc_TSDBJNIConnector_INVALID_CONNECTION_POINTER_VALUE
 #define com_taosdata_jdbc_TSDBJNIConnector_INVALID_CONNECTION_POINTER_VALUE 0LL
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    initImp
 * Signature: (Ljava/lang/String;)V
 */
 JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_initImp(JNIEnv *, jclass, jstring);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    setOptions
 * Signature: (ILjava/lang/String;)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setOptions(JNIEnv *, jclass, jint, jstring);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    setConfigImp
 * Signature: (Ljava/lang/String;)Lcom/taosdata/jdbc/TSDBException;
 */
 JNIEXPORT jobject JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setConfigImp(JNIEnv *, jclass, jstring);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    getTsCharset
 * Signature: ()Ljava/lang/String;
 */
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getTsCharset(JNIEnv *, jclass);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    getResultTimePrecisionImp
 * Signature: (JJ)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TDDBJNIConnector_getResultTimePrecisionImp(JNIEnv *, jobject, jlong,
                                                                                         jlong);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    connectImp
 * Signature: (Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)J
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_connectImp(JNIEnv *, jobject, jstring, jint, jstring,
                                                                           jstring, jstring);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    executeQueryImp
 * Signature: ([BJ)I
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeQueryImp(JNIEnv *, jobject, jbyteArray, jlong);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    getErrCodeImp
 * Signature: (J)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrCodeImp(JNIEnv *, jobject, jlong, jlong);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    getErrMsgImp
 * Signature: (J)Ljava/lang/String;
 */
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrMsgImp(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    getResultSetImp
 * Signature: (J)J
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultSetImp(JNIEnv *env, jobject jobj, jlong con,
                                                                                jlong tres);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    isUpdateQueryImp
 * Signature: (JJ)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_isUpdateQueryImp(JNIEnv *env, jobject jobj, jlong con,
                                                                                jlong tres);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    freeResultSetImp
 * Signature: (JJ)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_freeResultSetImp(JNIEnv *, jobject, jlong, jlong);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    getAffectedRowsImp
 * Signature: (J)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getAffectedRowsImp(JNIEnv *env, jobject jobj, jlong con,
                                                                                  jlong res);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    getSchemaMetaDataImp
 * Signature: (JJLjava/util/List;)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getSchemaMetaDataImp(JNIEnv *, jobject, jlong, jlong,
                                                                                    jobject);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    fetchRowImp
 * Signature: (JJLcom/taosdata/jdbc/TSDBResultSetRowData;)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEnv *, jobject, jlong, jlong, jobject);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    fetchBlockImp
 * Signature: (JJLcom/taosdata/jdbc/TSDBResultSetBlockData;)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchBlockImp(JNIEnv *, jobject, jlong, jlong, jobject);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    closeConnectionImp
 * Signature: (J)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeConnectionImp(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    subscribeImp
 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;JI)J
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_subscribeImp(JNIEnv *, jobject, jlong, jboolean,
                                                                             jstring, jstring, jint);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    consumeImp
 * Signature: (J)Lcom/taosdata/jdbc/TSDBResultSetRowData;
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    unsubscribeImp
 * Signature: (J)V
 */
 JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_unsubscribeImp(JNIEnv *, jobject, jlong, jboolean);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    validateCreateTableSqlImp
 * Signature: (J[B)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_validateCreateTableSqlImp(JNIEnv *, jobject, jlong,
                                                                                         jbyteArray);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    prepareStmtImp
 * Signature: ([BJ)I
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_prepareStmtImp(JNIEnv *, jobject, jbyteArray, jlong);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    setBindTableNameImp
 * Signature: (JLjava/lang/String;J)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setBindTableNameImp(JNIEnv *, jobject, jlong, jstring,
                                                                                   jlong);
 /**
 * 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);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    bindColDataImp
 * Signature: (J[B[B[BIIIIJ)J
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(JNIEnv *, jobject, jlong, jbyteArray,
                                                                               jbyteArray, jbyteArray, jint, jint, jint,
                                                                               jint, jlong);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    stmt_add_batch
 * Signature: (JJ)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_addBatchImp(JNIEnv *env, jobject jobj, jlong stmt,
                                                                           jlong con);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    executeBatchImp
 * Signature: (JJ)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeBatchImp(JNIEnv *env, jobject jobj, jlong stmt,
                                                                               jlong con);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * 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:    stmt_errstr
 * Signature: (JJ)I
 */
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_stmtErrorMsgImp(JNIEnv *env, jobject jobj, jlong stmt,
                                                                                  jlong con);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    insertLinesImp
 * Signature: ([Ljava/lang/String;JII)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_insertLinesImp(JNIEnv *, jobject, jobjectArray, jlong,
                                                                              jint, jint);
 /*
 * Class:     com_taosdata_jdbc_TSDBJNIConnector
 * Method:    schemalessInsertImp
 * Signature: (J[B[B[BIIIIJ)J
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_schemalessInsertImp(JNIEnv *, jobject, jobjectArray,
                                                                                    jlong, jint, jint);
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/source/client/jni/com_taosdata_jdbc_tmq_TMQConnector.h
+++ b/source/client/jni/com_taosdata_jdbc_tmq_TMQConnector.h
@ -0,0 +1,169 @@
 /*
 * 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 <jni.h>
 /* Header for class com_taosdata_jdbc_tmq_TMQConnector */
 #ifndef _Included_com_taosdata_jdbc_tmq_TMQConnector
 #define _Included_com_taosdata_jdbc_tmq_TMQConnector
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqConfNewImp
 * Signature: (Lcom/taosdata/jdbc/tmq/TAOSConsumer;)J
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqConfNewImp(JNIEnv *, jobject);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqConfSetImp
 * Signature: (JLjava/lang/String;Ljava/lang/String;)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqConfSetImp(JNIEnv *, jobject, jlong, jstring,
                                                                             jstring);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqConfDestroyImp
 * Signature: (J)V
 */
 JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqConfDestroyImp(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqConsumerNewImp
 * Signature: (JLcom/taosdata/jdbc/tmq/TMQConnector;)J
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqConsumerNewImp(JNIEnv *, jobject, jlong, jobject);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqTopicNewImp
 * Signature: (J)J
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqTopicNewImp(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqTopicAppendImp
 * Signature: (JLjava/lang/String;)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqTopicAppendImp(JNIEnv *, jobject, jlong, jstring);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqTopicDestroyImp
 * Signature: (J)V
 */
 JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqTopicDestroyImp(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqSubscribeImp
 * Signature: (JJ)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqSubscribeImp(JNIEnv *, jobject, jlong, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqSubscriptionImp
 * Signature: (JLcom/taosdata/jdbc/tmq/TMQConnector;)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqSubscriptionImp(JNIEnv *, jobject, jlong, jobject);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqCommitSync
 * Signature: (JJ)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqCommitSync(JNIEnv *, jobject, jlong, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqCommitAsync
 * Signature: (JJLcom/taosdata/jdbc/tmq/TAOSConsumer;)V
 */
 JNIEXPORT void JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqCommitAsync(JNIEnv *, jobject, jlong, jlong, jobject);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqUnsubscribeImp
 * Signature: (J)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqUnsubscribeImp(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqConsumerCloseImp
 * Signature: (J)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqConsumerCloseImp(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    getErrMsgImp
 * Signature: (I)Ljava/lang/String;
 */
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_getErrMsgImp(JNIEnv *, jobject, jint);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqConsumerPoll
 * Signature: (JJ)J
 */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqConsumerPoll(JNIEnv *, jobject, jlong, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqGetTopicName
 * Signature: (J)Ljava/lang/String;
 */
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetTopicName(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqGetDbName
 * Signature: (J)Ljava/lang/String;
 */
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetDbName(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqGetVgroupId
 * Signature: (J)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetVgroupId(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    tmqGetTableName
 * Signature: (J)Ljava/lang/String;
 */
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_tmqGetTableName(JNIEnv *, jobject, jlong);
 /*
 * Class:     com_taosdata_jdbc_tmq_TMQConnector
 * Method:    fetchBlockImp
 * Signature: (JJLcom/taosdata/jdbc/TSDBResultSetBlockData;ILjava/util/List;)I
 */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_tmq_TMQConnector_fetchRawBlockImp(JNIEnv *, jobject, jlong, jlong,
                                                                                jobject, jint, jobject);
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/source/client/jni/jniCommon.h
+++ b/source/client/jni/jniCommon.h
@ -0,0 +1,123 @@
 /*
 * 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 <jni.h>
 #include "taoserror.h"
 #include "tdef.h"
 #include "tlog.h"
 #include "ttypes.h"
 #ifndef TDENGINE_JNICOMMON_H
 #define TDENGINE_JNICOMMON_H
 #define jniFatal(...)                                                     \
  {                                                                       \
    if (jniDebugFlag & DEBUG_FATAL) {                                     \
      taosPrintLog("JNI FATAL ", DEBUG_FATAL, jniDebugFlag, __VA_ARGS__); \
    }                                                                     \
  }
 #define jniError(...)                                                     \
  {                                                                       \
    if (jniDebugFlag & DEBUG_ERROR) {                                     \
      taosPrintLog("JNI ERROR ", DEBUG_ERROR, jniDebugFlag, __VA_ARGS__); \
    }                                                                     \
  }
 #define jniWarn(...)                                                    \
  {                                                                     \
    if (jniDebugFlag & DEBUG_WARN) {                                    \
      taosPrintLog("JNI WARN ", DEBUG_WARN, jniDebugFlag, __VA_ARGS__); \
    }                                                                   \
  }
 #define jniInfo(...)                                               \
  {                                                                \
    if (jniDebugFlag & DEBUG_INFO) {                               \
      taosPrintLog("JNI ", DEBUG_INFO, jniDebugFlag, __VA_ARGS__); \
    }                                                              \
  }
 #define jniDebug(...)                                               \
  {                                                                 \
    if (jniDebugFlag & DEBUG_DEBUG) {                               \
      taosPrintLog("JNI ", DEBUG_DEBUG, jniDebugFlag, __VA_ARGS__); \
    }                                                               \
  }
 #define jniTrace(...)                                               \
  {                                                                 \
    if (jniDebugFlag & DEBUG_TRACE) {                               \
      taosPrintLog("JNI ", DEBUG_TRACE, jniDebugFlag, __VA_ARGS__); \
    }                                                               \
  }
 extern jclass    g_arrayListClass;
 extern jmethodID g_arrayListConstructFp;
 extern jmethodID g_arrayListAddFp;
 extern jclass    g_metadataClass;
 extern jmethodID g_metadataConstructFp;
 extern jfieldID  g_metadataColtypeField;
 extern jfieldID  g_metadataColnameField;
 extern jfieldID  g_metadataColsizeField;
 extern jfieldID  g_metadataColindexField;
 extern jclass    g_rowdataClass;
 extern jmethodID g_rowdataConstructor;
 extern jmethodID g_rowdataClearFp;
 extern jmethodID g_rowdataSetBooleanFp;
 extern jmethodID g_rowdataSetByteFp;
 extern jmethodID g_rowdataSetShortFp;
 extern jmethodID g_rowdataSetIntFp;
 extern jmethodID g_rowdataSetLongFp;
 extern jmethodID g_rowdataSetFloatFp;
 extern jmethodID g_rowdataSetDoubleFp;
 extern jmethodID g_rowdataSetStringFp;
 extern jmethodID g_rowdataSetTimestampFp;
 extern jmethodID g_rowdataSetByteArrayFp;
 extern jmethodID g_blockdataSetByteArrayFp;
 extern jmethodID g_blockdataSetNumOfRowsFp;
 extern jmethodID g_blockdataSetNumOfColsFp;
 extern jclass    g_tmqClass;
 extern jmethodID g_createConsumerErrorCallback;
 extern jmethodID g_topicListCallback;
 extern jclass    g_consumerClass;
 extern jmethodID g_commitCallback;
 jstring jniFromNCharToByteArray(JNIEnv *, char *, int32_t);
 #define JNI_SUCCESS         0
 #define JNI_TDENGINE_ERROR  -1
 #define JNI_CONNECTION_NULL -2
 #define JNI_RESULT_SET_NULL -3
 #define JNI_NUM_OF_FIELDS_0 -4
 #define JNI_SQL_NULL        -5
 #define JNI_FETCH_END       -6
 #define JNI_OUT_OF_MEMORY   -7
 #define TMQ_CONF_NULL             -100;
 #define TMQ_CONF_KEY_NULL         -101;
 #define TMQ_CONF_VALUE_NULL       -102;
 #define TMQ_TOPIC_NULL            -110;
 #define TMQ_TOPIC_NAME_NULL       -111;
 #define TMQ_CONSUMER_NULL         -120;
 #define TMQ_CONSUMER_CREATE_ERROR -121;
 extern JavaVM *g_vm;
 void jniGetGlobalMethod(JNIEnv *env);
 int32_t check_for_params(jobject jobj, jlong conn, jlong res);
 #endif  // TDENGINE_JNICOMMON_H
--- a/source/client/jni/linux/AWTCocoaComponent.h
+++ b/source/client/jni/linux/AWTCocoaComponent.h
@ -0,0 +1,15 @@
 //
 //  AWTCocoaComponent.h
 //
 //  Copyright (c) 2003 Apple Computer Inc. All rights reserved.
 //
 #import <Foundation/Foundation.h>
 #import <JavaVM/jni.h>
 // This is implemented by a com.apple.eawt.CocoaComponent. It receives messages
 //  from java safely on the AppKit thread. See the com.apple.eawt.CocoaComponent
 //  java documentation for more information.
@protocol AWTCocoaComponent
 -(void)awtMessage:(jint)messageID message:(jobject)message env:(JNIEnv*)env DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
@end
--- a/source/client/jni/linux/JDWP.h
+++ b/source/client/jni/linux/JDWP.h
@ -0,0 +1,53 @@
 /*
 * @(#)JDWP.h	1.33 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
 #ifndef JDWP_JDWP_H
 #define JDWP_JDWP_H
 #include "JDWPCommands.h"
 /*                         
 * JDWPCommands.h is the javah'ed version of all the constants defined
 * com.sun.tools.jdi.JDWP and all its nested classes. Since the names are
 * very long, the macros below are provided for convenience.
 */
 #define JDWP_COMMAND_SET(name) JDWP_ ## name 
 #define JDWP_COMMAND(set, name) JDWP_ ## set ## _ ## name
 #define JDWP_REQUEST_MODIFIER(name) \
           JDWP_EventRequest_Set_Out_modifiers_Modifier_ ## name
 #define JDWP_EVENT(name) \
           JDWP_EventKind_ ## name 
 #define JDWP_THREAD_STATUS(name) \
           JDWP_ThreadStatus_ ## name 
 #define JDWP_SUSPEND_STATUS(name) \
           JDWP_SuspendStatus_SUSPEND_STATUS_ ## name 
 #define JDWP_CLASS_STATUS(name) \
           JDWP_ClassStatus_ ## name 
 #define JDWP_TYPE_TAG(name) \
           JDWP_TypeTag_ ## name 
 #define JDWP_TAG(name) \
           JDWP_Tag_ ## name 
 #define JDWP_STEP_DEPTH(name) \
           JDWP_StepDepth_ ## name 
 #define JDWP_STEP_SIZE(name) \
           JDWP_StepSize_ ## name 
 #define JDWP_SUSPEND_POLICY(name) \
           JDWP_SuspendPolicy_ ## name 
 #define JDWP_INVOKE_OPTIONS(name) \
           JDWP_InvokeOptions_INVOKE_ ## name 
 #define JDWP_ERROR(name) \
           JDWP_Error_ ## name
 #define JDWP_HIGHEST_COMMAND_SET 17
 #define JDWP_REQUEST_NONE        -1
 /* This typedef helps keep the event and error types straight. */
 typedef unsigned short jdwpError;
 typedef unsigned char  jdwpEvent;
 typedef jint           jdwpThreadStatus;
 #endif
--- a/source/client/jni/linux/JDWPCommands.h
+++ b/source/client/jni/linux/JDWPCommands.h
@ -0,0 +1,257 @@
 #define JDWP_VirtualMachine 1
 #define JDWP_VirtualMachine_Version 1
 #define JDWP_VirtualMachine_ClassesBySignature 2
 #define JDWP_VirtualMachine_AllClasses 3
 #define JDWP_VirtualMachine_AllThreads 4
 #define JDWP_VirtualMachine_TopLevelThreadGroups 5
 #define JDWP_VirtualMachine_Dispose 6
 #define JDWP_VirtualMachine_IDSizes 7
 #define JDWP_VirtualMachine_Suspend 8
 #define JDWP_VirtualMachine_Resume 9
 #define JDWP_VirtualMachine_Exit 10
 #define JDWP_VirtualMachine_CreateString 11
 #define JDWP_VirtualMachine_Capabilities 12
 #define JDWP_VirtualMachine_ClassPaths 13
 #define JDWP_VirtualMachine_DisposeObjects 14
 #define JDWP_VirtualMachine_HoldEvents 15
 #define JDWP_VirtualMachine_ReleaseEvents 16
 #define JDWP_VirtualMachine_CapabilitiesNew 17
 #define JDWP_VirtualMachine_RedefineClasses 18
 #define JDWP_VirtualMachine_SetDefaultStratum 19
 #define JDWP_VirtualMachine_AllClassesWithGeneric 20
 #define JDWP_VirtualMachine_InstanceCounts 21
 #define JDWP_ReferenceType 2
 #define JDWP_ReferenceType_Signature 1
 #define JDWP_ReferenceType_ClassLoader 2
 #define JDWP_ReferenceType_Modifiers 3
 #define JDWP_ReferenceType_Fields 4
 #define JDWP_ReferenceType_Methods 5
 #define JDWP_ReferenceType_GetValues 6
 #define JDWP_ReferenceType_SourceFile 7
 #define JDWP_ReferenceType_NestedTypes 8
 #define JDWP_ReferenceType_Status 9
 #define JDWP_ReferenceType_Interfaces 10
 #define JDWP_ReferenceType_ClassObject 11
 #define JDWP_ReferenceType_SourceDebugExtension 12
 #define JDWP_ReferenceType_SignatureWithGeneric 13
 #define JDWP_ReferenceType_FieldsWithGeneric 14
 #define JDWP_ReferenceType_MethodsWithGeneric 15
 #define JDWP_ReferenceType_Instances 16
 #define JDWP_ReferenceType_ClassFileVersion 17
 #define JDWP_ReferenceType_ConstantPool 18
 #define JDWP_ClassType 3
 #define JDWP_ClassType_Superclass 1
 #define JDWP_ClassType_SetValues 2
 #define JDWP_ClassType_InvokeMethod 3
 #define JDWP_ClassType_NewInstance 4
 #define JDWP_ArrayType 4
 #define JDWP_ArrayType_NewInstance 1
 #define JDWP_InterfaceType 5
 #define JDWP_Method 6
 #define JDWP_Method_LineTable 1
 #define JDWP_Method_VariableTable 2
 #define JDWP_Method_Bytecodes 3
 #define JDWP_Method_IsObsolete 4
 #define JDWP_Method_VariableTableWithGeneric 5
 #define JDWP_Field 8
 #define JDWP_ObjectReference 9
 #define JDWP_ObjectReference_ReferenceType 1
 #define JDWP_ObjectReference_GetValues 2
 #define JDWP_ObjectReference_SetValues 3
 #define JDWP_ObjectReference_MonitorInfo 5
 #define JDWP_ObjectReference_InvokeMethod 6
 #define JDWP_ObjectReference_DisableCollection 7
 #define JDWP_ObjectReference_EnableCollection 8
 #define JDWP_ObjectReference_IsCollected 9
 #define JDWP_ObjectReference_ReferringObjects 10
 #define JDWP_StringReference 10
 #define JDWP_StringReference_Value 1
 #define JDWP_ThreadReference 11
 #define JDWP_ThreadReference_Name 1
 #define JDWP_ThreadReference_Suspend 2
 #define JDWP_ThreadReference_Resume 3
 #define JDWP_ThreadReference_Status 4
 #define JDWP_ThreadReference_ThreadGroup 5
 #define JDWP_ThreadReference_Frames 6
 #define JDWP_ThreadReference_FrameCount 7
 #define JDWP_ThreadReference_OwnedMonitors 8
 #define JDWP_ThreadReference_CurrentContendedMonitor 9
 #define JDWP_ThreadReference_Stop 10
 #define JDWP_ThreadReference_Interrupt 11
 #define JDWP_ThreadReference_SuspendCount 12
 #define JDWP_ThreadReference_OwnedMonitorsStackDepthInfo 13
 #define JDWP_ThreadReference_ForceEarlyReturn 14
 #define JDWP_ThreadGroupReference 12
 #define JDWP_ThreadGroupReference_Name 1
 #define JDWP_ThreadGroupReference_Parent 2
 #define JDWP_ThreadGroupReference_Children 3
 #define JDWP_ArrayReference 13
 #define JDWP_ArrayReference_Length 1
 #define JDWP_ArrayReference_GetValues 2
 #define JDWP_ArrayReference_SetValues 3
 #define JDWP_ClassLoaderReference 14
 #define JDWP_ClassLoaderReference_VisibleClasses 1
 #define JDWP_EventRequest 15
 #define JDWP_EventRequest_Set 1
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_Count 1
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_Conditional 2
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_ThreadOnly 3
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassOnly 4
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassMatch 5
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_ClassExclude 6
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_LocationOnly 7
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_ExceptionOnly 8
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_FieldOnly 9
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_Step 10
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_InstanceOnly 11
 #define JDWP_EventRequest_Set_Out_modifiers_Modifier_SourceNameMatch 12
 #define JDWP_EventRequest_Clear 2
 #define JDWP_EventRequest_ClearAllBreakpoints 3
 #define JDWP_StackFrame 16
 #define JDWP_StackFrame_GetValues 1
 #define JDWP_StackFrame_SetValues 2
 #define JDWP_StackFrame_ThisObject 3
 #define JDWP_StackFrame_PopFrames 4
 #define JDWP_ClassObjectReference 17
 #define JDWP_ClassObjectReference_ReflectedType 1
 #define JDWP_Event 64
 #define JDWP_Event_Composite 100
 #define JDWP_Event_Composite_Event_events_Events_VMStart JDWP.EventKind.VM_START
 #define JDWP_Event_Composite_Event_events_Events_SingleStep JDWP.EventKind.SINGLE_STEP
 #define JDWP_Event_Composite_Event_events_Events_Breakpoint JDWP.EventKind.BREAKPOINT
 #define JDWP_Event_Composite_Event_events_Events_MethodEntry JDWP.EventKind.METHOD_ENTRY
 #define JDWP_Event_Composite_Event_events_Events_MethodExit JDWP.EventKind.METHOD_EXIT
 #define JDWP_Event_Composite_Event_events_Events_MethodExitWithReturnValue JDWP.EventKind.METHOD_EXIT_WITH_RETURN_VALUE
 #define JDWP_Event_Composite_Event_events_Events_MonitorContendedEnter JDWP.EventKind.MONITOR_CONTENDED_ENTER
 #define JDWP_Event_Composite_Event_events_Events_MonitorContendedEntered JDWP.EventKind.MONITOR_CONTENDED_ENTERED
 #define JDWP_Event_Composite_Event_events_Events_MonitorWait JDWP.EventKind.MONITOR_WAIT
 #define JDWP_Event_Composite_Event_events_Events_MonitorWaited JDWP.EventKind.MONITOR_WAITED
 #define JDWP_Event_Composite_Event_events_Events_Exception JDWP.EventKind.EXCEPTION
 #define JDWP_Event_Composite_Event_events_Events_ThreadStart JDWP.EventKind.THREAD_START
 #define JDWP_Event_Composite_Event_events_Events_ThreadDeath JDWP.EventKind.THREAD_DEATH
 #define JDWP_Event_Composite_Event_events_Events_ClassPrepare JDWP.EventKind.CLASS_PREPARE
 #define JDWP_Event_Composite_Event_events_Events_ClassUnload JDWP.EventKind.CLASS_UNLOAD
 #define JDWP_Event_Composite_Event_events_Events_FieldAccess JDWP.EventKind.FIELD_ACCESS
 #define JDWP_Event_Composite_Event_events_Events_FieldModification JDWP.EventKind.FIELD_MODIFICATION
 #define JDWP_Event_Composite_Event_events_Events_VMDeath JDWP.EventKind.VM_DEATH
 #define JDWP_Error_NONE 0
 #define JDWP_Error_INVALID_THREAD 10
 #define JDWP_Error_INVALID_THREAD_GROUP 11
 #define JDWP_Error_INVALID_PRIORITY 12
 #define JDWP_Error_THREAD_NOT_SUSPENDED 13
 #define JDWP_Error_THREAD_SUSPENDED 14
 #define JDWP_Error_THREAD_NOT_ALIVE 15
 #define JDWP_Error_INVALID_OBJECT 20
 #define JDWP_Error_INVALID_CLASS 21
 #define JDWP_Error_CLASS_NOT_PREPARED 22
 #define JDWP_Error_INVALID_METHODID 23
 #define JDWP_Error_INVALID_LOCATION 24
 #define JDWP_Error_INVALID_FIELDID 25
 #define JDWP_Error_INVALID_FRAMEID 30
 #define JDWP_Error_NO_MORE_FRAMES 31
 #define JDWP_Error_OPAQUE_FRAME 32
 #define JDWP_Error_NOT_CURRENT_FRAME 33
 #define JDWP_Error_TYPE_MISMATCH 34
 #define JDWP_Error_INVALID_SLOT 35
 #define JDWP_Error_DUPLICATE 40
 #define JDWP_Error_NOT_FOUND 41
 #define JDWP_Error_INVALID_MONITOR 50
 #define JDWP_Error_NOT_MONITOR_OWNER 51
 #define JDWP_Error_INTERRUPT 52
 #define JDWP_Error_INVALID_CLASS_FORMAT 60
 #define JDWP_Error_CIRCULAR_CLASS_DEFINITION 61
 #define JDWP_Error_FAILS_VERIFICATION 62
 #define JDWP_Error_ADD_METHOD_NOT_IMPLEMENTED 63
 #define JDWP_Error_SCHEMA_CHANGE_NOT_IMPLEMENTED 64
 #define JDWP_Error_INVALID_TYPESTATE 65
 #define JDWP_Error_HIERARCHY_CHANGE_NOT_IMPLEMENTED 66
 #define JDWP_Error_DELETE_METHOD_NOT_IMPLEMENTED 67
 #define JDWP_Error_UNSUPPORTED_VERSION 68
 #define JDWP_Error_NAMES_DONT_MATCH 69
 #define JDWP_Error_CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED 70
 #define JDWP_Error_METHOD_MODIFIERS_CHANGE_NOT_IMPLEMENTED 71
 #define JDWP_Error_NOT_IMPLEMENTED 99
 #define JDWP_Error_NULL_POINTER 100
 #define JDWP_Error_ABSENT_INFORMATION 101
 #define JDWP_Error_INVALID_EVENT_TYPE 102
 #define JDWP_Error_ILLEGAL_ARGUMENT 103
 #define JDWP_Error_OUT_OF_MEMORY 110
 #define JDWP_Error_ACCESS_DENIED 111
 #define JDWP_Error_VM_DEAD 112
 #define JDWP_Error_INTERNAL 113
 #define JDWP_Error_UNATTACHED_THREAD 115
 #define JDWP_Error_INVALID_TAG 500
 #define JDWP_Error_ALREADY_INVOKING 502
 #define JDWP_Error_INVALID_INDEX 503
 #define JDWP_Error_INVALID_LENGTH 504
 #define JDWP_Error_INVALID_STRING 506
 #define JDWP_Error_INVALID_CLASS_LOADER 507
 #define JDWP_Error_INVALID_ARRAY 508
 #define JDWP_Error_TRANSPORT_LOAD 509
 #define JDWP_Error_TRANSPORT_INIT 510
 #define JDWP_Error_NATIVE_METHOD 511
 #define JDWP_Error_INVALID_COUNT 512
 #define JDWP_EventKind_SINGLE_STEP 1
 #define JDWP_EventKind_BREAKPOINT 2
 #define JDWP_EventKind_FRAME_POP 3
 #define JDWP_EventKind_EXCEPTION 4
 #define JDWP_EventKind_USER_DEFINED 5
 #define JDWP_EventKind_THREAD_START 6
 #define JDWP_EventKind_THREAD_DEATH 7
 #define JDWP_EventKind_THREAD_END 7
 #define JDWP_EventKind_CLASS_PREPARE 8
 #define JDWP_EventKind_CLASS_UNLOAD 9
 #define JDWP_EventKind_CLASS_LOAD 10
 #define JDWP_EventKind_FIELD_ACCESS 20
 #define JDWP_EventKind_FIELD_MODIFICATION 21
 #define JDWP_EventKind_EXCEPTION_CATCH 30
 #define JDWP_EventKind_METHOD_ENTRY 40
 #define JDWP_EventKind_METHOD_EXIT 41
 #define JDWP_EventKind_METHOD_EXIT_WITH_RETURN_VALUE 42
 #define JDWP_EventKind_MONITOR_CONTENDED_ENTER 43
 #define JDWP_EventKind_MONITOR_CONTENDED_ENTERED 44
 #define JDWP_EventKind_MONITOR_WAIT 45
 #define JDWP_EventKind_MONITOR_WAITED 46
 #define JDWP_EventKind_VM_START 90
 #define JDWP_EventKind_VM_INIT 90
 #define JDWP_EventKind_VM_DEATH 99
 #define JDWP_EventKind_VM_DISCONNECTED 100
 #define JDWP_ThreadStatus_ZOMBIE 0
 #define JDWP_ThreadStatus_RUNNING 1
 #define JDWP_ThreadStatus_SLEEPING 2
 #define JDWP_ThreadStatus_MONITOR 3
 #define JDWP_ThreadStatus_WAIT 4
 #define JDWP_SuspendStatus_SUSPEND_STATUS_SUSPENDED 0x1
 #define JDWP_ClassStatus_VERIFIED 1
 #define JDWP_ClassStatus_PREPARED 2
 #define JDWP_ClassStatus_INITIALIZED 4
 #define JDWP_ClassStatus_ERROR 8
 #define JDWP_TypeTag_CLASS 1
 #define JDWP_TypeTag_INTERFACE 2
 #define JDWP_TypeTag_ARRAY 3
 #define JDWP_Tag_ARRAY 91
 #define JDWP_Tag_BYTE 66
 #define JDWP_Tag_CHAR 67
 #define JDWP_Tag_OBJECT 76
 #define JDWP_Tag_FLOAT 70
 #define JDWP_Tag_DOUBLE 68
 #define JDWP_Tag_INT 73
 #define JDWP_Tag_LONG 74
 #define JDWP_Tag_SHORT 83
 #define JDWP_Tag_VOID 86
 #define JDWP_Tag_BOOLEAN 90
 #define JDWP_Tag_STRING 115
 #define JDWP_Tag_THREAD 116
 #define JDWP_Tag_THREAD_GROUP 103
 #define JDWP_Tag_CLASS_LOADER 108
 #define JDWP_Tag_CLASS_OBJECT 99
 #define JDWP_StepDepth_INTO 0
 #define JDWP_StepDepth_OVER 1
 #define JDWP_StepDepth_OUT 2
 #define JDWP_StepSize_MIN 0
 #define JDWP_StepSize_LINE 1
 #define JDWP_SuspendPolicy_NONE 0
 #define JDWP_SuspendPolicy_EVENT_THREAD 1
 #define JDWP_SuspendPolicy_ALL 2
 #define JDWP_InvokeOptions_INVOKE_SINGLE_THREADED 0x01
 #define JDWP_InvokeOptions_INVOKE_NONVIRTUAL 0x02
--- a/source/client/jni/linux/JavaVM.h
+++ b/source/client/jni/linux/JavaVM.h
@ -0,0 +1,11 @@
 /*
 * JavaVM.h
 *
 * Copyright (C) 1997-2001, Apple Computer, Inc.
 * All Rights Reserved.
 *
 */
 #import <JavaVM/NSJavaVirtualMachine.h>
 #import <JavaVM/NSJavaConfiguration.h>
--- a/source/client/jni/linux/NSJavaConfiguration.h
+++ b/source/client/jni/linux/NSJavaConfiguration.h
@ -0,0 +1,79 @@
 /*
 * NSJavaConfiguration.h
 *
 * Copyright (c) 1997-2001, Apple Computer, Inc.
 * All Rights Reserved.
 *
 * LaurentR- April, 2000
 *    - added:
 *             NSDefaultJavaLibraryKey
 *             NSDefaultJavaDebugLibraryKey
 *             NSDefaultObjCJavaLibraryKey
 *             NSDefaultObjCJavaDebugLibraryKey
 *             NSJavaVMArgumentsKey
 */
 #import <Foundation/Foundation.h>
 // The configuration dictionary contains a set of vendor-specific key/value
 // pairs and a set of default key/value pairs.  If no vendor is specified,
 // NSJavaConfiguration uses the NSDefaultJavaVendorKey key to determine which
 // vendor-specific dictionary should be searched before the top-level dictionary// is searched.  eg.:
 /*
    {
 	Vendor = sun;
 	default = {
 	    DefaultClasspath = "/NextLibrary/Java";
 	};
 	next = {
 	    Compiler = "/usr/bin/javac";
 	    VM = "/usr/bin/java";
 	};
 	sun = {
 	    Compiler = "/NextLibrary/JDK/bin/javac";
 	    VM = "/NextLibrary/JDK/bin/java";
 	};
    }
 */
 // In this case, if no vendor is specified, the `sun' mappings will be searched
 // first.  The value for `VM' would be "/NextLibrary/JDK/bin/java" and the value
 // for `DefaultClasspath' would be "/NextLibrary/Java".
 //
 // This search patter is applied to three dictionaries, in order:
 //    - the JavaConfiguration dictionary in the defaults for the application
 //    - the dictionary in the "JavaConfiguration" domain of the user defaults
 //    - the configuration file (/NextLibrary/Java/JavaConfig.plist).
 // This permits per-application, per-user and per-system specifications.
 extern NSString *NSDefaultJavaVendorKey DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 extern NSString *NSDefaultJavaVMKey DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 extern NSString *NSDefaultJavaCompilerKey DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 extern NSString *NSDefaultJavaClassPathKey DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 extern NSString *NSDefaultJavaLibraryKey DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 extern NSString *NSDefaultJavaDebugLibraryKey DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 extern NSString *NSDefaultObjCJavaLibraryKey DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 extern NSString *NSDefaultObjCJavaDebugLibraryKey DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 extern NSString *NSJavaVMArgumentsKey DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
@interface NSJavaConfiguration : NSObject
 {
    NSString *_vendorName;
 }
 + (NSJavaConfiguration *) defaultConfiguration DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 + (NSJavaConfiguration *) configurationForVendor:(NSString *)vendorName DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 + (NSArray *) vendorNames DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 - init DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 - initWithVendor:(NSString *)vendorName DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 - (NSString *) vendorName DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 - valueForKey:(NSString *)keyName DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 - valueForKey:(NSString *)keyName expandEnvironmentVariables:(BOOL)flag DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
@end
--- a/source/client/jni/linux/NSJavaVirtualMachine.h
+++ b/source/client/jni/linux/NSJavaVirtualMachine.h
@ -0,0 +1,61 @@
 /*
 * NSJavaVirtualMachine.h
 *
 * Copyright (c) 1997-2001, Apple Computer, Inc.
 * All Rights Reserved.
 */
 #import <Foundation/Foundation.h>
@interface NSJavaVirtualMachine : NSObject
 {
@private
    void *_vmdata;
 }
 // Returns the default virtual machine - if necessary, calls alloc + init
 + (id) defaultVirtualMachine DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 // Returns a class path.  First checks NSProcessInfo for an environment variable
 // called CLASSPATH and if that doesn't exist, uses NSJavaConfiguration to find
 // the default class path.
 + (NSString *) defaultClassPath DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 // Note that any NSThreads spawned after this method returns will automatically 
 // be attached to the virtual machine.  Likewise, it is not necessary to attach
 // the thread that is actually creating the virtual machine.  If you spawn a
 // thread before creating the virtual machine, or if you use the cthread/pthread
 // or any other non-NSThread api for creating a thread, you must explicitly
 // attach those threads before messaging any Java object from that thread.
 // This is most easily done by using the -attachCurrentThread method.
 // Use -detachCurrentThread to detach explicitly attached threads when done.
 - initWithClassPath:(NSString *)classPath DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 - (void) attachCurrentThread DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 - (void) detachCurrentThread DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 - (Class)findClass:(NSString *)className DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 - (Class)defineClass:(NSData *)javaClassData withName:(NSString *)className DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
@end
@interface NSObject (InstantiatingJavaObjects)
 // Instantiating java objects for when no -init/constructor mapping works.
 // The class these methods are invoked on *must* be a class returned by the
 // -findClass: method (or NSClassFromString() function), otherwise
 // NSInvalidJavaClassException is raised. The signature is specified using the
 // rather counter-intuitive format defined by the Java Virtual Machine
 // specification.  Try looking in JavaVM/vm-interface.h for help.
 + (id) newWithSignature:(NSString *)signature, ... DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
 + (id) newWithSignature:(NSString *)signature arguments:(va_list)args DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
@end
 extern NSString *NSInvalidJavaClassException DEPRECATED_IN_MAC_OS_X_VERSION_10_6_AND_LATER;
--- a/source/client/jni/linux/jawt.h
+++ b/source/client/jni/linux/jawt.h
@ -0,0 +1,278 @@
 /*
 * @(#)jawt.h	1.11 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
 #ifndef _JAVASOFT_JAWT_H_
 #define _JAVASOFT_JAWT_H_
 #include "jni.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 * AWT native interface (new in JDK 1.3)
 *
 * The AWT native interface allows a native C or C++ application a means
 * by which to access native structures in AWT.  This is to facilitate moving
 * legacy C and C++ applications to Java and to target the needs of the
 * community who, at present, wish to do their own native rendering to canvases
 * for performance reasons.  Standard extensions such as Java3D also require a
 * means to access the underlying native data structures of AWT.
 *
 * There may be future extensions to this API depending on demand.
 *
 * A VM does not have to implement this API in order to pass the JCK.
 * It is recommended, however, that this API is implemented on VMs that support
 * standard extensions, such as Java3D.
 *
 * Since this is a native API, any program which uses it cannot be considered
 * 100% pure java.
 */
 /*
 * AWT Native Drawing Surface (JAWT_DrawingSurface).
 *
 * For each platform, there is a native drawing surface structure.  This
 * platform-specific structure can be found in jawt_md.h.  It is recommended
 * that additional platforms follow the same model.  It is also recommended
 * that VMs on Win32 and Solaris support the existing structures in jawt_md.h.
 *
 *******************
 * EXAMPLE OF USAGE:
 *******************
 *
 * In Win32, a programmer wishes to access the HWND of a canvas to perform
 * native rendering into it.  The programmer has declared the paint() method
 * for their canvas subclass to be native:
 *
 *
 * MyCanvas.java:
 *
 * import java.awt.*;
 *
 * public class MyCanvas extends Canvas {
 *
 *     static {
 *         System.loadLibrary("mylib");
 *     }
 *
 *     public native void paint(Graphics g);
 * }
 *
 *
 * myfile.c:
 *
 * #include "jawt_md.h"
 * #include <assert.h>
 *
 * JNIEXPORT void JNICALL
 * Java_MyCanvas_paint(JNIEnv* env, jobject canvas, jobject graphics)
 * {
 *     JAWT awt;
 *     JAWT_DrawingSurface* ds;
 *     JAWT_DrawingSurfaceInfo* dsi;
 *     JAWT_Win32DrawingSurfaceInfo* dsi_win;
 *     jboolean result;
 *     jint lock;
 *
 *     // Get the AWT
 *     awt.version = JAWT_VERSION_1_3;
 *     result = JAWT_GetAWT(env, &awt);
 *     assert(result != JNI_FALSE);
 *
 *     // Get the drawing surface
 *     ds = awt.GetDrawingSurface(env, canvas);
 *     assert(ds != NULL);
 *
 *     // Lock the drawing surface
 *     lock = ds->Lock(ds);
 *     assert((lock & JAWT_LOCK_ERROR) == 0);
 *
 *     // Get the drawing surface info
 *     dsi = ds->GetDrawingSurfaceInfo(ds);
 *
 *     // Get the platform-specific drawing info
 *     dsi_win = (JAWT_Win32DrawingSurfaceInfo*)dsi->platformInfo;
 *
 *     //////////////////////////////
 *     // !!! DO PAINTING HERE !!! //
 *     //////////////////////////////
 *
 *     // Free the drawing surface info
 *     ds->FreeDrawingSurfaceInfo(dsi);
 *
 *     // Unlock the drawing surface
 *     ds->Unlock(ds);
 *
 *     // Free the drawing surface
 *     awt.FreeDrawingSurface(ds);
 * }
 *
 */
 /*
 * JAWT_Rectangle
 * Structure for a native rectangle.
 */
 typedef struct jawt_Rectangle {
    jint x;
    jint y;
    jint width;
    jint height;
 } JAWT_Rectangle;
 struct jawt_DrawingSurface;
 /*
 * JAWT_DrawingSurfaceInfo
 * Structure for containing the underlying drawing information of a component.
 */
 typedef struct jawt_DrawingSurfaceInfo {
    /*
     * Pointer to the platform-specific information.  This can be safely
     * cast to a JAWT_Win32DrawingSurfaceInfo on Windows or a
     * JAWT_X11DrawingSurfaceInfo on Solaris.  See jawt_md.h for details.
     */
    void* platformInfo;
    /* Cached pointer to the underlying drawing surface */
    struct jawt_DrawingSurface* ds;
    /* Bounding rectangle of the drawing surface */
    JAWT_Rectangle bounds;
    /* Number of rectangles in the clip */
    jint clipSize;
    /* Clip rectangle array */
    JAWT_Rectangle* clip;
 } JAWT_DrawingSurfaceInfo;
 #define JAWT_LOCK_ERROR                 0x00000001
 #define JAWT_LOCK_CLIP_CHANGED          0x00000002
 #define JAWT_LOCK_BOUNDS_CHANGED        0x00000004
 #define JAWT_LOCK_SURFACE_CHANGED       0x00000008
 /*
 * JAWT_DrawingSurface
 * Structure for containing the underlying drawing information of a component.
 * All operations on a JAWT_DrawingSurface MUST be performed from the same
 * thread as the call to GetDrawingSurface.
 */
 typedef struct jawt_DrawingSurface {
    /*
     * Cached reference to the Java environment of the calling thread.
     * If Lock(), Unlock(), GetDrawingSurfaceInfo() or
     * FreeDrawingSurfaceInfo() are called from a different thread,
     * this data member should be set before calling those functions.
     */
    JNIEnv* env;
    /* Cached reference to the target object */
    jobject target;
    /*
     * Lock the surface of the target component for native rendering.
     * When finished drawing, the surface must be unlocked with
     * Unlock().  This function returns a bitmask with one or more of the
     * following values:
     *
     * JAWT_LOCK_ERROR - When an error has occurred and the surface could not
     * be locked.
     *
     * JAWT_LOCK_CLIP_CHANGED - When the clip region has changed.
     *
     * JAWT_LOCK_BOUNDS_CHANGED - When the bounds of the surface have changed.
     *
     * JAWT_LOCK_SURFACE_CHANGED - When the surface itself has changed
     */
    jint (JNICALL *Lock)
        (struct jawt_DrawingSurface* ds);
    /*
     * Get the drawing surface info.
     * The value returned may be cached, but the values may change if
     * additional calls to Lock() or Unlock() are made.
     * Lock() must be called before this can return a valid value.
     * Returns NULL if an error has occurred.
     * When finished with the returned value, FreeDrawingSurfaceInfo must be
     * called.
     */
    JAWT_DrawingSurfaceInfo* (JNICALL *GetDrawingSurfaceInfo)
        (struct jawt_DrawingSurface* ds);
    /*
     * Free the drawing surface info.
     */
    void (JNICALL *FreeDrawingSurfaceInfo)
        (JAWT_DrawingSurfaceInfo* dsi);
    /* 
     * Unlock the drawing surface of the target component for native rendering.
     */
    void (JNICALL *Unlock)
        (struct jawt_DrawingSurface* ds);
 } JAWT_DrawingSurface;
 /*
 * JAWT
 * Structure for containing native AWT functions.
 */
 typedef struct jawt {
    /*
     * Version of this structure.  This must always be set before
     * calling JAWT_GetAWT()
     */
    jint version;
    /*
     * Return a drawing surface from a target jobject.  This value
     * may be cached.
     * Returns NULL if an error has occurred.
     * Target must be a java.awt.Component (should be a Canvas
     * or Window for native rendering).
     * FreeDrawingSurface() must be called when finished with the
     * returned JAWT_DrawingSurface.
     */
    JAWT_DrawingSurface* (JNICALL *GetDrawingSurface)
        (JNIEnv* env, jobject target);
    /*
     * Free the drawing surface allocated in GetDrawingSurface.
     */
    void (JNICALL *FreeDrawingSurface)
        (JAWT_DrawingSurface* ds);
    /*
     * Since 1.4
     * Locks the entire AWT for synchronization purposes
     */
    void (JNICALL *Lock)(JNIEnv* env);
    /*
     * Since 1.4
     * Unlocks the entire AWT for synchronization purposes
     */
    void (JNICALL *Unlock)(JNIEnv* env);
    /*
     * Since 1.4
     * Returns a reference to a java.awt.Component from a native
     * platform handle.  On Windows, this corresponds to an HWND;
     * on Solaris and Linux, this is a Drawable.  For other platforms,
     * see the appropriate machine-dependent header file for a description.
     * The reference returned by this function is a local
     * reference that is only valid in this environment.
     * This function returns a NULL reference if no component could be
     * found with matching platform information.
     */
    jobject (JNICALL *GetComponent)(JNIEnv* env, void* platformInfo);
 } JAWT;
 /*
 * Get the AWT native structure.  This function returns JNI_FALSE if
 * an error occurs.
 */
 _JNI_IMPORT_OR_EXPORT_ __attribute__((deprecated))
 jboolean JNICALL JAWT_GetAWT(JNIEnv* env, JAWT* awt);
 #define JAWT_VERSION_1_3 0x00010003
 #define JAWT_VERSION_1_4 0x00010004
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
 #endif /* !_JAVASOFT_JAWT_H_ */
--- a/source/client/jni/linux/jawt_md.h
+++ b/source/client/jni/linux/jawt_md.h
@ -0,0 +1,66 @@
 //
 //  jawt_md.h
 //  Copyright (c) 2002-2010 Apple Inc. All rights reserved.
 //
 #ifndef _JAVASOFT_JAWT_MD_H_
 #define _JAVASOFT_JAWT_MD_H_
 #include "jawt.h"
 #import <AppKit/NSView.h>
 #import <QuartzCore/CALayer.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 * JAWT on Mac OS X has two rendering models; legacy NSView, and CALayer.
 *
 * The CALayer based model returns an object conforming to the JAWT_SurfaceLayers
 * protocol in it's JAWT_DrawingSurfaceInfo->platformInfo pointer. A CALayer
 * assigned to the "layer" property overlays the rectangle of the java.awt.Component.
 * The client CALayer traces the rect of the Java component as it is moved and resized.
 * 
 * If there is a superlayer for the entire window, it is also accessible via
 * the "windowLayer" property. This layer is useful for embedding the Java
 * window in other layer graphs.
 *
 *
 * The legacy NSView model provides raw access to the NSView hierarchy which
 * mirrors the Java component hierarchy. The legacy NSView drawing model is deprecated,
 * and will not be available in future versions of Java for Mac OS X.
 * 
 * Clients can opt-into the CALayer model by OR'ing the JAWT_MACOSX_USE_CALAYER into the requested JAWT version.
 * 
 *    JAWT awt;
 *    awt.version = JAWT_VERSION_1_4 | JAWT_MACOSX_USE_CALAYER;
 *    jboolean success = JAWT_GetAWT(env, &awt);
 *
 * Future versions of Java for Mac OS X will only support the CALayer model,
 * and will not return a JAWT_MacOSXDrawingSurfaceInfo struct.
 */
 #define JAWT_MACOSX_USE_CALAYER 0x80000000
 // CALayer-based rendering 
@protocol JAWT_SurfaceLayers
@property (readwrite, retain) CALayer *layer;
@property (readonly) CALayer *windowLayer;
@end
 // Legacy NSView-based rendering
 typedef struct JAWT_MacOSXDrawingSurfaceInfo {
    NSView *cocoaViewRef; // the view is guaranteed to be valid only for the duration of Component.paint method
 }
 JAWT_MacOSXDrawingSurfaceInfo;
 #ifdef __cplusplus
 }
 #endif
 #endif /* !_JAVASOFT_JAWT_MD_H_ */
--- a/source/client/jni/linux/jdwpTransport.h
+++ b/source/client/jni/linux/jdwpTransport.h
@ -0,0 +1,237 @@
 /*
 * @(#)jdwpTransport.h	1.8 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
 /*
 * Java Debug Wire Protocol Transport Service Provider Interface.
 */
 #ifndef JDWPTRANSPORT_H
 #define JDWPTRANSPORT_H
 #include "jni.h"
 enum {
    JDWPTRANSPORT_VERSION_1_0 = 0x00010000
 };
 #ifdef __cplusplus
 extern "C" {
 #endif
 struct jdwpTransportNativeInterface_;
 struct _jdwpTransportEnv;
 #ifdef __cplusplus
 typedef _jdwpTransportEnv jdwpTransportEnv;
 #else
 typedef const struct jdwpTransportNativeInterface_ *jdwpTransportEnv;
 #endif /* __cplusplus */
 /*
 * Errors. Universal errors with JVMTI/JVMDI equivalents keep the
 * values the same.
 */
 typedef enum {
    JDWPTRANSPORT_ERROR_NONE = 0,
    JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT = 103,
    JDWPTRANSPORT_ERROR_OUT_OF_MEMORY = 110,
    JDWPTRANSPORT_ERROR_INTERNAL = 113,
    JDWPTRANSPORT_ERROR_ILLEGAL_STATE = 201,
    JDWPTRANSPORT_ERROR_IO_ERROR = 202,
    JDWPTRANSPORT_ERROR_TIMEOUT = 203,
    JDWPTRANSPORT_ERROR_MSG_NOT_AVAILABLE = 204
 } jdwpTransportError;
 /*
 * Structure to define capabilities
 */
 typedef struct {
    unsigned int can_timeout_attach     :1;
    unsigned int can_timeout_accept     :1;
    unsigned int can_timeout_handshake  :1;
    unsigned int reserved3              :1;
    unsigned int reserved4              :1;
    unsigned int reserved5              :1;
    unsigned int reserved6              :1;
    unsigned int reserved7              :1;
    unsigned int reserved8              :1;
    unsigned int reserved9              :1;
    unsigned int reserved10             :1;
    unsigned int reserved11             :1;
    unsigned int reserved12             :1;
    unsigned int reserved13             :1;
    unsigned int reserved14		:1;
    unsigned int reserved15		:1;
 } JDWPTransportCapabilities;
 /*
 * Structures to define packet layout.
 * 
 * See: http://java.sun.com/j2se/1.5/docs/guide/jpda/jdwp-spec.html
 */
 enum {
    JDWPTRANSPORT_FLAGS_NONE	 = 0x0,
    JDWPTRANSPORT_FLAGS_REPLY	 = 0x80
 };
 typedef struct {
    jint len; 
    jint id;
    jbyte flags;
    jbyte cmdSet;
    jbyte cmd;
    jbyte *data;
 } jdwpCmdPacket;
 typedef struct {
    jint len;
    jint id;
    jbyte flags;
    jshort errorCode;
    jbyte *data;
 } jdwpReplyPacket;
 typedef struct {
    union {
        jdwpCmdPacket cmd;
        jdwpReplyPacket reply;
    } type;
 } jdwpPacket;
 /*
 * JDWP functions called by the transport.
 */
 typedef struct jdwpTransportCallback {
    void *(*alloc)(jint numBytes);   /* Call this for all allocations */
    void (*free)(void *buffer);      /* Call this for all deallocations */
 } jdwpTransportCallback;
 typedef jint (JNICALL *jdwpTransport_OnLoad_t)(JavaVM *jvm,
 					       jdwpTransportCallback *callback,
 					       jint version,
                                      	       jdwpTransportEnv** env);
 /* Function Interface */
 struct jdwpTransportNativeInterface_ {
    /*  1 :  RESERVED */
    void *reserved1;
    /*	2 : Get Capabilities */
    jdwpTransportError (JNICALL *GetCapabilities)(jdwpTransportEnv* env,
 	 JDWPTransportCapabilities *capabilities_ptr);
    /*  3 : Attach */
    jdwpTransportError (JNICALL *Attach)(jdwpTransportEnv* env,
 	const char* address,
 	jlong attach_timeout,
 	jlong handshake_timeout);
    /*  4: StartListening */
    jdwpTransportError (JNICALL *StartListening)(jdwpTransportEnv* env,
 	const char* address, 
 	char** actual_address);
    /*  5: StopListening */
    jdwpTransportError (JNICALL *StopListening)(jdwpTransportEnv* env);
    /*  6: Accept */
    jdwpTransportError (JNICALL *Accept)(jdwpTransportEnv* env,
 	jlong accept_timeout, 
 	jlong handshake_timeout);
    /*  7: IsOpen */
    jboolean (JNICALL *IsOpen)(jdwpTransportEnv* env);
    /*  8: Close */
    jdwpTransportError (JNICALL *Close)(jdwpTransportEnv* env);
    /*  9: ReadPacket */
    jdwpTransportError (JNICALL *ReadPacket)(jdwpTransportEnv* env,
 	jdwpPacket *pkt);
    /*  10: Write Packet */
    jdwpTransportError (JNICALL *WritePacket)(jdwpTransportEnv* env,
 	const jdwpPacket* pkt);
    /*  11:  GetLastError */
    jdwpTransportError (JNICALL *GetLastError)(jdwpTransportEnv* env,
 	char** error);
 };
 /*
 * Use inlined functions so that C++ code can use syntax such as
 *	env->Attach("mymachine:5000", 10*1000, 0);
 *
 * rather than using C's :-
 *
 *	(*env)->Attach(env, "mymachine:5000", 10*1000, 0);
 */
 struct _jdwpTransportEnv {
    const struct jdwpTransportNativeInterface_ *functions;
 #ifdef __cplusplus
    jdwpTransportError GetCapabilities(JDWPTransportCapabilities *capabilities_ptr) {
 	return functions->GetCapabilities(this, capabilities_ptr);
    }
    jdwpTransportError Attach(const char* address, jlong attach_timeout,
        	jlong handshake_timeout) {
 	return functions->Attach(this, address, attach_timeout, handshake_timeout);
    }
    jdwpTransportError StartListening(const char* address,
        	char** actual_address) {
 	return functions->StartListening(this, address, actual_address);
    }
    jdwpTransportError StopListening(void) {
 	return functions->StopListening(this);
    }
    jdwpTransportError Accept(jlong accept_timeout, jlong handshake_timeout) {
 	return functions->Accept(this, accept_timeout, handshake_timeout);
    }
    jboolean IsOpen(void) {
        return functions->IsOpen(this);
    }
    jdwpTransportError Close(void) {
        return functions->Close(this);
    }
    jdwpTransportError ReadPacket(jdwpPacket *pkt) {
 	return functions->ReadPacket(this, pkt);
    }
    jdwpTransportError WritePacket(const jdwpPacket* pkt) {
 	return functions->WritePacket(this, pkt);
    }
    jdwpTransportError GetLastError(char** error) {
 	return functions->GetLastError(this, error);
    }
 #endif /* __cplusplus */
 };
 #ifdef __cplusplus
 } /* extern "C" */
 #endif /* __cplusplus */
 #endif /* JDWPTRANSPORT_H */
--- a/source/client/jni/linux/jni.h
+++ b/source/client/jni/linux/jni.h
--- a/source/client/jni/linux/jni_md.h
+++ b/source/client/jni/linux/jni_md.h
@ -0,0 +1,23 @@
 /*
 * @(#)jni_md.h	1.19 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
 #ifndef _JAVASOFT_JNI_MD_H_
 #define _JAVASOFT_JNI_MD_H_
 #define JNIEXPORT __attribute__((visibility("default")))
 #define JNIIMPORT
 #define JNICALL
 #if defined(__LP64__) && __LP64__ /* for -Wundef */
 typedef int jint;
 #else
 typedef long jint;
 #endif
 typedef long long jlong;
 typedef signed char jbyte;
 #endif /* !_JAVASOFT_JNI_MD_H_ */
--- a/source/client/jni/linux/jvmti.h
+++ b/source/client/jni/linux/jvmti.h
--- a/source/client/jni/windows/classfile_constants.h
+++ b/source/client/jni/windows/classfile_constants.h
@ -0,0 +1,560 @@
 /*
 * Copyright (c) 2004, 2012, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
 #ifndef CLASSFILE_CONSTANTS_H
 #define CLASSFILE_CONSTANTS_H
 #ifdef __cplusplus
 extern "C" {
 #endif
 /* Classfile version number for this information */
 #define JVM_CLASSFILE_MAJOR_VERSION 52
 #define JVM_CLASSFILE_MINOR_VERSION 0
 /* Flags */
 enum {
    JVM_ACC_PUBLIC        = 0x0001,
    JVM_ACC_PRIVATE       = 0x0002,
    JVM_ACC_PROTECTED     = 0x0004,
    JVM_ACC_STATIC        = 0x0008,
    JVM_ACC_FINAL         = 0x0010,
    JVM_ACC_SYNCHRONIZED  = 0x0020,
    JVM_ACC_SUPER         = 0x0020,
    JVM_ACC_VOLATILE      = 0x0040,
    JVM_ACC_BRIDGE        = 0x0040,
    JVM_ACC_TRANSIENT     = 0x0080,
    JVM_ACC_VARARGS       = 0x0080,
    JVM_ACC_NATIVE        = 0x0100,
    JVM_ACC_INTERFACE     = 0x0200,
    JVM_ACC_ABSTRACT      = 0x0400,
    JVM_ACC_STRICT        = 0x0800,
    JVM_ACC_SYNTHETIC     = 0x1000,
    JVM_ACC_ANNOTATION    = 0x2000,
    JVM_ACC_ENUM          = 0x4000
 };
 /* Used in newarray instruction. */
 enum {
    JVM_T_BOOLEAN = 4,
    JVM_T_CHAR    = 5,
    JVM_T_FLOAT   = 6,
    JVM_T_DOUBLE  = 7,
    JVM_T_BYTE    = 8,
    JVM_T_SHORT   = 9,
    JVM_T_INT     = 10,
    JVM_T_LONG    = 11
 };
 /* Constant Pool Entries */
 enum {
    JVM_CONSTANT_Utf8                   = 1,
    JVM_CONSTANT_Unicode                = 2, /* unused */
    JVM_CONSTANT_Integer                = 3,
    JVM_CONSTANT_Float                  = 4,
    JVM_CONSTANT_Long                   = 5,
    JVM_CONSTANT_Double                 = 6,
    JVM_CONSTANT_Class                  = 7,
    JVM_CONSTANT_String                 = 8,
    JVM_CONSTANT_Fieldref               = 9,
    JVM_CONSTANT_Methodref              = 10,
    JVM_CONSTANT_InterfaceMethodref     = 11,
    JVM_CONSTANT_NameAndType            = 12,
    JVM_CONSTANT_MethodHandle           = 15,  // JSR 292
    JVM_CONSTANT_MethodType             = 16,   // JSR 292
    JVM_CONSTANT_InvokeDynamic          = 18
 };
 /* JVM_CONSTANT_MethodHandle subtypes */
 enum {
    JVM_REF_getField                = 1,
    JVM_REF_getStatic               = 2,
    JVM_REF_putField                = 3,
    JVM_REF_putStatic               = 4,
    JVM_REF_invokeVirtual           = 5,
    JVM_REF_invokeStatic            = 6,
    JVM_REF_invokeSpecial           = 7,
    JVM_REF_newInvokeSpecial        = 8,
    JVM_REF_invokeInterface         = 9
 };
 /* StackMapTable type item numbers */
 enum {
    JVM_ITEM_Top                = 0,
    JVM_ITEM_Integer            = 1,
    JVM_ITEM_Float              = 2,
    JVM_ITEM_Double             = 3,
    JVM_ITEM_Long               = 4,
    JVM_ITEM_Null               = 5,
    JVM_ITEM_UninitializedThis  = 6,
    JVM_ITEM_Object             = 7,
    JVM_ITEM_Uninitialized      = 8
 };
 /* Type signatures */
 enum {
    JVM_SIGNATURE_ARRAY         = '[',
    JVM_SIGNATURE_BYTE          = 'B',
    JVM_SIGNATURE_CHAR          = 'C',
    JVM_SIGNATURE_CLASS         = 'L',
    JVM_SIGNATURE_ENDCLASS      = ';',
    JVM_SIGNATURE_ENUM          = 'E',
    JVM_SIGNATURE_FLOAT         = 'F',
    JVM_SIGNATURE_DOUBLE        = 'D',
    JVM_SIGNATURE_FUNC          = '(',
    JVM_SIGNATURE_ENDFUNC       = ')',
    JVM_SIGNATURE_INT           = 'I',
    JVM_SIGNATURE_LONG          = 'J',
    JVM_SIGNATURE_SHORT         = 'S',
    JVM_SIGNATURE_VOID          = 'V',
    JVM_SIGNATURE_BOOLEAN       = 'Z'
 };
 /* Opcodes */
 enum {
    JVM_OPC_nop                 = 0,
    JVM_OPC_aconst_null         = 1,
    JVM_OPC_iconst_m1           = 2,
    JVM_OPC_iconst_0            = 3,
    JVM_OPC_iconst_1            = 4,
    JVM_OPC_iconst_2            = 5,
    JVM_OPC_iconst_3            = 6,
    JVM_OPC_iconst_4            = 7,
    JVM_OPC_iconst_5            = 8,
    JVM_OPC_lconst_0            = 9,
    JVM_OPC_lconst_1            = 10,
    JVM_OPC_fconst_0            = 11,
    JVM_OPC_fconst_1            = 12,
    JVM_OPC_fconst_2            = 13,
    JVM_OPC_dconst_0            = 14,
    JVM_OPC_dconst_1            = 15,
    JVM_OPC_bipush              = 16,
    JVM_OPC_sipush              = 17,
    JVM_OPC_ldc                 = 18,
    JVM_OPC_ldc_w               = 19,
    JVM_OPC_ldc2_w              = 20,
    JVM_OPC_iload               = 21,
    JVM_OPC_lload               = 22,
    JVM_OPC_fload               = 23,
    JVM_OPC_dload               = 24,
    JVM_OPC_aload               = 25,
    JVM_OPC_iload_0             = 26,
    JVM_OPC_iload_1             = 27,
    JVM_OPC_iload_2             = 28,
    JVM_OPC_iload_3             = 29,
    JVM_OPC_lload_0             = 30,
    JVM_OPC_lload_1             = 31,
    JVM_OPC_lload_2             = 32,
    JVM_OPC_lload_3             = 33,
    JVM_OPC_fload_0             = 34,
    JVM_OPC_fload_1             = 35,
    JVM_OPC_fload_2             = 36,
    JVM_OPC_fload_3             = 37,
    JVM_OPC_dload_0             = 38,
    JVM_OPC_dload_1             = 39,
    JVM_OPC_dload_2             = 40,
    JVM_OPC_dload_3             = 41,
    JVM_OPC_aload_0             = 42,
    JVM_OPC_aload_1             = 43,
    JVM_OPC_aload_2             = 44,
    JVM_OPC_aload_3             = 45,
    JVM_OPC_iaload              = 46,
    JVM_OPC_laload              = 47,
    JVM_OPC_faload              = 48,
    JVM_OPC_daload              = 49,
    JVM_OPC_aaload              = 50,
    JVM_OPC_baload              = 51,
    JVM_OPC_caload              = 52,
    JVM_OPC_saload              = 53,
    JVM_OPC_istore              = 54,
    JVM_OPC_lstore              = 55,
    JVM_OPC_fstore              = 56,
    JVM_OPC_dstore              = 57,
    JVM_OPC_astore              = 58,
    JVM_OPC_istore_0            = 59,
    JVM_OPC_istore_1            = 60,
    JVM_OPC_istore_2            = 61,
    JVM_OPC_istore_3            = 62,
    JVM_OPC_lstore_0            = 63,
    JVM_OPC_lstore_1            = 64,
    JVM_OPC_lstore_2            = 65,
    JVM_OPC_lstore_3            = 66,
    JVM_OPC_fstore_0            = 67,
    JVM_OPC_fstore_1            = 68,
    JVM_OPC_fstore_2            = 69,
    JVM_OPC_fstore_3            = 70,
    JVM_OPC_dstore_0            = 71,
    JVM_OPC_dstore_1            = 72,
    JVM_OPC_dstore_2            = 73,
    JVM_OPC_dstore_3            = 74,
    JVM_OPC_astore_0            = 75,
    JVM_OPC_astore_1            = 76,
    JVM_OPC_astore_2            = 77,
    JVM_OPC_astore_3            = 78,
    JVM_OPC_iastore             = 79,
    JVM_OPC_lastore             = 80,
    JVM_OPC_fastore             = 81,
    JVM_OPC_dastore             = 82,
    JVM_OPC_aastore             = 83,
    JVM_OPC_bastore             = 84,
    JVM_OPC_castore             = 85,
    JVM_OPC_sastore             = 86,
    JVM_OPC_pop                 = 87,
    JVM_OPC_pop2                = 88,
    JVM_OPC_dup                 = 89,
    JVM_OPC_dup_x1              = 90,
    JVM_OPC_dup_x2              = 91,
    JVM_OPC_dup2                = 92,
    JVM_OPC_dup2_x1             = 93,
    JVM_OPC_dup2_x2             = 94,
    JVM_OPC_swap                = 95,
    JVM_OPC_iadd                = 96,
    JVM_OPC_ladd                = 97,
    JVM_OPC_fadd                = 98,
    JVM_OPC_dadd                = 99,
    JVM_OPC_isub                = 100,
    JVM_OPC_lsub                = 101,
    JVM_OPC_fsub                = 102,
    JVM_OPC_dsub                = 103,
    JVM_OPC_imul                = 104,
    JVM_OPC_lmul                = 105,
    JVM_OPC_fmul                = 106,
    JVM_OPC_dmul                = 107,
    JVM_OPC_idiv                = 108,
    JVM_OPC_ldiv                = 109,
    JVM_OPC_fdiv                = 110,
    JVM_OPC_ddiv                = 111,
    JVM_OPC_irem                = 112,
    JVM_OPC_lrem                = 113,
    JVM_OPC_frem                = 114,
    JVM_OPC_drem                = 115,
    JVM_OPC_ineg                = 116,
    JVM_OPC_lneg                = 117,
    JVM_OPC_fneg                = 118,
    JVM_OPC_dneg                = 119,
    JVM_OPC_ishl                = 120,
    JVM_OPC_lshl                = 121,
    JVM_OPC_ishr                = 122,
    JVM_OPC_lshr                = 123,
    JVM_OPC_iushr               = 124,
    JVM_OPC_lushr               = 125,
    JVM_OPC_iand                = 126,
    JVM_OPC_land                = 127,
    JVM_OPC_ior                 = 128,
    JVM_OPC_lor                 = 129,
    JVM_OPC_ixor                = 130,
    JVM_OPC_lxor                = 131,
    JVM_OPC_iinc                = 132,
    JVM_OPC_i2l                 = 133,
    JVM_OPC_i2f                 = 134,
    JVM_OPC_i2d                 = 135,
    JVM_OPC_l2i                 = 136,
    JVM_OPC_l2f                 = 137,
    JVM_OPC_l2d                 = 138,
    JVM_OPC_f2i                 = 139,
    JVM_OPC_f2l                 = 140,
    JVM_OPC_f2d                 = 141,
    JVM_OPC_d2i                 = 142,
    JVM_OPC_d2l                 = 143,
    JVM_OPC_d2f                 = 144,
    JVM_OPC_i2b                 = 145,
    JVM_OPC_i2c                 = 146,
    JVM_OPC_i2s                 = 147,
    JVM_OPC_lcmp                = 148,
    JVM_OPC_fcmpl               = 149,
    JVM_OPC_fcmpg               = 150,
    JVM_OPC_dcmpl               = 151,
    JVM_OPC_dcmpg               = 152,
    JVM_OPC_ifeq                = 153,
    JVM_OPC_ifne                = 154,
    JVM_OPC_iflt                = 155,
    JVM_OPC_ifge                = 156,
    JVM_OPC_ifgt                = 157,
    JVM_OPC_ifle                = 158,
    JVM_OPC_if_icmpeq           = 159,
    JVM_OPC_if_icmpne           = 160,
    JVM_OPC_if_icmplt           = 161,
    JVM_OPC_if_icmpge           = 162,
    JVM_OPC_if_icmpgt           = 163,
    JVM_OPC_if_icmple           = 164,
    JVM_OPC_if_acmpeq           = 165,
    JVM_OPC_if_acmpne           = 166,
    JVM_OPC_goto                = 167,
    JVM_OPC_jsr                 = 168,
    JVM_OPC_ret                 = 169,
    JVM_OPC_tableswitch         = 170,
    JVM_OPC_lookupswitch        = 171,
    JVM_OPC_ireturn             = 172,
    JVM_OPC_lreturn             = 173,
    JVM_OPC_freturn             = 174,
    JVM_OPC_dreturn             = 175,
    JVM_OPC_areturn             = 176,
    JVM_OPC_return              = 177,
    JVM_OPC_getstatic           = 178,
    JVM_OPC_putstatic           = 179,
    JVM_OPC_getfield            = 180,
    JVM_OPC_putfield            = 181,
    JVM_OPC_invokevirtual       = 182,
    JVM_OPC_invokespecial       = 183,
    JVM_OPC_invokestatic        = 184,
    JVM_OPC_invokeinterface     = 185,
    JVM_OPC_invokedynamic       = 186,
    JVM_OPC_new                 = 187,
    JVM_OPC_newarray            = 188,
    JVM_OPC_anewarray           = 189,
    JVM_OPC_arraylength         = 190,
    JVM_OPC_athrow              = 191,
    JVM_OPC_checkcast           = 192,
    JVM_OPC_instanceof          = 193,
    JVM_OPC_monitorenter        = 194,
    JVM_OPC_monitorexit         = 195,
    JVM_OPC_wide                = 196,
    JVM_OPC_multianewarray      = 197,
    JVM_OPC_ifnull              = 198,
    JVM_OPC_ifnonnull           = 199,
    JVM_OPC_goto_w              = 200,
    JVM_OPC_jsr_w               = 201,
    JVM_OPC_MAX                 = 201
 };
 /* Opcode length initializer, use with something like:
 *   unsigned char opcode_length[JVM_OPC_MAX+1] = JVM_OPCODE_LENGTH_INITIALIZER;
 */
 #define JVM_OPCODE_LENGTH_INITIALIZER { \
   1,   /* nop */                       \
   1,   /* aconst_null */               \
   1,   /* iconst_m1 */                 \
   1,   /* iconst_0 */                  \
   1,   /* iconst_1 */                  \
   1,   /* iconst_2 */                  \
   1,   /* iconst_3 */                  \
   1,   /* iconst_4 */                  \
   1,   /* iconst_5 */                  \
   1,   /* lconst_0 */                  \
   1,   /* lconst_1 */                  \
   1,   /* fconst_0 */                  \
   1,   /* fconst_1 */                  \
   1,   /* fconst_2 */                  \
   1,   /* dconst_0 */                  \
   1,   /* dconst_1 */                  \
   2,   /* bipush */                    \
   3,   /* sipush */                    \
   2,   /* ldc */                       \
   3,   /* ldc_w */                     \
   3,   /* ldc2_w */                    \
   2,   /* iload */                     \
   2,   /* lload */                     \
   2,   /* fload */                     \
   2,   /* dload */                     \
   2,   /* aload */                     \
   1,   /* iload_0 */                   \
   1,   /* iload_1 */                   \
   1,   /* iload_2 */                   \
   1,   /* iload_3 */                   \
   1,   /* lload_0 */                   \
   1,   /* lload_1 */                   \
   1,   /* lload_2 */                   \
   1,   /* lload_3 */                   \
   1,   /* fload_0 */                   \
   1,   /* fload_1 */                   \
   1,   /* fload_2 */                   \
   1,   /* fload_3 */                   \
   1,   /* dload_0 */                   \
   1,   /* dload_1 */                   \
   1,   /* dload_2 */                   \
   1,   /* dload_3 */                   \
   1,   /* aload_0 */                   \
   1,   /* aload_1 */                   \
   1,   /* aload_2 */                   \
   1,   /* aload_3 */                   \
   1,   /* iaload */                    \
   1,   /* laload */                    \
   1,   /* faload */                    \
   1,   /* daload */                    \
   1,   /* aaload */                    \
   1,   /* baload */                    \
   1,   /* caload */                    \
   1,   /* saload */                    \
   2,   /* istore */                    \
   2,   /* lstore */                    \
   2,   /* fstore */                    \
   2,   /* dstore */                    \
   2,   /* astore */                    \
   1,   /* istore_0 */                  \
   1,   /* istore_1 */                  \
   1,   /* istore_2 */                  \
   1,   /* istore_3 */                  \
   1,   /* lstore_0 */                  \
   1,   /* lstore_1 */                  \
   1,   /* lstore_2 */                  \
   1,   /* lstore_3 */                  \
   1,   /* fstore_0 */                  \
   1,   /* fstore_1 */                  \
   1,   /* fstore_2 */                  \
   1,   /* fstore_3 */                  \
   1,   /* dstore_0 */                  \
   1,   /* dstore_1 */                  \
   1,   /* dstore_2 */                  \
   1,   /* dstore_3 */                  \
   1,   /* astore_0 */                  \
   1,   /* astore_1 */                  \
   1,   /* astore_2 */                  \
   1,   /* astore_3 */                  \
   1,   /* iastore */                   \
   1,   /* lastore */                   \
   1,   /* fastore */                   \
   1,   /* dastore */                   \
   1,   /* aastore */                   \
   1,   /* bastore */                   \
   1,   /* castore */                   \
   1,   /* sastore */                   \
   1,   /* pop */                       \
   1,   /* pop2 */                      \
   1,   /* dup */                       \
   1,   /* dup_x1 */                    \
   1,   /* dup_x2 */                    \
   1,   /* dup2 */                      \
   1,   /* dup2_x1 */                   \
   1,   /* dup2_x2 */                   \
   1,   /* swap */                      \
   1,   /* iadd */                      \
   1,   /* ladd */                      \
   1,   /* fadd */                      \
   1,   /* dadd */                      \
   1,   /* isub */                      \
   1,   /* lsub */                      \
   1,   /* fsub */                      \
   1,   /* dsub */                      \
   1,   /* imul */                      \
   1,   /* lmul */                      \
   1,   /* fmul */                      \
   1,   /* dmul */                      \
   1,   /* idiv */                      \
   1,   /* ldiv */                      \
   1,   /* fdiv */                      \
   1,   /* ddiv */                      \
   1,   /* irem */                      \
   1,   /* lrem */                      \
   1,   /* frem */                      \
   1,   /* drem */                      \
   1,   /* ineg */                      \
   1,   /* lneg */                      \
   1,   /* fneg */                      \
   1,   /* dneg */                      \
   1,   /* ishl */                      \
   1,   /* lshl */                      \
   1,   /* ishr */                      \
   1,   /* lshr */                      \
   1,   /* iushr */                     \
   1,   /* lushr */                     \
   1,   /* iand */                      \
   1,   /* land */                      \
   1,   /* ior */                       \
   1,   /* lor */                       \
   1,   /* ixor */                      \
   1,   /* lxor */                      \
   3,   /* iinc */                      \
   1,   /* i2l */                       \
   1,   /* i2f */                       \
   1,   /* i2d */                       \
   1,   /* l2i */                       \
   1,   /* l2f */                       \
   1,   /* l2d */                       \
   1,   /* f2i */                       \
   1,   /* f2l */                       \
   1,   /* f2d */                       \
   1,   /* d2i */                       \
   1,   /* d2l */                       \
   1,   /* d2f */                       \
   1,   /* i2b */                       \
   1,   /* i2c */                       \
   1,   /* i2s */                       \
   1,   /* lcmp */                      \
   1,   /* fcmpl */                     \
   1,   /* fcmpg */                     \
   1,   /* dcmpl */                     \
   1,   /* dcmpg */                     \
   3,   /* ifeq */                      \
   3,   /* ifne */                      \
   3,   /* iflt */                      \
   3,   /* ifge */                      \
   3,   /* ifgt */                      \
   3,   /* ifle */                      \
   3,   /* if_icmpeq */                 \
   3,   /* if_icmpne */                 \
   3,   /* if_icmplt */                 \
   3,   /* if_icmpge */                 \
   3,   /* if_icmpgt */                 \
   3,   /* if_icmple */                 \
   3,   /* if_acmpeq */                 \
   3,   /* if_acmpne */                 \
   3,   /* goto */                      \
   3,   /* jsr */                       \
   2,   /* ret */                       \
   99,  /* tableswitch */               \
   99,  /* lookupswitch */              \
   1,   /* ireturn */                   \
   1,   /* lreturn */                   \
   1,   /* freturn */                   \
   1,   /* dreturn */                   \
   1,   /* areturn */                   \
   1,   /* return */                    \
   3,   /* getstatic */                 \
   3,   /* putstatic */                 \
   3,   /* getfield */                  \
   3,   /* putfield */                  \
   3,   /* invokevirtual */             \
   3,   /* invokespecial */             \
   3,   /* invokestatic */              \
   5,   /* invokeinterface */           \
   5,   /* invokedynamic */             \
   3,   /* new */                       \
   2,   /* newarray */                  \
   3,   /* anewarray */                 \
   1,   /* arraylength */               \
   1,   /* athrow */                    \
   3,   /* checkcast */                 \
   3,   /* instanceof */                \
   1,   /* monitorenter */              \
   1,   /* monitorexit */               \
   0,   /* wide */                      \
   4,   /* multianewarray */            \
   3,   /* ifnull */                    \
   3,   /* ifnonnull */                 \
   5,   /* goto_w */                    \
   5    /* jsr_w */                     \
 }
 #ifdef __cplusplus
 } /* extern "C" */
 #endif /* __cplusplus */
 #endif /* CLASSFILE_CONSTANTS */
--- a/Show More
+++ b/Show More
		`@ -1 +1 @@`
			`Subproject commit 1c8924dc668e6aa848214c2fc54e3ace3f5bf8df`				`Subproject commit 7ed7a97715388fa144718764d6bf20f9bfc29a12`