change

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

@@ -19,68 +19,71 @@ import java.util.Map;
 
 public abstract class TSDBConstants {
 
-	public static final String DEFAULT_PORT = "6200";
-	public static final String UNSUPPORT_METHOD_EXCEPTIONZ_MSG = "this operation is NOT supported currently!";
-	public static final String INVALID_VARIABLES = "invalid variables";
-	public static Map<Integer, String> DATATYPE_MAP = null;
+    public static final String DEFAULT_PORT = "6200";
+    public static final String UNSUPPORT_METHOD_EXCEPTIONZ_MSG = "this operation is NOT supported currently!";
+    public static final String INVALID_VARIABLES = "invalid variables";
+    public static Map<Integer, String> DATATYPE_MAP = null;
 
-	public static final long JNI_NULL_POINTER = 0L;
+    public static final long JNI_NULL_POINTER = 0L;
 
-	public static final int JNI_SUCCESS = 0;
-	public static final int JNI_TDENGINE_ERROR = -1;
-	public static final int JNI_CONNECTION_NULL = -2;
-	public static final int JNI_RESULT_SET_NULL = -3;
-	public static final int JNI_NUM_OF_FIELDS_0 = -4;
-	public static final int JNI_SQL_NULL = -5;
-	public static final int JNI_FETCH_END = -6;
-	
-	public static final int TSDB_DATA_TYPE_NULL = 0;
-	public static final int TSDB_DATA_TYPE_BOOL = 1;
-	public static final int TSDB_DATA_TYPE_TINYINT = 2;
-	public static final int TSDB_DATA_TYPE_SMALLINT = 3;
-	public static final int TSDB_DATA_TYPE_INT = 4;
-	public static final int TSDB_DATA_TYPE_BIGINT = 5;
-	public static final int TSDB_DATA_TYPE_FLOAT = 6;
-	public static final int TSDB_DATA_TYPE_DOUBLE = 7;
-	public static final int TSDB_DATA_TYPE_BINARY = 8;
-	public static final int TSDB_DATA_TYPE_TIMESTAMP = 9;
-	public static final int TSDB_DATA_TYPE_NCHAR = 10;
-	
-	public static String WrapErrMsg(String msg) {
-		return "TDengine Error: " + msg;
-	}
+    public static final int JNI_SUCCESS = 0;
+    public static final int JNI_TDENGINE_ERROR = -1;
+    public static final int JNI_CONNECTION_NULL = -2;
+    public static final int JNI_RESULT_SET_NULL = -3;
+    public static final int JNI_NUM_OF_FIELDS_0 = -4;
+    public static final int JNI_SQL_NULL = -5;
+    public static final int JNI_FETCH_END = -6;
 
-	public static String FixErrMsg(int code) {
-		switch (code) {
-		case JNI_TDENGINE_ERROR:
-			return WrapErrMsg("internal error of database!");
-		case JNI_CONNECTION_NULL:
-			return WrapErrMsg("invalid tdengine connection!");
-		case JNI_RESULT_SET_NULL:
-			return WrapErrMsg("invalid resultset pointer!");
-		case JNI_NUM_OF_FIELDS_0:
-			return WrapErrMsg("invalid num of fields!");
-		case JNI_SQL_NULL:
-			return WrapErrMsg("can't execute empty sql!");
-		case JNI_FETCH_END:
-			return WrapErrMsg("fetch to the end of resultset");
-		default:
-			break;
-		}
-		return WrapErrMsg("unkown error!");
-	}
+    public static final int TSDB_DATA_TYPE_NULL = 0;
+    public static final int TSDB_DATA_TYPE_BOOL = 1;
+    public static final int TSDB_DATA_TYPE_TINYINT = 2;
+    public static final int TSDB_DATA_TYPE_SMALLINT = 3;
+    public static final int TSDB_DATA_TYPE_INT = 4;
+    public static final int TSDB_DATA_TYPE_BIGINT = 5;
+    public static final int TSDB_DATA_TYPE_FLOAT = 6;
+    public static final int TSDB_DATA_TYPE_DOUBLE = 7;
+    public static final int TSDB_DATA_TYPE_BINARY = 8;
+    public static final int TSDB_DATA_TYPE_TIMESTAMP = 9;
+    public static final int TSDB_DATA_TYPE_NCHAR = 10;
 
-	static {
-		DATATYPE_MAP = new HashMap<Integer, String>();
-		DATATYPE_MAP.put(1, "BOOL");
-		DATATYPE_MAP.put(2, "TINYINT");
-		DATATYPE_MAP.put(3, "SMALLINT");
-		DATATYPE_MAP.put(4, "INT");
-		DATATYPE_MAP.put(5, "BIGINT");
-		DATATYPE_MAP.put(6, "FLOAT");
-		DATATYPE_MAP.put(7, "DOUBLE");
-		DATATYPE_MAP.put(8, "BINARY");
-		DATATYPE_MAP.put(9, "TIMESTAMP");
-		DATATYPE_MAP.put(10, "NCHAR");
-	}
+    // nchar field's max length
+    public static final int maxFieldSize = 16 * 1024;
+
+    public static String WrapErrMsg(String msg) {
+        return "TDengine Error: " + msg;
+    }
+
+    public static String FixErrMsg(int code) {
+        switch (code) {
+            case JNI_TDENGINE_ERROR:
+                return WrapErrMsg("internal error of database!");
+            case JNI_CONNECTION_NULL:
+                return WrapErrMsg("invalid tdengine connection!");
+            case JNI_RESULT_SET_NULL:
+                return WrapErrMsg("invalid resultset pointer!");
+            case JNI_NUM_OF_FIELDS_0:
+                return WrapErrMsg("invalid num of fields!");
+            case JNI_SQL_NULL:
+                return WrapErrMsg("can't execute empty sql!");
+            case JNI_FETCH_END:
+                return WrapErrMsg("fetch to the end of resultset");
+            default:
+                break;
+        }
+        return WrapErrMsg("unkown error!");
+    }
+
+    static {
+        DATATYPE_MAP = new HashMap<Integer, String>();
+        DATATYPE_MAP.put(1, "BOOL");
+        DATATYPE_MAP.put(2, "TINYINT");
+        DATATYPE_MAP.put(3, "SMALLINT");
+        DATATYPE_MAP.put(4, "INT");
+        DATATYPE_MAP.put(5, "BIGINT");
+        DATATYPE_MAP.put(6, "FLOAT");
+        DATATYPE_MAP.put(7, "DOUBLE");
+        DATATYPE_MAP.put(8, "BINARY");
+        DATATYPE_MAP.put(9, "TIMESTAMP");
+        DATATYPE_MAP.put(10, "NCHAR");
+    }
 }

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;
-import java.util.concurrent.atomic.AtomicBoolean;
 
 public class RestfulConnection implements Connection {
 
+    private static final String CONNECTION_IS_CLOSED = "connection is closed.";
+    private static final String AUTO_COMMIT_IS_TRUE = "auto commit is true";
     private final String host;
     private final int port;
     private final Properties props;
-    private final String database;
+    private volatile String database;
     private final String url;
-
-    /**********************************************/
-    private volatile AtomicBoolean isClosed = new AtomicBoolean(false);
-    private DatabaseMetaData databaseMetaData;
+    /******************************************************/
+    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;
@@ -26,282 +31,425 @@ public class RestfulConnection implements Connection {
         this.props = props;
         this.database = database;
         this.url = url;
-        //TODO
-        this.databaseMetaData = new RestfulDatabaseMetaData();
+        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(CONNECTION_IS_CLOSED);
+
         return new RestfulStatement(this, database);
     }
 
     @Override
     public PreparedStatement prepareStatement(String sql) throws SQLException {
-        //TODO:
-        return null;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        //TODO: prepareStatement
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public CallableStatement prepareCall(String sql) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public String nativeSQL(String sql) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+
+        //nothing did
+        return sql;
     }
 
     @Override
     public void setAutoCommit(boolean autoCommit) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        if (!autoCommit)
+            throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public boolean getAutoCommit() throws SQLException {
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
         return true;
     }
 
     @Override
     public void commit() throws SQLException {
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        if (getAutoCommit())
+            throw new SQLException(AUTO_COMMIT_IS_TRUE);
+        //nothing to do
     }
 
     @Override
     public void rollback() throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        if (getAutoCommit())
+            throw new SQLException(AUTO_COMMIT_IS_TRUE);
+        //nothing to do
     }
 
     @Override
     public void close() throws SQLException {
-        //TODO: check if resource need release
-        this.isClosed.set(true);
+        if (isClosed)
+            return;
+        //TODO: release all resources
+        isClosed = true;
     }
 
     @Override
     public boolean isClosed() throws SQLException {
-        return this.isClosed.get();
+        return isClosed;
     }
 
     @Override
     public DatabaseMetaData getMetaData() throws SQLException {
-        return this.databaseMetaData;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+
+        return this.metadata;
     }
 
     @Override
     public void setReadOnly(boolean readOnly) throws SQLException {
-        throw new SQLFeatureNotSupportedException("transactions are not supported");
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        // nothing to do
     }
 
     @Override
     public boolean isReadOnly() throws SQLException {
-        return false;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        return true;
     }
 
     @Override
     public void setCatalog(String catalog) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        synchronized (RestfulConnection.class) {
+            this.database = catalog;
+        }
     }
 
     @Override
     public String getCatalog() throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        return this.database;
     }
 
     @Override
     public void setTransactionIsolation(int level) throws SQLException {
-        //transaction is not supported
-        throw new SQLFeatureNotSupportedException("transactions are not supported");
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        switch (level) {
+            case Connection.TRANSACTION_NONE:
+                break;
+            case Connection.TRANSACTION_READ_UNCOMMITTED:
+            case Connection.TRANSACTION_READ_COMMITTED:
+            case Connection.TRANSACTION_REPEATABLE_READ:
+            case Connection.TRANSACTION_SERIALIZABLE:
+                throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+            default:
+                throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        }
     }
 
