[TD-2827]<fix>: fix JDBC-RESTful resultSet and restSetMetaData bugs

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConstants.java

@@ -22,6 +22,8 @@ public abstract class TSDBConstants {
     public static final String DEFAULT_PORT = "6200";
     public static final String UNSUPPORT_METHOD_EXCEPTIONZ_MSG = "this operation is NOT supported currently!";
     public static final String INVALID_VARIABLES = "invalid variables";
+    public static final String RESULT_SET_IS_CLOSED = "resultSet is closed.";
+
     public static Map<Integer, String> DATATYPE_MAP = null;
 
     public static final long JNI_NULL_POINTER = 0L;
@@ -74,7 +76,7 @@ public abstract class TSDBConstants {
     }
 
     static {
-        DATATYPE_MAP = new HashMap<Integer, String>();
+        DATATYPE_MAP = new HashMap<>();
         DATATYPE_MAP.put(1, "BOOL");
         DATATYPE_MAP.put(2, "TINYINT");
         DATATYPE_MAP.put(3, "SMALLINT");

src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulResultSetMetaData.java

 package com.taosdata.jdbc.rs;
 
+import com.taosdata.jdbc.TSDBConstants;
+
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
+import java.sql.Timestamp;
 import java.util.ArrayList;
 
 public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     private final String database;
     private ArrayList<RestfulResultSet.Field> fields;
+    private final RestfulResultSet resultSet;
 
-    public RestfulResultSetMetaData(String database, ArrayList<RestfulResultSet.Field> fields) {
+    public RestfulResultSetMetaData(String database, ArrayList<RestfulResultSet.Field> fields, RestfulResultSet resultSet) {
         this.database = database;
         this.fields = fields;
+        this.resultSet = resultSet;
     }
 
     @Override
@@ -26,13 +31,12 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     @Override
     public boolean isCaseSensitive(int column) throws SQLException {
-        //TODO
         return false;
     }
 
     @Override
     public boolean isSearchable(int column) throws SQLException {
-        return false;
+        return true;
     }
 
     @Override
@@ -42,17 +46,30 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     @Override
     public int isNullable(int column) throws SQLException {
+        if (column == 1)
+            return ResultSetMetaData.columnNoNulls;
         return ResultSetMetaData.columnNullable;
     }
 
     @Override
     public boolean isSigned(int column) throws SQLException {
-        return false;
+        String type = this.fields.get(column - 1).type.toUpperCase();
+        switch (type) {
+            case "TINYINT":
+            case "SMALLINT":
+            case "INT":
+            case "BIGINT":
+            case "FLOAT":
+            case "DOUBLE":
+                return true;
+            default:
+                return false;
+        }
     }
 
     @Override
     public int getColumnDisplaySize(int column) throws SQLException {
-        return 0;
+        return this.fields.get(column - 1).length;
     }
 
     @Override
@@ -62,27 +79,46 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     @Override
     public String getColumnName(int column) throws SQLException {
-        return null;
+        return fields.get(column - 1).name;
     }
 
     @Override
     public String getSchemaName(int column) throws SQLException {
-        return this.database;
+        return "";
     }
 
     @Override
     public int getPrecision(int column) throws SQLException {
-        return 0;
+        String type = this.fields.get(column - 1).type.toUpperCase();
+        switch (type) {
+            case "FLOAT":
+                return 5;
+            case "DOUBLE":
+                return 9;
+            case "BINARY":
+            case "NCHAR":
+                return this.fields.get(column - 1).length;
+            default:
+                return 0;
+        }
     }
 
     @Override
     public int getScale(int column) throws SQLException {
-        return 0;
+        String type = this.fields.get(column - 1).type.toUpperCase();
+        switch (type) {
+            case "FLOAT":
+                return 5;
+            case "DOUBLE":
+                return 9;
+            default:
+                return 0;
+        }
     }
 
     @Override
     public String getTableName(int column) throws SQLException {
-        return null;
+        return "";
     }
 
     @Override
@@ -92,17 +128,42 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     @Override
     public int getColumnType(int column) throws SQLException {
-        return 0;
+        String type = this.fields.get(column - 1).type.toUpperCase();
+        switch (type) {
+            case "BOOL":
+                return java.sql.Types.BOOLEAN;
+            case "TINYINT":
+                return java.sql.Types.TINYINT;
+            case "SMALLINT":
+                return java.sql.Types.SMALLINT;
+            case "INT":
+                return java.sql.Types.INTEGER;
+            case "BIGINT":
+                return java.sql.Types.BIGINT;
+            case "FLOAT":
+                return java.sql.Types.FLOAT;
+            case "DOUBLE":
+                return java.sql.Types.DOUBLE;
+            case "BINARY":
+                return java.sql.Types.BINARY;
+            case "TIMESTAMP":
+                return java.sql.Types.TIMESTAMP;
+            case "NCHAR":
+                return java.sql.Types.NCHAR;
+        }
+        throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+
     }
 
     @Override
     public String getColumnTypeName(int column) throws SQLException {
-        return null;
+        String type = fields.get(column - 1).type;
+        return type.toUpperCase();
     }
 
     @Override
     public boolean isReadOnly(int column) throws SQLException {
-        return false;
+        return true;
     }
 
     @Override
@@ -117,16 +178,43 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     @Override
     public String getColumnClassName(int column) throws SQLException {
-        return null;
+        String type = this.fields.get(column - 1).type;
+        String columnClassName = "";
+        switch (type) {
+            case "BOOL":
+                return Boolean.class.getName();
+            case "TINYINT":
+            case "SMALLINT":
+                return Short.class.getName();
+            case "INT":
+                return Integer.class.getName();
+            case "BIGINT":
+                return Long.class.getName();
+            case "FLOAT":
+                return Float.class.getName();
+            case "DOUBLE":
+                return Double.class.getName();
+            case "TIMESTAMP":
+                return Timestamp.class.getName();
+            case "BINARY":
+            case "NCHAR":
+                return String.class.getName();
+        }
+        return columnClassName;
     }
 
     @Override
     public <T> T unwrap(Class<T> iface) throws SQLException {
-        return null;
+        try {
+            return iface.cast(this);
+        } catch (ClassCastException cce) {
+            throw new SQLException("Unable to unwrap to " + iface.toString());
+        }
     }
 
     @Override
     public boolean isWrapperFor(Class<?> iface) throws SQLException {
-        return false;
+        return iface.isInstance(this);
     }
+
 }

src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java

@@ -65,37 +65,18 @@ public class RestfulStatement implements Statement {
     public ResultSet executeQuery(String sql) throws SQLException {
         if (isClosed())
             throw new SQLException("statement already closed");
-        if (!SqlSyntaxValidator.isSelectSql(sql))
-            throw new SQLException("not a select sql for executeQuery: " + sql);
+        if (!SqlSyntaxValidator.isValidForExecuteQuery(sql))
+            throw new SQLException("not a valid sql for executeQuery: " + sql);
 
         final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
-        // row data
-        String result = HttpClientPoolUtil.execute(url, sql);
-        JSONObject resultJson = JSON.parseObject(result);
-        if (resultJson.getString("status").equals("error")) {
-            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + resultJson.getString("desc") + "\n" + "error code: " + resultJson.getString("code")));
+        if (SqlSyntaxValidator.isDatabaseUnspecifiedQuery(sql)) {
+            return executeOneQuery(url, sql);
         }
 
-        // parse table name from sql
-        String[] tableIdentifiers = parseTableIdentifier(sql);
-        if (tableIdentifiers != null) {
-            List<JSONObject> fieldJsonList = new ArrayList<>();
-            for (String tableIdentifier : tableIdentifiers) {
-                // field meta
-                String fields = HttpClientPoolUtil.execute(url, "DESCRIBE " + tableIdentifier);
-                JSONObject fieldJson = JSON.parseObject(fields);
-                if (fieldJson.getString("status").equals("error")) {
-                    throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + fieldJson.getString("desc") + "\n" + "error code: " + fieldJson.getString("code")));
-                }
-                fieldJsonList.add(fieldJson);
-            }
-            this.resultSet = new RestfulResultSet(database, this, resultJson, fieldJsonList);
-        } else {
-            this.resultSet = new RestfulResultSet(database, this, resultJson);
-        }
-
-        this.affectedRows = 0;
-        return resultSet;
+        if (this.database == null || this.database.isEmpty())
+            throw new SQLException("Database not specified or available");
+        HttpClientPoolUtil.execute(url, "use " + this.database);
+        return executeOneQuery(url, sql);
     }
 
     @Override
