Merge branch '3.0' into dev/merge-3.0-0322

* 3.0: (24 commits)
  doc: update docs. (#30347)
  doc: update docs for analysis (#30352)
  docs: fix virtual table err code (#30348)
  fix(stmt2):stmt2 get fields return wrong when tag is value (#30283)
  docs: [TS-4897] Add docs for virtual table. (#30325)
  fix: add show connMode string (#30323)
  fix: add requests pkg in tdgpt install.sh
  ci: add release build
  Update remove.sh
  refactor: streamline library removal and linking in installation scripts
  doc: add error code information about tdgpt (#30338)
  Update 09-error-code.md (#30327)
  chore: update taosadapter depends (#30326)
  chore: use taosws 3.0 branch in TDengine 3.0
  fix: show connMode is ok for taos
  fix: remove old setConnMode
  fix: build error
  fix: get default port rule
  chore: use taosadapter 3.0 branch in 3.0
  ci: fix pthread_tryjoin_np compile error
  ...

.github/workflows/tdengine-build.yml

@@ -74,6 +74,11 @@ jobs:
             snappy \
             zlib
 
+      - name: prepare install path
+        run: |
+          sudo mkdir -p /usr/local/lib
+          sudo mkdir -p /usr/local/include
+
       - name: Build and install TDengine
         run: |
           mkdir debug && cd debug

.gitignore

@@ -59,7 +59,6 @@ tools/upx*
 html/
 /.vs
 /CMakeFiles/3.10.2
-/CMakeCache.txt
 /Makefile
 /*.cmake
 /src/cq/test/CMakeFiles/cqtest.dir/*.cmake

Jenkinsfile2

@@ -361,6 +361,7 @@ def pre_test_build_win() {
         pip3 install taospy==2.7.21 
         pip3 install taos-ws-py==0.3.8
         xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
+        xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taosnative.dll C:\\Windows\\System32
     '''
     return 1
 }
@@ -379,7 +380,9 @@ def run_win_test() {
     bat '''
         echo "windows test ..."
         xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
+        xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taosnative.dll C:\\Windows\\System32
         ls -l C:\\Windows\\System32\\taos.dll
+        ls -l C:\\Windows\\System32\\taosnative.dll
         time /t
         cd %WIN_SYSTEM_TEST_ROOT%
         echo "testing ..."

cmake/cmake.define

@@ -97,14 +97,10 @@ ELSE()
     SET(TD_TAOS_TOOLS TRUE)
 ENDIF()
 
-SET(TAOS_LIB taos)
+SET(TAOS_LIB taos) 
 SET(TAOS_LIB_STATIC taos_static)
-
+SET(TAOS_NATIVE_LIB taosnative)
-IF(${TD_WINDOWS})
+SET(TAOS_NATIVE_LIB_STATIC taosnative_static)
-    SET(TAOS_LIB_PLATFORM_SPEC taos_static)
-ELSE()
-    SET(TAOS_LIB_PLATFORM_SPEC taos)
-ENDIF()
 
 # build TSZ by default
 IF("${TSZ_ENABLED}" MATCHES "false")

cmake/taosws_CMakeLists.txt.in

@@ -2,7 +2,7 @@
 # taosws-rs
 ExternalProject_Add(taosws-rs
         GIT_REPOSITORY https://github.com/taosdata/taos-connector-rust.git
-        GIT_TAG main
+        GIT_TAG  3.0
         SOURCE_DIR "${TD_SOURCE_DIR}/tools/taosws-rs"
         BINARY_DIR ""
         #BUILD_IN_SOURCE TRUE

docs/en/14-reference/05-connector/10-cpp.md

@@ -682,7 +682,7 @@ The basic API is used to establish database connections and provide a runtime en
   - **Interface Description**: Cleans up the runtime environment, should be called before the application exits.
 
 - `int taos_options(TSDB_OPTION option, const void * arg, ...)`
-  - **Interface Description**: Sets client options, currently supports locale (`TSDB_OPTION_LOCALE`), character set (`TSDB_OPTION_CHARSET`), timezone (`TSDB_OPTION_TIMEZONE`), and configuration file path (`TSDB_OPTION_CONFIGDIR`). Locale, character set, and timezone default to the current settings of the operating system.
+  - **Interface Description**: Sets client options, currently supports locale (`TSDB_OPTION_LOCALE`), character set (`TSDB_OPTION_CHARSET`), timezone (`TSDB_OPTION_TIMEZONE`), configuration file path (`TSDB_OPTION_CONFIGDIR`), and driver type (`TSDB_OPTION_DRIVER`). Locale, character set, and timezone default to the current settings of the operating system. The driver type can be either the native interface(`native`) or the WebSocket interface(`websocket`), with the default being `websocket`.
   - **Parameter Description**:
     - `option`: [Input] Setting item type.
     - `arg`: [Input] Setting item value.

docs/en/14-reference/09-error-code.md

@@ -41,6 +41,8 @@ This document details the server error codes that may be encountered when using
 | 0x80000107 | Ref ID is removed                 | The referenced ref resource has been released                | Preserve the scene and logs, report issue on github          |
 | 0x80000108 | Invalid Ref ID                    | Invalid ref ID                                               | Preserve the scene and logs, report issue on github          |
 | 0x8000010A | Ref is not there                  | ref information does not exist                               | Preserve the scene and logs, report issue on github          |
+| 0x8000010B | Driver was not loaded                   | libtaosnative.so or libtaosws.so was not found in the system path                           | Reinstall the client driver |
+| 0x8000010C | Function was not loaded from the driver | some function defined in libtaos.so are not implemented in libtaosnative.so or libtaosws.so | Reinstall the client driver |
 | 0x80000110 | Unexpected generic error          | System internal error                                        | Preserve the scene and logs, report issue on github          |
 | 0x80000111 | Action in progress                | Operation in progress                                        | 1. Wait for the operation to complete 2. Cancel the operation if necessary 3. If it exceeds a reasonable time and still not completed, preserve the scene and logs, or contact customer support |
 | 0x80000112 | Out of range                      | Configuration parameter exceeds allowed value range          | Change the parameter                                         |
@@ -556,6 +558,20 @@ This document details the server error codes that may be encountered when using
 | 0x80004017 | Invalid status, please subscribe topic first | tmq status invalidate                 | Without calling subscribe, directly poll data     |
 | 0x80004100 | Stream task not exist | The stream computing task does not exist                     | Check the server-side error logs             |
 
+## TDgpt
+
+| Error Code     | Description              | Possible Error Scenarios or Reasons                    | Recommanded Actions for Users             |
+| ---------- | --------------------- | -------------------------------------------------------------------------------- | ------------------------------ |
+| 0x80000440 | Analysis service response is NULL | The response content is empty                     | Check the taosanode.app.log for detailed response information |
+| 0x80000441 | Analysis service can't access     | Service is not work currectly, or network is broken  | Check the status of taosanode and network status       |
+| 0x80000442 | Analysis algorithm is missing     | Algorithm used in analysis is not specified     |   Add the "algo" parameter in forecast function or anomaly_window clause       |
+| 0x80000443 | Analysis algorithm not loaded | The specified algorithm is not available   |   Check for the specified algorithm   |
+| 0x80000444 | Analysis invalid buffer type  | The bufferred data type is invalid  | Check the taosanode.app.log for more details     |
+| 0x80000445 | Analysis failed since anode return error       | The responses from anode with error message | Check the taosanode.app.log for more details     |
+| 0x80000446 | Analysis failed since too many input rows for anode | Input data is too many   | Reduce the rows of input data to below than the threshold   |
+| 0x80000447 | white-noise data not processed                      |  white noise data is not processed   |  Ignore the white noise check or use another input data  |
+| 0x80000448 | Analysis internal error, not processed                 | Internal error occurs   | Check the taosanode.app.log for more details     |
+
 
 ## virtual table
 
@@ -568,4 +584,4 @@ This document details the server error codes that may be encountered when using
 | 0x80006204 | Virtual table not support decimal type                  | Create virtual table using decimal type                                                                                                                              | create virtual table without using decimal type                               |
 | 0x80006205 | Virtual table not support in STMT query and STMT insert | Use virtual table in stmt query and stmt insert                                                                                                                      | do not use virtual table in stmt query and insert                             |
 | 0x80006206 | Virtual table not support in Topic                      | Use virtual table in topic                                                                                                                                           | do not use virtual table in topic                                             |
-| 0x80006206 | Virtual super table query not support origin table from different databases                      | Virtual super table ‘s child table's origin table from different databases                                                                               | make sure virtual super table's child table's origin table from same database |
+| 0x80006207 | Virtual super table query not support origin table from different databases                      | Virtual super table ‘s child table's origin table from different databases                                                                               | make sure virtual super table's child table's origin table from same database |

docs/examples/python/kafka_example_consumer.py

@@ -182,7 +182,7 @@ def test_json_to_taos(consumer: Consumer):
                                              'voltage': 105,
                                              'phase': 0.02027, }),
                            partition=1, topic='test', serialized_key_size=None, serialized_header_size=None,
-                           serialized_value_size=None, timestamp=time.time(), timestamp_type=None),
+                           serialized_value_size=None, timestamp=time.time(), timestamp_type=None, leader_epoch=0),
             ConsumerRecord(checksum=None, headers=None, offset=1, key=None,
                            value=json.dumps({'table_name': 'd1',
                                              'ts': '2022-12-06 15:13:39.643',
@@ -190,7 +190,7 @@ def test_json_to_taos(consumer: Consumer):
                                              'voltage': 102,
                                              'phase': 0.02027, }),
                            partition=1, topic='test', serialized_key_size=None, serialized_header_size=None,
-                           serialized_value_size=None, timestamp=time.time(), timestamp_type=None),
+                           serialized_value_size=None, timestamp=time.time(), timestamp_type=None,leader_epoch=0 ),
         ]
     ]
 
@@ -203,11 +203,11 @@ def test_line_to_taos(consumer: Consumer):
             ConsumerRecord(checksum=None, headers=None, offset=1, key=None,
                            value="d0 values('2023-01-01 00:00:00.001', 3.49, 109, 0.02737)".encode('utf-8'),
                            partition=1, topic='test', serialized_key_size=None, serialized_header_size=None,
-                           serialized_value_size=None, timestamp=time.time(), timestamp_type=None),
+                           serialized_value_size=None, timestamp=time.time(), timestamp_type=None,leader_epoch=0 ),
             ConsumerRecord(checksum=None, headers=None, offset=1, key=None,
                            value="d1 values('2023-01-01 00:00:00.002', 6.19, 112, 0.09171)".encode('utf-8'),
                            partition=1, topic='test', serialized_key_size=None, serialized_header_size=None,
-                           serialized_value_size=None, timestamp=time.time(), timestamp_type=None),
+                           serialized_value_size=None, timestamp=time.time(), timestamp_type=None,leader_epoch=0 ),
         ]
     ]
     consumer._line_to_taos(messages=records)

docs/zh/05-basic/01-model.md

@@ -77,6 +77,22 @@ toc_max_heading_level: 4
 
 ![数据模型示意图](./data-model.png)
 
+### 虚拟表
+
+“一个设备一张表”的设计解决了工业和物联网等场景下的大多数时序数据管理和分析难题，但是在遇到更复杂的场景时，这种设计受到了设备复杂性的挑战。这种复杂性的根源在于一个设备无法简单的用一个或一组数据采集点来描述或管理，而业务分析往往需要综合多个或多组采集点的数据才能完成。以汽车或发电风机为例，整个设备（汽车或风机）中含有非常大量的传感器（数据采集点），这些传感器的输出和采集频率千差万别。一个超级表只能描述其中一种传感器，当需要综合多个传感器的数据进行分析计算时，只能通过多级关联查询的方式来进行，而这往往会导致易用性和性能方面的问题。
+
+为了解决这个问题，TDengine 引入虚拟表（Virtual Table，简称为 VTable）的概念。虚拟表是一种不存储实际数据而可以用于分析计算的表，它的数据来源为其它真实存储数据的子表、普通表，通过将不同列数据按照时间戳排序、对齐、合并的方式来生成虚拟表。同真实表类似，虚拟表也可以分为虚拟超级表、虚拟子表、虚拟普通表。虚拟超级表可以是一个设备或一组分析计算所需数据的完整集合，每个虚拟子表可以根据需要引用相同或不同的列，因此可以灵活地根据业务需要进行定义，最终可以达到千表千面的效果。虚拟表不能写入、删除数据，在查询使用上同真实表基本相同，支持虚拟超级表、虚拟子表、虚拟普通表上的任何查询。唯一的区别在于虚拟表的数据是每次查询计算时动态生成的，只有一个查询中引用的列才会被合并进虚拟表中，因此同一个虚拟表在不同的查询中所呈现的数据可能是不同的。
+
+虚拟超级表的主要功能特点包括：
+1. 列选择与拼接 <br />
+   用户可以从多个原始表中选择指定的列，按需组合到一张虚拟表中，形成统一的数据视图。
+2. 基于时间戳对齐 <br />
+   以时间戳为依据对数据进行对齐，如果多个表在相同时间戳下存在数据，则对应列的值组合成同一行；若部分表在该时间戳下无数据，则对应列填充为 NULL。
+3. 动态更新 <br />
+   虚拟表根据原始表的数据变化自动更新，确保数据的实时性。虚拟表不需实际存储，计算在生成时动态完成。
+
+通过引入虚拟表的概念，现在 TDengine 可以非常方便的管理更大更复杂的设备数据。无论每个采集点如何建模（单列 or 多列），无论这些采集点的数据是分布在一个或多个库中，我们现在都可以通过定义虚拟子表的方式跨库跨表任意指定数据源，通过虚拟超级表的方式进行跨设备、跨分析的聚合运算，从此“一个设备一张表”彻底成为现实。
+
 ### 库
 
 库是 TDengine 中用于管理一组表的集合。TDengine 允许一个运行实例包含多个库，并且每个库都可以配置不同的存储策略。由于不同类型的数据采集点通常具有不同的数据特征，如数据采集频率、数据保留期限、副本数量、数据块大小等。为了在各种场景下确保 TDengine 能够发挥最大效率，建议将具有不同数据特征的超级表创建在不同的库中。
@@ -93,6 +109,7 @@ toc_max_heading_level: 4
 
 在查询数据时，TDengine 客户端会根据应用程序当前的时区设置，自动将保存的 UTC 时间戳转换成本地时间进行显示，确保用户在不同时区下都能看到正确的时间信息。
 
+
 ## 数据建模
 
 本节用智能电表做例子，简要的介绍如何在 TDengine 里使用 SQL 创建数据库、超级表、表的基本操作。
@@ -215,3 +232,177 @@ TDengine 支持灵活的数据模型设计，包括多列模型和单列模型
 尽管 TDengine 推荐使用多列模型，因为这种模型在写入效率和存储效率方面通常更优，但在某些特定场景下，单列模型可能更为适用。例如，当一个数据采集点的采集量种类经常发生变化时，如果采用多列模型，就需要频繁修改超级表的结构定义，这会增加应用程序的复杂性。在这种情况下，采用单列模型可以简化应用程序的设计和管理，因为它允许独立地管理和扩展每个物理量的超级表。
 
 总之，TDengine 提供了灵活的数据模型选项，用户可以根据实际需求和场景选择最适合的模型，以优化性能和管理复杂性。
+
+### 创建虚拟表
+
+无论是选择单列模型还是多列模型，TDengine 都可以通过使用虚拟表进行跨表的运算。为智能电表为例，这里介绍虚拟表的两种使用场景：
+
+1. 单源多维度时序聚合
+2. 跨源采集量对比分析
+
+#### 单源多维度时序聚合
+在单源多维度时序聚合场景中，“单源”并非指单一物理表，而是指来自**同一数据采集点**下的多个单列时序数据表。这些数据因业务需求或其他限制被拆分为多个单列存储的表，但通过设备标签和时间基准保持逻辑一致性。虚拟表在此场景中的作用是将一个采集点中“纵向“拆分的数据，还原为完整的“横向”状态。
+例如，在建模时采用了单列模型，对于电流、电压和相位这 3 种物理量，分别建立 3 张超级表。在这种场景下，用户可以通过虚拟表将这 3 种不同的采集量聚合到一张表中，以便进行统一的查询和分析。
+
+创建单列模型的超级表的 SQL 如下：
+
+```sql
+
+CREATE STABLE current_stb (
+    ts timestamp, 
+    current float
+) TAGS (
+    device_id varchar(64),
+    location varchar(64), 
+    group_id int
+);
+
+CREATE STABLE voltage_stb (
+    ts timestamp, 
+    voltage int
+) TAGS (
+    device_id varchar(64),
+    location varchar(64), 
+    group_id int
+);
+ 
+CREATE STABLE phase_stb (
+    ts timestamp, 
+    phase float
+) TAGS (
+    device_id varchar(64),
+    location varchar(64), 
+    group_id int
+);
+```
+
+假设分别有 d1001,d1002,d1003,d1004 四个设备，分别对四个设备的电流、电压、相位采集量创建子表，SQL 如下：
+
+```sql
+create table current_d1001 using current_stb(deviceid, location, group_id) tags("d1001", "California.SanFrancisco", 2);
+create table current_d1002 using current_stb(deviceid, location, group_id) tags("d1002", "California.SanFrancisco", 3);
+create table current_d1003 using current_stb(deviceid, location, group_id) tags("d1003", "California.LosAngeles", 3);
+create table current_d1004 using current_stb(deviceid, location, group_id) tags("d1004", "California.LosAngeles", 2);
+
+create table voltage_d1001 using voltage_stb(deviceid, location, group_id) tags("d1001", "California.SanFrancisco", 2);
+create table voltage_d1002 using voltage_stb(deviceid, location, group_id) tags("d1002", "California.SanFrancisco", 3);
+create table voltage_d1003 using voltage_stb(deviceid, location, group_id) tags("d1003", "California.LosAngeles", 3);
+create table voltage_d1004 using voltage_stb(deviceid, location, group_id) tags("d1004", "California.LosAngeles", 2);
+
+create table phase_d1001 using phase_stb(deviceid, location, group_id) tags("d1001", "California.SanFrancisco", 2);
+create table phase_d1002 using phase_stb(deviceid, location, group_id) tags("d1002", "California.SanFrancisco", 3);
+create table phase_d1003 using phase_stb(deviceid, location, group_id) tags("d1003", "California.LosAngeles", 3);
+create table phase_d1004 using phase_stb(deviceid, location, group_id) tags("d1004", "California.LosAngeles", 2);
+```
+
+此时想要通过一张虚拟超级表来讲这三种采集量聚合到一张表中，创建虚拟超级表 SQL 如下：
+
+```sql
+CREATE STABLE meters_v (
+    ts timestamp, 
+    current float, 
+    voltage int, 
+    phase float
+) TAGS (
+    location varchar(64), 
+    group_id int
+) VIRTUAL 1;
+```
+
+并且对四个设备 d1001,d1002,d1003,d1004 分别创建虚拟子表，SQL 如下：
+
+```sql
+CREATE VTABLE d1001_v (
+       current from current_d1001.current,
+       voltage from voltage_d1001.voltage, 
+       phase from phase_d1001.phase
+) 
+USING meters_v 
+TAGS (
+       "California.SanFrancisco", 
+       2
+);
+       
+CREATE VTABLE d1002_v (
+       current from current_d1002.current,
+       voltage from voltage_d1002.voltage, 
+       phase from phase_d1002.phase
+) 
+USING meters_v 
+TAGS (
+       "California.SanFrancisco", 
+       3
+);
+       
+CREATE VTABLE d1003_v (
+       current from current_d1003.current,
+       voltage from voltage_d1003.voltage, 
+       phase from phase_d1003.phase
+) 
+USING meters_v 
+TAGS (
+       "California.LosAngeles", 
+       3
+);
+       
+CREATE VTABLE d1004_v (
+       current from current_d1004.current,
+       voltage from voltage_d1004.voltage, 
+       phase from phase_d1004.phase
+) 
+USING meters_v 
+TAGS (
+       "California.LosAngeles", 
+       2
+);
+```
+
+以设备 d1001 为例，假设 d1001 设备的电流、电压、相位数据如下：
+
+![data-model-origin-table.png](data-model-origin-table.png)
+
+虚拟表 d1001_v 中的数据如下 :
+
+|   Timestamp    | Current |  Voltage  |  Phase  |
+|:--------------:|:-------:|:---------:|:-------:|
+| 1538548685000  |  10.3   |    219    |  0.31   |
+| 1538548695000  |  12.6   |    218    |  0.33   |
+| 1538548696800  |  12.3   |    221    |  0.31   |
+| 1538548697100  |  12.1   |    220    |  NULL   |
+| 1538548697200  |  NULL   |   NULL    |  0.32   |
+| 1538548697700  |  11.8   |   NULL    |  NULL   |
+| 1538548697800  |  NULL   |    222    |  0.33   |
+
+#### 跨源采集量对比分析
+
+在跨源采集量对比分析中，“跨源”指数据来自**不同数据采集点**。在不同数据采集点中提取具有可比语义的采集量，通过虚拟表将这些采集量按照时间戳进行对齐和合并，并进行对比分析。
+例如，用户可以将来自不同设备的电流数据聚合到一张虚拟表中，以便进行电流数据的对比分析。
+
+以分析 d1001, d1002, d1003, d1004 四个设备的电流数据为例，创建虚拟表的 SQL 如下：
+
+```sql
+CREATE VTABLE current_v (
+       ts timestamp,
+       d1001_current float from current_d1001.current,
+       d1002_current float from current_d1002.current, 
+       d1003_current float from current_d1003.current,
+       d1004_current float from current_d1004.current
+);
+```
+
+假设 d1001, d1002, d1003, d1004 四个设备的电流数据如下：
+
+![data-model-origin-table-2.png](data-model-origin-table-2.png)
+
+虚拟表 current_v 中的数据如下：
+
+|   Timestamp    | d1001_current | d1002_current | d1003_current | d1004_current |
+|:--------------:|:-------------:|:-------------:|:-------------:|:-------------:|
+| 1538548685000  |     10.3      |     11.7      |     11.2      |     12.4      |
+| 1538548695000  |     12.6      |     11.9      |     10.8      |     11.3      |
+| 1538548696800  |     12.3      |     12.4      |     12.3      |     10.1      |
+| 1538548697100  |     12.1      |     NULL      |     11.1      |     NULL      |
+| 1538548697200  |     NULL      |     12.2      |     NULL      |     11.7      |
+| 1538548697700  |     11.8      |     11.4      |     NULL      |     NULL      |
+| 1538548697800  |     NULL      |     NULL      |     12.1      |     12.6      |
+

docs/zh/06-advanced/06-TDgpt/03-preprocess.md

@@ -9,14 +9,14 @@ import wndata from './pic/white-noise-data.png'
 ### 分析流程
 时序数据分析之前需要有预处理的过程，为减轻分析算法的负担，TDgpt 在将时序数据发给具体分析算法进行分析时，已经对数据做了预处理，整体的流程如下图所示。
 
-<img src={activity} width="560" alt="预处理流程" />
+<img src={activity} width="320" alt="预处理流程" />
 
 TDgpt 首先对输入数据进行白噪声检查（White Noise Data check）, 检查通过以后针对预测分析，还要进行输入（历史）数据的重采样和时间戳对齐处理（异常检测跳过数据重采样和时间戳对齐步骤）。
 预处理完成以后，再进行预测或异常检测操作。预处理过程不属于预测或异常检测处理逻辑的一部分。
 
 ### 白噪声检查
 
-<img src={wndata} width="430" alt="white-noise-data"/>
+<img src={wndata} width="344" alt="white-noise-data"/>
 
 白噪声时序数据可以简单地认为是随机数构成的时间数据序列（如上图所示的正态分布随机数序列），随机数构成的时间序列没有分析的价值，因此会直接返回。白噪声检查采用经典的 `Ljung-Box` 统计量检验，计算 `Ljung-Box` 统计量需遍历整个输入时间序列。如果用户能够明确输入序列一定不是白噪声序列，那么可以在参数列表中增加参数 `wncheck=0` 强制要求分析平台忽略白噪声检查，从而节省计算资源。
 TDgpt 暂不提供独立的时间序列白噪声检测功能。

docs/zh/06-advanced/06-TDgpt/04-forecast/index.md

@@ -3,19 +3,18 @@ title: 预测算法
 description: 预测算法
 ---
 
-import fc_result from '../pic/fc.png';
+import fc_result from '../pic/fc-result.png';
-import fc_result_figure from '../pic/fc-result.png';
 
 时序数据预测处理以持续一个时间段的时序数据作为输入，预测接下来一个连续时间区间内时间序列数据趋势。用户可以指定输出的（预测）时间序列数据点的数量，因此其输出的结果行数不确定。为此，TDengine 使用新 SQL 函数 `FORECAST` 提供时序数据预测服务。基础数据（用于预测的历史时间序列数据）是该函数的输入，预测结果是该函数的输出。用户可以通过 `FORECAST` 函数调用 Anode 提供的预测算法提供的服务。
 
-在后续章节中，使用时序数据表`foo`作为示例，介绍预测和异常检测算法的使用方式，`foo` 表的模式如下：
+在后续章节中，使用时序数据表 `foo` 作为示例，介绍预测和异常检测算法的使用方式，`foo` 表的模式如下：
 
-|列名称|类型|说明|
+| 列名称 | 类型      | 说明                         |
-|---|---|---|
+| ------ | --------- | ---------------------------- |
-|ts| timestamp| 主时间戳列|
+| ts     | timestamp | 主时间戳列                   |
-|i32| int32| 4字节整数，设备测量值 metric|
+| i32    | int32     | 4字节整数，设备测量值 metric |
 
-```bash
+```sql
 taos> select * from foo;
            ts            |      i32    |
 ========================================
@@ -30,6 +29,7 @@ taos> select * from foo;
 ```
 
 ### 语法
+
 ```SQL
 FORECAST(column_expr, option_expr)
 
@@ -42,21 +42,21 @@ algo=expr1
 [,start=start_ts_val]
 [,expr2]
 "}
-
 ```
+
 1. `column_expr`：预测的时序数据列，只支持数值类型列输入。
 2. `options`：预测函数的参数。字符串类型，其中使用 K=V 方式调用算法及相关参数。采用逗号分隔的 K=V 字符串表示，其中的字符串不需要使用单引号、双引号、或转义号等符号，不能使用中文及其他宽字符。预测支持 `conf`, `every`, `rows`, `start`, `rows` 几个控制参数，其含义如下：
 
 ### 参数说明
 
-|参数|含义|默认值|
+| 参数    | 含义                                       | 默认值                                         |
-|---|---|---|
+| ------- | ------------------------------------------ | ---------------------------------------------- |
-|algo|预测分析使用的算法|holtwinters|
+| algo    | 预测分析使用的算法                         | holtwinters                                    |
-|wncheck|白噪声（white noise data）检查|默认值为 1，0 表示不进行检查|
+| wncheck | 白噪声（white noise data）检查             | 默认值为 1，0 表示不进行检查                   |
-|conf|预测数据的置信区间范围 ，取值范围 [0, 100]|95|
+| conf    | 预测数据的置信区间范围 ，取值范围 [0, 100] | 95                                             |
-|every|预测数据的采样间隔|输入数据的采样间隔|
+| every   | 预测数据的采样间隔                         | 输入数据的采样间隔                             |
-|start|预测结果的开始时间戳|输入数据最后一个时间戳加上一个采样间隔时间区间|
+| start   | 预测结果的开始时间戳                       | 输入数据最后一个时间戳加上一个采样间隔时间区间 |
-|rows|预测结果的记录数|10|
+| rows    | 预测结果的记录数                           | 10                                             |
 
 1. 预测查询结果新增三个伪列，具体如下：`_FROWTS`：预测结果的时间戳、`_FLOW`：置信区间下界、`_FHIGH`：置信区间上界, 对于没有置信区间的预测算法，其置信区间同预测结果
 2. 更改参数 `START`：返回预测结果的起始时间，改变起始时间不会影响返回的预测数值，只影响起始时间。
@@ -74,7 +74,8 @@ FROM foo;
 SELECT  _flow, _fhigh, _frowts, FORECAST(i32, "algo=arima,alpha=95,period=10,wncheck=0")
 FROM foo;
 ```
-```
+
+```sql
 taos> select _flow, _fhigh, _frowts, forecast(i32) from foo;
         _flow         |        _fhigh        |       _frowts           | forecast(i32) |
 ========================================================================================
@@ -90,8 +91,8 @@ taos> select _flow, _fhigh, _frowts, forecast(i32) from foo;
         -1076.1566162 |         1214.4498291 | 2020-01-01 00:01:44.000 |            69 |
 ```
 
-
 ## 内置预测算法
+
 - [arima](./02-arima.md)
 - [holtwinters](./03-holtwinters.md)
 - CES (Complex Exponential Smoothing) 
@@ -111,6 +112,7 @@ taos> select _flow, _fhigh, _frowts, forecast(i32) from foo;
 - TimesNet
 
 ## 算法有效性评估工具
+
 TDgpt 提供预测分析算法有效性评估工具 `analytics_compare`，调用该工具并设置合适的参数，能够使用 TDengine 中的数据作为回测依据，评估不同预测算法或相同的预测算法在不同的参数或训练模型的下的预测有效性。预测有效性的评估使用 `MSE` 和 `MAE` 指标作为依据，后续还将增加 `MAPE`指标。
 
 ```ini
@@ -134,12 +136,12 @@ res_start_time = 1730000000000
 gen_figure = true
 ```
 
-算法对比分析运行完成以后，生成 fc-results.xlsx 文件，其中包含了调用算法的预测分析误差、执行时间、调用参数等信息。如下图所示：
+| algorithm   | params                                                                    | MSE     | elapsed_time(ms.) |
-
+| ----------- | ------------------------------------------------------------------------- | ------- | ----------------- |
-<img src={fc_result} width="760" alt="预测对比结果" />
+| holtwinters | `{"trend":"add", "seasonal":"add"}`                                       | 351.622 | 125.1721          |
-
+| arima       | `{"time_step":3600000, "start_p":0, "max_p":10, "start_q":0, "max_q":10}` | 433.709 | 45577.9187        |
 
 如果设置了 `gen_figure` 为 true，分析结果中还会有绘制的分析预测结果图（如下图所示）。
 
-<img src={fc_result_figure} width="540" alt="预测对比结果" />
+<img src={fc_result} width="360" alt="预测对比结果" />
 

docs/zh/06-advanced/06-TDgpt/05-anomaly-detection/index.md

@@ -5,7 +5,6 @@ description: 异常检测算法
 
 import ad from '../pic/anomaly-detection.png';
 import ad_result from '../pic/ad-result.png';
-import ad_result_figure from '../pic/ad-result-figure.png';
 
 TDengine 中定义了异常（状态）窗口来提供异常检测服务。异常窗口可以视为一种特殊的**事件窗口（Event Window）**，即异常检测算法确定的连续异常时间序列数据所在的时间窗口。与普通事件窗口区别在于——时间窗口的起始时间和结束时间均是分析算法识别确定，不是用户给定的表达式进行判定。因此，在 `WHERE` 子句中使用 `ANOMALY_WINDOW` 关键词即可调用时序数据异常检测服务，同时窗口伪列（`_WSTART`, `_WEND`, `_WDURATION`）也能够像其他时间窗口一样用于描述异常窗口的起始时间(`_WSTART`)、结束时间(`_WEND`)、持续时间(`_WDURATION`)。例如：
 
@@ -40,13 +39,15 @@ algo=expr1
 4. 输入数据默认进行白噪声检查，如果输入数据是白噪声，将不会有任何（异常）窗口信息返回。
 
 ### 参数说明
-|参数|含义|默认值|
+
-|---|---|---|
+| 参数    | 含义                                       | 默认值 |
-|algo|异常检测调用的算法|iqr|
+| ------- | ------------------------------------------ | ------ |
-|wncheck|对输入数据列是否进行白噪声检查，取值为0或1|1|
+| algo    | 异常检测调用的算法                         | iqr    |
+| wncheck | 对输入数据列是否进行白噪声检查，取值为0或1 | 1      |
 
 
 ### 示例
+
 ```SQL
 --- 使用 iqr 算法进行异常检测，检测列 i32 列。
 SELECT _wstart, _wend, SUM(i32) 
@@ -65,11 +66,12 @@ taos> SELECT _wstart, _wend, count(*) FROM foo ANOMAYL_WINDOW(i32);
 Query OK, 1 row(s) in set (0.028946s)
 ```
 
-
 ### 内置异常检测算法
+
 分析平台内置了6个异常检查模型，分为3个类别，分别是[基于统计学的算法](./02-statistics-approach.md)、[基于数据密度的算法](./03-data-density.md)、以及[基于机器学习的算法](./04-machine-learning.md)。在不指定异常检测使用的方法的情况下，默认调用 IQR 进行异常检测。
 
 ### 异常检测算法有效性比较工具
+
 TDgpt 提供自动化的工具对比不同数据集的不同算法监测有效性，针对异常检测算法提供查全率（recall）和查准率（precision）两个指标衡量不同算法的有效性。
 通过在配置文件中(analysis.ini)设置以下的选项可以调用需要使用的异常检测算法，异常检测算法测试用数据的时间范围、是否生成标注结果的图片、调用的异常检测算法以及相应的参数。
 调用异常检测算法比较之前，需要人工手动标注异常监测数据集的结果，即设置[anno_res]选项的数值，第几个数值是异常点，需要标注在数组中，如下测试集中，第 9 个点是异常点，我们就标注异常结果为 [9].
@@ -93,14 +95,21 @@ anno_res = [9]
 ksigma={"k": 2}
 iqr={}
 grubbs={}
-lof={"algo":"auto", "n_neighbor": 3}
+lof={"algorithm":"auto", "n_neighbor": 3}
 ```
 
 对比程序执行完成以后，会自动生成名称为`ad_result.xlsx` 的文件，第一个卡片是算法运行结果（如下图所示），分别包含了算法名称、执行调用参数、查全率、查准率、执行时间 5 个指标。
 
-<img src={ad_result} width="760" alt="异常检测对比结果" />
+
+| algorithm | params                                 | precision(%) | recall(%) | elapsed_time(ms.) |
+| --------- | -------------------------------------- | ------------ | --------- | ----------------- |
+| ksigma    | `{"k":2}`                              | 100          | 100       | 0.453             |
+| iqr       | `{}`                                   | 100          | 100       | 2.727             |
+| grubbs    | `{}`                                   | 100          | 100       | 2.811             |
+| lof       | `{"algorithm":"auto", "n_neighbor":3}` | 0            | 0         | 4.660             |
+
 
 如果设置了 `gen_figure` 为 `true`，比较程序会自动将每个参与比较的算法分析结果采用图片方式呈现出来（如下图所示为 ksigma 的异常检测结果标注）。
 
-<img src={ad_result_figure} width="540" alt="异常检测标注图" />
+<img src={ad_result} width="540" alt="异常检测标注图" />
 

docs/zh/14-reference/03-taos-sql/04-stable.md

@@ -22,6 +22,7 @@ table_option: {
     COMMENT 'string_value'
   | SMA(col_name [, col_name] ...)  
   | KEEP value
+  | VIRTUAL {0 | 1}
 }
 ```
 
@@ -36,6 +37,7 @@ table_option: {
 4. 关于 `ENCODE` 和 `COMPRESS` 的使用，请参考 [按列压缩](../compress)
 5. 关于 table_option 中的参数说明，请参考 [建表 SQL 说明](../table)
 6. 关于 table_option 中的 keep 参数，仅对超级表生效，keep 参数的详细说明可以参考 [数据库说明](02-database.md)，唯一不同的是超级表 keep 不会立即影响查询结果，仅在 compact 后生效。
+7. 关于 table_option 中的 virtual 参数，仅对超级表生效，指定为 1 表示创建虚拟超级表，为 0 表示创建超级表，默认为 0。创建虚拟超级表时，column_definition 中只支持 type_name 选项，不支持定义额外主键列以及压缩选项。
 
 ## 查看超级表
 

docs/zh/14-reference/03-taos-sql/22-meta.md

@@ -151,18 +151,19 @@ TDengine 内置了一个名为 `INFORMATION_SCHEMA` 的数据库，提供对数
 
 提供用户创建的超级表的相关信息。
 
-| #   |   **列名**    | **数据类型** | **说明**                                                                                              |
+| #  |    **列名**     | **数据类型**      | **说明**                                                          |
-| --- | :-----------: | ------------ | ----------------------------------------------------------------------------------------------------- |
+|----|:-------------:|---------------|-----------------------------------------------------------------|
-| 1   |  stable_name  | VARCHAR(192)  | 超级表表名                                                                                            |
+| 1  |  stable_name  | VARCHAR(192)  | 超级表表名                                                           |
-| 2   |    db_name    | VARCHAR(64)   | 超级表所在的数据库的名称                                                                              |
+| 2  |    db_name    | VARCHAR(64)   | 超级表所在的数据库的名称                                                    |
-| 3   |  create_time  | TIMESTAMP    | 创建时间                                                                                              |
+| 3  |  create_time  | TIMESTAMP     | 创建时间                                                            |
-| 4   |    columns    | INT          | 列数目                                                                                                |
+| 4  |    columns    | INT           | 列数目                                                             |
-| 5   |     tags      | INT          | 标签数目。需要注意，`tags` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。                   |
+| 5  |     tags      | INT           | 标签数目。需要注意，`tags` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。             |
-| 6   |  last_update  | TIMESTAMP    | 最后更新时间                                                                                          |
+| 6  |  last_update  | TIMESTAMP     | 最后更新时间                                                          |
-| 7   | table_comment | VARCHAR(1024) | 表注释                                                                                                |
+| 7  | table_comment | VARCHAR(1024) | 表注释                                                             |
-| 8   |   watermark   | VARCHAR(64)   | 窗口的关闭时间。需要注意，`watermark` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。        |
+| 8  |   watermark   | VARCHAR(64)   | 窗口的关闭时间。需要注意，`watermark` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。     |
-| 9   |   max_delay   | VARCHAR(64)   | 推送计算结果的最大延迟。需要注意，`max_delay` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。|
+| 9  |   max_delay   | VARCHAR(64)   | 推送计算结果的最大延迟。需要注意，`max_delay` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。 |
-| 10  |    rollup     | VARCHAR(128)  | rollup 聚合函数。需要注意，`rollup` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。          |
+| 10 |    rollup     | VARCHAR(128)  | rollup 聚合函数。需要注意，`rollup` 为 TDengine 关键字，作为列名使用时需要使用 ` 进行转义。    |
+| 11 |    virtual    | BOOL          | 超级表是否是虚拟超级表。                                                    |
 
 ## INS_TABLES
 
@@ -194,17 +195,18 @@ TDengine 内置了一个名为 `INFORMATION_SCHEMA` 的数据库，提供对数
 
 ## INS_COLUMNS
 
-| #   |   **列名**    | **数据类型** | **说明**               |
+| #  |    **列名**     | **数据类型**     | **说明**                                                        |
-| --- | :-----------: | ------------ | ---------------------- |
+|----|:-------------:|--------------|---------------------------------------------------------------|
-| 1   |  table_name   | VARCHAR(192)  | 表名                   |
+| 1  |  table_name   | VARCHAR(192) | 表名                                                            |
-| 2   |    db_name    | VARCHAR(64)   | 该表所在的数据库的名称 |
+| 2  |    db_name    | VARCHAR(64)  | 该表所在的数据库的名称                                                   |
-| 3   |  table_type   | VARCHAR(21)   | 表类型                 |
+| 3  |  table_type   | VARCHAR(21)  | 表类型                                                           |
-| 4   |   col_name    | VARCHAR(64)   | 列 的名称              |
+| 4  |   col_name    | VARCHAR(64)  | 列 的名称                                                         |
-| 5   |   col_type    | VARCHAR(32)   | 列 的类型              |
+| 5  |   col_type    | VARCHAR(32)  | 列 的类型                                                         |
-| 6   |  col_length   | INT          | 列 的长度              |
+| 6  |  col_length   | INT          | 列 的长度                                                         |
-| 7   | col_precision | INT          | 列 的精度              |
+| 7  | col_precision | INT          | 列 的精度                                                         |
-| 8   |   col_scale   | INT          | 列 的比例              |
+| 8  |   col_scale   | INT          | 列 的比例                                                         |
-| 9   | col_nullable  | INT          | 列 是否可以为空        |
+| 9  | col_nullable  | INT          | 列 是否可以为空                                                      |
+| 10 |  col_source   | VARCHAR(322) | 列 的数据来源。只有虚拟表的列才会有该值，表示虚拟表的数据来源，为 db_name.table_name.col_name |
 
 ## INS_USERS
 

docs/zh/14-reference/03-taos-sql/34-virtualtable.md

@@ -0,0 +1,311 @@
+---
+sidebar_label: 虚拟表
+title: 虚拟表
+description: 对虚拟表的各种管理操作
+---
+## 创建虚拟表
+
+`CREATE VTABLE` 语句用于创建普通虚拟表和以虚拟超级表为模板创建虚拟子表。
+
+### 创建虚拟超级表
+
+见 [创建超级表](./04-stable.md#创建超级表) 中的 `VIRTUAL` 参数。
+
+### 创建虚拟普通表
+```sql
+CREATE VTABLE [IF NOT EXISTS] [db_name].vtb_name 
+    ts_col_name timestamp, 
+    (create_defination[ ,create_defination] ...) 
+     
+ create_definition:
+    vtb_col_name column_definition
+    
+column_definition:
+    type_name [FROM [db_name.]table_name.col_name]
+
+```
+
+### 创建虚拟子表
+```sql
+CREATE VTABLE [IF NOT EXISTS] [db_name].vtb_name 
+    (create_defination[ ,create_defination] ...) 
+    USING [db_name.]stb_name 
+    [(tag_name [, tag_name] ...)] 
+    TAGS (tag_value [, tag_value] ...)
+     
+ create_definition:
+    [stb_col_name FROM] [db_name.]table_name.col_name
+ tag_value:
+     const_value
+```
+
+**使用说明**
+
+1. 虚拟表（列）名命名规则参见 [名称命名规则](./19-limit.md#名称命名规则)。
+2. 表名最大长度为 192。
+3. 表的第一个字段必须是 TIMESTAMP，并且系统自动将其设为主键。
+4. 表的每行长度不能超过 64KB（注意：每个 VARCHAR/NCHAR/GEOMETRY 类型的列还会额外占用 2 个字节的存储位置）。
+5. 使用数据类型 VARCHAR/NCHAR/GEOMETRY，需指定其最长的字节数，如 VARCHAR(20)，表示 20 字节。
+6. 创建虚拟表时使用 FROM 来指定列的数据源，支持使用 db_name 跨库指定数据源，不指定 db_name 时默认使用当前 use 的数据库，若不指定 db_name 且未 use 数据库，则会报错。
+7. 创建虚拟表时不显式的指定 ts 列的数据源，ts 列的取值是查询虚拟表时查询语句中包含的所有列对应的原始表的主键时间戳合并的结果。
+8. 虚拟超级表下只支持创建虚拟子表，虚拟子表也只能以虚拟超级表为模版来创建。
+9. 创建虚拟表时需要保证虚拟表中的列、标签和指定的数据来源列、标签的数据类型相同，否则会报错。
+10. 在同一个数据库内，虚拟表名称不允许重名，虚拟表名和表名也不允许重名。虚拟表名和视图名允许重名（不推荐）当出现视图与虚拟表名重名时，写入、查询、授权、回收权限等操作优先使用同名表。
+11. 创建虚拟子表和虚拟普通表时，使用 FROM 指定某一列的数据来源时，该列只能来源于普通子表或普通表，不支持来源于超级表、视图或其他虚拟表。也不支持来源于有复合主键的表。
+
+## 查询虚拟表
+
+虚拟表与正常表无论是查询语法还是范围都没有区别，不同之处在于虚拟表所呈现的数据集在不同的查询中可能是不相同的，具体可以参考虚拟表数据生成规则。
+
+### 虚拟表数据生成规则
+
+1. 虚拟表以时间戳为基准，对多个原始表的数据进行对齐。
+2. 如果多个原始表在相同时间戳下有数据，则这些列的值组合成同一行；否则，对于缺失的列，填充 NULL。
+3. 虚拟表的时间戳的值是查询中包含的所有列所在的原始表的时间戳的并集，因此当不同查询选择列不同时可能出现结果集行数不一样的情况。
+4. 用户可以从多个表中选择任意列进行组合，未选择的列不会出现在虚拟表中。
+
+**示例**
+
+假设有表 t1, t2, t3 结构和数据如下：
+
+![virtual-table-origin-table.png](pic/virtual-table-origin-table.png)
+
+并且有虚拟普通表 v1 ，创建方式如下：
+
+```sql
+create vtable v1 (
+    ts timestamp,
+    c1 int from t1.value,
+    c2 int from t2.value,
+    c3 int from t3.value1,
+    c4 int from t3.value2);
+```
+
+那么根据虚拟表对于多表数据的整合规则，执行如下查询时：
+
+```sql
+select * from v1;
+```
+
+结果如下：
+
+![virtual-table-query-res.png](pic/virtual-table-query-res.png)
+
+如果没有选择全部列，只是选择了部分列，查询的结果只会包含选择的列的原始表的时间戳，例如执行如下查询：
+
+```sql
+select c1, c2 from v1;
+```
+
+得到的结果如下图所示：
+
+![virtual-table-query-res-part.png](pic/virtual-table-query-res-part.png)
+
+因为 c1, c2 列对应的原始表 t1, t2 中没有 0:00:03 这个时间戳，所以最后的结果也不会包含这个时间戳。
+
+**使用限制**
+
+1. 查询虚拟超级表时，暂不支持虚拟子表的数据源来自不同的数据库。
+
+## 修改虚拟普通表
+
+```sql
+ALTER VTABLE [db_name.]vtb_name alter_table_clause
+
+alter_table_clause: {
+  ADD COLUMN vtb_col_name vtb_column_type [FROM table_name.col_name]
+  | DROP COLUMN vtb_col_name
+  | ALTER COLUMN vtb_col_name SET {table_name.col_name | NULL }
+  | MODIFY COLUMN col_name column_type
+  | RENAME COLUMN old_col_name new_col_name
+}
+```
+
+**使用说明**
+对虚拟普通表可以进行如下修改操作
+
+1. ADD COLUMN：添加列。
+2. DROP COLUMN：删除列。
+3. MODIFY COLUMN：修改列定义，如果数据列的类型是可变长类型，那么可以使用此指令修改其宽度，只能改大，不能改小。如果虚拟表该列已指定数据源，那么修改列宽会因为修改后的列宽和数据源的列宽不匹配而报错，可以先将数据源置为空后再修改列宽。
+4. RENAME COLUMN：修改列名称。
+5. ALTER COLUMN .. SET：修改列的数据源。 SET NULL 表示将虚拟表某列的数据源置为空。
+
+### 增加列
+
+```sql
+ALTER VTABLE vtb_name ADD COLUMN vtb_col_name vtb_col_type [FROM [db_name].table_name.col_name]
+```
+
+### 删除列
+
+```sql
+ALTER VTABLE vtb_name DROP COLUMN vtb_col_name
+```
+
+### 修改列宽
+
+```sql
+ALTER VTABLE vtb_name MODIFY COLUMN vtb_col_name data_type(length);
+```
+
+### 修改列名
+
+```sql
+ALTER VTABLE vtb_name RENAME COLUMN old_col_name new_col_name
+```
+
+### 修改列的数据源
+
+```sql
+ALTER VTABLE vtb_name ALTER COLUMN vtb_col_name SET {[db_name.]table_name.col_name | NULL}
+```
+
+## 修改虚拟子表
+
+```sql
+ALTER VTABLE [db_name.]vtb_name alter_table_clause
+
+alter_table_clause: {
+  ALTER COLUMN vtb_col_name SET table_name.col_name
+  | SET TAG tag_name = new_tag_value
+}
+```
+
+**使用说明**
+
+1. 对虚拟子表的列和标签的修改，除了更改标签值以外，都要通过虚拟超级表才能进行。
+
+### 修改虚拟子表标签值
+
+```sql
+ALTER VTABLE tb_name SET TAG tag_name1=new_tag_value1, tag_name2=new_tag_value2 ...;
+```
+
+### 修改列的数据源
+
+```sql
+ALTER VTABLE vtb_name ALTER COLUMN vtb_col_name SET {[db_name.]table_name.col_name | NULL}
+```
+
+## 删除虚拟表
+
+```sql
+DROP VTABLE [IF EXISTS] [dbname].vtb_name;
+```
+
+## 查看虚拟表的信息
+
+### 显示某个数据库下所有虚拟表
+
+如下 SQL 语句可以列出当前数据库中的所有虚拟表名。
+
+```sql
+SHOW [NORMAL | CHILD] [db_name.]VTABLES [LIKE 'pattern'];
+```
+
+**使用说明**
+
+1. 如果没有指定 db_name, 显示当前数据库下的所有虚拟普通表和虚拟子表的信息。若没有使用数据库并且没有指定 db_name, 则会报错 database not specified。可以使用 LIKE 对表名进行模糊匹配。NORMAL 指定只显示虚拟普通表信息， CHILD 指定只显示虚拟子表信息。
+
+### 显示虚拟表创建语句
+
+```sql
+SHOW CREATE VTABLE [db_name.]vtable_name;
+```
+
+显示 vtable_name 指定的虚拟表的创建语句。支持虚拟普通表和虚拟子表。常用于数据库迁移。对一个已经存在的虚拟表，返回其创建语句；在另一个集群中执行该语句，就能得到一个结构完全相同的虚拟表。
+
+### 获取虚拟表结构信息
+
+```sql
+DESCRIBE [db_name.]vtb_name;
+```
+
+### 查看所有虚拟表信息
+
+```sql
+SELECT ... FROM information_schema.ins_tables where type = 'VIRTUAL_NORMAL_TABLE' or type = 'VIRTUAL_CHILD_TABLE';
+```
+
+## 写入虚拟表
+
+不支持向虚拟表中写入数据，以及不支持删除虚拟表中的数据。虚拟表只是对原始表进行运算后的计算结果，是一张逻辑表，因此只能对其进行查询，不可以写入或删除数据。
+
+
+## 虚拟表与视图
+
+虚拟表与视图看起来相似，但是有很多不同点：
+
+| 属性	         |虚拟表 (Virtual Table)	|视图 (View)|
+|----------------|------------------------|-----------|
+| 定义            |虚拟表是一种动态数据结构，根据多表的列和时间戳组合规则生成逻辑表。	|视图是一种基于 SQL 查询的虚拟化表结构，用于保存查询逻辑的定义。|
+| 数据来源	       |来自多个原始表，可以动态选择列，并通过时间戳对齐数据。	|来自单个或多个表的查询结果，通常是一个复杂的 SQL 查询。|
+| 数据存储	       |不实际存储数据，所有数据在查询时动态生成。	|不实际存储数据，仅保存 SQL 查询逻辑。|
+| 时间戳处理       |通过时间戳对齐将不同表的列整合到统一的时间轴上。|	不支持时间戳对齐，数据由查询逻辑直接决定。|
+| 更新机制	       |动态更新，原始表数据变更时，虚拟表数据实时反映变化。|	动态更新，但依赖于视图定义的查询逻辑，不涉及对齐或数据整合。|
+| 功能特性	       |支持空值填充和插值（如 prev、next、linear）。	|不支持内置填充和插值功能，需通过查询逻辑自行实现。|
+| 应用场景	       |时间序列对齐、跨表数据整合、多源数据对比分析等场景。|	简化复杂查询逻辑、限制用户访问、封装业务逻辑等场景。|
+| 性能            |由于多表对齐和空值处理，查询复杂度可能较高，尤其在数据量大时。|	性能通常取决于视图的查询语句复杂度，与单表查询性能相似。|
+
+不支持虚拟表和视图之间的相互转化，如根据虚拟表建立视图或者根据视图建立虚拟表。
+
+## 虚拟表的权限
+
+### 权限说明
+
+虚拟表的权限分为 READ、WRITE 两种，查询操作需要具备 READ 权限，对虚拟表本身的删除和修改操作需要具备 WRITE 权限。
+
+### 语法
+
+#### 授权
+
+```sql
+GRANT privileges ON [db_name.]vtable_name TO user_name
+privileges: {
+    ALL,
+  | priv_type [, priv_type] ...
+}
+priv_type: {
+    READ
+  | WRITE
+}
+```
+
+#### 回收权限
+
+```sql
+REVOKE privileges ON [db_name.]vtable_name FROM user_name
+privileges: {
+    ALL,
+  | priv_type [, priv_type] ...
+}
+priv_type: {
+    READ
+  | WRITE
+}
+```
+
+### 权限规则
+
+1. 虚拟表的创建者和 root 用户默认具备所有权限。
+2. 用户可以通过 dbname.vtbname 来为指定的虚拟表表（包括虚拟超级表和虚拟普通表）授予或回收其读写权限，不支持直接对虚拟子表授予或回收权限。
+3. 虚拟子表和虚拟超级表不支持基于标签的授权（表级授权），虚拟子表继承虚拟超级表的权限。
+4. 对其他用户进行授权与回收权限可以通过 GRANT 和 REVOKE 语句进行，该操作只能由 root 用户进行。
+5. 具体相关权限控制细则总结如下：
+
+| 序号 | 操作 | 权限要求                                                     |
+|------|------|----------------------------------------------------------|
+| 1 | CREATE VTABLE | 用户对虚拟表所属数据库有 WRITE 权限 且<br /> 用户对虚拟表的数据源对应的原始表有 READ 权限。 |
+| 2 | DROP/ALTER VTABLE | 用户对虚拟表有 WRITE 权限，若要指定某一列的数据源，需要同时对数据源对应的原始表有 READ 权限。    |
+| 3 |SHOW VTABLES | 无                                                        |
+| 4 | SHOW CREATE VTABLE | 无                                                        |
+| 5 | DESCRIBE VTABLE | 无                                                        |
+| 6 | 系统表查询 | 无                                                        |
+| 7 | SELECT FROM VTABLE | 操作用户对虚拟表有 READ 权限                                        |
+| 8 | GRANT/REVOKE | 只有 root 用户有权限                                            |
+
+## 使用场景
+
+| SQL 查询 | SQL 写入 | STMT 查询 | STMT 写入 | 订阅 | 流计算 |
+|---------|--------|---------|------|--------|---|
+| 支持     | 不支持    | 不支持     | 不支持 | 不支持 | 支持 |

docs/zh/14-reference/05-connector/10-cpp.mdx

@@ -680,7 +680,7 @@ TDengine 客户端驱动的版本号与 TDengine 服务端的版本号是一一
   - **接口说明**：清理运行环境，应用退出前应调用。
 
 - `int taos_options(TSDB_OPTION option, const void * arg, ...)`
-  - **接口说明**：设置客户端选项，支持区域设置（`TSDB_OPTION_LOCALE`）、字符集设置（`TSDB_OPTION_CHARSET`）、时区设置（`TSDB_OPTION_TIMEZONE`）、配置文件路径设置（`TSDB_OPTION_CONFIGDIR`）。区域设置、字符集、时区默认为操作系统当前设置。
+  - **接口说明**：设置客户端选项，支持区域设置（`TSDB_OPTION_LOCALE`）、字符集设置（`TSDB_OPTION_CHARSET`）、时区设置（`TSDB_OPTION_TIMEZONE`）、配置文件路径设置（`TSDB_OPTION_CONFIGDIR`）、驱动类型设置（`TSDB_OPTION_DRIVER`）。区域设置、字符集、时区默认为操作系统当前设置。驱动类型可选内部原生接口（`native`）和 WebSocket 接口（`websocket`），默认为 `websocket`。
   - **参数说明**：
     - `option`：[入参] 设置项类型。
     - `arg`：[入参] 设置项值。

docs/zh/14-reference/09-error-code.md

@@ -44,6 +44,8 @@ description: TDengine 服务端的错误码列表和详细说明
 | 0x80000107 | Ref ID is removed                 | 引用的 ref 资源已经释放               | 保留现场和日志，github 上报 issue |
 | 0x80000108 | Invalid Ref ID                    | 无效 ref ID                        | 保留现场和日志，github 上报 issue |
 | 0x8000010A | Ref is not there                  | ref 信息不存在                     | 保留现场和日志，github 上报 issue |
+| 0x8000010B | Driver was not loaded                   | 未在系统路径中找到 libtaosnative.so 或 libtaosws.so                      | 重新安装客户端驱动 |
+| 0x8000010C | Function was not loaded from the driver | 在 libtaos.so 中定义的一些函数在 libtaosnative.so 或 libtaosws.so 中未实现 | 保留现场和日志，github 上报 issue |
 | 0x80000110 | Unexpected generic error          | 系统内部错误                       | 保留现场和日志，github 上报 issue |
 | 0x80000111 | Action in progress                | 操作进行中                         | 1.等待操作完成 2.根据需要取消操作 3.当超出合理时间仍然未完成可保留现场和日志，或联系客户支持 |
 | 0x80000112 | Out of range                      | 配置参数超出允许值范围                 | 更改参数                                                                                                                                           |
@@ -589,3 +591,17 @@ description: TDengine 服务端的错误码列表和详细说明
 | 0x80006206 | Virtual table not support in Topic                      | 不支持在订阅中使用虚拟表                                   | 不在订阅中使用虚拟表              |
 | 0x80006207 | Virtual super table query not support origin table from different databases                      | 虚拟超级表不支持子表的数据源来自不同的数据库                         | 确保虚拟超级表的子表的数据源都来自同一个数据库 |
 
+
+## TDgpt
+
+| 错误码     | 错误描述              | 可能的出错场景或者可能的原因                                                     | 建议用户采取的措施             |
+| ---------- | --------------------- | -------------------------------------------------------------------------------- | ------------------------------ |
+| 0x80000440 | Analysis service response is NULL | 分析服务返回错误                                                   | 检查服务端日志确认返回信息是否正确 |
+| 0x80000441 | Analysis service can't access     | 分析服务无法使用 |  检查 anoded 服务是否可用        |
+| 0x80000442 | Analysis algorithm is missing     | 未指定分析算法名称     |   增加算法名称        |
+| 0x80000443 | Analysis algorithm not loaded | 指定算法未加载   |   指定算法未加载   |
+| 0x80000444 | Analysis invalid buffer type  | 缓存数据格式不对  | 具体查看server端的错误日志     |
+| 0x80000445 | Analysis failed since anode return error            | anode 返回错误信息  | 请检查服务端日志确认问题原因     |
+| 0x80000446 | Analysis failed since too many input rows for anode | 输入数据太多   | 减小分析数据输入规模     |
+| 0x80000447 | white-noise data not processed                      | 白噪声数据不分析   |    |
+| 0x80000448 | Analysis internal error, not processed                 | anode 出现内部错误   | 具体查看server端的日志 (taosanode.app.log)   |

examples/c/CMakeLists.txt

@@ -42,27 +42,27 @@ IF(TD_LINUX)
   )
 
   target_link_libraries(tmq
-    ${TAOS_LIB}
+    ${TAOS_NATIVE_LIB}
   )
 
   target_link_libraries(stream_demo
-    ${TAOS_LIB}
+    ${TAOS_NATIVE_LIB}
   )
 
   target_link_libraries(schemaless
-    ${TAOS_LIB}
+    ${TAOS_NATIVE_LIB}
   )
 
   target_link_libraries(prepare
-    ${TAOS_LIB}
+    ${TAOS_NATIVE_LIB}
   )
 
   target_link_libraries(demo
-    ${TAOS_LIB}
+    ${TAOS_NATIVE_LIB}
   )
 
   target_link_libraries(asyncdemo
-    ${TAOS_LIB}
+    ${TAOS_NATIVE_LIB}
   )
 
   SET_TARGET_PROPERTIES(tmq PROPERTIES OUTPUT_NAME tmq)

include/client/taos.h

@@ -62,6 +62,7 @@ typedef enum {
   TSDB_OPTION_CONFIGDIR,
   TSDB_OPTION_SHELL_ACTIVITY_TIMER,
   TSDB_OPTION_USE_ADAPTER,
+  TSDB_OPTION_DRIVER,
   TSDB_MAX_OPTIONS
 } TSDB_OPTION;
 
@@ -155,11 +156,14 @@ typedef enum {
   TAOS_NOTIFY_USER_DROPPED = 2,
 } TAOS_NOTIFY_TYPE;
 
+/* -- implemented in the native interface, for internal component only, the API may change -- */
 #define RET_MSG_LENGTH 1024
 typedef struct setConfRet {
   SET_CONF_RET_CODE retCode;
   char              retMsg[RET_MSG_LENGTH];
 } setConfRet;
+DLL_EXPORT setConfRet taos_set_config(const char *config);  // implemented in the native interface
+/* -- end -- */
 
 typedef struct TAOS_VGROUP_HASH_INFO {
   int32_t  vgId;
@@ -182,14 +186,13 @@ typedef struct TAOS_STMT_OPTIONS {
   bool    singleTableBindOnce;
 } TAOS_STMT_OPTIONS;
 
-DLL_EXPORT void       taos_cleanup(void);
+DLL_EXPORT int   taos_init(void);
-DLL_EXPORT int        taos_options(TSDB_OPTION option, const void *arg, ...);
+DLL_EXPORT void  taos_cleanup(void);
-DLL_EXPORT int        taos_options_connection(TAOS *taos, TSDB_OPTION_CONNECTION option, const void *arg, ...);
+DLL_EXPORT int   taos_options(TSDB_OPTION option, const void *arg, ...);
-DLL_EXPORT setConfRet taos_set_config(const char *config);
+DLL_EXPORT int   taos_options_connection(TAOS *taos, TSDB_OPTION_CONNECTION option, const void *arg, ...);
-DLL_EXPORT int        taos_init(void);
+DLL_EXPORT TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);
-DLL_EXPORT TAOS      *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);
+DLL_EXPORT TAOS *taos_connect_auth(const char *ip, const char *user, const char *auth, const char *db, uint16_t port);
-DLL_EXPORT TAOS      *taos_connect_auth(const char *ip, const char *user, const char *auth, const char *db, uint16_t port);
+DLL_EXPORT void  taos_close(TAOS *taos);
-DLL_EXPORT void       taos_close(TAOS *taos);
 
 DLL_EXPORT const char *taos_data_type(int type);
 
@@ -220,6 +223,7 @@ DLL_EXPORT char     *taos_stmt_errstr(TAOS_STMT *stmt);
 DLL_EXPORT int       taos_stmt_affected_rows(TAOS_STMT *stmt);
 DLL_EXPORT int       taos_stmt_affected_rows_once(TAOS_STMT *stmt);
 
+/* -- implemented in the native interface, for internal component only, the API may change -- */
 typedef void TAOS_STMT2;
 
 typedef struct TAOS_STMT2_OPTION {
@@ -257,6 +261,7 @@ DLL_EXPORT int taos_stmt2_get_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_AL
 DLL_EXPORT void      taos_stmt2_free_fields(TAOS_STMT2 *stmt, TAOS_FIELD_ALL *fields);
 DLL_EXPORT TAOS_RES *taos_stmt2_result(TAOS_STMT2 *stmt);
 DLL_EXPORT char     *taos_stmt2_error(TAOS_STMT2 *stmt);
+/* -- end -- */
 
 DLL_EXPORT TAOS_RES *taos_query(TAOS *taos, const char *sql);
 DLL_EXPORT TAOS_RES *taos_query_with_reqid(TAOS *taos, const char *sql, int64_t reqId);
@@ -313,9 +318,11 @@ DLL_EXPORT void taos_set_hb_quit(int8_t quitByKill);
 
 DLL_EXPORT int taos_set_notify_cb(TAOS *taos, __taos_notify_fn_t fp, void *param, int type);
 
+/* -- implemented in the native interface, for internal component only, the API may change -- */
 typedef void (*__taos_async_whitelist_fn_t)(void *param, int code, TAOS *taos, int numOfWhiteLists,
                                             uint64_t *pWhiteLists);
 DLL_EXPORT void taos_fetch_whitelist_a(TAOS *taos, __taos_async_whitelist_fn_t fp, void *param);
+/* ---- end ---- */
 
 typedef enum {
   TAOS_CONN_MODE_BI = 0,
@@ -414,7 +421,7 @@ DLL_EXPORT int32_t     tmq_get_vgroup_id(TAOS_RES *res);
 DLL_EXPORT int64_t     tmq_get_vgroup_offset(TAOS_RES *res);
 DLL_EXPORT const char *tmq_err2str(int32_t code);
 
-/* ------------------------------ TAOSX INTERFACE -----------------------------------*/
+/* -- implemented in the native interface, for internal component(TAOSX) only, the API may change -- */
 typedef struct tmq_raw_data {
   void    *raw;
   uint32_t raw_len;
@@ -435,8 +442,9 @@ DLL_EXPORT void    tmq_free_raw(tmq_raw_data raw);
 // Returning null means error. Returned result need to be freed by tmq_free_json_meta
 DLL_EXPORT char *tmq_get_json_meta(TAOS_RES *res);
 DLL_EXPORT void  tmq_free_json_meta(char *jsonMeta);
-/* ---------------------------- TAOSX END -------------------------------- */
+/* ---- end ---- */
 
+/* -- implemented in the native interface, for internal component only, the API may change -- */
 typedef enum {
   TSDB_SRV_STATUS_UNAVAILABLE = 0,
   TSDB_SRV_STATUS_NETWORK_OK = 1,
@@ -446,7 +454,10 @@ typedef enum {
 } TSDB_SERVER_STATUS;
 
 DLL_EXPORT TSDB_SERVER_STATUS taos_check_server_status(const char *fqdn, int port, char *details, int maxlen);
+DLL_EXPORT void               taos_write_crashinfo(int signum, void *sigInfo, void *context);
 DLL_EXPORT char              *getBuildInfo();
+/* ---- end ---- */
+
 #ifdef __cplusplus
 }
 #endif

include/os/os.h

@@ -54,6 +54,7 @@ extern "C" {
 #include <sys/wait.h>
 
 #if defined(DARWIN)
+#include <pwd.h>
 #else
 #if !defined(TD_ASTRA)
 #include <argp.h>

include/os/osDir.h

@@ -112,7 +112,9 @@ bool          taosDirEntryIsDir(TdDirEntryPtr pDirEntry);
 char         *taosGetDirEntryName(TdDirEntryPtr pDirEntry);
 int32_t       taosCloseDir(TdDirPtr *ppDir);
 
-int taosGetDirSize(const char *path, int64_t *size);
+int32_t taosAppPath(char *path, int32_t maxLen);
+int32_t taosGetDirSize(const char *path, int64_t *size);
+
 #ifdef __cplusplus
 }
 #endif

include/os/osSystem.h

@@ -46,10 +46,12 @@ int32_t taosEOFCmd(TdCmdPtr pCmd);
 
 void    taosCloseCmd(TdCmdPtr *ppCmd);
 
-void *taosLoadDll(const char *filename);
+void *taosLoadDll(const char *fileName);
 
 void taosCloseDll(void *handle);
 
+void *taosLoadDllFunc(void *handle, const char *funcName);
+
 int32_t taosSetConsoleEcho(bool on);
 
 int32_t taosSetTerminalMode();

include/util/taoserror.h

@@ -117,6 +117,8 @@ int32_t  taosGetErrSize();
 #define TSDB_CODE_REF_INVALID_ID                TAOS_DEF_ERROR_CODE(0, 0x0108) // internal
 #define TSDB_CODE_REF_ALREADY_EXIST             TAOS_DEF_ERROR_CODE(0, 0x0109) // internal
 #define TSDB_CODE_REF_NOT_EXIST                 TAOS_DEF_ERROR_CODE(0, 0x010A) // internal
+#define TSDB_CODE_DLL_NOT_LOAD                  TAOS_DEF_ERROR_CODE(0, 0x010B) 
+#define TSDB_CODE_DLL_FUNC_NOT_LOAD             TAOS_DEF_ERROR_CODE(0, 0x010C)
 
 #define TSDB_CODE_APP_ERROR                     TAOS_DEF_ERROR_CODE(0, 0x0110) //
 #define TSDB_CODE_ACTION_IN_PROGRESS            TAOS_DEF_ERROR_CODE(0, 0x0111) // internal

packaging/check_package.sh

@@ -152,10 +152,14 @@ function check_lib_path() {
     # check all links
     check_link ${lib_link_dir}/libtaos.so
     check_link ${lib_link_dir}/libtaos.so.1
+    check_link ${lib_link_dir}/libtaosnative.so
+    check_link ${lib_link_dir}/libtaosnative.so.1
 
     if [[ -d ${lib64_link_dir}  ]]; then
         check_link ${lib64_link_dir}/libtaos.so
         check_link ${lib64_link_dir}/libtaos.so.1
+        check_link ${lib64_link_dir}/libtaosnative.so
+        check_link ${lib64_link_dir}/libtaosnative.so.1
     fi
     echo -e "Check lib  path:\033[32mOK\033[0m!"
 }

packaging/deb/DEBIAN/preinst

@@ -80,4 +80,5 @@ 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/libtaosnative.*   || :
 [ -f ${install_main_dir}/driver/libtaosws.so ] && ${csudo}rm -f ${install_main_dir}/driver/libtaosws.so   || :

packaging/deb/DEBIAN/prerm

@@ -44,6 +44,8 @@ else
     ${csudo}rm -f ${inc_link_dir}/taosws.h     || :    
     ${csudo}rm -f ${lib_link_dir}/libtaos.*  || :
     ${csudo}rm -f ${lib64_link_dir}/libtaos.*  || :
+    ${csudo}rm -f ${lib_link_dir}/libtaosnative.*  || :
+    ${csudo}rm -f ${lib64_link_dir}/libtaosnative.*  || :
     ${csudo}rm -f ${lib_link_dir}/libtaosws.so  || :
     ${csudo}rm -f ${lib64_link_dir}/libtaosws.so  || : 
 

packaging/deb/makedeb.sh

@@ -31,6 +31,7 @@ mkdir -p ${pkg_dir}
 cd ${pkg_dir}
 
 libfile="libtaos.so.${tdengine_ver}"
+nativelibfile="libtaosnative.so.${tdengine_ver}"
 wslibfile="libtaosws.so"
 
 # create install dir
@@ -120,11 +121,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/${nativelibfile}        ${pkg_dir}${install_home_path}/driver
 [ -f ${compile_dir}/build/lib/${wslibfile} ] && 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/util/tdef.h       ${pkg_dir}${install_home_path}/include
+cp ${compile_dir}/../include/util/tdef.h            ${pkg_dir}${install_home_path}/include
 cp ${compile_dir}/../include/libs/function/taosudf.h       ${pkg_dir}${install_home_path}/include
 [ -f ${compile_dir}/build/include/taosws.h ] && cp ${compile_dir}/build/include/taosws.h            ${pkg_dir}${install_home_path}/include ||:
 cp -r ${top_dir}/examples/*                         ${pkg_dir}${install_home_path}/examples

packaging/rpm/tdengine.spec

@@ -44,6 +44,7 @@ echo version: %{_version}
 echo buildroot: %{buildroot}
 
 libfile="libtaos.so.%{_version}"
+nativelibfile="libtaosnative.so.%{_version}"
 wslibfile="libtaosws.so"
 
 # create install path, and cp file
@@ -112,11 +113,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/${nativelibfile}        %{buildroot}%{homepath}/driver
 [ -f %{_compiledir}/build/lib/${wslibfile} ] && 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/util/tdef.h       %{buildroot}%{homepath}/include
+cp %{_compiledir}/../include/util/tdef.h            %{buildroot}%{homepath}/include
 cp %{_compiledir}/../include/libs/function/taosudf.h       %{buildroot}%{homepath}/include
 [ -f %{_compiledir}/build/include/taosws.h ] && cp %{_compiledir}/build/include/taosws.h            %{buildroot}%{homepath}/include ||:
 #cp -r %{_compiledir}/../src/connector/python        %{buildroot}%{homepath}/connector
@@ -246,6 +248,8 @@ if [ $1 -eq 0 ];then
     ${csudo}rm -f ${inc_link_dir}/taosudf.h     || :  
     ${csudo}rm -f ${inc_link_dir}/taows.h     || :    
     ${csudo}rm -f ${lib_link_dir}/libtaos.so  || :
+    ${csudo}rm -f ${lib_link_dir}/libtaosnative.so  || :
+    ${csudo}rm -f ${lib64_link_dir}/libtaosnative.so  || :
     ${csudo}rm -f ${lib_link_dir}/libtaosws.so  || :
     ${csudo}rm -f ${lib64_link_dir}/libtaosws.so  || :
 

packaging/tools/install.sh

@@ -271,19 +271,29 @@ function install_lib() {
   # Remove links
   ${csudo}rm -f ${lib_link_dir}/libtaos.* || :
   ${csudo}rm -f ${lib64_link_dir}/libtaos.* || :
+  ${csudo}rm -f ${lib_link_dir}/libtaosnative.* || :
+  ${csudo}rm -f ${lib64_link_dir}/libtaosnative.* || :
+  ${csudo}rm -f ${lib_link_dir}/libtaosws.* || :
+  ${csudo}rm -f ${lib64_link_dir}/libtaosws.* || :
   #${csudo}rm -rf ${v15_java_app_dir}              || :
   ${csudo}cp -rf ${script_dir}/driver/* ${install_main_dir}/driver && ${csudo}chmod 777 ${install_main_dir}/driver/*
 
+  #link lib/link_dir
   ${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
+  ${csudo}ln -sf ${install_main_dir}/driver/libtaosnative.* ${lib_link_dir}/libtaosnative.so.1
+  ${csudo}ln -sf ${lib_link_dir}/libtaosnative.so.1 ${lib_link_dir}/libtaosnative.so
 
   [ -f ${install_main_dir}/driver/libtaosws.so ] && ${csudo}ln -sf ${install_main_dir}/driver/libtaosws.so ${lib_link_dir}/libtaosws.so || :
 
+  #link lib64/link_dir
   if [[ -d ${lib64_link_dir} && ! -e ${lib64_link_dir}/libtaos.so ]]; then
     ${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 ${install_main_dir}/driver/libtaosnative.* ${lib64_link_dir}/libtaosnative.so.1 || :
+    ${csudo}ln -sf ${lib64_link_dir}/libtaosnative.so.1 ${lib64_link_dir}/libtaosnative.so || :
 
-    [ -f ${install_main_dir}/libtaosws.so ] && ${csudo}ln -sf ${install_main_dir}/libtaosws.so ${lib64_link_dir}/libtaosws.so || :
+    [ -f ${install_main_dir}/driver/libtaosws.so ] && ${csudo}ln -sf ${install_main_dir}/driver/libtaosws.so ${lib64_link_dir}/libtaosws.so || :
   fi
 
   ${csudo}ldconfig

packaging/tools/install_client.sh

@@ -134,6 +134,7 @@ function install_bin() {
 
 function clean_lib() {
     sudo rm -f /usr/lib/libtaos.* || :
+    sudo rm -f /usr/lib/libtaosnative.* || :
     [ -f /usr/lib/libtaosws.so ] && sudo rm -f /usr/lib/libtaosws.so || :
     [ -f /usr/lib64/libtaosws.so ] && sudo rm -f /usr/lib64/libtaosws.so || :
     sudo rm -rf ${lib_dir} || :
@@ -143,6 +144,8 @@ function install_lib() {
     # Remove links
     ${csudo}rm -f ${lib_link_dir}/libtaos.*         || :
     ${csudo}rm -f ${lib64_link_dir}/libtaos.*       || :
+    ${csudo}rm -f ${lib_link_dir}/libtaosnative.*   || :
+    ${csudo}rm -f ${lib64_link_dir}/libtaosnative.* || :
 
     [ -f ${lib_link_dir}/libtaosws.so ] && ${csudo}rm -f ${lib_link_dir}/libtaosws.so         || :
     [ -f ${lib64_link_dir}/libtaosws.so ] && ${csudo}rm -f ${lib64_link_dir}/libtaosws.so         || :
@@ -154,18 +157,24 @@ function install_lib() {
     if [ "$osType" != "Darwin" ]; then
         ${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 ${install_main_dir}/driver/libtaosnative.* ${lib_link_dir}/libtaosnative.so.1
+        ${csudo}ln -s ${lib_link_dir}/libtaosnative.so.1 ${lib_link_dir}/libtaosnative.so
 
         [ -f ${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 -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 ${install_main_dir}/driver/libtaosnative.* ${lib64_link_dir}/libtaosnative.so.1       || :
+            ${csudo}ln -s ${lib64_link_dir}/libtaosnative.so.1 ${lib64_link_dir}/libtaosnative.so               || :
 
             [ -f ${install_main_dir}/driver/libtaosws.so ] && ${csudo}ln -sf ${install_main_dir}/driver/libtaosws.so ${lib64_link_dir}/libtaosws.so       || :
         fi
     else
         ${csudo}ln -s ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.1.dylib
         ${csudo}ln -s ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib
+        ${csudo}ln -s ${install_main_dir}/driver/libtaosnative.* ${lib_link_dir}/libtaosnative.1.dylib
+        ${csudo}ln -s ${lib_link_dir}/libtaosnative.1.dylib ${lib_link_dir}/libtaosnative.dylib
 
         [ -f ${install_main_dir}/driver/libtaosws.dylib ] && ${csudo}ln -sf ${install_main_dir}/driver/libtaosws.dylib ${lib_link_dir}/libtaosws.dylib ||:
     fi
@@ -178,7 +187,7 @@ function install_lib() {
 }
 
 function install_header() {
-    ${csudo}rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taosdef.h ${inc_link_dir}/tdef.h ${inc_link_dir}/taoserror.h  ${inc_link_dir}/taosudf.h  || :
+    ${csudo}rm -f ${inc_link_dir}/taos.h ${inc_link_dir}/taosws.h ${inc_link_dir}/taosdef.h ${inc_link_dir}/tdef.h ${inc_link_dir}/taoserror.h  ${inc_link_dir}/taosudf.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

packaging/tools/make_install.bat

@@ -66,6 +66,9 @@ copy %source_dir%\\include\\libs\\function\\taosudf.h %target_dir%\\include > nu
 copy %binary_dir%\\build\\lib\\taos.lib %target_dir%\\driver > nul
 copy %binary_dir%\\build\\lib\\taos_static.lib %target_dir%\\driver > nul
 copy %binary_dir%\\build\\lib\\taos.dll %target_dir%\\driver > nul
+copy %binary_dir%\\build\\lib\\taosnative.lib %target_dir%\\driver > nul
+copy %binary_dir%\\build\\lib\\taosnative_static.lib %target_dir%\\driver > nul
+copy %binary_dir%\\build\\lib\\taosnative.dll %target_dir%\\driver > nul
 copy %binary_dir%\\build\\bin\\taos.exe %target_dir% > nul
 if exist %binary_dir%\\build\\bin\\taosBenchmark.exe (
     copy %binary_dir%\\build\\bin\\taosBenchmark.exe %target_dir% > nul
@@ -149,12 +152,14 @@ call :check_svc taoskeeper
 if exist c:\\windows\\sysnative (
     echo x86
     copy /y C:\\TDengine\\driver\\taos.dll %windir%\\sysnative > nul
+    copy /y C:\\TDengine\\driver\\taosnative.dll %windir%\\sysnative > nul
     if exist C:\\TDengine\\driver\\taosws.dll (
         copy /y C:\\TDengine\\driver\\taosws.dll %windir%\\sysnative > nul
     )
 ) else (
     echo x64
     copy /y C:\\TDengine\\driver\\taos.dll C:\\Windows\\System32 > nul
+    copy /y C:\\TDengine\\driver\\taosnative.dll C:\\Windows\\System32 > nul
     if exist C:\\TDengine\\driver\\taosws.dll (
         copy /y C:\\TDengine\\driver\\taosws.dll C:\\Windows\\System32 > nul
     )

packaging/tools/make_install.sh

@@ -312,18 +312,46 @@ function install_avro() {
 
 function install_lib() {
   # Remove links
-  ${csudo}rm -f ${lib_link_dir}/libtaos.* || :
+  remove_links() {
-  [ -f ${lib_link_dir}/libtaosws.so ] && ${csudo}rm -f ${lib_link_dir}/libtaosws.so || :
+    local dir=$1
+    find ${dir} -name "libtaos.*" -exec ${csudo}rm -f {} \; || :
+    find ${dir} -name "libtaosnative.so" -exec ${csudo}rm -f {} \; || :
+    find ${dir} -name "libtaosws.so" -exec ${csudo}rm -f {} \; || :
+  }
+
+  remove_links ${lib_link_dir}
+
   if [ "$osType" != "Darwin" ]; then
-    ${csudo}rm -f ${lib64_link_dir}/libtaos.* || :
+    remove_links ${lib64_link_dir}
-    [ -f ${lib64_link_dir}/libtaosws.so ] && ${csudo}rm -f ${lib64_link_dir}/libtaosws.so || :
   fi
 
+  # Copy and set permissions for libraries
+  copy_and_set_permissions() {
+    local src=$1
+    local dest=$2
+    if [ "$osType" != "Darwin" ]; then
+      ${csudo}cp ${src} ${dest} && ${csudo}chmod 777 ${dest}
+    else
+      ${csudo}cp -Rf ${src} ${dest} && ${csudo}chmod 777 ${dest}
+    fi
+  }
+
+  # Create symbolic links
+  create_symlink() {
+    local target=$1
+    local link_name=$2
+    ${csudo}ln -sf ${target} ${link_name}
+  }
+
   if [ "$osType" != "Darwin" ]; then
     ${csudo}cp ${binary_dir}/build/lib/libtaos.so.${verNumber} \
       ${install_main_dir}/driver &&
       ${csudo}chmod 777 ${install_main_dir}/driver/libtaos.so.${verNumber}
 
+    ${csudo}cp ${binary_dir}/build/lib/libtaosnative.so.${verNumber} \
+      ${install_main_dir}/driver &&
+      ${csudo}chmod 777 ${install_main_dir}/driver/libtaosnative.so.${verNumber}  
+
     ${csudo}ln -sf ${install_main_dir}/driver/libtaos.* ${lib_link_dir}/libtaos.so.1 > /dev/null 2>&1
     ${csudo}ln -sf ${lib_link_dir}/libtaos.so.1 ${lib_link_dir}/libtaos.so > /dev/null 2>&1
     if [ -d "${lib64_link_dir}" ]; then
@@ -331,6 +359,13 @@ function install_lib() {
         ${csudo}ln -sf ${lib64_link_dir}/libtaos.so.1 ${lib64_link_dir}/libtaos.so > /dev/null 2>&1
     fi
 
+    ${csudo}ln -sf ${install_main_dir}/driver/libtaosnative.* ${lib_link_dir}/libtaosnative.so.1 > /dev/null 2>&1
+     ${csudo}ln -sf ${lib_link_dir}/libtaosnative.so.1 ${lib_link_dir}/libtaosnative.so > /dev/null 2>&1
+    if [ -d "${lib64_link_dir}" ]; then
+        ${csudo}ln -sf ${install_main_dir}/driver/libtaosnative.* ${lib64_link_dir}/libtaosnative.so.1 > /dev/null 2>&1
+        ${csudo}ln -sf ${lib64_link_dir}/libtaosnative.so.1 ${lib64_link_dir}/libtaosnative.so > /dev/null 2>&1
+    fi
+
     if [ -f ${binary_dir}/build/lib/libtaosws.so ]; then
         ${csudo}cp ${binary_dir}/build/lib/libtaosws.so \
             ${install_main_dir}/driver &&
@@ -342,11 +377,19 @@ function install_lib() {
     ${csudo}cp -Rf ${binary_dir}/build/lib/libtaos.${verNumber}.dylib \
       ${install_main_dir}/driver && ${csudo}chmod 777 ${install_main_dir}/driver/*
 
+    ${csudo}cp -Rf ${binary_dir}/build/lib/libtaosnative.${verNumber}.dylib \
+      ${install_main_dir}/driver && ${csudo}chmod 777 ${install_main_dir}/driver/*
+
     ${csudo}ln -sf ${install_main_dir}/driver/libtaos.${verNumber}.dylib \
       ${lib_link_dir}/libtaos.1.dylib > /dev/null 2>&1 || :
 
+    ${csudo}ln -sf ${install_main_dir}/driver/libtaosnative.${verNumber}.dylib \
+      ${lib_link_dir}/libtaosnative.1.dylib > /dev/null 2>&1 || :  
+
     ${csudo}ln -sf ${lib_link_dir}/libtaos.1.dylib ${lib_link_dir}/libtaos.dylib > /dev/null 2>&1 || :
 
+    ${csudo}ln -sf ${lib_link_dir}/libtaosnative.1.dylib ${lib_link_dir}/libtaosnative.dylib > /dev/null 2>&1 || :
+
     if [ -f ${binary_dir}/build/lib/libtaosws.dylib ]; then
         ${csudo}cp ${binary_dir}/build/lib/libtaosws.dylib \
             ${install_main_dir}/driver &&

packaging/tools/makeclient.sh

@@ -79,10 +79,12 @@ if [ "$osType" != "Darwin" ]; then
         ${script_dir}/get_client.sh"
   fi
   lib_files="${build_dir}/lib/libtaos.so.${version}"
+  nativelib_files="${build_dir}/lib/libtaosnative.so.${version}"
   wslib_files="${build_dir}/lib/libtaosws.so"
 else
   bin_files="${build_dir}/bin/${clientName} ${script_dir}/remove_client.sh"
   lib_files="${build_dir}/lib/libtaos.${version}.dylib"
+  nativelib_files="${build_dir}/lib/libtaosnative.${version}.dylib"
   wslib_files="${build_dir}/lib/libtaosws.dylib"
 fi
 
@@ -224,6 +226,7 @@ fi
 # Copy driver
 mkdir -p ${install_dir}/driver
 cp ${lib_files} ${install_dir}/driver
+cp ${nativelib_files} ${install_dir}/driver
 
 # Copy connector
 connector_dir="${code_dir}/connector"

packaging/tools/makepkg.sh

@@ -108,9 +108,11 @@ fi
 
 if [ "$osType" == "Darwin" ]; then
     lib_files="${build_dir}/lib/libtaos.${version}.dylib"
+    nativelib_files="${build_dir}/lib/libtaosnative.${version}.dylib"
     wslib_files="${build_dir}/lib/libtaosws.dylib"
 else
     lib_files="${build_dir}/lib/libtaos.so.${version}"
+    nativelib_files="${build_dir}/lib/libtaosnative.so.${version}"
     wslib_files="${build_dir}/lib/libtaosws.so"
 fi
 header_files="${code_dir}/include/client/taos.h ${code_dir}/include/common/taosdef.h ${code_dir}/include/util/taoserror.h ${code_dir}/include/util/tdef.h ${code_dir}/include/libs/function/taosudf.h"
@@ -332,7 +334,7 @@ if [[ $dbName == "taos" ]]; then
 fi
 
 # Copy driver
-mkdir -p ${install_dir}/driver && cp ${lib_files} ${install_dir}/driver && echo "${versionComp}" >${install_dir}/driver/vercomp.txt
+mkdir -p ${install_dir}/driver && cp ${lib_files} ${install_dir}/driver && cp ${nativelib_files} ${install_dir}/driver && echo "${versionComp}" >${install_dir}/driver/vercomp.txt
 [ -f ${wslib_files} ] && cp ${wslib_files} ${install_dir}/driver || :
 
 # Copy connector && taosx

packaging/tools/post.sh

@@ -205,18 +205,24 @@ function install_lib() {
     log_print "start install lib from ${lib_dir} to ${lib_link_dir}"
     ${csudo}rm -f ${lib_link_dir}/libtaos* || :
     ${csudo}rm -f ${lib64_link_dir}/libtaos* || :
+    ${csudo}rm -f ${lib_link_dir}/libtaosnative* || :
+    ${csudo}rm -f ${lib64_link_dir}/libtaosnative* || :
 
     [ -f ${lib_link_dir}/libtaosws.${lib_file_ext} ] && ${csudo}rm -f ${lib_link_dir}/libtaosws.${lib_file_ext} || :
     [ -f ${lib64_link_dir}/libtaosws.${lib_file_ext} ] && ${csudo}rm -f ${lib64_link_dir}/libtaosws.${lib_file_ext} || :
 
     ${csudo}ln -s ${lib_dir}/libtaos.* ${lib_link_dir}/libtaos.${lib_file_ext_1} 2>>${install_log_path} || return 1
     ${csudo}ln -s ${lib_link_dir}/libtaos.${lib_file_ext_1} ${lib_link_dir}/libtaos.${lib_file_ext} 2>>${install_log_path} || return 1
+    ${csudo}ln -s ${lib_dir}/libtaosnative.* ${lib_link_dir}/libtaosnative.${lib_file_ext_1} 2>>${install_log_path} || return 1
+    ${csudo}ln -s ${lib_link_dir}/libtaosnative.${lib_file_ext_1} ${lib_link_dir}/libtaosnative.${lib_file_ext} 2>>${install_log_path} || return 1
 
     [ -f ${lib_dir}/libtaosws.${lib_file_ext} ] && ${csudo}ln -sf ${lib_dir}/libtaosws.${lib_file_ext} ${lib_link_dir}/libtaosws.${lib_file_ext} ||:
 
     if [[ -d ${lib64_link_dir} && ! -e ${lib64_link_dir}/libtaos.${lib_file_ext} ]]; then
       ${csudo}ln -s ${lib_dir}/libtaos.* ${lib64_link_dir}/libtaos.${lib_file_ext_1} 2>>${install_log_path} || return 1
       ${csudo}ln -s ${lib64_link_dir}/libtaos.${lib_file_ext_1} ${lib64_link_dir}/libtaos.${lib_file_ext}  2>>${install_log_path} || return 1
+      ${csudo}ln -s ${lib_dir}/libtaosnative.* ${lib64_link_dir}/libtaosnative.${lib_file_ext_1} 2>>${install_log_path} || return 1
+      ${csudo}ln -s ${lib64_link_dir}/libtaosnative.${lib_file_ext_1} ${lib64_link_dir}/libtaosnative.${lib_file_ext}  2>>${install_log_path} || return 1
 
       [ -f ${lib_dir}/libtaosws.${lib_file_ext} ] && ${csudo}ln -sf ${lib_dir}/libtaosws.${lib_file_ext} ${lib64_link_dir}/libtaosws.${lib_file_ext} 2>>${install_log_path}
     fi

packaging/tools/preun.sh

@@ -168,8 +168,10 @@ ${csudo}rm -f ${inc_link_dir}/tdef.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}/libtaosnative.*   || :
 ${csudo}rm -f ${lib_link_dir}/libtaosws.so   || :
 ${csudo}rm -f ${lib64_link_dir}/libtaos.* || :
+${csudo}rm -f ${lib64_link_dir}/libtaosnative.* || :
 ${csudo}rm -f ${lib64_link_dir}/libtaosws.so || :
 
 ${csudo}rm -f ${log_link_dir}            || :

packaging/tools/remove.sh

@@ -179,11 +179,13 @@ remove_bin() {
 
 function clean_lib() {
   # Remove link
-  ${csudo}rm -f ${lib_link_dir}/libtaos.* || :
+  ${csudo}find ${lib_link_dir} -name "libtaos.*" -exec ${csudo}rm -f {} \; || :
-  [ -f ${lib_link_dir}/libtaosws.* ] && ${csudo}rm -f ${lib_link_dir}/libtaosws.* || :
+  ${csudo}find ${lib_link_dir} -name "libtaosnative.*" -exec ${csudo}rm -f {} \; || :
+  ${csudo}find ${lib_link_dir} -name "libtaosws.*" -exec ${csudo}rm -f {} \; || :
 
-  ${csudo}rm -f ${lib64_link_dir}/libtaos.* || :
+  ${csudo}find ${lib64_link_dir} -name "libtaos.*" -exec ${csudo}rm -f {} \; || :
-  [ -f ${lib64_link_dir}/libtaosws.* ] && ${csudo}rm -f ${lib64_link_dir}/libtaosws.* || :
+  ${csudo}find ${lib64_link_dir} -name "libtaosnative.*" -exec ${csudo}rm -f {} \; || :
+  ${csudo}find ${lib64_link_dir} -name "libtaosws.*" -exec ${csudo}rm -f {} \; || :
   #${csudo}rm -rf ${v15_java_app_dir}           || :
 }
 
@@ -336,4 +338,4 @@ fi
 command -v systemctl >/dev/null 2>&1 && ${csudo}systemctl daemon-reload >/dev/null 2>&1 || true 
 echo 
 echo "${productName} is removed successfully!"
-echo
+echo

packaging/tools/remove_client.sh

@@ -70,13 +70,16 @@ function clean_bin() {
 }
 
 function clean_lib() {
-  # Remove link
+    # Remove link
-  ${csudo}rm -f ${lib_link_dir}/libtaos.* || :
+    ${csudo}find ${lib_link_dir} -name "libtaos.*" -exec ${csudo}rm -f {} \; || :
-  [ -f ${lib_link_dir}/libtaosws.* ] && ${csudo}rm -f ${lib_link_dir}/libtaosws.* || :
+    ${csudo}find ${lib_link_dir} -name "libtaosnative.*" -exec ${csudo}rm -f {} \; || :
+    ${csudo}find ${lib_link_dir} -name "libtaosws.*" -exec ${csudo}rm -f {} \; || :
+
+    ${csudo}find ${lib64_link_dir} -name "libtaos.*" -exec ${csudo}rm -f {} \; || :
+    ${csudo}find ${lib64_link_dir} -name "libtaosnative.*" -exec ${csudo}rm -f {} \; || :
+    ${csudo}find ${lib64_link_dir} -name "libtaosws.*" -exec ${csudo}rm -f {} \; || :
+    #${csudo}rm -rf ${v15_java_app_dir}           || :
 
-  ${csudo}rm -f ${lib64_link_dir}/libtaos.* || :
-  [ -f ${lib64_link_dir}/libtaosws.* ] && ${csudo}rm -f ${lib64_link_dir}/libtaosws.* || :
-  #${csudo}rm -rf ${v15_java_app_dir}           || :
 }
 
 function clean_header() {

source/client/CMakeLists.txt

@@ -5,19 +5,19 @@ if(TD_ENTERPRISE)
 endif()
 
 if(TD_WINDOWS)
-    add_library(${TAOS_LIB} SHARED ${CLIENT_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/src/taos.rc.in)
+    add_library(${TAOS_NATIVE_LIB} SHARED ${CLIENT_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/src/taosnative.rc.in)
 else()
-    add_library(${TAOS_LIB} SHARED ${CLIENT_SRC})
+    add_library(${TAOS_NATIVE_LIB} SHARED ${CLIENT_SRC})
 endif()
 
 if(${TD_DARWIN})
-    target_compile_options(${TAOS_LIB} PRIVATE -Wno-error=deprecated-non-prototype)
+    target_compile_options(${TAOS_NATIVE_LIB} PRIVATE -Wno-error=deprecated-non-prototype)
 endif()
 
-INCLUDE_DIRECTORIES(jni)
+
 
 target_include_directories(
-    ${TAOS_LIB}
+    ${TAOS_NATIVE_LIB}
     PUBLIC "${TD_SOURCE_DIR}/include/client"
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
@@ -26,46 +26,38 @@ if(${TAOSD_INTEGRATED})
     set(TAOSD_MODULE "taosd")
 endif()
 target_link_libraries(
-    ${TAOS_LIB}
+    ${TAOS_NATIVE_LIB}
     INTERFACE api
     PRIVATE os util common transport monitor nodes parser command planner catalog scheduler function qcom geometry ${TAOSD_MODULE} decimal
 )
 
-if(TD_WINDOWS)
-    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_LIB}
+    ${TAOS_NATIVE_LIB}
     PROPERTIES
     CLEAN_DIRECT_OUTPUT
     1
 )
 
 set_target_properties(
-    ${TAOS_LIB}
+    ${TAOS_NATIVE_LIB}
     PROPERTIES
     VERSION ${TD_VER_NUMBER}
     SOVERSION 1
 )
 
-add_library(${TAOS_LIB_STATIC} STATIC ${CLIENT_SRC})
+add_library(${TAOS_NATIVE_LIB_STATIC} STATIC ${CLIENT_SRC})
 
 if(${TD_DARWIN})
-    target_compile_options(${TAOS_LIB_STATIC} PRIVATE -Wno-error=deprecated-non-prototype)
+    target_compile_options(${TAOS_NATIVE_LIB_STATIC} PRIVATE -Wno-error=deprecated-non-prototype)
 endif()
 
 target_include_directories(
-    ${TAOS_LIB_STATIC}
+    ${TAOS_NATIVE_LIB_STATIC}
     PUBLIC "${TD_SOURCE_DIR}/include/client"
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    ${TAOS_LIB_STATIC}
+    ${TAOS_NATIVE_LIB_STATIC}
     INTERFACE api
     PRIVATE os util common transport monitor nodes parser command planner catalog scheduler function qcom geometry decimal
 )
@@ -73,3 +65,5 @@ target_link_libraries(
 if(${BUILD_TEST})
     ADD_SUBDIRECTORY(test)
 endif(${BUILD_TEST})
+
+ADD_SUBDIRECTORY(wrapper)

source/client/src/clientEnv.c

@@ -922,7 +922,7 @@ void tscStopCrashReport() {
   }
 }
 
-void tscWriteCrashInfo(int signum, void *sigInfo, void *context) {
+void taos_write_crashinfo(int signum, void *sigInfo, void *context) {
   writeCrashLogToFile(signum, sigInfo, CUS_PROMPT, lastClusterId, appInfo.startTime);
 }
 #endif

source/client/src/taos.rc.in

@@ -15,10 +15,10 @@ BEGIN
     BEGIN
         BLOCK "040904b0"
         BEGIN
-            VALUE "FileDescription", "Native C Driver for TDengine"
+            VALUE "FileDescription", "C Driver for TDengine"
             VALUE "FileVersion", "${TD_VER_NUMBER}"
             VALUE "InternalName", "taos.dll(${TD_VER_CPUTYPE})"
-            VALUE "LegalCopyright", "Copyright (C) 2020 TAOS Data"
+            VALUE "LegalCopyright", "Copyright (C) 2025 TAOS Data"
             VALUE "OriginalFilename", ""
             VALUE "ProductName", "taos.dll(${TD_VER_CPUTYPE})"
             VALUE "ProductVersion", "${TD_VER_NUMBER}"

source/client/src/taosnative.rc.in

@@ -0,0 +1,31 @@
+1 VERSIONINFO
+ FILEVERSION ${TD_VER_NUMBER}
+ PRODUCTVERSION ${TD_VER_NUMBER}
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x0L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "Internal C Driver for TDengine"
+            VALUE "FileVersion", "${TD_VER_NUMBER}"
+            VALUE "InternalName", "taosnative.dll(${TD_VER_CPUTYPE})"
+            VALUE "LegalCopyright", "Copyright (C) 2025 TAOS Data"
+            VALUE "OriginalFilename", ""
+            VALUE "ProductName", "taosnative.dll(${TD_VER_CPUTYPE})"
+            VALUE "ProductVersion", "${TD_VER_NUMBER}"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END

source/client/test/CMakeLists.txt

@@ -8,49 +8,49 @@ AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCE_LIST)
 ADD_EXECUTABLE(clientTest clientTests.cpp)
 TARGET_LINK_LIBRARIES(
         clientTest
-        os util common transport parser catalog scheduler gtest ${TAOS_LIB_STATIC} qcom executor function
+        os util common transport parser catalog scheduler gtest ${TAOS_NATIVE_LIB_STATIC} qcom executor function
 )
 
 ADD_EXECUTABLE(connectOptionsTest connectOptionsTest.cpp)
 TARGET_LINK_LIBRARIES(
         connectOptionsTest
-        os util common transport parser catalog scheduler gtest ${TAOS_LIB_STATIC} qcom executor function
+        os util common transport parser catalog scheduler gtest ${TAOS_NATIVE_LIB_STATIC} qcom executor function
 )
 
 ADD_EXECUTABLE(tmqTest tmqTest.cpp)
 TARGET_LINK_LIBRARIES(
         tmqTest
-        PUBLIC os util common transport parser catalog scheduler function gtest ${TAOS_LIB_STATIC} qcom
+        PUBLIC os util common transport parser catalog scheduler function gtest ${TAOS_NATIVE_LIB_STATIC} qcom
 )
 
 ADD_EXECUTABLE(smlTest smlTest.cpp)
 TARGET_LINK_LIBRARIES(
         smlTest
-        PUBLIC os util common transport parser catalog scheduler function gtest ${TAOS_LIB_STATIC} qcom geometry
+        PUBLIC os util common transport parser catalog scheduler function gtest ${TAOS_NATIVE_LIB_STATIC} qcom geometry
 )
 
 #ADD_EXECUTABLE(clientMonitorTest clientMonitorTests.cpp)
 #TARGET_LINK_LIBRARIES(
 #        clientMonitorTest
-#        PUBLIC os util common transport monitor parser catalog scheduler function gtest ${TAOS_LIB_STATIC} qcom executor
+#        PUBLIC os util common transport monitor parser catalog scheduler function gtest ${TAOS_NATIVE_LIB_STATIC} qcom executor
 #)
 
 ADD_EXECUTABLE(userOperTest ../../../tests/script/api/passwdTest.c)
 TARGET_LINK_LIBRARIES(
         userOperTest
-        PUBLIC ${TAOS_LIB}
+        PUBLIC ${TAOS_NATIVE_LIB}
 )
 
 ADD_EXECUTABLE(stmt2Test stmt2Test.cpp)
 TARGET_LINK_LIBRARIES(
         stmt2Test
-        os util common transport parser catalog scheduler gtest ${TAOS_LIB_STATIC} qcom executor function
+        os util common transport parser catalog scheduler gtest ${TAOS_NATIVE_LIB_STATIC} qcom executor function
 )
 
 ADD_EXECUTABLE(stmtTest stmtTest.cpp)
 TARGET_LINK_LIBRARIES(
         stmtTest
-        os util common transport parser catalog scheduler gtest ${TAOS_LIB_STATIC} qcom executor function
+        os util common transport parser catalog scheduler gtest ${TAOS_NATIVE_LIB_STATIC} qcom executor function
 )
 
 TARGET_INCLUDE_DIRECTORIES(
@@ -129,4 +129,4 @@ add_test(
 add_test(
         NAME userOperTest
         COMMAND userOperTest
-)
+)

source/client/wrapper/CMakeLists.txt

@@ -0,0 +1,67 @@
+aux_source_directory(src WRAPPER_SRC)
+
+if(TD_WINDOWS)
+    add_library(${TAOS_LIB} SHARED ${WRAPPER_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/../src/taos.rc.in)
+else()
+    add_library(${TAOS_LIB} SHARED ${WRAPPER_SRC})
+endif()
+
+if(${TD_DARWIN})
+    target_compile_options(${TAOS_LIB} PRIVATE -Wno-error=deprecated-non-prototype)
+endif()
+
+# jni include
+INCLUDE_DIRECTORIES(jni)
+if(TD_WINDOWS)
+    INCLUDE_DIRECTORIES(jni/windows)
+    INCLUDE_DIRECTORIES(jni/windows/win32)
+    INCLUDE_DIRECTORIES(jni/windows/win32/bridge)
+else()
+    INCLUDE_DIRECTORIES(jni/linux)
+endif()
+
+target_include_directories(
+    ${TAOS_LIB}
+    PUBLIC "${TD_SOURCE_DIR}/include/client"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+
+target_link_libraries(
+    ${TAOS_LIB}
+    PUBLIC os util
+)
+
+set_target_properties(
+    ${TAOS_LIB}
+    PROPERTIES
+    CLEAN_DIRECT_OUTPUT
+    1
+)
+
+set_target_properties(
+    ${TAOS_LIB}
+    PROPERTIES
+    VERSION ${TD_VER_NUMBER}
+    SOVERSION 1
+)
+
+add_library(${TAOS_LIB_STATIC} STATIC ${WRAPPER_SRC})
+
+if(${TD_DARWIN})
+    target_compile_options(${TAOS_LIB_STATIC} PRIVATE -Wno-error=deprecated-non-prototype)
+endif()
+
+target_include_directories(
+    ${TAOS_LIB_STATIC}
+    PUBLIC "${TD_SOURCE_DIR}/include/client"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
+)
+
+target_link_libraries(
+    ${TAOS_LIB_STATIC}
+    PUBLIC os util
+)
+
+# if(${BUILD_TEST})
+# ADD_SUBDIRECTORY(test)
+# endif(${BUILD_TEST})

source/client/wrapper/inc/wrapper.h

@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TDENGINE_WRAPPER_H
+#define TDENGINE_WRAPPER_H
+
+#include "os.h"
+#include "taos.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+  DRIVER_NATIVE = 0,
+  DRIVER_WEBSOCKET = 1,
+  DRIVER_MAX = 2,
+} EDriverType;
+
+extern EDriverType tsDriverType;
+extern void       *tsDriver;
+
+extern int32_t taosDriverInit(EDriverType driverType);
+extern void    taosDriverCleanup();
+
+extern setConfRet (*fp_taos_set_config)(const char *config);
+
+extern int (*fp_taos_init)(void);
+extern void (*fp_taos_cleanup)(void);
+extern int (*fp_taos_options)(TSDB_OPTION option, const void *arg, ...);
+extern int (*fp_taos_options_connection)(TAOS *taos, TSDB_OPTION_CONNECTION option, const void *arg, ...);
+extern TAOS *(*fp_taos_connect)(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);
+extern TAOS *(*fp_taos_connect_auth)(const char *ip, const char *user, const char *auth, const char *db, uint16_t port);
+extern void (*fp_taos_close)(TAOS *taos);
+
+extern const char *(*fp_taos_data_type)(int type);
+
+extern TAOS_STMT *(*fp_taos_stmt_init)(TAOS *taos);
+extern TAOS_STMT *(*fp_taos_stmt_init_with_reqid)(TAOS *taos, int64_t reqid);
+extern TAOS_STMT *(*fp_taos_stmt_init_with_options)(TAOS *taos, TAOS_STMT_OPTIONS *options);
+extern int (*fp_taos_stmt_prepare)(TAOS_STMT *stmt, const char *sql, unsigned long length);
+extern int (*fp_taos_stmt_set_tbname_tags)(TAOS_STMT *stmt, const char *name, TAOS_MULTI_BIND *tags);
+extern int (*fp_taos_stmt_set_tbname)(TAOS_STMT *stmt, const char *name);
+extern int (*fp_taos_stmt_set_tags)(TAOS_STMT *stmt, TAOS_MULTI_BIND *tags);
+extern int (*fp_taos_stmt_set_sub_tbname)(TAOS_STMT *stmt, const char *name);
+extern int (*fp_taos_stmt_get_tag_fields)(TAOS_STMT *stmt, int *fieldNum, TAOS_FIELD_E **fields);
+extern int (*fp_taos_stmt_get_col_fields)(TAOS_STMT *stmt, int *fieldNum, TAOS_FIELD_E **fields);
+extern void (*fp_taos_stmt_reclaim_fields)(TAOS_STMT *stmt, TAOS_FIELD_E *fields);
+
+extern int (*fp_taos_stmt_is_insert)(TAOS_STMT *stmt, int *insert);
+extern int (*fp_taos_stmt_num_params)(TAOS_STMT *stmt, int *nums);
+extern int (*fp_taos_stmt_get_param)(TAOS_STMT *stmt, int idx, int *type, int *bytes);
+extern int (*fp_taos_stmt_bind_param)(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind);
+extern int (*fp_taos_stmt_bind_param_batch)(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind);
+extern int (*fp_taos_stmt_bind_single_param_batch)(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, int colIdx);
+extern int (*fp_taos_stmt_add_batch)(TAOS_STMT *stmt);
+extern int (*fp_taos_stmt_execute)(TAOS_STMT *stmt);
+extern TAOS_RES *(*fp_taos_stmt_use_result)(TAOS_STMT *stmt);
+extern int (*fp_taos_stmt_close)(TAOS_STMT *stmt);
+extern char *(*fp_taos_stmt_errstr)(TAOS_STMT *stmt);
+extern int (*fp_taos_stmt_affected_rows)(TAOS_STMT *stmt);
+extern int (*fp_taos_stmt_affected_rows_once)(TAOS_STMT *stmt);
+
+extern TAOS_STMT2 *(*fp_taos_stmt2_init)(TAOS *taos, TAOS_STMT2_OPTION *option);
+extern int (*fp_taos_stmt2_prepare)(TAOS_STMT2 *stmt, const char *sql, unsigned long length);
+extern int (*fp_taos_stmt2_bind_param)(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col_idx);
+extern int (*fp_taos_stmt2_bind_param_a)(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col_idx,
+                                         __taos_async_fn_t fp, void *param);
+extern int (*fp_taos_stmt2_exec)(TAOS_STMT2 *stmt, int *affected_rows);
+extern int (*fp_taos_stmt2_close)(TAOS_STMT2 *stmt);
+extern int (*fp_taos_stmt2_is_insert)(TAOS_STMT2 *stmt, int *insert);
+extern int (*fp_taos_stmt2_get_fields)(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_ALL **fields);
+extern void (*fp_taos_stmt2_free_fields)(TAOS_STMT2 *stmt, TAOS_FIELD_ALL *fields);
+extern TAOS_RES *(*fp_taos_stmt2_result)(TAOS_STMT2 *stmt);
+extern char *(*fp_taos_stmt2_error)(TAOS_STMT2 *stmt);
+
+extern TAOS_RES *(*fp_taos_query)(TAOS *taos, const char *sql);
+extern TAOS_RES *(*fp_taos_query_with_reqid)(TAOS *taos, const char *sql, int64_t reqId);
+
+extern TAOS_ROW (*fp_taos_fetch_row)(TAOS_RES *res);
+extern int (*fp_taos_result_precision)(TAOS_RES *res);  // get the time precision of result
+extern void (*fp_taos_free_result)(TAOS_RES *res);
+extern void (*fp_taos_kill_query)(TAOS *taos);
+extern int (*fp_taos_field_count)(TAOS_RES *res);
+extern int (*fp_taos_num_fields)(TAOS_RES *res);
+extern int (*fp_taos_affected_rows)(TAOS_RES *res);
+extern int64_t (*fp_taos_affected_rows64)(TAOS_RES *res);
+
+extern TAOS_FIELD *(*fp_taos_fetch_fields)(TAOS_RES *res);
+extern TAOS_FIELD_E *(*fp_taos_fetch_fields_e)(TAOS_RES *res);
+extern int (*fp_taos_select_db)(TAOS *taos, const char *db);
+extern int (*fp_taos_print_row)(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields);
+extern int (*fp_taos_print_row_with_size)(char *str, uint32_t size, TAOS_ROW row, TAOS_FIELD *fields, int num_fields);
+extern void (*fp_taos_stop_query)(TAOS_RES *res);
+extern bool (*fp_taos_is_null)(TAOS_RES *res, int32_t row, int32_t col);
+extern int (*fp_taos_is_null_by_column)(TAOS_RES *res, int columnIndex, bool result[], int *rows);
+extern bool (*fp_taos_is_update_query)(TAOS_RES *res);
+extern int (*fp_taos_fetch_block)(TAOS_RES *res, TAOS_ROW *rows);
+extern int (*fp_taos_fetch_block_s)(TAOS_RES *res, int *numOfRows, TAOS_ROW *rows);
+extern int (*fp_taos_fetch_raw_block)(TAOS_RES *res, int *numOfRows, void **pData);
+extern int *(*fp_taos_get_column_data_offset)(TAOS_RES *res, int columnIndex);
+extern int (*fp_taos_validate_sql)(TAOS *taos, const char *sql);
+extern void (*fp_taos_reset_current_db)(TAOS *taos);
+
+extern int *(*fp_taos_fetch_lengths)(TAOS_RES *res);
+extern TAOS_ROW *(*fp_taos_result_block)(TAOS_RES *res);
+
+extern const char *(*fp_taos_get_server_info)(TAOS *taos);
+extern const char *(*fp_taos_get_client_info)();
+extern int (*fp_taos_get_current_db)(TAOS *taos, char *database, int len, int *required);
+
+extern const char *(*fp_taos_errstr)(TAOS_RES *res);
+extern int (*fp_taos_errno)(TAOS_RES *res);
+
+extern void (*fp_taos_query_a)(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param);
+extern void (*fp_taos_query_a_with_reqid)(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param,
+                                          int64_t reqid);
+extern void (*fp_taos_fetch_rows_a)(TAOS_RES *res, __taos_async_fn_t fp, void *param);
+extern void (*fp_taos_fetch_raw_block_a)(TAOS_RES *res, __taos_async_fn_t fp, void *param);
+extern const void *(*fp_taos_get_raw_block)(TAOS_RES *res);
+
+extern int (*fp_taos_get_db_route_info)(TAOS *taos, const char *db, TAOS_DB_ROUTE_INFO *dbInfo);
+extern int (*fp_taos_get_table_vgId)(TAOS *taos, const char *db, const char *table, int *vgId);
+extern int (*fp_taos_get_tables_vgId)(TAOS *taos, const char *db, const char *table[], int tableNum, int *vgId);
+
+extern int (*fp_taos_load_table_info)(TAOS *taos, const char *tableNameList);
+
+extern void (*fp_taos_set_hb_quit)(int8_t quitByKill);
+
+extern int (*fp_taos_set_notify_cb)(TAOS *taos, __taos_notify_fn_t fp, void *param, int type);
+
+extern void (*fp_taos_fetch_whitelist_a)(TAOS *taos, __taos_async_whitelist_fn_t fp, void *param);
+
+extern int (*fp_taos_set_conn_mode)(TAOS *taos, int mode, int value);
+
+extern TAOS_RES *(*fp_taos_schemaless_insert)(TAOS *taos, char *lines[], int numLines, int protocol, int precision);
+extern TAOS_RES *(*fp_taos_schemaless_insert_with_reqid)(TAOS *taos, char *lines[], int numLines, int protocol,
+                                                         int precision, int64_t reqid);
+extern TAOS_RES *(*fp_taos_schemaless_insert_raw)(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol,
+                                                  int precision);
+extern TAOS_RES *(*fp_taos_schemaless_insert_raw_with_reqid)(TAOS *taos, char *lines, int len, int32_t *totalRows,
+                                                             int protocol, int precision, int64_t reqid);
+extern TAOS_RES *(*fp_taos_schemaless_insert_ttl)(TAOS *taos, char *lines[], int numLines, int protocol, int precision,
+                                                  int32_t ttl);
+extern TAOS_RES *(*fp_taos_schemaless_insert_ttl_with_reqid)(TAOS *taos, char *lines[], int numLines, int protocol,
+                                                             int precision, int32_t ttl, int64_t reqid);
+extern TAOS_RES *(*fp_taos_schemaless_insert_raw_ttl)(TAOS *taos, char *lines, int len, int32_t *totalRows,
+                                                      int protocol, int precision, int32_t ttl);
+extern TAOS_RES *(*fp_taos_schemaless_insert_raw_ttl_with_reqid)(TAOS *taos, char *lines, int len, int32_t *totalRows,
+                                                                 int protocol, int precision, int32_t ttl,
+                                                                 int64_t reqid);
+extern TAOS_RES *(*fp_taos_schemaless_insert_raw_ttl_with_reqid_tbname_key)(TAOS *taos, char *lines, int len,
+                                                                            int32_t *totalRows, int protocol,
+                                                                            int precision, int32_t ttl, int64_t reqid,
+                                                                            char *tbnameKey);
+extern TAOS_RES *(*fp_taos_schemaless_insert_ttl_with_reqid_tbname_key)(TAOS *taos, char *lines[], int numLines,
+                                                                        int protocol, int precision, int32_t ttl,
+                                                                        int64_t reqid, char *tbnameKey);
+
+extern tmq_conf_t *(*fp_tmq_conf_new)();
+extern tmq_conf_res_t (*fp_tmq_conf_set)(tmq_conf_t *conf, const char *key, const char *value);
+extern void (*fp_tmq_conf_destroy)(tmq_conf_t *conf);
+extern void (*fp_tmq_conf_set_auto_commit_cb)(tmq_conf_t *conf, tmq_commit_cb *cb, void *param);
+
+extern tmq_list_t *(*fp_tmq_list_new)();
+extern int32_t (*fp_tmq_list_append)(tmq_list_t *, const char *);
+extern void (*fp_tmq_list_destroy)(tmq_list_t *);
+extern int32_t (*fp_tmq_list_get_size)(const tmq_list_t *);
+extern char **(*fp_tmq_list_to_c_array)(const tmq_list_t *);
+
+extern tmq_t *(*fp_tmq_consumer_new)(tmq_conf_t *conf, char *errstr, int32_t errstrLen);
+extern int32_t (*fp_tmq_subscribe)(tmq_t *tmq, const tmq_list_t *topic_list);
+extern int32_t (*fp_tmq_unsubscribe)(tmq_t *tmq);
+extern int32_t (*fp_tmq_subscription)(tmq_t *tmq, tmq_list_t **topics);
+extern TAOS_RES *(*fp_tmq_consumer_poll)(tmq_t *tmq, int64_t timeout);
+extern int32_t (*fp_tmq_consumer_close)(tmq_t *tmq);
+extern int32_t (*fp_tmq_commit_sync)(tmq_t *tmq, const TAOS_RES *msg);
+extern void (*fp_tmq_commit_async)(tmq_t *tmq, const TAOS_RES *msg, tmq_commit_cb *cb, void *param);
+extern int32_t (*fp_tmq_commit_offset_sync)(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset);
+extern void (*fp_tmq_commit_offset_async)(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset,
+                                          tmq_commit_cb *cb, void *param);
+extern int32_t (*fp_tmq_get_topic_assignment)(tmq_t *tmq, const char *pTopicName, tmq_topic_assignment **assignment,
+                                              int32_t *numOfAssignment);
+extern void (*fp_tmq_free_assignment)(tmq_topic_assignment *pAssignment);
+extern int32_t (*fp_tmq_offset_seek)(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset);
+extern int64_t (*fp_tmq_position)(tmq_t *tmq, const char *pTopicName, int32_t vgId);
+extern int64_t (*fp_tmq_committed)(tmq_t *tmq, const char *pTopicName, int32_t vgId);
+
+extern TAOS *(*fp_tmq_get_connect)(tmq_t *tmq);
+extern const char *(*fp_tmq_get_table_name)(TAOS_RES *res);
+extern tmq_res_t (*fp_tmq_get_res_type)(TAOS_RES *res);
+extern const char *(*fp_tmq_get_topic_name)(TAOS_RES *res);
+extern const char *(*fp_tmq_get_db_name)(TAOS_RES *res);
+extern int32_t (*fp_tmq_get_vgroup_id)(TAOS_RES *res);
+extern int64_t (*fp_tmq_get_vgroup_offset)(TAOS_RES *res);
+extern const char *(*fp_tmq_err2str)(int32_t code);
+
+extern int32_t (*fp_tmq_get_raw)(TAOS_RES *res, tmq_raw_data *raw);
+extern int32_t (*fp_tmq_write_raw)(TAOS *taos, tmq_raw_data raw);
+extern int (*fp_taos_write_raw_block)(TAOS *taos, int numOfRows, char *pData, const char *tbname);
+extern int (*fp_taos_write_raw_block_with_reqid)(TAOS *taos, int numOfRows, char *pData, const char *tbname,
+                                                 int64_t reqid);
+extern int (*fp_taos_write_raw_block_with_fields)(TAOS *taos, int rows, char *pData, const char *tbname,
+                                                  TAOS_FIELD *fields, int numFields);
+extern int (*fp_taos_write_raw_block_with_fields_with_reqid)(TAOS *taos, int rows, char *pData, const char *tbname,
+                                                             TAOS_FIELD *fields, int numFields, int64_t reqid);
+extern void (*fp_tmq_free_raw)(tmq_raw_data raw);
+
+extern char *(*fp_tmq_get_json_meta)(TAOS_RES *res);
+extern void (*fp_tmq_free_json_meta)(char *jsonMeta);
+
+extern TSDB_SERVER_STATUS (*fp_taos_check_server_status)(const char *fqdn, int port, char *details, int maxlen);
+extern void (*fp_taos_write_crashinfo)(int signum, void *sigInfo, void *context);
+extern char *(*fp_getBuildInfo)();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TDENGINE_CLIENT_WRAPPER_H

source/client/wrapper/jni/linux/jawt.h

@@ -14,107 +14,6 @@
 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.

source/client/wrapper/jni/windows/jawt.h

@@ -52,87 +52,6 @@ extern "C" {
  * 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.

source/client/wrapper/src/wrapperDriver.c

@@ -0,0 +1,271 @@
+/*
+ * 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 "wrapper.h"
+
+#ifdef WINDOWS
+#define DRIVER_NATIVE_NAME    "taosnative.dll"
+#define DRIVER_WSBSOCKET_NAME "taosws.dll"
+#elif defined(DARWIN)
+#define DRIVER_NATIVE_NAME    "libtaosnative.dylib"
+#define DRIVER_WSBSOCKET_NAME "libtaosws.dylib"
+#else
+#define DRIVER_NATIVE_NAME    "libtaosnative.so"
+#define DRIVER_WSBSOCKET_NAME "libtaosws.so"
+#endif
+
+#define LOAD_FUNC(fptr, fname)                \
+  funcName = fname;                           \
+  fptr = taosLoadDllFunc(tsDriver, funcName); \
+  if (fptr == NULL) goto _OVER;
+
+#ifdef WEBSOCKET
+EDriverType tsDriverType = DRIVER_NATIVE;  // todo simon
+#else
+EDriverType tsDriverType = DRIVER_NATIVE;
+#endif
+
+void *tsDriver = NULL;
+
+static int32_t taosGetDevelopPath(char *driverPath, const char *driverName) {
+  char    appPath[PATH_MAX] = {0};
+  int32_t ret = taosAppPath(appPath, PATH_MAX);
+  if (ret == 0) {
+    snprintf(driverPath, PATH_MAX, "%s%s..%slib%s%s", appPath, TD_DIRSEP, TD_DIRSEP, TD_DIRSEP, driverName);
+    ret = taosRealPath(driverPath, NULL, PATH_MAX);
+  }
+
+  return ret;
+}
+
+static int32_t taosGetInstallPath(char *driverPath, const char *driverName) {
+  tstrncpy(driverPath, driverName, PATH_MAX);
+  return 0;
+}
+
+int32_t taosDriverInit(EDriverType driverType) {
+  int32_t     code = -1;
+  char        driverPath[PATH_MAX + 32] = {0};
+  const char *driverName = NULL;
+  const char *funcName = NULL;
+
+  if (driverType == DRIVER_NATIVE) {
+    driverName = DRIVER_NATIVE_NAME;
+  } else {
+    driverName = DRIVER_WSBSOCKET_NAME;
+  }
+
+  if (tsDriver == NULL && taosGetDevelopPath(driverPath, driverName) == 0) {
+    tsDriver = taosLoadDll(driverPath);
+  }
+
+  if (tsDriver == NULL && taosGetInstallPath(driverPath, driverName) == 0) {
+    tsDriver = taosLoadDll(driverPath);
+  }
+
+  if (tsDriver == NULL) {
+    printf("failed to load %s since %s [0x%X]\r\n", driverName, terrstr(), terrno);
+    return code;
+  }
+
+  // printf("load driver from %s\r\n", driverPath);
+  LOAD_FUNC(fp_taos_set_config, "taos_set_config");
+
+  LOAD_FUNC(fp_taos_init, "taos_init");
+  LOAD_FUNC(fp_taos_cleanup, "taos_cleanup");
+  LOAD_FUNC(fp_taos_options, "taos_options");
+  LOAD_FUNC(fp_taos_options_connection, "taos_options_connection");
+  LOAD_FUNC(fp_taos_connect, "taos_connect");
+  LOAD_FUNC(fp_taos_connect_auth, "taos_connect_auth");
+  LOAD_FUNC(fp_taos_close, "taos_close");
+
+  LOAD_FUNC(fp_taos_data_type, "taos_data_type");
+
+  LOAD_FUNC(fp_taos_stmt_init, "taos_stmt_init");
+  LOAD_FUNC(fp_taos_stmt_init_with_reqid, "taos_stmt_init_with_reqid");
+  LOAD_FUNC(fp_taos_stmt_init_with_options, "taos_stmt_init_with_options");
+  LOAD_FUNC(fp_taos_stmt_prepare, "taos_stmt_prepare");
+  LOAD_FUNC(fp_taos_stmt_set_tbname_tags, "taos_stmt_set_tbname_tags");
+  LOAD_FUNC(fp_taos_stmt_set_tbname, "taos_stmt_set_tbname");
+  LOAD_FUNC(fp_taos_stmt_set_tags, "taos_stmt_set_tags");
+  LOAD_FUNC(fp_taos_stmt_set_sub_tbname, "taos_stmt_set_sub_tbname");
+  LOAD_FUNC(fp_taos_stmt_get_tag_fields, "taos_stmt_get_tag_fields");
+  LOAD_FUNC(fp_taos_stmt_get_col_fields, "taos_stmt_get_col_fields");
+  LOAD_FUNC(fp_taos_stmt_reclaim_fields, "taos_stmt_reclaim_fields");
+
+  LOAD_FUNC(fp_taos_stmt_is_insert, "taos_stmt_is_insert");
+  LOAD_FUNC(fp_taos_stmt_num_params, "taos_stmt_num_params");
+  LOAD_FUNC(fp_taos_stmt_get_param, "taos_stmt_get_param");
+  LOAD_FUNC(fp_taos_stmt_bind_param, "taos_stmt_bind_param");
+  LOAD_FUNC(fp_taos_stmt_bind_param_batch, "taos_stmt_bind_param_batch");
+  LOAD_FUNC(fp_taos_stmt_bind_single_param_batch, "taos_stmt_bind_single_param_batch");
+  LOAD_FUNC(fp_taos_stmt_add_batch, "taos_stmt_add_batch");
+  LOAD_FUNC(fp_taos_stmt_execute, "taos_stmt_execute");
+  LOAD_FUNC(fp_taos_stmt_use_result, "taos_stmt_use_result");
+  LOAD_FUNC(fp_taos_stmt_close, "taos_stmt_close");
+  LOAD_FUNC(fp_taos_stmt_errstr, "taos_stmt_errstr");
+  LOAD_FUNC(fp_taos_stmt_affected_rows, "taos_stmt_affected_rows");
+  LOAD_FUNC(fp_taos_stmt_affected_rows_once, "taos_stmt_affected_rows_once");
+
+  LOAD_FUNC(fp_taos_stmt2_init, "taos_stmt2_init");
+  LOAD_FUNC(fp_taos_stmt2_prepare, "taos_stmt2_prepare");
+  LOAD_FUNC(fp_taos_stmt2_bind_param, "taos_stmt2_bind_param");
+  LOAD_FUNC(fp_taos_stmt2_bind_param_a, "taos_stmt2_bind_param_a");
+  LOAD_FUNC(fp_taos_stmt2_exec, "taos_stmt2_exec");
+  LOAD_FUNC(fp_taos_stmt2_close, "taos_stmt2_close");
+  LOAD_FUNC(fp_taos_stmt2_is_insert, "taos_stmt2_is_insert");
+  LOAD_FUNC(fp_taos_stmt2_get_fields, "taos_stmt2_get_fields");
+  LOAD_FUNC(fp_taos_stmt2_free_fields, "taos_stmt2_free_fields");
+  LOAD_FUNC(fp_taos_stmt2_result, "taos_stmt2_result");
+  LOAD_FUNC(fp_taos_stmt2_error, "taos_stmt2_error");
+
+  LOAD_FUNC(fp_taos_query, "taos_query");
+  LOAD_FUNC(fp_taos_query_with_reqid, "taos_query_with_reqid");
+
+  LOAD_FUNC(fp_taos_fetch_row, "taos_fetch_row");
+  LOAD_FUNC(fp_taos_result_precision, "taos_result_precision");
+  LOAD_FUNC(fp_taos_free_result, "taos_free_result");
+  LOAD_FUNC(fp_taos_kill_query, "taos_kill_query");
+  LOAD_FUNC(fp_taos_field_count, "taos_field_count");
+  LOAD_FUNC(fp_taos_num_fields, "taos_num_fields");
+  LOAD_FUNC(fp_taos_affected_rows, "taos_affected_rows");
+  LOAD_FUNC(fp_taos_affected_rows64, "taos_affected_rows64");
+
+  LOAD_FUNC(fp_taos_fetch_fields, "taos_fetch_fields");
+  LOAD_FUNC(fp_taos_fetch_fields_e, "taos_fetch_fields_e");
+  LOAD_FUNC(fp_taos_select_db, "taos_select_db");
+  LOAD_FUNC(fp_taos_print_row, "taos_print_row");
+  LOAD_FUNC(fp_taos_print_row_with_size, "taos_print_row_with_size");
+  LOAD_FUNC(fp_taos_stop_query, "taos_stop_query");
+  LOAD_FUNC(fp_taos_is_null, "taos_is_null");
+  LOAD_FUNC(fp_taos_is_null_by_column, "taos_is_null_by_column");
+  LOAD_FUNC(fp_taos_is_update_query, "taos_is_update_query");
+  LOAD_FUNC(fp_taos_fetch_block, "taos_fetch_block");
+  LOAD_FUNC(fp_taos_fetch_block_s, "taos_fetch_block_s");
+  LOAD_FUNC(fp_taos_fetch_raw_block, "taos_fetch_raw_block");
+  LOAD_FUNC(fp_taos_get_column_data_offset, "taos_get_column_data_offset");
+  LOAD_FUNC(fp_taos_validate_sql, "taos_validate_sql");
+  LOAD_FUNC(fp_taos_reset_current_db, "taos_reset_current_db");
+
+  LOAD_FUNC(fp_taos_fetch_lengths, "taos_fetch_lengths");
+  LOAD_FUNC(fp_taos_result_block, "taos_result_block");
+
+  LOAD_FUNC(fp_taos_get_server_info, "taos_get_server_info");
+  LOAD_FUNC(fp_taos_get_client_info, "taos_get_client_info");
+  LOAD_FUNC(fp_taos_get_current_db, "taos_get_current_db");
+
+  LOAD_FUNC(fp_taos_errstr, "taos_errstr");
+  LOAD_FUNC(fp_taos_errno, "taos_errno");
+
+  LOAD_FUNC(fp_taos_query_a, "taos_query_a");
+  LOAD_FUNC(fp_taos_query_a_with_reqid, "taos_query_a_with_reqid");
+  LOAD_FUNC(fp_taos_fetch_rows_a, "taos_fetch_rows_a");
+  LOAD_FUNC(fp_taos_fetch_raw_block_a, "taos_fetch_raw_block_a");
+  LOAD_FUNC(fp_taos_get_raw_block, "taos_get_raw_block");
+
+  LOAD_FUNC(fp_taos_get_db_route_info, "taos_get_db_route_info");
+  LOAD_FUNC(fp_taos_get_table_vgId, "taos_get_table_vgId");
+  LOAD_FUNC(fp_taos_get_tables_vgId, "taos_get_tables_vgId");
+
+  LOAD_FUNC(fp_taos_load_table_info, "taos_load_table_info");
+
+  LOAD_FUNC(fp_taos_set_hb_quit, "taos_set_hb_quit");
+
+  LOAD_FUNC(fp_taos_set_notify_cb, "taos_set_notify_cb");
+
+  LOAD_FUNC(fp_taos_fetch_whitelist_a, "taos_fetch_whitelist_a");
+
+  LOAD_FUNC(fp_taos_set_conn_mode, "taos_set_conn_mode");
+
+  LOAD_FUNC(fp_taos_schemaless_insert, "taos_schemaless_insert");
+  LOAD_FUNC(fp_taos_schemaless_insert_with_reqid, "taos_schemaless_insert_with_reqid");
+  LOAD_FUNC(fp_taos_schemaless_insert_raw, "taos_schemaless_insert_raw");
+  LOAD_FUNC(fp_taos_schemaless_insert_raw_with_reqid, "taos_schemaless_insert_raw_with_reqid");
+  LOAD_FUNC(fp_taos_schemaless_insert_ttl, "taos_schemaless_insert_ttl");
+  LOAD_FUNC(fp_taos_schemaless_insert_ttl_with_reqid, "taos_schemaless_insert_ttl_with_reqid");
+  LOAD_FUNC(fp_taos_schemaless_insert_raw_ttl, "taos_schemaless_insert_raw_ttl");
+  LOAD_FUNC(fp_taos_schemaless_insert_raw_ttl_with_reqid, "taos_schemaless_insert_raw_ttl_with_reqid");
+  LOAD_FUNC(fp_taos_schemaless_insert_raw_ttl_with_reqid_tbname_key,
+            "taos_schemaless_insert_raw_ttl_with_reqid_tbname_key");
+  LOAD_FUNC(fp_taos_schemaless_insert_ttl_with_reqid_tbname_key, "taos_schemaless_insert_ttl_with_reqid_tbname_key");
+
+  LOAD_FUNC(fp_tmq_conf_new, "tmq_conf_new");
+  LOAD_FUNC(fp_tmq_conf_set, "tmq_conf_set");
+  LOAD_FUNC(fp_tmq_conf_destroy, "tmq_conf_destroy");
+  LOAD_FUNC(fp_tmq_conf_set_auto_commit_cb, "tmq_conf_set_auto_commit_cb");
+
+  LOAD_FUNC(fp_tmq_list_new, "tmq_list_new");
+  LOAD_FUNC(fp_tmq_list_append, "tmq_list_append");
+  LOAD_FUNC(fp_tmq_list_destroy, "tmq_list_destroy");
+  LOAD_FUNC(fp_tmq_list_get_size, "tmq_list_get_size");
+  LOAD_FUNC(fp_tmq_list_to_c_array, "tmq_list_to_c_array");
+
+  LOAD_FUNC(fp_tmq_consumer_new, "tmq_consumer_new");
+  LOAD_FUNC(fp_tmq_subscribe, "tmq_subscribe");
+  LOAD_FUNC(fp_tmq_unsubscribe, "tmq_unsubscribe");
+  LOAD_FUNC(fp_tmq_subscription, "tmq_subscription");
+  LOAD_FUNC(fp_tmq_consumer_poll, "tmq_consumer_poll");
+  LOAD_FUNC(fp_tmq_consumer_close, "tmq_consumer_close");
+  LOAD_FUNC(fp_tmq_commit_sync, "tmq_commit_sync");
+  LOAD_FUNC(fp_tmq_commit_async, "tmq_commit_async");
+  LOAD_FUNC(fp_tmq_commit_offset_sync, "tmq_commit_offset_sync");
+  LOAD_FUNC(fp_tmq_commit_offset_async, "tmq_commit_offset_async");
+  LOAD_FUNC(fp_tmq_get_topic_assignment, "tmq_get_topic_assignment");
+  LOAD_FUNC(fp_tmq_free_assignment, "tmq_free_assignment");
+  LOAD_FUNC(fp_tmq_offset_seek, "tmq_offset_seek");
+  LOAD_FUNC(fp_tmq_position, "tmq_position");
+  LOAD_FUNC(fp_tmq_committed, "tmq_committed");
+
+  LOAD_FUNC(fp_tmq_get_connect, "tmq_get_connect");
+  LOAD_FUNC(fp_tmq_get_table_name, "tmq_get_table_name");
+  LOAD_FUNC(fp_tmq_get_res_type, "tmq_get_res_type");
+  LOAD_FUNC(fp_tmq_get_topic_name, "tmq_get_topic_name");
+  LOAD_FUNC(fp_tmq_get_db_name, "tmq_get_db_name");
+  LOAD_FUNC(fp_tmq_get_vgroup_id, "tmq_get_vgroup_id");
+  LOAD_FUNC(fp_tmq_get_vgroup_offset, "tmq_get_vgroup_offset");
+  LOAD_FUNC(fp_tmq_err2str, "tmq_err2str");
+
+  LOAD_FUNC(fp_tmq_get_raw, "tmq_get_raw");
+  LOAD_FUNC(fp_tmq_write_raw, "tmq_write_raw");
+  LOAD_FUNC(fp_taos_write_raw_block, "taos_write_raw_block");
+  LOAD_FUNC(fp_taos_write_raw_block_with_reqid, "taos_write_raw_block_with_reqid");
+  LOAD_FUNC(fp_taos_write_raw_block_with_fields, "taos_write_raw_block_with_fields");
+  LOAD_FUNC(fp_taos_write_raw_block_with_fields_with_reqid, "taos_write_raw_block_with_fields_with_reqid");
+  LOAD_FUNC(fp_tmq_free_raw, "tmq_free_raw");
+
+  LOAD_FUNC(fp_tmq_get_json_meta, "tmq_get_json_meta");
+  LOAD_FUNC(fp_tmq_free_json_meta, "tmq_free_json_meta");
+
+  LOAD_FUNC(fp_taos_check_server_status, "taos_check_server_status");
+  LOAD_FUNC(fp_taos_write_crashinfo, "taos_write_crashinfo");
+  LOAD_FUNC(fp_getBuildInfo, "getBuildInfo");
+
+  code = 0;
+
+_OVER:
+  if (code != 0) {
+    printf("failed to load function %s from %s since %s [0x%X]\r\n", funcName, driverPath, terrstr(), terrno);
+    taosDriverCleanup();
+  }
+
+  return code;
+}
+
+void taosDriverCleanup() {
+  if (tsDriver != NULL) {
+    taosCloseDll(tsDriver);
+    tsDriver = NULL;
+  }
+}

source/client/wrapper/src/wrapperFunc.c

@@ -0,0 +1,878 @@
+/*
+ * 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 "version.h"
+#include "wrapper.h"
+
+static TdThreadOnce tsDriverOnce = PTHREAD_ONCE_INIT;
+volatile int32_t    tsDriverOnceRet = 0;
+
+static TdThreadOnce tsInitOnce = PTHREAD_ONCE_INIT;
+volatile int32_t    tsInitOnceRet = 0;
+
+#define ERR_VOID(code) \
+  terrno = code;       \
+  return;
+
+#define ERR_PTR(code) \
+  terrno = code;      \
+  return NULL;
+
+#define ERR_INT(code) \
+  terrno = code;      \
+  return -1;
+
+#define ERR_BOOL(code) \
+  terrno = code;       \
+  return false;
+
+#define ERR_CONFRET(code)           \
+  terrno = code;                    \
+  setConfRet ret = {.retCode = -1}; \
+  return ret;
+
+#define CHECK_VOID(fp)               \
+  if (tsDriver == NULL) {            \
+    ERR_VOID(TSDB_CODE_DLL_NOT_LOAD) \
+  }                                  \
+  if (fp == NULL) {                  \
+    ERR_VOID(TSDB_CODE_DLL_NOT_LOAD) \
+  }
+
+#define CHECK_PTR(fp)               \
+  if (tsDriver == NULL) {           \
+    ERR_PTR(TSDB_CODE_DLL_NOT_LOAD) \
+  }                                 \
+  if (fp == NULL) {                 \
+    ERR_PTR(TSDB_CODE_DLL_NOT_LOAD) \
+  }
+
+#define CHECK_INT(fp)               \
+  if (tsDriver == NULL) {           \
+    ERR_INT(TSDB_CODE_DLL_NOT_LOAD) \
+  }                                 \
+  if (fp == NULL) {                 \
+    ERR_INT(TSDB_CODE_DLL_NOT_LOAD) \
+  }
+
+#define CHECK_BOOL(fp)               \
+  if (tsDriver == NULL) {            \
+    ERR_BOOL(TSDB_CODE_DLL_NOT_LOAD) \
+  }                                  \
+  if (fp == NULL) {                  \
+    ERR_BOOL(TSDB_CODE_DLL_NOT_LOAD) \
+  }
+
+#define CHECK_CONFRET(fp)               \
+  if (tsDriver == NULL) {               \
+    ERR_CONFRET(TSDB_CODE_DLL_NOT_LOAD) \
+  }                                     \
+  if (fp == NULL) {                     \
+    ERR_CONFRET(TSDB_CODE_DLL_NOT_LOAD) \
+  }
+
+setConfRet taos_set_config(const char *config) {
+  if (taos_init() != 0) {
+    ERR_CONFRET(TSDB_CODE_DLL_NOT_LOAD)
+  }
+
+  CHECK_CONFRET(fp_taos_set_config);
+  return (*fp_taos_set_config)(config);
+}
+
+static void taos_init_driver(void) {
+  tsDriverOnceRet = taosDriverInit(tsDriverType);
+  if (tsDriverOnceRet != 0) return;
+
+  tsDriverOnceRet = 0;
+}
+static void taos_init_wrapper(void) {
+  if (fp_taos_init == NULL) {
+    terrno = TSDB_CODE_DLL_FUNC_NOT_LOAD;
+    tsInitOnceRet = -1;
+  } else {
+    tsInitOnceRet = (*fp_taos_init)();
+  }
+}
+
+int taos_init(void) {
+  (void)taosThreadOnce(&tsDriverOnce, taos_init_driver);
+  (void)taosThreadOnce(&tsInitOnce, taos_init_wrapper);
+  return tsInitOnceRet;
+}
+
+void taos_cleanup(void) {
+  CHECK_VOID(fp_taos_cleanup);
+  (*fp_taos_cleanup)();
+}
+
+int taos_options(TSDB_OPTION option, const void *arg, ...) {
+  if (option == TSDB_OPTION_DRIVER) {
+    if (tsDriver == NULL) {
+      if (strcasecmp((const char *)arg, "native") == 0) {
+        tsDriverType = DRIVER_NATIVE;
+        return 0;
+      }
+      if (strcasecmp((const char *)arg, "websocket") == 0) {
+        tsDriverType = DRIVER_WEBSOCKET;
+        return 0;
+      }
+    }
+    terrno = TSDB_CODE_REPEAT_INIT;
+    return -1;
+  }
+  (void)taosThreadOnce(&tsDriverOnce, taos_init_driver);
+
+  CHECK_INT(fp_taos_options);
+  return (*fp_taos_options)(option, arg);
+}
+
+int taos_options_connection(TAOS *taos, TSDB_OPTION_CONNECTION option, const void *arg, ...) {
+  CHECK_INT(fp_taos_options_connection);
+  return (*fp_taos_options_connection)(taos, option, (const char *)arg);
+}
+
+TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port) {
+  if (taos_init() != 0) {
+    //terrno = TSDB_CODE_DLL_NOT_LOAD;
+    return NULL;
+  }
+
+  CHECK_PTR(fp_taos_connect);
+  return (*fp_taos_connect)(ip, user, pass, db, port);
+}
+
+TAOS *taos_connect_auth(const char *ip, const char *user, const char *auth, const char *db, uint16_t port) {
+  if (taos_init() != 0) {
+    terrno = TSDB_CODE_DLL_NOT_LOAD;
+    return NULL;
+  }
+
+  CHECK_PTR(fp_taos_connect_auth);
+  return (*fp_taos_connect_auth)(ip, user, auth, db, port);
+}
+
+void taos_close(TAOS *taos) {
+  CHECK_VOID(fp_taos_close);
+  (*fp_taos_close)(taos);
+}
+
+const char *taos_data_type(int type) {
+  CHECK_PTR(fp_taos_data_type);
+  return (*fp_taos_data_type)(type);
+}
+
+TAOS_STMT *taos_stmt_init(TAOS *taos) {
+  CHECK_PTR(fp_taos_stmt_init);
+  return (*fp_taos_stmt_init)(taos);
+}
+
+TAOS_STMT *taos_stmt_init_with_reqid(TAOS *taos, int64_t reqid) {
+  CHECK_PTR(fp_taos_stmt_init_with_reqid);
+  return (*fp_taos_stmt_init_with_reqid)(taos, reqid);
+}
+
+TAOS_STMT *taos_stmt_init_with_options(TAOS *taos, TAOS_STMT_OPTIONS *options) {
+  CHECK_PTR(fp_taos_stmt_init_with_options);
+  return (*fp_taos_stmt_init_with_options)(taos, options);
+}
+
+int taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length) {
+  CHECK_INT(fp_taos_stmt_prepare);
+  return (*fp_taos_stmt_prepare)(stmt, sql, length);
+}
+
+int taos_stmt_set_tbname_tags(TAOS_STMT *stmt, const char *name, TAOS_MULTI_BIND *tags) {
+  CHECK_INT(fp_taos_stmt_set_tbname_tags);
+  return (*fp_taos_stmt_set_tbname_tags)(stmt, name, tags);
+}
+
+int taos_stmt_set_tbname(TAOS_STMT *stmt, const char *name) {
+  CHECK_INT(fp_taos_stmt_set_tbname);
+  return (*fp_taos_stmt_set_tbname)(stmt, name);
+}
+
+int taos_stmt_set_tags(TAOS_STMT *stmt, TAOS_MULTI_BIND *tags) {
+  CHECK_INT(fp_taos_stmt_set_tags);
+  return (*fp_taos_stmt_set_tags)(stmt, tags);
+}
+
+int taos_stmt_set_sub_tbname(TAOS_STMT *stmt, const char *name) {
+  CHECK_INT(fp_taos_stmt_set_sub_tbname);
+  return (*fp_taos_stmt_set_sub_tbname)(stmt, name);
+}
+
+int taos_stmt_get_tag_fields(TAOS_STMT *stmt, int *fieldNum, TAOS_FIELD_E **fields) {
+  CHECK_INT(fp_taos_stmt_get_tag_fields);
+  return (*fp_taos_stmt_get_tag_fields)(stmt, fieldNum, fields);
+}
+
+int taos_stmt_get_col_fields(TAOS_STMT *stmt, int *fieldNum, TAOS_FIELD_E **fields) {
+  CHECK_INT(fp_taos_stmt_get_col_fields);
+  return (*fp_taos_stmt_get_col_fields)(stmt, fieldNum, fields);
+}
+
+void taos_stmt_reclaim_fields(TAOS_STMT *stmt, TAOS_FIELD_E *fields) {
+  CHECK_VOID(fp_taos_stmt_reclaim_fields);
+  (*fp_taos_stmt_reclaim_fields)(stmt, fields);
+}
+
+int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
+  CHECK_INT(fp_taos_stmt_is_insert);
+  return (*fp_taos_stmt_is_insert)(stmt, insert);
+}
+
+int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
+  CHECK_INT(fp_taos_stmt_num_params);
+  return (*fp_taos_stmt_num_params)(stmt, nums);
+}
+
+int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
+  CHECK_INT(fp_taos_stmt_get_param);
+  return (*fp_taos_stmt_get_param)(stmt, idx, type, bytes);
+}
+
+int taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {
+  CHECK_INT(fp_taos_stmt_bind_param);
+  return (*fp_taos_stmt_bind_param)(stmt, bind);
+}
+
+int taos_stmt_bind_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {
+  CHECK_INT(fp_taos_stmt_bind_param_batch);
+  return (*fp_taos_stmt_bind_param_batch)(stmt, bind);
+}
+
+int taos_stmt_bind_single_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, int colIdx) {
+  CHECK_INT(fp_taos_stmt_bind_single_param_batch);
+  return (*fp_taos_stmt_bind_single_param_batch)(stmt, bind, colIdx);
+}
+
+int taos_stmt_add_batch(TAOS_STMT *stmt) {
+  CHECK_INT(fp_taos_stmt_add_batch);
+  return (*fp_taos_stmt_add_batch)(stmt);
+}
+
+int taos_stmt_execute(TAOS_STMT *stmt) {
+  CHECK_INT(fp_taos_stmt_execute);
+  return (*fp_taos_stmt_execute)(stmt);
+}
+
+TAOS_RES *taos_stmt_use_result(TAOS_STMT *stmt) {
+  CHECK_PTR(fp_taos_stmt_use_result);
+  return (*fp_taos_stmt_use_result)(stmt);
+}
+
+int taos_stmt_close(TAOS_STMT *stmt) {
+  CHECK_INT(fp_taos_stmt_close);
+  return (*fp_taos_stmt_close)(stmt);
+}
+
+char *taos_stmt_errstr(TAOS_STMT *stmt) {
+  CHECK_PTR(fp_taos_stmt_errstr);
+  return (*fp_taos_stmt_errstr)(stmt);
+}
+
+int taos_stmt_affected_rows(TAOS_STMT *stmt) {
+  CHECK_INT(fp_taos_stmt_affected_rows);
+  return (*fp_taos_stmt_affected_rows)(stmt);
+}
+
+int taos_stmt_affected_rows_once(TAOS_STMT *stmt) {
+  CHECK_INT(fp_taos_stmt_affected_rows_once);
+  return (*fp_taos_stmt_affected_rows_once)(stmt);
+}
+
+TAOS_STMT2 *taos_stmt2_init(TAOS *taos, TAOS_STMT2_OPTION *option) {
+  CHECK_PTR(fp_taos_stmt2_init);
+  return (*fp_taos_stmt2_init)(taos, option);
+}
+
+int taos_stmt2_prepare(TAOS_STMT2 *stmt, const char *sql, unsigned long length) {
+  CHECK_INT(fp_taos_stmt2_prepare);
+  return (*fp_taos_stmt2_prepare)(stmt, sql, length);
+}
+
+int taos_stmt2_bind_param(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col_idx) {
+  CHECK_INT(fp_taos_stmt2_bind_param);
+  return (*fp_taos_stmt2_bind_param)(stmt, bindv, col_idx);
+}
+
+int taos_stmt2_bind_param_a(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col_idx, __taos_async_fn_t fp,
+                            void *param) {
+  CHECK_INT(fp_taos_stmt2_bind_param_a);
+  return (*fp_taos_stmt2_bind_param_a)(stmt, bindv, col_idx, fp, param);
+}
+
+int taos_stmt2_exec(TAOS_STMT2 *stmt, int *affected_rows) {
+  CHECK_INT(fp_taos_stmt2_exec);
+  return (*fp_taos_stmt2_exec)(stmt, affected_rows);
+}
+
+int taos_stmt2_close(TAOS_STMT2 *stmt) {
+  CHECK_INT(fp_taos_stmt2_close);
+  return (*fp_taos_stmt2_close)(stmt);
+}
+
+int taos_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert) {
+  CHECK_INT(fp_taos_stmt2_is_insert);
+  return (*fp_taos_stmt2_is_insert)(stmt, insert);
+}
+
+int taos_stmt2_get_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_ALL **fields) {
+  CHECK_INT(fp_taos_stmt2_get_fields);
+  return (*fp_taos_stmt2_get_fields)(stmt, count, fields);
+}
+
+void taos_stmt2_free_fields(TAOS_STMT2 *stmt, TAOS_FIELD_ALL *fields) {
+  CHECK_VOID(fp_taos_stmt2_free_fields);
+  (*fp_taos_stmt2_free_fields)(stmt, fields);
+}
+
+TAOS_RES *taos_stmt2_result(TAOS_STMT2 *stmt) {
+  CHECK_PTR(fp_taos_stmt2_result);
+  return (*fp_taos_stmt2_result)(stmt);
+}
+
+char *taos_stmt2_error(TAOS_STMT2 *stmt) {
+  CHECK_PTR(fp_taos_stmt2_error);
+  return (*fp_taos_stmt2_error)(stmt);
+}
+
+TAOS_RES *taos_query(TAOS *taos, const char *sql) {
+  CHECK_PTR(fp_taos_query);
+  return (*fp_taos_query)(taos, sql);
+}
+
+TAOS_RES *taos_query_with_reqid(TAOS *taos, const char *sql, int64_t reqId) {
+  CHECK_PTR(fp_taos_query_with_reqid);
+  return (*fp_taos_query_with_reqid)(taos, sql, reqId);
+}
+
+TAOS_ROW taos_fetch_row(TAOS_RES *res) {
+  CHECK_PTR(fp_taos_fetch_row);
+  return (*fp_taos_fetch_row)(res);
+}
+
+int taos_result_precision(TAOS_RES *res) {
+  CHECK_INT(fp_taos_result_precision);
+  return (*fp_taos_result_precision)(res);
+}
+
+void taos_free_result(TAOS_RES *res) {
+  CHECK_VOID(fp_taos_free_result);
+  return (*fp_taos_free_result)(res);
+}
+
+void taos_kill_query(TAOS *taos) {
+  CHECK_VOID(fp_taos_kill_query);
+  return (*fp_taos_kill_query)(taos);
+}
+
+int taos_field_count(TAOS_RES *res) {
+  CHECK_INT(fp_taos_field_count);
+  return (*fp_taos_field_count)(res);
+}
+
+int taos_num_fields(TAOS_RES *res) {
+  CHECK_INT(fp_taos_num_fields);
+  return (*fp_taos_num_fields)(res);
+}
+
+int taos_affected_rows(TAOS_RES *res) {
+  CHECK_INT(fp_taos_affected_rows);
+  return (*fp_taos_affected_rows)(res);
+}
+
+int64_t taos_affected_rows64(TAOS_RES *res) {
+  CHECK_INT(fp_taos_affected_rows64);
+  return (*fp_taos_affected_rows64)(res);
+}
+
+TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
+  CHECK_PTR(fp_taos_fetch_fields);
+  return (*fp_taos_fetch_fields)(res);
+}
+
+TAOS_FIELD_E *taos_fetch_fields_e(TAOS_RES *res) {
+  CHECK_PTR(fp_taos_fetch_fields_e);
+  return (*fp_taos_fetch_fields_e)(res);
+}
+
+int taos_select_db(TAOS *taos, const char *db) {
+  CHECK_INT(fp_taos_select_db);
+  return (*fp_taos_select_db)(taos, db);
+}
+
+int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
+  CHECK_INT(fp_taos_print_row);
+  return (*fp_taos_print_row)(str, row, fields, num_fields);
+}
+
+int taos_print_row_with_size(char *str, uint32_t size, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
+  CHECK_INT(fp_taos_print_row_with_size);
+  return (*fp_taos_print_row_with_size)(str, size, row, fields, num_fields);
+}
+
+void taos_stop_query(TAOS_RES *res) {
+  CHECK_VOID(fp_taos_stop_query);
+  (*fp_taos_stop_query)(res);
+}
+
+bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) {
+  CHECK_BOOL(fp_taos_is_null);
+  return (*fp_taos_is_null)(res, row, col);
+}
+
+int taos_is_null_by_column(TAOS_RES *res, int columnIndex, bool result[], int *rows) {
+  CHECK_INT(fp_taos_is_null_by_column);
+  return (*fp_taos_is_null_by_column)(res, columnIndex, result, rows);
+}
+
+bool taos_is_update_query(TAOS_RES *res) {
+  CHECK_BOOL(fp_taos_is_update_query);
+  return (*fp_taos_is_update_query)(res);
+}
+
+int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
+  CHECK_INT(fp_taos_fetch_block);
+  return (*fp_taos_fetch_block)(res, rows);
+}
+
+int taos_fetch_block_s(TAOS_RES *res, int *numOfRows, TAOS_ROW *rows) {
+  CHECK_INT(fp_taos_fetch_block_s);
+  return (*fp_taos_fetch_block_s)(res, numOfRows, rows);
+}
+
+int taos_fetch_raw_block(TAOS_RES *res, int *numOfRows, void **pData) {
+  CHECK_INT(fp_taos_fetch_raw_block);
+  return (*fp_taos_fetch_raw_block)(res, numOfRows, pData);
+}
+
+int *taos_get_column_data_offset(TAOS_RES *res, int columnIndex) {
+  CHECK_PTR(fp_taos_get_column_data_offset);
+  return (*fp_taos_get_column_data_offset)(res, columnIndex);
+}
+
+int taos_validate_sql(TAOS *taos, const char *sql) {
+  CHECK_INT(fp_taos_validate_sql);
+  return (*fp_taos_validate_sql)(taos, sql);
+}
+
+void taos_reset_current_db(TAOS *taos) {
+  CHECK_VOID(fp_taos_reset_current_db);
+  (*fp_taos_reset_current_db)(taos);
+}
+
+int *taos_fetch_lengths(TAOS_RES *res) {
+  CHECK_PTR(fp_taos_fetch_lengths);
+  return (*fp_taos_fetch_lengths)(res);
+}
+
+TAOS_ROW *taos_result_block(TAOS_RES *res) {
+  CHECK_PTR(fp_taos_result_block);
+  return (*fp_taos_result_block)(res);
+}
+
+const char *taos_get_server_info(TAOS *taos) {
+  CHECK_PTR(fp_taos_get_server_info);
+  return (*fp_taos_get_server_info)(taos);
+}
+
+const char *taos_get_client_info() {
+  if (fp_taos_get_client_info == NULL) {
+    return td_version;
+  } else {
+    return (*fp_taos_get_client_info)();
+  }
+}
+
+int taos_get_current_db(TAOS *taos, char *database, int len, int *required) {
+  CHECK_INT(fp_taos_get_current_db);
+  return (*fp_taos_get_current_db)(taos, database, len, required);
+}
+
+const char *taos_errstr(TAOS_RES *res) {
+  if (fp_taos_errstr == NULL) {
+    return tstrerror(terrno);
+  }
+  return (*fp_taos_errstr)(res);
+}
+
+int taos_errno(TAOS_RES *res) {
+  if (fp_taos_errno == NULL) {
+    return terrno;
+  }
+  return (*fp_taos_errno)(res);
+}
+
+void taos_query_a(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param) {
+  CHECK_VOID(fp_taos_query_a);
+  (*fp_taos_query_a)(taos, sql, fp, param);
+}
+
+void taos_query_a_with_reqid(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param, int64_t reqid) {
+  CHECK_VOID(fp_taos_query_a_with_reqid);
+  (*fp_taos_query_a_with_reqid)(taos, sql, fp, param, reqid);
+}
+
+void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
+  CHECK_VOID(fp_taos_fetch_rows_a);
+  (*fp_taos_fetch_rows_a)(res, fp, param);
+}
+
+void taos_fetch_raw_block_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) {
+  CHECK_VOID(fp_taos_fetch_raw_block_a);
+  (*fp_taos_fetch_raw_block_a)(res, fp, param);
+}
+
+const void *taos_get_raw_block(TAOS_RES *res) {
+  CHECK_PTR(fp_taos_get_raw_block);
+  return (*fp_taos_get_raw_block)(res);
+}
+
+int taos_get_db_route_info(TAOS *taos, const char *db, TAOS_DB_ROUTE_INFO *dbInfo) {
+  CHECK_INT(fp_taos_get_db_route_info);
+  return (*fp_taos_get_db_route_info)(taos, db, dbInfo);
+}
+
+int taos_get_table_vgId(TAOS *taos, const char *db, const char *table, int *vgId) {
+  CHECK_INT(fp_taos_get_table_vgId);
+  return (*fp_taos_get_table_vgId)(taos, db, table, vgId);
+}
+
+int taos_get_tables_vgId(TAOS *taos, const char *db, const char *table[], int tableNum, int *vgId) {
+  CHECK_INT(fp_taos_get_tables_vgId);
+  return (*fp_taos_get_tables_vgId)(taos, db, table, tableNum, vgId);
+}
+
+int taos_load_table_info(TAOS *taos, const char *tableNameList) {
+  CHECK_INT(fp_taos_load_table_info);
+  return (*fp_taos_load_table_info)(taos, tableNameList);
+}
+
+void taos_set_hb_quit(int8_t quitByKill) {
+  if (taos_init() != 0) {
+    return;
+  }
+
+  CHECK_VOID(fp_taos_set_hb_quit);
+  return (*fp_taos_set_hb_quit)(quitByKill);
+}
+
+int taos_set_notify_cb(TAOS *taos, __taos_notify_fn_t fp, void *param, int type) {
+  CHECK_INT(fp_taos_set_notify_cb);
+  return (*fp_taos_set_notify_cb)(taos, fp, param, type);
+}
+
+void taos_fetch_whitelist_a(TAOS *taos, __taos_async_whitelist_fn_t fp, void *param) {
+  CHECK_VOID(fp_taos_fetch_whitelist_a);
+  return (*fp_taos_fetch_whitelist_a)(taos, fp, param);
+}
+
+int taos_set_conn_mode(TAOS *taos, int mode, int value) {
+  CHECK_INT(fp_taos_set_conn_mode);
+  return (*fp_taos_set_conn_mode)(taos, mode, value);
+}
+
+TAOS_RES *taos_schemaless_insert(TAOS *taos, char *lines[], int numLines, int protocol, int precision) {
+  CHECK_PTR(fp_taos_schemaless_insert);
+  return (*fp_taos_schemaless_insert)(taos, lines, numLines, protocol, precision);
+}
+
+TAOS_RES *taos_schemaless_insert_with_reqid(TAOS *taos, char *lines[], int numLines, int protocol, int precision,
+                                            int64_t reqid) {
+  CHECK_PTR(fp_taos_schemaless_insert_with_reqid);
+  return (*fp_taos_schemaless_insert_with_reqid)(taos, lines, numLines, protocol, precision, reqid);
+}
+
+TAOS_RES *taos_schemaless_insert_raw(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol,
+                                     int precision) {
+  CHECK_PTR(fp_taos_schemaless_insert_raw);
+  return (*fp_taos_schemaless_insert_raw)(taos, lines, len, totalRows, protocol, precision);
+}
+
+TAOS_RES *taos_schemaless_insert_raw_with_reqid(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol,
+                                                int precision, int64_t reqid) {
+  CHECK_PTR(fp_taos_schemaless_insert_raw_with_reqid);
+  return (*fp_taos_schemaless_insert_raw_with_reqid)(taos, lines, len, totalRows, protocol, precision, reqid);
+}
+
+TAOS_RES *taos_schemaless_insert_ttl(TAOS *taos, char *lines[], int numLines, int protocol, int precision,
+                                     int32_t ttl) {
+  CHECK_PTR(fp_taos_schemaless_insert_ttl);
+  return (*fp_taos_schemaless_insert_ttl)(taos, lines, numLines, protocol, precision, ttl);
+}
+
+TAOS_RES *taos_schemaless_insert_ttl_with_reqid(TAOS *taos, char *lines[], int numLines, int protocol, int precision,
+                                                int32_t ttl, int64_t reqid) {
+  CHECK_PTR(fp_taos_schemaless_insert_ttl_with_reqid);
+  return (*fp_taos_schemaless_insert_ttl_with_reqid)(taos, lines, numLines, protocol, precision, ttl, reqid);
+}
+
+TAOS_RES *taos_schemaless_insert_raw_ttl(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol,
+                                         int precision, int32_t ttl) {
+  CHECK_PTR(fp_taos_schemaless_insert_raw_ttl);
+  return (*fp_taos_schemaless_insert_raw_ttl)(taos, lines, len, totalRows, protocol, precision, ttl);
+}
+
+TAOS_RES *taos_schemaless_insert_raw_ttl_with_reqid(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol,
+                                                    int precision, int32_t ttl, int64_t reqid) {
+  CHECK_PTR(fp_taos_schemaless_insert_raw_ttl_with_reqid);
+  return (*fp_taos_schemaless_insert_raw_ttl_with_reqid)(taos, lines, len, totalRows, protocol, precision, ttl, reqid);
+}
+
+TAOS_RES *taos_schemaless_insert_raw_ttl_with_reqid_tbname_key(TAOS *taos, char *lines, int len, int32_t *totalRows,
+                                                               int protocol, int precision, int32_t ttl, int64_t reqid,
+                                                               char *tbnameKey) {
+  CHECK_PTR(fp_taos_schemaless_insert_raw_ttl_with_reqid_tbname_key);
+  return (*fp_taos_schemaless_insert_raw_ttl_with_reqid_tbname_key)(taos, lines, len, totalRows, protocol, precision,
+                                                                    ttl, reqid, tbnameKey);
+}
+
+TAOS_RES *taos_schemaless_insert_ttl_with_reqid_tbname_key(TAOS *taos, char *lines[], int numLines, int protocol,
+                                                           int precision, int32_t ttl, int64_t reqid, char *tbnameKey) {
+  CHECK_PTR(fp_taos_schemaless_insert_ttl_with_reqid_tbname_key);
+  return (*fp_taos_schemaless_insert_ttl_with_reqid_tbname_key)(taos, lines, numLines, protocol, precision, ttl, reqid,
+                                                                tbnameKey);
+}
+
+tmq_conf_t *tmq_conf_new() {
+  taos_init();
+  CHECK_PTR(fp_tmq_conf_new);
+  return (*fp_tmq_conf_new)();
+}
+
+tmq_conf_res_t tmq_conf_set(tmq_conf_t *conf, const char *key, const char *value) {
+  CHECK_INT(fp_tmq_conf_set);
+  return (*fp_tmq_conf_set)(conf, key, value);
+}
+
+void tmq_conf_destroy(tmq_conf_t *conf) {
+  CHECK_VOID(fp_tmq_conf_destroy);
+  (*fp_tmq_conf_destroy)(conf);
+}
+
+void tmq_conf_set_auto_commit_cb(tmq_conf_t *conf, tmq_commit_cb *cb, void *param) {
+  CHECK_VOID(fp_tmq_conf_set_auto_commit_cb);
+  (*fp_tmq_conf_set_auto_commit_cb)(conf, cb, param);
+}
+
+tmq_list_t *tmq_list_new() {
+  taos_init();
+  CHECK_PTR(fp_tmq_list_new);
+  return (*fp_tmq_list_new)();
+}
+
+int32_t tmq_list_append(tmq_list_t *tlist, const char *val) {
+  CHECK_INT(fp_tmq_list_append);
+  return (*fp_tmq_list_append)(tlist, val);
+}
+
+void tmq_list_destroy(tmq_list_t *tlist) {
+  CHECK_VOID(fp_tmq_list_destroy);
+  (*fp_tmq_list_destroy)(tlist);
+}
+
+int32_t tmq_list_get_size(const tmq_list_t *tlist) {
+  CHECK_INT(fp_tmq_list_get_size);
+  return (*fp_tmq_list_get_size)(tlist);
+}
+
+char **tmq_list_to_c_array(const tmq_list_t *tlist) {
+  CHECK_PTR(fp_tmq_list_to_c_array);
+  return (*fp_tmq_list_to_c_array)(tlist);
+}
+
+tmq_t *tmq_consumer_new(tmq_conf_t *conf, char *errstr, int32_t errstrLen) {
+  taos_init();
+  CHECK_PTR(fp_tmq_consumer_new);
+  return (*fp_tmq_consumer_new)(conf, errstr, errstrLen);
+}
+
+int32_t tmq_subscribe(tmq_t *tmq, const tmq_list_t *topic_list) {
+  CHECK_INT(fp_tmq_subscribe);
+  return (*fp_tmq_subscribe)(tmq, topic_list);
+}
+
+int32_t tmq_unsubscribe(tmq_t *tmq) {
+  CHECK_INT(fp_tmq_unsubscribe);
+  return (*fp_tmq_unsubscribe)(tmq);
+}
+
+int32_t tmq_subscription(tmq_t *tmq, tmq_list_t **topics) {
+  CHECK_INT(fp_tmq_subscription);
+  return (*fp_tmq_subscription)(tmq, topics);
+}
+
+TAOS_RES *tmq_consumer_poll(tmq_t *tmq, int64_t timeout) {
+  CHECK_PTR(fp_tmq_consumer_poll);
+  return (*fp_tmq_consumer_poll)(tmq, timeout);
+}
+
+int32_t tmq_consumer_close(tmq_t *tmq) {
+  CHECK_INT(fp_tmq_consumer_close);
+  return (*fp_tmq_consumer_close)(tmq);
+}
+
+int32_t tmq_commit_sync(tmq_t *tmq, const TAOS_RES *msg) {
+  CHECK_INT(fp_tmq_commit_sync);
+  return (*fp_tmq_commit_sync)(tmq, msg);
+}
+
+void tmq_commit_async(tmq_t *tmq, const TAOS_RES *msg, tmq_commit_cb *cb, void *param) {
+  CHECK_VOID(fp_tmq_commit_async);
+  (*fp_tmq_commit_async)(tmq, msg, cb, param);
+}
+
+int32_t tmq_commit_offset_sync(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset) {
+  CHECK_INT(fp_tmq_commit_offset_sync);
+  return (*fp_tmq_commit_offset_sync)(tmq, pTopicName, vgId, offset);
+}
+
+void tmq_commit_offset_async(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset, tmq_commit_cb *cb,
+                             void *param) {
+  CHECK_VOID(fp_tmq_commit_offset_async);
+  (*fp_tmq_commit_offset_async)(tmq, pTopicName, vgId, offset, cb, param);
+}
+
+int32_t tmq_get_topic_assignment(tmq_t *tmq, const char *pTopicName, tmq_topic_assignment **assignment,
+                                 int32_t *numOfAssignment) {
+  CHECK_INT(fp_tmq_get_topic_assignment);
+  return (*fp_tmq_get_topic_assignment)(tmq, pTopicName, assignment, numOfAssignment);
+}
+
+void tmq_free_assignment(tmq_topic_assignment *pAssignment) {
+  CHECK_VOID(fp_tmq_free_assignment);
+  (*fp_tmq_free_assignment)(pAssignment);
+}
+
+int32_t tmq_offset_seek(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset) {
+  CHECK_INT(fp_tmq_offset_seek);
+  return (*fp_tmq_offset_seek)(tmq, pTopicName, vgId, offset);
+}
+
+int64_t tmq_position(tmq_t *tmq, const char *pTopicName, int32_t vgId) {
+  CHECK_INT(fp_tmq_position);
+  return (*fp_tmq_position)(tmq, pTopicName, vgId);
+}
+
+int64_t tmq_committed(tmq_t *tmq, const char *pTopicName, int32_t vgId) {
+  CHECK_INT(fp_tmq_committed);
+  return (*fp_tmq_committed)(tmq, pTopicName, vgId);
+}
+
+TAOS *tmq_get_connect(tmq_t *tmq) {
+  CHECK_PTR(fp_tmq_get_connect);
+  return (*fp_tmq_get_connect)(tmq);
+}
+
+const char *tmq_get_table_name(TAOS_RES *res) {
+  CHECK_PTR(fp_tmq_get_table_name);
+  return (*fp_tmq_get_table_name)(res);
+}
+
+tmq_res_t tmq_get_res_type(TAOS_RES *res) {
+  CHECK_INT(fp_tmq_get_res_type);
+  return (*fp_tmq_get_res_type)(res);
+}
+
+const char *tmq_get_topic_name(TAOS_RES *res) {
+  CHECK_PTR(fp_tmq_get_topic_name);
+  return (*fp_tmq_get_topic_name)(res);
+}
+
+const char *tmq_get_db_name(TAOS_RES *res) {
+  CHECK_PTR(fp_tmq_get_db_name);
+  return (*fp_tmq_get_db_name)(res);
+}
+
+int32_t tmq_get_vgroup_id(TAOS_RES *res) {
+  CHECK_INT(fp_tmq_get_vgroup_id);
+  return (*fp_tmq_get_vgroup_id)(res);
+}
+
+int64_t tmq_get_vgroup_offset(TAOS_RES *res) {
+  CHECK_INT(fp_tmq_get_vgroup_offset);
+  return (*fp_tmq_get_vgroup_offset)(res);
+}
+
+const char *tmq_err2str(int32_t code) {
+  CHECK_PTR(fp_tmq_err2str);
+  return (*fp_tmq_err2str)(code);
+}
+
+int32_t tmq_get_raw(TAOS_RES *res, tmq_raw_data *raw) {
+  CHECK_INT(fp_tmq_get_raw);
+  return (*fp_tmq_get_raw)(res, raw);
+}
+
+int32_t tmq_write_raw(TAOS *taos, tmq_raw_data raw) {
+  CHECK_INT(fp_tmq_write_raw);
+  return (*fp_tmq_write_raw)(taos, raw);
+}
+
+int taos_write_raw_block(TAOS *taos, int numOfRows, char *pData, const char *tbname) {
+  CHECK_INT(fp_taos_write_raw_block);
+  return (*fp_taos_write_raw_block)(taos, numOfRows, pData, tbname);
+}
+
+int taos_write_raw_block_with_reqid(TAOS *taos, int numOfRows, char *pData, const char *tbname, int64_t reqid) {
+  CHECK_INT(fp_taos_write_raw_block_with_reqid);
+  return (*fp_taos_write_raw_block_with_reqid)(taos, numOfRows, pData, tbname, reqid);
+}
+
+int taos_write_raw_block_with_fields(TAOS *taos, int rows, char *pData, const char *tbname, TAOS_FIELD *fields,
+                                     int numFields) {
+  CHECK_INT(fp_taos_write_raw_block_with_fields);
+  return (*fp_taos_write_raw_block_with_fields)(taos, rows, pData, tbname, fields, numFields);
+}
+
+int taos_write_raw_block_with_fields_with_reqid(TAOS *taos, int rows, char *pData, const char *tbname,
+                                                TAOS_FIELD *fields, int numFields, int64_t reqid) {
+  CHECK_INT(fp_taos_write_raw_block_with_fields_with_reqid);
+  return (*fp_taos_write_raw_block_with_fields_with_reqid)(taos, rows, pData, tbname, fields, numFields, reqid);
+}
+
+void tmq_free_raw(tmq_raw_data raw) {
+  CHECK_VOID(fp_tmq_free_raw);
+  (*fp_tmq_free_raw)(raw);
+}
+
+char *tmq_get_json_meta(TAOS_RES *res) {
+  CHECK_PTR(fp_tmq_get_json_meta);
+  return (*fp_tmq_get_json_meta)(res);
+}
+
+void tmq_free_json_meta(char *jsonMeta) {
+  CHECK_VOID(fp_tmq_free_json_meta);
+  return (*fp_tmq_free_json_meta)(jsonMeta);
+}
+
+TSDB_SERVER_STATUS taos_check_server_status(const char *fqdn, int port, char *details, int maxlen) {
+  CHECK_INT(fp_taos_check_server_status);
+  return (*fp_taos_check_server_status)(fqdn, port, details, maxlen);
+}
+
+void taos_write_crashinfo(int signum, void *sigInfo, void *context) {
+  taos_init();
+  CHECK_VOID(fp_taos_write_crashinfo);
+  (*fp_taos_write_crashinfo)(signum, sigInfo, context);
+}
+
+char *getBuildInfo() {
+  taos_init();
+  CHECK_PTR(fp_getBuildInfo);
+  return (*fp_getBuildInfo)();
+}

source/client/wrapper/src/wrapperVariable.c

@@ -0,0 +1,205 @@
+/*
+ * 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 = NULL; 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 "wrapper.h"
+
+setConfRet (*fp_taos_set_config)(const char *config) = NULL;
+
+int (*fp_taos_init)(void) = NULL;
+void (*fp_taos_cleanup)(void) = NULL;
+int (*fp_taos_options)(TSDB_OPTION option, const void *arg, ...) = NULL;
+int (*fp_taos_options_connection)(TAOS *taos, TSDB_OPTION_CONNECTION option, const void *arg, ...) = NULL;
+TAOS *(*fp_taos_connect)(const char *ip, const char *user, const char *pass, const char *db, uint16_t port) = NULL;
+TAOS *(*fp_taos_connect_auth)(const char *ip, const char *user, const char *auth, const char *db, uint16_t port) = NULL;
+void (*fp_taos_close)(TAOS *taos) = NULL;
+
+const char *(*fp_taos_data_type)(int type) = NULL;
+
+TAOS_STMT *(*fp_taos_stmt_init)(TAOS *taos) = NULL;
+TAOS_STMT *(*fp_taos_stmt_init_with_reqid)(TAOS *taos, int64_t reqid) = NULL;
+TAOS_STMT *(*fp_taos_stmt_init_with_options)(TAOS *taos, TAOS_STMT_OPTIONS *options) = NULL;
+int (*fp_taos_stmt_prepare)(TAOS_STMT *stmt, const char *sql, unsigned long length) = NULL;
+int (*fp_taos_stmt_set_tbname_tags)(TAOS_STMT *stmt, const char *name, TAOS_MULTI_BIND *tags) = NULL;
+int (*fp_taos_stmt_set_tbname)(TAOS_STMT *stmt, const char *name) = NULL;
+int (*fp_taos_stmt_set_tags)(TAOS_STMT *stmt, TAOS_MULTI_BIND *tags) = NULL;
+int (*fp_taos_stmt_set_sub_tbname)(TAOS_STMT *stmt, const char *name) = NULL;
+int (*fp_taos_stmt_get_tag_fields)(TAOS_STMT *stmt, int *fieldNum, TAOS_FIELD_E **fields) = NULL;
+int (*fp_taos_stmt_get_col_fields)(TAOS_STMT *stmt, int *fieldNum, TAOS_FIELD_E **fields) = NULL;
+void (*fp_taos_stmt_reclaim_fields)(TAOS_STMT *stmt, TAOS_FIELD_E *fields) = NULL;
+
+int (*fp_taos_stmt_is_insert)(TAOS_STMT *stmt, int *insert) = NULL;
+int (*fp_taos_stmt_num_params)(TAOS_STMT *stmt, int *nums) = NULL;
+int (*fp_taos_stmt_get_param)(TAOS_STMT *stmt, int idx, int *type, int *bytes) = NULL;
+int (*fp_taos_stmt_bind_param)(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) = NULL;
+int (*fp_taos_stmt_bind_param_batch)(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) = NULL;
+int (*fp_taos_stmt_bind_single_param_batch)(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, int colIdx) = NULL;
+int (*fp_taos_stmt_add_batch)(TAOS_STMT *stmt) = NULL;
+int (*fp_taos_stmt_execute)(TAOS_STMT *stmt) = NULL;
+TAOS_RES *(*fp_taos_stmt_use_result)(TAOS_STMT *stmt) = NULL;
+int (*fp_taos_stmt_close)(TAOS_STMT *stmt) = NULL;
+char *(*fp_taos_stmt_errstr)(TAOS_STMT *stmt) = NULL;
+int (*fp_taos_stmt_affected_rows)(TAOS_STMT *stmt) = NULL;
+int (*fp_taos_stmt_affected_rows_once)(TAOS_STMT *stmt) = NULL;
+
+TAOS_STMT2 *(*fp_taos_stmt2_init)(TAOS *taos, TAOS_STMT2_OPTION *option) = NULL;
+int (*fp_taos_stmt2_prepare)(TAOS_STMT2 *stmt, const char *sql, unsigned long length) = NULL;
+int (*fp_taos_stmt2_bind_param)(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col_idx) = NULL;
+int (*fp_taos_stmt2_bind_param_a)(TAOS_STMT2 *stmt, TAOS_STMT2_BINDV *bindv, int32_t col_idx, __taos_async_fn_t fp,
+                                  void *param) = NULL;
+int (*fp_taos_stmt2_exec)(TAOS_STMT2 *stmt, int *affected_rows) = NULL;
+int (*fp_taos_stmt2_close)(TAOS_STMT2 *stmt) = NULL;
+int (*fp_taos_stmt2_is_insert)(TAOS_STMT2 *stmt, int *insert) = NULL;
+int (*fp_taos_stmt2_get_fields)(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_ALL **fields) = NULL;
+void (*fp_taos_stmt2_free_fields)(TAOS_STMT2 *stmt, TAOS_FIELD_ALL *fields) = NULL;
+TAOS_RES *(*fp_taos_stmt2_result)(TAOS_STMT2 *stmt) = NULL;
+char *(*fp_taos_stmt2_error)(TAOS_STMT2 *stmt) = NULL;
+
+TAOS_RES *(*fp_taos_query)(TAOS *taos, const char *sql) = NULL;
+TAOS_RES *(*fp_taos_query_with_reqid)(TAOS *taos, const char *sql, int64_t reqId) = NULL;
+
+TAOS_ROW (*fp_taos_fetch_row)(TAOS_RES *res) = NULL;
+int (*fp_taos_result_precision)(TAOS_RES *res) = NULL;  // get the time precision of result
+void (*fp_taos_free_result)(TAOS_RES *res) = NULL;
+void (*fp_taos_kill_query)(TAOS *taos) = NULL;
+int (*fp_taos_field_count)(TAOS_RES *res) = NULL;
+int (*fp_taos_num_fields)(TAOS_RES *res) = NULL;
+int (*fp_taos_affected_rows)(TAOS_RES *res) = NULL;
+int64_t (*fp_taos_affected_rows64)(TAOS_RES *res) = NULL;
+
+TAOS_FIELD *(*fp_taos_fetch_fields)(TAOS_RES *res) = NULL;
+TAOS_FIELD_E *(*fp_taos_fetch_fields_e)(TAOS_RES *res) = NULL;
+int (*fp_taos_select_db)(TAOS *taos, const char *db) = NULL;
+int (*fp_taos_print_row)(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) = NULL;
+int (*fp_taos_print_row_with_size)(char *str, uint32_t size, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) = NULL;
+void (*fp_taos_stop_query)(TAOS_RES *res) = NULL;
+bool (*fp_taos_is_null)(TAOS_RES *res, int32_t row, int32_t col) = NULL;
+int (*fp_taos_is_null_by_column)(TAOS_RES *res, int columnIndex, bool result[], int *rows) = NULL;
+bool (*fp_taos_is_update_query)(TAOS_RES *res) = NULL;
+int (*fp_taos_fetch_block)(TAOS_RES *res, TAOS_ROW *rows) = NULL;
+int (*fp_taos_fetch_block_s)(TAOS_RES *res, int *numOfRows, TAOS_ROW *rows) = NULL;
+int (*fp_taos_fetch_raw_block)(TAOS_RES *res, int *numOfRows, void **pData) = NULL;
+int *(*fp_taos_get_column_data_offset)(TAOS_RES *res, int columnIndex) = NULL;
+int (*fp_taos_validate_sql)(TAOS *taos, const char *sql) = NULL;
+void (*fp_taos_reset_current_db)(TAOS *taos) = NULL;
+
+int *(*fp_taos_fetch_lengths)(TAOS_RES *res) = NULL;
+TAOS_ROW *(*fp_taos_result_block)(TAOS_RES *res) = NULL;
+
+const char *(*fp_taos_get_server_info)(TAOS *taos) = NULL;
+const char *(*fp_taos_get_client_info)() = NULL;
+int (*fp_taos_get_current_db)(TAOS *taos, char *database, int len, int *required) = NULL;
+
+const char *(*fp_taos_errstr)(TAOS_RES *res) = NULL;
+int (*fp_taos_errno)(TAOS_RES *res) = NULL;
+
+void (*fp_taos_query_a)(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param) = NULL;
+void (*fp_taos_query_a_with_reqid)(TAOS *taos, const char *sql, __taos_async_fn_t fp, void *param,
+                                   int64_t reqid) = NULL;
+void (*fp_taos_fetch_rows_a)(TAOS_RES *res, __taos_async_fn_t fp, void *param) = NULL;
+void (*fp_taos_fetch_raw_block_a)(TAOS_RES *res, __taos_async_fn_t fp, void *param) = NULL;
+const void *(*fp_taos_get_raw_block)(TAOS_RES *res) = NULL;
+
+int (*fp_taos_get_db_route_info)(TAOS *taos, const char *db, TAOS_DB_ROUTE_INFO *dbInfo) = NULL;
+int (*fp_taos_get_table_vgId)(TAOS *taos, const char *db, const char *table, int *vgId) = NULL;
+int (*fp_taos_get_tables_vgId)(TAOS *taos, const char *db, const char *table[], int tableNum, int *vgId) = NULL;
+
+int (*fp_taos_load_table_info)(TAOS *taos, const char *tableNameList) = NULL;
+
+void (*fp_taos_set_hb_quit)(int8_t quitByKill) = NULL;
+
+int (*fp_taos_set_notify_cb)(TAOS *taos, __taos_notify_fn_t fp, void *param, int type) = NULL;
+
+void (*fp_taos_fetch_whitelist_a)(TAOS *taos, __taos_async_whitelist_fn_t fp, void *param) = NULL;
+
+int (*fp_taos_set_conn_mode)(TAOS *taos, int mode, int value) = NULL;
+
+TAOS_RES *(*fp_taos_schemaless_insert)(TAOS *taos, char *lines[], int numLines, int protocol, int precision) = NULL;
+TAOS_RES *(*fp_taos_schemaless_insert_with_reqid)(TAOS *taos, char *lines[], int numLines, int protocol, int precision,
+                                                  int64_t reqid) = NULL;
+TAOS_RES *(*fp_taos_schemaless_insert_raw)(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol,
+                                           int precision) = NULL;
+TAOS_RES *(*fp_taos_schemaless_insert_raw_with_reqid)(TAOS *taos, char *lines, int len, int32_t *totalRows,
+                                                      int protocol, int precision, int64_t reqid) = NULL;
+TAOS_RES *(*fp_taos_schemaless_insert_ttl)(TAOS *taos, char *lines[], int numLines, int protocol, int precision,
+                                           int32_t ttl) = NULL;
+TAOS_RES *(*fp_taos_schemaless_insert_ttl_with_reqid)(TAOS *taos, char *lines[], int numLines, int protocol,
+                                                      int precision, int32_t ttl, int64_t reqid) = NULL;
+TAOS_RES *(*fp_taos_schemaless_insert_raw_ttl)(TAOS *taos, char *lines, int len, int32_t *totalRows, int protocol,
+                                               int precision, int32_t ttl) = NULL;
+TAOS_RES *(*fp_taos_schemaless_insert_raw_ttl_with_reqid)(TAOS *taos, char *lines, int len, int32_t *totalRows,
+                                                          int protocol, int precision, int32_t ttl,
+                                                          int64_t reqid) = NULL;
+TAOS_RES *(*fp_taos_schemaless_insert_raw_ttl_with_reqid_tbname_key)(TAOS *taos, char *lines, int len,
+                                                                     int32_t *totalRows, int protocol, int precision,
+                                                                     int32_t ttl, int64_t reqid,
+                                                                     char *tbnameKey) = NULL;
+TAOS_RES *(*fp_taos_schemaless_insert_ttl_with_reqid_tbname_key)(TAOS *taos, char *lines[], int numLines, int protocol,
+                                                                 int precision, int32_t ttl, int64_t reqid,
+                                                                 char *tbnameKey) = NULL;
+
+tmq_conf_t *(*fp_tmq_conf_new)() = NULL;
+tmq_conf_res_t (*fp_tmq_conf_set)(tmq_conf_t *conf, const char *key, const char *value) = NULL;
+void (*fp_tmq_conf_destroy)(tmq_conf_t *conf) = NULL;
+void (*fp_tmq_conf_set_auto_commit_cb)(tmq_conf_t *conf, tmq_commit_cb *cb, void *param) = NULL;
+
+tmq_list_t *(*fp_tmq_list_new)() = NULL;
+int32_t (*fp_tmq_list_append)(tmq_list_t *, const char *) = NULL;
+void (*fp_tmq_list_destroy)(tmq_list_t *) = NULL;
+int32_t (*fp_tmq_list_get_size)(const tmq_list_t *) = NULL;
+char **(*fp_tmq_list_to_c_array)(const tmq_list_t *) = NULL;
+
+tmq_t *(*fp_tmq_consumer_new)(tmq_conf_t *conf, char *errstr, int32_t errstrLen) = NULL;
+int32_t (*fp_tmq_subscribe)(tmq_t *tmq, const tmq_list_t *topic_list) = NULL;
+int32_t (*fp_tmq_unsubscribe)(tmq_t *tmq) = NULL;
+int32_t (*fp_tmq_subscription)(tmq_t *tmq, tmq_list_t **topics) = NULL;
+TAOS_RES *(*fp_tmq_consumer_poll)(tmq_t *tmq, int64_t timeout) = NULL;
+int32_t (*fp_tmq_consumer_close)(tmq_t *tmq) = NULL;
+int32_t (*fp_tmq_commit_sync)(tmq_t *tmq, const TAOS_RES *msg) = NULL;
+void (*fp_tmq_commit_async)(tmq_t *tmq, const TAOS_RES *msg, tmq_commit_cb *cb, void *param) = NULL;
+int32_t (*fp_tmq_commit_offset_sync)(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset) = NULL;
+void (*fp_tmq_commit_offset_async)(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset, tmq_commit_cb *cb,
+                                   void *param) = NULL;
+int32_t (*fp_tmq_get_topic_assignment)(tmq_t *tmq, const char *pTopicName, tmq_topic_assignment **assignment,
+                                       int32_t *numOfAssignment) = NULL;
+void (*fp_tmq_free_assignment)(tmq_topic_assignment *pAssignment) = NULL;
+int32_t (*fp_tmq_offset_seek)(tmq_t *tmq, const char *pTopicName, int32_t vgId, int64_t offset) = NULL;
+int64_t (*fp_tmq_position)(tmq_t *tmq, const char *pTopicName, int32_t vgId) = NULL;
+int64_t (*fp_tmq_committed)(tmq_t *tmq, const char *pTopicName, int32_t vgId) = NULL;
+
+TAOS *(*fp_tmq_get_connect)(tmq_t *tmq) = NULL;
+const char *(*fp_tmq_get_table_name)(TAOS_RES *res) = NULL;
+tmq_res_t (*fp_tmq_get_res_type)(TAOS_RES *res) = NULL;
+const char *(*fp_tmq_get_topic_name)(TAOS_RES *res) = NULL;
+const char *(*fp_tmq_get_db_name)(TAOS_RES *res) = NULL;
+int32_t (*fp_tmq_get_vgroup_id)(TAOS_RES *res) = NULL;
+int64_t (*fp_tmq_get_vgroup_offset)(TAOS_RES *res) = NULL;
+const char *(*fp_tmq_err2str)(int32_t code) = NULL;
+
+int32_t (*fp_tmq_get_raw)(TAOS_RES *res, tmq_raw_data *raw) = NULL;
+int32_t (*fp_tmq_write_raw)(TAOS *taos, tmq_raw_data raw) = NULL;
+int (*fp_taos_write_raw_block)(TAOS *taos, int numOfRows, char *pData, const char *tbname) = NULL;
+int (*fp_taos_write_raw_block_with_reqid)(TAOS *taos, int numOfRows, char *pData, const char *tbname,
+                                          int64_t reqid) = NULL;
+int (*fp_taos_write_raw_block_with_fields)(TAOS *taos, int rows, char *pData, const char *tbname, TAOS_FIELD *fields,
+                                           int numFields) = NULL;
+int (*fp_taos_write_raw_block_with_fields_with_reqid)(TAOS *taos, int rows, char *pData, const char *tbname,
+                                                      TAOS_FIELD *fields, int numFields, int64_t reqid) = NULL;
+void (*fp_tmq_free_raw)(tmq_raw_data raw) = NULL;
+char *(*fp_tmq_get_json_meta)(TAOS_RES *res) = NULL;
+void (*fp_tmq_free_json_meta)(char *jsonMeta) = NULL;
+
+TSDB_SERVER_STATUS (*fp_taos_check_server_status)(const char *fqdn, int port, char *details, int maxlen) = NULL;
+void (*fp_taos_write_crashinfo)(int signum, void *sigInfo, void *context) = NULL;
+char *(*fp_getBuildInfo)() = NULL;

source/dnode/mgmt/node_util/CMakeLists.txt

@@ -6,5 +6,5 @@ target_include_directories(
     PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/inc"
 )
 target_link_libraries(
-    node_util cjson mnode vnode qnode snode wal sync ${TAOS_LIB_STATIC} tfs monitor monitorfw
+    node_util cjson mnode vnode qnode snode wal sync ${TAOS_NATIVE_LIB_STATIC} tfs monitor monitorfw
 )

source/libs/catalog/test/CMakeLists.txt

@@ -9,7 +9,7 @@ IF(NOT TD_DARWIN)
         ADD_EXECUTABLE(catalogTest ${SOURCE_LIST})
         TARGET_LINK_LIBRARIES(
                 catalogTest
-                PUBLIC os util common nodes catalog transport gtest qcom ${TAOS_LIB_STATIC}
+                PUBLIC os util common nodes catalog transport gtest qcom ${TAOS_NATIVE_LIB_STATIC}
         )
 
         TARGET_INCLUDE_DIRECTORIES(
@@ -19,7 +19,7 @@ IF(NOT TD_DARWIN)
         )
 
         add_test(
-            NAME catalogTest
+                NAME catalogTest
-            COMMAND catalogTest
+                COMMAND catalogTest
         )
 ENDIF()

source/libs/executor/test/CMakeLists.txt

@@ -9,7 +9,7 @@ MESSAGE(STATUS "build parser unit test")
 # ADD_EXECUTABLE(executorTest ${SOURCE_LIST})
 # TARGET_LINK_LIBRARIES(
 # executorTest
-# PRIVATE os util common transport gtest ${TAOS_LIB_STATIC} qcom executor function planner scalar nodes vnode
+# PRIVATE os util common transport gtest ${TAOS_NATIVE_LIB_STATIC} qcom executor function planner scalar nodes vnode
 # )
 #
 # TARGET_INCLUDE_DIRECTORIES(

source/libs/scheduler/test/CMakeLists.txt

@@ -8,15 +8,15 @@ IF(NOT TD_DARWIN)
 
         ADD_EXECUTABLE(schedulerTest ${SOURCE_LIST})
 
-        IF (TD_GRANT)
+        IF(TD_GRANT)
                 TARGET_LINK_LIBRARIES(
                         schedulerTest
-                        PUBLIC os util common catalog transport gtest qcom ${TAOS_LIB_STATIC} planner scheduler grant
+                        PUBLIC os util common catalog transport gtest qcom ${TAOS_NATIVE_LIB_STATIC} planner scheduler grant
                 )
-        ELSE ()
+        ELSE()
                 TARGET_LINK_LIBRARIES(
                         schedulerTest
-                        PUBLIC os util common catalog transport gtest qcom ${TAOS_LIB_STATIC} planner scheduler
+                        PUBLIC os util common catalog transport gtest qcom ${TAOS_NATIVE_LIB_STATIC} planner scheduler
                 )
         ENDIF()
 
@@ -28,6 +28,5 @@ IF(NOT TD_DARWIN)
         add_test(
                 NAME schedulerTest
                 COMMAND schedulerTest
-            )
+        )
-        
 ENDIF()

source/os/CMakeLists.txt

@@ -85,6 +85,7 @@ else()
     )
 endif()
 
+
 if(JEMALLOC_ENABLED)
     add_dependencies(os jemalloc)
 endif()
@@ -96,3 +97,4 @@ endif()
 if(${BUILD_TEST})
     add_subdirectory(test)
 endif(${BUILD_TEST})
+

source/os/src/osDir.c

@@ -58,7 +58,7 @@ int32_t wordexp(char *words, wordexp_t *pwordexp, int32_t flags) {
 void wordfree(wordexp_t *pwordexp) {}
 
 #elif defined(DARWIN)
-
+#include <dlfcn.h>
 #include <dirent.h>
 #include <fcntl.h>
 #include <sys/stat.h>
@@ -77,6 +77,7 @@ typedef struct TdDir {
 
 #else
 
+#include <dlfcn.h>
 #include <dirent.h>
 #include <fcntl.h>
 #include <sys/stat.h>
@@ -372,8 +373,9 @@ int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen) {
 
 int32_t taosRealPath(char *dirname, char *realPath, int32_t maxlen) {
   OS_PARAM_CHECK(dirname);
+
 #ifndef TD_ASTRA
-  char tmp[PATH_MAX] = {0};
+  char tmp[PATH_MAX + 1] = {0};
 #ifdef WINDOWS
   if (_fullpath(tmp, dirname, maxlen) != NULL) {
 #else
@@ -602,6 +604,24 @@ void taosGetCwd(char *buf, int32_t len) {
 #endif
 }
 
+int32_t taosAppPath(char *path, int32_t maxLen) {
+  int32_t ret = 0;
+
+#ifdef WINDOWS
+  ret = GetModuleFileName(NULL, path, maxLen - 1);
+#elif defined(DARWIN)
+  ret = _NSGetExecutablePath(path, &maxLen) ;
+#else
+  ret = readlink("/proc/self/exe", path, maxLen - 1);
+#endif
+
+  if (ret >= 0) {
+    ret = (taosDirName(path) == NULL) ? -1 : 0;
+  }
+
+  return ret;
+}
+
 int32_t taosGetDirSize(const char *path, int64_t *size) {
   int32_t code = 0;
   char    fullPath[PATH_MAX + 100] = {0};
@@ -638,3 +658,54 @@ _OVER:
   TAOS_UNUSED(taosCloseDir(&pDir));
   return code;
 }
+
+
+void* taosLoadDll(const char* fileName) {
+#if defined(WINDOWS)
+  void* handle = LoadLibraryA(fileName);
+#else
+  void* handle = dlopen(fileName, RTLD_LAZY);
+#endif
+
+  if (handle == NULL) {
+    if (errno != 0) {
+      terrno = TAOS_SYSTEM_ERROR(errno);
+    } else {
+      terrno = TSDB_CODE_DLL_NOT_LOAD;
+    }
+  }
+
+  return handle;
+}
+
+void taosCloseDll(void* handle) {
+  if (handle == NULL) return;
+
+#if defined(WINDOWS)
+  FreeLibrary((HMODULE)handle);
+#else
+  if (dlclose(handle) != 0 && errno != 0) {
+      terrno = TAOS_SYSTEM_ERROR(errno);
+  }
+#endif
+}
+
+void* taosLoadDllFunc(void* handle, const char* funcName) {
+  if (handle == NULL) return NULL;
+
+#if defined(WINDOWS)
+  void *fptr = GetProcAddress((HMODULE)handle, funcName);
+#else
+  void *fptr = dlsym(handle, funcName);
+#endif
+
+  if (handle == NULL) {
+    if (errno != 0) {
+      terrno = TAOS_SYSTEM_ERROR(errno);
+    } else {
+      terrno = TSDB_CODE_DLL_FUNC_NOT_LOAD;
+    }
+  }
+
+  return fptr;
+}

source/os/src/osSystem.c

@@ -88,38 +88,6 @@ struct termios oldtio;
 
 typedef struct FILE TdCmd;
 
-#ifdef BUILD_NO_CALL
-void* taosLoadDll(const char* filename) {
-#if defined(WINDOWS)
-  return NULL;
-#elif defined(_TD_DARWIN_64)
-  return NULL;
-#else
-  void* handle = dlopen(filename, RTLD_LAZY);
-  if (!handle) {
-    // printf("load dll:%s failed, error:%s", filename, dlerror());
-    return NULL;
-  }
-
-  // printf("dll %s loaded", filename);
-
-  return handle;
-#endif
-}
-
-void taosCloseDll(void* handle) {
-#if defined(WINDOWS)
-  return;
-#elif defined(_TD_DARWIN_64)
-  return;
-#else
-  if (handle) {
-    dlclose(handle);
-  }
-#endif
-}
-#endif
-
 int32_t taosSetConsoleEcho(bool on) {
 #if defined(WINDOWS)
   HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);

source/util/src/terror.c

@@ -76,7 +76,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_REF_ID_REMOVED,               "Ref ID is removed")
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_INVALID_ID,               "Invalid Ref ID")
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_ALREADY_EXIST,            "Ref is already there")
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_NOT_EXIST,                "Ref is not there")
-
+TAOS_DEFINE_ERROR(TSDB_CODE_DLL_NOT_LOAD,                 "Driver was not loaded")
+TAOS_DEFINE_ERROR(TSDB_CODE_DLL_FUNC_NOT_LOAD,            "Function was not loaded from the driver")
 TAOS_DEFINE_ERROR(TSDB_CODE_APP_ERROR,                    "Unexpected generic error")
 TAOS_DEFINE_ERROR(TSDB_CODE_ACTION_IN_PROGRESS,           "Action in progress")
 TAOS_DEFINE_ERROR(TSDB_CODE_OUT_OF_RANGE,                 "Out of range")

source/util/src/tlog.c

@@ -1374,6 +1374,10 @@ static void checkWriteCrashLogToFileInNewThead() {
     }
     taosLogCrashInfo(gCrashBasicInfo.nodeType, pMsg, msgLen, gCrashBasicInfo.signum, gCrashBasicInfo.sigInfo);
     setCrashWriterStatus(CRASH_LOG_WRITER_INIT);
+    int32_t code = tsem_post(&gCrashBasicInfo.sem);
+    if (code != 0 ) {
+      uError("failed to post sem for crashBasicInfo, code:%d", code);
+    }
     TAOS_UNUSED(tsem_post(&gCrashBasicInfo.sem));
   }
 }

source/util/test/errorCodeTable.ini

@@ -17,6 +17,8 @@ TSDB_CODE_REF_ID_REMOVED                            = 0x80000107
 TSDB_CODE_REF_INVALID_ID                            = 0x80000108
 TSDB_CODE_REF_ALREADY_EXIST                         = 0x80000109
 TSDB_CODE_REF_NOT_EXIST                             = 0x8000010A
+TSDB_CODE_DLL_NOT_LOAD                              = 0x8000010B
+TSDB_CODE_DLL_FUNC_NOT_LOAD                         = 0x8000010C
 TSDB_CODE_APP_ERROR                                 = 0x80000110
 TSDB_CODE_ACTION_IN_PROGRESS                        = 0x80000111
 TSDB_CODE_OUT_OF_RANGE                              = 0x80000112

tests/army/cmdline/taosCli.py

@@ -57,31 +57,29 @@ class TDTestCase(TBase):
     def checkResultWithMode(self, db, stb, arg):
         result = "Query OK, 10 row(s)"
         mode = arg[0]
-        rowh = arg[1]
-        rowv = arg[2]
-        idx  = arg[3]
-        idxv = arg[4]
 
         # use db
-        if mode != "-R":
+        rlist = self.taos(f'{mode} -s "show databases;use {db};show databases;" ')
-            rlist = self.taos(f'{mode} -s "show databases;use {db};show databases;" ')
+        self.checkListString(rlist, "Database changed")
-            self.checkListString(rlist, "Database changed")
 
         # hori
-        cmd = f'{mode} -s "select * from {db}.{stb} limit 10'
+        cmd = f'{mode} -s "select ts,ic from {db}.{stb} limit 10'
         rlist = self.taos(cmd + '"')
-        # line count
+        results = [
-        self.checkSame(len(rlist), rowh)
+            "2022-10-01 00:00:09.000 |",
-        # last line
+            result
-        self.checkSame(rlist[idx][:len(result)], result)
+        ]
+        self.checkManyString(rlist, results)
 
         # vec
         rlist = self.taos(cmd + '\G"')
-        # line count
+        results = [
-        self.checkSame(len(rlist), rowv)
+            "****** 10.row *******",
-        self.checkSame(rlist[idxv], "*************************** 10.row ***************************")
+            "ts: 2022-10-01 00:00:09.000",
-        # last line
+            result
-        self.checkSame(rlist[idx][:len(result)], result)
+        ]
+        self.checkManyString(rlist, results)
+
 
         # -B have some problem need todo
         self.taos(f'{mode} -B -s "select * from {db}.{stb} where ts < 1"')
@@ -125,12 +123,16 @@ class TDTestCase(TBase):
         # insert
         json = "cmdline/json/taosCli.json"
         db, stb, childCount, insertRows = self.insertBenchJson(json)
+        # set
+        self.db  = db
+        self.stb = stb
+        self.insert_rows      = insertRows
+        self.childtable_count = childCount
 
         # native restful websock test
         args = [
-            ["",   18, 346, -2, 310], 
+            ["-Z native"], 
-            ["-R", 22, 350, -3, 313],
+            ["-T 40 -E http://localhost:6041"]
-            ["-T 40 -E http://localhost:6041", 21, 349, -3, 312]
         ]
         for arg in args:
             self.checkResultWithMode(db, stb, arg)
@@ -164,8 +166,7 @@ class TDTestCase(TBase):
 
     def checkDumpInOut(self):
         args = [
-            ["",   18], 
+            ["",   18],
-            ["-R ", 22],
             ["-E http://localhost:6041", 21]
         ]
 
@@ -181,10 +182,18 @@ class TDTestCase(TBase):
         rlist2 = self.taos("--version")
 
         self.checkSame(rlist1, rlist2)
-        self.checkSame(len(rlist1), 5)
+        if len(rlist1) < 4:
+            tdLog.exit(f"version lines less than 4. {rlist1}")
 
         if len(rlist1[2]) < 42:
             tdLog.exit("git commit id length is invalid: " + rlist1[2])
+        
+        keys = [
+            "version:",
+            "git:",
+            "build:"
+        ]
+        self.checkManyString(rlist1, keys)
 
 
     def checkHelp(self):
@@ -205,20 +214,13 @@ class TDTestCase(TBase):
     
     def checkCommand(self):
         # check coredump
-
-        # o logpath
-        char = 'a'
-        lname =f'-o "/root/log/{char * 1000}/" -s "quit;"' 
         queryOK = "Query OK"
 
-        # invalid input check
+        # support Both
         args = [
-            [lname, "failed to create log at"],
             ['-uroot -w 40 -ptaosdata -c /root/taos/ -s"show databases"', queryOK],
-            ['-o "./current/log/files/" -s"show databases;"', queryOK],
+            ['-o "./current/log/files/" -h localhost -uroot -ptaosdata  -s"show databases;"', queryOK],
-            ['-a ""', "Invalid auth"],
             ['-s "quit;"', "Welcome to the TDengine Command Line Interface"],
-            ['-a "abc"', "[0x80000357]"],
             ['-h "" -s "show dnodes;"', "Invalid host"],
             ['-u "" -s "show dnodes;"', "Invalid user"],
             ['-P "" -s "show dnodes;"', "Invalid port"],
@@ -226,7 +228,7 @@ class TDTestCase(TBase):
             ['-p"abc" -s "show dnodes;"', "[0x80000357]"],
             ['-d "abc" -s "show dnodes;"', "[0x80000388]"],
             ['-N 0 -s "show dnodes;"', "Invalid pktNum"],
-            ['-N 10 -s "show dnodes;"', queryOK],
+            ['-N 10 -h 127.0.0.1 -s "show dnodes;"', queryOK],
             ['-w 0 -s "show dnodes;"', "Invalid displayWidth"],
             ['-w 10 -s "show dnodes;"', queryOK],
             ['-W 10 -s "show dnodes;"', None],
@@ -240,10 +242,140 @@ class TDTestCase(TBase):
             ['-uroot -p < cmdline/data/pwd.txt -s "show dnodes;"', queryOK],
         ]
 
+        modes = ["-Z 0","-Z 1"]
+        for mode in modes:
+            for arg in args:
+                rlist = self.taos(mode + " " + arg[0])
+                if arg[1] != None:
+                    self.checkListString(rlist, arg[1])
+
+        #
+        # support native only
+        #
+        
+        # o logpath
+        char = 'a'
+        lname =f'-o "/root/log/{char * 1000}/" -s "quit;"' 
+
+        args = [
+            [lname, "failed to create log at"],
+            ['-a ""', "Invalid auth"],
+            ['-a "abc"', "[0x80000357]"],
+        ]
         for arg in args:
-            rlist = self.taos(arg[0])
+            rlist = self.taos("-Z 0 " + arg[0])
             if arg[1] != None:
-                self.checkListString(rlist, arg[1])    
+                self.checkListString(rlist, arg[1])
+
+    # expect cmd > json > evn
+    def checkPriority(self):
+        #
+        #  cmd & env
+        #
+        
+        # env  6043 - invalid
+        os.environ['TDENGINE_CLOUD_DSN'] = "http://127.0.0.1:6043"
+        # cmd 6041 - valid
+        cmd = f"-X http://127.0.0.1:6041 -s 'select ts from test.meters'"
+        rlist = self.taos(cmd, checkRun = True)
+        results = [
+            "WebSocket Client Version",
+            "2022-10-01 00:01:39.000", 
+            "Query OK, 200 row(s) in set"
+        ]
+        self.checkManyString(rlist, results)
+
+        #
+        # env
+        #
+
+        # cloud
+        os.environ['TDENGINE_CLOUD_DSN'] = "http://127.0.0.1:6041"
+        cmd = f"-s 'select ts from test.meters'"
+        rlist = self.taos(cmd, checkRun = True)
+        self.checkManyString(rlist, results)
+        # local
+        os.environ['TDENGINE_CLOUD_DSN'] = ""
+        os.environ['TDENGINE_DSN']       = "http://127.0.0.1:6041"
+        cmd = f"-s 'select ts from test.meters'"
+        rlist = self.taos(cmd, checkRun = True)
+        self.checkManyString(rlist, results)
+        # local & cloud -> cloud first
+        os.environ['TDENGINE_CLOUD_DSN'] = "http://127.0.0.1:6041"  # valid
+        os.environ['TDENGINE_DSN']       = "http://127.0.0.1:6042"  # invalid
+        cmd = f"-s 'select ts from test.meters'"
+        rlist = self.taos(cmd, checkRun = True)
+        self.checkManyString(rlist, results)
+
+
+        #
+        # cmd
+        #
+
+        os.environ['TDENGINE_CLOUD_DSN'] = ""
+        os.environ['TDENGINE_DSN']       = ""
+        cmd = f"-X http://127.0.0.1:6041 -s 'select ts from test.meters'"
+        rlist = self.taos(cmd, checkRun = True)
+        self.checkManyString(rlist, results)
+
+
+    def checkExceptCmd(self):
+        # exe
+        taos = frame.etool.taosFile()
+        # option
+        options = [
+            "-Z native -X http://127.0.0.1:6041",
+            "-Z 100",
+            "-Z abcdefg",
+            "-X",
+            "-X  ",
+            "-X 127.0.0.1:6041",
+            "-X https://gw.cloud.taosdata.com?token617ffdf...",
+            "-Z 1 -X https://gw.cloud.taosdata.com?token=617ffdf...",
+            "-X http://127.0.0.1:6042"
+        ]
+
+        # do check
+        for option in options:
+            self.checkExcept(taos + " -s 'show dnodes;' " + option)
+    
+    def checkModeVersion(self):    
+
+        # check default conn mode        
+        #DEFAULT_CONN = "WebSocket"
+        DEFAULT_CONN = "Native"
+
+        # results
+        results = [
+            f"{DEFAULT_CONN} Client Version",
+            "2022-10-01 00:01:39.000", 
+            "Query OK, 100 row(s) in set"
+        ]
+    
+        # default
+        cmd = f"-s 'select ts from test.d0'"
+        rlist = self.taos(cmd, checkRun = True)
+        self.checkManyString(rlist, results)
+        
+        # websocket
+        cmd = f"-Z 1 -s 'select ts from test.d0'"
+        results[0] = "WebSocket Client Version"
+        rlist = self.taos(cmd, checkRun = True)
+        self.checkManyString(rlist, results)        
+
+        # native
+        cmd = f"-Z 0 -s 'select ts from test.d0'"
+        results[0] = "Native Client Version"
+        rlist = self.taos(cmd, checkRun = True)
+        self.checkManyString(rlist, results)
+
+    def checkConnMode(self):
+        # priority
+        self.checkPriority()
+        # except
+        self.checkExceptCmd()
+        # mode version
+        self.checkModeVersion()
     
     # password
     def checkPassword(self):
@@ -288,6 +420,10 @@ class TDTestCase(TBase):
         # check data in/out
         self.checkDumpInOut()
 
+
+        # check conn mode
+        self.checkConnMode()
+
         # max password
         self.checkPassword()
 

tests/army/frame/caseBase.py

@@ -38,6 +38,12 @@ class TBase:
 
     # init
     def init(self, conn, logSql, replicaVar=1, db="db", stb="stb", checkColName="ic"):
+        
+        # init
+        self.childtable_count = 0
+        self.insert_rows      = 0
+        self.timestamp_step   = 0
+
         # save param
         self.replicaVar = int(replicaVar)
         tdSql.init(conn.cursor(), True)
@@ -54,12 +60,12 @@ class TBase:
         self.stb    = stb
 
         # sql 
-        self.sqlSum = f"select sum({checkColName}) from {self.stb}"
+        self.sqlSum = f"select sum({checkColName}) from {db}.{self.stb}"
-        self.sqlMax = f"select max({checkColName}) from {self.stb}"
+        self.sqlMax = f"select max({checkColName}) from {db}.{self.stb}"
-        self.sqlMin = f"select min({checkColName}) from {self.stb}"
+        self.sqlMin = f"select min({checkColName}) from {db}.{self.stb}"
-        self.sqlAvg = f"select avg({checkColName}) from {self.stb}"
+        self.sqlAvg = f"select avg({checkColName}) from {db}.{self.stb}"
-        self.sqlFirst = f"select first(ts) from {self.stb}"
+        self.sqlFirst = f"select first(ts) from {db}.{self.stb}"
-        self.sqlLast  = f"select last(ts) from {self.stb}"
+        self.sqlLast  = f"select last(ts) from {db}.{self.stb}"
 
     # stop
     def stop(self):
@@ -140,15 +146,15 @@ class TBase:
     # basic
     def checkInsertCorrect(self, difCnt = 0):
         # check count
-        sql = f"select count(*) from {self.stb}"
+        sql = f"select count(*) from {self.db}.{self.stb}"
         tdSql.checkAgg(sql, self.childtable_count * self.insert_rows)
 
         # check child table count
-        sql = f" select count(*) from (select count(*) as cnt , tbname from {self.stb} group by tbname) where cnt = {self.insert_rows} "
+        sql = f" select count(*) from (select count(*) as cnt , tbname from {self.db}.{self.stb} group by tbname) where cnt = {self.insert_rows} "
         tdSql.checkAgg(sql, self.childtable_count)
 
         # check step
-        sql = f"select count(*) from (select diff(ts) as dif from {self.stb} partition by tbname order by ts desc) where dif != {self.timestamp_step}"
+        sql = f"select count(*) from (select diff(ts) as dif from {self.db}.{self.stb} partition by tbname order by ts desc) where dif != {self.timestamp_step}"
         tdSql.checkAgg(sql, difCnt)
 
     # save agg result
@@ -172,27 +178,27 @@ class TBase:
     # self check 
     def checkConsistency(self, col):
         # top with max
-        sql = f"select max({col}) from {self.stb}"
+        sql = f"select max({col}) from {self.db}.{self.stb}"
         expect = tdSql.getFirstValue(sql)
-        sql = f"select top({col}, 5) from {self.stb}"
+        sql = f"select top({col}, 5) from {self.db}.{self.stb}"
         tdSql.checkFirstValue(sql, expect)
 
         #bottom with min
-        sql = f"select min({col}) from {self.stb}"
+        sql = f"select min({col}) from {self.db}.{self.stb}"
         expect = tdSql.getFirstValue(sql)
-        sql = f"select bottom({col}, 5) from {self.stb}"
+        sql = f"select bottom({col}, 5) from {self.db}.{self.stb}"
         tdSql.checkFirstValue(sql, expect)
 
         # order by asc limit 1 with first
-        sql = f"select last({col}) from {self.stb}"
+        sql = f"select last({col}) from {self.db}.{self.stb}"
         expect = tdSql.getFirstValue(sql)
-        sql = f"select {col} from {self.stb} order by _c0 desc limit 1"
+        sql = f"select {col} from {self.db}.{self.stb} order by _c0 desc limit 1"
         tdSql.checkFirstValue(sql, expect)
 
         # order by desc limit 1 with last
-        sql = f"select first({col}) from {self.stb}"
+        sql = f"select first({col}) from {self.db}.{self.stb}"
         expect = tdSql.getFirstValue(sql)
-        sql = f"select {col} from {self.stb} order by _c0 asc limit 1"
+        sql = f"select {col} from {self.db}.{self.stb} order by _c0 asc limit 1"
         tdSql.checkFirstValue(sql, expect)
 
 
@@ -243,6 +249,17 @@ class TBase:
         else:
             tdLog.exit(f"check same failed. real={real} expect={expect}.")
 
+    # check except
+    def checkExcept(self, command):
+        try:
+            code = frame.eos.exe(command, show = True)
+            if code == 0:
+                tdLog.exit(f"Failed, not report error cmd:{command}")
+            else:
+                tdLog.info(f"Passed, report error code={code} is expect, cmd:{command}")
+        except:
+            tdLog.info(f"Passed, catch expect report error for command {command}")
+
 #
 #   get db information
 #
@@ -292,7 +309,8 @@ class TBase:
     def taosdump(self, command, show = True, checkRun = True, retFail = True):
         return frame.etool.runBinFile("taosdump", command, show, checkRun, retFail)
 
-
+    def benchmark(self, command, show = True, checkRun = True, retFail = True):
+        return frame.etool.runBinFile("taosBenchmark", command, show, checkRun, retFail)
 #
 #   util 
 #
@@ -335,15 +353,22 @@ class TBase:
 
 
     # check list have str
-    def checkListString(self, vlist, s):
+    def checkListString(self, rlist, s):
-        for i in range(len(vlist)):
+        if s is None:
-            if vlist[i].find(s) != -1:
+            return 
+        for i in range(len(rlist)):
+            if rlist[i].find(s) != -1:
                 # found
-                tdLog.info(f'found "{s}" on index {i} , line={vlist[i]}')
+                tdLog.info(f'found "{s}" on index {i} , line={rlist[i]}')
                 return 
 
         # not found
-        tdLog.exit(f'faild, not found "{s}" on list:{vlist}')
+        tdLog.exit(f'faild, not found "{s}" on list:{rlist}')
+    
+    # check many string
+    def checkManyString(self, rlist, manys):
+        for s in manys:
+            self.checkListString(rlist, s)
 
 #
 #  str util
@@ -480,6 +505,23 @@ class TBase:
 
         return rlist
 
+    # cmd
+    def benchmarkCmd(self, options, childCnt, insertRows, timeStep, results):
+        # set
+        self.childtable_count = childCnt
+        self.insert_rows      = insertRows
+        self.timestamp_step   = timeStep
+
+        # run
+        cmd = f"{options} -t {childCnt} -n {insertRows} -S {timeStep} -y"
+        rlist = self.benchmark(cmd)
+        for result in results:
+            self.checkListString(rlist, result)
+
+        # check correct
+        self.checkInsertCorrect()    
+
+
     # generate new json file
     def genNewJson(self, jsonFile, modifyFunc=None):
         try:

tests/army/frame/etool.py

@@ -23,6 +23,14 @@ import frame.epath
 import frame.eos
 from frame.log import *
 
+
+# taos
+def taosFile():
+    bmFile = frame.epath.binFile("taos")
+    if frame.eos.isWin():
+        bmFile += ".exe"
+    return bmFile
+
 # taosdump
 def taosDumpFile():
     bmFile = frame.epath.binFile("taosdump")

tests/army/output.txt

@@ -1,52 +0,0 @@
-[02/10 13:52:16.164959] SUCC: created database (test)
-[02/10 13:52:16.182024] INFO: start creating 1000 table(s) with 8 thread(s)
-[02/10 13:52:16.396337] SUCC: Spent 0.2140 seconds to create 1000 table(s) with 8 thread(s) speed: 4673 tables/s, already exist 0 table(s), actual 1000 table(s) pre created, 0 table(s) will be auto created
-[02/10 13:53:05.155428] SUCC: thread[2] progressive mode, completed total inserted rows: 12500000, 339193.01 records/second
-[02/10 13:53:05.160652] SUCC: thread[7] progressive mode, completed total inserted rows: 12500000, 341816.65 records/second
-[02/10 13:53:05.207601] SUCC: thread[0] progressive mode, completed total inserted rows: 12500000, 340556.51 records/second
-[02/10 13:53:05.215370] SUCC: thread[4] progressive mode, completed total inserted rows: 12500000, 338804.97 records/second
-[02/10 13:53:05.224077] SUCC: thread[5] progressive mode, completed total inserted rows: 12500000, 338596.28 records/second
-[02/10 13:53:05.249786] SUCC: thread[1] progressive mode, completed total inserted rows: 12500000, 339208.40 records/second
-[02/10 13:53:05.256970] SUCC: thread[3] progressive mode, completed total inserted rows: 12500000, 339174.04 records/second
-[02/10 13:53:05.274900] SUCC: thread[6] progressive mode, completed total inserted rows: 12500000, 339551.12 records/second
-[02/10 13:53:05.275900] SUCC: Spent 48.867685 (real 36.806958) seconds to insert rows: 100000000 with 8 thread(s) into test 2046342.08 (real 2716877.61) records/second
-[02/10 13:53:05.275909] SUCC: insert delay, min: 11.2580ms, avg: 29.4456ms, p90: 32.7750ms, p95: 34.1120ms, p99: 39.5900ms, max: 70.3780ms
-[02/12 15:46:06.469780] SUCC: created database (test)
-[02/12 15:46:06.499844] INFO: start creating 10000 table(s) with 8 thread(s)
-[02/12 15:46:08.185009] SUCC: Spent 1.6860 seconds to create 10000 table(s) with 8 thread(s) speed: 5931 tables/s, already exist 0 table(s), actual 10000 table(s) pre created, 0 table(s) will be auto created
-[02/12 15:46:57.356674] SUCC: thread[0] progressive mode, completed total inserted rows: 12500000, 339076.93 records/second
-[02/12 15:46:57.434553] SUCC: thread[1] progressive mode, completed total inserted rows: 12500000, 338528.52 records/second
-[02/12 15:46:57.452522] SUCC: thread[2] progressive mode, completed total inserted rows: 12500000, 339844.37 records/second
-[02/12 15:46:57.452921] SUCC: thread[5] progressive mode, completed total inserted rows: 12500000, 339349.90 records/second
-[02/12 15:46:57.463726] SUCC: thread[4] progressive mode, completed total inserted rows: 12500000, 339986.37 records/second
-[02/12 15:46:57.466467] SUCC: thread[3] progressive mode, completed total inserted rows: 12500000, 339785.50 records/second
-[02/12 15:46:57.499118] SUCC: thread[6] progressive mode, completed total inserted rows: 12500000, 339326.86 records/second
-[02/12 15:46:57.501694] SUCC: thread[7] progressive mode, completed total inserted rows: 12500000, 338309.30 records/second
-[02/12 15:46:57.502535] SUCC: Spent 49.309586 (real 36.843268) seconds to insert rows: 100000000 with 8 thread(s) into test 2028003.24 (real 2714200.05) records/second
-[02/12 15:46:57.502546] SUCC: insert delay, min: 10.9580ms, avg: 29.4746ms, p90: 32.6960ms, p95: 33.8290ms, p99: 36.8390ms, max: 77.9940ms
-[02/14 15:27:32.543409] SUCC: created database (test)
-[02/14 15:27:32.568881] INFO: start creating 10000 table(s) with 8 thread(s)
-[02/14 15:27:34.249759] SUCC: Spent 1.6810 seconds to create 10000 table(s) with 8 thread(s) speed: 5949 tables/s, already exist 0 table(s), actual 10000 table(s) pre created, 0 table(s) will be auto created
-[02/14 15:28:26.165699] SUCC: thread[0] progressive mode, completed total inserted rows: 12500000, 321266.73 records/second
-[02/14 15:28:26.281188] SUCC: thread[4] progressive mode, completed total inserted rows: 12500000, 319863.00 records/second
-[02/14 15:28:26.326975] SUCC: thread[5] progressive mode, completed total inserted rows: 12500000, 321802.51 records/second
-[02/14 15:28:26.328615] SUCC: thread[6] progressive mode, completed total inserted rows: 12500000, 321804.13 records/second
-[02/14 15:28:26.379189] SUCC: thread[7] progressive mode, completed total inserted rows: 12500000, 320719.22 records/second
-[02/14 15:28:26.400891] SUCC: thread[1] progressive mode, completed total inserted rows: 12500000, 321512.59 records/second
-[02/14 15:28:26.470912] SUCC: thread[2] progressive mode, completed total inserted rows: 12500000, 319026.94 records/second
-[02/14 15:28:26.565079] SUCC: thread[3] progressive mode, completed total inserted rows: 12500000, 317248.21 records/second
-[02/14 15:28:26.566013] SUCC: Spent 52.307623 (real 39.013939) seconds to insert rows: 100000000 with 8 thread(s) into test 1911767.24 (real 2563186.45) records/second
-[02/14 15:28:26.566024] SUCC: insert delay, min: 11.1290ms, avg: 31.2112ms, p90: 35.4900ms, p95: 37.0580ms, p99: 41.5180ms, max: 68.5900ms
-[02/17 14:09:42.181835] SUCC: created database (test)
-[02/17 14:09:42.210373] INFO: start creating 10000 table(s) with 8 thread(s)
-[02/17 14:09:44.199467] SUCC: Spent 1.9890 seconds to create 10000 table(s) with 8 thread(s) speed: 5028 tables/s, already exist 0 table(s), actual 10000 table(s) pre created, 0 table(s) will be auto created
-[02/17 14:10:32.845475] SUCC: thread[3] progressive mode, completed total inserted rows: 12500000, 338184.62 records/second
-[02/17 14:10:32.872586] SUCC: thread[4] progressive mode, completed total inserted rows: 12500000, 338445.48 records/second
-[02/17 14:10:32.873271] SUCC: thread[1] progressive mode, completed total inserted rows: 12500000, 339256.73 records/second
-[02/17 14:10:32.938231] SUCC: thread[5] progressive mode, completed total inserted rows: 12500000, 338737.29 records/second
-[02/17 14:10:32.947655] SUCC: thread[2] progressive mode, completed total inserted rows: 12500000, 338938.99 records/second
-[02/17 14:10:32.952985] SUCC: thread[0] progressive mode, completed total inserted rows: 12500000, 338652.89 records/second
-[02/17 14:10:32.962370] SUCC: thread[6] progressive mode, completed total inserted rows: 12500000, 338890.00 records/second
-[02/17 14:10:32.998729] SUCC: thread[7] progressive mode, completed total inserted rows: 12500000, 339216.19 records/second
-[02/17 14:10:32.999680] SUCC: Spent 48.790057 (real 36.896020) seconds to insert rows: 100000000 with 8 thread(s) into test 2049597.93 (real 2710319.43) records/second
-[02/17 14:10:32.999696] SUCC: insert delay, min: 10.7720ms, avg: 29.5168ms, p90: 32.6910ms, p95: 33.8370ms, p99: 36.6750ms, max: 76.0590ms

tests/army/pytest.sh

@@ -89,6 +89,10 @@ else
   export LD_PRELOAD="$(realpath "$(gcc -print-file-name=libasan.so)") $(realpath "$(gcc -print-file-name=libstdc++.so)")"
   echo "Preload AsanSo:" $?
 
+  export ASAN_OPTIONS=detect_odr_violation=0
+  echo "forbid check ODR violation."
+
+
   $* -a 2>$AsanFile
 
   unset LD_PRELOAD