-    /**
-     *
-     */
     @Override
     public int getTransactionIsolation() throws SQLException {
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
         //Connection.TRANSACTION_NONE specifies that transactions are not supported.
         return Connection.TRANSACTION_NONE;
     }
 
     @Override
     public SQLWarning getWarnings() throws SQLException {
-        //TODO: getWarnings not implemented
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+
         return null;
     }
 
     @Override
     public void clearWarnings() throws SQLException {
-        throw new SQLFeatureNotSupportedException("clearWarnings not supported.");
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        //nothing to do
     }
 
     @Override
     public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+
+        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 (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        if (resultSetType != ResultSet.TYPE_FORWARD_ONLY || 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;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        if (resultSetType != ResultSet.TYPE_FORWARD_ONLY || resultSetConcurrency != ResultSet.CONCUR_READ_ONLY)
+            throw new SQLFeatureNotSupportedException(TSDBConstants.INVALID_VARIABLES);
+
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Map<String, Class<?>> getTypeMap() throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+
+        synchronized (RestfulConnection.class) {
+            if (this.typeMap == null) {
+                this.typeMap = new HashMap<>();
+            }
+            return this.typeMap;
+        }
     }
 
     @Override
     public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
 
+        synchronized (RestfulConnection.class) {
+            this.typeMap = map;
+        }
     }
 
     @Override
     public void setHoldability(int holdability) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        if (holdability != ResultSet.HOLD_CURSORS_OVER_COMMIT)
