change

src/connector/jdbc/pom.xml

@@ -73,6 +73,12 @@
             <version>1.2.58</version>
         </dependency>
 
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>5.1.49</version>
+        </dependency>
+
     </dependencies>
     <build>
         <plugins>

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

@@ -46,6 +46,9 @@ public abstract class TSDBConstants {
     public static final int TSDB_DATA_TYPE_TIMESTAMP = 9;
     public static final int TSDB_DATA_TYPE_NCHAR = 10;
 
+    // nchar field's max length
+    public static final int maxFieldSize = 16 * 1024;
+
     public static String WrapErrMsg(String msg) {
         return "TDengine Error: " + msg;
     }

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

 package com.taosdata.jdbc.rs;
 
 import com.taosdata.jdbc.TSDBConstants;
+import com.taosdata.jdbc.TSDBDriver;
 
 import java.sql.*;
+import java.util.Enumeration;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
 import java.util.concurrent.Executor;
@@ -14,6 +17,11 @@ public class RestfulConnection implements Connection {
     private final Properties props;
     private final String database;
     private final String url;
+    /******************************************************/
+    private boolean isClosed;
+    private DatabaseMetaData metadata;
+    private Map<String, Class<?>> typeMap;
+    private Properties clientInfoProps = new Properties();
 
     public RestfulConnection(String host, String port, Properties props, String database, String url) {
         this.host = host;
@@ -21,90 +29,94 @@ public class RestfulConnection implements Connection {
         this.props = props;
         this.database = database;
         this.url = url;
+        this.metadata = new RestfulDatabaseMetaData(url, props.getProperty(TSDBDriver.PROPERTY_KEY_USER), this);
     }
 
     @Override
     public Statement createStatement() throws SQLException {
         if (isClosed())
-            throw new SQLException(TSDBConstants.WrapErrMsg("restful TDengine connection is closed."));
+            throw new SQLException(TSDBConstants.WrapErrMsg("connection is closed."));
         return new RestfulStatement(this, database);
     }
 
     @Override
     public PreparedStatement prepareStatement(String sql) throws SQLException {
-        return null;
+        //TODO: prepareStatement
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public CallableStatement prepareCall(String sql) throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public String nativeSQL(String sql) throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void setAutoCommit(boolean autoCommit) throws SQLException {
-
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean getAutoCommit() throws SQLException {
-        return false;
+        return true;
     }
 
     @Override
     public void commit() throws SQLException {
-
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void rollback() throws SQLException {
-
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void close() throws SQLException {
-
+        if (isClosed)
+            return;
+        //TODO: release all resources
+        isClosed = true;
     }
 
     @Override
     public boolean isClosed() throws SQLException {
-        return false;
+        return isClosed;
     }
 
     @Override
     public DatabaseMetaData getMetaData() throws SQLException {
         //TODO: RestfulDatabaseMetaData is not implemented
-        return new RestfulDatabaseMetaData();
+        return this.metadata;
     }
 
     @Override
     public void setReadOnly(boolean readOnly) throws SQLException {
-
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean isReadOnly() throws SQLException {
-        return false;
+        return true;
     }
 
     @Override
     public void setCatalog(String catalog) throws SQLException {
-
+        //nothing to do
     }
 
     @Override
     public String getCatalog() throws SQLException {
-        return null;
+        return this.database;
     }
 
     @Override
     public void setTransactionIsolation(int level) throws SQLException {
-        //transaction is not supported
-        throw new SQLFeatureNotSupportedException("transactions are not supported");
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     /**
@@ -118,179 +130,212 @@ public class RestfulConnection implements Connection {
 
     @Override
     public SQLWarning getWarnings() throws SQLException {
-        //TODO: getWarnings not implemented
         return null;
     }
 
     @Override
     public void clearWarnings() throws SQLException {
-        throw new SQLFeatureNotSupportedException("clearWarnings not supported.");
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
-        return null;
+        if (resultSetType != ResultSet.TYPE_FORWARD_ONLY) {
+            throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        }
+        if (resultSetConcurrency != ResultSet.CONCUR_READ_ONLY)
+            throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return createStatement();
     }
 
     @Override
     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
-        return null;
+        if (resultSetType != ResultSet.TYPE_FORWARD_ONLY) {
+            throw new SQLFeatureNotSupportedException(TSDBConstants.INVALID_VARIABLES);
+        }
+        if (resultSetConcurrency != ResultSet.CONCUR_READ_ONLY) {
+            throw new SQLFeatureNotSupportedException(TSDBConstants.INVALID_VARIABLES);
+        }
+        return this.prepareStatement(sql);
     }
 
     @Override
     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Map<String, Class<?>> getTypeMap() throws SQLException {
-        return null;
+        synchronized (RestfulConnection.class) {
+            if (this.typeMap == null) {
+                this.typeMap = new HashMap<String, Class<?>>();
+            }
+            return this.typeMap;
+        }
     }
 
     @Override
     public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
-
+        synchronized (RestfulConnection.class) {
+            this.typeMap = map;
+        }
     }
 
     @Override
     public void setHoldability(int holdability) throws SQLException {
-
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int getHoldability() throws SQLException {
-        return 0;
+        return ResultSet.HOLD_CURSORS_OVER_COMMIT;
     }
 
     @Override
     public Savepoint setSavepoint() throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Savepoint setSavepoint(String name) throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void rollback(Savepoint savepoint) throws SQLException {
-
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void releaseSavepoint(Savepoint savepoint) throws SQLException {
-
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
-        return null;
+        if (resultSetHoldability != ResultSet.HOLD_CURSORS_OVER_COMMIT)
+            throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return createStatement(resultSetType, resultSetConcurrency);
     }
 
     @Override
     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
-        return null;
+        if (resultSetHoldability != ResultSet.HOLD_CURSORS_OVER_COMMIT)
+            throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return prepareStatement(sql, resultSetType, resultSetConcurrency);
     }
 
     @Override
     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Clob createClob() throws SQLException {
-        //TODO: not supported
-        throw new SQLFeatureNotSupportedException();
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Blob createBlob() throws SQLException {
-        //TODO: not supported
-        throw new SQLFeatureNotSupportedException();
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public NClob createNClob() throws SQLException {
-        //TODO: not supported
-        throw new SQLFeatureNotSupportedException();
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public SQLXML createSQLXML() throws SQLException {
-        //TODO: not supported
-        throw new SQLFeatureNotSupportedException();
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean isValid(int timeout) throws SQLException {
-        return false;
+        if (timeout < 0)
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        // TODO:
+        /* The driver shall submit a query on the connection or use some other mechanism that positively verifies
+         the connection is still valid when this method is called.*/
+        return !isClosed();
     }
 
     @Override
     public void setClientInfo(String name, String value) throws SQLClientInfoException {
-
+        clientInfoProps.setProperty(name, value);
     }
 
     @Override
     public void setClientInfo(Properties properties) throws SQLClientInfoException {
-
+        for (Enumeration<Object> enumer = properties.keys(); enumer.hasMoreElements(); ) {
+            String name = (String) enumer.nextElement();
+            clientInfoProps.put(name, properties.getProperty(name));
+        }
     }
 
     @Override
     public String getClientInfo(String name) throws SQLException {
-        return null;
+        return clientInfoProps.getProperty(name);
     }
 
     @Override
     public Properties getClientInfo() throws SQLException {
-        return null;
+        return clientInfoProps;
     }
 
     @Override
     public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
-        //TODO: not supported
-        throw new SQLFeatureNotSupportedException();
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
-        //TODO: not supported
-        throw new SQLFeatureNotSupportedException();
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void setSchema(String schema) throws SQLException {
-
+        //nothing to do
     }
 
     @Override
     public String getSchema() throws SQLException {
-        return null;
+        return this.database;
     }
 
     @Override
     public void abort(Executor executor) throws SQLException {
+        if (executor == null) {
+            throw new SQLException("Executor can not be null");
+        }
 
+        executor.execute(() -> {
+            try {
+                close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        });
     }
 
     @Override
     public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
-
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override

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

@@ -33,7 +33,7 @@ public class RestfulDriver extends AbstractTaosDriver {
             return null;
 
         Properties props = parseURL(url, info);
-        String host = props.getProperty(TSDBDriver.PROPERTY_KEY_HOST, "localhost");
+        String host = props.getProperty(TSDBDriver.PROPERTY_KEY_HOST);
         String port = props.getProperty(TSDBDriver.PROPERTY_KEY_PORT, "6041");
         String database = props.containsKey(TSDBDriver.PROPERTY_KEY_DBNAME) ? props.getProperty(TSDBDriver.PROPERTY_KEY_DBNAME) : null;
 

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

 package com.taosdata.jdbc.rs;
 
 import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.taosdata.jdbc.TSDBConstants;
 import com.taosdata.jdbc.rs.util.HttpClientPoolUtil;
@@ -12,12 +13,17 @@ import java.util.List;
 
 public class RestfulStatement implements Statement {
 
+    private static final String STATEMENT_CLOSED = "Statement already closed.";
     private boolean closed;
     private String database;
     private final RestfulConnection conn;
 
-    public RestfulStatement(RestfulConnection c, String database) {
-        this.conn = c;
+    private volatile RestfulResultSet resultSet;
+    private volatile int affectedRows;
+    private volatile boolean closeOnCompletion;
+
+    public RestfulStatement(RestfulConnection conn, String database) {
+        this.conn = conn;
         this.database = database;
     }
 
@@ -45,9 +51,7 @@ public class RestfulStatement implements Statement {
 
         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")));
+            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])) {
@@ -59,13 +63,13 @@ public class RestfulStatement implements Statement {
             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")));
+            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonField.getString("desc") + "\n" + "error code: " + jsonField.getString("code")));
         }
         String fieldData = jsonField.getString("data");
 
-        return new RestfulResultSet(dataStr, fieldData);
+        this.resultSet = new RestfulResultSet(dataStr, fieldData);
+        this.affectedRows = 0;
+        return resultSet;
     }
 
     @Override
@@ -78,77 +82,103 @@ public class RestfulStatement implements Statement {
         if (this.database == null)
             throw new SQLException("Database not specified or available");
 
-        final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
+        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")));
+            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonObject.getString("desc") + "\n" + "error code: " + jsonObject.getString("code")));
         }
-        return Integer.parseInt(jsonObject.getString("rows"));
+        this.resultSet = null;
+        this.affectedRows = Integer.parseInt(jsonObject.getString("rows"));
+        return this.affectedRows;
     }
 
     @Override
     public void close() throws SQLException {
+        synchronized (RestfulStatement.class) {
+            if (!isClosed())
                 this.closed = true;
         }
+    }
 
     @Override
     public int getMaxFieldSize() throws SQLException {
-        return 0;
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        return TSDBConstants.maxFieldSize;
     }
 
     @Override
     public void setMaxFieldSize(int max) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        if (max < 0)
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        // nothing to do
     }
 
     @Override
     public int getMaxRows() throws SQLException {
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
         return 0;
     }
 
     @Override
     public void setMaxRows(int max) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        if (max < 0)
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        // nothing to do
     }
 
     @Override
     public void setEscapeProcessing(boolean enable) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(RestfulStatement.STATEMENT_CLOSED);
     }
 
     @Override
     public int getQueryTimeout() throws SQLException {
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
         return 0;
     }
 
     @Override
     public void setQueryTimeout(int seconds) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        if (seconds < 0)
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
     }
 
     @Override
     public void cancel() throws SQLException {
-
+        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public SQLWarning getWarnings() throws SQLException {
-        //TODO: getWarnings not Implemented
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
         return null;
     }
 
     @Override
     public void clearWarnings() throws SQLException {
-
+        // nothing to do
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
     }
 
     @Override
     public void setCursorName(String name) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(RestfulStatement.STATEMENT_CLOSED);
+        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
@@ -163,129 +193,174 @@ public class RestfulStatement implements Statement {
         if (this.database == null)
             throw new SQLException("Database not specified or available");
 
+        if (SqlSyntaxValidator.isSelectSql(sql)) {
+            executeQuery(sql);
+        } else if (SqlSyntaxValidator.isInsertSql(sql)) {
+            executeUpdate(sql);
+        } else {
             final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
-        // use database
-        HttpClientPoolUtil.execute(url, "use " + conn.getDatabase());
-        // execute sql
+            HttpClientPoolUtil.execute(url, "use " + this.database);
             String result = HttpClientPoolUtil.execute(url, sql);
-        // parse result
             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")));
+                throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonObject.getString("desc") + "\n" + "error code: " + jsonObject.getString("code")));
             }
+            this.resultSet = new RestfulResultSet(jsonObject.getJSONArray("data"), jsonObject.getJSONArray("head"));
+        }
+
         return true;
     }
 
     @Override
     public ResultSet getResultSet() throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        return resultSet;
     }
 
     @Override
     public int getUpdateCount() throws SQLException {
-        return 0;
+        if (isClosed()) {
+            throw new SQLException("Invalid method call on a closed statement.");
+        }
+        return this.affectedRows;
     }
 
     @Override
     public boolean getMoreResults() throws SQLException {
-        return false;
+        return getMoreResults(CLOSE_CURRENT_RESULT);
     }
 
     @Override
     public void setFetchDirection(int direction) throws SQLException {
-
+        if (direction != ResultSet.FETCH_FORWARD && direction != ResultSet.FETCH_REVERSE && direction != ResultSet.FETCH_UNKNOWN)
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        this.resultSet.setFetchDirection(direction);
     }
 
     @Override
     public int getFetchDirection() throws SQLException {
-        return 0;
+        return this.resultSet.getFetchDirection();
     }
 
     @Override
     public void setFetchSize(int rows) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        if (rows < 0)
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        //nothing to do
     }
 
     @Override
     public int getFetchSize() throws SQLException {
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
         return 0;
     }
 
     @Override
     public int getResultSetConcurrency() throws SQLException {
-        return 0;
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        return this.resultSet.getConcurrency();
     }
 
     @Override
     public int getResultSetType() throws SQLException {
-        return 0;
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        return this.resultSet.getType();
     }
 
     @Override
     public void addBatch(String sql) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        //TODO:
     }
 
     @Override
     public void clearBatch() throws SQLException {
-
+        //TODO:
     }
 
     @Override
     public int[] executeBatch() throws SQLException {
+        //TODO:
         return new int[0];
     }
 
     @Override
     public Connection getConnection() throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        return this.conn;
     }
 
     @Override
     public boolean getMoreResults(int current) throws SQLException {
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        if (resultSet == null)
+            return false;
+
+//        switch (current) {
+//            case CLOSE_CURRENT_RESULT:
+//                resultSet.close();
+//                break;
+//            case KEEP_CURRENT_RESULT:
+//                break;
+//            case CLOSE_ALL_RESULTS:
+//                resultSet.close();
+//                break;
+//            default:
+//                throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+//        }
+//        return next;
         return false;
     }
 
     @Override
     public ResultSet getGeneratedKeys() throws SQLException {
-        return null;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
-        return 0;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
-        return 0;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int executeUpdate(String sql, String[] columnNames) throws SQLException {
-        return 0;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
-        return false;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean execute(String sql, int[] columnIndexes) throws SQLException {
-        return false;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean execute(String sql, String[] columnNames) throws SQLException {
-        return false;
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int getResultSetHoldability() throws SQLException {
-        return 0;
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        return this.resultSet.getHoldability();
     }
 
     @Override
@@ -295,22 +370,30 @@ public class RestfulStatement implements Statement {
 
     @Override
     public void setPoolable(boolean poolable) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        //nothing to do
     }
 
     @Override
     public boolean isPoolable() throws SQLException {
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
         return false;
     }
 
     @Override
     public void closeOnCompletion() throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        this.closeOnCompletion = true;
     }
 
     @Override
     public boolean isCloseOnCompletion() throws SQLException {
-        return false;
+        if (isClosed())
+            throw new SQLException(STATEMENT_CLOSED);
+        return this.closeOnCompletion;
     }
 
     @Override

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

@@ -31,8 +31,8 @@ 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");
@@ -46,6 +46,7 @@ public class SqlSyntaxValidator {
         }
         return res;
     }
+    */
 
     public static boolean isValidForExecuteUpdate(String sql) {
         for (String prefix : updateSQL) {

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

 package com.taosdata.jdbc.rs;
 
+
 import org.junit.*;
 import org.junit.runners.MethodSorters;
 

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

+package com.taosdata.jdbc.rs;
+
+import org.junit.*;
+import org.junit.runners.MethodSorters;
+
+import java.sql.*;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class SQLTest {
+    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);
+    }
+
+    @Test
+    public void testCase002() {
+        String sql = "use restful_test";
+        execute(sql);
+    }
+
+    @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();
+        }
+    }
+
+    @Test
+    public void testCase004() {
+        String sql = "select * from restful_test.weather";
+        executeQuery(sql);
+    }
+
+
+    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());
+        }
+    }
+
+    @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 {
+        connection.close();
+    }
+
+}