Skip to content

T
TDengine

taosdata / TDengine
大约 2 年 前同步成功

通知 1192
Star 22018
Fork 4786
T
TDengine
提交 24b5da8b 编写于 作者: H Hongze Cheng
浏览文件
操作

Merge branch 'develop' into feature/TD-1568

上级 88bf50f1 5f08a0ff
展开全部 显示空白变更内容
内联 并排
Showing with 2669 addition and 837 deletion
cmake/install.inc
浏览文件 @ 24b5da8b
......@@ -32,7 +32,7 @@ ELSEIF (TD_WINDOWS)
#INSTALL(TARGETS taos RUNTIME DESTINATION driver)
#INSTALL(TARGETS shell RUNTIME DESTINATION .)
IF (TD_MVN_INSTALLED)
INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.19-dist.jar DESTINATION connector/jdbc)
INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.20-dist.jar DESTINATION connector/jdbc)
ENDIF ()
ELSEIF (TD_DARWIN)
SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")
......
documentation20/cn/03.architecture/docs.md
浏览文件 @ 24b5da8b
......@@ -182,7 +182,7 @@ TDengine 分布式架构的逻辑结构图如下：
**集群对外连接:** TDengine集群可以容纳单个、多个甚至几千个数据节点。应用只需要向集群中任何一个数据节点发起连接即可，连接需要提供的网络参数是一数据节点的End Point(FQDN加配置的端口号）。通过命令行CLI启动应用taos时，可以通过选项-h来指定数据节点的FQDN, -P来指定其配置的端口号，如果端口不配置，将采用TDengine的系统配置参数serverPort。
**集群内部通讯**: 各个数据节点之间通过TCP/UDP进行连接。一个数据节点启动时，将获取mnode所在的dnode的EP信息，然后与系统中的mnode建立起连接，交换信息。获取mnode的EP信息有三步，1：检查mnodeEpList文件是否存在，如果不存在或不能正常打开获得mnode EP信息，进入第二步；2：检查系统配置文件taos.cfg, 获取mnode EP配置参数first, second，如果不存在或者taos.cfg里没有这两个配置参数，或无效，进入第三步；3：将自己的EP设为mnode EP, 并独立运行起来。获取mnode EP列表后，数据节点发起连接，如果连接成功，则成功加入进工作的集群，如果不成功，则尝试mnode EP列表中的下一个。如果都尝试了，但连接都仍然失败，则休眠几秒后，再进行尝试。
**集群内部通讯**: 各个数据节点之间通过TCP/UDP进行连接。一个数据节点启动时，将获取mnode所在的dnode的EP信息，然后与系统中的mnode建立起连接，交换信息。获取mnode的EP信息有三步，1：检查mnodeEpList文件是否存在，如果不存在或不能正常打开获得mnode EP信息，进入第二步；2：检查系统配置文件taos.cfg, 获取节点配置参数first, second，（这两个参数指定的节点可以是不带mnode的普通节点，这样的话，节点被连接时会尝试重定向到mnode节点）如果不存在或者taos.cfg里没有这两个配置参数，或无效，进入第三步；3：将自己的EP设为mnode EP, 并独立运行起来。获取mnode EP列表后，数据节点发起连接，如果连接成功，则成功加入进工作的集群，如果不成功，则尝试mnode EP列表中的下一个。如果都尝试了，但连接都仍然失败，则休眠几秒后，再进行尝试。
**MNODE的选择:** TDengine逻辑上有管理节点，但没有单独的执行代码，服务器侧只有一套执行代码taosd。那么哪个数据节点会是管理节点呢？这是系统自动决定的，无需任何人工干预。原则如下：一个数据节点启动时，会检查自己的End Point, 并与获取的mnode EP List进行比对，如果在其中，该数据节点认为自己应该启动mnode模块，成为mnode。如果自己的EP不在mnode EP List里，则不启动mnode模块。在系统的运行过程中，由于负载均衡、宕机等原因，mnode有可能迁移至新的dnode，但一切都是透明的，无需人工干预，配置参数的修改，是mnode自己根据资源做出的决定。
......
documentation20/cn/04.model/docs.md
浏览文件 @ 24b5da8b
......@@ -31,9 +31,13 @@ USE power;
## <a class="anchor" id="create-stable"></a>创建超级表
一个物联网系统，往往存在多种类型的设备，比如对于电网，存在智能电表、变压器、母线、开关等等。为便于多表之间的聚合，使用TDengine, 需要对每个类型的数据采集点创建一超级表。以表一中的智能电表为例，可以使用如下的SQL命令创建超级表：
```mysql
CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupdId int);
```
**注意：**这一指令中的 STABLE 关键字，在 2.0.15 之前的版本中需写作 TABLE 。
与创建普通表一样，创建表时，需要提供表名（示例中为meters），表结构Schema，即数据列的定义。第一列必须为时间戳（示例中为ts)，其他列为采集的物理量（示例中为current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的schema (示例中为location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组ID、管理员ID等等。标签的schema可以事后增加、删除、修改。具体定义以及细节请见 [TAOS SQL 的超级表管理](https://www.taosdata.com/cn/documentation/taos-sql#super-table) 章节。
每一种类型的数据采集点需要建立一个超级表，因此一个物联网系统，往往会有多个超级表。对于电网，我们就需要对智能电表、变压器、母线、开关等都建立一个超级表。在物联网中，一个设备就可能有多个数据采集点（比如一台风力发电的风机，有的采集点采集电流、电压等电参数，有的采集点采集温度、湿度、风向等环境参数），这个时候，对这一类型的设备，需要建立多张超级表。一张超级表里包含的采集物理量必须是同时采集的（时间戳是一致的）。
......@@ -43,9 +47,11 @@ CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAG
## <a class="anchor" id="create-table"></a>创建表
TDengine对每个数据采集点需要独立建表。与标准的关系型数据一样，一张表有表名，Schema，但除此之外，还可以带有一到多个标签。创建时，需要使用超级表做模板，同时指定标签的具体值。以表一中的智能电表为例，可以使用如下的SQL命令建表：
```mysql
CREATE TABLE d1001 USING meters TAGS ("Beijing.Chaoyang", 2);
```
其中d1001是表名，meters是超级表的表名，后面紧跟标签Location的具体标签值”Beijing.Chaoyang"，标签groupId的具体标签值2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 [TAOS SQL 的表管理](https://www.taosdata.com/cn/documentation/taos-sql#table) 章节。
**注意：**目前 TDengine 没有从技术层面限制使用一个 database （dbA）的超级表作为模板建立另一个 database （dbB）的子表，后续会禁止这种用法，不建议使用这种方法建表。
......@@ -57,6 +63,7 @@ TDengine建议将数据采集点的全局唯一ID作为表名(比如设备序列
```mysql
INSERT INTO d1001 USING METERS TAGS ("Beijng.Chaoyang", 2) VALUES (now, 10.2, 219, 0.32);
```
上述SQL语句将记录 (now, 10.2, 219, 0.32) 插入表d1001。如果表d1001还未创建，则使用超级表meters做模板自动创建，同时打上标签值“Beijing.Chaoyang", 2。
关于自动建表的详细语法请参见 [插入记录时自动建表](https://www.taosdata.com/cn/documentation/taos-sql#auto_create_table) 章节。
......
documentation20/cn/08.connector/01.java/docs.md
浏览文件 @ 24b5da8b
......@@ -266,6 +266,25 @@ while(resultSet.next()){
> 查询和操作关系型数据库一致，使用下标获取返回字段内容时从 1 开始，建议使用字段名称获取。
### 处理异常
在报错后，通过SQLException可以获取到错误的信息和错误码：
```java
try (Statement statement = connection.createStatement()) {
// executeQuery
ResultSet resultSet = statement.executeQuery(sql);
// print result
printResult(resultSet);
} catch (SQLException e) {
System.out.println("ERROR Message: " + e.getMessage());
System.out.println("ERROR Code: " + e.getErrorCode());
e.printStackTrace();
}
```
JDBC连接器可能报错的错误码包括3种：JDBC driver本身的报错（错误码在0x2301到0x2350之间），JNI方法的报错（错误码在0x2351到0x2400之间），TDengine其他功能模块的报错。
具体的错误码请参考：
* https://github.com/taosdata/TDengine/blob/develop/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
* https://github.com/taosdata/TDengine/blob/develop/src/inc/taoserror.h
### 订阅
#### 创建
......
documentation20/cn/09.connections/docs.md
浏览文件 @ 24b5da8b
......@@ -13,7 +13,11 @@ TDengine能够与开源数据可视化系统[Grafana](https://www.grafana.com/)
TDengine的Grafana插件在安装包的/usr/local/taos/connector/grafanaplugin目录下。
以CentOS 7.2操作系统为例，将tdengine目录拷贝到/var/lib/grafana/plugins目录下，重新启动grafana即可。
以CentOS 7.2操作系统为例，将grafanaplugin目录拷贝到/var/lib/grafana/plugins目录下，重新启动grafana即可。
```bash
sudo cp -rf /usr/local/taos/connector/grafanaplugin /var/lib/grafana/tdengine
```
### 使用 Grafana
......
documentation20/cn/12.taos-sql/docs.md
浏览文件 @ 24b5da8b
......@@ -230,7 +230,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
## <a class="anchor" id="super-table"></a>超级表STable管理
注意：在 2.0.15 以前的版本中，并不支持 STABLE 保留字，而是写作 TABLE。也即，在本节后文的指令说明中，CREATE、DROP、ALTER 三个指令在老版本中保留字需写作 TABLE 而不是 STABLE。
注意：在 2.0.15.0 及以后的版本中，开始支持 STABLE 保留字。也即，在本节后文的指令说明中，CREATE、DROP、ALTER 三个指令在老版本中保留字需写作 TABLE 而不是 STABLE。
- **创建超级表**
......
src/client/inc/tsclient.h
浏览文件 @ 24b5da8b
......@@ -334,7 +334,7 @@ typedef struct SSubqueryState {
typedef struct SSqlObj {
void *signature;
pthread_t owner; // owner of sql object, by which it is executed
int64_t owner; // owner of sql object, by which it is executed
STscObj *pTscObj;
int64_t rpcRid;
__async_cb_func_t fp;
......@@ -449,6 +449,9 @@ void doAsyncQuery(STscObj *pObj, SSqlObj *pSql, __async_cb_func_t fp, void *para
void tscImportDataFromFile(SSqlObj *pSql);
void tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen);
bool tscIsUpdateQuery(SSqlObj* pSql);
char* tscGetSqlStr(SSqlObj* pSql);
bool tscIsQueryWithLimit(SSqlObj* pSql);
bool tscHasReachLimitation(SQueryInfo *pQueryInfo, SSqlRes *pRes);
char *tscGetErrorMsgPayload(SSqlCmd *pCmd);
......
src/client/src/tscSQLParser.c
浏览文件 @ 24b5da8b
......@@ -1144,7 +1144,7 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
return false;
}
if ((pTagField->type < TSDB_DATA_TYPE_BOOL) || (pTagField->type > TSDB_DATA_TYPE_NCHAR)) {
if ((pTagField->type < TSDB_DATA_TYPE_BOOL) || (pTagField->type > TSDB_DATA_TYPE_UBIGINT)) {
invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
return false;
}
......@@ -1208,7 +1208,7 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
return false;
}
if (pColField->type < TSDB_DATA_TYPE_BOOL || pColField->type > TSDB_DATA_TYPE_NCHAR) {
if (pColField->type < TSDB_DATA_TYPE_BOOL || pColField->type > TSDB_DATA_TYPE_UBIGINT) {
invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
return false;
}
......@@ -1885,6 +1885,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
const char* msg7 = "normal table can not apply this function";
const char* msg8 = "multi-columns selection does not support alias column name";
const char* msg9 = "invalid function";
const char* msg10 = "diff can no be applied to unsigned numeric type";
switch (optr) {
case TK_COUNT: {
......@@ -2023,6 +2024,8 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
if (!IS_NUMERIC_TYPE(colType)) {
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
} else if (IS_UNSIGNED_NUMERIC_TYPE(colType) && optr == TK_DIFF) {
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg10);
}
int16_t resultType = 0;
......
src/client/src/tscServer.c
浏览文件 @ 24b5da8b
......@@ -418,6 +418,9 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
bool shouldFree = tscShouldBeFreed(pSql);
if (rpcMsg->code != TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
if (rpcMsg->code != TSDB_CODE_SUCCESS) {
pRes->code = rpcMsg->code;
}
rpcMsg->code = (pRes->code == TSDB_CODE_SUCCESS) ? (int32_t)pRes->numOfRows : pRes->code;
(*pSql->fp)(pSql->param, pSql, rpcMsg->code);
}
......
src/client/src/tscSubquery.c
浏览文件 @ 24b5da8b
......@@ -683,10 +683,14 @@ void tscBuildVgroupTableInfo(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SArr
prev = tt;
}
pTableMetaInfo->pVgroupTables = result;
pTableMetaInfo->vgroupIndex = 0;
if (taosArrayGetSize(result) > 0) {
if (taosArrayGetSize(result) <= 0) {
pTableMetaInfo->pVgroupTables = NULL;
taosArrayDestroy(result);
} else {
pTableMetaInfo->pVgroupTables = result;
SVgroupTableInfo* g = taosArrayGet(result, taosArrayGetSize(result) - 1);
tscDebug("%p vgId:%d, tables:%"PRIzu, pSql, g->vgInfo.vgId, taosArrayGetSize(g->itemList));
}
......
src/client/src/tscUtil.c
浏览文件 @ 24b5da8b
......@@ -2310,6 +2310,35 @@ bool tscIsUpdateQuery(SSqlObj* pSql) {
return ((pCmd->command >= TSDB_SQL_INSERT && pCmd->command <= TSDB_SQL_DROP_DNODE) || TSDB_SQL_USE_DB == pCmd->command);
}
char* tscGetSqlStr(SSqlObj* pSql) {
if (pSql == NULL || pSql->signature != pSql) {
return NULL;
}
return pSql->sqlstr;
}
bool tscIsQueryWithLimit(SSqlObj* pSql) {
if (pSql == NULL || pSql->signature != pSql) {
return false;
}
SSqlCmd* pCmd = &pSql->cmd;
for (int32_t i = 0; i < pCmd->numOfClause; ++i) {
SQueryInfo* pqi = tscGetQueryInfoDetailSafely(pCmd, i);
if (pqi == NULL) {
continue;
}
if (pqi->limit.limit > 0) {
return true;
}
}
return false;
}
int32_t tscSQLSyntaxErrMsg(char* msg, const char* additionalInfo, const char* sql) {
const char* msgFormat1 = "syntax error near \'%s\'";
const char* msgFormat2 = "syntax error near \'%s\' (%s)";
......@@ -2549,11 +2578,7 @@ bool tscSetSqlOwner(SSqlObj* pSql) {
SSqlRes* pRes = &pSql->res;
// set the sql object owner
#ifdef __APPLE__
pthread_t threadId = (pthread_t)taosGetSelfPthreadId();
#else // __APPLE__
uint64_t threadId = taosGetSelfPthreadId();
#endif // __APPLE__
int64_t threadId = taosGetSelfPthreadId();
if (atomic_val_compare_exchange_64(&pSql->owner, 0, threadId) != 0) {
pRes->code = TSDB_CODE_QRY_IN_EXEC;
return false;
......@@ -2563,7 +2588,6 @@ bool tscSetSqlOwner(SSqlObj* pSql) {
}
void tscClearSqlOwner(SSqlObj* pSql) {
assert(taosCheckPthreadValid(pSql->owner));
atomic_store_64(&pSql->owner, 0);
}
......
src/common/src/tglobal.c
浏览文件 @ 24b5da8b
......@@ -1151,7 +1151,7 @@ static void doInitGlobalConfig(void) {
cfg.ptr = &tsHttpMaxThreads;
cfg.valType = TAOS_CFG_VTYPE_INT32;
cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG;
cfg.minValue = 1;
cfg.minValue = 2;
cfg.maxValue = 1000000;
cfg.ptrLength = 0;
cfg.unitType = TAOS_CFG_UTYPE_NONE;
......@@ -1523,6 +1523,13 @@ int32_t taosCheckGlobalCfg() {
tsNumOfCores = 1;
}
if (tsHttpMaxThreads == 2) {
int32_t halfNumOfCores = tsNumOfCores >> 1;
if (halfNumOfCores > 2) {
tsHttpMaxThreads = halfNumOfCores;
}
}
if (tsMaxTablePerVnode < tsMinTablePerVnode) {
uError("maxTablesPerVnode(%d) < minTablesPerVnode(%d), reset to minTablesPerVnode(%d)",
tsMaxTablePerVnode, tsMinTablePerVnode, tsMinTablePerVnode);
......
src/connector/jdbc/CMakeLists.txt
浏览文件 @ 24b5da8b
......@@ -8,7 +8,7 @@ IF (TD_MVN_INSTALLED)
ADD_CUSTOM_COMMAND(OUTPUT ${JDBC_CMD_NAME}
POST_BUILD
COMMAND mvn -Dmaven.test.skip=true install -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.19-dist.jar ${LIBRARY_OUTPUT_PATH}
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.20-dist.jar ${LIBRARY_OUTPUT_PATH}
COMMAND mvn -Dmaven.test.skip=true clean -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
COMMENT "build jdbc driver")
ADD_CUSTOM_TARGET(${JDBC_TARGET_NAME} ALL WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} DEPENDS ${JDBC_CMD_NAME})
......
src/connector/jdbc/deploy-pom.xml
浏览文件 @ 24b5da8b
......@@ -5,7 +5,7 @@
<groupId>com.taosdata.jdbc</groupId>
<artifactId>taos-jdbcdriver</artifactId>
<version>2.0.19</version>
<version>2.0.20</version>
<packaging>jar</packaging>
<name>JDBCDriver</name>
......
src/connector/jdbc/pom.xml
浏览文件 @ 24b5da8b
......@@ -3,7 +3,7 @@
<modelVersion>4.0.0</modelVersion>
<groupId>com.taosdata.jdbc</groupId>
<artifactId>taos-jdbcdriver</artifactId>
<version>2.0.19</version>
<version>2.0.20</version>
<packaging>jar</packaging>
<name>JDBCDriver</name>
<url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>
......@@ -34,23 +34,9 @@
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
<maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
<commons-logging.version>1.1.2</commons-logging.version>
<commons-lang3.version>3.5</commons-lang3.version>
<maven.test.jvmargs></maven.test.jvmargs>
</properties>
<dependencies>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>${commons-logging.version}</version>
<exclusions>
<exclusion>
<groupId>*</groupId>
<artifactId>*</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
......@@ -64,23 +50,12 @@
<artifactId>httpclient</artifactId>
<version>4.5.8</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.9</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.58</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-dbcp2</artifactId>
<version>2.7.0</version>
</dependency>
</dependencies>
<build>
......
src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractConnection.java
浏览文件 @ 24b5da8b
......@@ -126,9 +126,9 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
case Connection.TRANSACTION_READ_COMMITTED:
case Connection.TRANSACTION_REPEATABLE_READ:
case Connection.TRANSACTION_SERIALIZABLE:
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
default:
throw new SQLException(TSDBConstants.INVALID_VARIABLES);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
}
//do nothing
}
......@@ -436,7 +436,7 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
@Override
public void setClientInfo(String name, String value) throws SQLClientInfoException {
if (isClosed)
throw TSDBError.createSQLClientInfoException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
throw (SQLClientInfoException) TSDBError.createSQLException(TSDBErrorNumbers.ERROR_SQLCLIENT_EXCEPTION_ON_CONNECTION_CLOSED);
if (clientInfoProps == null)
clientInfoProps = new Properties();
......@@ -446,7 +446,8 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
@Override
public void setClientInfo(Properties properties) throws SQLClientInfoException {
if (isClosed)
throw TSDBError.createSQLClientInfoException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
throw (SQLClientInfoException) TSDBError.createSQLException(TSDBErrorNumbers.ERROR_SQLCLIENT_EXCEPTION_ON_CONNECTION_CLOSED);
for (Enumeration<Object> enumer = properties.keys(); enumer.hasMoreElements(); ) {
String name = (String) enumer.nextElement();
......@@ -457,7 +458,7 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
@Override
public String getClientInfo(String name) throws SQLException {
if (isClosed)
throw TSDBError.createSQLClientInfoException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
return clientInfoProps.getProperty(name);
}
......@@ -465,7 +466,7 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
@Override
public Properties getClientInfo() throws SQLException {
if (isClosed)
throw TSDBError.createSQLClientInfoException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
return clientInfoProps;
}
......
src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractStatement.java
浏览文件 @ 24b5da8b
package com.taosdata.jdbc;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public abstract class AbstractStatement extends WrapperImpl implements Statement {
private volatile boolean closeOnCompletion;
protected List<String> batchedArgs;
private int fetchSize;
@Override
......@@ -45,13 +47,14 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (max < 0)
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
// nothing to do
// do nothing
}
@Override
public void setEscapeProcessing(boolean enable) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
// do nothing
}
@Override
......@@ -71,6 +74,9 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
@Override
public void cancel() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
......@@ -92,6 +98,7 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
public void setCursorName(String name) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
......@@ -113,6 +120,15 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
public void setFetchDirection(int direction) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
switch (direction) {
case ResultSet.FETCH_FORWARD:
case ResultSet.FETCH_REVERSE:
case ResultSet.FETCH_UNKNOWN:
break;
default:
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
}
//nothing to do
}
......@@ -155,13 +171,42 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
}
@Override
public abstract void addBatch(String sql) throws SQLException;
public void addBatch(String sql) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (batchedArgs == null) {
batchedArgs = new ArrayList<>();
}
batchedArgs.add(sql);
}
@Override
public abstract void clearBatch() throws SQLException;
public void clearBatch() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (batchedArgs != null)
batchedArgs.clear();
}
@Override
public abstract int[] executeBatch() throws SQLException;
public int[] executeBatch() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (batchedArgs == null || batchedArgs.isEmpty())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_BATCH_IS_EMPTY);
int[] res = new int[batchedArgs.size()];
for (int i = 0; i < batchedArgs.size(); i++) {
boolean isSelect = execute(batchedArgs.get(i));
if (isSelect) {
res[i] = SUCCESS_NO_INFO;
} else {
res[i] = getUpdateCount();
}
}
return res;
}
@Override
public abstract Connection getConnection() throws SQLException;
......@@ -170,42 +215,73 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
public boolean getMoreResults(int current) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
switch (current) {
case Statement.CLOSE_CURRENT_RESULT:
return false;
case Statement.KEEP_CURRENT_RESULT:
case Statement.CLOSE_ALL_RESULTS:
break;
default:
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
}
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public ResultSet getGeneratedKeys() throws SQLException {
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public int executeUpdate(String sql, String[] columnNames) throws SQLException {
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public boolean execute(String sql, int[] columnIndexes) throws SQLException {
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public boolean execute(String sql, String[] columnNames) throws SQLException {
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......@@ -222,7 +298,7 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
public void setPoolable(boolean poolable) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
//nothing to do
// do nothing
}
@Override
......@@ -236,14 +312,15 @@ public abstract class AbstractStatement extends WrapperImpl implements Statement
public void closeOnCompletion() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
this.closeOnCompletion = true;
// do nothing
}
@Override
public boolean isCloseOnCompletion() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
return this.closeOnCompletion;
return false;
}
}
src/connector/jdbc/src/main/java/com/taosdata/jdbc/DatabaseMetaDataResultSet.java
浏览文件 @ 24b5da8b
......@@ -160,12 +160,12 @@ public class DatabaseMetaDataResultSet implements ResultSet {
@Override
public Date getDate(int columnIndex) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public Time getTime(int columnIndex) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......@@ -176,17 +176,17 @@ public class DatabaseMetaDataResultSet implements ResultSet {
@Override
public InputStream getAsciiStream(int columnIndex) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public InputStream getUnicodeStream(int columnIndex) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public InputStream getBinaryStream(int columnIndex) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......@@ -256,22 +256,22 @@ public class DatabaseMetaDataResultSet implements ResultSet {
@Override
public InputStream getAsciiStream(String columnLabel) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public InputStream getUnicodeStream(String columnLabel) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public InputStream getBinaryStream(String columnLabel) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public SQLWarning getWarnings() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......@@ -281,7 +281,7 @@ public class DatabaseMetaDataResultSet implements ResultSet {
@Override
public String getCursorName() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......@@ -313,12 +313,12 @@ public class DatabaseMetaDataResultSet implements ResultSet {
@Override
public Reader getCharacterStream(int columnIndex) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public Reader getCharacterStream(String columnLabel) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......@@ -353,22 +353,22 @@ public class DatabaseMetaDataResultSet implements ResultSet {
@Override
public void beforeFirst() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void afterLast() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public boolean first() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public boolean last() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......@@ -383,17 +383,17 @@ public class DatabaseMetaDataResultSet implements ResultSet {
@Override
public boolean absolute(int row) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public boolean relative(int rows) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public boolean previous() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......@@ -443,227 +443,227 @@ public class DatabaseMetaDataResultSet implements ResultSet {
@Override
public void updateNull(int columnIndex) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateBoolean(int columnIndex, boolean x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateByte(int columnIndex, byte x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateShort(int columnIndex, short x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateInt(int columnIndex, int x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateLong(int columnIndex, long x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateFloat(int columnIndex, float x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateDouble(int columnIndex, double x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateString(int columnIndex, String x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateBytes(int columnIndex, byte[] x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateDate(int columnIndex, Date x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateTime(int columnIndex, Time x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateObject(int columnIndex, Object x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateNull(String columnLabel) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateBoolean(String columnLabel, boolean x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateByte(String columnLabel, byte x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateShort(String columnLabel, short x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateInt(String columnLabel, int x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateLong(String columnLabel, long x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateFloat(String columnLabel, float x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateDouble(String columnLabel, double x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateString(String columnLabel, String x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateBytes(String columnLabel, byte[] x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateDate(String columnLabel, Date x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateTime(String columnLabel, Time x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateObject(String columnLabel, Object x) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void insertRow() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void updateRow() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void deleteRow() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void refreshRow() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void cancelRowUpdates() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void moveToInsertRow() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void moveToCurrentRow() throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......@@ -673,12 +673,12 @@ public class DatabaseMetaDataResultSet implements ResultSet {
@Override
public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public Ref getRef(int columnIndex) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......@@ -1043,12 +1043,12 @@ public class DatabaseMetaDataResultSet implements ResultSet {
@Override
public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
throw new SQLException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
......
src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBError.java
浏览文件 @ 24b5da8b
......@@ -22,49 +22,47 @@ public class TSDBError {
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_DATABASE_NOT_SPECIFIED_OR_AVAILABLE, "Database not specified or available");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_INVALID_FOR_EXECUTE_UPDATE, "not a valid sql for executeUpdate: (?)");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_INVALID_FOR_EXECUTE, "not a valid sql for execute: (?)");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE, "parameter index out of range");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_SQLCLIENT_EXCEPTION_ON_CONNECTION_CLOSED, "connection already closed");
/**************************************************/
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_UNKNOWN, "unknown error");
/**************************************************/
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_SUBSCRIBE_FAILED, "failed to create subscription");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_UNSUPPORTED_ENCODING, "Unsupported encoding");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_TDENGINE_ERROR, "internal error of database!");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL, "JNI connection already closed!");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_RESULT_SET_NULL, "invalid JNI result set!");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_NUM_OF_FIELDS_0, "invalid num of fields!");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_SQL_NULL, "empty sql string!");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_FETCH_END, "fetch to the end of resultset");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY, "JNI alloc memory failed!");
}
public static String wrapErrMsg(String msg) {
return "TDengine Error: " + msg;
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_TDENGINE_ERROR, "internal error of database");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL, "JNI connection is NULL");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_RESULT_SET_NULL, "JNI result set is NULL");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_NUM_OF_FIELDS_0, "invalid num of fields");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_SQL_NULL, "empty sql string");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_FETCH_END, "fetch to the end of resultSet");
TSDBErrorMap.put(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY, "JNI alloc memory failed");
}
public static SQLException createSQLException(int errorNumber) {
return createSQLException(errorNumber, null);
}
public static SQLException createSQLException(int errorNumber, String message) {
if (message == null || message.isEmpty()) {
if (TSDBErrorNumbers.contains(errorNumber))
message = TSDBErrorMap.get(errorNumber);
public static SQLException createSQLException(int errorCode) {
String message;
if (TSDBErrorNumbers.contains(errorCode))
message = TSDBErrorMap.get(errorCode);
else
message = TSDBErrorMap.get(TSDBErrorNumbers.ERROR_UNKNOWN);
return createSQLException(errorCode, message);
}
if (errorNumber == TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD)
return new SQLFeatureNotSupportedException(message);
public static SQLException createSQLException(int errorCode, String message) {
// throw SQLFeatureNotSupportedException
if (errorCode == TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD)
return new SQLFeatureNotSupportedException(message, "", errorCode);
// throw SQLClientInfoException
if (errorCode == TSDBErrorNumbers.ERROR_SQLCLIENT_EXCEPTION_ON_CONNECTION_CLOSED)
return new SQLClientInfoException(message, null);
if (errorNumber < TSDBErrorNumbers.ERROR_UNKNOWN)
if (errorCode > 0x2300 && errorCode < 0x2350)
// JDBC exception's error number is less than 0x2350
return new SQLException("ERROR (" + Integer.toHexString(errorNumber) + "): " + message);
return new SQLException("ERROR (" + Integer.toHexString(errorCode) + "): " + message, "", errorCode);
if (errorCode > 0x2350 && errorCode < 0x2400)
// JNI exception's error number is large than 0x2350
return new SQLException("TDengine ERROR (" + Integer.toHexString(errorNumber) + "): " + message);
return new SQLException("JNI ERROR (" + Integer.toHexString(errorCode) + "): " + message, "", errorCode);
return new SQLException("TDengine ERROR (" + Integer.toHexString(errorCode) + "): " + message, "", errorCode);
}
public static SQLClientInfoException createSQLClientInfoException(int errorNumber) {
return new SQLClientInfoException();
}
}
src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
浏览文件 @ 24b5da8b
......@@ -13,22 +13,24 @@ public class TSDBErrorNumbers {
public static final int ERROR_INVALID_WITH_EXECUTEQUERY = 0x2307; //Can not issue data manipulation statements with executeQuery()
public static final int ERROR_INVALID_WITH_EXECUTEUPDATE = 0x2308; //Can not issue SELECT via executeUpdate()
public static final int ERROR_INVALID_FOR_EXECUTE_QUERY = 0x2309; //not a valid sql for executeQuery: (SQL)
public static final int ERROR_DATABASE_NOT_SPECIFIED_OR_AVAILABLE = 0x2310; //Database not specified or available
public static final int ERROR_INVALID_FOR_EXECUTE_UPDATE = 0x2311; //not a valid sql for executeUpdate: (SQL)
public static final int ERROR_INVALID_FOR_EXECUTE = 0x2312; //not a valid sql for execute: (SQL)
public static final int ERROR_DATABASE_NOT_SPECIFIED_OR_AVAILABLE = 0x230a; //Database not specified or available
public static final int ERROR_INVALID_FOR_EXECUTE_UPDATE = 0x230b; //not a valid sql for executeUpdate: (SQL)
public static final int ERROR_INVALID_FOR_EXECUTE = 0x230c; //not a valid sql for execute: (SQL)
public static final int ERROR_PARAMETER_INDEX_OUT_RANGE = 0x230d; // parameter index out of range
public static final int ERROR_SQLCLIENT_EXCEPTION_ON_CONNECTION_CLOSED = 0x230e; // connection already closed
public static final int ERROR_UNKNOWN = 0x2350; //unknown error
public static final int ERROR_SUBSCRIBE_FAILED = 0x2351; //failed to create subscription
public static final int ERROR_UNSUPPORTED_ENCODING = 0x2352; //Unsupported encoding
public static final int ERROR_SUBSCRIBE_FAILED = 0x2351; // failed to create subscription
public static final int ERROR_UNSUPPORTED_ENCODING = 0x2352; // Unsupported encoding
public static final int ERROR_JNI_TDENGINE_ERROR = 0x2353;
public static final int ERROR_JNI_CONNECTION_NULL = 0x2354; //invalid tdengine connection!
public static final int ERROR_JNI_RESULT_SET_NULL = 0x2355;
public static final int ERROR_JNI_NUM_OF_FIELDS_0 = 0x2356;
public static final int ERROR_JNI_SQL_NULL = 0x2357;
public static final int ERROR_JNI_FETCH_END = 0x2358;
public static final int ERROR_JNI_OUT_OF_MEMORY = 0x2359;
public static final int ERROR_JNI_TDENGINE_ERROR = 0x2353; // internal error of database
public static final int ERROR_JNI_CONNECTION_NULL = 0x2354; // JNI connection is NULL
public static final int ERROR_JNI_RESULT_SET_NULL = 0x2355; // invalid JNI result set
public static final int ERROR_JNI_NUM_OF_FIELDS_0 = 0x2356; // invalid num of fields
public static final int ERROR_JNI_SQL_NULL = 0x2357; // empty sql string
public static final int ERROR_JNI_FETCH_END = 0x2358; // fetch to the end of resultSet
public static final int ERROR_JNI_OUT_OF_MEMORY = 0x2359; // JNI alloc memory failed
private static final HashSet<Integer> errorNumbers;
......@@ -45,6 +47,8 @@ public class TSDBErrorNumbers {
errorNumbers.add(ERROR_DATABASE_NOT_SPECIFIED_OR_AVAILABLE);
errorNumbers.add(ERROR_INVALID_FOR_EXECUTE_UPDATE);
errorNumbers.add(ERROR_INVALID_FOR_EXECUTE);
errorNumbers.add(ERROR_PARAMETER_INDEX_OUT_RANGE);
errorNumbers.add(ERROR_SQLCLIENT_EXCEPTION_ON_CONNECTION_CLOSED);
/*****************************************************/
errorNumbers.add(ERROR_SUBSCRIBE_FAILED);
......
src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
浏览文件 @ 24b5da8b
......@@ -102,7 +102,7 @@ public class TSDBJNIConnector {
this.taos = this.connectImp(host, port, dbName, user, password);
if (this.taos == TSDBConstants.JNI_NULL_POINTER) {
throw new SQLException(TSDBConstants.WrapErrMsg(this.getErrMsg(0L)), "", this.getErrCode(0l));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL);
}
// invoke connectImp only here
taosInfo.conn_open_increment();
......@@ -187,7 +187,6 @@ public class TSDBJNIConnector {
// public long getResultSet() {
// return taosResultSetPointer;
// }
private native long getResultSetImp(long connection, long pSql);
public boolean isUpdateQuery(long pSql) {
......@@ -227,7 +226,6 @@ public class TSDBJNIConnector {
// }
// return resCode;
// }
private native int freeResultSetImp(long connection, long result);
/**
......@@ -275,7 +273,7 @@ public class TSDBJNIConnector {
public void closeConnection() throws SQLException {
int code = this.closeConnectionImp(this.taos);
if (code < 0) {
throw new SQLException(TSDBConstants.FixErrMsg(code), "", this.getErrCode(0l));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL);
} else if (code == 0) {
this.taos = TSDBConstants.JNI_NULL_POINTER;
} else {
......
src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java
浏览文件 @ 24b5da8b
......@@ -14,17 +14,13 @@
*****************************************************************************/
package com.taosdata.jdbc;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TSDBStatement extends AbstractStatement {
private TSDBJNIConnector connector;
/**
* To store batched commands
*/
protected List<String> batchedArgs;
/**
* Status of current statement
*/
......@@ -119,41 +115,6 @@ public class TSDBStatement extends AbstractStatement {
return this.affectedRows;
}
public void addBatch(String sql) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (batchedArgs == null) {
batchedArgs = new ArrayList<>();
}
batchedArgs.add(sql);
}
public void clearBatch() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (batchedArgs != null)
batchedArgs.clear();
}
public int[] executeBatch() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (batchedArgs == null || batchedArgs.isEmpty())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_BATCH_IS_EMPTY);
int[] res = new int[batchedArgs.size()];
for (int i = 0; i < batchedArgs.size(); i++) {
boolean isSelect = execute(batchedArgs.get(i));
if (isSelect) {
res[i] = SUCCESS_NO_INFO;
} else {
res[i] = getUpdateCount();
}
}
return res;
}
public Connection getConnection() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
......
src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulConnection.java
浏览文件 @ 24b5da8b
......@@ -26,7 +26,8 @@ public class RestfulConnection extends AbstractConnection {
@Override
public Statement createStatement() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);;
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
;
return new RestfulStatement(this, database);
}
......@@ -34,9 +35,8 @@ public class RestfulConnection extends AbstractConnection {
@Override
public PreparedStatement prepareStatement(String sql) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);;
//TODO: prepareStatement
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
return new RestfulPreparedStatement(this, database, sql);
}
@Override
......@@ -55,7 +55,8 @@ public class RestfulConnection extends AbstractConnection {
@Override
public DatabaseMetaData getMetaData() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);;
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
;
return this.metadata;
}
......
src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDriver.java
浏览文件 @ 24b5da8b
......@@ -5,8 +5,10 @@ import com.alibaba.fastjson.JSONObject;
import com.taosdata.jdbc.AbstractDriver;
import com.taosdata.jdbc.TSDBConstants;
import com.taosdata.jdbc.TSDBDriver;
import com.taosdata.jdbc.rs.util.HttpClientPoolUtil;
import com.taosdata.jdbc.utils.HttpClientPoolUtil;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.sql.*;
import java.util.Properties;
import java.util.logging.Logger;
......@@ -41,6 +43,15 @@ public class RestfulDriver extends AbstractDriver {
+ props.getProperty(TSDBDriver.PROPERTY_KEY_PORT) + "/rest/login/"
+ props.getProperty(TSDBDriver.PROPERTY_KEY_USER) + "/"
+ props.getProperty(TSDBDriver.PROPERTY_KEY_PASSWORD) + "";
try {
String user = URLEncoder.encode(props.getProperty(TSDBDriver.PROPERTY_KEY_USER), "UTF-8");
String password = URLEncoder.encode(props.getProperty(TSDBDriver.PROPERTY_KEY_PASSWORD), "UTF-8");
loginUrl = "http://" + props.getProperty(TSDBDriver.PROPERTY_KEY_HOST) + ":"
+ props.getProperty(TSDBDriver.PROPERTY_KEY_PORT) + "/rest/login/" + user + "/" + password + "";
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
String result = HttpClientPoolUtil.execute(loginUrl);
JSONObject jsonResult = JSON.parseObject(result);
String status = jsonResult.getString("status");
......
src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulPreparedStatement.java 0 → 100644
浏览文件 @ 24b5da8b
package com.taosdata.jdbc.rs;
import com.taosdata.jdbc.TSDBError;
import com.taosdata.jdbc.TSDBErrorNumbers;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.Calendar;
public class RestfulPreparedStatement extends RestfulStatement implements PreparedStatement {
private ParameterMetaData parameterMetaData;
private final String rawSql;
private Object[] parameters;
private boolean isPrepared;
public RestfulPreparedStatement(RestfulConnection conn, String database, String sql) {
super(conn, database);
this.rawSql = sql;
if (sql.contains("?")) {
int parameterCnt = 0;
for (int i = 0; i < sql.length(); i++) {
if ('?' == sql.charAt(i)) {
parameterCnt++;
}
}
parameters = new Object[parameterCnt];
this.isPrepared = true;
}
//TODO: build parameterMetaData
}
@Override
public ResultSet executeQuery() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (!isPrepared)
return executeQuery(this.rawSql);
final String sql = getNativeSql(this.rawSql);
return executeQuery(sql);
}
@Override
public int executeUpdate() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (!isPrepared)
return executeUpdate(this.rawSql);
final String sql = getNativeSql(this.rawSql);
return executeUpdate(sql);
}
private String getNativeSql(String rawSql) throws SQLException {
String sql = rawSql;
for (int i = 0; i < parameters.length; ++i) {
Object para = parameters[i];
if (para != null) {
String paraStr = para.toString();
if (para instanceof Timestamp || para instanceof String) {
paraStr = "'" + paraStr + "'";
}
sql = sql.replaceFirst("[?]", paraStr);
} else {
sql = sql.replaceFirst("[?]", "NULL");
}
}
clearParameters();
return sql;
}
@Override
public void setNull(int parameterIndex, int sqlType) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
setObject(parameterIndex, "NULL");
}
@Override
public void setBoolean(int parameterIndex, boolean x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
setObject(parameterIndex, x);
}
@Override
public void setByte(int parameterIndex, byte x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setShort(int parameterIndex, short x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
setObject(parameterIndex, x);
}
@Override
public void setInt(int parameterIndex, int x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
setObject(parameterIndex, x);
}
@Override
public void setLong(int parameterIndex, long x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
setObject(parameterIndex, x);
}
@Override
public void setFloat(int parameterIndex, float x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
setObject(parameterIndex, x);
}
@Override
public void setDouble(int parameterIndex, double x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
setObject(parameterIndex, x);
}
@Override
public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setString(int parameterIndex, String x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
setObject(parameterIndex, x);
}
@Override
public void setBytes(int parameterIndex, byte[] x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setDate(int parameterIndex, Date x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setTime(int parameterIndex, Time x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
setObject(parameterIndex, x);
}
@Override
public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void clearParameters() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
this.parameters = new Object[parameters.length];
}
@Override
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setObject(int parameterIndex, Object x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (parameterIndex < 1 && parameterIndex >= parameters.length)
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
parameters[parameterIndex - 1] = x;
}
@Override
public boolean execute() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
if (!isPrepared)
return execute(this.rawSql);
final String sql = getNativeSql(rawSql);
return execute(sql);
}
@Override
public void addBatch() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
final String sql = getNativeSql(this.rawSql);
addBatch(sql);
}
@Override
public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setRef(int parameterIndex, Ref x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setBlob(int parameterIndex, Blob x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setClob(int parameterIndex, Clob x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setArray(int parameterIndex, Array x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public ResultSetMetaData getMetaData() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setURL(int parameterIndex, URL x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public ParameterMetaData getParameterMetaData() throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
// throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
return this.parameterMetaData;
}
@Override
public void setRowId(int parameterIndex, RowId x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setNString(int parameterIndex, String value) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setNClob(int parameterIndex, NClob value) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setClob(int parameterIndex, Reader reader) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
@Override
public void setNClob(int parameterIndex, Reader reader) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
}
}
src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulResultSet.java
浏览文件 @ 24b5da8b
......@@ -106,7 +106,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public boolean next() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
pos++;
if (pos <= resultSet.size() - 1) {
return true;
......@@ -124,14 +124,14 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public boolean wasNull() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
return resultSet.isEmpty();
}
@Override
public String getString(int columnIndex) throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
if (columnIndex > resultSet.get(pos).size()) {
throw new SQLException(TSDBConstants.WrapErrMsg("Column Index out of range, " + columnIndex + " > " + resultSet.get(pos).size()));
......@@ -144,7 +144,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public boolean getBoolean(int columnIndex) throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
columnIndex = getTrueColumnIndex(columnIndex);
int result = getInt(columnIndex);
......@@ -154,7 +154,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public short getShort(int columnIndex) throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
columnIndex = getTrueColumnIndex(columnIndex);
return Short.parseShort(resultSet.get(pos).get(columnIndex).toString());
}
......@@ -162,7 +162,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public int getInt(int columnIndex) throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
columnIndex = getTrueColumnIndex(columnIndex);
return Integer.parseInt(resultSet.get(pos).get(columnIndex).toString());
}
......@@ -170,7 +170,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public long getLong(int columnIndex) throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
columnIndex = getTrueColumnIndex(columnIndex);
return Long.parseLong(resultSet.get(pos).get(columnIndex).toString());
}
......@@ -178,7 +178,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public float getFloat(int columnIndex) throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
columnIndex = getTrueColumnIndex(columnIndex);
return Float.parseFloat(resultSet.get(pos).get(columnIndex).toString());
}
......@@ -186,7 +186,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public double getDouble(int columnIndex) throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
columnIndex = getTrueColumnIndex(columnIndex);
return Double.parseDouble(resultSet.get(pos).get(columnIndex).toString());
......@@ -208,7 +208,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public Timestamp getTimestamp(int columnIndex) throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
columnIndex = getTrueColumnIndex(columnIndex);
String strDate = resultSet.get(pos).get(columnIndex).toString();
......@@ -220,7 +220,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public ResultSetMetaData getMetaData() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
return this.metaData;
}
......@@ -233,7 +233,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public int findColumn(String columnLabel) throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
int columnIndex = columnNames.indexOf(columnLabel);
if (columnIndex == -1)
......@@ -244,14 +244,14 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public boolean isBeforeFirst() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
return this.pos == -1 && this.resultSet.size() != 0;
}
@Override
public boolean isAfterLast() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
return this.pos >= resultSet.size() && this.resultSet.size() != 0;
}
......@@ -259,14 +259,14 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public boolean isFirst() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
return this.pos == 0;
}
@Override
public boolean isLast() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
if (this.resultSet.size() == 0)
return false;
return this.pos == (this.resultSet.size() - 1);
......@@ -275,7 +275,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public void beforeFirst() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
synchronized (this) {
if (this.resultSet.size() > 0) {
......@@ -287,7 +287,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public void afterLast() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
synchronized (this) {
if (this.resultSet.size() > 0) {
this.pos = this.resultSet.size();
......@@ -298,7 +298,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public boolean first() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
if (this.resultSet.size() == 0)
return false;
......@@ -312,7 +312,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public boolean last() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
if (this.resultSet.size() == 0)
return false;
synchronized (this) {
......@@ -324,7 +324,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public int getRow() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
int row;
synchronized (this) {
if (this.pos < 0 || this.pos >= this.resultSet.size())
......@@ -396,7 +396,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
@Override
public Statement getStatement() throws SQLException {
if (isClosed())
throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.RESULT_SET_IS_CLOSED));
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
return this.statement;
}
......@@ -407,5 +407,4 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
}
}
src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java
浏览文件 @ 24b5da8b
package com.taosdata.jdbc.rs;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.taosdata.jdbc.AbstractStatement;
import com.taosdata.jdbc.TSDBConstants;
import com.taosdata.jdbc.TSDBError;
import com.taosdata.jdbc.TSDBErrorNumbers;
import com.taosdata.jdbc.rs.util.HttpClientPoolUtil;
import com.taosdata.jdbc.utils.HttpClientPoolUtil;
import com.taosdata.jdbc.utils.SqlSyntaxValidator;
import java.sql.*;
......@@ -29,7 +30,7 @@ public class RestfulStatement extends AbstractStatement {
this.database = database;
}
private String[] parseTableIdentifier(String sql) {
protected String[] parseTableIdentifier(String sql) {
sql = sql.trim().toLowerCase();
String[] ret = null;
if (sql.contains("where"))
......@@ -74,8 +75,8 @@ public class RestfulStatement extends AbstractStatement {
return executeOneQuery(url, sql);
}
if (this.database == null || this.database.isEmpty())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_DATABASE_NOT_SPECIFIED_OR_AVAILABLE);
// if (this.database == null || this.database.isEmpty())
// throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_DATABASE_NOT_SPECIFIED_OR_AVAILABLE);
HttpClientPoolUtil.execute(url, "use " + this.database);
return executeOneQuery(url, sql);
}
......@@ -92,8 +93,8 @@ public class RestfulStatement extends AbstractStatement {
return executeOneUpdate(url, sql);
}
if (this.database == null || this.database.isEmpty())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_DATABASE_NOT_SPECIFIED_OR_AVAILABLE);
// if (this.database == null || this.database.isEmpty())
// throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_DATABASE_NOT_SPECIFIED_OR_AVAILABLE);
HttpClientPoolUtil.execute(url, "use " + this.database);
return executeOneUpdate(url, sql);
......@@ -115,24 +116,28 @@ public class RestfulStatement extends AbstractStatement {
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_FOR_EXECUTE, "not a valid sql for execute: " + sql);
//如果执行了use操作应该将当前Statement的catalog设置为新的database
boolean result = true;
final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
if (SqlSyntaxValidator.isUseSql(sql)) {
HttpClientPoolUtil.execute(url, sql);
this.database = sql.trim().replace("use", "").trim();
this.conn.setCatalog(this.database);
result = false;
} else if (SqlSyntaxValidator.isDatabaseUnspecifiedQuery(sql)) {
executeOneQuery(url, sql);
} else if (SqlSyntaxValidator.isDatabaseUnspecifiedUpdate(sql)) {
executeOneUpdate(url, sql);
result = false;
} else {
if (SqlSyntaxValidator.isValidForExecuteQuery(sql)) {
executeQuery(sql);
} else {
executeUpdate(sql);
result = false;
}
}
return true;
return result;
}
private ResultSet executeOneQuery(String url, String sql) throws SQLException {
......@@ -176,10 +181,23 @@ public class RestfulStatement extends AbstractStatement {
throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonObject.getString("desc") + "\n" + "error code: " + jsonObject.getString("code")));
}
this.resultSet = null;
this.affectedRows = Integer.parseInt(jsonObject.getString("rows"));
this.affectedRows = checkJsonResultSet(jsonObject);
return this.affectedRows;
}
private int checkJsonResultSet(JSONObject jsonObject) {
// create ... SQLs should return 0 , and Restful result is this:
// {"status": "succ", "head": ["affected_rows"], "data": [[0]], "rows": 1}
JSONArray head = jsonObject.getJSONArray("head");
JSONArray data = jsonObject.getJSONArray("data");
int rows = Integer.parseInt(jsonObject.getString("rows"));
if (head.size() == 1 && "affected_rows".equals(head.getString(0))
&& data.size() == 1 && data.getJSONArray(0).getInteger(0) == 0 && rows == 1) {
return 0;
}
return rows;
}
@Override
public ResultSet getResultSet() throws SQLException {
if (isClosed())
......@@ -195,24 +213,6 @@ public class RestfulStatement extends AbstractStatement {
return this.affectedRows;
}
@Override
public void addBatch(String sql) throws SQLException {
if (isClosed())
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
//TODO:
}
@Override
public void clearBatch() throws SQLException {
//TODO:
}
@Override
public int[] executeBatch() throws SQLException {
//TODO:
return new int[0];
}
@Override
public Connection getConnection() throws SQLException {
if (isClosed())
......
src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/util/HttpClientPoolUtil.java → src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/HttpClientPoolUtil.java
浏览文件 @ 24b5da8b
package com.taosdata.jdbc.rs.util;
package com.taosdata.jdbc.utils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HeaderElement;
import org.apache.http.HeaderElementIterator;
import org.apache.http.HttpEntity;
......@@ -39,7 +38,7 @@ public class HttpClientPoolUtil {
/**
* 初始化连接池
*/
public static synchronized void initPools() {
private static synchronized void initPools() {
if (httpClient == null) {
cm = new PoolingHttpClientConnectionManager();
cm.setDefaultMaxPerRoute(count);
......@@ -51,7 +50,7 @@ public class HttpClientPoolUtil {
/**
* Http connection keepAlive 设置
*/
public static ConnectionKeepAliveStrategy defaultStrategy = (response, context) -> {
private static ConnectionKeepAliveStrategy defaultStrategy = (response, context) -> {
HeaderElementIterator it = new BasicHeaderElementIterator(response.headerIterator(HTTP.CONN_KEEP_ALIVE));
int keepTime = Http_Default_Keep_Time * 1000;
while (it.hasNext()) {
......@@ -69,14 +68,6 @@ public class HttpClientPoolUtil {
return keepTime;
};
public static CloseableHttpClient getHttpClient() {
return httpClient;
}
public static PoolingHttpClientConnectionManager getHttpConnectionManager() {
return cm;
}
/**
* 执行http post请求
* 默认采用Content-Type：application/json，Accept：application/json
......@@ -95,8 +86,10 @@ public class HttpClientPoolUtil {
initPools();
}
method = (HttpEntityEnclosingRequestBase) getRequest(uri, HttpPost.METHOD_NAME, DEFAULT_CONTENT_TYPE, 0);
method.setHeader("Authorization", "Taosd " + token);
method.setHeader("Content-Type", "text/plain");
method.setHeader("Connection", "keep-alive");
method.setHeader("Authorization", "Taosd " + token);
method.setEntity(new StringEntity(data, Charset.forName("UTF-8")));
HttpContext context = HttpClientContext.create();
CloseableHttpResponse httpResponse = httpClient.execute(method, context);
......@@ -131,7 +124,7 @@ public class HttpClientPoolUtil {
* @return HttpRequestBase 返回类型
* @author lisc
*/
public static HttpRequestBase getRequest(String uri, String methodName, String contentType, int timeout) {
private static HttpRequestBase getRequest(String uri, String methodName, String contentType, int timeout) {
if (httpClient == null) {
initPools();
}
......@@ -152,7 +145,7 @@ public class HttpClientPoolUtil {
method = new HttpPost(uri);
}
if (StringUtils.isBlank(contentType)) {
if (contentType == null || contentType.isEmpty() || contentType.replaceAll("\\s", "").isEmpty()) {
contentType = DEFAULT_CONTENT_TYPE;
}
method.addHeader("Content-Type", contentType);
......
src/connector/jdbc/src/test/java/com/taosdata/jdbc/PreparedStatementTest.java 已删除 100644 → 0
浏览文件 @ 88bf50f1
package com.taosdata.jdbc;
import org.junit.*;
import org.junit.runners.MethodSorters;
import java.sql.*;
import java.util.Properties;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@FixMethodOrder(value = MethodSorters.NAME_ASCENDING)
public class PreparedStatementTest {
static Connection connection;
static TSDBPreparedStatement statement;
static String dbName = "test";
static String tName = "t0";
static String host = "localhost";
@BeforeClass
public static void createConnection() throws SQLException {
try {
Class.forName("com.taosdata.jdbc.TSDBDriver");
} catch (ClassNotFoundException e) {
return;
}
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("jdbc:TAOS://" + host + ":0/", properties);
String sql = "drop database if exists " + dbName;
statement = (TSDBPreparedStatement) connection.prepareStatement(sql);
}
@Test
public void case001_createTableAndQuery() throws SQLException {
long ts = System.currentTimeMillis();
statement.executeUpdate("create database if not exists " + dbName);
statement.executeUpdate("create table if not exists " + dbName + "." + tName + "(ts timestamp, k1 int)");
statement.executeUpdate("insert into " + dbName + "." + tName + " values (" + ts + ", 1)");
PreparedStatement selectStatement = connection.prepareStatement("select * from " + dbName + "." + tName);
ResultSet resultSet = selectStatement.executeQuery();
assertTrue(null != resultSet);
boolean isClosed = statement.isClosed();
assertEquals(false, isClosed);
selectStatement.close();
}
@Test
public void case002_testPreparedStatement() throws SQLException {
long ts = System.currentTimeMillis() + 20000;
PreparedStatement saveStatement = connection.prepareStatement("insert into " + dbName + "." + tName + " values (" + ts + ", 1)");
int affectedRows = saveStatement.executeUpdate();
assertTrue(1 == affectedRows);
saveStatement.close();
}
@Test
public void case003_testSavedPreparedStatement() throws SQLException {
long ts = System.currentTimeMillis();
TSDBPreparedStatement saveStatement = (TSDBPreparedStatement) connection.prepareStatement("insert into " + dbName + "." + tName + " values (?, ?)");
saveStatement.setObject(1, ts + 10000);
saveStatement.setObject(2, 3);
int rows = saveStatement.executeUpdate();
assertEquals(1, rows);
saveStatement.close();
}
@Test
public void case004_testUnsupport() throws SQLException {
Assert.assertNotNull(statement.unwrap(TSDBPreparedStatement.class));
Assert.assertTrue(statement.isWrapperFor(TSDBPreparedStatement.class));
try {
statement.getMaxFieldSize();
} catch (SQLException e) {
}
try {
statement.setMaxFieldSize(0);
} catch (SQLException e) {
}
try {
statement.setEscapeProcessing(true);
} catch (SQLException e) {
}
try {
statement.cancel();
} catch (SQLException e) {
}
try {
statement.getWarnings();
} catch (SQLException e) {
}
try {
statement.clearWarnings();
} catch (SQLException e) {
}
try {
statement.setCursorName(null);
} catch (SQLException e) {
}
try {
statement.getMoreResults();
} catch (SQLException e) {
}
try {
statement.setFetchDirection(0);
} catch (SQLException e) {
}
try {
statement.getFetchDirection();
} catch (SQLException e) {
}
try {
statement.getResultSetConcurrency();
} catch (SQLException e) {
}
try {
statement.getResultSetType();
} catch (SQLException e) {
}
try {
statement.getConnection();
} catch (SQLException e) {
}
try {
statement.getMoreResults();
} catch (SQLException e) {
}
try {
statement.getGeneratedKeys();
} catch (SQLException e) {
}
try {
statement.executeUpdate(null, 0);
} catch (SQLException e) {
}
try {
statement.executeUpdate(null, new int[]{0});
} catch (SQLException e) {
}
try {
statement.executeUpdate(null, new String[]{"str1", "str2"});
} catch (SQLException e) {
}
try {
statement.getResultSetHoldability();
} catch (SQLException e) {
}
try {
statement.setPoolable(true);
} catch (SQLException e) {
}
try {
statement.isPoolable();
} catch (SQLException e) {
}
try {
statement.closeOnCompletion();
} catch (SQLException e) {
}
try {
statement.isCloseOnCompletion();
} catch (SQLException e) {
}
}
@AfterClass
public static void close() throws Exception {
statement.executeUpdate("drop database " + dbName);
statement.close();
connection.close();
Thread.sleep(10);
}
}
src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBPreparedStatementTest.java
浏览文件 @ 24b5da8b
package com.taosdata.jdbc;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.*;
public class TSDBPreparedStatementTest {
private static final String host = "127.0.0.1";
private static Connection conn;
private static final String sql_insert = "insert into t1 values(?, ?)";
private static PreparedStatement pstmt_insert;
private static final String sql_select = "select * from t1 where ts > ? and ts <= ? and temperature >= ?";
private static PreparedStatement pstmt_select;
@Test
public void executeQuery() {
public void executeQuery() throws SQLException {
long end = System.currentTimeMillis();
long start = end - 1000 * 60 * 60;
pstmt_select.setTimestamp(1, new Timestamp(start));
pstmt_select.setTimestamp(2, new Timestamp(end));
pstmt_select.setFloat(3, 0);
ResultSet rs = pstmt_select.executeQuery();
Assert.assertNotNull(rs);
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();
}
}
@Test
public void executeUpdate() {
public void executeUpdate() throws SQLException {
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
pstmt_insert.setFloat(2, 3.14f);
int result = pstmt_insert.executeUpdate();
Assert.assertEquals(1, result);
}
@Test
public void setNull() {
public void setNull() throws SQLException {
pstmt_insert.setNull(2, Types.FLOAT);
}
@Test
public void setBoolean() {
public void setBoolean() throws SQLException {
pstmt_insert.setBoolean(2, true);
}
@Test
public void setByte() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setByte() throws SQLException {
pstmt_insert.setByte(1, (byte) 0x001);
}
@Test
public void setShort() {
}
@Test
public void setInt() {
}
@Test
public void setLong() {
}
@Test
public void setFloat() {
}
@Test
public void setDouble() {
}
@Test
public void setBigDecimal() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setBigDecimal() throws SQLException {
pstmt_insert.setBigDecimal(1, null);
}
@Test
public void setString() {
}
@Test
public void setBytes() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setBytes() throws SQLException {
pstmt_insert.setBytes(1, new byte[]{});
}
@Test
public void setDate() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setDate() throws SQLException {
pstmt_insert.setDate(1, new Date(System.currentTimeMillis()));
}
@Test
public void setTime() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setTime() throws SQLException {
pstmt_insert.setTime(1, new Time(System.currentTimeMillis()));
}
@Test
public void setTimestamp() {
//TODO
}
@Test
public void setAsciiStream() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setAsciiStream() throws SQLException {
pstmt_insert.setAsciiStream(1, null);
}
@Test
public void setUnicodeStream() {
}
@Test
public void setBinaryStream() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setBinaryStream() throws SQLException {
pstmt_insert.setBinaryStream(1, null);
}
@Test
public void clearParameters() {
//TODO
}
@Test
public void setObject() {
public void setObject() throws SQLException {
pstmt_insert.setObject(1, System.currentTimeMillis());
//TODO
}
@Test
public void execute() {
//TODO
}
@Test
public void addBatch() {
//TODO:
}
@Test
public void setCharacterStream() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setCharacterStream() throws SQLException {
pstmt_insert.setCharacterStream(1, null);
}
@Test
public void setRef() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setRef() throws SQLException {
pstmt_insert.setRef(1, null);
}
@Test
public void setBlob() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setBlob() throws SQLException {
pstmt_insert.setBlob(1, (Blob) null);
}
@Test
public void setClob() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setClob() throws SQLException {
pstmt_insert.setClob(1, (Clob) null);
}
@Test
public void setArray() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setArray() throws SQLException {
pstmt_insert.setArray(1, null);
}
@Test
public void getMetaData() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void getMetaData() throws SQLException {
pstmt_insert.getMetaData();
}
@Test
public void setURL() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setURL() throws SQLException {
pstmt_insert.setURL(1, null);
}
@Test
public void getParameterMetaData() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void getParameterMetaData() throws SQLException {
ParameterMetaData parameterMetaData = pstmt_insert.getParameterMetaData();
// Assert.assertNotNull(parameterMetaData);
//TODO:
}
@Test
public void setRowId() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setRowId() throws SQLException {
pstmt_insert.setRowId(1, null);
}
@Test
public void setNString() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setNString() throws SQLException {
pstmt_insert.setNString(1, null);
}
@Test
public void setNCharacterStream() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setNCharacterStream() throws SQLException {
pstmt_insert.setNCharacterStream(1, null);
}
@Test
public void setNClob() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setNClob() throws SQLException {
pstmt_insert.setNClob(1, (NClob) null);
}
@Test
public void setSQLXML() {
@Test(expected = SQLFeatureNotSupportedException.class)
public void setSQLXML() throws SQLException {
pstmt_insert.setSQLXML(1, null);
}
@BeforeClass
public static void beforeClass() {
try {
Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
Class.forName("com.taosdata.jdbc.TSDBDriver");
conn = DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata");
try (Statement stmt = conn.createStatement()) {
stmt.execute("drop database if exists test_pstmt");
stmt.execute("create database if not exists test_pstmt");
stmt.execute("use test_pstmt");
stmt.execute("create table weather(ts timestamp, temperature float) tags(loc nchar(64))");
stmt.execute("create table t1 using weather tags('beijing')");
}
pstmt_insert = conn.prepareStatement(sql_insert);
pstmt_select = conn.prepareStatement(sql_select);
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
......@@ -176,6 +231,7 @@ public class TSDBPreparedStatementTest {
@AfterClass
public static void afterClass() {
try {
if (conn != null)
conn.close();
} catch (SQLException e) {
......
src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBStatementTest.java
浏览文件 @ 24b5da8b
......@@ -51,6 +51,68 @@ public class TSDBStatementTest {
@Test
public void close() {
// test in AfterClass method
}
@Test
public void getMaxFieldSize() throws SQLException {
Assert.assertEquals(16 * 1024, stmt.getMaxFieldSize());
}
@Test(expected = SQLException.class)
public void setMaxFieldSize() throws SQLException {
stmt.setMaxFieldSize(0);
stmt.setMaxFieldSize(-1);
}
@Test
public void getMaxRows() throws SQLException {
Assert.assertEquals(0, stmt.getMaxRows());
}
@Test(expected = SQLException.class)
public void setMaxRows() throws SQLException {
stmt.setMaxRows(0);
stmt.setMaxRows(-1);
}
@Test
public void setEscapeProcessing() throws SQLException {
stmt.setEscapeProcessing(true);
stmt.setEscapeProcessing(false);
}
@Test
public void getQueryTimeout() throws SQLException {
Assert.assertEquals(0, stmt.getQueryTimeout());
}
@Test(expected = SQLException.class)
public void setQueryTimeout() throws SQLException {
stmt.setQueryTimeout(0);
stmt.setQueryTimeout(-1);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void cancel() throws SQLException {
stmt.cancel();
}
@Test
public void getWarnings() throws SQLException {
Assert.assertNull(stmt.getWarnings());
}
@Test
public void clearWarnings() throws SQLException {
stmt.clearWarnings();
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setCursorName() throws SQLException {
stmt.setCursorName("");
}
@Test
......@@ -130,7 +192,48 @@ public class TSDBStatementTest {
@Test
public void getUpdateCount() {
execute();
// already test in execute method
}
@Test
public void getMoreResults() throws SQLException {
Assert.assertEquals(false, stmt.getMoreResults());
}
@Test(expected = SQLException.class)
public void setFetchDirection() throws SQLException {
stmt.setFetchDirection(ResultSet.FETCH_FORWARD);
stmt.setFetchDirection(ResultSet.FETCH_REVERSE);
stmt.setFetchDirection(ResultSet.FETCH_UNKNOWN);
stmt.setFetchDirection(-1);
}
@Test
public void getFetchDirection() throws SQLException {
Assert.assertEquals(ResultSet.FETCH_FORWARD, stmt.getFetchDirection());
}
@Test(expected = SQLException.class)
public void setFetchSize() throws SQLException {
stmt.setFetchSize(0);
stmt.setFetchSize(-1);
}
@Test
public void getFetchSize() throws SQLException {
stmt.setFetchSize(0);
Assert.assertEquals(0, stmt.getFetchSize());
stmt.setFetchSize(0);
}
@Test
public void getResultSetConcurrency() throws SQLException {
Assert.assertEquals(ResultSet.CONCUR_READ_ONLY, stmt.getResultSetConcurrency());
}
@Test
public void getResultSetType() throws SQLException {
Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, stmt.getResultSetType());
}
@Test
......@@ -194,6 +297,52 @@ public class TSDBStatementTest {
}
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testGetMoreResults() throws SQLException {
Assert.assertEquals(false, stmt.getMoreResults(Statement.CLOSE_CURRENT_RESULT));
stmt.getMoreResults(Statement.KEEP_CURRENT_RESULT);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void getGeneratedKeys() throws SQLException {
stmt.getGeneratedKeys();
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecuteUpdate() throws SQLException {
stmt.executeUpdate("", 1);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecuteUpdate1() throws SQLException {
stmt.executeUpdate("", new int[]{});
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecuteUpdate2() throws SQLException {
stmt.executeUpdate("", new String[]{});
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecute() throws SQLException {
stmt.execute("", 1);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecute1() throws SQLException {
stmt.execute("", new int[]{});
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecute2() throws SQLException {
stmt.execute("", new String[]{});
}
@Test
public void getResultSetHoldability() throws SQLException {
Assert.assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, stmt.getResultSetHoldability());
}
@Test
public void isClosed() {
try {
......@@ -203,6 +352,38 @@ public class TSDBStatementTest {
}
}
@Test
public void setPoolable() throws SQLException {
stmt.setPoolable(true);
stmt.setPoolable(false);
}
@Test
public void isPoolable() throws SQLException {
Assert.assertEquals(false, stmt.isPoolable());
}
@Test
public void closeOnCompletion() throws SQLException {
stmt.closeOnCompletion();
}
@Test
public void isCloseOnCompletion() throws SQLException {
Assert.assertFalse(stmt.isCloseOnCompletion());
}
@Test
public void unwrap() throws SQLException {
TSDBStatement unwrap = stmt.unwrap(TSDBStatement.class);
Assert.assertNotNull(unwrap);
}
@Test
public void isWrapperFor() throws SQLException {
Assert.assertTrue(stmt.isWrapperFor(TSDBStatement.class));
}
@BeforeClass
public static void beforeClass() {
try {
......
src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ConnectWrongDatabaseTest.java
浏览文件 @ 24b5da8b
package com.taosdata.jdbc.cases;
import com.taosdata.jdbc.TSDBErrorNumbers;
import org.junit.Assert;
import org.junit.Test;
......@@ -16,8 +17,7 @@ public class ConnectWrongDatabaseTest {
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
System.out.println(e.getMessage());
Assert.assertEquals("TDengine Error: Invalid database name", e.getMessage());
Assert.assertEquals(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL, e.getErrorCode());
}
}
......
src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/ImportTest.java
浏览文件 @ 24b5da8b
......@@ -12,7 +12,7 @@ import static org.junit.Assert.assertEquals;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class ImportTest {
private static Connection connection;
static String dbName = "test";
static String dbName = "test_import";
static String tName = "t0";
static String host = "127.0.0.1";
private static long ts;
......
src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/AuthenticationTest.java
浏览文件 @ 24b5da8b
......@@ -10,7 +10,7 @@ public class AuthenticationTest {
private static final String host = "127.0.0.1";
// private static final String host = "master";
private static final String user = "root";
private static final String password = "123456";
private static final String password = "taos?data";
private Connection conn;
@Test
......
src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulConnectionTest.java
浏览文件 @ 24b5da8b
package com.taosdata.jdbc.rs;
import com.taosdata.jdbc.TSDBConnection;
import com.taosdata.jdbc.TSDBDriver;
import com.taosdata.jdbc.TSDBResultSet;
import com.taosdata.jdbc.TSDBSubscribe;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import javax.management.OperationsException;
import java.sql.*;
import java.util.Properties;
......@@ -17,6 +13,7 @@ public class RestfulConnectionTest {
private static final String host = "127.0.0.1";
// private static final String host = "master";
private static Connection conn;
@Test
......
src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulPreparedStatementTest.java 0 → 100644
浏览文件 @ 24b5da8b
package com.taosdata.jdbc.rs;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import java.sql.*;
public class RestfulPreparedStatementTest {
private static final String host = "127.0.0.1";
// private static final String host = "master";
private static Connection conn;
private static final String sql_insert = "insert into t1 values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
private static PreparedStatement pstmt_insert;
private static final String sql_select = "select * from t1 where ts > ? and ts <= ? and f1 >= ?";
private static PreparedStatement pstmt_select;
@Test
public void executeQuery() throws SQLException {
long end = System.currentTimeMillis();
long start = end - 1000 * 60 * 60;
pstmt_select.setTimestamp(1, new Timestamp(start));
pstmt_select.setTimestamp(2, new Timestamp(end));
pstmt_select.setInt(3, 0);
ResultSet rs = pstmt_select.executeQuery();
Assert.assertNotNull(rs);
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();
}
}
@Test
public void executeUpdate() throws SQLException {
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
pstmt_insert.setFloat(2, 3.14f);
int result = pstmt_insert.executeUpdate();
Assert.assertEquals(1, result);
}
@Test
public void setNull() throws SQLException {
pstmt_insert.setNull(2, Types.FLOAT);
}
@Test
public void setBoolean() throws SQLException {
pstmt_insert.setBoolean(2, true);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setByte() throws SQLException {
pstmt_insert.setByte(1, (byte) 0x001);
}
@Test
public void setShort() {
}
@Test
public void setInt() {
}
@Test
public void setLong() {
}
@Test
public void setFloat() {
}
@Test
public void setDouble() {
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setBigDecimal() throws SQLException {
pstmt_insert.setBigDecimal(1, null);
}
@Test
public void setString() {
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setBytes() throws SQLException {
pstmt_insert.setBytes(1, new byte[]{});
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setDate() throws SQLException {
pstmt_insert.setDate(1, new Date(System.currentTimeMillis()));
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setTime() throws SQLException {
pstmt_insert.setTime(1, new Time(System.currentTimeMillis()));
}
@Test
public void setTimestamp() {
//TODO
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setAsciiStream() throws SQLException {
pstmt_insert.setAsciiStream(1, null);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setBinaryStream() throws SQLException {
pstmt_insert.setBinaryStream(1, null);
}
@Test
public void clearParameters() {
//TODO
}
@Test
public void setObject() throws SQLException {
pstmt_insert.setObject(1, System.currentTimeMillis());
//TODO
}
@Test
public void execute() {
//TODO
}
@Test
public void addBatch() {
//TODO:
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setCharacterStream() throws SQLException {
pstmt_insert.setCharacterStream(1, null);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setRef() throws SQLException {
pstmt_insert.setRef(1, null);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setBlob() throws SQLException {
pstmt_insert.setBlob(1, (Blob) null);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setClob() throws SQLException {
pstmt_insert.setClob(1, (Clob) null);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setArray() throws SQLException {
pstmt_insert.setArray(1, null);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void getMetaData() throws SQLException {
pstmt_insert.getMetaData();
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setURL() throws SQLException {
pstmt_insert.setURL(1, null);
}
@Test
public void getParameterMetaData() throws SQLException {
ParameterMetaData parameterMetaData = pstmt_insert.getParameterMetaData();
Assert.assertNull(parameterMetaData);
//TODO:
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setRowId() throws SQLException {
pstmt_insert.setRowId(1, null);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setNString() throws SQLException {
pstmt_insert.setNString(1, null);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setNCharacterStream() throws SQLException {
pstmt_insert.setNCharacterStream(1, null);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setNClob() throws SQLException {
pstmt_insert.setNClob(1, (NClob) null);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setSQLXML() throws SQLException {
pstmt_insert.setSQLXML(1, null);
}
@BeforeClass
public static void beforeClass() {
try {
Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata");
try (Statement stmt = conn.createStatement()) {
stmt.execute("drop database if exists test_pstmt");
stmt.execute("create database if not exists test_pstmt");
stmt.execute("use test_pstmt");
stmt.execute("create table weather(ts timestamp, f1 int, f2 bigint, f3 float, f4 double, f5 smallint, f6 tinyint, f7 bool, f8 binary(64), f9 nchar(64)) tags(loc nchar(64))");
stmt.execute("create table t1 using weather tags('beijing')");
}
pstmt_insert = conn.prepareStatement(sql_insert);
pstmt_select = conn.prepareStatement(sql_select);
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
@AfterClass
public static void afterClass() {
try {
if (pstmt_insert != null)
pstmt_insert.close();
if (pstmt_select != null)
pstmt_select.close();
if (conn != null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
\ No newline at end of file
src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulStatementTest.java 0 → 100644
浏览文件 @ 24b5da8b
package com.taosdata.jdbc.rs;
import com.taosdata.jdbc.TSDBDriver;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import java.sql.*;
import java.util.Properties;
import java.util.UUID;
public class RestfulStatementTest {
// private static final String host = "127.0.0.1";
private static final String host = "master";
private static Connection conn;
private static Statement stmt;
@Test
public void executeQuery() {
try {
ResultSet rs = stmt.executeQuery("show databases");
Assert.assertNotNull(rs);
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();
}
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
@Test
public void executeUpdate() {
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();
}
}
@Test
public void close() {
// test in AfterClass method
}
@Test
public void getMaxFieldSize() throws SQLException {
Assert.assertEquals(16 * 1024, stmt.getMaxFieldSize());
}
@Test(expected = SQLException.class)
public void setMaxFieldSize() throws SQLException {
stmt.setMaxFieldSize(0);
stmt.setMaxFieldSize(-1);
}
@Test
public void getMaxRows() throws SQLException {
Assert.assertEquals(0, stmt.getMaxRows());
}
@Test(expected = SQLException.class)
public void setMaxRows() throws SQLException {
stmt.setMaxRows(0);
stmt.setMaxRows(-1);
}
@Test
public void setEscapeProcessing() throws SQLException {
stmt.setEscapeProcessing(true);
stmt.setEscapeProcessing(false);
}
@Test
public void getQueryTimeout() throws SQLException {
Assert.assertEquals(0, stmt.getQueryTimeout());
}
@Test(expected = SQLException.class)
public void setQueryTimeout() throws SQLException {
stmt.setQueryTimeout(0);
stmt.setQueryTimeout(-1);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void cancel() throws SQLException {
stmt.cancel();
}
@Test
public void getWarnings() throws SQLException {
Assert.assertNull(stmt.getWarnings());
}
@Test
public void clearWarnings() throws SQLException {
stmt.clearWarnings();
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void setCursorName() throws SQLException {
stmt.setCursorName("");
}
@Test
public void execute() {
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();
}
}
@Test
public void getResultSet() {
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()) {
for (int i = 1; i <= meta.getColumnCount(); i++) {
System.out.print(meta.getColumnLabel(i) + ": " + rs.getString(i) + "\t");
}
System.out.println();
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();
}
}
@Test
public void getUpdateCount() {
// already test in execute method
}
@Test
public void getMoreResults() throws SQLException {
Assert.assertEquals(false, stmt.getMoreResults());
}
@Test(expected = SQLException.class)
public void setFetchDirection() throws SQLException {
stmt.setFetchDirection(ResultSet.FETCH_FORWARD);
stmt.setFetchDirection(ResultSet.FETCH_REVERSE);
stmt.setFetchDirection(ResultSet.FETCH_UNKNOWN);
stmt.setFetchDirection(-1);
}
@Test
public void getFetchDirection() throws SQLException {
Assert.assertEquals(ResultSet.FETCH_FORWARD, stmt.getFetchDirection());
}
@Test(expected = SQLException.class)
public void setFetchSize() throws SQLException {
stmt.setFetchSize(0);
stmt.setFetchSize(-1);
}
@Test
public void getFetchSize() throws SQLException {
stmt.setFetchSize(0);
Assert.assertEquals(0, stmt.getFetchSize());
stmt.setFetchSize(0);
}
@Test
public void getResultSetConcurrency() throws SQLException {
Assert.assertEquals(ResultSet.CONCUR_READ_ONLY, stmt.getResultSetConcurrency());
}
@Test
public void getResultSetType() throws SQLException {
Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, stmt.getResultSetType());
}
@Test
public void addBatch() {
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();
}
}
@Test
public void clearBatch() {
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();
}
}
@Test
public void executeBatch() {
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();
}
}
@Test
public void getConnection() {
try {
Connection connection = stmt.getConnection();
Assert.assertNotNull(connection);
Assert.assertTrue(this.conn == connection);
} catch (SQLException e) {
e.printStackTrace();
}
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testGetMoreResults() throws SQLException {
Assert.assertEquals(false, stmt.getMoreResults(Statement.CLOSE_CURRENT_RESULT));
stmt.getMoreResults(Statement.KEEP_CURRENT_RESULT);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void getGeneratedKeys() throws SQLException {
stmt.getGeneratedKeys();
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecuteUpdate() throws SQLException {
stmt.executeUpdate("", 1);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecuteUpdate1() throws SQLException {
stmt.executeUpdate("", new int[]{});
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecuteUpdate2() throws SQLException {
stmt.executeUpdate("", new String[]{});
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecute() throws SQLException {
stmt.execute("", 1);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecute1() throws SQLException {
stmt.execute("", new int[]{});
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void testExecute2() throws SQLException {
stmt.execute("", new String[]{});
}
@Test
public void getResultSetHoldability() throws SQLException {
Assert.assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, stmt.getResultSetHoldability());
}
@Test
public void isClosed() {
try {
Assert.assertEquals(false, stmt.isClosed());
} catch (SQLException e) {
e.printStackTrace();
}
}
@Test
public void setPoolable() throws SQLException {
stmt.setPoolable(true);
stmt.setPoolable(false);
}
@Test
public void isPoolable() throws SQLException {
Assert.assertEquals(false, stmt.isPoolable());
}
@Test
public void closeOnCompletion() throws SQLException {
stmt.closeOnCompletion();
}
@Test
public void isCloseOnCompletion() throws SQLException {
Assert.assertFalse(stmt.isCloseOnCompletion());
}
@Test
public void unwrap() throws SQLException {
RestfulStatement unwrap = stmt.unwrap(RestfulStatement.class);
Assert.assertNotNull(unwrap);
}
@Test
public void isWrapperFor() throws SQLException {
Assert.assertTrue(stmt.isWrapperFor(RestfulStatement.class));
}
@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/?user=root&password=taosdata", properties);
stmt = conn.createStatement();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
@AfterClass
public static void afterClass() {
try {
if (stmt != null)
stmt.close();
if (conn != null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
src/dnode/src/dnodeMWrite.c
浏览文件 @ 24b5da8b
......@@ -145,6 +145,14 @@ void dnodeSendRpcMWriteRsp(void *pMsg, int32_t code) {
return;
}
dTrace("msg:%p, app:%p type:%s master:%p will be responsed", pWrite, pWrite->rpcMsg.ahandle,
taosMsg[pWrite->rpcMsg.msgType], pWrite->pBatchMasterMsg);
if (pWrite->pBatchMasterMsg && pWrite != pWrite->pBatchMasterMsg) {
dError("msg:%p, app:%p type:%s master:%p sub message should not response!", pWrite, pWrite->rpcMsg.ahandle,
taosMsg[pWrite->rpcMsg.msgType], pWrite->pBatchMasterMsg);
return;
}
SRpcMsg rpcRsp = {
.handle = pWrite->rpcMsg.handle,
.pCont = pWrite->rpcRsp.rsp,
......
src/inc/ttype.h
浏览文件 @ 24b5da8b
......@@ -27,7 +27,7 @@ typedef struct tstr {
#define IS_VAR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_BINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
// this data type is internally used only in 'in' query to hold the values
#define TSDB_DATA_TYPE_ARRAY (TSDB_DATA_TYPE_NCHAR + 1)
#define TSDB_DATA_TYPE_ARRAY (1000)
#define GET_TYPED_DATA(_v, _finalType, _type, _data) \
do { \
......
src/kit/shell/inc/shell.h
浏览文件 @ 24b5da8b
......@@ -30,6 +30,8 @@
#define MAX_COMMAND_SIZE 65536
#define HISTORY_FILE ".taos_history"
#define DEFAULT_RES_SHOW_NUM 100
typedef struct SShellHistory {
char* hist[MAX_HISTORY_SIZE];
int hstart;
......
src/kit/shell/src/shellEngine.c
浏览文件 @ 24b5da8b
......@@ -325,6 +325,7 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
if (!tscIsUpdateQuery(pSql)) { // select and show kinds of commands
int error_no = 0;
int numOfRows = shellDumpResult(pSql, fname, &error_no, printMode);
if (numOfRows < 0) {
atomic_store_64(&result, 0);
......@@ -659,6 +660,17 @@ static void printField(const char* val, TAOS_FIELD* field, int width, int32_t le
}
bool isSelectQuery(TAOS_RES* tres) {
char *sql = tscGetSqlStr(tres);
if (regex_match(sql, "^[\t ]*select[ \t]*", REG_EXTENDED | REG_ICASE)) {
return true;
}
return false;
}
static int verticalPrintResult(TAOS_RES* tres) {
TAOS_ROW row = taos_fetch_row(tres);
if (row == NULL) {
......@@ -677,10 +689,20 @@ static int verticalPrintResult(TAOS_RES* tres) {
}
}
uint64_t resShowMaxNum = UINT64_MAX;
if (args.commands == NULL && args.file[0] == 0 && isSelectQuery(tres) && !tscIsQueryWithLimit(tres)) {
resShowMaxNum = DEFAULT_RES_SHOW_NUM;
}
int numOfRows = 0;
int showMore = 1;
do {
if (numOfRows < resShowMaxNum) {
printf("*************************** %d.row ***************************\n", numOfRows + 1);
int32_t* length = taos_fetch_lengths(tres);
for (int i = 0; i < num_fields; i++) {
TAOS_FIELD* field = fields + i;
......@@ -690,6 +712,11 @@ static int verticalPrintResult(TAOS_RES* tres) {
printField((const char*)row[i], field, 0, length[i], precision);
putchar('\n');
}
} else if (showMore) {
printf("[100 Rows showed, and more rows are fetching but will not be showed. You can ctrl+c to stop or wait.]\n");
printf("[You can add limit statement to get more or redirect results to specific file to get all.]\n");
showMore = 0;
}
numOfRows++;
row = taos_fetch_row(tres);
......@@ -795,9 +822,18 @@ static int horizontalPrintResult(TAOS_RES* tres) {
printHeader(fields, width, num_fields);
uint64_t resShowMaxNum = UINT64_MAX;
if (args.commands == NULL && args.file[0] == 0 && isSelectQuery(tres) && !tscIsQueryWithLimit(tres)) {
resShowMaxNum = DEFAULT_RES_SHOW_NUM;
}
int numOfRows = 0;
int showMore = 1;
do {
int32_t* length = taos_fetch_lengths(tres);
if (numOfRows < resShowMaxNum) {
for (int i = 0; i < num_fields; i++) {
putchar(' ');
printField((const char*)row[i], fields + i, width[i], length[i], precision);
......@@ -805,6 +841,12 @@ static int horizontalPrintResult(TAOS_RES* tres) {
putchar('|');
}
putchar('\n');
} else if (showMore) {
printf("[100 Rows showed, and more rows are fetching but will not be showed. You can ctrl+c to stop or wait.]\n");
printf("[You can add limit statement to show more or redirect results to specific file to get all.]\n");
showMore = 0;
}
numOfRows++;
row = taos_fetch_row(tres);
} while(row != NULL);
......
src/kit/taosdemo/taosdemo.c
浏览文件 @ 24b5da8b
此差异已折叠。
src/kit/taosdump/taosdump.c
浏览文件 @ 24b5da8b
......@@ -793,6 +793,7 @@ int32_t taosSaveTableOfMetricToTempFile(TAOS *taosCon, char* metric, struct argu
*totalNumOfThread = numOfThread;
free(tblBuf);
return 0;
}
......@@ -1553,6 +1554,7 @@ int taosDumpDb(SDbInfo *dbInfo, struct arguments *arguments, FILE *fp, TAOS *tao
(void)remove(tmpBuf);
}
free(tblBuf);
return 0;
}
......
src/mnode/src/mnodeTable.c
浏览文件 @ 24b5da8b
......@@ -777,11 +777,11 @@ static int32_t mnodeValidateCreateTableMsg(SCreateTableMsg *pCreateTable, SMnode
}
if (pCreateTable->numOfTags != 0) {
mDebug("msg:%p, app:%p table:%s, create stable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
mDebug("msg:%p, app:%p table:%s, batch create stable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
pCreateTable->tableName, pMsg->rpcMsg.handle);
return mnodeProcessCreateSuperTableMsg(pMsg);
} else {
mDebug("msg:%p, app:%p table:%s, create ctable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
mDebug("msg:%p, app:%p table:%s, batch create ctable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
pCreateTable->tableName, pMsg->rpcMsg.handle);
return mnodeProcessCreateChildTableMsg(pMsg);
}
......@@ -1904,6 +1904,19 @@ static int32_t mnodeDoCreateChildTableCb(SMnodeMsg *pMsg, int32_t code) {
pMsg->rpcMsg.ahandle, pTable->info.tableId, pTable->tid, pTable->uid, tstrerror(code));
SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pTable, .pTable = tsChildTableSdb};
sdbDeleteRow(&desc);
if (pMsg->pBatchMasterMsg) {
++pMsg->pBatchMasterMsg->successed;
if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received
>= pMsg->pBatchMasterMsg->expected) {
dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, code);
}
mnodeDestroySubMsg(pMsg);
return TSDB_CODE_MND_ACTION_IN_PROGRESS;
}
return code;
}
}
......
src/mnode/src/mnodeVgroup.c
浏览文件 @ 24b5da8b
......@@ -534,6 +534,19 @@ static int32_t mnodeCreateVgroupCb(SMnodeMsg *pMsg, int32_t code) {
tstrerror(code));
SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pVgroup, .pTable = tsVgroupSdb};
sdbDeleteRow(&desc);
if (pMsg->pBatchMasterMsg) {
++pMsg->pBatchMasterMsg->received;
if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received
>= pMsg->pBatchMasterMsg->expected) {
dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, pMsg->code);
}
mnodeDestroySubMsg(pMsg);
return TSDB_CODE_MND_ACTION_IN_PROGRESS;
}
return code;
} else {
mInfo("msg:%p, app:%p vgId:%d, is created in sdb, db:%s replica:%d", pMsg, pMsg->rpcMsg.ahandle, pVgroup->vgId,
......
src/os/src/darwin/darwinSemphone.c
浏览文件 @ 24b5da8b
......@@ -32,6 +32,7 @@
#include <mach/mach_error.h>
#include <mach/semaphore.h>
#include <mach/task.h>
#include <pthread.h>
static pthread_t sem_thread;
static pthread_once_t sem_once;
......@@ -288,7 +289,9 @@ bool taosCheckPthreadValid(pthread_t thread) {
}
int64_t taosGetSelfPthreadId() {
return (int64_t)pthread_self();
uint64_t id;
pthread_threadid_np(0, &id);
return (int64_t) id;
}
int64_t taosGetPthreadId(pthread_t thread) {
......
src/os/src/detail/osSemphone.c
浏览文件 @ 24b5da8b
......@@ -31,7 +31,14 @@ int tsem_wait(tsem_t* sem) {
#ifndef TAOS_OS_FUNC_SEMPHONE_PTHREAD
bool taosCheckPthreadValid(pthread_t thread) { return thread != 0; }
int64_t taosGetSelfPthreadId() { return (int64_t)pthread_self(); }
int64_t taosGetSelfPthreadId() {
static __thread int id = 0;
if (id != 0) return id;
id = syscall(SYS_gettid);
return id;
}
int64_t taosGetPthreadId(pthread_t thread) { return (int64_t)thread; }
void taosResetPthread(pthread_t *thread) { *thread = 0; }
bool taosComparePthread(pthread_t first, pthread_t second) { return first == second; }
......
src/os/src/windows/wSemphone.c
浏览文件 @ 24b5da8b
......@@ -20,6 +20,7 @@
#include "ttimer.h"
#include "tulog.h"
#include "tutil.h"
#include <windows.h>
bool taosCheckPthreadValid(pthread_t thread) { return thread.p != NULL; }
......@@ -33,7 +34,9 @@ int64_t taosGetPthreadId(pthread_t thread) {
#endif
}
int64_t taosGetSelfPthreadId() { return taosGetPthreadId(pthread_self()); }
int64_t taosGetSelfPthreadId() {
return GetCurrentThreadId();
}
bool taosComparePthread(pthread_t first, pthread_t second) {
return first.p == second.p;
......
src/query/src/qAggMain.c
浏览文件 @ 24b5da8b
此差异已折叠。
src/query/src/qExecutor.c
浏览文件 @ 24b5da8b
......@@ -4743,7 +4743,11 @@ static FORCE_INLINE void setEnvForEachBlock(SQInfo* pQInfo, STableQueryInfo* pTa
}
if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
if (!QUERY_IS_ASC_QUERY(pRuntimeEnv->pQuery)) {
setIntervalQueryRange(pQInfo, pBlockInfo->window.ekey);
} else {
setIntervalQueryRange(pQInfo, pBlockInfo->window.skey);
}
} else { // non-interval query
setExecutionContext(pQInfo, pTableQueryInfo->groupIndex, pBlockInfo->window.ekey + step);
}
......
src/query/src/qParserImpl.c
浏览文件 @ 24b5da8b
......@@ -413,7 +413,55 @@ void tSqlSetColumnInfo(TAOS_FIELD *pField, SStrToken *pName, TAOS_FIELD *pType)
} else {
pField->bytes = pType->bytes;
}
}
static int32_t tryParseNameTwoParts(SStrToken *type) {
int32_t t = -1;
char* str = strndup(type->z, type->n);
if (str == NULL) {
return t;
}
char* p = strtok(str, " ");
if (p == NULL) {
tfree(str);
return t;
} else {
char* unsign = strtok(NULL, " ");
if (unsign == NULL) {
tfree(str);
return t;
}
if (strncasecmp(unsign, "UNSIGNED", 8) == 0) {
for(int32_t j = TSDB_DATA_TYPE_TINYINT; j <= TSDB_DATA_TYPE_BIGINT; ++j) {
if (strcasecmp(p, tDataTypes[j].name) == 0) {
t = j;
break;
}
}
tfree(str);
if (t == -1) {
return -1;
}
switch(t) {
case TSDB_DATA_TYPE_TINYINT: return TSDB_DATA_TYPE_UTINYINT;
case TSDB_DATA_TYPE_SMALLINT: return TSDB_DATA_TYPE_USMALLINT;
case TSDB_DATA_TYPE_INT: return TSDB_DATA_TYPE_UINT;
case TSDB_DATA_TYPE_BIGINT: return TSDB_DATA_TYPE_UBIGINT;
default:
return -1;
}
} else {
tfree(str);
return -1;
}
}
}
void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
......@@ -431,9 +479,13 @@ void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
i += 1;
}
// no qualified data type found, try unsigned data type
if (i == tListLen(tDataTypes)) {
i = tryParseNameTwoParts(type);
if (i == -1) {
return;
}
}
pField->type = i;
pField->bytes = tDataTypes[i].bytes;
......
src/sync/src/syncRestore.c
浏览文件 @ 24b5da8b
......@@ -276,7 +276,8 @@ void *syncRestoreData(void *param) {
atomic_add_fetch_32(&tsSyncNum, 1);
sInfo("%s, start to restore data, sstatus:%s", pPeer->id, syncStatus[nodeSStatus]);
(*pNode->notifyRoleFp)(pNode->vgId, TAOS_SYNC_ROLE_SYNCING);
nodeRole = TAOS_SYNC_ROLE_SYNCING;
(*pNode->notifyRoleFp)(pNode->vgId, nodeRole);
if (syncOpenRecvBuffer(pNode) < 0) {
sError("%s, failed to allocate recv buffer, restart connection", pPeer->id);
......
src/util/src/tcompare.c
浏览文件 @ 24b5da8b
......@@ -297,32 +297,14 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
__compar_fn_t comparFn = NULL;
switch (type) {
case TSDB_DATA_TYPE_SMALLINT: {
comparFn = compareInt16Val; break;
}
case TSDB_DATA_TYPE_INT: {
comparFn = compareInt32Val; break;
}
case TSDB_DATA_TYPE_BIGINT:
case TSDB_DATA_TYPE_TIMESTAMP: {
comparFn = compareInt64Val; break;
}
case TSDB_DATA_TYPE_BOOL:
case TSDB_DATA_TYPE_TINYINT:{
comparFn = compareInt8Val; break;
}
case TSDB_DATA_TYPE_FLOAT: {
comparFn = compareFloatVal; break;
}
case TSDB_DATA_TYPE_DOUBLE: {
comparFn = compareDoubleVal; break;
}
case TSDB_DATA_TYPE_TINYINT: comparFn = compareInt8Val; break;
case TSDB_DATA_TYPE_SMALLINT: comparFn = compareInt16Val; break;
case TSDB_DATA_TYPE_INT: comparFn = compareInt32Val; break;
case TSDB_DATA_TYPE_BIGINT:
case TSDB_DATA_TYPE_TIMESTAMP: comparFn = compareInt64Val; break;
case TSDB_DATA_TYPE_FLOAT: comparFn = compareFloatVal; break;
case TSDB_DATA_TYPE_DOUBLE: comparFn = compareDoubleVal; break;
case TSDB_DATA_TYPE_BINARY: {
if (optr == TSDB_RELATION_LIKE) { /* wildcard query using like operator */
comparFn = compareStrPatternComp;
......@@ -341,10 +323,14 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
} else {
comparFn = compareLenPrefixedWStr;
}
break;
}
case TSDB_DATA_TYPE_UTINYINT: comparFn = compareUint8Val; break;
case TSDB_DATA_TYPE_USMALLINT: comparFn = compareUint16Val;break;
case TSDB_DATA_TYPE_UINT: comparFn = compareUint32Val;break;
case TSDB_DATA_TYPE_UBIGINT: comparFn = compareUint64Val;break;
default:
comparFn = compareInt32Val;
break;
......
src/util/src/tlog.c
浏览文件 @ 24b5da8b
此差异已折叠。
src/util/src/tnote.c
浏览文件 @ 24b5da8b
......@@ -248,7 +248,7 @@ void taosNotePrint(SNoteObj *pNote, const char *const format, ...) {
gettimeofday(&timeSecs, NULL);
curTime = timeSecs.tv_sec;
ptm = localtime_r(&curTime, &Tm);
len = sprintf(buffer, "%02d/%02d %02d:%02d:%02d.%06d 0x%08" PRIx64 " ", ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour,
len = sprintf(buffer, "%02d/%02d %02d:%02d:%02d.%06d %08" PRId64 " ", ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour,
ptm->tm_min, ptm->tm_sec, (int32_t)timeSecs.tv_usec, taosGetSelfPthreadId());
va_start(argpointer, format);
len += vsnprintf(buffer + len, MAX_NOTE_LINE_SIZE - len, format, argpointer);
......
tests/examples/JDBC/JDBCDemo/pom.xml
浏览文件 @ 24b5da8b
......@@ -13,7 +13,7 @@
<dependency>
<groupId>com.taosdata.jdbc</groupId>
<artifactId>taos-jdbcdriver</artifactId>
<version>2.0.18</version>
<version>2.0.20</version>
</dependency>
</dependencies>
......
tests/examples/JDBC/taosdemo/pom.xml
浏览文件 @ 24b5da8b
......@@ -67,7 +67,7 @@
<dependency>
<groupId>com.taosdata.jdbc</groupId>
<artifactId>taos-jdbcdriver</artifactId>
<version>2.0.19</version>
<version>2.0.20</version>
<!-- <scope>system</scope>-->
<!-- <systemPath>${project.basedir}/src/main/resources/lib/taos-jdbcdriver-2.0.15-dist.jar</systemPath>-->
</dependency>
......
tests/examples/JDBC/taosdemo/readme.md
浏览文件 @ 24b5da8b
```
cd tests/examples/JDBC/taosdemo
mvn clean package -Dmaven.test.skip=true
# 先建表，再插入的
java -jar target/taosdemo-2.0-jar-with-dependencies.jar -host [hostname] -database [database] -doCreateTable true -superTableSQL "create table weather(ts timestamp, f1 int) tags(t1 nchar(4))" -numOfTables 1000 -numOfRowsPerTable 100000000 -numOfThreadsForInsert 10 -numOfTablesPerSQL 10 -numOfValuesPerSQL 100
# 不建表，直接插入的
java -jar target/taosdemo-2.0-jar-with-dependencies.jar -host [hostname] -database [database] -doCreateTable false -superTableSQL "create table weather(ts timestamp, f1 int) tags(t1 nchar(4))" -numOfTables 1000 -numOfRowsPerTable 100000000 -numOfThreadsForInsert 10 -numOfTablesPerSQL 10 -numOfValuesPerSQL 100
```
需求：
1. 可以读lowa的配置文件
......
tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosDemoApplication.java
浏览文件 @ 24b5da8b
......@@ -35,7 +35,7 @@ public class TaosDemoApplication {
final DatabaseService databaseService = new DatabaseService(dataSource);
final SuperTableService superTableService = new SuperTableService(dataSource);
final SubTableService subTableService = new SubTableService(dataSource);
final QueryService queryService = new QueryService(dataSource);
// 创建数据库
long start = System.currentTimeMillis();
Map<String, String> databaseParam = new HashMap<>();
......
tests/examples/JDBC/taosdemo/src/main/resources/application.properties
浏览文件 @ 24b5da8b
jdbc.driver=com.taosdata.jdbc.rs.RestfulDriver
#jdbc.driver=com.taosdata.jdbc.TSDBDriver
hikari.maximum-pool-size=1
hikari.minimum-idle=1
hikari.maximum-pool-size=20
hikari.minimum-idle=20
hikari.max-lifetime=0
\ No newline at end of file
tests/pytest/fulltest.sh
浏览文件 @ 24b5da8b
......@@ -22,6 +22,7 @@ python3 ./test.py -f insert/insertIntoTwoTables.py
#python3 ./test.py -f insert/before_1970.py
python3 ./test.py -f insert/metadataUpdate.py
python3 bug2265.py
python3 ./test.py -f insert/boundary2.py
#table
python3 ./test.py -f table/alter_wal0.py
......
tests/pytest/insert/boundary2.py 0 → 100644
浏览文件 @ 24b5da8b
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或