+            throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int getHoldability() throws SQLException {
-        return 0;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        return ResultSet.HOLD_CURSORS_OVER_COMMIT;
     }
 
     @Override
     public Savepoint setSavepoint() throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        if (getAutoCommit())
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        //nothing to do
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public Savepoint setSavepoint(String name) throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        if (getAutoCommit())
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        //nothing to do
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void rollback(Savepoint savepoint) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        if (getAutoCommit())
+            throw new SQLException(TSDBConstants.INVALID_VARIABLES);
+        //nothing to do
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public void releaseSavepoint(Savepoint savepoint) throws SQLException {
-
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        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 {
-
+        if (isClosed)
+            throw new SQLClientInfoException();
+        clientInfoProps.setProperty(name, value);
     }
 
     @Override
     public void setClientInfo(Properties properties) throws SQLClientInfoException {
+        if (isClosed)
+            throw new 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;
+        if (isClosed)
+            throw new SQLClientInfoException();
+
+        return clientInfoProps.getProperty(name);
     }
 
     @Override
     public Properties getClientInfo() throws SQLException {
-        return null;
+        if (isClosed)
+            throw new SQLClientInfoException();
+
+        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 {
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
 
+        synchronized (RestfulConnection.class) {
+            this.database = schema;
+        }
     }
 
     @Override
     public String getSchema() throws SQLException {
-        return null;
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        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 {
-
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
 
     @Override
     public int getNetworkTimeout() throws SQLException {
+        if (isClosed())
+            throw new SQLException(CONNECTION_IS_CLOSED);
         return 0;
     }
 

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

@@ -7,20 +7,60 @@ 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;
+import java.util.stream.Collectors;
 
 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;
     }
 
+    private String[] parseTableIdentifier(String sql) {
+        sql = sql.trim().toLowerCase();
+        String[] ret = null;
+        if (sql.contains("where"))
+            sql = sql.substring(0, sql.indexOf("where"));
+        if (sql.contains("interval"))
+            sql = sql.substring(0, sql.indexOf("interval"));
+        if (sql.contains("fill"))
+            sql = sql.substring(0, sql.indexOf("fill"));
+        if (sql.contains("sliding"))
+            sql = sql.substring(0, sql.indexOf("sliding"));
+        if (sql.contains("group by"))
+            sql = sql.substring(0, sql.indexOf("group by"));
+        if (sql.contains("order by"))
+            sql = sql.substring(0, sql.indexOf("order by"));
+        if (sql.contains("slimit"))
+            sql = sql.substring(0, sql.indexOf("slimit"));
+        if (sql.contains("limit"))
+            sql = sql.substring(0, sql.indexOf("limit"));
+        // parse
+        if (sql.contains("from")) {
+            sql = sql.substring(sql.indexOf("from") + 4).trim();
+            return Arrays.asList(sql.split(",")).stream()
+                    .map(tableIdentifier -> {
+                        tableIdentifier = tableIdentifier.trim();
+                        if (tableIdentifier.contains(" "))
+                            tableIdentifier = tableIdentifier.substring(0, tableIdentifier.indexOf(" "));
+                        return tableIdentifier;
+                    }).collect(Collectors.joining(",")).split(",");
+        }
+        return ret;
+    }
+
     @Override
     public ResultSet executeQuery(String sql) throws SQLException {
         if (isClosed())
@@ -29,43 +69,33 @@ 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 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, "");
+        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 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")));
+        // parse table name from sql
+        String[] tableIdentifiers = parseTableIdentifier(sql);
+        if (tableIdentifiers != null) {
+            List<JSONObject> fieldJsonList = new ArrayList<>();
+            for (String tableIdentifier : tableIdentifiers) {
+                // field meta
+                String fields = HttpClientPoolUtil.execute(url, "DESCRIBE " + tableIdentifier);
+                JSONObject fieldJson = JSON.parseObject(fields);
+                if (fieldJson.getString("status").equals("error")) {
+                    throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + fieldJson.getString("desc") + "\n" + "error code: " + fieldJson.getString("code")));
+                }
+                fieldJsonList.add(fieldJson);
+            }
+            this.resultSet = new RestfulResultSet(database, this, resultJson, fieldJsonList);
+        } else {
+            this.resultSet = new RestfulResultSet(database, this, resultJson);
         }
-        String fieldData = jsonField.getString("data");
 
-        return new RestfulResultSet(dataStr, fieldData);
+        this.affectedRows = 0;
+        return resultSet;
     }
 
     @Override