@@ -105,19 +86,15 @@ public class RestfulStatement implements Statement {
         if (!SqlSyntaxValidator.isValidForExecuteUpdate(sql))
             throw new SQLException("not a valid sql for executeUpdate: " + sql);
 
-        if (this.database == null)
-            throw new SQLException("Database not specified or available");
-
-        final String url = "http://" + conn.getHost().trim() + ":" + conn.getPort() + "/rest/sql";
-//        HttpClientPoolUtil.execute(url, "use " + conn.getDatabase());
-        String result = HttpClientPoolUtil.execute(url, sql);
-        JSONObject jsonObject = JSON.parseObject(result);
-        if (jsonObject.getString("status").equals("error")) {
-            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonObject.getString("desc") + "\n" + "error code: " + jsonObject.getString("code")));
+        final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
+        if (SqlSyntaxValidator.isDatabaseUnspecifiedUpdate(sql)) {
+            return executeOneUpdate(url, sql);
         }
-        this.resultSet = null;
-        this.affectedRows = Integer.parseInt(jsonObject.getString("rows"));
-        return this.affectedRows;
+
+        if (this.database == null || this.database.isEmpty())
+            throw new SQLException("Database not specified or available");
+        HttpClientPoolUtil.execute(url, "use " + this.database);
+        return executeOneUpdate(url, sql);
     }
 
     @Override
@@ -209,35 +186,75 @@ public class RestfulStatement implements Statement {
 
     @Override
     public boolean execute(String sql) throws SQLException {
-        if (isClosed()) {
+        if (isClosed())
             throw new SQLException("Invalid method call on a closed statement.");
-        }
+        if (!SqlSyntaxValidator.isValidForExecute(sql))
+            throw new SQLException("not a valid sql for execute: " + sql);
+
         //如果执行了use操作应该将当前Statement的catalog设置为新的database
+        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);
+        } else if (SqlSyntaxValidator.isDatabaseUnspecifiedQuery(sql)) {
+            executeOneQuery(url, sql);
+        } else if (SqlSyntaxValidator.isDatabaseUnspecifiedUpdate(sql)) {
+            executeOneUpdate(url, sql);
+        } else {
+            if (SqlSyntaxValidator.isValidForExecuteQuery(sql)) {
+                executeQuery(sql);
+            } else {
+                executeUpdate(sql);
+            }
         }
-        if (this.database == null)
-            throw new SQLException("Database not specified or available");
 
-        if (SqlSyntaxValidator.isSelectSql(sql)) {
-            executeQuery(sql);
-        } else if (SqlSyntaxValidator.isShowSql(sql) || SqlSyntaxValidator.isDescribeSql(sql)) {
-            final String url = "http://" + conn.getHost().trim() + ":" + conn.getPort() + "/rest/sql";
-            if (!SqlSyntaxValidator.isShowDatabaseSql(sql)) {
-                HttpClientPoolUtil.execute(url, "use " + conn.getDatabase());
-            }
-            String result = HttpClientPoolUtil.execute(url, sql);
-            JSONObject resultJson = JSON.parseObject(result);
-            if (resultJson.getString("status").equals("error")) {
-                throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + resultJson.getString("desc") + "\n" + "error code: " + resultJson.getString("code")));
+        return true;
+    }
+
+    private ResultSet executeOneQuery(String url, String sql) throws SQLException {
+        if (!SqlSyntaxValidator.isValidForExecuteQuery(sql))
+            throw new SQLException("not a select sql for executeQuery: " + sql);
+
+        // row data
+        String result = HttpClientPoolUtil.execute(url, sql);
+        JSONObject resultJson = JSON.parseObject(result);
+        if (resultJson.getString("status").equals("error")) {
+            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + resultJson.getString("desc") + "\n" + "error code: " + resultJson.getString("code")));
+        }
+        // parse table name from sql
+        String[] tableIdentifiers = parseTableIdentifier(sql);
+        if (tableIdentifiers != null) {
+            List<JSONObject> fieldJsonList = new ArrayList<>();
+            for (String tableIdentifier : tableIdentifiers) {
+                // field meta
+                String fields = HttpClientPoolUtil.execute(url, "DESCRIBE " + tableIdentifier);
+                JSONObject fieldJson = JSON.parseObject(fields);
+                if (fieldJson.getString("status").equals("error")) {
+                    throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + fieldJson.getString("desc") + "\n" + "error code: " + fieldJson.getString("code")));
+                }
+                fieldJsonList.add(fieldJson);
             }
-            this.resultSet = new RestfulResultSet(database, this, resultJson);
+            this.resultSet = new RestfulResultSet(database, this, resultJson, fieldJsonList);
         } else {
-            executeUpdate(sql);
+            this.resultSet = new RestfulResultSet(database, this, resultJson);
         }
+        this.affectedRows = 0;
+        return resultSet;
+    }
 
