TDengine Java Connector

taos-jdbcdriver 是 TDengine 的官方 Java 语言连接器，Java 开发人员可以通过它开发存取 TDengine 数据库的应用软件。taos-jdbcdriver 实现了 JDBC driver 标准的接口，并提供两种形式的连接器。一种是通过 TDengine 客户端驱动程序（taosc）原生连接 TDengine 实例，支持数据写入、查询、订阅、schemaless 接口和参数绑定接口等功能，一种是通过 taosAdapter 提供的 REST 接口连接 TDengine 实例。REST 连接实现的功能集合和原生连接有少量不同。

TDengine Database Connector Java

上图显示了两种 Java 应用使用连接器访问 TDengine 的两种方式：

  • JDBC 原生连接：Java 应用在物理节点 1（pnode1）上使用 TSDBDriver 直接调用客户端驱动（libtaos.so 或 taos.dll）的 API 将写入和查询请求发送到位于物理节点 2（pnode2）上的 taosd 实例。
  • JDBC REST 连接：Java 应用通过 RestfulDriver 将 SQL 封装成一个 REST 请求，发送给物理节点 2 的 REST 服务器（taosAdapter），通过 REST 服务器请求 taosd 并返回结果。

使用 REST 连接，不依赖 TDengine 客户端驱动，可以跨平台，更加方便灵活，但性能比原生连接器低约 30%。

Java - 图2info

TDengine 的 JDBC 驱动实现尽可能与关系型数据库驱动保持一致，但 TDengine 与关系对象型数据库的使用场景和技术特征存在差异，所以taos-jdbcdriver 与传统的 JDBC driver 也存在一定差异。在使用时需要注意以下几点：

  • TDengine 目前不支持针对单条数据记录的删除操作。
  • 目前不支持事务操作。

支持的平台

原生连接支持的平台和 TDengine 客户端驱动支持的平台一致。 REST 连接支持所有能运行 Java 的平台。

版本支持

请参考版本支持列表

TDengine DataType 和 Java DataType

TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对应类型转换如下：

TDengine DataTypeJDBCType
TIMESTAMPjava.sql.Timestamp
INTjava.lang.Integer
BIGINTjava.lang.Long
FLOATjava.lang.Float
DOUBLEjava.lang.Double
SMALLINTjava.lang.Short
TINYINTjava.lang.Byte
BOOLjava.lang.Boolean
BINARYbyte array
NCHARjava.lang.String
JSONjava.lang.String

注意：JSON 类型仅在 tag 中支持。

安装步骤

安装前准备

使用 Java Connector 连接数据库前，需要具备以下条件：

  • 已安装 Java 1.8 或以上版本运行时环境和 Maven 3.6 或以上版本
  • 已安装 TDengine 客户端驱动（使用原生连接必须安装，使用 REST 连接无需安装），具体步骤请参考安装客户端驱动

安装连接器

  • 使用 Maven 安装
  • 使用源码编译安装

目前 taos-jdbcdriver 已经发布到 Sonatype Repository 仓库，且各大仓库都已同步。

Maven 项目中，在 pom.xml 中添加以下依赖：

  1. <dependency>
  2.   <groupId>com.taosdata.jdbc</groupId>
  3.   <artifactId>taos-jdbcdriver</artifactId>
  4.   <version>3.0.0</version>
  5. </dependency>

可以通过下载 TDengine 的源码，自己编译最新版本的 Java connector

  1. git clone https://github.com/taosdata/taos-connector-jdbc.git
  2. cd taos-connector-jdbc
  3. mvn clean install -Dmaven.test.skip=true

编译后，在 target 目录下会产生 taos-jdbcdriver-3.0.*-dist.jar 的 jar 包，并自动将编译的 jar 文件放在本地的 Maven 仓库中。

建立连接

TDengine 的 JDBC URL 规范格式为： jdbc:[TAOS|TAOS-RS]://[host_name]:[port]/[database_name]?[user={user}|&password={password}|&charset={charset}|&cfgdir={config_dir}|&locale={locale}|&timezone={timezone}]

对于建立连接，原生连接与 REST 连接有细微不同。

  • 原生连接
  • REST 连接
  1. Class.forName("com.taosdata.jdbc.TSDBDriver");
  2. String jdbcUrl = "jdbc:TAOS://taosdemo.com:6030/test?user=root&password=taosdata";
  3. Connection conn = DriverManager.getConnection(jdbcUrl);

以上示例，使用了 JDBC 原生连接的 TSDBDriver，建立了到 hostname 为 taosdemo.com，端口为 6030（TDengine 的默认端口），数据库名为 test 的连接。这个 URL 中指定用户名（user）为 root，密码（password）为 taosdata。

注意：使用 JDBC 原生连接，taos-jdbcdriver 需要依赖客户端驱动（Linux 下是 libtaos.so；Windows 下是 taos.dll；macOS 下是 libtaos.dylib）。

url 中的配置参数如下：

  • user：登录 TDengine 用户名，默认值 ‘root’。
  • password：用户登录密码，默认值 ‘taosdata’。
  • cfgdir：客户端配置文件目录路径，Linux OS 上默认值 /etc/taos，Windows OS 上默认值 C:/TDengine/cfg。
  • charset：客户端使用的字符集，默认值为系统字符集。
  • locale：客户端语言环境，默认值系统当前 locale。
  • timezone：客户端使用的时区，默认值为系统当前时区。
  • batchfetch: true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：true。开启批量拉取同时获取一批数据在查询数据量较大时批量拉取可以有效的提升查询性能。
  • batchErrorIgnore：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败将继续执行下面的 SQL。false：不再执行失败 SQL 后的任何语句。默认值为：false。

JDBC 原生连接的使用请参见视频教程。

使用 TDengine 客户端驱动配置文件建立连接

当使用 JDBC 原生连接连接 TDengine 集群时，可以使用 TDengine 客户端驱动配置文件，在配置文件中指定集群的 firstEp、secondEp 等参数。如下所示：

  1. 在 Java 应用中不指定 hostname 和 port
  1. public Connection getConn() throws Exception{
  2.   Class.forName("com.taosdata.jdbc.TSDBDriver");
  3.   String jdbcUrl = "jdbc:TAOS://:/test?user=root&password=taosdata";
  4.   Properties connProps = new Properties();
  5.   connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
  6.   connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
  7.   connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
  8.   Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
  9.   return conn;
  10. }
  1. 在配置文件中指定 firstEp 和 secondEp
  1. # first fully qualified domain name (FQDN) for TDengine system
  2. firstEp cluster_node1:6030
  4. # second fully qualified domain name (FQDN) for TDengine system, for cluster only
  5. secondEp cluster_node2:6030
  7. # default system charset
  8. # charset UTF-8
  10. # system locale
  11. # locale en_US.UTF-8

以上示例，jdbc 会使用客户端的配置文件，建立到 hostname 为 cluster_node1、端口为 6030、数据库名为 test 的连接。当集群中 firstEp 节点失效时，JDBC 会尝试使用 secondEp 连接集群。

TDengine 中，只要保证 firstEp 和 secondEp 中一个节点有效，就可以正常建立到集群的连接。

注意：这里的配置文件指的是调用 JDBC Connector 的应用程序所在机器上的配置文件，Linux OS 上默认值 /etc/taos/taos.cfg ，Windows OS 上默认值 C://TDengine/cfg/taos.cfg。

  1. Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
  2. String jdbcUrl = "jdbc:TAOS-RS://taosdemo.com:6041/test?user=root&password=taosdata";
  3. Connection conn = DriverManager.getConnection(jdbcUrl);

以上示例，使用了 JDBC REST 连接的 RestfulDriver，建立了到 hostname 为 taosdemo.com，端口为 6041，数据库名为 test 的连接。这个 URL 中指定用户名（user）为 root，密码（password）为 taosdata。

使用 JDBC REST 连接，不需要依赖客户端驱动。与 JDBC 原生连接相比，仅需要：

  1. driverClass 指定为“com.taosdata.jdbc.rs.RestfulDriver”；
  2. jdbcUrl 以“jdbc:TAOS-RS://”开头；
  3. 使用 6041 作为连接端口。

url 中的配置参数如下：

  • user：登录 TDengine 用户名，默认值 ‘root’。
  • password：用户登录密码，默认值 ‘taosdata’。
  • batchfetch: true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：false。逐行拉取结果集使用 HTTP 方式进行数据传输。JDBC REST 连接支持批量拉取数据功能。taos-jdbcdriver 与 TDengine 之间通过 WebSocket 连接进行数据传输。相较于 HTTP，WebSocket 可以使 JDBC REST 连接支持大数据量查询，并提升查询性能。
  • charset: 当开启批量拉取数据时，指定解析字符串数据的字符集。
  • batchErrorIgnore：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败，继续执行下面的 SQL 了。false：不再执行失败 SQL 后的任何语句。默认值为：false。
  • httpConnectTimeout: 连接超时时间，单位 ms， 默认值为 5000。
  • httpSocketTimeout: socket 超时时间，单位 ms，默认值为 5000。仅在 batchfetch 设置为 false 时生效。
  • messageWaitTimeout: 消息超时时间, 单位 ms， 默认值为 3000。 仅在 batchfetch 设置为 true 时生效。
  • useSSL: 连接中是否使用 SSL。

注意：部分配置项（比如：locale、timezone）在 REST 连接中不生效。

Java - 图3note
  • 与原生连接方式不同，REST 接口是无状态的。在使用 JDBC REST 连接时，需要在 SQL 中指定表、超级表的数据库名称。例如：
  1. INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('California.SanFrancisco') VALUES(now, 24.6);
  • 如果在 url 中指定了 dbname，那么，JDBC REST 连接会默认使用/rest/sql/dbname 作为 restful 请求的 url，在 SQL 中不需要指定 dbname。例如：url 为 jdbc:TAOS-RS://127.0.0.1:6041/test，那么，可以执行 sql：insert into t1 using weather(ts, temperature) tags(‘California.SanFrancisco’) values(now, 24.6);

指定 URL 和 Properties 获取连接

除了通过指定的 URL 获取连接，还可以使用 Properties 指定建立连接时的参数。

注意：

  • 应用中设置的 client parameter 为进程级别的，即如果要更新 client 的参数，需要重启应用。这是因为 client parameter 是全局参数，仅在应用程序的第一次设置生效。
  • 以下示例代码基于 taos-jdbcdriver-3.0.0。
  1. public Connection getConn() throws Exception{
  2.   Class.forName("com.taosdata.jdbc.TSDBDriver");
  3.   String jdbcUrl = "jdbc:TAOS://taosdemo.com:6030/test?user=root&password=taosdata";
  4.   Properties connProps = new Properties();
  5.   connProps.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
  6.   connProps.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
  7.   connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
  8.   connProps.setProperty("debugFlag", "135");
  9.   connProps.setProperty("maxSQLLength", "1048576");
  10.   Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
  11.   return conn;
  12. }
  14. public Connection getRestConn() throws Exception{
  15.   Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
  16.   String jdbcUrl = "jdbc:TAOS-RS://taosdemo.com:6041/test?user=root&password=taosdata";
  17.   Properties connProps = new Properties();
  18.   connProps.setProperty(TSDBDriver.PROPERTY_KEY_BATCH_LOAD, "true");
  19.   Connection conn = DriverManager.getConnection(jdbcUrl, connProps);
  20.   return conn;
  21. }

以上示例，建立一个到 hostname 为 taosdemo.com，端口为 6030/6041，数据库名为 test 的连接。这个连接在 url 中指定了用户名(user)为 root，密码（password）为 taosdata，并在 connProps 中指定了使用的字符集、语言环境、时区、是否开启批量拉取等信息。

properties 中的配置参数如下：

  • TSDBDriver.PROPERTY_KEY_USER：登录 TDengine 用户名，默认值 ‘root’。
  • TSDBDriver.PROPERTY_KEY_PASSWORD：用户登录密码，默认值 ‘taosdata’。
  • TSDBDriver.PROPERTY_KEY_BATCH_LOAD: true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：false。
  • TSDBDriver.PROPERTY_KEY_BATCH_ERROR_IGNORE：true：在执行 Statement 的 executeBatch 时，如果中间有一条 SQL 执行失败，继续执行下面的 sq 了。false：不再执行失败 SQL 后的任何语句。默认值为：false。
  • TSDBDriver.PROPERTY_KEY_CONFIG_DIR：仅在使用 JDBC 原生连接时生效。客户端配置文件目录路径，Linux OS 上默认值 /etc/taos，Windows OS 上默认值 C:/TDengine/cfg。
  • TSDBDriver.PROPERTY_KEY_CHARSET：客户端使用的字符集，默认值为系统字符集。
  • TSDBDriver.PROPERTY_KEY_LOCALE：仅在使用 JDBC 原生连接时生效。 客户端语言环境，默认值系统当前 locale。
  • TSDBDriver.PROPERTY_KEY_TIME_ZONE：仅在使用 JDBC 原生连接时生效。 客户端使用的时区，默认值为系统当前时区。
  • TSDBDriver.HTTP_CONNECT_TIMEOUT: 连接超时时间，单位 ms， 默认值为 5000。仅在 REST 连接时生效。
  • TSDBDriver.HTTP_SOCKET_TIMEOUT: socket 超时时间，单位 ms，默认值为 5000。仅在 REST 连接且 batchfetch 设置为 false 时生效。
  • TSDBDriver.PROPERTY_KEY_MESSAGE_WAIT_TIMEOUT: 消息超时时间, 单位 ms， 默认值为 3000。 仅在 REST 连接且 batchfetch 设置为 true 时生效。
  • TSDBDriver.PROPERTY_KEY_USE_SSL: 连接中是否使用 SSL。仅在 REST 连接时生效。 此外对 JDBC 原生连接，通过指定 URL 和 Properties 还可以指定其他参数，比如日志级别、SQL 长度等。更多详细配置请参考客户端配置。

配置参数的优先级

通过前面三种方式获取连接，如果配置参数在 url、Properties、客户端配置文件中有重复，则参数的优先级由高到低分别如下：

  1. JDBC URL 参数，如上所述，可以在 JDBC URL 的参数中指定。
  2. Properties connProps
  3. 使用原生连接时，TDengine 客户端驱动的配置文件 taos.cfg

例如：在 url 中指定了 password 为 taosdata，在 Properties 中指定了 password 为 taosdemo，那么，JDBC 会使用 url 中的 password 建立连接。

使用示例

创建数据库和表

  1. Statement stmt = conn.createStatement();
  3. // create database
  4. stmt.executeUpdate("create database if not exists db");
  6. // use database
  7. stmt.executeUpdate("use db");
  9. // create table
  10. stmt.executeUpdate("create table if not exists tb (ts timestamp, temperature int, humidity float)");

注意：如果不使用 use db 指定数据库，则后续对表的操作都需要增加数据库名称作为前缀，如 db.tb。

插入数据

  1. // insert data
  2. int affectedRows = stmt.executeUpdate("insert into tb values(now, 23, 10.3) (now + 1s, 20, 9.3)");
  4. System.out.println("insert " + affectedRows + " rows.");

now 为系统内部函数，默认为客户端所在计算机当前时间。 now + 1s 代表客户端当前时间往后加 1 秒，数字后面代表时间单位：a(毫秒)，s(秒)，m(分)，h(小时)，d(天)，w(周)，n(月)，y(年)。

查询数据

  1. // query data
  2. ResultSet resultSet = stmt.executeQuery("select * from tb");
  4. Timestamp ts = null;
  5. int temperature = 0;
  6. float humidity = 0;
  7. while(resultSet.next()){
  9.     ts = resultSet.getTimestamp(1);
  10.     temperature = resultSet.getInt(2);
  11.     humidity = resultSet.getFloat("humidity");
  13.     System.out.printf("%s, %d, %s\n", ts, temperature, humidity);
  14. }

查询和操作关系型数据库一致，使用下标获取返回字段内容时从 1 开始，建议使用字段名称获取。

处理异常

在报错后，通过 SQLException 可以获取到错误的信息和错误码：

  1. try (Statement statement = connection.createStatement()) {
  2.     // executeQuery
  3.     ResultSet resultSet = statement.executeQuery(sql);
  4.     // print result
  5.     printResult(resultSet);
  6. } catch (SQLException e) {
  7.     System.out.println("ERROR Message: " + e.getMessage());
  8.     System.out.println("ERROR Code: " + e.getErrorCode());
  9.     e.printStackTrace();
  10. }

JDBC 连接器可能报错的错误码包括 3 种：JDBC driver 本身的报错（错误码在 0x2301 到 0x2350 之间），原生连接方法的报错（错误码在 0x2351 到 0x2400 之间），TDengine 其他功能模块的报错。

具体的错误码请参考：

通过参数绑定写入数据

TDengine 的 JDBC 原生连接实现大幅改进了参数绑定方式对数据写入（INSERT）场景的支持。采用这种方式写入数据时，能避免 SQL 语法解析的资源消耗，从而在很多情况下显著提升写入性能。

注意：

  • JDBC REST 连接目前不支持参数绑定
  • 以下示例代码基于 taos-jdbcdriver-3.0.0
  • binary 类型数据需要调用 setString 方法，nchar 类型数据需要调用 setNString 方法
  • setString 和 setNString 都要求用户在 size 参数里声明表定义中对应列的列宽
  1. public class ParameterBindingDemo {
  3.     private static final String host = "127.0.0.1";
  4.     private static final Random random = new Random(System.currentTimeMillis());
  5.     private static final int BINARY_COLUMN_SIZE = 30;
  6.     private static final String[] schemaList = {
  7.             "create table stable1(ts timestamp, f1 tinyint, f2 smallint, f3 int, f4 bigint) tags(t1 tinyint, t2 smallint, t3 int, t4 bigint)",
  8.             "create table stable2(ts timestamp, f1 float, f2 double) tags(t1 float, t2 double)",
  9.             "create table stable3(ts timestamp, f1 bool) tags(t1 bool)",
  10.             "create table stable4(ts timestamp, f1 binary(" + BINARY_COLUMN_SIZE + ")) tags(t1 binary(" + BINARY_COLUMN_SIZE + "))",
  11.             "create table stable5(ts timestamp, f1 nchar(" + BINARY_COLUMN_SIZE + ")) tags(t1 nchar(" + BINARY_COLUMN_SIZE + "))"
  12.     };
  13.     private static final int numOfSubTable = 10, numOfRow = 10;
  15.     public static void main(String[] args) throws SQLException {
  17.         String jdbcUrl = "jdbc:TAOS://" + host + ":6030/";
  18.         Connection conn = DriverManager.getConnection(jdbcUrl, "root", "taosdata");
  20.         init(conn);
  22.         bindInteger(conn);
  24.         bindFloat(conn);
  26.         bindBoolean(conn);
  28.         bindBytes(conn);
  30.         bindString(conn);
  32.         conn.close();
  33.     }
  35.     private static void init(Connection conn) throws SQLException {
  36.         try (Statement stmt = conn.createStatement()) {
  37.             stmt.execute("drop database if exists test_parabind");
  38.             stmt.execute("create database if not exists test_parabind");
  39.             stmt.execute("use test_parabind");
  40.             for (int i = 0; i < schemaList.length; i++) {
  41.                 stmt.execute(schemaList[i]);
  42.             }
  43.         }
  44.     }
  46.     private static void bindInteger(Connection conn) throws SQLException {
  47.         String sql = "insert into ? using stable1 tags(?,?,?,?) values(?,?,?,?,?)";
  49.         try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
  51.             for (int i = 1; i <= numOfSubTable; i++) {
  52.                 // set table name
  53.                 pstmt.setTableName("t1_" + i);
  54.                 // set tags
  55.                 pstmt.setTagByte(0, Byte.parseByte(Integer.toString(random.nextInt(Byte.MAX_VALUE))));
  56.                 pstmt.setTagShort(1, Short.parseShort(Integer.toString(random.nextInt(Short.MAX_VALUE))));
  57.                 pstmt.setTagInt(2, random.nextInt(Integer.MAX_VALUE));
  58.                 pstmt.setTagLong(3, random.nextLong());
  59.                 // set columns
  60.                 ArrayList<Long> tsList = new ArrayList<>();
  61.                 long current = System.currentTimeMillis();
  62.                 for (int j = 0; j < numOfRow; j++)
  63.                     tsList.add(current + j);
  64.                 pstmt.setTimestamp(0, tsList);
  66.                 ArrayList<Byte> f1List = new ArrayList<>();
  67.                 for (int j = 0; j < numOfRow; j++)
  68.                     f1List.add(Byte.parseByte(Integer.toString(random.nextInt(Byte.MAX_VALUE))));
  69.                 pstmt.setByte(1, f1List);
  71.                 ArrayList<Short> f2List = new ArrayList<>();
  72.                 for (int j = 0; j < numOfRow; j++)
  73.                     f2List.add(Short.parseShort(Integer.toString(random.nextInt(Short.MAX_VALUE))));
  74.                 pstmt.setShort(2, f2List);
  76.                 ArrayList<Integer> f3List = new ArrayList<>();
  77.                 for (int j = 0; j < numOfRow; j++)
  78.                     f3List.add(random.nextInt(Integer.MAX_VALUE));
  79.                 pstmt.setInt(3, f3List);
  81.                 ArrayList<Long> f4List = new ArrayList<>();
  82.                 for (int j = 0; j < numOfRow; j++)
  83.                     f4List.add(random.nextLong());
  84.                 pstmt.setLong(4, f4List);
  86.                 // add column
  87.                 pstmt.columnDataAddBatch();
  88.             }
  89.             // execute column
  90.             pstmt.columnDataExecuteBatch();
  91.         }
  92.     }
  94.     private static void bindFloat(Connection conn) throws SQLException {
  95.         String sql = "insert into ? using stable2 tags(?,?) values(?,?,?)";
  97.         TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class);
  99.         for (int i = 1; i <= numOfSubTable; i++) {
  100.             // set table name
  101.             pstmt.setTableName("t2_" + i);
  102.             // set tags
  103.             pstmt.setTagFloat(0, random.nextFloat());
  104.             pstmt.setTagDouble(1, random.nextDouble());
  105.             // set columns
  106.             ArrayList<Long> tsList = new ArrayList<>();
  107.             long current = System.currentTimeMillis();
  108.             for (int j = 0; j < numOfRow; j++)
  109.                 tsList.add(current + j);
  110.             pstmt.setTimestamp(0, tsList);
  112.             ArrayList<Float> f1List = new ArrayList<>();
  113.             for (int j = 0; j < numOfRow; j++)
  114.                 f1List.add(random.nextFloat());
  115.             pstmt.setFloat(1, f1List);
  117.             ArrayList<Double> f2List = new ArrayList<>();
  118.             for (int j = 0; j < numOfRow; j++)
  119.                 f2List.add(random.nextDouble());
  120.             pstmt.setDouble(2, f2List);
  122.             // add column
  123.             pstmt.columnDataAddBatch();
  124.         }
  125.         // execute
  126.         pstmt.columnDataExecuteBatch();
  127.         // close if no try-with-catch statement is used
  128.         pstmt.close();
  129.     }
  131.     private static void bindBoolean(Connection conn) throws SQLException {
  132.         String sql = "insert into ? using stable3 tags(?) values(?,?)";
  134.         try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
  135.             for (int i = 1; i <= numOfSubTable; i++) {
  136.                 // set table name
  137.                 pstmt.setTableName("t3_" + i);
  138.                 // set tags
  139.                 pstmt.setTagBoolean(0, random.nextBoolean());
  140.                 // set columns
  141.                 ArrayList<Long> tsList = new ArrayList<>();
  142.                 long current = System.currentTimeMillis();
  143.                 for (int j = 0; j < numOfRow; j++)
  144.                     tsList.add(current + j);
  145.                 pstmt.setTimestamp(0, tsList);
  147.                 ArrayList<Boolean> f1List = new ArrayList<>();
  148.                 for (int j = 0; j < numOfRow; j++)
  149.                     f1List.add(random.nextBoolean());
  150.                 pstmt.setBoolean(1, f1List);
  152.                 // add column
  153.                 pstmt.columnDataAddBatch();
  154.             }
  155.             // execute
  156.             pstmt.columnDataExecuteBatch();
  157.         }
  158.     }
  160.     private static void bindBytes(Connection conn) throws SQLException {
  161.         String sql = "insert into ? using stable4 tags(?) values(?,?)";
  163.         try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
  165.             for (int i = 1; i <= numOfSubTable; i++) {
  166.                 // set table name
  167.                 pstmt.setTableName("t4_" + i);
  168.                 // set tags
  169.                 pstmt.setTagString(0, new String("abc"));
  171.                 // set columns
  172.                 ArrayList<Long> tsList = new ArrayList<>();
  173.                 long current = System.currentTimeMillis();
  174.                 for (int j = 0; j < numOfRow; j++)
  175.                     tsList.add(current + j);
  176.                 pstmt.setTimestamp(0, tsList);
  178.                 ArrayList<String> f1List = new ArrayList<>();
  179.                 for (int j = 0; j < numOfRow; j++) {
  180.                     f1List.add(new String("abc"));
  181.                 }
  182.                 pstmt.setString(1, f1List, BINARY_COLUMN_SIZE);
  184.                 // add column
  185.                 pstmt.columnDataAddBatch();
  186.             }
  187.             // execute
  188.             pstmt.columnDataExecuteBatch();
  189.         }
  190.     }
  192.     private static void bindString(Connection conn) throws SQLException {
  193.         String sql = "insert into ? using stable5 tags(?) values(?,?)";
  195.         try (TSDBPreparedStatement pstmt = conn.prepareStatement(sql).unwrap(TSDBPreparedStatement.class)) {
  197.             for (int i = 1; i <= numOfSubTable; i++) {
  198.                 // set table name
  199.                 pstmt.setTableName("t5_" + i);
  200.                 // set tags
  201.                 pstmt.setTagNString(0, "California.SanFrancisco");
  203.                 // set columns
  204.                 ArrayList<Long> tsList = new ArrayList<>();
  205.                 long current = System.currentTimeMillis();
  206.                 for (int j = 0; j < numOfRow; j++)
  207.                     tsList.add(current + j);
  208.                 pstmt.setTimestamp(0, tsList);
  210.                 ArrayList<String> f1List = new ArrayList<>();
  211.                 for (int j = 0; j < numOfRow; j++) {
  212.                     f1List.add("California.LosAngeles");
  213.                 }
  214.                 pstmt.setNString(1, f1List, BINARY_COLUMN_SIZE);
  216.                 // add column
  217.                 pstmt.columnDataAddBatch();
  218.             }
  219.             // execute
  220.             pstmt.columnDataExecuteBatch();
  221.         }
  222.     }
  223. }

用于设定 TAGS 取值的方法总共有：

  1. public void setTagNull(int index, int type)
  2. public void setTagBoolean(int index, boolean value)
  3. public void setTagInt(int index, int value)
  4. public void setTagByte(int index, byte value)
  5. public void setTagShort(int index, short value)
  6. public void setTagLong(int index, long value)
  7. public void setTagTimestamp(int index, long value)
  8. public void setTagFloat(int index, float value)
  9. public void setTagDouble(int index, double value)
  10. public void setTagString(int index, String value)
  11. public void setTagNString(int index, String value)

用于设定 VALUES 数据列的取值的方法总共有：

  1. public void setInt(int columnIndex, ArrayList<Integer> list) throws SQLException
  2. public void setFloat(int columnIndex, ArrayList<Float> list) throws SQLException
  3. public void setTimestamp(int columnIndex, ArrayList<Long> list) throws SQLException
  4. public void setLong(int columnIndex, ArrayList<Long> list) throws SQLException
  5. public void setDouble(int columnIndex, ArrayList<Double> list) throws SQLException
  6. public void setBoolean(int columnIndex, ArrayList<Boolean> list) throws SQLException
  7. public void setByte(int columnIndex, ArrayList<Byte> list) throws SQLException
  8. public void setShort(int columnIndex, ArrayList<Short> list) throws SQLException
  9. public void setString(int columnIndex, ArrayList<String> list, int size) throws SQLException
  10. public void setNString(int columnIndex, ArrayList<String> list, int size) throws SQLException

