merge taos-jdbcdriver-2.0.28 all changes to master branch (#5974)
* merge taos-jdbcdriver-2.0.28 all changes to master branch * change version in cmake/install.inc
This commit is contained in:
zyyang
GitHub
parent
160516665c
commit
5eac06b287
|
|
@ -32,7 +32,7 @@ ELSEIF (TD_WINDOWS)
|
|||
#INSTALL(TARGETS taos RUNTIME DESTINATION driver)
|
||||
#INSTALL(TARGETS shell RUNTIME DESTINATION .)
|
||||
IF (TD_MVN_INSTALLED)
|
||||
INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.25-dist.jar DESTINATION connector/jdbc)
|
||||
INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.28-dist.jar DESTINATION connector/jdbc)
|
||||
ENDIF ()
|
||||
ELSEIF (TD_DARWIN)
|
||||
SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ IF (TD_MVN_INSTALLED)
|
|||
ADD_CUSTOM_COMMAND(OUTPUT ${JDBC_CMD_NAME}
|
||||
POST_BUILD
|
||||
COMMAND mvn -Dmaven.test.skip=true install -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.25-dist.jar ${LIBRARY_OUTPUT_PATH}
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.28-dist.jar ${LIBRARY_OUTPUT_PATH}
|
||||
COMMAND mvn -Dmaven.test.skip=true clean -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
|
||||
COMMENT "build jdbc driver")
|
||||
ADD_CUSTOM_TARGET(${JDBC_TARGET_NAME} ALL WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} DEPENDS ${JDBC_CMD_NAME})
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
<groupId>com.taosdata.jdbc</groupId>
|
||||
<artifactId>taos-jdbcdriver</artifactId>
|
||||
<version>2.0.25</version>
|
||||
<version>2.0.28</version>
|
||||
<packaging>jar</packaging>
|
||||
|
||||
<name>JDBCDriver</name>
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
<modelVersion>4.0.0</modelVersion>
|
||||
<groupId>com.taosdata.jdbc</groupId>
|
||||
<artifactId>taos-jdbcdriver</artifactId>
|
||||
<version>2.0.25</version>
|
||||
<version>2.0.28</version>
|
||||
<packaging>jar</packaging>
|
||||
<name>JDBCDriver</name>
|
||||
<url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>
|
||||
|
|
|
|||
|
|
@ -4,13 +4,23 @@ import java.sql.*;
|
|||
import java.util.Enumeration;
|
||||
import java.util.Map;
|
||||
import java.util.Properties;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.*;
|
||||
|
||||
public abstract class AbstractConnection extends WrapperImpl implements Connection {
|
||||
|
||||
protected volatile boolean isClosed;
|
||||
protected volatile String catalog;
|
||||
protected volatile Properties clientInfoProps = new Properties();
|
||||
protected final Properties clientInfoProps = new Properties();
|
||||
|
||||
protected AbstractConnection(Properties properties) {
|
||||
Set<String> propNames = properties.stringPropertyNames();
|
||||
for (String propName : propNames) {
|
||||
clientInfoProps.setProperty(propName, properties.getProperty(propName));
|
||||
}
|
||||
String timestampFormat = properties.getProperty(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT, "STRING");
|
||||
clientInfoProps.setProperty(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT, timestampFormat);
|
||||
}
|
||||
|
||||
@Override
|
||||
public abstract Statement createStatement() throws SQLException;
|
||||
|
|
@ -35,7 +45,6 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
|
|||
}
|
||||
|
||||
|
||||
|
||||
@Override
|
||||
public void setAutoCommit(boolean autoCommit) throws SQLException {
|
||||
if (isClosed())
|
||||
|
|
@ -441,9 +450,8 @@ public abstract class AbstractConnection extends WrapperImpl implements Connecti
|
|||
if (isClosed)
|
||||
throw (SQLClientInfoException) TSDBError.createSQLException(TSDBErrorNumbers.ERROR_SQLCLIENT_EXCEPTION_ON_CONNECTION_CLOSED);
|
||||
|
||||
if (clientInfoProps == null)
|
||||
clientInfoProps = new Properties();
|
||||
clientInfoProps.setProperty(name, value);
|
||||
if (clientInfoProps != null)
|
||||
clientInfoProps.setProperty(name, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ import java.util.Map;
|
|||
|
||||
public abstract class AbstractResultSet extends WrapperImpl implements ResultSet {
|
||||
private int fetchSize;
|
||||
protected boolean wasNull;
|
||||
|
||||
protected void checkAvailability(int columnIndex, int bounds) throws SQLException {
|
||||
if (isClosed())
|
||||
|
|
@ -28,7 +29,7 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
|
|||
|
||||
@Override
|
||||
public boolean wasNull() throws SQLException {
|
||||
return false;
|
||||
return wasNull;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ public class TSDBConnection extends AbstractConnection {
|
|||
}
|
||||
|
||||
public TSDBConnection(Properties info, TSDBDatabaseMetaData meta) throws SQLException {
|
||||
super(info);
|
||||
this.databaseMetaData = meta;
|
||||
connect(info.getProperty(TSDBDriver.PROPERTY_KEY_HOST),
|
||||
Integer.parseInt(info.getProperty(TSDBDriver.PROPERTY_KEY_PORT, "0")),
|
||||
|
|
|
|||
|
|
@ -95,11 +95,16 @@ public class TSDBDriver extends AbstractDriver {
|
|||
*/
|
||||
public static final String PROPERTY_KEY_BATCH_LOAD = "batchfetch";
|
||||
|
||||
/**
|
||||
* timestamp format for JDBC-RESTful,should one of the options: string or timestamp or utc
|
||||
*/
|
||||
public static final String PROPERTY_KEY_TIMESTAMP_FORMAT = "timestampFormat";
|
||||
|
||||
private TSDBDatabaseMetaData dbMetaData = null;
|
||||
|
||||
static {
|
||||
try {
|
||||
java.sql.DriverManager.registerDriver(new TSDBDriver());
|
||||
DriverManager.registerDriver(new TSDBDriver());
|
||||
} catch (SQLException e) {
|
||||
throw TSDBError.createRuntimeException(TSDBErrorNumbers.ERROR_CANNOT_REGISTER_JNI_DRIVER, e);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,11 +14,12 @@
|
|||
*****************************************************************************/
|
||||
package com.taosdata.jdbc;
|
||||
|
||||
import com.taosdata.jdbc.utils.Utils;
|
||||
|
||||
import java.io.InputStream;
|
||||
import java.io.Reader;
|
||||
import java.math.BigDecimal;
|
||||
import java.net.URL;
|
||||
import java.nio.charset.Charset;
|
||||
import java.sql.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Calendar;
|
||||
|
|
@ -33,17 +34,9 @@ import java.util.regex.Pattern;
|
|||
public class TSDBPreparedStatement extends TSDBStatement implements PreparedStatement {
|
||||
|
||||
private String rawSql;
|
||||
private String sql;
|
||||
// private ArrayList<Object> parameters = new ArrayList<>();
|
||||
private Object[] parameters;
|
||||
private boolean isPrepared;
|
||||
|
||||
//start with insert or import and is case-insensitive
|
||||
private static Pattern savePattern = Pattern.compile("(?i)^\\s*(insert|import)");
|
||||
// is insert or import
|
||||
private boolean isSaved;
|
||||
|
||||
// private SavedPreparedStatement savedPreparedStatement;
|
||||
private volatile TSDBParameterMetaData parameterMetaData;
|
||||
|
||||
TSDBPreparedStatement(TSDBConnection connection, TSDBJNIConnector connecter, String sql) {
|
||||
|
|
@ -65,35 +58,11 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
|
|||
private void init(String sql) {
|
||||
this.rawSql = sql;
|
||||
preprocessSql();
|
||||
// this.isSaved = isSavedSql(this.rawSql);
|
||||
// if (this.isSaved) {
|
||||
// try {
|
||||
// this.savedPreparedStatement = new SavedPreparedStatement(this.rawSql, this);
|
||||
// } catch (SQLException e) {
|
||||
// e.printStackTrace();
|
||||
// }
|
||||
// }
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* if the precompiled sql is insert or import
|
||||
*
|
||||
* @param sql
|
||||
* @return
|
||||
*/
|
||||
private boolean isSavedSql(String sql) {
|
||||
Matcher matcher = savePattern.matcher(sql);
|
||||
return matcher.find();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int[] executeBatch() throws SQLException {
|
||||
// if (isSaved) {
|
||||
// return this.savedPreparedStatement.executeBatch();
|
||||
// } else {
|
||||
return super.executeBatch();
|
||||
// }
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -157,152 +126,64 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
|
|||
*
|
||||
* @return a string of the native sql statement for TSDB
|
||||
*/
|
||||
// private String getNativeSql(String rawSql) {
|
||||
// for (int i = 0; i < parameters.length; i++) {
|
||||
// Object para = parameters[i];
|
||||
// if (para != null) {
|
||||
// String paraStr = para.toString();
|
||||
// if (para instanceof Timestamp || para instanceof String) {
|
||||
// paraStr = "'" + paraStr + "'";
|
||||
// }
|
||||
// this.sql = this.sql.replaceFirst("[?]", paraStr);
|
||||
// } else {
|
||||
// this.sql = this.sql.replaceFirst("[?]", "NULL");
|
||||
// }
|
||||
// }
|
||||
// parameters = new Object[parameters.length];
|
||||
// return sql;
|
||||
// }
|
||||
|
||||
private String getNativeSql(String rawSql) throws SQLException {
|
||||
String sql = rawSql;
|
||||
for (int i = 0; i < parameters.length; ++i) {
|
||||
Object para = parameters[i];
|
||||
if (para != null) {
|
||||
String paraStr;
|
||||
if (para instanceof byte[]) {
|
||||
paraStr = new String((byte[]) para, Charset.forName("UTF-8"));
|
||||
} else {
|
||||
paraStr = para.toString();
|
||||
}
|
||||
// if para is timestamp or String or byte[] need to translate ' character
|
||||
if (para instanceof Timestamp || para instanceof String || para instanceof byte[]) {
|
||||
paraStr = paraStr.replaceAll("'", "\\\\\\\\'");
|
||||
paraStr = "'" + paraStr + "'";
|
||||
}
|
||||
sql = sql.replaceFirst("[?]", paraStr);
|
||||
} else {
|
||||
sql = sql.replaceFirst("[?]", "NULL");
|
||||
}
|
||||
}
|
||||
clearParameters();
|
||||
return sql;
|
||||
return Utils.getNativeSql(rawSql, this.parameters);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ResultSet executeQuery() throws SQLException {
|
||||
// if (isSaved) {
|
||||
// this.savedPreparedStatement.executeBatchInternal();
|
||||
// return null;
|
||||
// } else {
|
||||
|
||||
if (!isPrepared)
|
||||
return executeQuery(this.rawSql);
|
||||
|
||||
final String sql = getNativeSql(this.rawSql);
|
||||
return executeQuery(sql);
|
||||
// }
|
||||
}
|
||||
|
||||
@Override
|
||||
public int executeUpdate() throws SQLException {
|
||||
// if (isSaved) {
|
||||
// return this.savedPreparedStatement.executeBatchInternal();
|
||||
// } else {
|
||||
if (!isPrepared)
|
||||
return executeUpdate(this.rawSql);
|
||||
String sql = getNativeSql(this.rawSql);
|
||||
return executeUpdate(sql);
|
||||
// }
|
||||
}
|
||||
|
||||
private boolean isSupportedSQLType(int sqlType) {
|
||||
switch (sqlType) {
|
||||
case Types.TIMESTAMP:
|
||||
case Types.INTEGER:
|
||||
case Types.BIGINT:
|
||||
case Types.FLOAT:
|
||||
case Types.DOUBLE:
|
||||
case Types.SMALLINT:
|
||||
case Types.TINYINT:
|
||||
case Types.BOOLEAN:
|
||||
case Types.BINARY:
|
||||
case Types.NCHAR:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNull(int parameterIndex, int sqlType) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
if (!isSupportedSQLType(sqlType) || parameterIndex < 0)
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
|
||||
// if (parameterIndex >= parameters.size())
|
||||
// throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_BOUNDARY);
|
||||
|
||||
setObject(parameterIndex, "NULL");
|
||||
setObject(parameterIndex, null);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBoolean(int parameterIndex, boolean x) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setByte(int parameterIndex, byte x) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
setObject(parameterIndex,x);
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setShort(int parameterIndex, short x) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setInt(int parameterIndex, int x) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setLong(int parameterIndex, long x) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setFloat(int parameterIndex, float x) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setDouble(int parameterIndex, double x) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
|
|
@ -315,17 +196,12 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
|
|||
|
||||
@Override
|
||||
public void setString(int parameterIndex, String x) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBytes(int parameterIndex, byte[] x) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
|
||||
setObject(parameterIndex,x);
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -344,8 +220,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
|
|||
|
||||
@Override
|
||||
public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
|
|
@ -360,7 +234,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
|
|||
public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
|
||||
}
|
||||
|
||||
|
|
@ -375,8 +248,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
|
|||
public void clearParameters() throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
|
||||
// parameters.clear();
|
||||
parameters = new Object[parameters.length];
|
||||
}
|
||||
|
||||
|
|
@ -384,43 +255,29 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
|
|||
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setObject(int parameterIndex, Object x) throws SQLException {
|
||||
// if (isSaved) {
|
||||
// this.savedPreparedStatement.setParam(parameterIndex, x);
|
||||
// } else {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
if (parameterIndex < 1 && parameterIndex >= parameters.length)
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
|
||||
|
||||
parameters[parameterIndex - 1] = x;
|
||||
// parameters.add(x);
|
||||
// }
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute() throws SQLException {
|
||||
// if (isSaved) {
|
||||
// int result = this.savedPreparedStatement.executeBatchInternal();
|
||||
// return result > 0;
|
||||
// } else {
|
||||
if (!isPrepared)
|
||||
return execute(this.rawSql);
|
||||
|
||||
final String sql = getNativeSql(this.rawSql);
|
||||
|
||||
return execute(sql);
|
||||
// }
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addBatch() throws SQLException {
|
||||
// if (isSaved) {
|
||||
// this.savedPreparedStatement.addBatch();
|
||||
// } else {
|
||||
if (this.batchedArgs == null) {
|
||||
batchedArgs = new ArrayList<>();
|
||||
}
|
||||
|
|
@ -431,7 +288,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
|
|||
String sql = this.getConnection().nativeSQL(this.rawSql);
|
||||
addBatch(sql);
|
||||
}
|
||||
// }
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -475,7 +331,6 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
|
|||
public ResultSetMetaData getMetaData() throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
// return this.getResultSet().getMetaData();
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -203,7 +203,11 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet {
|
|||
|
||||
this.lastWasNull = this.rowData.wasNull(columnIndex - 1);
|
||||
if (!lastWasNull) {
|
||||
res = this.rowData.getLong(columnIndex - 1, this.columnMetaDataList.get(columnIndex - 1).getColType());
|
||||
Object value = this.rowData.get(columnIndex - 1);
|
||||
if (value instanceof Timestamp)
|
||||
res = ((Timestamp) value).getTime();
|
||||
else
|
||||
res = this.rowData.getLong(columnIndex - 1, this.columnMetaDataList.get(columnIndex - 1).getColType());
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
|
@ -273,7 +277,6 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet {
|
|||
checkAvailability(columnIndex, this.columnMetaDataList.size());
|
||||
|
||||
Timestamp res = null;
|
||||
|
||||
if (this.getBatchFetch())
|
||||
return this.blockData.getTimestamp(columnIndex - 1);
|
||||
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@ package com.taosdata.jdbc;
|
|||
import java.math.BigDecimal;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Timestamp;
|
||||
import java.time.Instant;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
|
||||
|
|
@ -299,7 +300,19 @@ public class TSDBResultSetRowData {
|
|||
}
|
||||
|
||||
public void setTimestamp(int col, long ts) {
|
||||
data.set(col, new Timestamp(ts));
|
||||
//TODO: this implementation contains logical error
|
||||
// when precision is us the (long ts) is 16 digital number
|
||||
// when precision is ms, the (long ts) is 13 digital number
|
||||
// we need a JNI function like this:
|
||||
// public void setTimestamp(int col, long epochSecond, long nanoAdjustment)
|
||||
if (ts < 1_0000_0000_0000_0L) {
|
||||
data.set(col, new Timestamp(ts));
|
||||
} else {
|
||||
long epochSec = ts / 1000_000l;
|
||||
long nanoAdjustment = ts % 1000_000l * 1000l;
|
||||
Timestamp timestamp = Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
|
||||
data.set(col, timestamp);
|
||||
}
|
||||
}
|
||||
|
||||
public Timestamp getTimestamp(int col) {
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ public class RestfulConnection extends AbstractConnection {
|
|||
private final DatabaseMetaData metadata;
|
||||
|
||||
public RestfulConnection(String host, String port, Properties props, String database, String url) {
|
||||
super(props);
|
||||
this.host = host;
|
||||
this.port = Integer.parseInt(port);
|
||||
this.database = database;
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ public class RestfulDriver extends AbstractDriver {
|
|||
|
||||
static {
|
||||
try {
|
||||
java.sql.DriverManager.registerDriver(new RestfulDriver());
|
||||
DriverManager.registerDriver(new RestfulDriver());
|
||||
} catch (SQLException e) {
|
||||
throw TSDBError.createRuntimeException(TSDBErrorNumbers.ERROR_URL_NOT_SET, e);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,12 @@
|
|||
package com.taosdata.jdbc.rs;
|
||||
|
||||
import com.google.common.collect.Range;
|
||||
import com.google.common.collect.RangeSet;
|
||||
import com.google.common.collect.TreeRangeSet;
|
||||
import com.taosdata.jdbc.TSDBError;
|
||||
import com.taosdata.jdbc.TSDBErrorNumbers;
|
||||
import com.taosdata.jdbc.utils.SqlSyntaxValidator;
|
||||
import com.taosdata.jdbc.utils.Utils;
|
||||
|
||||
import java.io.InputStream;
|
||||
import java.io.Reader;
|
||||
|
|
@ -10,6 +15,12 @@ import java.net.URL;
|
|||
import java.nio.charset.Charset;
|
||||
import java.sql.*;
|
||||
import java.util.Calendar;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.IntStream;
|
||||
|
||||
public class RestfulPreparedStatement extends RestfulStatement implements PreparedStatement {
|
||||
|
||||
|
|
@ -21,6 +32,7 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
|
|||
public RestfulPreparedStatement(RestfulConnection conn, String database, String sql) {
|
||||
super(conn, database);
|
||||
this.rawSql = sql;
|
||||
|
||||
if (sql.contains("?")) {
|
||||
int parameterCnt = 0;
|
||||
for (int i = 0; i < sql.length(); i++) {
|
||||
|
|
@ -58,29 +70,14 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
|
|||
return executeUpdate(sql);
|
||||
}
|
||||
|
||||
private String getNativeSql(String rawSql) throws SQLException {
|
||||
String sql = rawSql;
|
||||
for (int i = 0; i < parameters.length; ++i) {
|
||||
Object para = parameters[i];
|
||||
if (para != null) {
|
||||
String paraStr;
|
||||
if (para instanceof byte[]) {
|
||||
paraStr = new String((byte[]) para, Charset.forName("UTF-8"));
|
||||
} else {
|
||||
paraStr = para.toString();
|
||||
}
|
||||
// if para is timestamp or String or byte[] need to translate ' character
|
||||
if (para instanceof Timestamp || para instanceof String || para instanceof byte[]) {
|
||||
paraStr = paraStr.replaceAll("'", "\\\\\\\\'");
|
||||
paraStr = "'" + paraStr + "'";
|
||||
}
|
||||
sql = sql.replaceFirst("[?]", paraStr);
|
||||
} else {
|
||||
sql = sql.replaceFirst("[?]", "NULL");
|
||||
}
|
||||
}
|
||||
clearParameters();
|
||||
return sql;
|
||||
/****
|
||||
* 将rawSql转换成一条可执行的sql语句，使用属性parameters中的变脸进行替换
|
||||
* 对于insert into ?.? (?,?,?) using ?.? (?,?,?) tags(?, ?, ?) values(?, ?, ?)
|
||||
* @param rawSql，可能是insert、select或其他，使用?做占位符
|
||||
* @return
|
||||
*/
|
||||
private String getNativeSql(String rawSql) {
|
||||
return Utils.getNativeSql(rawSql, this.parameters);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -220,8 +217,8 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
|
|||
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
|
||||
|
||||
setObject(parameterIndex,x);
|
||||
|
||||
setObject(parameterIndex, x);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -5,13 +5,12 @@ import com.alibaba.fastjson.JSONObject;
|
|||
import com.google.common.primitives.Ints;
|
||||
import com.google.common.primitives.Longs;
|
||||
import com.google.common.primitives.Shorts;
|
||||
import com.taosdata.jdbc.AbstractResultSet;
|
||||
import com.taosdata.jdbc.TSDBConstants;
|
||||
import com.taosdata.jdbc.TSDBError;
|
||||
import com.taosdata.jdbc.TSDBErrorNumbers;
|
||||
import com.taosdata.jdbc.*;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.sql.*;
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Calendar;
|
||||
|
||||
|
|
@ -19,6 +18,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
private volatile boolean isClosed;
|
||||
private int pos = -1;
|
||||
|
||||
|
||||
private final String database;
|
||||
private final Statement statement;
|
||||
// data
|
||||
|
|
@ -65,7 +65,7 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
}
|
||||
}
|
||||
|
||||
private Object parseColumnData(JSONArray row, int colIndex, int taosType) {
|
||||
private Object parseColumnData(JSONArray row, int colIndex, int taosType) throws SQLException {
|
||||
switch (taosType) {
|
||||
case TSDBConstants.TSDB_DATA_TYPE_BOOL:
|
||||
return row.getBoolean(colIndex);
|
||||
|
|
@ -81,8 +81,44 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
return row.getFloat(colIndex);
|
||||
case TSDBConstants.TSDB_DATA_TYPE_DOUBLE:
|
||||
return row.getDouble(colIndex);
|
||||
case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP:
|
||||
return new Timestamp(row.getDate(colIndex).getTime());
|
||||
case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP: {
|
||||
if (row.get(colIndex) == null)
|
||||
return null;
|
||||
String timestampFormat = this.statement.getConnection().getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT);
|
||||
if ("TIMESTAMP".equalsIgnoreCase(timestampFormat)) {
|
||||
Long value = row.getLong(colIndex);
|
||||
//TODO: this implementation has bug if the timestamp bigger than 9999_9999_9999_9
|
||||
if (value < 1_0000_0000_0000_0L)
|
||||
return new Timestamp(value);
|
||||
long epochSec = value / 1000_000l;
|
||||
long nanoAdjustment = value % 1000_000l * 1000l;
|
||||
return Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
|
||||
}
|
||||
if ("UTC".equalsIgnoreCase(timestampFormat)) {
|
||||
String value = row.getString(colIndex);
|
||||
long epochSec = Timestamp.valueOf(value.substring(0, 19).replace("T", " ")).getTime() / 1000;
|
||||
int fractionalSec = Integer.parseInt(value.substring(20, value.length() - 5));
|
||||
long nanoAdjustment = 0;
|
||||
if (value.length() > 28) {
|
||||
// ms timestamp: yyyy-MM-ddTHH:mm:ss.SSSSSS+0x00
|
||||
nanoAdjustment = fractionalSec * 1000l;
|
||||
} else {
|
||||
// ms timestamp: yyyy-MM-ddTHH:mm:ss.SSS+0x00
|
||||
nanoAdjustment = fractionalSec * 1000_000l;
|
||||
}
|
||||
ZoneOffset zoneOffset = ZoneOffset.of(value.substring(value.length() - 5));
|
||||
Instant instant = Instant.ofEpochSecond(epochSec, nanoAdjustment).atOffset(zoneOffset).toInstant();
|
||||
return Timestamp.from(instant);
|
||||
}
|
||||
String value = row.getString(colIndex);
|
||||
if (value.length() <= 23) // ms timestamp: yyyy-MM-dd HH:mm:ss.SSS
|
||||
return row.getTimestamp(colIndex);
|
||||
// us timestamp: yyyy-MM-dd HH:mm:ss.SSSSSS
|
||||
long epochSec = Timestamp.valueOf(value.substring(0, 19)).getTime() / 1000;
|
||||
long nanoAdjustment = Integer.parseInt(value.substring(20)) * 1000l;
|
||||
Timestamp timestamp = Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
|
||||
return timestamp;
|
||||
}
|
||||
case TSDBConstants.TSDB_DATA_TYPE_BINARY:
|
||||
return row.getString(colIndex) == null ? null : row.getString(colIndex).getBytes();
|
||||
case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
|
||||
|
|
@ -126,12 +162,12 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean wasNull() throws SQLException {
|
||||
if (isClosed())
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
|
||||
return resultSet.isEmpty();
|
||||
}
|
||||
// @Override
|
||||
// public boolean wasNull() throws SQLException {
|
||||
// if (isClosed())
|
||||
// throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
|
||||
// return resultSet.isEmpty();
|
||||
// }
|
||||
|
||||
@Override
|
||||
public String getString(int columnIndex) throws SQLException {
|
||||
|
|
@ -150,8 +186,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
checkAvailability(columnIndex, resultSet.get(pos).size());
|
||||
|
||||
Object value = resultSet.get(pos).get(columnIndex - 1);
|
||||
if (value == null)
|
||||
if (value == null) {
|
||||
wasNull = true;
|
||||
return false;
|
||||
}
|
||||
wasNull = false;
|
||||
if (value instanceof Boolean)
|
||||
return (boolean) value;
|
||||
return Boolean.valueOf(value.toString());
|
||||
|
|
@ -162,8 +201,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
checkAvailability(columnIndex, resultSet.get(pos).size());
|
||||
|
||||
Object value = resultSet.get(pos).get(columnIndex - 1);
|
||||
if (value == null)
|
||||
if (value == null) {
|
||||
wasNull = true;
|
||||
return 0;
|
||||
}
|
||||
wasNull = false;
|
||||
long valueAsLong = Long.parseLong(value.toString());
|
||||
if (valueAsLong == Byte.MIN_VALUE)
|
||||
return 0;
|
||||
|
|
@ -183,8 +225,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
checkAvailability(columnIndex, resultSet.get(pos).size());
|
||||
|
||||
Object value = resultSet.get(pos).get(columnIndex - 1);
|
||||
if (value == null)
|
||||
if (value == null) {
|
||||
wasNull = true;
|
||||
return 0;
|
||||
}
|
||||
wasNull = false;
|
||||
long valueAsLong = Long.parseLong(value.toString());
|
||||
if (valueAsLong == Short.MIN_VALUE)
|
||||
return 0;
|
||||
|
|
@ -198,8 +243,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
checkAvailability(columnIndex, resultSet.get(pos).size());
|
||||
|
||||
Object value = resultSet.get(pos).get(columnIndex - 1);
|
||||
if (value == null)
|
||||
if (value == null) {
|
||||
wasNull = true;
|
||||
return 0;
|
||||
}
|
||||
wasNull = false;
|
||||
long valueAsLong = Long.parseLong(value.toString());
|
||||
if (valueAsLong == Integer.MIN_VALUE)
|
||||
return 0;
|
||||
|
|
@ -213,9 +261,14 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
checkAvailability(columnIndex, resultSet.get(pos).size());
|
||||
|
||||
Object value = resultSet.get(pos).get(columnIndex - 1);
|
||||
if (value == null)
|
||||
if (value == null) {
|
||||
wasNull = true;
|
||||
return 0;
|
||||
|
||||
}
|
||||
wasNull = false;
|
||||
if (value instanceof Timestamp) {
|
||||
return ((Timestamp) value).getTime();
|
||||
}
|
||||
long valueAsLong = 0;
|
||||
try {
|
||||
valueAsLong = Long.parseLong(value.toString());
|
||||
|
|
@ -232,8 +285,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
checkAvailability(columnIndex, resultSet.get(pos).size());
|
||||
|
||||
Object value = resultSet.get(pos).get(columnIndex - 1);
|
||||
if (value == null)
|
||||
if (value == null) {
|
||||
wasNull = true;
|
||||
return 0;
|
||||
}
|
||||
wasNull = false;
|
||||
if (value instanceof Float || value instanceof Double)
|
||||
return (float) value;
|
||||
return Float.parseFloat(value.toString());
|
||||
|
|
@ -244,8 +300,11 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
checkAvailability(columnIndex, resultSet.get(pos).size());
|
||||
|
||||
Object value = resultSet.get(pos).get(columnIndex - 1);
|
||||
if (value == null)
|
||||
if (value == null) {
|
||||
wasNull = true;
|
||||
return 0;
|
||||
}
|
||||
wasNull = false;
|
||||
if (value instanceof Double || value instanceof Float)
|
||||
return (double) value;
|
||||
return Double.parseDouble(value.toString());
|
||||
|
|
@ -307,6 +366,13 @@ public class RestfulResultSet extends AbstractResultSet implements ResultSet {
|
|||
return null;
|
||||
if (value instanceof Timestamp)
|
||||
return (Timestamp) value;
|
||||
// if (value instanceof Long) {
|
||||
// if (1_0000_0000_0000_0L > (long) value)
|
||||
// return Timestamp.from(Instant.ofEpochMilli((long) value));
|
||||
// long epochSec = (long) value / 1000_000L;
|
||||
// long nanoAdjustment = (long) ((long) value % 1000_000L * 1000);
|
||||
// return Timestamp.from(Instant.ofEpochSecond(epochSec, nanoAdjustment));
|
||||
// }
|
||||
return Timestamp.valueOf(value.toString());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ import com.alibaba.fastjson.JSON;
|
|||
import com.alibaba.fastjson.JSONArray;
|
||||
import com.alibaba.fastjson.JSONObject;
|
||||
import com.taosdata.jdbc.AbstractStatement;
|
||||
import com.taosdata.jdbc.TSDBDriver;
|
||||
import com.taosdata.jdbc.TSDBError;
|
||||
import com.taosdata.jdbc.TSDBErrorNumbers;
|
||||
import com.taosdata.jdbc.utils.HttpClientPoolUtil;
|
||||
|
|
@ -34,14 +35,11 @@ public class RestfulStatement extends AbstractStatement {
|
|||
if (!SqlSyntaxValidator.isValidForExecuteQuery(sql))
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_FOR_EXECUTE_QUERY, "not a valid sql for executeQuery: " + sql);
|
||||
|
||||
final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
|
||||
if (SqlSyntaxValidator.isDatabaseUnspecifiedQuery(sql)) {
|
||||
return executeOneQuery(url, sql);
|
||||
return executeOneQuery(sql);
|
||||
}
|
||||
|
||||
// if (this.database != null && !this.database.trim().replaceAll("\\s","").isEmpty())
|
||||
// HttpClientPoolUtil.execute(url, "use " + this.database);
|
||||
return executeOneQuery(url, sql);
|
||||
return executeOneQuery(sql);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -56,8 +54,6 @@ public class RestfulStatement extends AbstractStatement {
|
|||
return executeOneUpdate(url, sql);
|
||||
}
|
||||
|
||||
// if (this.database != null && !this.database.trim().replaceAll("\\s", "").isEmpty())
|
||||
// HttpClientPoolUtil.execute(url, "use " + this.database);
|
||||
return executeOneUpdate(url, sql);
|
||||
}
|
||||
|
||||
|
|
@ -78,14 +74,21 @@ public class RestfulStatement extends AbstractStatement {
|
|||
|
||||
//如果执行了use操作应该将当前Statement的catalog设置为新的database
|
||||
boolean result = true;
|
||||
final String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
|
||||
String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
|
||||
if (conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT).equals("TIMESTAMP")) {
|
||||
url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlt";
|
||||
}
|
||||
if (conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT).equals("UTC")) {
|
||||
url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlutc";
|
||||
}
|
||||
|
||||
if (SqlSyntaxValidator.isUseSql(sql)) {
|
||||
HttpClientPoolUtil.execute(url, sql);
|
||||
this.database = sql.trim().replace("use", "").trim();
|
||||
this.conn.setCatalog(this.database);
|
||||
result = false;
|
||||
} else if (SqlSyntaxValidator.isDatabaseUnspecifiedQuery(sql)) {
|
||||
executeOneQuery(url, sql);
|
||||
executeOneQuery(sql);
|
||||
} else if (SqlSyntaxValidator.isDatabaseUnspecifiedUpdate(sql)) {
|
||||
executeOneUpdate(url, sql);
|
||||
result = false;
|
||||
|
|
@ -101,11 +104,18 @@ public class RestfulStatement extends AbstractStatement {
|
|||
return result;
|
||||
}
|
||||
|
||||
private ResultSet executeOneQuery(String url, String sql) throws SQLException {
|
||||
private ResultSet executeOneQuery(String sql) throws SQLException {
|
||||
if (!SqlSyntaxValidator.isValidForExecuteQuery(sql))
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_FOR_EXECUTE_QUERY, "not a valid sql for executeQuery: " + sql);
|
||||
|
||||
// row data
|
||||
String url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sql";
|
||||
String timestampFormat = conn.getClientInfo(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT);
|
||||
if ("TIMESTAMP".equalsIgnoreCase(timestampFormat))
|
||||
url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlt";
|
||||
if ("UTC".equalsIgnoreCase(timestampFormat))
|
||||
url = "http://" + conn.getHost() + ":" + conn.getPort() + "/rest/sqlutc";
|
||||
|
||||
String result = HttpClientPoolUtil.execute(url, sql);
|
||||
JSONObject resultJson = JSON.parseObject(result);
|
||||
if (resultJson.getString("status").equals("error")) {
|
||||
|
|
@ -126,21 +136,21 @@ public class RestfulStatement extends AbstractStatement {
|
|||
throw TSDBError.createSQLException(jsonObject.getInteger("code"), jsonObject.getString("desc"));
|
||||
}
|
||||
this.resultSet = null;
|
||||
this.affectedRows = checkJsonResultSet(jsonObject);
|
||||
this.affectedRows = getAffectedRows(jsonObject);
|
||||
return this.affectedRows;
|
||||
}
|
||||
|
||||
private int checkJsonResultSet(JSONObject jsonObject) {
|
||||
private int getAffectedRows(JSONObject jsonObject) throws SQLException {
|
||||
// create ... SQLs should return 0 , and Restful result is this:
|
||||
// {"status": "succ", "head": ["affected_rows"], "data": [[0]], "rows": 1}
|
||||
JSONArray head = jsonObject.getJSONArray("head");
|
||||
if (head.size() != 1 || !"affected_rows".equals(head.getString(0)))
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
|
||||
JSONArray data = jsonObject.getJSONArray("data");
|
||||
int rows = Integer.parseInt(jsonObject.getString("rows"));
|
||||
if (head.size() == 1 && "affected_rows".equals(head.getString(0))
|
||||
&& data.size() == 1 && data.getJSONArray(0).getInteger(0) == 0 && rows == 1) {
|
||||
return 0;
|
||||
}
|
||||
return rows;
|
||||
if (data != null)
|
||||
return data.getJSONArray(0).getInteger(0);
|
||||
|
||||
throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -0,0 +1,12 @@
|
|||
package com.taosdata.jdbc.utils;
|
||||
|
||||
import java.time.format.DateTimeFormatter;
|
||||
import java.time.format.DateTimeFormatterBuilder;
|
||||
|
||||
public class UtcTimestampUtil {
|
||||
public static final DateTimeFormatter formatter = new DateTimeFormatterBuilder()
|
||||
.appendPattern("yyyy-MM-ddTHH:mm:ss.SSS+")
|
||||
// .appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true)
|
||||
.toFormatter();
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
package com.taosdata.jdbc.utils;
|
||||
|
||||
import com.google.common.collect.Range;
|
||||
import com.google.common.collect.RangeSet;
|
||||
import com.google.common.collect.TreeRangeSet;
|
||||
|
||||
import java.nio.charset.Charset;
|
||||
import java.sql.Timestamp;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.IntStream;
|
||||
|
||||
public class Utils {
|
||||
|
||||
private static Pattern ptn = Pattern.compile(".*?'");
|
||||
|
||||
public static String escapeSingleQuota(String origin) {
|
||||
Matcher m = ptn.matcher(origin);
|
||||
StringBuffer sb = new StringBuffer();
|
||||
int end = 0;
|
||||
while (m.find()) {
|
||||
end = m.end();
|
||||
String seg = origin.substring(m.start(), end);
|
||||
int len = seg.length();
|
||||
if (len == 1) {
|
||||
if ('\'' == seg.charAt(0)) {
|
||||
sb.append("\\'");
|
||||
} else {
|
||||
sb.append(seg);
|
||||
}
|
||||
} else { // len > 1
|
||||
sb.append(seg.substring(0, seg.length() - 2));
|
||||
char lastcSec = seg.charAt(seg.length() - 2);
|
||||
if (lastcSec == '\\') {
|
||||
sb.append("\\'");
|
||||
} else {
|
||||
sb.append(lastcSec);
|
||||
sb.append("\\'");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (end < origin.length()) {
|
||||
sb.append(origin.substring(end));
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
public static String getNativeSql(String rawSql, Object[] parameters) {
|
||||
// toLowerCase
|
||||
String preparedSql = rawSql.trim().toLowerCase();
|
||||
|
||||
String[] clause = new String[0];
|
||||
if (SqlSyntaxValidator.isInsertSql(preparedSql)) {
|
||||
// insert or import
|
||||
clause = new String[]{"values\\s*\\(.*?\\)", "tags\\s*\\(.*?\\)"};
|
||||
}
|
||||
if (SqlSyntaxValidator.isSelectSql(preparedSql)) {
|
||||
// select
|
||||
clause = new String[]{"where\\s*.*"};
|
||||
}
|
||||
Map<Integer, Integer> placeholderPositions = new HashMap<>();
|
||||
RangeSet<Integer> clauseRangeSet = TreeRangeSet.create();
|
||||
findPlaceholderPosition(preparedSql, placeholderPositions);
|
||||
findClauseRangeSet(preparedSql, clause, clauseRangeSet);
|
||||
|
||||
return transformSql(preparedSql, parameters, placeholderPositions, clauseRangeSet);
|
||||
}
|
||||
|
||||
private static void findClauseRangeSet(String preparedSql, String[] regexArr, RangeSet<Integer> clauseRangeSet) {
|
||||
clauseRangeSet.clear();
|
||||
for (String regex : regexArr) {
|
||||
Matcher matcher = Pattern.compile(regex).matcher(preparedSql);
|
||||
while (matcher.find()) {
|
||||
int start = matcher.start();
|
||||
int end = matcher.end();
|
||||
clauseRangeSet.add(Range.closed(start, end));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void findPlaceholderPosition(String preparedSql, Map<Integer, Integer> placeholderPosition) {
|
||||
placeholderPosition.clear();
|
||||
Matcher matcher = Pattern.compile("\\?").matcher(preparedSql);
|
||||
int index = 0;
|
||||
while (matcher.find()) {
|
||||
int pos = matcher.start();
|
||||
placeholderPosition.put(index, pos);
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
/***
|
||||
*
|
||||
* @param preparedSql
|
||||
* @param paramArr
|
||||
* @param placeholderPosition
|
||||
* @param clauseRangeSet
|
||||
* @return
|
||||
*/
|
||||
private static String transformSql(String preparedSql, Object[] paramArr, Map<Integer, Integer> placeholderPosition, RangeSet<Integer> clauseRangeSet) {
|
||||
String[] sqlArr = preparedSql.split("\\?");
|
||||
return IntStream.range(0, sqlArr.length).mapToObj(index -> {
|
||||
if (index == paramArr.length)
|
||||
return sqlArr[index];
|
||||
|
||||
Object para = paramArr[index];
|
||||
String paraStr;
|
||||
if (para != null) {
|
||||
if (para instanceof byte[]) {
|
||||
paraStr = new String((byte[]) para, Charset.forName("UTF-8"));
|
||||
} else {
|
||||
paraStr = para.toString();
|
||||
}
|
||||
// if para is timestamp or String or byte[] need to translate ' character
|
||||
if (para instanceof Timestamp || para instanceof String || para instanceof byte[]) {
|
||||
paraStr = Utils.escapeSingleQuota(paraStr);
|
||||
|
||||
Integer pos = placeholderPosition.get(index);
|
||||
boolean contains = clauseRangeSet.contains(pos);
|
||||
if (contains) {
|
||||
paraStr = "'" + paraStr + "'";
|
||||
}
|
||||
}
|
||||
} else {
|
||||
paraStr = "NULL";
|
||||
}
|
||||
return sqlArr[index] + paraStr;
|
||||
}).collect(Collectors.joining());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -50,6 +50,51 @@ public class TSDBPreparedStatementTest {
|
|||
pstmt_insert.setNull(2, Types.INTEGER);
|
||||
int result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(3, Types.BIGINT);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(4, Types.FLOAT);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(5, Types.DOUBLE);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(6, Types.SMALLINT);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(7, Types.TINYINT);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(8, Types.BOOLEAN);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(9, Types.BINARY);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(10, Types.NCHAR);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(10, Types.OTHER);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -129,7 +174,7 @@ public class TSDBPreparedStatementTest {
|
|||
Assert.assertFalse(pstmt_insert.execute());
|
||||
}
|
||||
|
||||
class Person implements Serializable {
|
||||
class Person {
|
||||
String name;
|
||||
int age;
|
||||
boolean sex;
|
||||
|
|
|
|||
|
|
@ -160,6 +160,7 @@ public class TSDBResultSetTest {
|
|||
@Test
|
||||
public void getTime() throws SQLException {
|
||||
Time f1 = rs.getTime("f1");
|
||||
Assert.assertNotNull(f1);
|
||||
Assert.assertEquals("00:00:00", f1.toString());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ public class DriverAutoloadTest {
|
|||
final String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata";
|
||||
Connection conn = DriverManager.getConnection(url, properties);
|
||||
Assert.assertNotNull(conn);
|
||||
conn.close();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -27,6 +28,7 @@ public class DriverAutoloadTest {
|
|||
final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
|
||||
Connection conn = DriverManager.getConnection(url, properties);
|
||||
Assert.assertNotNull(conn);
|
||||
conn.close();
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,375 @@
|
|||
package com.taosdata.jdbc.cases;
|
||||
|
||||
import org.junit.*;
|
||||
|
||||
import java.sql.*;
|
||||
|
||||
public class InsertSpecialCharacterJniTest {
|
||||
|
||||
private static final String host = "127.0.0.1";
|
||||
private static Connection conn;
|
||||
private static String dbName = "spec_char_test";
|
||||
private static String tbname1 = "test";
|
||||
private static String tbname2 = "weather";
|
||||
private static String special_character_str_1 = "$asd$$fsfsf$";
|
||||
private static String special_character_str_2 = "\\asdfsfsf\\\\";
|
||||
private static String special_character_str_3 = "\\\\asdfsfsf\\";
|
||||
private static String special_character_str_4 = "?asd??fsf?sf?";
|
||||
private static String special_character_str_5 = "?#sd@$f(('<(s[P)>\"){]}f?s[]{}%vaew|\"fsfs^a&d*jhg)(j))(f@~!?$";
|
||||
|
||||
@Test
|
||||
public void testCase01() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_1.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from ?";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
pstmt.setString(1, tbname1);
|
||||
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_1, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testCase02() throws SQLException {
|
||||
//TODO:
|
||||
// Expected :\asdfsfsf\\
|
||||
// Actual :\asdfsfsf\
|
||||
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_2.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from " + tbname1;
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
//TODO: bug to be fixed
|
||||
// Assert.assertEquals(special_character_str_2, f1);
|
||||
Assert.assertEquals(special_character_str_2.substring(0, special_character_str_1.length() - 2), f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
public void testCase03() throws SQLException {
|
||||
//TODO:
|
||||
// TDengine ERROR (216): Syntax error in SQL
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_3.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from " + tbname1;
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_3, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase04() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_4.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from " + tbname1;
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery(query);
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_4, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase05() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_5.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from " + tbname1;
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery(query);
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_5, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase06() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into t? using " + tbname2 + " tags(?) values(?, ?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setInt(1, 1);
|
||||
pstmt.setString(2, special_character_str_4);
|
||||
pstmt.setTimestamp(3, new Timestamp(now));
|
||||
pstmt.setBytes(4, special_character_str_4.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query t1
|
||||
final String query = "select * from t1";
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery(query);
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_4, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase07() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1, f2) values(?, ?, ?) ; ";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_4.getBytes());
|
||||
pstmt.setString(3, special_character_str_4);
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from " + tbname1;
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery(query);
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_4, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertEquals(special_character_str_4, f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
public void testCase08() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into t? using " + tbname2 + " tags(?) values(?, ?, ?) ? ";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setInt(1, 1);
|
||||
pstmt.setString(2, special_character_str_5);
|
||||
pstmt.setTimestamp(3, new Timestamp(now));
|
||||
pstmt.setBytes(4, special_character_str_5.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase09() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into ?.t? using " + tbname2 + " tags(?) values(?, ?, ?) t? using weather tags(?) values(?,?,?) ";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
// t1
|
||||
pstmt.setString(1, dbName);
|
||||
pstmt.setInt(2, 1);
|
||||
pstmt.setString(3, special_character_str_5);
|
||||
pstmt.setTimestamp(4, new Timestamp(now));
|
||||
pstmt.setBytes(5, special_character_str_5.getBytes());
|
||||
// t2
|
||||
pstmt.setInt(7, 2);
|
||||
pstmt.setString(8, special_character_str_5);
|
||||
pstmt.setTimestamp(9, new Timestamp(now));
|
||||
pstmt.setString(11, special_character_str_5);
|
||||
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(2, ret);
|
||||
}
|
||||
// query t1
|
||||
String query = "select * from t?";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
pstmt.setInt(1, 1);
|
||||
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_5, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
// query t2
|
||||
query = "select * from t2";
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery(query);
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
byte[] f1 = rs.getBytes(2);
|
||||
Assert.assertNull(f1);
|
||||
String f2 = new String(rs.getBytes(3));
|
||||
Assert.assertEquals(special_character_str_5, f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase10() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
|
||||
// insert
|
||||
final String sql = "insert into t? using ? tags(?) values(?, ?, ?) t? using " + tbname2 + " tags(?) values(?,?,?) ";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
// t1
|
||||
pstmt.setInt(1, 1);
|
||||
pstmt.setString(2, tbname2);
|
||||
pstmt.setString(3, special_character_str_5);
|
||||
pstmt.setTimestamp(4, new Timestamp(now));
|
||||
pstmt.setBytes(5, special_character_str_5.getBytes());
|
||||
// t2
|
||||
pstmt.setInt(7, 2);
|
||||
pstmt.setString(8, special_character_str_5);
|
||||
pstmt.setTimestamp(9, new Timestamp(now));
|
||||
pstmt.setString(11, special_character_str_5);
|
||||
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(2, ret);
|
||||
}
|
||||
//query t1
|
||||
String query = "select * from ?.t? where ts < ? and ts >= ? and ? is not null";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
pstmt.setString(1, dbName);
|
||||
pstmt.setInt(2, 1);
|
||||
pstmt.setTimestamp(3, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt.setTimestamp(4, new Timestamp(0));
|
||||
pstmt.setString(5, "f1");
|
||||
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_5, f1);
|
||||
byte[] f2 = rs.getBytes(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
// query t2
|
||||
query = "select * from t? where ts < ? and ts >= ? and ? is not null";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
pstmt.setInt(1, 2);
|
||||
pstmt.setTimestamp(2, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt.setTimestamp(3, new Timestamp(0));
|
||||
pstmt.setString(4, "f2");
|
||||
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
byte[] f1 = rs.getBytes(2);
|
||||
Assert.assertNull(f1);
|
||||
String f2 = new String(rs.getBytes(3));
|
||||
Assert.assertEquals(special_character_str_5, f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
public void testCase11() throws SQLException {
|
||||
final String speicalCharacterStr = "?#sd@$f(((s[P)){]}f?s[]{}%vs^a&d*jhg)(j))(f@~!?$";
|
||||
final long now = System.currentTimeMillis();
|
||||
|
||||
final String sql = "insert into t? using " + tbname2 + " values(?, ?, 'abc?abc') ";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setInt(1, 1);
|
||||
pstmt.setTimestamp(2, new Timestamp(now));
|
||||
pstmt.setBytes(3, speicalCharacterStr.getBytes());
|
||||
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
}
|
||||
|
||||
@Before
|
||||
public void before() throws SQLException {
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
stmt.execute("drop table if exists " + tbname1 + "");
|
||||
stmt.execute("create table " + tbname1 + "(ts timestamp,f1 binary(64),f2 nchar(64))");
|
||||
stmt.execute("drop table if exists " + tbname2);
|
||||
stmt.execute("create table " + tbname2 + "(ts timestamp, f1 binary(64), f2 nchar(64)) tags(loc nchar(64))");
|
||||
}
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public static void beforeClass() throws SQLException {
|
||||
String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
|
||||
conn = DriverManager.getConnection(url);
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
stmt.execute("drop database if exists " + dbName);
|
||||
stmt.execute("create database if not exists " + dbName);
|
||||
stmt.execute("use " + dbName);
|
||||
}
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void afterClass() throws SQLException {
|
||||
if (conn != null)
|
||||
conn.close();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,376 @@
|
|||
package com.taosdata.jdbc.cases;
|
||||
|
||||
import org.junit.*;
|
||||
|
||||
import java.sql.*;
|
||||
|
||||
public class InsertSpecialCharacterRestfulTest {
|
||||
|
||||
private static final String host = "127.0.0.1";
|
||||
// private static final String host = "master";
|
||||
private static Connection conn;
|
||||
private static String dbName = "spec_char_test";
|
||||
private static String tbname1 = "test";
|
||||
private static String tbname2 = "weather";
|
||||
private static String special_character_str_1 = "$asd$$fsfsf$";
|
||||
private static String special_character_str_2 = "\\asdfsfsf\\\\";
|
||||
private static String special_character_str_3 = "\\\\asdfsfsf\\";
|
||||
private static String special_character_str_4 = "?asd??fsf?sf?";
|
||||
private static String special_character_str_5 = "?#sd@$f(('<(s[P)>\"){]}f?s[]{}%vaew|\"fsfs^a&d*jhg)(j))(f@~!?$";
|
||||
|
||||
@Test
|
||||
public void testCase01() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_1.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from ?";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
pstmt.setString(1, tbname1);
|
||||
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_1, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testCase02() throws SQLException {
|
||||
//TODO:
|
||||
// Expected :\asdfsfsf\\
|
||||
// Actual :\asdfsfsf\
|
||||
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_2.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from " + tbname1;
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
//TODO: bug to be fixed
|
||||
// Assert.assertEquals(special_character_str_2, f1);
|
||||
Assert.assertEquals(special_character_str_2.substring(0, special_character_str_1.length() - 2), f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
public void testCase03() throws SQLException {
|
||||
//TODO:
|
||||
// TDengine ERROR (216): Syntax error in SQL
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_3.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from " + tbname1;
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_3, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase04() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_4.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from " + tbname1;
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery(query);
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_4, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase05() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_5.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from " + tbname1;
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery(query);
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_5, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase06() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into t? using " + tbname2 + " tags(?) values(?, ?, ?)";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setInt(1, 1);
|
||||
pstmt.setString(2, special_character_str_4);
|
||||
pstmt.setTimestamp(3, new Timestamp(now));
|
||||
pstmt.setBytes(4, special_character_str_4.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query t1
|
||||
final String query = "select * from t1";
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery(query);
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_4, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase07() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into " + tbname1 + "(ts, f1, f2) values(?, ?, ?) ; ";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setTimestamp(1, new Timestamp(now));
|
||||
pstmt.setBytes(2, special_character_str_4.getBytes());
|
||||
pstmt.setString(3, special_character_str_4);
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
// query
|
||||
final String query = "select * from " + tbname1;
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery(query);
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_4, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertEquals(special_character_str_4, f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
public void testCase08() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into t? using " + tbname2 + " tags(?) values(?, ?, ?) ? ";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setInt(1, 1);
|
||||
pstmt.setString(2, special_character_str_5);
|
||||
pstmt.setTimestamp(3, new Timestamp(now));
|
||||
pstmt.setBytes(4, special_character_str_5.getBytes());
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase09() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
// insert
|
||||
final String sql = "insert into ?.t? using " + tbname2 + " tags(?) values(?, ?, ?) t? using weather tags(?) values(?,?,?) ";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
// t1
|
||||
pstmt.setString(1, dbName);
|
||||
pstmt.setInt(2, 1);
|
||||
pstmt.setString(3, special_character_str_5);
|
||||
pstmt.setTimestamp(4, new Timestamp(now));
|
||||
pstmt.setBytes(5, special_character_str_5.getBytes());
|
||||
// t2
|
||||
pstmt.setInt(7, 2);
|
||||
pstmt.setString(8, special_character_str_5);
|
||||
pstmt.setTimestamp(9, new Timestamp(now));
|
||||
pstmt.setString(11, special_character_str_5);
|
||||
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(2, ret);
|
||||
}
|
||||
// query t1
|
||||
String query = "select * from t?";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
pstmt.setInt(1, 1);
|
||||
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_5, f1);
|
||||
String f2 = rs.getString(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
// query t2
|
||||
query = "select * from t2";
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery(query);
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
byte[] f1 = rs.getBytes(2);
|
||||
Assert.assertNull(f1);
|
||||
String f2 = new String(rs.getBytes(3));
|
||||
Assert.assertEquals(special_character_str_5, f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase10() throws SQLException {
|
||||
final long now = System.currentTimeMillis();
|
||||
|
||||
// insert
|
||||
final String sql = "insert into t? using ? tags(?) values(?, ?, ?) t? using " + tbname2 + " tags(?) values(?,?,?) ";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
// t1
|
||||
pstmt.setInt(1, 1);
|
||||
pstmt.setString(2, tbname2);
|
||||
pstmt.setString(3, special_character_str_5);
|
||||
pstmt.setTimestamp(4, new Timestamp(now));
|
||||
pstmt.setBytes(5, special_character_str_5.getBytes());
|
||||
// t2
|
||||
pstmt.setInt(7, 2);
|
||||
pstmt.setString(8, special_character_str_5);
|
||||
pstmt.setTimestamp(9, new Timestamp(now));
|
||||
pstmt.setString(11, special_character_str_5);
|
||||
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(2, ret);
|
||||
}
|
||||
//query t1
|
||||
String query = "select * from ?.t? where ts < ? and ts >= ? and ? is not null";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
pstmt.setString(1, dbName);
|
||||
pstmt.setInt(2, 1);
|
||||
pstmt.setTimestamp(3, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt.setTimestamp(4, new Timestamp(0));
|
||||
pstmt.setString(5, "f1");
|
||||
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
String f1 = new String(rs.getBytes(2));
|
||||
Assert.assertEquals(special_character_str_5, f1);
|
||||
byte[] f2 = rs.getBytes(3);
|
||||
Assert.assertNull(f2);
|
||||
}
|
||||
// query t2
|
||||
query = "select * from t? where ts < ? and ts >= ? and ? is not null";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(query)) {
|
||||
pstmt.setInt(1, 2);
|
||||
pstmt.setTimestamp(2, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt.setTimestamp(3, new Timestamp(0));
|
||||
pstmt.setString(4, "f2");
|
||||
|
||||
ResultSet rs = pstmt.executeQuery();
|
||||
rs.next();
|
||||
long timestamp = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(now, timestamp);
|
||||
byte[] f1 = rs.getBytes(2);
|
||||
Assert.assertNull(f1);
|
||||
String f2 = new String(rs.getBytes(3));
|
||||
Assert.assertEquals(special_character_str_5, f2);
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
public void testCase11() throws SQLException {
|
||||
final String speicalCharacterStr = "?#sd@$f(((s[P)){]}f?s[]{}%vs^a&d*jhg)(j))(f@~!?$";
|
||||
final long now = System.currentTimeMillis();
|
||||
|
||||
final String sql = "insert into t? using " + tbname2 + " values(?, ?, 'abc?abc') ";
|
||||
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
|
||||
pstmt.setInt(1, 1);
|
||||
pstmt.setTimestamp(2, new Timestamp(now));
|
||||
pstmt.setBytes(3, speicalCharacterStr.getBytes());
|
||||
|
||||
int ret = pstmt.executeUpdate();
|
||||
Assert.assertEquals(1, ret);
|
||||
}
|
||||
}
|
||||
|
||||
@Before
|
||||
public void before() throws SQLException {
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
stmt.execute("drop table if exists " + tbname1 + "");
|
||||
stmt.execute("create table " + tbname1 + "(ts timestamp,f1 binary(64),f2 nchar(64))");
|
||||
stmt.execute("drop table if exists " + tbname2);
|
||||
stmt.execute("create table " + tbname2 + "(ts timestamp, f1 binary(64), f2 nchar(64)) tags(loc nchar(64))");
|
||||
}
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public static void beforeClass() throws SQLException {
|
||||
String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata";
|
||||
conn = DriverManager.getConnection(url);
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
stmt.execute("drop database if exists " + dbName);
|
||||
stmt.execute("create database if not exists " + dbName);
|
||||
stmt.execute("use " + dbName);
|
||||
}
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void afterClass() throws SQLException {
|
||||
if (conn != null)
|
||||
conn.close();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
package com.taosdata.jdbc.cases;
|
||||
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.sql.*;
|
||||
|
||||
public class NullValueInResultSetForJdbcJniTest {
|
||||
|
||||
private static final String host = "127.0.0.1";
|
||||
Connection conn;
|
||||
|
||||
@Test
|
||||
public void test() {
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery("select * from weather");
|
||||
ResultSetMetaData meta = rs.getMetaData();
|
||||
while (rs.next()) {
|
||||
for (int i = 1; i <= meta.getColumnCount(); i++) {
|
||||
Object value = rs.getObject(i);
|
||||
System.out.print(meta.getColumnLabel(i) + ": " + value + "\t");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Before
|
||||
public void before() throws SQLException {
|
||||
final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
|
||||
conn = DriverManager.getConnection(url);
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
stmt.execute("drop database if exists test_null");
|
||||
stmt.execute("create database if not exists test_null");
|
||||
stmt.execute("use test_null");
|
||||
stmt.execute("create table weather(ts timestamp, f1 int, f2 bigint, f3 float, f4 double, f5 smallint, f6 tinyint, f7 bool, f8 binary(64), f9 nchar(64))");
|
||||
stmt.executeUpdate("insert into weather(ts, f1) values(now+1s, 1)");
|
||||
stmt.executeUpdate("insert into weather(ts, f2) values(now+2s, 2)");
|
||||
stmt.executeUpdate("insert into weather(ts, f3) values(now+3s, 3.0)");
|
||||
stmt.executeUpdate("insert into weather(ts, f4) values(now+4s, 4.0)");
|
||||
stmt.executeUpdate("insert into weather(ts, f5) values(now+5s, 5)");
|
||||
stmt.executeUpdate("insert into weather(ts, f6) values(now+6s, 6)");
|
||||
stmt.executeUpdate("insert into weather(ts, f7) values(now+7s, true)");
|
||||
stmt.executeUpdate("insert into weather(ts, f8) values(now+8s, 'hello')");
|
||||
stmt.executeUpdate("insert into weather(ts, f9) values(now+9s, '涛思数据')");
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@After
|
||||
public void after() {
|
||||
try {
|
||||
if (conn != null)
|
||||
conn.close();
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
package com.taosdata.jdbc.cases;
|
||||
|
||||
import com.taosdata.jdbc.TSDBDriver;
|
||||
import com.taosdata.jdbc.utils.TimestampUtil;
|
||||
import org.junit.*;
|
||||
|
||||
import java.sql.*;
|
||||
import java.util.Properties;
|
||||
|
||||
public class TD3841Test {
|
||||
private static final String host = "127.0.0.1";
|
||||
private static Properties properties;
|
||||
private static Connection conn_restful;
|
||||
private static Connection conn_jni;
|
||||
|
||||
@Test
|
||||
public void testRestful() throws SQLException {
|
||||
String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata";
|
||||
conn_restful = DriverManager.getConnection(url, properties);
|
||||
|
||||
try (Statement stmt = conn_restful.createStatement()) {
|
||||
stmt.execute("drop database if exists test_null");
|
||||
stmt.execute("create database if not exists test_null");
|
||||
stmt.execute("use test_null");
|
||||
stmt.execute("create table weather(ts timestamp, f1 timestamp, f2 int, f3 bigint, f4 float, f5 double, f6 smallint, f7 tinyint, f8 bool, f9 binary(64), f10 nchar(64))");
|
||||
stmt.executeUpdate("insert into weather(ts, f1) values(now+1s, " + TimestampUtil.datetimeToLong("2021-04-21 12:00:00.000") + ")");
|
||||
ResultSet rs = stmt.executeQuery("select * from weather");
|
||||
rs.next();
|
||||
|
||||
Assert.assertEquals("2021-04-21 12:00:00.000", TimestampUtil.longToDatetime(rs.getTimestamp(2).getTime()));
|
||||
Assert.assertEquals(true, rs.getInt(3) == 0 && rs.wasNull());
|
||||
Assert.assertEquals(true, rs.getLong(4) == 0 && rs.wasNull());
|
||||
Assert.assertEquals(true, rs.getFloat(5) == 0.0f && rs.wasNull());
|
||||
Assert.assertEquals(true, rs.getDouble(6) == 0.0f && rs.wasNull());
|
||||
Assert.assertEquals(true, rs.getByte(7) == 0 && rs.wasNull());
|
||||
Assert.assertEquals(true, rs.getShort(8) == 0 && rs.wasNull());
|
||||
Assert.assertEquals(null, rs.getBytes(9));
|
||||
Assert.assertEquals(null, rs.getString(10));
|
||||
|
||||
rs.close();
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJNI() throws SQLException {
|
||||
final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
|
||||
conn_jni = DriverManager.getConnection(url, properties);
|
||||
|
||||
try (Statement stmt = conn_jni.createStatement()) {
|
||||
stmt.execute("drop database if exists test_null");
|
||||
stmt.execute("create database if not exists test_null");
|
||||
stmt.execute("use test_null");
|
||||
stmt.execute("create table weather(ts timestamp, f1 timestamp, f2 int, f3 bigint, f4 float, f5 double, f6 smallint, f7 tinyint, f8 bool, f9 binary(64), f10 nchar(64))");
|
||||
stmt.executeUpdate("insert into weather(ts, f1) values(now+1s, " + TimestampUtil.datetimeToLong("2021-04-21 12:00:00.000") + ")");
|
||||
ResultSet rs = stmt.executeQuery("select * from weather");
|
||||
rs.next();
|
||||
|
||||
Assert.assertEquals("2021-04-21 12:00:00.000", TimestampUtil.longToDatetime(rs.getTimestamp(2).getTime()));
|
||||
Assert.assertEquals(true, rs.getInt(3) == 0 && rs.wasNull());
|
||||
Assert.assertEquals(true, rs.getLong(4) == 0 && rs.wasNull());
|
||||
Assert.assertEquals(true, rs.getFloat(5) == 0.0f && rs.wasNull());
|
||||
Assert.assertEquals(true, rs.getDouble(6) == 0.0f && rs.wasNull());
|
||||
Assert.assertEquals(true, rs.getByte(7) == 0 && rs.wasNull());
|
||||
Assert.assertEquals(true, rs.getShort(8) == 0 && rs.wasNull());
|
||||
Assert.assertEquals(null, rs.getBytes(9));
|
||||
Assert.assertEquals(null, rs.getString(10));
|
||||
|
||||
rs.close();
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public static void beforeClass() {
|
||||
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");
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void afterClass() throws SQLException {
|
||||
if (conn_restful != null)
|
||||
conn_restful.close();
|
||||
if (conn_jni != null)
|
||||
conn_jni.close();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
package com.taosdata.jdbc.cases;
|
||||
|
||||
|
||||
import com.taosdata.jdbc.TSDBDriver;
|
||||
import org.junit.AfterClass;
|
||||
import org.junit.Assert;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.sql.*;
|
||||
import java.util.Properties;
|
||||
|
||||
public class TwoTypeTimestampPercisionInJniTest {
|
||||
|
||||
private static final String host = "127.0.0.1";
|
||||
private static final String ms_timestamp_db = "ms_precision_test";
|
||||
private static final String us_timestamp_db = "us_precision_test";
|
||||
private static final long timestamp1 = System.currentTimeMillis();
|
||||
private static final long timestamp2 = timestamp1 * 1000 + 123;
|
||||
|
||||
private static Connection conn;
|
||||
|
||||
@Test
|
||||
public void testCase1() {
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery("select last_row(ts) from " + ms_timestamp_db + ".weather");
|
||||
rs.next();
|
||||
long ts = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
ts = rs.getLong(1);
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase2() {
|
||||
try (Statement stmt = conn.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery("select last_row(ts) from " + us_timestamp_db + ".weather");
|
||||
rs.next();
|
||||
|
||||
Timestamp timestamp = rs.getTimestamp(1);
|
||||
System.out.println(timestamp);
|
||||
long ts = timestamp.getTime();
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
int nanos = timestamp.getNanos();
|
||||
Assert.assertEquals(timestamp2 % 1000_000l * 1000, nanos);
|
||||
|
||||
ts = rs.getLong(1);
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public static void beforeClass() throws SQLException {
|
||||
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");
|
||||
|
||||
String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
|
||||
conn = DriverManager.getConnection(url, properties);
|
||||
|
||||
Statement stmt = conn.createStatement();
|
||||
stmt.execute("drop database if exists " + ms_timestamp_db);
|
||||
stmt.execute("create database if not exists " + ms_timestamp_db + " precision 'ms'");
|
||||
stmt.execute("create table " + ms_timestamp_db + ".weather(ts timestamp, f1 int)");
|
||||
stmt.executeUpdate("insert into " + ms_timestamp_db + ".weather(ts,f1) values(" + timestamp1 + ", 127)");
|
||||
|
||||
stmt.execute("drop database if exists " + us_timestamp_db);
|
||||
stmt.execute("create database if not exists " + us_timestamp_db + " precision 'us'");
|
||||
stmt.execute("create table " + us_timestamp_db + ".weather(ts timestamp, f1 int)");
|
||||
stmt.executeUpdate("insert into " + us_timestamp_db + ".weather(ts,f1) values(" + timestamp2 + ", 127)");
|
||||
stmt.close();
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void afterClass() {
|
||||
try {
|
||||
if (conn != null)
|
||||
conn.close();
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
package com.taosdata.jdbc.cases;
|
||||
|
||||
|
||||
import com.taosdata.jdbc.TSDBDriver;
|
||||
import org.junit.AfterClass;
|
||||
import org.junit.Assert;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.sql.*;
|
||||
import java.util.Properties;
|
||||
|
||||
public class TwoTypeTimestampPercisionInRestfulTest {
|
||||
|
||||
private static final String host = "127.0.0.1";
|
||||
private static final String ms_timestamp_db = "ms_precision_test";
|
||||
private static final String us_timestamp_db = "us_precision_test";
|
||||
private static final long timestamp1 = System.currentTimeMillis();
|
||||
private static final long timestamp2 = timestamp1 * 1000 + 123;
|
||||
|
||||
private static Connection conn1;
|
||||
private static Connection conn2;
|
||||
private static Connection conn3;
|
||||
|
||||
@Test
|
||||
public void testCase1() {
|
||||
try (Statement stmt = conn1.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery("select last_row(ts) from " + ms_timestamp_db + ".weather");
|
||||
rs.next();
|
||||
long ts = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
ts = rs.getLong(1);
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase2() {
|
||||
try (Statement stmt = conn1.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery("select last_row(ts) from " + us_timestamp_db + ".weather");
|
||||
rs.next();
|
||||
|
||||
Timestamp timestamp = rs.getTimestamp(1);
|
||||
long ts = timestamp.getTime();
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
int nanos = timestamp.getNanos();
|
||||
Assert.assertEquals(timestamp2 % 1000_000l * 1000, nanos);
|
||||
|
||||
ts = rs.getLong(1);
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase3() {
|
||||
try (Statement stmt = conn2.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery("select last_row(ts) from " + ms_timestamp_db + ".weather");
|
||||
rs.next();
|
||||
Timestamp rsTimestamp = rs.getTimestamp(1);
|
||||
long ts = rsTimestamp.getTime();
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
ts = rs.getLong(1);
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase4() {
|
||||
try (Statement stmt = conn2.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery("select last_row(ts) from " + us_timestamp_db + ".weather");
|
||||
rs.next();
|
||||
|
||||
Timestamp timestamp = rs.getTimestamp(1);
|
||||
long ts = timestamp.getTime();
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
int nanos = timestamp.getNanos();
|
||||
Assert.assertEquals(timestamp2 % 1000_000l * 1000, nanos);
|
||||
|
||||
ts = rs.getLong(1);
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase5() {
|
||||
try (Statement stmt = conn3.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery("select last_row(ts) from " + ms_timestamp_db + ".weather");
|
||||
rs.next();
|
||||
long ts = rs.getTimestamp(1).getTime();
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
ts = rs.getLong(1);
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCase6() {
|
||||
try (Statement stmt = conn3.createStatement()) {
|
||||
ResultSet rs = stmt.executeQuery("select last_row(ts) from " + us_timestamp_db + ".weather");
|
||||
rs.next();
|
||||
|
||||
Timestamp timestamp = rs.getTimestamp(1);
|
||||
long ts = timestamp.getTime();
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
int nanos = timestamp.getNanos();
|
||||
Assert.assertEquals(timestamp2 % 1000_000l * 1000, nanos);
|
||||
|
||||
ts = rs.getLong(1);
|
||||
Assert.assertEquals(timestamp1, ts);
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@BeforeClass
|
||||
public static void beforeClass() throws SQLException {
|
||||
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");
|
||||
// properties.setProperty(TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT, "TIMESTAMP");
|
||||
|
||||
String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata";
|
||||
conn1 = DriverManager.getConnection(url, properties);
|
||||
|
||||
url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata×tampFormat=timestamp";
|
||||
conn2 = DriverManager.getConnection(url, properties);
|
||||
|
||||
url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata×tampFormat=utc";
|
||||
conn3 = DriverManager.getConnection(url, properties);
|
||||
|
||||
Statement stmt = conn1.createStatement();
|
||||
stmt.execute("drop database if exists " + ms_timestamp_db);
|
||||
stmt.execute("create database if not exists " + ms_timestamp_db + " precision 'ms'");
|
||||
stmt.execute("create table " + ms_timestamp_db + ".weather(ts timestamp, f1 int)");
|
||||
stmt.executeUpdate("insert into " + ms_timestamp_db + ".weather(ts,f1) values(" + timestamp1 + ", 127)");
|
||||
|
||||
stmt.execute("drop database if exists " + us_timestamp_db);
|
||||
stmt.execute("create database if not exists " + us_timestamp_db + " precision 'us'");
|
||||
stmt.execute("create table " + us_timestamp_db + ".weather(ts timestamp, f1 int)");
|
||||
stmt.executeUpdate("insert into " + us_timestamp_db + ".weather(ts,f1) values(" + timestamp2 + ", 127)");
|
||||
stmt.close();
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void afterClass() {
|
||||
try {
|
||||
if (conn1 != null)
|
||||
conn1.close();
|
||||
if (conn2 != null)
|
||||
conn2.close();
|
||||
if (conn3 != null)
|
||||
conn3.close();
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -6,11 +6,11 @@ import org.junit.BeforeClass;
|
|||
import org.junit.Test;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.Serializable;
|
||||
import java.sql.*;
|
||||
|
||||
public class RestfulPreparedStatementTest {
|
||||
private static final String host = "127.0.0.1";
|
||||
// private static final String host = "master";
|
||||
private static Connection conn;
|
||||
private static final String sql_insert = "insert into t1 values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
|
||||
private static PreparedStatement pstmt_insert;
|
||||
|
|
@ -50,6 +50,51 @@ public class RestfulPreparedStatementTest {
|
|||
pstmt_insert.setNull(2, Types.INTEGER);
|
||||
int result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(3, Types.BIGINT);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(4, Types.FLOAT);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(5, Types.DOUBLE);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(6, Types.SMALLINT);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(7, Types.TINYINT);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(8, Types.BOOLEAN);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(9, Types.BINARY);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(10, Types.NCHAR);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
|
||||
pstmt_insert.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
|
||||
pstmt_insert.setNull(10, Types.OTHER);
|
||||
result = pstmt_insert.executeUpdate();
|
||||
Assert.assertEquals(1, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -129,7 +174,7 @@ public class RestfulPreparedStatementTest {
|
|||
Assert.assertFalse(pstmt_insert.execute());
|
||||
}
|
||||
|
||||
class Person implements Serializable {
|
||||
private class Person {
|
||||
String name;
|
||||
int age;
|
||||
boolean sex;
|
||||
|
|
|
|||
|
|
@ -160,6 +160,7 @@ public class RestfulResultSetTest {
|
|||
@Test
|
||||
public void getTime() throws SQLException {
|
||||
Time f1 = rs.getTime("f1");
|
||||
Assert.assertNotNull(f1);
|
||||
Assert.assertEquals("00:00:00", f1.toString());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,24 @@
|
|||
package com.taosdata.jdbc.utils;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class UtilsTest {
|
||||
|
||||
@Test
|
||||
public void escapeSingleQuota() {
|
||||
String s = "'''''a\\'";
|
||||
String news = Utils.escapeSingleQuota(s);
|
||||
Assert.assertEquals("\\'\\'\\'\\'\\'a\\'", news);
|
||||
|
||||
s = "\'''''a\\'";
|
||||
news = Utils.escapeSingleQuota(s);
|
||||
Assert.assertEquals("\\'\\'\\'\\'\\'a\\'", news);
|
||||
|
||||
s = "\'\'\'\''a\\'";
|
||||
news = Utils.escapeSingleQuota(s);
|
||||
Assert.assertEquals("\\'\\'\\'\\'\\'a\\'", news);
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue