This is an automated email from the ASF dual-hosted git repository.
alexpl pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite.git
The following commit(s) were added to refs/heads/master by this push:
new e53ce57e6aa IGNITE-22576 SQL Calcite: Fix default TIMESTAMP precision
- Fixes #11407.
e53ce57e6aa is described below
commit e53ce57e6aa7a86c59633a9d88379309a5e177d8
Author: Aleksey Plekhanov <[email protected]>
AuthorDate: Fri Jul 19 10:30:37 2024 +0300
IGNITE-22576 SQL Calcite: Fix default TIMESTAMP precision - Fixes #11407.
Signed-off-by: Aleksey Plekhanov <[email protected]>
---
.../query/calcite/type/IgniteTypeSystem.java | 10 ++
.../calcite/{ => integration}/DateTimeTest.java | 121 +++++++++++----------
.../DynamicParametersIntegrationTest.java | 2 +-
.../integration/QueryMetadataIntegrationTest.java | 6 +-
.../integration/TableDdlIntegrationTest.java | 4 +-
.../ignite/testsuites/IntegrationTestSuite.java | 2 +-
...stamp_ms.test_ignore => test_timestamp_ms.test} | 5 +-
7 files changed, 83 insertions(+), 67 deletions(-)
diff --git
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/type/IgniteTypeSystem.java
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/type/IgniteTypeSystem.java
index dcde15bca89..a5a9594e20b 100644
---
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/type/IgniteTypeSystem.java
+++
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/type/IgniteTypeSystem.java
@@ -43,6 +43,16 @@ public class IgniteTypeSystem extends RelDataTypeSystemImpl
implements Serializa
return Short.MAX_VALUE;
}
+ /** {@inheritDoc} */
+ @Override public int getDefaultPrecision(SqlTypeName typeName) {
+ // Timestamps internally stored as millis, precision more than 3 is
redundant. At the same time,
+ // default Calcite precision 0 causes truncation when converting to
TIMESTAMP without specifying precision.
+ if (typeName == SqlTypeName.TIMESTAMP || typeName ==
SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE)
+ return 3;
+
+ return super.getDefaultPrecision(typeName);
+ }
+
/** {@inheritDoc} */
@Override public RelDataType deriveSumType(RelDataTypeFactory typeFactory,
RelDataType argumentType) {
RelDataType sumType;
diff --git
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/DateTimeTest.java
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/DateTimeTest.java
similarity index 63%
rename from
modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/DateTimeTest.java
rename to
modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/DateTimeTest.java
index bce76202e40..1335e33aa6e 100644
---
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/DateTimeTest.java
+++
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/DateTimeTest.java
@@ -15,39 +15,29 @@
* limitations under the License.
*/
-package org.apache.ignite.internal.processors.query.calcite;
+package org.apache.ignite.internal.processors.query.calcite.integration;
import java.sql.Time;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
-import org.apache.ignite.Ignite;
import org.apache.ignite.IgniteCache;
import org.apache.ignite.cache.CacheMode;
import org.apache.ignite.cache.QueryEntity;
import org.apache.ignite.configuration.CacheConfiguration;
-import org.apache.ignite.internal.IgniteEx;
-import org.apache.ignite.internal.processors.query.QueryEngine;
-import org.apache.ignite.internal.processors.query.calcite.util.Commons;
-import org.apache.ignite.testframework.junits.WithSystemProperty;
-import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
import org.junit.Test;
import static java.util.Collections.singletonList;
/** */
-@WithSystemProperty(key = "calcite.debug", value = "true")
-public class DateTimeTest extends GridCommonAbstractTest {
+public class DateTimeTest extends AbstractBasicIntegrationTest {
/** */
private static final SimpleDateFormat DATE_FORMAT = new
SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
- /** */
- private static QueryEngine queryEngine;
-
/** {@inheritDoc} */
@Override protected void beforeTestsStarted() throws Exception {
- Ignite grid = startGridsMultiThreaded(1);
+ super.beforeTestsStarted();
QueryEntity qryEnt = new QueryEntity();
qryEnt.setKeyFieldName("ID");
@@ -68,7 +58,7 @@ public class DateTimeTest extends GridCommonAbstractTest {
.setQueryEntities(singletonList(qryEnt))
.setSqlSchema("PUBLIC");
- IgniteCache<Integer, DateTimeEntry> dateTimeCache =
grid.createCache(cfg);
+ IgniteCache<Integer, DateTimeEntry> dateTimeCache =
client.createCache(cfg);
dateTimeCache.put(1, new DateTimeEntry(1, javaDate("2020-10-01
12:00:00.000"),
sqlDate("2020-10-01"), sqlTime("12:00:00"),
sqlTimestamp("2020-10-01 12:00:00.000")));
@@ -78,16 +68,17 @@ public class DateTimeTest extends GridCommonAbstractTest {
sqlDate("2020-10-20"), sqlTime("13:15:00"),
sqlTimestamp("2020-10-20 13:15:00.000")));
dateTimeCache.put(4, new DateTimeEntry(4, javaDate("2020-01-01
22:40:00.000"),
sqlDate("2020-01-01"), sqlTime("22:40:00"),
sqlTimestamp("2020-01-01 22:40:00.000")));
+ }
- queryEngine = Commons.lookupComponent(((IgniteEx)grid).context(),
QueryEngine.class);
-
- awaitPartitionMapExchange();
+ /** {@inheritDoc} */
+ @Override protected void afterTest() throws Exception {
+ // Don't clean up caches after test.
}
/** */
@Test
public void testQuery1() throws Exception {
- checkQuery("SELECT SQLDATE FROM datetimetable where SQLTIME =
'12:00:00'")
+ assertQuery("SELECT SQLDATE FROM datetimetable where SQLTIME =
'12:00:00'")
.returns(sqlDate("2020-10-01"))
.check();
}
@@ -95,7 +86,7 @@ public class DateTimeTest extends GridCommonAbstractTest {
/** */
@Test
public void testQuery2() throws Exception {
- checkQuery("SELECT SQLDATE FROM datetimetable where JAVADATE = ?")
+ assertQuery("SELECT SQLDATE FROM datetimetable where JAVADATE = ?")
.withParams(javaDate("2020-12-01 00:10:20.000"))
.returns(sqlDate("2020-12-01"))
.check();
@@ -104,7 +95,7 @@ public class DateTimeTest extends GridCommonAbstractTest {
/** */
@Test
public void testQuery3() throws Exception {
- checkQuery("SELECT SQLDATE FROM datetimetable where JAVADATE = ?")
+ assertQuery("SELECT SQLDATE FROM datetimetable where JAVADATE = ?")
.withParams(sqlTimestamp("2020-12-01 00:10:20.000"))
.returns(sqlDate("2020-12-01"))
.check();
@@ -113,7 +104,7 @@ public class DateTimeTest extends GridCommonAbstractTest {
/** */
@Test
public void testQuery4() throws Exception {
- checkQuery("SELECT MAX(SQLDATE) FROM datetimetable")
+ assertQuery("SELECT MAX(SQLDATE) FROM datetimetable")
.returns(sqlDate("2020-12-01"))
.check();
}
@@ -121,7 +112,7 @@ public class DateTimeTest extends GridCommonAbstractTest {
/** */
@Test
public void testQuery5() throws Exception {
- checkQuery("SELECT MIN(SQLDATE) FROM datetimetable")
+ assertQuery("SELECT MIN(SQLDATE) FROM datetimetable")
.returns(sqlDate("2020-01-01"))
.check();
}
@@ -129,7 +120,7 @@ public class DateTimeTest extends GridCommonAbstractTest {
/** */
@Test
public void testQuery6() throws Exception {
- checkQuery("SELECT JAVADATE FROM datetimetable WHERE SQLTIME =
'13:15:00'")
+ assertQuery("SELECT JAVADATE FROM datetimetable WHERE SQLTIME =
'13:15:00'")
.returns(javaDate("2020-10-20 13:15:00.000"))
.check();
}
@@ -137,7 +128,7 @@ public class DateTimeTest extends GridCommonAbstractTest {
/** */
@Test
public void testQuery7() throws Exception {
- checkQuery("SELECT t1.JAVADATE, t2.JAVADATE FROM datetimetable t1 " +
+ assertQuery("SELECT t1.JAVADATE, t2.JAVADATE FROM datetimetable t1 " +
"INNER JOIN " +
"(SELECT JAVADATE, CAST(SQLTIMESTAMP AS TIME) AS CASTED_TIME FROM
datetimetable) t2 " +
"ON t1.SQLTIME = t2.CASTED_TIME " +
@@ -157,52 +148,52 @@ public class DateTimeTest extends GridCommonAbstractTest {
TimeZone.setDefault(TimeZone.getTimeZone("Europe/Moscow"));
// Time zone change (EET->MSK) 1992-01-19 02:00:00 -> 1992-01-19
03:00:00
- checkQuery("select date
'1992-01-19'").returns(sqlDate("1992-01-19")).check();
- checkQuery("select date '1992-01-18' + interval (1)
days").returns(sqlDate("1992-01-19")).check();
- checkQuery("select date '1992-01-18' + interval (24)
hours").returns(sqlDate("1992-01-19")).check();
- checkQuery("SELECT timestamp '1992-01-18 02:30:00' + interval (25)
hours")
+ assertQuery("select date
'1992-01-19'").returns(sqlDate("1992-01-19")).check();
+ assertQuery("select date '1992-01-18' + interval (1)
days").returns(sqlDate("1992-01-19")).check();
+ assertQuery("select date '1992-01-18' + interval (24)
hours").returns(sqlDate("1992-01-19")).check();
+ assertQuery("SELECT timestamp '1992-01-18 02:30:00' + interval
(25) hours")
.returns(sqlTimestamp("1992-01-19 03:30:00.000")).check();
- checkQuery("SELECT timestamp '1992-01-18 02:30:00' + interval (23)
hours")
+ assertQuery("SELECT timestamp '1992-01-18 02:30:00' + interval
(23) hours")
.returns(sqlTimestamp("1992-01-19 01:30:00.000")).check();
- checkQuery("SELECT timestamp '1992-01-18 02:30:00' + interval (24)
hours")
+ assertQuery("SELECT timestamp '1992-01-18 02:30:00' + interval
(24) hours")
.returns(sqlTimestamp("1992-01-19 02:30:00.000")).check();
// DST started 1992-03-29 02:00:00 -> 1992-03-29 03:00:00
- checkQuery("select date
'1992-03-29'").returns(sqlDate("1992-03-29")).check();
- checkQuery("select date '1992-03-28' + interval (1)
days").returns(sqlDate("1992-03-29")).check();
- checkQuery("select date '1992-03-28' + interval (24)
hours").returns(sqlDate("1992-03-29")).check();
- checkQuery("SELECT timestamp '1992-03-28 02:30:00' + interval (25)
hours")
+ assertQuery("select date
'1992-03-29'").returns(sqlDate("1992-03-29")).check();
+ assertQuery("select date '1992-03-28' + interval (1)
days").returns(sqlDate("1992-03-29")).check();
+ assertQuery("select date '1992-03-28' + interval (24)
hours").returns(sqlDate("1992-03-29")).check();
+ assertQuery("SELECT timestamp '1992-03-28 02:30:00' + interval
(25) hours")
.returns(sqlTimestamp("1992-03-29 03:30:00.000")).check();
- checkQuery("SELECT timestamp '1992-03-28 02:30:00' + interval (23)
hours")
+ assertQuery("SELECT timestamp '1992-03-28 02:30:00' + interval
(23) hours")
.returns(sqlTimestamp("1992-03-29 01:30:00.000")).check();
- checkQuery("SELECT timestamp '1992-03-28 02:30:00' + interval (24)
hours")
+ assertQuery("SELECT timestamp '1992-03-28 02:30:00' + interval
(24) hours")
.returns(sqlTimestamp("1992-03-29 02:30:00.000")).check();
// DST ended 1992-09-27 03:00:00 -> 1992-09-27 02:00:00
- checkQuery("select date
'1992-09-27'").returns(sqlDate("1992-09-27")).check();
- checkQuery("select date '1992-09-26' + interval (1)
days").returns(sqlDate("1992-09-27")).check();
- checkQuery("select date '1992-09-26' + interval (24)
hours").returns(sqlDate("1992-09-27")).check();
- checkQuery("SELECT timestamp '1992-09-26 02:30:00' + interval (25)
hours")
+ assertQuery("select date
'1992-09-27'").returns(sqlDate("1992-09-27")).check();
+ assertQuery("select date '1992-09-26' + interval (1)
days").returns(sqlDate("1992-09-27")).check();
+ assertQuery("select date '1992-09-26' + interval (24)
hours").returns(sqlDate("1992-09-27")).check();
+ assertQuery("SELECT timestamp '1992-09-26 02:30:00' + interval
(25) hours")
.returns(sqlTimestamp("1992-09-27 03:30:00.000")).check();
- checkQuery("SELECT timestamp '1992-09-26 02:30:00' + interval (23)
hours")
+ assertQuery("SELECT timestamp '1992-09-26 02:30:00' + interval
(23) hours")
.returns(sqlTimestamp("1992-09-27 01:30:00.000")).check();
- checkQuery("SELECT timestamp '1992-09-26 02:30:00' + interval (24)
hours")
+ assertQuery("SELECT timestamp '1992-09-26 02:30:00' + interval
(24) hours")
.returns(sqlTimestamp("1992-09-27 02:30:00.000")).check();
TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));
// DST ended 2021-11-07 02:00:00 -> 2021-11-07 01:00:00
- checkQuery("select date
'2021-11-07'").returns(sqlDate("2021-11-07")).check();
- checkQuery("select date '2021-11-06' + interval (1)
days").returns(sqlDate("2021-11-07")).check();
- checkQuery("select date '2021-11-06' + interval (24)
hours").returns(sqlDate("2021-11-07")).check();
- checkQuery("SELECT timestamp '2021-11-06 01:30:00' + interval (25)
hours")
+ assertQuery("select date
'2021-11-07'").returns(sqlDate("2021-11-07")).check();
+ assertQuery("select date '2021-11-06' + interval (1)
days").returns(sqlDate("2021-11-07")).check();
+ assertQuery("select date '2021-11-06' + interval (24)
hours").returns(sqlDate("2021-11-07")).check();
+ assertQuery("SELECT timestamp '2021-11-06 01:30:00' + interval
(25) hours")
.returns(sqlTimestamp("2021-11-07 02:30:00.000")).check();
// Check string representation here, since after timestamp
calculation we have '2021-11-07T01:30:00.000-0800'
// but Timestamp.valueOf method converts '2021-11-07 01:30:00' in
'America/Los_Angeles' time zone to
// '2021-11-07T01:30:00.000-0700' (we pass through '2021-11-07
01:30:00' twice after DST ended).
- checkQuery("SELECT (timestamp '2021-11-06 02:30:00' + interval
(23) hours)::varchar")
+ assertQuery("SELECT (timestamp '2021-11-06 02:30:00' + interval
(23) hours)::varchar")
.returns("2021-11-07 01:30:00").check();
- checkQuery("SELECT (timestamp '2021-11-06 01:30:00' + interval
(24) hours)::varchar")
+ assertQuery("SELECT (timestamp '2021-11-06 01:30:00' + interval
(24) hours)::varchar")
.returns("2021-11-07 01:30:00").check();
}
finally {
@@ -210,6 +201,31 @@ public class DateTimeTest extends GridCommonAbstractTest {
}
}
+ /** */
+ @Test
+ public void testDateTimeCast() throws Exception {
+ assertQuery("SELECT CAST('2021-01-01 01:02:03.456' AS TIMESTAMP)")
+ .returns(sqlTimestamp("2021-01-01 01:02:03.456")).check();
+
+ assertQuery("SELECT CAST('2021-01-01 01:02:03.0' AS TIMESTAMP)")
+ .returns(sqlTimestamp("2021-01-01 01:02:03")).check();
+
+ assertQuery("SELECT CAST('2021-01-01 01:02:03' AS TIMESTAMP)")
+ .returns(sqlTimestamp("2021-01-01 01:02:03")).check();
+
+ assertQuery("SELECT CAST('2021-01-01 01:02:03.456' AS TIMESTAMP(0))")
+ .returns(sqlTimestamp("2021-01-01 01:02:03")).check();
+
+ assertQuery("SELECT CAST('2021-01-01 01:02:03.456' AS TIMESTAMP(2))")
+ .returns(sqlTimestamp("2021-01-01 01:02:03.45")).check();
+
+ assertQuery("SELECT CAST('2021-01-01' AS DATE)")
+ .returns(sqlDate("2021-01-01")).check();
+
+ assertQuery("SELECT CAST('01:02:03' AS TIME)")
+ .returns(sqlTime("01:02:03")).check();
+ }
+
/** */
public static class DateTimeEntry {
/** */
@@ -237,15 +253,6 @@ public class DateTimeTest extends GridCommonAbstractTest {
}
}
- /** */
- private QueryChecker checkQuery(String qry) {
- return new QueryChecker(qry) {
- @Override protected QueryEngine getEngine() {
- return queryEngine;
- }
- };
- }
-
/** */
private Date javaDate(String str) throws Exception {
return DATE_FORMAT.parse(str);
diff --git
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/DynamicParametersIntegrationTest.java
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/DynamicParametersIntegrationTest.java
index ae35a0d51f0..89fba933b5b 100644
---
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/DynamicParametersIntegrationTest.java
+++
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/DynamicParametersIntegrationTest.java
@@ -52,7 +52,7 @@ public class DynamicParametersIntegrationTest extends
AbstractBasicIntegrationTe
);
List<String> types = F.asList("VARCHAR", "DECIMAL(32767, 0)",
"INTEGER", "BIGINT", "REAL", "DOUBLE",
- "UUID", "INTERVAL DAY TO SECOND", "DATE", "TIMESTAMP(0)",
"TIME(0)", "INTERVAL YEAR TO MONTH");
+ "UUID", "INTERVAL DAY TO SECOND", "DATE", "TIMESTAMP(3)",
"TIME(0)", "INTERVAL YEAR TO MONTH");
for (int i = 0; i < values.size(); i++) {
assertQuery("SELECT
typeof(?)").withParams(values.get(i)).returns(types.get(i)).check();
diff --git
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/QueryMetadataIntegrationTest.java
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/QueryMetadataIntegrationTest.java
index c3e5ebbc6c8..36ee4dc647a 100644
---
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/QueryMetadataIntegrationTest.java
+++
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/QueryMetadataIntegrationTest.java
@@ -52,16 +52,16 @@ public class QueryMetadataIntegrationTest extends
AbstractBasicIntegrationTest {
.add("PUBLIC", "TBL1", BigDecimal.class, "ID", 10, 2, true)
.add("PUBLIC", "TBL1", String.class, "VAL", true)
.add("PUBLIC", "TBL1", Long.class, "VAL2", 19, 0, true)
- .add("PUBLIC", "TBL1", java.sql.Timestamp.class, "TS", 0,
SCALE_NOT_SPECIFIED, true)
+ .add("PUBLIC", "TBL1", java.sql.Timestamp.class, "TS", 3,
SCALE_NOT_SPECIFIED, true)
.add("PUBLIC", "TBL2", BigDecimal.class, "ID", 10, 2,
false)
.add("PUBLIC", "TBL2", String.class, "VAL", true)
.add("PUBLIC", "TBL2", Long.class, "VAL2", 19, 0, true)
- .add("PUBLIC", "TBL2", java.sql.Timestamp.class, "TS", 0,
SCALE_NOT_SPECIFIED, true),
+ .add("PUBLIC", "TBL2", java.sql.Timestamp.class, "TS", 3,
SCALE_NOT_SPECIFIED, true),
builder -> builder
.add(BigDecimal.class, 10, 2)
.add(BigDecimal.class, 10, 2)
.add(String.class)
- .add(java.sql.Timestamp.class, 0, SCALE_NOT_SPECIFIED)
+ .add(java.sql.Timestamp.class, 3, SCALE_NOT_SPECIFIED)
).check();
}
diff --git
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/TableDdlIntegrationTest.java
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/TableDdlIntegrationTest.java
index ccf7b0b5ae0..98ce8275f21 100644
---
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/TableDdlIntegrationTest.java
+++
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/TableDdlIntegrationTest.java
@@ -117,7 +117,7 @@ public class TableDdlIntegrationTest extends
AbstractDdlIntegrationTest {
"'test', " +
"date '2021-01-01', " +
"time '12:34:56', " +
- "timestamp '2021-01-01 12:34:56', " +
+ "timestamp '2021-01-01 12:34:56.789', " +
"1, " +
"9876543210, " +
"3, " +
@@ -138,7 +138,7 @@ public class TableDdlIntegrationTest extends
AbstractDdlIntegrationTest {
assertEquals("test", row.get(1));
assertEquals(Date.valueOf("2021-01-01"), row.get(2));
assertEquals(Time.valueOf("12:34:56"), row.get(3));
- assertEquals(Timestamp.valueOf("2021-01-01 12:34:56"), row.get(4));
+ assertEquals(Timestamp.valueOf("2021-01-01 12:34:56.789"), row.get(4));
assertEquals(1, row.get(5));
assertEquals(9876543210L, row.get(6));
assertEquals((short)3, row.get(7));
diff --git
a/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
b/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
index dd23c284ac1..84dcc6fdb61 100644
---
a/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
+++
b/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
@@ -20,7 +20,6 @@ package org.apache.ignite.testsuites;
import
org.apache.ignite.internal.processors.cache.DdlTransactionCalciteSelfTest;
import
org.apache.ignite.internal.processors.query.calcite.CalciteQueryProcessorTest;
import org.apache.ignite.internal.processors.query.calcite.CancelTest;
-import org.apache.ignite.internal.processors.query.calcite.DateTimeTest;
import
org.apache.ignite.internal.processors.query.calcite.IndexWithSameNameCalciteTest;
import
org.apache.ignite.internal.processors.query.calcite.SqlFieldsQueryUsageTest;
import
org.apache.ignite.internal.processors.query.calcite.UnstableTopologyTest;
@@ -30,6 +29,7 @@ import
org.apache.ignite.internal.processors.query.calcite.integration.CalciteBa
import
org.apache.ignite.internal.processors.query.calcite.integration.CalciteErrorHandlilngIntegrationTest;
import
org.apache.ignite.internal.processors.query.calcite.integration.CorrelatesIntegrationTest;
import
org.apache.ignite.internal.processors.query.calcite.integration.DataTypesTest;
+import
org.apache.ignite.internal.processors.query.calcite.integration.DateTimeTest;
import
org.apache.ignite.internal.processors.query.calcite.integration.DynamicParametersIntegrationTest;
import
org.apache.ignite.internal.processors.query.calcite.integration.ExpiredEntriesIntegrationTest;
import
org.apache.ignite.internal.processors.query.calcite.integration.FunctionsTest;
diff --git
a/modules/calcite/src/test/sql/types/timestamp/test_timestamp_ms.test_ignore
b/modules/calcite/src/test/sql/types/timestamp/test_timestamp_ms.test
similarity index 69%
rename from
modules/calcite/src/test/sql/types/timestamp/test_timestamp_ms.test_ignore
rename to modules/calcite/src/test/sql/types/timestamp/test_timestamp_ms.test
index 17711eb7b05..3e0f454054b 100644
--- a/modules/calcite/src/test/sql/types/timestamp/test_timestamp_ms.test_ignore
+++ b/modules/calcite/src/test/sql/types/timestamp/test_timestamp_ms.test
@@ -1,12 +1,11 @@
# name: test/sql/types/timestamp/test_timestamp_ms.test
# description: Test milliseconds with timestamp
# group: [timestamp]
-# Ignore https://issues.apache.org/jira/browse/IGNITE-15623
query TT
-SELECT CAST('2001-04-20 14:42:11.123' AS TIMESTAMP) a, CAST('2001-04-20
14:42:11.0' AS TIMESTAMP) b;
+SELECT CAST('2001-04-20 14:42:11.123' AS TIMESTAMP) a, CAST('2001-04-20
14:42:11.00' AS TIMESTAMP) b;
----
-2001-04-20 14:42:11.123 2001-04-20 14:42:11
+2001-04-20 14:42:11.123 2001-04-20 14:42:11.0
# many ms
query I
