This is an automated email from the ASF dual-hosted git repository.
korlov pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/ignite-3.git
The following commit(s) were added to refs/heads/main by this push:
new 3d41223c985 IGNITE-25091 Sql. Migrate to calcite's UUID (#5662)
3d41223c985 is described below
commit 3d41223c98531528e3a2d9bf3dd5341dd92de9ab
Author: korlov42 <[email protected]>
AuthorDate: Thu Apr 24 09:23:14 2025 +0300
IGNITE-25091 Sql. Migrate to calcite's UUID (#5662)
---
.../internal/sql/engine/ItImplicitCastsTest.java | 20 +--
.../sql/engine/datatypes/DataTypeTestSpecs.java | 11 +-
.../datatypes/tests/BaseDmlDataTypeTest.java | 11 ++
.../datatypes/tests/BaseQueryDataTypeTest.java | 11 ++
.../engine/datatypes/uuid/ItUuidAggregateTest.java | 4 +-
.../sql/engine/datatypes/uuid/ItUuidDmlTest.java | 4 +-
.../datatypes/uuid/ItUuidExpressionTest.java | 4 +-
.../sql/engine/datatypes/uuid/ItUuidIndexTest.java | 4 +-
.../sql/engine/datatypes/uuid/ItUuidJoinTest.java | 4 +-
.../sql/engine/datatypes/uuid/ItUuidQueryTest.java | 4 +-
.../sql/engine/datatypes/uuid/ItUuidSetOpTest.java | 4 +-
modules/sql-engine/src/main/codegen/config.fmpp | 2 +-
.../src/main/codegen/includes/parserImpls.ftl | 4 +-
.../sql/engine/exec/exp/ConverterUtils.java | 6 +
.../internal/sql/engine/exec/exp/RexImpTable.java | 5 +-
.../sql/engine/exec/exp/RexToLixTranslator.java | 11 ++
.../internal/sql/engine/externalize/RelJson.java | 8 +-
.../sql/engine/prepare/IgniteSqlValidator.java | 12 +-
.../sql/engine/prepare/IgniteTypeCoercion.java | 22 +++-
.../prepare/ddl/DdlSqlToCommandConverter.java | 47 ++++---
.../internal/sql/engine/rex/IgniteRexBuilder.java | 7 +
.../sql/engine/schema/TableDescriptorImpl.java | 14 --
.../sql/engine/sql/IgniteSqlColumnDeclaration.java | 144 ---------------------
.../internal/sql/engine/sql/IgniteSqlParser.java | 15 ---
.../sql/engine/sql/fun/IgniteSqlOperatorTable.java | 3 +-
.../sql/engine/type/IgniteTypeFactory.java | 92 +++++++------
.../ignite/internal/sql/engine/type/UuidType.java | 62 ---------
.../engine/util/IgniteCustomAssignmentsRules.java | 5 +
.../ignite/internal/sql/engine/util/TypeUtils.java | 21 +--
.../engine/exec/exp/ExpressionFactoryImplTest.java | 15 +--
.../sql/engine/planner/CastResolutionTest.java | 5 +-
.../sql/engine/planner/DmlPlannerTest.java | 6 +-
.../sql/engine/planner/DynamicParametersTest.java | 4 +-
.../pruning/PartitionPruningPredicateSelfTest.java | 4 +-
.../internal/sql/engine/sql/SqlDdlParserTest.java | 49 +++----
.../sql/engine/type/IgniteTypeFactorySelfTest.java | 61 ---------
.../internal/sql/engine/util/TypeUtilsTest.java | 4 +-
.../internal/sql/engine/util/SqlTestUtils.java | 27 +---
38 files changed, 243 insertions(+), 493 deletions(-)
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItImplicitCastsTest.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItImplicitCastsTest.java
index 0606d5e4ce7..2579a14ed93 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItImplicitCastsTest.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItImplicitCastsTest.java
@@ -30,9 +30,10 @@ import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.calcite.sql.type.SqlTypeUtil;
import org.apache.ignite.internal.sql.BaseSqlIntegrationTest;
import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.sql.engine.util.Commons;
+import org.apache.ignite.internal.sql.engine.util.SqlTestUtils;
import org.apache.ignite.lang.IgniteException;
+import org.apache.ignite.sql.ColumnType;
import org.apache.ignite.tx.Transaction;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
@@ -204,23 +205,14 @@ public class ItImplicitCastsTest extends
BaseSqlIntegrationTest {
static String generateValue(RelDataType type, int i, boolean literal) {
if (SqlTypeUtil.isNumeric(type)) {
return Integer.toString(i);
- } else if (type instanceof UuidType
- || type.getSqlTypeName() == SqlTypeName.CHAR
+ } else if (type.getSqlTypeName() == SqlTypeName.UUID) {
+ return SqlTestUtils.makeLiteral(new UUID(i, i),
ColumnType.UUID);
+ } else if (type.getSqlTypeName() == SqlTypeName.CHAR
|| type.getSqlTypeName() == SqlTypeName.VARCHAR) {
- // We need to generate valid UUID string so cast operations
won't fail at runtime.
- return generateUuid(i, literal);
+ return SqlTestUtils.makeLiteral(new UUID(i, i),
ColumnType.STRING);
} else {
throw new IllegalArgumentException("Unsupported type: " +
type);
}
}
-
- private static String generateUuid(int i, boolean literal) {
- UUID val = new UUID(i, i);
- if (!literal) {
- return val.toString();
- } else {
- return format("'{}'", val);
- }
- }
}
}
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/DataTypeTestSpecs.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/DataTypeTestSpecs.java
index a91c8af9deb..dd6d7830fbf 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/DataTypeTestSpecs.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/DataTypeTestSpecs.java
@@ -27,7 +27,6 @@ import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
import org.apache.ignite.internal.sql.engine.datatypes.tests.TestDataSamples;
import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.sql.engine.util.VarBinary;
import org.apache.ignite.sql.ColumnType;
@@ -37,24 +36,24 @@ import org.apache.ignite.sql.ColumnType;
public final class DataTypeTestSpecs {
/**
- * Test type spec for {@link UuidType UUID} data type.
+ * Test type spec for {@link SqlTypeName#UUID} data type.
*/
public static final DataTypeTestSpec<UUID> UUID_TYPE = new
DataTypeTestSpec<>(
- ColumnType.UUID, UuidType.NAME, UUID.class) {
+ ColumnType.UUID, ColumnType.UUID.name(), UUID.class) {
@Override
public boolean hasLiterals() {
- return false;
+ return true;
}
@Override
public String toLiteral(UUID value) {
- throw new UnsupportedOperationException();
+ return "uuid '" + value + "'";
}
@Override
public String toValueExpr(UUID value) {
- return format("'{}'::UUID", value);
+ return toLiteral(value);
}
@Override
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseDmlDataTypeTest.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseDmlDataTypeTest.java
index 60a0b1bbb0f..475b0e948f2 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseDmlDataTypeTest.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseDmlDataTypeTest.java
@@ -54,6 +54,17 @@ public abstract class BaseDmlDataTypeTest<T extends
Comparable<T>> extends BaseD
checkQuery("SELECT id FROM t").returns(2).returns(3).check();
}
+ @Test
+ public void testInsertDefaultLiteral() {
+ runSql("CREATE TABLE test_table (id INT PRIMARY KEY, val <type>
DEFAULT $0)");
+ runSql("INSERT INTO test_table(id) VALUES (0)");
+
+ assertQuery("SELECT val FROM test_table WHERE id = ?")
+ .withParam(0)
+ .returns(values.get(0))
+ .check();
+ }
+
/** {@code UPDATE} from a dynamic parameter. */
@Test
public void testUpdateFromDynamicParam() {
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseQueryDataTypeTest.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseQueryDataTypeTest.java
index be4146f43d1..deb6071fdcd 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseQueryDataTypeTest.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/tests/BaseQueryDataTypeTest.java
@@ -51,6 +51,17 @@ public abstract class BaseQueryDataTypeTest<T extends
Comparable<T>> extends Bas
.check();
}
+ @Test
+ public void testSelectLiteral() {
+ T expected = values.get(0);
+
+ String literal = testTypeSpec.toLiteral(expected);
+
+ checkQuery("SELECT " + literal)
+ .returns(expected)
+ .check();
+ }
+
/** Test for equality predicate. */
@ParameterizedTest
@MethodSource("eq")
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidAggregateTest.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidAggregateTest.java
index 3a97ed36626..5c4800ee0cb 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidAggregateTest.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidAggregateTest.java
@@ -18,13 +18,13 @@
package org.apache.ignite.internal.sql.engine.datatypes.uuid;
import java.util.UUID;
+import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs;
import
org.apache.ignite.internal.sql.engine.datatypes.tests.BaseAggregateDataTypeTest;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
/**
- * Tests for aggregates for {@link UuidType UUID data type}.
+ * Tests for aggregates for {@link SqlTypeName#UUID UUID data type}.
*/
public class ItUuidAggregateTest extends BaseAggregateDataTypeTest<UUID> {
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidDmlTest.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidDmlTest.java
index 922b49d3573..266bf15b383 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidDmlTest.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidDmlTest.java
@@ -18,13 +18,13 @@
package org.apache.ignite.internal.sql.engine.datatypes.uuid;
import java.util.UUID;
+import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs;
import
org.apache.ignite.internal.sql.engine.datatypes.tests.BaseDmlDataTypeTest;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
/**
- * Tests for DML statements for {@link UuidType UUID data type}.
+ * Tests for DML statements for {@link SqlTypeName#UUID UUID data type}.
*/
public class ItUuidDmlTest extends BaseDmlDataTypeTest<UUID> {
/** {@inheritDoc} **/
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidExpressionTest.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidExpressionTest.java
index 9310160d2ff..c90a4b81306 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidExpressionTest.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidExpressionTest.java
@@ -21,16 +21,16 @@ import static
org.apache.ignite.internal.lang.IgniteStringFormatter.format;
import static
org.apache.ignite.internal.sql.engine.util.SqlTestUtils.assertThrowsSqlException;
import java.util.UUID;
+import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs;
import
org.apache.ignite.internal.sql.engine.datatypes.tests.BaseExpressionDataTypeTest;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.lang.ErrorGroups.Sql;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
/**
- * Tests for expressions for {@link UuidType UUID data type}.
+ * Tests for expressions for {@link SqlTypeName#UUID UUID data type}.
*/
public class ItUuidExpressionTest extends BaseExpressionDataTypeTest<UUID> {
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidIndexTest.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidIndexTest.java
index 54a79041467..9aaa2639d72 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidIndexTest.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidIndexTest.java
@@ -18,13 +18,13 @@
package org.apache.ignite.internal.sql.engine.datatypes.uuid;
import java.util.UUID;
+import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs;
import
org.apache.ignite.internal.sql.engine.datatypes.tests.BaseIndexDataTypeTest;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
/**
- * Tests for queries that use indexes with {@link UuidType UUID data type}.
+ * Tests for queries that use indexes with {@link SqlTypeName#UUID UUID data
type}.
*/
public class ItUuidIndexTest extends BaseIndexDataTypeTest<UUID> {
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidJoinTest.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidJoinTest.java
index 1109be22b35..e9357b90e67 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidJoinTest.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidJoinTest.java
@@ -18,15 +18,15 @@
package org.apache.ignite.internal.sql.engine.datatypes.uuid;
import java.util.UUID;
+import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs;
import
org.apache.ignite.internal.sql.engine.datatypes.tests.BaseJoinDataTypeTest;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
/**
- * Tests for {@code JOIN} operator for {@link UuidType UUID data type}.
+ * Tests for {@code JOIN} operator for {@link SqlTypeName#UUID UUID data type}.
*/
public class ItUuidJoinTest extends BaseJoinDataTypeTest<UUID> {
/** {@inheritDoc} */
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidQueryTest.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidQueryTest.java
index 851471895e8..0f4574f5034 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidQueryTest.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidQueryTest.java
@@ -18,13 +18,13 @@
package org.apache.ignite.internal.sql.engine.datatypes.uuid;
import java.util.UUID;
+import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs;
import
org.apache.ignite.internal.sql.engine.datatypes.tests.BaseQueryDataTypeTest;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
/**
- * Tests for {@code SELECT} operations for {@link UuidType UUID data type}.
+ * Tests for {@code SELECT} operations for {@link SqlTypeName#UUID UUID data
type}.
*/
public class ItUuidQueryTest extends BaseQueryDataTypeTest<UUID> {
@Override
diff --git
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidSetOpTest.java
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidSetOpTest.java
index 3bd6fd5a69d..bd1519c2a05 100644
---
a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidSetOpTest.java
+++
b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/datatypes/uuid/ItUuidSetOpTest.java
@@ -18,13 +18,13 @@
package org.apache.ignite.internal.sql.engine.datatypes.uuid;
import java.util.UUID;
+import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.ignite.internal.sql.engine.datatypes.DataTypeTestSpecs;
import
org.apache.ignite.internal.sql.engine.datatypes.tests.BaseSetOpDataTypeTest;
import org.apache.ignite.internal.sql.engine.datatypes.tests.DataTypeTestSpec;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
/**
- * Tests for set operators for {@link UuidType UUID data type}.
+ * Tests for set operators for {@link SqlTypeName#UUID UUID data type}.
*/
public class ItUuidSetOpTest extends BaseSetOpDataTypeTest<UUID> {
diff --git a/modules/sql-engine/src/main/codegen/config.fmpp
b/modules/sql-engine/src/main/codegen/config.fmpp
index 10a70255e6e..42ba9ccb02c 100644
--- a/modules/sql-engine/src/main/codegen/config.fmpp
+++ b/modules/sql-engine/src/main/codegen/config.fmpp
@@ -33,8 +33,8 @@ data: {
"org.apache.calcite.sql.SqlDdl",
"org.apache.calcite.sql.SqlLiteral",
"org.apache.calcite.schema.ColumnStrategy",
+ "org.apache.calcite.sql.ddl.SqlDdlNodes",
"org.apache.ignite.internal.sql.engine.sql.IgniteSqlParserUtil",
- "org.apache.ignite.internal.sql.engine.sql.IgniteSqlColumnDeclaration",
"org.apache.ignite.internal.sql.engine.sql.IgniteSqlAlterTableAddColumn",
"org.apache.ignite.internal.sql.engine.sql.IgniteSqlAlterTableDropColumn",
"org.apache.ignite.internal.sql.engine.sql.IgniteSqlAlterColumn",
diff --git a/modules/sql-engine/src/main/codegen/includes/parserImpls.ftl
b/modules/sql-engine/src/main/codegen/includes/parserImpls.ftl
index c0d458f8525..982c258f97a 100644
--- a/modules/sql-engine/src/main/codegen/includes/parserImpls.ftl
+++ b/modules/sql-engine/src/main/codegen/includes/parserImpls.ftl
@@ -97,7 +97,7 @@ void TableElement(List<SqlNode> list) :
]
{
list.add(
- new IgniteSqlColumnDeclaration(s.add(id).end(this), id,
+ SqlDdlNodes.column(s.add(id).end(this), id,
type.withNullable(nullable), dflt, strategy));
}
|
@@ -411,7 +411,7 @@ SqlNode ColumnWithType() :
}
)
{
- return new IgniteSqlColumnDeclaration(s.add(id).end(this), id,
type.withNullable(nullable), dflt, strategy);
+ return SqlDdlNodes.column(s.add(id).end(this), id,
type.withNullable(nullable), dflt, strategy);
}
}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/ConverterUtils.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/ConverterUtils.java
index 85b2e72eeb2..2250b8e5d31 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/ConverterUtils.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/ConverterUtils.java
@@ -21,6 +21,7 @@ import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
+import java.util.UUID;
import org.apache.calcite.adapter.enumerable.EnumUtils;
import org.apache.calcite.adapter.enumerable.RexImpTable;
import org.apache.calcite.linq4j.tree.ConstantUntypedNull;
@@ -310,6 +311,11 @@ public class ConverterUtils {
}
}
+ // EnumUtils.convert lacks UUID handling, therefore we will WA on our
side.
+ if (toType == UUID.class && fromType == String.class) {
+ return Expressions.call(UUID.class, "fromString", operand);
+ }
+
var toCustomType = CustomTypesConversion.INSTANCE.tryConvert(operand,
toType);
return toCustomType != null ? toCustomType :
EnumUtils.convert(operand, toType);
}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/RexImpTable.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/RexImpTable.java
index 80941b9d234..30635a30d61 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/RexImpTable.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/RexImpTable.java
@@ -3402,7 +3402,10 @@ public class RexImpTable {
/** Returns whether any of a call's operands have ANY type. */
private static boolean anyAnyOperands(RexCall call) {
for (RexNode operand : call.operands) {
- if (operand.getType().getSqlTypeName() == SqlTypeName.ANY) {
+ // org.apache.calcite.runtime.SqlFunctions class lacks overrides for
UUID,
+ // but "*Any" counterparts handles UUID just fine, therefore let's
reuse
+ // these methods for UUID as well.
+ if (operand.getType().getSqlTypeName() == SqlTypeName.ANY ||
operand.getType().getSqlTypeName() == SqlTypeName.UUID) {
return true;
}
}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/RexToLixTranslator.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/RexToLixTranslator.java
index d4ad8f40567..705174bd5cf 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/RexToLixTranslator.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/exp/RexToLixTranslator.java
@@ -41,6 +41,7 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.UUID;
import java.util.function.Supplier;
import org.apache.calcite.DataContext;
import org.apache.calcite.adapter.enumerable.PhysType;
@@ -996,6 +997,16 @@ public class RexToLixTranslator implements
RexVisitor<RexToLixTranslator.Result>
() -> "getValueAs(Enum.class) for " + literal);
javaClass = value2.getClass();
break;
+ case UUID: {
+ UUID value = literal.getValueAs(UUID.class);
+
+ // Literal NULL is covered at the very beginning of this method.
+ assert value != null;
+
+ return Expressions.new_(
+ UUID.class, constant(value.getMostSignificantBits()),
constant(value.getLeastSignificantBits())
+ );
+ }
default:
final Primitive primitive = Primitive.ofBoxOr(javaClass);
final Comparable value = literal.getValueAs(Comparable.class);
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/externalize/RelJson.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/externalize/RelJson.java
index fa496c97bc4..604ecee8ae3 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/externalize/RelJson.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/externalize/RelJson.java
@@ -39,6 +39,7 @@ import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.UUID;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
@@ -264,7 +265,8 @@ class RelJson {
if (value == null
|| value instanceof Number
|| value instanceof String
- || value instanceof Boolean) {
+ || value instanceof Boolean
+ || value instanceof UUID) {
return value;
} else if (value instanceof Enum) {
return toJson((Enum) value);
@@ -897,6 +899,10 @@ class RelJson {
literal = toByteString(literal);
} else if (type.getSqlTypeName().getFamily() ==
SqlTypeFamily.TIMESTAMP && literal instanceof Integer) {
literal = ((Integer) literal).longValue();
+ } else if (type.getSqlTypeName() == SqlTypeName.UUID) {
+ assert literal instanceof String : literal;
+
+ literal = UUID.fromString((String) literal);
}
return rexBuilder.makeLiteral(literal, type, true);
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlValidator.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlValidator.java
index 12b748f6325..cd7dc32fd07 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlValidator.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteSqlValidator.java
@@ -79,7 +79,6 @@ import org.apache.calcite.sql.SqlTypeNameSpec;
import org.apache.calcite.sql.SqlUnknownLiteral;
import org.apache.calcite.sql.SqlUpdate;
import org.apache.calcite.sql.SqlUtil;
-import org.apache.calcite.sql.SqlUuidLiteral;
import org.apache.calcite.sql.SqlWithItem;
import org.apache.calcite.sql.dialect.CalciteSqlDialect;
import org.apache.calcite.sql.fun.SqlStdOperatorTable;
@@ -109,7 +108,6 @@ import
org.apache.ignite.internal.sql.engine.sql.fun.IgniteSqlOperatorTable;
import org.apache.ignite.internal.sql.engine.type.IgniteCustomType;
import
org.apache.ignite.internal.sql.engine.type.IgniteCustomTypeCoercionRules;
import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.sql.engine.util.Commons;
import org.apache.ignite.internal.sql.engine.util.IgniteCustomAssignmentsRules;
import org.apache.ignite.internal.sql.engine.util.IgniteResource;
@@ -585,9 +583,7 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
SqlLiteral resolved = super.resolveLiteral(literal);
SqlTypeName typeName = resolved.getTypeName();
- if (resolved instanceof SqlUuidLiteral) {
- throw newValidationError(resolved,
IgniteResource.INSTANCE.unsupportedExpression("UUID literal"));
- } else if (typeName == SqlTypeName.TIMESTAMP) {
+ if (typeName == SqlTypeName.TIMESTAMP) {
long ts =
resolved.getValueAs(TimestampString.class).getMillisSinceEpoch();
if (ts < IgniteSqlFunctions.TIMESTAMP_MIN_INTERNAL || ts >
IgniteSqlFunctions.TIMESTAMP_MAX_INTERNAL) {
@@ -985,7 +981,9 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
} else if (returnCustomType != null) {
check = coercionRules.needToCast(operandType, (IgniteCustomType)
returnCustomType);
} else {
- check = SqlTypeUtil.canCastFrom(returnType, operandType, true);
+ check = IgniteCustomAssignmentsRules.instance().canApplyFrom(
+ returnType.getSqlTypeName(), operandType.getSqlTypeName()
+ );
}
if (!check) {
@@ -1557,7 +1555,7 @@ public class IgniteSqlValidator extends SqlValidatorImpl {
case FLOAT: return typeFactory.createSqlType(SqlTypeName.REAL);
case DOUBLE: return typeFactory.createSqlType(SqlTypeName.DOUBLE);
case BOOLEAN: return
typeFactory.createSqlType(SqlTypeName.BOOLEAN);
- case UUID: return typeFactory().createCustomType(UuidType.NAME);
+ case UUID: return typeFactory.createSqlType(SqlTypeName.UUID);
case DATE: return typeFactory.createSqlType(SqlTypeName.DATE);
case TIME: return typeFactory.createSqlType(SqlTypeName.TIME);
case DATETIME: return
typeFactory.createSqlType(SqlTypeName.TIMESTAMP);
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteTypeCoercion.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteTypeCoercion.java
index 22820b3f198..02c63fa8e4d 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteTypeCoercion.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/IgniteTypeCoercion.java
@@ -36,6 +36,7 @@ import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.rel.type.RelDataTypeFactory;
import org.apache.calcite.rel.type.RelDataTypeFactoryImpl;
import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.sql.SqlBasicTypeNameSpec;
import org.apache.calcite.sql.SqlCall;
import org.apache.calcite.sql.SqlCallBinding;
import org.apache.calcite.sql.SqlCollation;
@@ -64,6 +65,7 @@ import org.apache.calcite.util.Util;
import org.apache.ignite.internal.sql.engine.type.IgniteCustomType;
import
org.apache.ignite.internal.sql.engine.type.IgniteCustomTypeCoercionRules;
import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
+import org.apache.ignite.internal.sql.engine.util.IgniteCustomAssignmentsRules;
import org.apache.ignite.internal.sql.engine.util.IgniteResource;
import org.apache.ignite.internal.sql.engine.util.TypeUtils;
import org.jetbrains.annotations.Nullable;
@@ -446,8 +448,11 @@ public class IgniteTypeCoercion extends TypeCoercionImpl {
return false;
}
- // No need to cast between binary types.
- if (SqlTypeUtil.isBinary(toType) && SqlTypeUtil.isBinary(fromType)) {
+ if (SqlTypeUtil.equalSansNullability(typeFactory, fromType, toType)) {
+ // Implicit type coercion does not handle nullability.
+ return false;
+ } else if (SqlTypeUtil.isBinary(toType) &&
SqlTypeUtil.isBinary(fromType)) {
+ // No need to cast between binary types.
return false;
} else if (SqlTypeUtil.isInterval(toType)) {
if (SqlTypeUtil.isInterval(fromType)) {
@@ -455,9 +460,6 @@ public class IgniteTypeCoercion extends TypeCoercionImpl {
return fromType.getSqlTypeName().getFamily() !=
toType.getSqlTypeName().getFamily();
}
} else if (SqlTypeUtil.isIntType(toType)) {
- if (fromType == null) {
- return false;
- }
// The following checks ensure that there no ClassCastException
when casting from one
// integer type to another (e.g. int to smallint, int to bigint)
if (SqlTypeUtil.isIntType(fromType) && fromType.getSqlTypeName()
!= toType.getSqlTypeName()) {
@@ -466,9 +468,13 @@ public class IgniteTypeCoercion extends TypeCoercionImpl {
} else if (toType.getSqlTypeName() == SqlTypeName.ANY ||
fromType.getSqlTypeName() == SqlTypeName.ANY) {
// IgniteCustomType: whether we need implicit cast from one type
to another.
return TypeUtils.customDataTypeNeedCast(typeFactory, fromType,
toType);
+ } else if (SqlTypeUtil.isNull(fromType)) {
+ // Need to cast NULL literal because type-checkers of built-in
function cannot properly handle explicit NULL
+ // since it belongs to a particular type family.
+ return true;
}
- return super.needToCast(scope, node, toType);
+ return
IgniteCustomAssignmentsRules.instance().canApplyFrom(toType.getSqlTypeName(),
fromType.getSqlTypeName());
}
/** {@inheritDoc} */
@@ -645,6 +651,10 @@ public class IgniteTypeCoercion extends TypeCoercionImpl {
var nameSpec = customType.createTypeNameSpec();
targetDataType = new SqlDataTypeSpec(nameSpec, SqlParserPos.ZERO);
+ } else if (type.getSqlTypeName() == SqlTypeName.UUID) {
+ targetDataType = new SqlDataTypeSpec(
+ new SqlBasicTypeNameSpec(SqlTypeName.UUID,
SqlParserPos.ZERO), null, type.isNullable(), SqlParserPos.ZERO
+ );
} else {
targetDataType =
SqlTypeUtil.convertTypeToSpec(type).withNullable(type.isNullable());
}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/ddl/DdlSqlToCommandConverter.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/ddl/DdlSqlToCommandConverter.java
index cd3ab93aea7..94319deb6a7 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/ddl/DdlSqlToCommandConverter.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/prepare/ddl/DdlSqlToCommandConverter.java
@@ -56,6 +56,7 @@ import java.util.stream.Collectors;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.runtime.CalciteContextException;
import org.apache.calcite.schema.ColumnStrategy;
+import org.apache.calcite.sql.SqlBasicTypeNameSpec;
import org.apache.calcite.sql.SqlCall;
import org.apache.calcite.sql.SqlCharStringLiteral;
import org.apache.calcite.sql.SqlDataTypeSpec;
@@ -69,6 +70,8 @@ import org.apache.calcite.sql.SqlLiteral;
import org.apache.calcite.sql.SqlNode;
import org.apache.calcite.sql.SqlNodeList;
import org.apache.calcite.sql.SqlNumericLiteral;
+import org.apache.calcite.sql.ddl.SqlColumnDeclaration;
+import org.apache.calcite.sql.ddl.SqlDdlNodes;
import org.apache.calcite.sql.parser.SqlParserPos;
import org.apache.calcite.sql.parser.SqlParserUtil;
import org.apache.calcite.sql.type.SqlTypeName;
@@ -119,7 +122,6 @@ import
org.apache.ignite.internal.sql.engine.sql.IgniteSqlAlterTableDropColumn;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlAlterZoneRenameTo;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlAlterZoneSet;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlAlterZoneSetDefault;
-import org.apache.ignite.internal.sql.engine.sql.IgniteSqlColumnDeclaration;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlCreateIndex;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlCreateSchema;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlCreateTable;
@@ -132,10 +134,8 @@ import
org.apache.ignite.internal.sql.engine.sql.IgniteSqlDropZone;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlIndexType;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlPrimaryKeyConstraint;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlPrimaryKeyIndexType;
-import org.apache.ignite.internal.sql.engine.sql.IgniteSqlTypeNameSpec;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlZoneOption;
import org.apache.ignite.internal.sql.engine.sql.IgniteSqlZoneOptionMode;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.sql.engine.util.Commons;
import org.apache.ignite.internal.type.NativeTypeSpec;
import org.apache.ignite.lang.IgniteException;
@@ -315,8 +315,8 @@ public class DdlSqlToCommandConverter {
.collect(Collectors.toList());
for (SqlNode sqlNode : createTblNode.columnList().getList()) {
- if (sqlNode instanceof IgniteSqlColumnDeclaration) {
- String colName = ((IgniteSqlColumnDeclaration)
sqlNode).name().getSimple();
+ if (sqlNode instanceof SqlColumnDeclaration) {
+ String colName = ((SqlColumnDeclaration)
sqlNode).name.getSimple();
if (IgniteSqlValidator.isSystemFieldName(colName)) {
throw new SqlException(STMT_VALIDATION_ERR, "Failed to
validate query. "
@@ -331,9 +331,8 @@ public class DdlSqlToCommandConverter {
pkConstraints.add(new
IgniteSqlPrimaryKeyConstraint(SqlParserPos.ZERO, null, SqlNodeList.of(colName),
IgniteSqlPrimaryKeyIndexType.IMPLICIT_HASH));
- SqlIdentifier uuidTypeName = new SqlIdentifier(UuidType.NAME,
SqlParserPos.ZERO);
- SqlDataTypeSpec type = new SqlDataTypeSpec(new
IgniteSqlTypeNameSpec(uuidTypeName, SqlParserPos.ZERO), SqlParserPos.ZERO);
- SqlNode col = new IgniteSqlColumnDeclaration(SqlParserPos.ZERO,
colName, type, null, ColumnStrategy.DEFAULT);
+ SqlDataTypeSpec type = new SqlDataTypeSpec(new
SqlBasicTypeNameSpec(SqlTypeName.UUID, SqlParserPos.ZERO), SqlParserPos.ZERO);
+ SqlNode col = SqlDdlNodes.column(SqlParserPos.ZERO, colName, type,
null, ColumnStrategy.DEFAULT);
createTblNode.columnList().add(0, col);
}
@@ -387,21 +386,21 @@ public class DdlSqlToCommandConverter {
.map(SqlIdentifier::getSimple)
.collect(Collectors.toList());
- List<IgniteSqlColumnDeclaration> colDeclarations =
createTblNode.columnList().getList().stream()
- .filter(IgniteSqlColumnDeclaration.class::isInstance)
- .map(IgniteSqlColumnDeclaration.class::cast)
+ List<SqlColumnDeclaration> colDeclarations =
createTblNode.columnList().getList().stream()
+ .filter(SqlColumnDeclaration.class::isInstance)
+ .map(SqlColumnDeclaration.class::cast)
.collect(Collectors.toList());
List<ColumnParams> columns = new ArrayList<>(colDeclarations.size());
- for (IgniteSqlColumnDeclaration col : colDeclarations) {
- if (!col.name().isSimple()) {
+ for (SqlColumnDeclaration col : colDeclarations) {
+ if (!col.name.isSimple()) {
throw new SqlException(STMT_VALIDATION_ERR, "Unexpected value
of columnName ["
- + "expected a simple identifier, but was " +
col.name() + "; "
+ + "expected a simple identifier, but was " + col.name
+ "; "
+ "querySql=\"" + ctx.query() + "\"]");
}
- columns.add(convertColumnDeclaration(col, ctx.planner(),
!pkColumns.contains(col.name().getSimple())));
+ columns.add(convertColumnDeclaration(col, ctx.planner(),
!pkColumns.contains(col.name.getSimple())));
}
String storageProfile = null;
@@ -425,14 +424,14 @@ public class DdlSqlToCommandConverter {
.build();
}
- private static ColumnParams
convertColumnDeclaration(IgniteSqlColumnDeclaration col, IgnitePlanner planner,
boolean nullable) {
- assert col.name().isSimple();
+ private static ColumnParams convertColumnDeclaration(SqlColumnDeclaration
col, IgnitePlanner planner, boolean nullable) {
+ assert col.name.isSimple();
- String name = col.name().getSimple();
+ String name = col.name.getSimple();
RelDataType relType;
try {
- relType = planner.convert(col.dataType(), nullable);
+ relType = planner.convert(col.dataType, nullable);
} catch (CalciteContextException e) {
String errorMessage = e.getMessage();
if (errorMessage == null) {
@@ -463,7 +462,7 @@ public class DdlSqlToCommandConverter {
.precision(typeParams.precision)
.scale(typeParams.scale)
.length(typeParams.length)
- .defaultValue(convertDefault(col.expression(), relType, name))
+ .defaultValue(convertDefault(col.expression, relType, name))
.build();
}
@@ -490,11 +489,11 @@ public class DdlSqlToCommandConverter {
List<ColumnParams> columns = new
ArrayList<>(alterTblNode.columns().size());
for (SqlNode colNode : alterTblNode.columns()) {
- assert colNode instanceof IgniteSqlColumnDeclaration :
colNode.getClass();
- IgniteSqlColumnDeclaration col = (IgniteSqlColumnDeclaration)
colNode;
- Boolean nullable = col.dataType().getNullable();
+ assert colNode instanceof SqlColumnDeclaration :
colNode.getClass();
+ SqlColumnDeclaration col = (SqlColumnDeclaration) colNode;
+ Boolean nullable = col.dataType.getNullable();
- String colName = col.name().getSimple();
+ String colName = col.name.getSimple();
if (IgniteSqlValidator.isSystemFieldName(colName)) {
throw new SqlException(STMT_VALIDATION_ERR, "Failed to
validate query. "
+ "Column '" + colName + "' is reserved name.");
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rex/IgniteRexBuilder.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rex/IgniteRexBuilder.java
index 293f13273f7..c73c42a758c 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rex/IgniteRexBuilder.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/rex/IgniteRexBuilder.java
@@ -17,6 +17,7 @@
package org.apache.ignite.internal.sql.engine.rex;
+import java.util.UUID;
import org.apache.calcite.avatica.util.ByteString;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.rel.type.RelDataTypeFactory;
@@ -89,6 +90,12 @@ public class IgniteRexBuilder extends RexBuilder {
}
}
+ if (value instanceof UUID && type.getSqlTypeName() ==
SqlTypeName.UUID) {
+ // Generic super.makeLiteral() lacks handling of UUID type,
therefore we will
+ // WA this on our side.
+ return makeUuidLiteral((UUID) value);
+ }
+
return super.makeLiteral(value, type, allowCast, trim);
}
}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/TableDescriptorImpl.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/TableDescriptorImpl.java
index cbd44c0126f..afa3c83b48f 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/TableDescriptorImpl.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/schema/TableDescriptorImpl.java
@@ -24,7 +24,6 @@ import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
-import java.util.UUID;
import org.apache.calcite.plan.RelOptTable;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.rel.type.RelDataTypeFactory;
@@ -32,14 +31,12 @@ import
org.apache.calcite.rel.type.RelDataTypeFactory.Builder;
import org.apache.calcite.rel.type.RelDataTypeField;
import org.apache.calcite.rex.RexNode;
import org.apache.calcite.schema.ColumnStrategy;
-import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.calcite.sql2rel.InitializerContext;
import org.apache.calcite.sql2rel.NullInitializerExpressionFactory;
import org.apache.calcite.util.ImmutableBitSet;
import org.apache.ignite.internal.sql.engine.sql.fun.IgniteSqlOperatorTable;
import org.apache.ignite.internal.sql.engine.trait.IgniteDistribution;
import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.sql.engine.util.Commons;
import org.apache.ignite.internal.sql.engine.util.TypeUtils;
import org.apache.ignite.internal.type.NativeType;
@@ -136,17 +133,6 @@ public class TableDescriptorImpl extends
NullInitializerExpressionFactory implem
Object internalValue = defaultVal == null ? defaultVal :
TypeUtils.toInternal(defaultVal, nativeType.spec());
RelDataType relDataType =
deriveLogicalType(rexBuilder.getTypeFactory(), descriptor);
- // UUID literals are not supported, so we replace it with
CAST(uuid.toString() AS UUID)
- if (internalValue != null && relDataType instanceof UuidType) {
- assert internalValue instanceof UUID;
-
- RelDataType charType =
rexBuilder.getTypeFactory().createSqlType(SqlTypeName.VARCHAR);
-
- RexNode literal =
rexBuilder.makeLiteral(internalValue.toString(), charType, false);
-
- return rexBuilder.makeCast(relDataType, literal);
- }
-
return rexBuilder.makeLiteral(internalValue, relDataType,
false);
}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/IgniteSqlColumnDeclaration.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/IgniteSqlColumnDeclaration.java
deleted file mode 100644
index 77b8dd1846b..00000000000
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/IgniteSqlColumnDeclaration.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.sql.engine.sql;
-
-import java.util.Arrays;
-import java.util.List;
-import org.apache.calcite.schema.ColumnStrategy;
-import org.apache.calcite.sql.SqlCall;
-import org.apache.calcite.sql.SqlDataTypeSpec;
-import org.apache.calcite.sql.SqlIdentifier;
-import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.SqlLiteral;
-import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlWriter;
-import org.apache.calcite.sql.ddl.SqlDdlNodes;
-import org.apache.calcite.sql.parser.SqlParserPos;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * Creates a SqlColumnDeclaration. Should be used instead of {@link
SqlDdlNodes#column} because it supports cloning.
- */
-public class IgniteSqlColumnDeclaration extends SqlCall {
- /** Column declaration operator. */
- protected static class Operator extends IgniteSqlSpecialOperator {
-
- private final ColumnStrategy columnStrategy;
-
- /** Constructor. */
- protected Operator(ColumnStrategy columnStrategy) {
- super("COLUMN_DECL", SqlKind.COLUMN_DECL);
- this.columnStrategy = columnStrategy;
- }
-
- /** {@inheritDoc} */
- @Override
- public SqlCall createCall(@Nullable SqlLiteral name, SqlParserPos pos,
@Nullable SqlNode... operands) {
- SqlIdentifier id = (SqlIdentifier) operands[0];
- SqlDataTypeSpec dataType = (SqlDataTypeSpec) operands[1];
- SqlNode expression = operands.length > 2 ? operands[2] : null;
-
- return new IgniteSqlColumnDeclaration(pos, id, dataType,
expression, columnStrategy);
- }
- }
-
- private final Operator operator;
- private final SqlIdentifier name;
- private final SqlDataTypeSpec dataType;
- private final @Nullable SqlNode expression;
- private final ColumnStrategy strategy;
-
- /** Constructor. */
- public IgniteSqlColumnDeclaration(SqlParserPos pos, SqlIdentifier name,
- SqlDataTypeSpec dataType, @Nullable SqlNode expression,
- ColumnStrategy strategy) {
- super(pos);
-
- this.operator = new Operator(strategy);
- this.name = name;
- this.dataType = dataType;
- this.expression = expression;
- this.strategy = strategy;
- }
-
- /** {@inheritDoc} */
- @Override
- public SqlOperator getOperator() {
- return operator;
- }
-
- /** {@inheritDoc} */
- @Override
- public List<SqlNode> getOperandList() {
- return Arrays.asList(name, dataType, expression);
- }
-
- public SqlIdentifier name() {
- return name;
- }
-
- public SqlDataTypeSpec dataType() {
- return dataType;
- }
-
- public @Nullable SqlNode expression() {
- return expression;
- }
-
- public ColumnStrategy strategy() {
- return strategy;
- }
-
- /** {@inheritDoc} */
- @Override
- public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
- name.unparse(writer, 0, 0);
- dataType.unparse(writer, 0, 0);
- if (Boolean.FALSE.equals(dataType.getNullable())) {
- writer.keyword("NOT NULL");
- }
- SqlNode expression = this.expression;
- if (expression != null) {
- switch (strategy) {
- case VIRTUAL:
- case STORED:
- writer.keyword("AS");
- exp(writer, expression);
- writer.keyword(strategy.name());
- break;
- case DEFAULT:
- writer.keyword("DEFAULT");
- exp(writer, expression);
- break;
- default:
- throw new AssertionError("unexpected: " + strategy);
- }
- }
- }
-
- private static void exp(SqlWriter writer, SqlNode expression) {
- if (writer.isAlwaysUseParentheses()) {
- expression.unparse(writer, 0, 0);
- } else {
- writer.sep("(");
- expression.unparse(writer, 0, 0);
- writer.sep(")");
- }
- }
-}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/IgniteSqlParser.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/IgniteSqlParser.java
index 25f91315f38..26c95cf48ff 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/IgniteSqlParser.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/IgniteSqlParser.java
@@ -27,7 +27,6 @@ import java.util.List;
import java.util.Map;
import org.apache.calcite.config.Lex;
import org.apache.calcite.sql.SqlBasicCall;
-import org.apache.calcite.sql.SqlBasicTypeNameSpec;
import org.apache.calcite.sql.SqlCall;
import org.apache.calcite.sql.SqlCollectionTypeNameSpec;
import org.apache.calcite.sql.SqlDataTypeSpec;
@@ -54,7 +53,6 @@ import
org.apache.ignite.internal.generated.query.calcite.sql.ParseException;
import org.apache.ignite.internal.generated.query.calcite.sql.Token;
import org.apache.ignite.internal.generated.query.calcite.sql.TokenMgrError;
import org.apache.ignite.internal.sql.engine.sql.fun.IgniteSqlOperatorTable;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.sql.engine.util.Commons;
import org.apache.ignite.internal.sql.engine.util.IgniteResource;
import org.apache.ignite.internal.util.StringUtils;
@@ -362,19 +360,6 @@ public final class IgniteSqlParser {
public @Nullable SqlNode visit(SqlDataTypeSpec type) {
this.visit(type.getTypeName());
- // Replace calcite's UUID with IgniteCustomDataType UUID because
calcite's UUID is not usable until
- // calcite's runtime expression engine supports it.
- if (type.getTypeNameSpec() instanceof SqlBasicTypeNameSpec) {
- SqlBasicTypeNameSpec basicTypeNameSpec =
(SqlBasicTypeNameSpec) type.getTypeNameSpec();
-
- if (basicTypeNameSpec.getTypeName().isSimple() &&
basicTypeNameSpec.getTypeName().getSimple().equals(UuidType.NAME)) {
- SqlIdentifier typeName = new SqlIdentifier(UuidType.NAME,
basicTypeNameSpec.getParserPos());
- IgniteSqlTypeNameSpec uuidTypeNameSpec = new
IgniteSqlTypeNameSpec(typeName, basicTypeNameSpec.getParserPos());
-
- return new SqlDataTypeSpec(uuidTypeNameSpec, null,
type.getNullable(), type.getParserPosition());
- }
- }
-
// getComponentTypeSpec throws AssertionError if typeNameSpec is
not an instance of CollectionTypeNameSpec.
if (type.getTypeNameSpec() instanceof SqlCollectionTypeNameSpec) {
SqlDataTypeSpec componentTypeSpec =
type.getComponentTypeSpec();
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/fun/IgniteSqlOperatorTable.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/fun/IgniteSqlOperatorTable.java
index 17060d10faf..36e3b4906f8 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/fun/IgniteSqlOperatorTable.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/fun/IgniteSqlOperatorTable.java
@@ -46,7 +46,6 @@ import org.apache.calcite.sql.type.SqlTypeTransforms;
import org.apache.calcite.sql.type.SqlTypeUtil;
import org.apache.calcite.sql.util.ReflectiveSqlOperatorTable;
import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.sql.engine.util.Commons;
import org.apache.ignite.internal.sql.engine.util.TypeUtils;
import org.checkerframework.checker.nullness.qual.Nullable;
@@ -151,7 +150,7 @@ public class IgniteSqlOperatorTable extends
ReflectiveSqlOperatorTable {
new SqlFunction(
"RAND_UUID",
SqlKind.OTHER_FUNCTION,
- ReturnTypes.explicit(new UuidType(false)),
+ ReturnTypes.explicit(SqlTypeName.UUID),
null,
OperandTypes.NILADIC,
SqlFunctionCategory.SYSTEM
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/type/IgniteTypeFactory.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/type/IgniteTypeFactory.java
index e086749caa9..1b7cf455f8b 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/type/IgniteTypeFactory.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/type/IgniteTypeFactory.java
@@ -41,6 +41,7 @@ import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;
+import java.util.UUID;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import org.apache.calcite.avatica.util.ByteString;
@@ -56,6 +57,7 @@ import org.apache.calcite.sql.type.IntervalSqlType;
import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.calcite.sql.type.SqlTypeUtil;
import org.apache.ignite.internal.sql.engine.util.Commons;
+import org.apache.ignite.internal.sql.engine.util.IgniteCustomAssignmentsRules;
import org.apache.ignite.internal.type.NativeType;
import org.apache.ignite.internal.type.NativeTypes;
import org.jetbrains.annotations.Nullable;
@@ -114,22 +116,7 @@ public class IgniteTypeFactory extends JavaTypeFactoryImpl
{
charset = StandardCharsets.UTF_8;
}
- // IgniteCustomType: all custom data types are registered here
- NewCustomType uuidType = new NewCustomType(UuidType.SPEC, (nullable,
precision) -> new UuidType(nullable));
- // UUID type can be converted from character types.
- uuidType.addCoercionRules(SqlTypeName.CHAR_TYPES);
-
- customDataTypes = new CustomDataTypes(Set.of(uuidType));
- }
-
- /** {@inheritDoc} */
- @Override
- public RelDataType createSqlType(SqlTypeName typeName) {
- if (typeName == SqlTypeName.UUID) {
- return createCustomType(UuidType.NAME);
- } else {
- return super.createSqlType(typeName);
- }
+ customDataTypes = new CustomDataTypes(Set.of());
}
/** {@inheritDoc} */
@@ -243,6 +230,8 @@ public class IgniteTypeFactory extends JavaTypeFactoryImpl {
return Object.class;
case NULL:
return Void.class;
+ case UUID:
+ return UUID.class;
default:
break;
}
@@ -327,6 +316,8 @@ public class IgniteTypeFactory extends JavaTypeFactoryImpl {
return relType.getPrecision() == PRECISION_NOT_SPECIFIED
? NativeTypes.blobOf(DEFAULT_VARLEN_LENGTH)
: NativeTypes.blobOf(relType.getPrecision());
+ case UUID:
+ return NativeTypes.UUID;
case ANY:
if (relType instanceof IgniteCustomType) {
var customType = (IgniteCustomType) relType;
@@ -446,28 +437,10 @@ public class IgniteTypeFactory extends
JavaTypeFactoryImpl {
return first(types);
}
- RelDataType resultType = super.leastRestrictive(types);
-
- if (resultType == null) {
- return null;
- }
-
- if (resultType.getSqlTypeName() != SqlTypeName.ANY) {
- // leastRestrictive defined by calcite returns leas restrictive
even among types of different families.
- // We need to trim such variants.
- if (!typeFamiliesAreCompatible(this, types)) {
- return null;
- }
-
- return resultType;
- }
-
- // leastRestrictive defined by calcite returns an instance of
BasicSqlType that represents an ANY type,
- // when at least one of its arguments have sqlTypeName = ANY.
- assert resultType instanceof BasicSqlType : "leastRestrictive is
expected to return a new instance of a type: " + resultType;
-
IgniteCustomType firstCustomType = null;
boolean hasAnyType = false;
+ boolean hasNullOrNullable = false;
+ boolean hasUuidType = false;
boolean hasBuiltInType = false;
boolean hasNullable = false;
IgniteCustomType firstNullable = null;
@@ -476,9 +449,14 @@ public class IgniteTypeFactory extends JavaTypeFactoryImpl
{
SqlTypeName sqlTypeName = type.getSqlTypeName();
// NULL types should be ignored when we are trying to determine
the least restrictive type.
if (sqlTypeName == SqlTypeName.NULL) {
+ hasNullOrNullable = true;
continue;
}
+ if (type.isNullable()) {
+ hasNullOrNullable = true;
+ }
+
if (type instanceof IgniteCustomType) {
if (firstCustomType == null) {
firstCustomType = (IgniteCustomType) type;
@@ -498,10 +476,50 @@ public class IgniteTypeFactory extends
JavaTypeFactoryImpl {
} else if (sqlTypeName == SqlTypeName.ANY) {
hasAnyType = true;
} else {
+ if (sqlTypeName == SqlTypeName.UUID) {
+ hasUuidType = true;
+ }
+
hasBuiltInType = true;
}
}
+ // Calcite's implementation of TypeFactory cannot derive least
restrictive type between UUID and NULL.
+ if (hasUuidType) {
+ // UUID doesn't have any other types in the family, therefore it's
safe to assume if all types are compatible,
+ // then there are either UUID or NULL types.
+ if (!typeFamiliesAreCompatible(this, types)) {
+ return null;
+ }
+
+ RelDataType returnType = createSqlType(SqlTypeName.UUID);
+ if (hasNullOrNullable) {
+ returnType = createTypeWithNullability(returnType, true);
+ }
+
+ return returnType;
+ }
+
+ RelDataType resultType = leastRestrictive(types,
IgniteCustomAssignmentsRules.instance());
+
+ if (resultType == null) {
+ return null;
+ }
+
+ if (resultType.getSqlTypeName() != SqlTypeName.ANY) {
+ // leastRestrictive defined by calcite returns least restrictive
even among types of different families.
+ // We need to trim such variants.
+ if (!typeFamiliesAreCompatible(this, types)) {
+ return null;
+ }
+
+ return resultType;
+ }
+
+ // leastRestrictive defined by calcite returns an instance of
BasicSqlType that represents an ANY type,
+ // when at least one of its arguments have sqlTypeName = ANY.
+ assert resultType instanceof BasicSqlType : "leastRestrictive is
expected to return a new instance of a type: " + resultType;
+
if (hasAnyType && hasBuiltInType && firstCustomType != null) {
// There is no least restrictive type between ANY, built-in type,
and a custom data type.
return null;
@@ -558,8 +576,6 @@ public class IgniteTypeFactory extends JavaTypeFactoryImpl {
public RelDataType createTypeWithNullability(RelDataType type, boolean
nullable) {
if (type instanceof IgniteCustomType) {
return canonize(((IgniteCustomType)
type).createWithNullability(nullable));
- } else if (type.getSqlTypeName() == SqlTypeName.UUID) {
- return
canonize(createCustomType(UuidType.NAME).createWithNullability(nullable));
} else {
return super.createTypeWithNullability(type, nullable);
}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/type/UuidType.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/type/UuidType.java
deleted file mode 100644
index 83b1503aa40..00000000000
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/type/UuidType.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.sql.engine.type;
-
-import java.util.UUID;
-import org.apache.ignite.internal.type.NativeTypes;
-import org.apache.ignite.sql.ColumnType;
-
-/** UUID SQL type. */
-public final class UuidType extends IgniteCustomType {
-
- /** A string name of this type: {@code UUID}. **/
- public static final String NAME = "UUID";
-
- /** Type spec of this type. **/
- public static final IgniteCustomTypeSpec SPEC = new
IgniteCustomTypeSpec(NAME, NativeTypes.UUID,
- ColumnType.UUID, UUID.class,
IgniteCustomTypeSpec.getCastFunction(UuidType.class, "cast"));
-
- /** Constructor. */
- public UuidType(boolean nullable) {
- super(SPEC, nullable, PRECISION_NOT_SPECIFIED);
- }
-
- /** {@inheritDoc} */
- @Override protected void generateTypeString(StringBuilder sb, boolean
withDetail) {
- sb.append(NAME);
- }
-
- /** {@inheritDoc} */
- @Override
- public UuidType createWithNullability(boolean nullable) {
- return new UuidType(nullable);
- }
-
- /**
- * Implementation of a cast function for {@code UUID} data type.
- */
- public static UUID cast(Object value) {
- // It would be better to generate Expression tree that is equivalent
to the code below
- // from type checking rules for this type in order to avoid code
duplication.
- if (value instanceof String) {
- return UUID.fromString((String) value);
- } else {
- return (UUID) value;
- }
- }
-}
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/IgniteCustomAssignmentsRules.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/IgniteCustomAssignmentsRules.java
index 833c897fde7..7e33a746934 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/IgniteCustomAssignmentsRules.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/IgniteCustomAssignmentsRules.java
@@ -130,10 +130,14 @@ public class IgniteCustomAssignmentsRules implements
SqlTypeMappingRule {
rule.add(SqlTypeName.TIME);
rule.add(SqlTypeName.TIMESTAMP);
rule.add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
+ rule.add(SqlTypeName.UUID);
rules.add(SqlTypeName.CHAR, rule);
rules.add(SqlTypeName.VARCHAR, rule);
+ // UUID is assignable from...
+ rules.add(SqlTypeName.UUID, EnumSet.of(SqlTypeName.UUID,
SqlTypeName.CHAR, SqlTypeName.VARCHAR));
+
// BOOLEAN is assignable from...
rules.add(SqlTypeName.BOOLEAN, EnumSet.of(SqlTypeName.BOOLEAN,
SqlTypeName.CHAR, SqlTypeName.VARCHAR));
@@ -243,6 +247,7 @@ public class IgniteCustomAssignmentsRules implements
SqlTypeMappingRule {
rule.add(SqlTypeName.DATE);
rule.add(SqlTypeName.TIMESTAMP);
rule.add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
+ rule.add(SqlTypeName.UUID);
rules.add(SqlTypeName.ANY, rule);
INSTANCE = new IgniteCustomAssignmentsRules(rules.map);
diff --git
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/TypeUtils.java
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/TypeUtils.java
index bc06f8356da..9583221959d 100644
---
a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/TypeUtils.java
+++
b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/TypeUtils.java
@@ -69,7 +69,6 @@ import
org.apache.ignite.internal.sql.engine.exec.row.TypeSpec;
import org.apache.ignite.internal.sql.engine.type.IgniteCustomType;
import
org.apache.ignite.internal.sql.engine.type.IgniteCustomTypeCoercionRules;
import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.type.DecimalNativeType;
import org.apache.ignite.internal.type.NativeType;
import org.apache.ignite.internal.type.NativeTypeSpec;
@@ -497,6 +496,8 @@ public class TypeUtils {
return ColumnType.DURATION;
case NULL:
return ColumnType.NULL;
+ case UUID:
+ return ColumnType.UUID;
default:
throw new IllegalArgumentException("Unexpected type: " +
type.getSqlTypeName());
}
@@ -532,8 +533,7 @@ public class TypeUtils {
return factory.createSqlType(SqlTypeName.DECIMAL,
decimal.precision(), decimal.scale());
case UUID:
- IgniteTypeFactory concreteTypeFactory = (IgniteTypeFactory)
factory;
- return concreteTypeFactory.createCustomType(UuidType.NAME);
+ return factory.createSqlType(SqlTypeName.UUID);
case STRING: {
assert nativeType instanceof VarlenNativeType;
@@ -964,18 +964,9 @@ public class TypeUtils {
*/
// TODO this method can be removed after
https://issues.apache.org/jira/browse/IGNITE-22295
public static boolean typesRepresentTheSameColumnTypes(RelDataType lhs,
RelDataType rhs) {
- // IgniteCustomType: check for custom data type, otherwise this
expression can fail when type is converted into column type.
- if (isCustomType(lhs) && isCustomType(rhs) ||
SqlTypeUtil.isAtomic(lhs) && SqlTypeUtil.isAtomic(rhs)) {
- ColumnType col1 = columnType(lhs);
- ColumnType col2 = columnType(rhs);
-
- return col1 == col2;
- } else {
- return false;
- }
- }
+ ColumnType col1 = columnType(lhs);
+ ColumnType col2 = columnType(rhs);
- private static boolean isCustomType(RelDataType type) {
- return type instanceof IgniteCustomType;
+ return col1 == col2;
}
}
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/exp/ExpressionFactoryImplTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/exp/ExpressionFactoryImplTest.java
index a5794385abf..2d29760760e 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/exp/ExpressionFactoryImplTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/exp/ExpressionFactoryImplTest.java
@@ -726,19 +726,17 @@ public class ExpressionFactoryImplTest extends
BaseIgniteAbstractTest {
* </ul>
*
* @param columnType Column type.
- * @param literalsOnly Flag indicating that the list of input expressions
should contain only literals.
*/
@ParameterizedTest(name = "type={0}, literals={1}")
@MethodSource("rowSourceTestArgs")
- public void testRowSource(ColumnType columnType, boolean literalsOnly) {
+ public void testRowSource(ColumnType columnType) {
Object val =
SqlTestUtils.generateValueByTypeWithMaxScalePrecisionForSql(columnType);
- RexNode expr1 = SqlTestUtils.generateLiteralOrValueExpr(columnType,
val);
+ RexNode expr1 = SqlTestUtils.generateLiteral(columnType, val);
assertInstanceOf(RexLiteral.class, expr1);
- Object val2 = literalsOnly ? 1 : randomUUID();
- RexNode expr2 = SqlTestUtils.generateLiteralOrValueExpr(literalsOnly ?
ColumnType.INT32 : ColumnType.UUID, val2);
- assertEquals(literalsOnly, expr2 instanceof RexLiteral);
+ Object val2 = randomUUID();
+ RexNode expr2 = SqlTestUtils.generateLiteral(ColumnType.UUID, val2);
ExpressionFactoryImpl<Object[]> expFactorySpy =
Mockito.spy(expFactory);
@@ -877,8 +875,6 @@ public class ExpressionFactoryImplTest extends
BaseIgniteAbstractTest {
private static List<Arguments> rowSourceTestArgs() {
EnumSet<ColumnType> ignoredTypes = EnumSet.of(
- // UUID literal doesn't exists.
- ColumnType.UUID,
// TODO https://issues.apache.org/jira/browse/IGNITE-17373
ColumnType.DURATION,
ColumnType.PERIOD
@@ -891,8 +887,7 @@ public class ExpressionFactoryImplTest extends
BaseIgniteAbstractTest {
continue;
}
- arguments.add(Arguments.of(columnType, true));
- arguments.add(Arguments.of(columnType, false));
+ arguments.add(Arguments.of(columnType));
}
return arguments;
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/CastResolutionTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/CastResolutionTest.java
index 2f8514b3abb..34f390bc6cd 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/CastResolutionTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/CastResolutionTest.java
@@ -50,7 +50,6 @@ import java.util.stream.Stream;
import org.apache.calcite.sql.type.SqlTypeCoercionRule;
import org.apache.calcite.sql.type.SqlTypeMappingRule;
import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.sql.engine.util.IgniteCustomAssignmentsRules;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;
@@ -108,7 +107,7 @@ public class CastResolutionTest extends AbstractPlannerTest
{
ALL_BESIDES_BINARY_NAMES.addAll(YM_INTERVAL);
ALL_BESIDES_BINARY_NAMES.addAll(DAY_INTERVAL);
ALL_BESIDES_BINARY_NAMES.add("NUMERIC");
- ALL_BESIDES_BINARY_NAMES.add(UuidType.NAME);
+ ALL_BESIDES_BINARY_NAMES.add(SqlTypeName.UUID.getName());
CHAR_NUMERIC_AND_INTERVAL_NAMES.addAll(NUMERIC_NAMES);
CHAR_NUMERIC_AND_INTERVAL_NAMES.addAll(CHAR_NAMES);
@@ -333,7 +332,7 @@ public class CastResolutionTest extends AbstractPlannerTest
{
NUMERIC("NUMERIC", CHAR_NUMERIC_AND_INTERVAL_NAMES),
- UUID(UuidType.NAME, new HashSet<>(CHAR_NAMES)),
+ UUID(SqlTypeName.UUID.getName(), new HashSet<>(CHAR_NAMES)),
VARCHAR(SqlTypeName.VARCHAR.getName(), ALL_BESIDES_BINARY_NAMES),
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/DmlPlannerTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/DmlPlannerTest.java
index 62fa935a32b..006d5238b35 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/DmlPlannerTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/DmlPlannerTest.java
@@ -17,6 +17,8 @@
package org.apache.ignite.internal.sql.engine.planner;
+import static org.apache.ignite.internal.sql.engine.util.Commons.cast;
+
import java.util.List;
import java.util.UUID;
import java.util.function.Predicate;
@@ -297,6 +299,8 @@ public class DmlPlannerTest extends AbstractPlannerTest {
kvModifyNodeWithExpressionsOfExpectedTypes
);
+ Predicate<IgniteValues> valuesNodeWithProjectionsOfExpectedTypes =
isInstanceOf(IgniteValues.class)
+ .and(project ->
expressionsAsOfExpectedType.test(cast(project.getTuples().get(0))));
Predicate<IgniteProject> projectNodeWithProjectionsOfExpectedTypes =
isInstanceOf(IgniteProject.class)
.and(project ->
expressionsAsOfExpectedType.test(project.getProjects()));
@@ -305,7 +309,7 @@ public class DmlPlannerTest extends AbstractPlannerTest {
schema,
hasChildThat(
isInstanceOf(IgniteUnionAll.class)
- .and(input(0,
projectNodeWithProjectionsOfExpectedTypes))
+ .and(input(0,
valuesNodeWithProjectionsOfExpectedTypes))
.and(input(1,
projectNodeWithProjectionsOfExpectedTypes))
)
);
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/DynamicParametersTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/DynamicParametersTest.java
index 5987580fe7d..caa2a88c4a4 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/DynamicParametersTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/planner/DynamicParametersTest.java
@@ -880,12 +880,12 @@ public class DynamicParametersTest extends
AbstractPlannerTest {
checkStatement()
.sql("SELECT COALESCE(?, 'UUID'::UUID)", new UUID(0,
0))
.parameterTypes(nullable(NativeTypes.UUID))
- .project("CASE(IS NOT NULL(?0), ?0,
CAST(_UTF-8'UUID'):UUID NOT NULL)"),
+ .project("CASE(IS NOT NULL(?0), CAST(?0):UUID NOT
NULL, CAST(_UTF-8'UUID'):UUID NOT NULL)"),
checkStatement()
.sql("SELECT NULLIF(?, 'UUID'::UUID)", new UUID(0, 0))
.parameterTypes(nullable(NativeTypes.UUID))
- .project("CASE(=(?0, CAST(_UTF-8'UUID'):UUID NOT
NULL), null:NULL, ?0)"),
+ .project("CASE(=(?0, CAST(_UTF-8'UUID'):UUID NOT
NULL), null:UUID, ?0)"),
// Set operations
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/pruning/PartitionPruningPredicateSelfTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/pruning/PartitionPruningPredicateSelfTest.java
index 3f54c5f7129..f8e98f05b1d 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/pruning/PartitionPruningPredicateSelfTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/prepare/pruning/PartitionPruningPredicateSelfTest.java
@@ -18,7 +18,7 @@
package org.apache.ignite.internal.sql.engine.prepare.pruning;
import static java.util.UUID.randomUUID;
-import static
org.apache.ignite.internal.sql.engine.util.SqlTestUtils.generateLiteralOrValueExpr;
+import static
org.apache.ignite.internal.sql.engine.util.SqlTestUtils.generateLiteral;
import static org.junit.jupiter.api.Assertions.assertEquals;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
@@ -106,7 +106,7 @@ public class PartitionPruningPredicateSelfTest extends
BaseIgniteAbstractTest {
int fieldIndex = 0;
Object val = generateFieldValue(table, fieldIndex);
- RexNode expr = generateLiteralOrValueExpr(columnType, val);
+ RexNode expr = generateLiteral(columnType, val);
PartitionPruningColumns columns = new
PartitionPruningColumns(List.of(Int2ObjectMaps.singleton(fieldIndex, expr)));
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/sql/SqlDdlParserTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/sql/SqlDdlParserTest.java
index fedc9f56352..378020473e7 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/sql/SqlDdlParserTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/sql/SqlDdlParserTest.java
@@ -44,6 +44,7 @@ import org.apache.calcite.sql.SqlLiteral;
import org.apache.calcite.sql.SqlNode;
import org.apache.calcite.sql.SqlNumericLiteral;
import org.apache.calcite.sql.SqlUnknownLiteral;
+import org.apache.calcite.sql.ddl.SqlColumnDeclaration;
import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.ignite.lang.ErrorGroups.Sql;
import org.hamcrest.CustomMatcher;
@@ -99,10 +100,10 @@ public class SqlDdlParserTest extends AbstractParserTest {
assertThat(createTable.name().names, is(List.of("MY_TABLE")));
assertThat(createTable.columnList(), hasItem(ofTypeMatching(
"Column with function's identifier as default",
- IgniteSqlColumnDeclaration.class,
- col -> "ID".equals(col.name().getSimple())
- && col.expression() instanceof SqlIdentifier
- && "RAND_UUID".equals(((SqlIdentifier)
col.expression()).getSimple())
+ SqlColumnDeclaration.class,
+ col -> "ID".equals(col.name.getSimple())
+ && col.expression instanceof SqlIdentifier
+ && "RAND_UUID".equals(((SqlIdentifier)
col.expression).getSimple())
)));
assertThat(createTable.columnList(), hasItem(ofTypeMatching(
"PK constraint with name \"ID\"",
IgniteSqlPrimaryKeyConstraint.class,
@@ -251,7 +252,7 @@ public class SqlDdlParserTest extends AbstractParserTest {
() -> parse(stmt));
}
- private <T extends SqlLiteral> Matcher<Iterable<? super
IgniteSqlColumnDeclaration>> hasColumnWithDefault(
+ private <T extends SqlLiteral> Matcher<Iterable<? super
SqlColumnDeclaration>> hasColumnWithDefault(
String columnName,
Class<T> nodeType,
String literalValue
@@ -264,7 +265,7 @@ public class SqlDdlParserTest extends AbstractParserTest {
);
}
- private static <T extends SqlNode> Matcher<Iterable<? super
IgniteSqlColumnDeclaration>> hasColumnWithDefaultExpr(
+ private static <T extends SqlNode> Matcher<Iterable<? super
SqlColumnDeclaration>> hasColumnWithDefaultExpr(
String columnName,
Class<T> nodeType,
String message,
@@ -272,10 +273,10 @@ public class SqlDdlParserTest extends AbstractParserTest {
) {
return hasItem(ofTypeMatching(
message,
- IgniteSqlColumnDeclaration.class,
- col -> columnName.equals(col.name().getSimple())
- && nodeType.isInstance(col.expression())
- && valCheck.test(nodeType.cast(col.expression()))
+ SqlColumnDeclaration.class,
+ col -> columnName.equals(col.name.getSimple())
+ && nodeType.isInstance(col.expression)
+ && valCheck.test(nodeType.cast(col.expression))
));
}
@@ -909,12 +910,12 @@ public class SqlDdlParserTest extends AbstractParserTest {
SqlNode sqlNode = parse("ALTER TABLE t ADD COLUMN c INT");
IgniteSqlAlterTableAddColumn addColumn =
assertInstanceOf(IgniteSqlAlterTableAddColumn.class, sqlNode);
- IgniteSqlColumnDeclaration declaration = (IgniteSqlColumnDeclaration)
addColumn.columns().get(0);
+ SqlColumnDeclaration declaration = (SqlColumnDeclaration)
addColumn.columns().get(0);
assertThat(addColumn.name.names, is(List.of("T")));
expectColumnBasic(declaration, "C", ColumnStrategy.NULLABLE,
"INTEGER", true);
- assertThat(declaration.expression(), is(nullValue()));
+ assertThat(declaration.expression, is(nullValue()));
expectUnparsed(addColumn, "ALTER TABLE \"T\" ADD COLUMN \"C\"
INTEGER");
}
@@ -924,12 +925,12 @@ public class SqlDdlParserTest extends AbstractParserTest {
SqlNode sqlNode = parse("ALTER TABLE t ADD COLUMN c INT NULL");
IgniteSqlAlterTableAddColumn addColumn =
assertInstanceOf(IgniteSqlAlterTableAddColumn.class, sqlNode);
- IgniteSqlColumnDeclaration column = (IgniteSqlColumnDeclaration)
addColumn.columns().get(0);
+ SqlColumnDeclaration column = (SqlColumnDeclaration)
addColumn.columns().get(0);
assertThat(addColumn.name.names, is(List.of("T")));
expectColumnBasic(column, "C", ColumnStrategy.NULLABLE, "INTEGER",
true);
- assertThat(column.expression(), is(nullValue()));
+ assertThat(column.expression, is(nullValue()));
expectUnparsed(addColumn, "ALTER TABLE \"T\" ADD COLUMN \"C\"
INTEGER");
}
@@ -939,12 +940,12 @@ public class SqlDdlParserTest extends AbstractParserTest {
SqlNode sqlNode = parse("ALTER TABLE t ADD COLUMN c INT NOT NULL");
IgniteSqlAlterTableAddColumn addColumn =
assertInstanceOf(IgniteSqlAlterTableAddColumn.class, sqlNode);
- IgniteSqlColumnDeclaration column = (IgniteSqlColumnDeclaration)
addColumn.columns().get(0);
+ SqlColumnDeclaration column = (SqlColumnDeclaration)
addColumn.columns().get(0);
assertThat(addColumn.name.names, is(List.of("T")));
expectColumnBasic(column, "C", ColumnStrategy.NOT_NULLABLE, "INTEGER",
false);
- assertThat(column.expression(), is(nullValue()));
+ assertThat(column.expression, is(nullValue()));
expectUnparsed(addColumn, "ALTER TABLE \"T\" ADD COLUMN \"C\" INTEGER
NOT NULL");
}
@@ -1037,25 +1038,25 @@ public class SqlDdlParserTest extends
AbstractParserTest {
* @param name Expected name.
* @return {@code true} in case name in the column declaration equals to
the expected one.
*/
- private static <T extends IgniteSqlColumnDeclaration> Matcher<T>
columnWithName(String name) {
+ private static <T extends SqlColumnDeclaration> Matcher<T>
columnWithName(String name) {
return new CustomMatcher<T>("column with name=" + name) {
/** {@inheritDoc} */
@Override
public boolean matches(Object item) {
- return item instanceof IgniteSqlColumnDeclaration
- && ((IgniteSqlColumnDeclaration)
item).name().names.get(0).equals(name);
+ return item instanceof SqlColumnDeclaration
+ && ((SqlColumnDeclaration)
item).name.names.get(0).equals(name);
}
};
}
/** Checks basic column properties such as name, type name and type's
nullability. */
- private static void expectColumnBasic(IgniteSqlColumnDeclaration
declaration,
+ private static void expectColumnBasic(SqlColumnDeclaration declaration,
String columnName, ColumnStrategy columnStrategy,
String typeName, Boolean nullable) {
- assertThat(List.of(columnName), is(declaration.name().names));
- assertThat(columnStrategy, is(declaration.strategy()));
- assertThat(List.of(typeName),
is(declaration.dataType().getTypeName().names));
- assertThat(nullable, is(declaration.dataType().getNullable()));
+ assertThat(List.of(columnName), is(declaration.name.names));
+ assertThat(columnStrategy, is(declaration.strategy));
+ assertThat(List.of(typeName),
is(declaration.dataType.getTypeName().names));
+ assertThat(nullable, is(declaration.dataType.getNullable()));
}
}
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/type/IgniteTypeFactorySelfTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/type/IgniteTypeFactorySelfTest.java
deleted file mode 100644
index 312a4bae595..00000000000
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/type/IgniteTypeFactorySelfTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.sql.engine.type;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertInstanceOf;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.ignite.internal.sql.engine.util.Commons;
-import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
-import org.junit.jupiter.api.Test;
-
-/**
- * Tests for {@link IgniteTypeFactory}.
- */
-public class IgniteTypeFactorySelfTest extends BaseIgniteAbstractTest {
-
- @Test
- public void createUuidProducesIgniteUuid() {
- IgniteTypeFactory typeFactory = Commons.typeFactory();
-
- RelDataType uuid = typeFactory.createSqlType(SqlTypeName.UUID);
- assertInstanceOf(UuidType.class, uuid);
- assertFalse(uuid.isNullable());
-
- RelDataType varchar = typeFactory.createSqlType(SqlTypeName.VARCHAR);
- assertEquals(varchar.isNullable(), uuid.isNullable(), "default
nullability");
-
- // Use customType method
- assertEquals(typeFactory.createCustomType(UuidType.NAME), uuid);
-
- // Nullable
- RelDataType nullable = typeFactory.createTypeWithNullability(uuid,
true);
- assertTrue(nullable.isNullable());
- assertNotEquals(uuid, nullable, uuid.getFullTypeString() + " | " +
nullable.getFullTypeString());
-
- // Not Nullable
- RelDataType notNullable = typeFactory.createTypeWithNullability(uuid,
false);
- assertFalse(notNullable.isNullable());
- assertEquals(uuid, notNullable, uuid.getFullTypeString() + " | " +
notNullable.getFullTypeString());
- }
-}
diff --git
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/util/TypeUtilsTest.java
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/util/TypeUtilsTest.java
index 20bf8be5e93..4a46aa7ddd6 100644
---
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/util/TypeUtilsTest.java
+++
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/util/TypeUtilsTest.java
@@ -53,7 +53,6 @@ import
org.apache.ignite.internal.sql.engine.framework.ArrayRowHandler;
import org.apache.ignite.internal.sql.engine.type.IgniteCustomType;
import org.apache.ignite.internal.sql.engine.type.IgniteCustomTypeSpec;
import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
import org.apache.ignite.internal.type.NativeTypeSpec;
import org.apache.ignite.internal.type.NativeTypes;
@@ -464,8 +463,7 @@ public class TypeUtilsTest extends BaseIgniteAbstractTest {
testCaseList.add(new
RelToExecTestCase(TYPE_FACTORY.createSqlIntervalType(dayTime), INT64));
}
- // IgniteCustomTypes
- testCaseList.add(new
RelToExecTestCase(TYPE_FACTORY.createCustomType(UuidType.NAME), UUID));
+ testCaseList.add(new RelToExecTestCase(SqlTypeName.UUID, UUID));
// Add test cases for nullable variants
for (RelToExecTestCase testCase : new ArrayList<>(testCaseList)) {
diff --git
a/modules/sql-engine/src/testFixtures/java/org/apache/ignite/internal/sql/engine/util/SqlTestUtils.java
b/modules/sql-engine/src/testFixtures/java/org/apache/ignite/internal/sql/engine/util/SqlTestUtils.java
index d3dc43f600b..76fb0552495 100644
---
a/modules/sql-engine/src/testFixtures/java/org/apache/ignite/internal/sql/engine/util/SqlTestUtils.java
+++
b/modules/sql-engine/src/testFixtures/java/org/apache/ignite/internal/sql/engine/util/SqlTestUtils.java
@@ -56,7 +56,6 @@ import java.util.stream.StreamSupport;
import org.apache.calcite.avatica.util.ByteString;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.rex.RexBuilder;
-import org.apache.calcite.rex.RexLiteral;
import org.apache.calcite.rex.RexNode;
import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.calcite.util.DateString;
@@ -65,10 +64,8 @@ import org.apache.calcite.util.TimestampString;
import org.apache.ignite.internal.sql.engine.InternalSqlRow;
import org.apache.ignite.internal.sql.engine.QueryCancelledException;
import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
-import org.apache.ignite.internal.sql.engine.type.IgniteCustomType;
import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
import org.apache.ignite.internal.sql.engine.type.IgniteTypeSystem;
-import org.apache.ignite.internal.sql.engine.type.UuidType;
import org.apache.ignite.internal.testframework.IgniteTestUtils;
import org.apache.ignite.internal.type.DecimalNativeType;
import org.apache.ignite.internal.type.NativeType;
@@ -122,7 +119,7 @@ public class SqlTestUtils {
COLUMN_TYPE_TO_SQL_TYPE_NAME_MAP.put(ColumnType.STRING,
SqlTypeName.VARCHAR);
COLUMN_TYPE_TO_SQL_TYPE_NAME_MAP.put(ColumnType.BYTE_ARRAY,
SqlTypeName.VARBINARY);
COLUMN_TYPE_TO_SQL_TYPE_NAME_MAP.put(ColumnType.NULL,
SqlTypeName.NULL);
- COLUMN_TYPE_TO_SQL_TYPE_NAME_MAP.put(ColumnType.UUID, SqlTypeName.ANY);
+ COLUMN_TYPE_TO_SQL_TYPE_NAME_MAP.put(ColumnType.UUID,
SqlTypeName.UUID);
COLUMN_TYPE_TO_SQL_TYPE_NAME_MAP.put(ColumnType.PERIOD, null);
COLUMN_TYPE_TO_SQL_TYPE_NAME_MAP.put(ColumnType.DURATION, null);
@@ -213,15 +210,6 @@ public class SqlTestUtils {
public static String toSqlType(ColumnType columnType) {
SqlTypeName type = COLUMN_TYPE_TO_SQL_TYPE_NAME_MAP.get(columnType);
- if (type == SqlTypeName.ANY) {
- switch (columnType) {
- case UUID:
- return UuidType.NAME;
- default:
- throw new IllegalArgumentException("Unsupported type " +
columnType);
- }
- }
-
if (type == null) {
throw new IllegalArgumentException("Unsupported type " +
columnType);
}
@@ -427,8 +415,9 @@ public class SqlTestUtils {
case BYTE_ARRAY:
assert value instanceof byte[];
return "X'" + StringUtils.toHexString((byte[]) value) + "'";
- case NULL:
case UUID:
+ return "UUID '" + value + "'";
+ case NULL:
case PERIOD:
case DURATION:
throw new IllegalArgumentException("The type " + type + "
isn't supported right now");
@@ -461,8 +450,8 @@ public class SqlTestUtils {
return result;
}
- /** Generates literal or value expression using specified column type and
value. */
- public static RexNode generateLiteralOrValueExpr(ColumnType type,
@Nullable Object value) {
+ /** Generates literal using specified column type and value. */
+ public static RexNode generateLiteral(ColumnType type, @Nullable Object
value) {
RexBuilder rexBuilder = Commons.rexBuilder();
IgniteTypeFactory typeFactory = Commons.typeFactory();
@@ -512,11 +501,7 @@ public class SqlTestUtils {
return
rexBuilder.makeTimestampLiteral(TimestampString.fromMillisSinceEpoch(requireNonNull(instant).toEpochMilli()),
6);
case UUID:
- RexLiteral uuidStr =
rexBuilder.makeLiteral(requireNonNull(value).toString(),
- typeFactory.createSqlType(SqlTypeName.VARCHAR));
- IgniteCustomType uuidType =
typeFactory.createCustomType(UuidType.NAME);
-
- return rexBuilder.makeCast(uuidType, uuidStr);
+ return rexBuilder.makeUuidLiteral((UUID) value);
case STRING:
return rexBuilder.makeLiteral(value,
typeFactory.createSqlType(SqlTypeName.VARCHAR));
case BYTE_ARRAY:
