Merge branch 'main' of github.com:taosdata/TDengine into test/main/TD-32816

Jenkinsfile2

@@ -1,9 +1,11 @@
 import hudson.model.Result
 import hudson.model.*;
 import jenkins.model.CauseOfInterruption
-docs_only=0
 node {
 }
+file_zh_changed = ''
+file_en_changed = ''
+file_no_doc_changed = ''
 def abortPreviousBuilds() {
     def currentJobName = env.JOB_NAME
     def currentBuildNumber = env.BUILD_NUMBER.toInteger()
@@ -29,7 +31,7 @@ def abort_previous(){
     if (buildNumber > 1) milestone(buildNumber - 1)
     milestone(buildNumber)
 }
-def check_docs() {
+def check_docs(){
     if (env.CHANGE_URL =~ /\/TDengine\//) {
         sh '''
             hostname
@@ -40,39 +42,94 @@ def check_docs() {
             cd ${WKC}
             git reset --hard
             git clean -f
-            rm -rf examples/rust/
             git remote prune origin
             git fetch
-        '''
+            git checkout ''' + env.CHANGE_TARGET + '''
-        script {
-            sh '''
-                cd ${WKC}
-                git checkout ''' + env.CHANGE_TARGET + '''
-            '''
-        }
-        sh '''
-            cd ${WKC}
-            git remote prune origin
             git pull >/dev/null
             git fetch origin +refs/pull/${CHANGE_ID}/merge
-            git checkout -qf FETCH_HEAD
+            git checkout -qf FETCH_HEAD 
         '''
-        def file_changed = sh (
+
+        file_zh_changed = sh (
             script: '''
                 cd ${WKC}
-                git --no-pager diff --name-only FETCH_HEAD `git merge-base FETCH_HEAD ${CHANGE_TARGET}`|grep -v "^docs/en/"|grep -v "^docs/zh/" || :
+                git --no-pager diff --name-only FETCH_HEAD `git merge-base FETCH_HEAD ${CHANGE_TARGET}`|grep  "^docs/zh/" || :
+            ''',
+            returnStdout: true
+        )
+
+        file_en_changed = sh (
+            script: '''
+                cd ${WKC}
+                git --no-pager diff --name-only FETCH_HEAD `git merge-base FETCH_HEAD ${CHANGE_TARGET}`|grep  "^docs/en/" || :
+            ''',
+            returnStdout: true
+        )
+        
+        file_no_doc_changed = sh (
+            script: '''
+                cd ${WKC}
+                git --no-pager diff --name-only FETCH_HEAD `git merge-base FETCH_HEAD ${CHANGE_TARGET}`|grep -v "^docs/en/"|grep -v "^docs/zh/"|grep -v "*.md" || :
             ''',
             returnStdout: true
         ).trim()
-        if (file_changed == '') {
+        echo "file_zh_changed: ${file_zh_changed}"
-            echo "docs PR"
+        echo "file_en_changed: ${file_en_changed}"
-            docs_only=1
+        echo "file_no_doc_changed: ${file_no_doc_changed}"
-        } else {
-            echo file_changed
-        }
-        env.FILE_CHANGED = file_changed
     }
 }
+
+def build_pre_docs(){
+    if (env.CHANGE_URL =~ /\/TDengine\//) {
+        sh '''
+            hostname
+            date
+            env
+        '''
+        
+        sh '''
+            cd ${DOC_WKC}/${td_repo}
+            git reset --hard
+            git clean -f
+            git remote prune origin
+            git fetch
+            git checkout ''' + env.CHANGE_TARGET + '''
+            git pull >/dev/null
+            git fetch origin +refs/pull/${CHANGE_ID}/merge
+            git checkout -qf FETCH_HEAD 
+        '''
+
+        sh '''
+             cd ${DOC_WKC}/${tools_repo}
+            git reset --hard
+            git clean -f
+            git fetch
+            git remote prune origin
+            git checkout ''' + env.CHANGE_TARGET + '''
+            git pull >/dev/null
+        '''
+    }
+}
+
+def build_zh_docs(){
+    sh '''
+        cd ${DOC_WKC}/${zh_doc_repo}
+        # git pull 
+        yarn ass local
+        yarn build
+    '''
+}
+
+def build_en_docs(){
+    sh '''
+        cd ${DOC_WKC}/${en_doc_repo}
+        # git pull 
+        yarn ass local
+        yarn build
+    '''
+}
+
+
 def pre_test(){
     sh '''
         hostname
@@ -153,6 +210,7 @@ def pre_test(){
     '''
     return 1
 }
+
 def pre_test_build_mac() {
     sh '''
         hostname
@@ -173,6 +231,7 @@ def pre_test_build_mac() {
         date
     '''
 }
+
 def pre_test_win(){
     bat '''
         hostname
@@ -273,17 +332,8 @@ def pre_test_win(){
         cd %WIN_COMMUNITY_ROOT%
         git submodule update --init --recursive
     '''
-    bat '''
-        cd %WIN_CONNECTOR_ROOT%
-        git branch
-        git reset --hard
-        git pull
-    '''
-    bat '''
-        cd %WIN_CONNECTOR_ROOT%
-        git log -5
-    '''
 }
+
 def pre_test_build_win() {
     bat '''
         echo "building ..."
@@ -303,16 +353,14 @@ def pre_test_build_win() {
         time /t
     '''
     bat '''
-        cd %WIN_CONNECTOR_ROOT%
+        cd %WIN_COMMUNITY_ROOT%/tests/ci
-        python.exe -m pip install --upgrade pip
+        pip3 install taospy==2.7.16 
-        python -m pip uninstall taospy -y 
+        pip3 install taos-ws-py==0.3.3
-        python -m pip install taospy==2.7.16
-        python -m pip uninstall taos-ws-py -y 
-        python -m pip install taos-ws-py==0.3.3
         xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
     '''
     return 1
 }
+
 def run_win_ctest() {
     bat '''
         echo "windows ctest ..."
@@ -322,10 +370,10 @@ def run_win_ctest() {
         time /t
     '''
 }
+
 def run_win_test() {
     bat '''
         echo "windows test ..."
-        cd %WIN_CONNECTOR_ROOT%
         xcopy /e/y/i/f %WIN_INTERNAL_ROOT%\\debug\\build\\lib\\taos.dll C:\\Windows\\System32
         ls -l C:\\Windows\\System32\\taos.dll
         time /t
@@ -343,29 +391,67 @@ pipeline {
         WKDIR = '/var/lib/jenkins/workspace'
         WK = '/var/lib/jenkins/workspace/TDinternal'
         WKC = '/var/lib/jenkins/workspace/TDinternal/community'
-        WKPY = '/var/lib/jenkins/workspace/taos-connector-python'
+        DOC_WKC = '/root/doc_ci_work'
+        td_repo = 'TDengine'
+        zh_doc_repo = 'docs.taosdata.com'
+        en_doc_repo = 'docs.tdengine.com'
+        tools_repo = 'taos-tools'
     }
     stages {
-        stage('check') {
+        stage ('check doc file changed') {
+            agent{label " slave1_47 || slave1_48 || slave1_49 || slave1_50 || slave1_52  || slave1_59 || slave1_63 ||  worker03 || slave215 || slave217 || slave219 || Mac_catalina "}            
+            steps {
+                check_docs()
+            }
+        }
+        
+        stage ('pre for build docs') {
             when {
-                allOf {
+                beforeAgent true
-                    not { expression { env.CHANGE_BRANCH =~ /docs\// }}
+                expression { env.CHANGE_BRANCH =~ /(?i)doc.*/ || file_zh_changed != '' || file_en_changed != '' }
-                }
+            }
+            agent{label "doc_build_0_30"}
+            steps {
+                build_pre_docs()
+            }
+        }
+
+        stage('build Docs') {
+            when {
+                beforeAgent true
+                expression { env.CHANGE_BRANCH =~ /(?i)doc.*/ || file_zh_changed != '' || file_en_changed != '' }
             }
             parallel {
-                stage('check docs') {
+                stage('build zh docs') {
-                    agent{label " slave1_47 || slave1_48 || slave1_49 || slave1_50 || slave1_52  || slave1_59 || slave1_63 ||  worker03 || slave215 || slave217 || slave219 || Mac_catalina "}
+                    agent{label "doc_build_0_30"}
+                    when {
+                        expression { file_zh_changed != '' }
+                    }
                     steps {
-                        check_docs()
+                        build_zh_docs()
+                    }
+                }
+                stage('build en docs') {
+                    agent{label "doc_build_0_30"}
+                    when {
+                        expression { file_en_changed != '' }
+                    }
+                    steps {
+                        build_en_docs()
                     }
                 }
             }
+            post {
+                unsuccessful {
+                    error('build docs stage failed, terminating pipeline.')
+                }
+            }
         }
+
         stage('run test') {
             when {
                 allOf {
-                    not { expression { env.CHANGE_BRANCH =~ /docs\// }}
+                    not { expression { file_no_doc_changed == '' }}
-                    expression { docs_only == 0 }
                 }
             }
             parallel {
@@ -375,7 +461,6 @@ pipeline {
                         WIN_INTERNAL_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\TDinternal"
                         WIN_COMMUNITY_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\TDinternal\\community"
                         WIN_SYSTEM_TEST_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\TDinternal\\community\\tests\\system-test"
-                        WIN_CONNECTOR_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\taos-connector-python"
                     }
                     steps {
                         catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
@@ -420,7 +505,7 @@ pipeline {
                                 script {
                                     sh '''
                                     mkdir -p ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID}
-                                    echo "''' + env.FILE_CHANGED + '''" > ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID}/docs_changed.txt
+                                    echo "''' + file_no_doc_changed + '''" > ${WKDIR}/tmp/${BRANCH_NAME}_${BUILD_ID}/docs_changed.txt
                                     '''
                                     sh '''
                                        cd ${WKC}/tests/parallel_test
@@ -570,4 +655,4 @@ pipeline {
             )
         }
     } 
-}
+}

cmake/cmake.version

@@ -2,7 +2,7 @@
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "3.3.4.0.alpha")
+  SET(TD_VER_NUMBER "3.3.4.3.alpha")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

docs/en/28-releases/01-tdengine.md

