diff --git a/src/main/java/org/tarantool/jdbc/type/TarantoolSqlType.java b/src/main/java/org/tarantool/jdbc/type/TarantoolSqlType.java index 3653a474..752cd9ab 100644 --- a/src/main/java/org/tarantool/jdbc/type/TarantoolSqlType.java +++ b/src/main/java/org/tarantool/jdbc/type/TarantoolSqlType.java @@ -10,23 +10,33 @@ public enum TarantoolSqlType { UNKNOWN(TarantoolType.UNKNOWN, JdbcType.UNKNOWN, "unknown"), + // float, double, real used to be number aliases before 2.2 FLOAT(TarantoolType.NUMBER, JdbcType.FLOAT, "float"), DOUBLE(TarantoolType.NUMBER, JdbcType.DOUBLE, "double"), REAL(TarantoolType.NUMBER, JdbcType.REAL, "real"), + // was introduced in Tarantool 2.2.1 + NUMBER(TarantoolType.NUMBER, JdbcType.DOUBLE, "number"), - INT(TarantoolType.INTEGER, JdbcType.INTEGER, "int"), - INTEGER(TarantoolType.INTEGER, JdbcType.INTEGER, "integer"), + INT(TarantoolType.INTEGER, JdbcType.BIGINT, "int"), + INTEGER(TarantoolType.INTEGER, JdbcType.BIGINT, "integer"), + // was introduced in 2.2 + UNSIGNED(TarantoolType.UNSIGNED, JdbcType.BIGINT, "integer"), + // were introduced in 2.2 BOOL(TarantoolType.BOOLEAN, JdbcType.BOOLEAN, "bool"), BOOLEAN(TarantoolType.BOOLEAN, JdbcType.BOOLEAN, "boolean"), + STRING(TarantoolType.STRING, JdbcType.VARCHAR, "string"), + TEXT(TarantoolType.STRING, JdbcType.VARCHAR, "text"), VARCHAR(TarantoolType.STRING, JdbcType.VARCHAR, "varchar") { @Override public String getDisplayType() { return getTypeName() + "(128)"; } }, - TEXT(TarantoolType.STRING, JdbcType.VARCHAR, "text"), + + // was introduced in 2.2 + VARBINARY(TarantoolType.VARBINARY, JdbcType.VARBINARY, "varbinary"), SCALAR(TarantoolType.SCALAR, JdbcType.BINARY, "scalar"); @@ -34,9 +44,11 @@ public String getDisplayType() { static { defaultSqlTypeMapping = new HashMap<>(); defaultSqlTypeMapping.put(TarantoolType.BOOLEAN, TarantoolSqlType.BOOLEAN); - defaultSqlTypeMapping.put(TarantoolType.STRING, TarantoolSqlType.VARCHAR); + defaultSqlTypeMapping.put(TarantoolType.STRING, TarantoolSqlType.STRING); defaultSqlTypeMapping.put(TarantoolType.INTEGER, TarantoolSqlType.INTEGER); - defaultSqlTypeMapping.put(TarantoolType.NUMBER, TarantoolSqlType.DOUBLE); + defaultSqlTypeMapping.put(TarantoolType.UNSIGNED, TarantoolSqlType.UNSIGNED); + defaultSqlTypeMapping.put(TarantoolType.NUMBER, TarantoolSqlType.NUMBER); + defaultSqlTypeMapping.put(TarantoolType.VARBINARY, TarantoolSqlType.VARBINARY); defaultSqlTypeMapping.put(TarantoolType.SCALAR, TarantoolSqlType.SCALAR); } diff --git a/src/main/java/org/tarantool/jdbc/type/TarantoolType.java b/src/main/java/org/tarantool/jdbc/type/TarantoolType.java index eac3c33f..0d06750d 100644 --- a/src/main/java/org/tarantool/jdbc/type/TarantoolType.java +++ b/src/main/java/org/tarantool/jdbc/type/TarantoolType.java @@ -10,9 +10,12 @@ public enum TarantoolType { STRING("string", false, true, Integer.MAX_VALUE, 0, Integer.MAX_VALUE), // precision is 20 due to Tarantool integer type has range [-2^63-1..2^64-1] INTEGER("integer", true, false, 20, 0, 20), + // precision is 20 due to Tarantool unsigned integer type has range [0..2^64-1] + UNSIGNED("unsigned", false, false, 20, 0, 20), // precision is 20 due to Tarantool allows both integer and floating-point values under number type NUMBER("number", true, false, 20, 16, 24), - SCALAR("scalar", false, true, Integer.MAX_VALUE, 0, Integer.MAX_VALUE); + SCALAR("scalar", false, true, Integer.MAX_VALUE, 0, Integer.MAX_VALUE), + VARBINARY("varbinary", false, true, Integer.MAX_VALUE, 0, Integer.MAX_VALUE); private final String typeName; private final boolean signed; diff --git a/src/test/java/org/tarantool/ServerVersion.java b/src/test/java/org/tarantool/ServerVersion.java index 5877bcca..45011070 100644 --- a/src/test/java/org/tarantool/ServerVersion.java +++ b/src/test/java/org/tarantool/ServerVersion.java @@ -7,7 +7,8 @@ public enum ServerVersion { V_1_9("1", "9", "0"), V_1_10("1", "10", "0"), V_2_1("2", "1", "0"), - V_2_2("2", "2", "0"); + V_2_2("2", "2", "0"), + V_2_2_1("2", "2", "1"); private final String majorVersion; private final String minorVersion; @@ -32,14 +33,18 @@ public String getPatchVersion() { return patchVersion; } - public boolean haveMinimalVersion(String versionString) { + public boolean isLessOrEqualThan(String versionString) { return compareVersions(versionString, (server, minimal) -> server >= minimal); } - public boolean haveMaximalVersion(String versionString) { + public boolean isGreaterOrEqualThan(String versionString) { return compareVersions(versionString, (server, maximal) -> server <= maximal); } + public boolean isGreaterThan(String versionString) { + return compareVersions(versionString, (server, maximal) -> server < maximal); + } + private boolean compareVersions(String versionString, BiFunction comparator) { int parsedVersion = toNumber(splitVersionParts(versionString)); int thisVersion = toNumber(new String[] { majorVersion, minorVersion, patchVersion }); diff --git a/src/test/java/org/tarantool/TestAssumptions.java b/src/test/java/org/tarantool/TestAssumptions.java index e7cf897d..65c235eb 100644 --- a/src/test/java/org/tarantool/TestAssumptions.java +++ b/src/test/java/org/tarantool/TestAssumptions.java @@ -5,11 +5,21 @@ public class TestAssumptions { public static void assumeMinimalServerVersion(String rawVersion, ServerVersion version) { - Assumptions.assumeTrue(version.haveMinimalVersion(rawVersion)); + Assumptions.assumeTrue(version.isLessOrEqualThan(rawVersion)); } public static void assumeMaximalServerVersion(String rawVersion, ServerVersion version) { - Assumptions.assumeTrue(version.haveMaximalVersion(rawVersion)); + Assumptions.assumeTrue(version.isGreaterOrEqualThan(rawVersion)); + } + + public static void assumeServerVersionLessThan(String rawVersion, ServerVersion version) { + Assumptions.assumeTrue(version.isGreaterThan(rawVersion)); + } + + public static void assumeServerVersionOutOfRange(String rawVersion, + ServerVersion left, + ServerVersion right) { + Assumptions.assumeFalse(left.isLessOrEqualThan(rawVersion) && right.isGreaterThan(rawVersion)); } } diff --git a/src/test/java/org/tarantool/jdbc/JdbcResultSetMetaDataIT.java b/src/test/java/org/tarantool/jdbc/JdbcResultSetMetaDataIT.java index 13140d53..62139cdc 100644 --- a/src/test/java/org/tarantool/jdbc/JdbcResultSetMetaDataIT.java +++ b/src/test/java/org/tarantool/jdbc/JdbcResultSetMetaDataIT.java @@ -6,11 +6,11 @@ import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.tarantool.TestAssumptions.assumeMinimalServerVersion; +import static org.tarantool.TestAssumptions.assumeServerVersionLessThan; +import static org.tarantool.TestAssumptions.assumeServerVersionOutOfRange; import org.tarantool.ServerVersion; import org.tarantool.TarantoolTestHelper; -import org.tarantool.jdbc.type.JdbcType; -import org.tarantool.jdbc.type.TarantoolSqlType; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.AfterEach; @@ -201,9 +201,12 @@ public void testCaseSensitiveColumns() throws SQLException { @Test @DisplayName("returned case insensitive columns") public void testCaseInsensitiveColumns() throws SQLException { - testHelper.executeSql( - "CREATE TABLE test(id INT PRIMARY KEY, num_val DOUBLE)" - ); + assumeServerVersionOutOfRange(testHelper.getInstanceVersion(), ServerVersion.V_2_2, ServerVersion.V_2_2_1); + if (ServerVersion.V_2_2.isGreaterThan(testHelper.getInstanceVersion())) { + testHelper.executeSql("CREATE TABLE test(id INT PRIMARY KEY, num_val DOUBLE)"); + } else { + testHelper.executeSql("CREATE TABLE test(id INT PRIMARY KEY, num_val NUMBER)"); + } try ( Statement statement = connection.createStatement(); ResultSet resultSet = statement.executeQuery("SELECT * FROM test") @@ -218,9 +221,16 @@ public void testCaseInsensitiveColumns() throws SQLException { @Test @DisplayName("returned searchable columns") public void testSearchableColumns() throws SQLException { - testHelper.executeSql( - "CREATE TABLE test(id INT PRIMARY KEY, num_val DOUBLE, text_val TEXT, bin_val SCALAR)" - ); + assumeServerVersionOutOfRange(testHelper.getInstanceVersion(), ServerVersion.V_2_2, ServerVersion.V_2_2_1); + if (ServerVersion.V_2_2.isGreaterThan(testHelper.getInstanceVersion())) { + testHelper.executeSql( + "CREATE TABLE test(id INT PRIMARY KEY, num_val DOUBLE, text_val TEXT, bin_val SCALAR)" + ); + } else { + testHelper.executeSql( + "CREATE TABLE test(id INT PRIMARY KEY, num_val NUMBER, text_val TEXT, bin_val SCALAR)" + ); + } try ( Statement statement = connection.createStatement(); ResultSet resultSet = statement.executeQuery("SELECT * FROM test") @@ -237,9 +247,16 @@ public void testSearchableColumns() throws SQLException { @Test @DisplayName("returned no monetary columns") public void testCurrencyColumns() throws SQLException { - testHelper.executeSql( - "CREATE TABLE test(id INT PRIMARY KEY, num_val DOUBLE, text_val TEXT, bin_val SCALAR)" - ); + assumeServerVersionOutOfRange(testHelper.getInstanceVersion(), ServerVersion.V_2_2, ServerVersion.V_2_2_1); + if (ServerVersion.V_2_2.isGreaterThan(testHelper.getInstanceVersion())) { + testHelper.executeSql( + "CREATE TABLE test(id INT PRIMARY KEY, num_val DOUBLE, text_val TEXT, bin_val SCALAR)" + ); + } else { + testHelper.executeSql( + "CREATE TABLE test(id INT PRIMARY KEY, num_val NUMBER, text_val TEXT, bin_val SCALAR)" + ); + } try ( Statement statement = connection.createStatement(); ResultSet resultSet = statement.executeQuery("SELECT * FROM test") @@ -254,8 +271,9 @@ public void testCurrencyColumns() throws SQLException { } @Test - @DisplayName("returned signed columns") - public void testSignedColumns() throws SQLException { + @DisplayName("returned signed decimal columns") + public void testSignedDecimalColumns() throws SQLException { + assumeServerVersionLessThan(testHelper.getInstanceVersion(), ServerVersion.V_2_2); testHelper.executeSql( "CREATE TABLE test(id INT PRIMARY KEY, double_val DOUBLE, real_val REAL, float_val FLOAT)" ); @@ -272,6 +290,23 @@ public void testSignedColumns() throws SQLException { } } + @Test + @DisplayName("returned signed number column") + public void testSignedNumberColumn() throws SQLException { + assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_2_1); + testHelper.executeSql( + "CREATE TABLE test(id INT PRIMARY KEY, num_val NUMBER)" + ); + try ( + Statement statement = connection.createStatement(); + ResultSet resultSet = statement.executeQuery("SELECT * FROM test") + ) { + ResultSetMetaData rsMeta = resultSet.getMetaData(); + assertTrue(rsMeta.isSigned(1)); + assertTrue(rsMeta.isSigned(2)); + } + } + @Test @DisplayName("returned not signed columns") public void testNotSignedColumns() throws SQLException { @@ -292,8 +327,9 @@ public void testNotSignedColumns() throws SQLException { } @Test - @DisplayName("returned numeric column types") - public void testColumnsNumericTypes() throws SQLException { + @DisplayName("returned number type aliases") + public void testColumnsNumberTypeAliases() throws SQLException { + assumeServerVersionLessThan(testHelper.getInstanceVersion(), ServerVersion.V_2_2); testHelper.executeSql( "CREATE TABLE test(id INT PRIMARY KEY, f_val FLOAT, d_val DOUBLE, r_val REAL)" ); @@ -303,26 +339,45 @@ public void testColumnsNumericTypes() throws SQLException { ) { ResultSetMetaData rsMeta = resultSet.getMetaData(); - assertEquals(Types.INTEGER, rsMeta.getColumnType(1)); + assertEquals(Types.BIGINT, rsMeta.getColumnType(1)); assertEquals("integer", rsMeta.getColumnTypeName(1)); - assertEquals("java.lang.Integer", rsMeta.getColumnClassName(1)); + assertEquals("java.lang.Long", rsMeta.getColumnClassName(1)); // we cannot distinguish numeric types because Tarantool // receives double noSQL type for all the numeric SQL types assertEquals(Types.DOUBLE, rsMeta.getColumnType(2)); - assertEquals("double", rsMeta.getColumnTypeName(2)); + assertEquals("number", rsMeta.getColumnTypeName(2)); assertEquals("java.lang.Double", rsMeta.getColumnClassName(2)); assertEquals(Types.DOUBLE, rsMeta.getColumnType(3)); - assertEquals("double", rsMeta.getColumnTypeName(3)); + assertEquals("number", rsMeta.getColumnTypeName(3)); assertEquals("java.lang.Double", rsMeta.getColumnClassName(3)); assertEquals(Types.DOUBLE, rsMeta.getColumnType(4)); - assertEquals("double", rsMeta.getColumnTypeName(4)); + assertEquals("number", rsMeta.getColumnTypeName(4)); assertEquals("java.lang.Double", rsMeta.getColumnClassName(4)); } } + @Test + @DisplayName("returned number column type") + public void testColumnsNumericTypes() throws SQLException { + assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_2_1); + testHelper.executeSql( + "CREATE TABLE test(id INT PRIMARY KEY, num_val NUMBER)" + ); + try ( + Statement statement = connection.createStatement(); + ResultSet resultSet = statement.executeQuery("SELECT * FROM test") + ) { + ResultSetMetaData rsMeta = resultSet.getMetaData(); + + assertEquals(Types.DOUBLE, rsMeta.getColumnType(2)); + assertEquals("number", rsMeta.getColumnTypeName(2)); + assertEquals("java.lang.Double", rsMeta.getColumnClassName(2)); + } + } + @Test @DisplayName("returned textual column types") public void testColumnsTextualTypes() throws SQLException { @@ -335,17 +390,17 @@ public void testColumnsTextualTypes() throws SQLException { ) { ResultSetMetaData rsMeta = resultSet.getMetaData(); - assertEquals(Types.INTEGER, rsMeta.getColumnType(1)); + assertEquals(Types.BIGINT, rsMeta.getColumnType(1)); assertEquals("integer", rsMeta.getColumnTypeName(1)); - assertEquals("java.lang.Integer", rsMeta.getColumnClassName(1)); + assertEquals("java.lang.Long", rsMeta.getColumnClassName(1)); assertEquals(Types.VARCHAR, rsMeta.getColumnType(2)); - assertEquals("varchar", rsMeta.getColumnTypeName(2)); + assertEquals("string", rsMeta.getColumnTypeName(2)); assertEquals("java.lang.String", rsMeta.getColumnClassName(2)); // TEXT and VARCHAR are not distinguishable assertEquals(Types.VARCHAR, rsMeta.getColumnType(3)); - assertEquals("varchar", rsMeta.getColumnTypeName(3)); + assertEquals("string", rsMeta.getColumnTypeName(3)); assertEquals("java.lang.String", rsMeta.getColumnClassName(3)); assertEquals(Types.BINARY, rsMeta.getColumnType(4)); diff --git a/src/test/java/org/tarantool/jdbc/JdbcTypesIT.java b/src/test/java/org/tarantool/jdbc/JdbcTypesIT.java index 446fa344..f84d4367 100644 --- a/src/test/java/org/tarantool/jdbc/JdbcTypesIT.java +++ b/src/test/java/org/tarantool/jdbc/JdbcTypesIT.java @@ -5,6 +5,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.tarantool.TestAssumptions.assumeMinimalServerVersion; +import static org.tarantool.TestAssumptions.assumeServerVersionLessThan; import static org.tarantool.TestUtils.fromHex; import org.tarantool.ServerVersion; @@ -18,6 +19,7 @@ import org.junit.jupiter.api.Test; import java.math.BigDecimal; +import java.math.BigInteger; import java.sql.Connection; import java.sql.Date; import java.sql.DriverManager; @@ -30,26 +32,27 @@ class JdbcTypesIT { - public static Integer[] INT_VALS = new Integer[] { Integer.MIN_VALUE, 0, Integer.MAX_VALUE, 1, 100, -50 }; - public static Double[] DOUBLE_VALS = new Double[] { 0.0d, Double.MIN_VALUE, Double.MAX_VALUE, 1.00001d, 100.5d }; - public static Float[] FLOAT_VALS = new Float[] { 0.0f, Float.MIN_VALUE, Float.MAX_VALUE, 1.00001f, 100.5f }; - public static String[] STRING_VALS = new String[] { "", "1", "A", "test test" }; - public static Byte[] BYTE_VALS = new Byte[] { Byte.MIN_VALUE, Byte.MAX_VALUE, (byte)0, (byte)100 }; - public static Short[] SHORT_VALS = new Short[] { Short.MIN_VALUE, Short.MAX_VALUE, (short)0, (short)1000 }; - public static Long[] LONG_VALS = new Long[] { Long.MIN_VALUE, Long.MAX_VALUE, 0L, 100000000L}; - public static BigDecimal[] BIGDEC_VALS = new BigDecimal[] { + public static Integer[] INT_VALS = { Integer.MIN_VALUE, 0, Integer.MAX_VALUE, 1, 100, -50 }; + public static Double[] DOUBLE_VALS = { 0.0d, Double.MIN_VALUE, Double.MAX_VALUE, 1.00001d, 100.5d }; + public static Float[] FLOAT_VALS = { 0.0f, Float.MIN_VALUE, Float.MAX_VALUE, 1.00001f, 100.5f }; + public static String[] STRING_VALS = { "", "1", "A", "test test" }; + public static Byte[] BYTE_VALS = { Byte.MIN_VALUE, Byte.MAX_VALUE, (byte)0, (byte)100 }; + public static Short[] SHORT_VALS = { Short.MIN_VALUE, Short.MAX_VALUE, (short)0, (short)1000 }; + public static Long[] LONG_VALS = { Long.MIN_VALUE, Long.MAX_VALUE, 0L, 100000000L}; + public static BigDecimal[] BIGDEC_VALS = { BigDecimal.valueOf(Double.MIN_VALUE), BigDecimal.valueOf(Double.MAX_VALUE), BigDecimal.ZERO, BigDecimal.ONE }; - public static byte[][] BINARY_VALS = new byte[][] { - fromHex(""), fromHex("00"), fromHex("FFFF"), fromHex("0102030405060708") + public static BigInteger[] BIGINT_VALS = { + BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.TEN), + BigInteger.valueOf(2).pow(64).subtract(BigInteger.ONE) }; - public static Date[] DATE_VALS = new Date[] { Date.valueOf("1983-03-14"), new Date(129479994) }; - - private static final String[] INIT_SQL = new String[] { - getCreateTableSQL() + public static byte[][] BINARY_VALS = { + fromHex(""), fromHex("00"), fromHex("FFFF"), fromHex("0102030405060708") }; + public static Date[] DATE_VALS = { Date.valueOf("1983-03-14"), new Date(129479994) }; + public static Boolean[] BOOLEAN_VALS = { Boolean.FALSE, Boolean.TRUE }; - private static final String[] CLEAN_SQL = new String[] { + private static final String[] CLEAN_SQL = { "DROP TABLE IF EXISTS test_types" }; @@ -74,113 +77,227 @@ static void teardownEnv() throws SQLException { } @BeforeEach - void setUpTest() throws SQLException { + void setUpTest() { assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_1); - testHelper.executeSql(INIT_SQL); } @AfterEach - void tearDownTest() throws SQLException { + void tearDownTest() { assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_1); testHelper.executeSql(CLEAN_SQL); } @Test void testSetByte() throws SQLException { + TarantoolSqlType[] targetTypes = { TarantoolSqlType.INT, TarantoolSqlType.INTEGER, TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + new TarantoolTestTypeHelper<>(connection, "test_types", Byte.class) - .setColumns(TarantoolSqlType.INT, TarantoolSqlType.INTEGER) + .setColumns(targetTypes) .setValues(BYTE_VALS) .testTypes(); } @Test void testSetShort() throws SQLException { + TarantoolSqlType[] targetTypes = { TarantoolSqlType.INT, TarantoolSqlType.INTEGER, TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + new TarantoolTestTypeHelper<>(connection, "test_types", Short.class) - .setColumns(TarantoolSqlType.INT, TarantoolSqlType.INTEGER) + .setColumns(targetTypes) .setValues(SHORT_VALS) .testTypes(); } @Test void testSetInt() throws SQLException { + assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_1); + + TarantoolSqlType[] targetTypes = { TarantoolSqlType.INT, TarantoolSqlType.INTEGER, TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + new TarantoolTestTypeHelper<>(connection, "test_types", Integer.class) - .setColumns(TarantoolSqlType.INT, TarantoolSqlType.INTEGER) + .setColumns(targetTypes) + .setValues(INT_VALS) + .testTypes(); + } + + @Test + void testSetIntUsingNumber() throws SQLException { + assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_2_1); + + TarantoolSqlType[] targetTypes = { TarantoolSqlType.NUMBER }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + + new TarantoolTestTypeHelper<>(connection, "test_types", Integer.class) + .setColumns(targetTypes) .setValues(INT_VALS) .testTypes(); } @Test void testSetLong() throws SQLException { + TarantoolSqlType[] targetTypes = { TarantoolSqlType.INT, TarantoolSqlType.INTEGER, TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + new TarantoolTestTypeHelper<>(connection, "test_types", Long.class) - .setColumns(TarantoolSqlType.INT, TarantoolSqlType.INTEGER) + .setColumns(targetTypes) .setValues(LONG_VALS) .testTypes(); } + @Test + void testSetLongUsingNumber() throws SQLException { + assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_2_1); + + TarantoolSqlType[] targetTypes = { TarantoolSqlType.NUMBER }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + + new TarantoolTestTypeHelper<>(connection, "test_types", Long.class) + .setColumns(targetTypes) + .setValues(LONG_VALS) + .testTypes(); + } + + @Test + void testSetBigIntegerUsingUnsigned() throws SQLException { + assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_2); + + TarantoolSqlType[] targetTypes = { TarantoolSqlType.UNSIGNED, TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + + new TarantoolTestTypeHelper<>(connection, "test_types", BigInteger.class) + .setColumns(targetTypes) + .setValues(BIGINT_VALS) + .testTypes(); + } + + @Test + void testSetBigInteger() throws SQLException { + assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_2); + TarantoolSqlType[] targetTypes = { TarantoolSqlType.INT, TarantoolSqlType.INTEGER, TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + + new TarantoolTestTypeHelper<>(connection, "test_types", BigInteger.class) + .setColumns(targetTypes) + .setValues(BIGINT_VALS) + .testTypes(); + } + @Test void testSetString() throws SQLException { + TarantoolSqlType[] targetTypes = { TarantoolSqlType.VARCHAR, TarantoolSqlType.TEXT, TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + new TarantoolTestTypeHelper<>(connection, "test_types", String.class) - .setColumns(TarantoolSqlType.VARCHAR, TarantoolSqlType.TEXT) + .setColumns(targetTypes) .setValues(STRING_VALS) .testTypes(); } + @Test + void testSetBoolean() throws SQLException { + assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_2); + + TarantoolSqlType[] targetTypes = { TarantoolSqlType.BOOLEAN, TarantoolSqlType.BOOL, TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + + new TarantoolTestTypeHelper<>(connection, "test_types", Boolean.class) + .setColumns(targetTypes) + .setValues(BOOLEAN_VALS) + .testTypes(); + } + @Test void testSetFloat() throws SQLException { + assumeServerVersionLessThan(testHelper.getInstanceVersion(), ServerVersion.V_2_2); + + TarantoolSqlType[] targetTypes = { TarantoolSqlType.REAL, TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + new TarantoolTestTypeHelper<>(connection, "test_types", Float.class) - .setColumns(TarantoolSqlType.REAL) + .setColumns(targetTypes) .setValues(FLOAT_VALS) .testTypes(); } @Test void testSetDouble() throws SQLException { + assumeServerVersionLessThan(testHelper.getInstanceVersion(), ServerVersion.V_2_2); + + TarantoolSqlType[] targetTypes = { TarantoolSqlType.FLOAT, TarantoolSqlType.DOUBLE, TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + new TarantoolTestTypeHelper<>(connection, "test_types", Double.class) - .setColumns(TarantoolSqlType.FLOAT, TarantoolSqlType.DOUBLE) + .setColumns(targetTypes) .setValues(DOUBLE_VALS) .testTypes(); } @Test void testSetBigDecimal() throws SQLException { + assumeServerVersionLessThan(testHelper.getInstanceVersion(), ServerVersion.V_2_2); + + TarantoolSqlType[] targetTypes = { + TarantoolSqlType.REAL, TarantoolSqlType.FLOAT, TarantoolSqlType.DOUBLE, TarantoolSqlType.SCALAR + }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + new TarantoolTestTypeHelper<>(connection, "test_types", BigDecimal.class) - .setColumns(TarantoolSqlType.REAL, TarantoolSqlType.FLOAT, TarantoolSqlType.DOUBLE) + .setColumns(targetTypes) .setValues(BIGDEC_VALS) .testTypes(); } @Test - void testSetByteArray() throws SQLException { - new TarantoolTestTypeHelper<>(connection, "test_types", byte[].class) - .setColumns(TarantoolSqlType.SCALAR) - .setValues(BINARY_VALS) + void testSetBigDecimalUsingNumber() throws SQLException { + assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_2_1); + + TarantoolSqlType[] targetTypes = { TarantoolSqlType.NUMBER }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + + new TarantoolTestTypeHelper<>(connection, "test_types", BigDecimal.class) + .setColumns(targetTypes) + .setValues(BIGDEC_VALS) .testTypes(); } @Test - void testSetDate() throws SQLException { - new TarantoolTestTypeHelper<>(connection, "test_types", Date.class) - .setColumns(TarantoolSqlType.INT, TarantoolSqlType.INTEGER) - .setValues(DATE_VALS) + void testSetByteArrayUsingScalar() throws SQLException { + TarantoolSqlType[] targetTypes = { TarantoolSqlType.SCALAR }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); + + new TarantoolTestTypeHelper<>(connection, "test_types", byte[].class) + .setColumns(targetTypes) + .setValues(BINARY_VALS) .testTypes(); } - private static String getCreateTableSQL() { + @Test + void testSetByteArrayUsingVarbinary() throws SQLException { + assumeMinimalServerVersion(testHelper.getInstanceVersion(), ServerVersion.V_2_2); - TarantoolSqlType[] types = { - TarantoolSqlType.FLOAT, - TarantoolSqlType.DOUBLE, - TarantoolSqlType.REAL, + TarantoolSqlType[] targetTypes = { TarantoolSqlType.VARBINARY }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); - TarantoolSqlType.INT, - TarantoolSqlType.INTEGER, + new TarantoolTestTypeHelper<>(connection, "test_types", byte[].class) + .setColumns(targetTypes) + .setValues(BINARY_VALS) + .testTypes(); + } - TarantoolSqlType.VARCHAR, - TarantoolSqlType.TEXT, + @Test + void testSetDate() throws SQLException { + TarantoolSqlType[] targetTypes = { TarantoolSqlType.INT, TarantoolSqlType.INTEGER }; + testHelper.executeSql(getCreateTypeTableSQL(targetTypes)); - TarantoolSqlType.SCALAR - }; + new TarantoolTestTypeHelper<>(connection, "test_types", Date.class) + .setColumns(targetTypes) + .setValues(DATE_VALS) + .testTypes(); + } + private static String getCreateTypeTableSQL(TarantoolSqlType... types) { StringBuilder sb = new StringBuilder("CREATE TABLE "); sb.append("test_types"); sb.append("(KEY INT PRIMARY KEY"); @@ -307,6 +424,8 @@ protected void apply(PreparedStatement ps, int col, T val) throws SQLException { ps.setBoolean(col, (Boolean)val); } else if (cls == BigDecimal.class) { ps.setBigDecimal(col, (BigDecimal) val); + } else if (cls == BigInteger.class) { + ps.setObject(col, val); } else if (cls == byte[].class) { ps.setBytes(col, (byte[])val); } else if (cls == Date.class) { @@ -348,6 +467,9 @@ protected void check(ResultSet rs, int col, String name, T val) throws SQLExcept } else if (cls == BigDecimal.class) { assertEquals(0, ((BigDecimal)val).compareTo(rs.getBigDecimal(col))); assertEquals(0, ((BigDecimal)val).compareTo(rs.getBigDecimal(name))); + } else if (cls == BigInteger.class) { + assertEquals(val, rs.getObject(col)); + assertEquals(val, rs.getObject(name)); } else if (cls == byte[].class) { assertArrayEquals((byte[])val, rs.getBytes(col)); assertArrayEquals((byte[])val, rs.getBytes(name));