-        return true;
+    private int executeOneUpdate(String url, String sql) throws SQLException {
+        if (!SqlSyntaxValidator.isValidForExecuteUpdate(sql))
+            throw new SQLException("not a valid sql for executeUpdate: " + sql);
+
+        String result = HttpClientPoolUtil.execute(url, sql);
+        JSONObject jsonObject = JSON.parseObject(result);
+        if (jsonObject.getString("status").equals("error")) {
+            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"));
+        return this.affectedRows;
     }
 
     @Override

src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/SqlSyntaxValidator.java

@@ -20,8 +20,11 @@ import java.sql.Connection;
 
 public class SqlSyntaxValidator {
 
-    private static final String[] updateSQL = {"insert", "update", "delete", "create", "alter", "drop", "show", "describe", "use", "import"};
-    private static final String[] querySQL = {"select"};
+    private static final String[] SQL = {"select", "insert", "import", "create", "use", "alter", "drop", "set", "show", "describe"};
+    private static final String[] updateSQL = {"insert", "import", "create", "use", "alter", "drop", "set"};
+    private static final String[] querySQL = {"select", "show", "describe"};
+
+    private static final String[] databaseUnspecifiedShow = {"databases", "dnodes", "mnodes", "variables"};
 
     private TSDBConnection tsdbConnection;
 
@@ -37,8 +40,38 @@ public class SqlSyntaxValidator {
         return false;
     }
 
+    public static boolean isValidForExecuteQuery(String sql) {
+        for (String prefix : querySQL) {
+            if (sql.trim().toLowerCase().startsWith(prefix))
+                return true;
+        }
+        return false;
+    }
+
+    public static boolean isValidForExecute(String sql) {
+        for (String prefix : SQL) {
+            if (sql.trim().toLowerCase().startsWith(prefix))
+                return true;
+        }
+        return false;
+    }
+
+    public static boolean isDatabaseUnspecifiedQuery(String sql) {
+        for (String databaseObj : databaseUnspecifiedShow) {
+            if (sql.trim().toLowerCase().matches("show\\s+" + databaseObj + ".*"))
+                return true;
+        }
+        return false;
+    }
+
+    public static boolean isDatabaseUnspecifiedUpdate(String sql) {
+        sql = sql.trim().toLowerCase();
+        return sql.matches("create\\s+database.*") || sql.startsWith("set") || sql.matches("drop\\s+database.*");
+    }
+
     public static boolean isUseSql(String sql) {
-        return sql.trim().toLowerCase().startsWith("use") || sql.trim().toLowerCase().matches("create\\s*database.*") || sql.toLowerCase().toLowerCase().matches("drop\\s*database.*");
+        return sql.trim().toLowerCase().startsWith("use");
+//                || sql.trim().toLowerCase().matches("create\\s*database.*") || sql.toLowerCase().toLowerCase().matches("drop\\s*database.*");
     }
 
     public static boolean isShowSql(String sql) {
@@ -58,8 +91,9 @@ public class SqlSyntaxValidator {
         return sql.trim().toLowerCase().startsWith("select");
     }
 
-
     public static boolean isShowDatabaseSql(String sql) {
         return sql.trim().toLowerCase().matches("show\\s*databases");
     }
+
+
 }

src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/AuthenticationTest.java

@@ -7,7 +7,8 @@ import java.sql.*;
 
 public class AuthenticationTest {
 
-    private static final String host = "127.0.0.1";
+//    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 Connection conn;

src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulJDBCTest.java

@@ -9,44 +9,33 @@ import java.util.Random;
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 public class RestfulJDBCTest {
 
-    private static final String host = "127.0.0.1";
-    private Connection connection;
-
-    @Before
-    public void before() throws ClassNotFoundException, SQLException {
-        Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
-        connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=root&password=taosdata");
-    }
-
-    @After
-    public void after() throws SQLException {
-        if (connection != null)
-            connection.close();
-    }
-
+    //    private static final String host = "127.0.0.1";
+    private static final String host = "master";
+    private static Connection connection;
+    private Random random = new Random(System.currentTimeMillis());
 
     /**
-     * 查询所有log.log
+     * select * from log.log
      **/
-    @Test
-    public void testCase001() {
-        try {
-            Statement statement = connection.createStatement();
-            ResultSet resultSet = statement.executeQuery("select * from log.log");
-            ResultSetMetaData metaData = resultSet.getMetaData();
-            while (resultSet.next()) {
-                for (int i = 1; i <= metaData.getColumnCount(); i++) {
-                    String column = metaData.getColumnLabel(i);
-                    String value = resultSet.getString(i);
-                    System.out.print(column + ":" + value + "\t");
-                }
-                System.out.println();
-            }
-            statement.close();
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-    }
+//    @Test
+//    public void testCase001() {
+//        try {
+//            Statement statement = connection.createStatement();
+//            ResultSet resultSet = statement.executeQuery("select * from log.log");
+//            ResultSetMetaData metaData = resultSet.getMetaData();
+//            while (resultSet.next()) {
+//                for (int i = 1; i <= metaData.getColumnCount(); i++) {
+//                    String column = metaData.getColumnLabel(i);
+//                    String value = resultSet.getString(i);
+//                    System.out.print(column + ":" + value + "\t");
+//                }
+//                System.out.println();
+//            }
+//            statement.close();
+//        } catch (SQLException e) {
+//            e.printStackTrace();
+//        }
+//    }
 
     /**
      * create database
@@ -85,7 +74,6 @@ public class RestfulJDBCTest {
         }
     }
 
-    private Random random = new Random(System.currentTimeMillis());
 
     @Test
     public void testCase005() {
@@ -105,5 +93,50 @@ public class RestfulJDBCTest {
         }
     }
 
+    @Test
+    public void testCase006() {
+        try (Statement stmt = connection.createStatement()) {
+            ResultSet rs = stmt.executeQuery("select * from weather");
+            while (rs.next()) {
+                System.out.print("ts: " + rs.getTimestamp("ts"));
+                System.out.print(", temperature: " + rs.getString("temperature"));
+                System.out.print(", humidity: " + rs.getString("humidity"));
+                System.out.println(", location: " + rs.getString("location"));
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void testCase007() {
+        try (Statement stmt = connection.createStatement()) {
+            ResultSet rs = stmt.executeQuery("select * from weather");
+            ResultSetMetaData meta = rs.getMetaData();
+            while (rs.next()) {
+                int columnCount = meta.getColumnCount();
+                for (int i = 1; i <= columnCount; i++) {
+                    String columnLabel = meta.getColumnLabel(i);
+                    String value = rs.getString(i);
+                    System.out.print(columnLabel + ": " + value+"\t");
+                }
+                System.out.println();
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @BeforeClass
+    public static void before() throws ClassNotFoundException, SQLException {
+        Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
+        connection = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=root&password=taosdata");
+    }
+
+    @AfterClass
+    public static void after() throws SQLException {
+        if (connection != null)
+            connection.close();
+    }
 
 }

src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulResultSetMetaDataTest.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.*;
+
+import static org.junit.Assert.*;
+
+public class RestfulResultSetMetaDataTest {
+
+    //    private static final String host = "127.0.0.1";
+    private static final String host = "master";
+
+    private static Connection conn;
+    private static Statement stmt;
+    private static ResultSet rs;
+    private static ResultSetMetaData meta;
+
+    @Test
+    public void getColumnCount() throws SQLException {
+        Assert.assertEquals(10, meta.getColumnCount());
+    }
+
+    @Test
+    public void isAutoIncrement() throws SQLException {
+        Assert.assertFalse(meta.isAutoIncrement(1));
+        Assert.assertFalse(meta.isAutoIncrement(2));
+        Assert.assertFalse(meta.isAutoIncrement(3));
+        Assert.assertFalse(meta.isAutoIncrement(4));
+        Assert.assertFalse(meta.isAutoIncrement(5));
+        Assert.assertFalse(meta.isAutoIncrement(6));
+        Assert.assertFalse(meta.isAutoIncrement(7));
+        Assert.assertFalse(meta.isAutoIncrement(8));
+        Assert.assertFalse(meta.isAutoIncrement(9));
+        Assert.assertFalse(meta.isAutoIncrement(10));
+    }
+
+    @Test
+    public void isCaseSensitive() throws SQLException {
+        Assert.assertFalse(meta.isCaseSensitive(1));
+    }
+
+    @Test
+    public void isSearchable() throws SQLException {
+        Assert.assertTrue(meta.isSearchable(1));
+    }
+
+    @Test
+    public void isCurrency() throws SQLException {
+        Assert.assertFalse(meta.isCurrency(1));
+    }
+
+    @Test
+    public void isNullable() throws SQLException {
+        Assert.assertEquals(ResultSetMetaData.columnNoNulls, meta.isNullable(1));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(2));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(3));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(4));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(5));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(6));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(7));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(8));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(9));
+        Assert.assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(10));
+    }
+
+    @Test
+    public void isSigned() throws SQLException {
+        Assert.assertFalse(meta.isSigned(1));
+    }
+
+    @Test
+    public void getColumnDisplaySize() throws SQLException {
+        Assert.assertEquals(64, meta.getColumnDisplaySize(10));
+    }
+
+    @Test
+    public void getColumnLabel() throws SQLException {
+        Assert.assertEquals("f1", meta.getColumnLabel(1));
+    }
+
+    @Test
+    public void getColumnName() throws SQLException {
+        Assert.assertEquals("f1", meta.getColumnName(1));
+    }
+
+    @Test
+    public void getSchemaName() throws SQLException {
+        Assert.assertEquals("", meta.getSchemaName(1));
+    }
+
+    @Test
+    public void getPrecision() throws SQLException {
+        Assert.assertEquals(0, meta.getPrecision(1));
+    }
+
+    @Test
+    public void getScale() throws SQLException {
+        Assert.assertEquals(0, meta.getScale(1));
+    }
+
+    @Test
+    public void getTableName() throws SQLException {
+        Assert.assertEquals("", meta.getTableName(1));
+    }
+
+    @Test
+    public void getCatalogName() throws SQLException {
+        Assert.assertEquals("restful_test", meta.getCatalogName(1));
+        Assert.assertEquals("restful_test", meta.getCatalogName(2));
+        Assert.assertEquals("restful_test", meta.getCatalogName(3));
+        Assert.assertEquals("restful_test", meta.getCatalogName(4));
+        Assert.assertEquals("restful_test", meta.getCatalogName(5));
+        Assert.assertEquals("restful_test", meta.getCatalogName(6));
+        Assert.assertEquals("restful_test", meta.getCatalogName(7));
+        Assert.assertEquals("restful_test", meta.getCatalogName(8));
+        Assert.assertEquals("restful_test", meta.getCatalogName(9));
+        Assert.assertEquals("restful_test", meta.getCatalogName(10));
+    }
+
+    @Test
+    public void getColumnType() throws SQLException {
+        Assert.assertEquals(Types.TIMESTAMP, meta.getColumnType(1));
+        Assert.assertEquals(Types.INTEGER, meta.getColumnType(2));
+        Assert.assertEquals(Types.BIGINT, meta.getColumnType(3));
+        Assert.assertEquals(Types.FLOAT, meta.getColumnType(4));
+        Assert.assertEquals(Types.DOUBLE, meta.getColumnType(5));
+        Assert.assertEquals(Types.BINARY, meta.getColumnType(6));
+        Assert.assertEquals(Types.SMALLINT, meta.getColumnType(7));
+        Assert.assertEquals(Types.TINYINT, meta.getColumnType(8));
+        Assert.assertEquals(Types.BOOLEAN, meta.getColumnType(9));
+        Assert.assertEquals(Types.NCHAR, meta.getColumnType(10));
+    }
+
+    @Test
+    public void getColumnTypeName() throws SQLException {
+        Assert.assertEquals("TIMESTAMP", meta.getColumnTypeName(1));
+        Assert.assertEquals("INT", meta.getColumnTypeName(2));
+        Assert.assertEquals("BIGINT", meta.getColumnTypeName(3));
+        Assert.assertEquals("FLOAT", meta.getColumnTypeName(4));
+        Assert.assertEquals("DOUBLE", meta.getColumnTypeName(5));
+        Assert.assertEquals("BINARY", meta.getColumnTypeName(6));
+        Assert.assertEquals("SMALLINT", meta.getColumnTypeName(7));
+        Assert.assertEquals("TINYINT", meta.getColumnTypeName(8));
+        Assert.assertEquals("BOOL", meta.getColumnTypeName(9));
+        Assert.assertEquals("NCHAR", meta.getColumnTypeName(10));
+    }
+
+    @Test
+    public void isReadOnly() throws SQLException {
+        Assert.assertTrue(meta.isReadOnly(1));
+    }
+
+    @Test
+    public void isWritable() throws SQLException {
+        Assert.assertFalse(meta.isWritable(1));
+    }
+
+    @Test
+    public void isDefinitelyWritable() throws SQLException {
+        Assert.assertFalse(meta.isDefinitelyWritable(1));
+    }
+
+    @Test
+    public void getColumnClassName() throws SQLException {
+        Assert.assertEquals(Timestamp.class.getName(), meta.getColumnClassName(1));
+        Assert.assertEquals(Integer.class.getName(), meta.getColumnClassName(2));
+        Assert.assertEquals(Long.class.getName(), meta.getColumnClassName(3));
+        Assert.assertEquals(Float.class.getName(), meta.getColumnClassName(4));
+        Assert.assertEquals(Double.class.getName(), meta.getColumnClassName(5));
+        Assert.assertEquals(String.class.getName(), meta.getColumnClassName(6));
+        Assert.assertEquals(Short.class.getName(), meta.getColumnClassName(7));
+        Assert.assertEquals(Short.class.getName(), meta.getColumnClassName(8));
+        Assert.assertEquals(Boolean.class.getName(), meta.getColumnClassName(9));
+        Assert.assertEquals(String.class.getName(), meta.getColumnClassName(10));
+    }
+
+    @Test
+    public void unwrap() throws SQLException {
+        Assert.assertNotNull(meta.unwrap(RestfulResultSetMetaData.class));
+    }
+
+    @Test
+    public void isWrapperFor() throws SQLException {
+        Assert.assertTrue(meta.isWrapperFor(RestfulResultSetMetaData.class));
+    }
+
+    @BeforeClass
+    public static void beforeClass() {
+        try {
+            Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
+            conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=root&password=taosdata");
+            stmt = conn.createStatement();
+            stmt.execute("create database if not exists restful_test");
+            stmt.execute("use restful_test");
+            stmt.execute("drop table if exists weather");
+            stmt.execute("create table if not exists weather(f1 timestamp, f2 int, f3 bigint, f4 float, f5 double, f6 binary(64), f7 smallint, f8 tinyint, f9 bool, f10 nchar(64))");
+            stmt.execute("insert into restful_test.weather values('2021-01-01 00:00:00.000', 1, 100, 3.1415, 3.1415926, 'abc', 10, 10, true, '涛思数据')");
+            rs = stmt.executeQuery("select * from restful_test.weather");
+            rs.next();
+            meta = rs.getMetaData();
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @AfterClass
+    public static void afterClass() {
+        try {
+            if (rs != null)
+                rs.close();
+            if (stmt != null)
+                stmt.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/RestfulResultSetTest.java

+package com.taosdata.jdbc.rs;
+
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.sql.*;
+
+public class RestfulResultSetTest {
+
+    //    private static final String host = "127.0.0.1";
+    private static final String host = "master";
+
+    private static Connection conn;
+    private static Statement stmt;
+    private static ResultSet rs;
+
+    @Test
+    public void wasNull() throws SQLException {
+        Assert.assertFalse(rs.wasNull());
+    }
+
+    @Test
+    public void getString() throws SQLException {
+        String f10 = rs.getString("f10");
+        Assert.assertEquals("涛思数据", f10);
+        f10 = rs.getString(10);
+        Assert.assertEquals("涛思数据", f10);
+    }
+
+    @Test
+    public void getBoolean() throws SQLException {
+        Boolean f9 = rs.getBoolean("f9");
+        Assert.assertEquals(true, f9);
+        f9 = rs.getBoolean(9);
+        Assert.assertEquals(true, f9);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getByte() throws SQLException {
+        rs.getByte(1);
+    }
+
+    @Test
+    public void getShort() throws SQLException {
+        short f7 = rs.getShort("f7");
+        Assert.assertEquals(10, f7);
+        f7 = rs.getShort(7);
+        Assert.assertEquals(10, f7);
+    }
+
+    @Test
+    public void getInt() throws SQLException {
+        int f2 = rs.getInt("f2");
+        Assert.assertEquals(1, f2);
+        f2 = rs.getInt(2);
+        Assert.assertEquals(1, f2);
+    }
+
+    @Test
+    public void getLong() throws SQLException {
+        long f3 = rs.getLong("f3");
+        Assert.assertEquals(100, f3);
+        f3 = rs.getLong(3);
+        Assert.assertEquals(100, f3);
+    }
+
+    @Test
+    public void getFloat() throws SQLException {
+        float f4 = rs.getFloat("f4");
+        Assert.assertEquals(3.1415f, f4, 0f);
+        f4 = rs.getFloat(4);
+        Assert.assertEquals(3.1415f, f4, 0f);
+    }
+
+    @Test
+    public void getDouble() throws SQLException {
+        double f5 = rs.getDouble("f5");
+        Assert.assertEquals(3.1415926, f5, 0.0);
+        f5 = rs.getDouble(5);
+        Assert.assertEquals(3.1415926, f5, 0.0);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getBigDecimal() throws SQLException {
+        rs.getBigDecimal("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getBytes() throws SQLException {
+        rs.getBytes("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getDate() throws SQLException {
+        rs.getDate("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getTime() throws SQLException {
+        rs.getTime("f1");
+    }
+
+    @Test
+    public void getTimestamp() throws SQLException {
+        Timestamp f1 = rs.getTimestamp("f1");
+        Assert.assertEquals("2021-01-01 00:00:00.0", f1.toString());
+        f1 = rs.getTimestamp(1);
+        Assert.assertEquals("2021-01-01 00:00:00.0", f1.toString());
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getAsciiStream() throws SQLException {
+        rs.getAsciiStream("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getUnicodeStream() throws SQLException {
+        rs.getUnicodeStream("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getBinaryStream() throws SQLException {
+        rs.getBinaryStream("f1");
+    }
+
+    @Test
+    public void getWarnings() throws SQLException {
+        Assert.assertNull(rs.getWarnings());
+    }
+
+    @Test
+    public void clearWarnings() throws SQLException {
+        rs.clearWarnings();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getCursorName() throws SQLException {
+        rs.getCursorName();
+    }
+
+    @Test
+    public void getMetaData() throws SQLException {
+        ResultSetMetaData meta = rs.getMetaData();
+        Assert.assertNotNull(meta);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getObject() throws SQLException {
+        rs.getObject("f1");
+    }
+
+    @Test(expected = SQLException.class)
+    public void findColumn() throws SQLException {
+        int columnIndex = rs.findColumn("f1");
+        Assert.assertEquals(1, columnIndex);
+        columnIndex = rs.findColumn("f2");
+        Assert.assertEquals(2, columnIndex);
+        columnIndex = rs.findColumn("f3");
+        Assert.assertEquals(3, columnIndex);
+        columnIndex = rs.findColumn("f4");
+        Assert.assertEquals(4, columnIndex);
+        columnIndex = rs.findColumn("f5");
+        Assert.assertEquals(5, columnIndex);
+        columnIndex = rs.findColumn("f6");
+        Assert.assertEquals(6, columnIndex);
+        columnIndex = rs.findColumn("f7");
+        Assert.assertEquals(7, columnIndex);
+        columnIndex = rs.findColumn("f8");
+        Assert.assertEquals(8, columnIndex);
+        columnIndex = rs.findColumn("f9");
+        Assert.assertEquals(9, columnIndex);
+        columnIndex = rs.findColumn("f10");
+        Assert.assertEquals(10, columnIndex);
+
+        rs.findColumn("f11");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getCharacterStream() throws SQLException {
+        rs.getCharacterStream(1);
+    }
+
+    @Test
+    public void isBeforeFirst() throws SQLException {
+        Assert.assertFalse(rs.isBeforeFirst());
+        rs.beforeFirst();
+        Assert.assertTrue(rs.isBeforeFirst());
+        rs.next();
+    }
+
+    @Test
+    public void isAfterLast() throws SQLException {
+        Assert.assertFalse(rs.isAfterLast());
+    }
+
+    @Test
+    public void isFirst() throws SQLException {
+        Assert.assertTrue(rs.isFirst());
+    }
+
+    @Test
+    public void isLast() throws SQLException {
+        Assert.assertTrue(rs.isLast());
+    }
+
+    @Test
+    public void beforeFirst() throws SQLException {
+        rs.beforeFirst();
+        Assert.assertTrue(rs.isBeforeFirst());
+        rs.next();
+    }
+
+    @Test
+    public void afterLast() throws SQLException {
+        rs.afterLast();
+        Assert.assertTrue(rs.isAfterLast());
+        rs.first();
+    }
+
+    @Test
+    public void first() throws SQLException {
+        rs.first();
+        Assert.assertEquals("2021-01-01 00:00:00.0", rs.getTimestamp("f1").toString());
+    }
+
+    @Test
+    public void last() throws SQLException {
+        rs.last();
+        Assert.assertEquals("2021-01-01 00:00:00.0", rs.getTimestamp("f1").toString());
+    }
+
+    @Test
+    public void getRow() throws SQLException {
+        int row = rs.getRow();
+        Assert.assertEquals(1, row);
+        rs.beforeFirst();
+        row = rs.getRow();
+        Assert.assertEquals(0, row);
+        rs.first();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void absolute() throws SQLException {
+        rs.absolute(-1);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void relative() throws SQLException {
+        rs.relative(-1);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void previous() throws SQLException {
+        rs.previous();
+    }
+
+    @Test(expected = SQLException.class)
+    public void setFetchDirection() throws SQLException {
+        rs.setFetchDirection(ResultSet.FETCH_FORWARD);
+        rs.setFetchDirection(ResultSet.FETCH_UNKNOWN);
+    }
+
+    @Test
+    public void getFetchDirection() throws SQLException {
+        Assert.assertEquals(ResultSet.FETCH_FORWARD, rs.getFetchDirection());
+    }
+
+    @Test(expected = SQLException.class)
+    public void setFetchSize() throws SQLException {
+        rs.setFetchSize(0);
+    }
+
+    @Test
+    public void getFetchSize() throws SQLException {
+        Assert.assertEquals(1, rs.getFetchSize());
+    }
+
+    @Test
+    public void getType() throws SQLException {
+        Assert.assertEquals(ResultSet.TYPE_FORWARD_ONLY, rs.getType());
+    }
+
+    @Test
+    public void getConcurrency() throws SQLException {
+        Assert.assertEquals(ResultSet.CONCUR_READ_ONLY, rs.getConcurrency());
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void rowUpdated() throws SQLException {
+        rs.rowUpdated();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void rowInserted() throws SQLException {
+        rs.rowInserted();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void rowDeleted() throws SQLException {
+        rs.rowDeleted();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateNull() throws SQLException {
+        rs.updateNull("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateBoolean() throws SQLException {
+        rs.updateBoolean(1, false);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateByte() throws SQLException {
+        rs.updateByte(1, new Byte("0"));
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateShort() throws SQLException {
+        rs.updateShort(1, new Short("0"));
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateInt() throws SQLException {
+        rs.updateInt(1, 1);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateLong() throws SQLException {
+        rs.updateLong(1, 1l);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateFloat() throws SQLException {
+        rs.updateFloat(1, 1f);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateDouble() throws SQLException {
+        rs.updateDouble(1, 1.0);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateBigDecimal() throws SQLException {
+        rs.updateBigDecimal(1, new BigDecimal(1));
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateString() throws SQLException {
+        rs.updateString(1, "abc");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateBytes() throws SQLException {
+        rs.updateBytes(1, new byte[]{});
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateDate() throws SQLException {
+        rs.updateDate(1, new Date(System.currentTimeMillis()));
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateTime() throws SQLException {
+        rs.updateTime(1, new Time(System.currentTimeMillis()));
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateTimestamp() throws SQLException {
+        rs.updateTimestamp(1, new Timestamp(System.currentTimeMillis()));
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateAsciiStream() throws SQLException {
+        rs.updateAsciiStream(1, null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateBinaryStream() throws SQLException {
+        rs.updateBinaryStream(1, null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateCharacterStream() throws SQLException {
+        rs.updateCharacterStream(1, null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateObject() throws SQLException {
+        rs.updateObject(1, null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void insertRow() throws SQLException {
+        rs.insertRow();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateRow() throws SQLException {
+        rs.updateRow();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void deleteRow() throws SQLException {
+        rs.deleteRow();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void refreshRow() throws SQLException {
+        rs.refreshRow();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void cancelRowUpdates() throws SQLException {
+        rs.cancelRowUpdates();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void moveToInsertRow() throws SQLException {
+        rs.moveToInsertRow();
+    }
+
+    @Test
+    public void getStatement() throws SQLException {
+        Statement stmt = rs.getStatement();
+        Assert.assertNotNull(stmt);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void moveToCurrentRow() throws SQLException {
+        rs.moveToCurrentRow();
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getRef() throws SQLException {
+        rs.getRef(1);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getBlob() throws SQLException {
+        rs.getBlob("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getClob() throws SQLException {
+        rs.getClob("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getArray() throws SQLException {
+        rs.getArray("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getURL() throws SQLException {
+        rs.getURL("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateRef() throws SQLException {
+        rs.updateRef("f1", null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateBlob() throws SQLException {
+        rs.updateBlob(1, (InputStream) null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateClob() throws SQLException {
+        rs.updateClob(1, (Reader) null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateArray() throws SQLException {
+        rs.updateArray(1, null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getRowId() throws SQLException {
+        rs.getRowId("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateRowId() throws SQLException {
+        rs.updateRowId(1, null);
+    }
+
+    @Test
+    public void getHoldability() throws SQLException {
+        Assert.assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, rs.getHoldability());
+    }
+
+    @Test
+    public void isClosed() throws SQLException {
+        Assert.assertFalse(rs.isClosed());
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateNString() throws SQLException {
+        rs.updateNString(1, null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateNClob() throws SQLException {
+        rs.updateNClob(1, (Reader) null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getNClob() throws SQLException {
+        rs.getNClob("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getSQLXML() throws SQLException {
+        rs.getSQLXML("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateSQLXML() throws SQLException {
+        rs.updateSQLXML(1, null);
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getNString() throws SQLException {
+        rs.getNString("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void getNCharacterStream() throws SQLException {
+        rs.getNCharacterStream("f1");
+    }
+
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void updateNCharacterStream() throws SQLException {
+        rs.updateNCharacterStream(1, null);
+    }
+
+    @Test
+    public void unwrap() throws SQLException {
+        RestfulResultSet unwrap = rs.unwrap(RestfulResultSet.class);
+        Assert.assertNotNull(unwrap);
+    }
+
+    @Test
+    public void isWrapperFor() throws SQLException {
+        Assert.assertTrue(rs.isWrapperFor(RestfulResultSet.class));
+    }
+
+    @BeforeClass
+    public static void beforeClass() {
+        try {
+            Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
+            conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/restful_test?user=root&password=taosdata");
+            stmt = conn.createStatement();
+            stmt.execute("create database if not exists restful_test");
+            stmt.execute("use restful_test");
+            stmt.execute("drop table if exists weather");
+            stmt.execute("create table if not exists weather(f1 timestamp, f2 int, f3 bigint, f4 float, f5 double, f6 binary(64), f7 smallint, f8 tinyint, f9 bool, f10 nchar(64))");
+            stmt.execute("insert into restful_test.weather values('2021-01-01 00:00:00.000', 1, 100, 3.1415, 3.1415926, 'abc', 10, 10, true, '涛思数据')");
+            rs = stmt.executeQuery("select * from restful_test.weather");
+            rs.next();
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    @AfterClass
+    public static void afterClass() {
+        try {
+            if (rs != null)
+                rs.close();
+            if (stmt != null)
+                stmt.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/SQLTest.java

 package com.taosdata.jdbc.rs;
 
+import com.taosdata.jdbc.utils.SQLExecutor;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.FixMethodOrder;
@@ -10,379 +11,316 @@ import java.sql.*;
 
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 public class SQLTest {
-    private static final String host = "127.0.0.1";
-
+//    private static final String host = "127.0.0.1";
+    private static final String host = "master";
     private static Connection connection;
 
     @Test
     public void testCase001() {
         String sql = "create database if not exists restful_test";
-        execute(sql);
+        SQLExecutor.execute(connection, sql);
     }
 
     @Test
     public void testCase002() {
         String sql = "use restful_test";
-        execute(sql);
+        SQLExecutor.execute(connection, sql);
     }
 
     @Test
     public void testCase003() {
         String sql = "show databases";
-        executeWithResult(sql);
+        SQLExecutor.executeWithResult(connection, sql);
     }
 
     @Test
     public void testCase004() {
         String sql = "show tables";
-        executeWithResult(sql);
+        SQLExecutor.executeWithResult(connection, sql);
     }
 
     @Test
     public void testCase005() {
         String sql = "show stables";
-        executeWithResult(sql);
+        SQLExecutor.executeWithResult(connection, sql);
     }
 
     @Test
     public void testCase006() {
         String sql = "show dnodes";
-        executeWithResult(sql);
+        SQLExecutor.executeWithResult(connection, sql);
     }
 
     @Test
     public void testCase007() {
         String sql = "show vgroups";
-        executeWithResult(sql);
+        SQLExecutor.executeWithResult(connection, sql);
     }
 
     @Test
     public void testCase008() {
         String sql = "drop table if exists restful_test.weather";
-        execute(sql);
+        SQLExecutor.execute(connection, sql);
     }
 
     @Test
     public void testCase009() {
         String sql = "create table if not exists restful_test.weather(ts timestamp, temperature float) tags(location nchar(64))";
-        execute(sql);
+        SQLExecutor.execute(connection, sql);
     }
 
     @Test
     public void testCase010() {
         String sql = "create table t1 using restful_test.weather tags('北京')";
-        execute(sql);
+        SQLExecutor.execute(connection, sql);
     }
 
     @Test
     public void testCase011() {
         String sql = "insert into restful_test.t1 values(now, 22.22)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase012() {
         String sql = "insert into restful_test.t1 values('2020-01-01 00:00:00.000', 22.22)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase013() {
         String sql = "insert into restful_test.t1 values('2020-01-01 00:01:00.000', 22.22),('2020-01-01 00:02:00.000', 22.22)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase014() {
         String sql = "insert into restful_test.t2 using weather tags('上海') values('2020-01-01 00:03:00.000', 22.22)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase015() {
         String sql = "insert into restful_test.t2 using weather tags('上海') values('2020-01-01 00:01:00.000', 22.22),('2020-01-01 00:02:00.000', 22.22)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase016() {
         String sql = "insert into t1 values('2020-01-01 01:0:00.000', 22.22),('2020-01-01 02:00:00.000', 22.22) t2 values('2020-01-01 01:0:00.000', 33.33),('2020-01-01 02:00:00.000', 33.33)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase017() {
         String sql = "Insert into t3 using weather tags('广东') values('2020-01-01 01:0:00.000', 22.22),('2020-01-01 02:00:00.000', 22.22) t4 using weather tags('天津') values('2020-01-01 01:0:00.000', 33.33),('2020-01-01 02:00:00.000', 33.33)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase018() {
         String sql = "select * from restful_test.t1";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase019() {
         String sql = "select * from restful_test.weather";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase020() {
         String sql = "select ts, temperature from restful_test.t1";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase021() {
         String sql = "select ts, temperature from restful_test.weather";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase022() {
         String sql = "select temperature, ts from restful_test.t1";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase023() {
         String sql = "select temperature, ts from restful_test.weather";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase024() {
         String sql = "import into restful_test.t5 using weather tags('石家庄') values('2020-01-01 00:01:00.000', 22.22)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase025() {
         String sql = "import into restful_test.t6 using weather tags('沈阳') values('2020-01-01 00:01:00.000', 22.22),('2020-01-01 00:02:00.000', 22.22)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase026() {
         String sql = "import into restful_test.t7 using weather tags('长沙') values('2020-01-01 00:01:00.000', 22.22) restful_test.t8 using weather tags('吉林') values('2020-01-01 00:01:00.000', 22.22)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase027() {
         String sql = "import into restful_test.t9 using weather tags('武汉') values('2020-01-01 00:01:00.000', 22.22) ,('2020-01-02 00:01:00.000', 22.22) restful_test.t10 using weather tags('哈尔滨') values('2020-01-01 00:01:00.000', 22.22),('2020-01-02 00:01:00.000', 22.22)";
-        executeUpdate(sql);
+        SQLExecutor.executeUpdate(connection, sql);
     }
 
     @Test
     public void testCase028() {
         String sql = "select location, temperature, ts from restful_test.weather where temperature > 1";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase029() {
         String sql = "select location, temperature, ts from restful_test.weather where temperature < 1";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase030() {
         String sql = "select location, temperature, ts from restful_test.weather where ts  > now";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase031() {
         String sql = "select location, temperature, ts from restful_test.weather where ts  < now";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase032() {
         String sql = "select count(*) from restful_test.weather";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase033() {
         String sql = "select first(*) from restful_test.weather";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase034() {
         String sql = "select last(*) from restful_test.weather";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase035() {
         String sql = "select last_row(*) from restful_test.weather";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase036() {
         String sql = "select ts, ts as primary_key from restful_test.weather";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
 
     @Test
     public void testCase037() {
         String sql = "select database()";
-        execute("use restful_test");
-        executeQuery(sql);
+        SQLExecutor.execute(connection, "use restful_test");
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase038() {
         String sql = "select client_version()";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase039() {
         String sql = "select server_status()";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase040() {
         String sql = "select server_status() as status";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase041() {
         String sql = "select tbname, location from restful_test.weather";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase042() {
         String sql = "select count(tbname) from restful_test.weather";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase043() {
         String sql = "select * from restful_test.weather where ts < now - 1h";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase044() {
         String sql = "select * from restful_test.weather where ts < now - 1h and location like '%'";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase045() {
         String sql = "select * from restful_test.weather where ts < now - 1h order by ts";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase046() {
         String sql = "select last(*) from restful_test.weather where ts < now - 1h group by tbname order by tbname";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase047() {
         String sql = "select * from restful_test.weather limit 2";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase048() {
         String sql = "select * from restful_test.weather limit 2 offset 5";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase049() {
         String sql = "select * from restful_test.t1, restful_test.t3 where t1.ts = t3.ts ";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase050() {
         String sql = "select * from restful_test.t1, restful_test.t3 where t1.ts = t3.ts and t1.location = t3.location";
-        executeQuery(sql);
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @Test
     public void testCase051() {
         String sql = "select * from restful_test.t1 tt, restful_test.t3 yy where tt.ts = yy.ts";
-        executeQuery(sql);
-    }
-
-    private void executeUpdate(String sql) {
-        try (Statement statement = connection.createStatement()) {
-            long start = System.currentTimeMillis();
-            int affectedRows = statement.executeUpdate(sql);
-            long end = System.currentTimeMillis();
-            System.out.println("[ affected rows : " + affectedRows + " ] time cost: " + (end - start) + " ms, execute statement ====> " + sql);
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private void executeWithResult(String sql) {
-        try (Statement statement = connection.createStatement()) {
-            statement.execute(sql);
-            ResultSet resultSet = statement.getResultSet();
-            printResult(resultSet);
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private void execute(String sql) {
-        try (Statement statement = connection.createStatement()) {
-            long start = System.currentTimeMillis();
-            boolean execute = statement.execute(sql);
-            long end = System.currentTimeMillis();
-            printSql(sql, execute, (end - start));
-        } catch (SQLException e) {
-            System.out.println("ERROR execute SQL ===> " + sql);
-            e.printStackTrace();
-        }
-    }
-
-    private static void printSql(String sql, boolean succeed, long cost) {
-        System.out.println("[ " + (succeed ? "OK" : "ERROR!") + " ] time cost: " + cost + " ms, execute statement ====> " + sql);
-    }
-
-    private void executeQuery(String sql) {
-        try (Statement statement = connection.createStatement()) {
-            long start = System.currentTimeMillis();
-            ResultSet resultSet = statement.executeQuery(sql);
-            long end = System.currentTimeMillis();
-            printSql(sql, true, (end - start));
-            printResult(resultSet);
-        } catch (SQLException e) {
-            System.out.println("ERROR execute SQL ===> " + sql);
-            e.printStackTrace();
-        }
-    }
-
-    private static void printResult(ResultSet resultSet) throws SQLException {
-        ResultSetMetaData metaData = resultSet.getMetaData();
-        while (resultSet.next()) {
-            StringBuilder sb = new StringBuilder();
-            for (int i = 1; i <= metaData.getColumnCount(); i++) {
-                String columnLabel = metaData.getColumnLabel(i);
-                String value = resultSet.getString(i);
-                sb.append(columnLabel + ": " + value + "\t");
-            }
-            System.out.println(sb.toString());
-        }
+        SQLExecutor.executeQuery(connection, sql);
     }
 
     @BeforeClass

src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/SQLExecutor.java

+package com.taosdata.jdbc.utils;
+
+import java.sql.*;
+
+public class SQLExecutor {
+
+    // insert, import
+    public static void executeUpdate(Connection connection, String sql) {
+        try (Statement statement = connection.createStatement()) {
+            long start = System.currentTimeMillis();
+            int affectedRows = statement.executeUpdate(sql);
+            long end = System.currentTimeMillis();
+            System.out.println("[ affected rows : " + affectedRows + " ] time cost: " + (end - start) + " ms, execute statement ====> " + sql);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // show databases, show tables, show stables
+    public static void executeWithResult(Connection connection, String sql) {
+        try (Statement statement = connection.createStatement()) {
+            statement.execute(sql);
+            ResultSet resultSet = statement.getResultSet();
+            printResult(resultSet);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // use database, create database, create table, drop table...
+    public static void execute(Connection connection, String sql) {
+        try (Statement statement = connection.createStatement()) {
+            long start = System.currentTimeMillis();
+            boolean execute = statement.execute(sql);
+            long end = System.currentTimeMillis();
+            printSql(sql, execute, (end - start));
+        } catch (SQLException e) {
+            System.out.println("ERROR execute SQL ===> " + sql);
+            e.printStackTrace();
+        }
+    }
+
+    // select
+    public static void executeQuery(Connection connection, String sql) {
+        try (Statement statement = connection.createStatement()) {
+            long start = System.currentTimeMillis();
+            ResultSet resultSet = statement.executeQuery(sql);
+            long end = System.currentTimeMillis();
+            printSql(sql, true, (end - start));
+            printResult(resultSet);
+        } catch (SQLException e) {
+            System.out.println("ERROR execute SQL ===> " + sql);
+            e.printStackTrace();
+        }
+    }
+
+    private static void printSql(String sql, boolean succeed, long cost) {
+        System.out.println("[ " + (succeed ? "OK" : "ERROR!") + " ] time cost: " + cost + " ms, execute statement ====> " + sql);
+    }
+
+    private static void printResult(ResultSet resultSet) throws SQLException {
+        ResultSetMetaData metaData = resultSet.getMetaData();
+        while (resultSet.next()) {
+            StringBuilder sb = new StringBuilder();
+            for (int i = 1; i <= metaData.getColumnCount(); i++) {
+                String columnLabel = metaData.getColumnLabel(i);
+                String value = resultSet.getString(i);
+                sb.append(columnLabel + ": " + value + "\t");
+            }
+            System.out.println(sb.toString());
+        }
+    }
+
+}

tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JdbcRestfulDemo.java

@@ -14,13 +14,14 @@ public class JdbcRestfulDemo {
             String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata";
 
             Properties properties = new Properties();
-            properties.setProperty("charset", "UTF-8");
-            properties.setProperty("locale", "en_US.UTF-8");
-            properties.setProperty("timezone", "UTC-8");
+//            properties.setProperty("charset", "UTF-8");
+//            properties.setProperty("locale", "en_US.UTF-8");
+//            properties.setProperty("timezone", "UTC-8");
 
             Connection conn = DriverManager.getConnection(url, properties);
             Statement stmt = conn.createStatement();
 
+            stmt.execute("drop database if exists restful_test");
             stmt.execute("create database if not exists restful_test");
             stmt.execute("use restful_test");
             stmt.execute("create table restful_test.weather(ts timestamp, temperature float) tags(location nchar(64))");
@@ -34,6 +35,7 @@ public class JdbcRestfulDemo {
                 System.out.println();
             }
 
+            rs.close();
             stmt.close();
             conn.close();
         } catch (ClassNotFoundException e) {

tests/examples/JDBC/connectionPools/pom.xml

@@ -12,7 +12,7 @@
         <dependency>
             <groupId>com.taosdata.jdbc</groupId>
             <artifactId>taos-jdbcdriver</artifactId>
-            <version>2.0.11</version>
+            <version>2.0.17</version>
         </dependency>
 
         <!-- druid -->
@@ -44,7 +44,6 @@
             <artifactId>c3p0</artifactId>
             <version>0.9.5.4</version>
         </dependency>
-
         <!-- log4j -->
         <dependency>
             <groupId>log4j</groupId>