无模式写入

TDengine 支持无模式写入功能。无模式写入兼容 InfluxDB 的 行协议（Line Protocol）、OpenTSDB 的 telnet 行协议和 OpenTSDB 的 JSON 格式协议。详情请参见无模式写入。

注意：

  • JDBC REST 连接目前不支持无模式写入
  • 以下示例代码基于 taos-jdbcdriver-3.0.0
  1. public class SchemalessInsertTest {
  2.     private static final String host = "127.0.0.1";
  3.     private static final String lineDemo = "st,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000";
  4.     private static final String telnetDemo = "stb0_0 1626006833 4 host=host0 interface=eth0";
  5.     private static final String jsonDemo = "{\"metric\": \"meter_current\",\"timestamp\": 1346846400,\"value\": 10.3, \"tags\": {\"groupid\": 2, \"location\": \"California.SanFrancisco\", \"id\": \"d1001\"}}";
  7.     public static void main(String[] args) throws SQLException {
  8.         final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
  9.         try (Connection connection = DriverManager.getConnection(url)) {
  10.             init(connection);
  12.             SchemalessWriter writer = new SchemalessWriter(connection);
  13.             writer.write(lineDemo, SchemalessProtocolType.LINE, SchemalessTimestampType.NANO_SECONDS);
  14.             writer.write(telnetDemo, SchemalessProtocolType.TELNET, SchemalessTimestampType.MILLI_SECONDS);
  15.             writer.write(jsonDemo, SchemalessProtocolType.JSON, SchemalessTimestampType.NOT_CONFIGURED);
  16.         }
  17.     }
  19.     private static void init(Connection connection) throws SQLException {
  20.         try (Statement stmt = connection.createStatement()) {
  21.             stmt.executeUpdate("drop database if exists test_schemaless");
  22.             stmt.executeUpdate("create database if not exists test_schemaless");
  23.             stmt.executeUpdate("use test_schemaless");
  24.         }
  25.     }
  26. }

数据订阅

TDengine Java 连接器支持订阅功能，应用 API 如下：

创建 Topic

  1. Connection connection = DriverManager.getConnection(url, properties);
  2. Statement statement = connection.createStatement();
  3. statement.executeUpdate("create topic if not exists topic_speed as select ts, speed from speed_table");

subscribe 方法的三个参数含义如下：

  • topic_speed：订阅的主题（即名称），此参数是订阅的唯一标识。
  • sql：订阅的查询语句，此语句只能是 select 语句，只应查询原始数据，只能按时间正序查询数据。

如上面的例子将使用 SQL 语句 select ts, speed from speed_table 创建一个名为 topic_speed 的订阅。

创建 Consumer

  1. Properties config = new Properties();
  2. config.setProperty("enable.auto.commit", "true");
  3. config.setProperty("group.id", "group1");
  4. config.setProperty("value.deserializer", "com.taosdata.jdbc.tmq.ConsumerTest.ResultDeserializer");
  6. TaosConsumer consumer = new TaosConsumer<>(config);
  • enable.auto.commit: 是否允许自动提交。
  • group.id: consumer: 所在的 group。
  • value.deserializer: 结果集反序列化方法，可以继承 com.taosdata.jdbc.tmq.ReferenceDeserializer，并指定结果集 bean，实现反序列化。也可以继承 com.taosdata.jdbc.tmq.Deserializer，根据 SQL 的 resultSet 自定义反序列化方式。
  • td.connect.type: 连接方式。jni：表示使用动态库连接的方式，ws/WebSocket：表示使用 WebSocket 进行数据通信。默认为 jni 方式。
  • httpConnectTimeout：创建连接超时参数，单位 ms，默认为 5000 ms。仅在 WebSocket 连接下有效。
  • messageWaitTimeout：数据传输超时参数，单位 ms，默认为 10000 ms。仅在 WebSocket 连接下有效。 其他参数请参考：Consumer 参数列表

