Skip to content

T
TDengine

taosdata / TDengine
1 年多 前同步成功

通知 1185
Star 22016
Fork 4786
T
TDengine
提交 7a7e8072 编写于 作者: A Alex Duan
浏览文件
操作

feat(storage): merge develop to here [TS-238]

上级 d78d8d22 d27b25a6
展开全部 隐藏空白更改
内联 并排
Showing with 38055 addition and 34073 deletion
.circleci/config.yml 已删除 100644 → 0
浏览文件 @ d78d8d22
# Use the latest 2.1 version of CircleCI pipeline process engine. See: https://circleci.com/docs/2.0/configuration-reference
version: 2.1
# Use a package of configuration called an orb.
orbs:
# Declare a dependency on the welcome-orb
welcome: circleci/welcome-orb@0.4.1
# Orchestrate or schedule a set of jobs
workflows:
# Name the workflow "welcome"
welcome:
# Run the welcome/run job in its own container
jobs:
- welcome/run
.drone.yml 已删除 100644 → 0
浏览文件 @ d78d8d22
---
kind: pipeline
name: test_arm64_bionic
platform:
os: linux
arch: arm64
steps:
- name: build
image: arm64v8/ubuntu:bionic
commands:
- apt-get update
- apt-get install -y cmake git build-essential wget
- wget https://dl.google.com/go/go1.16.9.linux-arm64.tar.gz
- tar -C /usr/local -xzf go1.16.9.linux-arm64.tar.gz
- export PATH=$PATH:/usr/local/go/bin
- git submodule update --init --recursive
- mkdir debug
- cd debug
- cmake .. -DCPUTYPE=aarch64 > /dev/null
- make -j4
trigger:
event:
- pull_request
when:
branch:
- develop
- master
- 2.0
---
kind: pipeline
name: test_arm64_focal
platform:
os: linux
arch: arm64
steps:
- name: build
image: arm64v8/ubuntu:focal
commands:
- echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections
- apt-get update
- apt-get install -y -qq git cmake build-essential wget
- wget https://dl.google.com/go/go1.16.9.linux-arm64.tar.gz
- tar -C /usr/local -xzf go1.16.9.linux-arm64.tar.gz
- export PATH=$PATH:/usr/local/go/bin
- git submodule update --init --recursive
- mkdir debug
- cd debug
- cmake .. -DCPUTYPE=aarch64 > /dev/null
- make -j4
trigger:
event:
- pull_request
when:
branch:
- develop
- master
- 2.0
---
kind: pipeline
name: test_arm64_centos7
platform:
os: linux
arch: arm64
steps:
- name: build
image: arm64v8/centos:7
commands:
- yum install -y epel-release
- yum install -y gcc gcc-c++ make cmake3 wget git
- wget https://dl.google.com/go/go1.16.9.linux-arm64.tar.gz
- tar -C /usr/local -xzf go1.16.9.linux-arm64.tar.gz
- export PATH=$PATH:/usr/local/go/bin
- ln -s /usr/bin/cmake3 /usr/bin/cmake
- go version
- git submodule update --init --recursive
- mkdir debug
- cd debug
- cmake3 .. -DCPUTYPE=aarch64 > /dev/null
- make -j4
trigger:
event:
- pull_request
when:
branch:
- develop
- master
- 2.0
---
kind: pipeline
name: test_arm64_centos8
platform:
os: linux
arch: arm64
steps:
- name: build
image: arm64v8/centos:8
commands:
- dnf install -y gcc gcc-c++ make cmake epel-release git libarchive golang
- git submodule update --init --recursive
- mkdir debug
- cd debug
- cmake .. -DCPUTYPE=aarch64 > /dev/null
- make -j4
trigger:
event:
- pull_request
when:
branch:
- develop
- master
- 2.0
---
kind: pipeline
name: test_arm_bionic
platform:
os: linux
arch: arm
steps:
- name: build
image: arm32v7/ubuntu:bionic
commands:
- apt-get update
- apt-get install -y cmake build-essential golang-go git
- git submodule update --init --recursive
- mkdir debug
- cd debug
- cmake .. -DCPUTYPE=aarch32 > /dev/null
- make -j4
trigger:
event:
- pull_request
when:
branch:
- develop
- master
- 2.0
---
kind: pipeline
name: build_trusty
platform:
os: linux
arch: amd64
steps:
- name: build
image: ubuntu:trusty
commands:
- apt-get update
- apt-get install -y gcc cmake3 build-essential git binutils-2.26 wget
- wget https://dl.google.com/go/go1.16.9.linux-amd64.tar.gz
- tar -C /usr/local -xzf go1.16.9.linux-amd64.tar.gz
- export PATH=$PATH:/usr/local/go/bin
- git submodule update --init --recursive
- mkdir debug
- cd debug
- cmake ..
- make -j4
trigger:
event:
- pull_request
when:
branch:
- develop
- master
- 2.0
---
kind: pipeline
name: build_xenial
platform:
os: linux
arch: amd64
steps:
- name: build
image: ubuntu:xenial
commands:
- apt-get update
- apt-get install -y gcc cmake build-essential git wget
- wget https://dl.google.com/go/go1.16.9.linux-amd64.tar.gz
- tar -C /usr/local -xzf go1.16.9.linux-amd64.tar.gz
- export PATH=$PATH:/usr/local/go/bin
- git submodule update --init --recursive
- mkdir debug
- cd debug
- cmake ..
- make -j4
trigger:
event:
- pull_request
when:
branch:
- develop
- master
- 2.0
---
kind: pipeline
name: build_bionic
platform:
os: linux
arch: amd64
steps:
- name: build
image: ubuntu:bionic
commands:
- apt-get update
- apt-get install -y gcc cmake build-essential git wget
- wget https://dl.google.com/go/go1.16.9.linux-amd64.tar.gz
- tar -C /usr/local -xzf go1.16.9.linux-amd64.tar.gz
- export PATH=$PATH:/usr/local/go/bin
- git submodule update --init --recursive
- mkdir debug
- cd debug
- cmake ..
- make -j4
trigger:
event:
- pull_request
when:
branch:
- develop
- master
- 2.0
---
kind: pipeline
name: build_centos7
platform:
os: linux
arch: amd64
steps:
- name: build
image: ansible/centos7-ansible
commands:
- yum install -y epel-release
- yum install -y gcc gcc-c++ make cmake3 wget git
- wget https://dl.google.com/go/go1.16.9.linux-amd64.tar.gz
- tar -C /usr/local -xzf go1.16.9.linux-amd64.tar.gz
- export PATH=$PATH:/usr/local/go/bin
- ln -s /usr/bin/cmake3 /usr/bin/cmake
- git submodule update --init --recursive
- mkdir debug
- cd debug
- cmake3 ..
- make -j4
trigger:
event:
- pull_request
when:
branch:
- develop
- master
- 2.0
\ No newline at end of file
.gitmodules
浏览文件 @ 7a7e8072
......@@ -20,3 +20,9 @@
[submodule "examples/rust"]
path = examples/rust
url = https://github.com/songtianyi/tdengine-rust-bindings.git
[submodule "src/connector/php-tdengine"]
path = src/connector/php-tdengine
url = https://github.com/Yurunsoft/php-tdengine.git
[submodule "src/connector/php-tdengine-restful-connector"]
path = src/connector/php-tdengine-restful-connector
url = https://github.com/Yurunsoft/tdengine-restful-connector.git
Jenkinsfile
浏览文件 @ 7a7e8072
......@@ -116,7 +116,7 @@ def pre_test(){
make > /dev/null
make install > /dev/null
cd ${WKC}/tests
pip3 install ${WKC}/src/connector/python/
pip3 install taospy
'''
return 1
}
......
Jenkinsfile2
浏览文件 @ 7a7e8072
......@@ -21,21 +21,25 @@ def sync_source() {
if (env.CHANGE_TARGET == 'master') {
sh '''
cd ${WKC}
git clean -fxd
git checkout master
'''
} else if (env.CHANGE_TARGET == '2.0') {
sh '''
cd ${WKC}
git clean -fxd
git checkout 2.0
'''
} else if (env.CHANGE_TARGET == '2.4') {
sh '''
cd ${WKC}
git clean -fxd
git checkout 2.4
'''
} else {
sh '''
cd ${WKC}
git clean -fxd
git checkout develop
'''
}
......@@ -83,6 +87,16 @@ 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
'''
} else if (env.CHANGE_URL =~ /\/TDinternal\//) {
sh '''
......@@ -90,6 +104,16 @@ 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
'''
} else {
sh '''
......
README-CN.md
浏览文件 @ 7a7e8072
......@@ -23,13 +23,13 @@ TDengine 是一款高性能、分布式、支持 SQL 的时序数据库。而且
- **零管理**：安装、集群几秒搞定，无任何依赖，不用分库分表，系统运行状态监测能与 Grafana 或其他运维工具无缝集成。
- **零学习成本**：采用 SQL 查询语言，支持 Python, Java, C/C++, Go, Rust, Node.js 等多种编程语言,与 MySQL 相似，零学习成本。
- **零学习成本**：采用 SQL 查询语言，支持 Python、Java、C/C++、Go、Rust、Node.js 等多种编程语言，与 MySQL 相似，零学习成本。
- **无缝集成**：不用一行代码，即可与 Telegraf, Grafana, EMQ X, Prometheus, StatsD, collectd, Matlab, R 等第三方工具无缝集成。
- **无缝集成**：不用一行代码，即可与 Telegraf、Grafana、EMQX、Prometheus、StatsD、collectd、Matlab、R 等第三方工具无缝集成。
- **互动 Console**: 通过命令行 console，不用编程，执行 SQL 语句就能做即席查询、各种数据库的操作、管理以及集群的维护.
TDengine 可以广泛应用于物联网、工业互联网、车联网、IT 运维、能源、金融等领域, 让大量设备、数据采集器每天产生的高达 TB 甚至 PB 级的数据能得到高效实时的处理，对业务的运行状态进行实时的监测、预警，从大数据中挖掘出商业价值。
TDengine 可以广泛应用于物联网、工业互联网、车联网、IT 运维、能源、金融等领域，让大量设备、数据采集器每天产生的高达 TB 甚至 PB 级的数据能得到高效实时的处理，对业务的运行状态进行实时的监测、预警，从大数据中挖掘出商业价值。
# 文档
......@@ -272,12 +272,12 @@ taos
在 TDengine 终端中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行插入查询操作。
```bash
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;
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 |
===================================
19-07-15 00:00:00.000| 10|
......
README.md
浏览文件 @ 7a7e8072
......@@ -21,7 +21,7 @@ TDengine is a high-performance, scalable time-series database with SQL support.
- **All in One**: TDengine has built-in caching, stream processing and data subscription functions, it is no longer necessary to integrate Kafka/Redis/HBase/Spark or other software in some scenarios. It makes the system architecture much simpler and easy to maintain.
- **Seamless Integration**: Without a single line of code, TDengine provide seamless integration with third-party tools such as Telegraf, Grafana, EMQ X, Prometheus, StatsD, collectd, etc. More will be integrated.
- **Seamless Integration**: Without a single line of code, TDengine provide seamless integration with third-party tools such as Telegraf, Grafana, EMQX, Prometheus, StatsD, collectd, etc. More will be integrated.
- **Zero Management**: Installation and cluster setup can be done in seconds. Data partitioning and sharding are executed automatically. TDengine’s running status can be monitored via Grafana or other DevOps tools.
......
alert/app/rule.go
浏览文件 @ 7a7e8072
......@@ -96,6 +96,7 @@ func (alert *Alert) doRefresh(firing bool, rule *Rule) bool {
case (!firing) && (alert.State == AlertStateFiring):
alert.State = AlertStateWaiting
alert.EndsAt = time.Now()
return false
case firing && (alert.State == AlertStateWaiting):
alert.StartsAt = time.Now()
......
cmake/define.inc
浏览文件 @ 7a7e8072
......@@ -287,9 +287,17 @@ IF (TD_LINUX)
SET(COMMON_FLAGS "${COMMON_FLAGS} -pipe -Wshadow")
ENDIF ()
MESSAGE(STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID})
IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
EXECUTE_PROCESS( COMMAND ${CMAKE_CXX_COMPILER} --version OUTPUT_VARIABLE clang_full_version_string )
string (REGEX REPLACE ".*clang version ([0-9]+\\.[0-9]+).*" "\\1" CLANG_VERSION_STRING ${clang_full_version_string})
IF (CLANG_VERSION_STRING GREATER_EQUAL 13.0)
SET(COMMON_FLAGS "${COMMON_FLAGS} -Wno-unused-but-set-variable")
ENDIF ()
ENDIF ()
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
MESSAGE(STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID})
cmake/install.inc
浏览文件 @ 7a7e8072
......@@ -20,7 +20,7 @@ ELSEIF (TD_WINDOWS)
INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)
IF (TD_MVN_INSTALLED)
INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.37-dist.jar DESTINATION connector/jdbc)
INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.38-dist.jar DESTINATION connector/jdbc)
ENDIF ()
ELSEIF (TD_DARWIN)
SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")
......
docs-cn/01-intro/01-intro.md 0 → 100644
浏览文件 @ 7a7e8072
---
sidebar_label: 产品简介
title: 产品简介
toc_max_heading_level: 2
---
## TDengine 简介
TDengine 是一款高性能、分布式、支持 SQL 的时序数据库。而且除时序数据库功能外，它还提供缓存、数据订阅、流式计算等功能，最大程度减少研发和运维的复杂度，且核心代码，包括集群功能全部开源（开源协议，AGPL v3.0）。与其他时序数据数据库相比，TDengine 有以下特点：
- **高性能**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，而且存储空间也大为节省。
- **分布式**：通过原生分布式的设计，TDengine 提供了水平扩展的能力，只需要增加节点就能获得更强的数据处理能力，同时通过多副本机制保证了系统的高可用。
- **支持 SQL**：TDengine 采用 SQL 作为数据查询语言，减少学习和迁移成本，同时提供 SQL 扩展来处理时序数据特有的分析，而且支持方便灵活的 schemaless 数据写入。
- **All in One**：将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低应用开发和维护成本。
- **零管理**：安装、集群几秒搞定，无任何依赖，不用分库分表，系统运行状态监测能与 Grafana 或其他运维工具无缝集成。
- **零学习成本**：采用 SQL 查询语言，支持 Python, Java, C/C++, Go, Rust, Node.js 等多种编程语言,与 MySQL 相似，零学习成本。
- **无缝集成**：不用一行代码，即可与 Telegraf, Grafana, EMQX, Prometheus, StatsD, collectd, Matlab, R 等第三方工具无缝集成。
- **互动 Console**: 通过命令行 console，不用编程，执行 SQL 语句就能做即席查询、各种数据库的操作、管理以及集群的维护.
采用 TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM 等通用型数据。
![TDengine技术生态图](eco_system.png)
<center>图 1. TDengine技术生态图</center>
## TDengine 总体适用场景
作为一个 IoT 大数据平台，TDengine 的典型适用场景是在 IoT 范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如 CRM，ERP 等，不在本文讨论范围内。
### 数据源特点和需求
从数据源角度，设计人员可以从下面几个角度分析 TDengine 在目标应用系统里面的适用性。
| 数据源特点和需求 | 不适用 | 可能适用 | 非常适用 | 简单说明 |
| ---------------------------- | ------ | -------- | -------- | ------------------------------------------------------------------------------------------------------------------------------- |
| 总体数据量巨大 | | | √ | TDengine 在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构，达到业界最优的存储效率。 |
| 数据输入速度偶尔或者持续巨大 | | | √ | TDengine 的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。 |
| 数据源数目巨大 | | | √ | TDengine 设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。 |
### 系统架构要求
| 系统架构要求 | 不适用 | 可能适用 | 非常适用 | 简单说明 |
| ---------------------- | ------ | -------- | -------- | ----------------------------------------------------------------------------------------------------- |
| 要求简单可靠的系统架构 | | | √ | TDengine 的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。 |
| 要求容错和高可靠 | | | √ | TDengine 的集群功能，自动提供容错灾备等高可靠功能。 |
| 标准化规范 | | | √ | TDengine 使用标准的 SQL 语言提供主要功能，遵守标准化规范。 |
### 系统功能需求
| 系统功能需求 | 不适用 | 可能适用 | 非常适用 | 简单说明 |
| -------------------------- | ------ | -------- | -------- | --------------------------------------------------------------------------------------------------------------------- |
| 要求完整的内置数据处理算法 | | √ | | TDengine 的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。 |
| 需要大量的交叉查询处理 | | √ | | 这种类型的处理更多应该用关系型数据系统处理，或者应该考虑 TDengine 和关系型数据系统配合实现系统功能。 |
### 系统性能需求
| 系统性能需求 | 不适用 | 可能适用 | 非常适用 | 简单说明 |
| ---------------------- | ------ | -------- | -------- | ------------------------------------------------------------------------------------------------------ |
| 要求较大的总体处理能力 | | | √ | TDengine 的集群功能可以轻松地让多服务器配合达成处理能力的提升。 |
| 要求高速处理数据 | | | √ | TDengine 的专门为 IoT 优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。 |
| 要求快速处理小粒度数据 | | | √ | 这方面 TDengine 性能可以完全对标关系型和 NoSQL 型数据处理系统。 |
### 系统维护需求
| 系统维护需求 | 不适用 | 可能适用 | 非常适用 | 简单说明 |
| ---------------------- | ------ | -------- | -------- | --------------------------------------------------------------------------------------------------------------------- |
| 要求系统可靠运行 | | | √ | TDengine 的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。 |
| 要求运维学习成本可控 | | | √ | 同上。 |
| 要求市场有大量人才储备 | √ | | | 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 与 InfluxDB 对比测试](https://www.taosdata.com/blog/2019/07/19/419.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/02-concept/02-concept.md 0 → 100644
浏览文件 @ 7a7e8072
---
title: 基本概念
---
## 物联网典型场景
在典型的物联网、车联网、运维监测场景中，往往有多种不同类型的数据采集设备，采集一个到多个不同的物理量。而同一种采集设备类型，往往又有多个具体的采集设备分布在不同的地点。大数据处理系统就是要将各种采集的数据汇总，然后进行计算和分析。对于同一类设备，其采集的数据类似如下的表格：
| Device ID | Time Stamp | Value 1 | Value 2 | Value 3 | Tag 1 | Tag 2 |
| :-------: | :-----------: | :-----: | :-----: | :-----: | :---: | :---: |
| D1001 | 1538548685000 | 10.3 | 219 | 0.31 | Red | Tesla |
| D1002 | 1538548684000 | 10.2 | 220 | 0.23 | Blue | BMW |
| D1003 | 1538548686500 | 11.5 | 221 | 0.35 | Black | Honda |
| D1004 | 1538548685500 | 13.4 | 223 | 0.29 | Red | Volvo |
| D1001 | 1538548695000 | 12.6 | 218 | 0.33 | Red | Tesla |
| D1004 | 1538548696600 | 11.8 | 221 | 0.28 | Black | Honda |
每一条记录都有设备 ID，时间戳，采集的物理量，还有与每个设备相关的静态标签。每个设备是受外界的触发，或按照设定的周期采集数据。采集的数据点是时序的，是一个数据流。
**数据特征**
除时序特征外，仔细研究发现，物联网、车联网、运维监测类数据还具有很多其他明显的特征。
1. 数据是结构化的；
2. 数据极少有更新或删除操作；
3. 无需传统数据库的事务处理；
4. 相对互联网应用，写多读少；
5. 流量平稳，根据设备数量和采集频次，可以预测出来；
6. 用户关注的是一段时间的趋势，而不是某一特点时间点的值；
7. 数据是有保留期限的；
8. 数据的查询分析一定是基于时间段和地理区域的；
9. 除存储查询外，还往往需要各种统计和实时计算操作；
10. 数据量巨大，一天采集的数据就可以超过 100 亿条。
充分利用上述特征，TDengine 采取了一特殊的优化的存储和计算设计来处理时序数据，能将系统处理能力显著提高。
## 数据采集点
持续按照预设频率生成数据的软件或硬件设备称为数据采集点。TDengine中推荐一个数据采集点生成的数据存储在对应的一个或若干个表中。采集点产生的数据通常是包括时间戳、测量值、标签等必要信息构成的元组。
## 采集量
数据采集点生成的具有时间、测量值、标签的元组信息。除了时间戳、标签信息以外的测量值称为采集量。
## 标签
表的结构化描述信息，以一维数组形式存在。标签模式需要在创建超级表的时候指定，后续可动态调整。只有基于超级表创建的子表才具有标签。标签信息的内容首次创建子表的时候指定，并可按需调整。可以看到，TDengine中标签信息是表级别，而不是记录级别。
## 数据库
TDengine中数据库与普通数据库管理系统中的数据库语义和行为相同，但是结合应用需求增加了若干配置参数用以控制其行为。
## 超级表
超级表（Super Table, STable）是TDengine中一个重要的概念。超级表是面向相同数据模式的数据表，提供（数据+标签）模式管理和查询处理的逻辑抽象。通常将基于超级表创建的表称为该超级表的子表，并在系统内部建立逻辑关联。超级表与（基于其创建的）子表的关系体现在以下几个方面：
超级表的子表共享其数据模式和标签模式。因此，不能通过子表调整数据或标签的模式。对于超级表的数据模式修改立即对所有的子表生效。
超级表自身不能存储任何数据或标签信息。因此，不能向一个超级表写入数据，只能将数据写入子表中。
针对超级表的查询，将所有子表中的数据视为一个整体数据集进行处理。但是可以直接发起针对某个或若干个子表的查询，此时查询请求将该子表视为一个普通的表进行处理。
## 表
一系列二维数组的集合，用来代表和储存数据对象之间的关系，由纵向的列和横向的行组成。TDengine中的表与普通数据库中的表没有差别。
但是，对于通过超级表创建的子表，还具有额外的标签数据信息。不能针对某个子表调整数据模式。每个子表具有与其关联的标签数据，并可按需调整内容。但是模式调整必须要通过超级表模式调整来完成。
使用TDengine存储和管理物联网数据的时候，推荐使用一个子表存储一个数据采集点生成的数据，而使用超级表用来代表一组相同类型的数据采集点的集合。
docs-cn/02-concept/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
label: 基本概念
\ No newline at end of file
docs-cn/03-get-started/03-get-started.md 0 → 100644
浏览文件 @ 7a7e8072
---
title: 立即开始
---
## 从 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 <containrid> bash
```
然后就可以执行相关的 Linux 命令操作和访问 TDengine
详细操作方法请参照 [通过 Docker 快速体验 TDengine](/train-fqa/docker)。
:::info
从 2.4.0.10 开始，除 taosd 以外，Docker 镜像还包含：taos、taosAdapter、taosdump、taosBenchmark、TDinsight 安装脚本和示例代码。启动 Docker 容器时，将同时启动 taosAdapter 和 taosd，实现对 RESTful 的支持。
:::
:::note
暂时不建议生产环境采用 Docker 来部署 TDengine 的客户端或服务端，但在开发环境下或初次尝试时，使用 Docker 方式部署是十分方便的。特别是，利用 Docker，可以方便地在 macOS 和 Windows 环境下尝试 TDengine。
:::
## 安装
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
import PkgInstall from "./\_pkg_install.mdx";
import AptGetInstall from "./\_apt_get_install.mdx";
import SrcInstall from "./\_src_install.mdx";
TDengine 包括服务端、客户端和周边生态工具软件，目前 2.0 版服务端仅在 Linux 系统上安装和运行，后续将支持 Windows、macOS 等系统。客户端可以在 Windows 或 Linux 上安装和运行。在任何操作系统上的应用都可以使用 RESTful 接口连接服务端程序 taosd，其中 2.4 之后版本默认使用单独运行的独立组件 taosAdapter 提供 http 服务和更多数据写入方式。taosAdapter 需要手动启动。
之前版本 TDengine 服务端，以及所有服务端 lite 版，均使用内置 http 服务。
TDengine 支持 X64/ARM64/MIPS64/Alpha64 硬件平台，后续将支持 ARM32、RISC-V 等 CPU 架构。
<Tabs defaultValue="apt-get">
<TabItem value="apt-get" label="apt-get">
<AptGetInstall />
</TabItem>
<TabItem value="pkg" label="安装包">
<PkgInstall />
</TabItem>
<TabItem value="src" label="源码">
<SrcInstall />
</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 的服务器配置好 hostname，在客户端应用运行的机器配置好 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 客户端程序，您只要在 Linux 终端执行 `taos` 即可。
```bash
taos
```
如果连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考 [FAQ](/train-fqa/faq) 来解决终端连接服务端失败的问题）。客户端的提示符号如下：
```cmd
taos>
```
在 TDengine 客户端中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行插入查询操作。在终端中运行的 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 客户端进行检查系统运行状态、添加删除用户账号等操作。
## 命令行参数
您可通过配置命令行参数来改变 TDengine 客户端的行为。以下为常用的几个命令行参数：
- -c, --config-dir: 指定配置文件目录，默认为 `/etc/taos`
- -h, --host: 指定服务的 FQDN 地址或 IP 地址，默认为连接本地服务
- -s, --commands: 在不进入终端的情况下运行 TDengine 命令
- -u, --user: 连接 TDengine 服务端的用户名，缺省为 root
- -p, --password: 连接 TDengine 服务端的密码，缺省为 taosdata
- -?, --help: 打印出所有命令行参数
示例：
```bash
taos -h h1.taos.com -s "use db; show tables;"
```
## 运行 SQL 命令脚本
TDengine 终端可以通过 `source` 命令来运行 SQL 命令脚本。
```sql
taos> source <filename>;
```
## taos shell 小技巧
- 可以使用上下光标键查看历史输入的指令
- 修改用户密码：在 shell 中使用 `alter user` 命令，缺省密码为 taosdata
- ctrl+c 中止正在进行中的查询
- 执行 `RESET QUERY CACHE` 可清除本地缓存的表 schema
- 批量执行 SQL 语句。可以将一系列的 shell 命令（以英文 ; 结尾，每个 SQL 语句为一行）按行存放在文件里，在 shell 里执行命令 `source <file-name>` 自动执行该文件里所有的 SQL 语句
- 输入 q 回车，退出 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 被设置为 "beijing" 或者 "shanghai"。
这条命令很快完成 1 亿条记录的插入。具体时间取决于硬件性能，即使在一台普通的 PC 服务器往往也仅需十几秒。
## taosBenchmark 详细功能列表
taosBenchmark 命令本身带有很多选项，配置表的数目、记录条数等等，请执行 `taosBenchmark --help` 详细列出。您可以设置不同参数进行体验。
taosBenchmark 详细使用方法请参照 [如何使用 taosBenchmark 对 TDengine 进行性能测试](https://www.taosdata.com/2021/10/09/3111.html)。
## 使用 taos shell 体验查询速度
在 TDengine 客户端输入查询命令，体验查询速度。
查询超级表下记录总条数：
```sql
taos> select count(*) from test.meters;
```
查询 1 亿条记录的平均值、最大值、最小值等：
```sql
taos> select avg(current), max(voltage), min(phase) from test.meters;
```
查询 location="beijing" 的记录总条数：
```sql
taos> select count(*) from test.meters where location="beijing";
```
查询 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/03-get-started/_apt_get_install.mdx 0 → 100644
浏览文件 @ 7a7e8072
如果，可以使用 apt-get 工具从官方仓库安装。
**安装包仓库**
```
wget -qO - http://repos.taosdata.com/tdengine.key | sudo apt-key add -
echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-stable stable main" | sudo tee /etc/apt/sources.list.d/tdengine-stable.list
```
如果安装 Beta 版需要安装包仓库
```
echo "deb [arch=amd64] http://repos.taosdata.com/tdengine-beta beta main" | sudo tee /etc/apt/sources.list.d/tdengine-beta.list
```
**使用 apt-get 命令安装**
```
sudo apt-get update
apt-cache policy tdengine
sudo apt-get install tdengine
```
:::tip
apt-get 方式只适用于 Debian 或 Ubuntu 系统
::::
docs-cn/03-get-started/_pkg_install.mdx 0 → 100644
浏览文件 @ 7a7e8072
import PkgList from "./_pkg_list.mdx";
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 />
具体的安装方法，请参见 [安装包的安装和卸载](/operation/pkg-install) 以及 [视频教程](https://www.taosdata.com/blog/2020/11/11/1941.html)。
docs-cn/03-get-started/_pkg_list.mdx 0 → 100644
浏览文件 @ 7a7e8072
**最新安装包**
<ul id="server-packageList" className="package-list">
<li>
<a id="tdengine_rpm" name="TDengine RPM">
TDengine-server-2.4.0.12-Linux-x64.rpm (14.5 M)
</a>
</li>
<li>
<a id="tdengine_deb" name="TDengine DEB">
TDengine-server-2.4.0.12-Linux-x64.deb (12.8 M)
</a>
</li>
<li>
<a id="tdengine_tar" name="TDengine Tarball">
TDengine-server-2.4.0.12-Linux-x64.tar.gz (15.5 M)
</a>
</li>
<li>
<a id="tdengine_Lite_tar" name="undefined">
TDengine-server-2.4.0.12-Linux-x64-Lite.tar.gz (3.4 M)
</a>
</li>
<li>
<a id="tdengine_Lite_beta_tar" name="TDengine Lite Beta Tarball">
TDengine-server-2.3.5.0-beta-Linux-x64-Lite.tar.gz (3 M)
</a>
</li>
<li>
<a id="tdengine_beta_rpm" name="TDengine Beta RPM">
TDengine-server-2.3.5.0-beta-Linux-x64.rpm (18.4 M)
</a>
</li>
<li>
<a id="tdengine_beta_deb" name="TDengine Beta DEB">
TDengine-server-2.3.5.0-beta-Linux-x64.deb (16.8 M)
</a>
</li>
<li>
<a id="tdengine_beta_tar" name="TDengine Beta Tarball">
TDengine-server-2.3.5.0-beta-Linux-x64.tar.gz (18.8 M)
</a>
</li>
</ul>
**所有下载**
https://www.taosdata.com/all-downloads
docs-cn/03-get-started/_src_install.mdx 0 → 100644
浏览文件 @ 7a7e8072
如果您希望对 TDengine 贡献代码或对内部实现感兴趣，请参考我们的 [TDengine GitHub 主页](https://github.com/taosdata/TDengine) 下载源码构建和安装.
下载其他组件、最新 Beta 版及之前版本的安装包，请点击[这里](https://www.taosdata.com/cn/all-downloads/)。
docs-cn/04-connect/_connect_c.mdx 0 → 100644
浏览文件 @ 7a7e8072
```c
{{#include docs-examples/c/connect_example.c}}
```
docs-cn/04-connect/_connect_cs_native.mdx 0 → 100644
浏览文件 @ 7a7e8072
首先添加 [TDengine.Connector](https://www.nuget.org/packages/TDengine.Connector/) 的引用：
```xml title=csharp.csproj
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<StartupObject>TDengineExample.ConnectExample</StartupObject>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="TDengine.Connector" Version="1.0.6" />
</ItemGroup>
</Project>
```
```csharp
{{#include docs-examples/csharp/ConnectExample.cs}}
```
docs-cn/04-connect/_connect_go.mdx 0 → 100644
浏览文件 @ 7a7e8072
```go-mod title=go.mod
module goexample
go 1.17
require github.com/taosdata/driver-go/v2 develop
```
```go
{{#include docs-examples/go/connect/restexample/main.go}}
```
docs-cn/04-connect/_connect_go_native.mdx 0 → 100644
浏览文件 @ 7a7e8072
:::note
driver-go 使用 cgo 封装了 taosc 的 API。cgo 需要使用 gcc 编译 C 的源码。因此需要确保你的系统上有 gcc。
:::
```go-mod title=go.mod
module goexample
go 1.17
require github.com/taosdata/driver-go/v2 develop
```
```go title="使用 database/sql 包建立连接"
{{#include docs-examples/go/connect/cgoexample/main.go}}
```
也可以使用 driver-go 的 af 包建立连接。这个模块封装了 TDengine 的高级功能, 如：动态绑定、订阅等。
```go title="使用 af 包建立连接"
{{#include docs-examples/go/connect/afconn/main.go}}
```
docs-cn/04-connect/_connect_java.mdx 0 → 100644
浏览文件 @ 7a7e8072
```xml title=pom.xml
<dependency>
<groupId>com.taosdata.jdbc</groupId>
<artifactId>taos-jdbcdriver</artifactId>
<version>2.0.37</version>
</dependency>
```
```java
{{#include docs-examples/java/src/main/java/com/taos/example/RESTConnectExample.java}}
```
docs-cn/04-connect/_connect_java_native.mdx 0 → 100644
浏览文件 @ 7a7e8072
```xml title=pom.xml
<dependency>
<groupId>com.taosdata.jdbc</groupId>
<artifactId>taos-jdbcdriver</artifactId>
<version>2.0.37</version>
</dependency>
```
```java
{{#include docs-examples/java/src/main/java/com/taos/example/JNIConnectExample.java}}
```
docs-cn/04-connect/_connect_node_native.mdx 0 → 100644
浏览文件 @ 7a7e8072
首先需要安装 node.js 的连接器 `td2.0-connector`：
```bash
npm install td2.0-connector
```
:::note
推荐Node版本大于等于 `node-v12.8.0` 小于 `node-v13.0.0`
:::
```js
{{#include docs-examples/node/nativeexample/connect.js}}
```
docs-cn/04-connect/_connect_python_native.mdx 0 → 100644
浏览文件 @ 7a7e8072
推荐使用 `python >= 3.4`。首先需要安装 python 连接器 `taospy`。执行以下命令即可：
```
pip3 install taospy
```
```python
{{#include docs-examples/python/connect_exmaple.py}}
```
docs-cn/04-connect/_connect_restful.mdx 0 → 100644
浏览文件 @ 7a7e8072
下面用 curl 工具来演示访问 RESTful 接口。在命令行执行下面的命令：
```bash
curl http://localhost:6041/rest/sql -u root:taosdata -d "select server_version()"
```
- `-u` 用于指定访问数据库的用户名和密码。
- `-d` 用于指定发送要执行的 SQL 语句。它会被放入 POST 请求的 Body 中。
如果正常，会返回一个 JSON 字符串，里面包含了服务端的版本。例如：
```json
{
"status": "succ",
"head": ["server_version()"],
"column_meta": [["server_version()", 8, 7]],
"data": [["2.4.0.0"]],
"rows": 1
}
```
了解更多：[RESTful API](/reference/restful-api)。
docs-cn/04-connect/_connect_rust.mdx 0 → 100644
浏览文件 @ 7a7e8072
```toml title=Cargo.toml
[dependencies]
libtaos = { version = "*", features = ["rest"] }
```
```rust
{{#include docs-examples/rust/restexample/examples/connect.rs}}
```
docs-cn/04-connect/_connect_rust_native.mdx 0 → 100644
浏览文件 @ 7a7e8072
```toml title=Cargo.toml
[dependencies]
libtaos = { version = "0.4.2"}
```
```rust
{{#include docs-examples/rust/nativeexample/examples/connect.rs}}
```
docs-cn/04-connect/index.mdx 0 → 100644
浏览文件 @ 7a7e8072
---
title: 建立连接
---
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
import ConnRest from "./_connect_restful.mdx";
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 ConnJavaNative from "./_connect_java_native.mdx";
import ConnPythonNative from "./_connect_python_native.mdx";
import ConnGoNative from "./_connect_go_native.mdx";
import ConnRustNative from "./_connect_rust_native.mdx";
import ConnNodeNative from "./_connect_node_native.mdx";
import ConnCSNative from "./_connect_cs_native.mdx";
import ConnC from "./_connect_c.mdx";
## 连接器介绍
TDengine 提供了丰富的应用程序开发接口，其中包括 C/C++、Java、Python、Go、Node.js、C# 、RESTful 等，便于用户快速开发应用。
![image-connecotr](/img/connector.png)
<center>(图：连接器工作原理)</center>
TDengine 提供了 RESTful 接口，应用程序无需安装任何依赖，只需发送 HTTP 请求就可以连接到 TDengine。同时也提供了各语言的连接器，使用驱动程序 (taosc) 连接 TDengine。通过驱动程序可以使用 TDengine 更丰富的功能。
## 前提条件
在执行这一步之前，请确保有一个正在运行的，且可以访问到的 TDengine。以下所有示例代码，都假设 TDengine 安装在本机，且 fqdn（默认 localhost） 和 serverPort（默认 6030） 都使用默认配置。
## 建立连接
### RESTful
如果你安装的是 TDengine 2.4 之后的版本，使用 RESTful 方式连接时还需启动 taosAdaper。
<Tabs groupId="lang">
<TabItem label="curl" value="">
<ConnRest />
</TabItem>
<TabItem label="Java" value="java">
<ConnJava />
</TabItem>
<TabItem label="Go" value="go">
<ConnGo />
</TabItem>
<TabItem label="Rust" value="rust">
<ConnRust />
</TabItem>
<TabItem label="Node.js" value="node">
<ConnNode />
</TabItem>
</Tabs>
### 本地驱动
在没有安装 TDengine 服务端软件的系统上使用本地驱动连接 TDengine, 需要提前[安装客户端驱动程序](/reference/connector/#安装客户端驱动)。
:::note
需要单独安装客户端时，为避免客户端驱动和服务端不兼容，请尽量使用一致的版本。
:::
<Tabs groupId="lang" defaultValue="java">
<TabItem label="Java" value="java">
<ConnJavaNative />
</TabItem>
<TabItem label="Python" value="python">
<ConnPythonNative />
</TabItem>
<TabItem label="Go" value="go">
<ConnGoNative />
</TabItem>
<TabItem label="Rust" value="rust">
<ConnRustNative />
</TabItem>
<TabItem label="Node.js" value="node">
<ConnNodeNative />
</TabItem>
<TabItem label="C#" value="csharp">
<ConnCSNative />
</TabItem>
<TabItem label="C" value="c">
<ConnC />
</TabItem>
</Tabs>
docs-cn/05-model/index.mdx 0 → 100644
浏览文件 @ 7a7e8072
---
slug: /model
title: TDengine 数据建模
---
TDengine 采用关系型数据模型，需要建库、建表。因此对于一个具体的应用场景，需要考虑库、超级表和普通表的设计。本节不讨论细致的语法规则，只介绍概念。
关于数据建模请参考[视频教程](https://www.taosdata.com/blog/2020/11/11/1945.html)。
## 创建库
不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为了在各种场景下 TDengine 都能最大效率的工作，TDengine 建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除 SQL 标准的选项外，应用还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
```sql
CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 6 UPDATE 1;
```
上述语句将创建一个名为 power 的库，这个库的数据将保留 365 天（超过 365 天将被自动删除），每 10 天一个数据文件，内存块数为 6，允许更新数据。详细的语法及参数请见 [数据库管理](/reference/taos-sql/database) 章节。
创建库之后，需要使用 SQL 命令 `USE` 将当前库切换过来，例如：
```sql
USE power;
```
将当前连接里操作的库换为 power，否则对具体表操作前，需要使用“库名.表名”来指定库的名字。
:::note
- 任何一张表或超级表是属于一个库的，在创建表之前，必须先创建库。
- 处于两个不同库的表是不能进行 JOIN 操作的。
- 创建并插入记录、查询历史记录的时候，均需要指定时间戳。
:::
## 创建超级表
一个物联网系统，往往存在多种类型的设备，比如对于电网，存在智能电表、变压器、母线、开关等等。为便于多表之间的聚合，使用 TDengine, 需要对每个类型的数据采集点创建一个超级表。以[表 1](/tdinternal/arch#model_table1) 中的智能电表为例，可以使用如下的 SQL 命令创建超级表：
```sql
CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);
```
:::note
这一指令中的 STABLE 关键字，在 2.0.15 之前的版本中需写作 TABLE 。
:::
与创建普通表一样，创建表时，需要提供表名（示例中为 meters），表结构 Schema，即数据列的定义。第一列必须为时间戳（示例中为 ts)，其他列为采集的物理量（示例中为 current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的 schema (示例中为 location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组 ID、管理员 ID 等等。标签的 schema 可以事后增加、删除、修改。具体定义以及细节请见 [TAOS SQL 的超级表管理](/reference/taos-sql/stable) 章节。
每一种类型的数据采集点需要建立一个超级表，因此一个物联网系统，往往会有多个超级表。对于电网，我们就需要对智能电表、变压器、母线、开关等都建立一个超级表。在物联网中，一个设备就可能有多个数据采集点（比如一台风力发电的风机，有的采集点采集电流、电压等电参数，有的采集点采集温度、湿度、风向等环境参数），这个时候，对这一类型的设备，需要建立多张超级表。一张超级表里包含的采集物理量必须是同时采集的（时间戳是一致的）。
一张超级表最多容许 1024 列，如果一个采集点采集的物理量个数超过 1024，需要建多张超级表来处理。一个系统可以有多个 DB，一个 DB 里可以有一到多个超级表。（从 2.1.7.0 版本开始，列数限制由 1024 列放宽到了 4096 列。）
## 创建表
TDengine 对每个数据采集点需要独立建表。与标准的关系型数据库一样，一张表有表名，Schema，但除此之外，还可以带有一到多个标签。创建时，需要使用超级表做模板，同时指定标签的具体值。以[表 1](/tdinternal/arch#model_table1)中的智能电表为例，可以使用如下的 SQL 命令建表：
```sql
CREATE TABLE d1001 USING meters TAGS ("Beijing.Chaoyang", 2);
```
其中 d1001 是表名，meters 是超级表的表名，后面紧跟标签 Location 的具体标签值 ”Beijing.Chaoyang"，标签 groupId 的具体标签值 2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 [TAOS SQL 的表管理](/reference/taos-sql/table) 章节。
:::warning
目前 TDengine 没有从技术层面限制使用一个 database (dbA)的超级表作为模板建立另一个 database (dbB)的子表，后续会禁止这种用法，不建议使用这种方法建表。
:::
TDengine 建议将数据采集点的全局唯一 ID 作为表名(比如设备序列号）。但对于有的场景，并没有唯一的 ID，可以将多个 ID 组合成一个唯一的 ID。不建议将具有唯一性的 ID 作为标签值。
### 自动建表
在某些特殊场景中，用户在写数据时并不确定某个数据采集点的表是否存在，此时可在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。比如：
```sql
INSERT INTO d1001 USING meters TAGS ("Beijng.Chaoyang", 2) VALUES (now, 10.2, 219, 0.32);
```
上述 SQL 语句将记录`(now, 10.2, 219, 0.32)`插入表 d1001。如果表 d1001 还未创建，则使用超级表 meters 做模板自动创建，同时打上标签值 `"Beijing.Chaoyang", 2`。
关于自动建表的详细语法请参见 [插入记录时自动建表](reference/taos-sql/insert#插入记录时自动建表) 章节。
## 多列模型 vs 单列模型
TDengine 支持多列模型，只要物理量是一个数据采集点同时采集的（时间戳一致），这些量就可以作为不同列放在一张超级表里。但还有一种极限的设计，单列模型，每个采集的物理量都单独建表，因此每种类型的物理量都单独建立一超级表。比如电流、电压、相位，就建三张超级表。
TDengine 建议尽可能采用多列模型，因为插入效率以及存储效率更高。但对于有些场景，一个采集点的采集量的种类经常变化，这个时候，如果采用多列模型，就需要频繁修改超级表的结构定义，让应用变的复杂，这个时候，采用单列模型会显得更简单。
docs-cn/06-insert-data/01-sql-writing.mdx 0 → 100644
浏览文件 @ 7a7e8072
---
title: SQL 写入
---
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
import JavaSQL from "./_java_sql.mdx";
import JavaStmt from "./_java_stmt.mdx";
import PySQL from "./_py_sql.mdx";
import PyStmt from "./_py_stmt.mdx";
import GoSQL from "./_go_sql.mdx";
import GoStmt from "./_go_stmt.mdx";
import RustSQL from "./_rust_sql.mdx";
import RustStmt from "./_rust_stmt.mdx";
import NodeSQL from "./_js_sql.mdx";
import NodeStmt from "./_js_stmt.mdx";
import CsSQL from "./_cs_sql.mdx";
import CsStmt from "./_cs_stmt.mdx";
import CSQL from "./_c_sql.mdx";
import CStmt from "./_c_stmt.mdx";
## SQL 写入
应用通过连接器执行 insert 语句来插入数据，用户还可以通过 TAOS Shell，手动输入 insert 语句插入数据。比如下面这条 insert 就将一条记录写入到表 d1001 中：
```sql
INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31);
```
TDengine 支持一次写入多条记录，比如下面这条命令就将两条记录写入到表 d1001 中：
```sql
INSERT INTO d1001 VALUES (1538548684000, 10.2, 220, 0.23) (1538548696650, 10.3, 218, 0.25);
```
TDengine 也支持一次向多个表写入数据，比如下面这条命令就向 d1001 写入两条记录，向 d1002 写入一条记录：
```sql
INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) d1002 VALUES (1538548696800, 12.3, 221, 0.31);
```
详细的 SQL INSERT 语法规则请见 [TAOS SQL 的数据写入](/reference/taos-sql/insert) 章节。
:::info
- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过 16K，一条 SQL 语句总长度不能超过 1M 。
- TDengine 支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开 20 个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程频繁切换，带来额外开销。
:::
:::warning
- 对同一张表，如果新插入记录的时间戳已经存在，默认情形下（UPDATE=0）新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。如果在创建数据库时使用了 UPDATE 1 选项，插入相同时间戳的新记录将覆盖原有记录。
- 写入的数据的时间戳必须大于当前时间减去配置参数 keep 的时间。如果 keep 配置为 3650 天，那么无法写入比 3650 天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数 days。如果 days 为 2，那么无法写入比当前时间还晚 2 天的数据。
:::
## 示例程序
### 普通 SQL 写入
<Tabs defaultValue="java" groupId="lang">
<TabItem label="Java" value="java">
<JavaSQL />
</TabItem>
<TabItem label="Python" value="python">
<PySQL />
</TabItem>
<TabItem label="Go" value="go">
<GoSQL />
</TabItem>
<TabItem label="Rust" value="rust">
<RustSQL />
</TabItem>
<TabItem label="Node.js" value="nodejs">
<NodeSQL />
</TabItem>
<TabItem label="C#" value="csharp">
<CsSQL />
</TabItem>
<TabItem label="C" value="c">
<CSQL />
</TabItem>
</Tabs>
:::note
1. 无论 RESTFful 方式建立连接还是本地驱动方式建立连接，以上示例代码都能正常工作。
2. 唯一需要注意的是：由于 RESTful 接口无状态， 不能使用 `use db` 语句来切换数据库, 所以在上面示例中使用了`dbName.tbName`指定表名。
:::
### 动态绑定写入
TDengine 也提供了支持参数绑定的 Prepare API，与 MySQL 一样，这些 API 目前也仅支持用问号 `?` 来代表待绑定的参数。文档中有时也会把此功能称为“原生接口写入”。从 2.1.1.0 和 2.1.2.0 版本开始，TDengine 大幅改进了参数绑定接口对数据写入（INSERT）场景的支持。这样在通过参数绑定接口写入数据时，就避免了 SQL 语法解析的资源消耗，从而在绝大多数情况下显著提升写入性能。
<Tabs defaultValue="java" groupId="lang">
<TabItem label="Java" value="java">
<JavaStmt />
</TabItem>
<TabItem label="Python" value="python">
<PyStmt />
</TabItem>
<TabItem label="Go" value="go">
<GoStmt />
</TabItem>
<TabItem label="Rust" value="rust">
<RustStmt />
</TabItem>
<TabItem label="Node.js" value="nodejs">
<NodeStmt />
</TabItem>
<TabItem label="C#" value="csharp">
<CsStmt />
</TabItem>
<TabItem label="C" value="c">
<CStmt />
</TabItem>
</Tabs>
:::note
只有使用本地驱动方式建立连接，才能使用动态绑定功能。
:::
docs-cn/06-insert-data/02-influxdb-line.mdx 0 → 100644
浏览文件 @ 7a7e8072
---
sidebar_label: InfluxDB Line 协议
title: InfluxDB Line 协议
---
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
import JavaLine from "./_java_line.mdx";
import PyLine from "./_py_line.mdx";
import GoLine from "./_go_line.mdx";
import RustLine from "./_rust_line.mdx";
import NodeLine from "./_js_line.mdx";
import CsLine from "./_cs_line.mdx";
import CLine from "./_c_line.mdx";
## 示例代码
<Tabs defaultValue="java" groupId="lang">
<TabItem label="Java" value="java">
<JavaLine />
</TabItem>
<TabItem label="Python" value="Python">
<PyLine />
</TabItem>
<TabItem label="Go" value="go">
<GoLine />
</TabItem>
<TabItem label="Rust" value="rust">
<RustLine />
</TabItem>
<TabItem label="Node.js" value="nodejs">
<NodeLine />
</TabItem>
<TabItem label="C#" value="csharp">
<CsLine />
</TabItem>
<TabItem label="C" value="c">
<CLine />
</TabItem>
</Tabs>
docs-cn/06-insert-data/03-opentsdb-telnet.mdx 0 → 100644
浏览文件 @ 7a7e8072
---
sidebar_label: OpentsDB Telnet 协议
title: OpentsDB Telnet 协议
---
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
import JavaTelnet from "./_java_opts_telnet.mdx";
import PyTelnet from "./_py_opts_telnet.mdx";
import GoTelnet from "./_go_opts_telnet.mdx";
import RustTelnet from "./_rust_opts_telnet.mdx";
import NodeTelnet from "./_js_opts_telnet.mdx";
import CsTelnet from "./_cs_opts_telnet.mdx";
import CTelnet from "./_c_opts_telnet.mdx";
## 示例代码
<Tabs defaultValue="java" groupId="lang">
<TabItem label="Java" value="java">
<JavaTelnet />
</TabItem>
<TabItem label="Python" value="Python">
<PyTelnet />
</TabItem>
<TabItem label="Go" value="go">
<GoTelnet />
</TabItem>
<TabItem label="Rust" value="rust">
<RustTelnet />
</TabItem>
<TabItem label="Node.js" value="nodejs">
<NodeTelnet />
</TabItem>
<TabItem label="C#" value="csharp">
<CsTelnet />
</TabItem>
<TabItem label="C" value="c">
<CTelnet />
</TabItem>
</Tabs>
以上示例代码会自动创建 2 个超级表， 每个超级表有 4 条数据。
```cmd
taos> use test;
Database changed.
taos> show stables;
name | created_time | columns | tags | tables |
============================================================================================
meters.current | 2022-03-30 17:04:10.877 | 2 | 2 | 2 |
meters.voltage | 2022-03-30 17:04:10.882 | 2 | 2 | 2 |
Query OK, 2 row(s) in set (0.002544s)
taos> select tbname, * from `meters.current`;
tbname | ts | value | groupid | location |
==================================================================================================================================
t_0e7bcfa21a02331c06764f275... | 2022-03-28 09:56:51.249 | 10.800000000 | 3 | Beijing.Haidian |
t_0e7bcfa21a02331c06764f275... | 2022-03-28 09:56:51.250 | 11.300000000 | 3 | Beijing.Haidian |
t_7e7b26dd860280242c6492a16... | 2022-03-28 09:56:51.249 | 10.300000000 | 2 | Beijing.Chaoyang |
t_7e7b26dd860280242c6492a16... | 2022-03-28 09:56:51.250 | 12.600000000 | 2 | Beijing.Chaoyang |
Query OK, 4 row(s) in set (0.005399s)
```
docs-cn/06-insert-data/04-opentsdb-json.mdx 0 → 100644
浏览文件 @ 7a7e8072
---
sidebar_label: OpentsDB JSON 格式协议
title: OpentsDB JSON 格式协议
---
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
import JavaJson from "./_java_opts_json.mdx";
import PyJson from "./_py_opts_json.mdx";
import GoJson from "./_go_opts_json.mdx";
import RustJson from "./_rust_opts_json.mdx";
import NodeJson from "./_js_opts_json.mdx";
import CsJson from "./_cs_opts_json.mdx";
import CJson from "./_c_opts_json.mdx";
## 示例代码
<Tabs defaultValue="java" groupId="lang">
<TabItem label="Java" value="java">
<JavaJson />
</TabItem>
<TabItem label="Python" value="Python">
<PyJson />
</TabItem>
<TabItem label="Go" value="go">
<GoJson />
</TabItem>
<TabItem label="Rust" value="rust">
<RustJson />
</TabItem>
<TabItem label="Node.js" value="nodejs">
<NodeJson />
</TabItem>
<TabItem label="C#" value="csharp">
<CsJson />
</TabItem>
<TabItem label="C" value="c">
<CJson />
</TabItem>
</Tabs>
以上示例代码会自动创建 2 个超级表， 每个超级表有 2 条数据。
```cmd
taos> use test;
Database changed.
taos> show stables;
name | created_time | columns | tags | tables |
============================================================================================
meters.current | 2022-03-29 16:05:25.193 | 2 | 2 | 1 |
meters.voltage | 2022-03-29 16:05:25.200 | 2 | 2 | 1 |
Query OK, 2 row(s) in set (0.001954s)
taos> select * from `meters.current`;
ts | value | groupid | location |
===================================================================================================================
2022-03-28 09:56:51.249 | 10.300000000 | 2.000000000 | Beijing.Chaoyang |
2022-03-28 09:56:51.250 | 12.600000000 | 2.000000000 | Beijing.Chaoyang |
Query OK, 2 row(s) in set (0.004076s)
```
docs-cn/06-insert-data/_c_line.mdx 0 → 100644
浏览文件 @ 7a7e8072
```c
{{#include docs-examples/c/line_example.c:main}}
```
\ No newline at end of file
docs-cn/06-insert-data/_c_opts_json.mdx 0 → 100644
浏览文件 @ 7a7e8072
```c
{{#include docs-examples/c/json_protocol_example.c:main}}
```
\ No newline at end of file
docs-cn/06-insert-data/_c_opts_telnet.mdx 0 → 100644
浏览文件 @ 7a7e8072
```c
{{#include docs-examples/c/telnet_line_example.c:main}}
```
\ No newline at end of file
docs-cn/06-insert-data/_c_sql.mdx 0 → 100644
浏览文件 @ 7a7e8072
```c
{{#include docs-examples/c/insert_example.c}}
```
\ No newline at end of file
docs-cn/06-insert-data/_c_stmt.mdx 0 → 100644
浏览文件 @ 7a7e8072
```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/06-insert-data/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
label: 写入数据
link:
type: generated-index
slug: /insert-data/
description: "TDengine 支持多种接口写入协议，包括 SQL，InfluxDB Line 协议, OpentsDB Telnet 协议， OpentsDB JSON 格式协议。数据可以单条插入，也可以批量插入，可以插入一个数据采集点的数据，也可以同时插入多个数据采集点的数据。支持多线程插入，支持时间乱序数据插入，也支持历史数据插入。"
docs-cn/06-insert-data/_cs_line.mdx 0 → 100644
浏览文件 @ 7a7e8072
```csharp
{{#include docs-examples/csharp/InfluxDBLineExample.cs}}
```
docs-cn/06-insert-data/_cs_opts_json.mdx 0 → 100644
浏览文件 @ 7a7e8072
```csharp
{{#include docs-examples/csharp/OptsJsonExample.cs}}
```
docs-cn/06-insert-data/_cs_opts_telnet.mdx 0 → 100644
浏览文件 @ 7a7e8072
```csharp
{{#include docs-examples/csharp/OptsTelnetExample.cs}}
```
docs-cn/06-insert-data/_cs_sql.mdx 0 → 100644
浏览文件 @ 7a7e8072
```csharp
{{#include docs-examples/csharp/SQLInsertExample.cs}}
```
docs-cn/06-insert-data/_cs_stmt.mdx 0 → 100644
浏览文件 @ 7a7e8072
```csharp
{{#include docs-examples/csharp/StmtInsertExample.cs}}
```
docs-cn/06-insert-data/_go_line.mdx 0 → 100644
浏览文件 @ 7a7e8072
```go
{{#include docs-examples/go/insert/line/main.go}}
```
docs-cn/06-insert-data/_go_opts_json.mdx 0 → 100644
浏览文件 @ 7a7e8072
```go
{{#include docs-examples/go/insert/json/main.go}}
```
docs-cn/06-insert-data/_go_opts_telnet.mdx 0 → 100644
浏览文件 @ 7a7e8072
```go
{{#include docs-examples/go/insert/telnet/main.go}}
```
docs-cn/06-insert-data/_go_sql.mdx 0 → 100644
浏览文件 @ 7a7e8072
```go
{{#include docs-examples/go/insert/sql/main.go}}
```
docs-cn/06-insert-data/_go_stmt.mdx 0 → 100644
浏览文件 @ 7a7e8072
```go
{{#include docs-examples/go/insert/stmt/main.go}}
```
:::tip
driver-go 的模块 `github.com/taosdata/driver-go/v2/wrapper` 是 C 接口的底层封装。使用这个模块也可以实现动态绑定写入。
:::
docs-cn/06-insert-data/_java_line.mdx 0 → 100644
浏览文件 @ 7a7e8072
```java
{{#include docs-examples/java/src/main/java/com/taos/example/LineProtocolExample.java}}
```
docs-cn/06-insert-data/_java_opts_json.mdx 0 → 100644
浏览文件 @ 7a7e8072
```java
{{#include docs-examples/java/src/main/java/com/taos/example/JSONProtocolExample.java}}
```
docs-cn/06-insert-data/_java_opts_telnet.mdx 0 → 100644
浏览文件 @ 7a7e8072
```java
{{#include docs-examples/java/src/main/java/com/taos/example/TelnetLineProtocolExample.java}}
```
docs-cn/06-insert-data/_java_sql.mdx 0 → 100644
浏览文件 @ 7a7e8072
```java
{{#include docs-examples/java/src/main/java/com/taos/example/RestInsertExample.java:insert}}
```
\ No newline at end of file
docs-cn/06-insert-data/_java_stmt.mdx 0 → 100644
浏览文件 @ 7a7e8072
```java
{{#include docs-examples/java/src/main/java/com/taos/example/StmtInsertExample.java}}
```
docs-cn/06-insert-data/_js_line.mdx 0 → 100644
浏览文件 @ 7a7e8072
```js
{{#include docs-examples/node/nativeexample/influxdb_line_example.js}}
```
docs-cn/06-insert-data/_js_opts_json.mdx 0 → 100644
浏览文件 @ 7a7e8072
```js
{{#include docs-examples/node/nativeexample/opentsdb_json_example.js}}
```
docs-cn/06-insert-data/_js_opts_telnet.mdx 0 → 100644
浏览文件 @ 7a7e8072
```js
{{#include docs-examples/node/nativeexample/opentsdb_telnet_example.js}}
```
docs-cn/06-insert-data/_js_sql.mdx 0 → 100644
浏览文件 @ 7a7e8072
```js
{{#include docs-examples/node/nativeexample/insert_example.js}}
```
docs-cn/06-insert-data/_js_stmt.mdx 0 → 100644
浏览文件 @ 7a7e8072
```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/06-insert-data/_py_line.mdx 0 → 100644
浏览文件 @ 7a7e8072
```py
{{#include docs-examples/python/line_protocol_example.py}}
```
docs-cn/06-insert-data/_py_opts_json.mdx 0 → 100644
浏览文件 @ 7a7e8072
```py
{{#include docs-examples/python/json_protocol_example.py}}
```
docs-cn/06-insert-data/_py_opts_telnet.mdx 0 → 100644
浏览文件 @ 7a7e8072
```py
{{#include docs-examples/python/telnet_line_protocol_example.py}}
```
docs-cn/06-insert-data/_py_sql.mdx 0 → 100644
浏览文件 @ 7a7e8072
```py
{{#include docs-examples/python/native_insert_example.py}}
```
docs-cn/06-insert-data/_py_stmt.mdx 0 → 100644
浏览文件 @ 7a7e8072
```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/06-insert-data/_rust_line.mdx 0 → 100644
浏览文件 @ 7a7e8072
```rust
{{#include docs-examples/rust/schemalessexample/examples/influxdb_line_example.rs}}
```
docs-cn/06-insert-data/_rust_opts_json.mdx 0 → 100644
浏览文件 @ 7a7e8072
```rust
{{#include docs-examples/rust/schemalessexample/examples/opentsdb_json_example.rs}}
```
docs-cn/06-insert-data/_rust_opts_telnet.mdx 0 → 100644
浏览文件 @ 7a7e8072
```rust
{{#include docs-examples/rust/schemalessexample/examples/opentsdb_telnet_example.rs}}
```
docs-cn/06-insert-data/_rust_sql.mdx 0 → 100644
浏览文件 @ 7a7e8072
```rust
{{#include docs-examples/rust/restexample/examples/insert_example.rs}}
```
docs-cn/06-insert-data/_rust_stmt.mdx 0 → 100644
浏览文件 @ 7a7e8072
```rust
{{#include docs-examples/rust/nativeexample/examples/stmt_example.rs}}
```
docs-cn/07-query-data/_c.mdx 0 → 100644
浏览文件 @ 7a7e8072
```c
{{#include docs-examples/c/query_example.c}}
```
\ No newline at end of file
docs-cn/07-query-data/_c_async.mdx 0 → 100644
浏览文件 @ 7a7e8072
```c
{{#include docs-examples/c/async_query_example.c}}
```
\ No newline at end of file
docs-cn/07-query-data/_cs.mdx 0 → 100644
浏览文件 @ 7a7e8072
```csharp
{{#include docs-examples/csharp/QueryExample.cs}}
```
docs-cn/07-query-data/_cs_async.mdx 0 → 100644
浏览文件 @ 7a7e8072
```csharp
{{#include docs-examples/csharp/AsyncQueryExample.cs}}
```
docs-cn/07-query-data/_go.mdx 0 → 100644
浏览文件 @ 7a7e8072
```go
{{#include docs-examples/go/query/sync/main.go}}
```
docs-cn/07-query-data/_go_async.mdx 0 → 100644
浏览文件 @ 7a7e8072
```go
{{#include docs-examples/go/query/async/main.go}}
```
docs-cn/07-query-data/_java.mdx 0 → 100644
浏览文件 @ 7a7e8072
```java
{{#include docs-examples/java/src/main/java/com/taos/example/RestQueryExample.java}}
```
docs-cn/07-query-data/_js.mdx 0 → 100644
浏览文件 @ 7a7e8072
```js
{{#include docs-examples/node/nativeexample/query_example.js}}
```
docs-cn/07-query-data/_js_async.mdx 0 → 100644
浏览文件 @ 7a7e8072
```js
{{#include docs-examples/node/nativeexample/async_query_example.js}}
```
docs-cn/07-query-data/_py.mdx 0 → 100644
浏览文件 @ 7a7e8072
通过迭代逐行获取查询结果。
```py
{{#include docs-examples/python/query_example.py:iter}}
```
一次获取所有查询结果，并把每一行转化为一个字典返回。
```py
{{#include docs-examples/python/query_example.py:fetch_all}}
```
docs-cn/07-query-data/_py_async.mdx 0 → 100644
浏览文件 @ 7a7e8072
```py
{{#include docs-examples/python/async_query_example.py}}
```
:::note
这个示例程序，目前在 Windows 系统上还无法运行
:::
docs-cn/07-query-data/_rust.mdx 0 → 100644
浏览文件 @ 7a7e8072
```rust
{{#include docs-examples/rust/restexample/examples/query_example.rs}}
```
docs-cn/07-query-data/index.mdx 0 → 100644
浏览文件 @ 7a7e8072
---
slug: /query-data
title: 查询数据
---
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 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 作为查询语言。应用程序可以通过 C/C++, Java, Go, C#, Python, Node.js 连接器发送 SQL 语句，用户可以通过 TDengine 提供的命令行（Command Line Interface, CLI）工具 TAOS Shell 手动执行 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 Shell 中，从表 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 的数据查询](https://www.taosdata.com/cn/documentation/taos-sql#select) 章节。
## 多表聚合查询
物联网场景中，往往同一个类型的数据采集点有多个。TDengine 采用超级表(STable)的概念来描述某一个类型的数据采集点，一张普通的表来描述一个具体的数据采集点。同时 TDengine 使用标签来描述数据采集点的静态属性，一个具体的数据采集点有具体的标签值。通过指定标签的过滤条件，TDengine 提供了一高效的方法将超级表(某一类型的数据采集点)所属的子表进行聚合查询。对普通表的聚合函数以及绝大部分操作都适用于超级表，语法完全一样。
**示例 1**：在 TAOS Shell，查找北京所有智能电表采集的电压平均值，并按照 location 分组
```
taos> SELECT AVG(voltage) FROM meters GROUP BY location;
avg(voltage) | location |
=============================================================
222.000000000 | Beijing.Haidian |
219.200000000 | Beijing.Chaoyang |
Query OK, 2 row(s) in set (0.002136s)
```
**示例 2**：在 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 的数据查询](https://www.taosdata.com/cn/documentation/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 "Beijing%" 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 的时间维度聚合](https://www.taosdata.com/cn/documentation/taos-sql#aggregation) 章节。
## 示例代码
### 查询数据
在 [SQL 写入](/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>
</Tabs>
:::note
1. 无论 RESTFful 方式建立连接还是本地驱动方式建立连接，以上示例代码都能正常工作。
2. 唯一需要注意的是：由于 RESTful 接口无状态， 不能使用 `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="Node.js" value="nodejs">
<NodeAsync />
</TabItem>
<TabItem label="C#" value="csharp">
<CsAsync />
</TabItem>
<TabItem label="C" value="c">
<CAsync />
</TabItem>
</Tabs>
:::note
只有使用本地驱动方式连接连接，才能使用异步查询功能。
:::
docs-cn/08-advance-feature/01-continuous-query.mdx 0 → 100644
浏览文件 @ 7a7e8072
---
sidebar_label: 连续查询
---
# 连续查询（Continuous Query）
连续查询是 TDengine 定期自动执行的查询，采用滑动窗口的方式进行计算，是一种简化的时间驱动的流式计算。针对库中的表或超级表，TDengine 可提供定期自动执行的连续查询，用户可让 TDengine 推送查询的结果，也可以将结果再写回到 TDengine 中。每次执行的查询是一个时间窗口，时间窗口随着时间流动向前滑动。在定义连续查询的时候需要指定时间窗口（time window, 参数 interval）大小和每次前向增量时间（forward sliding times, 参数 sliding）。
TDengine 的连续查询采用时间驱动模式，可以直接使用 TAOS SQL 进行定义，不需要额外的操作。使用连续查询，可以方便快捷地按照时间窗口生成结果，从而对原始采集数据进行降采样（down sampling）。用户通过 TAOS SQL 定义连续查询以后，TDengine 自动在最后的一个完整的时间周期末端拉起查询，并将计算获得的结果推送给用户或者写回 TDengine。
TDengine 提供的连续查询与普通流计算中的时间窗口计算具有以下区别：
- 不同于流计算的实时反馈计算结果，连续查询只在时间窗口关闭以后才开始计算。例如时间周期是 1 天，那么当天的结果只会在 23:59:59 以后才会生成。
- 如果有历史记录写入到已经计算完成的时间区间，连续查询并不会重新进行计算，也不会重新将结果推送给用户。对于写回 TDengine 的模式，也不会更新已经存在的计算结果。
- 使用连续查询推送结果的模式，服务端并不缓存客户端计算状态，也不提供 Exactly-Once 的语意保证。如果用户的应用端崩溃，再次拉起的连续查询将只会从再次拉起的时间开始重新计算最近的一个完整的时间窗口。如果使用写回模式，TDengine 可确保数据写回的有效性和连续性。
## 使用连续查询
下面以智能电表场景为例介绍连续查询的具体使用方法。假设我们通过下列 SQL 语句创建了超级表和子表：
```sql
create table meters (ts timestamp, current float, voltage int, phase float) tags (location binary(64), groupId int);
create table D1001 using meters tags ("Beijing.Chaoyang", 2);
create table D1002 using meters tags ("Beijing.Haidian", 2);
...
```
我们已经知道，可以通过下面这条 SQL 语句以一分钟为时间窗口、30 秒为前向增量统计这些电表的平均电压。
```sql
select avg(voltage) from meters interval(1m) sliding(30s);
```
每次执行这条语句，都会重新计算所有数据。 如果需要每隔 30 秒执行一次来增量计算最近一分钟的数据，可以把上面的语句改进成下面的样子，每次使用不同的 `startTime` 并定期执行：
```sql
select avg(voltage) from meters where ts > {startTime} interval(1m) sliding(30s);
```
这样做没有问题，但 TDengine 提供了更简单的方法，只要在最初的查询语句前面加上 `create table {tableName} as` 就可以了，例如：
```sql
create table avg_vol as select avg(voltage) from meters interval(1m) sliding(30s);
```
会自动创建一个名为 `avg_vol` 的新表，然后每隔 30 秒，TDengine 会增量执行 `as` 后面的 SQL 语句，并将查询结果写入这个表中，用户程序后续只要从 `avg_vol` 中查询数据即可。例如：
```sql
taos> select * from avg_vol;
ts | avg_voltage_ |
===================================================
2020-07-29 13:37:30.000 | 222.0000000 |
2020-07-29 13:38:00.000 | 221.3500000 |
2020-07-29 13:38:30.000 | 220.1700000 |
2020-07-29 13:39:00.000 | 223.0800000 |
```
需要注意，查询时间窗口的最小值是 10 毫秒，没有时间窗口范围的上限。
此外，TDengine 还支持用户指定连续查询的起止时间。如果不输入开始时间，连续查询将从第一条原始数据所在的时间窗口开始；如果没有输入结束时间，连续查询将永久运行；如果用户指定了结束时间，连续查询在系统时间达到指定的时间以后停止运行。比如使用下面的 SQL 创建的连续查询将运行一小时，之后会自动停止。
```sql
create table avg_vol as select avg(voltage) from meters where ts > now and ts <= now + 1h interval(1m) sliding(30s);
```
需要说明的是，上面例子中的 `now` 是指创建连续查询的时间，而不是查询执行的时间，否则，查询就无法自动停止了。另外，为了尽量避免原始数据延迟写入导致的问题，TDengine 中连续查询的计算有一定的延迟。也就是说，一个时间窗口过去后，TDengine 并不会立即计算这个窗口的数据，所以要稍等一会（一般不会超过 1 分钟）才能查到计算结果。
## 管理连续查询
用户可在控制台中通过 `show streams` 命令来查看系统中全部运行的连续查询，并可以通过 `kill stream` 命令杀掉对应的连续查询。后续版本会提供更细粒度和便捷的连续查询管理命令。
docs-cn/08-advance-feature/02-subscribe.mdx 0 → 100644
浏览文件 @ 7a7e8072
---
sidebar_label: 数据订阅
---
# 数据订阅
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](https://www.taosdata.com/cn/documentation/connector#c-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/_ 这个目录下，每个订阅有一个与其 `topic` 同名的文件，删掉某个文件，同样会导致下次创建其对应的订阅时只能重新开始。
代码介绍完毕，我们来看一下实际的运行效果。假设：
- 示例代码已经下载到本地
- TDengine 也已经在同一台机器上安装好
- 示例所需的数据库、超级表、子表已经全部创建好
则可以在示例代码所在目录执行以下命令来编译并启动示例程序：
```bash
make
./subscribe -sql='select * from meters where current > 10;'
```
示例程序启动后，打开另一个终端窗口，启动 TDengine 的 shell 向 **D1001** 插入一条电流为 12A 的数据：
```sql
$ taos
> use test;
> insert into D1001 values(now, 12, 220, 1);
```
这时，因为电流超过了 10A，您应该可以看到示例程序将它输出到了屏幕上。您可以继续插入一些数据观察示例程序的输出。
## 示例程序
下面以一个示例程序介绍其具体使用方法。示例程序的目的是订阅数据库中所有电流超过 10A 的记录。
### 准备数据
```sql
# 创建 power 库
taos> create database power;
# 切换库
taos> use power;
# 创建超级表
taos> create table meters(ts timestamp, current float, voltage int, phase int) tags(location binary(64), groupId int);
# 创建表
taos> create table d1001 using meters tags ("Beijing.Chaoyang", 2);
taos> create table d1002 using meters tags ("Beijing.Haidian", 2);
# 插入测试数据
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);
# 从超级表 meters 查询电流大于 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 | Beijing.Haidian | 2 |
2020-08-15 12:20:00.000 | 11.20000 | 220 | 1 | Beijing.Haidian | 2 |
2020-08-15 12:00:00.000 | 12.00000 | 220 | 1 | Beijing.Chaoyang | 2 |
2020-08-15 12:10:00.000 | 12.30000 | 220 | 2 | Beijing.Chaoyang | 2 |
2020-08-15 12:20:00.000 | 12.20000 | 220 | 1 | Beijing.Chaoyang | 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: Beijing.Chaoyang groupid : 2
ts: 1597464600000 current: 12.3 voltage: 220 phase: 2 location: Beijing.Chaoyang groupid : 2
ts: 1597465200000 current: 12.2 voltage: 220 phase: 1 location: Beijing.Chaoyang groupid : 2
ts: 1597464600000 current: 10.3 voltage: 220 phase: 1 location: Beijing.Haidian groupid : 2
ts: 1597465200000 current: 11.2 voltage: 220 phase: 1 location: Beijing.Haidian groupid : 2
```
接着，使用 taos 客户端向表中新增一条数据：
```sql
# taos
taos> use power;
taos> insert into d1001 values("2020-08-15 12:40:00.000", 12.4, 220, 1);
```
因为这条数据的电流大于 10A，示例程序会将其消费：
```
ts: 1597466400000 current: 12.4 voltage: 220 phase: 1 location: Beijing.Chaoyang groupid: 2
```
docs-cn/08-advance-feature/03-cache.md 0 → 100644
浏览文件 @ 7a7e8072
---
sidebar_label: 缓存
title: 缓存
---
TDengine 采用时间驱动缓存管理策略（First-In-First-Out，FIFO），又称为写驱动的缓存管理机制。这种策略有别于读驱动的数据缓存模式（Least-Recent-Used，LRU），直接将最近写入的数据保存在系统的缓存中。当缓存达到临界值的时候，将最早的数据批量写入磁盘。一般意义上来说，对于物联网数据的使用，用户最为关心最近产生的数据，即当前状态。TDengine 充分利用了这一特性，将最近到达的（当前状态）数据保存在缓存中。
TDengine 通过查询函数向用户提供毫秒级的数据获取能力。直接将最近到达的数据保存在缓存中，可以更加快速地响应用户针对最近一条或一批数据的查询分析，整体上提供更快的数据库查询响应能力。从这个意义上来说，可通过设置合适的配置参数将 TDengine 作为数据缓存来使用，而不需要再部署额外的缓存系统，可有效地简化系统架构，降低运维的成本。需要注意的是，TDengine 重启以后系统的缓存将被清空，之前缓存的数据均会被批量写入磁盘，缓存的数据将不会像专门的 key-value 缓存系统再将之前缓存的数据重新加载到缓存中。
TDengine 分配固定大小的内存空间作为缓存空间，缓存空间可根据应用的需求和硬件资源配置。通过适当的设置缓存空间，TDengine 可以提供极高性能的写入和查询的支持。TDengine 中每个虚拟节点（virtual node）创建时分配独立的缓存池。每个虚拟节点管理自己的缓存池，不同虚拟节点间不共享缓存池。每个虚拟节点内部所属的全部表共享该虚拟节点的缓存池。
TDengine 将内存池按块划分进行管理，数据在内存块里是以行（row）的形式存储。一个 vnode 的内存池是在 vnode 创建时按块分配好，而且每个内存块按照先进先出的原则进行管理。在创建内存池时，块的大小由系统配置参数 cache 决定；每个 vnode 中内存块的数目则由配置参数 blocks 决定。因此对于一个 vnode，总的内存大小为：`cache * blocks`。一个 cache block 需要保证每张表能存储至少几十条以上记录，才会有效率。
你可以通过函数 last_row() 快速获取一张表或一张超级表的最后一条记录，这样很便于在大屏显示各设备的实时状态或采集值。例如：
```sql
select last_row(voltage) from meters where location='Beijing.Chaoyang';
```
该 SQL 语句将获取所有位于北京朝阳区的电表最后记录的电压值。
docs-cn/08-advance-feature/04-udf.md 0 → 100644
浏览文件 @ 7a7e8072
---
sidebar_label: UDF
title: UDF（用户定义函数）
---
在有些应用场景中，应用逻辑需要的查询无法直接使用系统内置的函数来表示。利用 UDF 功能，TDengine 可以插入用户编写的处理代码并在查询中使用它们，就能够很方便地解决特殊应用场景中的使用需求。 UDF 通常以数据表中的一列数据做为输入，同时支持以嵌套子查询的结果作为输入。
从 2.2.0.0 版本开始，TDengine 支持通过 C/C++ 语言进行 UDF 定义。接下来结合示例讲解 UDF 的使用方法。
## 用 C/C++ 语言来定义 UDF
TDengine 提供 3 个 UDF 的源代码示例，分别为：
- [add_one.c](#add_one.c)
- [abs_max.c](#abs_max.c)
- [demo.c](#demo.c)
### 标量函数
[add_one.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/add_one.c) 是结构最简单的 UDF 实现。其功能为：对传入的一个数据列（可能因 WHERE 子句进行了筛选）中的每一项，都输出 +1 之后的值，并且要求输入的列数据类型为 INT。
这一具体的处理逻辑在函数 `void add_one(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)` 中定义。这类用于实现 UDF 的基础计算逻辑的函数，我们称为 udfNormalFunc，也就是对行数据块的标量计算函数。需要注意的是，udfNormalFunc 的参数项是固定的，用于按照约束完成与引擎之间的数据交换。
- udfNormalFunc 中各参数的具体含义是：
- data：输入数据。
- itype：输入数据的类型。这里采用的是短整型表示法，与各种数据类型对应的值可以参见 [column_meta 中的列类型说明](https://www.taosdata.com/cn/documentation/connector#column_meta)。例如 4 用于表示 INT 型。
- iBytes：输入数据中每个值会占用的字节数。
- numOfRows：输入数据的总行数。
- ts：主键时间戳在输入中的列数据(只读)。
- dataOutput：输出数据的缓冲区，缓冲区大小为用户指定的输出类型大小 \* numOfRows。
- interBuf：中间计算结果的缓冲区，大小为用户在创建 UDF 时指定的 BUFSIZE 大小。通常用于计算中间结果与最终结果不一致时使用，由引擎负责分配与释放。
- tsOutput：主键时间戳在输出时的列数据，如果非空可用于输出结果对应的时间戳。
- numOfOutput：输出结果的个数（行数）。
- oType：输出数据的类型。取值含义与 itype 参数一致。
- oBytes：输出数据中每个值占用的字节数。
- 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 条结果数据。
值得注意的是，udfNormalFunc、udfMergeFunc、udfFinalizeFunc 之间，函数名约定使用相同的前缀，此前缀即 udfNormalFunc 的实际函数名。udfMergeFunc 的函数名后缀 `_merge`、udfFinalizeFunc 的函数名后缀 `_finalize`，是 UDF 实现规则的一部分，系统会按照这些函数名后缀来调用相应功能。
- udfMergeFunc 用于对计算中间结果进行聚合，只有针对超级表的聚合查询才需要调用该函数。本例中 udfMergeFunc 对应的实现函数为 `void abs_max_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf)`，其中各参数的具体含义是：
- data：udfNormalFunc 的输出数据数组，如果使用了 interBuf 那么 data 就是 interBuf 的数组。
- numOfRows：data 中数据的行数。
- dataOutput：输出数据的缓冲区，大小等于一条最终结果的大小。如果此时输出还不是最终结果，可以选择输出到 interBuf 中即 data 中。
- numOfOutput：输出结果的个数（行数）。
- buf：用于在 UDF 与引擎间的状态控制信息传递块。
- udfFinalizeFunc 用于对计算结果进行最终计算，通常用于有 interBuf 使用的场景。本例中 udfFinalizeFunc 对应的实现函数为 `void abs_max_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf)`，其中各参数的具体含义是：
- dataOutput：输出数据的缓冲区。
- interBuf：中间结算结果缓冲区，可作为输入。
- numOfOutput：输出数据的个数，对聚合函数来说只能是 0 或者 1。
- buf：用于在 UDF 与引擎间的状态控制信息传递块。
其他典型场景，如协方差的计算，即可通过定义聚合 UDF 的方式实现。
### 其他 UDF 函数
用户 UDF 程序除了需要实现上面几个函数外，还有两个用于初始化和释放 UDF 与引擎间的状态控制信息传递块的函数。具体来说，也即对应 udfInitFunc 和 udfDestroyFunc。其函数名命名规则同样是采取以 udfNormalFunc 的实际函数名为前缀，以 `_init` 和 `_destroy` 为后缀。系统会在初始化和资源释放时调用对应名称的函数。
- udfInitFunc 用于初始化状态控制信息传递块。上例中 udfInitFunc 对应的实现函数为 `int abs_max_init(SUdfInit* buf)`，其中各参数的具体含义是：
- buf：用于在 UDF 与引擎间的状态控制信息传递块。
- udfDestroyFunc 用于释放状态控制信息传递块。上例中 udfDestroyFunc 对应的实现函数为 `void abs_max_destroy(SUdfInit* buf)`，其中各参数的具体含义是：
- buf：用于在 UDF 与引擎间的状态控制信息传递块。
目前该功能暂时没有实际意义，待后续扩展使用。
### UDF 实现方式的规则总结
根据 UDF 函数类型的不同，用户所要实现的功能函数也不同：
- 标量函数：UDF 中需实现 udfNormalFunc。
- 聚合函数：UDF 中需实现 udfNormalFunc、udfMergeFunc（对超级表查询）、udfFinalizeFunc。
需要注意的是，如果对应的函数不需要具体的功能，也需要实现一个空函数。
## 编译 UDF
用户定义函数的 C 语言源代码无法直接被 TDengine 系统使用，而是需要先编译为 .so 链接库，之后才能载入 TDengine 系统。
例如，按照上一章节描述的规则准备好了用户定义函数的源代码 add_one.c，那么可以执行如下指令编译得到动态链接库文件：
```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 匹配。
- 创建标量函数：`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;
```
- 创建聚合函数：`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) 参数一致，也即要删除的函数的名字，例如 `DROP FUNCTION add_one;`。
- 显示系统中当前可用的所有 UDF：`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.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/add_one.c)
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct SUdfInit{
int maybe_null; /* 1 if function can return NULL */
int decimals; /* for real functions */
long long length; /* For string functions */
char *ptr; /* free pointer for function data */
int const_item; /* 0 if result is independent of arguments */
} SUdfInit;
void add_one(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) {
int i;
int r = 0;
// printf("add_one input data:%p, type:%d, rows:%d, ts:%p,%lld, dataoutput:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, tsOutput, numOfOutput, buf);
if (itype == 4) {
for(i=0;i<numOfRows;++i) {
// printf("input %d - %d", i, *((int *)data + i));
*((int *)dataOutput+i)=*((int *)data + i) + 1;
// printf(", output %d\n", *((int *)dataOutput+i));
if (tsOutput) {
*(long long*)tsOutput=1000000;
}
}
*numOfOutput=numOfRows;
// printf("add_one out, numOfOutput:%d\n", *numOfOutput);
}
}
```
### [abs_max.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/abs_max.c)
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
typedef struct SUdfInit{
int maybe_null; /* 1 if function can return NULL */
int decimals; /* for real functions */
int64_t length; /* For string functions */
char *ptr; /* free pointer for function data */
int const_item; /* 0 if result is independent of arguments */
} SUdfInit;
#define TSDB_DATA_INT_NULL 0x80000000L
#define TSDB_DATA_BIGINT_NULL 0x8000000000000000L
void abs_max(char* data, short itype, short ibytes, int numOfRows, int64_t* ts, char* dataOutput, char* interBuf, char* tsOutput,
int* numOfOutput, short otype, short obytes, SUdfInit* buf) {
int i;
int64_t r = 0;
// printf("abs_max input data:%p, type:%d, rows:%d, ts:%p, %" PRId64 ", dataoutput:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, tsOutput, numOfOutput, buf);
if (itype == 5) {
r=*(int64_t *)dataOutput;
*numOfOutput=0;
for(i=0;i<numOfRows;++i) {
if (*((int64_t *)data + i) == TSDB_DATA_BIGINT_NULL) {
continue;
}
*numOfOutput=1;
//int64_t v = abs(*((int64_t *)data + i));
int64_t v = *((int64_t *)data + i);
if (v < 0) {
v = 0 - v;
}
if (v > r) {
r = v;
}
}
*(int64_t *)dataOutput=r;
// printf("abs_max out, dataoutput:%" PRId64", numOfOutput:%d\n", *(int64_t *)dataOutput, *numOfOutput);
}else {
*numOfOutput=0;
}
}
void abs_max_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf) {
int i;
//int64_t r = 0;
// printf("abs_max_finalize dataoutput:%p:%d, numOfOutput:%d, buf:%p\n", dataOutput, *dataOutput, *numOfOutput, buf);
// *numOfOutput=1;
// printf("abs_max finalize, dataoutput:%" PRId64", numOfOutput:%d\n", *(int64_t *)dataOutput, *numOfOutput);
}
void abs_max_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf) {
int64_t r = 0;
if (numOfRows > 0) {
r = *((int64_t *)data);
}
// printf("abs_max_merge numOfRows:%d, dataoutput:%p, buf:%p\n", numOfRows, dataOutput, buf);
for (int i = 1; i < numOfRows; ++i) {
// printf("abs_max_merge %d - %" PRId64"\n", i, *((int64_t *)data + i));
if (*((int64_t*)data + i) > r) {
r= *((int64_t*)data + i);
}
}
*(int64_t*)dataOutput=r;
if (numOfRows > 0) {
*numOfOutput=1;
} else {
*numOfOutput=0;
}
// printf("abs_max_merge, dataoutput:%" PRId64", numOfOutput:%d\n", *(int64_t *)dataOutput, *numOfOutput);
}
int abs_max_init(SUdfInit* buf) {
// printf("abs_max init\n");
return 0;
}
void abs_max_destroy(SUdfInit* buf) {
// printf("abs_max destroy\n");
}
```
### [demo.c](https://github.com/taosdata/TDengine/blob/develop/tests/script/sh/demo.c)
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct SUdfInit{
int maybe_null; /* 1 if function can return NULL */
int decimals; /* for real functions */
long long length; /* For string functions */
char *ptr; /* free pointer for function data */
int const_item; /* 0 if result is independent of arguments */
} SUdfInit;
typedef struct SDemo{
double sum;
int num;
short otype;
}SDemo;
#define FLOAT_NULL 0x7FF00000 // it is an NAN
#define DOUBLE_NULL 0x7FFFFF0000000000L // it is an NAN
void demo(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) {
int i;
double r = 0;
SDemo *p = (SDemo *)interBuf;
SDemo *q = (SDemo *)dataOutput;
printf("demo input data:%p, type:%d, rows:%d, ts:%p,%lld, dataoutput:%p, interBUf:%p, tsOutput:%p, numOfOutput:%p, buf:%p\n", data, itype, numOfRows, ts, *ts, dataOutput, interBuf, tsOutput, numOfOutput, buf);
for(i=0;i<numOfRows;++i) {
if (itype == 4) {
r=*((int *)data+i);
} else if (itype == 6) {
r=*((float *)data+i);
} else if (itype == 7) {
r=*((double *)data+i);
}
p->sum += r*r;
}
p->otype = otype;
p->num += numOfRows;
q->sum = p->sum;
q->num = p->num;
q->otype = p->otype;
*numOfOutput=1;
printf("demo out, sum:%f, num:%d, numOfOutput:%d\n", p->sum, p->num, *numOfOutput);
}
void demo_merge(char* data, int32_t numOfRows, char* dataOutput, int32_t* numOfOutput, SUdfInit* buf) {
int i;
SDemo *p = (SDemo *)data;
SDemo res = {0};
printf("demo_merge input data:%p, rows:%d, dataoutput:%p, numOfOutput:%p, buf:%p\n", data, numOfRows, dataOutput, numOfOutput, buf);
for(i=0;i<numOfRows;++i) {
res.sum += p->sum * p->sum;
res.num += p->num;
p++;
}
p->sum = res.sum;
p->num = res.num;
*numOfOutput=1;
printf("demo out, sum:%f, num:%d, numOfOutput:%d\n", p->sum, p->num, *numOfOutput);
}
void demo_finalize(char* dataOutput, char* interBuf, int* numOfOutput, SUdfInit* buf) {
SDemo *p = (SDemo *)interBuf;
printf("demo_finalize interbuf:%p, numOfOutput:%p, buf:%p, sum:%f, num:%d\n", interBuf, numOfOutput, buf, p->sum, p->num);
if (p->otype == 6) {
if (p->num != 30000) {
*(unsigned int *)dataOutput = FLOAT_NULL;
} else {
*(float *)dataOutput = (float)(p->sum / p->num);
}
printf("finalize values:%f\n", *(float *)dataOutput);
} else if (p->otype == 7) {
if (p->num != 30000) {
*(unsigned long long *)dataOutput = DOUBLE_NULL;
} else {
*(double *)dataOutput = (double)(p->sum / p->num);
}
printf("finalize values:%f\n", *(double *)dataOutput);
}
*numOfOutput=1;
printf("demo finalize, numOfOutput:%d\n", *numOfOutput);
}
int demo_init(SUdfInit* buf) {
printf("demo init\n");
return 0;
}
void demo_destroy(SUdfInit* buf) {
printf("demo destroy\n");
}
```
docs-cn/08-advance-feature/08-advance-feature.md 0 → 100644
浏览文件 @ 7a7e8072
---
title: 高级功能
---
本章介绍以下TDengine中的高级功能。
## 连续查询
连续查询是一个按照预设频率自动执行的查询功能，提供按照时间窗口的聚合查询能力，是一种简化的时间驱动流式计算。
## 订阅
轻量级的数据订阅与推送服务。连续写入到TDengine中时序数据均能够推动到订阅客户端。
## 缓存
提供写驱动的缓存管理机制，将每个表最近的一条写入记录数据持续保存在缓存中，可以提供给高性能的最近状态查询。
## 用户定义函数
支持用户编码的聚合函数和标量函数，在查询中嵌入并使用用户定义函数，拓展查询的能力和功能。
docs-cn/08-advance-feature/_05-stream.md 0 → 100644
浏览文件 @ 7a7e8072
---
sidebar_label: 流计算
---
# 流计算
docs-cn/08-advance-feature/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
label: 高级功能
\ No newline at end of file
docs-cn/08-advance-feature/_sub_c.mdx 0 → 100644
浏览文件 @ 7a7e8072
```c
{{#include docs-examples/c/subscribe_demo.c}}
```
\ No newline at end of file
docs-cn/08-advance-feature/_sub_cs.mdx 0 → 100644
浏览文件 @ 7a7e8072
```csharp
{{#include docs-examples/csharp/SubscribeDemo.cs}}
```
\ No newline at end of file
docs-cn/08-advance-feature/_sub_go.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/08-advance-feature/_sub_java.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/08-advance-feature/_sub_node.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/08-advance-feature/_sub_python.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/08-advance-feature/_sub_rust.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/09-third-party/01-grafana.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/09-third-party/02-prometheus.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/09-third-party/03-telegraf.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/09-third-party/05-collectd.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/09-third-party/06-statsd.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/09-third-party/07-icinga2.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/09-third-party/08-tcollector.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/09-third-party/09-emq-broder.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/09-third-party/10-hive-mq-broker.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/09-third-party/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/10-cluster/01-deploy.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/10-cluster/02-cluster-mgmt.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/10-cluster/03-ha-and-lb.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/10-cluster/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/01-pkg-install.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/02-planning.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/03-tolerance.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/06-admin.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/07-import.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/08-export.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/09-status.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/10-monitor.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/11-optimize.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/17-diagnose.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/11-operation/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/13-tdinternal/01-arch.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/13-tdinternal/02-replica.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/13-tdinternal/03-taosd.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/13-tdinternal/12-tsz-compress.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/13-tdinternal/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/01-data-type.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/02-database.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/03-table.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/04-stable.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/05-insert.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/06-select.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/07-function.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/08-interval.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/09-limit.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/10-json.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/11-escape.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/12-errorcode.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/01-taos-sql/index.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/02-restful-api/02-restful-api.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/02-restful-api/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/03-connector.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/_linux_install.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/_varify_linux.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/_varify_windows.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/_windows_install.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/cpp.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/csharp.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/go.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/java.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/node.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/python.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/03-connector/rust.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/05-support-platform/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/06-keywords/06-keywords.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/06-keywords/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/07-docker/07-docker.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/07-docker/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/08-server-config/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/09-client-config/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/12-direcotry.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/13-schemaless/13-schemaless.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/13-schemaless/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/14-reference/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/15-application/01-telegraf.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/15-application/02-collectd.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/15-application/03-immigrate.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/15-application/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/16-iot-big-data/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/16-iot-big-data/index.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/17-train-fqa/01-faq.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/17-train-fqa/02-video.mdx 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/17-train-fqa/03-docker.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-cn/17-train-fqa/_category_.yml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/.gitignore 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/.gitignre 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/.gitignore 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/async_query_example.c 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/connect_example.c 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/insert_example.c 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/json_protocol_example.c 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/line_example.c 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/multi_bind_example.c 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/query_example.c 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/stmt_example.c 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/subscribe_demo.c 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/c/telnet_line_example.c 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/.gitignore 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/AsyncQueryExample.cs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/ConnectExample.cs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/InfluxDBLineExample.cs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/OptsJsonExample.cs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/OptsTelnetExample.cs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/SQLInsertExample.cs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/StmtInsertExample.cs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/SubscribeDemo.cs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/asyncquery.csproj 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/influxdbline.csproj 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/optstelnet.csproj 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/sqlinsert.csproj 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/csharp/stmtinsert.csproj 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/.gitignore 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/connect/afconn/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/connect/cgoexample/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/connect/restexample/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/connect/wrapper/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/go.mod 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/insert/json/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/insert/line/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/insert/sql/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/insert/stmt/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/insert/telnet/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/query/async/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/query/sync/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/rest/opentsdbjson/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/go/sub/main.go 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/java/.gitignore 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/java/pom.xml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/node/.gitignore 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/node/nativeexample/async_query_example.js 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/node/nativeexample/connect.js 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/node/nativeexample/insert_example.js 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/node/nativeexample/multi_bind_example.js 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/node/nativeexample/param_bind_example.js 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/node/nativeexample/query_example.js 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/node/nativeexample/subscribe_demo.js 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/node/package.json 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/python/.gitignore 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/python/bind_param_example.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/python/connect_exmaple.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/python/json_protocol_example.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/python/line_protocol_example.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/python/multi_bind_example.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/python/native_insert_example.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/python/query_example.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/python/subscribe_demo.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/python/telnet_line_protocol_example.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/rust/Cargo.toml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/rust/nativeexample/Cargo.toml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/rust/nativeexample/examples/connect.rs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/rust/nativeexample/src/main.rs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/rust/restexample/Cargo.toml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/rust/restexample/examples/connect.rs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/rust/restexample/src/main.rs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/rust/schemalessexample/Cargo.toml 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
docs-examples/rust/schemalessexample/src/main.rs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
documentation20/cn/00.index/docs.md
浏览文件 @ 7a7e8072
此差异已折叠。
documentation20/cn/08.connector/03.php/docs.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
documentation20/cn/13.faq/docs.md
浏览文件 @ 7a7e8072
此差异已折叠。
documentation20/en/00.index/docs.md
浏览文件 @ 7a7e8072
此差异已折叠。
documentation20/en/13.faq/docs.md
浏览文件 @ 7a7e8072
此差异已折叠。
examples/C#/.gitignore
浏览文件 @ 7a7e8072
此差异已折叠。
examples/JDBC/taosdemo/pom.xml
浏览文件 @ 7a7e8072
此差异已折叠。
examples/R/command.txt
浏览文件 @ 7a7e8072
此差异已折叠。
examples/R/rjdbc.sample.R 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
examples/c/apitest.c
浏览文件 @ 7a7e8072
此差异已折叠。
examples/c/makefile
浏览文件 @ 7a7e8072
此差异已折叠。
examples/c/stream.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
packaging/cfg/taos.cfg
浏览文件 @ 7a7e8072
此差异已折叠。
packaging/docker/Dockerfile
浏览文件 @ 7a7e8072
此差异已折叠。
packaging/docker/dockerbuild.sh
浏览文件 @ 7a7e8072
此差异已折叠。
packaging/tools/makeclient.sh
浏览文件 @ 7a7e8072
此差异已折叠。
packaging/tools/makepkg.sh
浏览文件 @ 7a7e8072
此差异已折叠。
src/client/inc/tscUtil.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/client/src/TSDBJNIConnector.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/client/src/taos.def
浏览文件 @ 7a7e8072
此差异已折叠。
src/client/src/tscLocal.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/client/src/tscParseInsert.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/client/src/tscSQLParser.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/client/src/tscSubquery.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/client/src/tscUtil.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/common/inc/tglobal.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/common/inc/tname.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/common/src/tdataformat.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/common/src/texpr.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/common/src/tglobal.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/common/src/tname.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/C#/.gitignore
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/C#/examples/Main.cs
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/C#/examples/SchemalessSample.cs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/C#/examples/StreamSample.cs 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/C#/src/test/FunctionTest/Subscribe.cs 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/.gitignore 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/example/example.ts 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/index.ts 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/package.json 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/readme.md 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/src/connect.ts 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/src/cursor.ts 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/src/options.ts 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/src/request.ts 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/src/result.ts 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/tdengine_rest.ts 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/TypeScript-REST/tsconfig.json 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/jdbc/CMakeLists.txt
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/jdbc/deploy-pom.xml
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/jdbc/pom.xml
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/jdbc/readme.md
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/nodejs/examples/cursorClose.js 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/nodejs/package.json
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/python/LICENSE 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/README.md
浏览文件 @ 7a7e8072
此差异已折叠。
src/connector/python/examples/bind-multi.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/examples/bind-row.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/examples/demo.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/examples/insert-lines.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/examples/pep-249.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/examples/stream.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/pyproject.toml 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/setup.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/__init__.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/_version.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/bind.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/cinterface.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/connection.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/constants.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/cursor.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/error.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/field.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/precision.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/result.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/schemaless.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/statement.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/stream.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/subscription.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/taos/timestamp.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/tests/test-td6231.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/tests/test_ctaos.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/tests/test_info.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/tests/test_lines.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/tests/test_query.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/tests/test_query_a.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/tests/test_stmt.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/tests/test_stream.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/connector/python/tests/test_subscribe.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/dnode/CMakeLists.txt
浏览文件 @ 7a7e8072
此差异已折叠。
src/dnode/src/dnodeMain.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/dnode/src/dnodeModule.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/inc/taosdef.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/inc/tmqtt.h 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/kit/shell/src/shellLinux.c
浏览文件 @ 7a7e8072
此差异已折叠。
taos-tools @ bae99633
比较 94aec03d...bae99633
此差异已折叠。
src/mnode/src/mnodeDnode.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/mnode/src/mnodeShow.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/os/inc/osSysinfo.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/os/src/detail/osSysinfo.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/os/src/detail/osTime.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/os/src/windows/wSysinfo.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/plugins/http/src/httpParser.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/plugins/http/src/httpUtil.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/plugins/mqtt/CMakeLists.txt 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/plugins/mqtt/inc/mqttInit.h 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/plugins/mqtt/inc/mqttLog.h 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/plugins/mqtt/inc/mqttPayload.h 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/plugins/mqtt/src/mqttPayload.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
src/plugins/mqtt/src/mqttSystem.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
taosadapter @ f005d7bd
比较 09807060...f005d7bd
此差异已折叠。
src/query/inc/qAggMain.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/query/src/qAggMain.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/query/src/qExecutor.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/query/src/qExtbuffer.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/query/src/qFilter.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/rpc/src/rpcMain.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/sync/src/syncMain.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/tsdb/src/tsdbCommit.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/tsdb/src/tsdbRead.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/tsdb/src/tsdbReadImpl.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/inc/hashfunc.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/inc/tconfig.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/inc/tmd5.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/inc/ttoken.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/inc/tutil.h
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/src/tcompare.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/src/terror.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/src/thashutil.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/src/tmd5.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/src/tnettest.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/src/tsocket.c
浏览文件 @ 7a7e8072
此差异已折叠。
src/util/src/tutil.c
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/TD-13414.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/TD-13946.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/TD-14196.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/TD-5902.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/function_hll.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/nchar_funcs.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/query_window_keywords.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/scalar_expression.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/scalar_powlog.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/scalar_triangle.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/2-query/ts_shortcut.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/3-connectors/R/test.sh 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/3-connectors/TypeScript-REST/test.sh 0 → 100755
浏览文件 @ 7a7e8072
此差异已折叠。
tests/develop-test/3-connectors/php/test.sh 0 → 100755
浏览文件 @ 7a7e8072
此差异已折叠。
tests/docs-examples-test/test_c.sh 0 → 100755
浏览文件 @ 7a7e8072
此差异已折叠。
tests/docs-examples-test/test_csharp.sh 0 → 100755
浏览文件 @ 7a7e8072
此差异已折叠。
tests/docs-examples-test/test_go.sh 0 → 100755
浏览文件 @ 7a7e8072
此差异已折叠。
tests/docs-examples-test/test_java.sh 0 → 100755
浏览文件 @ 7a7e8072
此差异已折叠。
tests/docs-examples-test/test_node.sh 0 → 100755
浏览文件 @ 7a7e8072
此差异已折叠。
tests/docs-examples-test/test_python.sh 0 → 100755
浏览文件 @ 7a7e8072
此差异已折叠。
tests/docs-examples-test/test_rust.sh 0 → 100755
浏览文件 @ 7a7e8072
此差异已折叠。
tests/examples/C#/.gitignore 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/C#checker/C#checker.cs 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/insertCn/Program.cs 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/insertCn/TDengineDriver.cs 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/insertCn/insertCn.csproj 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/insertCn/lib/Utils.cs 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/jsonTag/JsonTag.cs 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/stmt/StmtDemo.cs 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/stmt/stmt.csproj 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/taosdemo/Dockerfile 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/taosdemo/README.md 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/taosdemo/taosdemo.cs 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/C#/taosdemo/taosdemo.csproj 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/JDBCDemo/.gitignore 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/JDBCDemo/pom.xml 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/JDBCDemo/readme.md 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/connectionPools/pom.xml 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/mybatisplus-demo/mvnw 已删除 100755 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/mybatisplus-demo/mvnw.cmd 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/mybatisplus-demo/pom.xml 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/readme.md 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/springbootdemo/.gitignore 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/springbootdemo/mvnw 已删除 100755 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/springbootdemo/mvnw.cmd 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/springbootdemo/pom.xml 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/springbootdemo/readme.md 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/taosdemo/.gitignore 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/taosdemo/mvnw 已删除 100755 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/taosdemo/mvnw.cmd 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/taosdemo/pom.xml 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/JDBC/taosdemo/readme.md 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/R/command.txt 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/bash/demo.csv 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/bash/demo.sql 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/CMakeLists.txt 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/apitest.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/asyncdemo.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/clientcfgtest-taosd.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/clientcfgtest-wrongjson.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/clientcfgtest-wrongtype.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/clientcfgtest-wrongvalue.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/clientcfgtest.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/connect_two_cluster.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/demo.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/epoll.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/makefile 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/parameter-binding.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/prepare.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/schemaless.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/sqlperf.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/stream.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/c/subscribe.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/go/taosdemo.go 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/OpenResty/conf/nginx.conf 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/OpenResty/logs/.gitignore 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/OpenResty/rest/config.lua 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/OpenResty/rest/test.lua 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/README.md 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/benchmark.lua 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/build.sh 已删除 100755 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/lua51/build.sh 已删除 100755 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/lua51/lauxlib.h 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/lua51/lua.h 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/lua51/lua_connector51.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/lua51/luaconf.h 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/lua51/luajit.h 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/lua51/lualib.h 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/lua_connector.c 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/lua/test.lua 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/matlab/TDengineDemo.m 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/nodejs/README-win.md 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/nodejs/node-example-raw.js 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/nodejs/node-example.js 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/nodejs/nodejsChecker.js 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/nodejs/test1970.js 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/python/read_example.py 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/python/taosdemo/README.md 已删除 100644 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/examples/python/taosdemo/taosdemo.py 已删除 100755 → 0
浏览文件 @ d78d8d22
此差异已折叠。
tests/parallel_test/cases.task
浏览文件 @ 7a7e8072
此差异已折叠。
tests/pytest/insert/line_insert.py
浏览文件 @ 7a7e8072
此差异已折叠。
tests/pytest/table/create.py
浏览文件 @ 7a7e8072
此差异已折叠。
tests/pytest/tools/taosdemoTest.py
浏览文件 @ 7a7e8072
此差异已折叠。
tests/pytest/tools/taosdumpTest.py
浏览文件 @ 7a7e8072
此差异已折叠。
tests/pytest/tools/taosdumpTest2.py
浏览文件 @ 7a7e8072
此差异已折叠。
tests/pytest/tools/taosdumpTest3.py
浏览文件 @ 7a7e8072
此差异已折叠。
tests/pytest/update/update2.py 0 → 100644
浏览文件 @ 7a7e8072
此差异已折叠。
tests/pytest/util/dnodes-default.py
浏览文件 @ 7a7e8072
此差异已折叠。
tests/pytest/util/dnodes.py
浏览文件 @ 7a7e8072
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或