change
This commit is contained in:
zyyang
parent
6e8bc15a34
commit
b29c531d78
|
|
@ -93,8 +93,13 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
|
|||
public void setCatalog(String catalog) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
|
||||
|
||||
this.catalog = catalog;
|
||||
try (Statement stmt = createStatement()) {
|
||||
boolean execute = stmt.execute("use " + catalog);
|
||||
if (execute)
|
||||
this.catalog = catalog;
|
||||
} catch (SQLException e) {
|
||||
// do nothing
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -1,34 +1,23 @@
|
|||
package com.taosdata.jdbc.rs;
|
||||
|
||||
import com.taosdata.jdbc.TSDBConstants;
|
||||
import com.taosdata.jdbc.TSDBDriver;
|
||||
import com.taosdata.jdbc.*;
|
||||
|
||||
import java.sql.*;
|
||||
import java.util.Enumeration;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Properties;
|
||||
import java.util.concurrent.Executor;
|
||||
|
||||
public class RestfulConnection implements Connection {
|
||||
public class RestfulConnection extends AbstractConnection {
|
||||
|
||||
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 volatile String database;
|
||||
private final String url;
|
||||
private volatile String database;
|
||||
/******************************************************/
|
||||
private boolean isClosed;
|
||||
private DatabaseMetaData metadata;
|
||||
private Map<String, Class<?>> typeMap;
|
||||
private Properties clientInfoProps = new Properties();
|
||||
private final DatabaseMetaData metadata;
|
||||
|
||||
public RestfulConnection(String host, String port, Properties props, String database, String url) {
|
||||
this.host = host;
|
||||
this.port = Integer.parseInt(port);
|
||||
this.props = props;
|
||||
this.database = database;
|
||||
this.url = url;
|
||||
this.metadata = new RestfulDatabaseMetaData(url, props.getProperty(TSDBDriver.PROPERTY_KEY_USER), this);
|
||||
|
|
@ -37,7 +26,7 @@ public class RestfulConnection implements Connection {
|
|||
@Override
|
||||
public Statement createStatement() throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);;
|
||||
|
||||
return new RestfulStatement(this, database);
|
||||
}
|
||||
|
|
@ -45,61 +34,11 @@ public class RestfulConnection implements Connection {
|
|||
@Override
|
||||
public PreparedStatement prepareStatement(String sql) throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);;
|
||||
//TODO: prepareStatement
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public CallableStatement prepareCall(String sql) throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String nativeSQL(String sql) throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
|
||||
//nothing did
|
||||
return sql;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setAutoCommit(boolean autoCommit) throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
if (!autoCommit)
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_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 {
|
||||
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 {
|
||||
if (isClosed)
|
||||
|
|
@ -116,355 +55,11 @@ public class RestfulConnection implements Connection {
|
|||
@Override
|
||||
public DatabaseMetaData getMetaData() throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);;
|
||||
|
||||
return this.metadata;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setReadOnly(boolean readOnly) throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
// nothing to do
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isReadOnly() throws SQLException {
|
||||
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 {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
return this.database;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTransactionIsolation(int level) throws SQLException {
|
||||
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.UNSUPPORTED_METHOD_EXCEPTION_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 {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clearWarnings() throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
//nothing to do
|
||||
}
|
||||
|
||||
@Override
|
||||
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
|
||||
if (resultSetType != ResultSet.TYPE_FORWARD_ONLY) {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
if (resultSetConcurrency != ResultSet.CONCUR_READ_ONLY)
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
return createStatement();
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
|
||||
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 {
|
||||
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.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<String, Class<?>> getTypeMap() throws SQLException {
|
||||
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.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getHoldability() throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
return ResultSet.HOLD_CURSORS_OVER_COMMIT;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Savepoint setSavepoint() 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.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Savepoint setSavepoint(String name) 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.UNSUPPORTED_METHOD_EXCEPTION_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.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void releaseSavepoint(Savepoint savepoint) throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
|
||||
if (resultSetHoldability != ResultSet.HOLD_CURSORS_OVER_COMMIT)
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
return createStatement(resultSetType, resultSetConcurrency);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
|
||||
if (resultSetHoldability != ResultSet.HOLD_CURSORS_OVER_COMMIT)
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
return prepareStatement(sql, resultSetType, resultSetConcurrency);
|
||||
}
|
||||
|
||||
@Override
|
||||
public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Clob createClob() throws SQLException {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Blob createBlob() throws SQLException {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public NClob createNClob() throws SQLException {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public SQLXML createSQLXML() throws SQLException {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isValid(int timeout) throws SQLException {
|
||||
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 {
|
||||
if (isClosed)
|
||||
throw new SQLClientInfoException();
|
||||
|
||||
return clientInfoProps.getProperty(name);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Properties getClientInfo() throws SQLException {
|
||||
if (isClosed)
|
||||
throw new SQLClientInfoException();
|
||||
|
||||
return clientInfoProps;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
|
||||
throw new SQLFeatureNotSupportedException(TSDBConstants.UNSUPPORTED_METHOD_EXCEPTION_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 {
|
||||
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.UNSUPPORTED_METHOD_EXCEPTION_MSG);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getNetworkTimeout() throws SQLException {
|
||||
if (isClosed())
|
||||
throw new SQLException(CONNECTION_IS_CLOSED);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public <T> T unwrap(Class<T> iface) throws SQLException {
|
||||
try {
|
||||
return iface.cast(this);
|
||||
} catch (ClassCastException cce) {
|
||||
throw new SQLException("Unable to unwrap to " + iface.toString());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isWrapperFor(Class<?> iface) throws SQLException {
|
||||
return iface.isInstance(this);
|
||||
}
|
||||
|
||||
public String getHost() {
|
||||
return host;
|
||||
}
|
||||
|
|
@ -473,10 +68,6 @@ public class RestfulConnection implements Connection {
|
|||
return port;
|
||||
}
|
||||
|
||||
public Properties getProps() {
|
||||
return props;
|
||||
}
|
||||
|
||||
public String getDatabase() {
|
||||
return database;
|
||||
}
|
||||
|
|
@ -484,4 +75,4 @@ public class RestfulConnection implements Connection {
|
|||
public String getUrl() {
|
||||
return url;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
package com.taosdata.jdbc;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.DriverManager;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.util.Properties;
|
||||
|
||||
|
||||
public class ConnectionTest {
|
||||
private Connection connection;
|
||||
private Statement statement;
|
||||
private static String host = "127.0.0.1";
|
||||
|
||||
@Test
|
||||
public void testConnection() {
|
||||
Properties properties = new Properties();
|
||||
properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
|
||||
properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
|
||||
properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
|
||||
|
||||
try {
|
||||
Class.forName("com.taosdata.jdbc.TSDBDriver");
|
||||
connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
|
||||
Assert.assertTrue(null != connection);
|
||||
statement = connection.createStatement();
|
||||
Assert.assertTrue(null != statement);
|
||||
statement.close();
|
||||
connection.close();
|
||||
} catch (ClassNotFoundException e) {
|
||||
return;
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,428 @@
|
|||
package com.taosdata.jdbc.rs;
|
||||
|
||||
import com.taosdata.jdbc.TSDBConnection;
|
||||
import com.taosdata.jdbc.TSDBDriver;
|
||||
import com.taosdata.jdbc.TSDBResultSet;
|
||||
import com.taosdata.jdbc.TSDBSubscribe;
|
||||
import org.junit.AfterClass;
|
||||
import org.junit.Assert;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
|
||||
import javax.management.OperationsException;
|
||||
import java.sql.*;
|
||||
import java.util.Properties;
|
||||
|
||||
public class RestfulConnectionTest {
|
||||
|
||||
// private static final String host = "127.0.0.1";
|
||||
private static final String host = "master";
|
||||
private static Connection conn;
|
||||
|
||||
@Test
|
||||
public void getConnection() {
|
||||
// already test in beforeClass method
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createStatement() {
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery("select server_status()");
|
||||
rs.next();
|
||||
int status = rs.getInt("server_status()");
|
||||
Assert.assertEquals(1, status);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void subscribe() {
|
||||
try {
|
||||
TSDBConnection unwrap = conn.unwrap(TSDBConnection.class);
|
||||
TSDBSubscribe subscribe = unwrap.subscribe("topic1", "select * from log.log", false);
|
||||
TSDBResultSet rs = subscribe.consume();
|
||||
ResultSetMetaData metaData = rs.getMetaData();
|
||||
for (int count = 0; count < 10 && rs.next(); count++) {
|
||||
for (int i = 1; i <= metaData.getColumnCount(); i++) {
|
||||
String value = rs.getString(i);
|
||||
System.out.print(metaData.getColumnLabel(i) + ":" + value + "\t");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
Assert.assertNotNull(rs);
|
||||
subscribe.close(false);
|
||||
} catch (SQLException | OperationsException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void prepareStatement() throws SQLException {
|
||||
PreparedStatement pstmt = conn.prepareStatement("select server_status()");
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
int status = rs.getInt("server_status()");
|
||||
Assert.assertEquals(1, status);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void prepareCall() throws SQLException {
|
||||
conn.prepareCall("select server_status()");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nativeSQL() throws SQLException {
|
||||
String nativeSQL = conn.nativeSQL("select * from log.log");
|
||||
Assert.assertEquals("select * from log.log", nativeSQL);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setAutoCommit() throws SQLException {
|
||||
conn.setAutoCommit(true);
|
||||
conn.setAutoCommit(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getAutoCommit() throws SQLException {
|
||||
Assert.assertTrue(conn.getAutoCommit());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void commit() throws SQLException {
|
||||
conn.commit();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void rollback() throws SQLException {
|
||||
conn.rollback();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void close() {
|
||||
// connection will close in afterClass method
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isClosed() throws SQLException {
|
||||
Assert.assertFalse(conn.isClosed());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getMetaData() throws SQLException {
|
||||
DatabaseMetaData meta = conn.getMetaData();
|
||||
Assert.assertNotNull(meta);
|
||||
Assert.assertEquals("com.taosdata.jdbc.TSDBDriver", meta.getDriverName());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setReadOnly() throws SQLException {
|
||||
conn.setReadOnly(true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isReadOnly() throws SQLException {
|
||||
Assert.assertTrue(conn.isReadOnly());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setCatalog() throws SQLException {
|
||||
conn.setCatalog("test");
|
||||
Assert.assertEquals("test", conn.getCatalog());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getCatalog() throws SQLException {
|
||||
conn.setCatalog("log");
|
||||
Assert.assertEquals("log", conn.getCatalog());
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void setTransactionIsolation() throws SQLException {
|
||||
conn.setTransactionIsolation(Connection.TRANSACTION_NONE);
|
||||
Assert.assertEquals(Connection.TRANSACTION_NONE, conn.getTransactionIsolation());
|
||||
conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getTransactionIsolation() throws SQLException {
|
||||
Assert.assertEquals(Connection.TRANSACTION_NONE, conn.getTransactionIsolation());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getWarnings() throws SQLException {
|
||||
Assert.assertNull(conn.getWarnings());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void clearWarnings() throws SQLException {
|
||||
conn.clearWarnings();
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testCreateStatement() throws SQLException {
|
||||
Statement stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
|
||||
ResultSet rs = stmt.executeQuery("select server_status()");
|
||||
rs.next();
|
||||
int status = rs.getInt("server_status()");
|
||||
Assert.assertEquals(1, status);
|
||||
|
||||
conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testPrepareStatement() throws SQLException {
|
||||
PreparedStatement pstmt = conn.prepareStatement("select server_status()",
|
||||
ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
int status = rs.getInt("server_status()");
|
||||
Assert.assertEquals(1, status);
|
||||
|
||||
conn.prepareStatement("select server_status", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testPrepareCall() throws SQLException {
|
||||
conn.prepareCall("", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void getTypeMap() throws SQLException {
|
||||
conn.getTypeMap();
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void setTypeMap() throws SQLException {
|
||||
conn.setTypeMap(null);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void setHoldability() throws SQLException {
|
||||
conn.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
|
||||
Assert.assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, conn.getHoldability());
|
||||
conn.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getHoldability() throws SQLException {
|
||||
Assert.assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, conn.getHoldability());
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void setSavepoint() throws SQLException {
|
||||
conn.setSavepoint();
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testSetSavepoint() throws SQLException {
|
||||
conn.setSavepoint(null);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testRollback() throws SQLException {
|
||||
conn.rollback(null);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void releaseSavepoint() throws SQLException {
|
||||
conn.releaseSavepoint(null);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testCreateStatement1() throws SQLException {
|
||||
Statement stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
|
||||
ResultSet rs = stmt.executeQuery("select server_status()");
|
||||
rs.next();
|
||||
int status = rs.getInt("server_status()");
|
||||
Assert.assertEquals(1, status);
|
||||
|
||||
conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testPrepareStatement1() throws SQLException {
|
||||
PreparedStatement pstmt = conn.prepareStatement("select server_status()",
|
||||
ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
int status = rs.getInt("server_status()");
|
||||
Assert.assertEquals(1, status);
|
||||
|
||||
conn.prepareStatement("select server_status", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testPrepareCall1() throws SQLException {
|
||||
conn.prepareCall("", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testPrepareStatement2() throws SQLException {
|
||||
Assert.assertNotNull("", Statement.NO_GENERATED_KEYS);
|
||||
conn.prepareStatement("", Statement.RETURN_GENERATED_KEYS);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testPrepareStatement3() throws SQLException {
|
||||
conn.prepareStatement("", new int[]{});
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void testPrepareStatement4() throws SQLException {
|
||||
conn.prepareStatement("", new String[]{});
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void createClob() throws SQLException {
|
||||
conn.createClob();
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void createBlob() throws SQLException {
|
||||
conn.createBlob();
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void createNClob() throws SQLException {
|
||||
conn.createNClob();
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void createSQLXML() throws SQLException {
|
||||
conn.createSQLXML();
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
public void isValid() throws SQLException {
|
||||
Assert.assertTrue(conn.isValid(10));
|
||||
Assert.assertTrue(conn.isValid(0));
|
||||
conn.isValid(-1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setClientInfo() throws SQLClientInfoException {
|
||||
conn.setClientInfo(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
|
||||
conn.setClientInfo(TSDBDriver.PROPERTY_KEY_CHARSET, "en_US.UTF-8");
|
||||
conn.setClientInfo(TSDBDriver.PROPERTY_KEY_CHARSET, "UTC-8");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetClientInfo() throws SQLClientInfoException {
|
||||
Properties properties = new Properties();
|
||||
properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
|
||||
properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
|
||||
properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
|
||||
conn.setClientInfo(properties);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getClientInfo() throws SQLException {
|
||||
conn.setClientInfo(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
|
||||
conn.setClientInfo(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
|
||||
conn.setClientInfo(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
|
||||
|
||||
Properties info = conn.getClientInfo();
|
||||
String charset = info.getProperty(TSDBDriver.PROPERTY_KEY_CHARSET);
|
||||
Assert.assertEquals("UTF-8", charset);
|
||||
String locale = info.getProperty(TSDBDriver.PROPERTY_KEY_LOCALE);
|
||||
Assert.assertEquals("en_US.UTF-8", locale);
|
||||
String timezone = info.getProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE);
|
||||
Assert.assertEquals("UTC-8", timezone);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetClientInfo() throws SQLException {
|
||||
conn.setClientInfo(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
|
||||
conn.setClientInfo(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
|
||||
conn.setClientInfo(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
|
||||
|
||||
String charset = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_CHARSET);
|
||||
Assert.assertEquals("UTF-8", charset);
|
||||
String locale = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_LOCALE);
|
||||
Assert.assertEquals("en_US.UTF-8", locale);
|
||||
String timezone = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIME_ZONE);
|
||||
Assert.assertEquals("UTC-8", timezone);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void createArrayOf() throws SQLException {
|
||||
conn.createArrayOf("", null);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void createStruct() throws SQLException {
|
||||
conn.createStruct("", null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setSchema() throws SQLException {
|
||||
conn.setSchema("test");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getSchema() throws SQLException {
|
||||
Assert.assertNull(conn.getSchema());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void abort() throws SQLException {
|
||||
conn.abort(null);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void setNetworkTimeout() throws SQLException {
|
||||
conn.setNetworkTimeout(null, 1000);
|
||||
}
|
||||
|
||||
@Test(expected = SQLFeatureNotSupportedException.class)
|
||||
public void getNetworkTimeout() throws SQLException {
|
||||
conn.getNetworkTimeout();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void unwrap() {
|
||||
try {
|
||||
TSDBConnection tsdbConnection = conn.unwrap(TSDBConnection.class);
|
||||
Assert.assertNotNull(tsdbConnection);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isWrapperFor() throws SQLException {
|
||||
Assert.assertTrue(conn.isWrapperFor(TSDBConnection.class));
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public static void beforeClass() {
|
||||
try {
|
||||
Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
|
||||
Properties properties = new Properties();
|
||||
properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
|
||||
properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
|
||||
properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
|
||||
conn = DriverManager.getConnection("jdbc:TAOS-RS://" + host + ":6041/log?user=root&password=taosdata", properties);
|
||||
// create test database for test cases
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
stmt.execute("create database if not exists test");
|
||||
}
|
||||
|
||||
} catch (ClassNotFoundException | SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void afterClass() {
|
||||
try {
|
||||
if (conn != null)
|
||||
conn.close();
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue