change

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

 package com.taosdata.jdbc.rs;
 
 import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import com.taosdata.jdbc.TSDBConstants;
-import org.apache.commons.lang3.StringUtils;
 
 import java.io.InputStream;
 import java.io.Reader;
@@ -10,45 +10,104 @@ import java.math.BigDecimal;
 import java.net.URL;
 import java.sql.*;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Map;
 
 public class RestfulResultSet implements ResultSet {
-    private boolean isClosed = false;
+    private static final String RESULT_SET_IS_CLOSED = "resultSet is closed.";
+    private volatile boolean isClosed;
     private int pos = -1;
-    private ArrayList<ArrayList<String>> data;
-    private ArrayList<String> fields;
 
-    public RestfulResultSet(String str, String fieldData) {
-        data = new ArrayList<>();
-        str = str.substring(2, str.length() - 2);
-        ArrayList<String> strTemp = new ArrayList<>(Arrays.asList(str.split("],\\[")));
-        for (String s : strTemp) {
-            ArrayList<String> curr = new ArrayList<>(Arrays.asList(s.split(",")));
-            data.add(curr);
-        }
-        if (!StringUtils.isBlank(fieldData)) {
-            fields = new ArrayList<>();
-            fieldData = fieldData.substring(2, fieldData.length() - 2);
-            ArrayList<String> fieldTemp = new ArrayList<>(Arrays.asList(fieldData.split("],\\[")));
-            for (String s : fieldTemp) {
-                String curr = Arrays.asList(s.split(",")).get(0);
-                fields.add(curr.substring(1, curr.length() - 1)); // 去掉双引号
+    private final String database;
+    private final Statement statement;
+    // data
+    private ArrayList<ArrayList<Object>> resultSet;
+    // meta
+    private ArrayList<String> columnNames;
+    private ArrayList<Field> columns;
+    private RestfulResultSetMetaData metaData;
+
+    /**
+     * 由一个result的Json构造结果集，对应执行show databases,show tables等这些语句，返回结果集，但无法获取结果集对应的meta，统一当成String处理
+     ***/
+    public RestfulResultSet(String database, Statement statement, JSONObject resultJson) {
+        this.database = database;
+        this.statement = statement;
+        // row data
+        JSONArray data = resultJson.getJSONArray("data");
+        resultSet = new ArrayList<>();
+        int columnIndex = 0;
+        for (; columnIndex < data.size(); columnIndex++) {
+            ArrayList oneRow = new ArrayList<>();
+            JSONArray one = data.getJSONArray(columnIndex);
+            for (int j = 0; j < one.size(); j++) {
+                oneRow.add(one.getString(j));
+            }
+            resultSet.add(oneRow);
+        }
+
+        // column only names
+        columnNames = new ArrayList<>();
+        columns = new ArrayList<>();
+        JSONArray head = resultJson.getJSONArray("head");
+        for (int i = 0; i < head.size(); i++) {
+            String name = head.getString(i);
+            columnNames.add(name);
+            columns.add(new Field(name, "", 0, ""));
+        }
+        this.metaData = new RestfulResultSetMetaData(this.database, columns);
+    }
+
+    /**
+     * 由2个resultSet的JSON构造结果集
+     * @param resultJson: 包含data信息的结果集，有sql返回的结果集
+     * @param fieldJson: 包含meta信息的结果集，有describe xxx
+     * **/
+    public RestfulResultSet(String database, Statement statement, JSONObject resultJson, JSONObject fieldJson) {
+        this(database, statement, resultJson);
+        ArrayList<Field> newColumns = new ArrayList<>();
+        for (Field column : columns) {
+            Field field = findField(column.name, fieldJson.getJSONArray("data"));
+            if (field != null) {
+                newColumns.add(field);
+            } else {
+                newColumns.add(column);
+            }
+        }
+        this.columns = newColumns;
+        this.metaData = new RestfulResultSetMetaData(this.database, this.columns);
+    }
+
+    public Field findField(String columnName, JSONArray fieldDataJson) {
+        for (int i = 0; i < fieldDataJson.size(); i++) {
+            JSONArray field = fieldDataJson.getJSONArray(i);
+            if (columnName.equalsIgnoreCase(field.getString(0))) {
+                return new Field(field.getString(0), field.getString(1), field.getInteger(2), field.getString(3));
             }
         }
+        return null;
     }
 
-    public RestfulResultSet(JSONArray data, JSONArray head) {
-        for (int i = 0; i < data.size(); i++) {
+    public class Field {
+        String name;
+        String type;
+        int length;
+        String note;
 
+        public Field(String name, String type, int length, String note) {
+            this.name = name;
+            this.type = type;
+            this.length = length;
+            this.note = note;
         }
     }
 
     @Override
     public boolean next() throws SQLException {
-        if (isClosed) throw new SQLException(TSDBConstants.WrapErrMsg("Result is Closed!!!"));
-        if (pos < data.size() - 1) {
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        if (pos < resultSet.size() - 1) {
             pos++;
             return true;
         }
@@ -57,24 +116,34 @@ public class RestfulResultSet implements ResultSet {
 
     @Override
     public void close() throws SQLException {
+        synchronized (RestfulResultSet.class) {
             this.isClosed = true;
         }
+    }
 
     @Override
     public boolean wasNull() throws SQLException {
-        return data.isEmpty();
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+        return resultSet.isEmpty();
     }
 
     @Override
     public String getString(int columnIndex) throws SQLException {
-        if (columnIndex > data.get(pos).size()) {
-            throw new SQLException(TSDBConstants.WrapErrMsg("Column Index out of range, " + columnIndex + " > " + data.get(pos).size()));
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        if (columnIndex > resultSet.get(pos).size()) {
+            throw new SQLException(TSDBConstants.WrapErrMsg("Column Index out of range, " + columnIndex + " > " + resultSet.get(pos).size()));
         }
-        return data.get(pos).get(columnIndex - 1);
+        return resultSet.get(pos).get(columnIndex - 1).toString();
     }
 
     @Override
     public boolean getBoolean(int columnIndex) throws SQLException {
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         String result = getString(columnIndex);
         if (!(result.equals("true") || result.equals("false"))) {
             throw new SQLException("not boolean value");
@@ -84,65 +153,90 @@ public class RestfulResultSet implements ResultSet {
 
     @Override
     public byte getByte(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public short getShort(int columnIndex) throws SQLException {
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         return Short.parseShort(getString(columnIndex));
     }
 
     @Override
     public int getInt(int columnIndex) throws SQLException {
-        String result = getString(columnIndex);
-        return Integer.parseInt(result);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+        return Integer.parseInt(getString(columnIndex));
     }
 
     @Override
     public long getLong(int columnIndex) throws SQLException {
-        String result = getString(columnIndex);
-        return Long.parseLong(result);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        return Long.parseLong(getString(columnIndex));
     }
 
     @Override
     public float getFloat(int columnIndex) throws SQLException {
-        String result = getString(columnIndex);
-        return Float.parseFloat(result);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        return Float.parseFloat(getString(columnIndex));
     }
 
     @Override
     public double getDouble(int columnIndex) throws SQLException {
-        String result = getString(columnIndex);
-        return Double.parseDouble(result);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        return Double.parseDouble(getString(columnIndex));
     }
 
+    /*******************************************************************************************************************/
+
     @Override
     public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public byte[] getBytes(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Date getDate(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Time getTime(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Timestamp getTimestamp(int columnIndex) throws SQLException {
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         String strDate = getString(columnIndex);
         strDate = strDate.substring(1, strDate.length() - 1);
         return Timestamp.valueOf(strDate);
@@ -150,756 +244,748 @@ public class RestfulResultSet implements ResultSet {
 
     @Override
     public InputStream getAsciiStream(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public InputStream getUnicodeStream(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public InputStream getBinaryStream(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public String getString(String columnLabel) throws SQLException {
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         return getString(findColumn(columnLabel) + 1);
     }
 
     @Override
     public boolean getBoolean(String columnLabel) throws SQLException {
-        return Boolean.parseBoolean(getString(columnLabel));
+        return getBoolean(findColumn(columnLabel));
     }
 
     @Override
     public byte getByte(String columnLabel) throws SQLException {
-        return 0;
+        return getByte(findColumn(columnLabel));
     }
 
     @Override
     public short getShort(String columnLabel) throws SQLException {
-        return Short.parseShort(getString(columnLabel));
+        return getShort(findColumn(columnLabel));
     }
 
     @Override
     public int getInt(String columnLabel) throws SQLException {
-        return Integer.parseInt(getString(columnLabel));
+        return getInt(findColumn(columnLabel));
     }
 
     @Override
     public long getLong(String columnLabel) throws SQLException {
-        return Long.parseLong(getString(columnLabel));
+        return getLong(findColumn(columnLabel));
     }
 
     @Override
     public float getFloat(String columnLabel) throws SQLException {
-        String result = getString(columnLabel);
-        return Float.parseFloat(result);
+        return getFloat(findColumn(columnLabel));
     }
 
     @Override
     public double getDouble(String columnLabel) throws SQLException {
-        return Double.parseDouble(getString(columnLabel));
+        return getDouble(findColumn(columnLabel));
     }
 
     @Override
     public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
-        return null;
+        return getBigDecimal(findColumn(columnLabel));
     }
 
     @Override
     public byte[] getBytes(String columnLabel) throws SQLException {
-        return new byte[0];
+        return getBytes(findColumn(columnLabel));
     }
 
     @Override
     public Date getDate(String columnLabel) throws SQLException {
-        return null;
+        return getDate(findColumn(columnLabel));
     }
 
     @Override
     public Time getTime(String columnLabel) throws SQLException {
-        return null;
+        return getTime(findColumn(columnLabel));
     }
 
     @Override
     public Timestamp getTimestamp(String columnLabel) throws SQLException {
-        return Timestamp.valueOf(getString(columnLabel));
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+        return Timestamp.valueOf(getString(findColumn(columnLabel)));
     }
 
     @Override
     public InputStream getAsciiStream(String columnLabel) throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public InputStream getUnicodeStream(String columnLabel) throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public InputStream getBinaryStream(String columnLabel) throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public SQLWarning getWarnings() throws SQLException {
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
         return null;
-        //TODO: SQLFeature Not Supported
-//        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void clearWarnings() throws SQLException {
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
         return;
-        //TODO: SQLFeature Not Supported
-//        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public String getCursorName() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public ResultSetMetaData getMetaData() throws SQLException {
-        return new RestfulResultSetMetaData(fields);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        return this.metaData;
     }
 
     @Override
     public Object getObject(int columnIndex) throws SQLException {
-//        return null;
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Object getObject(String columnLabel) throws SQLException {
-//        return null;
-        //TODO: SQLFeature Not Supported
-        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return getObject(findColumn(columnLabel));
     }
 
     @Override
     public int findColumn(String columnLabel) throws SQLException {
-        return fields.indexOf(columnLabel);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        return columnNames.indexOf(columnLabel);
     }
 
     @Override
     public Reader getCharacterStream(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Reader getCharacterStream(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean isBeforeFirst() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean isAfterLast() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean isFirst() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean isLast() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void beforeFirst() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void afterLast() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean first() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean last() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int getRow() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean absolute(int row) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean relative(int rows) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean previous() throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void setFetchDirection(int direction) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+        if (direction != ResultSet.FETCH_REVERSE || direction != ResultSet.FETCH_REVERSE || direction != ResultSet.FETCH_UNKNOWN)
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int getFetchDirection() throws SQLException {
-        //TODO: SQLFeature Not Supported
-        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        return ResultSet.FETCH_FORWARD;
     }
 
     @Override
     public void setFetchSize(int rows) throws SQLException {
-        //TODO: SQLFeature Not Supported
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+        if (rows < 0)
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int getFetchSize() throws SQLException {
-        //TODO: SQLFeature Not Supported
-        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        return this.resultSet.size();
     }
 
     @Override
     public int getType() throws SQLException {
-        //TODO: SQLFeature Not Supported
-        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return ResultSet.TYPE_FORWARD_ONLY;
     }
 
     @Override
     public int getConcurrency() throws SQLException {
-        //TODO: SQLFeature Not Supported
-        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return ResultSet.CONCUR_READ_ONLY;
     }
 
     @Override
     public boolean rowUpdated() throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean rowInserted() throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean rowDeleted() throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNull(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBoolean(int columnIndex, boolean x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateByte(int columnIndex, byte x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateShort(int columnIndex, short x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateInt(int columnIndex, int x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateLong(int columnIndex, long x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateFloat(int columnIndex, float x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateDouble(int columnIndex, double x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateString(int columnIndex, String x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBytes(int columnIndex, byte[] x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateDate(int columnIndex, Date x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateTime(int columnIndex, Time x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateObject(int columnIndex, Object x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNull(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBoolean(String columnLabel, boolean x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateByte(String columnLabel, byte x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateShort(String columnLabel, short x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateInt(String columnLabel, int x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateLong(String columnLabel, long x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateFloat(String columnLabel, float x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateDouble(String columnLabel, double x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateString(String columnLabel, String x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBytes(String columnLabel, byte[] x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateDate(String columnLabel, Date x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateTime(String columnLabel, Time x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateObject(String columnLabel, Object x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void insertRow() throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateRow() throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void deleteRow() throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void refreshRow() throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void cancelRowUpdates() throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void moveToInsertRow() throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void moveToCurrentRow() throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Statement getStatement() throws SQLException {
-        //TODO: SQLFeature Not Supported
-        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        if (isClosed())
+            throw new SQLException(TSDBConstants.WrapErrMsg(RESULT_SET_IS_CLOSED));
+
+        return this.statement;
     }
 
     @Override
     public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Ref getRef(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Blob getBlob(int columnIndex) throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Clob getClob(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Array getArray(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
+    /******************************************************************************************************************/
     @Override
     public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Ref getRef(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Blob getBlob(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Clob getClob(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Array getArray(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Date getDate(int columnIndex, Calendar cal) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Date getDate(String columnLabel, Calendar cal) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Time getTime(int columnIndex, Calendar cal) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Time getTime(String columnLabel, Calendar cal) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public URL getURL(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public URL getURL(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateRef(int columnIndex, Ref x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateRef(String columnLabel, Ref x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBlob(int columnIndex, Blob x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBlob(String columnLabel, Blob x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateClob(int columnIndex, Clob x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateClob(String columnLabel, Clob x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateArray(int columnIndex, Array x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateArray(String columnLabel, Array x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public RowId getRowId(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public RowId getRowId(String columnLabel) throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateRowId(int columnIndex, RowId x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateRowId(String columnLabel, RowId x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int getHoldability() throws SQLException {
-//        return 0;
-        //TODO: SQLFeature Not Supported
-        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return ResultSet.HOLD_CURSORS_OVER_COMMIT;
     }
 
     @Override
@@ -911,277 +997,231 @@ public class RestfulResultSet implements ResultSet {
 
     @Override
     public void updateNString(int columnIndex, String nString) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNString(String columnLabel, String nString) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public NClob getNClob(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public NClob getNClob(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public SQLXML getSQLXML(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public SQLXML getSQLXML(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public String getNString(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public String getNString(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Reader getNCharacterStream(int columnIndex) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Reader getNCharacterStream(String columnLabel) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateClob(int columnIndex, Reader reader) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateClob(String columnLabel, Reader reader) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNClob(int columnIndex, Reader reader) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void updateNClob(String columnLabel, Reader reader) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public <T> T unwrap(Class<T> iface) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean isWrapperFor(Class<?> iface) throws SQLException {
-        //TODO: SQLFeature Not Supported
         throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 }

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

@@ -2,13 +2,15 @@ package com.taosdata.jdbc.rs;
 
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
-import java.util.List;
+import java.util.ArrayList;
 
 public class RestfulResultSetMetaData implements ResultSetMetaData {
 
-    private List<String> fields;
+    private final String database;
+    private ArrayList<RestfulResultSet.Field> fields;
 
-    public RestfulResultSetMetaData(List<String> fields) {
+    public RestfulResultSetMetaData(String database, ArrayList<RestfulResultSet.Field> fields) {
+        this.database = database;
         this.fields = fields;
     }
 
@@ -24,6 +26,7 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     @Override
     public boolean isCaseSensitive(int column) throws SQLException {
+        //TODO
         return false;
     }
 
@@ -39,7 +42,7 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     @Override
     public int isNullable(int column) throws SQLException {
-        return 0;
+        return ResultSetMetaData.columnNullable;
     }
 
     @Override
@@ -54,7 +57,7 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     @Override
     public String getColumnLabel(int column) throws SQLException {
-        return fields.get(column - 1);
+        return fields.get(column - 1).name;
     }
 
     @Override
@@ -64,7 +67,7 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     @Override
     public String getSchemaName(int column) throws SQLException {
-        return null;
+        return this.database;
     }
 
     @Override
@@ -84,7 +87,7 @@ public class RestfulResultSetMetaData implements ResultSetMetaData {
 
     @Override
     public String getCatalogName(int column) throws SQLException {
-        return null;
+        return this.database;
     }
 
     @Override

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

@@ -8,6 +8,7 @@ import com.taosdata.jdbc.rs.util.HttpClientPoolUtil;
 import com.taosdata.jdbc.utils.SqlSyntaxValidator;
 
 import java.sql.*;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
@@ -27,6 +28,16 @@ public class RestfulStatement implements Statement {
         this.database = database;
     }
 
+    private String parseTableIdentifier(String sql) {
+        List<String> words = Arrays.asList(sql.trim().toLowerCase().split(" "));
+        if (words.get(0).equalsIgnoreCase("select")) {
+            if (words.contains("from")) {
+                return words.get(words.indexOf("from") + 1);
+            }
+        }
+        return null;
+    }
+
     @Override
     public ResultSet executeQuery(String sql) throws SQLException {
         if (isClosed())
@@ -35,39 +46,27 @@ public class RestfulStatement implements Statement {
             throw new SQLException("not a select sql for executeQuery: " + sql);
 
         final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
+        // row data
         String result = HttpClientPoolUtil.execute(url, sql);
-        String fields = "";
-        List<String> words = Arrays.asList(sql.split(" "));
-        if (words.get(0).equalsIgnoreCase("select")) {
-            int index = 0;
-            if (words.contains("from")) {
-                index = words.indexOf("from");
-            }
-            if (words.contains("FROM")) {
-                index = words.indexOf("FROM");
-            }
-            fields = HttpClientPoolUtil.execute(url, "DESCRIBE " + words.get(index + 1));
+        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")));
         }
 
-        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")));
-        }
-        String dataStr = jsonObject.getString("data");
-        if ("use".equalsIgnoreCase(fields.split(" ")[0])) {
-            return new RestfulResultSet(dataStr, "");
+        // parse table name from sql
+        String tableIdentifier = parseTableIdentifier(sql);
+        if (tableIdentifier != null) {
+            // 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")));
             }
-
-        JSONObject jsonField = JSON.parseObject(fields);
-        if (jsonField == null) {
-            return new RestfulResultSet(dataStr, "");
-        }
-        if (jsonField.getString("status").equals("error")) {
-            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonField.getString("desc") + "\n" + "error code: " + jsonField.getString("code")));
+            this.resultSet = new RestfulResultSet(database, this, resultJson, fieldJson);
+        } else {
+            this.resultSet = new RestfulResultSet(database, this, resultJson);
         }
-        String fieldData = jsonField.getString("data");
 
-        this.resultSet = new RestfulResultSet(dataStr, fieldData);
         this.affectedRows = 0;
         return resultSet;
     }
@@ -195,17 +194,19 @@ public class RestfulStatement implements Statement {
 
         if (SqlSyntaxValidator.isSelectSql(sql)) {
             executeQuery(sql);
-        } else if (SqlSyntaxValidator.isInsertSql(sql)) {
-            executeUpdate(sql);
-        } else {
-            final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
-            HttpClientPoolUtil.execute(url, "use " + this.database);
+        } 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 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")));
+            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")));
             }
-            this.resultSet = new RestfulResultSet(jsonObject.getJSONArray("data"), jsonObject.getJSONArray("head"));
+            this.resultSet = new RestfulResultSet(database, this, resultJson);
+        } else {
+            executeUpdate(sql);
         }
 
         return true;

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

@@ -15,14 +15,12 @@
 package com.taosdata.jdbc.utils;
 
 import com.taosdata.jdbc.TSDBConnection;
-import com.taosdata.jdbc.TSDBJNIConnector;
 
 import java.sql.Connection;
-import java.sql.SQLException;
 
 public class SqlSyntaxValidator {
 
-    private static final String[] updateSQL = {"insert", "update", "delete", "create", "alter", "drop", "show", "describe", "use"};
+    private static final String[] updateSQL = {"insert", "update", "delete", "create", "alter", "drop", "show", "describe", "use", "import"};
     private static final String[] querySQL = {"select"};
 
     private TSDBConnection tsdbConnection;
@@ -31,23 +29,6 @@ public class SqlSyntaxValidator {
         this.tsdbConnection = (TSDBConnection) connection;
     }
 
-    /*
-    public boolean validateSqlSyntax(String sql) throws SQLException {
-        boolean res = false;
-        if (tsdbConnection == null || tsdbConnection.isClosed()) {
-            throw new SQLException("invalid connection");
-        } else {
-            TSDBJNIConnector jniConnector = tsdbConnection.getConnection();
-            if (jniConnector == null) {
-                throw new SQLException("jniConnector is null");
-            } else {
-                res = jniConnector.validateCreateTableSql(sql);
-            }
-        }
-        return res;
-    }
-    */
-
     public static boolean isValidForExecuteUpdate(String sql) {
         for (String prefix : updateSQL) {
             if (sql.trim().toLowerCase().startsWith(prefix))
@@ -57,18 +38,28 @@ public class SqlSyntaxValidator {
     }
 
     public static boolean isUseSql(String sql) {
-        return sql.trim().toLowerCase().startsWith(updateSQL[8]) || 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) {
+        return sql.trim().toLowerCase().startsWith("show");
     }
 
-    public static boolean isUpdateSql(String sql) {
-        return sql.trim().toLowerCase().startsWith(updateSQL[1]);
+    public static boolean isDescribeSql(String sql) {
+        return sql.trim().toLowerCase().startsWith("describe");
     }
 
+
     public static boolean isInsertSql(String sql) {
-        return sql.trim().toLowerCase().startsWith(updateSQL[0]);
+        return sql.trim().toLowerCase().startsWith("insert") || sql.trim().toLowerCase().startsWith("import");
     }
 
     public static boolean isSelectSql(String sql) {
-        return sql.trim().toLowerCase().startsWith(querySQL[0]);
+        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/SQLTest.java

 package com.taosdata.jdbc.rs;
 
-import org.junit.*;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
 import org.junit.runners.MethodSorters;
 
 import java.sql.*;
@@ -26,21 +29,313 @@ public class SQLTest {
     @Test
     public void testCase003() {
         String sql = "show databases";
-        try (Statement statement = connection.createStatement()) {
-            statement.execute(sql);
-            ResultSet resultSet = statement.getResultSet();
-            printResult(resultSet);
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
+        executeWithResult(sql);
     }
 
     @Test
     public void testCase004() {
+        String sql = "show tables";
+        executeWithResult(sql);
+    }
+
+    @Test
+    public void testCase005() {
+        String sql = "show stables";
+        executeWithResult(sql);
+    }
+
+    @Test
+    public void testCase006() {
+        String sql = "show dnodes";
+        executeWithResult(sql);
+    }
+
+    @Test
+    public void testCase007() {
+        String sql = "show vgroups";
+        executeWithResult(sql);
+    }
+
+    @Test
+    public void testCase008() {
+        String sql = "drop table if exists restful_test.weather";
+        execute(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);
+    }
+
+    @Test
+    public void testCase010() {
+        String sql = "create table t1 using restful_test.weather tags('北京')";
+        execute(sql);
+    }
+
+    @Test
+    public void testCase011() {
+        String sql = "insert into restful_test.t1 values(now, 22.22)";
+        executeUpdate(sql);
+    }
+
+    @Test
+    public void testCase012() {
+        String sql = "insert into restful_test.t1 values('2020-01-01 00:00:00.000', 22.22)";
+        executeUpdate(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);
+    }
+
+    @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);
+    }
+
+    @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);
+    }
+
+    @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);
+    }
+
+    @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);
+    }
+
+    @Test
+    public void testCase018() {
+        String sql = "select * from restful_test.t1";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase019() {
         String sql = "select * from restful_test.weather";
         executeQuery(sql);
     }
 
+    @Test
+    public void testCase020() {
+        String sql = "select ts, temperature from restful_test.t1";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase021() {
+        String sql = "select ts, temperature from restful_test.weather";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase022() {
+        String sql = "select temperature, ts from restful_test.t1";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase023() {
+        String sql = "select temperature, ts from restful_test.weather";
+        executeQuery(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);
+    }
+
+    @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);
+    }
+
+    @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);
+    }
+
+    @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);
+    }
+
+    @Test
+    public void testCase028() {
+        String sql = "select location, temperature, ts from restful_test.weather where temperature > 1";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase029() {
+        String sql = "select location, temperature, ts from restful_test.weather where temperature < 1";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase30() {
+        String sql = "select location, temperature, ts from restful_test.weather where ts  > now";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase31() {
+        String sql = "select location, temperature, ts from restful_test.weather where ts  < now";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase32() {
+        String sql = "select count(*) from restful_test.weather";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase33() {
+        String sql = "select first(*) from restful_test.weather";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase34() {
+        String sql = "select last(*) from restful_test.weather";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase35() {
+        String sql = "select last_row(*) from restful_test.weather";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase36() {
+        String sql = "select ts, ts as primary_key from restful_test.weather";
+        executeQuery(sql);
+    }
+
+
+    @Test
+    public void testCase037() {
+        String sql = "select database()";
+        execute("use restful_test");
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase038() {
+        String sql = "select client_version()";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase039() {
+        String sql = "select server_status()";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase040() {
+        String sql = "select server_status() as status";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase041() {
+        String sql = "select tbname, location from restful_test.weather";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase042() {
+        String sql = "select count(tbname) from restful_test.weather";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase043() {
+        String sql = "select * from restful_test.weather where ts < now - 1h";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase044() {
+        String sql = "select * from restful_test.weather where ts < now - 1h and location like '%'";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase045() {
+        String sql = "select * from restful_test.weather where ts < now - 1h order by ts";
+        executeQuery(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);
+    }
+
+    @Test
+    public void testCase047() {
+        String sql = "select * from restful_test.weather limit 2";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase048() {
+        String sql = "select * from restful_test.weather limit 2 offset 5";
+        executeQuery(sql);
+    }
+
+    @Test
+    public void testCase049() {
+        String sql = "select * from restful_test.t1, restful_test.t3 where t1.ts = t3.ts ";
+        executeQuery(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);
+    }
+
+    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()) {