Merge branch 'develop' into feature/TD-1568

cmake/install.inc

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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);
   }
@@ -1807,7 +1810,7 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
   pMetaMsg->uid = htobe64(pMetaMsg->uid);
   pMetaMsg->contLen = htons(pMetaMsg->contLen);
   pMetaMsg->numOfColumns = htons(pMetaMsg->numOfColumns);
-
+  
   if ((pMetaMsg->tableType != TSDB_SUPER_TABLE) &&
       (pMetaMsg->tid <= 0 || pMetaMsg->vgroup.vgId < 2 || pMetaMsg->vgroup.numOfEps <= 0)) {
     tscError("invalid value in table numOfEps:%d, vgId:%d tid:%d, name:%s", pMetaMsg->vgroup.numOfEps, pMetaMsg->vgroup.vgId,

src/client/src/tscSubquery.c

@@ -683,10 +683,14 @@ void tscBuildVgroupTableInfo(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SArr
     prev = tt;
   }
 
-  pTableMetaInfo->pVgroupTables = result;
   pTableMetaInfo->vgroupIndex = 0;
+  
+  if (taosArrayGetSize(result) <= 0) {
+    pTableMetaInfo->pVgroupTables = NULL;
+    taosArrayDestroy(result);
+  } else {
+    pTableMetaInfo->pVgroupTables = result;
 
-  if (taosArrayGetSize(result) > 0) {
     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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

 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);
-        return false;
+        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

@@ -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

@@ -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 errorCode) {
+        String message;
+        if (TSDBErrorNumbers.contains(errorCode))
+            message = TSDBErrorMap.get(errorCode);
+        else
+            message = TSDBErrorMap.get(TSDBErrorNumbers.ERROR_UNKNOWN);
+        return createSQLException(errorCode, message);
     }
 
-    public static SQLException createSQLException(int errorNumber, String message) {
-        if (message == null || message.isEmpty()) {
-            if (TSDBErrorNumbers.contains(errorNumber))
-                message = TSDBErrorMap.get(errorNumber);
-            else
-                message = TSDBErrorMap.get(TSDBErrorNumbers.ERROR_UNKNOWN);
-        }
+    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_UNSUPPORTED_METHOD)
-            return new SQLFeatureNotSupportedException(message);
-
-        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);
-        // JNI exception's error number is large than 0x2350
-        return new SQLException("TDengine 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("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

@@ -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

@@ -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) {
@@ -206,7 +205,7 @@ public class TSDBJNIConnector {
 //        }
 
 //        if (taosResultSetPointer != TSDBConstants.JNI_NULL_POINTER) {
-            res = this.freeResultSetImp(this.taos, pSql);
+        res = this.freeResultSetImp(this.taos, pSql);
 //            taosResultSetPointer = TSDBConstants.JNI_NULL_POINTER;
 //        }
 
@@ -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

@@ -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

@@ -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

@@ -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

+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

@@ -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

 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

-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

-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

 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;
-
-    @Test
-    public void executeQuery() {
-
+    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() 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

@@ -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

 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

@@ -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

@@ -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

 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

+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

+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

@@ -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

@@ -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

@@ -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

@@ -324,7 +324,8 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
   }
 
   if (!tscIsUpdateQuery(pSql)) {  // select and show kinds of commands
-    int error_no = 0;
+    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,18 +689,33 @@ 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;
-  do {
-    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;
+  int showMore = 1;
+  do {  
+    if (numOfRows < resShowMaxNum) {
+      printf("*************************** %d.row ***************************\n", numOfRows + 1);
 
-      int padding = (int)(maxColNameLen - strlen(field->name));
-      printf("%*.s%s: ", padding, " ", field->name);
+      int32_t* length = taos_fetch_lengths(tres);
 
-      printField((const char*)row[i], field, 0, length[i], precision);
-      putchar('\n');
+      for (int i = 0; i < num_fields; i++) {
+        TAOS_FIELD* field = fields + i;
+
+        int padding = (int)(maxColNameLen - strlen(field->name));
+        printf("%*.s%s: ", padding, " ", field->name);
+
+        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++;
@@ -795,16 +822,31 @@ 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);
-    for (int i = 0; i < num_fields; i++) {
-      putchar(' ');
-      printField((const char*)row[i], fields + i, width[i], length[i], precision);
-      putchar(' ');
-      putchar('|');
+    if (numOfRows < resShowMaxNum) {
+      for (int i = 0; i < num_fields; i++) {
+        putchar(' ');
+        printField((const char*)row[i], fields + i, width[i], length[i], precision);
+        putchar(' ');
+        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;
     }
-    putchar('\n');
+    
     numOfRows++;
     row = taos_fetch_row(tres);
   } while(row != NULL);

src/kit/taosdump/taosdump.c

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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;
@@ -55,4 +58,4 @@ int32_t taosGetCurrentAPPName(char *name, int32_t* len) {
   }
 
   return 0;
-}
+}
\ No newline at end of file

src/query/src/qExecutor.c

@@ -4743,7 +4743,11 @@ static FORCE_INLINE void setEnvForEachBlock(SQInfo* pQInfo, STableQueryInfo* pTa
   }
 
   if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
-    setIntervalQueryRange(pQInfo, pBlockInfo->window.skey);
+    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

@@ -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,8 +479,12 @@ void tSqlSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
     i += 1;
   }
 
+  // no qualified data type found, try unsigned data type
   if (i == tListLen(tDataTypes)) {
-    return;
+    i = tryParseNameTwoParts(type);
+    if (i == -1) {
+      return;
+    }
   }
 
   pField->type = i;

src/sync/src/syncRestore.c

@@ -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

@@ -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/tnote.c

@@ -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

@@ -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>