Merge branch '2.6' into fix/TD-14698-V26

.devcontainer/Dockerfile

+# [Choice] Ubuntu version (use jammy or bionic on local arm64/Apple Silicon): jammy, focal, bionic
+ARG VARIANT="bullseye"
+FROM mcr.microsoft.com/vscode/devcontainers/base:0-${VARIANT}
+# FROM ubuntu:20.04
+# Options for setup script
+# ARG INSTALL_ZSH="true"
+# ARG UPGRADE_PACKAGES="true"
+ADD sources.list /etc/apt/
+RUN apt-get update && apt-get -y install tree vim tmux python3-pip gcc cmake build-essential git gdb
\ No newline at end of file

.devcontainer/devcontainer.json

+{
+	"name": "Ubuntu",
+	"build": {
+		"dockerfile": "Dockerfile",
+		// Update 'VARIANT' to pick an Ubuntu version: jammy / ubuntu-22.04, focal / ubuntu-20.04, bionic /ubuntu-18.04
+		// Use ubuntu-22.04 or ubuntu-18.04 on local arm64/Apple Silicon.
+		"args": { "VARIANT": "ubuntu-20.04" }
+	},
+	"runArgs": [
+		"--cap-add=SYS_PTRACE",
+		"--security-opt",
+		"seccomp=unconfined"
+	],
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "uname -a",
+
+	// Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+	"remoteUser": "root",
+	"extensions": [
+		"ms-vscode.cpptools",
+		"ms-vscode.cmake-tools",
+		"austin.code-gnu-global",
+		"visualstudioexptteam.vscodeintel",
+		"eamodio.gitlens",
+		"matepek.vscode-catch2-test-adapter",
+		"spmeesseman.vscode-taskexplorer",
+		"cschlosser.doxdocgen",
+		"urosvujosevic.explorer-manager"
+	]
+
+}

.devcontainer/sources.list

+deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal main restricted
+deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-updates main restricted
+deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal universe
+deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-updates universe
+deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal multiverse
+deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-updates multiverse
+deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-backports main restricted universe multiverse
+deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-security main restricted
+deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-security universe
+deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-security multiverse
\ No newline at end of file

.gitignore

@@ -5,6 +5,8 @@ build/
 cmake-build-debug/
 cmake-build-release/
 cscope.out
+cscope.files
+tags
 .DS_Store
 debug/
 release/

Jenkinsfile2