@@ -20,6 +20,10 @@ For TDengine 2.x installation packages by version, please visit [here](https://t
 
 import Release from "/components/ReleaseV3";
 
+## 3.3.4.3
+
+<Release type="tdengine" version="3.3.4.3" />
+
 ## 3.3.3.0
 
 <Release type="tdengine" version="3.3.3.0" />

docs/zh/07-develop/07-tmq.md

@@ -16,7 +16,7 @@ TDengine 提供了类似于消息队列产品的数据订阅和消费接口。
 
 **注意**
 在 TDengine 连接器实现中，对于订阅查询，有以下限制。
-- 查询语句限制：订阅查询只能使用 select 语句，不支持其他类型的SQL，如 insert、update 或 delete 等。
+- 查询语句限制：订阅查询只能使用 select 语句，并不支持其他类型的SQL，如订阅库，订阅超级表（非 select 方式），insert、update 或 delete 等。
 - 原始始数据查询：订阅查询只能查询原始数据，而不能查询聚合或计算结果。
 - 时间顺序限制：订阅查询只能按照时间正序查询数据。
 

docs/zh/08-operation/06-gui.md

@@ -165,6 +165,10 @@ toc_max_heading_level: 4
 第一步 填写添加新主题需要的信息，点击“创建”按钮；
 ![topic-03-addTopicWizard.jpeg](./pic/topic-03-addTopicWizard.jpeg "添加新主题 Wizard 页面")
 
+如上图，您可以选择是否 “同步 meta”。如果同步 meta 信息，则可以订阅到 meta 信息，比如增加或者删除超级表。
+
+您需要根据使用场景来选择是否开启，如果您引用 taos 连接器编写业务代码订阅 topic，则不能开启“同步 meta”，只能订阅数据；如果您创建 topic 在 explorer 配置同步任务使用，则可以开启“同步 meta”。
+
 第二步 页面出现以下记录，则证明创建成功。
 ![topic-05-addTopicSucc1.jpeg](./pic/topic-05-addTopicSucc1.jpeg "查看已创建的流计算")
 

docs/zh/14-reference/01-components/01-taosd.md

@@ -26,42 +26,66 @@ taosd 命令行参数如下
 :::
 
 ### 连接相关
-
+|参数名称|支持版本|参数含义|
-|        参数名称        |                                        参数说明                                         |
+|-----------------------|----------|-|
-| :--------------------: | :-------------------------------------------------------------------------------------: |
+|firstEp                |          |taosd 启动时，主动连接的集群中首个 dnode 的 end point，默认值 localhost:6030|
-|        firstEp         |      taosd 启动时，主动连接的集群中首个 dnode 的 end point，缺省值：localhost:6030      |
+|secondEp               |          |taosd 启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，无默认值|
-|        secondEp        | taosd 启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，缺省值：无 |
+|fqdn                   |          |taosd 监听的服务地址，默认为所在服务器上配置的第一个 hostname|
-|          fqdn          |        启动 taosd 后所监听的服务地址，缺省值：所在服务器上配置的第一个 hostname         |
+|serverPort             |          |taosd 监听的端口，默认值 6030|
-|       serverPort       |                         启动 taosd 后所监听的端口，缺省值：6030                         |
+|compressMsgSize        |          |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；默认值 -1|
-|    numOfRpcSessions    |          允许一个 dnode 能发起的最大连接数，取值范围 100-100000，缺省值：30000           |
+|shellActivityTimer     |          |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3|
-| timeToGetAvailableConn |      获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，缺省值：500000       |
+|numOfRpcSessions       |          |RPC 支持的最大连接数，取值范围 100-100000，默认值 30000|
+|numOfRpcThreads        |          |RPC 线程数目，默认值为 CPU 核数的一半|
+|numOfTaskQueueThreads  |          |dnode 处理 RPC 消息的线程数|
+|statusInterval         |          |dnode 与 mnode 之间的心跳间隔|
+|rpcQueueMemoryAllowed  |          |dnode 允许的 rpc 消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10 |
+|resolveFQDNRetryTime   |          |FQDN 解析失败时的重试次数|
+|timeToGetAvailableConn |          |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，默认值 500000|
+|maxShellConns          |          |允许创建的最大链接数|
+|maxRetryWaitTime       |          |重连最大超时时间|
+|shareConnLimit         |3.3.4.3 后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10|
+|readTimeout            |3.3.4.3 后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900|
 
 ### 监控相关
-|      参数名称      |                                        参数说明                                        |
+|参数名称|支持版本|参数含义|
-| :----------------: | :------------------------------------------------------------------------------------: |
+|-----------------------|----------|-|
-|      monitor       |                   是否收集监控数据并上报，0: 关闭；1:打开；缺省值：0                   |
+|monitor                |          |是否收集监控数据并上报，0：关闭；1:打开；默认值 0|
-|    monitorFqdn     |                      taosKeeper 服务所在服务器的 FQDN，缺省值：无                      |
+|monitorFqdn            |          |taosKeeper 服务所在服务器的 FQDN，默认值 无|
-|    monitorPort     |                      taosKeeper 服务所监听的端口号，缺省值：6043                       |
+|monitorPort            |          |taosKeeper 服务所监听的端口号，默认值 6043|
-|  monitorInternal   | 监控数据库记录系统参数（CPU/内存）的时间间隔，单位是秒，取值范围 1-200000 ，缺省值：30 |
+|monitorInterval        |          |监控数据库记录系统参数（CPU/内存）的时间间隔，单位是秒，取值范围 1-200000 ，默认值 30|
-| telemetryReporting |                   是否上传 telemetry，0: 不上传，1：上传，缺省值：1                    |
+|monitorMaxLogs         |          |缓存的待上报日志条数|
-|   crashReporting   |                  是否上传 crash 信息；0: 不上传，1: 上传；缺省值： 1                   |
+|monitorComp            |          |是否采用压缩方式上报监控日志时|
+|monitorLogProtocol     |          |是否打印监控日志|
+|monitorForceV2         |          |是否使用 V2 版本协议上报|
+|telemetryReporting     |          |是否上传 telemetry，0：不上传，1：上传，默认值 1|
+|telemetryServer        |          |telemetry 服务器地址|
+|telemetryPort          |          |telemetry 服务器端口编号|
+|telemetryInterval      |          |telemetry 上传时间间隔，单位为秒，默认 43200|
+|crashReporting         |          |是否上传 crash 信息；0：不上传，1：上传；默认值  1|
 
 ### 查询相关
-
+|参数名称|支持版本|参数含义|
-|        参数名称        |                                                                                                                               参数说明                                                                                                                                |
+|------------------------|----------|-|
-| :--------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|countAlwaysReturnValue  |          |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致|
-|      queryPolicy       |                                             查询策略，1: 只使用 vnode，不使用 qnode; 2: 没有扫描算子的子任务在 qnode 执行，带扫描算子的子任务在 vnode 执行; 3: vnode 只运行扫描算子，其余算子均在 qnode 执行 ；4: 使用客户端聚合模式；缺省值：1                                              |
+|tagFilterCache          |          |是否缓存标签过滤结果|
-|  maxNumOfDistinctRes   |                                                                                                    允许返回的 distinct 结果最大行数，默认值 10 万，最大允许值 1 亿                                                                                                    |
+|maxNumOfDistinctRes     |          |允许返回的 distinct 结果最大行数，默认值 10 万，最大允许值 1 亿|
-| countAlwaysReturnValue | count/hyperloglog函数在输入数据为空或者NULL的情况下是否返回值，0: 返回空行，1: 返回；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了TSMA时, 且相应的组或窗口内数据为空或者NULL， 对应的组或窗口将不返回查询结果. 注意此参数客户端和服务端值应保持一致. |
+|queryBufferSize         |          |暂不生效|
-
+|queryRspPolicy          |          |查询响应策略|
+|filterScalarMode        |          |强制使用标量过滤模式，0：关闭；1：开启，默认值 0|
+|queryPlannerTrace       |          |内部参数，查询计划是否输出详细日志|
+|queryNodeChunkSize      |          |内部参数，查询计划的块大小|
+|queryUseNodeAllocator   |          |内部参数，查询计划的分配方法|
+|queryMaxConcurrentTables|          |内部参数，查询计划的并发数目|
+|queryRsmaTolerance      |          |内部参数，用于判定查询哪一级 rsma 数据时的容忍时间，单位为毫秒|
+|enableQueryHb           |          |内部参数，是否发送查询心跳消息|
+|pqSortMemThreshold      |          |内部参数，排序使用的内存阈值|
 
 ### 区域相关
-
+|参数名称|支持版本|参数含义|
-| 参数名称 |                                                 参数说明                                                 |
+|-----------------|----------|-|
-| :------: | :------------------------------------------------------------------------------------------------------: |
+|timezone         |          |时区；缺省从系统中动态获取当前的时区设置|
-| timezone |                                   时区，缺省值：当前服务器所配置的时区                                   |
+|locale           |          |系统区位信息及编码格式，缺省从系统中获取|
-|  locale  | 系统区位信息及编码格式 ，缺省值：系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过 API 设置 |
+|charset          |          |字符集编码，缺省从系统中获取|
-| charset  |                                     字符集编码，缺省值：系统自动获取                                     |
 
 :::info
 1. 为应对多时区的数据写入和查询问题，TDengine 采用 Unix 时间戳(Unix Timestamp)来记录和存储时间戳。Unix 时间戳的特点决定了任一时刻不论在任何时区，产生的时间戳均一致。需要注意的是，Unix 时间戳是在客户端完成转换和记录。为了确保客户端其他形式的时间转换为正确的 Unix 时间戳，需要设置正确的时区。
@@ -101,7 +125,7 @@ SELECT count(*) FROM table_name WHERE TS<1554984068000;
 
 客户端的输入的字符均采用操作系统当前默认的编码格式，在 Linux/macOS 系统上多为 UTF-8，部分中文系统编码则可能是 GB18030 或 GBK 等。在 docker 环境中默认的编码是 POSIX。在中文版 Windows 系统中，编码则是 CP936。客户端需要确保正确设置自己所使用的字符集，即客户端运行的操作系统当前编码字符集，才能保证 nchar 中的数据正确转换为 UCS4-LE 编码格式。
 
-在 Linux/macOS 中 locale 的命名规则为: \<语言>_\<地区>.\<字符集编码> 如：zh_CN.UTF-8，zh 代表中文，CN 代表大陆地区，UTF-8 表示字符集。字符集编码为客户端正确解析本地字符串提供编码转换的说明。Linux/macOS 可以通过设置 locale 来确定系统的字符编码，由于 Windows 使用的 locale 中不是 POSIX 标准的 locale 格式，因此在 Windows 下需要采用另一个配置参数 charset 来指定字符编码。在 Linux/macOS 中也可以使用 charset 来指定字符编码。
+在 Linux/macOS 中 locale 的命名规则为：\<语言>_\<地区>.\<字符集编码> 如：zh_CN.UTF-8，zh 代表中文，CN 代表大陆地区，UTF-8 表示字符集。字符集编码为客户端正确解析本地字符串提供编码转换的说明。Linux/macOS 可以通过设置 locale 来确定系统的字符编码，由于 Windows 使用的 locale 中不是 POSIX 标准的 locale 格式，因此在 Windows 下需要采用另一个配置参数 charset 来指定字符编码。在 Linux/macOS 中也可以使用 charset 来指定字符编码。
 
 
 3. 如果配置文件中不设置 charset，在 Linux/macOS 中，taos 在启动时候，自动读取系统当前的 locale 信息，并从 locale 信息中解析提取 charset 编码格式。如果自动读取 locale 信息失败，则尝试读取 charset 配置，如果读取 charset 配置也失败，则中断启动过程。
@@ -139,73 +163,148 @@ charset 的有效值是 UTF-8。
 :::
 
 ### 存储相关
-
+|参数名称|支持版本|参数含义|
-|     参数名称     |                                参数说明                                |
+|--------------------|----------|-|
-| :--------------: | :--------------------------------------------------------------------: |
+|dataDir             |          |数据文件目录，所有的数据文件都将写入该目录，默认值 /var/lib/taos|
-|     dataDir      |      数据文件目录，所有的数据文件都将写入该目录，缺省值：/var/lib/taos    |
+|tempDir             |          |指定所有系统运行过程中的临时文件生成的目录，默认值 /tmp|
-|     tempDir      |        指定所有系统运行过程中的临时文件生成的目录，缺省值：/tmp        |
+|minimalDataDirGB    |          |dataDir 指定的时序数据存储目录所需要保留的最小空间，单位 GB，默认值 2|
-| minimalTmpDirGB  |  tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，缺省值: 1  |
+|minimalTmpDirGB     |          |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，默认值 1|
-| minimalDataDirGB | dataDir 指定的时序数据存储目录所需要保留的最小空间，单位 GB，缺省值: 2 |
+|minDiskFreeSize     |3.1.1.0 后|当某块磁盘上的可用空间小于等于这个阈值时，该磁盘将不再被选择用于生成新的数据文件，单位为字节，取值范围 52428800-1073741824，默认值为 52428800；企业版参数|
+|s3MigrateIntervalSec|3.3.4.3 后|本地数据文件自动上传 S3 的触发周期，单位为秒。最小值：600；最大值：100000。默认值 3600；企业版参数|
+|s3MigrateEnabled    |3.3.4.3 后|是否自动进行 S3 迁移，默认值为 0，表示关闭自动 S3 迁移，可配置为 1；企业版参数|
+|s3Accesskey         |3.3.4.3 后|冒号分隔的用户 SecretId:SecretKey，例如 AKIDsQmwsfKxTo2A6nGVXZN0UlofKn6JRRSJ:lIdoy99ygEacU7iHfogaN2Xq0yumSm1E；企业版参数|
+|s3Endpoint          |3.3.4.3 后|用户所在地域的 COS 服务域名，支持 http 和 https，bucket 的区域需要与 endpoint 保持一致，否则无法访问；企业版参数|
+|s3BucketName        |3.3.4.3 后|存储桶名称，减号后面是用户注册 COS 服务的 AppId，其中 AppId 是 COS 特有，AWS 和阿里云都没有，配置时需要作为 bucket name 的一部分，使用减号分隔；参数值均为字符串类型，但不需要引号；例如 test0711-1309024725；企业版参数|
+|s3PageCacheSize     |3.3.4.3 后|S3 page cache 缓存页数目，取值范围 4-1048576，单位为页，默认值 4096；企业版参数|
+|s3UploadDelaySec    |3.3.4.3 后|data 文件持续多长时间不再变动后上传至 S3，取值范围 1-2592000 (30天），单位为秒，默认值 60；企业版参数|
+|cacheLazyLoadThreshold|        |内部参数，缓存的装载策略|
 
 ### 集群相关
+|参数名称|支持版本|参数含义|
+|--------------------------|----------|-|
+|supportVnodes             |          |dnode 支持的最大 vnode 数目，取值范围 0-4096，默认值 CPU 核数的 2 倍 + 5|
+|numOfCommitThreads        |          |落盘线程的最大数量，取值范围 0-1024，默认值为 4|
+|numOfMnodeReadThreads     |          |mnode 的 Read 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
+|numOfVnodeQueryThreads    |          |vnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）|
+|numOfVnodeFetchThreads    |          |vnode 的 Fetch 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
+|numOfVnodeRsmaThreads     |          |vnode 的 Rsma 线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不超过 4）|
+|numOfQnodeQueryThreads    |          |qnode 的 Query 线程数目，取值范围 0-1024，默认值为 CPU 核数的两倍（不超过 16）|
+|numOfSnodeSharedThreads   |          |snode 的共享线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）|
+|numOfSnodeUniqueThreads   |          |snode 的独占线程数目，取值范围 0-1024，默认值为 CPU 核数的四分之一（不小于 2，不超过 4）|
+|ratioOfVnodeStreamThreads |          |流计算使用 vnode 线程的比例，取值范围 0.01-4，默认值 4|
+|ttlUnit                   |          |ttl 参数的单位，取值范围 1-31572500，单位为秒，默认值 86400|
+|ttlPushInterval           |          |ttl 检测超时频率，取值范围 1-100000，单位为秒，默认值 10|
+|ttlChangeOnWrite          |          |ttl 到期时间是否伴随表的修改操作改变；0：不改变，1：改变；默认值为 0|
+|ttlBatchDropNum           |          |ttl 一批删除子表的数目，最小值为 0，默认值 10000|
+|retentionSpeedLimitMB     |          |数据在不同级别硬盘上迁移时的速度限制，取值范围 0-1024，单位 MB，默认值 0，表示不限制|
+|maxTsmaNum                |          |集群内可创建的TSMA个数；取值范围 0-3；默认值 3|
+|tmqMaxTopicNum            |          |订阅最多可建立的 topic 数量；取值范围 1-10000；默认值为 20|
+|tmqRowSize                |          |订阅数据块的最大记录条数，取值范围 1-1000000，默认值 4096|
+|audit                     |          |审计功能开关；企业版参数|
+|auditInterval             |          |审计数据上报的时间间隔；企业版参数|
+|auditCreateTable          |          |是否针对创建子表开启申计功能；企业版参数|
+|encryptAlgorithm          |          |数据加密算法；企业版参数|
+|encryptScope              |          |加密范围；企业版参数|
+|enableWhiteList           |          |白名单功能开关；企业版参数|
+|syncLogBufferMemoryAllowed|          |一个 dnode 允许的 sync 日志缓存消息占用的内存最大值，单位 bytes，取值范围 104857600-INT64_MAX，默认值 服务器内存的 1/10，3.1.3.2/3.3.2.13 版本开始生效 |
+|syncElectInterval         |          |内部参数，用于同步模块调试|
+|syncHeartbeatInterval     |          |内部参数，用于同步模块调试|
+|syncHeartbeatTimeout      |          |内部参数，用于同步模块调试|
+|syncSnapReplMaxWaitN      |          |内部参数，用于同步模块调试|
+|syncSnapReplMaxWaitN      |          |内部参数，用于同步模块调试|
+|arbHeartBeatIntervalSec   |          |内部参数，用于同步模块调试|
+|arbCheckSyncIntervalSec   |          |内部参数，用于同步模块调试|
+|arbSetAssignedTimeoutSec  |          |内部参数，用于同步模块调试|
+|mndSdbWriteDelta          |          |内部参数，用于 mnode 模块调试|
+|mndLogRetention           |          |内部参数，用于 mnode 模块调试|
+|skipGrant                 |          |内部参数，用于授权检查|
+|trimVDbIntervalSec        |          |内部参数，用于删除过期数据|
+|ttlFlushThreshold         |          |内部参数，ttl 定时器的频率|
+|compactPullupInterval     |          |内部参数，数据重整定时器的频率|
+|walFsyncDataSizeLimit     |          |内部参数，WAL 进行 FSYNC 的阈值|
+|transPullupInterval       |          |内部参数，mnode 执行事务的重试间隔|
+|mqRebalanceInterval       |          |内部参数，消费者再平衡的时间间隔|
+|uptimeInterval            |          |内部参数，用于记录系统启动时间|
+|timeseriesThreshold       |          |内部参数，用于统计用量|
+|udf                       |          |是否启动 UDF 服务；0：不启动，1：启动；默认值为 0 |
+|udfdResFuncs              |          |内部参数，用于 UDF 结果集设置|
+|udfdLdLibPath             |          |内部参数，表示 UDF 装载的库路径|
 
-|   参数名称    |                                  参数说明                                   |
-| :-----------: | :-------------------------------------------------------------------------: |
-| supportVnodes | dnode 支持的最大 vnode 数目，取值范围：0-4096，缺省值： CPU 核数的 2 倍 + 5 |
 
-### 内存相关
+### 流计算参数
-|      参数名称       |                    参数说明                     |
+|参数名称|支持版本|参数含义|
-| :----------------: | :---------------------------------------------: |
+|-----------------------|----------|-|
-| rpcQueueMemoryAllowed       | 一个 dnode 允许的 rpc 消息占用的内存最大值，单位 bytes，取值范围：104857600-INT64_MAX，缺省值：服务器内存的 1/10 |
+|disableStream          |          |流计算的启动开关|
-| syncLogBufferMemoryAllowed  | 一个 dnode 允许的 sync 日志缓存消息占用的内存最大值，单位 bytes，取值范围：104857600-INT64_MAX，缺省值：服务器内存的 1/10，3.1.3.2/3.3.2.13 版本开始生效 |
+|streamBufferSize       |          |控制内存中窗口状态缓存的大小，默认值为 128MB|
-
+|streamAggCnt           |          |内部参数，并发进行聚合计算的数目|
-### 性能调优
+|checkpointInterval     |          |内部参数，checkponit 同步间隔|
-
+|concurrentCheckpoint   |          |内部参数，是否并发检查 checkpoint|
-|      参数名称      |                    参数说明                     |
+|maxStreamBackendCache  |          |内部参数，流计算使用的最大缓存|
-| :----------------: | :---------------------------------------------: |
+|streamSinkDataRate     |          |内部参数，用于控制流计算结果的写入速度|
-| numOfCommitThreads | 落盘线程的最大数量，取值范围 0-1024，缺省值为 4 |
 
 ### 日志相关
+|参数名称|支持版本|参数含义|
+|----------------|----------|-|
+|logDir          |          |日志文件目录，运行日志将写入该目录，默认值 /var/log/taos|
+|minimalLogDirGB |          |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，默认值 1|
+|numOfLogLines   |          |单个日志文件允许的最大行数，默认值 10,000,000|
+|asyncLog        |          |日志写入模式，0：同步，1：异步，默认值 1|
+|logKeepDays     |          |日志文件的最长保存时间，单位：天，默认值 0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taosdlog.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件|
+|slowLogThreshold|3.3.3.0 后|慢查询门限值，大于等于门限值认为是慢查询，单位秒，默认值 3 |
+|slowLogMaxLen   |3.3.3.0 后|慢查询日志最大长度，取值范围 1-16384，默认值 4096|
+|slowLogScope    |3.3.3.0 后|慢查询记录类型，取值范围 ALL/QUERY/INSERT/OTHERS/NONE，默认值 QUERY|
+|slowLogExceptDb |3.3.3.0 后|指定的数据库不上报慢查询，仅支持配置换一个数据库|
+|debugFlag       |          |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）|
+|tmrDebugFlag    |          |定时器模块的日志开关，取值范围同上|
+|uDebugFlag      |          |共用功能模块的日志开关，取值范围同上|
+|rpcDebugFlag    |          |rpc 模块的日志开关，取值范围同上|
+|qDebugFlag      |          |query 模块的日志开关，取值范围同上|
+|dDebugFlag      |          |dnode 模块的日志开关，取值范围同上|
+|vDebugFlag      |          |vnode 模块的日志开关，取值范围同上|
+|mDebugFlag      |          |mnode 模块的日志开关，取值范围同上|
+|azDebugFlag     |3.3.4.3 后|S3 模块的日志开关，取值范围同上|
+|sDebugFlag      |          |sync 模块的日志开关，取值范围同上|
+|tsdbDebugFlag   |          |tsdb 模块的日志开关，取值范围同上|
+|tqDebugFlag     |          |tq 模块的日志开关，取值范围同上|
+|fsDebugFlag     |          |fs 模块的日志开关，取值范围同上|
+|udfDebugFlag    |          |udf 模块的日志开关，取值范围同上|
+|smaDebugFlag    |          |sma 模块的日志开关，取值范围同上|
+|idxDebugFlag    |          |index 模块的日志开关，取值范围同上|
+|tdbDebugFlag    |          |tdb 模块的日志开关，取值范围同上|
+|metaDebugFlag   |          |meta 模块的日志开关，取值范围同上|
+|stDebugFlag     |          |stream 模块的日志开关，取值范围同上|
+|sndDebugFlag    |          |snode 模块的日志开关，取值范围同上|
 
-|     参数名称     |                                                                           参数说明                                                                           |
+### 调试相关
-| :--------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|参数名称|支持版本|参数含义|
-|      logDir      |                                                  日志文件目录，运行日志将写入该目录，缺省值：/var/log/taos                                                   |
+|--------------------|----------|-|
-| minimalLogDirGB  |                                          当日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位GB，缺省值：1                                           |
+|enableCoreFile      |          |crash 时是否生成 core 文件，0：不生成，1：生成；默认值 1|
-|  numOfLogLines   |                                                        单个日志文件允许的最大行数，缺省值：10,000,000                                                        |
+|configDir           |          |配置文件所在目录|
-|     asyncLog     |                                                          日志写入模式，0: 同步，1: 异步，缺省值: 1                                                           |
+|scriptDir           |          |内部测试工具的脚本目录|
-|   logKeepDays    | 日志文件的最长保存时间 ，单位：天，缺省值：0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于0 的值时，当日志文件大小达到设置的上限时会被重命名为 taosdlog.xxx，其中 xxx 为日志文件最后修改的时间戳，并滚动产生新的日志文件 |
+|assert              |          |断言控制开关，默认值 0|
-| slowLogThreshold |                                                 慢查询门限值，大于等于门限值认为是慢查询，单位秒，默认值: 3                                                  |
+|randErrorChance     |          |内部参数，用于随机失败测试|
-|   slowLogScope   |                                      定启动记录哪些类型的慢查询，可选值：ALL, QUERY, INSERT, OHTERS, NONE; 默认值：ALL                                       |
+|randErrorDivisor    |          |内部参数，用于随机失败测试|
-|    debugFlag     |    运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）; 默认值：131 或 135 （取决于不同模块）    |
+|randErrorScope      |          |内部参数，用于随机失败测试|
-|   tmrDebugFlag   |                                                              定时器模块的日志开关，取值范围同上                                                              |
+|safetyCheckLevel    |          |内部参数，用于随机失败测试|
-|    uDebugFlag    |                                                             共用功能模块的日志开关，取值范围同上                                                             |
+|experimental        |          |内部参数，用于一些实验特性|
-|   rpcDebugFlag   |                                                               rpc 模块的日志开关，取值范围同上                                                               |
+|simdEnable          |3.3.4.3 后|内部参数，用于测试 SIMD 加速|
-|   cDebugFlag   |                                                               客户端模块的日志开关，取值范围同上                                                               |
+|AVX512Enable        |3.3.4.3 后|内部参数，用于测试 AVX512 加速|
-|   jniDebugFlag   |                                                               jni 模块的日志开关，取值范围同上                                                               |
+|rsyncPort           |          |内部参数，用于调试流计算|
-|    qDebugFlag    |                                                              query 模块的日志开关，取值范围同上                                                              |
+|snodeAddress        |          |内部参数，用于调试流计算|
-|    dDebugFlag    |                                                        dnode 模块的日志开关，取值范围同上，缺省值 135                                                        |
+|checkpointBackupDir |          |内部参数，用于恢复 snode 数据|
-|    vDebugFlag    |                                                              vnode 模块的日志开关，取值范围同上                                                              |
+|enableAuditDelete   |          |内部参数，用于测试审计功能|
-|    mDebugFlag    |                                                              mnode 模块的日志开关，取值范围同上                                                              |
+|slowLogThresholdTest|          |内部参数，用于测试慢日志|
-|    wDebugFlag    |                                                               wal 模块的日志开关，取值范围同上                                                               |
-|    sDebugFlag    |                                                              sync 模块的日志开关，取值范围同上                                                               |
-|  tsdbDebugFlag   |                                                              tsdb 模块的日志开关，取值范围同上                                                               |
-|   tqDebugFlag    |                                                               tq 模块的日志开关，取值范围同上                                                                |
-|   fsDebugFlag    |                                                               fs 模块的日志开关，取值范围同上                                                                |
-|   udfDebugFlag   |                                                               udf 模块的日志开关，取值范围同上                                                               |
-|   smaDebugFlag   |                                                               sma 模块的日志开关，取值范围同上                                                               |
-|   idxDebugFlag   |                                                              index 模块的日志开关，取值范围同上                                                              |
-|   tdbDebugFlag   |                                                               tdb 模块的日志开关，取值范围同上                                                               |
 
 ### 压缩参数
-
+|参数名称|支持版本|参数含义|
-| 参数名称       |  参数说明                                                         |
+|------------|----------|-|
-|:-------------:|:----------------------------------------------------------------:|
+|fPrecision  |          |设置 float 类型浮点数压缩精度 ，取值范围 0.1 ~ 0.00000001  ，默认值  0.00000001  , 小于此值的浮点数尾数部分将被截断|
-| compressMsgSize | 是否对 RPC 消息进行压缩；-1: 所有消息都不压缩; 0: 所有消息都压缩; N (N>0): 只有大于 N 个字节的消息才压缩；缺省值  -1 |
+|dPrecision  |          |设置 double 类型浮点数压缩精度 , 取值范围 0.1 ~ 0.0000000000000001 ， 默认值 0.0000000000000001 ， 小于此值的浮点数尾数部分将被截取|
-| fPrecision | 设置 float 类型浮点数压缩精度 ，取值范围：0.1 ~ 0.00000001  ，默认值  0.00000001  , 小于此值的浮点数尾数部分将被截断 |
+|lossyColumn |3.3.0.0 前|对 float 和/或 double 类型启用 TSZ 有损压缩；取值范围 float/double/none；默认值 none，表示关闭无损压缩|
-|dPrecision | 设置 double 类型浮点数压缩精度 , 取值范围：0.1 ~ 0.0000000000000001 ， 缺省值 0.0000000000000001 ， 小于此值的浮点数尾数部分将被截取  |
+|ifAdtFse    |          |在启用 TSZ 有损压缩时，使用 FSE 算法替换 HUFFMAN 算法，FSE 算法压缩速度更快，但解压稍慢，追求压缩速度可选用此算法；0：关闭，1：打开；默认值为 0|
-|lossyColumn | 对 float 和/或 double 类型启用 TSZ 有损压缩；取值范围： float, double, none；缺省值: none，表示关闭无损压缩。**注意：此参数在 3.3.0.0 及更高版本中不再使用** |
+|maxRange    |          |内部参数，用于有损压缩设置|
-|ifAdtFse | 在启用 TSZ 有损压缩时，使用 FSE 算法替换 HUFFMAN 算法， FSE 算法压缩速度更快，但解压稍慢，追求压缩速度可选用此算法; 0: 关闭，1：打开；默认值为 0 |
+|curRange    |          |内部参数，用于有损压缩设置|
-
+|compressor  |          |内部参数，用于有损压缩设置|
 
 **补充说明**
 1. 在 3.2.0.0 ~ 3.3.0.0（不包含）版本生效，启用该参数后不能回退到升级前的版本
@@ -220,16 +319,6 @@ lossyColumns     float|double
    02/22 10:49:27.607990 00002933 UTL  lossyColumns     float|double
 ```
 
-### 其他参数
-
-|     参数名称     |                                                                                                 参数说明                                                                                                 |
-| :--------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-|  enableCoreFile  | crash 时是否生成 core 文件；0: 不生成，1：生成；默认值为 1; 不同的启动方式，生成 core 文件的目录如下：1、systemctl start taosd 启动：生成的 core 在根目录下  <br/> 2、手动启动，就在 taosd 执行目录下。  |
-|       udf        |                                                                            是否启动 UDF 服务；0: 不启动，1：启动；默认值为 0                                                                             |
-| ttlChangeOnWrite |                                                                   ttl 到期时间是否伴随表的修改操作改变; 0: 不改变，1：改变；默认值为 0                                                                   |
-|  tmqMaxTopicNum  |                                                                        订阅最多可建立的 topic 数量; 取值范围 1-10000；缺省值为20                                                                         |
-|    maxTsmaNum    |                                                                             集群内可创建的TSMA个数；取值范围：0-3；缺省值为 3                                                                            |
-
 
 ## taosd 监控指标
 
@@ -282,7 +371,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | :------------- | :-------- | :------ | :--------------------------------------------- |
 | \_ts           | TIMESTAMP |         | timestamp                                      |
 | tables\_num    | DOUBLE    |         | vgroup 中 table 数量                           |
-| status         | DOUBLE    |         | vgroup 状态, 取值范围：unsynced = 0, ready = 1 |
+| status         | DOUBLE    |         | vgroup 状态, 取值范围 unsynced = 0, ready = 1 |
 | vgroup\_id     | VARCHAR   | TAG     | vgroup id                                      |
 | database\_name | VARCHAR   | TAG     | vgroup 所属的 database 名字                    |
 | cluster\_id    | VARCHAR   | TAG     | cluster id                                     |
@@ -311,10 +400,10 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | io\_write\_disk   | DOUBLE    |         | 磁盘 io 吞吐率，从 `/proc/<taosd_pid>/io` 中读取的 write_bytes。单位 byte/s                       |
 | vnodes\_num       | DOUBLE    |         | dnode 上 vnodes 数量                                                                              |
 | masters           | DOUBLE    |         | dnode 上 master node 数量                                                                         |
-| has\_mnode        | DOUBLE    |         | dnode 是否包含 mnode，取值范围：包含=1,不包含=0                                                   |
+| has\_mnode        | DOUBLE    |         | dnode 是否包含 mnode，取值范围 包含=1,不包含=0                                                   |
-| has\_qnode        | DOUBLE    |         | dnode 是否包含 qnode，取值范围：包含=1,不包含=0                                                   |
+| has\_qnode        | DOUBLE    |         | dnode 是否包含 qnode，取值范围 包含=1,不包含=0                                                   |
-| has\_snode        | DOUBLE    |         | dnode 是否包含 snode，取值范围：包含=1,不包含=0                                                   |
+| has\_snode        | DOUBLE    |         | dnode 是否包含 snode，取值范围 包含=1,不包含=0                                                   |
-| has\_bnode        | DOUBLE    |         | dnode 是否包含 bnode，取值范围：包含=1,不包含=0                                                   |
+| has\_bnode        | DOUBLE    |         | dnode 是否包含 bnode，取值范围 包含=1,不包含=0                                                   |
 | error\_log\_count | DOUBLE    |         | error 总数                                                                                        |
 | info\_log\_count  | DOUBLE    |         | info 总数                                                                                         |
 | debug\_log\_count | DOUBLE    |         | debug 总数                                                                                        |
@@ -330,7 +419,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | field       | type      | is\_tag | comment                                  |
 | :---------- | :-------- | :------ | :--------------------------------------- |
 | \_ts        | TIMESTAMP |         | timestamp                                |
-| status      | DOUBLE    |         | dnode 状态,取值范围：ready=1，offline =0 |
+| status      | DOUBLE    |         | dnode 状态,取值范围 ready=1，offline =0 |
 | dnode\_id   | VARCHAR   | TAG     | dnode id                                 |
 | dnode\_ep   | VARCHAR   | TAG     | dnode endpoint                           |
 | cluster\_id | VARCHAR   | TAG     | cluster id                               |
@@ -373,7 +462,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | field       | type      | is\_tag | comment                                                                                                  |
 | :---------- | :-------- | :------ | :------------------------------------------------------------------------------------------------------- |
 | \_ts        | TIMESTAMP |         | timestamp                                                                                                |
-| role        | DOUBLE    |         | mnode 角色， 取值范围：offline = 0,follower = 100,candidate = 101,leader = 102,error = 103,learner = 104 |
+| role        | DOUBLE    |         | mnode 角色， 取值范围 offline = 0,follower = 100,candidate = 101,leader = 102,error = 103,learner = 104 |
 | mnode\_id   | VARCHAR   | TAG     | master node id                                                                                           |
 | mnode\_ep   | VARCHAR   | TAG     | master node endpoint                                                                                     |
 | cluster\_id | VARCHAR   | TAG     | cluster id                                                                                               |
@@ -385,7 +474,7 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | field          | type      | is\_tag | comment                                                                                                 |
 | :------------- | :-------- | :------ | :------------------------------------------------------------------------------------------------------ |
 | \_ts           | TIMESTAMP |         | timestamp                                                                                               |
-| vnode\_role    | DOUBLE    |         | vnode 角色，取值范围：offline = 0,follower = 100,candidate = 101,leader = 102,error = 103,learner = 104 |
+| vnode\_role    | DOUBLE    |         | vnode 角色，取值范围 offline = 0,follower = 100,candidate = 101,leader = 102,error = 103,learner = 104 |
 | vgroup\_id     | VARCHAR   | TAG     | dnode id                                                                                                |
 | dnode\_id      | VARCHAR   | TAG     | dnode id                                                                                                |
 | database\_name | VARCHAR   | TAG     | vgroup 所属的 database 名字                                                                             |
@@ -399,9 +488,9 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | :---------- | :-------- | :------ | :--------------------------------------- |
 | \_ts        | TIMESTAMP |         | timestamp                                |
 | count       | DOUBLE    |         | sql 数量                                 |
-| result      | VARCHAR   | TAG     | sql的执行结果，取值范围：Success, Failed |
+| result      | VARCHAR   | TAG     | sql的执行结果，取值范围 Success, Failed |
 | username    | VARCHAR   | TAG     | 执行sql的user name                       |
-| sql\_type   | VARCHAR   | TAG     | sql类型，取值范围：inserted_rows         |
+| sql\_type   | VARCHAR   | TAG     | sql类型，取值范围 inserted_rows         |
 | dnode\_id   | VARCHAR   | TAG     | dnode id                                 |
 | dnode\_ep   | VARCHAR   | TAG     | dnode endpoint                           |
 | vgroup\_id  | VARCHAR   | TAG     | dnode id                                 |
@@ -415,9 +504,9 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | :---------- | :-------- | :------ | :---------------------------------------- |
 | \_ts        | TIMESTAMP |         | timestamp                                 |
 | count       | DOUBLE    |         | sql 数量                                  |
-| result      | VARCHAR   | TAG     | sql的执行结果，取值范围：Success, Failed  |
+| result      | VARCHAR   | TAG     | sql的执行结果，取值范围 Success, Failed  |
 | username    | VARCHAR   | TAG     | 执行sql的user name                        |
-| sql\_type   | VARCHAR   | TAG     | sql类型，取值范围：select, insert，delete |
+| sql\_type   | VARCHAR   | TAG     | sql类型，取值范围 select, insert，delete |
 | cluster\_id | VARCHAR   | TAG     | cluster id                                |
 
 ### taos\_slow\_sql 表
@@ -428,9 +517,9 @@ taosd 会将监控指标上报给 taosKeeper，这些监控指标会被 taosKeep
 | :---------- | :-------- | :------ | :---------------------------------------------------- |
 | \_ts        | TIMESTAMP |         | timestamp                                             |
 | count       | DOUBLE    |         | sql 数量                                              |
-| result      | VARCHAR   | TAG     | sql的执行结果，取值范围：Success, Failed              |
+| result      | VARCHAR   | TAG     | sql的执行结果，取值范围 Success, Failed              |
 | username    | VARCHAR   | TAG     | 执行sql的user name                                    |
-| duration    | VARCHAR   | TAG     | sql执行耗时，取值范围：3-10s,10-100s,100-1000s,1000s- |
+| duration    | VARCHAR   | TAG     | sql执行耗时，取值范围 3-10s,10-100s,100-1000s,1000s- |
 | cluster\_id | VARCHAR   | TAG     | cluster id                                            |
 
 ## 日志相关

docs/zh/14-reference/01-components/02-taosc.md

@@ -8,38 +8,100 @@ TDengine 客户端驱动提供了应用编程所需要的全部 API，并且在
 
 ## 配置参数
 
-| 参数名称     | 参数含义                                                    |
+### 连接相关
-|:-----------:|:----------------------------------------------------------:|
+|参数名称|支持版本|参数含义|
-|firstEp | taos 启动时，主动连接的集群中首个 dnode 的 endpoint，缺省值：hostname:6030，若无法获取该服务器的 hostname，则赋值为 localhost  |
+|----------------------|----------|-|
-|secondEp | 启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，没有缺省值 |
+|firstEp               |          |启动时，主动连接的集群中首个 dnode 的 endpoint，缺省值：hostname:6030，若无法获取该服务器的 hostname，则赋值为 localhost|
-|numOfRpcSessions | 一个客户端能创建的最大连接数，取值范围：10-50000000(单位为毫秒)；缺省值：500000 |
+|secondEp              |          |启动时，如果 firstEp 连接不上，尝试连接集群中第二个 dnode 的 endpoint，没有缺省值|
-|telemetryReporting | 是否上传 telemetry，0: 不上传，1： 上传；缺省值：1 |
+|compressMsgSize       |          |是否对 RPC 消息进行压缩；-1：所有消息都不压缩；0：所有消息都压缩；N (N>0)：只有大于 N 个字节的消息才压缩；缺省值 -1|
-|crashReporting | 是否上传 telemetry，0: 不上传，1： 上传；缺省值：1  |
+|shellActivityTimer    |          |客户端向 mnode 发送心跳的时长，单位为秒，取值范围 1-120，默认值 3|
-|queryPolicy | 查询语句的执行策略，1: 只使用 vnode，不使用 qnode; 2: 没有扫描算子的子任务在 qnode 执行，带扫描算子的子任务在 vnode 执行; 3: vnode 只运行扫描算子，其余算子均在 qnode 执行 ；缺省值：1 |
+|numOfRpcSessions      |          |RPC 支持的最大连接数，取值范围 100-100000，缺省值 30000|
-|querySmaOptimize | sma index 的优化策略，0: 表示不使用 sma index，永远从原始数据进行查询; 1: 表示使用 sma index，对符合的语句，直接从预计算的结果进行查询；缺省值：0 |
+|numOfRpcThreads       |          |RPC 线程数目，默认值为 CPU 核数的一半|
-|keepColumnName | Last、First、LastRow 函数查询且未指定别名时，自动设置别名为列名（不含函数名），因此 order by 子句如果引用了该列名将自动引用该列对应的函数; 1: 表示自动设置别名为列名(不包含函数名), 0: 表示不自动设置别名; 缺省值: 0 |
+|timeToGetAvailableConn|          |获得可用连接的最长等待时间，取值范围 10-50000000，单位为毫秒，缺省值 500000|
-|countAlwaysReturnValue | count/hyperloglog函数在输入数据为空或者NULL的情况下是否返回值; 0：返回空行，1：返回; 缺省值 1; 该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了TSMA时, 且相应的组或窗口内数据为空或者NULL， 对应的组或窗口将不返回查询结果. 注意此参数客户端和服务端值应保持一致. |
+|useAdapter            |          |内部参数，是否使用 taosadapter，影响 CSV 文件导入|
-|multiResultFunctionStarReturnTags | 查询超级表时，last(\*)/last_row(\*)/first(\*) 是否返回标签列；查询普通表、子表时，不受该参数影响; 0：不返回标签列，1：返回标签列 ; 缺省值: 0; 该参数设置为 0 时，last(\*)/last_row(\*)/first(\*) 只返回超级表的普通列；为 1 时，返回超级表的普通列和标签列 |
+|shareConnLimit        |3.3.4.3 后|内部参数，一个链接可以共享的查询数目，取值范围 1-256，默认值 10|
-|maxTsmaCalcDelay| 查询时客户端可允许的tsma计算延迟, 若tsma的计算延迟大于配置值, 则该TSMA将不会被使用.; 取值范围: 600s - 86400s, 即10分钟-1小时 ; 缺省值：600 秒|
+|readTimeout           |3.3.4.3 后|内部参数，最小超时时间，取值范围 64-604800，单位为秒，默认值 900|
-|tsmaDataDeleteMark |TSMA计算的历史数据中间结果保存时间, 单位为毫秒; 取值范围：>= 3600000, 即大于等于1h; 缺省值: 86400000, 即1d  |
+
-|timezone | 时区; 缺省从系统中动态获取当前的时区设置 |
+### 查询相关
-|locale | 系统区位信息及编码格式, 缺省从系统中获取 |
+|参数名称|支持版本|参数含义|
-|charset | 字符集编码，缺省从系统中获取 |
+|---------------------------------|---------|-|
-|metaCacheMaxSize | 指定单个客户端元数据缓存大小的最大值, 单位 MB; 缺省值 -1，表示无限制 |
+|countAlwaysReturnValue           |         |count/hyperloglog 函数在输入数据为空或者 NULL 的情况下是否返回值；0：返回空行，1：返回；默认值 1；该参数设置为 1 时，如果查询中含有 INTERVAL 子句或者该查询使用了 TSMA 时，且相应的组或窗口内数据为空或者 NULL，对应的组或窗口将不返回查询结果；注意此参数客户端和服务端值应保持一致|
-|logDir | 日志文件目录，客户端运行日志将写入该目录, 缺省值: /var/log/taos |
+|keepColumnName                   |         |Last、First、LastRow 函数查询且未指定别名时，自动设置别名为列名（不含函数名），因此 order by 子句如果引用了该列名将自动引用该列对应的函数；1：表示自动设置别名为列名(不包含函数名)，0：表示不自动设置别名；缺省值：0|
-|minimalLogDirGB | 当日志文件夹所在磁盘可用空间大小小于该值时，停止写日志; 缺省值  1 |
+|multiResultFunctionStarReturnTags|3.3.3.0 后|查询超级表时，last(\*)/last_row(\*)/first(\*) 是否返回标签列；查询普通表、子表时，不受该参数影响；0：不返回标签列，1：返回标签列；缺省值：0；该参数设置为 0 时，last(\*)/last_row(\*)/first(\*) 只返回超级表的普通列；为 1 时，返回超级表的普通列和标签列|
-|numOfLogLines | 单个日志文件允许的最大行数; 缺省值 10,000,000 |
+|metaCacheMaxSize                 |         |指定单个客户端元数据缓存大小的最大值，单位 MB；缺省值 -1，表示无限制|
-|asyncLog | 是否异步写入日志，0：同步；1：异步；缺省值：1 |
+|maxTsmaCalcDelay                 |         |查询时客户端可允许的 tsma 计算延迟，若 tsma 的计算延迟大于配置值，则该 TSMA 将不会被使用；取值范围 600s - 86400s，即 10 分钟 - 1 小时；缺省值：600 秒|
-|logKeepDays | 日志文件的最长保存时间; 缺省值: 0，表示无限保存; 大于 0 时，日志文件会被重命名为 taosdlog.xxx，其中 xxx 为日志文件最后修改的时间戳|
+|tsmaDataDeleteMark               |         |TSMA 计算的历史数据中间结果保存时间，单位为毫秒；取值范围 >= 3600000，即大于等于1h；缺省值：86400000，即 1d |
-|smlChildTableName | schemaless 自定义的子表名的 key, 无缺省值 |
+|queryPolicy                      |         |查询语句的执行策略，1：只使用 vnode，不使用 qnode；2：没有扫描算子的子任务在 qnode 执行，带扫描算子的子任务在 vnode 执行；3：vnode 只运行扫描算子，其余算子均在 qnode 执行；缺省值：1|
-|smlAutoChildTableNameDelimiter | schemaless tag之间的连接符，连起来作为子表名，无缺省值 |
+|queryTableNotExistAsEmpty        |         |查询表不存在时是否返回空结果集；false：返回错误；true：返回空结果集；缺省值 false|
-|smlTagName | schemaless tag 为空时默认的 tag 名字, 缺省值 "_tag_null" |
+|querySmaOptimize                 |         |sma index 的优化策略，0：表示不使用 sma index，永远从原始数据进行查询；1：表示使用 sma index，对符合的语句，直接从预计算的结果进行查询；缺省值：0|
-|smlTsDefaultName | schemaless自动建表的时间列名字通过该配置设置, 缺省值 "_ts" |
+|queryPlannerTrace                |         |内部参数，查询计划是否输出详细日志|
-|smlDot2Underline | schemaless 把超级表名中的 dot 转成下划线 |
+|queryNodeChunkSize               |         |内部参数，查询计划的块大小|
-|enableCoreFile | crash 时是否生成 core 文件，0: 不生成， 1： 生成；缺省值：1 |
+|queryUseNodeAllocator            |         |内部参数，查询计划的分配方法|
-|enableScience | 是否开启科学计数法显示浮点数; 0: 不开始, 1: 开启；缺省值：1 |
+|queryMaxConcurrentTables         |         |内部参数，查询计划的并发数目|
-|compressMsgSize | 是否对 RPC 消息进行压缩; -1: 所有消息都不压缩; 0: 所有消息都压缩; N (N>0): 只有大于 N 个字节的消息才压缩; 缺省值 -1|
+|enableQueryHb                    |         |内部参数，是否发送查询心跳消息|
-|queryTableNotExistAsEmpty | 查询表不存在时是否返回空结果集; false: 返回错误; true: 返回空结果集; 缺省值 false|
+|minSlidingTime                   |         |内部参数，sliding 的最小允许值|
+|minIntervalTime                  |         |内部参数，interval 的最小允许值|
+
+### 写入相关
+|参数名称|支持版本|参数含义|
+|------------------------------|----------|-|
+|smlChildTableName             |          |schemaless 自定义的子表名的 key，无缺省值|
+|smlAutoChildTableNameDelimiter|          |schemaless tag 之间的连接符，连起来作为子表名，无缺省值|
+|smlTagName                    |          |schemaless tag 为空时默认的 tag 名字，缺省值 "_tag_null"|
+|smlTsDefaultName              |          |schemaless 自动建表的时间列名字通过该配置设置，缺省值 "_ts"|
+|smlDot2Underline              |          |schemaless 把超级表名中的 dot 转成下划线|
+|maxInsertBatchRows            |          |内部参数，一批写入的最大条数|
+
+### 区域相关
+|参数名称|支持版本|参数含义|
+|-----------------|----------|-|
+|timezone         |          |时区；缺省从系统中动态获取当前的时区设置|
+|locale           |          |系统区位信息及编码格式，缺省从系统中获取|
+|charset          |          |字符集编码，缺省从系统中获取|
+
+### 存储相关
+|参数名称|支持版本|参数含义|
+|-----------------|----------|-|
+|tempDir          |          |指定所有运行过程中的临时文件生成的目录，Linux 平台默认值为 /tmp|
+|minimalTmpDirGB  |          |tempDir 所指定的临时文件目录所需要保留的最小空间，单位 GB，缺省值：1|
+
+### 日志相关
+|参数名称|支持版本|参数含义|
+|-----------------|----------|-|
+|logDir           |          |日志文件目录，运行日志将写入该目录，缺省值：/var/log/taos|
+|minimalLogDirGB  |          |日志文件夹所在磁盘可用空间大小小于该值时，停止写日志，单位 GB，缺省值：1|
+|numOfLogLines    |          |单个日志文件允许的最大行数，缺省值：10,000,000|
+|asyncLog         |          |日志写入模式，0：同步，1：异步，缺省值：1|
+|logKeepDays      |          |日志文件的最长保存时间，单位：天，缺省值：0，意味着无限保存，日志文件不会被重命名，也不会有新的日志文件滚动产生，但日志文件的内容有可能会不断滚动，取决于日志文件大小的设置；当设置为大于 0 的值时，当日志文件大小达到设置的上限时会被重命名为 taoslogx.yyy，其中 yyy 为日志文件最后修改的时间戳，并滚动产生新的日志文件|
+|debugFlag        |          |运行日志开关，131（输出错误和警告日志），135（输出错误、警告和调试日志），143（输出错误、警告、调试和跟踪日志）；默认值 131 或 135 （取决于不同模块）|
+|tmrDebugFlag     |          |定时器模块的日志开关，取值范围同上|
+|uDebugFlag       |          |共用功能模块的日志开关，取值范围同上|
+|rpcDebugFlag     |          |rpc 模块的日志开关，取值范围同上|
+|jniDebugFlag     |          |jni 模块的日志开关，取值范围同上|
+|qDebugFlag       |          |query 模块的日志开关，取值范围同上|
+|cDebugFlag       |          |客户端模块的日志开关，取值范围同上|
+|simDebugFlag     |          |内部参数，测试工具的日志开关，取值范围同上|
+|tqClientDebugFlag|3.3.4.3 后|客户端模块的日志开关，取值范围同上|
+
+### 调试相关
+|参数名称|支持版本|参数含义|
+|-----------------|-----------|-|
+|crashReporting   |          |是否上传 crash 到 telemetry，0：不上传，1：上传；缺省值：1|
+|enableCoreFile   |          |crash 时是否生成 core 文件，0：不生成，1：生成；缺省值：1|
+|assert           |          |断言控制开关，缺省值：0|
+|configDir        |          |配置文件所在目录|
+|scriptDir        |          |内部参数，测试用例的目录|
+|randErrorChance  |3.3.3.0 后|内部参数，用于随机失败测试|
+|randErrorDivisor |3.3.3.0 后|内部参数，用于随机失败测试|
+|randErrorScope   |3.3.3.0 后|内部参数，用于随机失败测试|
+|safetyCheckLevel |3.3.3.0 后|内部参数，用于随机失败测试|
+|simdEnable       |3.3.4.3 后|内部参数，用于测试 SIMD 加速|
+|AVX512Enable     |3.3.4.3 后|内部参数，用于测试 AVX512 加速|
+
+### SHELL 相关
+|参数名称|支持版本|参数含义|
+|-----------------|----------|-|
+|enableScience    |          |是否开启科学计数法显示浮点数；0：不开始，1：开启；缺省值：1|
 
 ## API
 

docs/zh/14-reference/03-taos-sql/03-table.md

@@ -227,7 +227,7 @@ DROP TABLE [IF EXISTS] [db_name.]tb_name [, [IF EXISTS] [db_name.]tb_name] ...
 如下 SQL 语句可以列出当前数据库中的所有表名。
 
 ```sql
-SHOW TABLES [LIKE tb_name_wildchar];
+SHOW TABLES [LIKE tb_name_wildcard];
 ```
 
 ### 显示表创建语句

docs/zh/28-releases/01-tdengine.md

@@ -24,6 +24,10 @@ TDengine 3.x 各版本安装包下载链接如下：
 
 import Release from "/components/ReleaseV3";
 
+## 3.3.4.3
+
+<Release type="tdengine" version="3.3.4.3" />
+
 ## 3.3.3.0
 
 <Release type="tdengine" version="3.3.3.0" />

docs/zh/28-releases/03-notes/3.3.4.3.md

@@ -0,0 +1,69 @@
+---
+title: 3.3.4.3 版本说明
+sidebar_label: 3.3.4.3
+description: 3.3.4.3 版本说明
+---
+
+### 行为变更及兼容性
+1. 多副本流计算中必须使用 snode
+1. 增加了流计算的兼容性保证机制，避免后续函数变更产生新的兼容性问题，但之前版本的流计算必须重建，具体参见 https://docs.taosdata.com/advanced/stream/#流计算升级故障恢复
+1. 调整 case when 语句结果类型的判断方法
+   
+### 新特性
+1. 新功能：流计算的 TWA 函数支持时间驱动的结果推送模式 
+1. 新功能：流计算的 Interp 函数支持时间驱动的结果推送模式 
+1. 新功能：支持微软对象存储 
+
+### 优化
+1.  优化：提升并发大查询时节点之间互相拉数据的效率 
+1.  优化：支持使用 AVX2 和 AVX512 对 double 、timestamp 和 bigint 类型进行解码优化 
+1.  优化：调整 case when 语句的结果类型判断方法 
+1.  优化：顺序执行 compact 和 split vgroup操作时的日志错误提示 
+1.  优化：提升查询 “select ... from ... where ts in (...)” 的数据扫描速度 
+1.  优化：增加了流计算的兼容性保证机制，避免后续函数变更产生新的兼容性问题，之前版本的流计算必须重建 
+1.  优化：提升 taosX 在交叉写入场景下的数据同步性能 
+1.  优化：支持关闭整数/浮点数类型的编码 
+1.  优化：多副本流计算中必须使用 snode 
+1.  优化：客户端生成唯一 ID 标识每一个查询任务，避免重复 ID 导致的内存损坏 
+1.  优化：加快数据库的创建时间 
+1.  优化：修改 s3MigrateEnabled 默认值为0 
+1.  优化：支持在审计数据库中记录删除操作 
+1.  优化：支持在指定的 dnode 中创建数据库 [企业版] 
+1.  优化：调整删除超级表数据列时的报错信息 
+
+### 修复
+1. 修复：last_row 查询性能在 3.3.3.0 中大幅下降的问题 
+1. 修复：WAL 条目不完整时 taosd 无法启动的问题 
+1. 修复: partition by 常量时查询结果错误的问题 
+1. 修复：标量函数包含 _wstart 且填充方式为 prev 时计算结果错误 
+1. 修复：Windows 平台下的时区设置问题 
+1. 修复：空数据库进行 compact 操作时，事务无法结束【企业版】 
+1. 修复：事务冲突的逻辑错误 
+1. 修复：管理节点某些错误会导致事务无法停止 
+1. 修复：管理节点某些错误会导致事务无法停止 
+1. 修复：dnode 数据清空后 taosc 重试错误的问题 
+1. 修复：Data Compact 被异常终止后，中间文件未被清理 
+1. 修复：新增列后，Kafka 连接器的 earliest 模式消费不到新列数据 
+1. 修复：interp 函数在 fill(prev) 时行为不正确 
+1. 修复：TSMA 在高频元数据操作时异常停止的问题 
+1. 修复：show create stable 语句执行结果的标签显示错误 
+1. 修复：Percentile 函数在大数据量查询时会崩溃。 
+1. 修复：partition by 和 having 联合使用时的语法错误问题 
+1. 修复：interp 在 partition by tbname,c1 时 tbname 为空的问题 
+1. 修复：通过 stmt 写入非法布尔数值时 taosd 可能 crash 
+1. 修复：库符号 version 与使用相同符号的库冲突的问题 
+1. 修复：在 windows 平台下 JDBC 驱动的句柄数持续升高问题 
+1. 修复：3.3.3.1 升级至 3.3.4.0 偶现的启动失败问题 
+1. 修复：Windows 平台重复增删表的内存泄漏 
+1. 修复：无法限制并发拉起 checkpoint 数量导致流计算消耗资源过多 
+1. 修复：并发查询时的 too many session 问题 
+1. 修复：Windows 平台下 taos shell 在慢查询场景中崩溃的问题 
+1. 修复：当打开 dnode日志时，加密数据库无法恢复的问题 
+1. 修复：由于 mnode 同步超时，进而导致 taosd 无法启动的问题 
+1. 修复：由于在快照同步过程中整理文件组数据的速度过慢，从而导致 Vnode（虚拟节点）无法恢复的问题 
+1. 修复：通过行协议向字符串类型的字段中写入带转义符的数据时，taosd 会崩溃 
+1. 修复：Error Code 逻辑处理错误导致的元数据文件损坏 
+1. 修复：查询语句中包含多个 “not” 条件语句嵌套时，未设置标量模式导致查询错误 
+1. 修复：vnode 统计信息上报超时导致的 dnode offline 问题 
+1. 修复：在不支持 avx 指令集的服务器上，taosd 启动失败问题 
+1. 修复：taosX 数据迁移容错处理 0x09xx 错误码 

docs/zh/28-releases/03-notes/index.md

@@ -3,5 +3,7 @@ title: 版本说明
 sidebar_label: 版本说明
 description: 各版本版本说明
 ---
+
+[3.3.4.3](./3.3.4.3)  
 [3.3.3.0](./3.3.3.0)  
 [3.3.2.0](./3.3.2.0)

include/common/tmsg.h

@@ -2187,8 +2187,9 @@ int32_t tSerializeSShowVariablesReq(void* buf, int32_t bufLen, SShowVariablesReq
 
 typedef struct {
   char name[TSDB_CONFIG_OPTION_LEN + 1];
-  char value[TSDB_CONFIG_VALUE_LEN + 1];
+  char value[TSDB_CONFIG_PATH_LEN + 1];
   char scope[TSDB_CONFIG_SCOPE_LEN + 1];
+  char info[TSDB_CONFIG_INFO_LEN + 1];
 } SVariablesInfo;
 
 typedef struct {

include/libs/function/tudf.h

@@ -61,6 +61,35 @@ extern "C" {
     }                                               \
   } while (0)
 
+#define TAOS_UDF_CHECK_PTR_RCODE(...)                                          \
+  do {                                                                         \
+    const void *ptrs[] = {__VA_ARGS__};                                        \
+    for (int i = 0; i < sizeof(ptrs) / sizeof(ptrs[0]); ++i) {                 \
+      if (ptrs[i] == NULL) {                                                   \
+        fnError("udfd %dth parameter invalid, NULL PTR.line:%d", i, __LINE__); \
+        return TSDB_CODE_INVALID_PARA;                                         \
+      }                                                                        \
+    }                                                                          \
+  } while (0)
+
+#define TAOS_UDF_CHECK_PTR_RVOID(...)                                          \
+  do {                                                                         \
+    const void *ptrs[] = {__VA_ARGS__};                                        \
+    for (int i = 0; i < sizeof(ptrs) / sizeof(ptrs[0]); ++i) {                 \
+      if (ptrs[i] == NULL) {                                                   \
+        fnError("udfd %dth parameter invalid, NULL PTR.line:%d", i, __LINE__); \
+        return;                                                                \
+      }                                                                        \
+    }                                                                          \
+  } while (0)
+
+#define TAOS_UDF_CHECK_CONDITION(o, code)             \
+  do {                                                \
+    if ((o) == false) {                               \
+      fnError("Condition not met.line:%d", __LINE__); \
+      return code;                                    \
+    }                                                 \
+  } while (0)
 
 // low level APIs
 /**

include/libs/nodes/cmdnodes.h

@@ -42,10 +42,11 @@ extern "C" {
 #define SHOW_CREATE_VIEW_RESULT_FIELD1_LEN (TSDB_VIEW_FNAME_LEN + 4 + VARSTR_HEADER_SIZE)
 #define SHOW_CREATE_VIEW_RESULT_FIELD2_LEN (TSDB_MAX_ALLOWED_SQL_LEN + VARSTR_HEADER_SIZE)
 
-#define SHOW_LOCAL_VARIABLES_RESULT_COLS       3
+#define SHOW_LOCAL_VARIABLES_RESULT_COLS       4
 #define SHOW_LOCAL_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE)
-#define SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE)
+#define SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_LOCAL_VARIABLES_RESULT_FIELD3_LEN (TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE)
+#define SHOW_LOCAL_VARIABLES_RESULT_FIELD4_LEN (TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE)
 
 #define COMPACT_DB_RESULT_COLS       3
 #define COMPACT_DB_RESULT_FIELD1_LEN 32

include/os/os.h

@@ -137,6 +137,14 @@ extern threadlocal bool tsEnableRandErr;
     terrno = _code;           \
   }
 
+#define OS_PARAM_CHECK(_o)             \
+  do {                                 \
+    if ((_o) == NULL) {                \
+      terrno = TSDB_CODE_INVALID_PARA; \
+      return terrno;                   \
+    }                                  \
+  } while (0)
+
 #ifdef __cplusplus
 }
 #endif

include/os/osSystem.h

@@ -48,8 +48,6 @@ void    taosCloseCmd(TdCmdPtr *ppCmd);
 
 void *taosLoadDll(const char *filename);
 
-void *taosLoadSym(void *handle, char *name);
-
 void taosCloseDll(void *handle);
 
 int32_t taosSetConsoleEcho(bool on);

include/util/tdef.h

@@ -195,9 +195,9 @@ static const EOperatorType OPERATOR_ARRAY[] = {
   OP_TYPE_MULTI,
   OP_TYPE_DIV,
   OP_TYPE_REM,
-  
+
   OP_TYPE_MINUS,
-  
+
   OP_TYPE_BIT_AND,
   OP_TYPE_BIT_OR,
 
@@ -213,7 +213,7 @@ static const EOperatorType OPERATOR_ARRAY[] = {
   OP_TYPE_NOT_LIKE,
   OP_TYPE_MATCH,
   OP_TYPE_NMATCH,
-  
+
   OP_TYPE_IS_NULL,
   OP_TYPE_IS_NOT_NULL,
   OP_TYPE_IS_TRUE,
@@ -222,7 +222,7 @@ static const EOperatorType OPERATOR_ARRAY[] = {
   OP_TYPE_IS_NOT_TRUE,
   OP_TYPE_IS_NOT_FALSE,
   OP_TYPE_IS_NOT_UNKNOWN,
-  //OP_TYPE_COMPARE_MAX_VALUE, 
+  //OP_TYPE_COMPARE_MAX_VALUE,
 
   OP_TYPE_JSON_GET_VALUE,
   OP_TYPE_JSON_CONTAINS,
@@ -631,6 +631,8 @@ enum { RAND_ERR_MEMORY = 1, RAND_ERR_FILE = 2, RAND_ERR_NETWORK = 4 };
 #define TSDB_CONFIG_VALUE_LEN  64
 #define TSDB_CONFIG_SCOPE_LEN  8
 #define TSDB_CONFIG_NUMBER     16
+#define TSDB_CONFIG_PATH_LEN   4096
+#define TSDB_CONFIG_INFO_LEN   64
 
 #define QUERY_ID_SIZE      20
 #define QUERY_OBJ_ID_SIZE  18

include/util/tjson.h

@@ -25,7 +25,7 @@ extern "C" {
 
 #define tjsonGetNumberValue(pJson, pName, val, code) \
   do {                                               \
-    uint64_t _tmp = 0;                               \
+    int64_t _tmp = 0;                                \
     code = tjsonGetBigIntValue(pJson, pName, &_tmp); \
     val = _tmp;                                      \
   } while (0)

include/util/tutil.h

@@ -120,6 +120,18 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
   }
 }
 
+/*
+ * LIKELY and UNLIKELY macros for branch predication hints. Use them judiciously
+ * only in very hot code paths. Misuse or abuse can lead to performance degradation.
+ */
+#if __GNUC__ >= 3
+#define LIKELY(x)	__builtin_expect((x) != 0, 1)
+#define UNLIKELY(x) __builtin_expect((x) != 0, 0)
+#else
+#define LIKELY(x)	((x) != 0)
+#define UNLIKELY(x) ((x) != 0)
+#endif
+
 #define TAOS_CHECK_ERRNO(CODE)         \
   do {                                 \
     terrno = (CODE);                   \
@@ -129,25 +141,27 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
     }                                  \
   } while (0)
 
-#define TSDB_CHECK_CODE(CODE, LINO, LABEL) \
+#define TSDB_CHECK_CODE(CODE, LINO, LABEL)       \
-  do {                                     \
+  do {                                           \
-    if (TSDB_CODE_SUCCESS != (CODE)) {     \
+    if (UNLIKELY(TSDB_CODE_SUCCESS != (CODE))) { \
-      LINO = __LINE__;                     \
+      LINO = __LINE__;                           \
-      goto LABEL;                          \
+      goto LABEL;                                \
-    }                                      \
+    }                                            \
   } while (0)
 
 #define QUERY_CHECK_CODE TSDB_CHECK_CODE
 
-#define QUERY_CHECK_CONDITION(condition, CODE, LINO, LABEL, ERRNO) \
+#define TSDB_CHECK_CONDITION(condition, CODE, LINO, LABEL, ERRNO) \
-  if (!condition) {                                                \
+  if (UNLIKELY(!(condition))) {                                   \
-    (CODE) = (ERRNO);                                              \
+    (CODE) = (ERRNO);                                             \
-    (LINO) = __LINE__;                                             \
+    (LINO) = __LINE__;                                            \
-    goto LABEL;                                                    \
+    goto LABEL;                                                   \
   }
 
+#define QUERY_CHECK_CONDITION TSDB_CHECK_CONDITION
+
 #define TSDB_CHECK_NULL(ptr, CODE, LINO, LABEL, ERRNO) \
-  if ((ptr) == NULL) {                                 \
+  if (UNLIKELY((ptr) == NULL)) {                       \
     (CODE) = (ERRNO);                                  \
     (LINO) = __LINE__;                                 \
     goto LABEL;                                        \

packaging/smokeTest/test_server.py

@@ -61,7 +61,7 @@ def setup_module(get_config):
     else:
         cmd = "mkdir -p ../../debug/build/bin/"
     subprocess.getoutput(cmd)
-    if config["system"] == "Linux":  # add tmq_sim
+    if config["system"] == "Linux" or config["system"] == "Darwin" :  # add tmq_sim
         cmd = "cp -rf ../../../debug/build/bin/tmq_sim ../../debug/build/bin/."
         subprocess.getoutput(cmd)
     if config["system"] == "Darwin":
@@ -140,9 +140,11 @@ class TestServer:
             if line:
                 print(line.strip())
             if "succeed to write dnode" in line:
-                time.sleep(15)
+                time.sleep(5)
                 # 发送终止信号
-                os.kill(process.pid, signal.SIGTERM)
+                os.kill(process.pid, signal.SIGKILL)
+                # Waiting for the process to be completely killed
+                time.sleep(5)
                 break
 
     @pytest.mark.all

source/client/inc/clientInt.h

@@ -47,10 +47,11 @@ enum {
   RES_TYPE__TMQ_BATCH_META,
 };
 
-#define SHOW_VARIABLES_RESULT_COLS       3
+#define SHOW_VARIABLES_RESULT_COLS       4
 #define SHOW_VARIABLES_RESULT_FIELD1_LEN (TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_VARIABLES_RESULT_FIELD2_LEN (TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE)
 #define SHOW_VARIABLES_RESULT_FIELD3_LEN (TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE)
+#define SHOW_VARIABLES_RESULT_FIELD4_LEN (TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE)
 
 #define TD_RES_QUERY(res)          (*(int8_t*)(res) == RES_TYPE__QUERY)
 #define TD_RES_TMQ(res)            (*(int8_t*)(res) == RES_TYPE__TMQ)

source/client/src/clientMsgHandler.c

@@ -541,6 +541,10 @@ static int32_t buildShowVariablesBlock(SArray* pVars, SSDataBlock** block) {
   infoData.info.bytes = SHOW_VARIABLES_RESULT_FIELD3_LEN;
   TSDB_CHECK_NULL(taosArrayPush(pBlock->pDataBlock, &infoData), code, line, END, terrno);
 
+  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
+  infoData.info.bytes = SHOW_VARIABLES_RESULT_FIELD4_LEN;
+  TSDB_CHECK_NULL(taosArrayPush(pBlock->pDataBlock, &infoData), code, line, END, terrno);
+
   int32_t numOfCfg = taosArrayGetSize(pVars);
   code = blockDataEnsureCapacity(pBlock, numOfCfg);
   TSDB_CHECK_CODE(code, line, END);
@@ -569,6 +573,13 @@ static int32_t buildShowVariablesBlock(SArray* pVars, SSDataBlock** block) {
     TSDB_CHECK_NULL(pColInfo, code, line, END, terrno);
     code = colDataSetVal(pColInfo, i, scope, false);
     TSDB_CHECK_CODE(code, line, END);
+
+    char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};
+    STR_WITH_MAXSIZE_TO_VARSTR(info, pInfo->info, TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE);
+    pColInfo = taosArrayGet(pBlock->pDataBlock, c++);
+    TSDB_CHECK_NULL(pColInfo, code, line, END, terrno);
+    code = colDataSetVal(pColInfo, i, info, false);
+    TSDB_CHECK_CODE(code, line, END);
   }
 
   pBlock->info.rows = numOfCfg;
@@ -825,7 +836,7 @@ int32_t processCompactDbRsp(void* param, SDataBuf* pMsg, int32_t code) {
       tscError("failed to post semaphore");
     }
   }
-  return code;  
+  return code;
 }
 
 __async_send_cb_fn_t getMsgRspHandle(int32_t msgType) {
@@ -845,7 +856,7 @@ __async_send_cb_fn_t getMsgRspHandle(int32_t msgType) {
     case TDMT_MND_SHOW_VARIABLES:
       return processShowVariablesRsp;
     case TDMT_MND_COMPACT_DB:
-      return processCompactDbRsp;  
+      return processCompactDbRsp;
     default:
       return genericRspCallback;
   }

source/common/src/systable.c

@@ -327,8 +327,9 @@ static const SSysDbTableSchema configSchema[] = {
 static const SSysDbTableSchema variablesSchema[] = {
     {.name = "dnode_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
     {.name = "name", .bytes = TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
-    {.name = "value", .bytes = TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "value", .bytes = TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
     {.name = "scope", .bytes = TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
+    {.name = "info", .bytes = TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
 };
 
 static const SSysDbTableSchema topicSchema[] = {

source/common/src/tglobal.c

@@ -59,7 +59,6 @@ int32_t tsNumOfRpcSessions = 30000;
 int32_t tsShareConnLimit = 10;
 int32_t tsReadTimeout = 900;
 int32_t tsTimeToGetAvailableConn = 500000;
-int32_t tsKeepAliveIdle = 60;
 
 int32_t tsNumOfCommitThreads = 2;
 int32_t tsNumOfTaskQueueThreads = 16;
@@ -523,7 +522,7 @@ static int32_t taosLoadCfg(SConfig *pCfg, const char **envCmd, const char *input
 
 int32_t taosAddClientLogCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddDir(pCfg, "configDir", configDir, CFG_SCOPE_BOTH, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddDir(pCfg, "scriptDir", configDir, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddDir(pCfg, "scriptDir", configDir, CFG_SCOPE_CLIENT, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddDir(pCfg, "logDir", tsLogDir, CFG_SCOPE_BOTH, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddFloat(pCfg, "minimalLogDirGB", 1.0f, 0.001f, 10000000, CFG_SCOPE_BOTH, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(
@@ -531,13 +530,14 @@ int32_t taosAddClientLogCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "asyncLog", tsAsyncLog, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "logKeepDays", 0, -365000, 365000, CFG_SCOPE_BOTH, CFG_DYN_ENT_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "debugFlag", 0, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "simDebugFlag", simDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "simDebugFlag", simDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tmrDebugFlag", tmrDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "uDebugFlag", uDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "rpcDebugFlag", rpcDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "jniDebugFlag", jniDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "qDebugFlag", qDebugFlag, 0, 255, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "cDebugFlag", cDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tqClientDebugFlag", tqClientDebugFlag, 0, 255, CFG_SCOPE_CLIENT, CFG_DYN_SERVER));
   TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
@@ -550,7 +550,6 @@ static int32_t taosAddServerLogCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "sDebugFlag", sDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tsdbDebugFlag", tsdbDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tqDebugFlag", tqDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "tqClientDebugFlag", tqClientDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "fsDebugFlag", fsDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "udfDebugFlag", udfDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "smaDebugFlag", smaDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
@@ -591,17 +590,18 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(
       cfgAddBool(pCfg, "queryUseNodeAllocator", tsQueryUseNodeAllocator, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "keepColumnName", tsKeepColumnName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "minSlidingTime", tsMinSlidingTime, 1, 1000000, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "minIntervalTime", tsMinIntervalTime, 1, 1000000, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlChildTableName", tsSmlChildTableName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlAutoChildTableNameDelimiter", tsSmlAutoChildTableNameDelimiter,
                                  CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlTagName", tsSmlTagName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "smlTsDefaultName", tsSmlTsDefaultName, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "smlDot2Underline", tsSmlDot2Underline, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxShellConns", tsMaxShellConns, 10, 50000000, CFG_SCOPE_CLIENT, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxInsertBatchRows", tsMaxInsertBatchRows, 1, INT32_MAX, CFG_SCOPE_CLIENT,
                                 CFG_DYN_CLIENT) != 0);
   TAOS_CHECK_RETURN(
-      cfgAddInt32(pCfg, "maxRetryWaitTime", tsMaxRetryWaitTime, 0, 86400000, CFG_SCOPE_BOTH, CFG_DYN_CLIENT));
+      cfgAddInt32(pCfg, "maxRetryWaitTime", tsMaxRetryWaitTime, 0, 86400000, CFG_SCOPE_SERVER, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "useAdapter", tsUseAdapter, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "crashReporting", tsEnableCrashReport, CFG_SCOPE_BOTH, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "queryMaxConcurrentTables", tsQueryMaxConcurrentTables, INT64_MIN, INT64_MAX,
@@ -631,15 +631,12 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(
       cfgAddInt32(pCfg, "timeToGetAvailableConn", tsTimeToGetAvailableConn, 20, 1000000, CFG_SCOPE_BOTH, CFG_DYN_NONE));
 
-  tsKeepAliveIdle = TRANGE(tsKeepAliveIdle, 1, 72000);
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "keepAliveIdle", tsKeepAliveIdle, 1, 7200000, CFG_SCOPE_BOTH, CFG_DYN_NONE));
-
   tsNumOfTaskQueueThreads = tsNumOfCores * 2;
   tsNumOfTaskQueueThreads = TMAX(tsNumOfTaskQueueThreads, 16);
 
   TAOS_CHECK_RETURN(
       cfgAddInt32(pCfg, "numOfTaskQueueThreads", tsNumOfTaskQueueThreads, 4, 1024, CFG_SCOPE_CLIENT, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "experimental", tsExperimental, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
+  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "experimental", tsExperimental, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
 
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "multiResultFunctionStarReturnTags", tsMultiResultFunctionStarReturnTags,
                                CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
@@ -728,8 +725,7 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "encryptScope", tsEncryptScope, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "statusInterval", tsStatusInterval, 1, 30, CFG_SCOPE_SERVER, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "minSlidingTime", tsMinSlidingTime, 1, 1000000, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "maxShellConns", tsMaxShellConns, 10, 50000000, CFG_SCOPE_SERVER, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "minIntervalTime", tsMinIntervalTime, 1, 1000000, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
 
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryBufferSize", tsQueryBufferSize, -1, 500000000000, CFG_SCOPE_SERVER, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "queryRspPolicy", tsQueryRspPolicy, 0, 1, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER));
@@ -747,7 +743,7 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfSnodeSharedThreads", tsNumOfSnodeStreamThreads, 2, 1024, CFG_SCOPE_SERVER, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "numOfSnodeUniqueThreads", tsNumOfSnodeWriteThreads, 2, 1024, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
-  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "rpcQueueMemoryAllowed", tsQueueMemoryAllowed, TSDB_MAX_MSG_SIZE * 10L, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "rpcQueueMemoryAllowed", tsQueueMemoryAllowed, TSDB_MAX_MSG_SIZE * 10L, INT64_MAX, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncElectInterval", tsElectInterval, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "syncHeartbeatInterval", tsHeartbeatInterval, 10, 1000 * 60 * 24 * 2, CFG_SCOPE_SERVER, CFG_DYN_NONE));
@@ -784,12 +780,12 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "auditCreateTable", tsEnableAuditCreateTable, CFG_SCOPE_SERVER, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "auditInterval", tsAuditInterval, 500, 200000, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
-  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "telemetryReporting", tsEnableTelem, CFG_SCOPE_BOTH, CFG_DYN_ENT_SERVER));
+  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "telemetryReporting", tsEnableTelem, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "telemetryInterval", tsTelemInterval, 1, 200000, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "telemetryInterval", tsTelemInterval, 1, 200000, CFG_SCOPE_SERVER, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddString(pCfg, "telemetryServer", tsTelemServer, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
+  TAOS_CHECK_RETURN(cfgAddString(pCfg, "telemetryServer", tsTelemServer, CFG_SCOPE_SERVER, CFG_DYN_BOTH));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "telemetryPort", tsTelemPort, 1, 65056, CFG_SCOPE_BOTH, CFG_DYN_NONE));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "telemetryPort", tsTelemPort, 1, 65056, CFG_SCOPE_SERVER, CFG_DYN_NONE));
 
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "rsyncPort", tsRsyncPort, 1, 65535, CFG_SCOPE_BOTH, CFG_DYN_SERVER));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "rsyncPort", tsRsyncPort, 1, 65535, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "snodeAddress", tsSnodeAddress, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
   TAOS_CHECK_RETURN(cfgAddString(pCfg, "checkpointBackupDir", tsCheckpointBackupDir, CFG_SCOPE_SERVER, CFG_DYN_SERVER));
 
@@ -1295,9 +1291,6 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
   TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeToGetAvailableConn");
   tsTimeToGetAvailableConn = pItem->i32;
 
-  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "keepAliveIdle");
-  tsKeepAliveIdle = pItem->i32;
-
   TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "experimental");
   tsExperimental = pItem->bval;
 
@@ -2036,7 +2029,6 @@ static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {
 
                                          {"cacheLazyLoadThreshold", &tsCacheLazyLoadThreshold},
                                          {"checkpointInterval", &tsStreamCheckpointInterval},
-                                         {"keepAliveIdle", &tsKeepAliveIdle},
                                          {"logKeepDays", &tsLogKeepDays},
                                          {"maxStreamBackendCache", &tsMaxStreamBackendCache},
                                          {"mqRebalanceInterval", &tsMqRebalanceInterval},
@@ -2294,7 +2286,6 @@ static int32_t taosCfgDynamicOptionsForClient(SConfig *pCfg, const char *name) {
                                          {"crashReporting", &tsEnableCrashReport},
                                          {"enableQueryHb", &tsEnableQueryHb},
                                          {"keepColumnName", &tsKeepColumnName},
-                                         {"keepAliveIdle", &tsKeepAliveIdle},
                                          {"logKeepDays", &tsLogKeepDays},
                                          {"maxInsertBatchRows", &tsMaxInsertBatchRows},
                                          {"maxRetryWaitTime", &tsMaxRetryWaitTime},

source/common/src/tmisce.c

@@ -267,7 +267,14 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
 
   int8_t locked = 0;
 
-  TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf)), NULL, _exit);
+  size_t       exSize = 0;
+  size_t       index = 0;
+  SConfigItem* pDataDirItem = cfgGetItem(pConf, "dataDir");
+  if (pDataDirItem) {
+    exSize = TMAX(taosArrayGetSize(pDataDirItem->array), 1) - 1;
+  }
+
+  TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf) + exSize), NULL, _exit);
 
   TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit);
 
@@ -275,6 +282,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
   locked = 1;
 
   while ((pItem = cfgNextIter(pIter)) != NULL) {
+_start:
     col = startCol;
 
     // GRANT_CFG_SKIP;
@@ -289,9 +297,18 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
 
     TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, name, false), NULL, _exit);
 
-    char    value[TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE] = {0};
+    char    value[TSDB_CONFIG_PATH_LEN + VARSTR_HEADER_SIZE] = {0};
     int32_t valueLen = 0;
-    TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_VALUE_LEN, &valueLen), NULL, _exit);
+    SDiskCfg* pDiskCfg = NULL;
+    if (strcasecmp(pItem->name, "dataDir") == 0 && exSize > 0) {
+      char*     buf = &value[VARSTR_HEADER_SIZE];
+      pDiskCfg = taosArrayGet(pItem->array, index);
+      valueLen = tsnprintf(buf, TSDB_CONFIG_PATH_LEN, "%s", pDiskCfg->dir);
+      index++;
+    } else {
+      TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_PATH_LEN, &valueLen), NULL,
+                      _exit);
+    }
     varDataSetLen(value, valueLen);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
@@ -313,8 +330,28 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
     }
     TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, scope, false), NULL, _exit);
 
+    char info[TSDB_CONFIG_INFO_LEN + VARSTR_HEADER_SIZE] = {0};
+    if (strcasecmp(pItem->name, "dataDir") == 0 && pDiskCfg) {
+      char* buf = &info[VARSTR_HEADER_SIZE];
+      valueLen = tsnprintf(buf, TSDB_CONFIG_INFO_LEN, "level %d primary %d disabled %" PRIi8, pDiskCfg->level,
+                              pDiskCfg->primary, pDiskCfg->disable);
+    } else {
+      valueLen = 0;
+    }
+    varDataSetLen(info, valueLen);
+
+    pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
+    if (pColInfo == NULL) {
+      code = terrno;
+      TAOS_CHECK_GOTO(code, NULL, _exit);
+    }
+    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, info, false), NULL, _exit);
+
     numOfRows++;
-  }
+    if (index > 0 && index <= exSize) {
+      goto _start;
+    }
+}
   pBlock->info.rows = numOfRows;
 _exit:
   if (locked) cfgUnLock(pConf);

source/common/src/tmsg.c

@@ -5642,6 +5642,12 @@ int32_t tSerializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesRsp
     SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
     TAOS_CHECK_EXIT(tEncodeSVariablesInfo(&encoder, pInfo));
   }
+
+  for (int32_t i = 0; i < varNum; ++i) {
+    SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
+    TAOS_CHECK_RETURN(tEncodeCStr(&encoder, pInfo->info));
+  }
+
   tEndEncode(&encoder);
 
 _exit:
@@ -5675,6 +5681,13 @@ int32_t tDeserializeSShowVariablesRsp(void *buf, int32_t bufLen, SShowVariablesR
         TAOS_CHECK_EXIT(terrno);
       }
     }
+
+    if (!tDecodeIsEnd(&decoder)) {
+      for (int32_t i = 0; i < varNum; ++i) {
+        SVariablesInfo *pInfo = taosArrayGet(pRsp->variables, i);
+        TAOS_CHECK_EXIT(tDecodeCStrTo(&decoder, pInfo->info));
+      }
+    }
   }
 
   tEndDecode(&decoder);

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

@@ -1104,6 +1104,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
   (void)strcpy(info.name, "statusInterval");
   (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
   (void)strcpy(info.scope, "server");
+  // fill info.info
   if (taosArrayPush(rsp.variables, &info) == NULL) {
     code = terrno;
     goto _OVER;

source/dnode/vnode/inc/vnode.h

@@ -172,7 +172,7 @@ void         tsdbReleaseDataBlock2(STsdbReader *pReader);
 int32_t      tsdbRetrieveDataBlock2(STsdbReader *pReader, SSDataBlock **pBlock, SArray *pIdList);
 int32_t      tsdbReaderReset2(STsdbReader *pReader, SQueryTableDataCond *pCond);
 int32_t      tsdbGetFileBlocksDistInfo2(STsdbReader *pReader, STableBlockDistInfo *pTableBlockInfo);
-int64_t      tsdbGetNumOfRowsInMemTable2(STsdbReader *pHandle);
+int64_t      tsdbGetNumOfRowsInMemTable2(STsdbReader *pHandle, uint32_t *rows);
 void        *tsdbGetIdx2(SMeta *pMeta);
 void        *tsdbGetIvtIdx2(SMeta *pMeta);
 uint64_t     tsdbGetReaderMaxVersion2(STsdbReader *pReader);

source/dnode/vnode/src/tqCommon/tqCommon.c

@@ -1186,10 +1186,12 @@ int32_t tqStreamTaskProcessTaskResumeReq(void* handle, int64_t sversion, char* m
     streamMutexUnlock(&pHTask->lock);
 
     code = tqProcessTaskResumeImpl(handle, pHTask, sversion, pReq->igUntreated, fromVnode);
+    tqDebug("s-task:%s resume complete, code:%s", pHTask->id.idStr, tstrerror(code));
+
     streamMetaReleaseTask(pMeta, pHTask);
   }
 
-  return code;
+  return TSDB_CODE_SUCCESS;
 }
 
 int32_t tqStreamTasksGetTotalNum(SStreamMeta* pMeta) { return taosArrayGetSize(pMeta->pTaskList); }

source/dnode/vnode/src/tsdb/tsdbCacheRead.c

@@ -25,82 +25,109 @@
 #define HASTYPE(_type, _t) (((_type) & (_t)) == (_t))
 
 static int32_t setFirstLastResColToNull(SColumnInfoData* pCol, int32_t row) {
-  char* buf = taosMemoryCalloc(1, pCol->info.bytes);
+  int32_t        code = TSDB_CODE_SUCCESS;
-  if (buf == NULL) {
+  int32_t        lino = 0;
-    return terrno;
+  char*          buf = NULL;
-  }
+  SFirstLastRes* pRes = NULL;
 
-  SFirstLastRes* pRes = (SFirstLastRes*)((char*)buf + VARSTR_HEADER_SIZE);
+  TSDB_CHECK_NULL(pCol, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
+  buf = taosMemoryCalloc(1, pCol->info.bytes);
+  TSDB_CHECK_NULL(buf, code, lino, _end, terrno);
+
+  pRes = (SFirstLastRes*)((char*)buf + VARSTR_HEADER_SIZE);
   pRes->bytes = 0;
   pRes->hasResult = true;
   pRes->isNull = true;
   varDataSetLen(buf, pCol->info.bytes - VARSTR_HEADER_SIZE);
-  int32_t code = colDataSetVal(pCol, row, buf, false);
+  code = colDataSetVal(pCol, row, buf, false);
-  taosMemoryFree(buf);
+  TSDB_CHECK_CODE(code, lino, _end);
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  if (buf != NULL) {
+    taosMemoryFreeClear(buf);
+  }
   return code;
 }
 
 static int32_t saveOneRowForLastRaw(SLastCol* pColVal, SCacheRowsReader* pReader, const int32_t slotId,
-                                 SColumnInfoData* pColInfoData, int32_t numOfRows) {
+                                    SColumnInfoData* pColInfoData, int32_t numOfRows) {
-  SColVal* pVal = &pColVal->colVal;
+  int32_t  code = TSDB_CODE_SUCCESS;
-  int32_t code = 0;
+  int32_t  lino = 0;
+  SColVal* pVal = NULL;
+
+  TSDB_CHECK_NULL(pColVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
+  pVal = &pColVal->colVal;
 
   // allNullRow = false;
   if (IS_VAR_DATA_TYPE(pColVal->colVal.value.type)) {
     if (!COL_VAL_IS_VALUE(&pColVal->colVal)) {
       colDataSetNULL(pColInfoData, numOfRows);
     } else {
+      TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);
       varDataSetLen(pReader->transferBuf[slotId], pVal->value.nData);
 
       memcpy(varDataVal(pReader->transferBuf[slotId]), pVal->value.pData, pVal->value.nData);
       code = colDataSetVal(pColInfoData, numOfRows, pReader->transferBuf[slotId], false);
+      TSDB_CHECK_CODE(code, lino, _end);
     }
   } else {
     code = colDataSetVal(pColInfoData, numOfRows, (const char*)&pVal->value.val, !COL_VAL_IS_VALUE(pVal));
+    TSDB_CHECK_CODE(code, lino, _end);
   }
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   return code;
 }
 
 static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* pReader, const int32_t* slotIds,
                           const int32_t* dstSlotIds, void** pRes, const char* idStr) {
-  int32_t numOfRows = pBlock->info.rows;
+  int32_t code = TSDB_CODE_SUCCESS;
-  int32_t code = 0;
+  int32_t lino = 0;
+  int32_t numOfRows = 0;
+  SArray* funcTypeBlockArray = NULL;
+
+  TSDB_CHECK_NULL(pBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  if (pReader->numOfCols > 0) {
+    TSDB_CHECK_NULL(slotIds, code, lino, _end, TSDB_CODE_INVALID_PARA);
+    TSDB_CHECK_NULL(dstSlotIds, code, lino, _end, TSDB_CODE_INVALID_PARA);
+    TSDB_CHECK_NULL(pRes, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  }
+
+  numOfRows = pBlock->info.rows;
 
   if (HASTYPE(pReader->type, CACHESCAN_RETRIEVE_LAST)) {
     uint64_t       ts = TSKEY_MIN;
     SFirstLastRes* p = NULL;
     col_id_t       colId = -1;
 
-    SArray* funcTypeBlockArray = taosArrayInit(pReader->numOfCols, sizeof(int32_t));
+    funcTypeBlockArray = taosArrayInit(pReader->numOfCols, sizeof(int32_t));
-    if (funcTypeBlockArray == NULL) {
+    TSDB_CHECK_NULL(funcTypeBlockArray, code, lino, _end, terrno);
-      return terrno;
-    }
 
     for (int32_t i = 0; i < pReader->numOfCols; ++i) {
       SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, dstSlotIds[i]);
-      if (pColInfoData == NULL) {
+      TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);
-        return TSDB_CODE_INVALID_PARA;
-      }
 
       int32_t funcType = FUNCTION_TYPE_CACHE_LAST;
       if (pReader->pFuncTypeList != NULL && taosArrayGetSize(pReader->pFuncTypeList) > i) {
         void* pVal = taosArrayGet(pReader->pFuncTypeList, i);
-        if (pVal == NULL) {
+        TSDB_CHECK_NULL(pVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
-          return TSDB_CODE_INVALID_PARA;
-        }
 
-        funcType = *(int32_t*) pVal;
+        funcType = *(int32_t*)pVal;
         pVal = taosArrayGet(pReader->pFuncTypeList, i);
-        if (pVal == NULL) {
+        TSDB_CHECK_NULL(pVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
-          return TSDB_CODE_INVALID_PARA;
-        }
 
         void* px = taosArrayInsert(funcTypeBlockArray, dstSlotIds[i], pVal);
-        if (px == NULL) {
+        TSDB_CHECK_NULL(px, code, lino, _end, terrno);
-          return terrno;
-        }
       }
 
       if (slotIds[i] == -1) {
@@ -110,24 +137,18 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
         }
 
         code = setFirstLastResColToNull(pColInfoData, numOfRows);
-        if (code) {
+        TSDB_CHECK_CODE(code, lino, _end);
-          return code;
-        }
         continue;
       }
 
       int32_t   slotId = slotIds[i];
       SLastCol* pColVal = (SLastCol*)taosArrayGet(pRow, i);
-      if (pColVal == NULL) {
+      TSDB_CHECK_NULL(pColVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
-        return TSDB_CODE_INVALID_PARA;
-      }
 
       colId = pColVal->colVal.cid;
       if (FUNCTION_TYPE_CACHE_LAST_ROW == funcType) {
         code = saveOneRowForLastRaw(pColVal, pReader, slotId, pColInfoData, numOfRows);
-        if (code) {
+        TSDB_CHECK_CODE(code, lino, _end);
-          return code;
-        }
 
         continue;
       }
@@ -154,22 +175,16 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
       p->hasResult = true;
       varDataSetLen(pRes[i], pColInfoData->info.bytes - VARSTR_HEADER_SIZE);
       code = colDataSetVal(pColInfoData, numOfRows, (const char*)pRes[i], false);
-      if (code) {
+      TSDB_CHECK_CODE(code, lino, _end);
-        return code;
-      }
     }
 
     for (int32_t idx = 0; idx < taosArrayGetSize(pBlock->pDataBlock); ++idx) {
       SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, idx);
-      if (pCol == NULL) {
+      TSDB_CHECK_NULL(pCol, code, lino, _end, TSDB_CODE_INVALID_PARA);
-        return TSDB_CODE_INVALID_PARA;
-      }
 
       if (idx < funcTypeBlockArray->size) {
         void* pVal = taosArrayGet(funcTypeBlockArray, idx);
-        if (pVal == NULL) {
+        TSDB_CHECK_NULL(pVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
-          return TSDB_CODE_INVALID_PARA;
-        }
 
         int32_t funcType = *(int32_t*)pVal;
         if (FUNCTION_TYPE_CACHE_LAST_ROW == funcType) {
@@ -182,17 +197,13 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
           colDataSetNULL(pCol, numOfRows);
         } else {
           code = colDataSetVal(pCol, numOfRows, (const char*)&ts, false);
-          if (code) {
+          TSDB_CHECK_CODE(code, lino, _end);
-            return code;
-          }
         }
         continue;
       } else if (pReader->numOfCols == 1 && idx != dstSlotIds[0] && (pCol->info.colId == colId || colId == -1)) {
         if (p && !p->isNull) {
           code = colDataSetVal(pCol, numOfRows, p->buf, false);
-          if (code) {
+          TSDB_CHECK_CODE(code, lino, _end);
-            return code;
-          }
         } else {
           colDataSetNULL(pCol, numOfRows);
         }
@@ -201,13 +212,10 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
 
     // pBlock->info.rows += allNullRow ? 0 : 1;
     ++pBlock->info.rows;
-    taosArrayDestroy(funcTypeBlockArray);
   } else if (HASTYPE(pReader->type, CACHESCAN_RETRIEVE_LAST_ROW)) {
     for (int32_t i = 0; i < pReader->numOfCols; ++i) {
       SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, dstSlotIds[i]);
-      if (pColInfoData == NULL) {
+      TSDB_CHECK_NULL(pColInfoData, code, lino, _end, TSDB_CODE_INVALID_PARA);
-        return TSDB_CODE_INVALID_PARA;
-      }
 
       int32_t slotId = slotIds[i];
       if (slotId == -1) {
@@ -216,47 +224,53 @@ static int32_t saveOneRow(SArray* pRow, SSDataBlock* pBlock, SCacheRowsReader* p
       }
 
       SLastCol* pColVal = (SLastCol*)taosArrayGet(pRow, i);
-      if (pColVal == NULL) {
+      TSDB_CHECK_NULL(pColVal, code, lino, _end, TSDB_CODE_INVALID_PARA);
-        return TSDB_CODE_INVALID_PARA;
-      }
 
       code = saveOneRowForLastRaw(pColVal, pReader, slotId, pColInfoData, numOfRows);
-      if (code) {
+      TSDB_CHECK_CODE(code, lino, _end);
-        return code;
-      }
     }
 
     // pBlock->info.rows += allNullRow ? 0 : 1;
     ++pBlock->info.rows;
   } else {
     tsdbError("invalid retrieve type:%d, %s", pReader->type, idStr);
-    return TSDB_CODE_INVALID_PARA;
+    code = TSDB_CODE_INVALID_PARA;
+    TSDB_CHECK_CODE(code, lino, _end);
   }
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  if (funcTypeBlockArray != NULL) {
+    taosArrayDestroy(funcTypeBlockArray);
+  }
   return code;
 }
 
 static int32_t setTableSchema(SCacheRowsReader* p, uint64_t suid, const char* idstr) {
-  int32_t numOfTables = p->numOfTables;
+  int32_t code = TSDB_CODE_SUCCESS;
-  int32_t  code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
+  int32_t numOfTables = 0;
+
+  TSDB_CHECK_NULL(p, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
+  numOfTables = p->numOfTables;
 
   if (suid != 0) {
     code = metaGetTbTSchemaNotNull(p->pVnode->pMeta, suid, -1, 1, &p->pSchema);
     if (TSDB_CODE_SUCCESS != code) {
       tsdbWarn("stable:%" PRIu64 " has been dropped, failed to retrieve cached rows, %s", suid, idstr);
-      if(code == TSDB_CODE_NOT_FOUND) {
+      if (code == TSDB_CODE_NOT_FOUND) {
-        return TSDB_CODE_PAR_TABLE_NOT_EXIST;
+        code = TSDB_CODE_PAR_TABLE_NOT_EXIST;
-      }  else {
-        return code;
       }
+      TSDB_CHECK_CODE(code, lino, _end);
     }
   } else {
     for (int32_t i = 0; i < numOfTables; ++i) {
       uint64_t uid = p->pTableList[i].uid;
       code = metaGetTbTSchemaMaybeNull(p->pVnode->pMeta, uid, -1, 1, &p->pSchema);
-      if(code != TSDB_CODE_SUCCESS) {
+      TSDB_CHECK_CODE(code, lino, _end);
-        return code;
-      }
       if (p->pSchema != NULL) {
         break;
       }
@@ -267,33 +281,52 @@ static int32_t setTableSchema(SCacheRowsReader* p, uint64_t suid, const char* id
     // all queried tables have been dropped already, return immediately.
     if (p->pSchema == NULL) {
       tsdbWarn("all queried tables has been dropped, try next group, %s", idstr);
-      return TSDB_CODE_PAR_TABLE_NOT_EXIST;
+      code = TSDB_CODE_PAR_TABLE_NOT_EXIST;
+      TSDB_CHECK_CODE(code, lino, _end);
     }
   }
 
-  return TSDB_CODE_SUCCESS;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 int32_t tsdbReuseCacherowsReader(void* reader, void* pTableIdList, int32_t numOfTables) {
+  int32_t           code = TSDB_CODE_SUCCESS;
+  int32_t           lino = 0;
   SCacheRowsReader* pReader = (SCacheRowsReader*)reader;
 
+  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
   pReader->pTableList = pTableIdList;
   pReader->numOfTables = numOfTables;
   pReader->lastTs = INT64_MIN;
   destroySttBlockReader(pReader->pLDataIterArray, NULL);
   pReader->pLDataIterArray = taosArrayInit(4, POINTER_BYTES);
+  TSDB_CHECK_NULL(pReader->pLDataIterArray, code, lino, _end, terrno);
 
-  return (pReader->pLDataIterArray != NULL) ? TSDB_CODE_SUCCESS : terrno;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList, int32_t numOfTables, int32_t numOfCols,
                                 SArray* pCidList, int32_t* pSlotIds, uint64_t suid, void** pReader, const char* idstr,
                                 SArray* pFuncTypeList, SColumnInfo* pPkCol, int32_t numOfPks) {
+  int32_t           code = TSDB_CODE_SUCCESS;
+  int32_t           lino = 0;
+  SCacheRowsReader* p = NULL;
+
+  TSDB_CHECK_NULL(pVnode, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
   *pReader = NULL;
-  SCacheRowsReader* p = taosMemoryCalloc(1, sizeof(SCacheRowsReader));
+  p = taosMemoryCalloc(1, sizeof(SCacheRowsReader));
-  if (p == NULL) {
+  TSDB_CHECK_NULL(p, code, lino, _end, terrno);
-    return terrno;
-  }
 
   p->type = type;
   p->pVnode = pVnode;
@@ -307,12 +340,13 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList,
 
   p->rowKey.numOfPKs = numOfPks;
   if (numOfPks > 0) {
+    TSDB_CHECK_NULL(pPkCol, code, lino, _end, TSDB_CODE_INVALID_PARA);
     p->rowKey.pks[0].type = pPkCol->type;
     if (IS_VAR_DATA_TYPE(pPkCol->type)) {
       p->rowKey.pks[0].pData = taosMemoryCalloc(1, pPkCol->bytes);
       if (p->rowKey.pks[0].pData == NULL) {
-        taosMemoryFree(p);
+        taosMemoryFreeClear(p);
-        return terrno;
+        TSDB_CHECK_NULL(p->rowKey.pks[0].pData, code, lino, _end, terrno);
       }
     }
 
@@ -321,48 +355,46 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList,
 
   if (numOfTables == 0) {
     *pReader = p;
-    return TSDB_CODE_SUCCESS;
+    p = NULL;
+    goto _end;
   }
 
   p->pTableList = pTableIdList;
   p->numOfTables = numOfTables;
 
-  int32_t code = setTableSchema(p, suid, idstr);
+  code = setTableSchema(p, suid, idstr);
-  if (code != TSDB_CODE_SUCCESS) {
+  TSDB_CHECK_CODE(code, lino, _end);
-    tsdbCacherowsReaderClose(p);
-    return code;
-  }
 
   p->transferBuf = taosMemoryCalloc(p->pSchema->numOfCols, POINTER_BYTES);
-  if (p->transferBuf == NULL) {
+  TSDB_CHECK_NULL(p->transferBuf, code, lino, _end, terrno);
-    tsdbCacherowsReaderClose(p);
-    return terrno;
-  }
 
   for (int32_t i = 0; i < p->pSchema->numOfCols; ++i) {
     if (IS_VAR_DATA_TYPE(p->pSchema->columns[i].type)) {
       p->transferBuf[i] = taosMemoryMalloc(p->pSchema->columns[i].bytes);
-      if (p->transferBuf[i] == NULL) {
+      TSDB_CHECK_NULL(p->transferBuf[i], code, lino, _end, terrno);
-        tsdbCacherowsReaderClose(p);
-        return terrno;
-      }
     }
   }
 
-  p->idstr = taosStrdup(idstr);
+  if (idstr != NULL) {
-  if (idstr != NULL && p->idstr == NULL) {
+    p->idstr = taosStrdup(idstr);
-    tsdbCacherowsReaderClose(p);
+    TSDB_CHECK_NULL(p->idstr, code, lino, _end, terrno);
-    return terrno;
   }
   code = taosThreadMutexInit(&p->readerMutex, NULL);
-  if (code) {
+  TSDB_CHECK_CODE(code, lino, _end);
-    tsdbCacherowsReaderClose(p);
-    return code;
-  }
 
   p->lastTs = INT64_MIN;
 
   *pReader = p;
+  p = NULL;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    *pReader = NULL;
+  }
+  if (p != NULL) {
+    tsdbCacherowsReaderClose(p);
+  }
   return code;
 }
 
@@ -393,6 +425,7 @@ void tsdbCacherowsReaderClose(void* pReader) {
 
   if (p->pLDataIterArray) {
     destroySttBlockReader(p->pLDataIterArray, NULL);
+    p->pLDataIterArray = NULL;
   }
 
   if (p->pFileReader) {
@@ -401,7 +434,7 @@ void tsdbCacherowsReaderClose(void* pReader) {
   }
 
   taosMemoryFree((void*)p->idstr);
-  (void) taosThreadMutexDestroy(&p->readerMutex);
+  (void)taosThreadMutexDestroy(&p->readerMutex);
 
   if (p->pTableMap) {
     void*   pe = NULL;
@@ -443,39 +476,32 @@ static int32_t tsdbCacheQueryReseek(void* pQHandle) {
 
 int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32_t* slotIds, const int32_t* dstSlotIds,
                               SArray* pTableUidList, bool* pGotAll) {
-  if (pReader == NULL || pResBlock == NULL) {
-    return TSDB_CODE_INVALID_PARA;
-  }
-
   int32_t           code = TSDB_CODE_SUCCESS;
+  int32_t           lino = 0;
   bool              hasRes = false;
   SArray*           pRow = NULL;
   void**            pRes = NULL;
-  SCacheRowsReader* pr = pReader;
+  SCacheRowsReader* pr = NULL;
   int32_t           pkBufLen = 0;
 
+  TSDB_CHECK_NULL(pReader, code, lino, _end, TSDB_CODE_INVALID_PARA);
+  TSDB_CHECK_NULL(pResBlock, code, lino, _end, TSDB_CODE_INVALID_PARA);
+
+  pr = pReader;
+
   pr->pReadSnap = NULL;
   pRow = taosArrayInit(TARRAY_SIZE(pr->pCidList), sizeof(SLastCol));
-  if (pRow == NULL) {
+  TSDB_CHECK_NULL(pRow, code, lino, _end, terrno);
-    code = terrno;
-    goto _end;
-  }
 
   pRes = taosMemoryCalloc(pr->numOfCols, POINTER_BYTES);
-  if (pRes == NULL) {
+  TSDB_CHECK_NULL(pRes, code, lino, _end, terrno);
-    code = terrno;
-    goto _end;
-  }
 
   pkBufLen = (pr->rowKey.numOfPKs > 0) ? pr->pkColumn.bytes : 0;
   for (int32_t j = 0; j < pr->numOfCols; ++j) {
     int32_t bytes = (slotIds[j] == -1) ? 1 : pr->pSchema->columns[slotIds[j]].bytes;
 
     pRes[j] = taosMemoryCalloc(1, sizeof(SFirstLastRes) + bytes + pkBufLen + VARSTR_HEADER_SIZE);
-    if (pRes[j] == NULL) {
+    TSDB_CHECK_NULL(pRes[j], code, lino, _end, terrno);
-      code = terrno;
-      goto _end;
-    }
 
     SFirstLastRes* p = (SFirstLastRes*)varDataVal(pRes[j]);
     p->ts = INT64_MIN;
@@ -483,9 +509,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
 
   (void)taosThreadMutexLock(&pr->readerMutex);
   code = tsdbTakeReadSnap2((STsdbReader*)pr, tsdbCacheQueryReseek, &pr->pReadSnap, pr->idstr);
-  if (code != TSDB_CODE_SUCCESS) {
+  TSDB_CHECK_CODE(code, lino, _end);
-    goto _end;
-  }
 
   int8_t ltype = (pr->type & CACHESCAN_RETRIEVE_LAST) >> 3;
 
@@ -494,20 +518,14 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
   // retrieve the only one last row of all tables in the uid list.
   if (HASTYPE(pr->type, CACHESCAN_RETRIEVE_TYPE_SINGLE)) {
     SArray* pLastCols = taosArrayInit(pr->numOfCols, sizeof(SLastCol));
-    if (pLastCols == NULL) {
+    TSDB_CHECK_NULL(pLastCols, code, lino, _end, terrno);
-      code = terrno;
-      goto _end;
-    }
 
     for (int32_t i = 0; i < pr->numOfCols; ++i) {
       int32_t slotId = slotIds[i];
       if (slotId == -1) {
         SLastCol p = {.rowKey.ts = INT64_MIN, .colVal.value.type = TSDB_DATA_TYPE_BOOL, .colVal.flag = CV_FLAG_NULL};
         void*    px = taosArrayPush(pLastCols, &p);
-        if (px == NULL) {
+        TSDB_CHECK_NULL(px, code, lino, _end, terrno);
-          code = terrno;
-          goto _end;
-        }
         continue;
       }
       struct STColumn* pCol = &pr->pSchema->columns[slotId];
@@ -518,29 +536,19 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
         for (int32_t j = 0; j < pr->rowKey.numOfPKs; j++) {
           p.rowKey.pks[j].type = pr->pkColumn.type;
           if (IS_VAR_DATA_TYPE(pr->pkColumn.type)) {
-
             p.rowKey.pks[j].pData = taosMemoryCalloc(1, pr->pkColumn.bytes);
-            if (p.rowKey.pks[j].pData == NULL) {
+            TSDB_CHECK_NULL(p.rowKey.pks[j].pData, code, lino, _end, terrno);
-              code = terrno;
-              goto _end;
-            }
           }
         }
       }
 
       if (IS_VAR_DATA_TYPE(pCol->type)) {
         p.colVal.value.pData = taosMemoryCalloc(pCol->bytes, sizeof(char));
-        if (p.colVal.value.pData == NULL) {
+        TSDB_CHECK_NULL(p.colVal.value.pData, code, lino, _end, terrno);
-          code = terrno;
-          goto _end;
-        }
       }
 
       void* px = taosArrayPush(pLastCols, &p);
-      if (px == NULL) {
+      TSDB_CHECK_NULL(px, code, lino, _end, terrno);
-        code = terrno;
-        goto _end;
-      }
     }
 
     int64_t st = taosGetTimestampUs();
@@ -549,11 +557,10 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
       tb_uid_t uid = pTableList[i].uid;
 
       code = tsdbCacheGetBatch(pr->pTsdb, uid, pRow, pr, ltype);
-      if (code == -1) {// fix the invalid return code
+      if (code == -1) {  // fix the invalid return code
         code = 0;
-      } else if (code != 0) {
-        goto _end;
       }
+      TSDB_CHECK_CODE(code, lino, _end);
 
       if (TARRAY_SIZE(pRow) <= 0 || COL_VAL_IS_NONE(&((SLastCol*)TARRAY_DATA(pRow))[0].colVal)) {
         taosArrayClearEx(pRow, tsdbCacheFreeSLastColItem);
@@ -600,10 +607,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
             if (k == 0) {
               if (TARRAY_SIZE(pTableUidList) == 0) {
                 void* px = taosArrayPush(pTableUidList, &uid);
-                if (px == NULL) {
+                TSDB_CHECK_NULL(px, code, lino, _end, terrno);
-                  code = terrno;
-                  goto _end;
-                }
               } else {
                 taosArraySet(pTableUidList, 0, &uid);
               }
@@ -654,9 +658,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
 
     if (hasRes) {
       code = saveOneRow(pLastCols, pResBlock, pr, slotIds, dstSlotIds, pRes, pr->idstr);
-      if (code) {
+      TSDB_CHECK_CODE(code, lino, _end);
-        goto _end;
-      }
     }
 
     taosArrayDestroyEx(pLastCols, tsdbCacheFreeSLastColItem);
@@ -666,11 +668,10 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
       tb_uid_t uid = pTableList[i].uid;
 
       if ((code = tsdbCacheGetBatch(pr->pTsdb, uid, pRow, pr, ltype)) != 0) {
-        if (code == -1) {// fix the invalid return code
+        if (code == -1) {  // fix the invalid return code
           code = 0;
-        } else if (code != 0) {
-          goto _end;
         }
+        TSDB_CHECK_CODE(code, lino, _end);
       }
 
       if (TARRAY_SIZE(pRow) <= 0 || COL_VAL_IS_NONE(&((SLastCol*)TARRAY_DATA(pRow))[0].colVal)) {
@@ -679,17 +680,12 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
       }
 
       code = saveOneRow(pRow, pResBlock, pr, slotIds, dstSlotIds, pRes, pr->idstr);
-      if (code) {
+      TSDB_CHECK_CODE(code, lino, _end);
-        goto _end;
-      }
 
       taosArrayClearEx(pRow, tsdbCacheFreeSLastColItem);
 
       void* px = taosArrayPush(pTableUidList, &uid);
-      if (px == NULL) {
+      TSDB_CHECK_NULL(px, code, lino, _end, terrno);
-        code = terrno;
-        goto _end;
-      }
 
       ++pr->tableIndex;
       if (pResBlock->info.rows >= pResBlock->info.capacity) {
@@ -702,6 +698,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
     }
   } else {
     code = TSDB_CODE_INVALID_PARA;
+    TSDB_CHECK_CODE(code, lino, _end);
   }
 
 _end:
@@ -723,5 +720,8 @@ _end:
   taosMemoryFree(pRes);
   taosArrayDestroy(pRow);
 
+  if (code != TSDB_CODE_SUCCESS) {
+    tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   return code;
 }

source/dnode/vnode/src/tsdb/tsdbReadUtil.h

@@ -30,13 +30,13 @@ extern "C" {
   do {                      \
     (_w)->skey = INT64_MAX; \
     (_w)->ekey = INT64_MIN; \
-  } while (0);
+  } while (0)
 
 #define INIT_KEYRANGE(_k)      \
   do {                         \
     (_k)->skey.ts = INT64_MAX; \
     (_k)->ekey.ts = INT64_MIN; \
-  } while (0);
+  } while (0)
 
 #define tRowGetKeyEx(_pRow, _pKey)                                         \
   {                                                                        \
@@ -72,7 +72,6 @@ typedef struct STsdbReaderInfo {
 } STsdbReaderInfo;
 
 typedef struct SBlockInfoBuf {
-  int32_t currentIndex;
   SArray* pData;
   int32_t numPerBucket;
   int32_t numOfTables;
@@ -241,7 +240,6 @@ typedef struct SDataBlockIter {
   int32_t    index;
   SArray*    blockList;  // SArray<SFileDataBlockInfo>
   int32_t    order;
-  SDataBlk   block;  // current SDataBlk data
 } SDataBlockIter;
 
 typedef struct SFileBlockDumpInfo {
@@ -321,7 +319,7 @@ int32_t createDataBlockScanInfo(STsdbReader* pTsdbReader, SBlockInfoBuf* pBuf, c
 int32_t initTableBlockScanInfo(STableBlockScanInfo* pScanInfo, uint64_t uid, SSHashObj* pTableMap,
                                STsdbReader* pReader);
 void    clearBlockScanInfo(STableBlockScanInfo* p);
-void    destroyAllBlockScanInfo(SSHashObj* pTableMap);
+void    destroyAllBlockScanInfo(SSHashObj** pTableMap);
 void    resetAllDataBlockScanInfo(SSHashObj* pTableMap, int64_t ts, int32_t step);
 void    cleanupInfoForNextFileset(SSHashObj* pTableMap);
 int32_t ensureBlockScanInfoBuf(SBlockInfoBuf* pBuf, int32_t numOfTables);
@@ -335,7 +333,7 @@ void    clearBrinBlockIter(SBrinRecordIter* pIter);
 
 // initialize block iterator API
 int32_t initBlockIterator(STsdbReader* pReader, SDataBlockIter* pBlockIter, int32_t numOfBlocks, SArray* pTableList);
-bool    blockIteratorNext(SDataBlockIter* pBlockIter, const char* idStr);
+bool    blockIteratorNext(SDataBlockIter* pBlockIter);
 
 // load tomb data API (stt/mem only for one table each, tomb data from data files are load for all tables at one time)
 int32_t loadMemTombData(SArray** ppMemDelData, STbData* pMemTbData, STbData* piMemTbData, int64_t ver);

source/libs/command/src/command.c

@@ -56,6 +56,7 @@ static int32_t buildRetrieveTableRsp(SSDataBlock* pBlock, int32_t numOfCols, SRe
   int32_t len = blockEncode(pBlock, (*pRsp)->data + PAYLOAD_PREFIX_LEN, dataEncodeBufSize, numOfCols);
   if(len < 0) {
     taosMemoryFree(*pRsp);
+    *pRsp = NULL;
     return terrno;
   }
   SET_PAYLOAD_LEN((*pRsp)->data, len, len);
@@ -953,12 +954,18 @@ static int32_t buildLocalVariablesResultDataBlock(SSDataBlock** pOutput) {
     goto _exit;
   }
 
+  infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
+  infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD4_LEN;
+  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
+    goto _exit;
+  }
+
   *pOutput = pBlock;
 
 _exit:
   if (terrno != TSDB_CODE_SUCCESS) {
-    taosMemoryFree(pBlock);
     taosArrayDestroy(pBlock->pDataBlock);
+    taosMemoryFree(pBlock);
   }
   return terrno;
 }

source/libs/command/src/explain.c

@@ -2112,6 +2112,7 @@ static int32_t qExplainGenerateRsp(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp)
 }
 
 int32_t qExplainUpdateExecInfo(SExplainCtx *pCtx, SExplainRsp *pRspMsg, int32_t groupId, SRetrieveTableRsp **pRsp) {
+  if(!pCtx || !pRspMsg || !pRsp) return TSDB_CODE_INVALID_PARA;
   SExplainResNode *node = NULL;
   int32_t          code = 0;
   bool             groupDone = false;
@@ -2176,6 +2177,7 @@ _exit:
 }
 
 int32_t qExecStaticExplain(SQueryPlan *pDag, SRetrieveTableRsp **pRsp) {
+  if (!pDag || !pRsp) return TSDB_CODE_INVALID_PARA;
   int32_t      code = 0;
   SExplainCtx *pCtx = NULL;
 
@@ -2188,6 +2190,7 @@ _return:
 }
 
 int32_t qExecExplainBegin(SQueryPlan *pDag, SExplainCtx **pCtx, int64_t startTs) {
+  if(!pDag || !pCtx) return TSDB_CODE_INVALID_PARA;
   QRY_ERR_RET(qExplainPrepareCtx(pDag, pCtx));
 
   (*pCtx)->reqStartTs = startTs;
@@ -2197,6 +2200,7 @@ int32_t qExecExplainBegin(SQueryPlan *pDag, SExplainCtx **pCtx, int64_t startTs)
 }
 
 int32_t qExecExplainEnd(SExplainCtx *pCtx, SRetrieveTableRsp **pRsp) {
+  if(!pCtx || !pRsp) return TSDB_CODE_INVALID_PARA;
   int32_t code = 0;
   pCtx->jobDoneTs = taosGetTimestampUs();
 

source/libs/executor/src/sysscanoperator.c

@@ -685,10 +685,10 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
         pAPI->metaFn.pauseTableMetaCursor(pInfo->pCur);
         break;
       }
-    } else {
-      code = sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, pDataBlock, tableName, schemaRow, typeName);
-      QUERY_CHECK_CODE(code, lino, _end);
     }
+    // if pInfo->pRes->info.rows == 0, also need to add the meta to pDataBlock
+    code = sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, pDataBlock, tableName, schemaRow, typeName);
+    QUERY_CHECK_CODE(code, lino, _end);
   }
 
   if (numOfRows > 0) {
@@ -761,7 +761,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
 
     SMetaReader smrChildTable = {0};
     pAPI->metaReaderFn.initReader(&smrChildTable, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);
-    int32_t code = pAPI->metaReaderFn.getTableEntryByName(&smrChildTable, condTableName);
+    code = pAPI->metaReaderFn.getTableEntryByName(&smrChildTable, condTableName);
     if (code != TSDB_CODE_SUCCESS) {
       // terrno has been set by pAPI->metaReaderFn.getTableEntryByName, therefore, return directly
       pAPI->metaReaderFn.clearReader(&smrChildTable);
@@ -847,18 +847,18 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
         pAPI->metaReaderFn.clearReader(&smrSuperTable);
         break;
       }
-    } else {
+    }
-      code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &pInfo->pCur->mr, dbname, tableName, &numOfRows,
+    // if pInfo->pRes->info.rows == 0, also need to add this meta into datablock.
-                                              dataBlock);
+    code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &pInfo->pCur->mr, dbname, tableName, &numOfRows,
-      if (code != TSDB_CODE_SUCCESS) {
+                                            dataBlock);
-        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+    if (code != TSDB_CODE_SUCCESS) {
-        pAPI->metaReaderFn.clearReader(&smrSuperTable);
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
-        pAPI->metaFn.closeTableMetaCursor(pInfo->pCur);
+      pAPI->metaReaderFn.clearReader(&smrSuperTable);
-        pInfo->pCur = NULL;
+      pAPI->metaFn.closeTableMetaCursor(pInfo->pCur);
-        blockDataDestroy(dataBlock);
+      pInfo->pCur = NULL;
-        dataBlock = NULL;
+      blockDataDestroy(dataBlock);
-        T_LONG_JMP(pTaskInfo->env, terrno);
+      dataBlock = NULL;
-      }
+      T_LONG_JMP(pTaskInfo->env, terrno);
     }
     pAPI->metaReaderFn.clearReader(&smrSuperTable);
   }
@@ -2792,7 +2792,9 @@ static int32_t doBlockInfoScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes
   code = pAPI->tsdReader.tsdReaderGetDataBlockDistInfo(pBlockScanInfo->pHandle, &blockDistInfo);
   QUERY_CHECK_CODE(code, lino, _end);
 
-  blockDistInfo.numOfInmemRows = (int32_t)pAPI->tsdReader.tsdReaderGetNumOfInMemRows(pBlockScanInfo->pHandle);
+  blockDistInfo.numOfInmemRows = 0;
+  code = pAPI->tsdReader.tsdReaderGetNumOfInMemRows(pBlockScanInfo->pHandle, &blockDistInfo.numOfInmemRows);
+  QUERY_CHECK_CODE(code, lino, _end);
 
   SSDataBlock* pBlock = pBlockScanInfo->pResBlock;
 

source/libs/function/inc/tpercentile.h

@@ -26,7 +26,7 @@ extern "C" {
 struct tMemBucket;
 
 int32_t tMemBucketCreate(int32_t nElemSize, int16_t dataType, double minval, double maxval, bool hasWindowOrGroup,
-                         struct tMemBucket **pBucket);
+                         struct tMemBucket **pBucket, int32_t numOfElements);
 
 void tMemBucketDestroy(struct tMemBucket **pBucket);
 

source/libs/function/src/builtinsimpl.c

@@ -1805,7 +1805,7 @@ int32_t percentileFunction(SqlFunctionCtx* pCtx) {
       pResInfo->complete = true;
       return TSDB_CODE_SUCCESS;
     } else {
-      code = tMemBucketCreate(pCol->info.bytes, type, pInfo->minval, pInfo->maxval, pCtx->hasWindowOrGroup, &pInfo->pMemBucket);
+      code = tMemBucketCreate(pCol->info.bytes, type, pInfo->minval, pInfo->maxval, pCtx->hasWindowOrGroup, &pInfo->pMemBucket, pInfo->numOfElems);
       if (TSDB_CODE_SUCCESS != code) {
         return code;
       }

source/libs/function/src/tpercentile.c

@@ -269,18 +269,16 @@ static void resetSlotInfo(tMemBucket *pBucket) {
 }
 
 int32_t tMemBucketCreate(int32_t nElemSize, int16_t dataType, double minval, double maxval, bool hasWindowOrGroup,
-                         tMemBucket **pBucket) {
+                         tMemBucket **pBucket, int32_t numOfElements) {
   *pBucket = (tMemBucket *)taosMemoryCalloc(1, sizeof(tMemBucket));
   if (*pBucket == NULL) {
     return terrno;
   }
 
   if (hasWindowOrGroup) {
-    // With window or group by, we need to shrink page size and reduce page num to save memory.
+    // With window or group by, we need to shrink page size to save memory.
-    (*pBucket)->numOfSlots = DEFAULT_NUM_OF_SLOT / 8 ;  // 128 bucket
     (*pBucket)->bufPageSize = 4096;  // 4k per page
   } else {
-    (*pBucket)->numOfSlots = DEFAULT_NUM_OF_SLOT;
     (*pBucket)->bufPageSize = 16384 * 4;  // 16k per page
   }
 
@@ -302,6 +300,8 @@ int32_t tMemBucketCreate(int32_t nElemSize, int16_t dataType, double minval, dou
   }
 
   (*pBucket)->elemPerPage = ((*pBucket)->bufPageSize - sizeof(SFilePage)) / (*pBucket)->bytes;
+  (*pBucket)->numOfSlots = TMIN((int16_t)(numOfElements / ((*pBucket)->elemPerPage * 6)) + 1, DEFAULT_NUM_OF_SLOT);
+
   (*pBucket)->comparFn = getKeyComparFunc((*pBucket)->type, TSDB_ORDER_ASC);
 
   (*pBucket)->hashFunc = getHashFunc((*pBucket)->type);
@@ -587,7 +587,7 @@ int32_t getPercentileImpl(tMemBucket *pMemBucket, int32_t count, double fraction
         // try next round
         tMemBucket *tmpBucket = NULL;
         int32_t code = tMemBucketCreate(pMemBucket->bytes, pMemBucket->type, pSlot->range.dMinVal, pSlot->range.dMaxVal,
-                                            false, &tmpBucket);
+                                            false, &tmpBucket, pSlot->info.size);
         if (TSDB_CODE_SUCCESS != code) {
           tMemBucketDestroy(&tmpBucket);
           return code;

source/libs/function/src/tudf.c

@@ -62,6 +62,7 @@ static void    udfUdfdStopAsyncCb(uv_async_t *async);
 static void    udfWatchUdfd(void *args);
 
 void udfUdfdExit(uv_process_t *process, int64_t exitStatus, int32_t termSignal) {
+  TAOS_UDF_CHECK_PTR_RVOID(process);
   fnInfo("udfd process exited with status %" PRId64 ", signal %d", exitStatus, termSignal);
   SUdfdData *pData = process->data;
   if(pData == NULL) {
@@ -81,6 +82,7 @@ void udfUdfdExit(uv_process_t *process, int64_t exitStatus, int32_t termSignal)
 
 static int32_t udfSpawnUdfd(SUdfdData *pData) {
   fnInfo("start to init udfd");
+  TAOS_UDF_CHECK_PTR_RCODE(pData);
 
   int32_t              err = 0;
   uv_process_options_t options = {0};
@@ -271,17 +273,20 @@ _OVER:
 }
 
 static void udfUdfdCloseWalkCb(uv_handle_t *handle, void *arg) {
+  TAOS_UDF_CHECK_PTR_RVOID(handle);
   if (!uv_is_closing(handle)) {
     uv_close(handle, NULL);
   }
 }
 
 static void udfUdfdStopAsyncCb(uv_async_t *async) {
+  TAOS_UDF_CHECK_PTR_RVOID(async);
   SUdfdData *pData = async->data;
   uv_stop(&pData->loop);
 }
 
 static void udfWatchUdfd(void *args) {
+  TAOS_UDF_CHECK_PTR_RVOID(args);
   SUdfdData *pData = args;
   TAOS_UV_CHECK_ERRNO(uv_loop_init(&pData->loop));
   TAOS_UV_CHECK_ERRNO(uv_async_init(&pData->loop, &pData->stopAsync, udfUdfdStopAsyncCb));
@@ -877,6 +882,7 @@ void *decodeUdfResponse(const void *buf, SUdfResponse *rsp) {
 }
 
 void freeUdfColumnData(SUdfColumnData *data, SUdfColumnMeta *meta) {
+  TAOS_UDF_CHECK_PTR_RVOID(data, meta);
   if (IS_VAR_DATA_TYPE(meta->type)) {
     taosMemoryFree(data->varLenCol.varOffsets);
     data->varLenCol.varOffsets = NULL;
@@ -890,9 +896,13 @@ void freeUdfColumnData(SUdfColumnData *data, SUdfColumnMeta *meta) {
   }
 }
 
-void freeUdfColumn(SUdfColumn *col) { freeUdfColumnData(&col->colData, &col->colMeta); }
+void freeUdfColumn(SUdfColumn *col) {
+  TAOS_UDF_CHECK_PTR_RVOID(col);
+  freeUdfColumnData(&col->colData, &col->colMeta);
+}
 
 void freeUdfDataDataBlock(SUdfDataBlock *block) {
+  TAOS_UDF_CHECK_PTR_RVOID(block);
   for (int32_t i = 0; i < block->numOfCols; ++i) {
     freeUdfColumn(block->udfCols[i]);
     taosMemoryFree(block->udfCols[i]);
@@ -903,11 +913,17 @@ void freeUdfDataDataBlock(SUdfDataBlock *block) {
 }
 
 void freeUdfInterBuf(SUdfInterBuf *buf) {
+  TAOS_UDF_CHECK_PTR_RVOID(buf);
   taosMemoryFree(buf->buf);
   buf->buf = NULL;
 }
 
 int32_t convertDataBlockToUdfDataBlock(SSDataBlock *block, SUdfDataBlock *udfBlock) {
+  TAOS_UDF_CHECK_PTR_RCODE(block, udfBlock);
+  int32_t code = blockDataCheck(block);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
   udfBlock->numOfRows = block->info.rows;
   udfBlock->numOfCols = taosArrayGetSize(block->pDataBlock);
   udfBlock->udfCols = taosMemoryCalloc(taosArrayGetSize(block->pDataBlock), sizeof(SUdfColumn *));
@@ -977,6 +993,7 @@ int32_t convertDataBlockToUdfDataBlock(SSDataBlock *block, SUdfDataBlock *udfBlo
 }
 
 int32_t convertUdfColumnToDataBlock(SUdfColumn *udfCol, SSDataBlock *block) {
+  TAOS_UDF_CHECK_PTR_RCODE(udfCol, block);
   int32_t         code = 0, lino = 0;
   SUdfColumnMeta *meta = &udfCol->colMeta;
 
@@ -1002,6 +1019,8 @@ int32_t convertUdfColumnToDataBlock(SUdfColumn *udfCol, SSDataBlock *block) {
   }
   block->info.rows = udfCol->colData.numOfRows;
 
+  code = blockDataCheck(block);
+  TAOS_CHECK_GOTO(code, &lino, _exit);
 _exit:
   if (code != 0) {
     fnError("failed to convert udf column to data block, code:%d, line:%d", code, lino);
@@ -1010,6 +1029,7 @@ _exit:
 }
 
 int32_t convertScalarParamToDataBlock(SScalarParam *input, int32_t numOfCols, SSDataBlock *output) {
+  TAOS_UDF_CHECK_PTR_RCODE(input, output);
   int32_t code = 0, lino = 0;
   int32_t numOfRows = 0;
   for (int32_t i = 0; i < numOfCols; ++i) {
@@ -1057,6 +1077,7 @@ _exit:
 }
 
 int32_t convertDataBlockToScalarParm(SSDataBlock *input, SScalarParam *output) {
+  TAOS_UDF_CHECK_PTR_RCODE(input, output);
   if (taosArrayGetSize(input->pDataBlock) != 1) {
     fnError("scalar function only support one column");
     return 0;
@@ -1135,6 +1156,7 @@ int32_t compareUdfcFuncSub(const void *elem1, const void *elem2) {
 }
 
 int32_t acquireUdfFuncHandle(char *udfName, UdfcFuncHandle *pHandle) {
+  TAOS_UDF_CHECK_PTR_RCODE(udfName, pHandle);
   int32_t code = 0, line = 0;
   uv_mutex_lock(&gUdfcProxy.udfStubsMutex);
   SUdfcFuncStub key = {0};
@@ -1193,6 +1215,7 @@ _exit:
 }
 
 void releaseUdfFuncHandle(char *udfName, UdfcFuncHandle handle) {
+  TAOS_UDF_CHECK_PTR_RVOID(udfName);
   uv_mutex_lock(&gUdfcProxy.udfStubsMutex);
   SUdfcFuncStub key = {0};
   tstrncpy(key.udfName, udfName, TSDB_FUNC_NAME_LEN);
@@ -1295,6 +1318,7 @@ int32_t cleanUpUdfs() {
 }
 
 int32_t callUdfScalarFunc(char *udfName, SScalarParam *input, int32_t numOfCols, SScalarParam *output) {
+  TAOS_UDF_CHECK_PTR_RCODE(udfName, input, output);
   UdfcFuncHandle handle = NULL;
   int32_t        code = acquireUdfFuncHandle(udfName, &handle);
   if (code != 0) {
@@ -1324,6 +1348,10 @@ int32_t callUdfScalarFunc(char *udfName, SScalarParam *input, int32_t numOfCols,
 }
 
 bool udfAggGetEnv(struct SFunctionNode *pFunc, SFuncExecEnv *pEnv) {
+  if (pFunc == NULL || pEnv == NULL) {
+    fnError("udfAggGetEnv: invalid input lint: %d", __LINE__);
+    return false;
+  }
   if (fmIsScalarFunc(pFunc->funcId)) {
     return false;
   }
@@ -1332,6 +1360,7 @@ bool udfAggGetEnv(struct SFunctionNode *pFunc, SFuncExecEnv *pEnv) {
 }
 
 int32_t udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pResultCellInfo) {
+  TAOS_UDF_CHECK_PTR_RCODE(pCtx, pResultCellInfo);
   if (pResultCellInfo->initialized) {
     return TSDB_CODE_SUCCESS;
   }
@@ -1373,6 +1402,7 @@ int32_t udfAggInit(struct SqlFunctionCtx *pCtx, struct SResultRowEntryInfo *pRes
 }
 
 int32_t udfAggProcess(struct SqlFunctionCtx *pCtx) {
+  TAOS_UDF_CHECK_PTR_RCODE(pCtx);
   int32_t        udfCode = 0;
   UdfcFuncHandle handle = 0;
   if ((udfCode = acquireUdfFuncHandle((char *)pCtx->udfName, &handle)) != 0) {
@@ -1444,6 +1474,7 @@ int32_t udfAggProcess(struct SqlFunctionCtx *pCtx) {
 }
 
 int32_t udfAggFinalize(struct SqlFunctionCtx *pCtx, SSDataBlock *pBlock) {
+  TAOS_UDF_CHECK_PTR_RCODE(pCtx, pBlock);
   int32_t        udfCode = 0;
   UdfcFuncHandle handle = 0;
   if ((udfCode = acquireUdfFuncHandle((char *)pCtx->udfName, &handle)) != 0) {
@@ -1538,7 +1569,7 @@ int32_t udfcGetUdfTaskResultFromUvTask(SClientUdfTask *task, SClientUvTaskNode *
       }
 
       // TODO: the call buffer is setup and freed by udf invocation
-      taosMemoryFree(uvTask->rspBuf.base);
+      taosMemoryFreeClear(uvTask->rspBuf.base);
     } else {
       code = uvTask->errCode;
       if (code != 0) {
@@ -1763,7 +1794,7 @@ int32_t udfcInitializeUvTask(SClientUdfTask *task, int8_t uvTaskType, SClientUvT
   }
   if (uv_sem_init(&uvTask->taskSem, 0) != 0) {
     if (uvTaskType == UV_TASK_REQ_RSP) {
-      taosMemoryFree(uvTask->reqBuf.base);
+      taosMemoryFreeClear(uvTask->reqBuf.base);
     }
     fnError("udfc create uv task, init semaphore failed.");
     return TSDB_CODE_UDF_UV_EXEC_FAILURE;

source/libs/function/src/udfd.c

@@ -55,6 +55,7 @@ int32_t udfdCPluginOpen(SScriptUdfEnvItem *items, int numItems) { return 0; }
 int32_t udfdCPluginClose() { return 0; }
 
 int32_t udfdCPluginUdfInitLoadInitDestoryFuncs(SUdfCPluginCtx *udfCtx, const char *udfName) {
+  TAOS_UDF_CHECK_PTR_RCODE(udfCtx, udfName);
   char  initFuncName[TSDB_FUNC_NAME_LEN + 6] = {0};
   char *initSuffix = "_init";
   snprintf(initFuncName, sizeof(initFuncName), "%s%s", udfName, initSuffix);
@@ -68,6 +69,7 @@ int32_t udfdCPluginUdfInitLoadInitDestoryFuncs(SUdfCPluginCtx *udfCtx, const cha
 }
 
 int32_t udfdCPluginUdfInitLoadAggFuncs(SUdfCPluginCtx *udfCtx, const char *udfName) {
+  TAOS_UDF_CHECK_PTR_RCODE(udfCtx, udfName);
   char processFuncName[TSDB_FUNC_NAME_LEN] = {0};
   snprintf(processFuncName, sizeof(processFuncName), "%s", udfName); 
   TAOS_CHECK_RETURN(uv_dlsym(&udfCtx->lib, processFuncName, (void **)(&udfCtx->aggProcFunc)));
@@ -93,6 +95,7 @@ int32_t udfdCPluginUdfInitLoadAggFuncs(SUdfCPluginCtx *udfCtx, const char *udfNa
 }
 
 int32_t udfdCPluginUdfInit(SScriptUdfInfo *udf, void **pUdfCtx) {
+  TAOS_UDF_CHECK_PTR_RCODE(udf, pUdfCtx);
   int32_t         err = 0;
   SUdfCPluginCtx *udfCtx = taosMemoryCalloc(1, sizeof(SUdfCPluginCtx));
   if (NULL == udfCtx) {
@@ -146,6 +149,7 @@ _exit:
 }
 
 int32_t udfdCPluginUdfDestroy(void *udfCtx) {
+  TAOS_UDF_CHECK_PTR_RCODE(udfCtx);
   SUdfCPluginCtx *ctx = udfCtx;
   int32_t         code = 0;
   if (ctx->destroyFunc) {
@@ -157,6 +161,7 @@ int32_t udfdCPluginUdfDestroy(void *udfCtx) {
 }
 
 int32_t udfdCPluginUdfScalarProc(SUdfDataBlock *block, SUdfColumn *resultCol, void *udfCtx) {
+  TAOS_UDF_CHECK_PTR_RCODE(block, resultCol, udfCtx);
   SUdfCPluginCtx *ctx = udfCtx;
   if (ctx->scalarProcFunc) {
     return ctx->scalarProcFunc(block, resultCol);
@@ -167,6 +172,7 @@ int32_t udfdCPluginUdfScalarProc(SUdfDataBlock *block, SUdfColumn *resultCol, vo
 }
 
 int32_t udfdCPluginUdfAggStart(SUdfInterBuf *buf, void *udfCtx) {
+  TAOS_UDF_CHECK_PTR_RCODE(buf, udfCtx);
   SUdfCPluginCtx *ctx = udfCtx;
   if (ctx->aggStartFunc) {
     return ctx->aggStartFunc(buf);
@@ -178,6 +184,7 @@ int32_t udfdCPluginUdfAggStart(SUdfInterBuf *buf, void *udfCtx) {
 }
 
 int32_t udfdCPluginUdfAggProc(SUdfDataBlock *block, SUdfInterBuf *interBuf, SUdfInterBuf *newInterBuf, void *udfCtx) {
+  TAOS_UDF_CHECK_PTR_RCODE(block, interBuf, newInterBuf, udfCtx);
   SUdfCPluginCtx *ctx = udfCtx;
   if (ctx->aggProcFunc) {
     return ctx->aggProcFunc(block, interBuf, newInterBuf);
@@ -189,6 +196,7 @@ int32_t udfdCPluginUdfAggProc(SUdfDataBlock *block, SUdfInterBuf *interBuf, SUdf
 
 int32_t udfdCPluginUdfAggMerge(SUdfInterBuf *inputBuf1, SUdfInterBuf *inputBuf2, SUdfInterBuf *outputBuf,
                                void *udfCtx) {
+  TAOS_UDF_CHECK_PTR_RCODE(inputBuf1, inputBuf2, outputBuf, udfCtx);
   SUdfCPluginCtx *ctx = udfCtx;
   if (ctx->aggMergeFunc) {
     return ctx->aggMergeFunc(inputBuf1, inputBuf2, outputBuf);
@@ -199,6 +207,7 @@ int32_t udfdCPluginUdfAggMerge(SUdfInterBuf *inputBuf1, SUdfInterBuf *inputBuf2,
 }
 
 int32_t udfdCPluginUdfAggFinish(SUdfInterBuf *buf, SUdfInterBuf *resultData, void *udfCtx) {
+  TAOS_UDF_CHECK_PTR_RCODE(buf, resultData, udfCtx);
   SUdfCPluginCtx *ctx = udfCtx;
   if (ctx->aggFinishFunc) {
     return ctx->aggFinishFunc(buf, resultData);
@@ -360,6 +369,7 @@ int32_t udfdNewUdf(SUdf **pUdf,  const char *udfName);
 void  udfdGetFuncBodyPath(const SUdf *udf, char *path);
 
 int32_t udfdInitializeCPlugin(SUdfScriptPlugin *plugin) {
+  TAOS_UDF_CHECK_PTR_RCODE(plugin);
   plugin->scriptType = TSDB_FUNC_SCRIPT_BIN_LIB;
   plugin->openFunc = udfdCPluginOpen;
   plugin->closeFunc = udfdCPluginClose;
@@ -378,6 +388,7 @@ int32_t udfdInitializeCPlugin(SUdfScriptPlugin *plugin) {
 }
 
 int32_t udfdLoadSharedLib(char *libPath, uv_lib_t *pLib, const char *funcName[], void **func[], int numOfFuncs) {
+  TAOS_UDF_CHECK_PTR_RCODE(libPath, pLib, funcName, func);
   int err = uv_dlopen(libPath, pLib);
   if (err != 0) {
     fnError("can not load library %s. error: %s", libPath, uv_strerror(err));
@@ -394,6 +405,7 @@ int32_t udfdLoadSharedLib(char *libPath, uv_lib_t *pLib, const char *funcName[],
 }
 
 int32_t udfdInitializePythonPlugin(SUdfScriptPlugin *plugin) {
+  TAOS_UDF_CHECK_PTR_RCODE(plugin);
   plugin->scriptType = TSDB_FUNC_SCRIPT_PYTHON;
   // todo: windows support
   snprintf(plugin->libPath, PATH_MAX, "%s", "libtaospyudf.so");
@@ -439,6 +451,7 @@ int32_t udfdInitializePythonPlugin(SUdfScriptPlugin *plugin) {
 }
 
 void udfdDeinitCPlugin(SUdfScriptPlugin *plugin) {
+  TAOS_UDF_CHECK_PTR_RVOID(plugin);
   if (plugin->closeFunc) {
     if (plugin->closeFunc() != 0) {
       fnError("udf script c plugin close func failed.line:%d", __LINE__);
@@ -457,8 +470,9 @@ void udfdDeinitCPlugin(SUdfScriptPlugin *plugin) {
 }
 
 void udfdDeinitPythonPlugin(SUdfScriptPlugin *plugin) {
+  TAOS_UDF_CHECK_PTR_RVOID(plugin);
   if (plugin->closeFunc) {
-    if(plugin->closeFunc() != 0) {
+    if (plugin->closeFunc() != 0) {
       fnError("udf script python plugin close func failed.line:%d", __LINE__);
     }
   }
@@ -517,22 +531,29 @@ void udfdDeinitScriptPlugins() {
   if (plugin != NULL) {
     udfdDeinitPythonPlugin(plugin);
     taosMemoryFree(plugin);
+    global.scriptPlugins[TSDB_FUNC_SCRIPT_PYTHON] = NULL;
   }
 
   plugin = global.scriptPlugins[TSDB_FUNC_SCRIPT_BIN_LIB];
   if (plugin != NULL) {
     udfdDeinitCPlugin(plugin);
     taosMemoryFree(plugin);
+    global.scriptPlugins[TSDB_FUNC_SCRIPT_BIN_LIB] = NULL;
   }
   return;
 }
 
 void udfdProcessRequest(uv_work_t *req) {
+  TAOS_UDF_CHECK_PTR_RVOID(req);
   SUvUdfWork *uvUdf = (SUvUdfWork *)(req->data);
+  if (uvUdf == NULL) {
+    fnError("udf work is NULL");
+    return;
+  }
   SUdfRequest request = {0};
   if(decodeUdfRequest(uvUdf->input.base, &request) == NULL)
   {
-    taosMemoryFree(uvUdf->input.base);
+    taosMemoryFreeClear(uvUdf->input.base);
     fnError("udf request decode failed");
     return;
   }
@@ -557,7 +578,7 @@ void udfdProcessRequest(uv_work_t *req) {
   }
 }
 
-void convertUdf2UdfInfo(SUdf *udf, SScriptUdfInfo *udfInfo) {
+static void convertUdf2UdfInfo(SUdf *udf, SScriptUdfInfo *udfInfo) {
   udfInfo->bufSize = udf->bufSize;
   if (udf->funcType == TSDB_FUNC_TYPE_AGGREGATE) {
     udfInfo->funcType = UDF_FUNC_TYPE_AGG;
@@ -573,7 +594,8 @@ void convertUdf2UdfInfo(SUdf *udf, SScriptUdfInfo *udfInfo) {
   udfInfo->scriptType = udf->scriptType;
 }
 
-int32_t udfdInitUdf(char *udfName, SUdf *udf) {
+static int32_t udfdInitUdf(char *udfName, SUdf *udf) {
+  TAOS_UDF_CHECK_PTR_RCODE(udfName, udf);
   int32_t err = 0;
   err = udfdFillUdfInfoFromMNode(global.clientRpc, udfName, udf);
   if (err != 0) {
@@ -611,6 +633,7 @@ int32_t udfdInitUdf(char *udfName, SUdf *udf) {
 }
 
 int32_t udfdNewUdf(SUdf **pUdf, const char *udfName) {
+  TAOS_UDF_CHECK_PTR_RCODE(pUdf, udfName);
   SUdf *udfNew = taosMemoryCalloc(1, sizeof(SUdf));
   if (NULL == udfNew) {
     return terrno;
@@ -654,6 +677,7 @@ void udfdFreeUdf(void *pData) {
 }
 
 int32_t udfdGetOrCreateUdf(SUdf **ppUdf, const char *udfName) {
+  TAOS_UDF_CHECK_PTR_RCODE(ppUdf, udfName);
   uv_mutex_lock(&global.udfsMutex);
   SUdf  **pUdfHash = taosHashGet(global.udfsHash, udfName, strlen(udfName));
   int64_t currTime = taosGetTimestampMs();
@@ -693,6 +717,7 @@ int32_t udfdGetOrCreateUdf(SUdf **ppUdf, const char *udfName) {
 }
 
 void udfdProcessSetupRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
+  TAOS_UDF_CHECK_PTR_RVOID(uvUdf, request);
   // TODO: tracable id from client. connect, setup, call, teardown
   fnInfo("setup request. seq num: %" PRId64 ", udf name: %s", request->seqNum, request->setup.udfName);
 
@@ -760,11 +785,55 @@ _send:
   
   uvUdf->output = uv_buf_init(bufBegin, len);
 
-  taosMemoryFree(uvUdf->input.base);
+  taosMemoryFreeClear(uvUdf->input.base);
   return;
 }
 
+static int32_t checkUDFScalaResult(SSDataBlock *block, SUdfColumn *output) {
+  if (tsSafetyCheckLevel == TSDB_SAFETY_CHECK_LEVELL_NEVER) {
+    return TSDB_CODE_SUCCESS;
+  }
+  if (output->colData.numOfRows != block->info.rows) {
+    fnError("udf scala result num of rows %d not equal to input rows %" PRId64, output->colData.numOfRows, block->info.rows);
+    return TSDB_CODE_UDF_FUNC_EXEC_FAILURE;
+  }
+
+  if (tsSafetyCheckLevel == TSDB_SAFETY_CHECK_LEVELL_BYROW) {
+    for (int32_t i = 0; i < output->colData.numOfRows; ++i) {
+      if (!udfColDataIsNull(output, i)) {
+        if (IS_VAR_DATA_TYPE(output->colMeta.type)) {
+          TAOS_UDF_CHECK_CONDITION(output->colData.varLenCol.payload != NULL, TSDB_CODE_UDF_FUNC_EXEC_FAILURE);
+          TAOS_UDF_CHECK_CONDITION(output->colData.varLenCol.varOffsets[i] >= 0 &&
+                                       output->colData.varLenCol.varOffsets[i] < output->colData.varLenCol.payloadLen,
+                                   TSDB_CODE_UDF_FUNC_EXEC_FAILURE);
+        } else {
+          TAOS_UDF_CHECK_CONDITION(
+              output->colMeta.bytes * output->colData.numOfRows <= output->colData.fixLenCol.dataLen,
+              TSDB_CODE_UDF_FUNC_EXEC_FAILURE);
+          break;
+        }
+      }
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t checkUDFAggResult(SSDataBlock *block, SUdfInterBuf *output) {
+  if (tsSafetyCheckLevel == TSDB_SAFETY_CHECK_LEVELL_NEVER) {
+    return TSDB_CODE_SUCCESS;
+  }
+  if (output->numOfResult != 1 && output->numOfResult != 0) {
+    fnError("udf agg result num of rows %d not equal to 1", output->numOfResult);
+    return TSDB_CODE_UDF_FUNC_EXEC_FAILURE;
+  }
+  TAOS_UDF_CHECK_CONDITION(output->buf != NULL, TSDB_CODE_UDF_FUNC_EXEC_FAILURE);
+  TAOS_UDF_CHECK_CONDITION(output->bufLen > 0, TSDB_CODE_UDF_FUNC_EXEC_FAILURE);
+  return TSDB_CODE_SUCCESS;
+}
+
 void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
+  TAOS_UDF_CHECK_PTR_RVOID(uvUdf, request);
   SUdfCallRequest *call = &request->call;
   fnDebug("call request. call type %d, handle: %" PRIx64 ", seq num %" PRId64, call->callType, call->udfHandle,
           request->seqNum);
@@ -787,6 +856,7 @@ void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
         code = convertDataBlockToUdfDataBlock(&call->block, &input);
         if (code == TSDB_CODE_SUCCESS) code = udf->scriptPlugin->udfScalarProcFunc(&input, &output, udf->scriptUdfCtx);
         freeUdfDataDataBlock(&input);
+        if (code == TSDB_CODE_SUCCESS) code = checkUDFScalaResult(&call->block, &output);
         if (code == TSDB_CODE_SUCCESS) code = convertUdfColumnToDataBlock(&output, &response.callRsp.resultData);
       }
       freeUdfColumn(&output);
@@ -809,6 +879,7 @@ void udfdProcessCallRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
         if (outBuf.buf != NULL) {
           code = udf->scriptPlugin->udfAggProcFunc(&input, &call->interBuf, &outBuf, udf->scriptUdfCtx);
           freeUdfInterBuf(&call->interBuf);
+          if (code == TSDB_CODE_SUCCESS) code = checkUDFAggResult(&call->block, &outBuf);
           subRsp->resultBuf = outBuf;
         } else {
           code = terrno;
@@ -900,11 +971,12 @@ _exit:
       break;
   }
 
-  taosMemoryFree(uvUdf->input.base);
+  taosMemoryFreeClear(uvUdf->input.base);
   return;
 }
 
 void udfdProcessTeardownRequest(SUvUdfWork *uvUdf, SUdfRequest *request) {
+  TAOS_UDF_CHECK_PTR_RVOID(uvUdf, request);
   SUdfTeardownRequest *teardown = &request->teardown;
   fnInfo("teardown. seq number: %" PRId64 ", handle:%" PRIx64, request->seqNum, teardown->udfHandle);
   SUdfcFuncHandle *handle = (SUdfcFuncHandle *)(teardown->udfHandle);
@@ -964,6 +1036,7 @@ _send:
 }
 
 void udfdGetFuncBodyPath(const SUdf *udf, char *path) {
+  TAOS_UDF_CHECK_PTR_RVOID(udf, path);
   if (udf->scriptType == TSDB_FUNC_SCRIPT_BIN_LIB) {
 #ifdef WINDOWS
     snprintf(path, PATH_MAX, "%s%s_%d_%" PRIx64 ".dll", global.udfDataDir, udf->name, udf->version, udf->createdTime);
@@ -987,6 +1060,7 @@ void udfdGetFuncBodyPath(const SUdf *udf, char *path) {
 }
 
 int32_t udfdSaveFuncBodyToFile(SFuncInfo *pFuncInfo, SUdf *udf) {
+  TAOS_UDF_CHECK_PTR_RCODE(pFuncInfo, udf);
   if (!osDataSpaceAvailable()) {
     terrno = TSDB_CODE_NO_DISKSPACE;
     fnError("udfd create shared library failed since %s", terrstr());
@@ -1022,6 +1096,7 @@ int32_t udfdSaveFuncBodyToFile(SFuncInfo *pFuncInfo, SUdf *udf) {
 }
 
 void udfdProcessRpcRsp(void *parent, SRpcMsg *pMsg, SEpSet *pEpSet) {
+  TAOS_UDF_CHECK_PTR_RVOID(parent, pMsg);
   SUdfdRpcSendRecvInfo *msgInfo = (SUdfdRpcSendRecvInfo *)pMsg->info.ahandle;
 
   if (pEpSet) {
@@ -1093,6 +1168,7 @@ _return:
 }
 
 int32_t udfdFillUdfInfoFromMNode(void *clientRpc, char *udfName, SUdf *udf) {
+  TAOS_UDF_CHECK_PTR_RCODE(clientRpc, udfName, udf);
   SRetrieveFuncReq retrieveReq = {0};
   retrieveReq.numOfFuncs = 1;
   retrieveReq.pFuncNames = taosArrayInit(1, TSDB_FUNC_NAME_LEN);
@@ -1233,6 +1309,7 @@ void udfdCloseClientRpc() {
 }
 
 void udfdOnWrite(uv_write_t *req, int status) {
+  TAOS_UDF_CHECK_PTR_RVOID(req);
   SUvUdfWork *work = (SUvUdfWork *)req->data;
   if (status < 0) {
     fnError("udfd send response error, length: %zu code: %s", work->output.len, uv_err_name(status));
@@ -1254,6 +1331,7 @@ void udfdOnWrite(uv_write_t *req, int status) {
 }
 
 void udfdSendResponse(uv_work_t *work, int status) {
+  TAOS_UDF_CHECK_PTR_RVOID(work);
   SUvUdfWork *udfWork = (SUvUdfWork *)(work->data);
 
   if (udfWork->conn != NULL) {
@@ -1274,6 +1352,7 @@ void udfdSendResponse(uv_work_t *work, int status) {
 }
 
 void udfdAllocBuffer(uv_handle_t *handle, size_t suggestedSize, uv_buf_t *buf) {
+  TAOS_UDF_CHECK_PTR_RVOID(handle, buf);
   SUdfdUvConn *ctx = handle->data;
   int32_t      msgHeadSize = sizeof(int32_t) + sizeof(int64_t);
   if (ctx->inputCap == 0) {
@@ -1307,6 +1386,10 @@ void udfdAllocBuffer(uv_handle_t *handle, size_t suggestedSize, uv_buf_t *buf) {
 }
 
 bool isUdfdUvMsgComplete(SUdfdUvConn *pipe) {
+  if (pipe == NULL) {
+    fnError("udfd pipe is NULL, LINE:%d", __LINE__);
+    return false;
+  }
   if (pipe->inputTotal == -1 && pipe->inputLen >= sizeof(int32_t)) {
     pipe->inputTotal = *(int32_t *)(pipe->inputBuf);
   }
@@ -1318,6 +1401,7 @@ bool isUdfdUvMsgComplete(SUdfdUvConn *pipe) {
 }
 
 void udfdHandleRequest(SUdfdUvConn *conn) {
+  TAOS_UDF_CHECK_PTR_RVOID(conn);
   char   *inputBuf = conn->inputBuf;
   int32_t inputLen = conn->inputLen;
 
@@ -1350,6 +1434,7 @@ void udfdHandleRequest(SUdfdUvConn *conn) {
 }
 
 void udfdPipeCloseCb(uv_handle_t *pipe) {
+  TAOS_UDF_CHECK_PTR_RVOID(pipe);
   SUdfdUvConn *conn = pipe->data;
   SUvUdfWork  *pWork = conn->pWorkList;
   while (pWork != NULL) {
@@ -1363,6 +1448,7 @@ void udfdPipeCloseCb(uv_handle_t *pipe) {
 }
 
 void udfdPipeRead(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
+  TAOS_UDF_CHECK_PTR_RVOID(client, buf);
   fnDebug("udfd read %zd bytes from client", nread);
   if (nread == 0) return;
 
@@ -1389,6 +1475,7 @@ void udfdPipeRead(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
 }
 
 void udfdOnNewConnection(uv_stream_t *server, int status) {
+  TAOS_UDF_CHECK_PTR_RVOID(server);
   if (status < 0) {
     fnError("udfd new connection error. code: %s", uv_strerror(status));
     return;
@@ -1434,6 +1521,7 @@ _exit:
 }
 
 void udfdIntrSignalHandler(uv_signal_t *handle, int signum) {
+  TAOS_UDF_CHECK_PTR_RVOID(handle);
   fnInfo("udfd signal received: %d\n", signum);
   uv_fs_t req;
   int32_t code = uv_fs_unlink(global.loop, &req, global.listenPipeName, NULL);
@@ -1482,6 +1570,7 @@ static int32_t udfdInitLog() {
 }
 
 void udfdCtrlAllocBufCb(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
+  TAOS_UDF_CHECK_PTR_RVOID(buf);
   buf->base = taosMemoryMalloc(suggested_size);
   if (buf->base == NULL) {
     fnError("udfd ctrl pipe alloc buffer failed");
@@ -1491,6 +1580,7 @@ void udfdCtrlAllocBufCb(uv_handle_t *handle, size_t suggested_size, uv_buf_t *bu
 }
 
 void udfdCtrlReadCb(uv_stream_t *q, ssize_t nread, const uv_buf_t *buf) {
+  TAOS_UDF_CHECK_PTR_RVOID(q, buf);
   if (nread < 0) {
     fnError("udfd ctrl pipe read error. %s", uv_err_name(nread));
     taosMemoryFree(buf->base);
@@ -1580,7 +1670,7 @@ static void udfdGlobalDataDeinit() {
   taosHashCleanup(global.udfsHash);
   uv_mutex_destroy(&global.udfsMutex);
   uv_mutex_destroy(&global.scriptPluginsMutex);
-  taosMemoryFree(global.loop);
+  taosMemoryFreeClear(global.loop);
   fnInfo("udfd global data deinit");
 }
 

source/libs/parser/src/parTranslater.c

@@ -3311,11 +3311,11 @@ static int32_t selectCommonType(SDataType* commonType, const SDataType* newType)
   } else {
     resultType = gDisplyTypes[type2][type1];
   }
-  
+
   if (resultType == -1) {
     return TSDB_CODE_SCALAR_CONVERT_ERROR;
   }
-  
+
   if (commonType->type == newType->type) {
     commonType->bytes = TMAX(commonType->bytes, newType->bytes);
     return TSDB_CODE_SUCCESS;
@@ -3328,9 +3328,9 @@ static int32_t selectCommonType(SDataType* commonType, const SDataType* newType)
   } else {
     commonType->bytes = TMAX(TMAX(commonType->bytes, newType->bytes), TYPE_BYTES[resultType]);
   }
-  
+
   commonType->type = resultType;
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -13127,7 +13127,7 @@ static int32_t extractShowCreateViewResultSchema(int32_t* numOfCols, SSchema** p
 }
 
 static int32_t extractShowVariablesResultSchema(int32_t* numOfCols, SSchema** pSchema) {
-  *numOfCols = 3;
+  *numOfCols = SHOW_LOCAL_VARIABLES_RESULT_COLS; // SHOW_VARIABLES_RESULT_COLS
   *pSchema = taosMemoryCalloc((*numOfCols), sizeof(SSchema));
   if (NULL == (*pSchema)) {
     return terrno;
@@ -13138,13 +13138,17 @@ static int32_t extractShowVariablesResultSchema(int32_t* numOfCols, SSchema** pS
   strcpy((*pSchema)[0].name, "name");
 
   (*pSchema)[1].type = TSDB_DATA_TYPE_BINARY;
-  (*pSchema)[1].bytes = TSDB_CONFIG_VALUE_LEN;
+  (*pSchema)[1].bytes = TSDB_CONFIG_PATH_LEN;
   strcpy((*pSchema)[1].name, "value");
 
   (*pSchema)[2].type = TSDB_DATA_TYPE_BINARY;
   (*pSchema)[2].bytes = TSDB_CONFIG_SCOPE_LEN;
   strcpy((*pSchema)[2].name, "scope");
 
+  (*pSchema)[3].type = TSDB_DATA_TYPE_BINARY;
+  (*pSchema)[3].bytes = TSDB_CONFIG_INFO_LEN;
+  strcpy((*pSchema)[3].name, "info");
+
   return TSDB_CODE_SUCCESS;
 }
 

source/libs/planner/src/planOptimizer.c

@@ -3491,37 +3491,77 @@ static void eliminateProjPushdownProjIdx(SNodeList* pParentProjects, SNodeList*
   }
 }
 
+static int32_t eliminateProjOptFindProjPrefixWithOrderCheck(SProjectLogicNode* pProj, SProjectLogicNode* pChild, SNodeList** pNewChildTargets, bool *orderMatch) {
+  int32_t code = 0;
+  SNode* pProjection = NULL, *pChildTarget = NULL;
+  *orderMatch = true;
+  FORBOTH(pProjection, pProj->pProjections, pChildTarget, pChild->node.pTargets) {
+    if (!pProjection) break;
+    if (0 != strcmp(((SColumnNode*)pProjection)->colName, ((SColumnNode*)pChildTarget)->colName)) {
+      *orderMatch = false;
+      break;
+    }
+    if (pNewChildTargets) {
+      SNode* pNew = NULL;
+      code = nodesCloneNode(pChildTarget, &pNew);
+      if (TSDB_CODE_SUCCESS == code) {
+        code = nodesListMakeStrictAppend(pNewChildTargets, pNew);
+      }
+      if (TSDB_CODE_SUCCESS != code && pNewChildTargets) {
+        nodesDestroyList(*pNewChildTargets);
+        *pNewChildTargets = NULL;
+        break;
+      }
+    }
+  }
+  return code;
+}
+
+static int32_t eliminateProjOptPushTargetsToSetOpChildren(SProjectLogicNode* pSetOp) {
+  SNode*  pChildProj = NULL;
+  int32_t code = 0;
+  bool    orderMatch = false;
+  FOREACH(pChildProj, pSetOp->node.pChildren) {
+    if (QUERY_NODE_LOGIC_PLAN_PROJECT == nodeType(pChildProj)) {
+      SProjectLogicNode* pChildLogic = (SProjectLogicNode*)pChildProj;
+      SNodeList* pNewChildTargetsForChild = NULL;
+      code = eliminateProjOptFindProjPrefixWithOrderCheck(pSetOp, pChildLogic, &pNewChildTargetsForChild, &orderMatch);
+      if (TSDB_CODE_SUCCESS != code) break;
+      nodesDestroyList(pChildLogic->node.pTargets);
+      pChildLogic->node.pTargets = pNewChildTargetsForChild;
+      alignProjectionWithTarget((SLogicNode*)pChildLogic);
+      if (pChildLogic->isSetOpProj) {
+        code = eliminateProjOptPushTargetsToSetOpChildren(pChildLogic);
+        if (TSDB_CODE_SUCCESS != code) break;
+      }
+    }
+  }
+  return code;
+}
+
 static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan,
                                          SProjectLogicNode* pProjectNode) {
   SLogicNode* pChild = (SLogicNode*)nodesListGetNode(pProjectNode->node.pChildren, 0);
   int32_t     code = 0;
+  bool        isSetOpProj = false;
+  bool        orderMatch = false;
+  bool        sizeMatch = LIST_LENGTH(pProjectNode->pProjections) == LIST_LENGTH(pChild->pTargets);
+  bool        needReplaceTargets = true;
 
   if (NULL == pProjectNode->node.pParent) {
     SNodeList* pNewChildTargets = NULL;
-    code = nodesMakeList(&pNewChildTargets);
-    if (TSDB_CODE_SUCCESS != code) {
-      return code;
-    }
     SNode *    pProjection = NULL, *pChildTarget = NULL;
-    bool       orderMatch = true;
+    isSetOpProj =
-    bool       needOrderMatch =
         QUERY_NODE_LOGIC_PLAN_PROJECT == nodeType(pChild) && ((SProjectLogicNode*)pChild)->isSetOpProj;
-    if (needOrderMatch) {
+    if (isSetOpProj) {
       // For sql: select ... from (select ... union all select ...);
       // When eliminating the outer proj (the outer select), we have to make sure that the outer proj projections and
       // union all project targets have same columns in the same order. See detail in TD-30188
-      FORBOTH(pProjection, pProjectNode->pProjections, pChildTarget, pChild->pTargets) {
+      code = eliminateProjOptFindProjPrefixWithOrderCheck(pProjectNode, (SProjectLogicNode*)pChild,
-        if (!pProjection) break;
+                                                          sizeMatch ? NULL : &pNewChildTargets, &orderMatch);
-        if (0 != strcmp(((SColumnNode*)pProjection)->colName, ((SColumnNode*)pChildTarget)->colName)) {
+      if (TSDB_CODE_SUCCESS == code && sizeMatch && orderMatch) {
-          orderMatch = false;
+        pNewChildTargets = pChild->pTargets;
-          break;
+        needReplaceTargets = false;
-        }
-        SNode* pNew = NULL;
-        code = nodesCloneNode(pChildTarget, &pNew);
-        if (TSDB_CODE_SUCCESS == code) {
-          code = nodesListStrictAppend(pNewChildTargets, pNew);
-        }
-        if (TSDB_CODE_SUCCESS != code) break;
       }
     } else {
       FOREACH(pProjection, pProjectNode->pProjections) {
@@ -3530,7 +3570,7 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
             SNode* pNew = NULL;
             code = nodesCloneNode(pChildTarget, &pNew);
             if (TSDB_CODE_SUCCESS == code) {
-              code = nodesListStrictAppend(pNewChildTargets, pNew);
+              code = nodesListMakeStrictAppend(&pNewChildTargets, pNew);
             }
             break;
           }
@@ -3545,12 +3585,13 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
       return code;
     }
 
-    if (eliminateProjOptCanChildConditionUseChildTargets(pChild, pNewChildTargets) &&
+    if (eliminateProjOptCanChildConditionUseChildTargets(pChild, pNewChildTargets) && (!isSetOpProj || orderMatch)) {
-        (!needOrderMatch || (needOrderMatch && orderMatch))) {
+      if (needReplaceTargets) {
-      nodesDestroyList(pChild->pTargets);
+        nodesDestroyList(pChild->pTargets);
-      pChild->pTargets = pNewChildTargets;
+        pChild->pTargets = pNewChildTargets;
+      }
     } else {
-      nodesDestroyList(pNewChildTargets);
+      if (needReplaceTargets) nodesDestroyList(pNewChildTargets);
       OPTIMIZE_FLAG_SET_MASK(pProjectNode->node.optimizedFlag, OPTIMIZE_FLAG_ELIMINATE_PROJ);
       pCxt->optimized = true;
       return TSDB_CODE_SUCCESS;
@@ -3573,7 +3614,11 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
     NODES_CLEAR_LIST(pProjectNode->node.pChildren);
     nodesDestroyNode((SNode*)pProjectNode);
     // if pChild is a project logic node, remove its projection which is not reference by its target.
-    alignProjectionWithTarget(pChild);
+    if (needReplaceTargets) {
+      alignProjectionWithTarget(pChild);
+      // Since we have eliminated the outer proj, we need to push down the new targets to the children of the set operation.
+      if (isSetOpProj && orderMatch && !sizeMatch) code = eliminateProjOptPushTargetsToSetOpChildren((SProjectLogicNode*)pChild);
+    }
   }
   pCxt->optimized = true;
   return code;

source/libs/qcom/inc/queryInt.h

@@ -23,7 +23,13 @@ extern "C" {
 #define VALIDNUMOFCOLS(x) ((x) >= TSDB_MIN_COLUMNS && (x) <= TSDB_MAX_COLUMNS)
 #define VALIDNUMOFTAGS(x) ((x) >= 0 && (x) <= TSDB_MAX_TAGS)
 
-
+#define QUERY_PARAM_CHECK(_p)                                                \
+  do {                                                                       \
+    if ((_p) == NULL) {                                                      \
+      qError("function:%s, param invalid, line:%d", __FUNCTION__, __LINE__); \
+      return TSDB_CODE_TSC_INVALID_INPUT;                                    \
+    }                                                                        \
+  } while (0)
 
 #ifdef __cplusplus
 }

source/libs/qcom/src/queryUtil.c

@@ -59,6 +59,9 @@ const SSchema* tGetTbnameColumnSchema() {
 }
 
 static bool doValidateSchema(SSchema* pSchema, int32_t numOfCols, int32_t maxLen) {
+  if (!pSchema) {
+    return false;
+  }
   int32_t rowLen = 0;
 
   for (int32_t i = 0; i < numOfCols; ++i) {
@@ -100,7 +103,7 @@ static bool doValidateSchema(SSchema* pSchema, int32_t numOfCols, int32_t maxLen
 }
 
 bool tIsValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTags) {
-  if (!VALIDNUMOFCOLS(numOfCols)) {
+  if (!pSchema || !VALIDNUMOFCOLS(numOfCols)) {
     return false;
   }
 
@@ -127,6 +130,7 @@ bool tIsValidSchema(struct SSchema* pSchema, int32_t numOfCols, int32_t numOfTag
 static STaskQueue taskQueue = {0};
 
 static void processTaskQueue(SQueueInfo *pInfo, SSchedMsg *pSchedMsg) {
+  if(!pSchedMsg || !pSchedMsg->ahandle) return;
   __async_exec_fn_t execFn = (__async_exec_fn_t)pSchedMsg->ahandle;
   (void)execFn(pSchedMsg->thandle);
   taosFreeQitem(pSchedMsg);
@@ -205,7 +209,11 @@ void destroyAhandle(void *ahandle) {
 }
 
 int32_t asyncSendMsgToServerExt(void* pTransporter, SEpSet* epSet, int64_t* pTransporterId, SMsgSendInfo* pInfo,
-                                bool persistHandle, void* rpcCtx) {
+                                bool persistHandle, void* rpcCtx) {                         
+  QUERY_PARAM_CHECK(pTransporter);
+  QUERY_PARAM_CHECK(epSet);
+  QUERY_PARAM_CHECK(pInfo);
+
   char* pMsg = rpcMallocCont(pInfo->msgInfo.len);
   if (NULL == pMsg) {
     qError("0x%" PRIx64 " msg:%s malloc failed", pInfo->requestId, TMSG_INFO(pInfo->msgType));
@@ -236,6 +244,7 @@ int32_t asyncSendMsgToServer(void* pTransporter, SEpSet* epSet, int64_t* pTransp
   return asyncSendMsgToServerExt(pTransporter, epSet, pTransporterId, pInfo, false, NULL);
 }
 int32_t asyncFreeConnById(void* pTransporter, int64_t pid) {
+  QUERY_PARAM_CHECK(pTransporter);
   return rpcFreeConnById(pTransporter, pid);
 }
 
@@ -314,6 +323,8 @@ void destroyQueryExecRes(SExecResult* pRes) {
 }
 // clang-format on
 int32_t dataConverToStr(char* str, int64_t capacity, int type, void* buf, int32_t bufSize, int32_t* len) {
+  QUERY_PARAM_CHECK(str);
+  QUERY_PARAM_CHECK(buf);
   int32_t n = 0;
 
   switch (type) {
@@ -420,6 +431,10 @@ int32_t dataConverToStr(char* str, int64_t capacity, int type, void* buf, int32_
 }
 
 void parseTagDatatoJson(void* p, char** jsonStr) {
+  if (!p || !jsonStr) {
+    qError("parseTagDatatoJson invalid input, line:%d", __LINE__);
+    return;
+  }
   char*   string = NULL;
   SArray* pTagVals = NULL;
   cJSON*  json = NULL;
@@ -520,6 +535,7 @@ end:
 }
 
 int32_t cloneTableMeta(STableMeta* pSrc, STableMeta** pDst) {
+  QUERY_PARAM_CHECK(pDst);
   if (NULL == pSrc) {
     *pDst = NULL;
     return TSDB_CODE_SUCCESS;
@@ -553,6 +569,7 @@ int32_t cloneTableMeta(STableMeta* pSrc, STableMeta** pDst) {
 }
 
 void getColumnTypeFromMeta(STableMeta* pMeta, char* pName, ETableColumnType* pType) {
+  if(!pMeta || !pName || !pType) return;
   int32_t nums = pMeta->tableInfo.numOfTags + pMeta->tableInfo.numOfColumns;
   for (int32_t i = 0; i < nums; ++i) {
     if (0 == strcmp(pName, pMeta->schema[i].name)) {
@@ -576,6 +593,7 @@ void freeVgInfo(SDBVgInfo* vgInfo) {
 }
 
 int32_t cloneDbVgInfo(SDBVgInfo* pSrc, SDBVgInfo** pDst) {
+  QUERY_PARAM_CHECK(pDst);
   if (NULL == pSrc) {
     *pDst = NULL;
     return TSDB_CODE_SUCCESS;
@@ -617,6 +635,7 @@ int32_t cloneDbVgInfo(SDBVgInfo* pSrc, SDBVgInfo** pDst) {
 }
 
 int32_t cloneSVreateTbReq(SVCreateTbReq* pSrc, SVCreateTbReq** pDst) {
+  QUERY_PARAM_CHECK(pDst);
   if (NULL == pSrc) {
     *pDst = NULL;
     return TSDB_CODE_SUCCESS;
@@ -674,6 +693,7 @@ int32_t cloneSVreateTbReq(SVCreateTbReq* pSrc, SVCreateTbReq** pDst) {
 _exit:
   tdDestroySVCreateTbReq(*pDst);
   taosMemoryFree(*pDst);
+  *pDst = NULL;
   return terrno;
 }
 

source/libs/qcom/src/querymsg.c

@@ -29,6 +29,8 @@ int32_t (*queryBuildMsg[TDMT_MAX])(void *input, char **msg, int32_t msgSize, int
 int32_t (*queryProcessMsgRsp[TDMT_MAX])(void *output, char *msg, int32_t msgSize) = {0};
 
 int32_t queryBuildUseDbOutput(SUseDbOutput *pOut, SUseDbRsp *usedbRsp) {
+  QUERY_PARAM_CHECK(pOut);
+  QUERY_PARAM_CHECK(usedbRsp);
   memcpy(pOut->db, usedbRsp->db, TSDB_DB_FNAME_LEN);
   pOut->dbId = usedbRsp->uid;
 
@@ -71,10 +73,10 @@ int32_t queryBuildUseDbOutput(SUseDbOutput *pOut, SUseDbRsp *usedbRsp) {
 
 int32_t queryBuildTableMetaReqMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen,
                                   void *(*mallcFp)(int64_t)) {
+  QUERY_PARAM_CHECK(input);
+  QUERY_PARAM_CHECK(msg);
+  QUERY_PARAM_CHECK(msgLen);
   SBuildTableInput *pInput = input;
-  if (NULL == input || NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
-  }
 
   STableInfoReq infoReq = {0};
   infoReq.option = pInput->option;
@@ -101,10 +103,10 @@ int32_t queryBuildTableMetaReqMsg(void *input, char **msg, int32_t msgSize, int3
 }
 
 int32_t queryBuildUseDbMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
+  QUERY_PARAM_CHECK(input);
+  QUERY_PARAM_CHECK(msg);
+  QUERY_PARAM_CHECK(msgLen);
   SBuildUseDBInput *pInput = input;
-  if (NULL == pInput || NULL == msg || NULL == msgLen) {
-    return TSDB_CODE_TSC_INVALID_INPUT;
-  }
 
   SUseDbReq usedbReq = {0};
   tstrncpy(usedbReq.db, pInput->db, TSDB_DB_FNAME_LEN);
@@ -131,9 +133,8 @@ int32_t queryBuildUseDbMsg(void *input, char **msg, int32_t msgSize, int32_t *ms
 }
 
 int32_t queryBuildQnodeListMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(msg);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msgLen);
-  }
 
   SQnodeListReq qnodeListReq = {0};
   qnodeListReq.rowNum = -1;
@@ -155,9 +156,8 @@ int32_t queryBuildQnodeListMsg(void *input, char **msg, int32_t msgSize, int32_t
 }
 
 int32_t queryBuildDnodeListMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(msg);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msgLen);
-  }
 
   SDnodeListReq dnodeListReq = {0};
   dnodeListReq.rowNum = -1;
@@ -179,9 +179,8 @@ int32_t queryBuildDnodeListMsg(void *input, char **msg, int32_t msgSize, int32_t
 }
 
 int32_t queryBuildGetSerVerMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(msg);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msgLen);
-  }
 
   SServerVerReq req = {0};
 
@@ -202,9 +201,9 @@ int32_t queryBuildGetSerVerMsg(void *input, char **msg, int32_t msgSize, int32_t
 }
 
 int32_t queryBuildGetDBCfgMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(input);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msg);
-  }
+  QUERY_PARAM_CHECK(msgLen);
 
   SDbCfgReq dbCfgReq = {0};
   tstrncpy(dbCfgReq.db, input, TSDB_DB_FNAME_LEN);
@@ -226,9 +225,9 @@ int32_t queryBuildGetDBCfgMsg(void *input, char **msg, int32_t msgSize, int32_t
 }
 
 int32_t queryBuildGetIndexMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(input);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msg);
-  }
+  QUERY_PARAM_CHECK(msgLen);
 
   SUserIndexReq indexReq = {0};
   tstrncpy(indexReq.indexFName, input, TSDB_INDEX_FNAME_LEN);
@@ -251,9 +250,9 @@ int32_t queryBuildGetIndexMsg(void *input, char **msg, int32_t msgSize, int32_t
 
 int32_t queryBuildRetrieveFuncMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen,
                                   void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(input);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msg);
-  }
+  QUERY_PARAM_CHECK(msgLen);
 
   SRetrieveFuncReq funcReq = {0};
   funcReq.numOfFuncs = 1;
@@ -288,9 +287,9 @@ int32_t queryBuildRetrieveFuncMsg(void *input, char **msg, int32_t msgSize, int3
 }
 
 int32_t queryBuildGetUserAuthMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(input);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msg);
-  }
+  QUERY_PARAM_CHECK(msgLen);
 
   SGetUserAuthReq req = {0};
   tstrncpy(req.user, input, TSDB_USER_LEN);
@@ -311,9 +310,9 @@ int32_t queryBuildGetUserAuthMsg(void *input, char **msg, int32_t msgSize, int32
 }
 
 int32_t queryBuildGetTbIndexMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(input);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msg);
-  }
+  QUERY_PARAM_CHECK(msgLen);
 
   STableIndexReq indexReq = {0};
   tstrncpy(indexReq.tbFName, input, TSDB_TABLE_FNAME_LEN);
@@ -335,9 +334,9 @@ int32_t queryBuildGetTbIndexMsg(void *input, char **msg, int32_t msgSize, int32_
 }
 
 int32_t queryBuildGetTbCfgMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(input);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msg);
-  }
+  QUERY_PARAM_CHECK(msgLen);
 
   SBuildTableInput *pInput = input;
   STableCfgReq      cfgReq = {0};
@@ -362,9 +361,9 @@ int32_t queryBuildGetTbCfgMsg(void *input, char **msg, int32_t msgSize, int32_t
 }
 
 int32_t queryBuildGetViewMetaMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen, void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(input);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msg);
-  }
+  QUERY_PARAM_CHECK(msgLen);
 
   SViewMetaReq req = {0};
   tstrncpy(req.fullname, input, TSDB_VIEW_FNAME_LEN);
@@ -387,9 +386,9 @@ int32_t queryBuildGetViewMetaMsg(void *input, char **msg, int32_t msgSize, int32
 
 int32_t queryBuildGetTableTSMAMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen,
                                   void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(input);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msg);
-  }
+  QUERY_PARAM_CHECK(msgLen);
 
   STableTSMAInfoReq req = {0};
   tstrncpy(req.name, input, TSDB_TABLE_FNAME_LEN);
@@ -411,9 +410,9 @@ int32_t queryBuildGetTableTSMAMsg(void *input, char **msg, int32_t msgSize, int3
 
 int32_t queryBuildGetTSMAMsg(void *input, char **msg, int32_t msgSize, int32_t *msgLen,
                                   void *(*mallcFp)(int64_t)) {
-  if (NULL == msg || NULL == msgLen) {
+  QUERY_PARAM_CHECK(input);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msg);
-  }
+  QUERY_PARAM_CHECK(msgLen);
 
   STableTSMAInfoReq req = {0};
   req.fetchingWithTsmaName = true;
@@ -436,9 +435,9 @@ int32_t queryBuildGetTSMAMsg(void *input, char **msg, int32_t msgSize, int32_t *
 }
 
 int32_t queryBuildGetStreamProgressMsg(void* input, char** msg, int32_t msgSize, int32_t *msgLen, void*(*mallcFp)(int64_t)) {
-  if (!msg || !msgLen) {
+  QUERY_PARAM_CHECK(input);
-    return TSDB_CODE_TSC_INVALID_INPUT;
+  QUERY_PARAM_CHECK(msg);
-  }
+  QUERY_PARAM_CHECK(msgLen);
 
   int32_t len = tSerializeStreamProgressReq(NULL, 0, input);
   void* pBuf = (*mallcFp)(len);
@@ -504,6 +503,7 @@ PROCESS_USEDB_OVER:
 }
 
 static int32_t queryConvertTableMetaMsg(STableMetaRsp *pMetaMsg) {
+  QUERY_PARAM_CHECK(pMetaMsg);
   if (pMetaMsg->numOfTags < 0 || pMetaMsg->numOfTags > TSDB_MAX_TAGS) {
     qError("invalid numOfTags[%d] in table meta rsp msg", pMetaMsg->numOfTags);
     return TSDB_CODE_TSC_INVALID_VALUE;
@@ -539,6 +539,8 @@ static int32_t queryConvertTableMetaMsg(STableMetaRsp *pMetaMsg) {
 }
 
 int32_t queryCreateCTableMetaFromMsg(STableMetaRsp *msg, SCTableMeta *pMeta) {
+  QUERY_PARAM_CHECK(msg);
+  QUERY_PARAM_CHECK(pMeta);
   pMeta->vgId = msg->vgId;
   pMeta->tableType = msg->tableType;
   pMeta->uid = msg->tuid;
@@ -551,6 +553,8 @@ int32_t queryCreateCTableMetaFromMsg(STableMetaRsp *msg, SCTableMeta *pMeta) {
 }
 
 int32_t queryCreateTableMetaFromMsg(STableMetaRsp *msg, bool isStb, STableMeta **pMeta) {
+  QUERY_PARAM_CHECK(msg);
+  QUERY_PARAM_CHECK(pMeta);
   int32_t total = msg->numOfColumns + msg->numOfTags;
   int32_t metaSize = sizeof(STableMeta) + sizeof(SSchema) * total;
   int32_t schemaExtSize = (useCompress(msg->tableType) && msg->pSchemaExt) ? sizeof(SSchemaExt) * msg->numOfColumns : 0;
@@ -605,6 +609,8 @@ int32_t queryCreateTableMetaFromMsg(STableMetaRsp *msg, bool isStb, STableMeta *
 }
 
 int32_t queryCreateTableMetaExFromMsg(STableMetaRsp *msg, bool isStb, STableMeta **pMeta) {
+  QUERY_PARAM_CHECK(msg);
+  QUERY_PARAM_CHECK(pMeta);
   int32_t total = msg->numOfColumns + msg->numOfTags;
   int32_t metaSize = sizeof(STableMeta) + sizeof(SSchema) * total;
   int32_t schemaExtSize = (useCompress(msg->tableType) && msg->pSchemaExt) ? sizeof(SSchemaExt) * msg->numOfColumns : 0;

source/libs/sync/inc/syncSnapshot.h

@@ -91,6 +91,7 @@ typedef struct SSyncSnapshotReceiver {
 
   // update when begin
   void          *pWriter;
+  TdThreadMutex  writerMutex;
   SSnapshotParam snapshotParam;
   SSnapshot      snapshot;
 

source/libs/sync/src/syncSnapshot.c

@@ -429,6 +429,12 @@ int32_t snapshotReceiverCreate(SSyncNode *pSyncNode, SRaftId fromId, SSyncSnapsh
   pReceiver->startTime = 0;
   pReceiver->ack = SYNC_SNAPSHOT_SEQ_BEGIN;
   pReceiver->pWriter = NULL;
+  code = taosThreadMutexInit(&pReceiver->writerMutex, NULL);
+  if (code != 0) {
+    taosMemoryFree(pReceiver);
+    pReceiver = NULL;
+    TAOS_RETURN(code);
+  }
   pReceiver->pSyncNode = pSyncNode;
   pReceiver->fromId = fromId;
   pReceiver->term = raftStoreGetTerm(pSyncNode);
@@ -440,6 +446,10 @@ int32_t snapshotReceiverCreate(SSyncNode *pSyncNode, SRaftId fromId, SSyncSnapsh
   SSyncSnapBuffer *pRcvBuf = NULL;
   code = syncSnapBufferCreate(&pRcvBuf);
   if (pRcvBuf == NULL) {
+    int32_t ret = taosThreadMutexDestroy(&pReceiver->writerMutex);
+    if (ret != 0) {
+      sError("failed to destroy mutex since %s", tstrerror(ret));
+    }
     taosMemoryFree(pReceiver);
     pReceiver = NULL;
     TAOS_RETURN(code);
@@ -468,6 +478,7 @@ static int32_t snapshotReceiverClearInfoData(SSyncSnapshotReceiver *pReceiver) {
 void snapshotReceiverDestroy(SSyncSnapshotReceiver *pReceiver) {
   if (pReceiver == NULL) return;
 
+  (void)taosThreadMutexLock(&pReceiver->writerMutex);
   // close writer
   if (pReceiver->pWriter != NULL) {
     int32_t code = pReceiver->pSyncNode->pFsm->FpSnapshotStopWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter,
@@ -478,6 +489,9 @@ void snapshotReceiverDestroy(SSyncSnapshotReceiver *pReceiver) {
     }
     pReceiver->pWriter = NULL;
   }
+  (void)taosThreadMutexUnlock(&pReceiver->writerMutex);
+
+  (void)taosThreadMutexDestroy(&pReceiver->writerMutex);
 
   // free snap buf
   if (pReceiver->pRcvBuf) {
@@ -556,7 +570,8 @@ void snapshotReceiverStop(SSyncSnapshotReceiver *pReceiver) {
 
   int8_t stopped = !atomic_val_compare_exchange_8(&pReceiver->start, true, false);
   if (stopped) return;
-  (void)taosThreadMutexLock(&pReceiver->pRcvBuf->mutex);
+
+  (void)taosThreadMutexLock(&pReceiver->writerMutex);
   {
     if (pReceiver->pWriter != NULL) {
       int32_t code = pReceiver->pSyncNode->pFsm->FpSnapshotStopWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter,
@@ -568,7 +583,11 @@ void snapshotReceiverStop(SSyncSnapshotReceiver *pReceiver) {
     } else {
       sRInfo(pReceiver, "snapshot receiver stop, writer is null");
     }
+  }
+  (void)taosThreadMutexUnlock(&pReceiver->writerMutex);
 
+  (void)taosThreadMutexLock(&pReceiver->pRcvBuf->mutex);
+  {
     syncSnapBufferReset(pReceiver->pRcvBuf);
 
     (void)snapshotReceiverClearInfoData(pReceiver);
@@ -600,15 +619,19 @@ static int32_t snapshotReceiverFinish(SSyncSnapshotReceiver *pReceiver, SyncSnap
       raftStoreSetTerm(pReceiver->pSyncNode, pReceiver->snapshot.lastApplyTerm);
     }
 
-    // stop writer, apply data
+    (void)taosThreadMutexLock(&pReceiver->writerMutex);
-    code = pReceiver->pSyncNode->pFsm->FpSnapshotStopWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter, true,
+    if (pReceiver->pWriter != NULL) {
-                                                           &pReceiver->snapshot);
+      // stop writer, apply data
-    if (code != 0) {
+      code = pReceiver->pSyncNode->pFsm->FpSnapshotStopWrite(pReceiver->pSyncNode->pFsm, pReceiver->pWriter, true,
-      sRError(pReceiver, "snapshot receiver apply failed since %s", tstrerror(code));
+                                                             &pReceiver->snapshot);
-      TAOS_RETURN(code);
+      if (code != 0) {
+        sRError(pReceiver, "snapshot receiver apply failed since %s", tstrerror(code));
+        TAOS_RETURN(code);
+      }
+      pReceiver->pWriter = NULL;
+      sRInfo(pReceiver, "snapshot receiver write stopped");
     }
-    pReceiver->pWriter = NULL;
+    (void)taosThreadMutexUnlock(&pReceiver->writerMutex);
-    sRInfo(pReceiver, "snapshot receiver write stopped");
 
     // update progress
     pReceiver->ack = SYNC_SNAPSHOT_SEQ_END;

source/libs/wal/src/walMeta.c

@@ -424,9 +424,6 @@ static void printFileSet(int32_t vgId, SArray* fileSet, const char* str) {
 
 int32_t walCheckAndRepairMeta(SWal* pWal) {
   // load log files, get first/snapshot/last version info
-  if (pWal->cfg.level == TAOS_WAL_SKIP) {
-    return TSDB_CODE_SUCCESS;
-  }
   int32_t     code = 0;
   const char* logPattern = "^[0-9]+.log$";
   const char* idxPattern = "^[0-9]+.idx$";

source/libs/wal/src/walMgmt.c

@@ -90,6 +90,45 @@ static int32_t walInitLock(SWal *pWal) {
   return 0;
 }
 
+int32_t walInitWriteFileForSkip(SWal *pWal) {
+  TdFilePtr pIdxTFile = NULL, pLogTFile = NULL;
+  int64_t   fileFirstVer = 0;
+  int32_t   code = 0;
+
+  char fnameStr[WAL_FILE_LEN];
+  walBuildIdxName(pWal, fileFirstVer, fnameStr);
+  pIdxTFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
+  if (pIdxTFile == NULL) {
+    wError("vgId:%d, failed to open file since %s", pWal->cfg.vgId, tstrerror(terrno));
+    code = terrno;
+    goto _exit;
+  }
+  walBuildLogName(pWal, fileFirstVer, fnameStr);
+  pLogTFile = taosOpenFile(fnameStr, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_APPEND);
+  if (pLogTFile == NULL) {
+    wError("vgId:%d, failed to open file since %s", pWal->cfg.vgId, tstrerror(terrno));
+    code = terrno;
+    goto _exit;
+  }
+  // switch file
+  pWal->pIdxFile = pIdxTFile;
+  pWal->pLogFile = pLogTFile;
+  SWalFileInfo fileInfo;
+  (void)memset(&fileInfo, -1, sizeof(SWalFileInfo));
+  if (!taosArrayPush(pWal->fileInfoSet, &fileInfo)) {
+    wError("vgId:%d, failed to push fileInfo into array since %s", pWal->cfg.vgId, tstrerror(terrno));
+    code = terrno;
+    goto _exit;
+  }
+  pWal->writeCur = 0;
+_exit:
+  if (code != TSDB_CODE_SUCCESS) {
+    (void)taosCloseFile(&pIdxTFile);
+    (void)taosCloseFile(&pLogTFile);
+  }
+  TAOS_RETURN(code);
+}
+
 SWal *walOpen(const char *path, SWalCfg *pCfg) {
   int32_t code = 0;
   SWal   *pWal = taosMemoryCalloc(1, sizeof(SWal));
@@ -165,17 +204,25 @@ SWal *walOpen(const char *path, SWalCfg *pCfg) {
   if (code < 0) {
     wWarn("vgId:%d, failed to load meta since %s", pWal->cfg.vgId, tstrerror(code));
   }
+  if (pWal->cfg.level != TAOS_WAL_SKIP) {
+    code = walCheckAndRepairMeta(pWal);
+    if (code < 0) {
+      wError("vgId:%d, cannot open wal since repair meta file failed since %s", pWal->cfg.vgId, tstrerror(code));
+      goto _err;
+    }
 
-  code = walCheckAndRepairMeta(pWal);
+    code = walCheckAndRepairIdx(pWal);
-  if (code < 0) {
+    if (code < 0) {
-    wError("vgId:%d, cannot open wal since repair meta file failed since %s", pWal->cfg.vgId, tstrerror(code));
+      wError("vgId:%d, cannot open wal since repair idx file failed since %s", pWal->cfg.vgId, tstrerror(code));
-    goto _err;
+      goto _err;
-  }
+    }
-
+  } else {
-  code = walCheckAndRepairIdx(pWal);
+    code = walInitWriteFileForSkip(pWal);
-  if (code < 0) {
+    if (code < 0) {
-    wError("vgId:%d, cannot open wal since repair idx file failed since %s", pWal->cfg.vgId, tstrerror(code));
+      wError("vgId:%d, cannot open wal since init write file for wal_level = 0 failed since %s", pWal->cfg.vgId,
-    goto _err;
+             tstrerror(code));
+      goto _err;
+    }
   }
 
   // add ref
@@ -217,6 +264,14 @@ int32_t walAlter(SWal *pWal, SWalCfg *pCfg) {
         pWal->cfg.vgId, pWal->cfg.level, pWal->cfg.fsyncPeriod, pWal->cfg.retentionPeriod, pWal->cfg.retentionSize,
         pCfg->level, pCfg->fsyncPeriod, pCfg->retentionPeriod, pCfg->retentionSize);
 
+  if (pWal->cfg.level == TAOS_WAL_SKIP && pCfg->level != TAOS_WAL_SKIP) {
+    wInfo("vgId:%d, remove all wals, path:%s", pWal->cfg.vgId, pWal->path);
+    taosRemoveDir(pWal->path);
+    if (taosMkDir(pWal->path) != 0) {
+      wError("vgId:%d, path:%s, failed to create directory since %s", pWal->cfg.vgId, pWal->path, tstrerror(terrno));
+    }
+  }
+
   pWal->cfg.level = pCfg->level;
   pWal->cfg.fsyncPeriod = pCfg->fsyncPeriod;
   pWal->cfg.retentionPeriod = pCfg->retentionPeriod;

source/os/src/osDir.c

@@ -116,7 +116,10 @@ void taosRemoveDir(const char *dirname) {
   return;
 }
 
-bool taosDirExist(const char *dirname) { return taosCheckExistFile(dirname); }
+bool taosDirExist(const char *dirname) {
+  if (dirname == NULL || strlen(dirname) >= TDDIRMAXLEN) return false;
+  return taosCheckExistFile(dirname);
+}
 
 int32_t taosMkDir(const char *dirname) {
   if (taosDirExist(dirname)) return 0;
@@ -333,6 +336,8 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) {
 }
 
 int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen) {
+  OS_PARAM_CHECK(dirname);
+  OS_PARAM_CHECK(outname);
   wordexp_t full_path;
   int32_t code = wordexp(dirname, &full_path, 0);
   switch (code) {
@@ -355,6 +360,8 @@ 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);
+  OS_PARAM_CHECK(realPath);
   char tmp[PATH_MAX] = {0};
 #ifdef WINDOWS
   if (_fullpath(tmp, dirname, maxlen) != NULL) {
@@ -386,6 +393,10 @@ bool taosIsDir(const char *dirname) {
 }
 
 char *taosDirName(char *name) {
+  if(name == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
 #ifdef WINDOWS
   char Drive1[MAX_PATH], Dir1[MAX_PATH];
   _splitpath(name, Drive1, Dir1, NULL, NULL);
@@ -412,12 +423,16 @@ char *taosDirName(char *name) {
 }
 
 char *taosDirEntryBaseName(char *name) {
+  if(name == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
 #ifdef WINDOWS
   char Filename1[MAX_PATH], Ext1[MAX_PATH];
   _splitpath(name, NULL, NULL, Filename1, Ext1);
   return name + (strlen(name) - strlen(Filename1) - strlen(Ext1));
 #else
-  if (name == NULL || (name[0] == '/' && name[1] == '\0')) return name;
+  if ((name[0] == '/' && name[1] == '\0')) return name;
   char *pPoint = strrchr(name, '/');
   if (pPoint != NULL) {
     if (*(pPoint + 1) == '\0') {
@@ -515,9 +530,9 @@ bool taosDirEntryIsDir(TdDirEntryPtr pDirEntry) {
 }
 
 char *taosGetDirEntryName(TdDirEntryPtr pDirEntry) {
-  /*if (pDirEntry == NULL) {*/
+  if (pDirEntry == NULL) {
-  /*return NULL;*/
+    return NULL;
-  /*}*/
+  }
 #ifdef WINDOWS
   return pDirEntry->findFileData.cFileName;
 #else

source/os/src/osEnv.c

@@ -127,8 +127,13 @@ bool osTempSpaceSufficient() { return tsTempSpace.size.avail > tsTempSpace.reser
 int32_t osSetTimezone(const char *tz) { return taosSetSystemTimezone(tz, tsTimezoneStr, &tsDaylight, &tsTimezone); }
 
 void osSetSystemLocale(const char *inLocale, const char *inCharSet) {
-  (void)memcpy(tsLocale, inLocale, strlen(inLocale) + 1);
+  if (inLocale) (void)memcpy(tsLocale, inLocale, strlen(inLocale) + 1);
-  (void)memcpy(tsCharset, inCharSet, strlen(inCharSet) + 1);
+  if (inCharSet) (void)memcpy(tsCharset, inCharSet, strlen(inCharSet) + 1);
 }
 
-void osSetProcPath(int32_t argc, char **argv) { tsProcPath = argv[0]; }
+void osSetProcPath(int32_t argc, char **argv) {
+  if (argv == NULL || argc < 1) {
+    return;  // no command line arguments
+  }
+  tsProcPath = argv[0];
+}

source/os/src/osFile.c

@@ -80,6 +80,7 @@ typedef struct TdFile {
 #endif
 
 void taosGetTmpfilePath(const char *inputTmpDir, const char *fileNamePrefix, char *dstPath) {
+  if (inputTmpDir == NULL || fileNamePrefix == NULL) return;
 #ifdef WINDOWS
 
   char tmpPath[PATH_MAX];
@@ -120,6 +121,10 @@ void taosGetTmpfilePath(const char *inputTmpDir, const char *fileNamePrefix, cha
 }
 
 int64_t taosCopyFile(const char *from, const char *to) {
+  if (from == NULL || to == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return -1;
+  }
 #ifdef WINDOWS
   if (CopyFile(from, to, 0)) {
     return 1;
@@ -133,15 +138,15 @@ int64_t taosCopyFile(const char *from, const char *to) {
   int64_t bytes;
   int32_t code = TSDB_CODE_SUCCESS;
 
-  // fidfrom = open(from, O_RDONLY);
+  TdFilePtr pFileFrom = NULL;
-  TdFilePtr pFileFrom = taosOpenFile(from, TD_FILE_READ);
+  TdFilePtr pFileTo = NULL;
+  pFileFrom = taosOpenFile(from, TD_FILE_READ);
   if (pFileFrom == NULL) {
     code = terrno;
     goto _err;
   }
 
-  // fidto = open(to, O_WRONLY | O_CREAT | O_EXCL, 0755);
+  pFileTo = taosOpenFile(to, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_EXCL);
-  TdFilePtr pFileTo = taosOpenFile(to, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_EXCL);
   if (pFileTo == NULL) {
     code = terrno;
     goto _err;
@@ -193,6 +198,10 @@ _err:
 }
 
 TdFilePtr taosCreateFile(const char *path, int32_t tdFileOptions) {
+  if(path == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
   TdFilePtr fp = taosOpenFile(path, tdFileOptions);
   if (!fp) {
     if (terrno == TAOS_SYSTEM_ERROR(ENOENT)) {
@@ -213,6 +222,7 @@ TdFilePtr taosCreateFile(const char *path, int32_t tdFileOptions) {
 }
 
 int32_t taosRemoveFile(const char *path) {
+  OS_PARAM_CHECK(path);
   int32_t code = remove(path);
   if (-1 == code) {
     terrno = TAOS_SYSTEM_ERROR(errno);
@@ -222,6 +232,8 @@ int32_t taosRemoveFile(const char *path) {
 }
 
 int32_t taosRenameFile(const char *oldName, const char *newName) {
+  OS_PARAM_CHECK(oldName);
+  OS_PARAM_CHECK(newName);
 #ifdef WINDOWS
   bool finished = false;
 
@@ -262,6 +274,7 @@ int32_t taosRenameFile(const char *oldName, const char *newName) {
 }
 
 int32_t taosStatFile(const char *path, int64_t *size, int32_t *mtime, int32_t *atime) {
+  OS_PARAM_CHECK(path);
 #ifdef WINDOWS
   struct _stati64 fileStat;
   int32_t         code = _stati64(path, &fileStat);
@@ -335,6 +348,10 @@ int32_t taosDevInoFile(TdFilePtr pFile, int64_t *stDev, int64_t *stIno) {
 }
 
 FILE *taosOpenFileForStream(const char *path, int32_t tdFileOptions) {
+  if (path == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
   char *mode = NULL;
   if (tdFileOptions & TD_FILE_APPEND) {
     mode = (tdFileOptions & TD_FILE_TEXT) ? "at+" : "ab+";
@@ -358,6 +375,10 @@ FILE *taosOpenFileForStream(const char *path, int32_t tdFileOptions) {
 
 #ifdef WINDOWS
 HANDLE taosOpenFileNotStream(const char *path, int32_t tdFileOptions) {
+  if (path == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return INVALID_HANDLE_VALUE;
+  }
   DWORD openMode = 0;
   DWORD access = 0;
   DWORD fileFlag = FILE_ATTRIBUTE_NORMAL;
@@ -408,6 +429,10 @@ HANDLE taosOpenFileNotStream(const char *path, int32_t tdFileOptions) {
 }
 
 int64_t taosReadFile(TdFilePtr pFile, void *buf, int64_t count) {
+  if (pFile == NULL  ||  buf == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
 #if FILE_WITH_LOCK
   (void)taosThreadRwlockRdlock(&(pFile->rwlock));
 #endif
@@ -435,7 +460,7 @@ int64_t taosReadFile(TdFilePtr pFile, void *buf, int64_t count) {
 }
 
 int64_t taosWriteFile(TdFilePtr pFile, const void *buf, int64_t count) {
-  if (pFile == NULL || pFile->hFile == NULL) {
+  if (pFile == NULL || pFile->hFile == NULL || buf == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -457,7 +482,7 @@ int64_t taosWriteFile(TdFilePtr pFile, const void *buf, int64_t count) {
 }
 
 int64_t taosPWriteFile(TdFilePtr pFile, const void *buf, int64_t count, int64_t offset) {
-  if (pFile == NULL) {
+  if (pFile == NULL || buf == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -719,6 +744,10 @@ bool lastErrorIsFileNotExist() {
 
 #else
 int taosOpenFileNotStream(const char *path, int32_t tdFileOptions) {
+  if (path == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return -1;
+  }
   int access = O_BINARY;
   access |= (tdFileOptions & TD_FILE_CREATE) ? O_CREAT : 0;
   if ((tdFileOptions & TD_FILE_WRITE) && (tdFileOptions & TD_FILE_READ)) {
@@ -742,6 +771,10 @@ int taosOpenFileNotStream(const char *path, int32_t tdFileOptions) {
 }
 
 int64_t taosReadFile(TdFilePtr pFile, void *buf, int64_t count) {
+  if (pFile == NULL || buf == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return -1;
+  }
   STUB_RAND_IO_ERR(terrno)
 #if FILE_WITH_LOCK
   (void)taosThreadRwlockRdlock(&(pFile->rwlock));
@@ -797,7 +830,7 @@ int64_t taosReadFile(TdFilePtr pFile, void *buf, int64_t count) {
 
 int64_t taosWriteFile(TdFilePtr pFile, const void *buf, int64_t count) {
   STUB_RAND_IO_ERR(terrno)
-  if (pFile == NULL) {
+  if (pFile == NULL || buf == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -843,7 +876,7 @@ int64_t taosWriteFile(TdFilePtr pFile, const void *buf, int64_t count) {
 
 int64_t taosPWriteFile(TdFilePtr pFile, const void *buf, int64_t count, int64_t offset) {
   STUB_RAND_IO_ERR(terrno)
-  if (pFile == NULL) {
+  if (pFile == NULL || buf == NULL) {
     terrno = TSDB_CODE_INVALID_PARA;
     return 0;
   }
@@ -1050,6 +1083,10 @@ bool lastErrorIsFileNotExist() { return terrno == TAOS_SYSTEM_ERROR(ENOENT); }
 #endif  // WINDOWS
 
 TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) {
+  if (path == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
   STUB_RAND_IO_ERR(NULL)
   FILE *fp = NULL;
 #ifdef WINDOWS
@@ -1399,6 +1436,10 @@ int32_t taosEOFFile(TdFilePtr pFile) {
 }
 
 bool taosCheckAccessFile(const char *pathname, int32_t tdFileAccessOptions) {
+  if (pathname == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return false;  // invalid parameter
+  }
   int flags = 0;
 
   if (tdFileAccessOptions & TD_FILE_ACCESS_EXIST_OK) {
@@ -1422,6 +1463,8 @@ bool taosCheckAccessFile(const char *pathname, int32_t tdFileAccessOptions) {
 bool taosCheckExistFile(const char *pathname) { return taosCheckAccessFile(pathname, TD_FILE_ACCESS_EXIST_OK); };
 
 int32_t taosCompressFile(char *srcFileName, char *destFileName) {
+  OS_PARAM_CHECK(srcFileName);
+  OS_PARAM_CHECK(destFileName);
   int32_t   compressSize = 163840;
   int32_t   ret = 0;
   int32_t   len = 0;
@@ -1516,6 +1559,10 @@ int32_t taosLinkFile(char *src, char *dst) {
 }
 
 FILE *taosOpenCFile(const char *filename, const char *mode) {
+  if (filename == NULL || mode == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
   STUB_RAND_IO_ERR(NULL)
   FILE *f = fopen(filename, mode);
   if (NULL == f) {
@@ -1525,6 +1572,10 @@ FILE *taosOpenCFile(const char *filename, const char *mode) {
 }
 
 int taosSeekCFile(FILE *file, int64_t offset, int whence) {
+  if(NULL == file) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
 #ifdef WINDOWS
   return _fseeki64(file, offset, whence);
 #else
@@ -1538,6 +1589,10 @@ int taosSeekCFile(FILE *file, int64_t offset, int whence) {
 }
 
 size_t taosReadFromCFile(void *buffer, size_t size, size_t count, FILE *stream) {
+  if (buffer == NULL || stream == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   STUB_RAND_IO_ERR(terrno)
   return fread(buffer, size, count, stream);
 }

source/os/src/osLocale.c

@@ -52,6 +52,9 @@ typedef struct CharsetPair {
 } CharsetPair;
 
 char *taosCharsetReplace(char *charsetstr) {
+  if (charsetstr == NULL) {
+    return NULL;
+  }
   CharsetPair charsetRep[] = {
       {"utf8", "UTF-8"},
       {"936", "CP936"},
@@ -76,6 +79,8 @@ char *taosCharsetReplace(char *charsetstr) {
  * In case that the setLocale failed to be executed, the right charset needs to be set.
  */
 int32_t taosSetSystemLocale(const char *inLocale, const char *inCharSet) {
+  OS_PARAM_CHECK(inLocale);
+  OS_PARAM_CHECK(inCharSet);
   if (!taosValidateEncodec(inCharSet)) {
     return terrno;
   }
@@ -90,6 +95,7 @@ int32_t taosSetSystemLocale(const char *inLocale, const char *inCharSet) {
 }
 
 void taosGetSystemLocale(char *outLocale, char *outCharset) {
+  if (outLocale == NULL || outCharset == NULL) return;
 #ifdef WINDOWS
   char *locale = setlocale(LC_CTYPE, "en_US.UTF-8");
   if (locale != NULL) {

source/os/src/osSemaphore.c

@@ -29,7 +29,11 @@
 
 bool taosCheckPthreadValid(TdThread thread) { return thread.p != NULL; }
 
-void taosResetPthread(TdThread* thread) { thread->p = 0; }
+void taosResetPthread(TdThread* thread) {
+  if (thread != NULL) {
+    thread->p = NULL;
+  }
+}
 
 int64_t taosGetPthreadId(TdThread thread) {
 #ifdef PTW32_VERSION
@@ -46,6 +50,7 @@ bool taosComparePthread(TdThread first, TdThread second) { return first.p == sec
 int32_t taosGetPId() { return GetCurrentProcessId(); }
 
 int32_t taosGetAppName(char* name, int32_t* len) {
+  OS_PARAM_CHECK(name);
   char filepath[1024] = {0};
 
   if (GetModuleFileName(NULL, filepath, MAX_PATH) == 0) {
@@ -75,6 +80,8 @@ int32_t taosGetAppName(char* name, int32_t* len) {
 int32_t taosGetPIdByName(const char* name, int32_t* pPId) { return -1;}
 
 int32_t tsem_wait(tsem_t* sem) {
+  OS_PARAM_CHECK(sem);
+  OS_PARAM_CHECK(*sem);
   DWORD ret = WaitForSingleObject(*sem, INFINITE);
   if (ret == WAIT_OBJECT_0) {
     return 0;
@@ -84,6 +91,8 @@ int32_t tsem_wait(tsem_t* sem) {
 }
 
 int32_t tsem_timewait(tsem_t* sem, int64_t timeout_ms) {
+  OS_PARAM_CHECK(sem);
+  OS_PARAM_CHECK(*sem);
   DWORD result = WaitForSingleObject(*sem, timeout_ms);
   if (result == WAIT_OBJECT_0) {
     return 0;  // Semaphore acquired
@@ -96,16 +105,21 @@ int32_t tsem_timewait(tsem_t* sem, int64_t timeout_ms) {
 
 // Inter-process sharing is not currently supported. The pshared parameter is invalid.
 int32_t tsem_init(tsem_t* sem, int pshared, unsigned int value) {
+  OS_PARAM_CHECK(sem);
   *sem = CreateSemaphore(NULL, value, LONG_MAX, NULL);
   return (*sem != NULL) ? 0 : TAOS_SYSTEM_WINAPI_ERROR(GetLastError());
 }
 
 int32_t tsem_post(tsem_t* sem) {
+  OS_PARAM_CHECK(sem);
+  OS_PARAM_CHECK(*sem);
   if (ReleaseSemaphore(*sem, 1, NULL)) return 0;
   return TAOS_SYSTEM_WINAPI_ERROR(GetLastError());
 }
 
 int32_t tsem_destroy(tsem_t* sem) {
+  OS_PARAM_CHECK(sem);
+  OS_PARAM_CHECK(*sem);
   if (CloseHandle(*sem)) return 0;
   return TAOS_SYSTEM_WINAPI_ERROR(GetLastError());
 }
@@ -115,6 +129,7 @@ int32_t tsem_destroy(tsem_t* sem) {
 #include <libproc.h>
 
 int32_t tsem_init(tsem_t *psem, int flags, unsigned int count) {
+  OS_PARAM_CHECK(psem);
   *psem = dispatch_semaphore_create(count);
   if (*psem == NULL) return TAOS_SYSTEM_ERROR(errno);
   return 0;
@@ -128,19 +143,19 @@ int32_t tsem_destroy(tsem_t *psem) {
 }
 
 int32_t tsem_post(tsem_t *psem) {
-  if (psem == NULL || *psem == NULL) return -1;
+  if (psem == NULL || *psem == NULL) return TSDB_CODE_INVALID_PARA;
   (void)dispatch_semaphore_signal(*psem);
   return 0;
 }
 
 int32_t tsem_wait(tsem_t *psem) {
-  if (psem == NULL || *psem == NULL) return -1;
+  if (psem == NULL || *psem == NULL) return TSDB_CODE_INVALID_PARA;
   dispatch_semaphore_wait(*psem, DISPATCH_TIME_FOREVER);
   return 0;
 }
 
 int32_t tsem_timewait(tsem_t *psem, int64_t milis) {
-  if (psem == NULL || *psem == NULL) return -1;
+  if (psem == NULL || *psem == NULL) return TSDB_CODE_INVALID_PARA;
   dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(milis * USEC_PER_SEC));
   if (dispatch_semaphore_wait(*psem, time) == 0) {
     return 0;
@@ -158,13 +173,18 @@ int64_t taosGetSelfPthreadId() {
 
 int64_t taosGetPthreadId(TdThread thread) { return (int64_t)thread; }
 
-void taosResetPthread(TdThread *thread) { *thread = NULL; }
+void taosResetPthread(TdThread *thread) {
+  if (thread) {
+    *thread = NULL;
+  }
+}
 
 bool taosComparePthread(TdThread first, TdThread second) { return taosThreadEqual(first, second) ? true : false; }
 
 int32_t taosGetPId() { return (int32_t)getpid(); }
 
 int32_t taosGetAppName(char *name, int32_t *len) {
+  OS_PARAM_CHECK(name);
   char buf[PATH_MAX + 1];
   buf[0] = '\0';
   proc_name(getpid(), buf, sizeof(buf) - 1);
@@ -196,7 +216,11 @@ int64_t taosGetSelfPthreadId() {
 }
 
 int64_t taosGetPthreadId(TdThread thread) { return (int64_t)thread; }
-void    taosResetPthread(TdThread* thread) { *thread = 0; }
+void    taosResetPthread(TdThread* thread) {
+  if (thread) {
+    *thread = 0;
+  }
+}
 bool    taosComparePthread(TdThread first, TdThread second) { return first == second; }
 
 int32_t taosGetPId() {
@@ -207,6 +231,7 @@ int32_t taosGetPId() {
 }
 
 int32_t taosGetAppName(char* name, int32_t* len) {
+  OS_PARAM_CHECK(name);
   const char* self = "/proc/self/exe";
   char        path[PATH_MAX] = {0};
 
@@ -233,6 +258,8 @@ int32_t taosGetAppName(char* name, int32_t* len) {
 }
 
 int32_t taosGetPIdByName(const char* name, int32_t* pPId) {
+  OS_PARAM_CHECK(name);
+  OS_PARAM_CHECK(pPId);
   DIR*           dir = NULL;
   struct dirent* ptr = NULL;
   FILE*          fp = NULL;
@@ -294,6 +321,7 @@ int32_t tsem_init(tsem_t* psem, int flags, unsigned int count) {
 }
 
 int32_t tsem_timewait(tsem_t* sem, int64_t ms) {
+  OS_PARAM_CHECK(sem);
   int ret = 0;
 
   struct timespec ts = {0};
@@ -322,6 +350,7 @@ int32_t tsem_timewait(tsem_t* sem, int64_t ms) {
 }
 
 int32_t tsem_wait(tsem_t* sem) {
+  OS_PARAM_CHECK(sem);
   int ret = 0;
   do {
     ret = sem_wait(sem);
@@ -336,6 +365,7 @@ int32_t tsem_wait(tsem_t* sem) {
 }
 
 int tsem2_init(tsem2_t* sem, int pshared, unsigned int value) {
+  OS_PARAM_CHECK(sem);
   int ret = taosThreadMutexInit(&sem->mutex, NULL);
   if (ret != 0) return ret;
 
@@ -365,6 +395,7 @@ int tsem2_init(tsem2_t* sem, int pshared, unsigned int value) {
 }
 
 int32_t tsem_post(tsem_t* psem) {
+  OS_PARAM_CHECK(psem);
   if (sem_post(psem) == 0) {
     return 0;
   } else {
@@ -373,6 +404,7 @@ int32_t tsem_post(tsem_t* psem) {
 }
 
 int32_t tsem_destroy(tsem_t* sem) {
+  OS_PARAM_CHECK(sem);
   if (sem_destroy(sem) == 0) {
     return 0;
   } else {
@@ -381,6 +413,7 @@ int32_t tsem_destroy(tsem_t* sem) {
 }
 
 int tsem2_post(tsem2_t* sem) {
+  OS_PARAM_CHECK(sem);
   int32_t code = taosThreadMutexLock(&sem->mutex);
   if (code) {
     return code;
@@ -401,6 +434,7 @@ int tsem2_post(tsem2_t* sem) {
 }
 
 int tsem2_destroy(tsem2_t* sem) {
+  OS_PARAM_CHECK(sem);
   (void)taosThreadMutexDestroy(&sem->mutex);
   (void)taosThreadCondDestroy(&sem->cond);
   (void)taosThreadCondAttrDestroy(&sem->attr);
@@ -409,6 +443,7 @@ int tsem2_destroy(tsem2_t* sem) {
 }
 
 int32_t tsem2_wait(tsem2_t* sem) {
+  OS_PARAM_CHECK(sem);
   int32_t code = taosThreadMutexLock(&sem->mutex);
   if (code) {
     return code;
@@ -434,6 +469,7 @@ int32_t tsem2_wait(tsem2_t* sem) {
 }
 
 int32_t tsem2_timewait(tsem2_t* sem, int64_t ms) {
+  OS_PARAM_CHECK(sem);
   int32_t code = 0;
 
   code = taosThreadMutexLock(&sem->mutex);

source/os/src/osSocket.c

@@ -233,6 +233,8 @@ int32_t taosBlockSIGPIPE() {
 }
 
 int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t *ip) {
+  OS_PARAM_CHECK(fqdn);
+  OS_PARAM_CHECK(ip);
 #ifdef WINDOWS
   // Initialize Winsock
   WSADATA wsaData;
@@ -309,6 +311,7 @@ int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t *ip) {
 }
 
 int32_t taosGetFqdn(char *fqdn) {
+  OS_PARAM_CHECK(fqdn);
 #ifdef WINDOWS
   // Initialize Winsock
   WSADATA wsaData;
@@ -384,6 +387,9 @@ int32_t taosGetFqdn(char *fqdn) {
 }
 
 void tinet_ntoa(char *ipstr, uint32_t ip) {
+  if (ipstr == NULL) {
+    return;
+  }
   (void)snprintf(ipstr, TD_IP_LEN, "%d.%d.%d.%d", ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, ip >> 24);
 }
 

source/os/src/osString.c

@@ -25,15 +25,19 @@ extern int wcwidth(wchar_t c);
 extern int wcswidth(const wchar_t *s, size_t n);
 
 char *tstrdup(const char *str) {
+  if (str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
 #ifdef WINDOWS
   return _strdup(str);
 #else
-  char* p = strdup(str);
+  char *p = strdup(str);
-  if (str != NULL && NULL == p) {
+  if (NULL == p) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
   }
   return p;
-  
+
 #endif
 }
 
@@ -41,11 +45,19 @@ char *tstrdup(const char *str) {
 
 // No errors are expected to occur
 char *strsep(char **stringp, const char *delim) {
+  if (stringp == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
   char       *s;
   const char *spanp;
   int32_t     c, sc;
   char       *tok;
   if ((s = *stringp) == NULL) return (NULL);
+  if (delim == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
   for (tok = s;;) {
     c = *s++;
     spanp = delim;
@@ -81,6 +93,10 @@ char *taosStrndup(const char *s, int size) {
 /* Copy no more than N characters of SRC to DEST, returning the address of
    the terminating '\0' in DEST, if any, or else DEST + N.  */
 char *stpncpy(char *dest, const char *src, int n) {
+  if (dest == NULL || src == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
   size_t size = strnlen(src, n);
   memcpy(dest, src, size);
   dest += size;
@@ -117,6 +133,8 @@ int32_t taosStr2int64(const char *str, int64_t *val) {
 }
 
 int32_t taosStr2int16(const char *str, int16_t *val) {
+  OS_PARAM_CHECK(str);
+  OS_PARAM_CHECK(val);
   int64_t tmp = 0;
   int32_t code = taosStr2int64(str, &tmp);
   if (code) {
@@ -130,6 +148,8 @@ int32_t taosStr2int16(const char *str, int16_t *val) {
 }
 
 int32_t taosStr2int32(const char *str, int32_t *val) {
+  OS_PARAM_CHECK(str);
+  OS_PARAM_CHECK(val);
   int64_t tmp = 0;
   int32_t code = taosStr2int64(str, &tmp);
   if (code) {
@@ -143,6 +163,8 @@ int32_t taosStr2int32(const char *str, int32_t *val) {
 }
 
 int32_t taosStr2int8(const char *str, int8_t *val) {
+  OS_PARAM_CHECK(str);
+  OS_PARAM_CHECK(val);
   int64_t tmp = 0;
   int32_t code = taosStr2int64(str, &tmp);
   if (code) {
@@ -156,6 +178,9 @@ int32_t taosStr2int8(const char *str, int8_t *val) {
 }
 
 int32_t tasoUcs4Compare(TdUcs4 *f1_ucs4, TdUcs4 *f2_ucs4, int32_t bytes) {
+  if ((f1_ucs4 == NULL || f2_ucs4 == NULL)) {
+    return TSDB_CODE_INVALID_PARA;
+  }
   for (int32_t i = 0; i < bytes; i += sizeof(TdUcs4)) {
     int32_t f1 = *(int32_t *)((char *)f1_ucs4 + i);
     int32_t f2 = *(int32_t *)((char *)f2_ucs4 + i);
@@ -191,6 +216,9 @@ int32_t tasoUcs4Compare(TdUcs4 *f1_ucs4, TdUcs4 *f2_ucs4, int32_t bytes) {
 }
 
 int32_t tasoUcs4Copy(TdUcs4 *target_ucs4, TdUcs4 *source_ucs4, int32_t len_ucs4) {
+  if (target_ucs4 == NULL || source_ucs4 == NULL || len_ucs4 <= 0) {
+    return TSDB_CODE_INVALID_PARA;
+  }
   if (taosMemorySize(target_ucs4) < len_ucs4 * sizeof(TdUcs4)) {
     terrno = TSDB_CODE_INVALID_PARA;
     return terrno;
@@ -261,6 +289,10 @@ void taosConvDestroy() {
 }
 
 iconv_t taosAcquireConv(int32_t *idx, ConvType type) {
+  if(idx == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return (iconv_t)-1;
+  }
   if (gConvMaxNum[type] <= 0) {
     *idx = -1;
     if (type == M2C) {
@@ -321,6 +353,13 @@ void taosReleaseConv(int32_t idx, iconv_t conv, ConvType type) {
 }
 
 bool taosMbsToUcs4(const char *mbs, size_t mbsLength, TdUcs4 *ucs4, int32_t ucs4_max_len, int32_t *len) {
+  if (ucs4_max_len == 0) {
+    return true;
+  }
+  if(ucs4_max_len < 0 || mbs == NULL || ucs4 == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return false;
+  }
 #ifdef DISALLOW_NCHAR_WITHOUT_ICONV
   printf("Nchar cannot be read and written without iconv, please install iconv library and recompile.\n");
   terrno = TSDB_CODE_APP_ERROR;
@@ -359,6 +398,13 @@ bool taosMbsToUcs4(const char *mbs, size_t mbsLength, TdUcs4 *ucs4, int32_t ucs4
 // if success, return the number of bytes written to mbs ( >= 0)
 // otherwise return error code ( < 0)
 int32_t taosUcs4ToMbs(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs) {
+  if (ucs4_max_len == 0) {
+    return 0;
+  }
+  if(ucs4_max_len < 0 || ucs4 == NULL || mbs == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
 #ifdef DISALLOW_NCHAR_WITHOUT_ICONV
   printf("Nchar cannot be read and written without iconv, please install iconv library and recompile.\n");
   terrno = TSDB_CODE_APP_ERROR;
@@ -390,6 +436,13 @@ int32_t taosUcs4ToMbs(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs) {
 // if success, return the number of bytes written to mbs ( >= 0)
 // otherwise return error code ( < 0)
 int32_t taosUcs4ToMbsEx(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs, iconv_t conv) {
+  if (ucs4_max_len == 0) {
+    return 0;
+  }
+  if(ucs4_max_len < 0 || ucs4 == NULL || mbs == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
 #ifdef DISALLOW_NCHAR_WITHOUT_ICONV
   printf("Nchar cannot be read and written without iconv, please install iconv library and recompile.\n");
   terrno = TSDB_CODE_APP_ERROR;
@@ -408,6 +461,10 @@ int32_t taosUcs4ToMbsEx(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs, iconv_t c
 }
 
 bool taosValidateEncodec(const char *encodec) {
+  if(encodec == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return false;
+  }
 #ifdef DISALLOW_NCHAR_WITHOUT_ICONV
   printf("Nchar cannot be read and written without iconv, please install iconv library and recompile.\n");
   terrno = TSDB_CODE_APP_ERROR;
@@ -443,7 +500,7 @@ int32_t taosUcs4len(TdUcs4 *ucs4) {
 
 // dst buffer size should be at least 2*len + 1
 int32_t taosHexEncode(const unsigned char *src, char *dst, int32_t len, int32_t bufSize) {
-  if (!dst) {
+  if (!dst || !src || bufSize <= 0) {
     terrno = TSDB_CODE_INVALID_PARA;
     return terrno;
   }
@@ -456,7 +513,7 @@ int32_t taosHexEncode(const unsigned char *src, char *dst, int32_t len, int32_t
 }
 
 int32_t taosHexDecode(const char *src, char *dst, int32_t len) {
-  if (!dst) {
+  if(!src || !dst || len <= 0) {
     terrno = TSDB_CODE_INVALID_PARA;
     return terrno;
   }
@@ -475,19 +532,42 @@ int32_t taosHexDecode(const char *src, char *dst, int32_t len) {
 
 int32_t taosWcharWidth(TdWchar wchar) { return wcwidth(wchar); }
 
-int32_t taosWcharsWidth(TdWchar *pWchar, int32_t size) { return wcswidth(pWchar, size); }
+int32_t taosWcharsWidth(TdWchar *pWchar, int32_t size) {
+  if (pWchar == NULL || size <= 0) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
+  return wcswidth(pWchar, size);
+}
 
-int32_t taosMbToWchar(TdWchar *pWchar, const char *pStr, int32_t size) { return mbtowc(pWchar, pStr, size); }
+int32_t taosMbToWchar(TdWchar *pWchar, const char *pStr, int32_t size) {
+  if (pWchar == NULL || pStr == NULL || size <= 0) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
+  return mbtowc(pWchar, pStr, size);
+}
 
-int32_t taosMbsToWchars(TdWchar *pWchars, const char *pStrs, int32_t size) { return mbstowcs(pWchars, pStrs, size); }
+int32_t taosMbsToWchars(TdWchar *pWchars, const char *pStrs, int32_t size) {
+  if (pWchars == NULL || pStrs == NULL || size <= 0) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
+  return mbstowcs(pWchars, pStrs, size);
+}
 
-int32_t taosWcharToMb(char *pStr, TdWchar wchar) { return wctomb(pStr, wchar); }
+int32_t taosWcharToMb(char *pStr, TdWchar wchar) { 
+  OS_PARAM_CHECK(pStr);
+  return wctomb(pStr, wchar); }
 
 char *taosStrCaseStr(const char *str, const char *pattern) {
+  if (str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
+  if (!pattern || !*pattern) return (char *)str;
+
   size_t i;
-
-  if (!*pattern) return (char *)str;
-
   for (; *str; str++) {
     if (toupper(*str) == toupper(*pattern)) {
       for (i = 1;; i++) {
@@ -500,6 +580,10 @@ char *taosStrCaseStr(const char *str, const char *pattern) {
 }
 
 int64_t taosStr2Int64(const char *str, char **pEnd, int32_t radix) {
+  if(str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   int64_t tmp = strtoll(str, pEnd, radix);
 #if defined(DARWIN) || defined(_ALPINE)
   if (errno == EINVAL) errno = 0;
@@ -508,6 +592,10 @@ int64_t taosStr2Int64(const char *str, char **pEnd, int32_t radix) {
 }
 
 uint64_t taosStr2UInt64(const char *str, char **pEnd, int32_t radix) {
+  if(str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   uint64_t tmp = strtoull(str, pEnd, radix);
 #if defined(DARWIN) || defined(_ALPINE)
   if (errno == EINVAL) errno = 0;
@@ -516,6 +604,10 @@ uint64_t taosStr2UInt64(const char *str, char **pEnd, int32_t radix) {
 }
 
 int32_t taosStr2Int32(const char *str, char **pEnd, int32_t radix) {
+  if(str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   int32_t tmp = strtol(str, pEnd, radix);
 #if defined(DARWIN) || defined(_ALPINE)
   if (errno == EINVAL) errno = 0;
@@ -524,6 +616,10 @@ int32_t taosStr2Int32(const char *str, char **pEnd, int32_t radix) {
 }
 
 uint32_t taosStr2UInt32(const char *str, char **pEnd, int32_t radix) {
+  if(str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   uint32_t tmp = strtol(str, pEnd, radix);
 #if defined(DARWIN) || defined(_ALPINE)
   if (errno == EINVAL) errno = 0;
@@ -532,6 +628,10 @@ uint32_t taosStr2UInt32(const char *str, char **pEnd, int32_t radix) {
 }
 
 int16_t taosStr2Int16(const char *str, char **pEnd, int32_t radix) {
+  if(str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   int32_t tmp = strtol(str, pEnd, radix);
 #if defined(DARWIN) || defined(_ALPINE)
   if (errno == EINVAL) errno = 0;
@@ -540,6 +640,10 @@ int16_t taosStr2Int16(const char *str, char **pEnd, int32_t radix) {
 }
 
 uint16_t taosStr2UInt16(const char *str, char **pEnd, int32_t radix) {
+  if(str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   uint32_t tmp = strtoul(str, pEnd, radix);
 #if defined(DARWIN) || defined(_ALPINE)
   if (errno == EINVAL) errno = 0;
@@ -548,11 +652,19 @@ uint16_t taosStr2UInt16(const char *str, char **pEnd, int32_t radix) {
 }
 
 int8_t taosStr2Int8(const char *str, char **pEnd, int32_t radix) {
+  if(str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   int32_t tmp = strtol(str, pEnd, radix);
   return tmp;
 }
 
 uint8_t taosStr2UInt8(const char *str, char **pEnd, int32_t radix) {
+  if(str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   uint32_t tmp = strtoul(str, pEnd, radix);
 #if defined(DARWIN) || defined(_ALPINE)
   if (errno == EINVAL) errno = 0;
@@ -561,11 +673,19 @@ uint8_t taosStr2UInt8(const char *str, char **pEnd, int32_t radix) {
 }
 
 double taosStr2Double(const char *str, char **pEnd) {
+  if(str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   double tmp = strtod(str, pEnd);
   return tmp;
 }
 
 float taosStr2Float(const char *str, char **pEnd) {
+  if(str == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   float tmp = strtof(str, pEnd);
   return tmp;
 }
@@ -578,6 +698,10 @@ bool isHex(const char *z, uint32_t n) {
 }
 
 bool isValidateHex(const char *z, uint32_t n) {
+  if(!z) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return false;
+  }
   if ((n & 1) != 0) return false;
   for (size_t i = HEX_PREFIX_LEN; i < n; i++) {
     if (isxdigit(z[i]) == 0) {
@@ -588,6 +712,9 @@ bool isValidateHex(const char *z, uint32_t n) {
 }
 
 int32_t taosHex2Ascii(const char *z, uint32_t n, void **data, uint32_t *size) {
+  OS_PARAM_CHECK(z);
+  OS_PARAM_CHECK(data);
+  OS_PARAM_CHECK(size);
   n -= HEX_PREFIX_LEN;  // remove 0x
   z += HEX_PREFIX_LEN;
   *size = n / HEX_PREFIX_LEN;
@@ -712,6 +839,10 @@ int32_t taosAscii2Hex(const char *z, uint32_t n, void **data, uint32_t *size) {
 }
 
 int64_t tsnprintf(char *dst, int64_t size, const char *format, ...) {
+  if (dst == NULL || format == NULL) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return 0;
+  }
   if (size <= 0) return 0;
   if (size == 1) {
     dst[0] = '\0';

source/os/src/osSysinfo.c

@@ -154,6 +154,7 @@ static void taosGetProcIOnfos() {
 #endif
 
 static int32_t taosGetSysCpuInfo(SysCpuInfo *cpuInfo) {
+  OS_PARAM_CHECK(cpuInfo);
   int32_t code = 0;
 #ifdef WINDOWS
   FILETIME pre_idleTime = {0};
@@ -206,6 +207,7 @@ static int32_t taosGetSysCpuInfo(SysCpuInfo *cpuInfo) {
 }
 
 static int32_t taosGetProcCpuInfo(ProcCpuInfo *cpuInfo) {
+  OS_PARAM_CHECK(cpuInfo);
   int32_t code = 0;
 
 #ifdef WINDOWS
@@ -287,6 +289,7 @@ void taosGetSystemInfo() {
 }
 
 int32_t taosGetEmail(char *email, int32_t maxLen) {
+  OS_PARAM_CHECK(email);
 #ifdef WINDOWS
   return 0;
 #elif defined(_TD_DARWIN_64)
@@ -330,6 +333,7 @@ int32_t taosGetEmail(char *email, int32_t maxLen) {
 
 #ifdef WINDOWS
 bool getWinVersionReleaseName(char *releaseName, int32_t maxLen) {
+  if(releaseName == NULL) return false;
   TCHAR          szFileName[MAX_PATH];
   DWORD             dwHandle;
   DWORD             dwLen;
@@ -367,6 +371,7 @@ bool getWinVersionReleaseName(char *releaseName, int32_t maxLen) {
 #endif
 
 int32_t taosGetOsReleaseName(char *releaseName, char* sName, char* ver, int32_t maxLen) {
+  OS_PARAM_CHECK(releaseName);
 #ifdef WINDOWS
   if (!getWinVersionReleaseName(releaseName, maxLen)) {
     snprintf(releaseName, maxLen, "Windows");
@@ -437,6 +442,8 @@ int32_t taosGetOsReleaseName(char *releaseName, char* sName, char* ver, int32_t
 }
 
 int32_t taosGetCpuInfo(char *cpuModel, int32_t maxLen, float *numOfCores) {
+  OS_PARAM_CHECK(cpuModel);
+  OS_PARAM_CHECK(numOfCores);
 #ifdef WINDOWS
   char  value[100];
   DWORD bufferSize = sizeof(value);
@@ -541,6 +548,7 @@ int32_t taosGetCpuInfo(char *cpuModel, int32_t maxLen, float *numOfCores) {
 
 // Returns the container's CPU quota if successful, otherwise returns the physical CPU cores
 static int32_t taosCntrGetCpuCores(float *numOfCores) {
+  OS_PARAM_CHECK(numOfCores);
 #ifdef WINDOWS
   return TSDB_CODE_UNSUPPORT_OS;
 #elif defined(_TD_DARWIN_64)
@@ -600,6 +608,7 @@ _end:
 }
 
 int32_t taosGetCpuCores(float *numOfCores, bool physical) {
+  OS_PARAM_CHECK(numOfCores);
 #ifdef WINDOWS
   SYSTEM_INFO info;
   GetSystemInfo(&info);
@@ -702,6 +711,7 @@ int32_t taosGetCpuInstructions(char* sse42, char* avx, char* avx2, char* fma, ch
 }
 
 int32_t taosGetTotalMemory(int64_t *totalKB) {
+  OS_PARAM_CHECK(totalKB);
 #ifdef WINDOWS
   MEMORYSTATUSEX memsStat;
   memsStat.dwLength = sizeof(memsStat);
@@ -723,6 +733,7 @@ int32_t taosGetTotalMemory(int64_t *totalKB) {
 }
 
 int32_t taosGetProcMemory(int64_t *usedKB) {
+  OS_PARAM_CHECK(usedKB);
 #ifdef WINDOWS
   unsigned bytes_used = 0;
 
@@ -769,6 +780,7 @@ int32_t taosGetProcMemory(int64_t *usedKB) {
 }
 
 int32_t taosGetSysMemory(int64_t *usedKB) {
+  OS_PARAM_CHECK(usedKB);
 #ifdef WINDOWS
   MEMORYSTATUSEX memsStat;
   memsStat.dwLength = sizeof(memsStat);
@@ -794,6 +806,8 @@ int32_t taosGetSysMemory(int64_t *usedKB) {
 }
 
 int32_t taosGetDiskSize(char *dataDir, SDiskSize *diskSize) {
+  OS_PARAM_CHECK(dataDir);
+  OS_PARAM_CHECK(diskSize);
 #if defined(WINDOWS)
   unsigned _int64 i64FreeBytesToCaller;
   unsigned _int64 i64TotalBytes;
@@ -839,21 +853,25 @@ int32_t taosGetDiskSize(char *dataDir, SDiskSize *diskSize) {
 }
 
 int32_t taosGetProcIO(int64_t *rchars, int64_t *wchars, int64_t *read_bytes, int64_t *write_bytes) {
+  OS_PARAM_CHECK(rchars);
+  OS_PARAM_CHECK(wchars);
+  OS_PARAM_CHECK(read_bytes);
+  OS_PARAM_CHECK(write_bytes);
 #ifdef WINDOWS
   IO_COUNTERS io_counter;
   if (GetProcessIoCounters(GetCurrentProcess(), &io_counter)) {
-    if (rchars) *rchars = io_counter.ReadTransferCount;
+    *rchars = io_counter.ReadTransferCount;
-    if (wchars) *wchars = io_counter.WriteTransferCount;
+    *wchars = io_counter.WriteTransferCount;
-    if (read_bytes) *read_bytes = 0;
+    *read_bytes = 0;
-    if (write_bytes) *write_bytes = 0;
+    *write_bytes = 0;
     return 0;
   }
   return TAOS_SYSTEM_WINAPI_ERROR(GetLastError());
 #elif defined(_TD_DARWIN_64)
-  if (rchars) *rchars = 0;
+  *rchars = 0;
-  if (wchars) *wchars = 0;
+  *wchars = 0;
-  if (read_bytes) *read_bytes = 0;
+  *read_bytes = 0;
-  if (write_bytes) *write_bytes = 0;
+  *write_bytes = 0;
   return 0;
 #else
   TdFilePtr pFile = taosOpenFile(tsProcIOFile, TD_FILE_READ | TD_FILE_STREAM);
@@ -900,6 +918,9 @@ int32_t taosGetProcIO(int64_t *rchars, int64_t *wchars, int64_t *read_bytes, int
 }
 
 int32_t taosGetProcIODelta(int64_t *rchars, int64_t *wchars, int64_t *read_bytes, int64_t *write_bytes) {
+  if (rchars == NULL || wchars == NULL || read_bytes == NULL || write_bytes == NULL) {
+    return TSDB_CODE_INVALID_PARA;
+  }
   static int64_t last_rchars = -1;
   static int64_t last_wchars = -1;
   static int64_t last_read_bytes = -1;
@@ -932,13 +953,15 @@ int32_t taosGetProcIODelta(int64_t *rchars, int64_t *wchars, int64_t *read_bytes
   return 0;
 }
 void taosSetDefaultProcIODelta(int64_t *rchars, int64_t *wchars, int64_t *read_bytes, int64_t *write_bytes) {
-  *rchars = 0;
+  if(rchars) *rchars = 0;
-  *wchars = 0;
+  if(wchars) *wchars = 0;
-  *read_bytes = 0;
+  if(read_bytes) *read_bytes = 0;
-  *write_bytes = 0;
+  if(write_bytes) *write_bytes = 0;
 }
 
 int32_t taosGetCardInfo(int64_t *receive_bytes, int64_t *transmit_bytes) {
+  OS_PARAM_CHECK(receive_bytes);
+  OS_PARAM_CHECK(transmit_bytes);
   *receive_bytes = 0;
   *transmit_bytes = 0;
 
@@ -994,6 +1017,8 @@ int32_t taosGetCardInfo(int64_t *receive_bytes, int64_t *transmit_bytes) {
 }
 
 int32_t taosGetCardInfoDelta(int64_t *receive_bytes, int64_t *transmit_bytes) {
+  OS_PARAM_CHECK(receive_bytes);
+  OS_PARAM_CHECK(transmit_bytes);
   static int64_t last_receive_bytes = -1;
   static int64_t last_transmit_bytes = -1;
   int64_t cur_receive_bytes = 0;
@@ -1017,8 +1042,8 @@ int32_t taosGetCardInfoDelta(int64_t *receive_bytes, int64_t *transmit_bytes) {
   return 0;
 }
 void taosSetDefaultCardInfoDelta(int64_t *receive_bytes, int64_t *transmit_bytes) {
-  *receive_bytes = 0;
+  if (receive_bytes) *receive_bytes = 0;
-  *transmit_bytes = 0;
+  if (transmit_bytes) *transmit_bytes = 0;
 }
 
 void taosKillSystem() {
@@ -1037,6 +1062,7 @@ void taosKillSystem() {
 
 #define UUIDLEN (36)
 int32_t taosGetSystemUUIDLimit36(char *uid, int32_t uidlen) {
+  OS_PARAM_CHECK(uid);
 #ifdef WINDOWS
   GUID guid;
   HRESULT h = CoCreateGuid(&guid);
@@ -1334,6 +1360,7 @@ int32_t getMacLocalHostNameBySCD(char *hostname, size_t maxLen) {
 #endif
 
 int32_t taosGetlocalhostname(char *hostname, size_t maxLen) {
+  OS_PARAM_CHECK(hostname);
 #ifdef _TD_DARWIN_64
   int res = getMacLocalHostNameBySCD(hostname, maxLen);
   if (res != 0) {

source/os/src/osSystem.c

@@ -107,26 +107,6 @@ void* taosLoadDll(const char* filename) {
 #endif
 }
 
-void* taosLoadSym(void* handle, char* name) {
-#if defined(WINDOWS)
-  return NULL;
-#elif defined(_TD_DARWIN_64)
-  return NULL;
-#else
-  void* sym = dlsym(handle, name);
-  char* error = NULL;
-
-  if ((error = dlerror()) != NULL) {
-    // printf("load sym:%s failed, error:%s", name, dlerror());
-    return NULL;
-  }
-
-  // printf("sym %s loaded", name);
-
-  return sym;
-#endif
-}
-
 void taosCloseDll(void* handle) {
 #if defined(WINDOWS)
   return;

source/os/src/osThread.c

@@ -18,6 +18,8 @@
 #include "os.h"
 
 int32_t taosThreadCreate(TdThread *tid, const TdThreadAttr *attr, void *(*start)(void *), void *arg) {
+  OS_PARAM_CHECK(tid);
+  OS_PARAM_CHECK(start);
   int32_t code = pthread_create(tid, attr, start, arg);
   if (code) {
     taosThreadClear(tid);
@@ -28,6 +30,7 @@ int32_t taosThreadCreate(TdThread *tid, const TdThreadAttr *attr, void *(*start)
 }
 
 int32_t taosThreadAttrDestroy(TdThreadAttr *attr) { 
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_attr_destroy(attr); 
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -37,6 +40,8 @@ int32_t taosThreadAttrDestroy(TdThreadAttr *attr) {
 }
 
 int32_t taosThreadAttrGetDetachState(const TdThreadAttr *attr, int32_t *detachstate) {
+  OS_PARAM_CHECK(attr);
+  OS_PARAM_CHECK(detachstate);
   int32_t code = pthread_attr_getdetachstate(attr, detachstate);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -46,6 +51,8 @@ int32_t taosThreadAttrGetDetachState(const TdThreadAttr *attr, int32_t *detachst
 }
 
 int32_t taosThreadAttrGetInheritSched(const TdThreadAttr *attr, int32_t *inheritsched) {
+  OS_PARAM_CHECK(attr);
+  OS_PARAM_CHECK(inheritsched);
   int32_t code = pthread_attr_getinheritsched(attr, inheritsched);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -55,6 +62,8 @@ int32_t taosThreadAttrGetInheritSched(const TdThreadAttr *attr, int32_t *inherit
 }
 
 int32_t taosThreadAttrGetSchedParam(const TdThreadAttr *attr, struct sched_param *param) {
+  OS_PARAM_CHECK(attr);
+  OS_PARAM_CHECK(param);
   int32_t code = pthread_attr_getschedparam(attr, param);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -64,6 +73,8 @@ int32_t taosThreadAttrGetSchedParam(const TdThreadAttr *attr, struct sched_param
 }
 
 int32_t taosThreadAttrGetSchedPolicy(const TdThreadAttr *attr, int32_t *policy) {
+  OS_PARAM_CHECK(attr);
+  OS_PARAM_CHECK(policy);
   int32_t code = pthread_attr_getschedpolicy(attr, policy);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -73,6 +84,8 @@ int32_t taosThreadAttrGetSchedPolicy(const TdThreadAttr *attr, int32_t *policy)
 }
 
 int32_t taosThreadAttrGetScope(const TdThreadAttr *attr, int32_t *contentionscope) {
+  OS_PARAM_CHECK(attr);
+  OS_PARAM_CHECK(contentionscope);
   int32_t code = pthread_attr_getscope(attr, contentionscope);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -82,6 +95,8 @@ int32_t taosThreadAttrGetScope(const TdThreadAttr *attr, int32_t *contentionscop
 }
 
 int32_t taosThreadAttrGetStackSize(const TdThreadAttr *attr, size_t *stacksize) {
+  OS_PARAM_CHECK(attr);
+  OS_PARAM_CHECK(stacksize);
   int32_t code = pthread_attr_getstacksize(attr, stacksize);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -90,7 +105,8 @@ int32_t taosThreadAttrGetStackSize(const TdThreadAttr *attr, size_t *stacksize)
   return code;
 }
 
-int32_t taosThreadAttrInit(TdThreadAttr *attr) { 
+int32_t taosThreadAttrInit(TdThreadAttr *attr) {
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_attr_init(attr); 
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -100,6 +116,7 @@ int32_t taosThreadAttrInit(TdThreadAttr *attr) {
 }
 
 int32_t taosThreadAttrSetDetachState(TdThreadAttr *attr, int32_t detachstate) {
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_attr_setdetachstate(attr, detachstate);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -109,6 +126,7 @@ int32_t taosThreadAttrSetDetachState(TdThreadAttr *attr, int32_t detachstate) {
 }
 
 int32_t taosThreadAttrSetInheritSched(TdThreadAttr *attr, int32_t inheritsched) {
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_attr_setinheritsched(attr, inheritsched);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -118,6 +136,7 @@ int32_t taosThreadAttrSetInheritSched(TdThreadAttr *attr, int32_t inheritsched)
 }
 
 int32_t taosThreadAttrSetSchedParam(TdThreadAttr *attr, const struct sched_param *param) {
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_attr_setschedparam(attr, param);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -127,6 +146,7 @@ int32_t taosThreadAttrSetSchedParam(TdThreadAttr *attr, const struct sched_param
 }
 
 int32_t taosThreadAttrSetSchedPolicy(TdThreadAttr *attr, int32_t policy) {
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_attr_setschedpolicy(attr, policy);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -136,6 +156,7 @@ int32_t taosThreadAttrSetSchedPolicy(TdThreadAttr *attr, int32_t policy) {
 }
 
 int32_t taosThreadAttrSetScope(TdThreadAttr *attr, int32_t contentionscope) {
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_attr_setscope(attr, contentionscope);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -145,6 +166,7 @@ int32_t taosThreadAttrSetScope(TdThreadAttr *attr, int32_t contentionscope) {
 }
 
 int32_t taosThreadAttrSetStackSize(TdThreadAttr *attr, size_t stacksize) {
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_attr_setstacksize(attr, stacksize);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -163,6 +185,7 @@ int32_t taosThreadCancel(TdThread thread) {
 }
 
 int32_t taosThreadCondDestroy(TdThreadCond *cond) {
+  OS_PARAM_CHECK(cond);
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
@@ -176,6 +199,7 @@ int32_t taosThreadCondDestroy(TdThreadCond *cond) {
 }
 
 int32_t taosThreadCondInit(TdThreadCond *cond, const TdThreadCondAttr *attr) {
+  OS_PARAM_CHECK(cond);
 #ifdef __USE_WIN_THREAD
   InitializeConditionVariable(cond);
   return 0;
@@ -190,6 +214,7 @@ int32_t taosThreadCondInit(TdThreadCond *cond, const TdThreadCondAttr *attr) {
 }
 
 int32_t taosThreadCondSignal(TdThreadCond *cond) {
+  OS_PARAM_CHECK(cond);
 #ifdef __USE_WIN_THREAD
   WakeConditionVariable(cond);
   return 0;
@@ -204,6 +229,7 @@ int32_t taosThreadCondSignal(TdThreadCond *cond) {
 }
 
 int32_t taosThreadCondBroadcast(TdThreadCond *cond) {
+  OS_PARAM_CHECK(cond);
 #ifdef __USE_WIN_THREAD
   WakeAllConditionVariable(cond);
   return 0;
@@ -218,6 +244,8 @@ int32_t taosThreadCondBroadcast(TdThreadCond *cond) {
 }
 
 int32_t taosThreadCondWait(TdThreadCond *cond, TdThreadMutex *mutex) {
+  OS_PARAM_CHECK(cond);
+  OS_PARAM_CHECK(mutex);
 #ifdef __USE_WIN_THREAD
   if (!SleepConditionVariableCS(cond, mutex, INFINITE)) {
     return EINVAL;
@@ -234,8 +262,10 @@ int32_t taosThreadCondWait(TdThreadCond *cond, TdThreadMutex *mutex) {
 }
 
 int32_t taosThreadCondTimedWait(TdThreadCond *cond, TdThreadMutex *mutex, const struct timespec *abstime) {
-#ifdef __USE_WIN_THREAD
   if (!abstime) return 0;
+  OS_PARAM_CHECK(cond);
+  OS_PARAM_CHECK(mutex);
+#ifdef __USE_WIN_THREAD
   if (SleepConditionVariableCS(cond, mutex, (DWORD)(abstime->tv_sec * 1e3 + abstime->tv_nsec / 1e6))) return 0;
   DWORD error = GetLastError();
   if (error == ERROR_TIMEOUT) {
@@ -258,6 +288,7 @@ int32_t taosThreadCondAttrDestroy(TdThreadCondAttr *attr) {
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_condattr_destroy(attr);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -268,10 +299,12 @@ int32_t taosThreadCondAttrDestroy(TdThreadCondAttr *attr) {
 }
 
 int32_t taosThreadCondAttrGetPshared(const TdThreadCondAttr *attr, int32_t *pshared) {
+  OS_PARAM_CHECK(pshared);
 #ifdef __USE_WIN_THREAD
   if (pshared) *pshared = PTHREAD_PROCESS_PRIVATE;
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_condattr_getpshared(attr, pshared);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -285,6 +318,7 @@ int32_t taosThreadCondAttrInit(TdThreadCondAttr *attr) {
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_condattr_init(attr);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -300,6 +334,7 @@ int32_t taosThreadCondAttrSetclock(TdThreadCondAttr *attr, int clockId) {
 #elif defined(__APPLE__)
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_condattr_setclock(attr, clockId);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -310,6 +345,7 @@ int32_t taosThreadCondAttrSetclock(TdThreadCondAttr *attr, int clockId) {
 }
 
 int32_t taosThreadCondAttrSetPshared(TdThreadCondAttr *attr, int32_t pshared) {
+  OS_PARAM_CHECK(attr);
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
@@ -336,10 +372,12 @@ int32_t taosThreadEqual(TdThread t1, TdThread t2) {
 }
 
 void taosThreadExit(void *valuePtr) { 
-  return pthread_exit(valuePtr); 
+  if(valuePtr) return pthread_exit(valuePtr); 
 }
 
 int32_t taosThreadGetSchedParam(TdThread thread, int32_t *policy, struct sched_param *param) {
+  OS_PARAM_CHECK(policy);
+  OS_PARAM_CHECK(param);
   int32_t code = pthread_getschedparam(thread, policy, param);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -362,6 +400,7 @@ int32_t taosThreadJoin(TdThread thread, void **valuePtr) {
 }
 
 int32_t taosThreadKeyCreate(TdThreadKey *key, void (*destructor)(void *)) {
+  OS_PARAM_CHECK(key);
   int32_t code = pthread_key_create(key, destructor);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -393,6 +432,7 @@ int32_t taosThreadKill(TdThread thread, int32_t sig) {
 // }
 
 int32_t taosThreadMutexDestroy(TdThreadMutex *mutex) {
+  OS_PARAM_CHECK(mutex);
 #ifdef __USE_WIN_THREAD
   DeleteCriticalSection(mutex);
   return 0;
@@ -407,6 +447,7 @@ int32_t taosThreadMutexDestroy(TdThreadMutex *mutex) {
 }
 
 int32_t taosThreadMutexInit(TdThreadMutex *mutex, const TdThreadMutexAttr *attr) {
+  OS_PARAM_CHECK(mutex);
 #ifdef __USE_WIN_THREAD
   /**
    * Windows Server 2003 and Windows XP:  In low memory situations, InitializeCriticalSection can raise a
@@ -426,6 +467,7 @@ int32_t taosThreadMutexInit(TdThreadMutex *mutex, const TdThreadMutexAttr *attr)
 }
 
 int32_t taosThreadMutexLock(TdThreadMutex *mutex) {
+  OS_PARAM_CHECK(mutex);
 #ifdef __USE_WIN_THREAD
   EnterCriticalSection(mutex);
   return 0;
@@ -444,6 +486,7 @@ int32_t taosThreadMutexLock(TdThreadMutex *mutex) {
 // }
 
 int32_t taosThreadMutexTryLock(TdThreadMutex *mutex) {
+  OS_PARAM_CHECK(mutex);
 #ifdef __USE_WIN_THREAD
   if (TryEnterCriticalSection(mutex)) return 0;
   return EBUSY;
@@ -457,6 +500,7 @@ int32_t taosThreadMutexTryLock(TdThreadMutex *mutex) {
 }
 
 int32_t taosThreadMutexUnlock(TdThreadMutex *mutex) {
+  OS_PARAM_CHECK(mutex);
 #ifdef __USE_WIN_THREAD
   LeaveCriticalSection(mutex);
   return 0;
@@ -474,6 +518,7 @@ int32_t taosThreadMutexAttrDestroy(TdThreadMutexAttr *attr) {
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_mutexattr_destroy(attr);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -484,10 +529,12 @@ int32_t taosThreadMutexAttrDestroy(TdThreadMutexAttr *attr) {
 }
 
 int32_t taosThreadMutexAttrGetPshared(const TdThreadMutexAttr *attr, int32_t *pshared) {
+  OS_PARAM_CHECK(pshared);
 #ifdef __USE_WIN_THREAD
   if (pshared) *pshared = PTHREAD_PROCESS_PRIVATE;
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_mutexattr_getpshared(attr, pshared);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -502,10 +549,12 @@ int32_t taosThreadMutexAttrGetPshared(const TdThreadMutexAttr *attr, int32_t *ps
 // }
 
 int32_t taosThreadMutexAttrGetType(const TdThreadMutexAttr *attr, int32_t *kind) {
+  OS_PARAM_CHECK(kind);
 #ifdef __USE_WIN_THREAD
   if (kind) *kind = PTHREAD_MUTEX_NORMAL;
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_mutexattr_gettype(attr, kind);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -519,6 +568,7 @@ int32_t taosThreadMutexAttrInit(TdThreadMutexAttr *attr) {
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_mutexattr_init(attr);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -532,6 +582,7 @@ int32_t taosThreadMutexAttrSetPshared(TdThreadMutexAttr *attr, int32_t pshared)
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_mutexattr_setpshared(attr, pshared);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -549,6 +600,7 @@ int32_t taosThreadMutexAttrSetType(TdThreadMutexAttr *attr, int32_t kind) {
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_mutexattr_settype(attr, kind);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -574,6 +626,7 @@ int32_t taosThreadRwlockDestroy(TdThreadRwlock *rwlock) {
    */
   return 0;
 #else
+    OS_PARAM_CHECK(rwlock);
   int32_t code = pthread_rwlock_destroy(rwlock);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -584,6 +637,7 @@ int32_t taosThreadRwlockDestroy(TdThreadRwlock *rwlock) {
 }
 
 int32_t taosThreadRwlockInit(TdThreadRwlock *rwlock, const TdThreadRwlockAttr *attr) {
+  OS_PARAM_CHECK(rwlock);
 #ifdef __USE_WIN_THREAD
   memset(rwlock, 0, sizeof(*rwlock));
   InitializeSRWLock(&rwlock->lock);
@@ -599,6 +653,7 @@ int32_t taosThreadRwlockInit(TdThreadRwlock *rwlock, const TdThreadRwlockAttr *a
 }
 
 int32_t taosThreadRwlockRdlock(TdThreadRwlock *rwlock) {
+  OS_PARAM_CHECK(rwlock);
 #ifdef __USE_WIN_THREAD
   AcquireSRWLockShared(&rwlock->lock);
   return 0;
@@ -621,6 +676,7 @@ int32_t taosThreadRwlockRdlock(TdThreadRwlock *rwlock) {
 // }
 
 int32_t taosThreadRwlockTryRdlock(TdThreadRwlock *rwlock) {
+  OS_PARAM_CHECK(rwlock);
 #ifdef __USE_WIN_THREAD
   if (!TryAcquireSRWLockShared(&rwlock->lock)) return EBUSY;
   return 0;
@@ -635,6 +691,7 @@ int32_t taosThreadRwlockTryRdlock(TdThreadRwlock *rwlock) {
 }
 
 int32_t taosThreadRwlockTryWrlock(TdThreadRwlock *rwlock) {
+  OS_PARAM_CHECK(rwlock);
 #ifdef __USE_WIN_THREAD
   if (!TryAcquireSRWLockExclusive(&rwlock->lock)) return EBUSY;
   atomic_store_8(&rwlock->excl, 1);
@@ -650,6 +707,7 @@ int32_t taosThreadRwlockTryWrlock(TdThreadRwlock *rwlock) {
 }
 
 int32_t taosThreadRwlockUnlock(TdThreadRwlock *rwlock) {
+  OS_PARAM_CHECK(rwlock);
 #ifdef __USE_WIN_THREAD
   if (1 == atomic_val_compare_exchange_8(&rwlock->excl, 1, 0)) {
     ReleaseSRWLockExclusive(&rwlock->lock);
@@ -668,6 +726,7 @@ int32_t taosThreadRwlockUnlock(TdThreadRwlock *rwlock) {
 }
 
 int32_t taosThreadRwlockWrlock(TdThreadRwlock *rwlock) {
+  OS_PARAM_CHECK(rwlock);
 #ifdef __USE_WIN_THREAD
   AcquireSRWLockExclusive(&rwlock->lock);
   atomic_store_8(&rwlock->excl, 1);
@@ -686,6 +745,7 @@ int32_t taosThreadRwlockAttrDestroy(TdThreadRwlockAttr *attr) {
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_rwlockattr_destroy(attr);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -696,6 +756,7 @@ int32_t taosThreadRwlockAttrDestroy(TdThreadRwlockAttr *attr) {
 }
 
 int32_t taosThreadRwlockAttrGetPshared(const TdThreadRwlockAttr *attr, int32_t *pshared) {
+  OS_PARAM_CHECK(pshared);
 #ifdef __USE_WIN_THREAD
   if (pshared) *pshared = PTHREAD_PROCESS_PRIVATE;
   return 0;
@@ -713,6 +774,7 @@ int32_t taosThreadRwlockAttrInit(TdThreadRwlockAttr *attr) {
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_rwlockattr_init(attr);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -726,6 +788,7 @@ int32_t taosThreadRwlockAttrSetPshared(TdThreadRwlockAttr *attr, int32_t pshared
 #ifdef __USE_WIN_THREAD
   return 0;
 #else
+  OS_PARAM_CHECK(attr);
   int32_t code = pthread_rwlockattr_setpshared(attr, pshared);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -756,6 +819,7 @@ int32_t taosThreadSetCancelType(int32_t type, int32_t *oldtype) {
 }
 
 int32_t taosThreadSetSchedParam(TdThread thread, int32_t policy, const struct sched_param *param) {
+  OS_PARAM_CHECK(param);
   int32_t code = pthread_setschedparam(thread, policy, param);
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -765,6 +829,7 @@ int32_t taosThreadSetSchedParam(TdThread thread, int32_t policy, const struct sc
 }
 
 int32_t taosThreadSetSpecific(TdThreadKey key, const void *value) { 
+  OS_PARAM_CHECK(value);
   int32_t code = pthread_setspecific(key, value); 
   if (code) {
     terrno = TAOS_SYSTEM_ERROR(code);
@@ -774,6 +839,7 @@ int32_t taosThreadSetSpecific(TdThreadKey key, const void *value) {
 }
 
 int32_t taosThreadSpinDestroy(TdThreadSpinlock *lock) {
+  OS_PARAM_CHECK(lock);
 #ifdef TD_USE_SPINLOCK_AS_MUTEX
   return pthread_mutex_destroy((pthread_mutex_t *)lock);
 #else
@@ -787,6 +853,7 @@ int32_t taosThreadSpinDestroy(TdThreadSpinlock *lock) {
 }
 
 int32_t taosThreadSpinInit(TdThreadSpinlock *lock, int32_t pshared) {
+  OS_PARAM_CHECK(lock);
 #ifdef TD_USE_SPINLOCK_AS_MUTEX
   if (pshared != 0) return TSDB_CODE_INVALID_PARA;
   return pthread_mutex_init((pthread_mutex_t *)lock, NULL);
@@ -801,6 +868,7 @@ int32_t taosThreadSpinInit(TdThreadSpinlock *lock, int32_t pshared) {
 }
 
 int32_t taosThreadSpinLock(TdThreadSpinlock *lock) {
+  OS_PARAM_CHECK(lock);
 #ifdef TD_USE_SPINLOCK_AS_MUTEX
   return pthread_mutex_lock((pthread_mutex_t *)lock);
 #else
@@ -814,6 +882,7 @@ int32_t taosThreadSpinLock(TdThreadSpinlock *lock) {
 }
 
 int32_t taosThreadSpinTrylock(TdThreadSpinlock *lock) {
+  OS_PARAM_CHECK(lock);
 #ifdef TD_USE_SPINLOCK_AS_MUTEX
   return pthread_mutex_trylock((pthread_mutex_t *)lock);
 #else
@@ -826,6 +895,7 @@ int32_t taosThreadSpinTrylock(TdThreadSpinlock *lock) {
 }
 
 int32_t taosThreadSpinUnlock(TdThreadSpinlock *lock) {
+  OS_PARAM_CHECK(lock);
 #ifdef TD_USE_SPINLOCK_AS_MUTEX
   return pthread_mutex_unlock((pthread_mutex_t *)lock);
 #else
@@ -843,6 +913,7 @@ void taosThreadTestCancel(void) {
 }
 
 void taosThreadClear(TdThread *thread) { 
+  if (!thread) return;
   (void)memset(thread, 0, sizeof(TdThread)); 
 }
 

source/util/src/tconfig.c

@@ -25,7 +25,7 @@
 #include "tunit.h"
 #include "tutil.h"
 
-#define CFG_NAME_PRINT_LEN 24
+#define CFG_NAME_PRINT_LEN 32
 #define CFG_SRC_PRINT_LEN  12
 
 struct SConfig {
@@ -881,11 +881,26 @@ void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump) {
       case CFG_DTYPE_CHARSET:
       case CFG_DTYPE_TIMEZONE:
       case CFG_DTYPE_NONE:
+        if (strcasecmp(pItem->name, "dataDir") == 0) {
+          size_t sz = taosArrayGetSize(pItem->array);
+          if (sz > 1) {
+            for (size_t j = 0; j < sz; ++j) {
+              SDiskCfg *pCfg = taosArrayGet(pItem->array, j);
+              if (dump) {
+                (void)printf("%s %s %s l:%d p:%d d:%"PRIi8"\n", src, name, pCfg->dir, pCfg->level, pCfg->primary, pCfg->disable);
+              } else {
+                uInfo("%s %s %s l:%d p:%d d:%"PRIi8, src, name, pCfg->dir, pCfg->level, pCfg->primary, pCfg->disable);
+              }
+            }
+            break;
+          }
+        }
         if (dump) {
           (void)printf("%s %s %s\n", src, name, pItem->str);
         } else {
           uInfo("%s %s %s", src, name, pItem->str);
         }
+
         break;
     }
   }

tests/army/query/function/generate_answer.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+set -e 
+set -x
+# 检查是否传入了两个参数
+# echo "参数个数: $#"
+# if [ "$#" -ne 4 ]; then
+#     echo "使用方法: $0 -i <sqlfile> -o <query_result_file>"
+#     exit 1
+# fi
+
+# 读取传入的参数
+while getopts "i:o:" opt; do
+  case $opt in
+    i)
+      sqlfile="$OPTARG"
+      ;;
+    o)
+      query_result_file="$OPTARG"
+      ;;
+    \?)
+      echo "无效选项: -$OPTARG" >&2
+      exit 1
+      ;;
+    :)
+      echo "选项 -$OPTARG 需要一个参数." >&2
+      exit 1
+      ;;
+  esac
+done
+
+# 删除sqlfile文件中每一行末尾的分号和空格
+sed -i 's/;\s*$//' "$sqlfile"
+
+# 执行SQL文件并生成query_result_file文件
+taos -f "$sqlfile" | grep -v 'Query OK' | grep -v 'Copyright' | grep -v 'Welcome to the TDengine Command' > "$query_result_file"
+# echo  $(cat "$query_result_file")
+# echo "1"
+# sed -i 's/ ([^()]*)$//' "$query_result_file"
+# echo "1"
+# 打印输入的文件名
+echo "输入的文件: $sqlfile"
+
+# 打印输出的文件名
+echo "输出的文件: $query_result_file"

tests/ci/Dockerfile

@@ -7,7 +7,7 @@ RUN apt-get install -y locales psmisc sudo tree  libgeos-dev libgflags2.2 libgfl
 RUN sed -i 's/# en_US.UTF-8/en_US.UTF-8/' /etc/locale.gen  && locale-gen 
 RUN pip3 config set global.index-url http://admin:123456@192.168.0.212:3141/admin/dev/+simple/
 RUN pip3 config set global.trusted-host 192.168.0.212
-RUN pip3 install taospy==2.7.15 taos-ws-py==0.3.1 pandas psutil fabric2 requests faker simplejson toml pexpect tzlocal distro decorator loguru hyperloglog
+RUN pip3 install taospy==2.7.16 taos-ws-py==0.3.3 pandas psutil fabric2 requests faker simplejson toml pexpect tzlocal distro decorator loguru hyperloglog
 ENV LANG=en_US.UTF-8 LANGUAGE=en_US.UTF-8 LC_ALL=en_US.UTF-8
 RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9
 RUN add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu focal-cran40/'

tests/parallel_test/cases.task

@@ -335,6 +335,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 99-TDcase/TS-3311.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 99-TDcase/TS-3821.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 99-TDcase/TS-5130.py
+,,y,system-test,./pytest.sh python3 ./test.py -f 99-TDcase/TS-5580.py
 
 ,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/balance_vgroups_r1.py -N 6
 ,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/taosShell.py
@@ -368,6 +369,7 @@
 ,,n,system-test,python3 ./test.py -f 0-others/tag_index_basic.py
 ,,n,system-test,python3 ./test.py -f 0-others/udfpy_main.py
 ,,n,system-test,python3 ./test.py -N 3 -f 0-others/walRetention.py
+,,n,system-test,python3 ./test.py -f 0-others/wal_level_skip.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/splitVGroup.py -N 3 -n 1
 ,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/splitVGroupWal.py -N 3 -n 1
 ,,y,system-test,./pytest.sh python3 ./test.py -f 0-others/splitVGroup.py -N 3 -n 3

tests/parallel_test/container_build.sh

@@ -83,7 +83,7 @@ docker run \
     -v ${REP_REAL_PATH}/community/contrib/xml2/:${REP_DIR}/community/contrib/xml2 \
     -v ${REP_REAL_PATH}/community/contrib/zlib/:${REP_DIR}/community/contrib/zlib \
     -v ${REP_REAL_PATH}/community/contrib/zstd/:${REP_DIR}/community/contrib/zstd \
-    --rm --ulimit core=-1 taos_test:v1.0 sh -c "pip uninstall taospy -y;pip3 install taospy==2.7.2;cd $REP_DIR;rm -rf debug;mkdir -p debug;cd debug;cmake .. -DBUILD_HTTP=false -DBUILD_TOOLS=true -DBUILD_TEST=true -DWEBSOCKET=true -DBUILD_TAOSX=false -DJEMALLOC_ENABLED=0 -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ;make -j|| exit 1"
+    --rm --ulimit core=-1 taos_test:v1.0 sh -c "cd $REP_DIR;rm -rf debug;mkdir -p debug;cd debug;cmake .. -DBUILD_HTTP=false -DBUILD_TOOLS=true -DBUILD_TEST=true -DWEBSOCKET=true -DBUILD_TAOSX=false -DJEMALLOC_ENABLED=0 -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ;make -j|| exit 1"
  # -v ${REP_REAL_PATH}/community/contrib/jemalloc/:${REP_DIR}/community/contrib/jemalloc \
 
 if [[ -d ${WORKDIR}/debugNoSan  ]] ;then
@@ -137,7 +137,7 @@ docker run \
     -v ${REP_REAL_PATH}/community/contrib/xml2/:${REP_DIR}/community/contrib/xml2 \
     -v ${REP_REAL_PATH}/community/contrib/zlib/:${REP_DIR}/community/contrib/zlib \
     -v ${REP_REAL_PATH}/community/contrib/zstd/:${REP_DIR}/community/contrib/zstd \
-    --rm --ulimit core=-1 taos_test:v1.0 sh -c "pip uninstall taospy -y;pip3 install taospy==2.7.2;cd $REP_DIR;rm -rf debug;mkdir -p debug;cd debug;cmake .. -DBUILD_HTTP=false -DBUILD_TOOLS=true -DBUILD_TEST=false -DWEBSOCKET=true   -DBUILD_SANITIZER=1  -DTOOLS_SANITIZE=true -DCMAKE_BUILD_TYPE=Debug -DTOOLS_BUILD_TYPE=Debug -DBUILD_TAOSX=false -DJEMALLOC_ENABLED=0;make -j|| exit 1 "
+    --rm --ulimit core=-1 taos_test:v1.0 sh -c "cd $REP_DIR;rm -rf debug;mkdir -p debug;cd debug;cmake .. -DBUILD_HTTP=false -DBUILD_TOOLS=true -DBUILD_TEST=false -DWEBSOCKET=true   -DBUILD_SANITIZER=1  -DTOOLS_SANITIZE=true -DCMAKE_BUILD_TYPE=Debug -DTOOLS_BUILD_TYPE=Debug -DBUILD_TAOSX=false -DJEMALLOC_ENABLED=0;make -j|| exit 1 "
 
 mv  ${REP_REAL_PATH}/debug  ${WORKDIR}/debugSan
 

tests/parallel_test/run_case.sh

@@ -76,16 +76,9 @@ ulimit -c unlimited
 md5sum /usr/lib/libtaos.so.1
 md5sum /home/TDinternal/debug/build/lib/libtaos.so
 
-#define taospy 2.7.16
+#get python connector and update: taospy 2.7.16 taos-ws-py 0.3.3
-pip3 list|grep taospy
+pip3 install taospy==2.7.16 
-pip3 uninstall taospy -y
+pip3 install taos-ws-py==0.3.3
-pip3 install --default-timeout=120 taospy==2.7.16
-
-#define taos-ws-py 0.3.1
-pip3 list|grep taos-ws-py
-pip3 uninstall taos-ws-py -y
-pip3 install --default-timeout=600 taos-ws-py==0.3.3
-
 $TIMEOUT_CMD $cmd
 RET=$?
 echo "cmd exit code: $RET"

tests/pytest/util/dnodes.py

@@ -594,8 +594,7 @@ class TDDnode:
 
     def forcestop(self):
         if self.asan:
-            stopCmd = "%s -s stop -n dnode%d -x SIGKILL" + \
+            stopCmd = "%s -s stop -n dnode%d -x SIGKILL" % (self.execPath, self.index)
-                (self.execPath, self.index)
             tdLog.info("execute script: " + stopCmd)
             os.system(stopCmd)
             return

tests/system-test/0-others/information_schema.py

@@ -222,7 +222,7 @@ class TDTestCase:
 
         tdSql.query("select * from information_schema.ins_columns where db_name ='information_schema'")
         tdLog.info(len(tdSql.queryResult))
-        tdSql.checkEqual(True, len(tdSql.queryResult) in range(281, 282))
+        tdSql.checkEqual(True, len(tdSql.queryResult) in range(282, 283))
 
         tdSql.query("select * from information_schema.ins_columns where db_name ='performance_schema'")
         tdSql.checkEqual(56, len(tdSql.queryResult))

tests/system-test/0-others/wal_level_skip.py

@@ -0,0 +1,170 @@
+import sys
+import taos
+import os
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+class TDTestCase:
+
+    def init(self, conn, logSql,replicaVar=1):
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor())
+
+    def getBuildPath(self):
+        selfPath = os.path.dirname(os.path.realpath(__file__))
+
+        if ("community" in selfPath):
+            projPath = selfPath[:selfPath.find("community")]
+        else:
+            projPath = selfPath[:selfPath.find("tests")]
+
+        for root, dirs, files in os.walk(projPath):
+            if ("taosd" in files or "taosd.exe" in files):
+                rootRealPath = os.path.dirname(os.path.realpath(root))
+                if ("packaging" not in rootRealPath):
+                    buildPath = root[:len(root) - len("/build/bin")]
+                    break
+        return buildPath
+
+    def preData(self):
+        tdSql.execute("drop database if exists db0;")
+        tdSql.execute("create database db0 KEEP 30 vgroups 1 buffer 3 wal_level 0;")
+        tdSql.execute("create table if not exists db0.stb (ts timestamp, c1 int, c2 float, c3 double) tags (t1 int unsigned);")
+        tdSql.execute("create table db0.ct1 using db0.stb tags(1000);")
+        tdSql.execute("create table db0.ct2 using db0.stb tags(2000);")
+        tdSql.execute("create table if not exists db0.ntb (ts timestamp, c1 int, c2 float, c3 double) ;")
+        tdSql.query("show db0.stables;")
+        tdSql.execute("insert into db0.ct1 values(now+0s, 10, 2.0, 3.0);")
+        tdSql.execute("insert into db0.ct1 values(now+1s, 11, 2.1, 3.1)(now+2s, 12, 2.2, 3.2)(now+3s, 13, 2.3, 3.3);")
+        tdSql.execute("insert into db0.ntb values(now+2s, 10, 2.0, 3.0);")
+
+    def insertData(self):
+        tdSql.execute("insert into db0.ct1 values(now+0s, 10, 2.0, 3.0);")
+        tdSql.execute("insert into db0.ct1 values(now+1s, 11, 2.1, 3.1)(now+2s, 12, 2.2, 3.2)(now+3s, 13, 2.3, 3.3);")
+        tdSql.execute("insert into db0.ntb values(now+2s, 10, 2.0, 3.0);")
+
+    def createSubTableAndInsertData(self):
+        tdSql.execute("create table db0.ct1 using db0.stb tags(1000);")
+        tdSql.execute("create table db0.ct2 using db0.stb tags(2000);")
+        tdSql.execute("create table if not exists db0.ntb (ts timestamp, c1 int, c2 float, c3 double) ;")
+        tdSql.execute("insert into db0.ct1 values(now+0s, 10, 2.0, 3.0);")
+        tdSql.execute("insert into db0.ct1 values(now+1s, 11, 2.1, 3.1)(now+2s, 12, 2.2, 3.2)(now+3s, 13, 2.3, 3.3);")
+        tdSql.execute("insert into db0.ntb values(now+2s, 10, 2.0, 3.0);")
+
+
+    def alterWalLevel(self,level):
+        tdSql.execute("alter database db0 wal_level %d;"%level)
+
+    def run(self):  
+        tdSql.prepare()
+
+        tdLog.info("-----------test for stop taosd before alter wal level-----------")
+        tdLog.info("create database wal_level = 0 and insert data")
+        self.preData()
+        tdDnodes.stop(1)
+        time.sleep(2)
+        tdLog.info("restart taosd")
+        tdDnodes.start(1)
+
+        tdLog.info(" alter wal level from 0 to 1")
+        self.alterWalLevel(1)
+        self.insertData()
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+
+        tdLog.info("create database wal_level = 0 and insert data")
+        self.preData()
+        tdDnodes.stop(1)
+        time.sleep(2)
+        tdLog.info("restart taosd")
+        tdDnodes.start(1)
+
+        tdLog.info(" alter wal level from 0 to 2")
+        self.alterWalLevel(2)
+        self.insertData()
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+
+
+        tdLog.info("-----------test for kill taosd before alter wal level-----------")
+        tdLog.info("create database wal_level = 0 and insert data")
+        self.preData()
+        tdDnodes.forcestop(1)
+        time.sleep(2)
+        tdLog.info("restart taosd")
+        tdDnodes.start(1)
+
+        tdLog.info(" alter wal level from 0 to 1")
+        self.alterWalLevel(1)
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+
+        tdLog.info("create database wal_level = 0 and insert data")
+        self.preData()
+        tdDnodes.forcestop(1)
+        time.sleep(2)
+        tdLog.info("restart taosd")
+        tdDnodes.start(1)
+
+        tdLog.info(" alter wal level from 0 to 2")
+        self.alterWalLevel(2)
+        tdDnodes.forcestop(1)
+        tdDnodes.start(1)
+
+        tdLog.info("-----------test for stop taosd after alter wal level-----------")
+        tdLog.info("create database wal_level = 0 and insert data")
+        self.preData()
+        tdLog.info(" alter wal level from 0 to 1")
+        self.alterWalLevel(1)
+        time.sleep(1)
+        self.insertData()
+        tdDnodes.stop(1)
+        time.sleep(2)
+        tdLog.info("restart taosd")
+        tdDnodes.start(1)
+
+
+        tdLog.info("create database wal_level = 0 and insert data")
+        self.preData()
+        tdLog.info(" alter wal level from 0 to 2")
+        self.alterWalLevel(2)
+        time.sleep(1)
+        self.insertData()
+        tdDnodes.stop(1)
+        time.sleep(2)
+        tdLog.info("restart taosd")
+        tdDnodes.start(1)
+
+        tdLog.info("-----------test for kill taosd after alter wal level-----------")
+        tdLog.info("create database wal_level = 0 and insert data")
+        self.preData()
+        tdLog.info(" alter wal level from 0 to 1")
+        self.alterWalLevel(1)
+        time.sleep(1)
+        self.insertData()
+        tdDnodes.forcestop(1)
+        time.sleep(2)
+        tdLog.info("restart taosd")
+        tdDnodes.start(1)
+
+
+        tdLog.info("create database wal_level = 0 and insert data")
+        self.preData()
+        tdLog.info(" alter wal level from 0 to 2")
+        self.alterWalLevel(2)
+        time.sleep(1)
+        self.insertData()
+        tdDnodes.forcestop(1)
+        time.sleep(2)
+        tdLog.info("restart taosd")
+        tdDnodes.start(1)
+
+        
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())

tests/system-test/2-query/agg_group_NotReturnValue.py

@@ -1590,11 +1590,9 @@ class TDTestCase(TDTestCase):
         self.modify_tables()
         tdSql.execute('alter local "countAlwaysReturnValue" "0"')
                
-        for i in range(2):
+        self.tag_count_all()
-            self.tag_count_all() 
+        self.tbname_count_all()
-            self.tbname_count_all()  
+        self.tbname_agg_all()
-            self.tbname_agg_all()   
-        
 
         endTime = time.time()
         print("total time %ds" % (endTime - startTime))

tests/system-test/2-query/union.py

@@ -369,8 +369,46 @@ class TDTestCase:
             '''
         )
 
+    def test_TS_5630(self):
+        sql = "CREATE DATABASE `ep_iot` BUFFER 256 CACHESIZE 20 CACHEMODEL 'both' COMP 2 DURATION 14400m WAL_FSYNC_PERIOD 3000 MAXROWS 4096 MINROWS 100 STT_TRIGGER 2 KEEP 5256000m,5256000m,5256000m PAGES 256 PAGESIZE 4 PRECISION 'ms' REPLICA 1 WAL_LEVEL 1 VGROUPS 3 SINGLE_STABLE 0 TABLE_PREFIX 0 TABLE_SUFFIX 0 TSDB_PAGESIZE 4 WAL_RETENTION_PERIOD 3600 WAL_RETENTION_SIZE 0"
+        tdSql.execute(sql, queryTimes=1)
+        tdLog.info("database ep_iot created")
+        sql = "CREATE STABLE `ep_iot`.`sldc_dp` (`ts` TIMESTAMP, `data_write_time` TIMESTAMP, `jz1fdgl` DOUBLE, `jz1ssfdfh` DOUBLE, `jz1fdmh` DOUBLE, `jz1gdmh` DOUBLE, `jz1qjrhl` DOUBLE, `jz1zhcydl` DOUBLE, `jz1zkby` DOUBLE, `jz1zzqyl` DOUBLE, `jz1zzqwda` DOUBLE, `jz1zzqwdb` DOUBLE, `jz1zzqll` DOUBLE, `jz1gswd` DOUBLE, `jz1gsll` DOUBLE, `jz1glxl` DOUBLE, `jz1qjrh` DOUBLE, `jz1zhrxl` DOUBLE, `jz1gmjassllfk` DOUBLE, `jz1gmjasslllj` DOUBLE, `jz1gmjbssllfk` DOUBLE, `jz1gmjbsslllj` DOUBLE, `jz1gmjcssllfk` DOUBLE, `jz1gmjcsslllj` DOUBLE, `jz1gmjdssllfk` DOUBLE, `jz1gmjdsslllj` DOUBLE, `jz1gmjessllfk` DOUBLE, `jz1gmjesslllj` DOUBLE, `jz1gmjfssllfk` DOUBLE, `jz1gmjfsslllj` DOUBLE, `jz1zrqwda` DOUBLE, `jz1zrqwdb` DOUBLE, `jz1zrzqyl` DOUBLE, `jz1mmjadl` DOUBLE, `jz1mmjbdl` DOUBLE, `jz1mmjcdl` DOUBLE, `jz1mmjddl` DOUBLE, `jz1mmjedl` DOUBLE, `jz1mmjfdl` DOUBLE, `jz1cyqckwda` DOUBLE, `jz1cyqckwdb` DOUBLE, `jz1njswd` DOUBLE, `jz1nqqxhsckawd` DOUBLE, `jz1nqqxhsckbwd` DOUBLE, `jz1nqqxhsrkawd` DOUBLE, `jz1nqqxhsrkbwd` DOUBLE, `jz1kyqackyqwdsel` DOUBLE, `jz1kyqbckyqwdsel` DOUBLE, `jz1yfjackyqwd` DOUBLE, `jz1yfjbckyqwd` DOUBLE, `jz1trkyqwd` DOUBLE, `jz1trkyqwd1` DOUBLE, `jz1trkyqwd2` DOUBLE, `jz1trkyqwd3` DOUBLE, `jz1tckjyqwd1` DOUBLE, `jz1tckjyqwd2` DOUBLE, `jz1tckyqwd1` DOUBLE, `jz1bya` DOUBLE, `jz1byb` DOUBLE, `jz1pqwda` DOUBLE, `jz1pqwdb` DOUBLE, `jz1gmjadl` DOUBLE, `jz1gmjbdl` DOUBLE, `jz1gmjcdl` DOUBLE, `jz1gmjddl` DOUBLE, `jz1gmjedl` DOUBLE, `jz1gmjfdl` DOUBLE, `jz1yfjadl` DOUBLE, `jz1yfjbdl` DOUBLE, `jz1ycfjadl` DOUBLE, `jz1ycfjbdl` DOUBLE, `jz1sfjadl` DOUBLE, `jz1sfjbdl` DOUBLE, `jz1fdjyggl` DOUBLE, `jz1fdjwggl` DOUBLE, `jz1sjzs` DOUBLE, `jz1zfl` DOUBLE, `jz1ltyl` DOUBLE, `jz1smb` DOUBLE, `jz1rll` DOUBLE, `jz1grd` DOUBLE, `jz1zjwd` DOUBLE, `jz1yl` DOUBLE, `jz1kyqckwd` DOUBLE, `jz1abmfsybrkcy` DOUBLE, `jz1bbmfsybrkcy` DOUBLE, `jz1abjcsdmfytwdzdz` DOUBLE, `jz1bbjcsdmfytwdzdz` DOUBLE, `jz2fdgl` DOUBLE, `jz2ssfdfh` DOUBLE, `jz2fdmh` DOUBLE, `jz2gdmh` DOUBLE, `jz2qjrhl` DOUBLE, `jz2zhcydl` DOUBLE, `jz2zkby` DOUBLE, `jz2zzqyl` DOUBLE, `jz2zzqwda` DOUBLE, `jz2zzqwdb` DOUBLE, `jz2zzqll` DOUBLE, `jz2gswd` DOUBLE, `jz2gsll` DOUBLE, `jz2glxl` DOUBLE, `jz2qjrh` DOUBLE, `jz2zhrxl` DOUBLE, `jz2gmjassllfk` DOUBLE, `jz2gmjasslllj` DOUBLE, `jz2gmjbssllfk` DOUBLE, `jz2gmjbsslllj` DOUBLE, `jz2gmjcssllfk` DOUBLE, `jz2gmjcsslllj` DOUBLE, `jz2gmjdssllfk` DOUBLE, `jz2gmjdsslllj` DOUBLE, `jz2gmjessllfk` DOUBLE, `jz2gmjesslllj` DOUBLE, `jz2gmjfssllfk` DOUBLE, `jz2gmjfsslllj` DOUBLE, `jz2zrqwda` DOUBLE, `jz2zrqwdb` DOUBLE, `jz2zrzqyl` DOUBLE, `jz2mmjadl` DOUBLE, `jz2mmjbdl` DOUBLE, `jz2mmjcdl` DOUBLE, `jz2mmjddl` DOUBLE, `jz2mmjedl` DOUBLE, `jz2mmjfdl` DOUBLE, `jz2cyqckwda` DOUBLE, `jz2cyqckwdb` DOUBLE, `jz2njswd` DOUBLE, `jz2nqqxhsckawd` DOUBLE, `jz2nqqxhsckbwd` DOUBLE, `jz2nqqxhsrkawd` DOUBLE, `jz2nqqxhsrkbwd` DOUBLE, `jz2kyqackyqwdsel` DOUBLE, `jz2kyqbckyqwdsel` DOUBLE, `jz2yfjackyqwd` DOUBLE, `jz2yfjbckyqwd` DOUBLE, `jz2trkyqwd` DOUBLE, `jz2trkyqwd1` DOUBLE, `jz2trkyqwd2` DOUBLE, `jz2trkyqwd3` DOUBLE, `jz2tckjyqwd1` DOUBLE, `jz2tckjyqwd2` DOUBLE, `jz2tckyqwd1` DOUBLE, `jz2bya` DOUBLE, `jz2byb` DOUBLE, `jz2pqwda` DOUBLE, `jz2pqwdb` DOUBLE, `jz2gmjadl` DOUBLE, `jz2gmjbdl` DOUBLE, `jz2gmjcdl` DOUBLE, `jz2gmjddl` DOUBLE, `jz2gmjedl` DOUBLE, `jz2gmjfdl` DOUBLE, `jz2yfjadl` DOUBLE, `jz2yfjbdl` DOUBLE, `jz2ycfjadl` DOUBLE, `jz2ycfjbdl` DOUBLE, `jz2sfjadl` DOUBLE, `jz2sfjbdl` DOUBLE, `jz2fdjyggl` DOUBLE, `jz2fdjwggl` DOUBLE, `jz2sjzs` DOUBLE, `jz2zfl` DOUBLE, `jz2ltyl` DOUBLE, `jz2smb` DOUBLE, `jz2rll` DOUBLE, `jz2grd` DOUBLE, `jz2zjwd` DOUBLE, `jz2yl` DOUBLE, `jz2kyqckwd` DOUBLE, `jz2abmfsybrkcy` DOUBLE, `jz2bbmfsybrkcy` DOUBLE, `jz2abjcsdmfytwdzdz` DOUBLE, `jz2bbjcsdmfytwdzdz` DOUBLE) TAGS (`iot_hub_id` VARCHAR(100), `device_group_code` VARCHAR(100), `device_code` VARCHAR(100))"
+        tdLog.info("stable ep_iot.sldc_dp created")
+        tdSql.execute(sql, queryTimes=1)
+        sql = "insert into ep_iot.sldc_dp_t1 using ep_iot.sldc_dp tags('a','a','a') values(now, now, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9,0,1);"
+        tdSql.execute(sql, queryTimes=1)
+        sql = "insert into ep_iot.sldc_dp_t1 using ep_iot.sldc_dp tags('b','b','b') values(now, now, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9,0,1);"
+        tdSql.execute(sql, queryTimes=1)
+        sql = "insert into ep_iot.sldc_dp_t1 using ep_iot.sldc_dp tags('c','c','c') values(now, now, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9,0,1);"
+        tdSql.execute(sql, queryTimes=1)
+        sql = "insert into ep_iot.sldc_dp_t1 using ep_iot.sldc_dp tags('d','d','d') values(now, now, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9,0,1);"
+        tdSql.execute(sql, queryTimes=1)
+        sql = "insert into ep_iot.sldc_dp_t1 using ep_iot.sldc_dp tags('e','e','e') values(now, now, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9, 0,1,2,3,4,5,6,7,8,9,0,1);"
+        tdSql.execute(sql, queryTimes=1)
+        sql = "select scdw_code, scdw_name, jzmc, fdgl, jzzt from ((select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组1' as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组2' as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp)) where scdw_code like '%%';"
+        tdSql.query(sql, queryTimes=1)
+        tdSql.checkCols(5)
+        tdSql.checkRows(6)
+
+        sql = "select scdw_name, scdw_code, jzmc, fdgl, jzzt from ((select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组1' as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组2' as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp)) where scdw_code like '%%';"
+        tdSql.query(sql, queryTimes=1)
+        tdSql.checkCols(5)
+        tdSql.checkRows(6)
+        sql = "select scdw_name, scdw_code, jzzt from ((select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组1' as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组2' as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp)) where scdw_code like '%%';"
+        tdSql.query(sql, queryTimes=1)
+        tdSql.checkRows(6)
+        tdSql.checkCols(3)
+
+        sql = "select scdw_code, scdw_name, jzmc, fdgl, jzzt,ts from ((select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组1' as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01072016' as scdw_code, '盛鲁电厂' as scdw_name, '机组2' as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '00103673' as scdw_code, '鲁西电厂' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt, last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组1'as jzmc, last(jz1fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp) union all ( select '01061584' as scdw_code, '富源热电' as scdw_name, '机组2'as jzmc, last(jz2fdjyggl) as fdgl, '填报' as jzzt ,last(ts) as ts from ep_iot.sldc_dp)) where scdw_code like '%%';"
+        tdSql.query(sql, queryTimes=1)
+        tdSql.checkCols(6)
+        tdSql.checkRows(6)
+        ##tdSql.execute("drop database ep_iot")
+
     def run(self):
         tdSql.prepare()
+        self.test_TS_5630()
 
         tdLog.printNoPrefix("==========step1:create table")
         self.__create_tb()

tests/system-test/99-TDcase/TS-5580.py

@@ -0,0 +1,118 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import time
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.common import *
+from util.sqlset import *
+
+class TDTestCase:
+    updatecfgDict = {'qDebugFlag':135 , 'mDebugFlag':135}
+
+    def init(self, conn, logSql, replicaVar=1):
+        self.replicaVar = int(replicaVar)
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), True)
+        self.setsql = TDSetSql()
+        self.dbname = 'db'
+        self.stbname = 'stb'
+        self.binary_length = 20 # the length of binary for column_dict
+        self.nchar_length = 20  # the length of nchar for column_dict
+        self.ts = 1537146000000
+        self.column_dict = {
+            'ts'  : 'timestamp',
+            'col1': 'tinyint',
+            'col2': 'smallint',
+            'col3': 'int',
+            'col4': 'bigint',
+            'col5': 'float',
+            'col6': 'double',
+            'col7': 'double',
+            'col8': 'double',
+            'col9': 'double',
+            'col10': 'double',
+            'col11': 'double',
+            'col12': 'double',
+            'col13': 'double',
+            'col14': 'double',
+            'col15': 'double',
+            'col16': 'double',
+            'col17': 'double',
+            'col18': 'double',
+            'col19': 'double'
+        }
+        self.tbnum = 500
+        self.rowNum = 10
+        self.tag_dict = {
+            't0':'int',
+            't1':'bigint',
+            't2':'float',
+            't3':'double',
+            't4':'bool',
+            't5':'bool',
+            't6':'bool',
+            't7':'bool',
+            't8':'bool',
+            't9':'bool',
+            't10':'bool',
+            't11':'bool',
+            't12':'bool',
+            't13':'bool',
+            't14':'bool',
+            't15':'bool',
+            't16':'bool',
+            't17':'bool',
+            't18':'bool',
+            't19':'bool',
+        }
+        self.tag_values = [
+            f'1','1','1','1','true','true','true','true','true','true','true','true','true','true','true','true','true',
+            'true','true','true'
+        ]
+    def prepare_data(self):
+        tdSql.execute(f"create database if not exists {self.dbname} vgroups 2")
+        tdSql.execute(f'use {self.dbname}')
+        tdSql.execute(self.setsql.set_create_stable_sql(self.stbname,self.column_dict,self.tag_dict))
+        for i in range(self.tbnum):
+            tdSql.execute(f"create table {self.stbname}_{i} using {self.stbname} tags({self.tag_values[0]}, {self.tag_values[1]}, "
+                          f"{self.tag_values[2]}, {self.tag_values[3]}, {self.tag_values[4]}, {self.tag_values[5]}, "
+                          f"{self.tag_values[6]}, {self.tag_values[7]}, {self.tag_values[8]}, {self.tag_values[9]}, "
+                          f"{self.tag_values[10]}, {self.tag_values[11]}, {self.tag_values[12]}, {self.tag_values[13]}, "
+                          f"{self.tag_values[14]}, {self.tag_values[15]}, {self.tag_values[16]}, {self.tag_values[17]}, "
+                          f"{self.tag_values[18]}, {self.tag_values[19]})")
+
+    def test_query_ins_tags(self):
+        for i in range(self.tbnum):
+            sql = f'select tag_name, tag_value from information_schema.ins_tags where table_name = "{self.stbname}_{i}"'
+            tdSql.query(sql)
+            tdSql.checkRows(20)
+
+    def test_query_ins_columns(self):
+        for i in range(self.tbnum):
+            sql = f'select col_name from information_schema.ins_columns where table_name = "{self.stbname}_{i}"'
+            tdSql.query(sql)
+            tdSql.checkRows(20)
+    def run(self):
+        self.prepare_data()
+        self.test_query_ins_tags()
+        self.test_query_ins_columns()
+
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())