diff --git a/plugin/trino-clickhouse/src/test/java/io/trino/plugin/clickhouse/TestClickHouseTypeMapping.java b/plugin/trino-clickhouse/src/test/java/io/trino/plugin/clickhouse/TestClickHouseTypeMapping.java index 8b893dbddaf1..cbbd379825fc 100644 --- a/plugin/trino-clickhouse/src/test/java/io/trino/plugin/clickhouse/TestClickHouseTypeMapping.java +++ b/plugin/trino-clickhouse/src/test/java/io/trino/plugin/clickhouse/TestClickHouseTypeMapping.java @@ -243,7 +243,7 @@ public void testUint8() .addRoundTrip("UInt8", "0", SMALLINT, "SMALLINT '0'") // min value in ClickHouse .addRoundTrip("UInt8", "255", SMALLINT, "SMALLINT '255'") // max value in ClickHouse .addRoundTrip("Nullable(UInt8)", "NULL", SMALLINT, "CAST(null AS SMALLINT)") - .execute(getQueryRunner(), clickhouseCreateTrinoInsert("tpch.test_uint8")); + .execute(getQueryRunner(), clickhouseCreateAndTrinoInsert("tpch.test_uint8")); } @Test @@ -279,7 +279,7 @@ public void testUint16() .addRoundTrip("UInt16", "0", INTEGER, "0") // min value in ClickHouse .addRoundTrip("UInt16", "65535", INTEGER, "65535") // max value in ClickHouse .addRoundTrip("Nullable(UInt16)", "NULL", INTEGER, "CAST(null AS INTEGER)") - .execute(getQueryRunner(), clickhouseCreateTrinoInsert("tpch.test_uint16")); + .execute(getQueryRunner(), clickhouseCreateAndTrinoInsert("tpch.test_uint16")); } @Test @@ -315,7 +315,7 @@ public void testUint32() .addRoundTrip("UInt32", "BIGINT '0'", BIGINT, "BIGINT '0'") // min value in ClickHouse .addRoundTrip("UInt32", "BIGINT '4294967295'", BIGINT, "BIGINT '4294967295'") // max value in ClickHouse .addRoundTrip("Nullable(UInt32)", "NULL", BIGINT, "CAST(null AS BIGINT)") - .execute(getQueryRunner(), clickhouseCreateTrinoInsert("tpch.test_uint32")); + .execute(getQueryRunner(), clickhouseCreateAndTrinoInsert("tpch.test_uint32")); } @Test @@ -351,7 +351,7 @@ public void testUint64() .addRoundTrip("UInt64", "CAST('0' AS decimal(20, 0))", createDecimalType(20), "CAST('0' AS decimal(20, 0))") // min value in ClickHouse .addRoundTrip("UInt64", "CAST('18446744073709551615' AS decimal(20, 0))", createDecimalType(20), "CAST('18446744073709551615' AS decimal(20, 0))") // max value in ClickHouse .addRoundTrip("Nullable(UInt64)", "NULL", createDecimalType(20), "CAST(null AS decimal(20, 0))") - .execute(getQueryRunner(), clickhouseCreateTrinoInsert("tpch.test_uint64")); + .execute(getQueryRunner(), clickhouseCreateAndTrinoInsert("tpch.test_uint64")); } @Test @@ -625,12 +625,18 @@ public void testDate(ZoneId sessionZone) .addRoundTrip("date", "DATE '1983-10-01'", DATE, "DATE '1983-10-01'") .addRoundTrip("date", "DATE '2106-02-07'", DATE, "DATE '2106-02-07'") // max value in ClickHouse .execute(getQueryRunner(), session, clickhouseCreateAndInsert("tpch.test_date")) - .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_date")); + .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_date")) + .execute(getQueryRunner(), session, trinoCreateAsSelect("test_date")) + .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_date")) + .execute(getQueryRunner(), session, trinoCreateAndInsert("test_date")); // Null SqlDataTypeTest.create() .addRoundTrip("date", "NULL", DATE, "CAST(NULL AS DATE)") - .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_date")); + .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_date")) + .execute(getQueryRunner(), session, trinoCreateAsSelect("test_date")) + .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_date")) + .execute(getQueryRunner(), session, trinoCreateAndInsert("test_date")); SqlDataTypeTest.create() .addRoundTrip("Nullable(date)", "NULL", DATE, "CAST(NULL AS DATE)") .execute(getQueryRunner(), session, clickhouseCreateAndInsert("tpch.test_date")); @@ -663,8 +669,10 @@ public void testTimestamp(ZoneId sessionZone) .addRoundTrip("timestamp(0)", "timestamp '2018-10-28 01:33:17'", createTimestampType(0), "TIMESTAMP '2018-10-28 01:33:17'") // time doubled in JVM zone .addRoundTrip("timestamp(0)", "timestamp '2018-10-28 03:33:33'", createTimestampType(0), "TIMESTAMP '2018-10-28 03:33:33'") // time double in Vilnius .addRoundTrip("timestamp(0)", "timestamp '2105-12-31 23:59:59'", createTimestampType(0), "TIMESTAMP '2105-12-31 23:59:59'") // max value in ClickHouse - .execute(getQueryRunner(), session, trinoCreateAsSelect("tpch.test_timestamp")) - .execute(getQueryRunner(), session, trinoCreateAndInsert("tpch.test_timestamp")); + .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_timestamp")) + .execute(getQueryRunner(), session, trinoCreateAsSelect("test_timestamp")) + .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_timestamp")) + .execute(getQueryRunner(), session, trinoCreateAndInsert("test_timestamp")); addTimestampRoundTrips("timestamp") .execute(getQueryRunner(), session, clickhouseCreateAndInsert("tpch.test_timestamp")); @@ -764,7 +772,7 @@ public void testIp() .addRoundTrip("IPv6", "IPADDRESS 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'", IPADDRESS, "IPADDRESS 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'") .addRoundTrip("Nullable(IPv4)", "NULL", IPADDRESS, "CAST(NULL AS IPADDRESS)") .addRoundTrip("Nullable(IPv6)", "NULL", IPADDRESS, "CAST(NULL AS IPADDRESS)") - .execute(getQueryRunner(), clickhouseCreateTrinoInsert("tpch.test_ip")); + .execute(getQueryRunner(), clickhouseCreateAndTrinoInsert("tpch.test_ip")); } private static Session mapStringAsVarcharSession() @@ -801,7 +809,7 @@ private DataSetup clickhouseCreateAndInsert(String tableNamePrefix) return new CreateAndInsertDataSetup(new ClickHouseSqlExecutor(clickhouseServer::execute), tableNamePrefix); } - private DataSetup clickhouseCreateTrinoInsert(String tableNamePrefix) + private DataSetup clickhouseCreateAndTrinoInsert(String tableNamePrefix) { return new CreateAndTrinoInsertDataSetup(new ClickHouseSqlExecutor(clickhouseServer::execute), new TrinoSqlExecutor(getQueryRunner()), tableNamePrefix); } diff --git a/plugin/trino-mysql/src/test/java/io/trino/plugin/mysql/TestMySqlTypeMapping.java b/plugin/trino-mysql/src/test/java/io/trino/plugin/mysql/TestMySqlTypeMapping.java index e7c77a034b9c..b37cc4a4cfbc 100644 --- a/plugin/trino-mysql/src/test/java/io/trino/plugin/mysql/TestMySqlTypeMapping.java +++ b/plugin/trino-mysql/src/test/java/io/trino/plugin/mysql/TestMySqlTypeMapping.java @@ -687,6 +687,7 @@ public void testTimeFromTrino(ZoneId sessionZone) .addRoundTrip("TIME(5)", "NULL", createTimeType(5), "CAST(NULL AS TIME(5))") .addRoundTrip("TIME(6)", "NULL", createTimeType(6), "CAST(NULL AS TIME(6))") + .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_time")) .execute(getQueryRunner(), session, trinoCreateAsSelect("test_time")) .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_time")) .execute(getQueryRunner(), session, trinoCreateAndInsert("test_time")); diff --git a/plugin/trino-oracle/src/test/java/io/trino/plugin/oracle/AbstractTestOracleTypeMapping.java b/plugin/trino-oracle/src/test/java/io/trino/plugin/oracle/AbstractTestOracleTypeMapping.java index 7c3748970f1f..267d6ae34cdd 100644 --- a/plugin/trino-oracle/src/test/java/io/trino/plugin/oracle/AbstractTestOracleTypeMapping.java +++ b/plugin/trino-oracle/src/test/java/io/trino/plugin/oracle/AbstractTestOracleTypeMapping.java @@ -16,9 +16,11 @@ import com.google.common.collect.ImmutableList; import io.trino.Session; import io.trino.plugin.jdbc.UnsupportedTypeHandling; +import io.trino.spi.type.TimeZoneKey; import io.trino.testing.AbstractTestQueryFramework; import io.trino.testing.TestingSession; import io.trino.testing.datatype.CreateAndInsertDataSetup; +import io.trino.testing.datatype.CreateAndTrinoInsertDataSetup; import io.trino.testing.datatype.CreateAsSelectDataSetup; import io.trino.testing.datatype.DataSetup; import io.trino.testing.datatype.DataTypeTest; @@ -36,6 +38,7 @@ import java.time.ZoneId; import java.util.Optional; +import static com.google.common.base.Preconditions.checkState; import static com.google.common.base.Verify.verify; import static io.trino.plugin.jdbc.TypeHandlingJdbcSessionProperties.UNSUPPORTED_TYPE_HANDLING; import static io.trino.plugin.jdbc.UnsupportedTypeHandling.CONVERT_TO_VARCHAR; @@ -47,7 +50,6 @@ import static io.trino.spi.type.DecimalType.createDecimalType; import static io.trino.spi.type.DoubleType.DOUBLE; import static io.trino.spi.type.RealType.REAL; -import static io.trino.spi.type.TimeZoneKey.UTC_KEY; import static io.trino.spi.type.TimeZoneKey.getTimeZoneKey; import static io.trino.spi.type.TimestampType.TIMESTAMP_MILLIS; import static io.trino.spi.type.TimestampType.TIMESTAMP_SECONDS; @@ -94,31 +96,23 @@ public abstract class AbstractTestOracleTypeMapping @BeforeClass public void setUp() { + checkState(jvmZone.getId().equals("America/Bahia_Banderas"), "This test assumes certain JVM time zone"); + LocalDate dateOfLocalTimeChangeForwardAtMidnightInJvmZone = LocalDate.of(1970, 1, 1); + checkIsGap(jvmZone, dateOfLocalTimeChangeForwardAtMidnightInJvmZone.atStartOfDay()); checkIsGap(jvmZone, timeGapInJvmZone1); checkIsGap(jvmZone, timeGapInJvmZone2); checkIsDoubled(jvmZone, timeDoubledInJvmZone); + LocalDate dateOfLocalTimeChangeForwardAtMidnightInSomeZone = LocalDate.of(1983, 4, 1); + checkIsGap(vilnius, dateOfLocalTimeChangeForwardAtMidnightInSomeZone.atStartOfDay()); + LocalDate dateOfLocalTimeChangeBackwardAtMidnightInSomeZone = LocalDate.of(1983, 10, 1); + checkIsDoubled(vilnius, dateOfLocalTimeChangeBackwardAtMidnightInSomeZone.atStartOfDay().minusMinutes(1)); checkIsGap(vilnius, timeGapInVilnius); checkIsDoubled(vilnius, timeDoubledInVilnius); checkIsGap(kathmandu, timeGapInKathmandu); } - private DataSetup trinoCreateAsSelect(String tableNamePrefix) - { - return trinoCreateAsSelect(getSession(), tableNamePrefix); - } - - private DataSetup trinoCreateAsSelect(Session session, String tableNamePrefix) - { - return new CreateAsSelectDataSetup(new TrinoSqlExecutor(getQueryRunner(), session), tableNamePrefix); - } - - private DataSetup trinoCreateAndInsert(String tableNamePrefix) - { - return new CreateAndInsertDataSetup(new TrinoSqlExecutor(getQueryRunner()), tableNamePrefix); - } - /* Floating point types tests */ @Test @@ -494,10 +488,24 @@ public void testRoundingOfUnspecifiedNumber() @Test public void testNumberNegativeScaleReadMapping() { - // TODO: Add similar tests for write mappings. - // Those tests would require the table to be created in Oracle, but values inserted - // by Trino, which is outside the capabilities of the current DataSetup classes. - SqlDataTypeTest.create() + numberWithNegativeScaleTest() + .addRoundTrip("number(37, -1)", "99999999999999999999999999999999999990", createDecimalType(38, 0), "CAST('99999999999999999999999999999999999990' AS DECIMAL(38, 0))") // max + .addRoundTrip("number(37, -1)", "-99999999999999999999999999999999999990", createDecimalType(38, 0), "CAST('-99999999999999999999999999999999999990' AS DECIMAL(38, 0))") // min + .execute(getQueryRunner(), oracleCreateAndInsert("number_negative_s")); + } + + @Test + public void testNumberNegativeScaleWriteMapping() + { + numberWithNegativeScaleTest() + .addRoundTrip("number(37, -1)", "CAST('99999999999999999999999999999999999990' AS DECIMAL(38, 0))", createDecimalType(38, 0), "CAST('99999999999999999999999999999999999990' AS DECIMAL(38, 0))") // max + .addRoundTrip("number(37, -1)", "CAST('-99999999999999999999999999999999999990' AS DECIMAL(38, 0))", createDecimalType(38, 0), "CAST('-99999999999999999999999999999999999990' AS DECIMAL(38, 0))") // min + .execute(getQueryRunner(), oracleCreateAndTrinoInsert("number_negative_s")); + } + + private SqlDataTypeTest numberWithNegativeScaleTest() + { + return SqlDataTypeTest.create() .addRoundTrip("number(1, -1)", "20", createDecimalType(2, 0), "CAST(20 AS DECIMAL(2, 0))") .addRoundTrip("number(1, -1)", "35", createDecimalType(2, 0), "CAST(40 AS DECIMAL(2, 0))") // More useful as a test for write mappings. .addRoundTrip("number(2, -4)", "470000", createDecimalType(6, 0), "CAST(470000 AS DECIMAL(6, 0))") @@ -509,10 +517,7 @@ public void testNumberNegativeScaleReadMapping() .addRoundTrip("number(5, -33)", "1.2345E+37", createDecimalType(38, 0), "CAST(1.2345E+37 AS DECIMAL(38, 0))") .addRoundTrip("number(5, -33)", "-1.2345E+37", createDecimalType(38, 0), "CAST(-1.2345E+37 AS DECIMAL(38, 0))") .addRoundTrip("number(1, -37)", "1E+37", createDecimalType(38, 0), "CAST(1E+37 AS DECIMAL(38, 0))") - .addRoundTrip("number(1, -37)", "-1E+37", createDecimalType(38, 0), "CAST(-1E+37 AS DECIMAL(38, 0))") - .addRoundTrip("number(37, -1)", "99999999999999999999999999999999999990", createDecimalType(38, 0), "CAST('99999999999999999999999999999999999990' AS DECIMAL(38, 0))") // max - .addRoundTrip("number(37, -1)", "-99999999999999999999999999999999999990", createDecimalType(38, 0), "CAST('-99999999999999999999999999999999999990' AS DECIMAL(38, 0))") // min - .execute(getQueryRunner(), oracleCreateAndInsert("number_negative_s")); + .addRoundTrip("number(1, -37)", "-1E+37", createDecimalType(38, 0), "CAST(-1E+37 AS DECIMAL(38, 0))"); } @Test @@ -579,8 +584,8 @@ private Session number(UnsupportedTypeHandling unsupportedTypeHandlingStrategy, @Test public void testSpecialNumberFormats() { - getOracleSqlExecutor().execute("CREATE TABLE test (num1 number)"); - getOracleSqlExecutor().execute("INSERT INTO test VALUES (12345678901234567890.12345678901234567890123456789012345678)"); + onRemoteDatabase().execute("CREATE TABLE test (num1 number)"); + onRemoteDatabase().execute("INSERT INTO test VALUES (12345678901234567890.12345678901234567890123456789012345678)"); assertQuery(number(HALF_UP, 10), "SELECT * FROM test", "VALUES (12345678901234567890.1234567890)"); } @@ -629,35 +634,16 @@ public void testVarbinary() .execute(getQueryRunner(), oracleCreateAndInsert("test_blob")); } - @Test - public void testDate() + @Test(dataProvider = "sessionZonesDataProvider") + public void testDate(ZoneId sessionZone) { // Note: these test cases are duplicates of those for PostgreSQL and MySQL. - LocalDate dateOfLocalTimeChangeForwardAtMidnightInJvmZone = - LocalDate.of(1970, 1, 1); - - verify(jvmZone.getRules().getValidOffsets( - dateOfLocalTimeChangeForwardAtMidnightInJvmZone - .atStartOfDay()).isEmpty()); - - ZoneId someZone = ZoneId.of("Europe/Vilnius"); - - LocalDate dateOfLocalTimeChangeForwardAtMidnightInSomeZone = - LocalDate.of(1983, 4, 1); - - verify(someZone.getRules().getValidOffsets( - dateOfLocalTimeChangeForwardAtMidnightInSomeZone - .atStartOfDay()).isEmpty()); - - LocalDate dateOfLocalTimeChangeBackwardAtMidnightInSomeZone = - LocalDate.of(1983, 10, 1); - - verify(someZone.getRules().getValidOffsets( - dateOfLocalTimeChangeBackwardAtMidnightInSomeZone - .atStartOfDay().minusMinutes(1)).size() == 2); + Session session = Session.builder(getSession()) + .setTimeZoneKey(TimeZoneKey.getTimeZoneKey(sessionZone.getId())) + .build(); - SqlDataTypeTest dateTests = SqlDataTypeTest.create() + SqlDataTypeTest.create() // min value in Oracle .addRoundTrip("DATE", "DATE '-4712-01-01'", TIMESTAMP_SECONDS, "TIMESTAMP '-4712-01-01 00:00:00'") .addRoundTrip("DATE", "DATE '-0001-01-01'", TIMESTAMP_SECONDS, "TIMESTAMP '-0001-01-01 00:00:00'") @@ -677,16 +663,12 @@ public void testDate() .addRoundTrip("DATE", "DATE '1983-04-01'", TIMESTAMP_SECONDS, "TIMESTAMP '1983-04-01 00:00:00'") .addRoundTrip("DATE", "DATE '1983-10-01'", TIMESTAMP_SECONDS, "TIMESTAMP '1983-10-01 00:00:00'") // max value in Oracle - .addRoundTrip("DATE", "DATE '9999-12-31'", TIMESTAMP_SECONDS, "TIMESTAMP '9999-12-31 00:00:00'"); - - for (String timeZoneId : ImmutableList.of(UTC_KEY.getId(), ZoneId.systemDefault().getId(), ZoneId.of("Europe/Vilnius").getId())) { - Session session = Session.builder(getSession()) - .setTimeZoneKey(getTimeZoneKey(timeZoneId)) - .build(); - dateTests.execute(getQueryRunner(), session, oracleCreateAndInsert("test_date")); - dateTests.execute(getQueryRunner(), session, trinoCreateAsSelect("test_date")); - dateTests.execute(getQueryRunner(), session, trinoCreateAndInsert("test_date")); - } + .addRoundTrip("DATE", "DATE '9999-12-31'", TIMESTAMP_SECONDS, "TIMESTAMP '9999-12-31 00:00:00'") + .execute(getQueryRunner(), session, oracleCreateAndInsert("test_date")) + .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_date")) + .execute(getQueryRunner(), session, trinoCreateAsSelect("test_date")) + .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_date")) + .execute(getQueryRunner(), session, trinoCreateAndInsert("test_date")); } @Test @@ -719,8 +701,12 @@ public void testUnsupportedDate() @Test(dataProvider = "sessionZonesDataProvider") public void testTimestamp(ZoneId sessionZone) { + Session session = Session.builder(getSession()) + .setTimeZoneKey(getTimeZoneKey(sessionZone.getId())) + .build(); + // using two non-JVM zones so that we don't need to worry what Oracle system zone is - SqlDataTypeTest tests = SqlDataTypeTest.create() + SqlDataTypeTest.create() // min value in Oracle .addRoundTrip("timestamp", "TIMESTAMP '-4712-01-01 00:00:00.000'", TIMESTAMP_MILLIS, "TIMESTAMP '-4712-01-01 00:00:00.000'") .addRoundTrip("timestamp", "TIMESTAMP '-0001-01-01 00:00:00.000'", TIMESTAMP_MILLIS, "TIMESTAMP '-0001-01-01 00:00:00.000'") @@ -740,14 +726,11 @@ public void testTimestamp(ZoneId sessionZone) .addRoundTrip("timestamp", timestampDataType(3).toLiteral(timeGapInVilnius), TIMESTAMP_MILLIS, timestampDataType(3).toLiteral(timeGapInVilnius)) .addRoundTrip("timestamp", timestampDataType(3).toLiteral(timeGapInKathmandu), TIMESTAMP_MILLIS, timestampDataType(3).toLiteral(timeGapInKathmandu)) // max value in Oracle - .addRoundTrip("timestamp", "TIMESTAMP '9999-12-31 00:00:00.000'", TIMESTAMP_MILLIS, "TIMESTAMP '9999-12-31 00:00:00.000'"); - - Session session = Session.builder(getSession()) - .setTimeZoneKey(getTimeZoneKey(sessionZone.getId())) - .build(); - tests.execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_timestamp")); - tests.execute(getQueryRunner(), session, trinoCreateAndInsert("test_timestamp")); - tests.execute(getQueryRunner(), session, oracleCreateAndInsert("test_timestamp")); + .addRoundTrip("timestamp", "TIMESTAMP '9999-12-31 00:00:00.000'", TIMESTAMP_MILLIS, "TIMESTAMP '9999-12-31 00:00:00.000'") + .execute(getQueryRunner(), session, oracleCreateAndInsert("test_timestamp")) + .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_timestamp")) + .execute(getQueryRunner(), session, trinoCreateAsSelect("test_timestamp")) + .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_timestamp")); } @Test @@ -927,17 +910,42 @@ public void testUnsupportedNumberScale() */ private void testUnsupportedOracleType(String dataTypeName) { - try (TestTable table = new TestTable(getOracleSqlExecutor(), "unsupported_type", format("(unsupported_type %s)", dataTypeName))) { + try (TestTable table = new TestTable(onRemoteDatabase(), "unsupported_type", format("(unsupported_type %s)", dataTypeName))) { assertQueryFails("SELECT * FROM " + table.getName(), NO_SUPPORTED_COLUMNS); } } + private DataSetup trinoCreateAsSelect(String tableNamePrefix) + { + return trinoCreateAsSelect(getSession(), tableNamePrefix); + } + + private DataSetup trinoCreateAsSelect(Session session, String tableNamePrefix) + { + return new CreateAsSelectDataSetup(new TrinoSqlExecutor(getQueryRunner(), session), tableNamePrefix); + } + + private DataSetup trinoCreateAndInsert(String tableNamePrefix) + { + return trinoCreateAndInsert(getSession(), tableNamePrefix); + } + + private DataSetup trinoCreateAndInsert(Session session, String tableNamePrefix) + { + return new CreateAndInsertDataSetup(new TrinoSqlExecutor(getQueryRunner(), session), tableNamePrefix); + } + private DataSetup oracleCreateAndInsert(String tableNamePrefix) { - return new CreateAndInsertDataSetup(getOracleSqlExecutor(), tableNamePrefix); + return new CreateAndInsertDataSetup(onRemoteDatabase(), tableNamePrefix); + } + + private DataSetup oracleCreateAndTrinoInsert(String tableNamePrefix) + { + return new CreateAndTrinoInsertDataSetup(onRemoteDatabase(), new TrinoSqlExecutor(getQueryRunner()), tableNamePrefix); } - protected abstract SqlExecutor getOracleSqlExecutor(); + protected abstract SqlExecutor onRemoteDatabase(); private static void checkIsGap(ZoneId zone, LocalDateTime dateTime) { @@ -956,6 +964,6 @@ private static void checkIsDoubled(ZoneId zone, LocalDateTime dateTime) private TestTable oracleTable(String tableName, String schema, String data) { - return new TestTable(getOracleSqlExecutor(), tableName, format("(%s)", schema), ImmutableList.of(data)); + return new TestTable(onRemoteDatabase(), tableName, format("(%s)", schema), ImmutableList.of(data)); } } diff --git a/plugin/trino-oracle/src/test/java/io/trino/plugin/oracle/TestOracleTypeMapping.java b/plugin/trino-oracle/src/test/java/io/trino/plugin/oracle/TestOracleTypeMapping.java index 6c34fc880693..1c5c942fabdd 100644 --- a/plugin/trino-oracle/src/test/java/io/trino/plugin/oracle/TestOracleTypeMapping.java +++ b/plugin/trino-oracle/src/test/java/io/trino/plugin/oracle/TestOracleTypeMapping.java @@ -17,7 +17,6 @@ import com.google.common.collect.ImmutableMap; import io.trino.testing.QueryRunner; import io.trino.testing.sql.SqlExecutor; -import org.testng.annotations.AfterClass; import static io.trino.plugin.oracle.TestingOracleServer.TEST_PASS; import static io.trino.plugin.oracle.TestingOracleServer.TEST_USER; @@ -31,7 +30,7 @@ public class TestOracleTypeMapping protected QueryRunner createQueryRunner() throws Exception { - this.oracleServer = new TestingOracleServer(); + this.oracleServer = closeAfterClass(new TestingOracleServer()); return OracleQueryRunner.createOracleQueryRunner( oracleServer, ImmutableMap.of(), @@ -45,16 +44,8 @@ protected QueryRunner createQueryRunner() ImmutableList.of()); } - @AfterClass(alwaysRun = true) - public final void destroy() - { - if (oracleServer != null) { - oracleServer.close(); - } - } - @Override - protected SqlExecutor getOracleSqlExecutor() + protected SqlExecutor onRemoteDatabase() { return sql -> oracleServer.execute(sql); } diff --git a/plugin/trino-postgresql/src/test/java/io/trino/plugin/postgresql/TestPostgreSqlTypeMapping.java b/plugin/trino-postgresql/src/test/java/io/trino/plugin/postgresql/TestPostgreSqlTypeMapping.java index 5abffc1604e2..b92d715b0a58 100644 --- a/plugin/trino-postgresql/src/test/java/io/trino/plugin/postgresql/TestPostgreSqlTypeMapping.java +++ b/plugin/trino-postgresql/src/test/java/io/trino/plugin/postgresql/TestPostgreSqlTypeMapping.java @@ -214,7 +214,7 @@ public void testSmallserial() .addRoundTrip("smallserial", "32456", SMALLINT, "SMALLINT '32456'") .addRoundTrip("smallserial", "32767", SMALLINT, "SMALLINT '32767'") // max value in PostgreSQL and Trino .execute(getQueryRunner(), postgresCreateAndInsert("tpch.test_smallserial")) - .execute(getQueryRunner(), postgresCreateTrinoInsert("tpch.test_smallserial")); + .execute(getQueryRunner(), postgresCreateAndTrinoInsert("tpch.test_smallserial")); } @Test @@ -252,7 +252,7 @@ public void testSerial() .addRoundTrip("serial", "1234567890", INTEGER, "1234567890") .addRoundTrip("serial", "2147483647", INTEGER, "2147483647") // max value in PostgreSQL and Trino .execute(getQueryRunner(), postgresCreateAndInsert("tpch.test_serial")) - .execute(getQueryRunner(), postgresCreateTrinoInsert("tpch.test_serial")); + .execute(getQueryRunner(), postgresCreateAndTrinoInsert("tpch.test_serial")); } @Test @@ -290,7 +290,7 @@ public void testBigserial() .addRoundTrip("bigserial", "123456789012", BIGINT, "123456789012") .addRoundTrip("bigserial", "9223372036854775807", BIGINT, "9223372036854775807") // max value in PostgreSQL and Trino .execute(getQueryRunner(), postgresCreateAndInsert("tpch.test_bigserial")) - .execute(getQueryRunner(), postgresCreateTrinoInsert("tpch.test_bigserial")); + .execute(getQueryRunner(), postgresCreateAndTrinoInsert("tpch.test_bigserial")); } @Test @@ -1096,7 +1096,8 @@ public void testDate(ZoneId sessionZone) .execute(getQueryRunner(), session, postgresCreateAndInsert("test_date")) .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_date")) .execute(getQueryRunner(), session, trinoCreateAsSelect("test_date")) - .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_date")); + .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_date")) + .execute(getQueryRunner(), session, trinoCreateAndInsert("test_date")); // min value SqlDataTypeTest.create() @@ -1106,7 +1107,8 @@ public void testDate(ZoneId sessionZone) .addRoundTrip("DATE", "DATE '-4712-01-01'", DATE, "DATE '-4712-01-01'") .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_date_min")) .execute(getQueryRunner(), session, trinoCreateAsSelect("test_date_min")) - .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_date_min")); + .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_date_min")) + .execute(getQueryRunner(), session, trinoCreateAndInsert("test_date_min")); } @Test @@ -1161,10 +1163,11 @@ public void testTime(ZoneId sessionZone) .addRoundTrip("time(6)", "TIME '23:59:59.999999'", createTimeType(6), "TIME '23:59:59.999999'") .addRoundTrip("time(3)", "TIME '00:00:00.000'", createTimeType(3), "TIME '00:00:00.000'") .addRoundTrip("time(3)", "TIME '00:12:34.567'", createTimeType(3), "TIME '00:12:34.567'") + .execute(getQueryRunner(), session, postgresCreateAndInsert("test_time")) .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_time")) .execute(getQueryRunner(), session, trinoCreateAsSelect("test_time")) .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_time")) - .execute(getQueryRunner(), session, postgresCreateAndInsert("test_time")); + .execute(getQueryRunner(), session, trinoCreateAndInsert("test_time")); } /** @@ -1339,10 +1342,11 @@ public void testTimestamp(ZoneId sessionZone) .addRoundTrip("timestamp(6)", "TIMESTAMP '1969-12-31 23:59:59.123000'", createTimestampType(6), "TIMESTAMP '1969-12-31 23:59:59.123000'") .addRoundTrip("timestamp(6)", "TIMESTAMP '1969-12-31 23:59:59.123456'", createTimestampType(6), "TIMESTAMP '1969-12-31 23:59:59.123456'") + .execute(getQueryRunner(), session, postgresCreateAndInsert("test_timestamp")) .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_timestamp")) .execute(getQueryRunner(), session, trinoCreateAsSelect("test_timestamp")) .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_timestamp")) - .execute(getQueryRunner(), session, postgresCreateAndInsert("test_timestamp")); + .execute(getQueryRunner(), session, trinoCreateAndInsert("test_timestamp")); } /** @@ -1685,7 +1689,7 @@ public void testHstore() .addRoundTrip("hstore", "MAP(ARRAY['key1','key2','key3'], ARRAY['value1','value2','value3'])", mapOfVarcharToVarchar, "CAST(MAP(ARRAY['key1','key2','key3'], ARRAY['value1','value2','value3']) AS MAP(VARCHAR, VARCHAR))") .addRoundTrip("hstore", "MAP(ARRAY['key1','key2','key3'], ARRAY[' \" ',' '' ',' ]) '])", mapOfVarcharToVarchar, "CAST(MAP(ARRAY['key1','key2','key3'], ARRAY[' \" ',' '' ',' ]) ']) AS MAP(VARCHAR, VARCHAR))") .addRoundTrip("hstore", "MAP(ARRAY['key1'], ARRAY[null])", mapOfVarcharToVarchar, "CAST(MAP(ARRAY['key1'], ARRAY[null]) AS MAP(VARCHAR, VARCHAR))") - .execute(getQueryRunner(), postgresCreateTrinoInsert("postgresql_test_hstore")); + .execute(getQueryRunner(), postgresCreateAndTrinoInsert("postgresql_test_hstore")); } @Test @@ -1876,7 +1880,7 @@ private DataSetup postgresCreateAndInsert(String tableNamePrefix) return new CreateAndInsertDataSetup(new JdbcSqlExecutor(postgreSqlServer.getJdbcUrl(), postgreSqlServer.getProperties()), tableNamePrefix); } - private DataSetup postgresCreateTrinoInsert(String tableNamePrefix) + private DataSetup postgresCreateAndTrinoInsert(String tableNamePrefix) { return new CreateAndTrinoInsertDataSetup(new JdbcSqlExecutor(postgreSqlServer.getJdbcUrl(), postgreSqlServer.getProperties()), new TrinoSqlExecutor(getQueryRunner()), tableNamePrefix); } diff --git a/plugin/trino-singlestore/src/test/java/io/trino/plugin/singlestore/TestSingleStoreTypeMapping.java b/plugin/trino-singlestore/src/test/java/io/trino/plugin/singlestore/TestSingleStoreTypeMapping.java index 2fefc73603f8..32b4b9c4a4bb 100644 --- a/plugin/trino-singlestore/src/test/java/io/trino/plugin/singlestore/TestSingleStoreTypeMapping.java +++ b/plugin/trino-singlestore/src/test/java/io/trino/plugin/singlestore/TestSingleStoreTypeMapping.java @@ -676,7 +676,9 @@ public void testTime(ZoneId sessionZone) .addRoundTrip("time(6)", "TIME '01:02:03.123456'", TIME_MICROS, "TIME '01:02:03.123456'") .addRoundTrip("time(6)", "TIME '23:59:59.999999'", TIME_MICROS, "TIME '23:59:59.999999'") .addRoundTrip("time(6)", "TIME '00:00:00.000000'", TIME_MICROS, "TIME '00:00:00.000000'") // round by engine + .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_time")) .execute(getQueryRunner(), session, trinoCreateAsSelect("test_time")) + .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_time")) .execute(getQueryRunner(), session, trinoCreateAndInsert("test_time")); SqlDataTypeTest.create() @@ -898,7 +900,9 @@ public void testTimestampWrite(ZoneId sessionZone) .addRoundTrip("timestamp(6)", "NULL", createTimestampType(6), "CAST(NULL AS TIMESTAMP(6))") .execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_datetime")) - .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_datetime")); + .execute(getQueryRunner(), session, trinoCreateAsSelect("test_datetime")) + .execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_datetime")) + .execute(getQueryRunner(), session, trinoCreateAndInsert("test_datetime")); } @DataProvider diff --git a/plugin/trino-sqlserver/src/test/java/io/trino/plugin/sqlserver/BaseSqlServerTypeMapping.java b/plugin/trino-sqlserver/src/test/java/io/trino/plugin/sqlserver/BaseSqlServerTypeMapping.java index dc1c7ab51813..599a54bab643 100644 --- a/plugin/trino-sqlserver/src/test/java/io/trino/plugin/sqlserver/BaseSqlServerTypeMapping.java +++ b/plugin/trino-sqlserver/src/test/java/io/trino/plugin/sqlserver/BaseSqlServerTypeMapping.java @@ -697,6 +697,7 @@ public void testTimestamp(ZoneId sessionZone) tests.execute(getQueryRunner(), session, trinoCreateAsSelect(session, "test_timestamp")); tests.execute(getQueryRunner(), session, trinoCreateAsSelect("test_timestamp")); tests.execute(getQueryRunner(), session, trinoCreateAndInsert(session, "test_timestamp")); + tests.execute(getQueryRunner(), session, trinoCreateAndInsert("test_timestamp")); } @Test