@@ -78,77 +108,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 {
-        this.closed = true;
+        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
@@ -159,133 +215,181 @@ public class RestfulStatement implements Statement {
         //如果执行了use操作应该将当前Statement的catalog设置为新的database
         if (SqlSyntaxValidator.isUseSql(sql)) {
             this.database = sql.trim().replace("use", "").trim();
+            this.conn.setCatalog(this.database);
         }
         if (this.database == null)
             throw new SQLException("Database not specified or available");
 
-        final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
-        // use database
-        HttpClientPoolUtil.execute(url, "use " + conn.getDatabase());
-        // execute sql
-        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")));
+        if (SqlSyntaxValidator.isSelectSql(sql)) {
+            executeQuery(sql);
+        } else if (SqlSyntaxValidator.isShowSql(sql) || SqlSyntaxValidator.isDescribeSql(sql)) {
+            final String url = "http://" + conn.getHost().trim() + ":" + conn.getPort() + "/rest/sql";
+            if (!SqlSyntaxValidator.isShowDatabaseSql(sql)) {
+                HttpClientPoolUtil.execute(url, "use " + conn.getDatabase());
+            }
+            String result = HttpClientPoolUtil.execute(url, sql);
+            JSONObject resultJson = JSON.parseObject(result);
+            if (resultJson.getString("status").equals("error")) {
+                throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + resultJson.getString("desc") + "\n" + "error code: " + resultJson.getString("code")));
+            }
+            this.resultSet = new RestfulResultSet(database, this, resultJson);
+        } else {
+            executeUpdate(sql);
         }
