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/AbstractDatabaseMetaData.java

@@ -0,0 +1,808 @@
+/***************************************************************************
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *****************************************************************************/
+package com.taosdata.jdbc;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AbstractDatabaseMetaData implements DatabaseMetaData {
+
+    private final static String PRODUCT_NAME = "TDengine";
+    private final static String PRODUCT_VESION = "2.0.x.x";
+    private final static String DRIVER_NAME = "taos-jdbcdriver";
+    private final static String DRIVER_VERSION = "2.0.x";
+    private final static int DRIVER_MAJAR_VERSION = 2;
+    private final static int DRIVER_MINOR_VERSION = 0;
+
+    public boolean allProceduresAreCallable() throws SQLException {
+        return false;
+    }
+
+    public boolean allTablesAreSelectable() throws SQLException {
+        return false;
+    }
+
+    public abstract String getURL() throws SQLException;
+
+    public abstract String getUserName() throws SQLException;
+
+    public boolean isReadOnly() throws SQLException {
+        return false;
+    }
+
+    public boolean nullsAreSortedHigh() throws SQLException {
+        return false;
+    }
+
+    public boolean nullsAreSortedLow() throws SQLException {
+        return !nullsAreSortedHigh();
+    }
+
+    public boolean nullsAreSortedAtStart() throws SQLException {
+        return true;
+    }
+
+    public boolean nullsAreSortedAtEnd() throws SQLException {
+        return !nullsAreSortedAtStart();
+    }
+
+    public String getDatabaseProductName() throws SQLException {
+        return PRODUCT_NAME;
+    }
+
+    public String getDatabaseProductVersion() throws SQLException {
+        return PRODUCT_VESION;
+    }
+
+    public String getDriverName() throws SQLException {
+        return DRIVER_NAME;
+    }
+
+    public String getDriverVersion() throws SQLException {
+        return DRIVER_VERSION;
+    }
+
+    public int getDriverMajorVersion() {
+        return DRIVER_MAJAR_VERSION;
+    }
+
+    public int getDriverMinorVersion() {
+        return DRIVER_MINOR_VERSION;
+    }
+
+    public boolean usesLocalFiles() throws SQLException {
+        return false;
+    }
+
+    public boolean usesLocalFilePerTable() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsMixedCaseIdentifiers() throws SQLException {
+        return false;
+    }
+
+    public boolean storesUpperCaseIdentifiers() throws SQLException {
+        return false;
+    }
+
+    public boolean storesLowerCaseIdentifiers() throws SQLException {
+        return false;
+    }
+
+    public boolean storesMixedCaseIdentifiers() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
+        return false;
+    }
+
+    public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
+        return false;
+    }
+
+    public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
+        return false;
+    }
+
+    public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
+        return false;
+    }
+
+    public String getIdentifierQuoteString() throws SQLException {
+        return " ";
+    }
+
+    public String getSQLKeywords() throws SQLException {
+        return null;
+    }
+
+    public String getNumericFunctions() throws SQLException {
+        return null;
+    }
+
+    public String getStringFunctions() throws SQLException {
+        return null;
+    }
+
+    public String getSystemFunctions() throws SQLException {
+        return null;
+    }
+
+    public String getTimeDateFunctions() throws SQLException {
+        return null;
+    }
+
+    public String getSearchStringEscape() throws SQLException {
+        return null;
+    }
+
+    public String getExtraNameCharacters() throws SQLException {
+        return null;
+    }
+
+    public boolean supportsAlterTableWithAddColumn() throws SQLException {
+        return true;
+    }
+
+    public boolean supportsAlterTableWithDropColumn() throws SQLException {
+        return true;
+    }
+
+    public boolean supportsColumnAliasing() throws SQLException {
+        return true;
+    }
+
+    public boolean nullPlusNonNullIsNull() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsConvert() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsConvert(int fromType, int toType) throws SQLException {
+        return false;
+    }
+
+    public boolean supportsTableCorrelationNames() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsDifferentTableCorrelationNames() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsExpressionsInOrderBy() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsOrderByUnrelated() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsGroupBy() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsGroupByUnrelated() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsGroupByBeyondSelect() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsLikeEscapeClause() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsMultipleResultSets() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsMultipleTransactions() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsNonNullableColumns() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsMinimumSQLGrammar() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsCoreSQLGrammar() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsExtendedSQLGrammar() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsANSI92EntryLevelSQL() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsANSI92IntermediateSQL() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsANSI92FullSQL() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsIntegrityEnhancementFacility() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsOuterJoins() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsFullOuterJoins() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsLimitedOuterJoins() throws SQLException {
+        return false;
+    }
+
+    public String getSchemaTerm() throws SQLException {
+        return null;
+    }
+
+    public String getProcedureTerm() throws SQLException {
+        return null;
+    }
+
+    public String getCatalogTerm() throws SQLException {
+        return "database";
+    }
+
+    public boolean isCatalogAtStart() throws SQLException {
+        return true;
+    }
+
+    public String getCatalogSeparator() throws SQLException {
+        return ".";
+    }
+
+    public boolean supportsSchemasInDataManipulation() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsSchemasInProcedureCalls() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsSchemasInTableDefinitions() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsSchemasInIndexDefinitions() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsCatalogsInDataManipulation() throws SQLException {
+        return true;
+    }
+
+    public boolean supportsCatalogsInProcedureCalls() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsCatalogsInTableDefinitions() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsPositionedDelete() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsPositionedUpdate() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsSelectForUpdate() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsStoredProcedures() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsSubqueriesInComparisons() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsSubqueriesInExists() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsSubqueriesInIns() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsSubqueriesInQuantifieds() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsCorrelatedSubqueries() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsUnion() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsUnionAll() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
+        return false;
+    }
+
+    public int getMaxBinaryLiteralLength() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxCharLiteralLength() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxColumnNameLength() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxColumnsInGroupBy() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxColumnsInIndex() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxColumnsInOrderBy() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxColumnsInSelect() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxColumnsInTable() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxConnections() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxCursorNameLength() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxIndexLength() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxSchemaNameLength() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxProcedureNameLength() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxCatalogNameLength() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxRowSize() throws SQLException {
+        return 0;
+    }
+
+    public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
+        return false;
+    }
+
+    public int getMaxStatementLength() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxStatements() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxTableNameLength() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxTablesInSelect() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxUserNameLength() throws SQLException {
+        return 0;
+    }
+
+    public int getDefaultTransactionIsolation() throws SQLException {
+        return 0;
+    }
+
+    public boolean supportsTransactions() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsTransactionIsolationLevel(int level) throws SQLException {
+        return false;
+    }
+
+    public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
+        return false;
+    }
+
+    public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
+        return false;
+    }
+
+    public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
+        return false;
+    }
+
+    public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern)
+            throws SQLException {
+        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+    }
+
+    public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern,
+                                         String columnNamePattern) throws SQLException {
+        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+    }
+
+    public abstract ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types)
+            throws SQLException;
+
+    public ResultSet getSchemas() throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public abstract ResultSet getCatalogs() throws SQLException;
+
+    public ResultSet getTableTypes() throws SQLException {
+        DatabaseMetaDataResultSet resultSet = new DatabaseMetaDataResultSet();
+
+        // set up ColumnMetaDataList
+        List<ColumnMetaData> columnMetaDataList = new ArrayList<ColumnMetaData>(1);
+        ColumnMetaData colMetaData = new ColumnMetaData();
+        colMetaData.setColIndex(0);
+        colMetaData.setColName("TABLE_TYPE");
+        colMetaData.setColSize(10);
+        colMetaData.setColType(TSDBConstants.TSDB_DATA_TYPE_BINARY);
+        columnMetaDataList.add(colMetaData);
+
+        // set up rowDataList
+        List<TSDBResultSetRowData> rowDataList = new ArrayList<TSDBResultSetRowData>(2);
+        TSDBResultSetRowData rowData = new TSDBResultSetRowData();
+        rowData.setString(0, "TABLE");
+        rowDataList.add(rowData);
+        rowData = new TSDBResultSetRowData();
+        rowData.setString(0, "STABLE");
+        rowDataList.add(rowData);
+
+        resultSet.setColumnMetaDataList(columnMetaDataList);
+        resultSet.setRowDataList(rowDataList);
+        return resultSet;
+    }
+
+    public abstract ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException;
+
+    protected int getNullable(int index, String typeName) {
+        if (index == 0 && "TIMESTAMP".equals(typeName))
+            return DatabaseMetaData.columnNoNulls;
+        return DatabaseMetaData.columnNullable;
+    }
+
+    protected int getColumnSize(String typeName, int length) {
+        switch (typeName) {
+            case "TIMESTAMP":
+                return 23;
+
+            default:
+                return 0;
+        }
+    }
+
+    protected int getDecimalDigits(String typeName) {
+        switch (typeName) {
+            case "FLOAT":
+                return 5;
+            case "DOUBLE":
+                return 9;
+            default:
+                return 0;
+        }
+    }
+
+    protected int getDataType(String typeName) {
+        switch (typeName) {
+            case "TIMESTAMP":
+                return Types.TIMESTAMP;
+            case "INT":
+                return Types.INTEGER;
+            case "BIGINT":
+                return Types.BIGINT;
+            case "FLOAT":
+                return Types.FLOAT;
+            case "DOUBLE":
+                return Types.DOUBLE;
+            case "BINARY":
+                return Types.BINARY;
+            case "SMALLINT":
+                return Types.SMALLINT;
+            case "TINYINT":
+                return Types.TINYINT;
+            case "BOOL":
+                return Types.BOOLEAN;
+            case "NCHAR":
+                return Types.NCHAR;
+            default:
+                return Types.NULL;
+        }
+    }
+
+    public ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern)
+            throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern)
+            throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable)
+            throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getCrossReference(String parentCatalog, String parentSchema, String parentTable,
+                                       String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getTypeInfo() throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate)
+            throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public boolean supportsResultSetType(int type) throws SQLException {
+        return false;
+    }
+
+    public boolean supportsResultSetConcurrency(int type, int concurrency) throws SQLException {
+        return false;
+    }
+
+    public boolean ownUpdatesAreVisible(int type) throws SQLException {
+        return false;
+    }
+
+    public boolean ownDeletesAreVisible(int type) throws SQLException {
+        return false;
+    }
+
+    public boolean ownInsertsAreVisible(int type) throws SQLException {
+        return false;
+    }
+
+    public boolean othersUpdatesAreVisible(int type) throws SQLException {
+        return false;
+    }
+
+    public boolean othersDeletesAreVisible(int type) throws SQLException {
+        return false;
+    }
+
+    public boolean othersInsertsAreVisible(int type) throws SQLException {
+        return false;
+    }
+
+    public boolean updatesAreDetected(int type) throws SQLException {
+        return false;
+    }
+
+    public boolean deletesAreDetected(int type) throws SQLException {
+        return false;
+    }
+
+    public boolean insertsAreDetected(int type) throws SQLException {
+        return false;
+    }
+
+    public boolean supportsBatchUpdates() throws SQLException {
+        return false;
+    }
+
+    public ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types)
+            throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public Connection getConnection() throws SQLException {
+        return null;
+    }
+
+    public boolean supportsSavepoints() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsNamedParameters() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsMultipleOpenResults() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsGetGeneratedKeys() throws SQLException {
+        return false;
+    }
+
+    public ResultSet getSuperTypes(String catalog, String schemaPattern, String typeNamePattern) throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getSuperTables(String catalog, String schemaPattern, String tableNamePattern) throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getAttributes(String catalog, String schemaPattern, String typeNamePattern,
+                                   String attributeNamePattern) throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public boolean supportsResultSetHoldability(int holdability) throws SQLException {
+        return false;
+    }
+
+    public int getResultSetHoldability() throws SQLException {
+        return 0;
+    }
+
+    public int getDatabaseMajorVersion() throws SQLException {
+        return 0;
+    }
+
+    public int getDatabaseMinorVersion() throws SQLException {
+        return 0;
+    }
+
+    public int getJDBCMajorVersion() throws SQLException {
+        return 0;
+    }
+
+    public int getJDBCMinorVersion() throws SQLException {
+        return 0;
+    }
+
+    public int getSQLStateType() throws SQLException {
+        return 0;
+    }
+
+    public boolean locatorsUpdateCopy() throws SQLException {
+        return false;
+    }
+
+    public boolean supportsStatementPooling() throws SQLException {
+        return false;
+    }
+
+    public RowIdLifetime getRowIdLifetime() throws SQLException {
+        return null;
+    }
+
+    public ResultSet getSchemas(String catalog, String schemaPattern) throws SQLException {
+        return null;
+    }
+
+    public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
+        return false;
+    }
+
+    public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
+        return false;
+    }
+
+    public ResultSet getClientInfoProperties() throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getFunctions(String catalog, String schemaPattern, String functionNamePattern)
+            throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern,
+                                        String columnNamePattern) throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public ResultSet getPseudoColumns(String catalog, String schemaPattern, String tableNamePattern,
+                                      String columnNamePattern) throws SQLException {
+        return getEmptyResultSet();
+    }
+
+    public boolean generatedKeyAlwaysReturned() throws SQLException {
+        return false;
+    }
+
+    private ResultSet getEmptyResultSet() {
+        return new EmptyResultSet();
+    }
+}

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 DEFAULT_PORT = "6200";
-	public static final String UNSUPPORT_METHOD_EXCEPTIONZ_MSG = "this operation is NOT supported currently!";
+    public static final String UNSUPPORT_METHOD_EXCEPTIONZ_MSG = "this operation is NOT supported currently!";
-	public static final String INVALID_VARIABLES = "invalid variables";
+    public static final String INVALID_VARIABLES = "invalid variables";
-	public static Map<Integer, String> DATATYPE_MAP = null;
+    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_SUCCESS = 0;
-	public static final int JNI_TDENGINE_ERROR = -1;
+    public static final int JNI_TDENGINE_ERROR = -1;
-	public static final int JNI_CONNECTION_NULL = -2;
+    public static final int JNI_CONNECTION_NULL = -2;
-	public static final int JNI_RESULT_SET_NULL = -3;
+    public static final int JNI_RESULT_SET_NULL = -3;
-	public static final int JNI_NUM_OF_FIELDS_0 = -4;
+    public static final int JNI_NUM_OF_FIELDS_0 = -4;
-	public static final int JNI_SQL_NULL = -5;
+    public static final int JNI_SQL_NULL = -5;
-	public static final int JNI_FETCH_END = -6;
+    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 String FixErrMsg(int code) {
+    public static final int TSDB_DATA_TYPE_NULL = 0;
-		switch (code) {
+    public static final int TSDB_DATA_TYPE_BOOL = 1;
-		case JNI_TDENGINE_ERROR:
+    public static final int TSDB_DATA_TYPE_TINYINT = 2;
-			return WrapErrMsg("internal error of database!");
+    public static final int TSDB_DATA_TYPE_SMALLINT = 3;
-		case JNI_CONNECTION_NULL:
+    public static final int TSDB_DATA_TYPE_INT = 4;
-			return WrapErrMsg("invalid tdengine connection!");
+    public static final int TSDB_DATA_TYPE_BIGINT = 5;
-		case JNI_RESULT_SET_NULL:
+    public static final int TSDB_DATA_TYPE_FLOAT = 6;
-			return WrapErrMsg("invalid resultset pointer!");
+    public static final int TSDB_DATA_TYPE_DOUBLE = 7;
-		case JNI_NUM_OF_FIELDS_0:
+    public static final int TSDB_DATA_TYPE_BINARY = 8;
-			return WrapErrMsg("invalid num of fields!");
+    public static final int TSDB_DATA_TYPE_TIMESTAMP = 9;
-		case JNI_SQL_NULL:
+    public static final int TSDB_DATA_TYPE_NCHAR = 10;
-			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 {
+    // nchar field's max length
-		DATATYPE_MAP = new HashMap<Integer, String>();
+    public static final int maxFieldSize = 16 * 1024;
-		DATATYPE_MAP.put(1, "BOOL");
+
-		DATATYPE_MAP.put(2, "TINYINT");
+    public static String WrapErrMsg(String msg) {
-		DATATYPE_MAP.put(3, "SMALLINT");
+        return "TDengine Error: " + msg;
-		DATATYPE_MAP.put(4, "INT");
+    }
-		DATATYPE_MAP.put(5, "BIGINT");
+
-		DATATYPE_MAP.put(6, "FLOAT");
+    public static String FixErrMsg(int code) {
-		DATATYPE_MAP.put(7, "DOUBLE");
+        switch (code) {
-		DATATYPE_MAP.put(8, "BINARY");
+            case JNI_TDENGINE_ERROR:
-		DATATYPE_MAP.put(9, "TIMESTAMP");
+                return WrapErrMsg("internal error of database!");
-		DATATYPE_MAP.put(10, "NCHAR");
+            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

@@ -1,8 +1,11 @@
 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(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
-        throw new SQLFeatureNotSupportedException("transactions are not supported");
     }
 
     /**
@@ -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(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
-        throw new SQLFeatureNotSupportedException();
     }
 
     @Override
     public Blob createBlob() throws SQLException {
-        //TODO: not supported
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
-        throw new SQLFeatureNotSupportedException();
     }
 
     @Override
     public NClob createNClob() throws SQLException {
-        //TODO: not supported
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
-        throw new SQLFeatureNotSupportedException();
     }
 
     @Override
     public SQLXML createSQLXML() throws SQLException {
-        //TODO: not supported
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
-        throw new SQLFeatureNotSupportedException();
     }
 
     @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(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
-        throw new SQLFeatureNotSupportedException();
     }
 
     @Override
     public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
-        //TODO: not supported
+        throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
-        throw new SQLFeatureNotSupportedException();
     }
 
     @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

@@ -1,6 +1,7 @@
 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) {
+    private volatile RestfulResultSet resultSet;
-        this.conn = c;
+    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: " +
+            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonObject.getString("desc") + "\n" + "error code: " + jsonObject.getString("code")));
-                    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: " +
+            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonField.getString("desc") + "\n" + "error code: " + jsonField.getString("code")));
-                    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: " +
+            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " + jsonObject.getString("desc") + "\n" + "error code: " + jsonObject.getString("code")));
-                    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
@@ -163,129 +193,174 @@ 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";
+        if (SqlSyntaxValidator.isSelectSql(sql)) {
-        // use database
+            executeQuery(sql);
-        HttpClientPoolUtil.execute(url, "use " + conn.getDatabase());
+        } else if (SqlSyntaxValidator.isInsertSql(sql)) {
-        // execute sql
+            executeUpdate(sql);
-        String result = HttpClientPoolUtil.execute(url, sql);
+        } else {
-        // parse result
+            final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
-        JSONObject jsonObject = JSON.parseObject(result);
+            HttpClientPoolUtil.execute(url, "use " + this.database);
-        if (jsonObject.getString("status").equals("error")) {
+            String result = HttpClientPoolUtil.execute(url, sql);
-            throw new SQLException(TSDBConstants.WrapErrMsg("SQL execution error: " +
+            JSONObject jsonObject = JSON.parseObject(result);
-                    jsonObject.getString("desc") + "\n" +
+            if (jsonObject.getString("status").equals("error")) {
-                    "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

@@ -1,5 +1,6 @@
 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

@@ -0,0 +1,98 @@
+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();
+    }
+
+}