建立连接
TDengine 提供了丰富的应用程序开发接口,为了便于用户快速开发自己的应用,TDengine 支持了多种编程语言的连接器,其中官方连接器包括支持 C/C++、Java、Python、Go、Node.js、C#、Rust、Lua(社区贡献)和 PHP (社区贡献)的连接器。这些连接器支持使用原生接口(taosc)和 REST 接口(部分语言暂不支持)连接 TDengine 集群。社区开发者也贡献了多个非官方连接器,例如 ADO.NET 连接器、Lua 连接器和 PHP 连接器。另外 TDengine 还可以直接调用 taosadapter 提供的 REST API 接口,进行数据写入和查询操作。
连接方式
连接器建立连接的方式,TDengine 提供三种:
- 通过客户端驱动程序 taosc 直接与服务端程序 taosd 建立连接,这种连接方式下文中简称 “原生连接”。
- 通过 taosAdapter 组件提供的 REST API 建立与 taosd 的连接,这种连接方式下文中简称 “REST 连接”
- 通过 taosAdapter 组件提供的 WebSocket API 建立与 taosd 的连接,这种连接方式下文中简称 “WebSocket 连接”
无论使用何种方式建立连接,连接器都提供了相同或相似的 API 操作数据库,都可以执行 SQL 语句,只是初始化连接的方式稍有不同,用户在使用上不会感到什么差别。 各种连接方式和各语言连接器支持情况请参考:连接器功能特性
关键不同点在于:
- 使用 原生连接,需要保证客户端的驱动程序 taosc 和服务端的 TDengine 版本保持一致。
- 使用 REST 连接,用户无需安装客户端驱动程序 taosc,具有跨平台易用的优势,但是无法体验数据订阅和二进制数据类型等功能。另外与 原生连接 和 WebSocket 连接相比,REST连接的性能最低。REST 接口是无状态的。在使用 REST 连接时,需要在 SQL 中指定表、超级表的数据库名称。
- 使用 WebSocket 连接,用户也无需安装客户端驱动程序 taosc。
- 连接云服务实例,必须使用 REST 连接 或 WebSocket 连接。
推荐使用 WebSocket 连接
安装客户端驱动 taosc
如果选择原生连接,而且应用程序不在 TDengine 同一台服务器上运行,你需要先安装客户端驱动,否则可以跳过此一步。为避免客户端驱动和服务端不兼容,请使用一致的版本。
安装步骤
- Linux
- Windows
- macOS
- 下载客户端安装包
-
解压缩软件包
将软件包放置在当前用户可读写的任意目录下,然后执行下面的命令:
tar -xzvf TDengine-client-VERSION.tar.gz
其中 VERSION 需要替换为实际版本的字符串。 -
执行安装脚本
解压软件包之后,会在解压目录下看到以下文件(目录):
- _ install_client.sh_:安装脚本,用于应用驱动程序
- _ package.tar.gz_:应用驱动安装包
- _ driver_:TDengine 应用驱动 driver
- examples: 各种编程语言的示例程序(c/C#/go/JDBC/MATLAB/python/R) 运行 install_client.sh 进行安装。
-
配置 taos.cfg
编辑
taos.cfg
文件(默认路径/etc/taos/taos.cfg),将firstEP
修改为 TDengine 服务器的 End Point,例如:h1.tdengine.com:6030
- 如本机没有部署 TDengine 服务,仅安装了应用驱动,则
taos.cfg
中仅需配置firstEP
,无需在本机配置FQDN
。 - 为防止与服务器端连接时出现“Unable to resolve FQDN”错误,建议确认本机的
/etc/hosts
文件已经配置了服务器正确的 FQDN 值,或配置好了 DNS 服务。
-
下载客户端安装包
下载 TDengine输入您的电子邮箱以接收下载链接同意涛思数据通过此邮件地址联系我 -
执行安装程序,按提示选择默认值,完成安装
-
安装路径
默认安装路径为:C:\TDengine,其中包括以下文件(目录):
- taos.exe:TDengine CLI 命令行程序
- taosadapter.exe:提供 RESTful 服务和接受其他多种软件写入请求的服务端可执行文件
- taosBenchmark.exe:TDengine 测试程序
- cfg : 配置文件目录
- driver: 应用驱动动态链接库
- examples: 示例程序 bash/C/C#/go/JDBC/Python/Node.js
- include: 头文件
- log : 日志文件
- unins000.exe: 卸载程序
-
配置 taos.cfg
编辑 taos.cfg 文件(默认路径 C:\TDengine\cfg\taos.cfg),将 firstEP 修改为 TDengine 服务器的 End Point,例如:
h1.tdengine.com:6030
。
- 如利用 FQDN 连接服务器,必须确认本机网络环境 DNS 已配置好,或在 hosts 文件中添加 FQDN 寻址记录, 如编辑 C:\Windows\system32\drivers\etc\hosts,添加类似如下的记录:
192.168.1.99 h1.taos.com
- 卸载:运行 unins000.exe 可卸载 TDengine 应用驱动。
-
下载客户端安装包
下载 TDengine输入您的电子邮箱以接收下载链接同意涛思数据通过此邮件地址联系我 -
执行安装程序,按提示选择默认值,完成安装。如果安装被阻止,可以右键或者按 Ctrl 点击安装包,选择
打开
。 -
配置 taos.cfg
编辑
taos.cfg
文件(默认路径/etc/taos/taos.cfg),将firstEP
修改为 TDengine 服务器的 End Point,例如:h1.tdengine.com:6030
- 如本机没有部署 TDengine 服务,仅 安装了应用驱动,则
taos.cfg
中仅需配置firstEP
,无需在本机配置FQDN
。 - 为防止与服务器端连接时出现“Unable to resolve FQDN”错误,建议确认本机的
/etc/hosts
文件已经配置了服务器正确的 FQDN 值,或配置好了 DNS 服务。
安装验证
以上安装和配置完成后,并确认 TDengine 服务已经正常启动运行,此时可以执行安装包里带有的 TDengine 命令行程序 taos 进行登录。
- Linux
- Windows
- macOS
在 Linux shell 下直接执行 taos
连接到 TDengine 服务,进入到 TDengine CLI 界面,示例如下:
$ taos
taos> show databases;
name |
=================================
information_schema |
performance_schema |
db |
Query OK, 3 rows in database (0.019154s)
taos>
在 cmd 下进入到 C:\TDengine 目录下直接执行 taos.exe
,连接到 TDengine 服务,进入到 TDengine CLI 界面,示例如下:
taos> show databases;
name | create_time | vgroups | ntables | replica | strict | duration | keep | buffer | pagesize | pages | minrows | maxrows | comp | precision | status | retention | single_stable | cachemodel | cachesize | wal_level | wal_fsync_period | wal_retention_period | wal_retention_size |
===============================================================================================================================================================================================================================================================================================================================================================================================================================
information_schema | NULL | NULL | 14 | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | ready | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL |
performance_schema | NULL | NULL | 3 | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | ready | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL |
test | 2022-08-04 16:46:40.506 | 2 | 0 | 1 | off | 14400m | 5256000m,5256000m,5256000m | 96 | 4 | 256 |
100 | 4096 | 2 | ms | ready | NULL | false | none | 1 | 1 | 3000 | 0 | 0 | 0 | 0 |
Query OK, 3 rows in database (0.123000s)
taos>
在 macOS shell 下直接执行 taos
连接到 TDengine 服务,进入到 TDengine CLI 界面,示例如下:
$ taos
taos> show databases;
name |
=================================
information_schema |
performance_schema |
db |
Query OK, 3 rows in database (0.019154s)
taos>
安装连接器
- Java
- Python
- Go
- Rust
- Node.js
- C#
- C
- REST API
如果使用 Maven 管理项目,只需在 pom.xml 中加入以下依赖。
<dependency>
<groupId>com.taosdata.jdbc</groupId>
<artifactId>taos-jdbcdriver</artifactId>
<version>3.4.0</version>
</dependency>
-
安装前准备
- 安装 Python。新近版本 taospy 包要求 Python 3.6.2+。早期版本 taospy 包要求 Python 3.7+。taos-ws-py 包要求 Python 3.7+。如果系统上还没有 Python 可参考 Python BeginnersGuide 安装。
- 安装 pip。大部分情况下 Python 的安装包都自带了 pip 工具, 如果没有请参考 pip documentation 安装。
- 如果使用原生连接,还需安装客户端驱动。客户端软件包含了 TDengine 客户端动态链接库(libtaos.so 或 taos.dll) 和 TDengine CLI。
-
使用 pip 安装
- 卸载旧版本
如果以前安装过旧版本的 Python 连接器, 请提前卸载。
pip3 uninstall taos taospy
pip3 uninstall taos taos-ws-py - 安装
taospy
- 最新版本
pip3 install taospy
- 指定某个特定版本安装
pip3 install taospy==2.3.0
- 从 GitHub 安装
pip3 install git+https://github.com/taosdata/taos-connector-python.git
此安装包为原生连接器 - 最新版本
- 安装
taos-ws-py
pip3 install taos-ws-py
此安装包为 WebSocket 连接器 - 同时安装
taospy
和taos-ws-py
pip3 install taospy[ws]
- 卸载旧版本
如果以前安装过旧版本的 Python 连接器, 请提前卸载。
-
安装验证
- 原生连接
- REST 连接
- WebSocket 连接
对于原生连接,需要验证客户端驱动和 Python 连接器本身是否都正确安装。如果能成功导入
taos
模块,则说明已经正确安装了客户端驱动和 Python 连接器。可在 Python 交互式 Shell 中输入:import taos
对于 REST 连接,只需验证是否能成功导入
taosrest
模块。可在 Python 交互式 Shell 中输入:import taosrest
对于 WebSocket 连接,只需验证是否能成功导入
taosws
模块。可在 Python 交互式 Shell 中输入:import taosws
编辑 go.mod
添加 driver-go
依赖即可。
module goexample
go 1.17
require github.com/taosdata/driver-go/v3 latest
driver-go 使用 cgo 封装了 taosc 的 API。cgo 需要使用 GCC 编译 C 的源码。因此需要确保你的系统上有 GCC。
编辑 Cargo.toml
添加 taos
依赖即可。
[dependencies]
taos = { version = "*"}
Rust 连接器通过不同的特性区分不同的连接方式。默认同时支持原生连接和 WebSocket 连接,如果仅需要建立 WebSocket 连接,可设置 ws
特性:
taos = { version = "*", default-features = false, features = ["ws"] }
-
安装前准备
- 安装 Node.js 开发环境, 使用14以上版本。下载链接: https://nodejs.org/en/download/
-
安装
- 使用 npm 安装 Node.js 连接器
npm install @tdengine/websocket
Node.js 目前只支持 WebSocket 连接 - 使用 npm 安装 Node.js 连接器
-
安装验证
- 新建安装验证目录,例如:
~/tdengine-test
,下载 GitHub 上 nodejsChecker.js 源代码到本地。 - 在命令行中执行以下命令。
npm init -y
npm install @tdengine/websocket
node nodejsChecker.js - 执行以上步骤后,在命令行会输出 nodeChecker.js 连接 TDengine 实例,并执行简单插入和查询的结果。
- 新建安装验证目录,例如:
编辑项目配置文件中添加 TDengine.Connector 的引用即可:
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<StartupObject>TDengineExample.AsyncQueryExample</StartupObject>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="TDengine.Connector" Version="3.1.0" />
</ItemGroup>
</Project>
也可通过 dotnet 命令添加:
dotnet add package TDengine.Connector
以下示例代码,均基于 dotnet6.0,如果使用其它版本,可能需要做适当调整。
如果已经安装了 TDengine 服务端软件或 TDengine 客户端驱动 taosc, 那么已经安装了 C 连接器,无需额外操作。
使用 REST API 方式访问 TDengine,无需安装任何驱动和连接器。
建立连接
在执行这一步之前,请确保有一个正在运行的,且可以访问到的 TDengine,而且服务端的 FQDN 配置正确。以下示例代码,都假设 TDengine 安装在本机,且 FQDN(默认 localhost) 和 serverPort(默认 6030) 都使用默认配置。
连接参数
连接的配置项较多,因此在建立连接之前,我们能先介绍一下各语言连接器建立连接使用的参数。
- Java
- Python
- Go
- Rust
- Node.js
- C#
- C
- REST API
Java 连接器建立连接的参数有 URL 和 Properties。
TDengine 的 JDBC URL 规范格式为:
jdbc:[TAOS|TAOS-WS|TAOS-RS]://[host_name]:[port]/[database_name]?[user={user}|&password={password}|&charset={charset}|&cfgdir={config_dir}|&locale={locale}|&timezone={timezone}|&batchfetch={batchfetch}]
URL 和 Properties 的详细参数说明和如何使用详见 url 规范
Python 连接器使用 connect()
方法来建立连接,下面是连接参数的具体说明:
- url:
taosAdapter
REST 服务的 URL。默认是localhost
的6041
端口。 - user: TDengine 用户名。默认是
root
。 - password: TDengine 用户密码。默认是
taosdata
。 - timeout: HTTP 请求超时时间。单位为秒。默认为
socket._GLOBAL_DEFAULT_TIMEOUT
。一般无需配置。
数据源名称具有通用格式,例如 PEAR DB,但没有类型前缀(方括号表示可选):
[username[:password]@][protocol[(address)]]/[dbname][?param1=value1&...¶mN=valueN]
完整形式的 DSN:
username:password@protocol(address)/dbname?param=value
支持的 DSN 参数如下
原生连接:
cfg
指定 taos.cfg 目录cgoThread
指定 cgo 同时执行的数量,默认为系统核数cgoAsyncHandlerPoolSize
指定异步函数的 handle 大小,默认为 10000
REST 连接:
disableCompression
是否接受压缩数据,默认为 true 不接受压缩数据,如果传输数据使用 gzip 压缩设置为 false。readBufferSize
读取数据的缓存区大小默认为 4K(4096),当查询结果数据量多时可以适当调大该值。token
连接云服务时使用的 token。skipVerify
是否跳过证书验证,默认为 false 不跳过证书验证,如果连接的是不安全的服务设置为 true。
WebSocket 连接:
enableCompression
是否发送压缩数据,默认为 false 不发送压缩数据,如果传输数据使用压缩设置为 true。readTimeout
读取数据的超时时间,默认为 5m。writeTimeout
写入数据的超时时间,默认为 10s。
Rust 连接器使用 DSN 来创建连接, DSN 描述字符串基本结构如下:
<driver>[+<protocol>]://[[<username>:<password>@]<host>:<port>][/<database>][?<p1>=<v1>[&<p2>=<v2>]]
|------|------------|---|-----------|-----------|------|------|------------|-----------------------|
|driver| protocol | | username | password | host | port | database | params |
DSN 的详细说明和如何使用详见 连接功能
Node.js 连接器使用 DSN 来创建连接, DSN 描述字符串基本结构如下:
[+<protocol>]://[[<username>:<password>@]<host>:<port>][/<database>][?<p1>=<v1>[&<p2>=<v2>]]
|------------|---|-----------|-----------|------|------|------------|-----------------------|
| protocol | | username | password | host | port | database | params |
-
protocol: 使用 websocket 协议建立连接。例如
ws://localhost:6041
-
username/password: 数据库的用户名和密码。
-
host/port: 主机地址和端口号。例如
localhost:6041
-
database: 数据库名称。
-
params: 其他参数。 例如token。
-
完整 DSN 示例:
ws://root:taosdata@localhost:6041
ConnectionStringBuilder 使用 key-value 对方式设置连接参数,key 为参数名,value 为参数值,不同参数之间使用分号 ;
分割。
例如:
"protocol=WebSocket;host=127.0.0.1;port=6041;useSSL=false"
支持的参数如下:
host
:TDengine 运行实例的地址。port
:TDengine 运行实例的端口。username
:连接的用户名。password
:连接的密码。protocol
:连接的协议,可选值为 Native 或 WebSocket,默认为 Native。db
:连接的数据库。timezone
:时区,默认为本地时区。connTimeout
:连接超时时间,默认为 1 分钟。
WebSocket 连接额外支持以下参数:
readTimeout
:读取超时时间,默认为 5 分钟。writeTimeout
:发送超时时间,默认为 10 秒。token
:连接 TDengine cloud 的 token。useSSL
:是否使用 SSL 连接,默认为 false。enableCompression
:是否启用 WebSocket 压缩,默认为 false。autoReconnect
:是否自动重连,默认为 false。reconnectRetryCount
:重连次数,默认为 3。reconnectIntervalMs
:重连间隔毫秒时间,默认为 2000。
WebSocket 连接
C/C++ 语言连接器 WebSocket 连接方式使用 ws_connect()
函数用于建立与 TDengine 数据库的连接。其参数为 DSN 描述字符串,其基本结构如下:
<driver>[+<protocol>]://[[<username>:<password>@]<host>:<port>][/<database>][?<p1>=<v1>[&<p2>=<v2>]]
|------|------------|---|-----------|-----------|------|------|------------|-----------------------|
|driver| protocol | | username | password | host | port | database | params |
DSN 的详细说明和如何使用详见 连接功能
原生连接
C/C++ 语言连接器原生连接方式使用 taos_connect()
函数用于建立与 TDengine 数据库的连接。其参数详细说明如下:
host
:要连接的数据库服务器的主机名或IP地址。如果是本地数据库,可以使用"localhost"
。user
:用于登录数据库的用户名。passwd
:与用户名对应的密码。db
:连接时默认选择的数据库名。如果不指定数据库,可以传递NULL
或空字符串。port
:数据库服务器监听的端口号。默认的端口号是6030
。
还提供了 taos_connect_auth()
函数用于使 用 MD5 加密的密码建立与 TDengine 数据库的连接。此函数与 taos_connect
功能相同,不同之处在于密码的处理方式,taos_connect_auth
需要的是密码的 MD5 加密字符串。
通过 REST API 方式访问 TDengine 时,应用程序直接与 taosAdapter 建立 HTTP 连接,建议使用连接池来管理连接。 使用 REST API 的参数具体可以参考:http-请求格式
WebSocket 连接
下面是各语言连接器建立 WebSocket 连接代码样例。演示了如何使用 WebSocket 连接方式连接到 TDengine 数据库,并对连接设定一些参数。整个过程主要涉及到数据库连接的建立和异常处理。
- Java
- Python
- Go
- Rust
- Node.js
- C#
- C
- REST API
public static void main(String[] args) throws Exception {
// use
// String jdbcUrl =
// "jdbc:TAOS-WS://localhost:6041/dbName?user=root&password=taosdata";
// if you want to connect a specified database named "dbName".
String jdbcUrl = "jdbc:TAOS-WS://localhost:6041?user=root&password=taosdata";
Properties connProps = new Properties();
connProps.setProperty(TSDBDriver.PROPERTY_KEY_ENABLE_AUTO_RECONNECT, "true");
connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
try (Connection conn = DriverManager.getConnection(jdbcUrl, connProps)) {
System.out.println("Connected to " + jdbcUrl + " successfully.");
// you can use the connection for execute SQL here
} catch (Exception ex) {
// please refer to the JDBC specifications for detailed exceptions info
System.out.printf("Failed to connect to %s, %sErrMessage: %s%n",
jdbcUrl,
ex instanceof SQLException ? "ErrCode: " + ((SQLException) ex).getErrorCode() + ", " : "",
ex.getMessage());
// Print stack trace for context in examples. Use logging in production.
ex.printStackTrace();
throw ex;
}
}
import taosws
def create_connection():
conn = None
host = "localhost"
port = 6041
try:
conn = taosws.connect(
user="root",
password="taosdata",
host=host,
port=port,
)
print(f"Connected to {host}:{port} successfully.");
except Exception as err:
print(f"Failed to connect to {host}:{port} , ErrMessage:{err}")
raise err
return conn
package main
import (
"database/sql"
"fmt"
"log"
_ "github.com/taosdata/driver-go/v3/taosWS"
)
func main() {
// use
// var taosDSN = "root:taosdata@ws(localhost:6041)/dbName"
// if you want to connect a specified database named "dbName".
var taosDSN = "root:taosdata@ws(localhost:6041)/"
taos, err := sql.Open("taosWS", taosDSN)
if err != nil {
log.Fatalln("Failed to connect to " + taosDSN + "; ErrMessage: " + err.Error())
}
fmt.Println("Connected to " + taosDSN + " successfully.")
defer taos.Close()
}
use taos::*;
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let dsn = "ws://localhost:6041".to_string();
match TaosBuilder::from_dsn(&dsn)?.build().await {
Ok(_taos) => {
println!("Connected to {} successfully.", dsn);
Ok(())
}
Err(err) => {
eprintln!("Failed to connect to {}, ErrMessage: {}", dsn, err);
return Err(err.into());
}
}
}
const taos = require("@tdengine/websocket");
let dsn = 'ws://localhost:6041';
async function createConnect() {
try {
let conf = new taos.WSConfig(dsn);
conf.setUser('root');
conf.setPwd('taosdata');
conf.setDb('power');
conn = await taos.sqlConnect(conf);
console.log("Connected to " + dsn + " successfully.");
return conn;
} catch (err) {
console.log("Failed to connect to " + dsn + ", ErrCode: " + err.code + ", ErrMessage: " + err.message);
throw err;
}
}
static void Main(string[] args)
{
var connectionString =
"protocol=WebSocket;host=localhost;port=6041;useSSL=false;username=root;password=taosdata";
try
{
// Connect to TDengine server using WebSocket
var builder = new ConnectionStringBuilder(connectionString);
// Open connection with using block, it will close the connection automatically
using (var client = DbDriver.Open(builder))
{
Console.WriteLine("Connected to " + connectionString + " successfully.");
}
}
catch (TDengineError e)
{
// handle TDengine error
Console.WriteLine("Failed to connect to " + connectionString + "; ErrCode:" + e.Code +
"; ErrMessage: " + e.Error);
throw;
}
catch (Exception e)
{
// handle other exceptions
Console.WriteLine("Failed to connect to " + connectionString + "; Err:" + e.Message);
throw;
}
}
// compile with
// gcc connect_example.c -o connect_example -ltaos
#include <stdio.h>
#include <stdlib.h>
#include "taosws.h"
int main() {
ws_enable_log("debug");
char *dsn = "ws://localhost:6041";
WS_TAOS *taos = ws_connect(dsn);
if (taos == NULL) {
fprintf(stderr, "Failed to connect to %s, ErrCode: 0x%x, ErrMessage: %s.\n", dsn, ws_errno(NULL), ws_errstr(NULL));
return -1;
}
fprintf(stdout, "Connected to %s successfully.\n", dsn);
/* put your code here for read and write */
// close & clean
ws_close(taos);
}
不支持
原生连接
下面是各语言连接器建立原生连接代码样例。演示了如何使用原生连接方式连接到 TDengine 数据库,并对连接设定一些参数。整个过程主要涉及到数据库连接的建立和异常处理。
- Java
- Python
- Go
- Rust
- Node.js
- C#
- C
- REST API
public static void main(String[] args) throws Exception {
// use
// String jdbcUrl =
// "jdbc:TAOS://localhost:6030/dbName?user=root&password=taosdata";
// if you want to connect a specified database named "dbName".
String jdbcUrl = "jdbc:TAOS://localhost:6030?user=root&password=taosdata";
Properties connProps = new Properties();
connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
try (Connection conn = DriverManager.getConnection(jdbcUrl, connProps)) {
System.out.println("Connected to " + jdbcUrl + " successfully.");
// you can use the connection for execute SQL here
} catch (Exception ex) {
// please refer to the JDBC specifications for detailed exceptions info
System.out.printf("Failed to connect to %s, %sErrMessage: %s%n",
jdbcUrl,
ex instanceof SQLException ? "ErrCode: " + ((SQLException) ex).getErrorCode() + ", " : "",
ex.getMessage());
// Print stack trace for context in examples. Use logging in production.
ex.printStackTrace();
throw ex;
}
}
import taos
def create_connection():
# all parameters are optional.
conn = None
host = "localhost"
port = 6030
try:
conn = taos.connect(
user="root",
password="taosdata",
host=host,
port=port,
)
print(f"Connected to {host}:{port} successfully.");
except Exception as err:
print(f"Failed to connect to {host}:{port} , ErrMessage:{err}")
raise err
finally:
if conn:
conn.close()
if __name__ == "__main__":
create_connection()
package main
import (
"database/sql"
"fmt"
"log"
_ "github.com/taosdata/driver-go/v3/taosSql"
)
func main() {
// use
// var taosDSN = "root:taosdata@tcp(localhost:6030)/dbName"
// if you want to connect a specified database named "dbName".
var taosDSN = "root:taosdata@tcp(localhost:6030)/"
taos, err := sql.Open("taosSql", taosDSN)
if err != nil {
log.Fatalln("Failed to connect to " + taosDSN + "; ErrMessage: " + err.Error())
}
fmt.Println("Connected to " + taosDSN + " successfully.")
defer taos.Close()
}
use taos::*;
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let dsn = "taos://localhost:6030".to_string();
match TaosBuilder::from_dsn(&dsn)?.build().await {
Ok(_taos) => {
println!("Connected to {} successfully.", dsn);
Ok(())
}
Err(err) => {
eprintln!("Failed to connect to {}, ErrMessage: {}", dsn, err);
return Err(err.into());
}
}
}
不支持
static void Main(String[] args)
{
var connectionString = "host=127.0.0.1;port=6030;username=root;password=taosdata";
try
{
// Connect to TDengine server using Native
var builder = new ConnectionStringBuilder(connectionString);
// Open connection with using block, it will close the connection automatically
using (var client = DbDriver.Open(builder))
{
Console.WriteLine("Connected to " + connectionString + " successfully.");
}
}
catch (TDengineError e)
{
// handle TDengine error
Console.WriteLine("Failed to connect to " + connectionString + "; ErrCode:" + e.Code + "; ErrMessage: " + e.Error);
throw;
}
catch (Exception e)
{
// handle other exceptions
Console.WriteLine("Failed to connect to " + connectionString + "; Err:" + e.Message);
throw;
}
}
// compile with
// gcc connect_example.c -o connect_example -ltaos
#include <stdio.h>
#include <stdlib.h>
#include "taos.h"
int main() {
const char *host = "localhost";
const char *user = "root";
const char *passwd = "taosdata";
const char *db = NULL; // if don't want to connect to a default db, set it to NULL or ""
uint16_t port = 6030; // 0 means use the default port
TAOS *taos = taos_connect(host, user, passwd, db, port);
if (taos == NULL) {
fprintf(stderr, "Failed to connect to %s:%hu, ErrCode: 0x%x, ErrMessage: %s.\n", host, port, taos_errno(NULL), taos_errstr(NULL));
taos_cleanup();
return -1;
}
fprintf(stdout, "Connected to %s:%hu successfully.\n", host, port);
/* put your code here for read and write */
// close & clean
taos_close(taos);
taos_cleanup();
}
不支持
REST 连接
下面是各语言连接器建立 REST 连接代码样例。演示了如何使用 REST 连接方式连接到 TDengine 数据库。整个过程主要涉及到数据库连接的建立和异常处理。
- Java
- Python
- Go
- Rust
- Node.js
- C#
- C
- REST API
public static void main(String[] args) throws Exception {
String jdbcUrl = "jdbc:TAOS-RS://localhost:6041?user=root&password=taosdata";
try (Connection conn = DriverManager.getConnection(jdbcUrl)) {
System.out.println("Connected to " + jdbcUrl + " successfully.");
// you can use the connection for execute SQL here
} catch (Exception ex) {
// please refer to the JDBC specifications for detailed exceptions info
System.out.printf("Failed to connect to %s, %sErrMessage: %s%n",
jdbcUrl,
ex instanceof SQLException ? "ErrCode: " + ((SQLException) ex).getErrorCode() + ", " : "",
ex.getMessage());
// Print stack trace for context in examples. Use logging in production.
ex.printStackTrace();
throw ex;
}
}
import taosrest
def create_connection():
conn = None
url="http://localhost:6041"
try:
conn = taosrest.connect(url=url,
user="root",
password="taosdata",
timeout=30)
print(f"Connected to {url} successfully.");
except Exception as err:
print(f"Failed to connect to {url} , ErrMessage:{err}")
finally:
if conn:
conn.close()
package main
import (
"database/sql"
"fmt"
"log"
_ "github.com/taosdata/driver-go/v3/taosRestful"
)
func main() {
// use
// var taosDSN = "root:taosdata@http(localhost:6041)/dbName"
// if you want to connect a specified database named "dbName".
var taosDSN = "root:taosdata@http(localhost:6041)/"
taos, err := sql.Open("taosRestful", taosDSN)
if err != nil {
log.Fatalln("Failed to connect to " + taosDSN + "; ErrMessage: " + err.Error())
}
fmt.Println("Connected to " + taosDSN + " successfully.")
defer taos.Close()
}
不支持
不支持
不支持
不支持
使用 REST API 方式访问 TDengine,由应用程序自主去建立 HTTP 连接。
如果建立连接失败,大部分情况下是 FQDN 或防火墙的配置不正确,详细的排查方法请看《常见问题及反馈》中的“遇到错误 Unable to establish connection, 我怎么办?”
连接池
有些连接器提供了连接池,或者可以与已有的连接池组件配合使用。 使用连接池,应用程序可以快速地从连接池中获取可用连接,避免了每次操作时创建和销毁连接的开销。这不仅减少了资源消耗,还提高了响应速度。此外,连接池还支持对连接的管理,如最大连接数限制、连接的有效性检查,确保了连接的高效和可靠使用。我们推荐使用连接池管理连接。
下面是各语言连接器的连接池支持代码样例。
- Java
- Python
- Go
- Rust
HikariCP
使用示例如下:
public static void main(String[] args) throws Exception {
HikariConfig config = new HikariConfig();
// jdbc properties
config.setJdbcUrl("jdbc:TAOS-WS://127.0.0.1:6041/log");
config.setUsername("root");
config.setPassword("taosdata");
// connection pool configurations
config.setMinimumIdle(10); // minimum number of idle connection
config.setMaximumPoolSize(10); // maximum number of connection in the pool
config.setConnectionTimeout(30000); // maximum wait milliseconds for get connection from pool
config.setMaxLifetime(0); // maximum life time for each connection
config.setIdleTimeout(0); // max idle time for recycle idle connection
config.setConnectionTestQuery("SELECT SERVER_VERSION()"); // validation query
HikariDataSource dataSource = new HikariDataSource(config); // create datasource
Connection connection = dataSource.getConnection(); // get connection
Statement statement = connection.createStatement(); // get statement
// query or insert
// ...
statement.close();
connection.close(); // put back to connection pool
dataSource.close();
}
通过 HikariDataSource.getConnection() 获取连接后,使用完成后需要调用 close() 方法,实际上它并不会关闭连接,只是放回连接池中。 更多 HikariCP 使用问题请查看官方说明。
Druid
使用示例如下:
public static void main(String[] args) throws Exception {
String url = "jdbc:TAOS-WS://127.0.0.1:6041/log";
DruidDataSource dataSource = new DruidDataSource();
// jdbc properties
dataSource.setDriverClassName("com.taosdata.jdbc.ws.WebSocketDriver");
dataSource.setUrl(url);
dataSource.setUsername("root");
dataSource.setPassword("taosdata");
// pool configurations
dataSource.setInitialSize(10);
dataSource.setMinIdle(10);
dataSource.setMaxActive(10);
dataSource.setMaxWait(30000);
dataSource.setValidationQuery("SELECT SERVER_VERSION()");
Connection connection = dataSource.getConnection(); // get connection
Statement statement = connection.createStatement(); // get statement
// query or insert
// ...
statement.close();
connection.close(); // put back to connection pool
dataSource.close();
}
更多 druid 使用问题请查看官方说明。
import taos
def create_connection():
# all parameters are optional.
conn = None
host = "localhost"
port = 6030
try:
conn = taos.connect(
user="root",
password="taosdata",
host=host,
port=port,
)
print(f"Connected to {host}:{port} successfully.");
except Exception as err:
print(f"Failed to connect to {host}:{port} , ErrMessage:{err}")
raise err
finally:
if conn:
conn.close()
if __name__ == "__main__":
create_connection()
使用 sql.Open
创建出来的连接已经实现了连接池,可以通过 API 设置连接池参数,样例如下
// SetMaxOpenConns sets the maximum number of open connections to the database. 0 means unlimited.
taos.SetMaxOpenConns(0)
// SetMaxIdleConns sets the maximum number of connections in the idle connection pool.
taos.SetMaxIdleConns(2)
// SetConnMaxLifetime sets the maximum amount of time a connection may be reused.
taos.SetConnMaxLifetime(0)
// SetConnMaxIdleTime sets the maximum amount of time a connection may be idle.
taos.SetConnMaxIdleTime(0)
在复杂应用中,建议启用连接池。[taos] 的连接池默认(异步模式)使用 [deadpool] 实现。
如下,可以生成一个默认参数的连接池。
let pool: Pool<TaosBuilder> = TaosBuilder::from_dsn("taos:///")
.unwrap()
.pool()
.unwrap();
同样可以使用连接池的构造器,对连接池参数进行设置:
let pool: Pool<TaosBuilder> = Pool::builder(Manager::from_dsn(self.dsn.clone()).unwrap().0)
.max_size(88) // 最大连接数
.build()
.unwrap();
在应用代码中,使用 pool.get()?
来获取一个连接对象 [Taos]。
let taos = pool.get()?;