+
         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 +399,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/rs/util/HttpClientPoolUtil.java

@@ -17,6 +17,8 @@ import org.apache.http.protocol.HTTP;
 import org.apache.http.protocol.HttpContext;
 import org.apache.http.util.EntityUtils;
 
+import java.nio.charset.Charset;
+
 
 public class HttpClientPoolUtil {
     public static PoolingHttpClientConnectionManager cm = null;
@@ -94,7 +96,8 @@ public class HttpClientPoolUtil {
                 initPools();
             }
             method = (HttpEntityEnclosingRequestBase) getRequest(uri, HttpPost.METHOD_NAME, DEFAULT_CONTENT_TYPE, 0);
-            method.setEntity(new StringEntity(data));
+            method.setHeader("Content-Type", "text/plain");
+            method.setEntity(new StringEntity(data, Charset.forName("UTF-8")));
             HttpContext context = HttpClientContext.create();
             CloseableHttpResponse httpResponse = httpClient.execute(method, context);
             httpEntity = httpResponse.getEntity();
@@ -105,26 +108,13 @@ public class HttpClientPoolUtil {
             if (method != null) {
                 method.abort();
             }
-//            e.printStackTrace();
-//            logger.error("execute post request exception, url:" + uri + ", exception:" + e.toString()
-//                    + ", cost time(ms):" + (System.currentTimeMillis() - startTime));
-            new Exception("execute post request exception, url:"
-                    + uri + ", exception:" + e.toString() +
-                    ", cost time(ms):" + (System.currentTimeMillis() - startTime))
-                    .printStackTrace();
+            new Exception("execute post request exception, url:" + uri + ", exception:" + e.toString() + ", cost time(ms):" + (System.currentTimeMillis() - startTime)).printStackTrace();
         } finally {
             if (httpEntity != null) {
                 try {
                     EntityUtils.consumeQuietly(httpEntity);
                 } catch (Exception e) {
-//                    e.printStackTrace();
-//                    logger.error("close response exception, url:" + uri + ", exception:" + e.toString()
-//                            + ", cost time(ms):" + (System.currentTimeMillis() - startTime));
-                    new Exception(
-                            "close response exception, url:" + uri +
-                                    ", exception:" + e.toString()
-                                    + ", cost time(ms):" + (System.currentTimeMillis() - startTime))
-                            .printStackTrace();
+                    new Exception("close response exception, url:" + uri + ", exception:" + e.toString() + ", cost time(ms):" + (System.currentTimeMillis() - startTime)).printStackTrace();
                 }
             }
         }

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,22 +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))
@@ -56,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");
     }
 }