@@ -7,7 +7,8 @@ def sync_source() {
     sh '''
         hostname
         date
-        '''
+        env
+    '''
     sh '''
         cd ${WKC}
         [ -f src/connector/grafanaplugin/README.md ] && rm -f src/connector/grafanaplugin/README.md > /dev/null || echo "failed to remove grafanaplugin README.md"
@@ -57,6 +58,7 @@ def sync_source() {
         [ -f src/connector/grafanaplugin/README.md ] && rm -f src/connector/grafanaplugin/README.md > /dev/null || echo "failed to remove grafanaplugin README.md"
         git pull >/dev/null
         git clean -dfx
+        git log -5
     '''
     script {
         if (env.CHANGE_TARGET == 'master') {
@@ -90,6 +92,7 @@ def sync_source() {
         cd ${WK}
         git pull >/dev/null
         git clean -dfx
+        git log -5
     '''
     script {
         if (env.CHANGE_URL =~ /\/TDengine\//) {
@@ -98,16 +101,13 @@ def sync_source() {
                 cd ${WKC}
                 git fetch origin +refs/pull/${CHANGE_ID}/merge
                 git checkout -qf FETCH_HEAD
-
-                if [ ! -d src/connector/python/.github ]; then
-                    rm -rf src/connector/python/* || :
-                    rm -rf src/connector/python/.* || :
-                    git clone --depth 1 https://github.com/taosdata/taos-connector-python src/connector/python || echo "failed to clone python connector"
-                else
-                    cd src/connector/python || echo "src/connector/python not exist"
-                    git pull || :
-                    cd ${WKC}
-                fi
+                git log -5
+            '''
+            sh '''
+                cd ${WKC}
+                rm -rf src/connector/python
+                mkdir -p src/connector/python
+                git clone --depth 1 https://github.com/taosdata/taos-connector-python src/connector/python || echo "failed to clone python connector"
             '''
         } else if (env.CHANGE_URL =~ /\/TDinternal\//) {
             sh '''
@@ -115,16 +115,13 @@ def sync_source() {
                 cd ${WK}
                 git fetch origin +refs/pull/${CHANGE_ID}/merge
                 git checkout -qf FETCH_HEAD
-
-                if [ ! -d community/src/connector/python/.github ]; then
-                    rm -rf community/src/connector/python/* || :
-                    rm -rf community/src/connector/python/.* || :
-                    git clone --depth 1 https://github.com/taosdata/taos-connector-python community/src/connector/python || echo "failed to clone python connector"
-                else
-                    cd community/src/connector/python || echo "community/src/connector/python not exist"
-                    git pull || :
-                    cd ${WK}
-                fi
+                git log -5
+            '''
+            sh '''
+                cd ${WKC}
+                rm -rf src/connector/python
+                mkdir -p src/connector/python
+                git clone --depth 1 https://github.com/taosdata/taos-connector-python src/connector/python || echo "failed to clone python connector"
             '''
         } else {
             sh '''
@@ -136,18 +133,8 @@ def sync_source() {
         cd ${WKC}
         git submodule update --init --recursive
     '''
-    sh '''
-        cd ${WKC}
-        git branch
-        git log -5
-    '''
-    sh '''
-        cd ${WK}
-        git branch
-        git log -5
-    '''
 }
-def pre_test() {
+def pre_test_arm64() {
     sync_source()
     sh '''
         cd ${WK}
@@ -160,6 +147,14 @@ def pre_test() {
     '''
     return 1
 }
+def pre_test() {
+    sync_source()
+    sh '''
+        cd ${WKC}/tests/parallel_test
+        ./container_build.sh -w ${WKDIR} -t 8 >/dev/null
+    '''
+    return 1
+}
 def pre_test_mac() {
     sync_source()
     sh '''
@@ -173,27 +168,164 @@ def pre_test_mac() {
     '''
     return 1
 }
+def pre_test_win(){
+    bat '''
+        hostname
+        ipconfig
+        set
+        date /t
+        time /t
+        taskkill /f /t /im python.exe
+        taskkill /f /t /im bash.exe
+        taskkill /f /t /im taosd.exe
+        rd /s /Q %WIN_INTERNAL_ROOT%\\debug || echo "no debug folder"
+        echo "clean environment done"
+        exit 0
+    '''
+    bat '''
+        cd %WIN_INTERNAL_ROOT%
+        git reset --hard
+    '''
+    bat '''
+        cd %WIN_COMMUNITY_ROOT%
+        git reset --hard
+    '''
+    script {
+        if (env.CHANGE_TARGET == 'master') {
+            bat '''
+                cd %WIN_INTERNAL_ROOT%
+                git checkout master
+            '''
+            bat '''
+                cd %WIN_COMMUNITY_ROOT%
+                git checkout master
+            '''
+        } else if (env.CHANGE_TARGET == '2.0') {
+            bat '''
+                cd %WIN_INTERNAL_ROOT%
+                git checkout 2.0
+            '''
+            bat '''
+                cd %WIN_COMMUNITY_ROOT%
+                git checkout 2.0
+            '''
+        } else if (env.CHANGE_TARGET == '2.4') {
+            bat '''
+                cd %WIN_INTERNAL_ROOT%
+                git checkout 2.4
+            '''
+            bat '''
+                cd %WIN_COMMUNITY_ROOT%
+                git checkout 2.4
+            '''
+        } else if (env.CHANGE_TARGET == '2.6') {
+            bat '''
+                cd %WIN_INTERNAL_ROOT%
+                git checkout 2.6
+            '''
+            bat '''
+                cd %WIN_COMMUNITY_ROOT%
+                git checkout 2.6
+            '''
+        } else {
+            bat '''
+                cd %WIN_INTERNAL_ROOT%
+                git checkout develop
+            '''
+            bat '''
+                cd %WIN_COMMUNITY_ROOT%
+                git checkout develop
+            '''
+        }
+    }
+    bat '''
+        cd %WIN_INTERNAL_ROOT%
+        git pull
+    '''
+    bat '''
+        cd %WIN_COMMUNITY_ROOT%
+        git remote prune origin
+        git pull
+    '''
+    bat '''
+        cd %WIN_INTERNAL_ROOT%
+        git branch
+        git log -5
+    '''
+    bat '''
+        cd %WIN_COMMUNITY_ROOT%
+        git branch
+        git log -5
+    '''
+    script {
+        if (env.CHANGE_URL =~ /\/TDengine\//) {
+            bat '''
+                echo "match /TDengine/ repository"
+                cd %WIN_COMMUNITY_ROOT%
+                git fetch origin +refs/pull/%CHANGE_ID%/merge
+                git checkout -qf FETCH_HEAD
+                git log -5
+            '''
+        } else if (env.CHANGE_URL =~ /\/TDinternal\//) {
+            bat '''
+                echo "match /TDinternal/ repository"
+                cd %WIN_INTERNAL_ROOT%
+                git fetch origin +refs/pull/%CHANGE_ID%/merge
+                git checkout -qf FETCH_HEAD
+                git log -5
+            '''
+        } else {
+            bat '''
+                echo "unmatched reposiotry %CHANGE_URL%"
+            '''
+        }
+    }
+    bat '''
+        cd %WIN_COMMUNITY_ROOT%
+        git submodule update --init --recursive
+    '''
+    /*bat '''
+        cd %WIN_CONNECTOR_ROOT%
+        git branch
+        git reset --hard
+        git pull
+    '''
+    bat '''
+        cd %WIN_CONNECTOR_ROOT%
+        git log -5
+    '''*/
+}
+def pre_test_build_win() {
+    bat '''
+        echo "building ..."
+        time /t
+        cd %WIN_INTERNAL_ROOT%
+        mkdir debug
+        cd debug
+        time /t
+        call "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community\\VC\\Auxiliary\\Build\\vcvarsall.bat" x64
+        set CL=/MP8
+        echo ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cmake"
+        time /t
+        cmake .. -G "NMake Makefiles JOM" || exit 7
+        echo ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jom -j 6"
+        time /t
+        jom -j 6 || exit 8
+        time /t
+    '''
+    return 1
+}
 pipeline {
-    agent {label " dispatcher "}
+    agent none
     options { skipDefaultCheckout() }
     environment{
+        WKDIR = '/var/data/jenkins/workspace'
         WK = '/var/data/jenkins/workspace/TDinternal'
         WKC = '/var/data/jenkins/workspace/TDinternal/community'
         LOGDIR = '/var/data/jenkins/workspace/log'
     }
     stages {
-        stage ('pre_build') {
-            steps {
-                sh '''
-                    date
-                    pwd
-                    env
-                    hostname
-                '''
-            }
-        }
-        stage ('Parallel build stage') {
-            //only build pr
+        stage('run test') {
             options { skipDefaultCheckout() }
             when {
                 allOf {
@@ -202,103 +334,104 @@ pipeline {
                 }
             }
             parallel {
-                stage ('dispatcher sync source') {
-                    steps {
-                        timeout(time: 20, unit: 'MINUTES') {
-                            sync_source()
-                            script {
-                                sh '''
-                                    echo "dispatcher ready"
-                                    date
-                                '''
-                            }
-                        }
-                    }
-                }
-                stage ('build worker01') {
-                    agent {label " worker01 "}
+                stage ('build arm64') {
+                    agent {label " worker07_arm64 || worker09_arm64 "}
                     steps {
                         timeout(time: 20, unit: 'MINUTES') {
-                            pre_test()
+                            pre_test_arm64()
                             script {
                                 sh '''
-                                    echo "worker01 build done"
+                                    echo "arm64 build done"
                                     date
                                 '''
                             }
                         }
                     }
                 }
-                stage ('build worker02') {
-                    agent {label " worker02 "}
+                stage ('build Mac') {
+                    agent {label " Mac_catalina "}
                     steps {
                         timeout(time: 20, unit: 'MINUTES') {
-                            pre_test()
+                            pre_test_mac()
                             script {
                                 sh '''
-                                    echo "worker02 build done"
+                                    echo "Mac build done"
                                     date
                                 '''
                             }
                         }
                     }
                 }
-            }
-        }
-        stage('run test') {
-            options { skipDefaultCheckout() }
-            when {
-                allOf {
-                    changeRequest()
-                    not { expression { env.CHANGE_BRANCH =~ /docs\// }}
-                }
-            }
-            parallel {
-                stage ('build worker07_arm64') {
-                    agent {label " worker07_arm64 "}
-                    steps {
-                        timeout(time: 20, unit: 'MINUTES') {
-                            pre_test()
-                            script {
-                                sh '''
-                                    echo "worker07_arm64 build done"
-                                    date
-                                '''
-                            }
-                        }
+                stage('build win') {
+                    agent {label " windows10_05 || windows10_06 "}
+                    environment{
+                        WIN_INTERNAL_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\TDinternal"
+                        WIN_COMMUNITY_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\TDinternal\\community"
+                        WIN_SYSTEM_TEST_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\TDinternal\\community\\tests\\system-test"
+                        WIN_CONNECTOR_ROOT="C:\\workspace\\${env.EXECUTOR_NUMBER}\\taos-connector-python"
                     }
-                }
-                stage ('build Mac_catalina ') {
-                    agent {label " Mac_catalina "}
                     steps {
                         timeout(time: 20, unit: 'MINUTES') {
-                            pre_test_mac()
-                            script {
-                                sh '''
-                                    echo "Mac_catalina build done"
-                                    date
-                                '''
-                            }
+                            pre_test_win()
+                            pre_test_build_win()
                         }
                     }
                 }
                 stage('run cases') {
+                    agent {label " worker01 || worker02 "}
                     steps {
                         sh '''
                             date
+                            pwd
                             hostname
                         '''
-                        catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
-                            timeout(time: 20, unit: 'MINUTES') {
+                        timeout(time: 15, unit: 'MINUTES') {
+                            pre_test()
+                            script {
                                 sh '''
+                                    echo "Linux build done"
                                     date
-                                    cd ${WKC}/tests/parallel_test
-                                    time ./run.sh -m m.json -t cases.task -l ${LOGDIR} -b ${BRANCH_NAME}
-                                    date
-                                    hostname
                                 '''
                             }
                         }
+                        catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
+                            timeout(time: 60, unit: 'MINUTES') {
+                                script {
+                                    def extra_param = ""
+                                    def log_server_file = "/home/log_server.json"
+                                    def timeout_cmd = ""
+                                    if (fileExists(log_server_file)) {
+                                        def log_server_enabled = sh (
+                                            script: 'jq .enabled ' + log_server_file,
+                                            returnStdout: true
+                                        ).trim()
+                                        def timeout_param = sh (
+                                            script: 'jq .timeout ' + log_server_file,
+                                            returnStdout: true
+                                        ).trim()
+                                        if (timeout_param != "null" &&  timeout_param != "0") {
+                                            timeout_cmd = "timeout " + timeout_param
+                                        }
+                                        if (log_server_enabled == "1") {
+                                            def log_server = sh (
+                                                script: 'jq .server ' + log_server_file + ' | sed "s/\\\"//g"',
+                                                returnStdout: true
+                                            ).trim()
+                                            if (log_server != "null" && log_server != "") { 
+                                                extra_param = "-w " + log_server
+                                            }
+                                        }
+                                    }
+                                    sh '''
+                                        date
+                                        cd ${WKC}/tests/parallel_test
+                                        ''' + timeout_cmd + ''' time ./run.sh -m /home/m.json -t cases.task -l ${LOGDIR} -b ${BRANCH_NAME} ''' + extra_param + '''
+                                        date
+                                        hostname
+                                    '''
+                                }
+                            }
+                        }
                     }
                 }
             }    

deps/TSZ/sz/src/CompressElement.c

@@ -7,7 +7,9 @@
  *      See COPYRIGHT in top-level directory.
  */
 #ifndef WINDOWS
+#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
   #pragma GCC diagnostic push
+#endif
   #pragma GCC diagnostic ignored "-Wchar-subscripts"
 #endif
 
@@ -233,5 +235,7 @@ INLINE void updateLossyCompElement_Float(unsigned char* diffBytes, unsigned char
 }
 
 #ifndef WINDOWS
+#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
   #pragma GCC diagnostic pop
-#endif
+#endif
\ No newline at end of file
+#endif

deps/TSZ/sz/src/Huffman.c

@@ -117,7 +117,7 @@ node qremove(HuffmanTree* huffmanTree)
 /**
  * @out1 should be set to 0.
  * @out2 should be 0 as well.
- * @index: the index of the byte
+ * @idx: the idx of the byte
  * */
 void build_code(HuffmanTree *huffmanTree, node n, int len, unsigned long out1, unsigned long out2)
 {
@@ -136,8 +136,8 @@ void build_code(HuffmanTree *huffmanTree, node n, int len, unsigned long out1, u
 		huffmanTree->cout[n->c] = (unsigned char)len;
 		return;
 	}
-	int index = len >> 6; //=len/64
-	if(index == 0)
+	int idx = len >> 6; //=len/64
+	if(idx == 0)
 	{
 		out1 = out1 << 1;
 		out1 = out1 | 0;
@@ -164,13 +164,13 @@ void build_code(HuffmanTree *huffmanTree, node n, int len, unsigned long out1, u
  * */
 void init(HuffmanTree* huffmanTree, int *s, size_t length)
 {
-	size_t i, index;
+	size_t i, idx;
 	size_t *freq = (size_t *)malloc(huffmanTree->allNodes*sizeof(size_t));
 	memset(freq, 0, huffmanTree->allNodes*sizeof(size_t));
 	for(i = 0;i < length;i++)
 	{
-		index = s[i];
-		freq[index]++;
+		idx = s[i];
+		freq[idx]++;
 	}
 
 	for (i = 0; i < huffmanTree->allNodes; i++)

deps/TSZ/sz/src/TightDataPointStorageD.c

@@ -25,9 +25,9 @@ void new_TightDataPointStorageD_Empty(TightDataPointStorageD **this)
 int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsigned char* flatBytes, size_t flatBytesLength, sz_exedata* pde_exe, sz_params* pde_params)
 {
 	new_TightDataPointStorageD_Empty(this);
-	size_t i, index = 0;
-	unsigned char version = flatBytes[index++]; //3
-	unsigned char sameRByte = flatBytes[index++]; //1
+	size_t i, idx = 0;
+	unsigned char version = flatBytes[idx++]; //3
+	unsigned char sameRByte = flatBytes[idx++]; //1
 
     // parse data format
 	switch (version)
@@ -46,15 +46,15 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 	pde_params->accelerate_pw_rel_compression = (sameRByte & 0x08) >> 3;
 	int errorBoundMode = SZ_ABS;
 	
-	convertBytesToSZParams(&(flatBytes[index]), pde_params, pde_exe);
+	convertBytesToSZParams(&(flatBytes[idx]), pde_params, pde_exe);
 
-	index += MetaDataByteLength_double;
+	idx += MetaDataByteLength_double;
 
 	int isRegression = (sameRByte >> 7) & 0x01;
 
 	unsigned char dsLengthBytes[8];
 	for (i = 0; i < pde_exe->SZ_SIZE_TYPE; i++)
-		dsLengthBytes[i] = flatBytes[index++];
+		dsLengthBytes[i] = flatBytes[idx++];
 	(*this)->dataSeriesLength = bytesToSize(dsLengthBytes, pde_exe->SZ_SIZE_TYPE);
 
 	if((*this)->isLossless==1)
@@ -65,7 +65,7 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 	else if(same==1)
 	{
 		(*this)->allSameData = 1;
-		(*this)->exactMidBytes = &(flatBytes[index]);
+		(*this)->exactMidBytes = &(flatBytes[idx]);
 		return errorBoundMode;
 	}
 	else
@@ -74,42 +74,42 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 	if(isRegression == 1)
 	{
 		(*this)->raBytes_size = flatBytesLength - 3 - 1 - MetaDataByteLength_double - pde_exe->SZ_SIZE_TYPE;
-		(*this)->raBytes = &(flatBytes[index]);
+		(*this)->raBytes = &(flatBytes[idx]);
 		return errorBoundMode;
 	}						
 
 	unsigned char byteBuf[8];
 
 	for (i = 0; i < 4; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	int max_quant_intervals = bytesToInt_bigEndian(byteBuf);// 4	
 
 	pde_params->maxRangeRadius = max_quant_intervals/2;
 
 	for (i = 0; i < 4; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	(*this)->intervals = bytesToInt_bigEndian(byteBuf);// 4	
 
 	for (i = 0; i < 8; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	(*this)->medianValue = bytesToDouble(byteBuf);//8
 
-	(*this)->reqLength = flatBytes[index++]; //1
+	(*this)->reqLength = flatBytes[idx++]; //1
 	
 	for (i = 0; i < 8; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	(*this)->realPrecision = bytesToDouble(byteBuf);//8
 
 	for (i = 0; i < pde_exe->SZ_SIZE_TYPE; i++)
-	    byteBuf[i] = flatBytes[index++];
+	    byteBuf[i] = flatBytes[idx++];
 	(*this)->typeArray_size = bytesToSize(byteBuf, pde_exe->SZ_SIZE_TYPE);
 
 	for (i = 0; i < pde_exe->SZ_SIZE_TYPE; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	(*this)->exactDataNum = bytesToSize(byteBuf, pde_exe->SZ_SIZE_TYPE);// ST
 
 	for (i = 0; i < pde_exe->SZ_SIZE_TYPE; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	(*this)->exactMidBytes_size = bytesToSize(byteBuf, pde_exe->SZ_SIZE_TYPE);// ST
 
 	size_t logicLeadNumBitsNum = (*this)->exactDataNum * 2;
@@ -122,12 +122,12 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 		(*this)->leadNumArray_size = (logicLeadNumBitsNum >> 3) + 1;
 	}
 	
-	(*this)->typeArray = &flatBytes[index];
+	(*this)->typeArray = &flatBytes[idx];
 	//retrieve the number of states (i.e., stateNum)
 	(*this)->allNodes = bytesToInt_bigEndian((*this)->typeArray); //the first 4 bytes store the stateNum
 	(*this)->stateNum = ((*this)->allNodes+1)/2;	
 
-	index+=(*this)->typeArray_size;
+	idx+=(*this)->typeArray_size;
 
 
     // todo need check length
@@ -135,15 +135,15 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 			- pde_exe->SZ_SIZE_TYPE - pde_exe->SZ_SIZE_TYPE - pde_exe->SZ_SIZE_TYPE
 			- (*this)->leadNumArray_size - (*this)->exactMidBytes_size - (*this)->typeArray_size;
 
-	(*this)->leadNumArray = &flatBytes[index];
+	(*this)->leadNumArray = &flatBytes[idx];
 	
-	index+=(*this)->leadNumArray_size;
+	idx+=(*this)->leadNumArray_size;
 	
-	(*this)->exactMidBytes = &flatBytes[index];
+	(*this)->exactMidBytes = &flatBytes[idx];
 	
-	index+=(*this)->exactMidBytes_size;
+	idx+=(*this)->exactMidBytes_size;
 	
-	(*this)->residualMidBits = &flatBytes[index];
+	(*this)->residualMidBits = &flatBytes[idx];
 	
 	
 	return errorBoundMode;

deps/TSZ/sz/src/TightDataPointStorageF.c

@@ -25,15 +25,15 @@ void new_TightDataPointStorageF_Empty(TightDataPointStorageF **this)
 int new_TightDataPointStorageF_fromFlatBytes(TightDataPointStorageF **this, unsigned char* flatBytes, size_t flatBytesLength, sz_exedata* pde_exe, sz_params* pde_params)
 {
 	new_TightDataPointStorageF_Empty(this);
-	size_t i, index = 0;
+	size_t i, idx = 0;
 
 	//
 	// parse tdps
 	//
 
 	// 1 version(1)
-	unsigned char version = flatBytes[index++]; //1
-	unsigned char sameRByte = flatBytes[index++]; //1
+	unsigned char version = flatBytes[idx++]; //1
+	unsigned char sameRByte = flatBytes[idx++]; //1
 
     // parse data format
 	switch (version)
@@ -51,12 +51,12 @@ int new_TightDataPointStorageF_fromFlatBytes(TightDataPointStorageF **this, unsi
 	pde_exe->SZ_SIZE_TYPE = ((sameRByte & 0x40)>>6)==1?8:4; 				//0100,0000	
 	int errorBoundMode = SZ_ABS;
     // 3 meta(2)   
-	convertBytesToSZParams(&(flatBytes[index]), pde_params, pde_exe);
-	index += MetaDataByteLength;
+	convertBytesToSZParams(&(flatBytes[idx]), pde_params, pde_exe);
+	idx += MetaDataByteLength;
     // 4 element count(4)
 	unsigned char dsLengthBytes[8];
 	for (i = 0; i < pde_exe->SZ_SIZE_TYPE; i++)
-		dsLengthBytes[i] = flatBytes[index++];
+		dsLengthBytes[i] = flatBytes[idx++];
 	(*this)->dataSeriesLength = bytesToSize(dsLengthBytes, pde_exe->SZ_SIZE_TYPE);// 4 or 8		
 	if((*this)->isLossless==1)
 	{
@@ -66,7 +66,7 @@ int new_TightDataPointStorageF_fromFlatBytes(TightDataPointStorageF **this, unsi
 	else if(same==1)
 	{
 		(*this)->allSameData = 1;
-		(*this)->exactMidBytes = &(flatBytes[index]);
+		(*this)->exactMidBytes = &(flatBytes[idx]);
 		return errorBoundMode;
 	}
 	else
@@ -76,40 +76,40 @@ int new_TightDataPointStorageF_fromFlatBytes(TightDataPointStorageF **this, unsi
 	if(isRegression == 1)
 	{
 		(*this)->raBytes_size = flatBytesLength - 1 - 1 - MetaDataByteLength - pde_exe->SZ_SIZE_TYPE;
-		(*this)->raBytes = &(flatBytes[index]);
+		(*this)->raBytes = &(flatBytes[idx]);
 		return errorBoundMode;
 	}			
     // 5 quant intervals(4)   
 	unsigned char byteBuf[8];
 	for (i = 0; i < 4; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	int max_quant_intervals = bytesToInt_bigEndian(byteBuf);// 4	
 	pde_params->maxRangeRadius = max_quant_intervals/2;
     // 6 intervals
 	for (i = 0; i < 4; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	(*this)->intervals = bytesToInt_bigEndian(byteBuf);// 4	
     // 7 median
 	for (i = 0; i < 4; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	(*this)->medianValue = bytesToFloat(byteBuf); //4
 	// 8 reqLength
-	(*this)->reqLength = flatBytes[index++]; //1
+	(*this)->reqLength = flatBytes[idx++]; //1
 	// 9 realPrecision(8)
 	for (i = 0; i < 8; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	(*this)->realPrecision = bytesToDouble(byteBuf);//8
 	// 10 typeArray_size
 	for (i = 0; i < pde_exe->SZ_SIZE_TYPE; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	(*this)->typeArray_size = bytesToSize(byteBuf, pde_exe->SZ_SIZE_TYPE);// 4		
     // 11 exactNum
 	for (i = 0; i < pde_exe->SZ_SIZE_TYPE; i++)
-		byteBuf[i] = flatBytes[index++];    
+		byteBuf[i] = flatBytes[idx++];    
 	(*this)->exactDataNum = bytesToSize(byteBuf, pde_exe->SZ_SIZE_TYPE);// ST
     // 12 mid size
 	for (i = 0; i < pde_exe->SZ_SIZE_TYPE; i++)
-		byteBuf[i] = flatBytes[index++];
+		byteBuf[i] = flatBytes[idx++];
 	(*this)->exactMidBytes_size = bytesToSize(byteBuf, pde_exe->SZ_SIZE_TYPE);// STqq
     
 	// calc leadNumArray_size
@@ -124,20 +124,20 @@ int new_TightDataPointStorageF_fromFlatBytes(TightDataPointStorageF **this, unsi
 	}	
 
     // 13 typeArray
-	(*this)->typeArray = &flatBytes[index]; 
+	(*this)->typeArray = &flatBytes[idx]; 
 	//retrieve the number of states (i.e., stateNum)
 	(*this)->allNodes = bytesToInt_bigEndian((*this)->typeArray); //the first 4 bytes store the stateNum
 	(*this)->stateNum = ((*this)->allNodes+1)/2;	
-	index+=(*this)->typeArray_size;
+	idx+=(*this)->typeArray_size;
 
     // 14 leadNumArray
-	(*this)->leadNumArray = &flatBytes[index];
-	index += (*this)->leadNumArray_size;
+	(*this)->leadNumArray = &flatBytes[idx];
+	idx += (*this)->leadNumArray_size;
 	// 15 exactMidBytes
-	(*this)->exactMidBytes = &flatBytes[index];
-	index+=(*this)->exactMidBytes_size;
+	(*this)->exactMidBytes = &flatBytes[idx];
+	idx+=(*this)->exactMidBytes_size;
 	// 16 residualMidBits
-	(*this)->residualMidBits = &flatBytes[index];
+	(*this)->residualMidBits = &flatBytes[idx];
 
     // calc residualMidBits_size
 	(*this)->residualMidBits_size = flatBytesLength - 1 - 1 - MetaDataByteLength - pde_exe->SZ_SIZE_TYPE - 4 - 4 - 4 - 1 - 8 

deps/cJson/src/cJSON.c

@@ -1683,7 +1683,7 @@ CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)
     return (int)size;
 }
 
-static cJSON* get_array_item(const cJSON *array, size_t index)
+static cJSON* get_array_item(const cJSON *array, size_t idx)
 {
     cJSON *current_child = NULL;
 
@@ -1693,23 +1693,23 @@ static cJSON* get_array_item(const cJSON *array, size_t index)
     }
 
     current_child = array->child;
-    while ((current_child != NULL) && (index > 0))
+    while ((current_child != NULL) && (idx > 0))
     {
-        index--;
+        idx--;
         current_child = current_child->next;
     }
 
     return current_child;
 }
 
-CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index)
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int idx)
 {
-    if (index < 0)
+    if (idx < 0)
     {
         return NULL;
     }
 
-    return get_array_item(array, (size_t)index);
+    return get_array_item(array, (size_t)idx);
 }
 
 static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)

deps/lua/src/ldump.c

@@ -60,7 +60,7 @@ static void DumpVector(const void* b, int n, size_t size, DumpState* D)
 
 static void DumpString(const TString* s, DumpState* D)
 {
- if (s==NULL || getstr(s)==NULL)
+ if (s==NULL)
  {
   size_t size=0;
   DumpVar(size,D);

docs-cn/02-intro.md

----
-title: 产品简介
-toc_max_heading_level: 2
----
-
-TDengine 是一款高性能、分布式、支持 SQL 的时序数据库 (Database)，其核心代码，包括集群功能全部开源（开源协议，AGPL v3.0）。TDengine 能被广泛运用于物联网、工业互联网、车联网、IT 运维、金融等领域。除核心的时序数据库 (Database) 功能外，TDengine 还提供[缓存](/develop/cache/)、[数据订阅](/develop/subscribe)、[流式计算](/develop/continuous-query)等大数据平台所需要的系列功能，最大程度减少研发和运维的复杂度。
-
-本章节介绍TDengine的主要功能、竞争优势、适用场景、与其他数据库的对比测试等等，让大家对TDengine有个整体的了解。
-
-## 主要功能
-
-TDengine的主要功能如下：
-
-1. 高速数据写入，除 [SQL 写入](/develop/insert-data/sql-writing)外，还支持 [Schemaless 写入](/reference/schemaless/)，支持 [InfluxDB LINE 协议](/develop/insert-data/influxdb-line)，[OpenTSDB Telnet](/develop/insert-data/opentsdb-telnet), [OpenTSDB JSON ](/develop/insert-data/opentsdb-json)等协议写入；
-2. 第三方数据采集工具 [Telegraf](/third-party/telegraf)，[Prometheus](/third-party/prometheus)，[StatsD](/third-party/statsd)，[collectd](/third-party/collectd)，[icinga2](/third-party/icinga2), [TCollector](/third-party/tcollector), [EMQ](/third-party/emq-broker), [HiveMQ](/third-party/hive-mq-broker) 等都可以进行配置后，不用任何代码，即可将数据写入；
-3. 支持[各种查询](/develop/query-data),包括聚合查询、嵌套查询、降采样查询、插值等
-4. 支持[用户自定义函数](/develop/udf)
-5. 支持[缓存](/develop/cache)，将每张表的最后一条记录缓存起来，这样无需 Redis
-6. 支持[连续查询](/develop/continuous-query)(Continuous Query)
-7. 支持[数据订阅](/develop/subscribe)，而且可以指定过滤条件
-8. 支持[集群](/cluster/)，可以通过多节点进行水平扩展，并通过多副本实现高可靠
-9. 提供[命令行程序](/reference/taos-shell)，便于管理集群，检查系统状态，做即席查询
-10. 提供多种数据的[导入](/operation/import)、[导出](/operation/export)
-11. 支持对[TDengine 集群本身的监控](/operation/monitor)
-12. 提供 [C/C++](/reference/connector/cpp), [Java](/reference/connector/java), [Python](/reference/connector/python), [Go](/reference/connector/go), [Rust](/reference/connector/rust), [Node.js](/reference/connector/node) 等多种编程语言的[连接器](/reference/connector/)
-13. 支持 [REST 接口](/reference/rest-api/)
-14. 支持与[ Grafana 无缝集成](/third-party/grafana)
-15. 支持与 Google Data Studio 无缝集成
-
-更多细小的功能，请阅读整个文档。
-
-## 竞争优势
-
-由于 TDengine 充分利用了[时序数据特点](https://www.taosdata.com/blog/2019/07/09/105.html)，比如结构化、无需事务、很少删除或更新、写多读少等等，设计了全新的针对时序数据的存储引擎和计算引擎，因此与其他时序数据库相比，TDengine 有以下特点：
-
-- **[高性能](https://www.taosdata.com/fast)**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，而且存储空间也大为节省。
-
-- **[分布式](https://www.taosdata.com/scalable)**：通过原生分布式的设计，TDengine 提供了水平扩展的能力，只需要增加节点就能获得更强的数据处理能力，同时通过多副本机制保证了系统的高可用。
-
-- **[支持 SQL](https://www.taosdata.com/sql-support)**：TDengine 采用 SQL 作为数据查询语言，减少学习和迁移成本，同时提供 SQL 扩展来处理时序数据特有的分析，而且支持方便灵活的 schemaless 数据写入。
-
-- **All in One**：将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低应用开发和维护成本。
-
-- **零管理**：安装、集群几秒搞定，无任何依赖，不用分库分表，系统运行状态监测能与 Grafana 或其他运维工具无缝集成。
-
-- **零学习成本**：采用 SQL 查询语言，支持 C/C++、Python、Java、Go、Rust、Node.js、C#、Lua（社区贡献）、PHP（社区贡献） 等多种编程语言,与 MySQL 相似，零学习成本。
-
-- **无缝集成**：不用一行代码，即可与 Telegraf、Grafana、Prometheus、EMQX、HiveMQ、StatsD、collectd、icinga、TCollector、Matlab、R 等第三方工具无缝集成。
-
-- **互动 Console**: 通过命令行 console，不用编程，执行 SQL 语句就能做即席查询、各种数据库的操作、管理以及集群的维护.
-
-采用 TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。表现在几个方面：
-
-1. 由于其超强性能，它能将系统需要的计算资源和存储资源大幅降低
-2. 因为采用 SQL 接口，能与众多第三放软件无缝集成，学习迁移成本大幅下降
-3. 因为其 All In One 的特性，系统复杂度降低，能降研发成本
-4. 因为运维维护简单，运营维护成本能大幅降低
-
-## 技术生态
-
-在整个时序大数据平台中，TDengine 在其中扮演的角色如下：
-
-<figure>
-
-![TDengine Database 技术生态图](eco_system.webp)
-
-</figure>
-<center>图 1. TDengine技术生态图</center>
-
-上图中，左侧是各种数据采集或消息队列，包括 OPC-UA、MQTT、Telegraf、也包括 Kafka, 他们的数据将被源源不断的写入到 TDengine。右侧则是可视化、BI 工具、组态软件、应用程序。下侧则是 TDengine 自身提供的命令行程序 (CLI) 以及可视化管理管理。
-
-## 总体适用场景
-
-作为一个高性能、分布式、支持 SQL 的时序数据库 （Database)，TDengine 的典型适用场景包括但不限于 IoT、工业互联网、车联网、IT 运维、能源、金融证券等领域。需要指出的是，TDengine 是针对时序数据场景设计的专用数据库和专用大数据处理工具，因充分利用了时序大数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM 等通用型数据。本文对适用场景做更多详细的分析。
-
-### 数据源特点和需求
-
-从数据源角度，设计人员可以从下面几个角度分析 TDengine 在目标应用系统里面的适用性。
-
-| 数据源特点和需求             | 不适用 | 可能适用 | 非常适用 | 简单说明                                                                                                                        |
-| ---------------------------- | ------ | -------- | -------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| 总体数据量巨大               |        |          | √        | TDengine 在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构，达到业界最优的存储效率。                               |
-| 数据输入速度偶尔或者持续巨大 |        |          | √        | TDengine 的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。 |
-| 数据源数目巨大               |        |          | √        | TDengine 设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。           |
-
-### 系统架构要求
-
-| 系统架构要求           | 不适用 | 可能适用 | 非常适用 | 简单说明                                                                                              |
-| ---------------------- | ------ | -------- | -------- | ----------------------------------------------------------------------------------------------------- |
-| 要求简单可靠的系统架构 |        |          | √        | TDengine 的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。 |
-| 要求容错和高可靠       |        |          | √        | TDengine 的集群功能，自动提供容错灾备等高可靠功能。                                                   |
-| 标准化规范             |        |          | √        | TDengine 使用标准的 SQL 语言提供主要功能，遵守标准化规范。                                            |
-
-### 系统功能需求
-
-| 系统功能需求               | 不适用 | 可能适用 | 非常适用 | 简单说明                                                                                                              |
-| -------------------------- | ------ | -------- | -------- | --------------------------------------------------------------------------------------------------------------------- |
-| 要求完整的内置数据处理算法 |        | √        |          | TDengine 的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。 |
-| 需要大量的交叉查询处理     |        | √        |          | 这种类型的处理更多应该用关系型数据系统处理，或者应该考虑 TDengine 和关系型数据系统配合实现系统功能。                  |
-
-### 系统性能需求
-
-| 系统性能需求           | 不适用 | 可能适用 | 非常适用 | 简单说明                                                                                               |
-| ---------------------- | ------ | -------- | -------- | ------------------------------------------------------------------------------------------------------ |
-| 要求较大的总体处理能力 |        |          | √        | TDengine 的集群功能可以轻松地让多服务器配合达成处理能力的提升。                                        |
-| 要求高速处理数据       |        |          | √        | TDengine 的专门为 IoT 优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。 |
-| 要求快速处理小粒度数据 |        |          | √        | 这方面 TDengine 性能可以完全对标关系型和 NoSQL 型数据处理系统。                                        |
-
-### 系统维护需求
-
-| 系统维护需求           | 不适用 | 可能适用 | 非常适用 | 简单说明                                                                                                              |
-| ---------------------- | ------ | -------- | -------- | --------------------------------------------------------------------------------------------------------------------- |
-| 要求系统可靠运行       |        |          | √        | TDengine 的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。         |
-| 要求运维学习成本可控   |        |          | √        | 同上。                                                                                                                |
-| 要求市场有大量人才储备 | √      |          |          | TDengine 作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务。 |
-
-## 与其他数据库的对比测试
-
-- [用 InfluxDB 开源的性能测试工具对比 InfluxDB 和 TDengine](https://www.taosdata.com/blog/2020/01/13/1105.html)
-- [TDengine 与 OpenTSDB 对比测试](https://www.taosdata.com/blog/2019/08/21/621.html)
-- [TDengine 与 Cassandra 对比测试](https://www.taosdata.com/blog/2019/08/14/573.html)
-- [TDengine VS InfluxDB ，写入性能大 PK ！](https://www.taosdata.com/2021/11/05/3248.html)
-- [TDengine 和 InfluxDB 查询性能对比测试报告](https://www.taosdata.com/2022/02/22/5969.html)
-- [TDengine 与 InfluxDB、OpenTSDB、Cassandra、MySQL、ClickHouse 等数据库的对比测试报告](https://www.taosdata.com/downloads/TDengine_Testing_Report_cn.pdf)

docs-cn/04-concept/index.md

----
-title: 数据模型和基本概念
----
-
-为了便于解释基本概念，便于撰写示例程序，整个 TDengine 文档以智能电表作为典型时序数据场景。假设每个智能电表采集电流、电压、相位三个量，有多个智能电表，每个电表有位置 location 和分组 group ID 的静态属性. 其采集的数据类似如下的表格：
-
-<div className="center-table">
-<table>
-<thead><tr>
-    <th>Device ID</th>
-    <th>Time Stamp</th>
-    <th colSpan="3">Collected Metrics</th>
-    <th colSpan="2">Tags</th>
-    </tr>
-<tr>
-<th>Device ID</th>
-<th>Time Stamp</th>
-<th>current</th>
-<th>voltage</th>
-<th>phase</th>
-<th>location</th>
-<th>groupId</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td>d1001</td>
-<td>1538548685000</td>
-<td>10.3</td>
-<td>219</td>
-<td>0.31</td>
-<td>California.SanFrancisco</td>
-<td>2</td>
-</tr>
-<tr>
-<td>d1002</td>
-<td>1538548684000</td>
-<td>10.2</td>
-<td>220</td>
-<td>0.23</td>
-<td>California.SanFrancisco</td>
-<td>3</td>
-</tr>
-<tr>
-<td>d1003</td>
-<td>1538548686500</td>
-<td>11.5</td>
-<td>221</td>
-<td>0.35</td>
-<td>California.LosAngeles</td>
-<td>3</td>
-</tr>
-<tr>
-<td>d1004</td>
-<td>1538548685500</td>
-<td>13.4</td>
-<td>223</td>
-<td>0.29</td>
-<td>California.LosAngeles</td>
-<td>2</td>
-</tr>
-<tr>
-<td>d1001</td>
-<td>1538548695000</td>
-<td>12.6</td>
-<td>218</td>
-<td>0.33</td>
-<td>California.SanFrancisco</td>
-<td>2</td>
-</tr>
-<tr>
-<td>d1004</td>
-<td>1538548696600</td>
-<td>11.8</td>
-<td>221</td>
-<td>0.28</td>
-<td>California.LosAngeles</td>
-<td>2</td>
-</tr>
-<tr>
-<td>d1002</td>
-<td>1538548696650</td>
-<td>10.3</td>
-<td>218</td>
-<td>0.25</td>
-<td>California.SanFrancisco</td>
-<td>3</td>
-</tr>
-<tr>
-<td>d1001</td>
-<td>1538548696800</td>
-<td>12.3</td>
-<td>221</td>
-<td>0.31</td>
-<td>California.SanFrancisco</td>
-<td>2</td>
-</tr>
-</tbody>
-</table>
-<a href="#model_table1">表 1：智能电表数据示例</a>
-</div>
-
-每一条记录都有设备 ID，时间戳，采集的物理量以及每个设备相关的静态标签。每个设备是受外界的触发，或按照设定的周期采集数据。采集的数据点是时序的，是一个数据流。
-
-## 采集量 (Metric)
-
-采集量是指传感器、设备或其他类型采集点采集的物理量，比如电流、电压、温度、压力、GPS 位置等，是随时间变化的，数据类型可以是整型、浮点型、布尔型，也可是字符串。随着时间的推移，存储的采集量的数据量越来越大。
-
-## 标签 (Label/Tag)
-
-标签是指传感器、设备或其他类型采集点的静态属性，不是随时间变化的，比如设备型号、颜色、设备的所在地等，数据类型可以是任何类型。虽然是静态的，但 TDengine 容许用户修改、删除或增加标签值。与采集量不一样的是，随时间的推移，存储的标签的数据量不会有什么变化。
-
-## 数据采集点 (Data Collection Point)
-
-数据采集点是指按照预设时间周期或受事件触发采集物理量的硬件或软件。一个数据采集点可以采集一个或多个采集量，**但这些采集量都是同一时刻采集的，具有相同的时间戳**。对于复杂的设备，往往有多个数据采集点，每个数据采集点采集的周期都可能不一样，而且完全独立，不同步。比如对于一台汽车，有数据采集点专门采集 GPS 位置，有数据采集点专门采集发动机状态，有数据采集点专门采集车内的环境，这样一台汽车就有三个数据采集点。
-
-## 表 (Table)
-
-因为采集量一般是结构化数据，同时为降低学习门槛，TDengine 采用传统的关系型数据库模型管理数据。用户需要先创建库，然后创建表，之后才能插入或查询数据。
-
-为充分利用其数据的时序性和其他数据特点，TDengine 采取**一个数据采集点一张表**的策略，要求对每个数据采集点单独建表（比如有一千万个智能电表，就需创建一千万张表，上述表格中的 d1001，d1002，d1003，d1004 都需单独建表），用来存储这个数据采集点所采集的时序数据。这种设计有几大优点：
-
-1. 由于不同数据采集点产生数据的过程完全独立，每个数据采集点的数据源是唯一的，一张表也就只有一个写入者，这样就可采用无锁方式来写，写入速度就能大幅提升。
-2. 对于一个数据采集点而言，其产生的数据是按照时间排序的，因此写的操作可用追加的方式实现，进一步大幅提高数据写入速度。
-3. 一个数据采集点的数据是以块为单位连续存储的。如果读取一个时间段的数据，它能大幅减少随机读取操作，成数量级的提升读取和查询速度。
-4. 一个数据块内部，采用列式存储，对于不同数据类型，采用不同压缩算法，而且由于一个数据采集点的采集量的变化是缓慢的，压缩率更高。
-
-如果采用传统的方式，将多个数据采集点的数据写入一张表，由于网络延时不可控，不同数据采集点的数据到达服务器的时序是无法保证的，写入操作是要有锁保护的，而且一个数据采集点的数据是难以保证连续存储在一起的。**采用一个数据采集点一张表的方式，能最大程度的保证单个数据采集点的插入和查询的性能是最优的。**
-
-TDengine 建议用数据采集点的名字（如上表中的 D1001）来做表名。每个数据采集点可能同时采集多个采集量（如上表中的 current，voltage，phase），每个采集量对应一张表中的一列，数据类型可以是整型、浮点型、字符串等。除此之外，表的第一列必须是时间戳，即数据类型为 timestamp。对采集量，TDengine 将自动按照时间戳建立索引，但对采集量本身不建任何索引。数据用列式存储方式保存。
-
-对于复杂的设备，比如汽车，它有多个数据采集点，那么就需要为一台汽车建立多张表。
-
-## 超级表 (STable)
-
-由于一个数据采集点一张表，导致表的数量巨增，难以管理，而且应用经常需要做采集点之间的聚合操作，聚合的操作也变得复杂起来。为解决这个问题，TDengine 引入超级表（Super Table，简称为 STable）的概念。
-
-超级表是指某一特定类型的数据采集点的集合。同一类型的数据采集点，其表的结构是完全一样的，但每个表（数据采集点）的静态属性（标签）是不一样的。描述一个超级表（某一特定类型的数据采集点的集合），除需要定义采集量的表结构之外，还需要定义其标签的 schema，标签的数据类型可以是整数、浮点数、字符串，标签可以有多个，可以事后增加、删除或修改。如果整个系统有 N 个不同类型的数据采集点，就需要建立 N 个超级表。
-
-在 TDengine 的设计里，**表用来代表一个具体的数据采集点，超级表用来代表一组相同类型的数据采集点集合**。
-
-## 子表 (Subtable)
-
-当为某个具体数据采集点创建表时，用户可以使用超级表的定义做模板，同时指定该具体采集点（表）的具体标签值来创建该表。**通过超级表创建的表称之为子表**。正常的表与子表的差异在于：
-
-1. 子表就是表，因此所有正常表的SQL操作都可以在子表上执行。
-2. 子表在正常表的基础上有扩展，它是带有静态标签的，而且这些标签可以事后增加、删除、修改，而正常的表没有。
-3. 子表一定属于一张超级表，但普通表不属于任何超级表
-4. 普通表无法转为子表，子表也无法转为普通表。
-
-超级表与与基于超级表建立的子表之间的关系表现在：
-
-1. 一张超级表包含有多张子表，这些子表具有相同的采集量 schema，但带有不同的标签值。
-2. 不能通过子表调整数据或标签的模式，对于超级表的数据模式修改立即对所有的子表生效。
-3. 超级表只定义一个模板，自身不存储任何数据或标签信息。因此，不能向一个超级表写入数据，只能将数据写入子表中。
-
-查询既可以在表上进行，也可以在超级表上进行。针对超级表的查询，TDengine 将把所有子表中的数据视为一个整体数据集进行处理，会先把满足标签过滤条件的表从超级表中找出来，然后再扫描这些表的时序数据，进行聚合操作，这样需要扫描的数据集会大幅减少，从而显著提高查询的性能。本质上，TDengine 通过对超级表查询的支持，实现了多个同类数据采集点的高效聚合。
-
-TDengine系统建议给一个数据采集点建表，需要通过超级表建表，而不是建普通表。
-
-## 库 (database)
-
-库是指一组表的集合。TDengine 容许一个运行实例有多个库，而且每个库可以配置不同的存储策略。不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为了在各种场景下 TDengine 都能最大效率的工作，TDengine 建议将不同数据特征的超级表创建在不同的库里。
-
-一个库里，可以有一到多个超级表，但一个超级表只属于一个库。一个超级表所拥有的子表全部存在一个库里。
-
-## FQDN & End Point
-
-FQDN (fully qualified domain name, 完全限定域名)是 Internet 上特定计算机或主机的完整域名。FQDN 由两部分组成:主机名和域名。例如，假设邮件服务器的 FQDN 可能是 mail.tdengine.com。主机名是 mail，主机位于域名 tdengine.com 中。DNS(Domain Name System)，负责将 FQDN 翻译成 IP，是互联网应用的寻址方式。对于没有 DNS 的系统，可以通过配置 hosts 文件来解决。
-
-TDengine 集群的每个节点是由 End Point 来唯一标识的，End Point 是由 FQDN 外加 Port 组成，比如 h1.tdengine.com:6030。这样当 IP 发生变化的时候，我们依然可以使用 FQDN 来动态找到节点，不需要更改集群的任何配置。而且采用 FQDN，便于内网和外网对同一个集群的统一访问。
-
-TDengine 不建议采用直接的 IP 地址访问集群，不利于管理。不了解 FQDN 概念，请看博文[《一篇文章说清楚 TDengine 的 FQDN》](https://www.taosdata.com/blog/2020/09/11/1824.html)。

docs-cn/05-get-started/_pkg_install.mdx

-import PkgList from "/components/PkgList";
-
-TDengine 的安装非常简单，从下载到安装成功仅仅只要几秒钟。
-
-为方便使用，从 2.4.0.10 开始，标准的服务端安装包包含了 taos、taosd、taosAdapter、taosdump、taosBenchmark、TDinsight 安装脚本和示例代码；如果您只需要用到服务端程序和客户端连接的 C/C++ 语言支持，也可以仅下载 lite 版本的安装包。
-
-在安装包格式上，我们提供 tar.gz, rpm 和 deb 格式，为企业客户提供 tar.gz 格式安装包，以方便在特定操作系统上使用。需要注意的是，rpm 和 deb 包不含 taosdump、taosBenchmark 和 TDinsight 安装脚本，这些工具需要通过安装 taosTool 包获得。
-
-发布版本包括稳定版和 Beta 版，Beta 版含有更多新功能。正式上线或测试建议安装稳定版。您可以根据需要选择下载：
-
-<PkgList type={0}/>
-
-具体的安装方法，请参见[安装包的安装和卸载](/operation/pkg-install)。
-
-下载其他组件、最新 Beta 版及之前版本的安装包，请点击[这里](https://www.taosdata.com/all-downloads)
-
-查看 Release Notes, 请点击[这里](https://github.com/taosdata/TDengine/releases) 

docs-cn/05-get-started/index.md

----
-title: 立即开始
-description: '从 Docker，安装包或使用 apt-get 快速安装 TDengine, 通过命令行程序TAOS CLI和工具 taosdemo 快速体验 TDengine 功能'
----
-
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-import PkgInstall from "./\_pkg_install.mdx";
-import AptGetInstall from "./\_apt_get_install.mdx";
-
-## 安装
-
-TDengine 完整的软件包包括服务端（taosd）、用于与第三方系统对接并提供 RESTful 接口的 taosAdapter、应用驱动（taosc）、命令行程序 (CLI，taos) 和一些工具软件，目前 2.X 版服务端 taosd 和 taosAdapter 仅在 Linux 系统上安装和运行，后续将支持 Windows、macOS 等系统。应用驱动 taosc 与 TDengine CLI 可以在 Windows 或 Linux 上安装和运行。TDengine 除了提供多种语言的连接器之外，还通过 [taosAdapter](/reference/taosadapter) 提供 [RESTful 接口](/reference/rest-api)。但在 2.4 之前的版本中没有 taosAdapter，RESTful 接口是由 taosd 内置的 HTTP 服务提供的。
-
-TDengine 支持 X64/ARM64/MIPS64/Alpha64 硬件平台，后续将支持 ARM32、RISC-V 等 CPU 架构。
-
-<Tabs defaultValue="apt-get">
-<TabItem value="docker" label="Docker">
-如果已经安装了 docker， 只需执行下面的命令。
-
-```shell
-docker run -d -p 6030-6049:6030-6049 -p 6030-6049:6030-6049/udp tdengine/tdengine
-```
-
-确定该容器已经启动并且在正常运行
-
-```shell
-docker ps
-```
-
-进入该容器并执行 bash
-
-```shell
-docker exec -it <container name> bash
-```
-
-然后就可以执行相关的 Linux 命令操作和访问 TDengine
-
-详细操作方法请参照 [通过 Docker 快速体验 TDengine](/train-faq/docker)。
-
-:::info
-从 2.4.0.10 开始，除 taosd 以外，Docker 镜像还包含：taos、taosAdapter、taosdump、taosBenchmark、TDinsight 安装脚本和示例代码。启动 Docker 容器时，将同时启动 taosAdapter 和 taosd，实现对 RESTful 的支持。
-
-:::
-
-</TabItem>
-<TabItem value="apt-get" label="apt-get">
-<AptGetInstall />
-</TabItem>
-<TabItem value="pkg" label="安装包">
-<PkgInstall />
-</TabItem>
-<TabItem value="src" label="源码">
-
-如果您希望对 TDengine 贡献代码或对内部实现感兴趣，请参考我们的 [TDengine GitHub 主页](https://github.com/taosdata/TDengine) 下载源码构建和安装.
-
-下载其他组件、最新 Beta 版及之前版本的安装包，请点击[这里](https://www.taosdata.com/cn/all-downloads/)。
-
-</TabItem>
-</Tabs>
-
-## 启动
-
-安装后，请使用 `systemctl` 命令来启动 TDengine 的服务进程。
-
-```bash
-systemctl start taosd
-```
-
-检查服务是否正常工作：
-
-```bash
-systemctl status taosd
-```
-
-如果 TDengine 服务正常工作，那么您可以通过 TDengine 的命令行程序 `taos` 来访问并体验 TDengine。
-
-:::info
-
-- systemctl 命令需要 _root_ 权限来运行，如果您非 _root_ 用户，请在命令前添加 sudo 。
-- 为更好的获得产品反馈，改善产品，TDengine 会采集基本的使用信息，但您可以修改系统配置文件 taos.cfg 里的配置参数 telemetryReporting，将其设为 0，就可将其关闭。
-- TDengine 采用 FQDN（一般就是 hostname）作为节点的 ID，为保证正常运行，需要给运行 taosd 的服务器配置好 FQDN，在 TDengine CLI 或应用运行的机器配置好 DNS 服务或 hosts 文件，保证 FQDN 能够解析。
-- `systemctl stop taosd` 指令在执行后并不会马上停止 TDengine 服务，而是会等待系统中必要的落盘工作正常完成。在数据量很大的情况下，这可能会消耗较长时间。
-
-TDengine 支持在使用 [`systemd`](https://en.wikipedia.org/wiki/Systemd) 做进程服务管理的 Linux 系统上安装，用 `which systemctl` 命令来检测系统中是否存在 `systemd` 包:
-
-```bash
-which systemctl
-```
-
-如果系统中不支持 `systemd`，也可以用手动运行 `/usr/local/taos/bin/taosd` 方式启动 TDengine 服务。
-
-:::note
-
-## TDengine 命令行 (CLI)
-
-为便于检查 TDengine 的状态，执行数据库 (Database) 的各种即席(Ad Hoc)查询，TDengine 提供一命令行应用程序(以下简称为 TDengine CLI) taos。要进入 TDengine 命令行，您只要在安装有 TDengine 的 Linux 终端执行 `taos` 即可。
-
-```bash
-taos
-```
-
-如果连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考 [FAQ](/train-faq/faq) 来解决终端连接服务端失败的问题）。 TDengine CLI 的提示符号如下：
-
-```cmd
-taos>
-```
-
-在 TDengine CLI 中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行数据库(database)插入查询操作。在终端中运行的 SQL 语句需要以分号结束来运行。示例：
-
-```sql
-create database demo;
-use demo;
-create table t (ts timestamp, speed int);
-insert into t values ('2019-07-15 00:00:00', 10);
-insert into t values ('2019-07-15 01:00:00', 20);
-select * from t;
-           ts            |    speed    |
-========================================
- 2019-07-15 00:00:00.000 |          10 |
- 2019-07-15 01:00:00.000 |          20 |
-Query OK, 2 row(s) in set (0.003128s)
-```
-
-除执行 SQL 语句外，系统管理员还可以从 TDengine CLI 进行检查系统运行状态、添加删除用户账号等操作。TAOS CLI 连同应用驱动也可以独立安装在 Linux 或 Windows 机器上运行，更多细节请参考 [这里](../reference/taos-shell/)
-
-## 使用 taosBenchmark 体验写入速度
-
-启动 TDengine 的服务，在 Linux 终端执行 `taosBenchmark` （曾命名为 `taosdemo`）：
-
-```bash
-taosBenchmark
-```
-
-该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "d0" 到 "d9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupId，groupId 被设置为 1 到 10， location 被设置为 "California.SanFrancisco" 或者 "California.LosAngeles"。
-
-这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能，即使在一台普通的 PC 服务器往往也仅需十几秒。
-
-taosBenchmark 命令本身带有很多选项，配置表的数目、记录条数等等，您可以设置不同参数进行体验，请执行 `taosBenchmark --help` 详细列出。taosBenchmark 详细使用方法请参照 [如何使用 taosBenchmark 对 TDengine 进行性能测试](https://www.taosdata.com/2021/10/09/3111.html)。
-
-## 使用 TDengine CLI 体验查询速度
-
-使用上述 taosBenchmark 插入数据后，可以在 TDengine CLI 输入查询命令，体验查询速度。
-
-查询超级表下记录总条数：
-
-```sql
-taos> select count(*) from test.meters;
-```
-
-查询 1 亿条记录的平均值、最大值、最小值等：
-
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.meters;
-```
-
-查询 location="California.SanFrancisco" 的记录总条数：
-
-```sql
-taos> select count(*) from test.meters where location="California.SanFrancisco";
-```
-
-查询 groupId=10 的所有记录的平均值、最大值、最小值等：
-
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.meters where groupId=10;
-```
-
-对表 d10 按 10s 进行平均值、最大值和最小值聚合统计：
-
-```sql
-taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
-```

docs-cn/07-develop/01-connect/_connect_c.mdx

-```c title="原生连接"
-{{#include docs-examples/c/connect_example.c}}
-```

docs-cn/07-develop/01-connect/_connect_cs.mdx

-```csharp title="原生连接"
-{{#include docs-examples/csharp/ConnectExample.cs}}
-```
-
-:::info
-C# 连接器目前只支持原生连接。
-
-:::

docs-cn/07-develop/01-connect/_connect_go.mdx

-#### 使用数据库访问统一接口
-
-```go title="原生连接"
-{{#include docs-examples/go/connect/cgoexample/main.go}}
-```
-
-```go title="REST 连接"
-{{#include docs-examples/go/connect/restexample/main.go}}
-```
-
-#### 使用高级封装
-
-也可以使用 driver-go 的 af 包建立连接。这个模块封装了 TDengine 的高级功能, 如：参数绑定、订阅等。
-
-```go title="使用 af 包建立原生连接"
-{{#include docs-examples/go/connect/afconn/main.go}}
-```

docs-cn/07-develop/01-connect/_connect_java.mdx

-```java title="原生连接"
-{{#include docs-examples/java/src/main/java/com/taos/example/JNIConnectExample.java}}
-```
-
-```java title="REST 连接"
-{{#include docs-examples/java/src/main/java/com/taos/example/RESTConnectExample.java:main}}
-```
-
-使用 REST 连接时，如果查询数据量比较大，还可开启批量拉取功能。
-
-```java title="开启批量拉取功能" {4}
-{{#include docs-examples/java/src/main/java/com/taos/example/WSConnectExample.java:main}}
-```
-
-更多连接参数配置，参考[Java 连接器](/reference/connector/java)

docs-cn/07-develop/01-connect/_connect_node.mdx

-```js title="原生连接"
-{{#include docs-examples/node/nativeexample/connect.js}}
-```
-
-```js title="REST 连接"
-{{#include docs-examples/node/restexample/connect.js}}
-```

docs-cn/07-develop/01-connect/_connect_php.mdx

-```php title="原生连接"
-{{#include docs-examples/php/connect.php}}
-```

docs-cn/07-develop/01-connect/_connect_python.mdx

-```python title="原生连接"
-{{#include docs-examples/python/connect_example.py}}
-```

docs-cn/07-develop/01-connect/_connect_r.mdx

-```r title="原生连接"
-{{#include docs-examples/R/connect_native.r:demo}}
-```

docs-cn/07-develop/01-connect/_connect_rust.mdx

-```rust title="原生连接/REST 连接"
-{{#include docs-examples/rust/nativeexample/examples/connect.rs}}
-```
-
-:::note
-对于 Rust 连接器， 连接方式的不同只体现在使用的特性不同。如果启用了 "rest" 特性，那么只有 RESTful 的实现会被编译进来。
-
-:::

docs-cn/07-develop/01-connect/index.md

----
-title: 建立连接
-description: "本节介绍如何使用连接器建立与 TDengine 的连接，给出连接器安装、连接的简单说明。"
----
-
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-import ConnJava from "./_connect_java.mdx";
-import ConnGo from "./_connect_go.mdx";
-import ConnRust from "./_connect_rust.mdx";
-import ConnNode from "./_connect_node.mdx";
-import ConnPythonNative from "./_connect_python.mdx";
-import ConnCSNative from "./_connect_cs.mdx";
-import ConnC from "./_connect_c.mdx";
-import ConnR from "./_connect_r.mdx";
-import ConnPHP from "./_connect_php.mdx";
-import InstallOnWindows from "../../14-reference/03-connector/_linux_install.mdx";
-import InstallOnLinux from "../../14-reference/03-connector/_windows_install.mdx";
-import VerifyLinux from "../../14-reference/03-connector/_verify_linux.mdx";
-import VerifyWindows from "../../14-reference/03-connector/_verify_windows.mdx";
-
-TDengine 提供了丰富的应用程序开发接口，为了便于用户快速开发自己的应用，TDengine 支持了多种编程语言的连接器，其中官方连接器包括支持 C/C++、Java、Python、Go、Node.js、C#、Rust、Lua（社区贡献）和 PHP （社区贡献）的连接器。这些连接器支持使用原生接口（taosc）和 REST 接口（部分语言暂不支持）连接 TDengine 集群。社区开发者也贡献了多个非官方连接器，例如 ADO.NET 连接器、Lua 连接器和 PHP 连接器。
-
-## 连接器建立连接的方式
-
-连接器建立连接的方式，TDengine 提供两种:
-
-1. 通过 taosAdapter 组件提供的 REST API 建立与 taosd 的连接，这种连接方式下文中简称“REST 连接”
-2. 通过客户端驱动程序 taosc 直接与服务端程序 taosd 建立连接，这种连接方式下文中简称“原生连接”。
-
-无论使用何种方式建立连接，连接器都提供了相同或相似的 API 操作数据库，都可以执行 SQL 语句，只是初始化连接的方式稍有不同，用户在使用上不会感到什么差别。
-
-关键不同点在于：
-
-1. 使用 REST 连接，用户无需安装客户端驱动程序 taosc，具有跨平台易用的优势，但性能要下降 30%左右。
-2. 使用原生连接可以体验 TDengine 的全部功能，如[参数绑定接口](/reference/connector/cpp#参数绑定-api)、[订阅](/reference/connector/cpp#订阅和消费-api)等等。
-
-## 安装客户端驱动 taosc
-
-如果选择原生连接，而且应用程序不在 TDengine 同一台服务器上运行，你需要先安装客户端驱动，否则可以跳过此一步。为避免客户端驱动和服务端不兼容，请使用一致的版本。
-
-### 安装步骤
-
-<Tabs defaultValue="linux" groupId="os">
-  <TabItem value="linux" label="Linux">
-    <InstallOnWindows />
-  </TabItem>
-  <TabItem value="windows" label="Windows">
-    <InstallOnLinux />
-  </TabItem>
-</Tabs>
-
-### 安装验证
-
-以上安装和配置完成后，并确认 TDengine 服务已经正常启动运行，此时可以执行安装包里带有的 TDengine 命令行程序 taos 进行登录。
-
-<Tabs defaultValue="linux" groupId="os">
-  <TabItem value="linux" label="Linux">
-    <VerifyLinux />
-  </TabItem>
-  <TabItem value="windows" label="Windows">
-    <VerifyWindows />
-  </TabItem>
-</Tabs>
-
-## 安装连接器
-
-<Tabs groupId="lang">
-<TabItem label="Java" value="java">
-  
-如果使用 maven 管理项目，只需在 pom.xml 中加入以下依赖。
-
-```xml
-<dependency>
-  <groupId>com.taosdata.jdbc</groupId>
-  <artifactId>taos-jdbcdriver</artifactId>
-  <version>2.0.38</version>
-</dependency>
-```
-
-</TabItem>
-<TabItem label="Python" value="python">
-
-使用 `pip` 从 PyPI 安装:
-
-```
-pip install taospy
-```
-
-从 Git URL 安装：
-
-```
-pip install git+https://github.com/taosdata/taos-connector-python.git
-```
-
-</TabItem>
-<TabItem label="Go" value="go">
-
-编辑 `go.mod` 添加 `driver-go` 依赖即可。
-
-```go-mod title=go.mod
-module goexample
-
-go 1.17
-
-require github.com/taosdata/driver-go/v2 develop
-```
-
-:::note
-driver-go 使用 cgo 封装了 taosc 的 API。cgo 需要使用 gcc 编译 C 的源码。因此需要确保你的系统上有 gcc。
-
-:::
-
-</TabItem>
-<TabItem label="Rust" value="rust">
-
-编辑 `Cargo.toml` 添加 `libtaos` 依赖即可。
-
-```toml title=Cargo.toml
-[dependencies]
-libtaos = { version = "0.4.2"}
-```
-
-:::info
-Rust 连接器通过不同的特性区分不同的连接方式。如果要建立 REST 连接，需要开启 `rest` 特性：
-
-```toml
-libtaos = { version = "*", features = ["rest"] }
-```
-
-:::
-
-</TabItem>
-<TabItem label="Node.js" value="node">
-
-Node.js 连接器通过不同的包提供不同的连接方式。
-
-1. 安装 Node.js 原生连接器
-
-  ```
-  npm i td2.0-connector
-  ```
-
-:::note
-推荐 Node 版本大于等于 `node-v12.8.0` 小于 `node-v13.0.0`
-::: 
-  
-2. 安装 Node.js REST 连接器
-
-  ```
-  npm i td2.0-rest-connector
-  ```
-
-</TabItem>
-<TabItem label="C#" value="csharp">
-
-编辑项目配置文件中添加 [TDengine.Connector](https://www.nuget.org/packages/TDengine.Connector/) 的引用即可：
-
-```xml title=csharp.csproj {12}
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <StartupObject>TDengineExample.AsyncQueryExample</StartupObject>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="TDengine.Connector" Version="1.0.6" />
-  </ItemGroup>
-
-</Project>
-```
-
-也可通过 dotnet 命令添加：
-
-```
-dotnet add package TDengine.Connector
-```
-
-:::note
-以下示例代码，均基于 dotnet6.0，如果使用其它版本，可能需要做适当调整。
-
-:::
-
-</TabItem>
-<TabItem label="R" value="r">
-
-1. 下载 [taos-jdbcdriver-version-dist.jar](https://repo1.maven.org/maven2/com/taosdata/jdbc/taos-jdbcdriver/2.0.38/)。
-2. 安装 R 的依赖包`RJDBC`：
-
-```R
-install.packages("RJDBC")
-```
-
-</TabItem>
-<TabItem label="C" value="c">
-
-如果已经安装了 TDengine 服务端软件或 TDengine 客户端驱动 taosc， 那么已经安装了 C 连接器，无需额外操作。
-<br/>
-
-</TabItem>
-<TabItem label="PHP" value="php">
-
-**下载代码并解压：**
-
-```shell
-curl -L -o php-tdengine.tar.gz https://github.com/Yurunsoft/php-tdengine/archive/refs/tags/v1.0.2.tar.gz \
-&& mkdir php-tdengine \
-&& tar -xzf php-tdengine.tar.gz -C php-tdengine --strip-components=1
-```
-
-> 版本 `v1.0.2` 只是示例，可替换为任意更新的版本，可在 [TDengine PHP Connector 发布历史](https://github.com/Yurunsoft/php-tdengine/releases) 中查看可用版本。
-
-**非 Swoole 环境：**
-
-```shell
-phpize && ./configure && make -j && make install
-```
-
-**手动指定 TDengine 目录：**
-
-```shell
-phpize && ./configure --with-tdengine-dir=/usr/local/Cellar/tdengine/2.4.0.0 && make -j && make install
-```
-
-> `--with-tdengine-dir=` 后跟上 TDengine 目录。
-> 适用于默认找不到的情况，或者 macOS 系统用户。
-
-**Swoole 环境：**
-
-```shell
-phpize && ./configure --enable-swoole && make -j && make install
-```
-
-**启用扩展：**
-
-方法一：在 `php.ini` 中加入 `extension=tdengine`
-
-方法二：运行带参数 `php -d extension=tdengine test.php`
-
-</TabItem>
-</Tabs>
-
-## 建立连接
-
-在执行这一步之前，请确保有一个正在运行的，且可以访问到的 TDengine，而且服务端的 FQDN 配置正确。以下示例代码，都假设 TDengine 安装在本机，且 FQDN（默认 localhost） 和 serverPort（默认 6030） 都使用默认配置。
-
-<Tabs groupId="lang" defaultValue="java">
-  <TabItem label="Java" value="java">
-    <ConnJava />
-  </TabItem>
-  <TabItem label="Python" value="python">
-    <ConnPythonNative />
-  </TabItem>
-  <TabItem label="Go" value="go">
-      <ConnGo />
-  </TabItem>
-  <TabItem label="Rust" value="rust">
-    <ConnRust />
-  </TabItem>
-  <TabItem label="Node.js" value="node">
-    <ConnNode />
-  </TabItem>
-  <TabItem label="C#" value="csharp">
-    <ConnCSNative />
-  </TabItem>
-  <TabItem label="R" value="r">
-    <ConnR/>
-  </TabItem>
-  <TabItem label="C" value="c">
-    <ConnC />
-  </TabItem>
-  <TabItem label="PHP" value="php">
-    <ConnPHP />
-  </TabItem>
-</Tabs>
-
-:::tip
-如果建立连接失败，大部分情况下是 FQDN 或防火墙的配置不正确，详细的排查方法请看[《常见问题及反馈》](https://docs.taosdata.com/train-faq/faq)中的“遇到错误 Unable to establish connection, 我怎么办？”
-
-:::

docs-cn/07-develop/03-insert-data/_c_line.mdx

-```c
-{{#include docs-examples/c/line_example.c:main}}
-```
\ No newline at end of file

docs-cn/07-develop/03-insert-data/_c_opts_json.mdx

-```c
-{{#include docs-examples/c/json_protocol_example.c:main}}
-```
\ No newline at end of file

docs-cn/07-develop/03-insert-data/_c_opts_telnet.mdx

-```c
-{{#include docs-examples/c/telnet_line_example.c:main}}
-```
\ No newline at end of file

docs-cn/07-develop/03-insert-data/_c_sql.mdx

-```c
-{{#include docs-examples/c/insert_example.c}}
-```
\ No newline at end of file

docs-cn/07-develop/03-insert-data/_c_stmt.mdx

-```c title=一次绑定一行
-{{#include docs-examples/c/stmt_example.c}}
-```
-```c title=一次绑定多行 72:117
-{{#include docs-examples/c/multi_bind_example.c}}
-```
\ No newline at end of file

docs-cn/07-develop/03-insert-data/_cs_line.mdx

-```csharp
-{{#include docs-examples/csharp/InfluxDBLineExample.cs}}
-```

docs-cn/07-develop/03-insert-data/_cs_opts_json.mdx

-```csharp
-{{#include docs-examples/csharp/OptsJsonExample.cs}}
-```

docs-cn/07-develop/03-insert-data/_cs_opts_telnet.mdx

-```csharp
-{{#include docs-examples/csharp/OptsTelnetExample.cs}}
-```

docs-cn/07-develop/03-insert-data/_cs_sql.mdx

-```csharp
-{{#include docs-examples/csharp/SQLInsertExample.cs}}
-```

docs-cn/07-develop/03-insert-data/_cs_stmt.mdx

-```csharp
-{{#include docs-examples/csharp/StmtInsertExample.cs}}
-```

docs-cn/07-develop/03-insert-data/_go_line.mdx

-```go
-{{#include docs-examples/go/insert/line/main.go}}
-```

docs-cn/07-develop/03-insert-data/_go_opts_json.mdx

-```go
-{{#include docs-examples/go/insert/json/main.go}}
-```

docs-cn/07-develop/03-insert-data/_go_opts_telnet.mdx

-```go
-{{#include docs-examples/go/insert/telnet/main.go}}
-```

docs-cn/07-develop/03-insert-data/_go_sql.mdx

-```go
-{{#include docs-examples/go/insert/sql/main.go}}
-```

docs-cn/07-develop/03-insert-data/_go_stmt.mdx

-```go
-{{#include docs-examples/go/insert/stmt/main.go}}
-```
-
-:::tip
-driver-go 的模块 `github.com/taosdata/driver-go/v2/wrapper` 是 C 接口的底层封装。使用这个模块也可以实现参数绑定写入。
-
-:::

docs-cn/07-develop/03-insert-data/_java_line.mdx

-```java
-{{#include docs-examples/java/src/main/java/com/taos/example/LineProtocolExample.java}}
-```

docs-cn/07-develop/03-insert-data/_java_opts_json.mdx

-```java
-{{#include docs-examples/java/src/main/java/com/taos/example/JSONProtocolExample.java}}
-```

docs-cn/07-develop/03-insert-data/_java_opts_telnet.mdx

-```java
-{{#include docs-examples/java/src/main/java/com/taos/example/TelnetLineProtocolExample.java}}
-```

docs-cn/07-develop/03-insert-data/_java_sql.mdx

-```java
-{{#include docs-examples/java/src/main/java/com/taos/example/RestInsertExample.java:insert}}
-```
\ No newline at end of file

docs-cn/07-develop/03-insert-data/_java_stmt.mdx

-```java
-{{#include docs-examples/java/src/main/java/com/taos/example/StmtInsertExample.java}}
-```

docs-cn/07-develop/03-insert-data/_js_line.mdx

-```js
-{{#include docs-examples/node/nativeexample/influxdb_line_example.js}}
-```

docs-cn/07-develop/03-insert-data/_js_opts_json.mdx

-```js
-{{#include docs-examples/node/nativeexample/opentsdb_json_example.js}}
-```

docs-cn/07-develop/03-insert-data/_js_opts_telnet.mdx

-```js
-{{#include docs-examples/node/nativeexample/opentsdb_telnet_example.js}}
-```

docs-cn/07-develop/03-insert-data/_js_sql.mdx

-```js
-{{#include docs-examples/node/nativeexample/insert_example.js}}
-```

docs-cn/07-develop/03-insert-data/_js_stmt.mdx

-```js title=一次绑定一行
-{{#include docs-examples/node/nativeexample/param_bind_example.js}}
-```
-
-```js title=一次绑定多行
-{{#include docs-examples/node/nativeexample/multi_bind_example.js:insertData}}
-```
-
-:::info
-一次绑定一行效率不如一次绑定多行，但支持非 INSERT 语句。一次绑定多行效率更高，但仅支持 INSERT 语句。
-
-:::

docs-cn/07-develop/03-insert-data/_php_sql.mdx

-```php
-{{#include docs-examples/php/insert.php}}
-```

docs-cn/07-develop/03-insert-data/_php_stmt.mdx

-```php
-{{#include docs-examples/php/insert_stmt.php}}
-```

docs-cn/07-develop/03-insert-data/_py_line.mdx

-```py
-{{#include docs-examples/python/line_protocol_example.py}}
-```

docs-cn/07-develop/03-insert-data/_py_opts_json.mdx

-```py
-{{#include docs-examples/python/json_protocol_example.py}}
-```

docs-cn/07-develop/03-insert-data/_py_opts_telnet.mdx

-```py
-{{#include docs-examples/python/telnet_line_protocol_example.py}}
-```

docs-cn/07-develop/03-insert-data/_py_sql.mdx

-```py
-{{#include docs-examples/python/native_insert_example.py}}
-```

docs-cn/07-develop/03-insert-data/_py_stmt.mdx

-```py title=一次绑定一行
-{{#include docs-examples/python/bind_param_example.py}}
-```
-
-```py title=一次绑定多行
-{{#include docs-examples/python/multi_bind_example.py:bind_batch}}
-```
-
-:::info
-一次绑定一行效率不如一次绑定多行，但支持非 INSERT 语句。一次绑定多行效率更高，但仅支持 INSERT 语句。
-
-:::
\ No newline at end of file

docs-cn/07-develop/03-insert-data/_rust_line.mdx

-```rust
-{{#include docs-examples/rust/schemalessexample/examples/influxdb_line_example.rs}}
-```

docs-cn/07-develop/03-insert-data/_rust_opts_json.mdx

-```rust
-{{#include docs-examples/rust/schemalessexample/examples/opentsdb_json_example.rs}}
-```

docs-cn/07-develop/03-insert-data/_rust_opts_telnet.mdx

-```rust
-{{#include docs-examples/rust/schemalessexample/examples/opentsdb_telnet_example.rs}}
-```

docs-cn/07-develop/03-insert-data/_rust_sql.mdx

-```rust
-{{#include docs-examples/rust/restexample/examples/insert_example.rs}}
-```

docs-cn/07-develop/03-insert-data/_rust_stmt.mdx

-```rust
-{{#include docs-examples/rust/nativeexample/examples/stmt_example.rs}}
-```

docs-cn/07-develop/04-query-data/_c.mdx

-```c
-{{#include docs-examples/c/query_example.c}}
-```
\ No newline at end of file

docs-cn/07-develop/04-query-data/_c_async.mdx

-```c
-{{#include docs-examples/c/async_query_example.c:demo}}
-```
\ No newline at end of file

docs-cn/07-develop/04-query-data/_cs.mdx

-```csharp
-{{#include docs-examples/csharp/QueryExample.cs}}
-```

docs-cn/07-develop/04-query-data/_cs_async.mdx

-```csharp
-{{#include docs-examples/csharp/AsyncQueryExample.cs}}
-```

docs-cn/07-develop/04-query-data/_go.mdx

-```go
-{{#include docs-examples/go/query/sync/main.go}}
-```

docs-cn/07-develop/04-query-data/_go_async.mdx

-```go
-{{#include docs-examples/go/query/async/main.go}}
-```

docs-cn/07-develop/04-query-data/_java.mdx

-```java
-{{#include docs-examples/java/src/main/java/com/taos/example/RestQueryExample.java}}
-```

docs-cn/07-develop/04-query-data/_js.mdx

-```js
-{{#include docs-examples/node/nativeexample/query_example.js}}
-```

docs-cn/07-develop/04-query-data/_js_async.mdx

-```js
-{{#include docs-examples/node/nativeexample/async_query_example.js}}
-```

docs-cn/07-develop/04-query-data/_php.mdx

-```go
-{{#include docs-examples/php/query.php}}
-```

docs-cn/07-develop/04-query-data/_py.mdx

-通过迭代逐行获取查询结果。
-
-```py
-{{#include docs-examples/python/query_example.py:iter}}
-```
-
-一次获取所有查询结果，并把每一行转化为一个字典返回。
-
-```py
-{{#include docs-examples/python/query_example.py:fetch_all}}
-```

docs-cn/07-develop/04-query-data/_py_async.mdx

-```py
-{{#include docs-examples/python/async_query_example.py}}
-```
-
-:::note
-这个示例程序，目前在 Windows 系统上还无法运行
-
-:::

docs-cn/07-develop/04-query-data/_rust.mdx

-```rust
-{{#include docs-examples/rust/restexample/examples/query_example.rs}}
-```

docs-cn/07-develop/04-query-data/index.mdx

----
-title: 查询数据
-description: "主要查询功能，通过连接器执行同步查询和异步查询"
----
-
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-import JavaQuery from "./_java.mdx";
-import PyQuery from "./_py.mdx";
-import GoQuery from "./_go.mdx";
-import RustQuery from "./_rust.mdx";
-import NodeQuery from "./_js.mdx";
-import CsQuery from "./_cs.mdx";
-import CQuery from "./_c.mdx";
-import PhpQuery from "./_php.mdx";
-import PyAsync from "./_py_async.mdx";
-import NodeAsync from "./_js_async.mdx";
-import CsAsync from "./_cs_async.mdx";
-import CAsync from "./_c_async.mdx";
-
-## 主要查询功能
-
-TDengine 采用 SQL 作为查询语言。应用程序可以通过 REST API 或连接器发送 SQL 语句，用户还可以通过 TDengine 命令行工具 taos 手动执行 SQL 即席查询（Ad-Hoc Query）。TDengine 支持如下查询功能：
-
-- 单列、多列数据查询
-- 标签和数值的多种过滤条件：>, <, =, <\>, like 等
-- 聚合结果的分组（Group by）、排序（Order by）、约束输出（Limit/Offset）
-- 数值列及聚合结果的四则运算
-- 时间戳对齐的连接查询（Join Query: 隐式连接）操作
-- 多种聚合/计算函数: count, max, min, avg, sum, twa, stddev, leastsquares, top, bottom, first, last, percentile, apercentile, last_row, spread, diff 等
-
-例如：在命令行工具 taos 中，从表 d1001 中查询出 voltage > 215 的记录，按时间降序排列，仅仅输出 2 条。
-
-```sql
-taos> select * from d1001 where voltage > 215 order by ts desc limit 2;
-           ts            |       current        |   voltage   |        phase         |
-======================================================================================
- 2018-10-03 14:38:16.800 |             12.30000 |         221 |              0.31000 |
- 2018-10-03 14:38:15.000 |             12.60000 |         218 |              0.33000 |
-Query OK, 2 row(s) in set (0.001100s)
-```
-
-为满足物联网场景的需求，TDengine 支持几个特殊的函数，比如 twa(时间加权平均)，spread (最大值与最小值的差)，last_row(最后一条记录)等，更多与物联网场景相关的函数将添加进来。TDengine 还支持连续查询。
-
-具体的查询语法请看 [TAOS SQL 的数据查询](/taos-sql/select) 章节。
-
-## 多表聚合查询
-
-物联网场景中，往往同一个类型的数据采集点有多个。TDengine 采用超级表(STable)的概念来描述某一个类型的数据采集点，一张普通的表来描述一个具体的数据采集点。同时 TDengine 使用标签来描述数据采集点的静态属性，一个具体的数据采集点有具体的标签值。通过指定标签的过滤条件，TDengine 提供了一高效的方法将超级表(某一类型的数据采集点)所属的子表进行聚合查询。对普通表的聚合函数以及绝大部分操作都适用于超级表，语法完全一样。
-
-### 示例一
-
-在 TAOS Shell，查找加利福尼亚州所有智能电表采集的电压平均值，并按照 location 分组。
-
-```
-taos> SELECT AVG(voltage) FROM meters GROUP BY location;
-       avg(voltage)        |            location            |
-=============================================================
-             222.000000000 | California.LosAngeles                |
-             219.200000000 | California.SanFrancisco               |
-Query OK, 2 row(s) in set (0.002136s)
-```
-
-### 示例二
-
-在 TAOS shell, 查找 groupId 为 2 的所有智能电表过去 24 小时的记录条数，电流的最大值。
-
-```
-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 仅容许对属于同一个超级表的表之间进行聚合查询，不同超级表之间的聚合查询不支持。在 [TAOS SQL 的数据查询](/taos-sql/select) 一章，查询类操作都会注明是否支持超级表。
-
-## 降采样查询、插值
-
-物联网场景里，经常需要通过降采样（down sampling）将采集的数据按时间段进行聚合。TDengine 提供了一个简便的关键词 interval 让按照时间窗口的查询操作变得极为简单。比如，将智能电表 d1001 采集的电流值每 10 秒钟求和
-
-```
-taos> SELECT sum(current) FROM d1001 INTERVAL(10s);
-           ts            |       sum(current)        |
-======================================================
- 2018-10-03 14:38:00.000 |              10.300000191 |
- 2018-10-03 14:38:10.000 |              24.900000572 |
-Query OK, 2 row(s) in set (0.000883s)
-```
-
-降采样操作也适用于超级表，比如：将加利福尼亚州所有智能电表采集的电流值每秒钟求和
-
-```
-taos> SELECT SUM(current) FROM meters where location like "California%" INTERVAL(1s);
-           ts            |       sum(current)        |
-======================================================
- 2018-10-03 14:38:04.000 |              10.199999809 |
- 2018-10-03 14:38:05.000 |              32.900000572 |
- 2018-10-03 14:38:06.000 |              11.500000000 |
- 2018-10-03 14:38:15.000 |              12.600000381 |
- 2018-10-03 14:38:16.000 |              36.000000000 |
-Query OK, 5 row(s) in set (0.001538s)
-```
-
-降采样操作也支持时间偏移，比如：将所有智能电表采集的电流值每秒钟求和，但要求每个时间窗口从 500 毫秒开始
-
-```
-taos> SELECT SUM(current) FROM meters INTERVAL(1s, 500a);
-           ts            |       sum(current)        |
-======================================================
- 2018-10-03 14:38:04.500 |              11.189999809 |
- 2018-10-03 14:38:05.500 |              31.900000572 |
- 2018-10-03 14:38:06.500 |              11.600000000 |
- 2018-10-03 14:38:15.500 |              12.300000381 |
- 2018-10-03 14:38:16.500 |              35.000000000 |
-Query OK, 5 row(s) in set (0.001521s)
-```
-
-物联网场景里，每个数据采集点采集数据的时间是难同步的，但很多分析算法(比如 FFT)需要把采集的数据严格按照时间等间隔的对齐，在很多系统里，需要应用自己写程序来处理，但使用 TDengine 的降采样操作就轻松解决。
-
-如果一个时间间隔里，没有采集的数据，TDengine 还提供插值计算的功能。
-
-语法规则细节请见 [TAOS SQL 的按时间窗口切分聚合](/taos-sql/interval) 章节。
-
-## 示例代码
-
-### 查询数据
-
-在 [SQL 写入](/develop/insert-data/sql-writing) 一章，我们创建了 power 数据库，并向 meters 表写入了一些数据，以下示例代码展示如何查询这个表的数据。
-
-<Tabs defaultValue="java" groupId="lang">
-  <TabItem label="Java" value="java">
-    <JavaQuery />
-  </TabItem>
-  <TabItem label="Python" value="python">
-    <PyQuery />
-  </TabItem>
-  <TabItem label="Go" value="go">
-    <GoQuery />
-  </TabItem>
-  <TabItem label="Rust" value="rust">
-    <RustQuery />
-  </TabItem>
-  <TabItem label="Node.js" value="nodejs">
-    <NodeQuery />
-  </TabItem>
-  <TabItem label="C#" value="csharp">
-    <CsQuery />
-  </TabItem>
-  <TabItem label="C" value="c">
-    <CQuery />
-  </TabItem>
-  <TabItem label="PHP" value="php">
-    <PhpQuery />
-  </TabItem>
-</Tabs>
-
-:::note
-
-1. 无论是使用 REST 连接还是原生连接的连接器，以上示例代码都能正常工作。
-2. 唯一需要注意的是：由于 REST 接口无状态， 不能使用 `use db` 语句来切换数据库。
-
-:::
-
-### 异步查询
-
-除同步查询 API 之外，TDengine 还提供性能更高的异步调用 API 处理数据插入、查询操作。在软硬件环境相同的情况下，异步 API 处理数据插入的速度比同步 API 快 2-4 倍。异步 API 采用非阻塞式的调用方式，在系统真正完成某个具体数据库操作前，立即返回。调用的线程可以去处理其他工作，从而可以提升整个应用的性能。异步 API 在网络延迟严重的情况下，优点尤为突出。
-
-需要注意的是，只有使用原生连接的连接器，才能使用异步查询功能。
-
-<Tabs defaultValue="python" groupId="lang">
-  <TabItem label="Python" value="python">
-    <PyAsync />
-  </TabItem>
-  <TabItem label="C#" value="csharp">
-    <CsAsync />
-  </TabItem>
-  <TabItem label="C" value="c">
-    <CAsync />
-  </TabItem>
-</Tabs>

docs-cn/07-develop/07-subscribe.mdx

----
-sidebar_label: 数据订阅
-description: "轻量级的数据订阅与推送服务。连续写入到 TDengine 中的时序数据能够被自动推送到订阅客户端。"
-title: 数据订阅
----
-
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-import Java from "./_sub_java.mdx";
-import Python from "./_sub_python.mdx";
-import Go from "./_sub_go.mdx";
-import Rust from "./_sub_rust.mdx";
-import Node from "./_sub_node.mdx";
-import CSharp from "./_sub_cs.mdx";
-import CDemo from "./_sub_c.mdx";
-
-基于数据天然的时间序列特性，TDengine 的数据写入（insert）与消息系统的数据发布（pub）逻辑上一致，均可视为系统中插入一条带时间戳的新记录。同时，TDengine 在内部严格按照数据时间序列单调递增的方式保存数据。本质上来说，TDengine 中每一张表均可视为一个标准的消息队列。
-
-TDengine 内嵌支持轻量级的消息订阅与推送服务。使用系统提供的 API，用户可使用普通查询语句订阅数据库中的一张或多张表。订阅的逻辑和操作状态的维护均是由客户端完成，客户端定时轮询服务器是否有新的记录到达，有新的记录到达就会将结果反馈到客户。
-
-TDengine 的订阅与推送服务的状态是由客户端维持，TDengine 服务端并不维持。因此如果应用重启，从哪个时间点开始获取最新数据，由应用决定。
-
-TDengine 的 API 中，与订阅相关的主要有以下三个：
-
-```c
-taos_subscribe
-taos_consume
-taos_unsubscribe
-```
-
-这些 API 的文档请见 [C/C++ Connector](/reference/connector/cpp)，下面仍以智能电表场景为例介绍一下它们的具体用法（超级表和子表结构请参考上一节“连续查询”），完整的示例代码可以在 [这里](https://github.com/taosdata/TDengine/blob/master/examples/c/subscribe.c) 找到。
-
-如果我们希望当某个电表的电流超过一定限制（比如 10A）后能得到通知并进行一些处理， 有两种方法：一是分别对每张子表进行查询，每次查询后记录最后一条数据的时间戳，后续只查询这个时间戳之后的数据：
-
-```sql
-select * from D1001 where ts > {last_timestamp1} and current > 10;
-select * from D1002 where ts > {last_timestamp2} and current > 10;
-...
-```
-
-这确实可行，但随着电表数量的增加，查询数量也会增加，客户端和服务端的性能都会受到影响，当电表数增长到一定的程度，系统就无法承受了。
-
-另一种方法是对超级表进行查询。这样，无论有多少电表，都只需一次查询：
-
-```sql
-select * from meters where ts > {last_timestamp} and current > 10;
-```
-
-但是，如何选择 `last_timestamp` 就成了一个新的问题。因为，一方面数据的产生时间（也就是数据时间戳）和数据入库的时间一般并不相同，有时偏差还很大；另一方面，不同电表的数据到达 TDengine 的时间也会有差异。所以，如果我们在查询中使用最慢的那台电表的数据的时间戳作为 `last_timestamp`，就可能重复读入其它电表的数据；如果使用最快的电表的时间戳，其它电表的数据就可能被漏掉。
-
-TDengine 的订阅功能为上面这个问题提供了一个彻底的解决方案。
-
-首先是使用 `taos_subscribe` 创建订阅：
-
-```c
-TAOS_SUB* tsub = NULL;
-if (async) {
-　　// create an asynchronized subscription, the callback function will be called every 1s
-　　tsub = taos_subscribe(taos, restart, topic, sql, subscribe_callback, &blockFetch, 1000);
-} else {
-　　// create an synchronized subscription, need to call 'taos_consume' manually
-　　tsub = taos_subscribe(taos, restart, topic, sql, NULL, NULL, 0);
-}
-```
-
-TDengine 中的订阅既可以是同步的，也可以是异步的，上面的代码会根据从命令行获取的参数 `async` 的值来决定使用哪种方式。这里，同步的意思是用户程序要直接调用 `taos_consume` 来拉取数据，而异步则由 API 在内部的另一个线程中调用 `taos_consume`，然后把拉取到的数据交给回调函数 `subscribe_callback`去处理。（注意，`subscribe_callback` 中不宜做较为耗时的操作，否则有可能导致客户端阻塞等不可控的问题。）
-
-参数 `taos` 是一个已经建立好的数据库连接，在同步模式下无特殊要求。但在异步模式下，需要注意它不会被其它线程使用，否则可能导致不可预计的错误，因为回调函数在 API 的内部线程中被调用，而 TDengine 的部分 API 不是线程安全的。
-
-参数 `sql` 是查询语句，可以在其中使用 where 子句指定过滤条件。在我们的例子中，如果只想订阅电流超过 10A 时的数据，可以这样写：
-
-```sql
-select * from meters where current > 10;
-```
-
-注意，这里没有指定起始时间，所以会读到所有时间的数据。如果只想从一天前的数据开始订阅，而不需要更早的历史数据，可以再加上一个时间条件：
-
-```sql
-select * from meters where ts > now - 1d and current > 10;
-```
-
-订阅的 `topic` 实际上是它的名字，因为订阅功能是在客户端 API 中实现的，所以没必要保证它全局唯一，但需要它在一台客户端机器上唯一。
-
-如果名为 `topic` 的订阅不存在，参数 `restart` 没有意义；但如果用户程序创建这个订阅后退出，当它再次启动并重新使用这个 `topic` 时，`restart` 就会被用于决定是从头开始读取数据，还是接续上次的位置进行读取。本例中，如果 `restart` 是 **true**（非零值），用户程序肯定会读到所有数据。但如果这个订阅之前就存在了，并且已经读取了一部分数据，且 `restart` 是 **false**（**0**），用户程序就不会读到之前已经读取的数据了。
-
-`taos_subscribe`的最后一个参数是以毫秒为单位的轮询周期。在同步模式下，如果前后两次调用 `taos_consume` 的时间间隔小于此时间，`taos_consume` 会阻塞，直到间隔超过此时间。异步模式下，这个时间是两次调用回调函数的最小时间间隔。
-
-`taos_subscribe` 的倒数第二个参数用于用户程序向回调函数传递附加参数，订阅 API 不对其做任何处理，只原样传递给回调函数。此参数在同步模式下无意义。
-
-订阅创建以后，就可以消费其数据了，同步模式下，示例代码是下面的 else 部分：
-
-```c
-if (async) {
-　　getchar();
-} else while(1) {
-　　TAOS_RES* res = taos_consume(tsub);
-　　if (res == NULL) {
-　　　　printf("failed to consume data.");
-　　　　break;
-　　} else {
-　　　　print_result(res, blockFetch);
-　　　　getchar();
-　　}
-}
-```
-
-这里是一个 **while** 循环，用户每按一次回车键就调用一次 `taos_consume`，而 `taos_consume` 的返回值是查询到的结果集，与 `taos_use_result` 完全相同，例子中使用这个结果集的代码是函数 `print_result`：
-
-```c
-void print_result(TAOS_RES* res, int blockFetch) {
-　　TAOS_ROW row = NULL;
-　　int num_fields = taos_num_fields(res);
-　　TAOS_FIELD* fields = taos_fetch_fields(res);
-　　int nRows = 0;
-　　if (blockFetch) {
-　　　　nRows = taos_fetch_block(res, &row);
-　　　　for (int i = 0; i < nRows; i++) {
-　　　　　　char temp[256];
-　　　　　　taos_print_row(temp, row + i, fields, num_fields);
-　　　　　　puts(temp);
-　　　　}
-　　} else {
-　　　　while ((row = taos_fetch_row(res))) {
-　　　　　　char temp[256];
-　　　　　　taos_print_row(temp, row, fields, num_fields);
-　　　　　　puts(temp);
-　　　　　　nRows++;
-　　　　}
-　　}
-　　printf("%d rows consumed.\n", nRows);
-}
-```
-
-其中的 `taos_print_row` 用于处理订阅到数据，在我们的例子中，它会打印出所有符合条件的记录。而异步模式下，消费订阅到的数据则显得更为简单：
-
-```c
-void subscribe_callback(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
-　　print_result(res, *(int*)param);
-}
-```
-
-当要结束一次数据订阅时，需要调用 `taos_unsubscribe`：
-
-```c
-taos_unsubscribe(tsub, keep);
-```
-
-其第二个参数，用于决定是否在客户端保留订阅的进度信息。如果这个参数是**false**（**0**），那无论下次调用 `taos_subscribe` 时的 `restart` 参数是什么，订阅都只能重新开始。另外，进度信息的保存位置是 _{DataDir}/subscribe/_ 这个目录下（注：`taos.cfg` 配置文件中 `DataDir` 参数值默认为 **/var/lib/taos/**,但是 Windows 服务器上本身不存在该目录，所以需要在 Windows 的配置文件中修改 `DataDir` 参数值为相应的已存在目录"），每个订阅有一个与其 `topic` 同名的文件，删掉某个文件，同样会导致下次创建其对应的订阅时只能重新开始。
-
-代码介绍完毕，我们来看一下实际的运行效果。假设：
-
-- 示例代码已经下载到本地
-- TDengine 也已经在同一台机器上安装好
-- 示例所需的数据库、超级表、子表已经全部创建好
-
-则可以在示例代码所在目录执行以下命令来编译并启动示例程序：
-
-```bash
-make
-./subscribe -sql='select * from meters where current > 10;'
-```
-
-示例程序启动后，打开另一个终端窗口，启动 TDengine CLI 向 **D1001** 插入一条电流为 12A 的数据：
-
-```sql
-$ taos
-> use test;
-> insert into D1001 values(now, 12, 220, 1);
-```
-
-这时，因为电流超过了 10A，您应该可以看到示例程序将它输出到了屏幕上。您可以继续插入一些数据观察示例程序的输出。
-
-## 示例程序
-
-下面的示例程序展示是如何使用连接器订阅所有电流超过 10A 的记录。
-
-### 准备数据
-
-```
-# create database "power"
-taos> create database power;
-# use "power" as the database in following operations
-taos> use power;
-# create super table "meters"
-taos> create table meters(ts timestamp, current float, voltage int, phase int) tags(location binary(64), groupId int);
-# create tabes using the schema defined by super table "meters"
-taos> create table d1001 using meters tags ("California.SanFrancisco", 2);
-taos> create table d1002 using meters tags ("California.LosAngeles", 2);
-# insert some rows
-taos> insert into d1001 values("2020-08-15 12:00:00.000", 12, 220, 1),("2020-08-15 12:10:00.000", 12.3, 220, 2),("2020-08-15 12:20:00.000", 12.2, 220, 1);
-taos> insert into d1002 values("2020-08-15 12:00:00.000", 9.9, 220, 1),("2020-08-15 12:10:00.000", 10.3, 220, 1),("2020-08-15 12:20:00.000", 11.2, 220, 1);
-# filter out the rows in which current is bigger than 10A
-taos> select * from meters where current > 10;
-           ts            |    current   |    voltage   |  phase |         location          |   groupid   |
-===========================================================================================================
- 2020-08-15 12:10:00.000 |    10.30000  |     220      |      1 |      California.LosAngeles      |           2 |
- 2020-08-15 12:20:00.000 |    11.20000  |     220      |      1 |      California.LosAngeles      |           2 |
- 2020-08-15 12:00:00.000 |    12.00000  |     220      |      1 |      California.SanFrancisco     |           2 |
- 2020-08-15 12:10:00.000 |    12.30000  |     220      |      2 |      California.SanFrancisco     |           2 |
- 2020-08-15 12:20:00.000 |    12.20000  |     220      |      1 |      California.SanFrancisco     |           2 |
-Query OK, 5 row(s) in set (0.004896s)
-```
-
-### 示例代码
-
-<Tabs defaultValue="java" groupId="lang">
-  <TabItem label="Java" value="java">
-    <Java />
-  </TabItem>
-  <TabItem label="Python" value="Python">
-    <Python />
-  </TabItem>
-  {/* <TabItem label="Go" value="go">
-      <Go/>
-  </TabItem> */}
-  <TabItem label="Rust" value="rust">
-    <Rust />
-  </TabItem>
-  {/* <TabItem label="Node.js" value="nodejs">
-      <Node/>
-  </TabItem>
-  <TabItem label="C#" value="csharp">
-      <CSharp/>
-  </TabItem> */}
-  <TabItem label="C" value="c">
-    <CDemo />
-  </TabItem>
-</Tabs>
-
-### 运行示例程序
-
-示例程序会先消费符合查询条件的所有历史数据：
-
-```bash
-ts: 1597464000000	current: 12.0	voltage: 220	phase: 1	location: California.SanFrancisco	groupid : 2
-ts: 1597464600000	current: 12.3	voltage: 220	phase: 2	location: California.SanFrancisco	groupid : 2
-ts: 1597465200000	current: 12.2	voltage: 220	phase: 1	location: California.SanFrancisco	groupid : 2
-ts: 1597464600000	current: 10.3	voltage: 220	phase: 1	location: California.LosAngeles	groupid : 2
-ts: 1597465200000	current: 11.2	voltage: 220	phase: 1	location: California.LosAngeles	groupid : 2
-```
-
-接着，使用 TDengine CLI 向表中新增一条数据：
-
-```
-# taos
-taos> use power;
-taos> insert into d1001 values(now, 12.4, 220, 1);
-```
-
-因为这条数据的电流大于 10A，示例程序会将其消费：
-
-```
-ts: 1651146662805	current: 12.4	voltage: 220	phase: 1	location: California.SanFrancisco	groupid: 2
-```

docs-cn/07-develop/09-udf.md

----
-sidebar_label: 用户定义函数
-title: UDF（用户定义函数）
-description: "支持用户编码的聚合函数和标量函数，在查询中嵌入并使用用户定义函数，拓展查询的能力和功能。"
----
-
-在有些应用场景中，应用逻辑需要的查询无法直接使用系统内置的函数来表示。利用 UDF 功能，TDengine 可以插入用户编写的处理代码并在查询中使用它们，就能够很方便地解决特殊应用场景中的使用需求。 UDF 通常以数据表中的一列数据做为输入，同时支持以嵌套子查询的结果作为输入。
-
-从 2.2.0.0 版本开始，TDengine 支持通过 C/C++ 语言进行 UDF 定义。接下来结合示例讲解 UDF 的使用方法。
-
-用户可以通过 UDF 实现两类函数： 标量函数 和 聚合函数。
-
-## 用 C/C++ 语言来定义 UDF
-
-### 标量函数
-
-用户可以按照下列函数模板定义自己的标量计算函数
-
- `void udfNormalFunc(char* data, short itype, short ibytes, int numOfRows, long long* ts, char* dataOutput, char* interBuf, char* tsOutput, int* numOfOutput, short otype, short obytes, SUdfInit* buf)` 
- 
- 其中 udfNormalFunc 是函数名的占位符，以上述模板实现的函数对行数据块进行标量计算，其参数项是固定的，用于按照约束完成与引擎之间的数据交换。
-
-- udfNormalFunc 中各参数的具体含义是：
-  - data：输入数据。
-  - itype：输入数据的类型。这里采用的是短整型表示法，与各种数据类型对应的值可以参见 [column_meta 中的列类型说明](/reference/rest-api/)。例如 4 用于表示 INT 型。
-  - iBytes：输入数据中每个值会占用的字节数。
-  - numOfRows：输入数据的总行数。
-  - ts：主键时间戳在输入中的列数据(只读)。
-  - dataOutput：输出数据的缓冲区，缓冲区大小为用户指定的输出类型大小 \* numOfRows。
-  - interBuf：中间计算结果的缓冲区，大小为用户在创建 UDF 时指定的 BUFSIZE 大小。通常用于计算中间结果与最终结果不一致时使用，由引擎负责分配与释放。
-  - tsOutput：主键时间戳在输出时的列数据，如果非空可用于输出结果对应的时间戳。
-  - numOfOutput：输出结果的个数（行数）。
-  - oType：输出数据的类型。取值含义与 itype 参数一致。
-  - oBytes：输出数据中每个值占用的字节数。
-  - buf：用于在 UDF 与引擎间的状态控制信息传递块。
-
-  [add_one.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/add_one.c) 是结构最简单的 UDF 实现，也即上面定义的 udfNormalFunc 函数的一个具体实现。其功能为：对传入的一个数据列（可能因 WHERE 子句进行了筛选）中的每一项，都输出 +1 之后的值，并且要求输入的列数据类型为 INT。
-
-### 聚合函数
-
-用户可以按照如下函数模板定义自己的聚合函数。
-
-`void abs_max_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf)`
-
-其中 udfMergeFunc 是函数名的占位符，以上述模板实现的函数用于对计算中间结果进行聚合，只有针对超级表的聚合查询才需要调用该函数。其中各参数的具体含义是：
-
-  - data：udfNormalFunc 的输出数据数组，如果使用了 interBuf 那么 data 就是 interBuf 的数组。
-  - numOfRows：data 中数据的行数。
-  - dataOutput：输出数据的缓冲区，大小等于一条最终结果的大小。如果此时输出还不是最终结果，可以选择输出到 interBuf 中即 data 中。
-  - numOfOutput：输出结果的个数（行数）。
-  - buf：用于在 UDF 与引擎间的状态控制信息传递块。
-
-[abs_max.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/abs_max.c) 实现的是一个聚合函数，功能是对一组数据按绝对值取最大值。
-
-其计算过程为：与所在查询语句相关的数据会被分为多个行数据块，对每个行数据块调用 udfNormalFunc（在本例的实现代码中，实际函数名是 `abs_max`)来生成每个子表的中间结果，再将子表的中间结果调用 udfMergeFunc（本例中，其实际的函数名是 `abs_max_merge`）进行聚合，生成超级表的最终聚合结果或中间结果。聚合查询最后还会通过 udfFinalizeFunc（本例中，其实际的函数名是 `abs_max_finalize`）再把超级表的中间结果处理为最终结果，最终结果只能含 0 或 1 条结果数据。
-
-其他典型场景，如协方差的计算，也可通过定义聚合 UDF 的方式实现。
-
-### 最终计算
-
-用户可以按下面的函数模板实现自己的函数对计算结果进行最终计算，通常用于有 interBuf 使用的场景。
-
-`void abs_max_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf)`
-
-其中 udfFinalizeFunc 是函数名的占位符 ，其中各参数的具体含义是：
-  - dataOutput：输出数据的缓冲区。
-  - interBuf：中间结算结果缓冲区，可作为输入。
-  - numOfOutput：输出数据的个数，对聚合函数来说只能是 0 或者 1。
-  - buf：用于在 UDF 与引擎间的状态控制信息传递块。
-
-## UDF 实现方式的规则总结
-
-三类 UDF 函数： udfNormalFunc、udfMergeFunc、udfFinalizeFunc ，其函数名约定使用相同的前缀，此前缀即 udfNormalFunc 的实际函数名，也即 udfNormalFunc 函数不需要在实际函数名后添加后缀；而udfMergeFunc 的函数名要加上后缀 `_merge`、udfFinalizeFunc 的函数名要加上后缀 `_finalize`，这是 UDF 实现规则的一部分，系统会按照这些函数名后缀来调用相应功能。
-
-根据 UDF 函数类型的不同，用户所要实现的功能函数也不同：
-
-- 标量函数：UDF 中需实现 udfNormalFunc。
-- 聚合函数：UDF 中需实现 udfNormalFunc、udfMergeFunc（对超级表查询）、udfFinalizeFunc。
-
-:::note
-如果对应的函数不需要具体的功能，也需要实现一个空函数。
-
-:::
-
-## 编译 UDF
-
-用户定义函数的 C 语言源代码无法直接被 TDengine 系统使用，而是需要先编译为 动态链接库，之后才能载入 TDengine 系统。
-
-例如，按照上一章节描述的规则准备好了用户定义函数的源代码 add_one.c，以 Linux 为例可以执行如下指令编译得到动态链接库文件：
-
-```bash
-gcc -g -O0 -fPIC -shared add_one.c -o add_one.so
-```
-
-这样就准备好了动态链接库 add_one.so 文件，可以供后文创建 UDF 时使用了。为了保证可靠的系统运行，编译器 GCC 推荐使用 7.5 及以上版本。
-
-## 在系统中管理和使用 UDF
-
-### 创建 UDF
-
-用户可以通过 SQL 指令在系统中加载客户端所在主机上的 UDF 函数库（不能通过 RESTful 接口或 HTTP 管理界面来进行这一过程）。一旦创建成功，则当前 TDengine 集群的所有用户都可以在 SQL 指令中使用这些函数。UDF 存储在系统的 MNode 节点上，因此即使重启 TDengine 系统，已经创建的 UDF 也仍然可用。
-
-在创建 UDF 时，需要区分标量函数和聚合函数。如果创建时声明了错误的函数类别，则可能导致通过 SQL 指令调用函数时出错。此外， UDF 支持输入与输出类型不一致，用户需要保证输入数据类型与 UDF 程序匹配，UDF 输出数据类型与 OUTPUTTYPE 匹配。
-
-- 创建标量函数
-```sql
-CREATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) [ BUFSIZE B ];
-```
-
-  - ids(X)：标量函数未来在 SQL 指令中被调用时的函数名，必须与函数实现中 udfNormalFunc 的实际名称一致；
-  - ids(Y)：包含 UDF 函数实现的动态链接库的库文件绝对路径（指的是库文件在当前客户端所在主机上的保存路径，通常是指向一个 .so 文件），这个路径需要用英文单引号或英文双引号括起来；
-  - typename(Z)：此函数计算结果的数据类型，与上文中 udfNormalFunc 的 itype 参数不同，这里不是使用数字表示法，而是直接写类型名称即可；
-  - B：中间计算结果的缓冲区大小，单位是字节，最小 0，最大 512，如果不使用可以不设置。
-
-  例如，如下语句可以把 add_one.so 创建为系统中可用的 UDF：
-
-  ```sql
-  CREATE FUNCTION add_one AS "/home/taos/udf_example/add_one.so" OUTPUTTYPE INT;
-  ```
-
-- 创建聚合函数：
-```sql
-CREATE AGGREGATE FUNCTION ids(X) AS ids(Y) OUTPUTTYPE typename(Z) [ BUFSIZE B ];
-```
-
-  - ids(X)：聚合函数未来在 SQL 指令中被调用时的函数名，必须与函数实现中 udfNormalFunc 的实际名称一致；
-  - ids(Y)：包含 UDF 函数实现的动态链接库的库文件绝对路径（指的是库文件在当前客户端所在主机上的保存路径，通常是指向一个 .so 文件），这个路径需要用英文单引号或英文双引号括起来；
-  - typename(Z)：此函数计算结果的数据类型，与上文中 udfNormalFunc 的 itype 参数不同，这里不是使用数字表示法，而是直接写类型名称即可；
-  - B：中间计算结果的缓冲区大小，单位是字节，最小 0，最大 512，如果不使用可以不设置。
-
-  关于中间计算结果的使用，可以参考示例程序[demo.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/demo.c)
-
-  例如，如下语句可以把 demo.so 创建为系统中可用的 UDF：
-
-  ```sql
-  CREATE AGGREGATE FUNCTION demo AS "/home/taos/udf_example/demo.so" OUTPUTTYPE DOUBLE bufsize 14;
-  ```
-
-### 管理 UDF
-
-- 删除指定名称的用户定义函数：
-```
-DROP FUNCTION ids(X);
-```
-
-- ids(X)：此参数的含义与 CREATE 指令中的 ids(X) 参数一致，也即要删除的函数的名字，例如 
-```sql
-DROP FUNCTION add_one;
-```
-- 显示系统中当前可用的所有 UDF：
-```sql
-SHOW FUNCTIONS;
-```
-
-### 调用 UDF
-
-在 SQL 指令中，可以直接以在系统中创建 UDF 时赋予的函数名来调用用户定义函数。例如：
-```sql
-SELECT X(c) FROM table/stable;
-```
-
-表示对名为 c 的数据列调用名为 X 的用户定义函数。SQL 指令中用户定义函数可以配合 WHERE 等查询特性来使用。
-
-## UDF 的一些使用限制
-
-在当前版本下，使用 UDF 存在如下这些限制：
-
-1. 在创建和调用 UDF 时，服务端和客户端都只支持 Linux 操作系统；
-2. UDF 不能与系统内建的 SQL 函数混合使用，暂不支持在一条 SQL 语句中使用多个不同名的 UDF ；
-3. UDF 只支持以单个数据列作为输入；
-4. UDF 只要创建成功，就会被持久化存储到 MNode 节点中；
-5. 无法通过 RESTful 接口来创建 UDF；
-6. UDF 在 SQL 中定义的函数名，必须与 .so 库文件实现中的接口函数名前缀保持一致，也即必须是 udfNormalFunc 的名称，而且不可与 TDengine 中已有的内建 SQL 函数重名。
-
-## 示例代码
-
-### 标量函数示例 [add_one](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/add_one.c)
-
-<details>
-<summary>add_one.c</summary>
-
-```c
-{{#include tests/script/sh/add_one.c}}
-```
-
-</details>
-
-### 向量函数示例 [abs_max](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/abs_max.c)
-
-<details>
-<summary>abs_max.c</summary>
-
-```c
-{{#include tests/script/sh/abs_max.c}}
-```
-
-</details>
-
-### 使用中间计算结果示例 [demo](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/demo.c)
-
-<details>
-<summary>demo.c</summary>
-
-```c
-{{#include tests/script/sh/demo.c}}
-```
-
-</details>

docs-cn/07-develop/_sub_c.mdx

-```c
-{{#include docs-examples/c/subscribe_demo.c}}
-```
\ No newline at end of file

docs-cn/07-develop/_sub_cs.mdx

-```csharp
-{{#include docs-examples/csharp/SubscribeDemo.cs}}
-```
\ No newline at end of file

docs-cn/07-develop/_sub_go.mdx

-```go
-{{#include docs-examples/go/sub/main.go}}
-```
\ No newline at end of file

docs-cn/07-develop/_sub_java.mdx

-```java
-{{#include docs-examples/java/src/main/java/com/taos/example/SubscribeDemo.java}}
-```
-:::note
-目前 Java 接口没有提供异步订阅模式，但用户程序可以通过创建 `TimerTask` 等方式达到同样的效果。
-
-:::
\ No newline at end of file

docs-cn/07-develop/_sub_node.mdx

-```js
-{{#include docs-examples/node/nativeexample/subscribe_demo.js}}
-```
\ No newline at end of file

docs-cn/07-develop/_sub_python.mdx

-```py
-{{#include docs-examples/python/subscribe_demo.py}}
-```
\ No newline at end of file

docs-cn/07-develop/_sub_rust.mdx

-```rs
-{{#include docs-examples/rust/nativeexample/examples/subscribe_demo.rs}}
-```
\ No newline at end of file

docs-cn/07-develop/index.md

----
-title: 开发指南
----
-
-开发一个应用，如果你准备采用TDengine作为时序数据处理的工具，那么有如下几个事情要做：
-1. 确定应用到TDengine的链接方式。无论你使用何种编程语言，你总可以使用REST接口, 但也可以使用每种编程语言独有的连接器方便的进行链接。
-2. 根据自己的应用场景，确定数据模型。根据数据特征，决定建立一个还是多个库；分清静态标签、采集量，建立正确的超级表，建立子表。
-3. 决定插入数据的方式。TDengine支持使用标准的SQL写入，但同时也支持schemaless模式写入，这样不用手工建表，可以将数据直接写入。
-4. 根据业务要求，看需要撰写哪些SQL查询语句。
-5. 如果你要基于时序数据做实时的统计分析，包括各种监测看板，那么建议你采用TDengine的连续查询功能，而不用上线Spark, Flink等复杂的流式计算系统。
-6. 如果你的应用有模块需要消费插入的数据，希望有新的数据插入时，就能获取通知，那么建议你采用TDengine提供的数据订阅功能，而无需专门部署Kafka或其他消息队列软件。
-7. 在很多场景下(如车辆管理)，应用需要获取每个数据采集点的最新状态，那么建议你采用TDengine的cache功能，而不用单独部署Redis等缓存软件。
-8. 如果你发现TDengine的函数无法满足你的要求，那么你可以使用用户自定义函数来解决问题。
-
-本部分内容就是按照上述的顺序组织的。为便于理解，TDengine为每个功能为每个支持的编程语言都提供了示例代码。如果你希望深入了解SQL的使用，需要查看[SQL手册](/taos-sql/)。如果想更深入地了解各连接器的使用，请阅读[连接器参考指南](/reference/connector/)。如果还希望想将TDengine与第三方系统集成起来，比如Grafana, 请参考[第三方工具](/third-party/)。
-
-如果在开发过程中遇到任何问题，请点击每个页面下方的["反馈问题"](https://github.com/taosdata/TDengine/issues/new/choose), 在GitHub上直接递交issue。
-
-```mdx-code-block
-import DocCardList from '@theme/DocCardList';
-import {useCurrentSidebarCategory} from '@docusaurus/theme-common';
-
-<DocCardList items={useCurrentSidebarCategory().items}/>
-```

docs-cn/12-taos-sql/02-database.md

----
-sidebar_label: 数据库管理
-title: 数据库管理
-description: "创建、删除数据库，查看、修改数据库参数"
----
-
-## 创建数据库
-
-```
-CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep] [DAYS days] [UPDATE 1];
-```
-
-:::info
-1. KEEP 是该数据库的数据保留多长天数，缺省是 3650 天(10 年)，数据库会自动删除超过时限的数据；<!-- REPLACE_OPEN_TO_ENTERPRISE__KEEP_PARAM_DESCRIPTION -->
-2. UPDATE 标志数据库支持更新相同时间戳数据；（从 2.1.7.0 版本开始此参数支持设为 2，表示允许部分列更新，也即更新数据行时未被设置的列会保留原值。）（从 2.0.8.0 版本开始支持此参数。注意此参数不能通过 `ALTER DATABASE` 指令进行修改。）
-   1. UPDATE 设为 0 时，表示不允许更新数据，后发送的相同时间戳的数据会被直接丢弃；
-   2. UPDATE 设为 1 时，表示更新全部列数据，即如果更新一个数据行，其中某些列没有提供取值，那么这些列会被设为 NULL；
-   3. UPDATE 设为 2 时，表示支持更新部分列数据，即如果更新一个数据行，其中某些列没有提供取值，那么这些列会保持原有数据行中的对应值；
-   4. 更多关于 UPDATE 参数的用法，请参考[FAQ](/train-faq/faq)。
-3. 数据库名最大长度为 33；
-4. 一条 SQL 语句的最大长度为 65480 个字符；
-5. 创建数据库时可用的参数有：
-   - cache: [详细说明](/reference/config/#cache)
-   - blocks: [详细说明](/reference/config/#blocks)
-   - days: [详细说明](/reference/config/#days)
-   - keep: [详细说明](/reference/config/#keep)
-   - minRows: [详细说明](/reference/config/#minrows)
-   - maxRows: [详细说明](/reference/config/#maxrows)
-   - wal: [详细说明](/reference/config/#wallevel)
-   - fsync: [详细说明](/reference/config/#fsync)
-   - update: [详细说明](/reference/config/#update)
-   - cacheLast: [详细说明](/reference/config/#cachelast)
-   - replica: [详细说明](/reference/config/#replica)
-   - quorum: [详细说明](/reference/config/#quorum)
-   - maxVgroupsPerDb: [详细说明](/reference/config/#maxvgroupsperdb)
-   - comp: [详细说明](/reference/config/#comp)
-   - precision: [详细说明](/reference/config/#precision)
-6. 请注意上面列出的所有参数都可以配置在配置文件 `taosd.cfg` 中作为创建数据库时使用的默认配置， `create database` 的参数中明确指定的会覆盖配置文件中的设置。
-
-:::
-
-### 创建数据库示例
-
-创建时间精度为纳秒的数据库, 保留 1 年数据：
-
-```sql
-CREATE DATABASE test PRECISION 'ns' KEEP 365;
-```
-
-## 显示系统当前参数
-
-```
-SHOW VARIABLES;
-```
-
-## 使用数据库
-
-```
-USE db_name;
-```
-
-使用/切换数据库（在 REST 连接方式下无效）。
-
-## 删除数据库
-
-```
-DROP DATABASE [IF EXISTS] db_name;
-```
-
-删除数据库。指定 Database 所包含的全部数据表将被删除，谨慎使用！
-
-## 修改数据库参数
-
-```
-ALTER DATABASE db_name COMP 2;
-```
-
-COMP 参数是指修改数据库文件压缩标志位，缺省值为 2，取值范围为 [0, 2]。0 表示不压缩，1 表示一阶段压缩，2 表示两阶段压缩。
-
-```
-ALTER DATABASE db_name REPLICA 2;
-```
-
-REPLICA 参数是指修改数据库副本数，取值范围 [1, 3]。在集群中使用，副本数必须小于或等于 DNODE 的数目。
-
-```
-ALTER DATABASE db_name KEEP 365;
-```
-
-KEEP 参数是指修改数据文件保存的天数，缺省值为 3650，取值范围 [days, 365000]，必须大于或等于 days 参数值。
-
-```
-ALTER DATABASE db_name QUORUM 2;
-```
-
-QUORUM 参数是指数据写入成功所需要的确认数，取值范围 [1, 2]。对于异步复制，quorum 设为 1，具有 master 角色的虚拟节点自己确认即可。对于同步复制，quorum 设为 2。原则上，Quorum >= 1 并且 Quorum <= replica(副本数)，这个参数在启动一个同步模块实例时需要提供。
-
-```
-ALTER DATABASE db_name BLOCKS 100;
-```
-
-BLOCKS 参数是每个 VNODE (TSDB) 中有多少 cache 大小的内存块，因此一个 VNODE 的用的内存大小粗略为（cache \* blocks）。取值范围 [3, 1000]。
-
-```
-ALTER DATABASE db_name CACHELAST 0;
-```
-
-CACHELAST 参数控制是否在内存中缓存子表的最近数据。缺省值为 0，取值范围 [0, 1, 2, 3]。其中 0 表示不缓存，1 表示缓存子表最近一行数据，2 表示缓存子表每一列的最近的非 NULL 值，3 表示同时打开缓存最近行和列功能。（从 2.0.11.0 版本开始支持参数值 [0, 1]，从 2.1.2.0 版本开始支持参数值 [0, 1, 2, 3]。）  
-说明：缓存最近行，将显著改善 LAST_ROW 函数的性能表现；缓存每列的最近非 NULL 值，将显著改善无特殊影响（WHERE、ORDER BY、GROUP BY、INTERVAL）下的 LAST 函数的性能表现。
-
-:::tip
-以上所有参数修改后都可以用 show databases 来确认是否修改成功。另外，从 2.1.3.0 版本开始，修改这些参数后无需重启服务器即可生效。
-:::
-
-## 显示系统所有数据库
-
-```
-SHOW DATABASES;
-```
-
-## 显示一个数据库的创建语句
-
-```
-SHOW CREATE DATABASE db_name;
-```
-
-常用于数据库迁移。对一个已经存在的数据库，返回其创建语句；在另一个集群中执行该语句，就能得到一个设置完全相同的 Database。
-

docs-cn/12-taos-sql/08-interval.md

----
-sidebar_label: 按窗口切分聚合
-title: 按窗口切分聚合
----
-
-
-TDengine 支持按时间段窗口切分方式进行聚合结果查询，比如温度传感器每秒采集一次数据，但需查询每隔 10 分钟的温度平均值。这种场景下可以使用窗口子句来获得需要的查询结果。
-窗口子句用于针对查询的数据集合进行按照窗口切分成为查询子集并进行聚合，窗口包含时间窗口（time window）、状态窗口（status window）、会话窗口（session window）三种窗口。其中时间窗口又可划分为滑动时间窗口和翻转时间窗口。
-
-## 时间窗口
-
-INTERVAL 子句用于产生相等时间周期的窗口，SLIDING 用以指定窗口向前滑动的时间。每次执行的查询是一个时间窗口，时间窗口随着时间流动向前滑动。在定义连续查询的时候需要指定时间窗口（time window ）大小和每次前向增量时间（forward sliding times）。如图，[t0s, t0e] ，[t1s , t1e]， [t2s, t2e] 是分别是执行三次连续查询的时间窗口范围，窗口的前向滑动的时间范围 sliding time 标识 。查询过滤、聚合等操作按照每个时间窗口为独立的单位执行。当 SLIDING 与 INTERVAL 相等的时候，滑动窗口即为翻转窗口。
-
-![TDengine Database 时间窗口示意图](./timewindow-1.webp)
-
-INTERVAL 和 SLIDING 子句需要配合聚合和选择函数来使用。以下 SQL 语句非法：
-
-```
-SELECT * FROM temp_tb_1 INTERVAL(1m);
-```
-
-SLIDING 的向前滑动的时间不能超过一个窗口的时间范围。以下语句非法：
-
-```
-SELECT COUNT(*) FROM temp_tb_1 INTERVAL(1m) SLIDING(2m);
-```
-
-当 SLIDING 与 INTERVAL 取值相等的时候，滑动窗口即为翻转窗口。
-_ 聚合时间段的窗口宽度由关键词 INTERVAL 指定，最短时间间隔 10 毫秒（10a）；并且支持偏移 offset（偏移必须小于间隔），也即时间窗口划分与“UTC 时刻 0”相比的偏移量。SLIDING 语句用于指定聚合时间段的前向增量，也即每次窗口向前滑动的时长。
-_ 从 2.1.5.0 版本开始，INTERVAL 语句允许的最短时间间隔调整为 1 微秒（1u），当然如果所查询的 DATABASE 的时间精度设置为毫秒级，那么允许的最短时间间隔为 1 毫秒（1a）。 \* **注意**：用到 INTERVAL 语句时，除非极特殊的情况，都要求把客户端和服务端的 taos.cfg 配置文件中的 timezone 参数配置为相同的取值，以避免时间处理函数频繁进行跨时区转换而导致的严重性能影响。
-
-## 状态窗口
-
-使用整数（布尔值）或字符串来标识产生记录时候设备的状态量。产生的记录如果具有相同的状态量数值则归属于同一个状态窗口，数值改变后该窗口关闭。如下图所示，根据状态量确定的状态窗口分别是[2019-04-28 14:22:07，2019-04-28 14:22:10]和[2019-04-28 14:22:11，2019-04-28 14:22:12]两个。（状态窗口暂不支持对超级表使用）
-
-![TDengine Database 时间窗口示意图](./timewindow-3.webp)
-
-使用 STATE_WINDOW 来确定状态窗口划分的列。例如：
-
-```
-SELECT COUNT(*), FIRST(ts), status FROM temp_tb_1 STATE_WINDOW(status);
-```
-
-## 会话窗口
-
-会话窗口根据记录的时间戳主键的值来确定是否属于同一个会话。如下图所示，如果设置时间戳的连续的间隔小于等于 12 秒，则以下 6 条记录构成 2 个会话窗口，分别是：[2019-04-28 14:22:10，2019-04-28 14:22:30]和[2019-04-28 14:23:10，2019-04-28 14:23:30]。因为 2019-04-28 14:22:30 与 2019-04-28 14:23:10 之间的时间间隔是 40 秒，超过了连续时间间隔（12 秒）。
-
-![TDengine Database 时间窗口示意图](./timewindow-2.webp)
-
-在 tol_value 时间间隔范围内的结果都认为归属于同一个窗口，如果连续的两条记录的时间超过 tol_val，则自动开启下一个窗口。（会话窗口暂不支持对超级表使用）
-
-```
-
-SELECT COUNT(*), FIRST(ts) FROM temp_tb_1 SESSION(ts, tol_val);
-```
-
-这种类型的查询语法如下：
-
-```
-SELECT function_list FROM tb_name
-  [WHERE where_condition]
-  [SESSION(ts_col, tol_val)]
-  [STATE_WINDOW(col)]
-  [INTERVAL(interval [, offset]) [SLIDING sliding]]
-  [FILL({NONE | VALUE | PREV | NULL | LINEAR | NEXT})]
-
-SELECT function_list FROM stb_name
-  [WHERE where_condition]
-  [INTERVAL(interval [, offset]) [SLIDING sliding]]
-  [FILL({NONE | VALUE | PREV | NULL | LINEAR | NEXT})]
-  [GROUP BY tags]
-```
-
-- 在聚合查询中，function_list 位置允许使用聚合和选择函数，并要求每个函数仅输出单个结果（例如：COUNT、AVG、SUM、STDDEV、LEASTSQUARES、PERCENTILE、MIN、MAX、FIRST、LAST），而不能使用具有多行输出结果的函数（例如：DIFF 以及四则运算）。
-- 此外 LAST_ROW 查询也不能与窗口聚合同时出现。
-- 标量函数（如：CEIL/FLOOR 等）也不能使用在窗口聚合查询中。
--
-
-- WHERE 语句可以指定查询的起止时间和其他过滤条件。
-- FILL 语句指定某一窗口区间数据缺失的情况下的填充模式。填充模式包括以下几种：
-  1. 不进行填充：NONE（默认填充模式）。
-  2. VALUE 填充：固定值填充，此时需要指定填充的数值。例如：FILL(VALUE, 1.23)。
-  3. PREV 填充：使用前一个非 NULL 值填充数据。例如：FILL(PREV)。
-  4. NULL 填充：使用 NULL 填充数据。例如：FILL(NULL)。
-  5. LINEAR 填充：根据前后距离最近的非 NULL 值做线性插值填充。例如：FILL(LINEAR)。
-  6. NEXT 填充：使用下一个非 NULL 值填充数据。例如：FILL(NEXT)。
-
-:::info
-
-1. 使用 FILL 语句的时候可能生成大量的填充输出，务必指定查询的时间区间。针对每次查询，系统可返回不超过 1 千万条具有插值的结果。
-2. 在时间维度聚合中，返回的结果中时间序列严格单调递增。
-3. 如果查询对象是超级表，则聚合函数会作用于该超级表下满足值过滤条件的所有表的数据。如果查询中没有使用 GROUP BY 语句，则返回的结果按照时间序列严格单调递增；如果查询中使用了 GROUP BY 语句分组，则返回结果中每个 GROUP 内不按照时间序列严格单调递增。
-
-:::
-
-时间聚合也常被用于连续查询场景，可以参考文档 [连续查询(Continuous Query)](/develop/continuous-query)。
-
-## 示例
-
-智能电表的建表语句如下：
-
-```
-CREATE TABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT);
-```
-
-针对智能电表采集的数据，以 10 分钟为一个阶段，计算过去 24 小时的电流数据的平均值、最大值、电流的中位数。如果没有计算值，用前一个非 NULL 值填充。使用的查询语句如下：
-
-```
-SELECT AVG(current), MAX(current), APERCENTILE(current, 50) FROM meters
-  WHERE ts>=NOW-1d and ts<=now
-  INTERVAL(10m)
-  FILL(PREV);
-```

docs-cn/12-taos-sql/10-json.md

----
-sidebar_label: JSON 类型使用说明
-title: JSON 类型使用说明
----
-
-
-## 语法说明
-
-1. 创建 json 类型 tag
-
-   ```
-   create stable s1 (ts timestamp, v1 int) tags (info json)
-
-   create table s1_1 using s1 tags ('{"k1": "v1"}')
-   ```
-
-2. json 取值操作符 ->
-
-   ```
-   select * from s1 where info->'k1' = 'v1'
-
-   select info->'k1' from s1
-   ```
-
-3. json key 是否存在操作符 contains
-
-   ```
-   select * from s1 where info contains 'k2'
-
-   select * from s1 where info contains 'k1'
-   ```
-
-## 支持的操作
-
-1. 在 where 条件中时，支持函数 match/nmatch/between and/like/and/or/is null/is no null，不支持 in
-
-   ```
-   select * from s1 where info->'k1' match 'v*';
-
-   select * from s1 where info->'k1' like 'v%' and info contains 'k2';
-
-   select * from s1 where info is null;
-
-   select * from s1 where info->'k1' is not null
-   ```
-
-2. 支持 json tag 放在 group by、order by、join 子句、union all 以及子查询中，比如 group by json->'key'
-
-3. 支持 distinct 操作.
-
-   ```
-   select distinct info->'k1' from s1
-   ```
-
-4. 标签操作
-
-   支持修改 json 标签值（全量覆盖）
-
-   支持修改 json 标签名
-
-   不支持添加 json 标签、删除 json 标签、修改 json 标签列宽
-
-## 其他约束条件
-
-1. 只有标签列可以使用 json 类型，如果用 json 标签，标签列只能有一个。
-
-2. 长度限制：json 中 key 的长度不能超过 256，并且 key 必须为可打印 ascii 字符；json 字符串总长度不超过 4096 个字节。
-
-3. json 格式限制：
-
-   1. json 输入字符串可以为空（"","\t"," "或 null）或 object，不能为非空的字符串，布尔型和数组。
-   2. object 可为{}，如果 object 为{}，则整个 json 串记为空。key 可为""，若 key 为""，则 json 串中忽略该 k-v 对。
-   3. value 可以为数字(int/double)或字符串或 bool 或 null，暂不可以为数组。不允许嵌套。
-   4. 若 json 字符串中出现两个相同的 key，则第一个生效。
-   5. json 字符串里暂不支持转义。
-
-4. 当查询 json 中不存在的 key 时，返回 NULL
-
-5. 当 json tag 作为子查询结果时，不再支持上层查询继续对子查询中的 json 串做解析查询。
-
-   比如暂不支持
-
-   ```
-   select jtag->'key' from (select jtag from stable)
-   ```
-
-   不支持
-
-   ```
-   select jtag->'key' from (select jtag from stable) where jtag->'key'>0
-   ```

docs-cn/12-taos-sql/11-escape.md

----
-title: 转义字符说明
----
-
-## 转义字符表
-
-| 字符序列 | **代表的字符** |
-| :------: | -------------- |
-|   `\'`   | 单引号'        |
-|   `\"`   | 双引号"        |
-|    \n    | 换行符         |
-|    \r    | 回车符         |
-|    \t    | tab 符         |
-|   `\\`   | 斜杠\          |
-|   `\%`   | % 规则见下     |
-|   `\_`   | \_ 规则见下    |
-
-:::note
-转义符的功能从 2.4.0.4 版本开始
-
-:::
-
-## 转义字符使用规则
-
-1. 标识符里有转义字符（数据库名、表名、列名）
-   1. 普通标识符： 直接提示错误的标识符，因为标识符规定必须是数字、字母和下划线，并且不能以数字开头。
-   2. 反引号``标识符： 保持原样，不转义
-2. 数据里有转义字符
-   1. 遇到上面定义的转义字符会转义（%和\_见下面说明），如果没有匹配的转义字符会忽略掉转义符\。
-   2. 对于%和\_，因为在 like 里这两个字符是通配符，所以在模式匹配 like 里用`\%`%和`\_`表示字符里本身的%和\_，如果在 like 模式匹配上下文之外使用`\%`或`\_`，则它们的计算结果为字符串`\%`和`\_`，而不是%和\_。

docs-cn/12-taos-sql/12-keywords/_category_.yml

-label: 参数限制与保留关键字
\ No newline at end of file

docs-cn/12-taos-sql/12-keywords/index.md

----
-sidebar_label: 参数限制与保留关键字 
-title: TDengine 参数限制与保留关键字
----
-
-## 名称命名规则
-
-1. 合法字符：英文字符、数字和下划线
-2. 允许英文字符或下划线开头，不允许以数字开头
-3. 不区分大小写
-4. 转义后表（列）名规则：
-   为了兼容支持更多形式的表（列）名，TDengine 引入新的转义符 "`"。可用让表名与关键词不冲突，同时不受限于上述表名称合法性约束检查。
-   转义后的表（列）名同样受到长度限制要求，且长度计算的时候不计算转义符。使用转义字符以后，不再对转义字符中的内容进行大小写统一。
-
-   例如：\`aBc\` 和 \`abc\` 是不同的表（列）名，但是 abc 和 aBc 是相同的表（列）名。
-   需要注意的是转义字符中的内容必须是可打印字符。
-   支持转义符的功能从 2.3.0.1 版本开始。
-
-## 密码合法字符集
-
-`[a-zA-Z0-9!?$%^&*()_–+={[}]:;@~#|<,>.?/]`
-
-去掉了 `` ‘“`\ `` (单双引号、撇号、反斜杠、空格)
-
-- 数据库名：不能包含“.”以及特殊字符，不能超过 32 个字符
-- 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过 192 个字节 ，每行数据最大长度 48KB
-- 表的列名：不能包含特殊字符，不能超过 64 个字节
-- 数据库名、表名、列名，都不能以数字开头，合法的可用字符集是“英文字符、数字和下划线”
-- 表的列数：不能超过 1024 列，最少需要 2 列，第一列必须是时间戳（从 2.1.7.0 版本开始，改为最多支持 4096 列）
-- 记录的最大长度：包括时间戳 8 字节，不能超过 48KB（每个 BINARY/NCHAR 类型的列还会额外占用 2 个 字节 的存储位置）
-- 单条 SQL 语句默认最大字符串长度：1048576 字节，但可通过系统配置参数 maxSQLLength 修改，取值范围 65480 ~ 1048576 字节
-- 数据库副本数：不能超过 3
-- 用户名：不能超过 23 个 字节
-- 用户密码：不能超过 15 个 字节
-- 标签(Tags)数量：不能超过 128 个，可以 0 个
-- 标签的总长度：不能超过 16KB
-- 记录条数：仅受存储空间限制
-- 表的个数：仅受节点个数限制
-- 库的个数：仅受节点个数限制
-- 单个库上虚拟节点个数：不能超过 64 个
-- 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制
-- SELECT 语句的查询结果，最多允许返回 1024 列（语句中的函数调用可能也会占用一些列空间），超限时需要显式指定较少的返回数据列，以避免语句执行报错。（从 2.1.7.0 版本开始，改为最多允许 4096 列）
-
-## 保留关键字
-
-目前 TDengine 有将近 200 个内部保留关键字，这些关键字无论大小写均不可以用作库名、表名、STable 名、数据列名及标签列名等。这些关键字列表如下：
-
-| 关键字列表  |            |           |            |              |
-| ----------- | ---------- | --------- | ---------- | ------------ |
-| ABORT       | CREATE     | IGNORE    | NULL       | STAR         |
-| ACCOUNT     | CTIME      | IMMEDIATE | OF         | STATE        |
-| ACCOUNTS    | DATABASE   | IMPORT    | OFFSET     | STATEMENT    |
-| ADD         | DATABASES  | IN        | OR         | STATE_WINDOW |
-| AFTER       | DAYS       | INITIALLY | ORDER      | STORAGE      |
-| ALL         | DBS        | INSERT    | PARTITIONS | STREAM       |
-| ALTER       | DEFERRED   | INSTEAD   | PASS       | STREAMS      |
-| AND         | DELIMITERS | INT       | PLUS       | STRING       |
-| AS          | DESC       | INTEGER   | PPS        | SYNCDB       |
-| ASC         | DESCRIBE   | INTERVAL  | PRECISION  | TABLE        |
-| ATTACH      | DETACH     | INTO      | PREV       | TABLES       |
-| BEFORE      | DISTINCT   | IS        | PRIVILEGE  | TAG          |
-| BEGIN       | DIVIDE     | ISNULL    | QTIME      | TAGS         |
-| BETWEEN     | DNODE      | JOIN      | QUERIES    | TBNAME       |
-| BIGINT      | DNODES     | KEEP      | QUERY      | TIMES        |
-| BINARY      | DOT        | KEY       | QUORUM     | TIMESTAMP    |
-| BITAND      | DOUBLE     | KILL      | RAISE      | TINYINT      |
-| BITNOT      | DROP       | LE        | REM        | TOPIC        |
-| BITOR       | EACH       | LIKE      | REPLACE    | TOPICS       |
-| BLOCKS      | END        | LIMIT     | REPLICA    | TRIGGER      |
-| BOOL        | EQ         | LINEAR    | RESET      | TSERIES      |
-| BY          | EXISTS     | LOCAL     | RESTRICT   | UMINUS       |
-| CACHE       | EXPLAIN    | LP        | ROW        | UNION        |
-| CACHELAST   | FAIL       | LSHIFT    | RP         | UNSIGNED     |
-| CASCADE     | FILE       | LT        | RSHIFT     | UPDATE       |
-| CHANGE      | FILL       | MATCH     | SCORES     | UPLUS        |
-| CLUSTER     | FLOAT      | MAXROWS   | SELECT     | USE          |
-| COLON       | FOR        | MINROWS   | SEMI       | USER         |
-| COLUMN      | FROM       | MINUS     | SESSION    | USERS        |
-| COMMA       | FSYNC      | MNODES    | SET        | USING        |
-| COMP        | GE         | MODIFY    | SHOW       | VALUES       |
-| COMPACT     | GLOB       | MODULES   | SLASH      | VARIABLE     |
-| CONCAT      | GRANTS     | NCHAR     | SLIDING    | VARIABLES    |
-| CONFLICT    | GROUP      | NE        | SLIMIT     | VGROUPS      |
-| CONNECTION  | GT         | NONE      | SMALLINT   | VIEW         |
-| CONNECTIONS | HAVING     | NOT       | SOFFSET    | VNODES       |
-| CONNS       | ID         | NOTNULL   | STABLE     | WAL          |
-| COPY        | IF         | NOW       | STABLES    | WHERE        |
-| _C0         | _QSTART    | _QSTOP    | _QDURATION | _WSTART      |
-| _WSTOP      | _WDURATION |
-
-## 特殊说明
-### TBNAME
-`TBNAME` 可以视为超级表中一个特殊的标签，代表子表的表名。
-
-获取一个超级表所有的子表名及相关的标签信息：
-```mysql
-SELECT TBNAME, location FROM meters;
-
-统计超级表下辖子表数量：
-```mysql
-SELECT COUNT(TBNAME) FROM meters;
-```
-
-以上两个查询均只支持在WHERE条件子句中添加针对标签（TAGS）的过滤条件。例如：
-```mysql
-taos> SELECT TBNAME, location FROM meters;
-             tbname             |            location            |
-==================================================================
- d1004                          | California.SanFrancisco        |
- d1003                          | California.SanFrancisco        |
- d1002                          | California.LosAngeles          |
- d1001                          | California.LosAngeles          |
-Query OK, 4 row(s) in set (0.000881s)
-
-taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2;
-     count(tbname)     |
-========================
-                     2 |
-Query OK, 1 row(s) in set (0.001091s)
-```
-### _QSTART/_QSTOP/_QDURATION
-表示查询过滤窗口的起始，结束以及持续时间 (从2.6.0.0版本开始支持)
-
-### _WSTART/_WSTOP/_WDURATION
-窗口切分聚合查询（例如 interval/session window/state window）中表示每个切分窗口的起始，结束以及持续时间（从 2.6.0.0 版本开始支持）
-
-### _c0
-表示表或超级表的第一列
\ No newline at end of file

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

----
-title: TAOS SQL
-description: "TAOS SQL 支持的语法规则、主要查询功能、支持的 SQL 查询函数，以及常用技巧等内容"
----
-
-本文档说明 TAOS SQL 支持的语法规则、主要查询功能、支持的 SQL 查询函数，以及常用技巧等内容。阅读本文档需要读者具有基本的 SQL 语言的基础。
-
-TAOS SQL 是用户对 TDengine 进行数据写入和查询的主要工具。TAOS SQL 为了便于用户快速上手，在一定程度上提供与标准 SQL 类似的风格和模式。严格意义上，TAOS SQL 并不是也不试图提供标准的 SQL 语法。此外，由于 TDengine 针对的时序性结构化数据不提供删除功能，因此在 TAO SQL 中不提供数据删除的相关功能。
-
-本章节 SQL 语法遵循如下约定：
-
-- <\> 里的内容是用户需要输入的，但不要输入 <\> 本身
-- \[ \] 表示内容为可选项，但不能输入 [] 本身
-- | 表示多选一，选择其中一个即可，但不能输入 | 本身
-- … 表示前面的项可重复多个
-
-为更好地说明 SQL 语法的规则及其特点，本文假设存在一个数据集。以智能电表(meters)为例，假设每个智能电表采集电流、电压、相位三个量。其建模如下：
-
-```
-taos> DESCRIBE meters;
-             Field              |        Type        |   Length    |    Note    |
-=================================================================================
- ts                             | TIMESTAMP          |           8 |            |
- current                        | FLOAT              |           4 |            |
- voltage                        | INT                |           4 |            |
- phase                          | FLOAT              |           4 |            |
- location                       | BINARY             |          64 | TAG        |
- groupid                        | INT                |           4 | TAG        |
-```
-
-数据集包含 4 个智能电表的数据，按照 TDengine 的建模规则，对应 4 个子表，其名称分别是 d1001, d1002, d1003, d1004。
-
-```mdx-code-block
-import DocCardList from '@theme/DocCardList';
-import {useCurrentSidebarCategory} from '@docusaurus/theme-common';
-
-<DocCardList items={useCurrentSidebarCategory().items}/>
-```

docs-cn/14-reference/02-rest-api/02-rest-api.mdx

----
-title: REST API
----
-
-为支持各种不同类型平台的开发，TDengine 提供符合 REST 设计标准的 API，即 REST API。为最大程度降低学习成本，不同于其他数据库 REST API 的设计方法，TDengine 直接通过 HTTP POST 请求 BODY 中包含的 SQL 语句来操作数据库，仅需要一个 URL。REST 连接器的使用参见[视频教程](https://www.taosdata.com/blog/2020/11/11/1965.html)。
-
-:::note
-与原生连接器的一个区别是，RESTful 接口是无状态的，因此 `USE db_name` 指令没有效果，所有对表名、超级表名的引用都需要指定数据库名前缀。从 2.2.0.0 版本开始，支持在 RESTful URL 中指定 db_name，这时如果 SQL 语句中没有指定数据库名前缀的话，会使用 URL 中指定的这个 db_name。从 2.4.0.0 版本开始，RESTful 默认由 taosAdapter 提供，要求必须在 URL 中指定 db_name。
-:::
-
-## 安装
-
-RESTful 接口不依赖于任何 TDengine 的库，因此客户端不需要安装任何 TDengine 的库，只要客户端的开发语言支持 HTTP 协议即可。
-
-## 验证
-
-在已经安装 TDengine 服务器端的情况下，可以按照如下方式进行验证。
-
-下面以 Ubuntu 环境中使用 curl 工具（确认已经安装）来验证 RESTful 接口的正常，验证前请确认 taosAdapter 服务已开启，在 Linux 系统上此服务默认由 systemd 管理，使用命令 `systemctl start taosadapter` 启动。
-
-下面示例是列出所有的数据库，请把 h1.taosdata.com 和 6041（缺省值）替换为实际运行的 TDengine 服务 FQDN 和端口号：
-
-```html
-curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'show databases;' h1.taosdata.com:6041/rest/sql
-```
-
-返回值结果如下表示验证通过：
-
-```json
-{
-  "status": "succ",
-  "head": [
-    "name",
-    "created_time",
-    "ntables",
-    "vgroups",
-    "replica",
-    "quorum",
-    "days",
-    "keep1,keep2,keep(D)",
-    "cache(MB)",
-    "blocks",
-    "minrows",
-    "maxrows",
-    "wallevel",
-    "fsync",
-    "comp",
-    "precision",
-    "status"
-  ],
-  "data": [
-    [
-      "log",
-      "2020-09-02 17:23:00.039",
-      4,
-      1,
-      1,
-      1,
-      10,
-      "30,30,30",
-      1,
-      3,
-      100,
-      4096,
-      1,
-      3000,
-      2,
-      "us",
-      "ready"
-    ]
-  ],
-  "rows": 1
-}
-```
-
-## HTTP 请求格式
-
-```
-http://<fqdn>:<port>/rest/sql/[db_name]
-```
-
-参数说明：
-
-- fqnd: 集群中的任一台主机 FQDN 或 IP 地址
-- port: 配置文件中 httpPort 配置项，缺省为 6041
-- db_name: 可选参数，指定本次所执行的 SQL 语句的默认数据库库名。（从 2.2.0.0 版本开始支持）
-
-例如：`http://h1.taos.com:6041/rest/sql/test` 是指向地址为 `h1.taos.com:6041` 的 URL，并将默认使用的数据库库名设置为 `test`。
-
-HTTP 请求的 Header 里需带有身份认证信息，TDengine 支持 Basic 认证与自定义认证两种机制，后续版本将提供标准安全的数字签名机制来做身份验证。
-
-- 自定义身份认证信息如下所示（token 稍后介绍）
-
-  ```
-  Authorization: Taosd <TOKEN>
-  ```
-
-- Basic 身份认证信息如下所示
-
-  ```
-  Authorization: Basic <TOKEN>
-  ```
-
-HTTP 请求的 BODY 里就是一个完整的 SQL 语句，SQL 语句中的数据表应提供数据库前缀，例如 db_name.tb_name。如果表名不带数据库前缀，又没有在 URL 中指定数据库名的话，系统会返回错误。因为 HTTP 模块只是一个简单的转发，没有当前 DB 的概念。
-
-使用 `curl` 通过自定义身份认证方式来发起一个 HTTP Request，语法如下：
-
-```bash
-curl -H 'Authorization: Basic <TOKEN>' -d '<SQL>' <ip>:<PORT>/rest/sql/[db_name]
-```
-
-或者
-
-```bash
-curl -u username:password -d '<SQL>' <ip>:<PORT>/rest/sql/[db_name]
-```
-
-其中，`TOKEN` 为 `{username}:{password}` 经过 Base64 编码之后的字符串，例如 `root:taosdata` 编码后为 `cm9vdDp0YW9zZGF0YQ==`
-
-## HTTP 返回格式
-
-返回值为 JSON 格式，如下:
-
-```json
-{
-    "status": "succ",
-    "head": ["ts","current", …],
-    "column_meta": [["ts",9,8],["current",6,4], …],
-    "data": [
-        ["2018-10-03 14:38:05.000", 10.3, …],
-        ["2018-10-03 14:38:15.000", 12.6, …]
-    ],
-    "rows": 2
-}
-```
-
-说明：
-
-- status: 告知操作结果是成功还是失败。
-- head: 表的定义，如果不返回结果集，则仅有一列 “affected_rows”。（从 2.0.17.0 版本开始，建议不要依赖 head 返回值来判断数据列类型，而推荐使用 column_meta。在后续版本中，有可能会从返回值中去掉 head 这一项。）
-- column_meta: 从 2.0.17.0 版本开始，返回值中增加这一项来说明 data 里每一列的数据类型。具体每个列会用三个值来说明，分别为：列名、列类型、类型长度。例如`["current",6,4]`表示列名为“current”；列类型为 6，也即 float 类型；类型长度为 4，也即对应 4 个字节表示的 float。如果列类型为 binary 或 nchar，则类型长度表示该列最多可以保存的内容长度，而不是本次返回值中的具体数据长度。当列类型是 nchar 的时候，其类型长度表示可以保存的 unicode 字符数量，而不是 bytes。
-- data: 具体返回的数据，一行一行的呈现，如果不返回结果集，那么就仅有 [[affected_rows]]。data 中每一行的数据列顺序，与 column_meta 中描述数据列的顺序完全一致。
-- rows: 表明总共多少行数据。
-
-column_meta 中的列类型说明：
-
-- 1：BOOL
-- 2：TINYINT
-- 3：SMALLINT
-- 4：INT
-- 5：BIGINT
-- 6：FLOAT
-- 7：DOUBLE
-- 8：BINARY
-- 9：TIMESTAMP
-- 10：NCHAR
-
-## 自定义授权码
-
-HTTP 请求中需要带有授权码 `<TOKEN>`，用于身份识别。授权码通常由管理员提供，可简单的通过发送 `HTTP GET` 请求来获取授权码，操作如下：
-
-```bash
-curl http://<fqnd>:<port>/rest/login/<username>/<password>
-```
-
-其中，`fqdn` 是 TDengine 数据库的 FQDN 或 IP 地址，`port` 是 TDengine 服务的端口号，`username` 为数据库用户名，`password` 为数据库密码，返回值为 JSON 格式，各字段含义如下：
-
-- status：请求结果的标志位
-
-- code：返回值代码
-
-- desc：授权码
-
-获取授权码示例：
-
-```bash
-curl http://192.168.0.1:6041/rest/login/root/taosdata
-```
-
-返回值：
-
-```json
-{
-  "status": "succ",
-  "code": 0,
-  "desc": "/KfeAzX/f9na8qdtNZmtONryp201ma04bEl8LcvLUd7a8qdtNZmtONryp201ma04"
-}
-```
-
-## 使用示例
-
-- 在 demo 库里查询表 d1001 的所有记录：
-
-  ```bash
-  curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001' 192.168.0.1:6041/rest/sql
-  ```
-
-  返回值：
-
-  ```json
-  {
-    "status": "succ",
-    "head": ["ts", "current", "voltage", "phase"],
-    "column_meta": [
-      ["ts", 9, 8],
-      ["current", 6, 4],
-      ["voltage", 4, 4],
-      ["phase", 6, 4]
-    ],
-    "data": [
-      ["2018-10-03 14:38:05.000", 10.3, 219, 0.31],
-      ["2018-10-03 14:38:15.000", 12.6, 218, 0.33]
-    ],
-    "rows": 2
-  }
-  ```
-
-- 创建库 demo：
-
-  ```bash
-  curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'create database demo' 192.168.0.1:6041/rest/sql
-  ```
-
-  返回值：
-
-  ```json
-  {
-    "status": "succ",
-    "head": ["affected_rows"],
-    "column_meta": [["affected_rows", 4, 4]],
-    "data": [[1]],
-    "rows": 1
-  }
-  ```
-
-## 其他用法
-
-### 结果集采用 Unix 时间戳
-
-HTTP 请求 URL 采用 `/rest/sqlt` 时，返回结果集的时间戳将采用 Unix 时间戳格式表示，例如
-
-```bash
-curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.d1001' 192.168.0.1:6041/rest/sqlt
-```
-
-返回结果：
-
-```json
-{
-  "status": "succ",
-  "head": ["ts", "current", "voltage", "phase"],
-  "column_meta": [
-    ["ts", 9, 8],
-    ["current", 6, 4],
-    ["voltage", 4, 4],
-    ["phase", 6, 4]
-  ],
-  "data": [
-    [1538548685000, 10.3, 219, 0.31],
-    [1538548695000, 12.6, 218, 0.33]
-  ],
-  "rows": 2
-}
-```
-
-### 结果集采用 UTC 时间字符串
-
-HTTP 请求 URL 采用 `/rest/sqlutc` 时，返回结果集的时间戳将采用 UTC 时间字符串表示，例如
-
-```bash
-  curl -H 'Authorization: Basic cm9vdDp0YW9zZGF0YQ==' -d 'select * from demo.t1' 192.168.0.1:6041/rest/sqlutc
-```
-
-返回值：
-
-```json
-{
-  "status": "succ",
-  "head": ["ts", "current", "voltage", "phase"],
-  "column_meta": [
-    ["ts", 9, 8],
-    ["current", 6, 4],
-    ["voltage", 4, 4],
-    ["phase", 6, 4]
-  ],
-  "data": [
-    ["2018-10-03T14:38:05.000+0800", 10.3, 219, 0.31],
-    ["2018-10-03T14:38:15.000+0800", 12.6, 218, 0.33]
-  ],
-  "rows": 2
-}
-```
-
-## 重要配置项
-
-下面仅列出一些与 RESTful 接口有关的配置参数，其他系统参数请看配置文件里的说明。
-
-- 对外提供 RESTful 服务的端口号，默认绑定到 6041（实际取值是 serverPort + 11，因此可以通过修改 serverPort 参数的设置来修改）。
-- httpMaxThreads: 启动的线程数量，默认为 2（2.0.17.0 版本开始，默认值改为 CPU 核数的一半向下取整）。
-- restfulRowLimit: 返回结果集（JSON 格式）的最大条数，默认值为 10240。
-- httpEnableCompress: 是否支持压缩，默认不支持，目前 TDengine 仅支持 gzip 压缩格式。
-- httpDebugFlag: 日志开关，默认 131。131：仅错误和报警信息，135：调试信息，143：非常详细的调试信息。
-- httpDbNameMandatory: 是否必须在 RESTful URL 中指定默认的数据库名。默认为 0，即关闭此检查。如果设置为 1，那么每个 RESTful URL 中都必须设置一个默认数据库名，否则无论此时执行的 SQL 语句是否需要指定数据库，都会返回一个执行错误，拒绝执行此 SQL 语句。
-
-:::note
-如果使用 taosd 提供的 REST API, 那么以上配置需要写在 taosd 的配置文件 taos.cfg 中。如果使用 taosAdapter 提供的 REST API, 那么需要参考 taosAdapter [对应的配置方法](/reference/taosadapter/)。
-:::

docs-cn/14-reference/03-connector/_verify_linux.mdx

-在 Linux shell 下直接执行 `taos` 连接到 TDengine 服务，进入到 TDengine CLI 界面，示例如下：
-
-```text
-$ taos
-Welcome to the TDengine shell from Linux, Client  Version:2.0.5.0
-Copyright (c) 2017 by TAOS Data, Inc. All rights  reserved.
-taos> show databases;
-name       |   created_time    |   ntables  |  vgroups   | replica | quorum | days |    keep1,keep2,keep(D)   | cache(MB)|   blocks  |  minrows   |  maxrows  | wallevel |  fsync    | comp | precision |    status  |
-=========================================================================================================================================================================================================================
-test       | 2020-10-14  10:35:48.617 |     10 |      1 |    1 |   1 |     2 | 3650,3650,3650        |     16|      6 |     100 |    4096 |    1 |    3000 |  2 | ms      | ready    |
-log        | 2020-10-12  09:08:21.651 |      4 |      1 |    1 |   1 |   10 | 30,30,30               |      1|      3 |     100 |    4096 |    1 |    3000 |  2 | us    | ready    |
-Query OK, 2 row(s) in set (0.001198s)
-taos>
-```

docs-cn/14-reference/03-connector/_verify_windows.mdx

-在 cmd 下进入到 C:\TDengine 目录下直接执行 `taos.exe`，连接到 TDengine 服务，进入到 TDengine CLI 界面，示例如下：
-
-```text
-  C:\TDengine>taos
-  Welcome to the TDengine  shell from Linux, Client Version:2.0.5.0
-  Copyright (c) 2017 by  TAOS Data, Inc. All rights reserved.
-  taos> show  databases;
-  name       |   created_time    |   ntables  |  vgroups   | replica | quorum | days |    keep1,keep2,keep(D)   | cache(MB)   |  blocks  |   minrows  |  maxrows   | wallevel |  fsync  | comp | precision |  status    |
-  ===================================================================================================================================================================================================================================================================
-  test       | 2020-10-14  10:35:48.617 |     10 |      1 |    1 |   1 |     2 | 3650,3650,3650        |     16 |      6 |     100 |    4096 |    1 |    3000 |  2 | ms    | ready    |
-  log        | 2020-10-12  09:08:21.651 |      4 |      1 |    1 |   1 |    10 | 30,30,30              |      1 |      3 |     100 |    4096 |    1 |    3000 |  2 | us    | ready    |
-  Query OK, 2 row(s) in  set (0.045000s)
-  taos>
-```

docs-cn/14-reference/03-connector/csharp.mdx

----
-toc_max_heading_level: 4
-sidebar_position: 7
-sidebar_label: C#
-title: C# Connector
----
-
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
-
-import Preparition from "./_preparition.mdx"
-import CSInsert from "../../07-develop/03-insert-data/_cs_sql.mdx"
-import CSInfluxLine from "../../07-develop/03-insert-data/_cs_line.mdx"
-import CSOpenTSDBTelnet from "../../07-develop/03-insert-data/_cs_opts_telnet.mdx"
-import CSOpenTSDBJson from "../../07-develop/03-insert-data/_cs_opts_json.mdx"
-import CSQuery from "../../07-develop/04-query-data/_cs.mdx"
-import CSAsyncQuery from "../../07-develop/04-query-data/_cs_async.mdx"
-
-`TDengine.Connector` 是 TDengine 提供的 C# 语言连接器。C# 开发人员可以通过它开发存取 TDengine 集群数据的 C# 应用软件。
-
-`TDengine.Connector` 连接器支持通过 TDengine 客户端驱动（taosc）建立与 TDengine 运行实例的连接，提供数据写入、查询、订阅、schemaless 数据写入、参数绑定接口数据写入等功能 `TDengine.Connector` 目前暂未提供 REST 连接方式，用户可以参考 [REST API](/reference/rest-api/) 文档自行编写。
-
-本文介绍如何在 Linux 或 Windows 环境中安装 `TDengine.Connector`，并通过 `TDengine.Connector` 连接 TDengine 集群，进行数据写入、查询等基本操作。
-
-`TDengine.Connector` 的源码托管在 [GitHub](https://github.com/taosdata/taos-connector-dotnet)。
-
-## 支持的平台
-
-支持的平台和 TDengine 客户端驱动支持的平台一致。
-
-## 版本支持
-
-请参考[版本支持列表](/reference/connector#版本支持)
-
-## 支持的功能特性
-
-1. 连接管理
-2. 普通查询
-3. 连续查询
-4. 参数绑定
-5. 订阅功能
-6. Schemaless
-
-## 安装步骤
-
-### 安装前准备
-
-* 安装 [.NET SDK](https://dotnet.microsoft.com/download)
-* [Nuget 客户端](https://docs.microsoft.com/en-us/nuget/install-nuget-client-tools) （可选安装）
-* 安装 TDengine 客户端驱动，具体步骤请参考[安装客户端驱动](/reference/connector#安装客户端驱动)
-
-### 使用 dotnet CLI 安装
-
-<Tabs defaultValue="CLI">
-<TabItem value="CLI" label="使用 dotnet CLI 获取 C# 驱动">
-
-可以在当前 .NET 项目的路径下，通过 dotnet 命令引用 Nuget 中发布的 `TDengine.Connector` 到当前项目。
-
-``` bash
-dotnet add package TDengine.Connector
-```
-
-</TabItem>
-<TabItem value="source" label="使用源码获取 C# 驱动">
-
-可以下载 TDengine 的源码，直接引用最新版本的 TDengine.Connector 库
-
-```bash
-git clone https://github.com/taosdata/TDengine.git
-cd TDengine/src/connector/C#/src/
-cp -r TDengineDriver/ myProject
-
-cd myProject
-dotnet add TDengineDriver/TDengineDriver.csproj
-```
-</TabItem>
-</Tabs>
-
-## 建立连接
-
-``` C#
-using TDengineDriver;
-
-namespace TDengineExample
-{
-
-    internal class EstablishConnection
-    {
-        static void Main(String[] args)
-        {
-            string host = "localhost";
-            short port = 6030;
-            string username = "root";
-            string password = "taosdata";
-            string dbname = "";
-
-            var conn = TDengine.Connect(host, username, password, dbname, port);
-            if (conn == IntPtr.Zero)
-            {
-                Console.WriteLine("Connect to TDengine failed");
-            }
-            else
-            {
-                Console.WriteLine("Connect to TDengine success");
-            }
-            TDengine.Close(conn);
-            TDengine.Cleanup();
-        }
-    }
-}
-
-```
-
-## 使用示例
-
-### 写入数据
-
-#### SQL 写入
-
-<CSInsert />
-
-#### InfluxDB 行协议写入
-
-<CSInfluxLine />
-
-#### OpenTSDB Telnet 行协议写入
-
-<CSOpenTSDBTelnet />
-
-#### OpenTSDB JSON 行协议写入
-
-<CSOpenTSDBJson />
-
-### 查询数据
-
-#### 同步查询
-
-<CSQuery />
-
-#### 异步查询
-
-<CSAsyncQuery />
-
-### 更多示例程序
-
-|示例程序                                                                                                               | 示例程序描述                                       |
-|--------------------------------------------------------------------------------------------------------------------|--------------------------------------------|
-| [C#checker](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/C%23checker)                           | 使用 TDengine.Connector 可以通过 help 命令中提供的参数，测试C# Driver的同步写入和查询    |
-| [TDengineTest](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/TDengineTest)                       | 使用 TDengine.Connector 实现的简单写入和查询的示例 |
-| [insertCn](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/insertCn)                               | 使用 TDengine.Connector 实现的写入和查询中文字符的示例    |
-| [jsonTag](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/jsonTag)                                 | 使用 TDengine.Connector 实现的写入和查询 json tag 类型数据的示例 |
-| [stmt](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/stmt)                                       | 使用 TDengine.Connector 实现的参数绑定的示例 |
-| [schemaless](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/schemaless)                           | 使用 TDengine.Connector 实现的使用 schemaless 写入的示例 |
-| [benchmark](https://github.com/taosdata/TDengine/tree/develop/examples/C%23/taosdemo)                              | 使用 TDengine.Connector 实现的简易 Benchmark |
-| [async   query](https://github.com/taosdata/taos-connector-dotnet/blob/develop/examples/QueryAsyncSample.cs) | 使用 TDengine.Connector 实现的异步查询的示例 |
-| [subscribe](https://github.com/taosdata/taos-connector-dotnet/blob/develop/examples/SubscribeSample.cs)      | 使用 TDengine.Connector 实现的订阅数据的示例 |
-
-## 重要更新记录
-
-| TDengine.Connector | 说明                           |
-|--------------------|--------------------------------|
-|        1.0.6       | 修复 schemaless 在 1.0.4 和 1.0.5 中失效 bug。 |
-|        1.0.5       | 修复 Windows 同步查询中文报错 bug。   |
-|        1.0.4       | 新增异步查询，订阅等功能。修复绑定参数 bug。    |
-|        1.0.3       | 新增参数绑定、schemaless、 json tag等功能。 |
-|        1.0.2       | 新增连接管理、同步查询、错误信息等功能。   |
-
-## 其他说明
-
-### 第三方驱动
-
-`Maikebing.Data.Taos` 是一个 TDengine 的 ADO.NET 连接器，支持 Linux，Windows 平台。该连接器由社区贡献者`麦壳饼@@maikebing` 提供，具体请参考:
-
-* 接口下载:<https://github.com/maikebing/Maikebing.EntityFrameworkCore.Taos>
-* 用法说明:<https://www.taosdata.com/blog/2020/11/02/1901.html>
-
-## 常见问题
-
-1. "Unable to establish connection"，"Unable to resolve FQDN"
-
-  一般是因为 FQDN 配置不正确。可以参考[如何彻底搞懂 TDengine 的 FQDN](https://www.taosdata.com/blog/2021/07/29/2741.html)解决。
-
-2. Unhandled exception. System.DllNotFoundException: Unable to load DLL 'taos' or one of its dependencies: 找不到指定的模块。
-
-  一般是因为程序没有找到依赖的客户端驱动。解决方法为：Windows 下可以将 `C:\TDengine\driver\taos.dll` 拷贝到 `C:\Windows\System32\ ` 目录下，Linux 下建立如下软链接 `ln -s /usr/local/taos/driver/libtaos.so.x.x.x.x /usr/lib/libtaos.so` 即可。
-
-## API 参考
-
-[API 参考](https://docs.taosdata.com/api/connector-csharp/html/860d2ac1-dd52-39c9-e460-0829c4e5a40b.htm)

docs-cn/14-reference/03-connector/go.mdx

----
-toc_max_heading_level: 4
-sidebar_position: 4
-sidebar_label: Go
-title: TDengine Go Connector
----
-
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
-
-import Preparition from "./_preparition.mdx"
-import GoInsert from "../../07-develop/03-insert-data/_go_sql.mdx"
-import GoInfluxLine from "../../07-develop/03-insert-data/_go_line.mdx"
-import GoOpenTSDBTelnet from "../../07-develop/03-insert-data/_go_opts_telnet.mdx"
-import GoOpenTSDBJson from "../../07-develop/03-insert-data/_go_opts_json.mdx"
-import GoQuery from "../../07-develop/04-query-data/_go.mdx"
-
-`driver-go` 是 TDengine 的官方 Go 语言连接器，实现了 Go 语言[ database/sql ](https://golang.org/pkg/database/sql/) 包的接口。Go 开发人员可以通过它开发存取 TDengine 集群数据的应用软件。
-
-`driver-go` 提供两种建立连接的方式。一种是**原生连接**，它通过 TDengine 客户端驱动程序（taosc）原生连接 TDengine 运行实例，支持数据写入、查询、订阅、schemaless 接口和参数绑定接口等功能。另外一种是 **REST 连接**，它通过 taosAdapter 提供的 REST 接口连接 TDengine 运行实例。REST 连接实现的功能特性集合和原生连接有少量不同。
-
-本文介绍如何安装 `driver-go`，并通过 `driver-go` 连接 TDengine 集群、进行数据查询、数据写入等基本操作。
-
-`driver-go` 的源码托管在 [GitHub](https://github.com/taosdata/driver-go)。
-
-## 支持的平台
-
-原生连接支持的平台和 TDengine 客户端驱动支持的平台一致。
-REST 连接支持所有能运行 Go 的平台。
-
-## 版本支持
-
-请参考[版本支持列表](/reference/connector#版本支持)
-
-## 支持的功能特性
-
-### 原生连接
-
-“原生连接”指连接器通过 TDengine 客户端驱动（taosc）直接与 TDengine 运行实例建立的连接。支持的功能特性有：
-
-* 普通查询
-* 连续查询
-* 订阅
-* schemaless 接口
-* 参数绑定接口
-
-### REST 连接
-
-"REST 连接"指连接器通过 taosAdapter 组件提供的 REST API 与 TDengine 运行实例建立的连接。支持的功能特性有：
-
-* 普通查询
-* 连续查询
-
-## 安装步骤
-
-### 安装前准备
-
-* 安装 Go 开发环境（Go 1.14 及以上，GCC 4.8.5 及以上）
-* 如果使用原生连接器，请安装 TDengine 客户端驱动，具体步骤请参考[安装客户端驱动](/reference/connector#安装客户端驱动)
-
-配置好环境变量，检查命令：
-
-* ```go env```
-* ```gcc -v```
-
-### 使用 go get 安装
-
-`go get -u github.com/taosdata/driver-go/v2@develop`
-
-### 使用 go mod 管理
-
-1. 使用 `go mod` 命令初始化项目：
-
-  ```text
-  go mod init taos-demo
-  ```
-
-2. 引入 taosSql ：
-
-  ```go
-  import (
-    "database/sql"
-    _ "github.com/taosdata/driver-go/v2/taosSql"
-  )
-  ```
-
-3. 使用 `go mod tidy` 更新依赖包：
-
-  ```text
-  go mod tidy
-  ```
-
-4. 使用 `go run taos-demo` 运行程序或使用 `go build` 命令编译出二进制文件。
-
-  ```text
-  go run taos-demo
-  go build
-  ```
-
-## 建立连接
-
-### 数据源名称（DSN）
-
-数据源名称具有通用格式，例如 [PEAR DB](http://pear.php.net/manual/en/package.database.db.intro-dsn.php)，但没有类型前缀（方括号表示可选）：
-
-``` text
-[username[:password]@][protocol[(address)]]/[dbname][?param1=value1&...&paramN=valueN]
-```
-
-完整形式的 DSN：
-
-```text
-username:password@protocol(address)/dbname?param=value
-```
-### 使用连接器进行连接
-
-<Tabs defaultValue="native">
-<TabItem value="native" label="原生连接">
-
-_taosSql_ 通过 cgo 实现了 Go 的 `database/sql/driver` 接口。只需要引入驱动就可以使用 [`database/sql`](https://golang.org/pkg/database/sql/) 的接口。
-
-使用 `taosSql` 作为 `driverName` 并且使用一个正确的 [DSN](#DSN) 作为 `dataSourceName`，DSN 支持的参数：
-
-* configPath 指定 taos.cfg 目录
-
-示例：
-
-```go
-package main
-
-import (
-    "database/sql"
-    "fmt"
-
-    _ "github.com/taosdata/driver-go/v2/taosSql"
-)
-
-func main() {
-    var taosUri = "root:taosdata@tcp(localhost:6030)/"
-    taos, err := sql.Open("taosSql", taosUri)
-    if err != nil {
-        fmt.Println("failed to connect TDengine, err:", err)
-        return
-    }
-}
-```
-
-</TabItem>
-<TabItem value="rest" label="REST 连接">
-
-_taosRestful_ 通过 `http client` 实现了 Go 的 `database/sql/driver` 接口。只需要引入驱动就可以使用[`database/sql`](https://golang.org/pkg/database/sql/)的接口。
-
-使用 `taosRestful` 作为 `driverName` 并且使用一个正确的 [DSN](#DSN) 作为 `dataSourceName`，DSN 支持的参数：
-
-* `disableCompression` 是否接受压缩数据，默认为 true 不接受压缩数据，如果传输数据使用 gzip 压缩设置为 false。
-* `readBufferSize` 读取数据的缓存区大小默认为 4K（4096），当查询结果数据量多时可以适当调大该值。
-
-示例：
-
-```go
-package main
-
-import (
-    "database/sql"
-    "fmt"
-
-    _ "github.com/taosdata/driver-go/v2/taosRestful"
-)
-
-func main() {
-    var taosUri = "root:taosdata@http(localhost:6041)/"
-    taos, err := sql.Open("taosRestful", taosUri)
-    if err != nil {
-        fmt.Println("failed to connect TDengine, err:", err)
-        return
-    }
-}
-```
-</TabItem>
-</Tabs>
-
-## 使用示例
-
-### 写入数据
-
-#### SQL 写入
-
-<GoInsert />
-
-#### InfluxDB 行协议写入
-
-<GoInfluxLine />
-
-#### OpenTSDB Telnet 行协议写入
-
-<GoOpenTSDBTelnet />
-
-#### OpenTSDB JSON 行协议写入
-
-<GoOpenTSDBJson />
-
-### 查询数据
-
-<GoQuery />
-
-### 更多示例程序
-
-* [示例程序](https://github.com/taosdata/TDengine/tree/develop/examples/go)
-* [视频教程](https://www.taosdata.com/blog/2020/11/11/1951.html)。
-
-## 使用限制
-
-由于 REST 接口无状态所以 `use db` 语法不会生效，需要将 db 名称放到 SQL 语句中，如：`create table if not exists tb1 (ts timestamp, a int)`改为`create table if not exists test.tb1 (ts timestamp, a int)`否则将报错`[0x217] Database not specified or available`。
-
-也可以将 db 名称放到 DSN 中，将 `root:taosdata@http(localhost:6041)/` 改为 `root:taosdata@http(localhost:6041)/test`，此方法在 TDengine 2.4.0.5 版本的 taosAdapter 开始支持。当指定的 db 不存在时执行 `create database` 语句不会报错，而执行针对该 db 的其他查询或写入操作会报错。
-
-完整示例如下：
-
-```go
-package main
-
-import (
-    "database/sql"
-    "fmt"
-    "time"
-
-    _ "github.com/taosdata/driver-go/v2/taosRestful"
-)
-
-func main() {
-    var taosDSN = "root:taosdata@http(localhost:6041)/test"
-    taos, err := sql.Open("taosRestful", taosDSN)
-    if err != nil {
-        fmt.Println("failed to connect TDengine, err:", err)
-        return
-    }
-    defer taos.Close()
-    taos.Exec("create database if not exists test")
-    taos.Exec("create table if not exists tb1 (ts timestamp, a int)")
-    _, err = taos.Exec("insert into tb1 values(now, 0)(now+1s,1)(now+2s,2)(now+3s,3)")
-    if err != nil {
-        fmt.Println("failed to insert, err:", err)
-        return
-    }
-    rows, err := taos.Query("select * from tb1")
-    if err != nil {
-        fmt.Println("failed to select from table, err:", err)
-        return
-    }
-
-    defer rows.Close()
-    for rows.Next() {
-        var r struct {
-            ts time.Time
-            a  int
-        }
-        err := rows.Scan(&r.ts, &r.a)
-        if err != nil {
-            fmt.Println("scan error:\n", err)
-            return
-        }
-        fmt.Println(r.ts, r.a)
-    }
-}
-```
-
-## 常见问题
-
-1. 无法找到包 `github.com/taosdata/driver-go/v2/taosRestful`
-
-  将 `go.mod` 中 require 块对`github.com/taosdata/driver-go/v2`的引用改为`github.com/taosdata/driver-go/v2 develop`，之后执行 `go mod tidy`。
-
-2. database/sql 中 stmt（参数绑定）相关接口崩溃
-
-  REST 不支持参数绑定相关接口，建议使用`db.Exec`和`db.Query`。
-
-3. 使用 `use db` 语句后执行其他语句报错 `[0x217] Database not specified or available`
-
-  在 REST 接口中 SQL 语句的执行无上下文关联，使用 `use db` 语句不会生效，解决办法见上方使用限制章节。
-
-4. 使用 taosSql 不报错使用 taosRestful 报错 `[0x217] Database not specified or available`
-
-  因为 REST 接口无状态，使用 `use db` 语句不会生效，解决办法见上方使用限制章节。
-
-5. 升级 `github.com/taosdata/driver-go/v2/taosRestful`
-
-  将 `go.mod` 文件中对 `github.com/taosdata/driver-go/v2` 的引用改为 `github.com/taosdata/driver-go/v2 develop`，之后执行 `go mod tidy`。
-
-6. `readBufferSize` 参数调大后无明显效果
-
-  `readBufferSize` 调大后会减少获取结果时 `syscall` 的调用。如果查询结果的数据量不大，修改该参数不会带来明显提升，如果该参数修改过大，瓶颈会在解析 JSON 数据。如果需要优化查询速度，需要根据实际情况调整该值来达到查询效果最优。
-
-7. `disableCompression` 参数设置为 `false` 时查询效率降低
-
-  当 `disableCompression` 参数设置为 `false` 时查询结果会使用 `gzip` 压缩后传输，拿到数据后要先进行 `gzip` 解压。
-
-8. `go get` 命令无法获取包，或者获取包超时
-
-  设置 Go 代理 `go env -w GOPROXY=https://goproxy.cn,direct`。
-
-## 常用 API
-
-### database/sql API
-
-* `sql.Open(DRIVER_NAME string, dataSourceName string) *DB`
-
-  该 API 用来打开 DB，返回一个类型为 \*DB 的对象。
-
-:::info
-该 API 成功创建的时候，并没有做权限等检查，只有在真正执行 Query 或者 Exec 的时候才能真正的去创建连接，并同时检查 user/password/host/port 是不是合法。
-:::
-
-* `func (db *DB) Exec(query string, args ...interface{}) (Result, error)`
-
-  `sql.Open` 内置的方法，用来执行非查询相关 SQL。
-
-* `func (db *DB) Query(query string, args ...interface{}) (*Rows, error)`
-
-  `sql.Open` 内置的方法，用来执行查询语句。
-
-### 高级功能（af）API
-
-`af` 包封装了连接管理、订阅、schemaless、参数绑定等 TDengine 高级功能。
-
-#### 连接管理
-
-* `af.Open(host, user, pass, db string, port int) (*Connector, error)`
-
-  该 API 通过 cgo 创建与 taosd 的连接。
-
-* `func (conn *Connector) Close() error`
-
-  关闭与 taosd 的连接。
-
-#### 订阅
-
-* `func (conn *Connector) Subscribe(restart bool, topic string, sql string, interval time.Duration) (Subscriber, error)`
-
-  订阅数据。
-
-* `func (s *taosSubscriber) Consume() (driver.Rows, error)`
-
-  消费订阅数据，返回 `database/sql/driver` 包的 `Rows` 结构。
-
-* `func (s *taosSubscriber) Unsubscribe(keepProgress bool)`
-
-  取消订阅数据。
-
-#### schemaless
-
-* `func (conn *Connector) InfluxDBInsertLines(lines []string, precision string) error`
-
-  写入 influxDB 行协议。
-
-* `func (conn *Connector) OpenTSDBInsertTelnetLines(lines []string) error`
-
-  写入 OpenTDSB telnet 协议数据。
-
-* `func (conn *Connector) OpenTSDBInsertJsonPayload(payload string) error`
-
-  写入 OpenTSDB JSON 协议数据。
-
-#### 参数绑定
-
-* `func (conn *Connector) StmtExecute(sql string, params *param.Param) (res driver.Result, err error)`
-
-  参数绑定单行插入。
-
-* `func (conn *Connector) StmtQuery(sql string, params *param.Param) (rows driver.Rows, err error)`
-
-  参数绑定查询，返回 `database/sql/driver` 包的 `Rows` 结构。
-
-* `func (conn *Connector) InsertStmt() *insertstmt.InsertStmt`
-
-  初始化参数。
-
-* `func (stmt *InsertStmt) Prepare(sql string) error`
-
-  参数绑定预处理 SQL 语句。
-
-* `func (stmt *InsertStmt) SetTableName(name string) error`
-
-  参数绑定设置表名。
-
-* `func (stmt *InsertStmt) SetSubTableName(name string) error`
-
-  参数绑定设置子表名。
-
-* `func (stmt *InsertStmt) BindParam(params []*param.Param, bindType *param.ColumnType) error`
-
-  参数绑定多行数据。
-
-* `func (stmt *InsertStmt) AddBatch() error`
-
-  添加到参数绑定批处理。
-
-* `func (stmt *InsertStmt) Execute() error`
-
-  执行参数绑定。
-
-* `func (stmt *InsertStmt) GetAffectedRows() int`
-
-  获取参数绑定插入受影响行数。
-
-* `func (stmt *InsertStmt) Close() error`
-
-  结束参数绑定。
-
-## API 参考
-
-全部 API 见 [driver-go 文档](https://pkg.go.dev/github.com/taosdata/driver-go/v2)