diff --git a/Jenkinsfile b/Jenkinsfile index 9cc65d24f8aae3a97890e6676ff1091d32f7dc59..297dde63e196ff3ae4083926f51bd6a88c1c9f3a 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -455,17 +455,18 @@ pipeline { npm install td2.0-connector > /dev/null 2>&1 node nodejsChecker.js host=localhost node test1970.js - cd ${WKC}/tests/connectorTest/nodejsTest/nanosupport - npm install td2.0-connector > /dev/null 2>&1 + cd ${WKC}/tests/connectorTest/nodejsTest/nanosupport + npm install td2.0-connector > /dev/null 2>&1 node nanosecondTest.js ''' - - sh ''' - cd ${WKC}/tests/examples/C#/taosdemo - mcs -out:taosdemo *.cs > /dev/null 2>&1 - echo '' |./taosdemo -c /etc/taos - ''' + catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') { + sh ''' + cd ${WKC}/tests/examples/C#/taosdemo + mcs -out:taosdemo *.cs > /dev/null 2>&1 + echo '' |./taosdemo -c /etc/taos + ''' + } sh ''' cd ${WKC}/tests/gotest bash batchtest.sh diff --git a/documentation20/cn/00.index/docs.md b/documentation20/cn/00.index/docs.md index 70a6b7c5281e1a96f8348ff3a3bb81892b80c93c..a4fba357bbc47bd84ea7c2a6931a64bf274e5d9b 100644 --- a/documentation20/cn/00.index/docs.md +++ b/documentation20/cn/00.index/docs.md @@ -121,10 +121,11 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专 * [数据复制](/architecture/replica)：支持实时同步、异步复制，保证系统的High Availibility * [技术博客](https://www.taosdata.com/cn/blog/?categories=3)：更多的技术分析和架构设计文章 -## [应用 TDengine 快速搭建 IT 运维系统](/devops) +## 应用 TDengine 快速搭建 IT 运维系统 * [devops](/devops/telegraf)：使用 TDengine + Telegraf + Grafana 快速搭建 IT 运维系统 * [devops](/devops/collectd)：使用 TDengine + collectd_statsd + Grafana 快速搭建 IT 运维系统 +* [最佳实践](/devops/immigrate)：OpenTSDB 应用迁移到 TDengine 的最佳实践 ## 常用工具 diff --git a/documentation20/cn/05.insert/docs.md b/documentation20/cn/05.insert/docs.md index 24ac6c52e19e24697c8ad35fdaf822adbd614a0a..a82aecd97c832f9b7f276ec27832097e46845dfc 100644 --- a/documentation20/cn/05.insert/docs.md +++ b/documentation20/cn/05.insert/docs.md @@ -145,27 +145,27 @@ st,t1=3,t2=4,t3=t3 c1=3i64,c6="passit" 1626006833640000000
如果是无模式写入过程中的数据本身错误，应用会得到 TSDB_CODE_TSC_LINE_SYNTAX_ERROR 错误信息，该错误信息表明错误发生在写入文本中。其他的错误码与原系统一致，可以通过 taos_errstr 获取具体的错误原因。 **后续升级计划** -
当前版本只提供了 C 版本的 API，后续将提供 其他高级语言的 API，例如 Java/Go/Python/C# 等。此外，在TDengine v2.3及后续版本中，您还可以通过 BLM v3 采用 REST 的方式直接写入无模式数据。 +
当前版本只提供了 C 版本的 API，后续将提供 其他高级语言的 API，例如 Java/Go/Python/C# 等。此外，在TDengine v2.3及后续版本中，您还可以通过 Taos Adapter 采用 REST 的方式直接写入无模式数据。 ## Prometheus 直接写入 [Prometheus](https://www.prometheus.io/)作为Cloud Native Computing Fundation毕业的项目，在性能监控以及K8S性能监控领域有着非常广泛的应用。TDengine提供一个小工具[Bailongma](https://github.com/taosdata/Bailongma)，只需对Prometheus做简单配置，无需任何代码，就可将Prometheus采集的数据直接写入TDengine，并按规则在TDengine自动创建库和相关表项。博文[用Docker容器快速搭建一个Devops监控Demo](https://www.taosdata.com/blog/2020/02/03/1189.html)即是采用Bailongma将Prometheus和Telegraf的数据写入TDengine中的示例，可以参考。 -### 从源代码编译 taosadapter_prometheus +### 从源代码编译 blm_prometheus 用户需要从github下载[Bailongma](https://github.com/taosdata/Bailongma)的源码，使用Golang语言编译器编译生成可执行文件。在开始编译前，需要准备好以下条件： - Linux操作系统的服务器 - 安装好Golang，1.14版本以上 - 对应的TDengine版本。因为用到了TDengine的客户端动态链接库，因此需要安装好和服务端相同版本的TDengine程序；比如服务端版本是TDengine 2.0.0, 则在Bailongma所在的Linux服务器（可以与TDengine在同一台服务器，或者不同服务器） -Bailongma项目中有一个文件夹taosadapter_prometheus，存放了prometheus的写入API程序。编译过程如下： +Bailongma项目中有一个文件夹blm_prometheus，存放了prometheus的写入API程序。编译过程如下： ```bash -cd taosadapter_prometheus +cd blm_prometheus go build ``` -一切正常的情况下，就会在对应的目录下生成一个taosadapter_prometheus的可执行程序。 +一切正常的情况下，就会在对应的目录下生成一个blm_prometheus的可执行程序。 ### 安装 Prometheus @@ -176,23 +176,23 @@ go build 参考Prometheus的[配置文档](https://prometheus.io/docs/prometheus/latest/configuration/configuration/)，在Prometheus的配置文件中的部分，增加以下配置： ``` - - url: "bailongma API服务提供的URL"（参考下面的taosadapter_prometheus启动示例章节） + - url: "bailongma API服务提供的URL"（参考下面的blm_prometheus启动示例章节） ``` 启动Prometheus后，可以通过taos客户端查询确认数据是否成功写入。 -### 启动 taosadapter_prometheus 程序 +### 启动 blm_prometheus 程序 -taosadapter_prometheus程序有以下选项，在启动taosadapter_prometheus程序时可以通过设定这些选项来设定taosadapter_prometheus的配置。 +blm_prometheus程序有以下选项，在启动blm_prometheus程序时可以通过设定这些选项来设定blm_prometheus的配置。 ```bash --tdengine-name 如果TDengine安装在一台具备域名的服务器上，也可以通过配置TDengine的域名来访问TDengine。在K8S环境下，可以配置成TDengine所运行的service name。 --batch-size -taosadapter_prometheus会将收到的prometheus的数据拼装成TDengine的写入请求，这个参数控制一次发给TDengine的写入请求中携带的数据条数。 +blm_prometheus会将收到的prometheus的数据拼装成TDengine的写入请求，这个参数控制一次发给TDengine的写入请求中携带的数据条数。 --dbname -设置在TDengine中创建的数据库名称，taosadapter_prometheus会自动在TDengine中创建一个以dbname为名称的数据库，缺省值是prometheus。 +设置在TDengine中创建的数据库名称，blm_prometheus会自动在TDengine中创建一个以dbname为名称的数据库，缺省值是prometheus。 --dbuser 设置访问TDengine的用户名，缺省值是'root'。 @@ -201,16 +201,16 @@ taosadapter_prometheus会将收到的prometheus的数据拼装成TDengine的写 设置访问TDengine的密码，缺省值是'taosdata'。 --port -taosadapter_prometheus对prometheus提供服务的端口号。 +blm_prometheus对prometheus提供服务的端口号。 ``` ### 启动示例 -通过以下命令启动一个taosadapter_prometheus的API服务 +通过以下命令启动一个blm_prometheus的API服务 ```bash -./taosadapter_prometheus -port 8088 +./blm_prometheus -port 8088 ``` -假设taosadapter_prometheus所在服务器的IP地址为"10.1.2.3"，则在prometheus的配置文件中部分增加url为 +假设blm_prometheus所在服务器的IP地址为"10.1.2.3"，则在prometheus的配置文件中部分增加url为 ```yaml remote_write: - url: "http://10.1.2.3:8088/receive" @@ -235,7 +235,7 @@ prometheus产生的数据格式如下： } } ``` -其中，apiserver_request_latencies_bucket为prometheus采集的时序数据的名称，后面{}中的为该时序数据的标签。taosadapter_prometheus会以时序数据的名称在TDengine中自动创建一个超级表，并将{}中的标签转换成TDengine的tag值，Timestamp作为时间戳，value作为该时序数据的值。因此在TDengine的客户端中，可以通过以下指令查到这个数据是否成功写入。 +其中，apiserver_request_latencies_bucket为prometheus采集的时序数据的名称，后面{}中的为该时序数据的标签。blm_prometheus会以时序数据的名称在TDengine中自动创建一个超级表，并将{}中的标签转换成TDengine的tag值，Timestamp作为时间戳，value作为该时序数据的值。因此在TDengine的客户端中，可以通过以下指令查到这个数据是否成功写入。 ```mysql use prometheus; select * from apiserver_request_latencies_bucket; @@ -314,7 +314,7 @@ taosadapter 相关配置参数请参考 taosadapter --help 命令输出以及相 [Telegraf](https://www.influxdata.com/time-series-platform/telegraf/)是一流行的IT运维数据采集开源工具，TDengine提供一个小工具[Bailongma](https://github.com/taosdata/Bailongma)，只需在Telegraf做简单配置，无需任何代码，就可将Telegraf采集的数据直接写入TDengine，并按规则在TDengine自动创建库和相关表项。博文[用Docker容器快速搭建一个Devops监控Demo](https://www.taosdata.com/blog/2020/02/03/1189.html)即是采用bailongma将Prometheus和Telegraf的数据写入TDengine中的示例，可以参考。 -### 从源代码编译 taosadapter_telegraf +### 从源代码编译 blm_telegraf 用户需要从github下载[Bailongma](https://github.com/taosdata/Bailongma)的源码，使用Golang语言编译器编译生成可执行文件。在开始编译前，需要准备好以下条件： @@ -322,14 +322,14 @@ taosadapter 相关配置参数请参考 taosadapter --help 命令输出以及相 - 安装好Golang，1.10版本以上 - 对应的TDengine版本。因为用到了TDengine的客户端动态链接库，因此需要安装好和服务端相同版本的TDengine程序；比如服务端版本是TDengine 2.0.0, 则在Bailongma所在的Linux服务器（可以与TDengine在同一台服务器，或者不同服务器） -Bailongma项目中有一个文件夹taosadapter_telegraf，存放了Telegraf的写入API程序。编译过程如下： +Bailongma项目中有一个文件夹blm_telegraf，存放了Telegraf的写入API程序。编译过程如下： ```bash -cd taosadapter_telegraf +cd blm_telegraf go build ``` -一切正常的情况下，就会在对应的目录下生成一个taosadapter_telegraf的可执行程序。 +一切正常的情况下，就会在对应的目录下生成一个blm_telegraf的可执行程序。 ### 安装 Telegraf @@ -352,19 +352,19 @@ go build 关于如何使用Telegraf采集数据以及更多有关使用Telegraf的信息，请参考Telegraf官方的[文档](https://docs.influxdata.com/telegraf/v1.11/)。 -### 启动 taosadapter_telegraf 程序 +### 启动 blm_telegraf 程序 -taosadapter_telegraf程序有以下选项，在启动taosadapter_telegraf程序时可以通过设定这些选项来设定taosadapter_telegraf的配置。 +blm_telegraf程序有以下选项，在启动blm_telegraf程序时可以通过设定这些选项来设定blm_telegraf的配置。 ```bash --host TDengine服务端的IP地址，缺省值为空。 --batch-size -taosadapter_telegraf会将收到的telegraf的数据拼装成TDengine的写入请求，这个参数控制一次发给TDengine的写入请求中携带的数据条数。 +blm_telegraf会将收到的telegraf的数据拼装成TDengine的写入请求，这个参数控制一次发给TDengine的写入请求中携带的数据条数。 --dbname -设置在TDengine中创建的数据库名称，taosadapter_telegraf会自动在TDengine中创建一个以dbname为名称的数据库，缺省值是prometheus。 +设置在TDengine中创建的数据库名称，blm_telegraf会自动在TDengine中创建一个以dbname为名称的数据库，缺省值是prometheus。 --dbuser 设置访问TDengine的用户名，缺省值是'root'。 @@ -373,17 +373,17 @@ taosadapter_telegraf会将收到的telegraf的数据拼装成TDengine的写入 设置访问TDengine的密码，缺省值是'taosdata'。 --port -taosadapter_telegraf对telegraf提供服务的端口号。 +blm_telegraf对telegraf提供服务的端口号。 ``` ### 启动示例 -通过以下命令启动一个taosadapter_telegraf的API服务： +通过以下命令启动一个blm_telegraf的API服务： ```bash -./taosadapter_telegraf -host 127.0.0.1 -port 8089 +./blm_telegraf -host 127.0.0.1 -port 8089 ``` -假设taosadapter_telegraf所在服务器的IP地址为"10.1.2.3"，则在telegraf的配置文件中, 在output plugins部分，增加[[outputs.http]]配置项： +假设blm_telegraf所在服务器的IP地址为"10.1.2.3"，则在telegraf的配置文件中, 在output plugins部分，增加[[outputs.http]]配置项： ```yaml url = "http://10.1.2.3:8089/telegraf" @@ -416,7 +416,7 @@ telegraf产生的数据格式如下： } ``` -其中，name字段为telegraf采集的时序数据的名称，tags字段为该时序数据的标签。taosadapter_telegraf会以时序数据的名称在TDengine中自动创建一个超级表，并将tags字段中的标签转换成TDengine的tag值，timestamp作为时间戳，fields字段中的值作为该时序数据的值。因此在TDengine的客户端中，可以通过以下指令查到这个数据是否成功写入。 +其中，name字段为telegraf采集的时序数据的名称，tags字段为该时序数据的标签。blm_telegraf会以时序数据的名称在TDengine中自动创建一个超级表，并将tags字段中的标签转换成TDengine的tag值，timestamp作为时间戳，fields字段中的值作为该时序数据的值。因此在TDengine的客户端中，可以通过以下指令查到这个数据是否成功写入。 ```mysql use telegraf; diff --git a/documentation20/cn/11.administrator/docs.md b/documentation20/cn/11.administrator/docs.md index 448df75d808e06996ef61814692c7948adb11e32..4ef1c60112018cb29289314e199feda75ca7c2ba 100644 --- a/documentation20/cn/11.administrator/docs.md +++ b/documentation20/cn/11.administrator/docs.md @@ -1,4 +1,4 @@ -# TDengine的运营与运维 +# TDengine的运营与维护 ## 容量规划 @@ -157,7 +157,7 @@ taosd -C | 39 | keep | | **S** | 天 | 数据保留的天数 | | 3650 | | | 40 | minRows | | **S** | | 文件块中记录的最小条数 | | 100 | | | 41 | maxRows | | **S** | | 文件块中记录的最大条数 | | 4096 | | -| 42 | quorum | | **S** | | 异步写入成功所需应答之法定数 | 1-3 | 1 | | +| 42 | quorum | | **S** | | 多副本环境下指令执行的确认数要求 | 1,2 | 1 | | | 43 | comp | | **S** | | 文件压缩标志位 | 0：关闭，1:一阶段压缩，2:两阶段压缩 | 2 | | | 44 | walLevel | | **S** | | WAL级别 | 1：写wal, 但不执行fsync; 2：写wal, 而且执行fsync | 1 | | | 45 | fsync | | **S** | 毫秒 | 当wal设置为2时，执行fsync的周期 | 最小为0，表示每次写入，立即执行fsync；最大为180000（三分钟） | 3000 | | diff --git a/documentation20/cn/12.taos-sql/docs.md b/documentation20/cn/12.taos-sql/docs.md index 4ba496d575e0f680c2dbd2820d3dfc062c56cb1c..bf3e1c6fd8bc45a4fc10a42f5f3389aa884e9158 100644 --- a/documentation20/cn/12.taos-sql/docs.md +++ b/documentation20/cn/12.taos-sql/docs.md @@ -124,7 +124,7 @@ TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传 ```mysql ALTER DATABASE db_name QUORUM 2; ``` - QUORUM 参数是指数据写入成功所需要的确认数，取值范围 [1, 2]。对于异步复制，quorum 设为 1，具有 master 角色的虚拟节点自己确认即可。对于同步复制，需要至少大于等于 2。原则上，Quorum >= 1 并且 Quorum <= replica(副本数)，这个参数在启动一个同步模块实例时需要提供。 + QUORUM 参数是指数据写入成功所需要的确认数，取值范围 [1, 2]。对于异步复制，quorum 设为 1，具有 master 角色的虚拟节点自己确认即可。对于同步复制，quorum 设为 2。原则上，Quorum >= 1 并且 Quorum <= replica(副本数)，这个参数在启动一个同步模块实例时需要提供。 ```mysql ALTER DATABASE db_name BLOCKS 100; diff --git a/documentation20/cn/14.devops/02.collectd/docs.md b/documentation20/cn/14.devops/02.collectd/docs.md index a35772bb498d426a1f44a9e7eb0bea61b51f92a5..5860e70ceafafadc21c5772c96515e0925897e3a 100644 --- a/documentation20/cn/14.devops/02.collectd/docs.md +++ b/documentation20/cn/14.devops/02.collectd/docs.md @@ -40,7 +40,7 @@ IT 运维监测数据通常都是对时间特性比较敏感的数据，例如 ``` ### 配置 collectd -在 /etc/collectd/collectd.conf 文件中增加如下内容，其中 host 和 port 请填写 TDengine 和 BLM3 配置的实际值： +在 /etc/collectd/collectd.conf 文件中增加如下内容，其中 host 和 port 请填写 TDengine 和 Taos Adapter 配置的实际值： ``` LoadPlugin network @@ -51,7 +51,7 @@ sudo systemctl start collectd ``` ### 配置 StatsD -在 config.js 文件中增加如下内容后启动 StatsD，其中 host 和 port 请填写 TDengine 和 BLM3 配置的实际值： +在 config.js 文件中增加如下内容后启动 StatsD，其中 host 和 port 请填写 TDengine 和 Taos Adapter 配置的实际值： ``` backends 部分添加 "./backends/repeater" repeater 部分添加 { host:'', port: } diff --git a/documentation20/cn/14.devops/03.immigrate/docs.md b/documentation20/cn/14.devops/03.immigrate/docs.md new file mode 100644 index 0000000000000000000000000000000000000000..b2a68e1b15acef2d574600e59d1b18d890938ac6 --- /dev/null +++ b/documentation20/cn/14.devops/03.immigrate/docs.md @@ -0,0 +1,435 @@ +# OpenTSDB 应用迁移到 TDengine 的最佳实践 + +作为一个分布式、可伸缩、基于HBase 的分布式时序数据库系统，得益于其先发优势，OpenTSDB被 DevOps 领域的人员引入并广泛地应用在了运维监控领域。但最近几年，随着云计算、微服务、容器化等新技术快速落地发展，企业级服务种类变得越来越多，架构也越来越复杂，应用运行基础环境日益多样化，给系统和运行监控带来的压力也越来越大。从这一现状出发，使用 OpenTSDB 作为DevOps的监控后端存储，越来越受困于其性能问题以及迟缓的功能升级，以及由此而衍生出来的应用部署成本上升和运行效率降低等问题，这些问题随着系统规模的扩大日益严重。 + +在这一背景下，为满足高速增长的物联网大数据市场和技术需求，在吸取众多传统关系型数据库、NoSQL 数据库、流计算引擎、消息队列等软件的优点之后，涛思数据自主开发出创新型大数据处理产品TDengine。在时序大数据处理上，TDengine 有着自己独特的优势。就 OpenTSDB 当前遇到的问题来说，TDengine 能够有效解决。 + +相对于 OpenTSDB，TDengine 具有如下显著特点： + +- 数据写入和查询的性能远超 OpenTSDB； +- 针对时序数据的高效压缩机制，压缩后在磁盘上的存储空间不到 1/5； +- 安装部署非常简单，单一安装包完成安装部署，除了 taosadapter 需要依赖 Go 运行环境外，不依赖其他的第三方软件，整个安装部署过程秒级搞定; +- 提供的内建函数覆盖 OpenTSDB 支持的全部查询函数，还支持更多的时序数据查询函数、标量函数及聚合函数，支持多种时间窗口聚合、连接查询、表达式运算、多种分组聚合、用户定义排序、以及用户定义函数等高级查询功能。采用类 SQL 的语法规则，更加简单易学，基本上没有学习成本。 +- 支持多达 128 个标签，标签总长度可达到 16 KB； +- 除 HTTP 之外，还提供 Java、Python、C、Rust、Go 等多种语言的接口，支持 JDBC 等多种企业级标准连接器协议。 + +如果我们将原本运行在 OpenTSDB 上的应用迁移到 TDengine 上，不仅可以有效地降低计算和存储资源的占用、减少部署服务器的规模，还能够极大减少运行维护的成本的输出，让运维管理工作更简单、更轻松，大幅降低总拥有成本。与OpenTSDB一样，TDengine也已经进行了开源，不同的是，除了单机版，后者还实现了集群版开源，被厂商绑定的顾虑一扫而空。 + +在下文中我们将就“使用最典型并广泛应用的运维监控（DevOps）场景”来说明，如何在不编码的情况下将 OpenTSDB 的应用快速、安全、可靠地迁移到 TDengine之上。后续的章节会做更深度的介绍，以便于进行非DevOps场景的迁移。 + +## DevOps应用快速迁移 + +### 1、典型应用场景 + +一个典型的 DevOps 应用场景的系统整体的架构如下图（图1） 所示。 + +![IT-DevOps-Solutions-Immigrate-OpenTSDB-Arch](../../images/IT-DevOps-Solutions-Immigrate-OpenTSDB-Arch.jpg) +
图1. DevOps场景中典型架构
+ +在该应用场景中，包含了部署在应用环境中负责收集机器度量（Metrics）、网络度量（Metrics）以及应用度量（Metrics）的 Agent 工具、汇聚agent收集信息的数据收集器，数据持久化存储和管理的系统以及监控数据可视化工具（例如：Grafana等）。 + +其中，部署在应用节点的 Agents 负责向 collectd/Statsd 提供不同来源的运行指标，collectd/StatsD则负责将汇聚的数据推送到 OpenTSDB 集群系统，然后使用可视化看板 Grafana 将数据可视化呈现出来。 + +### 2、迁移服务 + +- **TDengine 安装部署** + +首先是TDengine的安装，从官网上下载TDengine最新稳定版，解压缩后运行install.sh进行安装。各种安装包的使用帮助请参见博客[《 TDengine多种安装包的安装和卸载》](https://www.taosdata.com/blog/2019/08/09/566.html)。 + +注意，安装完成以后，不要立即启动 taosd 服务，在正确配置完成参数以后再启动。 + +- **调整数据收集器配置** + +在 TDengine 2.3 版本中，后台服务 taosd 启动后一个 HTTP 的服务 taosadapter 也会自动启用*。*利用 taosadapter 能够兼容 Influxdb 的 Line Protocol 和 OpenTSDB 的 telnet/Json 写入协议，可以将 collectd 和 StatsD 收集的数据直接推送到TDengine。 + +如果使用 collectd，修改其默认位置 `/etc/collectd/collectd.conf` 的配置文件为指向 taosadapter 部署的节点 IP 地址和端口。假设 taosadapter 的 IP 地址为192.168.1.130，端口为 6046，配置如下： + +```html +LoadPlugin write_tsdb + + + Host "192.168.1.130" + Port "6046" + HostTags "status=production" + StoreRates false + AlwaysAppendDS false + + +``` + +即可让 collectd 将数据使用推送到 OpenTSDB 的插件方式推送到 taosadapter， taosadapter 将调用 API 将数据写入到 taosd 中，从而完成数据的写入工作。如果你使用的是 StatsD 相应地调整配置文件信息。 + +- **调整看板（Dashborad）系统** + +在数据能够正常写入TDengine 后，可以调整适配 Grafana 将写入 TDengine 的数据可视化呈现出来。Grafana 暂时还不能够直接连接 TDengine，在 TDengine 的安装目录下 connector/grafanaplugin 有为 Grafana 提供的连接插件。使用该插件的方式很简单： + +首先将grafanaplugin目录下的dist目录整体拷贝到Grafana的插件目录（默认地址为 `/var/lib/grafana/plugins/`），然后重启 Grafana 即可在 **Add Data Source** 菜单下看见 TDengine 数据源。 + +```shell +sudo cp -r . /var/lib/grafana/plugins/tdengine +sudo chown grafana:grafana -R /var/lib/grafana/plugins/tdengine +echo -e "[plugins]\nallow_loading_unsigned_plugins = taosdata-tdengine-datasource\n" | sudo tee -a /etc/grafana/grafana.ini + +# start grafana service +sudo service grafana-server restart +# or with systemd +sudo systemctl start grafana-server +``` + + + +此外，TDengine 还提供了默认的两套Dashboard 模板，供用户快速查看保存到TDengine库里的信息。你只需要将 Grafana 目录下的模板导入到Grafana中即可激活使用。 + +![](../../images/IT-DevOps-Solutions-Immigrate-OpenTSDB-Dashboard.jpg) + +
图2. 导入Grafana模板
+ +操作完以上步骤后，就完成了将OpenTSDB替换成为TDengine的迁移工作。可以看到整个流程非常简单，不需要写代码，只需要对某些配置文件进行调整即可完成全部的迁移工作。 + +### 3、迁移后架构 + +完成迁移以后，此时的系统整体的架构如下图（图3）所示，而整个过程中采集端、数据写入端、以及监控呈现端均保持了稳定，除了极少的配置调整外，不涉及任何重要的更改和变动。OpenTSDB 大量的应用场景均为 DevOps ，这种场景下，简单的参数设置即可完成 OpenTSDB 到 TDengine 迁移动作，使用上 TDengine 更加强大的处理能力和查询性能。 + +在绝大多数的 DevOps 场景中，如果你拥有一个小规模的 OpenTSDB 集群（3台及以下的节点）作为 DevOps 的存储端，依赖于 OpenTSDB 为系统持久化层提供数据存储和查询功能，那么你可以安全地将其替换为 TDengine，并节约更多的计算和存储资源。在同等计算资源配置情况下，单台 TDengine 即可满足 3 ~ 5 台 OpenTSDB 节点提供的服务能力。如果规模比较大，那便需要采用TDengine集群。 + +如果你的应用特别复杂，或者应用领域并不是 DevOps 场景，你可以继续阅读后续的章节，更加全面深入地了解将 OpenTSDB 的应用迁移到 TDengine 的高级话题。 + +![IT-DevOps-Solutions-Immigrate-TDengine-Arch](../../images/IT-DevOps-Solutions-Immigrate-TDengine-Arch.jpg) + +
图3. 迁移完成后的系统架构
+ +## 其他场景的迁移评估与策略 + +### 1、TDengine 与 OpenTSDB 的差异 + +本章将详细介绍 OpenTSDB 与 TDengine 在系统功能层面上存在的差异。阅读完本章的内容，你可以全面地评估是否能够将某些基于 OpenTSDB 的复杂应用迁移到TDengine上，以及迁移之后应该注意的问题。 + +TDengine 当前只支持 Grafana 的可视化看板呈现，所以如果你的应用中使用了 Grafana 以外的前端看板（例如[TSDash](https://github.com/facebook/tsdash)、[Status Wolf](https://github.com/box/StatusWolf)等），那么前端看板将无法直接迁移到 TDengine，需要将前端看板重新适配到 Grafana 才可以正常运行。 + +截止到 2.3.0.x 版本，TDengine 只能够支持 collectd 和 StatsD 作为数据收集汇聚软件，当然后面会陆续提供更多的数据收集聚合软件的接入支持。如果您的收集端使用了其他类型的数据汇聚器，您的应用需要适配到这两个数据汇聚端系统，才能够将数据正常写入。除了上述两个数据汇聚端软件协议以外，TDengine 还支持通过 InfluxDB 的行协议和 OpenTSDB 的数据写入协议、Json 格式将数据直接写入，您可以重写数据推送端的逻辑，使用 TDengine 支持的行协议来写入数据。 + +此外，如果你的应用中使用了 OpenTSDB 以下特性，在将应用迁移到 TDengine 之前你还需要了解以下注意事项： + +1. ` /api/stats`：如果你的应用中使用了该项特性来监控OpenTSDB的服务状态，并在应用中建立了相关的逻辑来联动处理，那么这部分状态读取和获取的逻辑需要重新适配到TDengine。TDengine 提供了全新的处理集群状态监控机制，来满足你的应用对其进行的监控和维护的需求。 +2. `/api/tree`：如果你依赖于OpenTSDB的该项特性来进行时间线的层级化组织和维护，那么便无法将其直接迁移至TDengine。TDengine 采用了数据库->超级表->子表这样的层级来组织和维护时间线，归属于同一个超级表的所有的时间线在系统中同一个层级，但是可以通过不同标签值的特殊构造来模拟应用逻辑上的多级结构。 +3. `Rollup And PreAggregates`：采用了 Rollup 和 PreAggregates 需要应用来决定在合适的地方访问 Rollup 的结果，在某些场景下又要访问原始的结果，这种结构的不透明性让应用处理逻辑变得极为复杂而且完全不具有移植性。我们认为这种策略是时序数据库无法提供高性能聚合情况下的妥协与折中。TDengine 暂不支持多个时间线的自动降采样和（时间段范围的）预聚合，由于 其拥有的高性能查询处理逻辑，即使不依赖于Rollup 和 （时间段）预聚合计算结果，也能够提供很高性能的查询响应，而且让你的应用查询处理逻辑更加简单。 +4. `Rate`: TDengine提供了两个计算数值变化率的函数，分别是Derivative（其计算结果与InfluxDB的Derivative行为一致）和IRate（其计算结果与Prometheus中的IRate函数计算结果一致）。但是这两个函数的计算结果与 Rate 有细微的差别，但整体上功能更强大。此外，**OpenTSDB提供的所有计算函数，TDengine 均有对应的查询函数支持，并且TDengine的查询函数功能远超过OpenTSDB支持的查询函数，**可以极大地简化你的应用处理逻辑。 + +通过上面的介绍，相信你应该能够了解OpenTSDB迁移到TDengine带来的变化，这些信息也有助于你正确地判断是否可以接受将应用 迁移到TDengine之上，体验TDengine提供的强大的时序数据处理能力和便捷的使用体验。 + +### 2、迁移策略 + +首先将基于OpenTSDB的系统进行迁移涉及到的数据模式设计、系统规模估算、数据写入端改造，进行数据分流、应用适配工作；之后将两个系统并行运行一段时间，再将历史数据迁移到 TDengine 中。当然如果你的应用中有部分功能强依赖于上述OpenTSDB特性，同时又不希望停止使用，可以考虑保持原有的OpenTSDB系统运行，同时启动 TDengine来提供主要的服务。 + +## 数据模型设计 + +一方面，TDengine 要求其入库的数据具有严格的模式定义。另一方面，TDengine 的数据模型相对于 OpenTSDB 来说又更加丰富，多值模型能够兼容全部的单值模型的建立需求。 + +现在让我们假设一个 DevOps 的场景，我们使用了 collectd 收集设备的基础度量（metrics），包含了 memory 、swap、disk 等几个度量，其在 OpenTSDB 中的模式如下： + +| 序号 | 测量（metric） | 值名称 | 类型 | tag1 | tag2 | tag3 | tag4 | tag5 | +| ---- | -------------- | ------ | ------ | ---- | ----------- | -------------------- | --------- | ------ | +| 1 | memory | value | double | host | memory_type | memory_type_instance | source | | +| 2 | swap | value | double | host | swap_type | swap_type_instance | source | | +| 3 | disk | value | double | host | disk_point | disk_instance | disk_type | source | + + + +TDengine 要求存储的数据具有数据模式，即写入数据之前需创建超级表并指定超级表的模式。对于数据模式的建立，你有两种方式来完成此项工作：1）充分利用TDengine对 OpenTSDB 的数据原生写入的支持，调用 TDengine 提供的 API 将（文本行或 JSON 格式）数据写入，并自动化地建立单值模型。采用这种方式不需要对数据写入应用进行较大的调整，也不需要对写入的数据格式进行转换。 + +在 C 语言层面，TDengine提供了 taos_insert_lines 来直接写入OpenTSDB格式的数据（在2.3.x 版本中该函数对应的是 taos_schemaless_insert ）。其代码参考示例请参见安装包目录下示例代码 schemaless.c。 + + 2）在充分理解 TDengine 的数据模型基础上，结合生成数据的特点，手动方式建立 OpenTSDB 到 TDengine 的数据模型调整的映射关系。TDengine 能够支持多值模型和单值模型，考虑到OpenTSDB 均为单值映射模型，这里推荐使用单值模型在 TDengine 中进行建模。 + +- **单值模型**。 + +具体步骤如下：将度量（metrics）的名称作为 TDengine 超级表的名称，该超级表建成后具有两个基础的数据列—时间戳（timestamp）和值（value），超级表的标签等效于 度量 的标签信息，标签数量等同于度量 的标签的数量。子表的表名采用具有固定规则的方式进行命名：`metric + '_' + tags1_value + '_' + tag2_value + '_' + tag3_value ... `作为子表名称。 + +在TDengine中建立3个超级表： + +```sql +create stable memory(ts timestamp, val float) tags(host binary(12)，memory_type binary(20), memory_type_instance binary(20), source binary(20)); +create stable swap(ts timestamp, val double) tags(host binary(12), swap_type binary(20), swap_type_binary binary(20), source binary(20)); +create stable disk(ts timestamp, val double) tags(host binary(12), disk_point binary(20), disk_instance binary(20), disk_type binary(20), source binary(20)); +``` + + + +对于子表使用动态建表的方式创建如下所示： + +```sql +insert into memory_vm130_memory_bufferred_collectd using memory tags(‘vm130’, ‘memory’, 'buffer', 'collectd') values(1632979445, 3.0656); +``` + +最终系统中会建立 340 个左右的子表，3个超级表。需要注意的是，如果采用串联标签值的方式导致子表名称超过系统限制（191字节），那么需要采用一定的编码方式（例如 MD5）将其转化为可接受长度。 + +- **多值模型** + +如果你想要利用 TDengine 的多值模型能力，需要首先满足以下要求：不同的采集量具有相同的采集频率，且能够通过消息队列**同时到达**数据写入端，从而确保使用SQL语句将多个指标一次性写入。将度量的名称作为超级表的名称，建立具有相同采集频率且能够同时到达的数据多列模型。子表的表名采用具有固定规则的方式进行命名。上述每个度量均只包含一个测量值，因此无法将其转化为多值模型。 + + + +## 数据分流与应用适配 + +从消息队列中订阅数据，并启动调整后的写入程序写入数据。 + +数据开始写入持续一段时间后，可以采用SQL语句检查写入的数据量是否符合预计的写入要求。统计数据量使用如下SQL语句： + +```sql +select count(*) from memory +``` + +完成查询后，如果写入的数据与预期的相比没有差别，同时写入程序本身没有异常的报错信息，那么可用确认数据写入是完整有效的。 + +TDengine不支持采用OpenTSDB的查询语法进行查询或数据获取处理，但是针对OpenTSDB的每种查询都提供对应的支持。你可以用检查附件2获取对应的查询处理的调整和应用使用的方式，如果需要全面了解TDengine支持的查询类型，请参阅TDengine的用户手册。 + +TDengine支持标准的JDBC 3.0接口操纵数据库，你也可以使用其他类型的高级语言的连接器来查询读取数据，以适配你的应用。具体的操作和使用帮助也请参阅用户手册。 + +## 历史数据迁移 + +### 1、使用工具自动迁移数据 + +为了方便历史数据的迁移工作，我们为数据同步工具DataX提供了插件，能够将数据自动写入到TDengine中，需要注意的是DataX的自动化数据迁移只能够支持单值模型的数据迁移过程。 + +DataX 具体的使用方式及如何使用DataX将数据写入TDengine请参见其使用帮助手册 [github.com/taosdata/datax](http://github.com/taosdata/datax)。 + +### 2、手动迁移数据 + +如果你需要使用多值模型进行数据写入，就需要自行开发一个将数据从OpenTSDB导出的工具，然后确认哪些时间线能够合并导入到同一个时间线，再将可以同时导入的时间通过SQL语句的写入到数据库中。 + +手动迁移数据需要注意以下两个问题： + +1）在磁盘中存储导出数据时，磁盘需要有足够的存储空间以便能够充分容纳导出的数据文件。为了避免全量数据导出后导致磁盘文件存储紧张，可以采用部分导入的模式，对于归属于同一个超级表的时间线优先导出，然后将导出部分的数据文件导入到TDengine系统中。 + +2）在系统全负载运行下，如果有足够的剩余计算和IO资源，可以建立多线程的导入机制，最大限度地提升数据迁移的效率。考虑到数据解析对于CPU带来的巨大负载，需要控制最大的并行任务数量，以避免因导入历史数据而触发的系统整体过载。 + +由于TDegnine本身操作简易性，所以不需要在整个过程中进行索引维护、数据格式的变化处理等工作，整个过程只需要顺序执行即可。 + +当历史数据完全导入到TDengine以后，此时两个系统处于同时运行的状态，之后便可以将查询请求切换到TDengine上，从而实现无缝的应用切换。 + +## 附录1: OpenTSDB查询函数对应表 + +**Avg** + +等效函数：avg + +示例： + +SELECT avg(val) FROM (SELECT first(val) FROM super_table WHERE ts >= startTime and ts <= endTime INTERVAL(20s) Fill(linear)) INTERVAL(20s) + +备注： + +1. Interval内的数值与外层查询的 interval 数值需要相同。 +2. 在TDengine中插值处理需要使用子查询来协助完成，如上所示，在内层查询中指明插值类型即可，由于 OpenTSDB 中数值的插值使用了线性插值，因此在插值子句中使用fill(linear) 来声明插值类型。以下有相同插值计算需求的函数，均采用该方法处理。 +3. Interval中参数20s表示将内层查询按照20秒一个时间窗口生成结果。在真实的查询中，需要调整为不同的记录之间的时间间隔。这样可确保等效于原始数据生成了插值结果。 +4. 由于 OpenTSDB 特殊的插值策略和机制，聚合查询（Aggregate）中先插值再计算的方式导致其计算结果与 TDengine 不可能完全一致。但是在降采样（Downsample）的情况下，TDengine 和 OpenTSDB 能够获得一致的结果（由于 OpenTSDB 在聚合查询和降采样查询中采用了完全不同的插值策略）。 + + + +**Count** + +等效函数：count + +示例： + +select count(*) from super_table_name; + + + +**Dev** + +等效函数：stddev + +示例： + +Select stddev(val) from table_name + + + +**Estimated percentiles** + +等效函数：apercentile + +示例： + +Select apercentile(col1, 50, “t-digest”) from table_name + +备注： + +1. 近似查询处理过程中，OpenTSDB默认采用t-digest算法，所以为了获得相同的计算结果，需要在apercentile函数中指明使用的算法。TDengine能够支持两种不同的近似处理算法，分别通过”default”和”t-digest”来声明。 + + + +**First** + +等效函数：first + +示例： + +Select first(col1) from table_name + + + +**Last** + +等效函数：last + +示例： + +Select last(col1) from table_name + + + +**Max** + +等效函数：max + +示例： + +Select max(value) from (select first(val) value from table_name interval(10s) fill(linear)) interval(10s) + +备注：Max函数需要插值，原因见上。 + + + +**Min** + +等效函数：min + +示例： + +Select min(value) from (select first(val) value from table_name interval(10s) fill(linear)) interval(10s); + + + +**MinMax** + +等效函数：max + +Select max(val) from table_name + +备注：该函数无插值需求，因此可用直接计算。 + + + +**MimMin** + +等效函数：min + +Select min(val) from table_name + +备注：该函数无插值需求，因此可用直接计算。 + + + +**Percentile** + +等效函数：percentile + +备注： + + + +**Sum** + +等效函数：sum + +Select max(value) from (select first(val) value from table_name interval(10s) fill(linear)) interval(10s) + +备注：该函数无插值需求，因此可用直接计算。 + + + +**Zimsum** + +等效函数：sum + +Select sum(val) from table_name + +备注：该函数无插值需求，因此可用直接计算。 + + + +完整示例： + +```json +//OpenTSDB查询Json +query = { +“start”:1510560000, +“end”: 1515000009, +“queries”:[{ +“aggregator”: “count”, +“metric”:”cpu.usage_user”, +}] +} + +//等效查询SQL: +SELECT count(*) +FROM `cpu.usage_user` +WHERE ts>=1510560000 AND ts<=1515000009 +``` + + + +## 附录2: 资源估算方法 + +### 数据生成环境 + +我们仍然使用第 4 章中的假设环境，3个测量值。分别是：温度和湿度的数据写入的速率是每 5 秒一条记录，时间线 10万个。空气质量的写入速率是10 秒一条记录，时间线1万个，查询的请求频率 500 QPS。 + +### 存储资源估算 + +假设产生数据并需要存储的传感器设备数量为 `n`，数据生成的频率为` t `条/秒，每条记录的长度为 `L` bytes，则每天产生的数据规模为 `n×t×L` bytes。假设压缩比为 C，则每日产生数据规模为 `(n×t×L)/C` bytes。存储资源预估为能够容纳1.5年的数据规模，生产环境下 TDengine 的压缩比 C 一般在 5 ~ 7 之间，同时为最后结果增加 20% 的冗余，可计算得到需要存储资源： + +```matlab +(n×t×L)×(365×1.5)×(1+20%)/C +``` + +结合以上的计算公式，将参数带入计算公式，在不考虑标签信息的情况下，每年产生的原始数据规模是11.8TB。需要注意的是，由于标签信息在TDengine中关联到每个时间线，并不是每条记录。所以需要记录的数据量规模相对于产生的数据有一定的降低，而这部分标签数据整体上可以忽略不记。假设压缩比为5，则保留的数据规模最终为 2.56 TB。 + +### 存储设备选型考虑 + +硬盘应该选用具有较好随机读性能的硬盘设备，如果能够有SSD，尽可能考虑使用SSD。较好的随机读性能的磁盘对于提升系统查询性能具有极大的帮助，能够整体上提升系统的查询响应性能。为了获得较好的查询性能，硬盘设备的单线程随机读IOPS的性能指标不应该低于1000，能够达到5000 IOPS以上为佳。为了获得当前的设备随机读取的IO性能的评估，建议使用fio软件对其进行运行性能评估（具体的使用方式请参阅附录1），确认其是否能够满足大文件随机读性能要求。 + +硬盘写性能对于TDengine的影响不大。TDengine写入过程采用了追加写的模式，所以只要有较好的顺序写性能即可，一般意义上的SAS硬盘和SSD均能够很好地满足TDengine对于磁盘写入性能的要求。 + +### 计算资源估算 + +由于物联网数据的特殊性，数据产生的频率固定以后，TDengine写入的过程对于（计算和存储）资源消耗都保持一个相对固定的量。《[TDengine的运营与维护](https://www.taosdata.com/cn/documentation/administrator)》上的描述，该系统中每秒 22000个写入，消耗CPU不到 1个核。 + +在针对查询所需要消耗的CPU资源的估算上，假设应用要求数据库提供的QPS为 10000，每次查询消耗的CPU时间约 1 ms，那么每个核每秒提供的查询为 1000 QPS，满足10000 QPS的查询请求，至少需要10个核。为了让系统整体上CPU负载小于 50%，整个集群需要10个核的两倍，即 20 个核。 + +### 内存资源估算 + +数据库默认为每个Vnode分配内存 16MB*3缓冲区，集群系统包括22个CPU核，则默认会建立22个虚拟节点Vnode，每个Vnode包含1000张表，则可以容纳所有的表。则约1个半小时写满一个block，从而触发落盘，可以不做调整。22个Vnode共计需要内存缓存约 1GB。考虑到查询所需要的内存，假设每次查询的内存开销约50MB，则500个查询并发需要的内存约25GB。 + +综上所述，可使用单台16核32GB的机器，或者使用2台 8核 16GB机器构成的集群。 + +## 附录3: 集群部署及启动 + +TDengine提供了丰富的帮助文档说明集群安装、部署的诸多方面的内容，这里提供响应的文档索引，供你参考。 + +### 集群部署 + +首先是安装 TDengine，从官网上下载 TDengine 最新稳定版，解压缩后运行 install.sh 进行安装。各种安装包的使用帮助请参见博客[《 TDengine多种安装包的安装和卸载》](https://www.taosdata.com/blog/2019/08/09/566.html)。 + +注意安装完成以后，不要立即启动taosd服务，在正确配置完成参数以后才启动taosd服务。 + +### 设置运行参数并启动服务 + +为确保系统能够正常获取运行的必要信息。请在服务端正确设置以下关键参数： + +FQDN、firstEp、secondEP、dataDir、logDir、tmpDir、serverPort。各参数的具体含义及设置的要求，可参见文档《[TDengine 集群安装、管理](https://www.taosdata.com/cn/documentation/cluster)》 + +按照相同的步骤，在需要运行的节点上设置参数，并启动taosd服务，然后添加Dnode到集群中。 + +最后启动taos，执行命令 show dnodes，如果能看到所有的加入集群的节点，那么集群顺利搭建完成。具体的操作流程及注意事项，请参阅文档《[TDengine 集群安装、管理](https://www.taosdata.com/cn/documentation/cluster)》 + +## 附录4: 超级表名称 + +由于OpenTSDB的metric名称中带有点号（“.“），例如”cpu.usage_user”这种名称的metric。但是点号在TDengine中具有特殊含义，是用来分隔数据库和表名称的分隔符。TDengine也提供转义符，以允许用户在（超级）表名称中使用关键词或特殊分隔符（如：点号）。为了使用特殊字符，需要采用转义字符将表的名称括起来，例如：`cpu.usage_user`这样就是合法的（超级）表名称。 + +## 附录5：参考文章 + +1. [使用 TDengine + collectd/StatsD + Grafana 快速搭建 IT 运维监控系统](https://www.taosdata.com/cn/documentation20/devops/collectd) +2. [通过 collectd 将采集数据直接写入TDengine](https://www.taosdata.com/cn/documentation20/insert#collectd) diff --git a/documentation20/cn/images/IT-DevOps-Solutions-Immigrate-OpenTSDB-Arch.jpg b/documentation20/cn/images/IT-DevOps-Solutions-Immigrate-OpenTSDB-Arch.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d3de5fb7a10a1cb22693468029bc26ad63a96d71 Binary files /dev/null and b/documentation20/cn/images/IT-DevOps-Solutions-Immigrate-OpenTSDB-Arch.jpg differ diff --git a/documentation20/cn/images/IT-DevOps-Solutions-Immigrate-OpenTSDB-Dashboard.jpg b/documentation20/cn/images/IT-DevOps-Solutions-Immigrate-OpenTSDB-Dashboard.jpg new file mode 100644 index 0000000000000000000000000000000000000000..be3704cb72d6c2614614852bfef17147ce49d061 Binary files /dev/null and b/documentation20/cn/images/IT-DevOps-Solutions-Immigrate-OpenTSDB-Dashboard.jpg differ diff --git a/documentation20/cn/images/IT-DevOps-Solutions-Immigrate-TDengine-Arch.jpg b/documentation20/cn/images/IT-DevOps-Solutions-Immigrate-TDengine-Arch.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fd406a140beea43fbfe2c417c85b872cfd6a2219 Binary files /dev/null and b/documentation20/cn/images/IT-DevOps-Solutions-Immigrate-TDengine-Arch.jpg differ diff --git a/packaging/deb/makedeb.sh b/packaging/deb/makedeb.sh index f753668b3b1a83d15c126ae6b0d94c06e97c80aa..f28d98ba9a6fae4390bfa301760aff9583ba4e40 100755 --- a/packaging/deb/makedeb.sh +++ b/packaging/deb/makedeb.sh @@ -45,10 +45,10 @@ mkdir -p ${pkg_dir}${install_home_path}/script cp ${compile_dir}/../packaging/cfg/taos.cfg ${pkg_dir}${install_home_path}/cfg if [ -f "${compile_dir}/test/cfg/taosadapter.toml" ]; then - cp ${compile_dir}/test/cfg/taosadapter.toml ${pkg_dir}${install_home_path}/cfg + cp ${compile_dir}/test/cfg/taosadapter.toml ${pkg_dir}${install_home_path}/cfg || : fi if [ -f "${compile_dir}/test/cfg/taosadapter.service" ]; then - cp ${compile_dir}/test/cfg/taosadapter.service ${pkg_dir}${install_home_path}/cfg ||: + cp ${compile_dir}/test/cfg/taosadapter.service ${pkg_dir}${install_home_path}/cfg || : fi cp ${compile_dir}/../packaging/deb/taosd ${pkg_dir}${install_home_path}/init.d diff --git a/packaging/tools/install.sh b/packaging/tools/install.sh index 61fcd3e51982dab6a72245fe0ffb9de5ac51a664..dcd4a83da8929d76aa61d848985b5c4ffe46b9c5 100755 --- a/packaging/tools/install.sh +++ b/packaging/tools/install.sh @@ -757,8 +757,12 @@ function install_service_on_systemd() { } function install_taosadapter_service() { - [ -f ${script_dir}/cfg/taosadapter.service ] &&\ - ${csudo} cp ${script_dir}/cfg/taosadapter.service ${service_config_dir}/ + if ((${service_mod}==0)); then + [ -f ${script_dir}/cfg/taosadapter.service ] &&\ + ${csudo} cp ${script_dir}/cfg/taosadapter.service \ + ${service_config_dir}/ || : + ${csudo} systemctl daemon-reload + fi } function install_service() { diff --git a/packaging/tools/make_install.sh b/packaging/tools/make_install.sh index 8309fa516c4ffdcd9e5a17056304427543dad0a9..c6bc8b9ce00a7fa34f617970f728baf4ee8d234f 100755 --- a/packaging/tools/make_install.sh +++ b/packaging/tools/make_install.sh @@ -523,9 +523,8 @@ function install_taosadapter_service() { if ((${service_mod}==0)); then [ -f ${binary_dir}/test/cfg/taosadapter.service ] &&\ ${csudo} cp ${binary_dir}/test/cfg/taosadapter.service\ - ${service_config_dir}/ || : - else - kill_taosadapter + ${service_config_dir}/ || : + ${csudo} systemctl daemon-reload fi } diff --git a/packaging/tools/makepkg.sh b/packaging/tools/makepkg.sh index 05b49ff6a9599c6050d2ccad778f63d285981420..7ad703be86016bd0c0ce55c80b76bf34914c54bb 100755 --- a/packaging/tools/makepkg.sh +++ b/packaging/tools/makepkg.sh @@ -78,7 +78,13 @@ mkdir -p ${install_dir} mkdir -p ${install_dir}/inc && cp ${header_files} ${install_dir}/inc mkdir -p ${install_dir}/cfg && cp ${cfg_dir}/taos.cfg ${install_dir}/cfg/taos.cfg -[ -f ${cfg_dir}/taosadapter.toml ] && cp ${cfg_dir}/taosadapter.toml ${install_dir}/cfg/taosadapter.toml +if [ -f "${compile_dir}/test/cfg/taosadapter.toml" ]; then + cp ${compile_dir}/test/cfg/taosadapter.toml ${install_dir}/cfg || : +fi + +if [ -f "${compile_dir}/test/cfg/taosadapter.service" ]; then + cp ${compile_dir}/test/cfg/taosadapter.service ${install_dir}/cfg || : +fi mkdir -p ${install_dir}/bin && cp ${bin_files} ${install_dir}/bin && chmod a+x ${install_dir}/bin/* || : mkdir -p ${install_dir}/init.d && cp ${init_file_deb} ${install_dir}/init.d/taosd.deb diff --git a/packaging/tools/post.sh b/packaging/tools/post.sh index c3db7e417adb11b92d55464b69c715e3aee2d6bb..2f4b07067fd08ee3a9591f97e7291305307ff498 100755 --- a/packaging/tools/post.sh +++ b/packaging/tools/post.sh @@ -467,7 +467,12 @@ function install_service_on_systemd() { } function install_taosadapter_service() { - [ -f ${cfg_dir}/taosadapter.service ] && ${csudo} cp ${cfg_dir}/taosadapter.service ${service_config_dir} + if ((${service_mod}==0)); then + [ -f ${script_dir}/cfg/taosadapter.service ] &&\ + ${csudo} cp ${script_dir}/cfg/taosadapter.service \ + ${service_config_dir}/ || : + ${csudo} systemctl daemon-reload + fi } function install_service() { diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c index d7ceee630217acc72f8cebc464b3e38aaf440a4e..029c39e8287f151646d017a854750ed321a33c3e 100644 --- a/src/client/src/tscParseInsert.c +++ b/src/client/src/tscParseInsert.c @@ -314,8 +314,6 @@ int32_t tsParseOneColumn(SSchema *pSchema, SStrToken *pToken, char *payload, cha ret = tStrToInteger(pToken->z, pToken->type, pToken->n, &iv, false); if (ret != TSDB_CODE_SUCCESS) { return tscInvalidOperationMsg(msg, "invalid unsigned bigint data", pToken->z); - } else if (!IS_VALID_UBIGINT((uint64_t)iv)) { - return tscInvalidOperationMsg(msg, "unsigned bigint data overflow", pToken->z); } *((uint64_t *)payload) = iv; diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java index 67652b1c7ada63a8336fdc44dc9814f0a266c086..c992cf58ba43eb0e052d9bc80824d94e98b725ca 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java @@ -413,8 +413,7 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti status = future.get(); else status = future.get(timeout, TimeUnit.SECONDS); - } catch (InterruptedException | ExecutionException e) { - e.printStackTrace(); + } catch (InterruptedException | ExecutionException ignored) { } catch (TimeoutException e) { future.cancel(true); status = false; diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDatabaseMetaData.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDatabaseMetaData.java index f6ec70fbac555b97b2cb342edfaa5fde56245c5a..6343a802af280415b4d21f56476eb4403b4608ac 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDatabaseMetaData.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDatabaseMetaData.java @@ -597,7 +597,7 @@ public abstract class AbstractDatabaseMetaData extends WrapperImpl implements Da return col4; } - public ResultSet getSchemas() throws SQLException { + public ResultSet getSchemas() { return getEmptyResultSet(); } @@ -629,7 +629,7 @@ public abstract class AbstractDatabaseMetaData extends WrapperImpl implements Da public abstract ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException; - protected ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern, Connection conn) { + protected ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern, Connection conn) throws SQLException { if (catalog == null || catalog.isEmpty()) return null; if (!isAvailableCatalog(conn, catalog)) @@ -682,8 +682,6 @@ public abstract class AbstractDatabaseMetaData extends WrapperImpl implements Da rowIndex++; } resultSet.setRowDataList(rowDataList); - } catch (SQLException e) { - e.printStackTrace(); } return resultSet; } @@ -1220,7 +1218,7 @@ public abstract class AbstractDatabaseMetaData extends WrapperImpl implements Da return col6; } - private boolean isAvailableCatalog(Connection connection, String catalog) { + private boolean isAvailableCatalog(Connection connection, String catalog) throws SQLException { try (Statement stmt = connection.createStatement(); ResultSet databases = stmt.executeQuery("show databases")) { while (databases.next()) { @@ -1229,8 +1227,6 @@ public abstract class AbstractDatabaseMetaData extends WrapperImpl implements Da if (dbname.equalsIgnoreCase(catalog)) return true; } - } catch (SQLException e) { - e.printStackTrace(); } return false; } diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java index a5c7f26a266f81e3a7915503d2983efe077765c2..ee2c8141a81bb9dc2aa51ba14247dfbb834ec746 100755 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java @@ -21,6 +21,7 @@ import com.taosdata.jdbc.enums.SchemalessProtocolType; import com.taosdata.jdbc.enums.SchemalessTimestampType; import com.taosdata.jdbc.utils.TaosInfo; +import java.io.UnsupportedEncodingException; import java.nio.ByteBuffer; import java.sql.SQLException; import java.sql.SQLWarning; @@ -107,8 +108,7 @@ public class TSDBJNIConnector { try { pSql = this.executeQueryImp(sql.getBytes(TaosGlobalConfig.getCharset()), this.taos); taosInfo.stmt_count_increment(); - } catch (Exception e) { - e.printStackTrace(); + } catch (UnsupportedEncodingException e) { this.freeResultSetImp(this.taos, pSql); throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_ENCODING); } diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java index 42ebedf4027b0e333b9e79b8045f1bae0d338ac7..5fd8f181388824bccd4a2ab2b488667af117b172 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java @@ -611,7 +611,7 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat try { this.tagValueLength += value.getBytes(charset).length; } catch (UnsupportedEncodingException e) { - e.printStackTrace(); + throw new RuntimeException(e.getMessage()); } } @@ -786,7 +786,7 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat b = val.getBytes(charset); } } catch (UnsupportedEncodingException e) { - e.printStackTrace(); + throw new RuntimeException(e.getMessage()); } tagDataList.put(b); @@ -921,7 +921,7 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat b = val.getBytes(charset); } } catch (UnsupportedEncodingException e) { - e.printStackTrace(); + throw new RuntimeException(e.getMessage()); } if (val.length() > col1.bytes) { @@ -980,8 +980,10 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat @Override public void close() throws SQLException { - this.columnDataClearBatchInternal(); - this.columnDataCloseBatch(); + if (this.nativeStmtHandle != 0L) { + this.columnDataClearBatchInternal(); + this.columnDataCloseBatch(); + } super.close(); } } diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java index ff49677b01fa1c3a4d482cebd51269d5f1589e43..e404db64e3dffbdcc0d2c2845279723874f6b5d8 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java @@ -92,75 +92,71 @@ public class TSDBResultSetBlockData { } public void setByteArray(int col, int length, byte[] value) { - try { - switch (this.columnMetaDataList.get(col).getColType()) { - case TSDBConstants.TSDB_DATA_TYPE_BOOL: { - ByteBuffer buf = ByteBuffer.wrap(value, 0, length); - buf.order(ByteOrder.LITTLE_ENDIAN).asCharBuffer(); - this.colData.set(col, buf); - break; - } - case TSDBConstants.TSDB_DATA_TYPE_UTINYINT: - case TSDBConstants.TSDB_DATA_TYPE_TINYINT: { - ByteBuffer buf = ByteBuffer.wrap(value, 0, length); - buf.order(ByteOrder.LITTLE_ENDIAN); - this.colData.set(col, buf); - break; - } - case TSDBConstants.TSDB_DATA_TYPE_USMALLINT: - case TSDBConstants.TSDB_DATA_TYPE_SMALLINT: { - ByteBuffer buf = ByteBuffer.wrap(value, 0, length); - ShortBuffer sb = buf.order(ByteOrder.LITTLE_ENDIAN).asShortBuffer(); - this.colData.set(col, sb); - break; - } - case TSDBConstants.TSDB_DATA_TYPE_UINT: - case TSDBConstants.TSDB_DATA_TYPE_INT: { - ByteBuffer buf = ByteBuffer.wrap(value, 0, length); - IntBuffer ib = buf.order(ByteOrder.LITTLE_ENDIAN).asIntBuffer(); - this.colData.set(col, ib); - break; - } - case TSDBConstants.TSDB_DATA_TYPE_UBIGINT: - case TSDBConstants.TSDB_DATA_TYPE_BIGINT: { - ByteBuffer buf = ByteBuffer.wrap(value, 0, length); - LongBuffer lb = buf.order(ByteOrder.LITTLE_ENDIAN).asLongBuffer(); - this.colData.set(col, lb); - break; - } - case TSDBConstants.TSDB_DATA_TYPE_FLOAT: { - ByteBuffer buf = ByteBuffer.wrap(value, 0, length); - FloatBuffer fb = buf.order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer(); - this.colData.set(col, fb); - break; - } - case TSDBConstants.TSDB_DATA_TYPE_DOUBLE: { - ByteBuffer buf = ByteBuffer.wrap(value, 0, length); - DoubleBuffer db = buf.order(ByteOrder.LITTLE_ENDIAN).asDoubleBuffer(); - this.colData.set(col, db); - break; - } - case TSDBConstants.TSDB_DATA_TYPE_BINARY: { - ByteBuffer buf = ByteBuffer.wrap(value, 0, length); - buf.order(ByteOrder.LITTLE_ENDIAN); - this.colData.set(col, buf); - break; - } - case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP: { - ByteBuffer buf = ByteBuffer.wrap(value, 0, length); - LongBuffer lb = buf.order(ByteOrder.LITTLE_ENDIAN).asLongBuffer(); - this.colData.set(col, lb); - break; - } - case TSDBConstants.TSDB_DATA_TYPE_NCHAR: { - ByteBuffer buf = ByteBuffer.wrap(value, 0, length); - buf.order(ByteOrder.LITTLE_ENDIAN); - this.colData.set(col, buf); - break; - } + switch (this.columnMetaDataList.get(col).getColType()) { + case TSDBConstants.TSDB_DATA_TYPE_BOOL: { + ByteBuffer buf = ByteBuffer.wrap(value, 0, length); + buf.order(ByteOrder.LITTLE_ENDIAN).asCharBuffer(); + this.colData.set(col, buf); + break; + } + case TSDBConstants.TSDB_DATA_TYPE_UTINYINT: + case TSDBConstants.TSDB_DATA_TYPE_TINYINT: { + ByteBuffer buf = ByteBuffer.wrap(value, 0, length); + buf.order(ByteOrder.LITTLE_ENDIAN); + this.colData.set(col, buf); + break; + } + case TSDBConstants.TSDB_DATA_TYPE_USMALLINT: + case TSDBConstants.TSDB_DATA_TYPE_SMALLINT: { + ByteBuffer buf = ByteBuffer.wrap(value, 0, length); + ShortBuffer sb = buf.order(ByteOrder.LITTLE_ENDIAN).asShortBuffer(); + this.colData.set(col, sb); + break; + } + case TSDBConstants.TSDB_DATA_TYPE_UINT: + case TSDBConstants.TSDB_DATA_TYPE_INT: { + ByteBuffer buf = ByteBuffer.wrap(value, 0, length); + IntBuffer ib = buf.order(ByteOrder.LITTLE_ENDIAN).asIntBuffer(); + this.colData.set(col, ib); + break; + } + case TSDBConstants.TSDB_DATA_TYPE_UBIGINT: + case TSDBConstants.TSDB_DATA_TYPE_BIGINT: { + ByteBuffer buf = ByteBuffer.wrap(value, 0, length); + LongBuffer lb = buf.order(ByteOrder.LITTLE_ENDIAN).asLongBuffer(); + this.colData.set(col, lb); + break; + } + case TSDBConstants.TSDB_DATA_TYPE_FLOAT: { + ByteBuffer buf = ByteBuffer.wrap(value, 0, length); + FloatBuffer fb = buf.order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer(); + this.colData.set(col, fb); + break; + } + case TSDBConstants.TSDB_DATA_TYPE_DOUBLE: { + ByteBuffer buf = ByteBuffer.wrap(value, 0, length); + DoubleBuffer db = buf.order(ByteOrder.LITTLE_ENDIAN).asDoubleBuffer(); + this.colData.set(col, db); + break; + } + case TSDBConstants.TSDB_DATA_TYPE_BINARY: { + ByteBuffer buf = ByteBuffer.wrap(value, 0, length); + buf.order(ByteOrder.LITTLE_ENDIAN); + this.colData.set(col, buf); + break; + } + case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP: { + ByteBuffer buf = ByteBuffer.wrap(value, 0, length); + LongBuffer lb = buf.order(ByteOrder.LITTLE_ENDIAN).asLongBuffer(); + this.colData.set(col, lb); + break; + } + case TSDBConstants.TSDB_DATA_TYPE_NCHAR: { + ByteBuffer buf = ByteBuffer.wrap(value, 0, length); + buf.order(ByteOrder.LITTLE_ENDIAN); + this.colData.set(col, buf); + break; } - } catch (Exception e) { - e.printStackTrace(); } } @@ -283,14 +279,8 @@ public class TSDBResultSetBlockData { return 0; } - public Timestamp getTimestamp(int col) { - try { - return new Timestamp(getLong(col)); - } catch (SQLException e) { - e.printStackTrace(); - } - - return null; + public Timestamp getTimestamp(int col) throws SQLException { + return new Timestamp(getLong(col)); } public double getDouble(int col) { @@ -429,7 +419,7 @@ public class TSDBResultSetBlockData { String charset = TaosGlobalConfig.getCharset(); return new String(dest, charset); } catch (UnsupportedEncodingException e) { - e.printStackTrace(); + throw new RuntimeException(e.getMessage()); } } } diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java index 5cdaa3c70c334bc7bd97be08f2318e6fc548d22a..d8ac10d839651bb476a8688f28917aa356b5b1fe 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java @@ -16,6 +16,7 @@ package com.taosdata.jdbc; import com.taosdata.jdbc.utils.NullType; +import java.io.UnsupportedEncodingException; import java.math.BigDecimal; import java.sql.SQLException; import java.sql.Timestamp; @@ -378,8 +379,8 @@ public class TSDBResultSetRowData { // this setByteArr(int, byte[]) to handle NCHAR value, we need to build a String with charsetEncoding by TaosGlobalConfig try { data.set(col, new String(value, TaosGlobalConfig.getCharset())); - } catch (Exception e) { - e.printStackTrace(); + } catch (UnsupportedEncodingException e) { + throw new RuntimeException(e.getMessage()); } } diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/TaosInfo.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/TaosInfo.java index d4664f2678013b3de87bcd3f0dc24631be511ede..583c2c3236574b8474b834513b28160c37d5b250 100644 --- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/TaosInfo.java +++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/TaosInfo.java @@ -16,8 +16,8 @@ public class TaosInfo implements TaosInfoMBean { MBeanServer server = ManagementFactory.getPlatformMBeanServer(); ObjectName name = new ObjectName("TaosInfoMBean:name=TaosInfo"); server.registerMBean(TaosInfo.getInstance(), name); - } catch (MalformedObjectNameException | InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e) { - e.printStackTrace(); + } catch (MalformedObjectNameException | InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException ignored) { + throw new RuntimeException("registerMBean failed"); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBConnectionTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBConnectionTest.java index 7cdda572a7e6950005d47798bece6cc5c6fef7d1..64b7ab1cabe2c5815ff87d9881873150f21049c6 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBConnectionTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBConnectionTest.java @@ -30,42 +30,6 @@ public class TSDBConnectionTest { } } - @Test - public void runSubscribe() { - try { - // given - TSDBConnection unwrap = conn.unwrap(TSDBConnection.class); - TSDBSubscribe subscribe = unwrap.subscribe("topic1", "select * from log.log", false); - // when - TSDBResultSet rs = subscribe.consume(); - ResultSetMetaData metaData = rs.getMetaData(); - - // then - Assert.assertNotNull(rs); - Assert.assertEquals(4, metaData.getColumnCount()); - Assert.assertEquals("ts", metaData.getColumnLabel(1)); - Assert.assertEquals("level", metaData.getColumnLabel(2)); - Assert.assertEquals("content", metaData.getColumnLabel(3)); - Assert.assertEquals("ipaddr", metaData.getColumnLabel(4)); - rs.next(); - // row 1 - { - Assert.assertNotNull(rs.getTimestamp(1)); - Assert.assertNotNull(rs.getTimestamp("ts")); - Assert.assertNotNull(rs.getByte(2)); - Assert.assertNotNull(rs.getByte("level")); - Assert.assertNotNull(rs.getString(3)); - Assert.assertNotNull(rs.getString("content")); - Assert.assertNotNull(rs.getString(4)); - Assert.assertNotNull(rs.getString("ipaddr")); - } - subscribe.close(false); - } catch (SQLException e) { - e.printStackTrace(); - } - - } - @Test public void prepareStatement() throws SQLException { PreparedStatement pstmt = conn.prepareStatement("select server_status()"); @@ -391,13 +355,9 @@ public class TSDBConnectionTest { } @Test - public void unwrap() { - try { - TSDBConnection tsdbConnection = conn.unwrap(TSDBConnection.class); - Assert.assertNotNull(tsdbConnection); - } catch (SQLException e) { - e.printStackTrace(); - } + public void unwrap() throws SQLException { + TSDBConnection tsdbConnection = conn.unwrap(TSDBConnection.class); + Assert.assertNotNull(tsdbConnection); } @Test @@ -406,32 +366,22 @@ public class TSDBConnectionTest { } @BeforeClass - public static void beforeClass() { - try { - Class.forName("com.taosdata.jdbc.TSDBDriver"); - Properties properties = new Properties(); - properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); - conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/log?user=root&password=taosdata", properties); - // create test database for test cases - try (Statement stmt = conn.createStatement()) { - stmt.execute("create database if not exists test"); - } - - } catch (ClassNotFoundException | SQLException e) { - e.printStackTrace(); + public static void beforeClass() throws SQLException { + Properties properties = new Properties(); + properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); + conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/log?user=root&password=taosdata", properties); + // create test database for test cases + try (Statement stmt = conn.createStatement()) { + stmt.execute("create database if not exists test"); } } @AfterClass - public static void afterClass() { - try { - if (conn != null) - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public static void afterClass() throws SQLException { + if (conn != null) + conn.close(); } } \ No newline at end of file diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDriverTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDriverTest.java index 671ecd723d6fea8d6b9b8ccf94cba06689ce26b8..9f297955d687f3cfcc3acef626e1f905ecee6bdf 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDriverTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDriverTest.java @@ -33,7 +33,6 @@ public class TSDBDriverTest { conn = DriverManager.getConnection(url); assertNotNull("failure - connection should not be null", conn); } catch (SQLException e) { - e.printStackTrace(); fail("failure - should not throw Exception"); } } @@ -49,7 +48,6 @@ public class TSDBDriverTest { conn = DriverManager.getConnection(jdbcUrl, connProps); assertNotNull("failure - connection should not be null", conn); } catch (SQLException e) { - e.printStackTrace(); fail("failure - should not throw Exception"); } } @@ -65,7 +63,6 @@ public class TSDBDriverTest { conn = DriverManager.getConnection(jdbcUrl, connProps); assertNotNull("failure - connection should not be null", conn); } catch (SQLException e) { - e.printStackTrace(); fail("failure - should not throw Exception"); } } @@ -157,16 +154,8 @@ public class TSDBDriverTest { } @Test - public void getParentLogger() throws SQLFeatureNotSupportedException { + public void getParentLogger() { assertNull(new TSDBDriver().getParentLogger()); } - @BeforeClass - public static void before() { - try { - Class.forName("com.taosdata.jdbc.TSDBDriver"); - } catch (ClassNotFoundException e) { - e.printStackTrace(); - } - } } \ No newline at end of file diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/AuthenticationTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/AuthenticationTest.java index 0ea46dade29316b99447a6ea4e372bc8057670e8..5b38f9b0640bb6eec6d1c9749db0abf0388c04ce 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/AuthenticationTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/AuthenticationTest.java @@ -57,44 +57,31 @@ public class AuthenticationTest { @Ignore @Test - public void test() { + public void test() throws SQLException { // change password - try { - conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=" + user + "&password=taosdata"); - Statement stmt = conn.createStatement(); + String url = "jdbc:TAOS-RS://" + host + ":6041/restful_test?user=" + user + "&password=taosdata"; + try (Connection conn = DriverManager.getConnection(url); + Statement stmt = conn.createStatement();) { stmt.execute("alter user " + user + " pass '" + password + "'"); - stmt.close(); - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); } + // use new to login and execute query - try { - conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=" + user + "&password=" + password); - Statement stmt = conn.createStatement(); + url = "jdbc:TAOS-RS://" + host + ":6041/restful_test?user=" + user + "&password=" + password; + try (Connection conn = DriverManager.getConnection(url); + Statement stmt = conn.createStatement()) { stmt.execute("show databases"); ResultSet rs = stmt.getResultSet(); ResultSetMetaData meta = rs.getMetaData(); while (rs.next()) { - for (int i = 1; i <= meta.getColumnCount(); i++) { - System.out.print(meta.getColumnLabel(i) + ":" + rs.getString(i) + "\t"); - } - System.out.println(); } - } catch (SQLException e) { - e.printStackTrace(); } + // change password back - try { - conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=" + user + "&password=" + password); - Statement stmt = conn.createStatement(); + url = "jdbc:TAOS-RS://" + host + ":6041/restful_test?user=" + user + "&password=" + password; + try (Connection conn = DriverManager.getConnection(url); + Statement stmt = conn.createStatement()) { stmt.execute("alter user " + user + " pass 'taosdata'"); - stmt.close(); - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); } - } @Before diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/BadLocaleSettingTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/BadLocaleSettingTest.java deleted file mode 100644 index 2211e0fa176c67329ac13ee4374daf4667da933b..0000000000000000000000000000000000000000 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/BadLocaleSettingTest.java +++ /dev/null @@ -1,59 +0,0 @@ -package com.taosdata.jdbc.cases; - - -import com.taosdata.jdbc.TSDBDriver; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.Test; - -import java.sql.Connection; -import java.sql.DriverManager; -import java.sql.SQLException; -import java.sql.Statement; -import java.util.Properties; - -public class BadLocaleSettingTest { - - private static final String host = "127.0.0.1"; - private static final String dbName = "bad_locale_test"; - private static Connection conn; - - @Test - public void canSetLocale() { - try { - Properties properties = new Properties(); - properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); - - String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"; - conn = DriverManager.getConnection(url, properties); - Statement stmt = conn.createStatement(); - stmt.execute("drop database if exists " + dbName); - stmt.execute("create database if not exists " + dbName); - stmt.execute("use " + dbName); - stmt.execute("drop table if exists weather"); - stmt.execute("create table weather(ts timestamp, temperature float, humidity int)"); - stmt.executeUpdate("insert into weather values(1624071506435, 12.3, 4)"); - stmt.close(); - } catch (SQLException e) { - e.printStackTrace(); - } - } - - @BeforeClass - public static void beforeClass() { - System.setProperty("sun.jnu.encoding", "ANSI_X3.4-1968"); - System.setProperty("file.encoding", "ANSI_X3.4-1968"); - } - - @AfterClass - public static void afterClass() { - try { - if (conn != null) - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); - } - } -} \ No newline at end of file diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/BatchErrorIgnoreTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/BatchErrorIgnoreTest.java index 2934b54b5bd2e7f5450a9a1a00cb5bddca37e945..548c1cff240a811ba998373167588185305a0d59 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/BatchErrorIgnoreTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/BatchErrorIgnoreTest.java @@ -19,16 +19,14 @@ public class BatchErrorIgnoreTest { IntStream.range(1, 6).mapToObj(i -> "insert into test.t" + i + " values(now, " + i + ")").forEach(sql -> { try { stmt.addBatch(sql); - } catch (SQLException e) { - e.printStackTrace(); + } catch (SQLException ignored) { } }); stmt.addBatch("insert into t11 values(now, 11)"); IntStream.range(6, 11).mapToObj(i -> "insert into test.t" + i + " values(now, " + i + "),(now + 1s, " + (10 * i) + ")").forEach(sql -> { try { stmt.addBatch(sql); - } catch (SQLException e) { - e.printStackTrace(); + } catch (SQLException ignored) { } }); stmt.addBatch("select count(*) from test.weather"); @@ -57,23 +55,19 @@ public class BatchErrorIgnoreTest { IntStream.range(1, 6).mapToObj(i -> "insert into test.t" + i + " values(now, " + i + ")").forEach(sql -> { try { stmt.addBatch(sql); - } catch (SQLException e) { - e.printStackTrace(); + } catch (SQLException ignored) { } }); stmt.addBatch("insert into t11 values(now, 11)"); IntStream.range(6, 11).mapToObj(i -> "insert into test.t" + i + " values(now, " + i + "),(now + 1s, " + (10 * i) + ")").forEach(sql -> { try { stmt.addBatch(sql); - } catch (SQLException e) { - e.printStackTrace(); + } catch (SQLException ignored) { } }); stmt.addBatch("select count(*) from test.weather"); results = stmt.executeBatch(); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -94,10 +88,10 @@ public class BatchErrorIgnoreTest { } @Before - public void before() { - try { - Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"); - Statement stmt = conn.createStatement(); + public void before() throws SQLException { + try (Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"); + Statement stmt = conn.createStatement();) { + stmt.execute("use test"); stmt.execute("drop table if exists weather"); stmt.execute("create table weather (ts timestamp, f1 float) tags(t1 int)"); @@ -108,37 +102,25 @@ public class BatchErrorIgnoreTest { e.printStackTrace(); } }); - stmt.close(); - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); } } @BeforeClass - public static void beforeClass() { - try { - Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"); - Statement stmt = conn.createStatement(); + public static void beforeClass() throws SQLException { + try (Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"); + Statement stmt = conn.createStatement()) { + stmt.execute("drop database if exists test"); stmt.execute("create database if not exists test"); - stmt.close(); - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); } } @AfterClass - public static void afterClass() { - try { - Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"); - Statement stmt = conn.createStatement(); + public static void afterClass() throws SQLException { + try (Connection conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"); + Statement stmt = conn.createStatement()) { + stmt.execute("drop database if exists test"); - stmt.close(); - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); } } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectMultiTaosdByRestfulWithDifferentTokenTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectMultiTaosdByRestfulWithDifferentTokenTest.java index fcb6ab7aaff2406acf59262a9cdef90b628b8934..8299cfebec6ba54be42dc1fbe8dcff1b14034860 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectMultiTaosdByRestfulWithDifferentTokenTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectMultiTaosdByRestfulWithDifferentTokenTest.java @@ -20,22 +20,20 @@ public class ConnectMultiTaosdByRestfulWithDifferentTokenTest { private Connection conn2; @Test - public void test() { + public void test() throws SQLException { //when executeSelectStatus(conn1); executeSelectStatus(conn2); executeSelectStatus(conn1); } - private void executeSelectStatus(Connection connection) { + private void executeSelectStatus(Connection connection) throws SQLException { try (Statement stmt = connection.createStatement()) { ResultSet rs = stmt.executeQuery("select server_status()"); ResultSetMetaData meta = rs.getMetaData(); Assert.assertNotNull(meta); while (rs.next()) { } - } catch (SQLException e) { - e.printStackTrace(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectWrongDatabaseTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectWrongDatabaseTest.java index d8d8f1eae42f555b2bc0be12e8a3a943071da3c6..d60ee14fbc87ba5d2bd2e851b5195b513fc4e028 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectWrongDatabaseTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectWrongDatabaseTest.java @@ -1,7 +1,5 @@ package com.taosdata.jdbc.cases; -import com.taosdata.jdbc.TSDBErrorNumbers; -import org.junit.Assert; import org.junit.Test; import java.sql.DriverManager; @@ -9,16 +7,9 @@ import java.sql.SQLException; public class ConnectWrongDatabaseTest { - @Test - public void connect() { - try { - Class.forName("com.taosdata.jdbc.TSDBDriver"); - DriverManager.getConnection("jdbc:TAOS://localhost:6030/wrong_db?user=root&password=taosdata"); - } catch (ClassNotFoundException e) { - e.printStackTrace(); - } catch (SQLException e) { - Assert.assertEquals(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL, e.getErrorCode()); - } + @Test(expected = SQLException.class) + public void connect() throws SQLException { + DriverManager.getConnection("jdbc:TAOS://localhost:6030/wrong_db?user=root&password=taosdata"); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DatetimeBefore1970Test.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DatetimeBefore1970Test.java index 14c76985484857a92e174955c943caa21bdd2e72..bfffaa4a129dc7fe19a92c34abbcc886d5e4e22f 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DatetimeBefore1970Test.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/DatetimeBefore1970Test.java @@ -11,7 +11,7 @@ public class DatetimeBefore1970Test { private Connection conn; @Test - public void test() { + public void test() throws SQLException { try (Statement stmt = conn.createStatement()) { // given stmt.executeUpdate("insert into weather(ts) values('1969-12-31 23:59:59.999')"); @@ -45,36 +45,25 @@ public class DatetimeBefore1970Test { // then ts = rs.getTimestamp("ts"); Assert.assertEquals("1970-01-01 07:59:59.999", TimestampUtil.longToDatetime(ts.getTime())); - - } catch (SQLException e) { - e.printStackTrace(); } } @Before - public void before() { - try { - conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"); - Statement stmt = conn.createStatement(); - stmt.execute("drop database if exists test_timestamp"); - stmt.execute("create database if not exists test_timestamp keep 36500"); - stmt.execute("use test_timestamp"); - stmt.execute("create table weather(ts timestamp,f1 float)"); - stmt.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public void before() throws SQLException { + conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"); + Statement stmt = conn.createStatement(); + stmt.execute("drop database if exists test_timestamp"); + stmt.execute("create database if not exists test_timestamp keep 36500"); + stmt.execute("use test_timestamp"); + stmt.execute("create table weather(ts timestamp,f1 float)"); + stmt.close(); } @After - public void after() { - try { - Statement stmt = conn.createStatement(); - stmt.execute("drop database if exists test_timestamp"); - if (conn != null) - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public void after() throws SQLException { + Statement stmt = conn.createStatement(); + stmt.execute("drop database if exists test_timestamp"); + if (conn != null) + conn.close(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ImportTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ImportTest.java index 1297a6b4c4eb0eca208950363c13e9bb4d1cd3a9..a8fdf4f2caa88d2651bebf2a1c46b95644b488d2 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ImportTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ImportTest.java @@ -17,29 +17,6 @@ public class ImportTest { static String host = "127.0.0.1"; private static long ts; - @BeforeClass - public static void before() { - try { - Properties properties = new Properties(); - properties.setProperty(TSDBDriver.PROPERTY_KEY_USER, "root"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_PASSWORD, "taosdata"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); - connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties); - - Statement stmt = connection.createStatement(); - stmt.execute("create database if not exists " + dbName); - stmt.execute("create table if not exists " + dbName + "." + tName + " (ts timestamp, k int, v int)"); - stmt.close(); - - ts = System.currentTimeMillis(); - } catch (SQLException e) { - e.printStackTrace(); - } - - } - @Test public void case001_insertData() throws Exception { try (Statement stmt = connection.createStatement()) { @@ -52,28 +29,25 @@ public class ImportTest { } @Test - public void case002_checkSum() { + public void case002_checkSum() throws SQLException { Assert.assertEquals(50, select()); } - private int select() { + private int select() throws SQLException { int count = 0; try (Statement stmt = connection.createStatement()) { - String sql = "select * from " + dbName + "." + tName; ResultSet rs = stmt.executeQuery(sql); while (rs.next()) { count++; } rs.close(); - } catch (SQLException e) { - e.printStackTrace(); } return count; } @Test - public void case003_importData() { + public void case003_importData() throws SQLException { // 避免时间重复 try (Statement stmt = connection.createStatement()) { StringBuilder sqlBuilder = new StringBuilder("import into ").append(dbName).append(".").append(tName).append(" values "); @@ -84,27 +58,40 @@ public class ImportTest { } int rows = stmt.executeUpdate(sqlBuilder.toString()); assertEquals(50, rows); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void case004_checkSum() { + public void case004_checkSum() throws SQLException { Assert.assertEquals(100, select()); } + + @BeforeClass + public static void before() throws SQLException { + Properties properties = new Properties(); + properties.setProperty(TSDBDriver.PROPERTY_KEY_USER, "root"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_PASSWORD, "taosdata"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); + connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties); + + Statement stmt = connection.createStatement(); + stmt.execute("create database if not exists " + dbName); + stmt.execute("create table if not exists " + dbName + "." + tName + " (ts timestamp, k int, v int)"); + stmt.close(); + + ts = System.currentTimeMillis(); + } + @AfterClass - public static void close() { - try { - if (connection != null) { - Statement statement = connection.createStatement(); - statement.executeUpdate("drop database " + dbName); - statement.close(); - connection.close(); - } - } catch (SQLException e) { - e.printStackTrace(); + public static void close() throws SQLException { + if (connection != null) { + Statement statement = connection.createStatement(); + statement.executeUpdate("drop database " + dbName); + statement.close(); + connection.close(); } } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MicroSecondPrecisionRestfulTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MicroSecondPrecisionRestfulTest.java index 7e9f04cd6360431a3fe6c29a2f0eb61fbdc9e7c4..f418436a4afac5f16b27789eb43081f131bf1f92 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MicroSecondPrecisionRestfulTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MicroSecondPrecisionRestfulTest.java @@ -23,7 +23,7 @@ public class MicroSecondPrecisionRestfulTest { private static Connection conn3; @Test - public void testCase1() { + public void testCase1() throws SQLException { try (Statement stmt = conn1.createStatement()) { ResultSet rs = stmt.executeQuery("select last_row(ts) from " + ms_timestamp_db + ".weather"); rs.next(); @@ -31,13 +31,11 @@ public class MicroSecondPrecisionRestfulTest { Assert.assertEquals(timestamp1, ts); ts = rs.getLong(1); Assert.assertEquals(timestamp1, ts); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void testCase2() { + public void testCase2() throws SQLException { try (Statement stmt = conn1.createStatement()) { ResultSet rs = stmt.executeQuery("select last_row(ts) from " + us_timestamp_db + ".weather"); rs.next(); @@ -50,13 +48,11 @@ public class MicroSecondPrecisionRestfulTest { ts = rs.getLong(1); Assert.assertEquals(timestamp1, ts); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void testCase3() { + public void testCase3() throws SQLException { try (Statement stmt = conn2.createStatement()) { ResultSet rs = stmt.executeQuery("select last_row(ts) from " + ms_timestamp_db + ".weather"); rs.next(); @@ -65,13 +61,11 @@ public class MicroSecondPrecisionRestfulTest { Assert.assertEquals(timestamp1, ts); ts = rs.getLong(1); Assert.assertEquals(timestamp1, ts); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void testCase4() { + public void testCase4() throws SQLException { try (Statement stmt = conn2.createStatement()) { ResultSet rs = stmt.executeQuery("select last_row(ts) from " + us_timestamp_db + ".weather"); rs.next(); @@ -84,13 +78,11 @@ public class MicroSecondPrecisionRestfulTest { ts = rs.getLong(1); Assert.assertEquals(timestamp1, ts); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void testCase5() { + public void testCase5() throws SQLException { try (Statement stmt = conn3.createStatement()) { ResultSet rs = stmt.executeQuery("select last_row(ts) from " + ms_timestamp_db + ".weather"); rs.next(); @@ -99,13 +91,11 @@ public class MicroSecondPrecisionRestfulTest { Assert.assertEquals(timestamp1, ts); ts = rs.getLong(1); Assert.assertEquals(timestamp1, ts); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void testCase6() { + public void testCase6() throws SQLException { try (Statement stmt = conn3.createStatement()) { ResultSet rs = stmt.executeQuery("select last_row(ts) from " + us_timestamp_db + ".weather"); rs.next(); @@ -118,8 +108,6 @@ public class MicroSecondPrecisionRestfulTest { ts = rs.getLong(1); Assert.assertEquals(timestamp1, ts); - } catch (SQLException e) { - e.printStackTrace(); } } @@ -154,16 +142,12 @@ public class MicroSecondPrecisionRestfulTest { } @AfterClass - public static void afterClass() { - try { - if (conn1 != null) - conn1.close(); - if (conn2 != null) - conn2.close(); - if (conn3 != null) - conn3.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public static void afterClass() throws SQLException { + if (conn1 != null) + conn1.close(); + if (conn2 != null) + conn2.close(); + if (conn3 != null) + conn3.close(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java index 18a2c32aca0535567dd42e886bc87ae618596a40..0bf8334079e630bf61b7955a37c74401da24a947 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiConnectionWithDifferentDbTest.java @@ -9,8 +9,7 @@ import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; import java.util.stream.IntStream; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.*; public class MultiConnectionWithDifferentDbTest { @@ -26,16 +25,17 @@ public class MultiConnectionWithDifferentDbTest { @Override public void run() { for (int j = 0; j < 10; j++) { - queryDb(); try { + queryDb(); TimeUnit.SECONDS.sleep(1); - } catch (InterruptedException e) { - e.printStackTrace(); + } catch (InterruptedException ignored) { + } catch (SQLException throwables) { + fail(); } } } - private void queryDb() { + private void queryDb() throws SQLException { String url = "jdbc:TAOS-RS://" + host + ":6041/db" + i + "?user=root&password=taosdata"; try (Connection connection = DriverManager.getConnection(url)) { Statement stmt = connection.createStatement(); @@ -54,8 +54,6 @@ public class MultiConnectionWithDifferentDbTest { assertEquals(loc, loc_actual); stmt.close(); - } catch (SQLException e) { - e.printStackTrace(); } } }, "thread-" + i)).collect(Collectors.toList()); @@ -73,12 +71,10 @@ public class MultiConnectionWithDifferentDbTest { } @Before - public void before() { + public void before() throws SQLException { ts = System.currentTimeMillis(); - try { - Connection conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"); - + try (Connection conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata")) { Statement stmt = conn.createStatement(); stmt.execute("drop database if exists " + db1); stmt.execute("create database if not exists " + db1); @@ -91,10 +87,6 @@ public class MultiConnectionWithDifferentDbTest { stmt.execute("use " + db2); stmt.execute("create table weather(ts timestamp, f1 int) tags(loc nchar(10))"); stmt.execute("insert into t1 using weather tags('shanghai') values(" + ts + ", 2)"); - - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiThreadsWithSameStatementTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiThreadsWithSameStatementTest.java deleted file mode 100644 index 73da79f357b1c066943e2f39bf9f8bdc86382d7e..0000000000000000000000000000000000000000 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiThreadsWithSameStatementTest.java +++ /dev/null @@ -1,85 +0,0 @@ -package com.taosdata.jdbc.cases; - -import org.junit.After; -import org.junit.Before; -import org.junit.Test; - -import java.sql.*; -import java.util.concurrent.TimeUnit; - -public class MultiThreadsWithSameStatementTest { - - private static class Service { - public Connection conn; - public Statement stmt; - - public Service() { - try { - conn = DriverManager.getConnection("jdbc:TAOS://localhost:6030/?user=root&password=taosdata"); - stmt = conn.createStatement(); - stmt.execute("create database if not exists jdbctest"); - stmt.executeUpdate("create table if not exists jdbctest.weather (ts timestamp, f1 int)"); - } catch (SQLException e) { - e.printStackTrace(); - } - } - - public void release() { - try { - stmt.close(); - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); - } - } - } - - @Before - public void before() { - } - - @Test - public void test() { - Thread t1 = new Thread(() -> { - try { - Service service = new Service(); - ResultSet resultSet = service.stmt.executeQuery("select * from jdbctest.weather"); - while (resultSet.next()) { - ResultSetMetaData metaData = resultSet.getMetaData(); - } - resultSet.close(); - service.release(); - } catch (SQLException e) { - e.printStackTrace(); - } - }); - - Thread t2 = new Thread(() -> { - while (true) { - try { - Service service = new Service(); - service.stmt.executeUpdate("insert into jdbctest.weather values(now,1)"); - service.release(); - } catch (SQLException e) { - e.printStackTrace(); - } - } - - }); - t1.start(); - sleep(1000); - t2.start(); - } - - private void sleep(long mills) { - try { - TimeUnit.MILLISECONDS.sleep(mills); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - - @After - public void after() { - } -} diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampJNITest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampJNITest.java index 4f2c87966ad6bb8390bab47b795e7d952725baf5..a84f5233974e9bd9acdbbe3ca8ae0404c11b34a1 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampJNITest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampJNITest.java @@ -17,7 +17,7 @@ public class NanoSecondTimestampJNITest { private static Connection conn; @Test - public void insertUsingLongValue() { + public void insertUsingLongValue() throws SQLException { // given long ms = System.currentTimeMillis(); long ns = ms * 1000_000 + random.nextInt(1000_000); @@ -26,8 +26,6 @@ public class NanoSecondTimestampJNITest { int ret = 0; try (Statement stmt = conn.createStatement()) { ret = stmt.executeUpdate("insert into weather(ts, temperature, humidity) values(" + ns + ", 12.3, 4)"); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -35,15 +33,13 @@ public class NanoSecondTimestampJNITest { } @Test - public void insertUsingStringValue() { + public void insertUsingStringValue() throws SQLException { // given // when int ret = 0; try (Statement stmt = conn.createStatement()) { ret = stmt.executeUpdate("insert into weather(ts, temperature, humidity) values('2021-01-01 12:00:00.123456789', 12.3, 4)"); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -51,7 +47,7 @@ public class NanoSecondTimestampJNITest { } @Test - public void insertUsingTimestampValue() { + public void insertUsingTimestampValue() throws SQLException { // given long epochSec = System.currentTimeMillis() / 1000; long nanoAdjustment = random.nextInt(1000_000_000); @@ -65,8 +61,6 @@ public class NanoSecondTimestampJNITest { pstmt.setFloat(2, 12.34f); pstmt.setInt(3, 55); ret = pstmt.executeUpdate(); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -85,8 +79,6 @@ public class NanoSecondTimestampJNITest { stmt.executeUpdate("insert into weather(ts, temperature, humidity) values(" + ns + ", 12.3, 4)"); rs = stmt.executeQuery("select * from weather"); rs.next(); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -102,13 +94,11 @@ public class NanoSecondTimestampJNITest { String timestampStr = "2021-01-01 12:00:00.123456789"; // when - ResultSet rs = null; + ResultSet rs; try (Statement stmt = conn.createStatement()) { stmt.executeUpdate("insert into weather(ts, temperature, humidity) values('" + timestampStr + "', 12.3, 4)"); rs = stmt.executeQuery("select * from weather"); rs.next(); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -133,8 +123,6 @@ public class NanoSecondTimestampJNITest { pstmt.setFloat(2, 12.34f); pstmt.setInt(3, 55); pstmt.executeUpdate(); - } catch (SQLException e) { - e.printStackTrace(); } // when @@ -142,8 +130,6 @@ public class NanoSecondTimestampJNITest { try (Statement stmt = conn.createStatement()) { rs = stmt.executeQuery("select * from weather"); rs.next(); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -156,26 +142,21 @@ public class NanoSecondTimestampJNITest { } @Before - public void before() { + public void before() throws SQLException { try (Statement stmt = conn.createStatement()) { stmt.execute("drop table if exists weather"); stmt.execute("create table weather(ts timestamp, temperature float, humidity int)"); - } catch (SQLException e) { - e.printStackTrace(); } } @BeforeClass - public static void beforeClass() { + public static void beforeClass() throws SQLException { final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"; - try { - conn = DriverManager.getConnection(url); - Statement stmt = conn.createStatement(); + conn = DriverManager.getConnection(url); + try (Statement stmt = conn.createStatement()) { stmt.execute("drop database if exists " + dbname); stmt.execute("create database if not exists " + dbname + " precision 'ns'"); stmt.execute("use " + dbname); - } catch (SQLException e) { - e.printStackTrace(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampRestfulTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampRestfulTest.java index 4271f918b9b096000cc59b730d7b70f032a0ab29..c8aaf5c6788d18e782e431ba4ed97fb69f4702ab 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampRestfulTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NanoSecondTimestampRestfulTest.java @@ -17,7 +17,7 @@ public class NanoSecondTimestampRestfulTest { private static Connection conn; @Test - public void insertUsingLongValue() { + public void insertUsingLongValue() throws SQLException { // given long ms = System.currentTimeMillis(); long ns = ms * 1000_000 + random.nextInt(1000_000); @@ -26,8 +26,6 @@ public class NanoSecondTimestampRestfulTest { int ret = 0; try (Statement stmt = conn.createStatement()) { ret = stmt.executeUpdate("insert into weather(ts, temperature, humidity) values(" + ns + ", 12.3, 4)"); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -35,15 +33,13 @@ public class NanoSecondTimestampRestfulTest { } @Test - public void insertUsingStringValue() { + public void insertUsingStringValue() throws SQLException { // given // when int ret = 0; try (Statement stmt = conn.createStatement()) { ret = stmt.executeUpdate("insert into weather(ts, temperature, humidity) values('2021-01-01 12:00:00.123456789', 12.3, 4)"); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -51,7 +47,7 @@ public class NanoSecondTimestampRestfulTest { } @Test - public void insertUsingTimestampValue() { + public void insertUsingTimestampValue() throws SQLException { // given long epochSec = System.currentTimeMillis() / 1000; long nanoAdjustment = random.nextInt(1000_000_000); @@ -65,8 +61,6 @@ public class NanoSecondTimestampRestfulTest { pstmt.setFloat(2, 12.34f); pstmt.setInt(3, 55); ret = pstmt.executeUpdate(); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -80,13 +74,11 @@ public class NanoSecondTimestampRestfulTest { long ns = ms * 1000_000L + random.nextInt(1000_000); // when - ResultSet rs = null; + ResultSet rs; try (Statement stmt = conn.createStatement()) { stmt.executeUpdate("insert into weather(ts, temperature, humidity) values(" + ns + ", 12.3, 4)"); rs = stmt.executeQuery("select * from weather"); rs.next(); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -102,13 +94,11 @@ public class NanoSecondTimestampRestfulTest { String timestampStr = "2021-01-01 12:00:00.123456789"; // when - ResultSet rs = null; + ResultSet rs; try (Statement stmt = conn.createStatement()) { stmt.executeUpdate("insert into weather(ts, temperature, humidity) values('" + timestampStr + "', 12.3, 4)"); rs = stmt.executeQuery("select * from weather"); rs.next(); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -133,8 +123,6 @@ public class NanoSecondTimestampRestfulTest { pstmt.setFloat(2, 12.34f); pstmt.setInt(3, 55); pstmt.executeUpdate(); - } catch (SQLException e) { - e.printStackTrace(); } // when @@ -142,8 +130,6 @@ public class NanoSecondTimestampRestfulTest { try (Statement stmt = conn.createStatement()) { rs = stmt.executeQuery("select * from weather"); rs.next(); - } catch (SQLException e) { - e.printStackTrace(); } // then @@ -156,26 +142,21 @@ public class NanoSecondTimestampRestfulTest { } @Before - public void before() { + public void before() throws SQLException { try (Statement stmt = conn.createStatement()) { stmt.execute("drop table if exists weather"); stmt.execute("create table weather(ts timestamp, temperature float, humidity int)"); - } catch (SQLException e) { - e.printStackTrace(); } } @BeforeClass - public static void beforeClass() { + public static void beforeClass() throws SQLException { final String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"; - try { - conn = DriverManager.getConnection(url); - Statement stmt = conn.createStatement(); + conn = DriverManager.getConnection(url); + try (Statement stmt = conn.createStatement()) { stmt.execute("drop database if exists " + dbname); stmt.execute("create database if not exists " + dbname + " precision 'ns'"); stmt.execute("use " + dbname); - } catch (SQLException e) { - e.printStackTrace(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetJNITest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetJNITest.java index ae0241bf31eea85083bf102c4123f7e30c2bd693..6efd9f5ebee29a122c2106439117738c44241597 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetJNITest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetJNITest.java @@ -12,15 +12,13 @@ public class NullValueInResultSetJNITest { Connection conn; @Test - public void test() { + public void test() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select * from weather"); ResultSetMetaData meta = rs.getMetaData(); while (rs.next()) { } - } catch (SQLException e) { - e.printStackTrace(); } } @@ -42,18 +40,12 @@ public class NullValueInResultSetJNITest { stmt.executeUpdate("insert into weather(ts, f7) values(now+7s, true)"); stmt.executeUpdate("insert into weather(ts, f8) values(now+8s, 'hello')"); stmt.executeUpdate("insert into weather(ts, f9) values(now+9s, '涛思数据')"); - } catch (SQLException e) { - e.printStackTrace(); } } @After - public void after() { - try { - if (conn != null) - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public void after() throws SQLException { + if (conn != null) + conn.close(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetRestfulTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetRestfulTest.java index 7fbb30a5244a53129807cd76472674ff1cfd6ae4..f331a58583db832124465492d07f24f1772348ce 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetRestfulTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/NullValueInResultSetRestfulTest.java @@ -12,7 +12,7 @@ public class NullValueInResultSetRestfulTest { Connection conn; @Test - public void test() { + public void test() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select * from weather"); ResultSetMetaData meta = rs.getMetaData(); @@ -21,9 +21,6 @@ public class NullValueInResultSetRestfulTest { Object value = rs.getObject(i); } } - - } catch (SQLException e) { - e.printStackTrace(); } } @@ -45,18 +42,12 @@ public class NullValueInResultSetRestfulTest { stmt.executeUpdate("insert into weather(ts, f7) values(now+7s, true)"); stmt.executeUpdate("insert into weather(ts, f8) values(now+8s, 'hello')"); stmt.executeUpdate("insert into weather(ts, f9) values(now+9s, '涛思数据')"); - } catch (SQLException e) { - e.printStackTrace(); } } @After - public void after() { - try { - if (conn != null) - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public void after() throws SQLException { + if (conn != null) + conn.close(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/PreparedStatementBatchInsertRestfulTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/PreparedStatementBatchInsertRestfulTest.java index 90b285381a2ab57b170da327a95dde4c8991ce21..85fbeef1b589434dc17267af20510bc2a8ebd554 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/PreparedStatementBatchInsertRestfulTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/PreparedStatementBatchInsertRestfulTest.java @@ -20,7 +20,7 @@ public class PreparedStatementBatchInsertRestfulTest { private Connection conn; @Test - public void test() { + public void test() throws SQLException { // given long ts = System.currentTimeMillis(); List rows = IntStream.range(0, 10).mapToObj(i -> { @@ -52,7 +52,6 @@ public class PreparedStatementBatchInsertRestfulTest { } pstmt.executeBatch(); } catch (SQLException e) { - e.printStackTrace(); Assert.fail(); } @@ -64,35 +63,25 @@ public class PreparedStatementBatchInsertRestfulTest { count++; } Assert.assertEquals(10, count); - } catch (SQLException e) { - e.printStackTrace(); } } @Before - public void before() { - try { - conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"); - Statement stmt = conn.createStatement(); - stmt.execute("drop database if exists " + dbname); - stmt.execute("create database if not exists " + dbname); - stmt.execute("use " + dbname); - stmt.execute("create table meters(ts timestamp, current float, voltage int, phase int) tags(groupId int)"); - } catch (SQLException e) { - e.printStackTrace(); - } + public void before() throws SQLException { + conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"); + Statement stmt = conn.createStatement(); + stmt.execute("drop database if exists " + dbname); + stmt.execute("create database if not exists " + dbname); + stmt.execute("use " + dbname); + stmt.execute("create table meters(ts timestamp, current float, voltage int, phase int) tags(groupId int)"); } @After - public void after() { - try { - Statement stmt = conn.createStatement(); - stmt.execute("drop database if exists " + dbname); - stmt.close(); - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public void after() throws SQLException { + Statement stmt = conn.createStatement(); + stmt.execute("drop database if exists " + dbname); + stmt.close(); + conn.close(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/QueryDataTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/QueryDataTest.java index b4449491a93c2ffc857448b8697e771eabd0f97a..fd74e9433a786f407f75e2a28a9b5672f7373b8b 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/QueryDataTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/QueryDataTest.java @@ -19,26 +19,22 @@ public class QueryDataTest { static String host = "127.0.0.1"; @Before - public void createDatabase() { - try { - Properties properties = new Properties(); - properties.setProperty(TSDBDriver.PROPERTY_KEY_USER, "root"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_PASSWORD, "taosdata"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); - connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties); - - statement = connection.createStatement(); - statement.executeUpdate("drop database if exists " + dbName); - statement.executeUpdate("create database if not exists " + dbName); - statement.executeUpdate("use " + dbName); - - String createTableSql = "create table " + stbName + "(ts timestamp, name binary(64))"; - statement.executeUpdate(createTableSql); - } catch (SQLException e) { - e.printStackTrace(); - } + public void createDatabase() throws SQLException { + Properties properties = new Properties(); + properties.setProperty(TSDBDriver.PROPERTY_KEY_USER, "root"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_PASSWORD, "taosdata"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); + connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties); + + statement = connection.createStatement(); + statement.executeUpdate("drop database if exists " + dbName); + statement.executeUpdate("create database if not exists " + dbName); + statement.executeUpdate("use " + dbName); + + String createTableSql = "create table " + stbName + "(ts timestamp, name binary(64))"; + statement.executeUpdate(createTableSql); } @Test @@ -57,15 +53,11 @@ public class QueryDataTest { } @After - public void close() { - try { - if (statement != null) - statement.close(); - if (connection != null) - connection.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public void close() throws SQLException { + if (statement != null) + statement.close(); + if (connection != null) + connection.close(); } } \ No newline at end of file diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ResultSetMetaShouldNotBeNullRestfulTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ResultSetMetaShouldNotBeNullRestfulTest.java index be27b1350781245e3056185db4bbaa8b5105d2f0..ff0dad1bda4b8defa8c515011604deeddf13f95b 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ResultSetMetaShouldNotBeNullRestfulTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ResultSetMetaShouldNotBeNullRestfulTest.java @@ -15,19 +15,15 @@ public class ResultSetMetaShouldNotBeNullRestfulTest { private Connection connection; @Test - public void testExecuteQuery() { + public void testExecuteQuery() throws SQLException { // given - ResultSetMetaData metaData = null; - int columnCount = -1; + ResultSetMetaData metaData; + int columnCount; // when - try { - Statement statement = connection.createStatement(); - metaData = statement.executeQuery("select * from weather").getMetaData(); - columnCount = metaData.getColumnCount(); - } catch (SQLException e) { - e.printStackTrace(); - } + Statement statement = connection.createStatement(); + metaData = statement.executeQuery("select * from weather").getMetaData(); + columnCount = metaData.getColumnCount(); // then Assert.assertNotNull(metaData); @@ -35,20 +31,17 @@ public class ResultSetMetaShouldNotBeNullRestfulTest { } @Test - public void testExecute() { + public void testExecute() throws SQLException { // given - ResultSetMetaData metaData = null; - int columnCount = -1; - boolean execute = false; + ResultSetMetaData metaData; + int columnCount; + boolean execute; + // when - try { - Statement statement = connection.createStatement(); - execute = statement.execute("select * from weather"); - metaData = statement.getResultSet().getMetaData(); - columnCount = metaData.getColumnCount(); - } catch (SQLException e) { - e.printStackTrace(); - } + Statement statement = connection.createStatement(); + execute = statement.execute("select * from weather"); + metaData = statement.getResultSet().getMetaData(); + columnCount = metaData.getColumnCount(); // then Assert.assertEquals(true, execute); @@ -57,30 +50,22 @@ public class ResultSetMetaShouldNotBeNullRestfulTest { } @Before - public void before() { - try { - connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"); - Statement stmt = connection.createStatement(); - stmt.execute("drop database if exists " + dbname); - stmt.execute("create database if not exists " + dbname); - stmt.execute("use " + dbname); - stmt.execute("create table weather (ts timestamp, temperature float)"); - stmt.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public void before() throws SQLException { + connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"); + Statement stmt = connection.createStatement(); + stmt.execute("drop database if exists " + dbname); + stmt.execute("create database if not exists " + dbname); + stmt.execute("use " + dbname); + stmt.execute("create table weather (ts timestamp, temperature float)"); + stmt.close(); } @After - public void after() { - try { - Statement stmt = connection.createStatement(); - stmt.execute("drop database if exists " + dbname); - stmt.close(); - connection.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public void after() throws SQLException { + Statement stmt = connection.createStatement(); + stmt.execute("drop database if exists " + dbname); + stmt.close(); + connection.close(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/SelectTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/SelectTest.java index b51c0309be809250839a5241d12296182067dfd3..79e5602e9e6c436d5671cc1c92847e54949d9025 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/SelectTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/SelectTest.java @@ -17,25 +17,20 @@ public class SelectTest { String host = "127.0.0.1"; @Before - public void createDatabaseAndTable() { - try { - Properties properties = new Properties(); - properties.setProperty(TSDBDriver.PROPERTY_KEY_USER, "root"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_PASSWORD, "taosdata"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); - connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties); - - Statement stmt = connection.createStatement(); - stmt.execute("drop database if exists " + dbName); - stmt.execute("create database if not exists " + dbName); - stmt.execute("create table if not exists " + dbName + "." + tName + " (ts timestamp, k int, v int)"); - stmt.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public void createDatabaseAndTable() throws SQLException { + Properties properties = new Properties(); + properties.setProperty(TSDBDriver.PROPERTY_KEY_USER, "root"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_PASSWORD, "taosdata"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); + connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties); + Statement stmt = connection.createStatement(); + stmt.execute("drop database if exists " + dbName); + stmt.execute("create database if not exists " + dbName); + stmt.execute("create table if not exists " + dbName + "." + tName + " (ts timestamp, k int, v int)"); + stmt.close(); } @Test @@ -65,16 +60,12 @@ public class SelectTest { } @After - public void close() { - try { - if (connection != null) { - Statement stmt = connection.createStatement(); - stmt.executeUpdate("drop database " + dbName); - stmt.close(); - connection.close(); - } - } catch (SQLException e) { - e.printStackTrace(); + public void close() throws SQLException { + if (connection != null) { + Statement stmt = connection.createStatement(); + stmt.executeUpdate("drop database " + dbName); + stmt.close(); + connection.close(); } } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TaosInfoMonitorTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TaosInfoMonitorTest.java deleted file mode 100644 index 7df9f7380704eefb51b26214295624995811c84f..0000000000000000000000000000000000000000 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TaosInfoMonitorTest.java +++ /dev/null @@ -1,49 +0,0 @@ -package com.taosdata.jdbc.cases; - -import org.junit.Test; - -import java.sql.*; -import java.util.List; -import java.util.concurrent.TimeUnit; -import java.util.stream.Collectors; -import java.util.stream.IntStream; - -public class TaosInfoMonitorTest { - - @Test - public void testCreateTooManyConnection() throws ClassNotFoundException { - Class.forName("com.taosdata.jdbc.TSDBDriver"); - final String url = "jdbc:TAOS://127.0.0.1:6030/?user=root&password=taosdata"; - - List connectionList = IntStream.range(0, 100).mapToObj(i -> { - try { - TimeUnit.MILLISECONDS.sleep(100); - return DriverManager.getConnection(url); - } catch (SQLException | InterruptedException e) { - e.printStackTrace(); - } - return null; - }).collect(Collectors.toList()); - - connectionList.forEach(conn -> { - try (Statement stmt = conn.createStatement()) { - ResultSet rs = stmt.executeQuery("show databases"); - while (rs.next()) { - - } - TimeUnit.MILLISECONDS.sleep(100); - } catch (SQLException | InterruptedException e) { - e.printStackTrace(); - } - }); - - connectionList.forEach(conn -> { - try { - conn.close(); - TimeUnit.MILLISECONDS.sleep(100); - } catch (SQLException | InterruptedException e) { - e.printStackTrace(); - } - }); - } -} diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TimestampPrecisionInNanoInJniTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TimestampPrecisionInNanoInJniTest.java index 72734cb0ecdfe67cbd02306acef3ae8625f942b0..2d336135e5d1dc28db010387ab838f17d9b9a9cc 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TimestampPrecisionInNanoInJniTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TimestampPrecisionInNanoInJniTest.java @@ -25,7 +25,7 @@ public class TimestampPrecisionInNanoInJniTest { private static final String date4 = format.format(new Date(timestamp1 + 10L)); private static final String date2 = date1 + "123455"; private static final String date3 = date4 + "123456"; - + private static Connection conn; @@ -43,7 +43,7 @@ public class TimestampPrecisionInNanoInJniTest { stmt.execute("drop database if exists " + ns_timestamp_db); stmt.execute("create database if not exists " + ns_timestamp_db + " precision 'ns'"); stmt.execute("create table " + ns_timestamp_db + ".weather(ts timestamp, ts2 timestamp, f1 int)"); - stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(\"" + date3 + "\", \"" + date3 + "\", 128)"); + stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(\"" + date3 + "\", \"" + date3 + "\", 128)"); stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(" + timestamp2 + "," + timestamp2 + ", 127)"); stmt.close(); } @@ -54,7 +54,7 @@ public class TimestampPrecisionInNanoInJniTest { stmt.execute("drop database if exists " + ns_timestamp_db); stmt.execute("create database if not exists " + ns_timestamp_db + " precision 'ns'"); stmt.execute("create table " + ns_timestamp_db + ".weather(ts timestamp, ts2 timestamp, f1 int)"); - stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(\"" + date3 + "\", \"" + date3 + "\", 128)"); + stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(\"" + date3 + "\", \"" + date3 + "\", 128)"); stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(" + timestamp2 + "," + timestamp2 + ", 127)"); stmt.close(); } @@ -105,7 +105,7 @@ public class TimestampPrecisionInNanoInJniTest { @Test public void canImportTimestampAndQueryByEqualToInDateTypeInBothFirstAndSecondCol() { try (Statement stmt = conn.createStatement()) { - stmt.executeUpdate("import into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(\"" + date1 + "123123\", \"" + date1 + "123123\", 127)"); + stmt.executeUpdate("import into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(\"" + date1 + "123123\", \"" + date1 + "123123\", 127)"); ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts = '" + date1 + "123123'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts from " + ns_timestamp_db + ".weather where ts = '" + date1 + "123123'"); @@ -139,7 +139,7 @@ public class TimestampPrecisionInNanoInJniTest { public void canImportTimestampAndQueryByEqualToInNumberTypeInBothFirstAndSecondCol() { try (Statement stmt = conn.createStatement()) { long timestamp4 = timestamp1 * 1000_000 + 123123; - stmt.executeUpdate("import into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(" + timestamp4 + ", " + timestamp4 + ", 127)"); + stmt.executeUpdate("import into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(" + timestamp4 + ", " + timestamp4 + ", 127)"); ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts = '" + timestamp4 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts from " + ns_timestamp_db + ".weather where ts = '" + timestamp4 + "'"); @@ -184,300 +184,248 @@ public class TimestampPrecisionInNanoInJniTest { } @Test - public void canSelectFirstRowFromWeatherForSecondCol() { + public void canSelectFirstRowFromWeatherForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select first(ts2) from " + ns_timestamp_db + ".weather"); checkTime(timestamp2, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLargerThanInDateTypeForFirstCol() { + public void canQueryLargerThanInDateTypeForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts > '" + date2 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts from " + ns_timestamp_db + ".weather where ts > '" + date2 + "'"); checkTime(timestamp3, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLargerThanInDateTypeForSecondCol() { + public void canQueryLargerThanInDateTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 > '" + date2 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts2 from " + ns_timestamp_db + ".weather where ts2 > '" + date2 + "'"); checkTime(timestamp3, rs); - } catch (SQLException e) { - e.printStackTrace(); } - } + } @Test - public void canQueryLargerThanInNumberTypeForFirstCol() { + public void canQueryLargerThanInNumberTypeForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts > '" + timestamp2 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts from " + ns_timestamp_db + ".weather where ts > '" + timestamp2 + "'"); checkTime(timestamp3, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLargerThanInNumberTypeForSecondCol() { + public void canQueryLargerThanInNumberTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 > '" + timestamp2 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts2 from " + ns_timestamp_db + ".weather where ts2 > '" + timestamp2 + "'"); checkTime(timestamp3, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLargerThanOrEqualToInDateTypeForFirstCol() { + public void canQueryLargerThanOrEqualToInDateTypeForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts >= '" + date2 + "'"); checkCount(2l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLargerThanOrEqualToInDateTypeForSecondCol() { + public void canQueryLargerThanOrEqualToInDateTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 >= '" + date2 + "'"); checkCount(2l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLargerThanOrEqualToInNumberTypeForFirstCol() { + public void canQueryLargerThanOrEqualToInNumberTypeForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts >= '" + timestamp2 + "'"); checkCount(2l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLargerThanOrEqualToInNumberTypeForSecondCol() { + public void canQueryLargerThanOrEqualToInNumberTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 >= '" + timestamp2 + "'"); checkCount(2l, rs); - } catch (SQLException e) { - e.printStackTrace(); } - } + } @Test - public void canQueryLessThanInDateTypeForFirstCol() { + public void canQueryLessThanInDateTypeForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts < '" + date3 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts from " + ns_timestamp_db + ".weather where ts < '" + date3 + "'"); checkTime(timestamp2, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLessThanInDateTypeForSecondCol() { + public void canQueryLessThanInDateTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 < '" + date3 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts2 from " + ns_timestamp_db + ".weather where ts2 < '" + date3 + "'"); checkTime(timestamp2, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLessThanInNumberTypeForFirstCol() { + public void canQueryLessThanInNumberTypeForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts < '" + timestamp3 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts from " + ns_timestamp_db + ".weather where ts < '" + timestamp3 + "'"); checkTime(timestamp2, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLessThanInNumberTypeForSecondCol() { + public void canQueryLessThanInNumberTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 < '" + timestamp3 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts2 from " + ns_timestamp_db + ".weather where ts2 < '" + timestamp3 + "'"); checkTime(timestamp2, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLessThanOrEqualToInDateTypeForFirstCol() { + public void canQueryLessThanOrEqualToInDateTypeForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts <= '" + date3 + "'"); checkCount(2l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLessThanOrEqualToInDateTypeForSecondCol() { + public void canQueryLessThanOrEqualToInDateTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 <= '" + date3 + "'"); checkCount(2l, rs); - } catch (SQLException e) { - e.printStackTrace(); } - } + } @Test - public void canQueryLessThanOrEqualToInNumberTypeForFirstCol() { + public void canQueryLessThanOrEqualToInNumberTypeForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts <= '" + timestamp3 + "'"); checkCount(2l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryLessThanOrEqualToInNumberTypeForSecondCol() { + public void canQueryLessThanOrEqualToInNumberTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 <= '" + timestamp3 + "'"); checkCount(2l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryBetweenAndInDateTypeForFirstCol() { + public void canQueryBetweenAndInDateTypeForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts <= '" + date3 + "' AND ts > '" + date2 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts from " + ns_timestamp_db + ".weather where ts <= '" + date3 + "' AND ts > '" + date2 + "'"); checkTime(timestamp3, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryBetweenAndInDateTypeForSecondCol() { + public void canQueryBetweenAndInDateTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 <= '" + date3 + "' AND ts2 > '" + date2 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts2 from " + ns_timestamp_db + ".weather where ts2 <= '" + date3 + "' AND ts2 > '" + date2 + "'"); checkTime(timestamp3, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryBetweenAndInNumberTypeForFirstCol() { + public void canQueryBetweenAndInNumberTypeForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts <= '" + timestamp3 + "' AND ts > '" + timestamp2 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts from " + ns_timestamp_db + ".weather where ts <= '" + timestamp3 + "' AND ts > '" + timestamp2 + "'"); checkTime(timestamp3, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryBetweenAndInNumberTypeForSecondCol() { + public void canQueryBetweenAndInNumberTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 <= '" + timestamp3 + "' AND ts2 > '" + timestamp2 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts2 from " + ns_timestamp_db + ".weather where ts2 <= '" + timestamp3 + "' AND ts2 > '" + timestamp2 + "'"); checkTime(timestamp3, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryNotEqualToInDateTypeForSecondCol() { + public void canQueryNotEqualToInDateTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 <> '" + date3 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts2 from " + ns_timestamp_db + ".weather where ts2 <> '" + date3 + "'"); checkTime(timestamp2, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryNotEqualToInNumberTypeForSecondCol() { + public void canQueryNotEqualToInNumberTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 <> '" + timestamp3 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts2 from " + ns_timestamp_db + ".weather where ts2 <> '" + timestamp3 + "'"); checkTime(timestamp2, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryNotEqualInDateTypeForSecondCol() { + public void canQueryNotEqualInDateTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 != '" + date3 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts2 from " + ns_timestamp_db + ".weather where ts2 != '" + date3 + "'"); checkTime(timestamp2, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canQueryNotEqualInNumberTypeForSecondCol() { + public void canQueryNotEqualInNumberTypeForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 != '" + timestamp3 + "'"); checkCount(1l, rs); rs = stmt.executeQuery("select ts2 from " + ns_timestamp_db + ".weather where ts2 != '" + timestamp3 + "'"); checkTime(timestamp2, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canInsertTimestampWithNowAndNsOffsetInBothFirstAndSecondCol(){ + public void canInsertTimestampWithNowAndNsOffsetInBothFirstAndSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values(now + 1000b, now - 1000b, 128)"); ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather"); checkCount(3l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canIntervalAndSlidingAcceptNsUnitForFirstCol(){ + public void canIntervalAndSlidingAcceptNsUnitForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select sum(f1) from " + ns_timestamp_db + ".weather where ts >= '" + date2 + "' and ts <= '" + date3 + "' interval(10000000b) sliding(10000000b)"); rs.next(); @@ -486,13 +434,11 @@ public class TimestampPrecisionInNanoInJniTest { rs.next(); sum = rs.getLong(2); Assert.assertEquals(128l, sum); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void canIntervalAndSlidingAcceptNsUnitForSecondCol(){ + public void canIntervalAndSlidingAcceptNsUnitForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select sum(f1) from " + ns_timestamp_db + ".weather where ts2 >= '" + date2 + "' and ts <= '" + date3 + "' interval(10000000b) sliding(10000000b)"); rs.next(); @@ -501,8 +447,6 @@ public class TimestampPrecisionInNanoInJniTest { rs.next(); sum = rs.getLong(2); Assert.assertEquals(128l, sum); - } catch (SQLException e) { - e.printStackTrace(); } } @@ -525,46 +469,38 @@ public class TimestampPrecisionInNanoInJniTest { } @Test - public void willAutomaticallyFillToNsUnitWithZerosForFirstCol() { + public void willAutomaticallyFillToNsUnitWithZerosForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values('" + date1 + "', '" + date1 + "', 127)"); ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts = '" + date1 + "000000'"); checkCount(1l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void willAutomaticallyFillToNsUnitWithZerosForSecondCol() { + public void willAutomaticallyFillToNsUnitWithZerosForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values('" + date1 + "', '" + date1 + "', 127)"); ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 = '" + date1 + "000000'"); checkCount(1l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void willAutomaticallyDropDigitExceedNsDigitNumberForFirstCol() { + public void willAutomaticallyDropDigitExceedNsDigitNumberForFirstCol() throws SQLException { try (Statement stmt = conn.createStatement()) { stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values('" + date1 + "999999999', '" + date1 + "999999999', 127)"); ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts = '" + date1 + "999999'"); checkCount(1l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void willAutomaticallyDropDigitExceedNsDigitNumberForSecondCol() { + public void willAutomaticallyDropDigitExceedNsDigitNumberForSecondCol() throws SQLException { try (Statement stmt = conn.createStatement()) { stmt.executeUpdate("insert into " + ns_timestamp_db + ".weather(ts, ts2, f1) values('" + date1 + "999999999', '" + date1 + "999999999', 127)"); ResultSet rs = stmt.executeQuery("select count(*) from " + ns_timestamp_db + ".weather where ts2 = '" + date1 + "999999'"); checkCount(1l, rs); - } catch (SQLException e) { - e.printStackTrace(); } } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UnsignedNumberJniTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UnsignedNumberJniTest.java index e4149793aca46ebe5df47aec002828441fef481d..0be6b90e7a9b5e1e7707b88c1c60d2751b7d245b 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UnsignedNumberJniTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UnsignedNumberJniTest.java @@ -15,7 +15,7 @@ public class UnsignedNumberJniTest { private static long ts; @Test - public void testCase001() { + public void testCase001() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select * from us_table"); ResultSetMetaData meta = rs.getMetaData(); @@ -27,13 +27,11 @@ public class UnsignedNumberJniTest { Assert.assertEquals("2147483647", rs.getString(4)); Assert.assertEquals("9223372036854775807", rs.getString(5)); } - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void testCase002() { + public void testCase002() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select * from us_table"); ResultSetMetaData meta = rs.getMetaData(); @@ -46,8 +44,6 @@ public class UnsignedNumberJniTest { Assert.assertEquals(2147483647, rs.getInt(4)); Assert.assertEquals(9223372036854775807L, rs.getLong(5)); } - } catch (SQLException e) { - e.printStackTrace(); } } @@ -140,36 +136,28 @@ public class UnsignedNumberJniTest { } @BeforeClass - public static void beforeClass() { + public static void beforeClass() throws SQLException { Properties properties = new Properties(); properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); ts = System.currentTimeMillis(); - try { - final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"; - conn = DriverManager.getConnection(url, properties); - Statement stmt = conn.createStatement(); - stmt.execute("drop database if exists unsign_jni"); - stmt.execute("create database if not exists unsign_jni"); - stmt.execute("use unsign_jni"); - stmt.execute("create table us_table(ts timestamp, f1 tinyint unsigned, f2 smallint unsigned, f3 int unsigned, f4 bigint unsigned)"); - stmt.executeUpdate("insert into us_table(ts,f1,f2,f3,f4) values(" + ts + ", 127, 32767,2147483647, 9223372036854775807)"); - stmt.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"; + conn = DriverManager.getConnection(url, properties); + Statement stmt = conn.createStatement(); + stmt.execute("drop database if exists unsign_jni"); + stmt.execute("create database if not exists unsign_jni"); + stmt.execute("use unsign_jni"); + stmt.execute("create table us_table(ts timestamp, f1 tinyint unsigned, f2 smallint unsigned, f3 int unsigned, f4 bigint unsigned)"); + stmt.executeUpdate("insert into us_table(ts,f1,f2,f3,f4) values(" + ts + ", 127, 32767,2147483647, 9223372036854775807)"); + stmt.close(); } @AfterClass - public static void afterClass() { - try { - if (conn != null) - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public static void afterClass() throws SQLException { + if (conn != null) + conn.close(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UnsignedNumberRestfulTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UnsignedNumberRestfulTest.java index 3bdf5ae4f2404db5f56e27b740d4e4951e10818d..842dbfeff8478115df93b48cfe29fe376c4cff05 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UnsignedNumberRestfulTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UnsignedNumberRestfulTest.java @@ -16,7 +16,7 @@ public class UnsignedNumberRestfulTest { private static long ts; @Test - public void testCase001() { + public void testCase001() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select * from us_table"); ResultSetMetaData meta = rs.getMetaData(); @@ -28,13 +28,11 @@ public class UnsignedNumberRestfulTest { Assert.assertEquals("2147483647", rs.getString(4)); Assert.assertEquals("9223372036854775807", rs.getString(5)); } - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void testCase002() { + public void testCase002() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select * from us_table"); ResultSetMetaData meta = rs.getMetaData(); @@ -47,8 +45,6 @@ public class UnsignedNumberRestfulTest { Assert.assertEquals(2147483647, rs.getInt(4)); Assert.assertEquals(9223372036854775807L, rs.getLong(5)); } - } catch (SQLException e) { - e.printStackTrace(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UseNowInsertTimestampTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UseNowInsertTimestampTest.java index fbce021d1bff3655eedcf487dbcbf4747d5f9897..2e0448bc248bb2a962466e632443d4e6d918ab9f 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UseNowInsertTimestampTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/UseNowInsertTimestampTest.java @@ -1,6 +1,5 @@ package com.taosdata.jdbc.cases; -import org.junit.Before; import org.junit.Test; import java.sql.*; @@ -12,7 +11,7 @@ public class UseNowInsertTimestampTest { String url = "jdbc:TAOS://127.0.0.1:6030/?user=root&password=taosdata"; @Test - public void millisec() { + public void millisec() throws SQLException { try (Connection conn = DriverManager.getConnection(url)) { Statement stmt = conn.createStatement(); stmt.execute("drop database if exists test"); @@ -30,13 +29,11 @@ public class UseNowInsertTimestampTest { assertEquals(0, nanos % 1000_000); stmt.execute("drop database if exists test"); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void microsec() { + public void microsec() throws SQLException { try (Connection conn = DriverManager.getConnection(url)) { Statement stmt = conn.createStatement(); stmt.execute("drop database if exists test"); @@ -53,13 +50,11 @@ public class UseNowInsertTimestampTest { assertEquals(0, nanos % 1000); stmt.execute("drop database if exists test"); - } catch (SQLException e) { - e.printStackTrace(); } } @Test - public void nanosec() { + public void nanosec() throws SQLException { try (Connection conn = DriverManager.getConnection(url)) { Statement stmt = conn.createStatement(); stmt.execute("drop database if exists test"); @@ -77,8 +72,6 @@ public class UseNowInsertTimestampTest { assertTrue(nanos % 1000 != 0); stmt.execute("drop database if exists test"); - } catch (SQLException e) { - e.printStackTrace(); } } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/BadLocaleSettingTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/BadLocaleSettingTest.java new file mode 100644 index 0000000000000000000000000000000000000000..bbf71349b85c7bdc51fde30f293c7cd724de3699 --- /dev/null +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/BadLocaleSettingTest.java @@ -0,0 +1,51 @@ +package com.taosdata.jdbc.confprops; + + +import com.taosdata.jdbc.TSDBDriver; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.Properties; + +public class BadLocaleSettingTest { + + private static final String host = "127.0.0.1"; + private static final String dbName = "bad_locale_test"; + private static Connection conn; + + @Test + public void canSetLocale() throws SQLException { + Properties properties = new Properties(); + properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); + + String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"; + conn = DriverManager.getConnection(url, properties); + Statement stmt = conn.createStatement(); + stmt.execute("drop database if exists " + dbName); + stmt.execute("create database if not exists " + dbName); + stmt.execute("use " + dbName); + stmt.execute("drop table if exists weather"); + stmt.execute("create table weather(ts timestamp, temperature float, humidity int)"); + stmt.executeUpdate("insert into weather values(1624071506435, 12.3, 4)"); + stmt.close(); + } + + @BeforeClass + public static void beforeClass() { + System.setProperty("sun.jnu.encoding", "ANSI_X3.4-1968"); + System.setProperty("file.encoding", "ANSI_X3.4-1968"); + } + + @AfterClass + public static void afterClass() throws SQLException { + if (conn != null) + conn.close(); + } +} \ No newline at end of file diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/BatchFetchTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/BatchFetchTest.java new file mode 100644 index 0000000000000000000000000000000000000000..e8c799e86c61c6b4a7cb8b3396c6c3e09548ee0e --- /dev/null +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/BatchFetchTest.java @@ -0,0 +1,82 @@ +package com.taosdata.jdbc.confprops; + +import org.junit.*; +import org.junit.runners.MethodSorters; + +import java.sql.*; +import java.util.Random; + +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class BatchFetchTest { + + private static String host = "127.0.0.1"; + private long rowFetchCost, batchFetchCost; + + @Test + public void case01_rowFetch() throws SQLException { + String url = "jdbc:TAOS://" + host + ":6030/test?user=root&password=taosdata"; + try (Connection conn = DriverManager.getConnection(url); + Statement stmt = conn.createStatement()) { + + boolean batchfetch = Boolean.parseBoolean(conn.getClientInfo("batchfetch")); + Assert.assertFalse(batchfetch); + + long start = System.currentTimeMillis(); + ResultSet rs = stmt.executeQuery("select * from weather"); + while (rs.next()) { + } + long end = System.currentTimeMillis(); + rowFetchCost = end - start; + } + } + + @Test + public void case02_batchFetch() throws SQLException { + String url = "jdbc:TAOS://" + host + ":6030/test?user=root&password=taosdata&batchfetch=true"; + try (Connection conn = DriverManager.getConnection(url); + Statement stmt = conn.createStatement()) { + + boolean batchfetch = Boolean.parseBoolean(conn.getClientInfo("batchfetch")); + Assert.assertTrue(batchfetch); + + long start = System.currentTimeMillis(); + ResultSet rs = stmt.executeQuery("select * from weather"); + while (rs.next()) { + } + long end = System.currentTimeMillis(); + batchFetchCost = end - start; + } + } + + @Test + public void case03_batchFetchFastThanRowFetch() { + Assert.assertTrue(rowFetchCost - batchFetchCost >= 0); + } + + @BeforeClass + public static void beforeClass() throws SQLException { + String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"; + try (Connection conn = DriverManager.getConnection(url); + Statement stmt = conn.createStatement()) { + stmt.execute("drop database if exists test"); + stmt.execute("create database if not exists test"); + stmt.execute("use test"); + stmt.execute("create table weather(ts timestamp, f int) tags(t int)"); + for (int i = 0; i < 1000; i++) { + stmt.execute(generateSql(100, 100)); + } + } + } + + private static String generateSql(int tableSize, int valueSize) { + Random random = new Random(System.currentTimeMillis()); + StringBuilder builder = new StringBuilder("insert into "); + for (int i = 0; i < tableSize; i++) { + builder.append("t" + i).append(" using weather tags(").append(random.nextInt(100)).append(") values"); + for (int j = 0; j < valueSize; j++) { + builder.append(" (now + ").append(i).append("s, ").append(random.nextInt(100)).append(")"); + } + } + return builder.toString(); + } +} diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/CharsetTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/CharsetTest.java new file mode 100644 index 0000000000000000000000000000000000000000..e28faeb280a9f9f9ae931e7b610910fb912278b3 --- /dev/null +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/CharsetTest.java @@ -0,0 +1,40 @@ +package com.taosdata.jdbc.confprops; + +import com.taosdata.jdbc.TSDBDriver; +import org.junit.Assert; +import org.junit.Test; + +import java.sql.*; +import java.util.Properties; + +public class CharsetTest { + private static final String host = "127.0.0.1"; + + @Test + public void test() throws SQLException { + // given + String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"; + Properties props = new Properties(); + props.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); + + try (Connection conn = DriverManager.getConnection(url, props); + Statement stmt = conn.createStatement()) { + + // when + stmt.execute("drop database if exists test"); + stmt.execute("create database if not exists test"); + stmt.execute("use test"); + stmt.execute("create table weather(ts timestamp, temperature nchar(10))"); + stmt.execute("insert into weather values(now, '北京')"); + + // then + ResultSet rs = stmt.executeQuery("select * from weather"); + while (rs.next()) { + Object value = rs.getObject("temperature"); + Assert.assertTrue(value instanceof String); + Assert.assertEquals("北京", value.toString()); + } + } + } + +} diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/HttpKeepAliveTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/HttpKeepAliveTest.java similarity index 97% rename from src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/HttpKeepAliveTest.java rename to src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/HttpKeepAliveTest.java index 30fc2fa76597c30b905db5c9d49815189d71aaa3..7f7979eb01154a85b25bbea7b9d3f042b4f1c104 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/HttpKeepAliveTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/HttpKeepAliveTest.java @@ -1,4 +1,4 @@ -package com.taosdata.jdbc.rs; +package com.taosdata.jdbc.confprops; import org.junit.Assert; import org.junit.Test; diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/TaosInfoMonitorTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/TaosInfoMonitorTest.java new file mode 100644 index 0000000000000000000000000000000000000000..4a919db6f403a9f6ad54e261fdb28f93dddf4958 --- /dev/null +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/TaosInfoMonitorTest.java @@ -0,0 +1,54 @@ +package com.taosdata.jdbc.confprops; + +import org.junit.Assert; +import org.junit.Test; + +import java.sql.*; +import java.util.List; +import java.util.Random; +import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +public class TaosInfoMonitorTest { + + private static final String host = "127.0.0.1"; + private Random random = new Random(System.currentTimeMillis()); + + @Test + public void testCreateTooManyConnection() throws InterruptedException { + + List threads = IntStream.range(1, 11).mapToObj(i -> new Thread(() -> { + final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata"; + + int connSize = random.nextInt(10); + for (int j = 0; j < connSize; j++) { + + try { + Connection conn = DriverManager.getConnection(url); + TimeUnit.MILLISECONDS.sleep(random.nextInt(3000)); + + int stmtSize = random.nextInt(100); + for (int k = 0; k < stmtSize; k++) { + Statement stmt = conn.createStatement(); + TimeUnit.MILLISECONDS.sleep(random.nextInt(3000)); + + ResultSet rs = stmt.executeQuery("show databases"); + while (rs.next()) { + } + rs.close(); + stmt.close(); + } + } catch (SQLException | InterruptedException throwables) { + Assert.fail(); + } + } + }, "thread-" + i)).collect(Collectors.toList()); + + threads.forEach(Thread::start); + + for (Thread thread : threads) { + thread.join(); + } + } +} diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TimeZoneTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/TimeZoneTest.java similarity index 98% rename from src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TimeZoneTest.java rename to src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/TimeZoneTest.java index 94a175ad5c7fd50fa35d6b45ea59ab26ffc02ce1..6569aa5f085f5d389144a9e8ddc0787786f9fff3 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/TimeZoneTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/TimeZoneTest.java @@ -1,4 +1,4 @@ -package com.taosdata.jdbc.cases; +package com.taosdata.jdbc.confprops; import com.taosdata.jdbc.TSDBDriver; import org.junit.Test; diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/TimestampFormatTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/TimestampFormatTest.java new file mode 100644 index 0000000000000000000000000000000000000000..7e3701c153fa3f45852dd1a5860cf30910dc906d --- /dev/null +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/confprops/TimestampFormatTest.java @@ -0,0 +1,167 @@ +package com.taosdata.jdbc.confprops; + +import com.taosdata.jdbc.TSDBDriver; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.sql.*; +import java.time.Instant; +import java.util.Properties; + +public class TimestampFormatTest { + private static final String host = "127.0.0.1"; + private long ts = Instant.now().toEpochMilli(); + + @Test + public void string() throws SQLException { + // given + String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"; + + // when + try (Connection conn = DriverManager.getConnection(url); + Statement stmt = conn.createStatement()) { + // then + String actual = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT); + Assert.assertEquals("STRING", actual); + + ResultSet rs = stmt.executeQuery("select * from test.weather"); + while (rs.next()) { + String value = rs.getString("ts"); + String expect = new Timestamp(ts).toString(); + Assert.assertEquals(expect, value); + } + } + } + + @Test + public void stringInProperties() throws SQLException { + // given + String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"; + + // when + String timestampFormat = "STRING"; + Properties props = new Properties(); + props.setProperty(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT, timestampFormat); + try (Connection conn = DriverManager.getConnection(url, props); + Statement stmt = conn.createStatement()) { + + // then + String actual = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT); + Assert.assertEquals(timestampFormat, actual); + + ResultSet rs = stmt.executeQuery("select * from test.weather"); + while (rs.next()) { + String value = rs.getString("ts"); + String expect = new Timestamp(ts).toString(); + Assert.assertEquals(expect, value); + } + } + } + + @Test + public void timestampInUrl() throws SQLException { + // given + String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata×tampFormat="; + String timestampFormat = "TIMESTAMP"; + + // when + try (Connection conn = DriverManager.getConnection(url + timestampFormat); + Statement stmt = conn.createStatement()) { + // then + String actual = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT); + Assert.assertEquals(timestampFormat, actual); + + ResultSet rs = stmt.executeQuery("select * from test.weather"); + while (rs.next()) { + Object value = rs.getObject("ts"); + String expect = new Timestamp(ts).toString(); + Assert.assertEquals(expect, value.toString()); + } + } + } + + @Test + public void timestampInProperties() throws SQLException { + // given + String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"; + String timestampFormat = "TIMESTAMP"; + + // when + Properties props = new Properties(); + props.setProperty(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT, timestampFormat); + try (Connection conn = DriverManager.getConnection(url, props); + Statement stmt = conn.createStatement()) { + // then + String actual = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT); + Assert.assertEquals(timestampFormat, actual); + + ResultSet rs = stmt.executeQuery("select * from test.weather"); + while (rs.next()) { + Object value = rs.getObject("ts"); + String expect = new Timestamp(ts).toString(); + Assert.assertEquals(expect, value.toString()); + } + } + } + + @Test + public void utcInUrl() throws SQLException { + // given + String timestampFormat = "UTC"; + String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata×tampFormat=" + timestampFormat; + + // when & then + try (Connection conn = DriverManager.getConnection(url); + Statement stmt = conn.createStatement()) { + String actual = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT); + Assert.assertEquals(timestampFormat, actual); + ResultSet rs = stmt.executeQuery("select * from test.weather"); + while (rs.next()) { + Object value = rs.getObject("ts"); + Assert.assertTrue(value instanceof Timestamp); + String expect = new Timestamp(ts).toString(); + Assert.assertEquals(expect, value.toString()); + } + } + } + + @Test + public void utcInProperties() throws SQLException { + // given + String timestampFormat = "UTC"; + String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"; + + // when + Properties props = new Properties(); + props.setProperty(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT, timestampFormat); + try (Connection conn = DriverManager.getConnection(url, props); + Statement stmt = conn.createStatement()) { + + // then + String actual = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT); + Assert.assertEquals(timestampFormat, actual); + ResultSet rs = stmt.executeQuery("select * from test.weather"); + while (rs.next()) { + Object value = rs.getObject("ts"); + Assert.assertTrue(value instanceof Timestamp); + String expect = new Timestamp(ts).toString(); + Assert.assertEquals(expect, value.toString()); + } + } + } + + @Before + public void before() throws SQLException { + String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata"; + try (Connection conn = DriverManager.getConnection(url); + Statement stmt = conn.createStatement()) { + stmt.execute("drop database if exists test"); + stmt.execute("create database if not exists test"); + stmt.execute("use test"); + stmt.execute("create table weather(ts timestamp, temperature nchar(10))"); + stmt.execute("insert into weather values(" + ts + ", '北京')"); + } + } + +} diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java index 1c5c03aacb5e7ed5683c75414975224a67d49e21..b08f8ff227dc16e1b413391e58a9de8fd0182c42 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java @@ -23,14 +23,12 @@ public class RestfulConnectionTest { } @Test - public void createStatement() { + public void createStatement() throws SQLException { try (Statement stmt = conn.createStatement()) { ResultSet rs = stmt.executeQuery("select server_status()"); rs.next(); int status = rs.getInt("server_status()"); assertEquals(1, status); - } catch (SQLException e) { - e.printStackTrace(); } } @@ -359,13 +357,9 @@ public class RestfulConnectionTest { } @Test - public void unwrap() { - try { - RestfulConnection restfulConnection = conn.unwrap(RestfulConnection.class); - Assert.assertNotNull(restfulConnection); - } catch (SQLException e) { - e.printStackTrace(); - } + public void unwrap() throws SQLException { + RestfulConnection restfulConnection = conn.unwrap(RestfulConnection.class); + Assert.assertNotNull(restfulConnection); } @Test @@ -374,32 +368,22 @@ public class RestfulConnectionTest { } @BeforeClass - public static void beforeClass() { - try { - Class.forName("com.taosdata.jdbc.rs.RestfulDriver"); - Properties properties = new Properties(); - properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); - conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/log?user=root&password=taosdata", properties); - // create test database for test cases - try (Statement stmt = conn.createStatement()) { - stmt.execute("create database if not exists test"); - } - - } catch (ClassNotFoundException | SQLException e) { - e.printStackTrace(); + public static void beforeClass() throws SQLException { + Properties properties = new Properties(); + properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); + conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/log?user=root&password=taosdata", properties); + // create test database for test cases + try (Statement stmt = conn.createStatement()) { + stmt.execute("create database if not exists test"); } } @AfterClass - public static void afterClass() { - try { - if (conn != null) - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public static void afterClass() throws SQLException { + if (conn != null) + conn.close(); } } \ No newline at end of file diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaDataTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaDataTest.java index 85007db0e555634b25dee4f10446b1041bf19b21..50b0b97d90da255a8995e921d7e3ff22685e3bdb 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaDataTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaDataTest.java @@ -1085,30 +1085,26 @@ public class RestfulDatabaseMetaDataTest { } @BeforeClass - public static void beforeClass() { - try { - Class.forName("com.taosdata.jdbc.rs.RestfulDriver"); - Properties properties = new Properties(); - properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); - connection = DriverManager.getConnection(url, properties); - metaData = connection.getMetaData().unwrap(RestfulDatabaseMetaData.class); - } catch (ClassNotFoundException e) { - e.printStackTrace(); - } catch (SQLException e) { - e.printStackTrace(); - } + public static void beforeClass() throws SQLException { + Properties properties = new Properties(); + properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); + connection = DriverManager.getConnection(url, properties); + Statement stmt = connection.createStatement(); + stmt.execute("drop database if exists log"); + stmt.execute("create database if not exists log precision 'us'"); + stmt.execute("use log"); + stmt.execute("create table `dn` (ts TIMESTAMP,cpu_taosd FLOAT,cpu_system FLOAT,cpu_cores INT,mem_taosd FLOAT,mem_system FLOAT,mem_total INT,disk_used FLOAT,disk_total INT,band_speed FLOAT,io_read FLOAT,io_write FLOAT,req_http INT,req_select INT,req_insert INT) TAGS (dnodeid INT,fqdn BINARY(128))"); + stmt.execute("insert into dn1 using dn tags(1,'a') (ts) values(now)"); + + metaData = connection.getMetaData().unwrap(RestfulDatabaseMetaData.class); } @AfterClass - public static void afterClass() { - try { - if (connection != null) - connection.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public static void afterClass() throws SQLException { + if (connection != null) + connection.close(); } } \ No newline at end of file diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java index b07dae8003d6e2fea073c0d240f59fb6db0c593f..858f7b32f0d8a72be5b6cfa68aa120b08909df6c 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java @@ -14,7 +14,7 @@ public class RestfulJDBCTest { private Connection connection; @Test - public void testCase001() { + public void testCase001() throws SQLException { // given String sql = "drop database if exists restful_test"; // when @@ -38,7 +38,7 @@ public class RestfulJDBCTest { } @Test - public void testCase002() { + public void testCase002() throws SQLException { // given String sql = "create table weather(ts timestamp, temperature float, humidity int) tags(location nchar(64), groupId int)"; // when @@ -48,7 +48,7 @@ public class RestfulJDBCTest { } @Test - public void testCase004() { + public void testCase004() throws SQLException { for (int i = 1; i <= 100; i++) { // given String sql = "create table t" + i + " using weather tags('beijing', '" + i + "')"; @@ -60,7 +60,7 @@ public class RestfulJDBCTest { } @Test - public void testCase005() { + public void testCase005() throws SQLException { int rows = 0; for (int i = 0; i < 10; i++) { for (int j = 1; j <= 100; j++) { @@ -99,7 +99,7 @@ public class RestfulJDBCTest { } @Test - public void testCase007() { + public void testCase007() throws SQLException { // given String sql = "drop database restful_test"; @@ -110,51 +110,34 @@ public class RestfulJDBCTest { Assert.assertFalse(execute); } - private int executeUpdate(Connection connection, String sql) { + private int executeUpdate(Connection connection, String sql) throws SQLException { try (Statement stmt = connection.createStatement()) { return stmt.executeUpdate(sql); - } catch (SQLException e) { - e.printStackTrace(); } - return 0; } - private boolean execute(Connection connection, String sql) { + private boolean execute(Connection connection, String sql) throws SQLException { try (Statement stmt = connection.createStatement()) { return stmt.execute(sql); - } catch (SQLException e) { - e.printStackTrace(); } - return false; } - private ResultSet executeQuery(Connection connection, String sql) { + private ResultSet executeQuery(Connection connection, String sql) throws SQLException { try (Statement statement = connection.createStatement()) { return statement.executeQuery(sql); - } catch (SQLException e) { - e.printStackTrace(); } - return null; } @Before - public void before() { - try { - connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=root&password=taosdata"); - } catch (SQLException e) { - e.printStackTrace(); - } + public void before() throws SQLException { + connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=root&password=taosdata&httpKeepAlive=false"); } @After - public void after() { - try { - if (connection != null) - connection.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public void after() throws SQLException { + if (connection != null) + connection.close(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulStatementTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulStatementTest.java index a7b3ceb9d3bb243a2a053d5289afe39d3c870d79..83ab2c7263cb61388d6cbdfd31b241d547520f53 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulStatementTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulStatementTest.java @@ -17,46 +17,32 @@ public class RestfulStatementTest { private static Statement stmt; @Test - public void executeQuery() { - try { - ResultSet rs = stmt.executeQuery("show databases"); - Assert.assertNotNull(rs); - ResultSetMetaData meta = rs.getMetaData(); - int columnCount = meta.getColumnCount(); - Assert.assertTrue(columnCount > 1); - while (rs.next()) { - Assert.assertEquals("name", meta.getColumnLabel(1)); - Assert.assertNotNull(rs.getString("name")); - } - rs.close(); - } catch (SQLException e) { - e.printStackTrace(); + public void executeQuery() throws SQLException { + ResultSet rs = stmt.executeQuery("show databases"); + Assert.assertNotNull(rs); + ResultSetMetaData meta = rs.getMetaData(); + int columnCount = meta.getColumnCount(); + Assert.assertTrue(columnCount > 1); + while (rs.next()) { + Assert.assertEquals("name", meta.getColumnLabel(1)); + Assert.assertNotNull(rs.getString("name")); } + rs.close(); } @Test - public void executeUpdate() { + public void executeUpdate() throws SQLException { final String dbName = ("test_" + UUID.randomUUID()).replace("-", "_").substring(0, 32); - try { - int affectRows = stmt.executeUpdate("create database " + dbName); - Assert.assertEquals(0, affectRows); - affectRows = stmt.executeUpdate("create table " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); - Assert.assertEquals(0, affectRows); - affectRows = stmt.executeUpdate("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); - Assert.assertEquals(1, affectRows); - affectRows = stmt.executeUpdate("drop database " + dbName); - Assert.assertEquals(0, affectRows); - } catch (SQLException e) { - e.printStackTrace(); - } + int affectRows = stmt.executeUpdate("create database " + dbName); + Assert.assertEquals(0, affectRows); + affectRows = stmt.executeUpdate("create table " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); + Assert.assertEquals(0, affectRows); + affectRows = stmt.executeUpdate("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); + Assert.assertEquals(1, affectRows); + affectRows = stmt.executeUpdate("drop database " + dbName); + Assert.assertEquals(0, affectRows); } - @Test - public void close() { - // test in AfterClass method - } - - @Test public void getMaxFieldSize() throws SQLException { Assert.assertEquals(16 * 1024, stmt.getMaxFieldSize()); @@ -64,7 +50,6 @@ public class RestfulStatementTest { @Test(expected = SQLException.class) public void setMaxFieldSize() throws SQLException { - stmt.setMaxFieldSize(0); stmt.setMaxFieldSize(-1); } @@ -118,83 +103,70 @@ public class RestfulStatementTest { } @Test - public void execute() { + public void execute() throws SQLException { final String dbName = ("test_" + UUID.randomUUID()).replace("-", "_").substring(0, 32); - try { - boolean isSelect = stmt.execute("create database if not exists " + dbName); - Assert.assertEquals(false, isSelect); - int affectedRows = stmt.getUpdateCount(); - Assert.assertEquals(0, affectedRows); - - isSelect = stmt.execute("create table if not exists " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); - Assert.assertEquals(false, isSelect); - affectedRows = stmt.getUpdateCount(); - Assert.assertEquals(0, affectedRows); - - isSelect = stmt.execute("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); - Assert.assertEquals(false, isSelect); - affectedRows = stmt.getUpdateCount(); - Assert.assertEquals(1, affectedRows); - - isSelect = stmt.execute("select * from " + dbName + ".weather"); - Assert.assertEquals(true, isSelect); - - isSelect = stmt.execute("drop database " + dbName); - Assert.assertEquals(false, isSelect); - affectedRows = stmt.getUpdateCount(); - Assert.assertEquals(0, affectedRows); - } catch (SQLException e) { - e.printStackTrace(); - } + boolean isSelect = stmt.execute("create database if not exists " + dbName); + Assert.assertEquals(false, isSelect); + int affectedRows = stmt.getUpdateCount(); + Assert.assertEquals(0, affectedRows); + + isSelect = stmt.execute("create table if not exists " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); + Assert.assertEquals(false, isSelect); + affectedRows = stmt.getUpdateCount(); + Assert.assertEquals(0, affectedRows); + + isSelect = stmt.execute("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); + Assert.assertEquals(false, isSelect); + affectedRows = stmt.getUpdateCount(); + Assert.assertEquals(1, affectedRows); + + isSelect = stmt.execute("select * from " + dbName + ".weather"); + Assert.assertEquals(true, isSelect); + + isSelect = stmt.execute("drop database " + dbName); + Assert.assertEquals(false, isSelect); + affectedRows = stmt.getUpdateCount(); + Assert.assertEquals(0, affectedRows); } @Test - public void getResultSet() { + public void getResultSet() throws SQLException { final String dbName = ("test_" + UUID.randomUUID()).replace("-", "_").substring(0, 32); - try { - boolean isSelect = stmt.execute("create database if not exists " + dbName); - Assert.assertEquals(false, isSelect); - int affectedRows = stmt.getUpdateCount(); - Assert.assertEquals(0, affectedRows); - - isSelect = stmt.execute("create table if not exists " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); - Assert.assertEquals(false, isSelect); - affectedRows = stmt.getUpdateCount(); - Assert.assertEquals(0, affectedRows); - - isSelect = stmt.execute("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); - Assert.assertEquals(false, isSelect); - affectedRows = stmt.getUpdateCount(); - Assert.assertEquals(1, affectedRows); - - isSelect = stmt.execute("select * from " + dbName + ".weather"); - Assert.assertEquals(true, isSelect); - ResultSet rs = stmt.getResultSet(); - Assert.assertNotNull(rs); - ResultSetMetaData meta = rs.getMetaData(); - Assert.assertEquals(3, meta.getColumnCount()); - int count = 0; - while (rs.next()) { - Assert.assertEquals("ts", meta.getColumnLabel(1)); - Assert.assertNotNull(rs.getTimestamp(1)); - Assert.assertEquals("temperature", meta.getColumnLabel(2)); - Assert.assertEquals(22.33, rs.getFloat(2), 0.001f); - count++; - } - Assert.assertEquals(1, count); - - isSelect = stmt.execute("drop database " + dbName); - Assert.assertEquals(false, isSelect); - affectedRows = stmt.getUpdateCount(); - Assert.assertEquals(0, affectedRows); - } catch (SQLException e) { - e.printStackTrace(); + boolean isSelect = stmt.execute("create database if not exists " + dbName); + Assert.assertEquals(false, isSelect); + int affectedRows = stmt.getUpdateCount(); + Assert.assertEquals(0, affectedRows); + + isSelect = stmt.execute("create table if not exists " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); + Assert.assertEquals(false, isSelect); + affectedRows = stmt.getUpdateCount(); + Assert.assertEquals(0, affectedRows); + + isSelect = stmt.execute("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); + Assert.assertEquals(false, isSelect); + affectedRows = stmt.getUpdateCount(); + Assert.assertEquals(1, affectedRows); + + isSelect = stmt.execute("select * from " + dbName + ".weather"); + Assert.assertEquals(true, isSelect); + ResultSet rs = stmt.getResultSet(); + Assert.assertNotNull(rs); + ResultSetMetaData meta = rs.getMetaData(); + Assert.assertEquals(3, meta.getColumnCount()); + int count = 0; + while (rs.next()) { + Assert.assertEquals("ts", meta.getColumnLabel(1)); + Assert.assertNotNull(rs.getTimestamp(1)); + Assert.assertEquals("temperature", meta.getColumnLabel(2)); + Assert.assertEquals(22.33, rs.getFloat(2), 0.001f); + count++; } - } + Assert.assertEquals(1, count); - @Test - public void getUpdateCount() { - // already test in execute method + isSelect = stmt.execute("drop database " + dbName); + Assert.assertEquals(false, isSelect); + affectedRows = stmt.getUpdateCount(); + Assert.assertEquals(0, affectedRows); } @Test @@ -239,64 +211,48 @@ public class RestfulStatementTest { } @Test - public void addBatch() { + public void addBatch() throws SQLException { final String dbName = ("test_" + UUID.randomUUID()).replace("-", "_").substring(0, 32); - try { - stmt.addBatch("create database " + dbName); - stmt.addBatch("create table " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); - stmt.addBatch("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); - stmt.addBatch("select * from " + dbName + ".weather"); - stmt.addBatch("drop database " + dbName); - } catch (SQLException e) { - e.printStackTrace(); - } + stmt.addBatch("create database " + dbName); + stmt.addBatch("create table " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); + stmt.addBatch("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); + stmt.addBatch("select * from " + dbName + ".weather"); + stmt.addBatch("drop database " + dbName); } @Test - public void clearBatch() { + public void clearBatch() throws SQLException { final String dbName = ("test_" + UUID.randomUUID()).replace("-", "_").substring(0, 32); - try { - stmt.clearBatch(); - stmt.addBatch("create database " + dbName); - stmt.addBatch("create table " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); - stmt.addBatch("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); - stmt.addBatch("select * from " + dbName + ".weather"); - stmt.addBatch("drop database " + dbName); - stmt.clearBatch(); - } catch (SQLException e) { - e.printStackTrace(); - } + stmt.clearBatch(); + stmt.addBatch("create database " + dbName); + stmt.addBatch("create table " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); + stmt.addBatch("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); + stmt.addBatch("select * from " + dbName + ".weather"); + stmt.addBatch("drop database " + dbName); + stmt.clearBatch(); } @Test - public void executeBatch() { + public void executeBatch() throws SQLException { final String dbName = ("test_" + UUID.randomUUID()).replace("-", "_").substring(0, 32); - try { - stmt.addBatch("create database " + dbName); - stmt.addBatch("create table " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); - stmt.addBatch("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); - stmt.addBatch("select * from " + dbName + ".weather"); - stmt.addBatch("drop database " + dbName); - int[] results = stmt.executeBatch(); - Assert.assertEquals(0, results[0]); - Assert.assertEquals(0, results[1]); - Assert.assertEquals(1, results[2]); - Assert.assertEquals(Statement.SUCCESS_NO_INFO, results[3]); - Assert.assertEquals(0, results[4]); - } catch (SQLException e) { - e.printStackTrace(); - } + stmt.addBatch("create database " + dbName); + stmt.addBatch("create table " + dbName + ".weather(ts timestamp, temperature float) tags(loc nchar(64))"); + stmt.addBatch("insert into " + dbName + ".t1 using " + dbName + ".weather tags('北京') values(now, 22.33)"); + stmt.addBatch("select * from " + dbName + ".weather"); + stmt.addBatch("drop database " + dbName); + int[] results = stmt.executeBatch(); + Assert.assertEquals(0, results[0]); + Assert.assertEquals(0, results[1]); + Assert.assertEquals(1, results[2]); + Assert.assertEquals(Statement.SUCCESS_NO_INFO, results[3]); + Assert.assertEquals(0, results[4]); } @Test - public void getConnection() { - try { - Connection connection = stmt.getConnection(); - Assert.assertNotNull(connection); - Assert.assertTrue(this.conn == connection); - } catch (SQLException e) { - e.printStackTrace(); - } + public void getConnection() throws SQLException { + Connection connection = stmt.getConnection(); + Assert.assertNotNull(connection); + Assert.assertTrue(this.conn == connection); } @Test(expected = SQLFeatureNotSupportedException.class) @@ -346,12 +302,8 @@ public class RestfulStatementTest { } @Test - public void isClosed() { - try { - Assert.assertEquals(false, stmt.isClosed()); - } catch (SQLException e) { - e.printStackTrace(); - } + public void isClosed() throws SQLException { + Assert.assertEquals(false, stmt.isClosed()); } @Test @@ -387,29 +339,21 @@ public class RestfulStatementTest { } @BeforeClass - public static void beforeClass() { - try { - Properties properties = new Properties(); - properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); - properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); - conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata", properties); - stmt = conn.createStatement(); - } catch (SQLException e) { - e.printStackTrace(); - } + public static void beforeClass() throws SQLException { + Properties properties = new Properties(); + properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8"); + properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8"); + conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata", properties); + stmt = conn.createStatement(); } @AfterClass - public static void afterClass() { - try { - if (stmt != null) - stmt.close(); - if (conn != null) - conn.close(); - } catch (SQLException e) { - e.printStackTrace(); - } + public static void afterClass() throws SQLException { + if (stmt != null) + stmt.close(); + if (conn != null) + conn.close(); } } diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/SQLTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/SQLTest.java index 98482ade80656f2e48bc6927953439cfe4b010c1..a28bdbe2e5f6e0d545241a80071d85b0964a4102 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/SQLTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/SQLTest.java @@ -543,15 +543,6 @@ public class SQLTest { Assert.assertNotNull(rs); } - @Test - public void testCase053() { - String sql = "select avg(cpu_taosd), avg(cpu_system), max(cpu_cores), avg(mem_taosd), avg(mem_system), max(mem_total), avg(disk_used), max(disk_total), avg(band_speed), avg(io_read), avg(io_write), sum(req_http), sum(req_select), sum(req_insert) from log.dn1 where ts> now - 60m and ts<= now interval(1m) fill(value, 0)"; - // when - ResultSet rs = executeQuery(connection, sql); - // then - Assert.assertNotNull(rs); - } - private boolean execute(Connection connection, String sql) { try (Statement statement = connection.createStatement()) { return statement.execute(sql); diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/HttpClientPoolUtilTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/HttpClientPoolUtilTest.java index 7ba1607fdd32a594bca22528dee48d902736c703..128a62e5d964bc2276328312eb9998895923547f 100644 --- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/HttpClientPoolUtilTest.java +++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/HttpClientPoolUtilTest.java @@ -17,7 +17,6 @@ public class HttpClientPoolUtilTest { String user = "root"; String password = "taosdata"; String host = "127.0.0.1"; -// String host = "master"; @Test public void useLog() { diff --git a/src/tsdb/src/tsdbFile.c b/src/tsdb/src/tsdbFile.c index 67696e48a572c29d0d6a33d4359236162f50cd28..77d172893e5ee176e636c8f0e5f3ed15ed86be2e 100644 --- a/src/tsdb/src/tsdbFile.c +++ b/src/tsdb/src/tsdbFile.c @@ -79,7 +79,7 @@ void *tsdbDecodeSMFileEx(void *buf, SMFile *pMFile) { char *aname; buf = tsdbDecodeMFInfo(buf, &(pMFile->info)); buf = taosDecodeString(buf, &aname); - strncpy(TSDB_FILE_FULL_NAME(pMFile), aname, TSDB_FILENAME_LEN); + tstrncpy(TSDB_FILE_FULL_NAME(pMFile), aname, TSDB_FILENAME_LEN); TSDB_FILE_SET_CLOSED(pMFile); tfree(aname); @@ -345,7 +345,7 @@ static void *tsdbDecodeSDFileEx(void *buf, SDFile *pDFile) { // The sync module would send DFileSet with latest verion. buf = tsdbDecodeDFInfo(buf, &(pDFile->info), TSDB_LATEST_SFS_VER); buf = taosDecodeString(buf, &aname); - strncpy(TSDB_FILE_FULL_NAME(pDFile), aname, TSDB_FILENAME_LEN); + tstrncpy(TSDB_FILE_FULL_NAME(pDFile), aname, TSDB_FILENAME_LEN); TSDB_FILE_SET_CLOSED(pDFile); tfree(aname); @@ -716,4 +716,4 @@ static void tsdbGetFilename(int vid, int fid, uint32_t ver, TSDB_FILE_T ftype, c snprintf(fname, TSDB_FILENAME_LEN, "vnode/vnode%d/tsdb/%s-ver%" PRIu32, vid, TSDB_FNAME_SUFFIX[ftype], ver); } } -} \ No newline at end of file +} diff --git a/tests/examples/JDBC/JDBCDemo/pom.xml b/tests/examples/JDBC/JDBCDemo/pom.xml index 8cf0356721f8ffd568e87fa4a77c86eb0f90a62b..5f0e35fa8f739453651ce3a7af092437531c00c6 100644 --- a/tests/examples/JDBC/JDBCDemo/pom.xml +++ b/tests/examples/JDBC/JDBCDemo/pom.xml @@ -17,7 +17,7 @@ com.taosdata.jdbc taos-jdbcdriver - 2.0.34 + 2.0.35 diff --git a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/BatchInsert.java b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/BatchInsert.java new file mode 100644 index 0000000000000000000000000000000000000000..a2566bd07e96ddd245c9b548a3192d0e4f343147 --- /dev/null +++ b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/BatchInsert.java @@ -0,0 +1,87 @@ +package com.taosdata.example; + +import java.sql.*; +import java.util.*; + +public class BatchInsert { + + private static final String host = "127.0.0.1"; + private static final String user = "root"; + private static final String password = "taosdata"; + + + private static final String dbname = "test"; + private static final String stbname = "stb"; + private static final int tables= 100; + private static final int rows = 500; + private static final long ts = 1604877767000l; + + private Connection conn; + + private void init() { + // final String url = "jdbc:TAOS://" + host + ":6030/?user=" + user + "&password=" + password; + final String url = "jdbc:TAOS-RS://" + host + ":6041/?user=" + user + "&password=" + password; + + // get connection + try { + Properties properties = new Properties(); + properties.setProperty("charset", "UTF-8"); + properties.setProperty("locale", "en_US.UTF-8"); + properties.setProperty("timezone", "UTC-8"); + System.out.println("get connection starting..."); + conn = DriverManager.getConnection(url, properties); + if (conn != null){ + System.out.println("[ OK ] Connection established."); + } + + Statement stmt = conn.createStatement(); + + stmt.execute("drop database if exists " + dbname); + stmt.execute("create database if not exists " + dbname); + stmt.execute("use " + dbname); + stmt.execute("create table " + dbname + "." + stbname + "(ts timestamp, col int) tags(id int)"); + + } catch (SQLException e) { + e.printStackTrace(); + } + } + + private String generateSql() { + StringBuilder sb = new StringBuilder(); + Random rand = new Random(); + sb.append("insert into "); + for (int i = 0; i < tables; i++) { + sb.append(dbname + ".tb" + i + " using " + dbname + "." + stbname + " tags(" + i + ") values"); + for (int j = 0; j < rows; j++) { + sb.append("("); + sb.append(ts + j); + sb.append(","); + sb.append(rand.nextInt(1000)); + sb.append(") "); + } + } + return sb.toString(); + } + + private void executeQuery(String sql) { + try (Statement stmt = conn.createStatement()) { + long start = System.currentTimeMillis(); + stmt.execute(sql); + long end = System.currentTimeMillis(); + + System.out.println("insert " + tables * rows + " records, cost " + (end - start)+ "ms"); + } catch (SQLException ex) { + ex.printStackTrace(); + } + } + + public static void main(String[] args) { + BatchInsert bi = new BatchInsert(); + + String sql = bi.generateSql(); + bi.init(); + bi.executeQuery(sql); + } + + +} diff --git a/tests/examples/nodejs/node-example-raw.js b/tests/examples/nodejs/node-example-raw.js index 058a50c4c3f0f7d44da4bdcc4fc54b81d7e1bc38..80d5cd1bdea23370f1ac03756541eaa96937a6d6 100644 --- a/tests/examples/nodejs/node-example-raw.js +++ b/tests/examples/nodejs/node-example-raw.js @@ -23,43 +23,31 @@ var conn = taos.connect({host:"127.0.0.1", user:"root", password:"taosdata", con // Initialize our TDengineCursor, which we use to interact with TDengine var c1 = conn.cursor(); +//execute the sql +function execute(sql){ + try { + c1.execute(sql); + } + catch(err) { + conn.close(); + throw err; + } +} + // c1.execute(query) will execute the query // Let's create a database named db -try { - c1.execute('create database if not exists db;'); -} -catch(err) { - conn.close(); - throw err; -} +execute('create database if not exists db;') // Now we will use database db -try { - c1.execute('use db;'); -} -catch (err) { - conn.close(); - throw err; -} +execute('use db;') + // Let's create a table called weather // which stores some weather data like humidity, AQI (air quality index), temperature, and some notes as text -try { - c1.execute('create table if not exists weather (ts timestamp, humidity smallint, aqi int, temperature float, notes binary(30));'); -} -catch (err) { - conn.close(); - throw err; -} +execute('create table if not exists weather (ts timestamp, humidity smallint, aqi int, temperature float, notes binary(30));'); // Let's get the description of the table weather -try { - c1.execute('describe db.weather'); -} -catch (err) { - conn.close(); - throw err; -} +execute('describe db.weather'); // To get results, we run the function c1.fetchall() // It only returns the query results as an array of result rows, but also stores the latest results in c1.data