订阅消费数据

  1. while(true) {
  2.     ConsumerRecords<ResultBean> records = consumer.poll(Duration.ofMillis(100));
  3.         for (ResultBean record : records) {
  4.             process(record);
  5.         }
  6. }

poll 每次调用获取一个消息。

关闭订阅

  1. // 取消订阅
  2. consumer.unsubscribe();
  3. // 关闭消费
  4. consumer.close()

详情请参考：数据订阅

使用示例如下：

  • 原生连接
  • WebSocket 连接
  1. public abstract class ConsumerLoop {
  2.     private final TaosConsumer<ResultBean> consumer;
  3.     private final List<String> topics;
  4.     private final AtomicBoolean shutdown;
  5.     private final CountDownLatch shutdownLatch;
  7.     public ConsumerLoop() throws SQLException {
  8.         Properties config = new Properties();
  9.         config.setProperty("msg.with.table.name", "true");
  10.         config.setProperty("enable.auto.commit", "true");
  11.         config.setProperty("group.id", "group1");
  12.         config.setProperty("value.deserializer", "com.taosdata.jdbc.tmq.ConsumerTest.ConsumerLoop$ResultDeserializer");
  14.         this.consumer = new TaosConsumer<>(config);
  15.         this.topics = Collections.singletonList("topic_speed");
  16.         this.shutdown = new AtomicBoolean(false);
  17.         this.shutdownLatch = new CountDownLatch(1);
  18.     }
  20.     public abstract void process(ResultBean result);
  22.     public void pollData() throws SQLException {
  23.         try {
  24.             consumer.subscribe(topics);
  26.             while (!shutdown.get()) {
  27.                 ConsumerRecords<ResultBean> records = consumer.poll(Duration.ofMillis(100));
  28.                 for (ResultBean record : records) {
  29.                     process(record);
  30.                 }
  31.             }
  32.             consumer.unsubscribe();
  33.         } finally {
  34.             consumer.close();
  35.             shutdownLatch.countDown();
  36.         }
  37.     }
  39.     public void shutdown() throws InterruptedException {
  40.         shutdown.set(true);
  41.         shutdownLatch.await();
  42.     }
  44.     public static class ResultDeserializer extends ReferenceDeserializer<ResultBean> {
  46.     }
  48.     public static class ResultBean {
  49.         private Timestamp ts;
  50.         private int speed;
  52.         public Timestamp getTs() {
  53.             return ts;
  54.         }
  56.         public void setTs(Timestamp ts) {
  57.             this.ts = ts;
  58.         }
  60.         public int getSpeed() {
  61.             return speed;
  62.         }
  64.         public void setSpeed(int speed) {
  65.             this.speed = speed;
  66.         }
  67.     }
  68. }

除了原生的连接方式，Java 连接器还支持通过 WebSocket 订阅数据。

  1. public abstract class ConsumerLoop {
  2.     private final TaosConsumer<ResultBean> consumer;
  3.     private final List<String> topics;
  4.     private final AtomicBoolean shutdown;
  5.     private final CountDownLatch shutdownLatch;
  7.     public ConsumerLoop() throws SQLException {
  8.         Properties config = new Properties();
  9.         config.setProperty("bootstrap.servers", "localhost:6041");
  10.         config.setProperty("td.connect.type", "ws");
  11.         config.setProperty("msg.with.table.name", "true");
  12.         config.setProperty("enable.auto.commit", "true");
  13.         config.setProperty("group.id", "group2");
  14.         config.setProperty("value.deserializer", "com.taosdata.jdbc.tmq.ConsumerTest.ConsumerLoop$ResultDeserializer");
  16.         this.consumer = new TaosConsumer<>(config);
  17.         this.topics = Collections.singletonList("topic_speed");
  18.         this.shutdown = new AtomicBoolean(false);
  19.         this.shutdownLatch = new CountDownLatch(1);
  20.     }
  22.     public abstract void process(ResultBean result);
  24.     public void pollData() throws SQLException {
  25.         try {
  26.             consumer.subscribe(topics);
  28.             while (!shutdown.get()) {
  29.                 ConsumerRecords<ResultBean> records = consumer.poll(Duration.ofMillis(100));
  30.                 for (ResultBean record : records) {
  31.                     process(record);
  32.                 }
  33.             }
  34.             consumer.unsubscribe();
  35.         } finally {
  36.             consumer.close();
  37.             shutdownLatch.countDown();
  38.         }
  39.     }
  41.     public void shutdown() throws InterruptedException {
  42.         shutdown.set(true);
  43.         shutdownLatch.await();
  44.     }
  46.     public static class ResultDeserializer extends ReferenceDeserializer<ResultBean> {
  48.     }
  50.     public static class ResultBean {
  51.         private Timestamp ts;
  52.         private int speed;
  54.         public Timestamp getTs() {
  55.             return ts;
  56.         }
  58.         public void setTs(Timestamp ts) {
  59.             this.ts = ts;
  60.         }
  62.         public int getSpeed() {
  63.             return speed;
  64.         }
  66.         public void setSpeed(int speed) {
  67.             this.speed = speed;
  68.         }
  69.     }
  70. }

注意：这里的 value.deserializer 配置参数值应该根据测试环境的包路径做相应的调整。

与连接池使用

HikariCP

使用示例如下：

  1.  public static void main(String[] args) throws SQLException {
  2.     HikariConfig config = new HikariConfig();
  3.     // jdbc properties
  4.     config.setJdbcUrl("jdbc:TAOS://127.0.0.1:6030/log");
  5.     config.setUsername("root");
  6.     config.setPassword("taosdata");
  7.     // connection pool configurations
  8.     config.setMinimumIdle(10);           //minimum number of idle connection
  9.     config.setMaximumPoolSize(10);      //maximum number of connection in the pool
  10.     config.setConnectionTimeout(30000); //maximum wait milliseconds for get connection from pool
  11.     config.setMaxLifetime(0);       // maximum life time for each connection
  12.     config.setIdleTimeout(0);       // max idle time for recycle idle connection
  13.     config.setConnectionTestQuery("select server_status()"); //validation query
  15.     HikariDataSource ds = new HikariDataSource(config); //create datasource
  17.     Connection  connection = ds.getConnection(); // get connection
  18.     Statement statement = connection.createStatement(); // get statement
  20.     //query or insert
  21.     // ...
  23.     connection.close(); // put back to connection pool
  24. }

通过 HikariDataSource.getConnection() 获取连接后，使用完成后需要调用 close() 方法，实际上它并不会关闭连接，只是放回连接池中。 更多 HikariCP 使用问题请查看官方说明。

Druid

使用示例如下：

  1. public static void main(String[] args) throws Exception {
  3.     DruidDataSource dataSource = new DruidDataSource();
  4.     // jdbc properties
  5.     dataSource.setDriverClassName("com.taosdata.jdbc.TSDBDriver");
  6.     dataSource.setUrl(url);
  7.     dataSource.setUsername("root");
  8.     dataSource.setPassword("taosdata");
  9.     // pool configurations
  10.     dataSource.setInitialSize(10);
  11.     dataSource.setMinIdle(10);
  12.     dataSource.setMaxActive(10);
  13.     dataSource.setMaxWait(30000);
  14.     dataSource.setValidationQuery("select server_status()");
  16.     Connection  connection = dataSource.getConnection(); // get connection
  17.     Statement statement = connection.createStatement(); // get statement
  18.     //query or insert
  19.     // ...
  21.     connection.close(); // put back to connection pool
  22. }

更多 druid 使用问题请查看官方说明。

更多示例程序

示例程序源码位于 TDengine/examples/JDBC 下:

  • JDBCDemo：JDBC 示例源程序。
  • JDBCConnectorChecker：JDBC 安装校验源程序及 jar 包。
  • connectionPools：HikariCP, Druid, dbcp, c3p0 等连接池中使用 taos-jdbcdriver。
  • SpringJdbcTemplate：Spring JdbcTemplate 中使用 taos-jdbcdriver。
  • mybatisplus-demo：Springboot + Mybatis 中使用 taos-jdbcdriver。

请参考：JDBC example

最近更新记录

taos-jdbcdriver 版本主要变化
3.1.0WebSocket 连接支持订阅功能
3.0.1 - 3.0.4修复一些情况下结果集数据解析错误的问题。3.0.1 在 JDK 11 环境编译，JDK 8 环境下建议使用其他版本
3.0.0支持 TDengine 3.0
2.0.42修在 WebSocket 连接中 wasNull 接口返回值
2.0.41修正 REST 连接中用户名和密码转码方式
2.0.39 - 2.0.40增加 REST 连接/请求 超时设置
2.0.38JDBC REST 连接增加批量拉取功能
2.0.37增加对 json tag 支持
2.0.36增加对 schemaless 写入支持

常见问题

  1. 使用 Statement 的 addBatch() 和 executeBatch() 来执行“批量写入/更新”，为什么没有带来性能上的提升？

原因：TDengine 的 JDBC 实现中，通过 addBatch 方法提交的 SQL 语句，会按照添加的顺序，依次执行，这种方式没有减少与服务端的交互次数，不会带来性能上的提升。

解决方法：1. 在一条 insert 语句中拼接多个 values 值；2. 使用多线程的方式并发插入；3. 使用参数绑定的写入方式

  1. java.lang.UnsatisfiedLinkError: no taos in java.library.path

原因：程序没有找到依赖的本地函数库 taos。

解决方法：Windows 下可以将 C:\TDengine\driver\taos.dll 拷贝到 C:\Windows\System32\ 目录下，Linux 下将建立如下软链 ln -s /usr/local/taos/driver/libtaos.so.x.x.x.x /usr/lib/libtaos.so 即可，macOS 下需要建立软链 ln -s /usr/local/lib/libtaos.dylib。

  1. java.lang.UnsatisfiedLinkError: taos.dll Can’t load AMD 64 bit on a IA 32-bit platform

原因：目前 TDengine 只支持 64 位 JDK。

解决方法：重新安装 64 位 JDK。

  1. java.lang.NoSuchMethodError: setByteArray

原因：taos-jdbcdriver 3.* 版本仅支持 TDengine 3.0 及以上版本。

解决方法： 使用 taos-jdbcdriver 2. 版本连接 TDengine 2. 版本。

  1. java.lang.NoSuchMethodError: java.nio.ByteBuffer.position(I)Ljava/nio/ByteBuffer; … taos-jdbcdriver-3.0.1.jar

原因：taos-jdbcdriver 3.0.1 版本需要在 JDK 11+ 环境使用。

解决方法： 更换 taos-jdbcdriver 3.0.2+ 版本。

其它问题请参考 FAQ

API 参考

taos-jdbcdriver doc