Merge branch 'develop' into feature/update

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "src/connector/grafanaplugin"]
 	path = src/connector/grafanaplugin
 	url = https://github.com/taosdata/grafanaplugin
+[submodule "src/connector/hivemq-tdengine-extension"]
+	path = src/connector/hivemq-tdengine-extension
+	url = https://github.com/huskar-t/hivemq-tdengine-extension.git

.lgtm.yml

+##########################################################################################
+# Customize file classifications.                                                        #
+# Results from files under any classifier will be excluded from LGTM                     #
+# statistics.                                                                            #
+##########################################################################################
+
+##########################################################################################
+# Use the `path_classifiers` block to define changes to the default classification of    #
+# files.                                                                                 #
+##########################################################################################
+
+path_classifiers:
+        # docs:
+    # Identify the top-level file called `generate_javadoc.py` as documentation-related.
+  test:
+    # Override LGTM's default classification of test files by excluding all files.
+    - exclude: /
+    # Classify all files in the top-level directories tests/ and testsuites/ as test code.
+    - tests
+      # - testsuites
+    # Classify all files with suffix `.test` as test code.
+    #        Note: use only forward slash / as a path separator.
+    #        Use ** to indicate an arbitrary parent path.
+    #        Use * to indicate any sequence of characters excluding /.
+    #        Always enclose the expression in double quotes if it includes *.
+    # - "**/*.test"
+    # Refine the classifications above by excluding files in test/util/.
+    # - exclude: test/util
+  # The default behavior is to tag all files created during the
+  # build as `generated`. Results are hidden for generated code. You can tag 
+  # further files as being generated by adding them to the `generated` section.
+  generated:
+    # Exclude all `*.c` files under the `ui/` directory from classification as 
+    # generated code.
+    # - exclude: ui/**/*.c
+    # By default, all files not checked into the repository are considered to be
+    # 'generated'.
+  # The default behavior is to tag library code as `library`. Results are hidden 
+  # for library code. You can tag further files as being library code by adding them
+  # to the `library` section.
+  library:
+    - exclude: deps/
+  # The default behavior is to tag template files as `template`. Results are hidden 
+  # for template files. You can tag further files as being template files by adding 
+  # them to the `template` section.
+  template:
+          #- exclude: path/to/template/code/**/*.c
+  # Define your own category, for example: 'some_custom_category'.
+  some_custom_category:
+    # Classify all files in the top-level directory tools/ (or the top-level file 
+    # called tools).
+    # - tools
+
+#########################################################################################
+# Use the `queries` block to change the default display of query results.               #
+#########################################################################################
+
+          # queries:
+  # Start by hiding the results of all queries.
+  #  - exclude: "*"
+  # Then include all queries tagged 'security' and 'correctness', and with a severity of
+  # 'error'.
+  #  - include:           
+  #      tags:
+  #        - "security"
+  #        - "correctness"           
+  #    severity: "error"
+  # Specifically hide the results of two queries.
+  # - exclude: cpp/use-of-goto
+    # - exclude: java/equals-on-unrelated-types
+  # Refine by including the `java/command-line-injection` query.
+  # - include: java/command-line-injection
+
+#########################################################################################
+# Define changes to the default code extraction process.                                #
+# Each block configures the extraction of a single language, and modifies actions in a  #
+# named step. Every named step includes automatic default actions,                      #
+# except for the 'prepare' step. The steps are performed in the following sequence:     #
+# prepare                                                                               #
+# after_prepare                                                                         #
+# configure (C/C++ only)                                                                #
+# python_setup (Python only)                                                            #
+# before_index                                                                          #
+# index                                                                                 #
+##########################################################################################
+
+#########################################################################################
+# Environment variables available to the steps:                                         #
+#########################################################################################
+
+# LGTM_SRC
+#   The root of the source tree.
+# LGTM_WORKSPACE
+#   An existing (initially empty) folder outside the source tree.
+#   Used for temporary download and setup commands.
+
+#########################################################################################
+# Use the extraction block to define changes to the default code extraction process     #
+# for one or more languages. The settings for each language are defined in a child      #
+# block, with one or more steps.                                                        #
+#########################################################################################
+
+extraction: 
+  # Define settings for C/C++ analysis
+  #####################################
+  cpp:
+    # The `prepare` step exists for customization on LGTM.com only.
+    prepare:
+    #   # The `packages` section is valid for LGTM.com only. It names Ubuntu packages to
+    #   # be installed.
+        packages:
+          - cmake
+    # Add an `after-prepare` step if you need to run commands after the prepare step.
+    # Each command should be listed on a separate line.
+    # This step is useful for C/C++ analysis where you want to prepare the environment
+    # for the `configure` step without changing the default behavior for that step. 
+    #    after_prepare:
+            #- export GNU_MAKE=make
+            #- export GIT=true
+    # The `configure` step generates build configuration files which the `index` step
+    # then uses to build the codebase.
+    configure:
+      command:
+        - mkdir build
+        - cd build
+        - cmake ..
+              # - ./prepare_deps
+    # Optional step. You should add a `before_index` step if you need to run commands
+    # before the `index` step.
+    # before_index:
+            # - export BOOST_DIR=$LGTM_SRC/boost
+            # - export GTEST_DIR=$LGTM_SRC/googletest
+            # - export HUNSPELL_DIR=$LGTM_SRC/hunspell
+            # - export CRYPTOPP_DIR=$LGTM_SRC/cryptopp
+    # The `index` step builds the code and extracts information during the build
+    # process.
+    index:
+      # Override the autobuild process by specifying a list of custom build commands
+      # to use instead. 
+      build_command:
+        - cd build
+        - make
+              # - $GNU_MAKE -j2 -s
+      # Specify that all project or solution files should be used for extraction.
+      # Default: false.
+      # all_solutions: true
+      # Specify a list of one or more project or solution files for extraction.
+      # Default: LGTM chooses the file closest to the root of the repository (this may
+      # fail if there are multiple candidates).
+      # solution: 
+      #  - myProject.sln
+      # Specify MSBuild settings
+      # msbuild:
+        # Specify a list of additional arguments to MSBuild. Default: empty.
+        # arguments: /p:Platform=x64 /p:Configuration=Release
+        # Specify the MSBuild configuration to use, for example, debug or release.
+        # Default: read from the solution file or files.
+        # configuration:
+        # Specify the platform to target, for example: x86, x64, or Any CPU.
+        # Default: read from the solution file or files.
+        # platform:
+        # Specify the MSBuild target. Default: rebuild.
+        # target:
+      # Specify whether or not to perform a NuGet restore for extraction. Default: true.
+      # nuget_restore: false
+      # Specify a version of Microsoft Visual Studio to use for MSBuild or any custom
+      # build commands (build_command). For example:
+      #    10 for Visual Studio 2010
+      #    12 for Visual Studio 2012
+      #    14 for Visual Studio 2015
+      #    15 for Visual Studio 2017
+      # Default: read from project files.
+      # vstools_version: 10
+
+  # Define settings for C# analysis
+  ##################################
+  #  csharp:
+    # The `prepare` step exists for customization on LGTM.com only.
+    # prepare:
+    #   packages:
+    #     - example_package
+    # Add an `after-prepare` step if you need to run commands after the `prepare` step.
+    # Each command should be listed on a separate line.
+    #  after_prepare:
+    #  - export PATH=$LGTM_WORKSPACE/tools:$PATH
+    # The `index` step builds the code and extracts information during the build
+    # process.
+    #index:
+      # Specify that all project or solution files should be used for extraction.
+      # Default: false.
+      #  all_solutions: true
+      # Specify a list of one or more project or solution files for extraction.
+      # Default: LGTM chooses the file closest to the root of the repository (this may
+      # fail if there are multiple candidates).
+      # solution: 
+      #  - myProject.sln
+      # Override the autobuild process by specifying a list of custom build commands
+      # to use instead. 
+      # build_command:
+      #  - ./example-compile-all.sh
+      # By default, LGTM analyzes the code by building it. You can override this,
+      # and tell LGTM not to build the code. Beware that this can lead
+      # to less accurate results.
+      # buildless: true
+      # Specify .NET Core settings.
+      # dotnet:
+        # Specify additional arguments to `dotnet build`.
+        # Default: empty.
+        # arguments: "example_arg"
+        # Specify the version of .NET Core SDK to use.
+        # Default: The version installed on the build machine.
+        # version: 2.1
+      # Specify MSBuild settings.
+      # msbuild:
+        # Specify a list of additional arguments to MSBuild. Default: empty.
+        # arguments: /P:WarningLevel=2
+        # Specify the MSBuild configuration to use, for example, debug or release.
+        # Default: read from the solution file or files.
+        # configuration: release
+        # Specify the platform to target, for example: x86, x64, or Any CPU.
+        # Default: read from the solution file or files.
+        # platform: x86
+        # Specify the MSBuild target. Default: rebuild.
+        # target: notest
+      # Specify whether or not to perform a NuGet restore for extraction. Default: true.
+      # nuget_restore: false
+      # Specify a version of Microsoft Visual Studio to use for MSBuild or any custom
+      # build commands (build_command). For example:
+      #    10 for Visual Studio 2010
+      #    12 for Visual Studio 2012
+      #    14 for Visual Studio 2015
+      #    15 for Visual Studio 2017
+      # Default: read from project files
+      # vstools_version: 10
+      # Specify additional options for the extractor,
+      # for example --fast to perform a faster extraction that produces a smaller 
+      # database.
+      # extractor: "--fast"
+
+  # Define settings for Go analysis
+  ##################################
+  #  go:
+    # The `prepare` step exists for customization on LGTM.com only.
+    # prepare:
+    #   packages:
+    #     - example_package
+    # Add an `after-prepare` step if you need to run commands after the `prepare` step.
+    # Each command should be listed on a separate line.
+    # after_prepare:
+    #  - export PATH=$LGTM_WORKSPACE/tools:$PATH
+    # The `index` step builds the code and extracts information during the build
+    # process.
+    # index:
+      # Override the autobuild process by specifying a list of custom build commands
+      # to use instead.
+      # build_command:
+              #  - ./compile-all.sh
+
+  # Define settings for Java analysis
+  ####################################
+  #  java:
+    # The `prepare` step exists for customization on LGTM.com only.
+    # prepare:
+    #   packages:
+    #     - example_package
+    # Add an `after-prepare` step if you need to run commands after the prepare step.
+    # Each command should be listed on a separate line.
+    # after_prepare:
+    # - export PATH=$LGTM_WORKSPACE/tools:$PATH
+    # The `index` step extracts information from the files in the codebase.
+    # index:
+      # Specify Gradle settings.
+      # gradle:
+        # Specify the required Gradle version.
+        # Default: determined automatically.
+        # version: 4.4
+      # Override the autobuild process by specifying a list of custom build commands
+      # to use instead. 
+      # build_command: ./compile-all.sh
+      # Specify the Java version required to build the project.
+      # java_version: 11
+      # Specify whether to extract Java .properties files
+      # Default: false
+      # properties_files: true
+      # Specify Maven settings.
+      # maven:
+        # Specify the path (absolute or relative) of a Maven settings file to use.
+        # Default: Maven uses a settings file in the default location, if it exists.
+        # settings_file: /opt/share/settings.xml
+        # Specify the path of a Maven toolchains file.
+        # Default: Maven uses a toolchains file in the default location, if it exists.
+        # toolchains_file: /opt/share/toolchains.xml
+        # Specify the required Maven version.
+        # Default: the Maven version is determined automatically, where feasible.
+        # version: 3.5.2
+      # Specify how XML files should be extracted:
+      #   all = extract all XML files.
+      #   default = only extract XML files named `AndroidManifest.xml`, `pom.xml`, and `web.xml`.
+      #   disabled = do not extract any XML files.
+      # xml_mode: all
+
+  # Define settings for JavaScript analysis
+  ##########################################
+  # javascript:
+    # The `prepare` step exists for customization on LGTM.com only.
+    # prepare:
+    #   packages:
+    #     - example_package
+    # Add an `after-prepare` step if you need to run commands after the prepare step.
+    # Each command should be listed on a separate line.
+    # after_prepare:
+    # - export PATH=$LGTM_WORKSPACE/tools:$PATH
+    # The `index` step extracts information from the files in the codebase.
+    # index:
+      # Specify a list of files and folders to extract.
+      # Default: The project root directory.
+      # include:
+              # - src/js
+      # Specify a list of files and folders to exclude from extraction.
+      # exclude:
+              # - thirdparty/lib
+      # You can add additional file types for LGTM to extract, by mapping file 
+      # extensions (including the leading dot) to file types. The usual 
+      # include/exclude patterns apply, so, for example, `.jsm` files under
+      # `thirdparty/lib` will not be extracted.
+      # filetypes:
+      # ".jsm": "js"
+      # ".tmpl": "html"
+      # Specify a list of glob patterns to include/exclude files from extraction; this 
+      # is applied on top of the include/exclude paths from above; patterns are 
+      # processed in the same way as for path classifiers above.
+      # Default: include all files with known extensions (such as .js, .ts and .html),
+      # but exclude files ending in `-min.js` or `.min.js` and folders named `node_modules`
+      # or `bower_components`
+      # filters:
+        # exclude any *.ts files anywhere.
+        # - exclude: "**/*.ts"
+        # but include *.ts files under src/js/typescript.
+        # - include: "src/js/typescript/**/*.ts"
+      # Specify how TypeScript files should be extracted:
+      #   none = exclude all TypeScript files.
+      #   basic = extract syntactic information from TypeScript files.
+      #   full = extract syntactic and type information from TypeScript files.
+      # Default: full.
+      # typescript: basic
+      # By default, LGTM doesn't extract any XML files. You can override this by 
+      # using the `xml_mode` property and setting it to `all`.
+      # xml_mode: all
+
+  # Define settings for Python analysis
+  ######################################
+  #  python:
+  #    # The `prepare` step exists for customization on LGTM.com only.
+  #    # prepare:
+  #    #   # The `packages` section is valid for LGTM.com only. It names packages to
+  #    #   # be installed.
+  #    #   packages: libpng-dev
+  #    # This step is useful for Python analysis where you want to prepare the 
+  #    # environment for the `python_setup` step without changing the default behavior 
+  #    # for that step.
+  #    after_prepare:
+  #      - export PATH=$LGTM_WORKSPACE/tools:$PATH
+  #      # This sets up the Python interpreter and virtual environment, ready for the 
+  #      # `index` step to extract the codebase.
+  #    python_setup:
+  #      # Specify packages that should NOT be installed despite being mentioned in the
+  #      # requirements.txt file.
+  #      # Default: no package marked for exclusion.
+  #      exclude_requirements:
+  #        - pywin32
+  #      # Specify a list of pip packages to install.
+  #      # If any of these packages cannot be installed, the extraction will fail.
+  #      requirements:
+  #        - Pillow
+  #      # Specify a list of requirements text files to use to set up the environment,
+  #      # or false for none. Default: any requirements.txt, test-requirements.txt,
+  #      # and similarly named files identified in the codebase are used.
+  #      requirements_files:
+  #        - required-packages.txt
+  #      # Specify a setup.py file to use to set up the environment, or false for none.
+  #      # Default: any setup.py files identified in the codebase are used in preference
+  #      # to any requirements text files.
+  #      setup_py: new-setup.py
+  #      # Override the version of the Python interpreter used for setup and extraction
+  #      # Default: Python 3.
+  #      version: 2
+  #    # Optional step. You should add a `before_index` step if you need to run commands
+  #    # before the `index` step.
+  #    before_index:
+  #      - antlr4 -Dlanguage=Python3 Grammar.g4
+  #    # The `index` step extracts information from the files in the codebase.
+  #    index:
+  #      # Specify a list of files and folders to exclude from extraction.
+  #      # Default: Git submodules and Subversion externals.
+  #      exclude:
+  #        - legacy-implementation
+  #        - thirdparty/libs
+  #      filters:
+  #       - exclude: "**/documentation/examples/snippets/*.py"
+  #       - include: "**/documentation/examples/test_application/*"
+  #      include:
+  #        - example/to/include

.travis.yml

@@ -32,6 +32,8 @@ matrix:
           - python3-setuptools
           - valgrind
           - psmisc
+          - unixodbc
+          - unixodbc-dev
 
     before_script:
       - export TZ=Asia/Harbin
@@ -54,6 +56,7 @@ matrix:
 
           py3ver=`python3 --version|awk '{print $2}'|cut -d "." -f 1,2` && apt install python$py3ver-dev
           pip3 install psutil
+          pip3 install guppy3
           pip3 install --user ${TRAVIS_BUILD_DIR}/src/connector/python/linux/python3/
 
           cd ${TRAVIS_BUILD_DIR}/tests

Jenkinsfile

+pipeline {
+  agent none
+  environment{
+      WK = '/var/lib/jenkins/workspace/TDinternal'
+      WKC= '/var/lib/jenkins/workspace/TDinternal/community'
+  }
+
+  stages {
+      stage('Parallel test stage') {
+      parallel {
+        stage('pytest') {
+          agent{label '184'}
+          steps {
+            sh '''
+            date
+            cd ${WKC}
+            git checkout develop
+            git pull
+            git submodule update
+            cd ${WK}
+            git checkout develop
+            git pull
+            export TZ=Asia/Harbin
+            date
+            rm -rf ${WK}/debug
+            mkdir debug
+            cd debug
+            cmake .. > /dev/null
+            make > /dev/null
+            cd ${WKC}/tests
+            #./test-all.sh smoke
+            ./test-all.sh pytest
+            date'''
+          }
+        }
+        stage('test_b1') {
+          agent{label 'master'}
+          steps {
+            sh '''
+            cd ${WKC}
+            git checkout develop
+            git pull
+              
+            git submodule update
+            cd ${WK}
+            git checkout develop
+            git pull
+            export TZ=Asia/Harbin
+            date
+            rm -rf ${WK}/debug
+            mkdir debug
+            cd debug
+            cmake .. > /dev/null
+            make > /dev/null
+            cd ${WKC}/tests
+            #./test-all.sh smoke
+            ./test-all.sh b1
+            date'''
+          }
+        }
+
+        stage('test_crash_gen') {
+          agent{label "185"}
+          steps {
+            sh '''
+            cd ${WKC}
+            git checkout develop
+            git pull
+              
+            git submodule update
+            cd ${WK}
+            git checkout develop
+            git pull
+            export TZ=Asia/Harbin
+            
+            rm -rf ${WK}/debug
+            mkdir debug
+            cd debug
+            cmake .. > /dev/null
+            make > /dev/null
+            cd ${WKC}/tests/pytest
+            '''
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/pytest
+                ./crash_gen.sh -a -p -t 4 -s 2000
+                '''
+            }
+            sh '''
+            date
+            cd ${WKC}/tests
+            ./test-all.sh b2
+            date
+            '''
+          }
+        }
+
+        stage('test_valgrind') {
+          agent{label "186"}
+
+          steps {
+            sh '''
+            cd ${WKC}
+            git checkout develop
+            git pull
+              
+            git submodule update
+            cd ${WK}
+            git checkout develop
+            git pull
+            export TZ=Asia/Harbin
+            date
+            rm -rf ${WK}/debug
+            mkdir debug
+            cd debug
+            cmake .. > /dev/null
+            make > /dev/null
+            cd ${WKC}/tests/pytest
+            ./valgrind-test.sh 2>&1 > mem-error-out.log
+            ./handle_val_log.sh
+          
+            date
+            cd ${WKC}/tests
+            ./test-all.sh b3
+            date'''
+          }
+        }
+       stage('connector'){
+         agent{label "release"}
+         steps{
+            sh'''
+            cd ${WORKSPACE}
+            git checkout develop
+            cd tests/gotest
+            bash batchtest.sh
+            cd ${WORKSPACE}/tests/examples/JDBC/JDBCDemo/
+            mvn clean package assembly:single >/dev/null 
+            java -jar target/jdbcChecker-SNAPSHOT-jar-with-dependencies.jar -host 127.0.0.1
+            cd ${WORKSPACE}/tests/examples/python/PYTHONConnectorChecker
+            python3 PythonChecker.py
+            '''
+         }
+       }
+
+      }
+    }
+
+  }
+  
+}
\ No newline at end of file

README.md

@@ -83,12 +83,18 @@ sudo dnf install -y maven
 
 ## Get the source codes
 
-- github:
+First of all, you may clone the source codes from github:
 ```bash
 git clone https://github.com/taosdata/TDengine.git
 cd TDengine
 ```
 
+The connectors for go & grafana have been moved to separated repositories,
+so you should run this command in the TDengine directory to install them:
+```bash
+git submodule update --init --recursive
+```
+
 ## Build TDengine
 
 ### On Linux platform

alert/README.md

@@ -61,7 +61,7 @@ The use of each configuration item is:
 
 * **port**: This is the `http` service port which enables other application to manage rules by `restful API`.
 * **database**: rules are stored in a `sqlite` database, this is the path of the database file (if the file does not exist, the alert application creates it automatically).
-* **tdengine**: connection string of `TDEngine` server, note in most cases the database information should be put in a rule, thus it should NOT be included here.
+* **tdengine**: connection string of `TDEngine` server, note the database name should be put in the `sql` field of a rule in most cases, thus it should NOT be included in the string.
 * **log > level**: log level, could be `production` or `debug`.
 * **log > path**: log output file path.
 * **receivers > alertManager**: the alert application pushes alerts to `AlertManager` at this URL.

alert/README_cn.md

@@ -58,7 +58,7 @@ $ go build
 
 * **port**：报警监测程序支持使用 `restful API` 对规则进行管理，这个参数用于配置 `http` 服务的侦听端口。
 * **database**：报警监测程序将规则保存到了一个 `sqlite` 数据库中，这个参数用于指定数据库文件的路径（不需要提前创建这个文件，如果它不存在，程序会自动创建它）。
-* **tdengine**：`TDEngine` 的连接信息，一般来说，数据库信息应该在报警规则中指定，所以这里 **不** 应包含这一部分信息。
+* **tdengine**：`TDEngine` 的连接字符串，一般来说，数据库名应该在报警规则的 `sql` 语句中指定，所以这个字符串中 **不** 应包含数据库名。
 * **log > level**：日志的记录级别，可选 `production` 或 `debug`。
 * **log > path**：日志文件的路径。
 * **receivers > alertManager**：报警监测程序会将报警推送到 `AlertManager`，在这里指定 `AlertManager` 的接收地址。

cmake/define.inc

@@ -48,6 +48,7 @@ ENDIF ()
 IF (TD_LINUX_64)
   ADD_DEFINITIONS(-D_M_X64)
   ADD_DEFINITIONS(-D_TD_LINUX_64)
+  MESSAGE(STATUS "linux64 is defined")
   SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g3 -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
   ADD_DEFINITIONS(-DUSE_LIBICONV)
 ENDIF ()
@@ -55,30 +56,38 @@ ENDIF ()
 IF (TD_LINUX_32)
   ADD_DEFINITIONS(-D_TD_LINUX_32)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g -fsigned-char -munaligned-access -fpack-struct=8 -latomic -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  MESSAGE(STATUS "linux32 is defined")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g -fsigned-char -munaligned-access -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_ARM_64)
   ADD_DEFINITIONS(-D_M_X64)
-  ADD_DEFINITIONS(-D_TD_ARM_64_)
+  ADD_DEFINITIONS(-D_TD_ARM_64)
   ADD_DEFINITIONS(-D_TD_ARM_)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
+  MESSAGE(STATUS "arm64 is defined")
   SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_ARM_32)
-  ADD_DEFINITIONS(-D_TD_ARM_32_)
+  ADD_DEFINITIONS(-D_TD_ARM_32)
   ADD_DEFINITIONS(-D_TD_ARM_)
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  ADD_DEFINITIONS(-DUSE_LIBICONV)
+  MESSAGE(STATUS "arm32 is defined")
+  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast -Wno-incompatible-pointer-types ")
 ENDIF ()
 
 IF (TD_MIPS_64)
   ADD_DEFINITIONS(-D_TD_MIPS_64_)
+  ADD_DEFINITIONS(-DUSE_LIBICONV)
+  MESSAGE(STATUS "mips64 is defined")
   SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g3 -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_MIPS_32)
   ADD_DEFINITIONS(-D_TD_MIPS_32_)
+  ADD_DEFINITIONS(-DUSE_LIBICONV)
+  MESSAGE(STATUS "mips32 is defined")
   SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g3 -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
@@ -86,6 +95,7 @@ IF (TD_APLHINE)
   SET(COMMON_FLAGS "${COMMON_FLAGS} -largp")
   link_libraries(/usr/lib/libargp.a)
   ADD_DEFINITIONS(-D_ALPINE)
+  MESSAGE(STATUS "aplhine is defined")
 ENDIF ()
 
 IF (TD_LINUX)
@@ -95,7 +105,7 @@ IF (TD_LINUX)
   ADD_DEFINITIONS(-D_REENTRANT -D__USE_POSIX -D_LIBC_REENTRANT)
 
   IF (TD_NINGSI_60)
-    ADD_DEFINITIONS(-D_TD_NINGSI_60_)
+    ADD_DEFINITIONS(-D_TD_NINGSI_60)
     MESSAGE(STATUS "set ningsi macro to true")
   ENDIF ()
   
@@ -118,6 +128,7 @@ IF (TD_DARWIN_64)
   ADD_DEFINITIONS(-DDARWIN)
   ADD_DEFINITIONS(-D_REENTRANT -D__USE_POSIX -D_LIBC_REENTRANT)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
+  MESSAGE(STATUS "darwin64 is defined")
   SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -Wno-missing-braces -fPIC -g -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
   SET(DEBUG_FLAGS "-O0 -DDEBUG")
   SET(RELEASE_FLAGS "-O0")
@@ -147,11 +158,13 @@ IF (TD_WINDOWS_64)
   ADD_DEFINITIONS(-D_M_X64)
   ADD_DEFINITIONS(-D_TD_WINDOWS_64)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
+  MESSAGE(STATUS "windows64 is defined")
 ENDIF ()
 
 IF (TD_WINDOWS_32)
   ADD_DEFINITIONS(-D_TD_WINDOWS_32)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
+  MESSAGE(STATUS "windows32 is defined")
 ENDIF ()
 
 INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)

cmake/env.inc

@@ -45,7 +45,7 @@ IF (${CMAKE_BUILD_TYPE} MATCHES "Debug")
 ELSEIF (${CMAKE_BUILD_TYPE} MATCHES "Release")
   MESSAGE(STATUS "Build Release Version")
 ELSE ()
-  IF (TD_WINDOWS_64)
+  IF (TD_WINDOWS)
     SET(CMAKE_BUILD_TYPE "Release")
     MESSAGE(STATUS "Build Release Version in Windows as default")
   ELSE ()

cmake/install.inc

@@ -10,13 +10,13 @@ ELSEIF (TD_WINDOWS)
     SET(CMAKE_INSTALL_PREFIX C:/TDengine)
   ENDIF ()
   
-  IF (NOT TD_GODLL)
-    #INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/go DESTINATION connector)
-    #INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/grafana DESTINATION connector)
+  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/go     DESTINATION connector)
+  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/nodejs DESTINATION connector)
   INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/python DESTINATION connector)
   INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/tests/examples DESTINATION .)
   INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/packaging/cfg DESTINATION .)
   INSTALL(FILES ${TD_COMMUNITY_DIR}/src/inc/taos.h DESTINATION include)
+  INSTALL(FILES ${TD_COMMUNITY_DIR}/src/inc/taoserror.h DESTINATION include)
   INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.lib DESTINATION driver)
   INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.exp DESTINATION driver)
   INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.dll DESTINATION driver) 
@@ -25,16 +25,13 @@ ELSEIF (TD_WINDOWS)
     INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/power.exe DESTINATION .)
   ELSE ()   
     INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)   
+    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taosdemo.exe DESTINATION .)
   ENDIF ()
 
   #INSTALL(TARGETS taos RUNTIME DESTINATION driver)
   #INSTALL(TARGETS shell RUNTIME DESTINATION .)
   IF (TD_MVN_INSTALLED)
-      INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.0-dist.jar DESTINATION connector/jdbc)
-    ENDIF ()
-  ELSE ()
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/libtaos.dll DESTINATION driver)
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/libtaos.dll.a DESTINATION driver)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.8-dist.jar DESTINATION connector/jdbc)
   ENDIF ()
 ELSEIF (TD_DARWIN)
   SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")

cmake/version.inc

@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.0.4.0")
+  SET(TD_VER_NUMBER "2.0.6.0")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)
@@ -42,6 +42,12 @@ IF (DEFINED CPUTYPE)
 ELSE ()
   IF (TD_WINDOWS_32)
     SET(TD_VER_CPUTYPE "x86")
+  ELSEIF (TD_LINUX_32)
+    SET(TD_VER_CPUTYPE "x86")  
+  ELSEIF (TD_ARM_32)
+    SET(TD_VER_CPUTYPE "x86")  
+  ELSEIF (TD_MIPS_32)
+    SET(TD_VER_CPUTYPE "x86")  
   ELSE ()
     SET(TD_VER_CPUTYPE "x64")
   ENDIF ()

deps/zlib-1.2.11/CMakeLists.txt

 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
-IF (TD_LINUX)
-  INCLUDE_DIRECTORIES(inc)
-  AUX_SOURCE_DIRECTORY(src SRC)
-  ADD_LIBRARY(z ${SRC})
-ENDIF ()
\ No newline at end of file
+IF (TD_WINDOWS)
+  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /WX-")
+  SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /WX-")
+ENDIF()
+
+INCLUDE_DIRECTORIES(inc)
+AUX_SOURCE_DIRECTORY(src SRC)
+ADD_LIBRARY(z ${SRC})

deps/zlib-1.2.11/inc/zconf.h

@@ -472,7 +472,7 @@ typedef uint64_t  z_crc_t;
 #endif
 #ifndef Z_SOLO
 #if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
-#if (_WIN64)
+#if defined(_WIN64) || defined(_WIN32)
 #include <io.h>
 #include <process.h>
 #else

deps/zlib-1.2.11/src/zconf.h

@@ -472,7 +472,7 @@ typedef uLong FAR uLongf;
 #endif
 #ifndef Z_SOLO
 #  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
-#if (_WIN64)
+#if defined(_WIN64) || defined(_WIN32)
 #include <io.h>
 #include <process.h>
 #else

documentation/tdenginedocs-cn/advanced-features/index.html

@@ -51,8 +51,8 @@ INTERVAL(1M)</code></pre>
 <li><p>mseconds：查询数据库更新的时间间隔，单位为毫秒。一般设置为1000毫秒。返回值为指向TDengine_SUB 结构的指针，如果返回为空，表示失败。</p></li>
 </ul><li><p><code>TAOS_ROW taos_consume(TAOS_SUB *tsub)</code>
 </p><p>该函数用来获取订阅的结果，用户应用程序将其置于一个无限循环语句。如果数据库有新记录到达，该API将返回该最新的记录。如果没有新的记录，该API将阻塞。如果返回值为空，说明系统出错。参数说明：</p></li><ul><li><p>tsub：taos_subscribe的结构体指针。</p></li></ul><li><p><code>void taos_unsubscribe(TAOS_SUB *tsub)</code></p><p>取消订阅。应用程序退出时，务必调用该函数以避免资源泄露。</p></li>
-<li><p><code>int taos_num_subfields(TAOS_SUB *tsub)</code></p><p>获取返回的一行记录中数据包含多少列。</p></li>
-<li><p><code>TAOS_FIELD *taos_fetch_subfields(TAOS_SUB *tsub)</code></p><p>获取每列数据的属性（数据类型、名字、长度），与taos_num_subfileds配合使用，可解析返回的每行数据。</p></li></ul>
+<li><p><code>int taos_num_fields(TAOS_SUB *tsub)</code></p><p>获取返回的一行记录中数据包含多少列。</p></li>
+<li><p><code>TAOS_FIELD *taos_fetch_fields(TAOS_SUB *tsub)</code></p><p>获取每列数据的属性（数据类型、名字、长度），与taos_num_subfileds配合使用，可解析返回的每行数据。</p></li></ul>
 <p>示例代码：请看安装包中的的示范程序</p>
 <a class='anchor' id='缓存-(Cache)'></a><h2>缓存 (Cache)</h2>
 <p>TDengine采用时间驱动缓存管理策略（First-In-First-Out，FIFO），又称为写驱动的缓存管理机制。这种策略有别于读驱动的数据缓存模式（Least-Recent-Use，LRU），直接将最近写入的数据保存在系统的缓存中。当缓存达到临界值的时候，将最早的数据批量写入磁盘。一般意义上来说，对于物联网数据的使用，用户最为关心最近产生的数据，即当前状态。TDengine充分利用了这一特性，将最近到达的（当前状态）数据保存在缓存中。</p>

documentation/tdenginedocs-cn/connector/index.html

@@ -64,9 +64,9 @@
 <p>该API用来获取最新消息，应用程序一般会将其置于一个无限循环语句中。其中参数tsub是taos_subscribe的返回值。如果数据库有新的记录，该API将返回，返回参数是一行记录。如果没有新的记录，该API将阻塞。如果返回值为空，说明系统出错，需要检查系统是否还在正常运行。</p></li>
 <li><p><code>void taos_unsubscribe(TAOS_SUB *tsub)</code></p>
 <p>该API用于取消订阅，参数tsub是taos_subscribe的返回值。应用程序退出时，需要调用该API，否则有资源泄露。</p></li>
-<li><p><code>int taos_num_subfields(TAOS_SUB *tsub)</code></p>
+<li><p><code>int taos_num_fields(TAOS_SUB *tsub)</code></p>
 <p>该API用来获取返回的一排数据中数据的列数</p></li>
-<li><p><code>TAOS_FIELD *taos_fetch_subfields(TAOS_RES *res)</code></p>
+<li><p><code>TAOS_FIELD *taos_fetch_fields(TAOS_RES *res)</code></p>
 <p>该API用来获取每列数据的属性（数据类型、名字、字节数），与taos_num_subfileds配合使用，可用来解析返回的一排数据。</p></li>
 </ul>
 <a class='anchor' id='Java-Connector'></a><h2>Java Connector</h2>

documentation/tdenginedocs-en/connector/index.html

@@ -72,9 +72,9 @@ The API is used to start a subscription session by given a handle. The parameter
 The API used to get the new data from a TDengine server. It should be put in an infinite loop. The parameter <em>tsub</em> is the handle returned by <em>taos_subscribe</em>. If new data are updated, the API will return a row of the result. Otherwise, the API is blocked until new data arrives. If <em>NULL</em> pointer is returned, it means an error occurs.</p></li>
 <li><p><code>void taos_unsubscribe(TAOS_SUB *tsub)</code>
 Stop a subscription session by the handle returned by <em>taos_subscribe</em>.</p></li>
-<li><p><code>int taos_num_subfields(TAOS_SUB *tsub)</code>
+<li><p><code>int taos_num_fields(TAOS_SUB *tsub)</code>
 The API used to get the number of fields in a row.</p></li>
-<li><p><code>TAOS_FIELD *taos_fetch_subfields(TAOS_RES *res)</code>
+<li><p><code>TAOS_FIELD *taos_fetch_fields(TAOS_RES *res)</code>
 The API used to get the description of each column.</p></li>
 </ul>
 <a class='anchor' id='Java-Connector'></a><h2>Java Connector</h2>

documentation20/webdocs/markdowndocs/Evaluation-ch.md

@@ -11,7 +11,7 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
 * __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成Kafka/Redis/HBase/Spark/HDFS等软件，大幅降低应用开发和维护的复杂度成本。 
 * __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过Shell, Python, R, Matlab随时进行。
 * __与第三方工具无缝连接__：不用一行代码，即可与Telegraf, Grafana, EMQ, Prometheus, Matlab, R等集成。后续将支持OPC, Hadoop, Spark等, BI工具也将无缝连接。
-* __零运维成本、零学习成本__：安装、集群一秒搞定，无需分库分表，实时备份。标准SQL，支持JDBC, RESTful, 支持Python/Java/C/C++/Go, 与MySQL相似，零学习成本。
+* __零运维成本、零学习成本__：安装集群简单快捷，无需分库分表，实时备份。类似标准SQL，支持RESTful, 支持Python/Java/C/C++/C#/Go/Node.js, 与MySQL相似，零学习成本。
 
 采用TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM等通用型数据。
 

documentation20/webdocs/markdowndocs/Getting Started-ch.md

@@ -30,13 +30,13 @@ TDengine软件分为服务器、客户端和报警模块三部分，目前2.0版
 
 - TDengine-alert-2.0.0-Linux-x64.tar.gz (8.1M)
 
-目前，TDengine只支持在使用[`systemd`](https://en.wikipedia.org/wiki/Systemd)做进程服务管理的linux系统上安装。其他linux系统的支持正在开发中。用`which`命令来检测系统中是否存在`systemd`:
+目前，TDengine只支持在使用[`systemd`](https://en.wikipedia.org/wiki/Systemd)做进程服务管理的linux系统上安装。其他linux系统的支持正在开发中。用`which systemctl`命令来检测系统中是否存在`systemd`包:
 
 ```cmd
-which systemd
+which systemctl
 ```
 
-如果系统中不存在`systemd`命令，请考虑[通过源码安装](#通过源码安装)TDengine。
+如果系统中不存在`systemd`包，请考虑[通过源码安装](#通过源码安装)TDengine。
 
 具体的安装过程，请参见<a href="https://www.taosdata.com/blog/2019/08/09/566.html">TDengine多种安装包的安装和卸载</a>。
 
@@ -68,7 +68,7 @@ systemctl status taosd
 taos
 ```
 
-如果TDengine终端链接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考[FAQ](https://www.taosdata.com/cn/faq/)来解决终端链接服务端失败的问题）。TDengine终端的提示符号如下：
+如果TDengine终端连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考[FAQ](https://www.taosdata.com/cn/faq/)来解决终端连接服务端失败的问题）。TDengine终端的提示符号如下：
 
 ```cmd
 taos>
@@ -99,8 +99,8 @@ Query OK, 2 row(s) in set (0.001700s)
 - -c, --config-dir: 指定配置文件目录，默认为_/etc/taos_
 - -h, --host: 指定服务的IP地址，默认为本地服务
 - -s, --commands: 在不进入终端的情况下运行TDengine命令
-- -u, -- user:  链接TDengine服务器的用户名，缺省为root
-- -p, --password: 链接TDengine服务器的密码，缺省为taosdata
+- -u, -- user:  连接TDengine服务器的用户名，缺省为root
+- -p, --password: 连接TDengine服务器的密码，缺省为taosdata
 - -?, --help: 打印出所有命令行参数
 
 示例：

documentation20/webdocs/markdowndocs/Getting Started.md

@@ -16,13 +16,13 @@ Three different packages are provided, please pick up the one you like.
 <li><a id='tdengine-deb' style='color:var(--b2)'>TDengine DEB package (1.7M)</a></li>
 <li><a id='tdengine-tar' style='color:var(--b2)'>TDengine Tarball (3.0M)</a></li>
 </ul>
-For the time being, TDengine only supports installation on Linux systems using [`systemd`](https://en.wikipedia.org/wiki/Systemd) as the service manager. To check if your system has *systemd*, use the _which_ command.
+For the time being, TDengine only supports installation on Linux systems using [`systemd`](https://en.wikipedia.org/wiki/Systemd) as the service manager. To check if your system has *systemd* package, use the _which systemctl_ command.
 
 ```cmd
-which systemd
+which systemctl
 ```
 
-If the `systemd` command is not found, please [install from source code](#Install-from-Source). 
+If the `systemd` package is not found, please [install from source code](#Install-from-Source). 
 
 ### Running TDengine
 

documentation20/webdocs/markdowndocs/Model-ch.md

@@ -19,7 +19,7 @@ CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 4;
 USE power;	
 ```
 
-就当前链接里操作的库换为power，否则对具体表操作前，需要使用“库名.表名”来指定库的名字。  
+就当前连接里操作的库换为power，否则对具体表操作前，需要使用“库名.表名”来指定库的名字。  
   
 **注意：**
 

documentation20/webdocs/markdowndocs/More on System Architecture-ch.md

@@ -196,7 +196,7 @@ TDengine是基于硬件、软件系统不可靠、一定会有故障的假设进
 
 **对外服务地址**：TDengine集群可以容纳单台、多台甚至几千台物理节点。应用只需要向集群中任何一个物理节点的publicIp发起连接即可。启动CLI应用taos时，选项-h需要提供的就是publicIp。
 
-**master/secondIp**：每一个dnode都需要配置一个masterIp。dnode启动后，将对配置的masterIp发起加入集群的连接请求。masterIp是已经创建的集群中的任何一个节点的privateIp，对于集群中的第一个节点，就是它自己的privateIp。为保证连接成功，每个dnode还可配置secondIp, 该IP地址也是已创建的集群中的任何一个节点的privateIp。如果一个节点连接masterIp失败,它将试图链接secondIp。
+**master/secondIp**：每一个dnode都需要配置一个masterIp。dnode启动后，将对配置的masterIp发起加入集群的连接请求。masterIp是已经创建的集群中的任何一个节点的privateIp，对于集群中的第一个节点，就是它自己的privateIp。为保证连接成功，每个dnode还可配置secondIp, 该IP地址也是已创建的集群中的任何一个节点的privateIp。如果一个节点连接masterIp失败,它将试图连接secondIp。
 
 dnode启动后，会获知集群的mnode IP列表，并且定时向mnode发送状态信息。
 

documentation20/webdocs/markdowndocs/Queries-ch.md

@@ -29,23 +29,9 @@ Query OK, 2 row(s) in set (0.001100s)
 具体的查询语法请看<a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL </a>。
 
 ## 多表聚合查询
+物联网场景中，往往同一个类型的数据采集点有多个。TDengine采用超级表(STable)的概念来描述某一个类型的数据采集点，一张普通的表来描述一个具体的数据采集点。同时TDengine使用标签来描述数据采集点的静态属性，一个具体的数据采集点有具体的标签值。通过指定标签的过滤条件，TDengine提供了一高效的方法将超级表(某一类型的数据采集点)所属的子表进行聚合查询。对普通表的聚合函数以及绝大部分操作都适用于超级表，语法完全一样。  
 
-TDengine对每个数据采集点单独建表，但在实际应用中经常需要对不同的采集点数据进行聚合。为高效的进行聚合操作，TDengine引入超级表（STable）的概念。超级表用来代表一特定类型的数据采集点，它是包含多张表的表集合，集合里每张表的模式（schema）完全一致，但每张表都带有自己的静态标签，标签可以多个，可以随时增加、删除和修改。
-
-应用可通过指定标签的过滤条件，对一个STable下的全部或部分表进行聚合或统计操作，这样大大简化应用的开发。其具体流程如下图所示：
-
-<center> <img src="../assets/stable.png"> </center>
-
-<center> 多表聚合查询原理图  </center>
-
-1：应用将一个查询条件发往系统；2: taosc将超级表的名字发往 Meta Node（管理节点)；3：管理节点将超级表所拥有的 vnode 列表发回 taosc；4：taosc将计算的请求连同标签过滤条件发往这些vnode对应的多个数据节点；5：每个vnode先在内存里查找出自己节点里符合标签过滤条件的表的集合，然后扫描存储的时序数据，完成相应的聚合计算，将结果返回给taosc；6：taosc将多个数据节点返回的结果做最后的聚合，将其返回给应用。
-
-由于TDengine在vnode内将标签数据与时序数据分离存储，通过先在内存里过滤标签数据，将需要扫描的数据集大幅减少，大幅提升聚合计算速度。同时，由于数据分布在多个vnode/dnode，聚合计算操作在多个vnode里并发进行，又进一步提升了聚合的速度。
-
-对普通表的聚合函数以及绝大部分操作都适用于超级表，语法完全一样，细节请看 TAOS SQL。
-
-比如：在TAOS Shell，查找所有智能电表采集的电压平均值，并按照location分组
-
+**示例1**：在TAOS Shell，查找北京所有智能电表采集的电压平均值，并按照location分组
 ```mysql
 taos> SELECT AVG(voltage) FROM meters GROUP BY location;
        avg(voltage)        |            location            |
@@ -55,6 +41,18 @@ taos> SELECT AVG(voltage) FROM meters GROUP BY location;
 Query OK, 2 row(s) in set (0.002136s)
 ```
 
+**示例2**：在TAOS shell, 查找groupId为2的所有智能电表过去24小时的记录条数，电流的最大值
+
+```mysql
+taos> SELECT count(*), max(current) FROM meters where groupId = 2 and ts > now - 24h;
+     cunt(*)  |    max(current)  |
+==================================
+            5 |             13.4 |
+Query OK, 1 row(s) in set (0.002136s)
+```
+
+TDengine仅容许对属于同一个超级表的表之间进行聚合查询，不同超级表之间的聚合查询不支持。在<a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL </a>一章，查询类操作都会注明是否支持超级表。
+
 ## 降采样查询、插值
 
 物联网场景里，经常需要通过降采样（down sampling）将采集的数据按时间段进行聚合。TDengine 提供了一个简便的关键词 interval 让按照时间窗口的查询操作变得极为简单。比如，将智能电表 d1001 采集的电流值每10秒钟求和
@@ -66,9 +64,9 @@ taos> SELECT sum(current) FROM d1001 INTERVAL(10s);
  2018-10-03 14:38:10.000 |              24.900000572 |
 Query OK, 2 row(s) in set (0.000883s)
 ```
-降采样操作也适用于超级表，比如：将所有智能电表采集的电流值每秒钟求和
+降采样操作也适用于超级表，比如：将北京所有智能电表采集的电流值每秒钟求和
 ```mysql
-taos> SELECT SUM(current) FROM meters INTERVAL(1s);
+taos> SELECT SUM(current) FROM meters where location like "Beijing%" INTERVAL(1s);
            ts            |       sum(current)        |
 ======================================================
  2018-10-03 14:38:04.000 |              10.199999809 |

documentation20/webdocs/markdowndocs/TAOS SQL-ch.md

@@ -98,12 +98,12 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     KEEP参数是指修改数据文件保存的天数，缺省值为3650，取值范围[days, 365000]，必须大于或等于days参数值。
 
     ```mysql
-    ALTER DATABASE db_name QUORUM 365;
+    ALTER DATABASE db_name QUORUM 2;
     ```
     QUORUM参数是指数据写入成功所需要的确认数。取值范围[1, 3]。对于异步复制，quorum设为1，具有master角色的虚拟节点自己确认即可。对于同步复制，需要至少大于等于2。原则上，Quorum >=1 并且 Quorum <= replica(副本数)，这个参数在启动一个同步模块实例时需要提供。
 
     ```mysql
-    ALTER DATABASE db_name BLOCKS 365;
+    ALTER DATABASE db_name BLOCKS 100;
     ```
     BLOCKS参数是每个VNODE (TSDB) 中有多少cache大小的内存块，因此一个VNODE的用的内存大小粗略为（cache * blocks）。取值范围[3, 1000]。
 
@@ -125,6 +125,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     1) 表的第一个字段必须是TIMESTAMP，并且系统自动将其设为主键；
     2) 表名最大长度为193；
     3) 表的每行长度不能超过16k个字符;
+    4) 子表名只能由字母、数字和下划线组成，且不能以数字开头
     5) 使用数据类型binary或nchar，需指定其最长的字节数，如binary(20)，表示20字节；
 
 - **删除数据表**

documentation20/webdocs/markdowndocs/administrator-ch.md

@@ -82,8 +82,7 @@ TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修
 
 下面仅仅列出一些重要的配置参数，更多的参数请看配置文件里的说明。各个参数的详细介绍及作用请看前述章节，而且这些参数的缺省配置都是工作的，一般无需设置。**注意：配置修改后，需要重启*taosd*服务才能生效。**
 
-- firstEp: taosd启动时，主动连接的集群中第一个dnode的end point, 默认值为localhost:6030。
-- secondEp: taosd启动时，如果first连接不上，尝试连接集群中第二个dnode的end point, 默认值为空。
+- firstEp: taosd启动时，主动连接的集群中首个dnode的end point, 默认值为localhost:6030。
 - fqdn：数据节点的FQDN，缺省为操作系统配置的第一个hostname。如果习惯IP地址访问，可设置为该节点的IP地址。
 - serverPort：taosd启动后，对外服务的端口号，默认值为6030。
 - httpPort: RESTful服务使用的端口号，所有的HTTP请求（TCP）都需要向该接口发起查询/写入请求, 默认值为6041。
@@ -130,9 +129,25 @@ TDengine集群中加入一个新的dnode时，涉及集群相关的一些参数
 - statusInterval: dnode向mnode报告状态时长。单位为秒，默认值：1。
 - maxTablesPerVnode: 每个vnode中能够创建的最大表个数。默认值：1000000。
 - maxVgroupsPerDb: 每个数据库中能够使用的最大vnode个数。
-- arbitrator: 系统中裁决器的end point，缺省为空
+- arbitrator: 系统中裁决器的end point，缺省为空。
 - timezone、locale、charset 的配置见客户端配置。
 
+为方便调试，可通过SQL语句临时调整每个dnode的日志配置，系统重启后会失效：
+
+```mysql
+ALTER DNODE <dnode_id> <config>
+```
+
+- dnode_id: 可以通过SQL语句"SHOW DNODES"命令获取
+- config: 要调整的日志参数，在如下列表中取值    
+    > resetlog 截断旧日志文件，创建一个新日志文件    
+    > debugFlag  < 131 | 135 | 143 > 设置debugFlag为131、135或者143
+
+例如：
+```
+    alter dnode 1 debugFlag 135;
+```
+
 ## 客户端配置 
 
 TDengine系统的前台交互客户端应用程序为taos，它与taosd共享同一个配置文件taos.cfg。运行taos时，使用参数-c指定配置文件目录，如taos -c /home/cfg，表示使用/home/cfg/目录下的taos.cfg配置文件中的参数，缺省目录是/etc/taos。本节主要说明 taos 客户端应用在配置文件 taos.cfg 文件中使用到的参数。
@@ -140,76 +155,80 @@ TDengine系统的前台交互客户端应用程序为taos，它与taosd共享同
 客户端配置参数
 
 - firstEp: taos启动时，主动连接的集群中第一个taosd实例的end point, 缺省值为 localhost:6030。
-- secondEp: taos启动时，如果first连接不上，尝试连接集群中第二个taosd实例的end point, 缺省值为空。
 - locale
 
-    > 默认值：系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置
+    默认值：系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置
     
-TDengine为存储中文、日文、韩文等非ASCII编码的宽字符，提供一种专门的字段类型nchar。写入nchar字段的数据将统一采用UCS4-LE格式进行编码并发送到服务器。需要注意的是，编码正确性是客户端来保证。因此，如果用户想要正常使用nchar字段来存储诸如中文、日文、韩文等非ASCII字符，需要正确设置客户端的编码格式。
+    TDengine为存储中文、日文、韩文等非ASCII编码的宽字符，提供一种专门的字段类型nchar。写入nchar字段的数据将统一采用UCS4-LE格式进行编码并发送到服务器。需要注意的是，编码正确性是客户端来保证。因此，如果用户想要正常使用nchar字段来存储诸如中文、日文、韩文等非ASCII字符，需要正确设置客户端的编码格式。
 
-客户端的输入的字符均采用操作系统当前默认的编码格式，在Linux系统上多为UTF-8，部分中文系统编码则可能是GB18030或GBK等。在docker环境中默认的编码是POSIX。在中文版Windows系统中，编码则是CP936。客户端需要确保正确设置自己所使用的字符集，即客户端运行的操作系统当前编码字符集，才能保证nchar中的数据正确转换为UCS4-LE编码格式。
+    客户端的输入的字符均采用操作系统当前默认的编码格式，在Linux系统上多为UTF-8，部分中文系统编码则可能是GB18030或GBK等。在docker环境中默认的编码是POSIX。在中文版Windows系统中，编码则是CP936。客户端需要确保正确设置自己所使用的字符集，即客户端运行的操作系统当前编码字符集，才能保证nchar中的数据正确转换为UCS4-LE编码格式。
 
-在 Linux 中 locale 的命名规则为: <语言>_<地区>.<字符集编码> 如：zh_CN.UTF-8，zh代表中文，CN代表大陆地区，UTF-8表示字符集。字符集编码为客户端正确解析本地字符串提供编码转换的说明。Linux系统与 Mac OSX 系统可以通过设置locale来确定系统的字符编码，由于Windows使用的locale中不是POSIX标准的locale格式，因此在Windows下需要采用另一个配置参数charset来指定字符编码。在Linux 系统中也可以使用charset来指定字符编码。
+    在 Linux 中 locale 的命名规则为: <语言>_<地区>.<字符集编码> 如：zh_CN.UTF-8，zh代表中文，CN代表大陆地区，UTF-8表示字符集。字符集编码为客户端正确解析本地字符串提供编码转换的说明。Linux系统与 Mac OSX 系统可以通过设置locale来确定系统的字符编码，由于Windows使用的locale中不是POSIX标准的locale格式，因此在Windows下需要采用另一个配置参数charset来指定字符编码。在Linux 系统中也可以使用charset来指定字符编码。
 
 - charset
 
-    > 默认值：系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置
+    默认值：系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置
     
-如果配置文件中不设置charset，在Linux系统中，taos在启动时候，自动读取系统当前的locale信息，并从locale信息中解析提取charset编码格式。如果自动读取locale信息失败，则尝试读取charset配置，如果读取charset配置也失败，则中断启动过程。
+    如果配置文件中不设置charset，在Linux系统中，taos在启动时候，自动读取系统当前的locale信息，并从locale信息中解析提取charset编码格式。如果自动读取locale信息失败，则尝试读取charset配置，如果读取charset配置也失败，则中断启动过程。
 
-在Linux系统中，locale信息包含了字符编码信息，因此正确设置了Linux系统locale以后可以不用再单独设置charset。例如：
-```
+    在Linux系统中，locale信息包含了字符编码信息，因此正确设置了Linux系统locale以后可以不用再单独设置charset。例如：
+    ```
     locale zh_CN.UTF-8
-```
-在Windows系统中，无法从locale获取系统当前编码。如果无法从配置文件中读取字符串编码信息，taos默认设置为字符编码为CP936。其等效在配置文件中添加如下配置：
-```
+    ```
+    在Windows系统中，无法从locale获取系统当前编码。如果无法从配置文件中读取字符串编码信息，taos默认设置为字符编码为CP936。其等效在配置文件中添加如下配置：
+    ```
     charset CP936
-```
-如果需要调整字符编码，请查阅当前操作系统使用的编码，并在配置文件中正确设置。
+    ```
+    如果需要调整字符编码，请查阅当前操作系统使用的编码，并在配置文件中正确设置。
 
-在Linux系统中，如果用户同时设置了locale和字符集编码charset，并且locale和charset的不一致，后设置的值将覆盖前面设置的值。
-```
+    在Linux系统中，如果用户同时设置了locale和字符集编码charset，并且locale和charset的不一致，后设置的值将覆盖前面设置的值。
+    ```
     locale zh_CN.UTF-8
     charset GBK
-```
-则charset的有效值是GBK。
-```
+    ```
+    则charset的有效值是GBK。
+    ```
     charset GBK
     locale zh_CN.UTF-8
-```
-charset的有效值是UTF-8。
+    ```
+    charset的有效值是UTF-8。
 
-日志的配置参数，与server 的配置参数完全一样。
+    日志的配置参数，与server 的配置参数完全一样。
 
 - timezone
 
     默认值：从系统中动态获取当前的时区设置
 
-客户端运行系统所在的时区。为应对多时区的数据写入和查询问题，TDengine 采用 Unix 时间戳(Unix Timestamp)来记录和存储时间戳。Unix 时间戳的特点决定了任一时刻不论在任何时区，产生的时间戳均一致。需要注意的是，Unix时间戳是在客户端完成转换和记录。为了确保客户端其他形式的时间转换为正确的 Unix 时间戳，需要设置正确的时区。
+    客户端运行系统所在的时区。为应对多时区的数据写入和查询问题，TDengine 采用 Unix 时间戳(Unix Timestamp)来记录和存储时间戳。Unix 时间戳的特点决定了任一时刻不论在任何时区，产生的时间戳均一致。需要注意的是，Unix时间戳是在客户端完成转换和记录。为了确保客户端其他形式的时间转换为正确的 Unix 时间戳，需要设置正确的时区。
 
-在Linux系统中，客户端会自动读取系统设置的时区信息。用户也可以采用多种方式在配置文件设置时区。例如：
-```
+    在Linux系统中，客户端会自动读取系统设置的时区信息。用户也可以采用多种方式在配置文件设置时区。例如：
+    ```
     timezone UTC-8
     timezone GMT-8
     timezone Asia/Shanghai
-```
-均是合法的设置东八区时区的格式。
+    ```
+    均是合法的设置东八区时区的格式。
 
-时区的设置对于查询和写入SQL语句中非Unix时间戳的内容（时间戳字符串、关键词now的解析）产生影响。例如：
-```
+    时区的设置对于查询和写入SQL语句中非Unix时间戳的内容（时间戳字符串、关键词now的解析）产生影响。例如：
+    ```
     SELECT count(*) FROM table_name WHERE TS<'2019-04-11 12:01:08';
-```
-在东八区，SQL语句等效于
-```
+    ```
+    在东八区，SQL语句等效于
+    ```
     SELECT count(*) FROM table_name WHERE TS<1554955268000;
-```
-在UTC时区，SQL语句等效于
-```
+    ```
+    在UTC时区，SQL语句等效于
+    ```
     SELECT count(*) FROM table_name WHERE TS<1554984068000;
-```
-为了避免使用字符串时间格式带来的不确定性，也可以直接使用Unix时间戳。此外，还可以在SQL语句中使用带有时区的时间戳字符串，例如：RFC3339格式的时间戳字符串，2013-04-12T15:52:01.123+08:00或者ISO-8601格式时间戳字符串2013-04-12T15:52:01.123+0800。上述两个字符串转化为Unix时间戳不受系统所在时区的影响。
+    ```
+    为了避免使用字符串时间格式带来的不确定性，也可以直接使用Unix时间戳。此外，还可以在SQL语句中使用带有时区的时间戳字符串，例如：RFC3339格式的时间戳字符串，2013-04-12T15:52:01.123+08:00或者ISO-8601格式时间戳字符串2013-04-12T15:52:01.123+0800。上述两个字符串转化为Unix时间戳不受系统所在时区的影响。
+
+    启动taos时，也可以从命令行指定一个taosd实例的end point，否则就从taos.cfg读取。
+   
+- maxBinaryDisplayWidth
+
+    Shell中binary 和 nchar字段的显示宽度上限，超过此限制的部分将被隐藏。默认值：30。可在 shell 中通过命令 set max_binary_display_width nn 动态修改此选项。
    
-启动taos时，也可以从命令行指定一个taosd实例的end point，否则就从taos.cfg读取。
 
 ## 用户管理
 
@@ -233,6 +252,12 @@ ALTER USER <user_name> PASS <'password'>;
 
 修改用户密码, 为避免被转换为小写，密码需要用单引号引用,单引号为英文半角
 
+```
+ALTER USER <user_name> PRIVILEDGE <super|write|read>;
+```
+
+修改用户权限为：super/write/read，不需要添加单引号
+
 ```
 SHOW USERS;
 ```
@@ -356,7 +381,7 @@ KILL STREAM <stream-id>;
 
 ## 系统监控
 
-TDengine启动后，会自动创建一个监测数据库SYS，并自动将服务器的CPU、内存、硬盘空间、带宽、请求数、磁盘读写速度、慢查询等信息定时写入该数据库。TDengine还将重要的系统操作（比如登录、创建、删除数据库等）日志以及各种错误报警信息记录下来存放在SYS库里。系统管理员可以从CLI直接查看这个数据库，也可以在WEB通过图形化界面查看这些监测信息。
+TDengine启动后，会自动创建一个监测数据库log，并自动将服务器的CPU、内存、硬盘空间、带宽、请求数、磁盘读写速度、慢查询等信息定时写入该数据库。TDengine还将重要的系统操作（比如登录、创建、删除数据库等）日志以及各种错误报警信息记录下来存放在log库里。系统管理员可以从CLI直接查看这个数据库，也可以在WEB通过图形化界面查看这些监测信息。
 
 这些监测信息的采集缺省是打开的，但可以修改配置文件里的选项enableMonitor将其关闭或打开。
 
@@ -387,4 +412,3 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
 您可以通过修改系统配置文件taos.cfg来配置不同的数据目录和日志目录。
 
 
-

documentation20/webdocs/markdowndocs/advanced features-ch.md

@@ -39,7 +39,7 @@ create table D1002 using meters tags ("Beijing.Haidian", 2);
 我们已经知道，可以通过下面这条SQL语句以一分钟为时间窗口、30秒为前向增量统计这些电表的平均电压。
 
 ```sql
-select avg(voltage) from meters interval(1m) sliding(30s)；
+select avg(voltage) from meters interval(1m) sliding(30s);
 ```
 
 每次执行这条语句，都会重新计算所有数据。 
@@ -47,14 +47,14 @@ select avg(voltage) from meters interval(1m) sliding(30s)；
 可以把上面的语句改进成下面的样子，每次使用不同的 `startTime` 并定期执行：
 
 ```sql
-select avg(voltage) from meters where ts > {startTime} interval(1m) sliding(30s)；
+select avg(voltage) from meters where ts > {startTime} interval(1m) sliding(30s);
 ```
 
 这样做没有问题，但TDengine提供了更简单的方法，
 只要在最初的查询语句前面加上 `create table {tableName} as ` 就可以了, 例如：
 
 ```sql
-create table avg_vol as select avg(voltage) from meters interval(1m) sliding(30s)；
+create table avg_vol as select avg(voltage) from meters interval(1m) sliding(30s);
 ```
 
 会自动创建一个名为 `avg_vol` 的新表，然后每隔30秒，TDengine会增量执行 `as` 后面的 SQL 语句，
@@ -80,7 +80,7 @@ taos> select * from avg_vol;
 比如使用下面的SQL创建的连续查询将运行一小时，之后会自动停止。
 
 ```sql
-create table avg_vol as select avg(voltage) from meters where ts > now and ts <= now + 1h interval(1m) sliding(30s)；
+create table avg_vol as select avg(voltage) from meters where ts > now and ts <= now + 1h interval(1m) sliding(30s);
 ```
 
 需要说明的是，上面例子中的 `now` 是指创建连续查询的时间，而不是查询执行的时间，否则，查询就无法自动停止了。 
@@ -396,7 +396,7 @@ ts: 1597465200000	current: 11.2	voltage: 220	phase: 1	location: Beijing.Haidian
 
 ```sql
 # taos
-taos> use power；
+taos> use power;
 taos> insert into d1001 values("2020-08-15 12:40:00.000", 12.4, 220, 1);
 ```
 

documentation20/webdocs/markdowndocs/cluster-ch.md

@@ -8,7 +8,7 @@ TDengine的集群管理极其简单，除添加和删除节点需要人工干预
 
 ## 准备工作
 
-**第零步**：如果没有部署DNS服务，请规划集群所有物理节点的FQDN，然后按照《[一篇文章说清楚TDengine的FQDN](https://www.taosdata.com/blog/2020/09/11/1824.html)》里的步骤，将所有集群物理节点的IP与FQDN的对应关系添加好。
+**第零步**：规划集群所有物理节点的FQDN，将规划好的FQDN分别添加到每个物理节点的/etc/hostname；修改每个物理节点的/etc/hosts，将所有集群物理节点的IP与FQDN的对应添加好。【如部署了DNS，请联系网络管理员在DNS上做好相关配置】
 
 **第一步**：如果搭建集群的物理节点中，存有之前的测试数据、装过1.X的版本，或者装过其他版本的TDengine，请先将其删除，并清空所有数据，具体步骤请参考博客[《TDengine多种安装包的安装和卸载》](https://www.taosdata.com/blog/2019/08/09/566.html ) 
 **注意1：**因为FQDN的信息会写进文件，如果之前没有配置或者更改FQDN，且启动了TDengine。请一定在确保数据无用或者备份的前提下，清理一下之前的数据（rm -rf /var/lib/taos/）；
@@ -16,9 +16,9 @@ TDengine的集群管理极其简单，除添加和删除节点需要人工干预
 
 **第二步**：建议关闭所有物理节点的防火墙，至少保证端口：6030 - 6042的TCP和UDP端口都是开放的。**强烈建议**先关闭防火墙，集群搭建完毕之后，再来配置端口；
 
-**第三步**：在所有节点安装TDengine，且版本必须是一致的，**但不要启动taosd**。安装时，提示输入是否要加入一个已经存在的TDengine集群时，第一个物理节点直接回车创建新集群，后续物理节点则输入该集群任何一个在线的物理节点的FQDN:端口号(默认6030)；
+**第三步**：在所有物理节点安装TDengine，且版本必须是一致的，**但不要启动taosd**。安装时，提示输入是否要加入一个已经存在的TDengine集群时，第一个物理节点直接回车创建新集群，后续物理节点则输入该集群任何一个在线的物理节点的FQDN:端口号(默认6030)；
 
-**第四步**：检查所有数据节点，以及应用所在物理节点的网络设置：
+**第四步**：检查所有数据节点，以及应用程序所在物理节点的网络设置：
 
 1. 每个物理节点上执行命令`hostname -f`，查看和确认所有节点的hostname是不相同的(应用驱动所在节点无需做此项检查)；
 2. 每个物理节点上执行`ping host`, 其中host是其他物理节点的hostname, 看能否ping通其它物理节点; 如果不能ping通，需要检查网络设置, 或/etc/hosts文件(Windows系统默认路径为C:\Windows\system32\drivers\etc\hosts)，或DNS的配置。如果无法ping通，是无法组成集群的；
@@ -89,7 +89,7 @@ taos>
 2. 在第一个数据节点，使用CLI程序taos, 登录进TDengine系统, 执行命令:
 
    ```
-   CREATE DNODE "h2.taos.com:6030"； 
+   CREATE DNODE "h2.taos.com:6030"; 
    ```
 
    将新数据节点的End Point (准备工作中第四步获知的) 添加进集群的EP列表。**"fqdn:port"需要用双引号引起来**，否则出错。请注意将示例的“h2.taos.com:6030" 替换为这个新数据节点的End Point。
@@ -97,7 +97,7 @@ taos>
 3. 然后执行命令
 
    ```
-   SHOW DNODES；
+   SHOW DNODES;
    ```
 
    查看新节点是否被成功加入。如果该被加入的数据节点处于离线状态，请做两个检查
@@ -122,7 +122,7 @@ taos>
 执行CLI程序taos, 使用root账号登录进系统, 执行:
 
 ```
-CREATE DNODE "fqdn:port"； 
+CREATE DNODE "fqdn:port"; 
 ```
 
 将新数据节点的End Point添加进集群的EP列表。**"fqdn:port"需要用双引号引起来**，否则出错。一个数据节点对外服务的fqdn和port可以通过配置文件taos.cfg进行配置，缺省是自动获取。【强烈不建议用自动获取方式来配置FQDN，可能导致生成的数据节点的End Point不是所期望的】
@@ -213,6 +213,6 @@ SHOW MNODES;
 
 ## Arbitrator的使用
 
-如果副本数为偶数，当一个vnode group里一半或超过一半的vnode不工作时，是无法从中选出master的。同理，一半或超过一半的mnode不工作时，是无法选出mnode的master的，因为存在“split brain”问题。为解决这个问题，TDengine引入了arbitrator的概念。Arbitrator模拟一个vnode或mnode在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含arbitrator在内，超过半数的vnode或mnode工作，那么该vnode group或mnode组就可以正常的提供数据插入或查询服务。比如对于副本数为2的情形，如果一个节点A离线，但另外一个节点B正常，而且能连接到arbitrator, 那么节点B就能正常工作。
+如果副本数为偶数，当一个vnode group里一半vnode不工作时，是无法从中选出master的。同理，一半mnode不工作时，是无法选出mnode的master的，因为存在“split brain”问题。为解决这个问题，TDengine引入了arbitrator的概念。Arbitrator模拟一个vnode或mnode在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含arbitrator在内，超过半数的vnode或mnode工作，那么该vnode group或mnode组就可以正常的提供数据插入或查询服务。比如对于副本数为2的情形，如果一个节点A离线，但另外一个节点B正常，而且能连接到arbitrator, 那么节点B就能正常工作。
 
-TDengine安装包里带有一个执行程序tarbitrator, 找任何一台Linux服务器运行它即可。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6042。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为arbitrator的End Point。如果该参数配置了，当副本数为偶数数，系统将自动连接配置的arbitrator。
+TDengine提供一个执行程序tarbitrator, 找任何一台Linux服务器运行它即可。请点击[安装包下载](https://www.taosdata.com/cn/all-downloads/)，在TDengine Arbitrator Linux一节中，选择适合的版本下载并安装。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6042。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为arbitrator的End Point。如果该参数配置了，当副本数为偶数数，系统将自动连接配置的arbitrator。如果副本数为奇数，即使配置了arbitrator, 系统也不会去建立连接。

documentation20/webdocs/markdowndocs/cluster.md

@@ -46,7 +46,7 @@ taos>
 5. 在第一个节点，使用CLI程序taos, 登录进TDengine系统, 使用命令:
 
    ```
-   CREATE DNODE "h2.taos.com:6030"； 
+   CREATE DNODE "h2.taos.com:6030"; 
    ```
 
    将新节点的End Point添加进集群的EP列表。**"fqdn:port"需要用双引号引起来**，否则出错。请注意将示例的“h2.taos.com:6030" 替换为你自己第一个节点的End Point
@@ -54,7 +54,7 @@ taos>
 6. 使用命令
 
    ```
-   SHOW DNODES；
+   SHOW DNODES;
    ```
 
    查看新节点是否被成功加入。
@@ -71,7 +71,7 @@ taos>
 ###添加节点
 执行CLI程序taos, 使用root账号登录进系统, 执行:
 ```
-CREATE DNODE "fqdn:port"； 
+CREATE DNODE "fqdn:port"; 
 ```
 将新节点的End Point添加进集群的EP列表。**"fqdn:port"需要用双引号引起来**，否则出错。一个节点对外服务的fqdn和port可以通过配置文件taos.cfg进行配置，缺省是自动获取。
 

documentation20/webdocs/markdowndocs/connector-ch.md

@@ -142,7 +142,7 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
   获取最近一次API调用失败的原因，返回值为错误代码。
 
 
-**注意**：对于单个数据库连接，在同一时刻只能有一个线程使用该链接调用API，否则会有未定义的行为出现并可能导致客户端crash。客户端应用可以通过建立多个连接进行多线程的数据写入或查询处理。
+**注意**：对于单个数据库连接，在同一时刻只能有一个线程使用该连接调用API，否则会有未定义的行为出现并可能导致客户端crash。客户端应用可以通过建立多个连接进行多线程的数据写入或查询处理。
 
 
 ### 异步查询API

documentation20/webdocs/markdowndocs/connector-java-ch.md

@@ -72,38 +72,34 @@ maven 项目中使用如下 pom.xml 配置即可：
 
 ### 获取连接
 
-如下所示配置即可获取 TDengine Connection：
+#### 通过JdbcUrl获取连接
+
+通过指定的jdbcUrl获取连接，如下所示：
 ```java
 Class.forName("com.taosdata.jdbc.TSDBDriver");
-String jdbcUrl = "jdbc:TAOS://127.0.0.1:6030/log?user=root&password=taosdata";
+String jdbcUrl = "jdbc:TAOS://taosdemo.com:6030/test?user=root&password=taosdata";
 Connection conn = DriverManager.getConnection(jdbcUrl);
 ```
-> 端口 6030 为默认连接端口，JDBC URL 中的 log 为系统本身的监控数据库。
+以上示例，建立了到hostname为taosdemo.com，端口为6030（TDengine的默认端口），数据库名为test的连接。这个url中指定用户名（user）为root，密码（password）为taosdata。
 
 TDengine 的 JDBC URL 规范格式为：
-`jdbc:TAOS://{host_ip}:{port}/[database_name]?[user={user}|&password={password}|&charset={charset}|&cfgdir={config_dir}|&locale={locale}|&timezone={timezone}]`
-
-其中，`{}` 中的内容必须，`[]` 中为可选。配置参数说明如下：
-
+`jdbc:TAOS://[host_name]:[port]/[database_name]?[user={user}|&password={password}|&charset={charset}|&cfgdir={config_dir}|&locale={locale}|&timezone={timezone}]`
+url中的配置参数如下：
 * user：登录 TDengine 用户名，默认值 root。
 * password：用户登录密码，默认值 taosdata。
-* charset：客户端使用的字符集，默认值为系统字符集。
 * cfgdir：客户端配置文件目录路径，Linux OS 上默认值 /etc/taos ，Windows OS 上默认值 C:/TDengine/cfg。
+* charset：客户端使用的字符集，默认值为系统字符集。
 * locale：客户端语言环境，默认值系统当前 locale。
 * timezone：客户端使用的时区，默认值为系统当前时区。
 
-以上参数可以在 3 处配置，`优先级由高到低`分别如下：
-1. JDBC URL 参数
-    如上所述，可以在 JDBC URL 的参数中指定。
-2. java.sql.DriverManager.getConnection(String jdbcUrl, Properties connProps)
+#### 使用JdbcUrl和Properties获取连接
+
+除了通过指定的jdbcUrl获取连接，还可以使用Properties指定建立连接时的参数，如下所示：
 ```java
 public Connection getConn() throws Exception{
   Class.forName("com.taosdata.jdbc.TSDBDriver");
-  String jdbcUrl = "jdbc:TAOS://127.0.0.1:0/log?user=root&password=taosdata";
+  String jdbcUrl = "jdbc:TAOS://taosdemo.com:6030/test?user=root&password=taosdata";
   Properties connProps = new Properties();
-  connProps.setProperty(TSDBDriver.PROPERTY_KEY_USER, "root");
-  connProps.setProperty(TSDBDriver.PROPERTY_KEY_PASSWORD, "taosdata");
-  connProps.setProperty(TSDBDriver.PROPERTY_KEY_CONFIG_DIR, "/etc/taos");
   connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
   connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
   connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
@@ -111,16 +107,39 @@ public Connection getConn() throws Exception{
   return conn;
 }
 ```
+以上示例，建立一个到hostname为taosdemo.com，端口为6030，数据库名为test的连接。这个连接在url中指定了用户名(user)为root，密码（password）为taosdata，并在connProps中指定了使用的字符集、语言环境、时区等信息。
+
+properties中的配置参数如下：
+* TSDBDriver.PROPERTY_KEY_USER：登录 TDengine 用户名，默认值 root。
+* TSDBDriver.PROPERTY_KEY_PASSWORD：用户登录密码，默认值 taosdata。
+* TSDBDriver.PROPERTY_KEY_CONFIG_DIR：客户端配置文件目录路径，Linux OS 上默认值 /etc/taos ，Windows OS 上默认值 C:/TDengine/cfg。
+* TSDBDriver.PROPERTY_KEY_CHARSET：客户端使用的字符集，默认值为系统字符集。
+* TSDBDriver.PROPERTY_KEY_LOCALE：客户端语言环境，默认值系统当前 locale。
+* TSDBDriver.PROPERTY_KEY_TIME_ZONE：客户端使用的时区，默认值为系统当前时区。
+
+#### 使用客户端配置文件建立连接
+当使用JDBC连接TDengine集群时，可以使用客户端配置文件，在客户端配置文件中指定集群的firstEp、secondEp参数。
+如下所示：
+1. 在java中不指定hostname和port
+```java
+public Connection getConn() throws Exception{
+  Class.forName("com.taosdata.jdbc.TSDBDriver");
+  String jdbcUrl = "jdbc:TAOS://:/test?user=root&password=taosdata";
+  Properties connProps = new Properties();
+  connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
+  connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
+  connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
+  Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
+  return conn;
+}
+```
+2. 在配置文件中指定firstEp和secondEp
+```
+# first fully qualified domain name (FQDN) for TDengine system
+firstEp               cluster_node1:6030
 
-3. 客户端配置文件 taos.cfg
-
-    linux 系统默认配置文件为 /var/lib/taos/taos.cfg，windows 系统默认配置文件路径为 C:\TDengine\cfg\taos.cfg。
-```properties
-# client default username
-# defaultUser           root
-
-# client default password
-# defaultPass           taosdata
+# second fully qualified domain name (FQDN) for TDengine system, for cluster only
+secondEp              cluster_node2:6030
 
 # default system charset
 # charset               UTF-8
@@ -128,6 +147,19 @@ public Connection getConn() throws Exception{
 # system locale
 # locale                en_US.UTF-8
 ```
+
+以上示例，jdbc会使用客户端的配置文件，建立到hostname为cluster_node1，端口为6030，数据库名为test的连接。当集群中firstEp节点失效时，JDBC会尝试使用secondEp连接集群。
+TDengine中，只要保证firstEp和secondEp中一个节点有效，就可以正常建立到集群的连接。
+
+> 注意：这里的配置文件指的是调用JDBC Connector的应用程序所在机器上的配置文件，Linux OS 上默认值 /etc/taos/taos.cfg ，Windows OS 上默认值 C://TDengine/cfg/taos.cfg。
+
+#### 配置参数的优先级
+通过以上3种方式获取连接，如果配置参数在url、Properties、客户端配置文件中有重复，则参数的`优先级由高到低`分别如下：
+1. JDBC URL 参数，如上所述，可以在 JDBC URL 的参数中指定。
+2. Properties connProps
+3. 客户端配置文件 taos.cfg
+例如：在url中指定了password为taosdata，在Properties中指定了password为taosdemo，那么，JDBC会使用url中的password建立连接。
+
 > 更多详细配置请参考[客户端配置][13]
 
 ### 创建数据库和表

documentation20/webdocs/markdowndocs/faq-ch.md

@@ -21,7 +21,7 @@
 
 ## 5. 遇到错误"Unable to establish connection", 我怎么办？
 
-客户端遇到链接故障，请按照下面的步骤进行检查：
+客户端遇到连接故障，请按照下面的步骤进行检查：
 
 1. 检查网络环境
     * 云服务器：检查云服务器的安全组是否打开TCP/UDP 端口6030-6042的访问权限
@@ -45,7 +45,7 @@
 9. 如果仍不能排除连接故障，请使用命令行工具nc来分别判断指定端口的TCP和UDP连接是否通畅
    检查UDP端口连接是否工作：`nc -vuz {hostIP} {port} `
    检查服务器侧TCP端口连接是否工作：`nc -l {port}`
-   检查客户端侧TCP端口链接是否工作：`nc {hostIP} {port}`
+   检查客户端侧TCP端口连接是否工作：`nc {hostIP} {port}`
    
 10. 也可以使用taos程序内嵌的网络连通检测功能，来验证服务器和客户端之间指定的端口连接是否通畅（包括TCP和UDP）：[TDengine 内嵌网络检测工具使用指南](https://www.taosdata.com/blog/2020/09/08/1816.html)。
 
@@ -57,7 +57,7 @@
 1. 请检查连接的服务器的FQDN是否正确,FQDN配置参考：[一篇文章说清楚TDengine的FQDN](https://www.taosdata.com/blog/2020/09/11/1824.html)。
 2. 如果网络配置有DNS server, 请检查是否正常工作
 3. 如果网络没有配置DNS server, 请检查客户端所在机器的hosts文件，查看该FQDN是否配置，并是否有正确的IP地址。
-4. 如果网络配置OK，从客户端所在机器，你需要能Ping该连接的FQDN，否则客户端是无法链接服务器的
+4. 如果网络配置OK，从客户端所在机器，你需要能Ping该连接的FQDN，否则客户端是无法连接服务器的
 
 
 ## 7. 虽然语法正确，为什么我还是得到 "Invalid SQL" 错误
@@ -108,4 +108,8 @@ Connection = DriverManager.getConnection(url, properties);
 
 附上必要的问题描述，以及发生该问题的执行操作，出现问题的表征及大概的时间，在<a href='https://github.com/taosdata/TDengine'> GitHub</a>提交Issue。
 
-为了保证有足够的debug信息，如果问题能够重复，请修改/etc/taos/taos.cfg文件，最后面添加一行“debugFlag 135"(不带引号本身），然后重启taosd, 重复问题，然后再递交。但系统正常运行时，请一定将debugFlag设置为131，否则会产生大量的日志信息，降低系统效率。
+为了保证有足够的debug信息，如果问题能够重复，请修改/etc/taos/taos.cfg文件，最后面添加一行“debugFlag 135"(不带引号本身），然后重启taosd, 重复问题，然后再递交。也可以通过如下SQL语句，临时设置taosd的日志级别。
+```
+    alter dnode <dnode_id> debugFlag 135;
+```
+但系统正常运行时，请一定将debugFlag设置为131，否则会产生大量的日志信息，降低系统效率。

documentation20/webdocs/markdowndocs/insert-ch.md

@@ -22,7 +22,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 
 **Tips:** 
 
-- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过16K，一条SQL语句总长度不能超过64K（可通过参数maxSQLLength配置，最大可配置为8M）。
+- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过16K，一条SQL语句总长度不能超过64K（可通过参数maxSQLLength配置，最大可配置为1M）。
 - TDengine支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开20个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程切频繁切换，带来额外开销。
 - 对同一张表，如果新插入记录的时间戳已经存在，新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。
 - 写入的数据的时间戳必须大于当前时间减去配置参数keep的时间。如果keep配置为3650天，那么无法写入比3650天还老的数据。写入数据的时间戳也不能大于当前时间加配置参数days。如果days配置为2，那么无法写入比当前时间还晚2天的数据。

documentation20/webdocs/markdowndocs/replica-ch.md

@@ -66,21 +66,21 @@ TDengine采取的是Master-Slave模式进行同步，与流行的RAFT一致性
 
 数据实时复制有三个主要流程：选主、数据转发、数据恢复。后续做详细讨论。
 
-## 虚拟节点之间的网络链接
+## 虚拟节点之间的网络连接
 
-虚拟节点之间通过TCP进行链接，节点之间的状态交换、数据包的转发都是通过这个TCP链接(peerFd)进行。为避免竞争，两个虚拟节点之间的TCP链接，总是由IP地址(UINT32)小的节点作为TCP客户端发起。一旦TCP链接被中断，虚拟节点能通过TCP socket自动检测到，将对方标为offline。如果监测到任何错误（比如数据恢复流程），虚拟节点将主动重置该链接。
+虚拟节点之间通过TCP进行连接，节点之间的状态交换、数据包的转发都是通过这个TCP连接(peerFd)进行。为避免竞争，两个虚拟节点之间的TCP连接，总是由IP地址(UINT32)小的节点作为TCP客户端发起。一旦TCP连接被中断，虚拟节点能通过TCP socket自动检测到，将对方标为offline。如果监测到任何错误（比如数据恢复流程），虚拟节点将主动重置该连接。
 
-一旦作为客户端的节点链接不成或中断，它将周期性的每隔一秒钟去试图去链接一次。因为TCP本身有心跳机制，虚拟节点之间不再另行提供心跳。
+一旦作为客户端的节点连接不成或中断，它将周期性的每隔一秒钟去试图去连接一次。因为TCP本身有心跳机制，虚拟节点之间不再另行提供心跳。
 
-如果一个unsynced节点要发起数据恢复流程，它与Master将建立起专有的TCP链接(syncFd)。数据恢复完成后，该链接会被关闭。而且为限制资源的使用，系统只容许一定数量(配置参数tsMaxSyncNum)的数据恢复的socket存在。如果超过这个数字，系统会将新的数据恢复请求延后处理。
+如果一个unsynced节点要发起数据恢复流程，它与Master将建立起专有的TCP连接(syncFd)。数据恢复完成后，该连接会被关闭。而且为限制资源的使用，系统只容许一定数量(配置参数tsMaxSyncNum)的数据恢复的socket存在。如果超过这个数字，系统会将新的数据恢复请求延后处理。
 
-任意一个节点，无论有多少虚拟节点，都会启动而且只会启动一个TCP server, 来接受来自其他虚拟节点的上述两类TCP的链接请求。当TCP socket建立起来，客户端侧发送的消息体里会带有vgId（全局唯一的vgroup ID), TCP 服务器侧会检查该vgId是否已经在该节点启动运行。如果已经启动运行，就接受其请求。如果不存在，就直接将链接请求关闭。在TDengine代码里，mnode group的vgId设置为1。 
+任意一个节点，无论有多少虚拟节点，都会启动而且只会启动一个TCP server, 来接受来自其他虚拟节点的上述两类TCP的连接请求。当TCP socket建立起来，客户端侧发送的消息体里会带有vgId（全局唯一的vgroup ID), TCP 服务器侧会检查该vgId是否已经在该节点启动运行。如果已经启动运行，就接受其请求。如果不存在，就直接将连接请求关闭。在TDengine代码里，mnode group的vgId设置为1。 
 
 ## 选主流程
 
 当同一组的两个虚拟节点之间(vnode A, vnode B)建立连接后，他们互换status消息。status消息里包含本地存储的同一虚拟节点组内所有虚拟节点的role和version。
 
-如果一个虚拟节点(vnode A)检测到与同一虚拟节点组内另外一虚拟节点（vnode B）的链接中断，vnode A将立即把vnode B的role设置为offline。无论是接收到另外一虚拟节点发来的status消息，还是检测与另外一虚拟节点的链接中断，该虚拟节点都将进入状态处理流程。状态处理流程的规则如下：
+如果一个虚拟节点(vnode A)检测到与同一虚拟节点组内另外一虚拟节点（vnode B）的连接中断，vnode A将立即把vnode B的role设置为offline。无论是接收到另外一虚拟节点发来的status消息，还是检测与另外一虚拟节点的连接中断，该虚拟节点都将进入状态处理流程。状态处理流程的规则如下：
 
 1. 如果检测到在线的节点数没有超过一半，则将自己的状态设置为unsynced.
 2. 如果在线的虚拟节点数超过一半，会检查master节点是否存在，如果存在，则会决定是否将自己状态改为slave或启动数据恢复流程
@@ -118,7 +118,7 @@ TDengine采取的是Master-Slave模式进行同步，与流行的RAFT一致性
 9. 如果quorum为1，上述6，7，8步不会发生。
 10. 如果要等待slave的确认，master会启动2秒的定时器（可配置），如果超时，则认为失败。
 
-对于回复确认，sync模块提供的是异步回调函数，因此APP在调用syncForwardToPeer之后，无需等待，可以处理下一个操作。在Master与Slave的TCP链接管道里，可能有多个Forward消息，这些消息是严格按照应用提供的顺序排好的。对于Forward Response也是一样，TCP管道里存在多个，但都是排序好的。这个顺序，SYNC模块并没有做特别的事情，是由APP单线程顺序写来保证的(TDengine里每个vnode的写数据，都是单线程）。
+对于回复确认，sync模块提供的是异步回调函数，因此APP在调用syncForwardToPeer之后，无需等待，可以处理下一个操作。在Master与Slave的TCP连接管道里，可能有多个Forward消息，这些消息是严格按照应用提供的顺序排好的。对于Forward Response也是一样，TCP管道里存在多个，但都是排序好的。这个顺序，SYNC模块并没有做特别的事情，是由APP单线程顺序写来保证的(TDengine里每个vnode的写数据，都是单线程）。
 
 ## 数据恢复流程
 
@@ -142,9 +142,9 @@ TDengine采取的是Master-Slave模式进行同步，与流行的RAFT一致性
 
 <center> <img src="../assets/replica-restore.png"> </center>
 
-1. 通过已经建立的TCP链接，发送sync req给master节点
-2. master收到sync req后，以client的身份，向vnode B主动建立一新的专用于同步的TCP链接（syncFd)
-3. 新的TCP链接建立成功后，master将开始retrieve流程，对应的，vnode B将同步启动restore流程
+1. 通过已经建立的TCP连接，发送sync req给master节点
+2. master收到sync req后，以client的身份，向vnode B主动建立一新的专用于同步的TCP连接（syncFd)
+3. 新的TCP连接建立成功后，master将开始retrieve流程，对应的，vnode B将同步启动restore流程
 4. Retrieve/Restore流程里，先处理所有archived data (vnode里的data, head, last文件），后处理WAL data。
 5. 对于archived data，master将通过回调函数getFileInfo获取数据文件的基本信息，包括文件名、magic以及文件大小。
 6. master 将获得的文件名、magic以及文件大小发给vnode B
@@ -157,7 +157,7 @@ TDengine采取的是Master-Slave模式进行同步，与流行的RAFT一致性
 1. master节点调用回调函数getWalInfo，获取WAL的文件名。
 2. 如果getWalInfo返回值大于0，表示该文件还不是最后一个WAL，因此master调用sendfile一下把该文件发送给vnode B
 3. 如果getWalInfo返回时为0，表示该文件是最后一个WAL，因为文件可能还处于写的状态中，sync模块要根据WAL Head的定义逐条读出记录，然后发往vnode B。
-4. vnode A读取TCP链接传来的数据，按照WAL Head，逐条读取，如果版本号比现有的大，调用回调函数writeToCache，交给应用处理。如果小，直接扔掉。
+4. vnode A读取TCP连接传来的数据，按照WAL Head，逐条读取，如果版本号比现有的大，调用回调函数writeToCache，交给应用处理。如果小，直接扔掉。
 5. 上述流程循环，直到所有WAL文件都被处理完。处理完后，master就会将新来的数据包通过Forward消息转发给slave。
 
 从同步文件启动起，sync模块会通过inotify监控所有处理过的file以及wal。一旦发现被处理过的文件有更新变化，同步流程将中止，会重新启动。因为有可能落盘操作正在进行（比如历史数据导入，内存数据落盘），把已经处理过的文件进行了修改，需要重新同步才行。
@@ -194,15 +194,15 @@ sync模块通过inotify监控LastWal文件的更新和关闭操作。而且在
 
 因为写入失败，客户端会重新写入数据。但对于TDengine而言，是OK的。因为时序数据都是有时间戳的，时间戳相同的数据更新操作，第一次会执行，但第二次会自动扔掉。对于Meta Data(增加、删除库、表等等）的操作，也是OK的。一张表、库已经被创建或删除，再创建或删除，不会被执行的。
 
-在TDengine的设计里，虚拟节点与虚拟节点之间，是一个TCP链接，是一个pipeline，数据块一个接一个按顺序在这个pipeline里等待处理。一旦某个数据块的处理失败，这个链接会被重置，后续的数据块的处理都会失败。因此不会存在Pipeline里一个数据块更新失败，但下一个数据块成功的可能。
+在TDengine的设计里，虚拟节点与虚拟节点之间，是一个TCP连接，是一个pipeline，数据块一个接一个按顺序在这个pipeline里等待处理。一旦某个数据块的处理失败，这个连接会被重置，后续的数据块的处理都会失败。因此不会存在Pipeline里一个数据块更新失败，但下一个数据块成功的可能。
 
 ## Split Brain的问题
 
 选举流程中，有个强制要求，那就是一定有超过半数的虚拟节点在线。但是如果replication正好是偶数，这个时候，完全可能存在splt brain问题。
 
-为解决这个问题，TDengine提供Arbitrator的解决方法。Arbitrator是一个节点，它的任务就是接受任何虚拟节点的链接请求，并保持它。
+为解决这个问题，TDengine提供Arbitrator的解决方法。Arbitrator是一个节点，它的任务就是接受任何虚拟节点的连接请求，并保持它。
 
-在启动复制模块实例时，在配置参数中，应用可以提供Arbitrator的IP地址。如果是奇数个副本，复制模块不会与这个arbitrator去建立链接，但如果是偶数个副本，就会主动去建立链接。
+在启动复制模块实例时，在配置参数中，应用可以提供Arbitrator的IP地址。如果是奇数个副本，复制模块不会与这个arbitrator去建立连接，但如果是偶数个副本，就会主动去建立连接。
 
 Arbitrator的程序tarbitrator.c在复制模块的同一目录, 编译整个系统时，会在bin目录生成。命令行参数“-？”查看可以配置的参数，比如绑定的IP地址，监听的端口号。
 

documentation20/webdocs/markdowndocs/taosd-ch.md

@@ -13,7 +13,7 @@ taosd的启动入口是dnode模块，dnode然后启动其他模块，包括可
 
 该模块负责taosd与taosc, 以及其他数据节点之间的通讯。TDengine没有采取标准的HTTP或gRPC等第三方工具，而是实现了自己的通讯模块RPC。
 
-考虑到物联网场景下，数据写入的包一般不大，因此除支持TCP链接之外，RPC还支持UDP链接。当数据包小于15K时，RPC将采用UDP方式进行链接，否则将采用TCP链接。对于查询类的消息，RPC不管包的大小，总是采取TCP链接。对于UDP链接，RPC实现了自己的超时、重传、顺序检查等机制，以保证数据可靠传输。
+考虑到物联网场景下，数据写入的包一般不大，因此除支持TCP连接之外，RPC还支持UDP连接。当数据包小于15K时，RPC将采用UDP方式进行连接，否则将采用TCP连接。对于查询类的消息，RPC不管包的大小，总是采取TCP连接。对于UDP连接，RPC实现了自己的超时、重传、顺序检查等机制，以保证数据可靠传输。
 
 RPC模块还提供数据压缩功能，如果数据包的字节数超过系统配置参数compressMsgSize, RPC在传输中将自动压缩数据，以节省带宽。
 
@@ -25,7 +25,7 @@ RPC模块还提供数据压缩功能，如果数据包的字节数超过系统
 
 - 系统的初始化，包括
   - 从文件taos.cfg读取系统配置参数，从文件dnodeCfg.json读取数据节点的配置参数；
-  - 启动RPC模块，并建立起与taosc通讯的server链接，与其他数据节点通讯的server链接；
+  - 启动RPC模块，并建立起与taosc通讯的server连接，与其他数据节点通讯的server连接；
   - 启动并初始化dnode的内部管理, 该模块将扫描该数据节点已有的vnode，并打开它们；
   - 初始化可配置的模块，如mnode, http, monitor等。
 - 数据节点的管理，包括
@@ -61,7 +61,7 @@ vnode与其子模块是通过API直接调用，而不是通过消息队列传递
 
 mnode是整个系统的大脑，负责整个系统的资源调度，负责meta data的管理与存储。
 
-一个运行的系统里，只有一个mnode，但它有多个副本（由系统配置参数numOfMpeers控制）。这些副本分布在不同的dnode里，目的是保证系统的高可靠运行。副本之间的数据复制是采用同步而非异步的方式，以确保数据的一致性，确保数据不会丢失。这些副本会自动选举一个Master，其他副本是slave。所有数据更新类的操作，都只能在master上进行，而查询类的可以在slave节点上进行。代码实现上，同步模块与vnode共享，但mnode被分配一个特殊的vgroup ID: 1，而且quorum大于1。整个集群系统是由多个dnode组成的，运行的mnode的副本数不可能超过dnode的个数，但不会超过配置的副本数。如果某个mnode副本宕机一段时间，只要超过半数的mnode副本仍在运行，运行的mnode会自动根据整个系统的资源情况，在其他dnode里再启动一个mnode, 以保证运行的副本数。
+一个运行的系统里，只有一个mnode，但它有多个副本（由系统配置参数numOfMnodes控制）。这些副本分布在不同的dnode里，目的是保证系统的高可靠运行。副本之间的数据复制是采用同步而非异步的方式，以确保数据的一致性，确保数据不会丢失。这些副本会自动选举一个Master，其他副本是slave。所有数据更新类的操作，都只能在master上进行，而查询类的可以在slave节点上进行。代码实现上，同步模块与vnode共享，但mnode被分配一个特殊的vgroup ID: 1，而且quorum大于1。整个集群系统是由多个dnode组成的，运行的mnode的副本数不可能超过dnode的个数，但不会超过配置的副本数。如果某个mnode副本宕机一段时间，只要超过半数的mnode副本仍在运行，运行的mnode会自动根据整个系统的资源情况，在其他dnode里再启动一个mnode, 以保证运行的副本数。
 
 各个dnode通过信息交换，保存有mnode各个副本的End Point列表，并向其中的master节点定时（间隔由系统配置参数statusInterval控制）发送status消息，消息体里包含该dnode的CPU、内存、剩余存储空间、vnode个数，以及各个vnode的状态(存储空间、原始数据大小、记录条数、角色等）。这样mnode就了解整个系统的资源情况，如果用户创建新的表，就可以决定需要在哪个dnode创建；如果增加或删除dnode, 或者监测到某dnode数据过热、或离线太长，就可以决定需要挪动那些vnode，以实现负载均衡。
 

packaging/cfg/taos.cfg

@@ -6,10 +6,7 @@
 ########################################################
 
 # first fully qualified domain name (FQDN) for TDengine system
-# firstEp               hostname1:6030
-
-# second fully qualified domain name (FQDN) for TDengine system, for cluster only
-# secondEp              cluster_hostname2:6030
+# firstEp                   hostname:6030
 
 # local fully qualified domain name (FQDN)
 # fqdn                      hostname
@@ -29,12 +26,18 @@
 # number of threads per CPU core
 # numOfThreadsPerCore       1.0
 
+# the proportion of total threads responsible for query
+# ratioOfQueryThreads       0.5
+
 # number of management nodes in the system
 # numOfMnodes               3
 
 # enable/disable backuping vnode directory when removing dnode
 # vnodeBak                  1
 
+# if report installation / use information
+# telemetryReporting        1
+
 # enable/disable load balancing
 # balance                   1
 
@@ -89,9 +92,6 @@
 # max number of tables per vnode
 # maxTablesPerVnode         1000000
 
-# step size of increasing table number in a vnode
-# tableIncStepPerVnode      1000
-
 # cache block size (Mbyte)
 # cache                     16
 
@@ -110,6 +110,9 @@
 # maximum rows of records in file block
 # maxRows               4096
 
+# the number of acknowledgments required for successful data writing
+# quorum                1     
+
 # enable/disable compression
 # comp                  2
 
@@ -122,15 +125,6 @@
 # number of replications, for cluster only 
 # replica               1
 
-# mqtt hostname  
-# mqttHostName          test.mosquitto.org
-
-# mqtt port  
-# mqttPort              1883
-
-# mqtt topic
-# mqttTopic             /test
-
 # the compressed rpc message, option:
 #  -1 (no compression)
 #   0 (all message compressed),
@@ -167,12 +161,12 @@
 # stop writing data when the disk size of the log folder is less than this value
 # minimalDataDirGB      0.1
 
+# One mnode is equal to the number of vnode consumed
+# mnodeEqualVnodeNum    4
+
 # enbale/disable http service
 # http                  1
 
-# enable/disable muqq service
-# mqtt                  0
-
 # enable/disable system monitor 
 # monitor               1
 
@@ -189,11 +183,12 @@
 # max number of rows per log filters
 # numOfLogLines         10000000
 
+# enable/disable async log
+# asyncLog              1
+
 # time of keeping log files, days
 # logKeepDays           0
 
-# enable/disable async log
-# asyncLog              1
 
 # The following parameters are used for debug purpose only.
 # debugFlag 8 bits mask: FILE-SCREEN-UNUSED-HeartBeat-DUMP-TRACE_WARN-ERROR
@@ -231,18 +226,12 @@
 # debug flag for JNI
 # jniDebugflag          131
 
-# debug flag for ODBC
-# odbcDebugflag         131
-
 # debug flag for storage
 # uDebugflag            131
 
 # debug flag for http server
 # httpDebugFlag         131
 
-# debug flag for mqtt
-# mqttDebugFlag         131
-
 # debug flag for monitor
 # monitorDebugFlag      131
 
@@ -255,6 +244,9 @@
 # debug flag for http server
 # tsdbDebugFlag         131
 
+# debug flag for continue query
+# cqDebugFlag           131
+
 # enable/disable recording the SQL in taos client
 # tscEnableRecordSql    0
 

packaging/deb/makedeb.sh

@@ -57,7 +57,8 @@ cp -r ${top_dir}/tests/examples/*                   ${pkg_dir}${install_home_pat
 cp -r ${top_dir}/src/connector/grafanaplugin        ${pkg_dir}${install_home_path}/connector
 cp -r ${top_dir}/src/connector/python               ${pkg_dir}${install_home_path}/connector
 cp -r ${top_dir}/src/connector/go                   ${pkg_dir}${install_home_path}/connector
-cp ${compile_dir}/build/lib/taos-jdbcdriver*dist.*  ${pkg_dir}${install_home_path}/connector
+cp -r ${top_dir}/src/connector/nodejs               ${pkg_dir}${install_home_path}/connector
+cp ${compile_dir}/build/lib/taos-jdbcdriver*dist.*  ${pkg_dir}${install_home_path}/connector ||:
 
 cp -r ${compile_dir}/../packaging/deb/DEBIAN        ${pkg_dir}/
 chmod 755 ${pkg_dir}/DEBIAN/*

packaging/docker/Dockerfile

-FROM centos:7
+FROM ubuntu:20.04
 
 WORKDIR /root
 
+ARG version
+RUN echo $version
 COPY tdengine.tar.gz /root/
 RUN tar -zxf tdengine.tar.gz
-WORKDIR /root/TDengine-server/
-RUN sh install.sh -e no
+WORKDIR /root/TDengine-server-$version/
+RUN /bin/bash install.sh -e no
 
 
 ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/lib"

packaging/docker/dockerbuild-aarch64.sh

+#!/bin/bash
+set -x
+docker build --rm -f "Dockerfile" -t tdengine/tdengine-aarch64:$1 "." --build-arg version=$1
+docker login -u tdengine -p $2  #replace the docker registry username and password
+docker push tdengine/tdengine-aarch64:$1

packaging/docker/dockerbuild.sh

 #!/bin/bash
 set -x
-docker build --rm -f "Dockerfile" -t tdengine/tdengine:$1 "."
+docker build --rm -f "Dockerfile" -t tdengine/tdengine:$1 "." --build-arg version=$1
 docker login -u tdengine -p $2  #replace the docker registry username and password
 docker push tdengine/tdengine:$1

packaging/release.sh

@@ -156,9 +156,15 @@ build_time=$(date +"%F %R")
 
 # get commint id from git
 gitinfo=$(git rev-parse --verify HEAD)
-enterprise_dir="${top_dir}/../enterprise"
-cd ${enterprise_dir}
-gitinfoOfInternal=$(git rev-parse --verify HEAD)
+
+if [[ "$verMode" == "cluster" ]]; then
+  enterprise_dir="${top_dir}/../enterprise"
+  cd ${enterprise_dir}
+  gitinfoOfInternal=$(git rev-parse --verify HEAD)
+else
+  gitinfoOfInternal=NULL
+fi
+  
 cd ${curr_dir}
 
 # 2. cmake executable file
@@ -193,6 +199,9 @@ cd ${curr_dir}
 # 3. Call the corresponding script for packaging
 if [ "$osType" != "Darwin" ]; then
   if [[ "$verMode" != "cluster" ]] && [[ "$cpuType" == "x64" ]] && [[ "$dbName" == "taos" ]]; then
+    ret='0'    
+    command -v dpkg >/dev/null 2>&1 || { ret='1'; }
+    if [ "$ret" -eq 0 ]; then  
       echo "====do deb package for the ubuntu system===="
       output_dir="${top_dir}/debs"
       if [ -d ${output_dir} ]; then
@@ -201,7 +210,13 @@ if [ "$osType" != "Darwin" ]; then
       ${csudo} mkdir -p ${output_dir}
       cd ${script_dir}/deb
       ${csudo} ./makedeb.sh ${compile_dir} ${output_dir} ${verNumber} ${cpuType} ${osType} ${verMode} ${verType}
+    else
+      echo "==========dpkg command not exist, so not release deb package!!!"
+    fi
 
+    ret='0'    
+    command -v rpmbuild >/dev/null 2>&1 || { ret='1'; }
+    if [ "$ret" -eq 0 ]; then  
       echo "====do rpm package for the centos system===="
       output_dir="${top_dir}/rpms"
       if [ -d ${output_dir} ]; then
@@ -210,6 +225,9 @@ if [ "$osType" != "Darwin" ]; then
       ${csudo} mkdir -p ${output_dir}
       cd ${script_dir}/rpm
       ${csudo} ./makerpm.sh ${compile_dir} ${output_dir} ${verNumber} ${cpuType} ${osType} ${verMode} ${verType}
+    else
+      echo "==========rpmbuild command not exist, so not release rpm package!!!"
+    fi
   fi
 	
   echo "====do tar.gz package for all systems===="

packaging/rpm/tdengine.spec

@@ -64,7 +64,8 @@ cp %{_compiledir}/../src/inc/taoserror.h            %{buildroot}%{homepath}/incl
 cp -r %{_compiledir}/../src/connector/grafanaplugin %{buildroot}%{homepath}/connector
 cp -r %{_compiledir}/../src/connector/python        %{buildroot}%{homepath}/connector
 cp -r %{_compiledir}/../src/connector/go            %{buildroot}%{homepath}/connector
-cp %{_compiledir}/build/lib/taos-jdbcdriver*dist.*  %{buildroot}%{homepath}/connector
+cp -r %{_compiledir}/../src/connector/nodejs        %{buildroot}%{homepath}/connector
+cp %{_compiledir}/build/lib/taos-jdbcdriver*dist.*  %{buildroot}%{homepath}/connector ||:
 cp -r %{_compiledir}/../tests/examples/*            %{buildroot}%{homepath}/examples
 
 #Scripts executed before installation

packaging/tools/install.sh

@@ -272,6 +272,29 @@ function install_config() {
             break
         fi
     done	
+
+    # user email 
+    #EMAIL_PATTERN='^[A-Za-z0-9\u4e00-\u9fa5]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$'
+    #EMAIL_PATTERN='^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$'
+    #EMAIL_PATTERN="^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"
+    echo
+    echo -e -n "${GREEN}Enter your email address for priority support or enter empty to skip${NC}: "
+    read emailAddr
+    while true; do
+        if [ ! -z "$emailAddr" ]; then
+            # check the format of the emailAddr
+            #if [[ "$emailAddr" =~ $EMAIL_PATTERN ]]; then
+                # Write the email address to temp file                    
+                email_file="${install_main_dir}/email" 
+                ${csudo} bash -c "echo $emailAddr > ${email_file}"
+                break         
+            #else
+            #    read -p "Please enter the correct email address: " emailAddr   
+            #fi
+        else
+            break
+        fi
+    done	
 }
 
 

packaging/tools/make_install.sh

@@ -278,11 +278,11 @@ function install_service_on_sysvinit() {
 
     # Install taosd service
     if ((${os_type}==1)); then
-    ${csudo} cp -f ${script_dir}/../deb/init.d/taosd ${install_main_dir}/init.d
-    ${csudo} cp    ${script_dir}/../deb/init.d/taosd ${service_config_dir} && ${csudo} chmod a+x ${service_config_dir}/taosd
+    ${csudo} cp -f ${script_dir}/../deb/taosd ${install_main_dir}/init.d
+    ${csudo} cp    ${script_dir}/../deb/taosd ${service_config_dir} && ${csudo} chmod a+x ${service_config_dir}/taosd
     elif ((${os_type}==2)); then
-    ${csudo} cp -f ${script_dir}/../rpm/init.d/taosd ${install_main_dir}/init.d
-    ${csudo} cp    ${script_dir}/../rpm/init.d/taosd ${service_config_dir} && ${csudo} chmod a+x ${service_config_dir}/taosd
+    ${csudo} cp -f ${script_dir}/../rpm/taosd ${install_main_dir}/init.d
+    ${csudo} cp    ${script_dir}/../rpm/taosd ${service_config_dir} && ${csudo} chmod a+x ${service_config_dir}/taosd
     fi
     
     #restart_config_str="taos:2345:respawn:${service_config_dir}/taosd start"

packaging/tools/makearbi.sh

@@ -25,9 +25,9 @@ release_dir="${top_dir}/release"
 
 #package_name='linux'
 if [ "$verMode" == "cluster" ]; then
-    install_dir="${release_dir}/TDengine-enterprise-arbitrator"
+    install_dir="${release_dir}/TDengine-enterprise-arbitrator-${version}"
 else
-    install_dir="${release_dir}/TDengine-arbitrator"
+    install_dir="${release_dir}/TDengine-arbitrator-${version}"
 fi
 
 # Directories and files.
@@ -48,9 +48,9 @@ mkdir -p ${install_dir}/init.d && cp ${init_file_tarbitrator_rpm} ${install_dir}
 cd ${release_dir} 
 
 if [ "$verMode" == "cluster" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 elif [ "$verMode" == "edge" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 else
   echo "unknow verMode, nor cluster or edge"
   exit 1

packaging/tools/makearbi_power.sh

@@ -25,9 +25,9 @@ release_dir="${top_dir}/release"
 
 #package_name='linux'
 if [ "$verMode" == "cluster" ]; then
-    install_dir="${release_dir}/PowerDB-enterprise-arbitrator"
+    install_dir="${release_dir}/PowerDB-enterprise-arbitrator-${version}"
 else
-    install_dir="${release_dir}/PowerDB-arbitrator"
+    install_dir="${release_dir}/PowerDB-arbitrator-${version}"
 fi
 
 # Directories and files.
@@ -48,9 +48,9 @@ mkdir -p ${install_dir}/init.d && cp ${init_file_tarbitrator_rpm} ${install_dir}
 cd ${release_dir} 
 
 if [ "$verMode" == "cluster" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 elif [ "$verMode" == "edge" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 else
   echo "unknow verMode, nor cluster or edge"
   exit 1

packaging/tools/makeclient.sh

@@ -32,9 +32,9 @@ release_dir="${top_dir}/release"
 #package_name='linux'
 
 if [ "$verMode" == "cluster" ]; then
-    install_dir="${release_dir}/TDengine-enterprise-client"
+    install_dir="${release_dir}/TDengine-enterprise-client-${version}"
 else
-    install_dir="${release_dir}/TDengine-client"
+    install_dir="${release_dir}/TDengine-client-${version}"
 fi
 
 # Directories and files.
@@ -97,6 +97,8 @@ if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   cp -r ${examples_dir}/python ${install_dir}/examples
   cp -r ${examples_dir}/R      ${install_dir}/examples
   cp -r ${examples_dir}/go     ${install_dir}/examples
+  cp -r ${examples_dir}/nodejs ${install_dir}/examples
+  cp -r ${examples_dir}/C#     ${install_dir}/examples
 fi
 # Copy driver
 mkdir -p ${install_dir}/driver 
@@ -108,11 +110,12 @@ mkdir -p ${install_dir}/connector
 
 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   if [ "$osType" != "Darwin" ]; then
-    cp ${build_dir}/lib/*.jar      ${install_dir}/connector
+    cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
   fi
   cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
   cp -r ${connector_dir}/python        ${install_dir}/connector/
   cp -r ${connector_dir}/go            ${install_dir}/connector
+  cp -r ${connector_dir}/nodejs        ${install_dir}/connector
 fi
 # Copy release note
 # cp ${script_dir}/release_note ${install_dir}
@@ -122,9 +125,9 @@ fi
 cd ${release_dir} 
 
 if [ "$verMode" == "cluster" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 elif [ "$verMode" == "edge" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 else
   echo "unknow verMode, nor cluster or edge"
   exit 1

packaging/tools/makeclient_power.sh

@@ -32,9 +32,9 @@ release_dir="${top_dir}/release"
 #package_name='linux'
 
 if [ "$verMode" == "cluster" ]; then
-    install_dir="${release_dir}/PowerDB-enterprise-client"
+    install_dir="${release_dir}/PowerDB-enterprise-client-${version}"
 else
-    install_dir="${release_dir}/PowerDB-client"
+    install_dir="${release_dir}/PowerDB-client-${version}"
 fi
 
 # Directories and files.
@@ -123,7 +123,7 @@ if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   cp -r ${examples_dir}/R      ${install_dir}/examples
   sed -i '/password/ {s/taosdata/powerdb/g}'  ${install_dir}/examples/R/command.txt
   cp -r ${examples_dir}/go     ${install_dir}/examples  
-  sed -i '/root/ {s/taosdata/powerdb/g}'  ${install_dir}/examples/go/src/taosapp/taosapp.go
+  sed -i '/root/ {s/taosdata/powerdb/g}'  ${install_dir}/examples/go/taosdemo.go
 fi
 # Copy driver
 mkdir -p ${install_dir}/driver 
@@ -135,7 +135,7 @@ mkdir -p ${install_dir}/connector
 
 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   if [ "$osType" != "Darwin" ]; then
-    cp ${build_dir}/lib/*.jar      ${install_dir}/connector
+    cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
   fi
   cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
   cp -r ${connector_dir}/python  ${install_dir}/connector/
@@ -164,9 +164,9 @@ fi
 cd ${release_dir} 
 
 if [ "$verMode" == "cluster" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 elif [ "$verMode" == "edge" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 else
   echo "unknow verMode, nor cluster or edge"
   exit 1

packaging/tools/makepkg.sh

@@ -25,9 +25,9 @@ release_dir="${top_dir}/release"
 
 #package_name='linux'
 if [ "$verMode" == "cluster" ]; then
-    install_dir="${release_dir}/TDengine-enterprise-server"
+    install_dir="${release_dir}/TDengine-enterprise-server-${version}"
 else
-    install_dir="${release_dir}/TDengine-server"
+    install_dir="${release_dir}/TDengine-server-${version}"
 fi
 
 # Directories and files.
@@ -113,6 +113,8 @@ if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   cp -r ${examples_dir}/python ${install_dir}/examples
   cp -r ${examples_dir}/R      ${install_dir}/examples
   cp -r ${examples_dir}/go     ${install_dir}/examples
+  cp -r ${examples_dir}/nodejs ${install_dir}/examples
+  cp -r ${examples_dir}/C#     ${install_dir}/examples
 fi
 # Copy driver
 mkdir -p ${install_dir}/driver 
@@ -122,10 +124,11 @@ cp ${lib_files} ${install_dir}/driver
 connector_dir="${code_dir}/connector"
 mkdir -p ${install_dir}/connector
 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
-  cp ${build_dir}/lib/*.jar      ${install_dir}/connector
+  cp ${build_dir}/lib/*.jar            ${install_dir}/connector ||:
   cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
   cp -r ${connector_dir}/python        ${install_dir}/connector/
   cp -r ${connector_dir}/go            ${install_dir}/connector
+  cp -r ${connector_dir}/nodejs        ${install_dir}/connector
 fi
 # Copy release note
 # cp ${script_dir}/release_note ${install_dir}
@@ -135,9 +138,9 @@ fi
 cd ${release_dir} 
 
 if [ "$verMode" == "cluster" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 elif [ "$verMode" == "edge" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 else
   echo "unknow verMode, nor cluster or edge"
   exit 1

packaging/tools/makepkg_power.sh

@@ -25,9 +25,9 @@ release_dir="${top_dir}/release"
 
 #package_name='linux'
 if [ "$verMode" == "cluster" ]; then
-    install_dir="${release_dir}/PowerDB-enterprise-server"
+    install_dir="${release_dir}/PowerDB-enterprise-server-${version}"
 else
-    install_dir="${release_dir}/PowerDB-server"
+    install_dir="${release_dir}/PowerDB-server-${version}"
 fi
 
 # Directories and files.
@@ -146,7 +146,7 @@ if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   cp -r ${examples_dir}/R      ${install_dir}/examples
   sed -i '/password/ {s/taosdata/powerdb/g}'  ${install_dir}/examples/R/command.txt  
   cp -r ${examples_dir}/go     ${install_dir}/examples  
-  sed -i '/root/ {s/taosdata/powerdb/g}'  ${install_dir}/examples/go/src/taosapp/taosapp.go
+  sed -i '/root/ {s/taosdata/powerdb/g}'  ${install_dir}/examples/go/taosdemo.go
 fi
 # Copy driver
 mkdir -p ${install_dir}/driver 
@@ -156,7 +156,7 @@ cp ${lib_files} ${install_dir}/driver
 connector_dir="${code_dir}/connector"
 mkdir -p ${install_dir}/connector
 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
-  cp ${build_dir}/lib/*.jar      ${install_dir}/connector
+  cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
   cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
   cp -r ${connector_dir}/python  ${install_dir}/connector/
   cp -r ${connector_dir}/go      ${install_dir}/connector
@@ -184,9 +184,9 @@ fi
 cd ${release_dir} 
 
 if [ "$verMode" == "cluster" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 elif [ "$verMode" == "edge" ]; then
-  pkg_name=${install_dir}-${version}-${osType}-${cpuType}
+  pkg_name=${install_dir}-${osType}-${cpuType}
 else
   echo "unknow verMode, nor cluster or edge"
   exit 1

packaging/tools/post.sh

@@ -10,6 +10,7 @@ data_dir="/var/lib/taos"
 log_dir="/var/log/taos"
 data_link_dir="/usr/local/taos/data"
 log_link_dir="/usr/local/taos/log"
+install_main_dir="/usr/local/taos"
 
 # static directory
 cfg_dir="/usr/local/taos/cfg"
@@ -135,6 +136,29 @@ function install_config() {
             break
         fi
     done		
+
+    # user email 
+    #EMAIL_PATTERN='^[A-Za-z0-9\u4e00-\u9fa5]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$'
+    #EMAIL_PATTERN='^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$'
+    #EMAIL_PATTERN="^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"
+    echo
+    echo -e -n "${GREEN}Enter your email address for priority support or enter empty to skip${NC}: "
+    read emailAddr
+    while true; do
+        if [ ! -z "$emailAddr" ]; then
+            # check the format of the emailAddr
+            #if [[ "$emailAddr" =~ $EMAIL_PATTERN ]]; then
+                # Write the email address to temp file                    
+                email_file="${install_main_dir}/email" 
+                ${csudo} bash -c "echo $emailAddr > ${email_file}"
+                break         
+            #else
+            #    read -p "Please enter the correct email address: " emailAddr   
+            #fi
+        else
+            break
+        fi
+    done	
 }
 
 function clean_service_on_sysvinit() {

snap/snapcraft.yaml

 name: tdengine
 base: core18
-version: 'RELEASE_VERSION'
+version: '2.0.6.0'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@@ -72,7 +72,7 @@ parts:
       - usr/bin/taosd
       - usr/bin/taos
       - usr/bin/taosdemo
-      - usr/lib/libtaos.so.RELEASE_VERSION
+      - usr/lib/libtaos.so.2.0.6.0
       - usr/lib/libtaos.so.1
       - usr/lib/libtaos.so
 

src/CMakeLists.txt

@@ -20,4 +20,6 @@ ADD_SUBDIRECTORY(tsdb)
 ADD_SUBDIRECTORY(wal)
 ADD_SUBDIRECTORY(cq)
 ADD_SUBDIRECTORY(dnode)
+ADD_SUBDIRECTORY(connector/odbc)
 ADD_SUBDIRECTORY(connector/jdbc)
+

src/balance/src/balance.c

@@ -126,6 +126,8 @@ int32_t balanceAllocVnodes(SVgObj *pVgroup) {
 
   balanceAccquireDnodeList();
 
+  mDebug("db:%s, try alloc %d vnodes to vgroup, dnodes total:%d, avail:%d", pVgroup->dbName, pVgroup->numOfVnodes,
+         mnodeGetDnodesNum(), tsBalanceDnodeListSize);
   for (int32_t i = 0; i < pVgroup->numOfVnodes; ++i) {
     for (; dnode < tsBalanceDnodeListSize; ++dnode) {
       SDnodeObj *pDnode = tsBalanceDnodeList[dnode];
@@ -135,17 +137,33 @@ int32_t balanceAllocVnodes(SVgObj *pVgroup) {
         pVnodeGid->pDnode = pDnode;
         dnode++;
         vnodes++;
+        mDebug("dnode:%d, is selected, vnodeIndex:%d", pDnode->dnodeId, i);
         break;
+      } else {
+        mDebug("dnode:%d, is not selected, status:%s vnodes:%d disk:%fGB role:%d", pDnode->dnodeId,
+               mnodeGetDnodeStatusStr(pDnode->status), pDnode->openVnodes, pDnode->diskAvailable,
+               pDnode->alternativeRole);
       }
     }
   }
 
   if (vnodes != pVgroup->numOfVnodes) {
-    mDebug("vgId:%d, db:%s need vnodes:%d, but alloc:%d, free them", pVgroup->vgId, pVgroup->dbName,
-           pVgroup->numOfVnodes, vnodes);
     balanceReleaseDnodeList();
     balanceUnLock();
 
+    mDebug("db:%s, need vnodes:%d, but alloc:%d", pVgroup->dbName, pVgroup->numOfVnodes, vnodes);
+
+    void *     pIter = NULL;
+    SDnodeObj *pDnode = NULL;
+    while (1) {
+      pIter = mnodeGetNextDnode(pIter, &pDnode);
+      if (pDnode == NULL) break;
+      mDebug("dnode:%d, status:%s vnodes:%d disk:%fGB role:%d", pDnode->dnodeId, mnodeGetDnodeStatusStr(pDnode->status),
+             pDnode->openVnodes, pDnode->diskAvailable, pDnode->alternativeRole);
+      mnodeDecDnodeRef(pDnode);
+    }
+    sdbFreeIter(pIter);
+
     if (mnodeGetOnlineDnodesNum() == 0) {
       return TSDB_CODE_MND_NOT_READY;
     } else {
@@ -198,8 +216,8 @@ static bool balanceCheckVgroupReady(SVgObj *pVgroup, SVnodeGid *pRmVnode) {
     SVnodeGid *pVnode = pVgroup->vnodeGid + i;
     if (pVnode == pRmVnode) continue;
 
-    mTrace("vgId:%d, change vgroup status, dnode:%d status:%d", pVgroup->vgId, pVnode->pDnode->dnodeId,
-           pVnode->pDnode->status);
+    mTrace("vgId:%d, check vgroup status, dnode:%d status:%d, vnode role:%s", pVgroup->vgId, pVnode->pDnode->dnodeId,
+           pVnode->pDnode->status, syncRole[pVnode->role]);
     if (pVnode->pDnode->status == TAOS_DN_STATUS_DROPPING) continue;
     if (pVnode->pDnode->status == TAOS_DN_STATUS_OFFLINE) continue;
 
@@ -389,6 +407,7 @@ void balanceReset() {
     pDnode->lastAccess = 0;
     if (pDnode->status != TAOS_DN_STATUS_DROPPING) {
       pDnode->status = TAOS_DN_STATUS_OFFLINE;
+      pDnode->offlineReason = TAOS_DN_OFF_STATUS_NOT_RECEIVED;
     }
 
     mnodeDecDnodeRef(pDnode);
@@ -551,7 +570,9 @@ static void balanceCheckDnodeAccess() {
     if (tsAccessSquence - pDnode->lastAccess > 3) {
       if (pDnode->status != TAOS_DN_STATUS_DROPPING && pDnode->status != TAOS_DN_STATUS_OFFLINE) {
         pDnode->status = TAOS_DN_STATUS_OFFLINE;
-        mInfo("dnode:%d, set to offline state", pDnode->dnodeId);
+        pDnode->offlineReason = TAOS_DN_OFF_STATUS_MSG_TIMEOUT;
+        mInfo("dnode:%d, set to offline state, access seq:%d, last seq:%d", pDnode->dnodeId, tsAccessSquence,
+              pDnode->lastAccess);
         balanceSetVgroupOffline(pDnode);
       }
     }
@@ -935,6 +956,7 @@ static int32_t balanceRetrieveScores(SShowObj *pShow, char *data, int32_t rows,
     mnodeDecDnodeRef(pDnode);
   }
 
+  mnodeVacuumResult(data, pShow->numOfColumns, numOfRows, rows, pShow);
   pShow->numOfReads += numOfRows;
   return numOfRows;
 }
@@ -955,11 +977,16 @@ static void balanceMonitorDnodeModule() {
       continue;
     }
 
-    mLInfo("dnode:%d, numOfMnodes:%d expect:%d, add mnode in this dnode", pDnode->dnodeId, numOfMnodes, tsNumOfMnodes);
-    mnodeAddMnode(pDnode->dnodeId);
+    mLInfo("dnode:%d, numOfMnodes:%d expect:%d, create mnode in this dnode", pDnode->dnodeId, numOfMnodes, tsNumOfMnodes);
+    mnodeCreateMnode(pDnode->dnodeId, pDnode->dnodeEp, true);
 
+#if 0
+    // Only create one mnode each time
+    return;
+#else
     numOfMnodes = mnodeGetMnodesNum();
     if (numOfMnodes >= tsNumOfMnodes) return;
+#endif
   }
 }
 

src/client/inc/tscLocalMerge.h

@@ -72,17 +72,10 @@ typedef struct SLocalReducer {
   bool                   orderPrjOnSTable;   // projection query on stable
 } SLocalReducer;
 
-typedef struct SSubqueryState {
-  int32_t  numOfRemain;         // the number of remain unfinished subquery
-  int32_t  numOfTotal;          // the number of total sub-queries
-  uint64_t numOfRetrievedRows;  // total number of points in this query
-} SSubqueryState;
-
 typedef struct SRetrieveSupport {
   tExtMemBuffer **  pExtMemBuffer;     // for build loser tree
   tOrderDescriptor *pOrderDescriptor;
   SColumnModel *    pFinalColModel;    // colModel for final result
-  SSubqueryState *  pState;
   int32_t           subqueryIndex;     // index of current vnode in vnode list
   SSqlObj *         pParentSql;
   tFilePage *       localBuffer;       // temp buffer, there is a buffer for each vnode to

src/client/inc/tscSubquery.h

@@ -28,7 +28,7 @@ void tscFetchDatablockFromSubquery(SSqlObj* pSql);
 void tscSetupOutputColumnIndex(SSqlObj* pSql);
 void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code);
 
-SJoinSupporter* tscCreateJoinSupporter(SSqlObj* pSql, SSubqueryState* pState, int32_t index);
+SJoinSupporter* tscCreateJoinSupporter(SSqlObj* pSql, int32_t index);
 
 void tscHandleMasterJoinQuery(SSqlObj* pSql);
 
@@ -39,7 +39,7 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql);
 int32_t tscHandleInsertRetry(SSqlObj* pSql);
 
 void tscBuildResFromSubqueries(SSqlObj *pSql);
-void **doSetResultRowData(SSqlObj *pSql, bool finalResult);
+TAOS_ROW doSetResultRowData(SSqlObj *pSql, bool finalResult);
 
 #ifdef __cplusplus
 }

src/client/inc/tscUtil.h

@@ -66,7 +66,6 @@ typedef struct STidTags {
 #pragma pack(pop)
 
 typedef struct SJoinSupporter {
-  SSubqueryState* pState;
   SSqlObj*        pObj;           // parent SqlObj
   int32_t         subqueryIndex;  // index of sub query
   SInterval       interval;
@@ -83,6 +82,7 @@ typedef struct SJoinSupporter {
   char*           pIdTagList;      // result of first stage tags
   int32_t         totalLen;
   int32_t         num;
+  SArray*         pVgroupTables;
 } SJoinSupporter;
 
 typedef struct SVgroupTableInfo {
@@ -110,7 +110,6 @@ SParamInfo* tscAddParamToDataBlock(STableDataBlocks* pDataBlock, char type, uint
 
 void*   tscDestroyBlockArrayList(SArray* pDataBlockList);
 int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock);
-void    tscFreeUnusedDataBlocks(SArray* pDataBlockList);
 int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SArray* pDataList);
 int32_t tscGetDataBlockFromList(void* pHashList, SArray* pDataBlockList, int64_t id, int32_t size,
                                 int32_t startOffset, int32_t rowSize, const char* tableId, STableMeta* pTableMeta,
@@ -151,14 +150,13 @@ int tscAllocPayload(SSqlCmd* pCmd, int size);
 
 TAOS_FIELD tscCreateField(int8_t type, const char* name, int16_t bytes);
 
-SFieldSupInfo* tscFieldInfoAppend(SFieldInfo* pFieldInfo, TAOS_FIELD* pField);
-SFieldSupInfo* tscFieldInfoInsert(SFieldInfo* pFieldInfo, int32_t index, TAOS_FIELD* field);
+SInternalField* tscFieldInfoAppend(SFieldInfo* pFieldInfo, TAOS_FIELD* pField);
+SInternalField* tscFieldInfoInsert(SFieldInfo* pFieldInfo, int32_t index, TAOS_FIELD* field);
 
-SFieldSupInfo* tscFieldInfoGetSupp(SFieldInfo* pFieldInfo, int32_t index);
+SInternalField* tscFieldInfoGetInternalField(SFieldInfo* pFieldInfo, int32_t index);
 TAOS_FIELD* tscFieldInfoGetField(SFieldInfo* pFieldInfo, int32_t index);
 
 void tscFieldInfoUpdateOffset(SQueryInfo* pQueryInfo);
-void tscFieldInfoCopy(SFieldInfo* dst, const SFieldInfo* src);
 void tscFieldInfoUpdateOffsetForInterResult(SQueryInfo* pQueryInfo);
 
 int16_t tscFieldInfoGetOffset(SQueryInfo* pQueryInfo, int32_t index);
@@ -191,6 +189,7 @@ SColumn* tscColumnListInsert(SArray* pColList, SColumnIndex* colIndex);
 SArray* tscColumnListClone(const SArray* src, int16_t tableIndex);
 void tscColumnListDestroy(SArray* pColList);
 
+void tscDequoteAndTrimToken(SStrToken* pToken);
 int32_t tscValidateName(SStrToken* pToken);
 
 void tscIncStreamExecutionCount(void* pStream);
@@ -206,8 +205,6 @@ void tscTagCondRelease(STagCond* pCond);
 
 void tscGetSrcColumnInfo(SSrcColumnInfo* pColInfo, SQueryInfo* pQueryInfo);
 
-void tscSetFreeHeatBeat(STscObj* pObj);
-bool tscShouldFreeHeartBeat(SSqlObj* pHb);
 bool tscShouldBeFreed(SSqlObj* pSql);
 
 STableMetaInfo* tscGetTableMetaInfoFromCmd(SSqlCmd *pCmd, int32_t subClauseIndex, int32_t tableIndex);
@@ -219,7 +216,7 @@ SQueryInfo *tscGetQueryInfoDetailSafely(SSqlCmd *pCmd, int32_t subClauseIndex);
 void tscClearTableMetaInfo(STableMetaInfo* pTableMetaInfo, bool removeFromCache);
 
 STableMetaInfo* tscAddTableMetaInfo(SQueryInfo* pQueryInfo, const char* name, STableMeta* pTableMeta,
-    SVgroupsInfo* vgroupList, SArray* pTagCols);
+    SVgroupsInfo* vgroupList, SArray* pTagCols, SArray* pVgroupTables);
 
 STableMetaInfo* tscAddEmptyMetaInfo(SQueryInfo *pQueryInfo);
 int32_t tscAddSubqueryInfo(SSqlCmd *pCmd);
@@ -228,16 +225,19 @@ void tscInitQueryInfo(SQueryInfo* pQueryInfo);
 
 void tscClearSubqueryInfo(SSqlCmd* pCmd);
 void tscFreeVgroupTableInfo(SArray* pVgroupTables);
+SArray* tscCloneVgroupTableInfo(SArray* pVgroupTables);
+void tscRemoveVgroupTableGroup(SArray* pVgroupTable, int32_t index);
 
 int  tscGetSTableVgroupInfo(SSqlObj* pSql, int32_t clauseIndex);
 int  tscGetTableMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
 int  tscGetMeterMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
 
 void tscResetForNextRetrieve(SSqlRes* pRes);
-
-void tscAddTimestampColumn(SQueryInfo* pQueryInfo, int16_t functionId, int16_t tableIndex);
 void tscDoQuery(SSqlObj* pSql);
 
+SVgroupsInfo* tscVgroupInfoClone(SVgroupsInfo *pInfo);
+void* tscVgroupInfoClear(SVgroupsInfo *pInfo);
+void tscSCMVgroupInfoCopy(SCMVgroupInfo* dst, const SCMVgroupInfo* src);
 /**
  * The create object function must be successful expect for the out of memory issue.
  *
@@ -257,6 +257,8 @@ void tscDoQuery(SSqlObj* pSql);
  */
 SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cmd);
 
+void registerSqlObj(SSqlObj* pSql);
+
 SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void* param, int32_t cmd, SSqlObj* pPrevSql);
 void     addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClauseIndex, int32_t tableIndex);
 

src/client/inc/tsclient.h

@@ -30,6 +30,7 @@ extern "C" {
 #include "tsqlfunction.h"
 #include "tutil.h"
 #include "tcache.h"
+#include "tref.h"
 
 #include "qExecutor.h"
 #include "qSqlparser.h"
@@ -80,6 +81,8 @@ enum {
   DATA_FROM_DATA_FILE = 2,
 };
 
+typedef void (*__async_cb_func_t)(void *param, TAOS_RES *tres, int32_t numOfRows);
+
 typedef struct STableComInfo {
   uint8_t numOfTags;
   uint8_t precision;
@@ -91,7 +94,7 @@ typedef struct SCMCorVgroupInfo {
   int32_t    version;
   int8_t     inUse;
   int8_t     numOfEps;
-  SEpAddr epAddr[TSDB_MAX_REPLICA];
+  SEpAddr1   epAddr[TSDB_MAX_REPLICA];
 } SCMCorVgroupInfo;
 
 typedef struct STableMeta {
@@ -99,6 +102,7 @@ typedef struct STableMeta {
   uint8_t        tableType;
   int16_t        sversion;
   int16_t        tversion;
+  char           sTableId[TSDB_TABLE_FNAME_LEN];
   SCMVgroupInfo  vgroupInfo;
   SCMCorVgroupInfo  corVgroupInfo;
   STableId       id;
@@ -106,7 +110,7 @@ typedef struct STableMeta {
 } STableMeta;
 
 typedef struct STableMetaInfo {
-  STableMeta *  pTableMeta;      // table meta, cached in client side and acquired by name
+  STableMeta   *pTableMeta;      // table meta, cached in client side and acquired by name
   SVgroupsInfo *vgroupList;
   SArray       *pVgroupTables;   // SArray<SVgroupTableInfo>
   
@@ -139,16 +143,17 @@ typedef struct SColumnIndex {
   int16_t columnIndex;
 } SColumnIndex;
 
-typedef struct SFieldSupInfo {
+typedef struct SInternalField {
+  TAOS_FIELD      field;
   bool            visible;
   SExprInfo      *pArithExprInfo;
   SSqlExpr       *pSqlExpr;
-} SFieldSupInfo;
+} SInternalField;
 
 typedef struct SFieldInfo {
   int16_t      numOfOutput;   // number of column in result
-  SArray *pFields;       // SArray<TAOS_FIELD>
-  SArray *pSupportInfo;  // SArray<SFieldSupInfo>
+  TAOS_FIELD*  final;
+  SArray      *internalField; // SArray<SInternalField>
 } SFieldInfo;
 
 typedef struct SColumn {
@@ -225,10 +230,9 @@ typedef struct STableDataBlocks {
 typedef struct SQueryInfo {
   int16_t          command;       // the command may be different for each subclause, so keep it seperately.
   uint32_t         type;          // query/insert type
-  // TODO refactor
+
   STimeWindow      window;        // query time window
   SInterval        interval;
-  int32_t          tz;            // query client timezone
 
   SSqlGroupbyExpr  groupbyExpr;   // group by tags info
   SArray *         colList;       // SArray<SColumn*>
@@ -276,6 +280,7 @@ typedef struct {
 
   int8_t       dataSourceType;     // load data from file or not
   int8_t       submitSchema; // submit block is built with table schema
+  STagData     tagData;
   SHashObj    *pTableList;   // referred table involved in sql
   SArray      *pDataBlocks;  // SArray<STableDataBlocks*> submit data blocks after parsing sql
 } SSqlCmd;
@@ -305,7 +310,7 @@ typedef struct {
   int32_t               numOfGroups;
   SResRec *             pGroupRec;
   char *                data;
-  void **               tsrow;
+  TAOS_ROW              tsrow;
   int32_t*              length;  // length for each field for current row
   char **               buffer;  // Buffer used to put multibytes encoded using unicode (wchar_t)
   SColumnIndex *        pColumnIndex;
@@ -333,6 +338,12 @@ typedef struct STscObj {
   T_REF_DECLARE()
 } STscObj;
 
+typedef struct SSubqueryState {
+  int32_t          numOfRemain;         // the number of remain unfinished subquery
+  int32_t          numOfSub;            // the number of total sub-queries
+  uint64_t         numOfRetrievedRows;  // total number of points in this query
+} SSubqueryState;
+
 typedef struct SSqlObj {
   void            *signature;
   pthread_t        owner;        // owner of sql object, by which it is executed
@@ -354,10 +365,11 @@ typedef struct SSqlObj {
   tsem_t           rspSem;
   SSqlCmd          cmd;
   SSqlRes          res;
-  uint16_t         numOfSubs;
+
+  SSubqueryState   subState;
   struct SSqlObj **pSubs;
-  struct SSqlObj * prev, *next;
 
+  struct SSqlObj  *prev, *next;
   struct SSqlObj **self;
 } SSqlObj;
 
@@ -432,19 +444,20 @@ void tscPartiallyFreeSqlObj(SSqlObj *pSql);
  * @param pObj
  */
 void tscFreeSqlObj(SSqlObj *pSql);
+void tscFreeRegisteredSqlObj(void *pSql);
+void tscFreeTableMetaHelper(void *pTableMeta);
 
-void tscFreeSqlObjInCache(void *pSql);
-
-void tscCloseTscObj(STscObj *pObj);
+void tscCloseTscObj(void *pObj);
 
+// todo move to taos? or create a new file: taos_internal.h
 TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
-                     void *param, void **taos);
-void waitForQueryRsp(void *param, TAOS_RES *tres, int code) ;
+                     void *param, TAOS **taos);
+TAOS_RES* taos_query_h(TAOS* taos, const char *sqlstr, TAOS_RES** res);
+void waitForQueryRsp(void *param, TAOS_RES *tres, int code);
 
-void doAsyncQuery(STscObj *pObj, SSqlObj *pSql, void (*fp)(), void *param, const char *sqlstr, size_t sqlLen);
+void doAsyncQuery(STscObj *pObj, SSqlObj *pSql, __async_cb_func_t fp, void *param, const char *sqlstr, size_t sqlLen);
 
 void tscProcessMultiVnodesImportFromFile(SSqlObj *pSql);
-void tscKillSTableQuery(SSqlObj *pSql);
 void tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen);
 bool tscIsUpdateQuery(SSqlObj* pSql);
 bool tscHasReachLimitation(SQueryInfo *pQueryInfo, SSqlRes *pRes);
@@ -457,7 +470,7 @@ int32_t tscSQLSyntaxErrMsg(char* msg, const char* additionalInfo,  const char* s
 int32_t tscToSQLCmd(SSqlObj *pSql, struct SSqlInfo *pInfo);
 
 static FORCE_INLINE void tscGetResultColumnChr(SSqlRes* pRes, SFieldInfo* pFieldInfo, int32_t columnIndex) {
-  SFieldSupInfo* pInfo = (SFieldSupInfo*) TARRAY_GET_ELEM(pFieldInfo->pSupportInfo, columnIndex);
+  SInternalField* pInfo = (SInternalField*) TARRAY_GET_ELEM(pFieldInfo->internalField, columnIndex);
   assert(pInfo->pSqlExpr != NULL);
 
   int32_t type = pInfo->pSqlExpr->resType;
@@ -470,11 +483,11 @@ static FORCE_INLINE void tscGetResultColumnChr(SSqlRes* pRes, SFieldInfo* pField
     if (type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BINARY) {
       pData = pInfo->pSqlExpr->param[1].pz;
       pRes->length[columnIndex] = pInfo->pSqlExpr->param[1].nLen;
-      pRes->tsrow[columnIndex] = (pInfo->pSqlExpr->param[1].nType == TSDB_DATA_TYPE_NULL) ? NULL : pData;
+      pRes->tsrow[columnIndex] = (pInfo->pSqlExpr->param[1].nType == TSDB_DATA_TYPE_NULL) ? NULL : (unsigned char*)pData;
     } else {
       assert(bytes == tDataTypeDesc[type].nSize);
 
-      pRes->tsrow[columnIndex] = isNull(pData, type) ? NULL : &pInfo->pSqlExpr->param[1].i64Key;
+      pRes->tsrow[columnIndex] = isNull(pData, type) ? NULL : (unsigned char*)&pInfo->pSqlExpr->param[1].i64Key;
       pRes->length[columnIndex] = bytes;
     }
   } else {
@@ -482,7 +495,7 @@ static FORCE_INLINE void tscGetResultColumnChr(SSqlRes* pRes, SFieldInfo* pField
       int32_t realLen = varDataLen(pData);
       assert(realLen <= bytes - VARSTR_HEADER_SIZE);
 
-      pRes->tsrow[columnIndex] = (isNull(pData, type)) ? NULL : ((tstr *)pData)->data;
+      pRes->tsrow[columnIndex] = (isNull(pData, type)) ? NULL : (unsigned char*)((tstr *)pData)->data;
       if (realLen < pInfo->pSqlExpr->resBytes - VARSTR_HEADER_SIZE) {  // todo refactor
         *(pData + realLen + VARSTR_HEADER_SIZE) = 0;
       }
@@ -491,7 +504,7 @@ static FORCE_INLINE void tscGetResultColumnChr(SSqlRes* pRes, SFieldInfo* pField
     } else {
       assert(bytes == tDataTypeDesc[type].nSize);
 
-      pRes->tsrow[columnIndex] = isNull(pData, type) ? NULL : pData;
+      pRes->tsrow[columnIndex] = isNull(pData, type) ? NULL : (unsigned char*)pData;
       pRes->length[columnIndex] = bytes;
     }
   }
@@ -504,13 +517,12 @@ extern void *    tscQhandle;
 extern int       tscKeepConn[];
 extern int       tsInsertHeadSize;
 extern int       tscNumOfThreads;
+extern int       tscRefId;
   
 extern SRpcCorEpSet tscMgmtEpSet;
 
 extern int (*tscBuildMsg[TSDB_SQL_MAX])(SSqlObj *pSql, SSqlInfo *pInfo);
 
-typedef void (*__async_cb_func_t)(void *param, TAOS_RES *tres, int numOfRows);
-
 int32_t tscCompareTidTags(const void* p1, const void* p2);
 void tscBuildVgroupTableInfo(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SArray* tables);
 

src/client/src/TSDBJNIConnector.c

@@ -149,7 +149,7 @@ JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_initImp(JNIEnv *e
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setOptions(JNIEnv *env, jobject jobj, jint optionIndex,
                                                                           jstring optionValue) {
   if (optionValue == NULL) {
-    jniDebug("option index:%d value is null", optionIndex);
+    jniDebug("option index:%d value is null", (int32_t)optionIndex);
     return 0;
   }
 
@@ -183,7 +183,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setOptions(JNIEnv
     }
     (*env)->ReleaseStringUTFChars(env, optionValue, tz1);
   } else {
-    jniError("option index:%d is not found", optionIndex);
+    jniError("option index:%d is not found", (int32_t)optionIndex);
   }
 
   return res;
@@ -227,10 +227,10 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_connectImp(JNIEn
   ret = (jlong)taos_connect((char *)host, (char *)user, (char *)pass, (char *)dbname, (uint16_t)jport);
   if (ret == 0) {
     jniError("jobj:%p, conn:%p, connect to database failed, host=%s, user=%s, dbname=%s, port=%d", jobj, (void *)ret,
-             (char *)host, (char *)user, (char *)dbname, jport);
+             (char *)host, (char *)user, (char *)dbname, (int32_t)jport);
   } else {
     jniDebug("jobj:%p, conn:%p, connect to database succeed, host=%s, user=%s, dbname=%s, port=%d", jobj, (void *)ret,
-             (char *)host, (char *)user, (char *)dbname, jport);
+             (char *)host, (char *)user, (char *)dbname, (int32_t)jport);
   }
 
   if (host != NULL) (*env)->ReleaseStringUTFChars(env, jhost, host);
@@ -385,7 +385,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getAffectedRowsIm
   }
 
   jint ret = taos_affected_rows((SSqlObj *)res);
-  jniDebug("jobj:%p, conn:%p, sql:%p, res: %p, affect rows:%d", jobj, tscon, (void *)con, (void *)res, ret);
+  jniDebug("jobj:%p, conn:%p, sql:%p, res: %p, affect rows:%d", jobj, tscon, (void *)con, (void *)res, (int32_t)ret);
 
   return ret;
 }
@@ -490,13 +490,13 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetBooleanFp, i, (jboolean)(*((char *)row[i]) == 1));
         break;
       case TSDB_DATA_TYPE_TINYINT:
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetByteFp, i, (jbyte) * ((char *)row[i]));
+        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetByteFp, i, (jbyte) * ((int8_t *)row[i]));
         break;
       case TSDB_DATA_TYPE_SMALLINT:
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetShortFp, i, (jshort) * ((short *)row[i]));
+        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetShortFp, i, (jshort) * ((int16_t *)row[i]));
         break;
       case TSDB_DATA_TYPE_INT:
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetIntFp, i, (jint) * (int *)row[i]);
+        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetIntFp, i, (jint) * (int32_t *)row[i]);
         break;
       case TSDB_DATA_TYPE_BIGINT:
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetLongFp, i, (jlong) * ((int64_t *)row[i]));

src/client/src/tscAsync.c

@@ -40,7 +40,7 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
 static void tscAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOfRows);
 static void tscAsyncFetchSingleRowProxy(void *param, TAOS_RES *tres, int numOfRows);
 
-void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const char* sqlstr, size_t sqlLen) {
+void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* param, const char* sqlstr, size_t sqlLen) {
   SSqlCmd* pCmd = &pSql->cmd;
 
   pSql->signature = pSql;
@@ -51,10 +51,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const
   pSql->fp        = fp;
   pSql->fetchFp   = fp;
 
-  uint64_t handle = (uint64_t) pSql;
-  pSql->self = taosCachePut(tscObjCache, &handle, sizeof(uint64_t), &pSql, sizeof(uint64_t), 2*3600*1000);
-
-  T_REF_INC(pSql->pTscObj);
+  registerSqlObj(pSql);
 
   pSql->sqlstr = calloc(1, sqlLen + 1);
   if (pSql->sqlstr == NULL) {
@@ -330,7 +327,7 @@ void tscAsyncFetchSingleRowProxy(void *param, TAOS_RES *tres, int numOfRows) {
   }
   
   for (int i = 0; i < pCmd->numOfCols; ++i){
-    SFieldSupInfo* pSup = taosArrayGet(pQueryInfo->fieldsInfo.pSupportInfo, i);
+    SInternalField* pSup = taosArrayGet(pQueryInfo->fieldsInfo.internalField, i);
     if (pSup->pSqlExpr != NULL) {
 //      pRes->tsrow[i] = TSC_GET_RESPTR_BASE(pRes, pQueryInfo, i) + pSup->pSqlExpr->resBytes * pRes->row;
     } else {
@@ -351,7 +348,7 @@ void tscProcessFetchRow(SSchedMsg *pMsg) {
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
 
   for (int i = 0; i < pCmd->numOfCols; ++i) {
-    SFieldSupInfo* pSup = taosArrayGet(pQueryInfo->fieldsInfo.pSupportInfo, i);
+    SInternalField* pSup = taosArrayGet(pQueryInfo->fieldsInfo.internalField, i);
 
     if (pSup->pSqlExpr != NULL) {
       tscGetResultColumnChr(pRes, &pQueryInfo->fieldsInfo, i);
@@ -364,15 +361,6 @@ void tscProcessFetchRow(SSchedMsg *pMsg) {
   (*pSql->fetchFp)(pSql->param, pSql, pRes->tsrow);
 }
 
-void tscProcessAsyncRes(SSchedMsg *pMsg) {
-  SSqlObj *pSql = (SSqlObj *)pMsg->ahandle;
-  SSqlRes *pRes = &pSql->res;
-  assert(pSql->fp != NULL && pSql->fetchFp != NULL);
-
-  pSql->fp = pSql->fetchFp;
-  (*pSql->fp)(pSql->param, pSql, pRes->code);
-}
-
 // this function will be executed by queue task threads, so the terrno is not valid
 static void tscProcessAsyncError(SSchedMsg *pMsg) {
   void (*fp)() = pMsg->ahandle;
@@ -396,22 +384,15 @@ void tscQueueAsyncRes(SSqlObj *pSql) {
   if (pSql == NULL || pSql->signature != pSql) {
     tscDebug("%p SqlObj is freed, not add into queue async res", pSql);
     return;
-  } else {
-    tscError("%p add into queued async res, code:%s", pSql, tstrerror(pSql->res.code));
   }
 
-  SSchedMsg schedMsg = { 0 };
-  schedMsg.fp = tscProcessAsyncRes;
-  schedMsg.ahandle = pSql;
-  schedMsg.thandle = (void *)1;
-  schedMsg.msg = NULL;
-  taosScheduleTask(tscQhandle, &schedMsg);
-}
+  tscError("%p add into queued async res, code:%s", pSql, tstrerror(pSql->res.code));
 
-void tscProcessAsyncFree(SSchedMsg *pMsg) {
-  SSqlObj *pSql = (SSqlObj *)pMsg->ahandle;
-  tscDebug("%p sql is freed", pSql);
-  taos_free_result(pSql);
+  SSqlRes *pRes = &pSql->res;
+  assert(pSql->fp != NULL && pSql->fetchFp != NULL);
+
+  pSql->fp = pSql->fetchFp;
+  (*pSql->fp)(pSql->param, pSql, pRes->code);
 }
 
 int tscSendMsgToServer(SSqlObj *pSql);
@@ -424,11 +405,11 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
   SSqlRes *pRes = &pSql->res;
   pRes->code = code;
 
+  const char* msg = (pCmd->command == TSDB_SQL_STABLEVGROUP)? "vgroup-list":"table-meta";
   if (code != TSDB_CODE_SUCCESS) {
-    tscError("%p get tableMeta failed, code:%s", pSql, tstrerror(code));
+    tscError("%p get %s failed, code:%s", pSql, msg, tstrerror(code));
     goto _error;
   } else {
-    const char* msg = (pCmd->command == TSDB_SQL_STABLEVGROUP)? "vgroup-list":"table-meta";
     tscDebug("%p get %s successfully", pSql, msg);
   }
 
@@ -512,7 +493,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
           goto _error;
         }
 
-        if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STMT_INSERT)) {
+        if (pCmd->insertType == TSDB_QUERY_TYPE_STMT_INSERT) {
           STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
           code = tscGetTableMeta(pSql, pTableMetaInfo);
           if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {

src/client/src/tscFunctionImpl.c

@@ -525,7 +525,7 @@ static void do_sum(SQLFunctionCtx *pCtx) {
       *retVal += pCtx->preAggVals.statis.sum;
     } else if (pCtx->inputType == TSDB_DATA_TYPE_DOUBLE || pCtx->inputType == TSDB_DATA_TYPE_FLOAT) {
       double *retVal = (double*) pCtx->aOutputBuf;
-      *retVal += GET_DOUBLE_VAL(&(pCtx->preAggVals.statis.sum));
+      *retVal += GET_DOUBLE_VAL((const char*)&(pCtx->preAggVals.statis.sum));
     }
   } else {  // computing based on the true data block
     void *pData = GET_INPUT_CHAR(pCtx);
@@ -768,7 +768,7 @@ static void avg_function(SQLFunctionCtx *pCtx) {
     if (pCtx->inputType >= TSDB_DATA_TYPE_TINYINT && pCtx->inputType <= TSDB_DATA_TYPE_BIGINT) {
       *pVal += pCtx->preAggVals.statis.sum;
     } else if (pCtx->inputType == TSDB_DATA_TYPE_DOUBLE || pCtx->inputType == TSDB_DATA_TYPE_FLOAT) {
-      *pVal += GET_DOUBLE_VAL(&(pCtx->preAggVals.statis.sum));
+      *pVal += GET_DOUBLE_VAL((const char *)&(pCtx->preAggVals.statis.sum));
     }
   } else {
     void *pData = GET_INPUT_CHAR(pCtx);
@@ -2445,8 +2445,8 @@ static bool percentile_function_setup(SQLFunctionCtx *pCtx) {
   // in the first round, get the min-max value of all involved data
   SResultInfo *pResInfo = GET_RES_INFO(pCtx);
   SPercentileInfo *pInfo = pResInfo->interResultBuf;
-  pInfo->minval = DBL_MAX;
-  pInfo->maxval = -DBL_MAX;
+  SET_DOUBLE_VAL(&pInfo->minval, DBL_MAX);
+  SET_DOUBLE_VAL(&pInfo->maxval, -DBL_MAX);
   pInfo->numOfElems = 0;
 
   return true;
@@ -2461,12 +2461,22 @@ static void percentile_function(SQLFunctionCtx *pCtx) {
   // the first stage, only acquire the min/max value
   if (pInfo->stage == 0) {
     if (pCtx->preAggVals.isSet) {
-      if (pInfo->minval > pCtx->preAggVals.statis.min) {
-        pInfo->minval = (double)pCtx->preAggVals.statis.min;
+      double tmin = 0.0, tmax = 0.0;
+      if (pCtx->inputType >= TSDB_DATA_TYPE_TINYINT && pCtx->inputType <= TSDB_DATA_TYPE_BIGINT) {
+        tmin = (double)GET_INT64_VAL(&pCtx->preAggVals.statis.min); 
+        tmax = (double)GET_INT64_VAL(&pCtx->preAggVals.statis.max); 
+      } else if (pCtx->inputType == TSDB_DATA_TYPE_DOUBLE || pCtx->inputType == TSDB_DATA_TYPE_FLOAT) {
+        tmin = GET_DOUBLE_VAL(&pCtx->preAggVals.statis.min); 
+        tmax = GET_DOUBLE_VAL(&pCtx->preAggVals.statis.max); 
+      } else {
+        assert(true);
+      }
+      if (GET_DOUBLE_VAL(&pInfo->minval) > tmin) {
+        SET_DOUBLE_VAL(&pInfo->minval, tmin);
       }
 
-      if (pInfo->maxval < pCtx->preAggVals.statis.max) {
-        pInfo->maxval = (double)pCtx->preAggVals.statis.max;
+      if (GET_DOUBLE_VAL(&pInfo->maxval) < tmax) {
+        SET_DOUBLE_VAL(&pInfo->maxval, tmax);
       }
 
       pInfo->numOfElems += (pCtx->size - pCtx->preAggVals.statis.numOfNull);
@@ -2500,12 +2510,12 @@ static void percentile_function(SQLFunctionCtx *pCtx) {
             break;
         }
 
-        if (v < pInfo->minval) {
-          pInfo->minval = v;
+        if (v < GET_DOUBLE_VAL(&pInfo->minval)) {
+          SET_DOUBLE_VAL(&pInfo->minval, v);
         }
 
-        if (v > pInfo->maxval) {
-          pInfo->maxval = v;
+        if (v > GET_DOUBLE_VAL(&pInfo->maxval)) {
+          SET_DOUBLE_VAL(&pInfo->maxval, v);
         }
 
         pInfo->numOfElems += 1;
@@ -2564,12 +2574,12 @@ static void percentile_function_f(SQLFunctionCtx *pCtx, int32_t index) {
         break;
     }
 
-    if (v < pInfo->minval) {
-      pInfo->minval = v;
+    if (v < GET_DOUBLE_VAL(&pInfo->minval)) {
+      SET_DOUBLE_VAL(&pInfo->minval, v);
     }
 
-    if (v > pInfo->maxval) {
-      pInfo->maxval = v;
+    if (v > GET_DOUBLE_VAL(&pInfo->maxval)) {
+      SET_DOUBLE_VAL(&pInfo->maxval, v);
     }
 
     pInfo->numOfElems += 1;
@@ -2609,7 +2619,7 @@ static void percentile_next_step(SQLFunctionCtx *pCtx) {
     }
 
     pInfo->stage += 1;
-    pInfo->pMemBucket = tMemBucketCreate(pCtx->inputBytes, pCtx->inputType, pInfo->minval, pInfo->maxval);
+    pInfo->pMemBucket = tMemBucketCreate(pCtx->inputBytes, pCtx->inputType, GET_DOUBLE_VAL(&pInfo->minval), GET_DOUBLE_VAL(&pInfo->maxval));
   } else {
     pResInfo->complete = true;
   }
@@ -3516,12 +3526,12 @@ static void spread_function(SQLFunctionCtx *pCtx) {
         pInfo->max = (double)pCtx->preAggVals.statis.max;
       }
     } else if (pCtx->inputType == TSDB_DATA_TYPE_DOUBLE || pCtx->inputType == TSDB_DATA_TYPE_FLOAT) {
-      if (pInfo->min > GET_DOUBLE_VAL(&(pCtx->preAggVals.statis.min))) {
-        pInfo->min = GET_DOUBLE_VAL(&(pCtx->preAggVals.statis.min));
+      if (pInfo->min > GET_DOUBLE_VAL((const char *)&(pCtx->preAggVals.statis.min))) {
+        pInfo->min = GET_DOUBLE_VAL((const char *)&(pCtx->preAggVals.statis.min));
       }
       
-      if (pInfo->max < GET_DOUBLE_VAL(&(pCtx->preAggVals.statis.max))) {
-        pInfo->max = GET_DOUBLE_VAL(&(pCtx->preAggVals.statis.max));
+      if (pInfo->max < GET_DOUBLE_VAL((const char *)&(pCtx->preAggVals.statis.max))) {
+        pInfo->max = GET_DOUBLE_VAL((const char *)&(pCtx->preAggVals.statis.max));
       }
     }
     
@@ -4025,11 +4035,11 @@ static void ts_comp_function(SQLFunctionCtx *pCtx) {
   
   // primary ts must be existed, so no need to check its existance
   if (pCtx->order == TSDB_ORDER_ASC) {
-    tsBufAppend(pTSbuf, 0, &pCtx->tag, input, pCtx->size * TSDB_KEYSIZE);
+    tsBufAppend(pTSbuf, (int32_t)pCtx->param[0].i64Key, &pCtx->tag, input, pCtx->size * TSDB_KEYSIZE);
   } else {
     for (int32_t i = pCtx->size - 1; i >= 0; --i) {
       char *d = GET_INPUT_CHAR_INDEX(pCtx, i);
-      tsBufAppend(pTSbuf, 0, &pCtx->tag, d, TSDB_KEYSIZE);
+      tsBufAppend(pTSbuf, (int32_t)pCtx->param[0].i64Key, &pCtx->tag, d, (int32_t)TSDB_KEYSIZE);
     }
   }
   
@@ -4048,7 +4058,7 @@ static void ts_comp_function_f(SQLFunctionCtx *pCtx, int32_t index) {
   
   STSBuf *pTSbuf = pInfo->pTSBuf;
   
-  tsBufAppend(pTSbuf, 0, &pCtx->tag, pData, TSDB_KEYSIZE);
+  tsBufAppend(pTSbuf, (int32_t)pCtx->param[0].i64Key, &pCtx->tag, pData, TSDB_KEYSIZE);
   SET_VAL(pCtx, pCtx->size, 1);
   
   pResInfo->hasResult = DATA_SET_FLAG;

src/client/src/tscLocalMerge.c

@@ -510,7 +510,8 @@ void tscDestroyLocalReducer(SSqlObj *pSql) {
     taosTFree(pLocalReducer->pResultBuf);
 
     if (pLocalReducer->pResInfo != NULL) {
-      for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
+      size_t num = tscSqlExprNumOfExprs(pQueryInfo);
+      for (int32_t i = 0; i < num; ++i) {
         taosTFree(pLocalReducer->pResInfo[i].interResultBuf);
       }
 
@@ -554,27 +555,48 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm
     numOfGroupByCols++;
   }
 
-  int32_t *orderIdx = (int32_t *)calloc(numOfGroupByCols, sizeof(int32_t));
-  if (orderIdx == NULL) {
+  int32_t *orderColIndexList = (int32_t *)calloc(numOfGroupByCols, sizeof(int32_t));
+  if (orderColIndexList == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
   if (numOfGroupByCols > 0) {
+
+    if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
       int32_t startCols = pQueryInfo->fieldsInfo.numOfOutput - pQueryInfo->groupbyExpr.numOfGroupCols;
 
-    // tags value locate at the last columns
+      // the last "pQueryInfo->groupbyExpr.numOfGroupCols" columns are order-by columns
       for (int32_t i = 0; i < pQueryInfo->groupbyExpr.numOfGroupCols; ++i) {
-      orderIdx[i] = startCols++;
+        orderColIndexList[i] = startCols++;
       }
 
       if (pQueryInfo->interval.interval != 0) {
         // the first column is the timestamp, handles queries like "interval(10m) group by tags"
-      orderIdx[numOfGroupByCols - 1] = PRIMARYKEY_TIMESTAMP_COL_INDEX;
+        orderColIndexList[numOfGroupByCols - 1] = PRIMARYKEY_TIMESTAMP_COL_INDEX; //TODO ???
+      }
+    } else {
+      /*
+       * 1. the orderby ts asc/desc projection query for the super table
+       * 2. interval query without groupby clause
+       */
+      if (pQueryInfo->interval.interval != 0) {
+        orderColIndexList[0] = PRIMARYKEY_TIMESTAMP_COL_INDEX;
+      } else {
+        size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+        for (int32_t i = 0; i < size; ++i) {
+          SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, i);
+          if (pExpr->functionId == TSDB_FUNC_PRJ && pExpr->colInfo.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+            orderColIndexList[0] = i;
+          }
         }
       }
 
-  *pOrderDesc = tOrderDesCreate(orderIdx, numOfGroupByCols, pModel, pQueryInfo->order.order);
-  taosTFree(orderIdx);
+      assert(pQueryInfo->order.orderColId == PRIMARYKEY_TIMESTAMP_COL_INDEX);
+    }
+  }
+
+  *pOrderDesc = tOrderDesCreate(orderColIndexList, numOfGroupByCols, pModel, pQueryInfo->order.order);
+  taosTFree(orderColIndexList);
 
   if (*pOrderDesc == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -588,7 +610,6 @@ bool isSameGroup(SSqlCmd *pCmd, SLocalReducer *pReducer, char *pPrev, tFilePage
 
   // disable merge procedure for column projection query
   int16_t functionId = pReducer->pCtx[0].functionId;
-  assert(functionId != TSDB_FUNC_ARITHM);
   if (pReducer->orderPrjOnSTable) {
     return true;
   }
@@ -606,7 +627,7 @@ bool isSameGroup(SSqlCmd *pCmd, SLocalReducer *pReducer, char *pPrev, tFilePage
     return true;
   }
 
-  if (orderInfo->pData[numOfCols - 1] == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+  if (orderInfo->colIndex[numOfCols - 1] == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
     /*
      * super table interval query
      * if the order columns is the primary timestamp, all result data belongs to one group
@@ -620,7 +641,7 @@ bool isSameGroup(SSqlCmd *pCmd, SLocalReducer *pReducer, char *pPrev, tFilePage
   }
 
   // only one row exists
-  int32_t index = orderInfo->pData[0];
+  int32_t index = orderInfo->colIndex[0];
   int32_t offset = (pOrderDesc->pColumnModel)->pFields[index].offset;
 
   int32_t ret = memcmp(pPrev + offset, tmpBuffer->data + offset, pOrderDesc->pColumnModel->rowSize - offset);
@@ -639,7 +660,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
   SQueryInfo *    pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
-  (*pMemBuffer) = (tExtMemBuffer **)malloc(POINTER_BYTES * pSql->numOfSubs);
+  (*pMemBuffer) = (tExtMemBuffer **)malloc(POINTER_BYTES * pSql->subState.numOfSub);
   if (*pMemBuffer == NULL) {
     tscError("%p failed to allocate memory", pSql);
     pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -661,7 +682,6 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
 
     pSchema[i].bytes = pExpr->resBytes;
     pSchema[i].type = (int8_t)pExpr->resType;
-
     rlen += pExpr->resBytes;
   }
 
@@ -678,7 +698,8 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
     pg *= 2;
   }
 
-  size_t numOfSubs = pTableMetaInfo->vgroupList->numOfVgroups;
+  size_t numOfSubs = pSql->subState.numOfSub;
+  assert(numOfSubs <= pTableMetaInfo->vgroupList->numOfVgroups);
   for (int32_t i = 0; i < numOfSubs; ++i) {
     (*pMemBuffer)[i] = createExtMemBuffer(nBufferSizes, rlen, pg, pModel);
     (*pMemBuffer)[i]->flushModel = MULTIPLE_APPEND_MODEL;
@@ -701,12 +722,8 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
     int16_t type = -1;
     int16_t bytes = 0;
 
-    //    if ((pExpr->functionId >= TSDB_FUNC_FIRST_DST && pExpr->functionId <= TSDB_FUNC_LAST_DST) ||
-    //        (pExpr->functionId >= TSDB_FUNC_SUM && pExpr->functionId <= TSDB_FUNC_MAX) ||
-    //        pExpr->functionId == TSDB_FUNC_LAST_ROW) {
     // the final result size and type in the same as query on single table.
     // so here, set the flag to be false;
-
     int32_t functionId = pExpr->functionId;
     if (functionId >= TSDB_FUNC_TS && functionId <= TSDB_FUNC_DIFF) {
       type = pModel->pFields[i].field.type;
@@ -742,6 +759,7 @@ void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDe
                                int32_t numOfVnodes) {
   destroyColumnModel(pFinalModel);
   tOrderDescDestroy(pDesc);
+
   for (int32_t i = 0; i < numOfVnodes; ++i) {
     pMemBuffer[i] = destoryExtMemBuffer(pMemBuffer[i]);
   }

src/client/src/tscParseInsert.c

@@ -406,7 +406,7 @@ static int32_t tsCheckTimestamp(STableDataBlocks *pDataBlocks, const char *start
   return TSDB_CODE_SUCCESS;
 }
 
-int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[], SParsedDataColInfo *spd, char *error,
+int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[], SParsedDataColInfo *spd, SSqlCmd* pCmd,
                       int16_t timePrec, int32_t *code, char *tmpTokenBuf) {
   int32_t index = 0;
   SStrToken sToken = {0};
@@ -426,12 +426,17 @@ int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[
     *str += index;
 
     if (sToken.type == TK_QUESTION) {
+      if (pCmd->insertType != TSDB_QUERY_TYPE_STMT_INSERT) {
+        *code = tscSQLSyntaxErrMsg(pCmd->payload, "? only allowed in binding insertion", *str);
+        return -1;
+      }
+
       uint32_t offset = (uint32_t)(start - pDataBlocks->pData);
       if (tscAddParamToDataBlock(pDataBlocks, pSchema->type, (uint8_t)timePrec, pSchema->bytes, offset) != NULL) {
         continue;
       }
 
-      strcpy(error, "client out of memory");
+      strcpy(pCmd->payload, "client out of memory");
       *code = TSDB_CODE_TSC_OUT_OF_MEMORY;
       return -1;
     }
@@ -439,8 +444,7 @@ int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[
     int16_t type = sToken.type;
     if ((type != TK_NOW && type != TK_INTEGER && type != TK_STRING && type != TK_FLOAT && type != TK_BOOL &&
          type != TK_NULL && type != TK_HEX && type != TK_OCT && type != TK_BIN) || (sToken.n == 0) || (type == TK_RP)) {
-      tscSQLSyntaxErrMsg(error, "invalid data or symbol", sToken.z);
-      *code = TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
+      *code = tscSQLSyntaxErrMsg(pCmd->payload, "invalid data or symbol", sToken.z);
       return -1;
     }
 
@@ -470,14 +474,14 @@ int tsParseOneRowData(char **str, STableDataBlocks *pDataBlocks, SSchema schema[
     }
 
     bool    isPrimaryKey = (colIndex == PRIMARYKEY_TIMESTAMP_COL_INDEX);
-    int32_t ret = tsParseOneColumnData(pSchema, &sToken, start, error, str, isPrimaryKey, timePrec);
+    int32_t ret = tsParseOneColumnData(pSchema, &sToken, start, pCmd->payload, str, isPrimaryKey, timePrec);
     if (ret != TSDB_CODE_SUCCESS) {
       *code = TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
       return -1;  // NOTE: here 0 mean error!
     }
 
     if (isPrimaryKey && tsCheckTimestamp(pDataBlocks, start) != TSDB_CODE_SUCCESS) {
-      tscInvalidSQLErrMsg(error, "client time/server time can not be mixed up", sToken.z);
+      tscInvalidSQLErrMsg(pCmd->payload, "client time/server time can not be mixed up", sToken.z);
       *code = TSDB_CODE_TSC_INVALID_TIME_STAMP;
       return -1;
     }
@@ -522,7 +526,7 @@ static int32_t rowDataCompar(const void *lhs, const void *rhs) {
 }
 
 int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pTableMeta, int maxRows,
-                  SParsedDataColInfo *spd, char *error, int32_t *code, char *tmpTokenBuf) {
+                  SParsedDataColInfo *spd, SSqlCmd* pCmd, int32_t *code, char *tmpTokenBuf) {
   int32_t   index = 0;
   SStrToken sToken;
 
@@ -534,8 +538,7 @@ int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pTableMe
   int32_t  precision = tinfo.precision;
 
   if (spd->hasVal[0] == false) {
-    strcpy(error, "primary timestamp column can not be null");
-    *code = TSDB_CODE_TSC_INVALID_SQL;
+    *code = tscInvalidSQLErrMsg(pCmd->payload, "primary timestamp column can not be null", *str);
     return -1;
   }
 
@@ -547,17 +550,17 @@ int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pTableMe
     *str += index;
     if (numOfRows >= maxRows || pDataBlock->size + tinfo.rowSize >= pDataBlock->nAllocSize) {
       int32_t tSize;
-      int32_t retcode = tscAllocateMemIfNeed(pDataBlock, tinfo.rowSize, &tSize);
-      if (retcode != TSDB_CODE_SUCCESS) {  //TODO pass the correct error code to client
-        strcpy(error, "client out of memory");
-        *code = retcode;
+      *code = tscAllocateMemIfNeed(pDataBlock, tinfo.rowSize, &tSize);
+      if (*code != TSDB_CODE_SUCCESS) {  //TODO pass the correct error code to client
+        strcpy(pCmd->payload, "client out of memory");
         return -1;
       }
+
       ASSERT(tSize > maxRows);
       maxRows = tSize;
     }
 
-    int32_t len = tsParseOneRowData(str, pDataBlock, pSchema, spd, error, precision, code, tmpTokenBuf);
+    int32_t len = tsParseOneRowData(str, pDataBlock, pSchema, spd, pCmd, precision, code, tmpTokenBuf);
     if (len <= 0) {  // error message has been set in tsParseOneRowData
       return -1;
     }
@@ -568,7 +571,7 @@ int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pTableMe
     sToken = tStrGetToken(*str, &index, false, 0, NULL);
     *str += index;
     if (sToken.n == 0 || sToken.type != TK_RP) {
-      tscSQLSyntaxErrMsg(error, ") expected", *str);
+      tscSQLSyntaxErrMsg(pCmd->payload, ") expected", *str);
       *code = TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
       return -1;
     }
@@ -577,7 +580,7 @@ int tsParseValues(char **str, STableDataBlocks *pDataBlock, STableMeta *pTableMe
   }
 
   if (numOfRows <= 0) {
-    strcpy(error, "no any data points");
+    strcpy(pCmd->payload, "no any data points");
     *code = TSDB_CODE_TSC_SQL_SYNTAX_ERROR;
     return -1;
   } else {
@@ -704,7 +707,7 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableList, char **st
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  int32_t numOfRows = tsParseValues(str, dataBuf, pTableMeta, maxNumOfRows, spd, pCmd->payload, &code, tmpTokenBuf);
+  int32_t numOfRows = tsParseValues(str, dataBuf, pTableMeta, maxNumOfRows, spd, pCmd, &code, tmpTokenBuf);
   free(tmpTokenBuf);
   if (numOfRows <= 0) {
     return code;
@@ -724,10 +727,6 @@ static int32_t doParseInsertStatement(SSqlObj *pSql, void *pTableList, char **st
   dataBuf->vgId = pTableMeta->vgroupInfo.vgId;
   dataBuf->numOfTables = 1;
 
-  /*
-   * the value of pRes->numOfRows does not affect the true result of AFFECTED ROWS,
-   * which is actually returned from server.
-   */
   *totalNum += numOfRows;
   return TSDB_CODE_SUCCESS;
 }
@@ -791,7 +790,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
     sql += index;
 
     tscAllocPayload(pCmd, sizeof(STagData));
-    STagData *pTag = (STagData *) pCmd->payload;
+    STagData *pTag = &pCmd->tagData;
 
     memset(pTag, 0, sizeof(STagData));
     
@@ -946,7 +945,6 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
       return tscSQLSyntaxErrMsg(pCmd->payload, ") expected", sToken.z);
     }
 
-    pCmd->payloadLen = sizeof(pTag->name) + sizeof(pTag->dataLen) + pTag->dataLen;
     pTag->dataLen = htonl(pTag->dataLen);
 
     if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
@@ -1192,8 +1190,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
         str += index;
 
         if (TK_STRING == sToken.type) {
-          strdequote(sToken.z);
-          sToken.n = (uint32_t)strtrim(sToken.z);
+          tscDequoteAndTrimToken(&sToken);
         }
 
         if (sToken.type == TK_RP) {
@@ -1460,8 +1457,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
     char *lineptr = line;
     strtolower(line, line);
 
-    int32_t len =
-        tsParseOneRowData(&lineptr, pTableDataBlock, pSchema, &spd, pCmd->payload, tinfo.precision, &code, tokenBuf);
+    int32_t len = tsParseOneRowData(&lineptr, pTableDataBlock, pSchema, &spd, pCmd, tinfo.precision, &code, tokenBuf);
     if (len <= 0 || pTableDataBlock->numOfParams > 0) {
       pSql->res.code = code;
       break;

src/client/src/tscPrepare.c

@@ -43,10 +43,6 @@ typedef struct SNormalStmt {
   tVariant*        params;
 } SNormalStmt;
 
-//typedef struct SInsertStmt {
-//
-//} SInsertStmt;
-
 typedef struct STscStmt {
   bool isInsert;
   STscObj* taos;
@@ -54,7 +50,6 @@ typedef struct STscStmt {
   SNormalStmt normal;
 } STscStmt;
 
-
 static int normalStmtAddPart(SNormalStmt* stmt, bool isParam, char* str, uint32_t len) {
   uint16_t size = stmt->numParts + 1;
   if (size > stmt->sizeParts) {
@@ -271,6 +266,388 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) {
     return TSDB_CODE_SUCCESS;
   }
 
+  if (1) {
+    // allow user bind param data with different type
+    short size = 0;
+    union {
+      int8_t          v1;
+      int16_t         v2;
+      int32_t         v4;
+      int64_t         v8;
+      float           f4;
+      double          f8;
+      unsigned char   buf[32*1024];
+    } u;
+    switch (param->type) {
+      case TSDB_DATA_TYPE_BOOL: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL: {
+            u.v1 = *(int8_t*)bind->buffer;
+            if (u.v1==0 || u.v1==1) break;
+          } break;
+          case TSDB_DATA_TYPE_TINYINT: {
+            u.v1 = *(int8_t*)bind->buffer;
+            if (u.v1==0 || u.v1==1) break;
+          } break;
+          case TSDB_DATA_TYPE_SMALLINT: {
+            u.v1 = (int8_t)*(int16_t*)bind->buffer;
+            if (u.v1==0 || u.v1==1) break;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            u.v1 = (int8_t)*(int32_t*)bind->buffer;
+            if (u.v1==0 || u.v1==1) break;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            u.v1 = (int8_t)*(int64_t*)bind->buffer;
+            if (u.v1==0 || u.v1==1) break;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            // "0", "1" convertible
+            if (strncmp((const char*)bind->buffer, "0", *bind->length)==0) {
+              u.v1 = 0;
+              break;
+            }
+            if (strncmp((const char*)bind->buffer, "1", *bind->length)==0) {
+              u.v1 = 1;
+              break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.v1, sizeof(u.v1));
+        return TSDB_CODE_SUCCESS;
+      } break;
+      case TSDB_DATA_TYPE_TINYINT: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT: {
+            int8_t v = *(int8_t*)bind->buffer;
+            u.v1 = v;
+            if (v >= SCHAR_MIN && v <= SCHAR_MAX) break;
+          } break;
+          case TSDB_DATA_TYPE_SMALLINT: {
+            int16_t v = *(int16_t*)bind->buffer;
+            u.v1 = (int8_t)v;
+            if (v >= SCHAR_MIN && v <= SCHAR_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            int32_t v = *(int32_t*)bind->buffer;
+            u.v1 = (int8_t)v;
+            if (v >= SCHAR_MIN && v <= SCHAR_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            int64_t v = *(int64_t*)bind->buffer;
+            u.v1 = (int8_t)v;
+            if (v >= SCHAR_MIN && v <= SCHAR_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            int64_t v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%" PRId64 "%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.v1 = (int8_t)v;
+              if (v >= SCHAR_MIN && v <= SCHAR_MAX) break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.v1, sizeof(u.v1));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_SMALLINT: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_SMALLINT: {
+            int v = *(int16_t*)bind->buffer;
+            u.v2 = (int16_t)v;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            int32_t v = *(int32_t*)bind->buffer;
+            u.v2 = (int16_t)v;
+            if (v >= SHRT_MIN && v <= SHRT_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            int64_t v = *(int64_t*)bind->buffer;
+            u.v2 = (int16_t)v;
+            if (v >= SHRT_MIN && v <= SHRT_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            int64_t v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%" PRId64 "%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.v2 = (int16_t)v;
+              if (v >= SHRT_MIN && v <= SHRT_MAX) break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.v2, sizeof(u.v2));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_INT: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_INT: {
+            u.v4 = *(int32_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            int64_t v = *(int64_t*)bind->buffer;
+            u.v4 = (int32_t)v;
+            if (v >= INT_MIN && v <= INT_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            int64_t v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%" PRId64 "%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.v4 = (int32_t)v;
+              if (v >= INT_MIN && v <= INT_MAX) break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.v2, sizeof(u.v2));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_FLOAT: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT: {
+            u.f4 = *(int8_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_SMALLINT: {
+            u.f4 = *(int16_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            u.f4 = (float)*(int32_t*)bind->buffer;
+            // shall we check equality?
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            u.f4 = (float)*(int64_t*)bind->buffer;
+            // shall we check equality?
+          } break;
+          case TSDB_DATA_TYPE_FLOAT: {
+            u.f4 = *(float*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_DOUBLE: {
+            u.f4 = *(float*)bind->buffer;
+            // shall we check equality?
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            float v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%f%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.f4 = v;
+              break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.f4, sizeof(u.f4));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_BIGINT: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT: {
+            u.v8 = *(int8_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_SMALLINT: {
+            u.v8 = *(int16_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            u.v8 = *(int32_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            u.v8 = *(int64_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            int64_t v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%" PRId64 "%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.v8 = v;
+              break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.v8, sizeof(u.v8));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_DOUBLE: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT: {
+            u.f8 = *(int8_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_SMALLINT: {
+            u.f8 = *(int16_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            u.f8 = *(int32_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            u.f8 = (double)*(int64_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT: {
+            u.f8 = *(float*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_DOUBLE: {
+            u.f8 = *(double*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            double v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%lf%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.f8 = v;
+              break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        } break;
+        memcpy(data + param->offset, &u.f8, sizeof(u.f8));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_TIMESTAMP: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_TIMESTAMP: {
+            u.v8 = *(int64_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            // is this the correct way to call taosParseTime?
+            int32_t len = (int32_t)*bind->length;
+            if (taosParseTime(bind->buffer, &u.v8, len, 3, tsDaylight) == TSDB_CODE_SUCCESS) {
+              break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_INT:
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_BIGINT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        } break;
+        memcpy(data + param->offset, &u.v8, sizeof(u.v8));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_BINARY: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BINARY: {
+            if ((*bind->length) > (uintptr_t)param->bytes) {
+              return TSDB_CODE_TSC_INVALID_VALUE;
+            }
+            size = (short)*bind->length;
+            STR_WITH_SIZE_TO_VARSTR(data + param->offset, bind->buffer, size);
+            return TSDB_CODE_SUCCESS;
+          } break;
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_INT:
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_BIGINT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          case TSDB_DATA_TYPE_NCHAR:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+			} break;
+      case TSDB_DATA_TYPE_NCHAR: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_NCHAR: {
+            size_t output = 0;
+            if (!taosMbsToUcs4(bind->buffer, *bind->length, varDataVal(data + param->offset), param->bytes - VARSTR_HEADER_SIZE, &output)) {
+              return TSDB_CODE_TSC_INVALID_VALUE;
+            }
+            varDataSetLen(data + param->offset, output);
+            return TSDB_CODE_SUCCESS;
+          } break;
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_INT:
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_BIGINT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          case TSDB_DATA_TYPE_BINARY:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+			} break;
+      default: {
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      } break;
+    }
+  }
+
   if (bind->buffer_type != param->type) {
     return TSDB_CODE_TSC_INVALID_VALUE;
   }
@@ -514,7 +891,6 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   SSqlObj* pSql = pStmt->pSql;
   size_t   sqlLen = strlen(sql);
 
-  //doAsyncQuery(pObj, pSql, waitForQueryRsp, taos, sqlstr, sqlLen);
   SSqlCmd *pCmd    = &pSql->cmd;
   SSqlRes *pRes    = &pSql->res;
   pSql->param      = (void*) pSql;
@@ -546,9 +922,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
     pSql->cmd.numOfParams = 0;
     pSql->cmd.batchSize   = 0;
 
-    uint64_t handle = (uint64_t) pSql;
-    pSql->self = taosCachePut(tscObjCache, &handle, sizeof(uint64_t), &pSql, sizeof(uint64_t), 2*3600*1000);
-    T_REF_INC(pSql->pTscObj);
+    registerSqlObj(pSql);
 
     int32_t code = tsParseSql(pSql, true);
     if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
@@ -645,3 +1019,80 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
   pStmt->pSql = NULL;
   return result;
 }
+
+int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
+  STscStmt* pStmt = (STscStmt*)stmt;
+
+  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  if (insert) *insert = pStmt->isInsert;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
+  STscStmt* pStmt = (STscStmt*)stmt;
+
+  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  if (pStmt->isInsert) {
+    SSqlObj* pSql = pStmt->pSql;
+    SSqlCmd *pCmd    = &pSql->cmd;
+    *nums = pCmd->numOfParams;
+    return TSDB_CODE_SUCCESS;
+  } else {
+    SNormalStmt* normal = &pStmt->normal;
+    *nums = normal->numParams;
+    return TSDB_CODE_SUCCESS;
+  }
+}
+
+int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
+  STscStmt* pStmt = (STscStmt*)stmt;
+
+  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  if (pStmt->isInsert) {
+    SSqlObj* pSql = pStmt->pSql;
+    SSqlCmd *pCmd    = &pSql->cmd;
+    STableDataBlocks* pBlock = taosArrayGetP(pCmd->pDataBlocks, 0);
+
+    assert(pCmd->numOfParams == pBlock->numOfParams);
+    if (idx < 0 || idx >= pBlock->numOfParams) return -1;
+
+    SParamInfo* param = pBlock->params + idx;
+    if (type) *type = param->type;
+    if (bytes) *bytes = param->bytes;
+
+    return TSDB_CODE_SUCCESS;
+  } else {
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+}
+
+const char *taos_data_type(int type) {
+  switch (type) {
+    case TSDB_DATA_TYPE_NULL:            return "TSDB_DATA_TYPE_NULL";
+    case TSDB_DATA_TYPE_BOOL:            return "TSDB_DATA_TYPE_BOOL";
+    case TSDB_DATA_TYPE_TINYINT:         return "TSDB_DATA_TYPE_TINYINT";
+    case TSDB_DATA_TYPE_SMALLINT:        return "TSDB_DATA_TYPE_SMALLINT";
+    case TSDB_DATA_TYPE_INT:             return "TSDB_DATA_TYPE_INT";
+    case TSDB_DATA_TYPE_BIGINT:          return "TSDB_DATA_TYPE_BIGINT";
+    case TSDB_DATA_TYPE_FLOAT:           return "TSDB_DATA_TYPE_FLOAT";
+    case TSDB_DATA_TYPE_DOUBLE:          return "TSDB_DATA_TYPE_DOUBLE";
+    case TSDB_DATA_TYPE_BINARY:          return "TSDB_DATA_TYPE_BINARY";
+    case TSDB_DATA_TYPE_TIMESTAMP:       return "TSDB_DATA_TYPE_TIMESTAMP";
+    case TSDB_DATA_TYPE_NCHAR:           return "TSDB_DATA_TYPE_NCHAR";
+    default: return "UNKNOWN";
+  }
+}
+

src/client/src/tscProfile.c

@@ -20,8 +20,10 @@
 #include "tutil.h"
 #include "taosmsg.h"
 
+#include "taos.h"
+
 void  tscSaveSlowQueryFp(void *handle, void *tmrId);
-void *tscSlowQueryConn = NULL;
+TAOS *tscSlowQueryConn = NULL;
 bool  tscSlowQueryConnInitialized = false;
 
 void tscInitConnCb(void *param, TAOS_RES *result, int code) {
@@ -151,10 +153,12 @@ void tscKillQuery(STscObj *pObj, uint32_t killId) {
 
   pthread_mutex_unlock(&pObj->mutex);
 
-  if (pSql == NULL) return;
-
+  if (pSql == NULL) {
+    tscError("failed to kill query, id:%d, it may have completed/terminated", killId);
+  } else {
     tscDebug("%p query is killed, queryId:%d", pSql, killId);
     taos_stop_query(pSql);
+  }
 }
 
 void tscAddIntoStreamList(SSqlStream *pStream) {
@@ -242,6 +246,7 @@ int tscBuildQueryStreamDesc(void *pMsg, STscObj *pObj) {
     pQdesc->stime = htobe64(pSql->stime);
     pQdesc->queryId = htonl(pSql->queryId);
     pQdesc->useconds = htobe64(pSql->res.useconds);
+    pQdesc->qHandle = htobe64(pSql->res.qhandle);
 
     pHeartbeat->numOfQueries++;
     pQdesc++;

src/client/src/tscSchemaUtil.c

@@ -145,10 +145,11 @@ static void tscInitCorVgroupInfo(SCMCorVgroupInfo *corVgroupInfo, SCMVgroupInfo
   corVgroupInfo->inUse = 0;
   corVgroupInfo->numOfEps = vgroupInfo->numOfEps;
   for (int32_t i = 0; i < corVgroupInfo->numOfEps; i++) {
-    strncpy(corVgroupInfo->epAddr[i].fqdn, vgroupInfo->epAddr[i].fqdn, TSDB_FQDN_LEN);
+    corVgroupInfo->epAddr[i].fqdn = strdup(vgroupInfo->epAddr[i].fqdn);
     corVgroupInfo->epAddr[i].port = vgroupInfo->epAddr[i].port;
   }
 }
+
 STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg, size_t* size) {
   assert(pTableMetaMsg != NULL);
   
@@ -162,14 +163,25 @@ STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg, size_t* size
     .numOfColumns = pTableMetaMsg->numOfColumns,
   };
   
-  pTableMeta->id.tid = pTableMetaMsg->sid;
+  pTableMeta->id.tid = pTableMetaMsg->tid;
   pTableMeta->id.uid = pTableMetaMsg->uid;
-  pTableMeta->vgroupInfo = pTableMetaMsg->vgroup;
 
-  tscInitCorVgroupInfo(&pTableMeta->corVgroupInfo, &pTableMeta->vgroupInfo);
+  SCMVgroupInfo* pVgroupInfo = &pTableMeta->vgroupInfo;
+  pVgroupInfo->numOfEps = pTableMetaMsg->vgroup.numOfEps;
+  pVgroupInfo->vgId = pTableMetaMsg->vgroup.vgId;
+
+  for(int32_t i = 0; i < pVgroupInfo->numOfEps; ++i) {
+    SEpAddrMsg* pEpMsg = &pTableMetaMsg->vgroup.epAddr[i];
+
+    pVgroupInfo->epAddr[i].fqdn = strndup(pEpMsg->fqdn, tListLen(pEpMsg->fqdn));
+    pVgroupInfo->epAddr[i].port = pEpMsg->port;
+  }
+
+  tscInitCorVgroupInfo(&pTableMeta->corVgroupInfo, pVgroupInfo);
 
   pTableMeta->sversion = pTableMetaMsg->sversion;
   pTableMeta->tversion = pTableMetaMsg->tversion;
+  tstrncpy(pTableMeta->sTableId, pTableMetaMsg->sTableId, TSDB_TABLE_FNAME_LEN);
   
   memcpy(pTableMeta->schema, pTableMetaMsg->schema, schemaSize);
   

src/common/inc/tcmdtype.h

@@ -78,6 +78,9 @@ enum {
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_RETRIEVE_LOCALMERGE, "retrieve-localmerge" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_TABLE_JOIN_RETRIEVE, "join-retrieve" )
 
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SHOW_CREATE_TABLE, "show-create-table")
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SHOW_CREATE_DATABASE, "show-create-database")
+
   /*
    * build empty result instead of accessing dnode to fetch result
    * reset the client cache

go @ 8c58c512

-Subproject commit 06ec30a0f1762e8169bf6b9045c82bcaa52bcdf0
+Subproject commit 8c58c512b6acda8bcdfa48fdc7140227b5221766

hivemq-tdengine-extension @ b62a26ec

+Subproject commit b62a26ecc164a310104df57691691b237e091c89

src/connector/jdbc/CMakeLists.txt

@@ -8,7 +8,7 @@ IF (TD_MVN_INSTALLED)
   ADD_CUSTOM_COMMAND(OUTPUT ${JDBC_CMD_NAME}
     POST_BUILD
     COMMAND mvn -Dmaven.test.skip=true install -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.0-dist.jar ${LIBRARY_OUTPUT_PATH}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.8-dist.jar ${LIBRARY_OUTPUT_PATH}
     COMMAND mvn -Dmaven.test.skip=true clean -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
     COMMENT "build jdbc driver")
   ADD_CUSTOM_TARGET(${JDBC_TARGET_NAME} ALL WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} DEPENDS ${JDBC_CMD_NAME})