You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by ko...@apache.org on 2022/07/14 08:55:31 UTC
[ignite-3] branch main updated: IGNITE-17219 Revise types support in schema module (#938)
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 f3e8ff272 IGNITE-17219 Revise types support in schema module (#938)
f3e8ff272 is described below
commit f3e8ff2726b5bcb961ff9853996bcfa5c76fa88a
Author: korlov42 <ko...@gridgain.com>
AuthorDate: Thu Jul 14 11:55:27 2022 +0300
IGNITE-17219 Revise types support in schema module (#938)
---
.../ignite/schema/definition/ColumnType.java | 30 +--
.../apache/ignite/table/mapper/TypeConverter.java | 2 +-
.../apache/ignite/internal/util/IgniteUtils.java | 21 ++
.../runner/app/AbstractSchemaChangeTest.java | 8 +-
.../runner/app/jdbc/ItJdbcMetadataSelfTest.java | 2 +-
.../runner/app/jdbc/ItJdbcResultSetSelfTest.java | 6 +-
.../SchemaConfigurationConverter.java | 112 ++++++++--
.../configuration/SchemaDescriptorConverter.java | 71 +------
.../marshaller/schema/SchemaSerializerImpl.java | 118 ++++++++++-
.../ignite/internal/schema/NativeTypeTest.java | 2 +-
.../configuration/AbstractSchemaConverterTest.java | 201 ++++++++++++++++++
.../SchemaConfigurationConverterTest.java | 86 +++++++-
.../SchemaDescriptorConverterTest.java | 109 ++++++----
.../schema/serializer/AbstractSerializerTest.java | 233 ++++++++++++++++++---
.../sql/engine/type/IgniteTypeFactory.java | 2 +-
.../index/RocksDbSortedIndexStorageTest.java | 6 +-
16 files changed, 811 insertions(+), 198 deletions(-)
diff --git a/modules/api/src/main/java/org/apache/ignite/schema/definition/ColumnType.java b/modules/api/src/main/java/org/apache/ignite/schema/definition/ColumnType.java
index 9b5c43129..5be9f736b 100644
--- a/modules/api/src/main/java/org/apache/ignite/schema/definition/ColumnType.java
+++ b/modules/api/src/main/java/org/apache/ignite/schema/definition/ColumnType.java
@@ -36,18 +36,6 @@ public class ColumnType {
/** 64-bit signed int. */
public static final ColumnType INT64 = new ColumnType(ColumnTypeSpec.INT64);
- /** 8-bit unsigned int. */
- public static final ColumnType UINT8 = new ColumnType(ColumnTypeSpec.UINT8);
-
- /** 16-bit unsigned int. */
- public static final ColumnType UINT16 = new ColumnType(ColumnTypeSpec.UINT16);
-
- /** 32-bit unsigned int. */
- public static final ColumnType UINT32 = new ColumnType(ColumnTypeSpec.UINT32);
-
- /** 64-bit unsigned int. */
- public static final ColumnType UINT64 = new ColumnType(ColumnTypeSpec.UINT64);
-
/** 32-bit float. */
public static final ColumnType FLOAT = new ColumnType(ColumnTypeSpec.FLOAT);
@@ -95,7 +83,7 @@ public class ColumnType {
* @return Blob type.
* @see #blobOf(int)
*/
- public static VarLenColumnType blobOf() {
+ public static VarLenColumnType blob() {
return VarLenColumnType.UNLIMITED_BLOB;
}
@@ -130,7 +118,7 @@ public class ColumnType {
* @return Number type.
* @see #numberOf(int)
*/
- public static NumberColumnType numberOf() {
+ public static NumberColumnType number() {
return NumberColumnType.UNLIMITED_NUMBER;
}
@@ -165,7 +153,7 @@ public class ColumnType {
* @return Decimal type.
* @see #decimalOf(int, int)
*/
- public static DecimalColumnType decimalOf() {
+ public static DecimalColumnType decimal() {
return new DecimalColumnType(
ColumnTypeSpec.DECIMAL,
DecimalColumnType.DEFAULT_PRECISION,
@@ -551,18 +539,6 @@ public class ColumnType {
/** 64-bit signed integer. */
INT64,
- /** 8-bit unsigned integer. */
- UINT8,
-
- /** 16-bit unsigned integer. */
- UINT16,
-
- /** 32-bit unsigned integer. */
- UINT32,
-
- /** 64-bit unsigned integer. */
- UINT64,
-
/** 32-bit single-precision floating-point number. */
FLOAT,
diff --git a/modules/api/src/main/java/org/apache/ignite/table/mapper/TypeConverter.java b/modules/api/src/main/java/org/apache/ignite/table/mapper/TypeConverter.java
index 5961f1619..316bdc20f 100644
--- a/modules/api/src/main/java/org/apache/ignite/table/mapper/TypeConverter.java
+++ b/modules/api/src/main/java/org/apache/ignite/table/mapper/TypeConverter.java
@@ -24,7 +24,7 @@ import org.apache.ignite.schema.definition.ColumnType;
* the column type, and vice versa.
*
* <p>The converter can be used to convert object (or their fields), which type is incompatible with the schema.
- * E.g. serialize an arbitrary object to a byte[] for storing is a BLOB column {@link ColumnType#blobOf()}.
+ * E.g. serialize an arbitrary object to a byte[] for storing is a BLOB column {@link ColumnType#blob()}.
*
* @param <ObjectT> Object type.
* @param <ColumnT> Column type.
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java b/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java
index 037ca54b7..77478a8b6 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java
@@ -290,6 +290,27 @@ public class IgniteUtils {
return sb.toString();
}
+ /**
+ * Returns byte array represented by given hex string.
+ *
+ * @param s String containing a hex representation of bytes.
+ * @return A byte array.
+ */
+ public static byte[] fromHexString(String s) {
+ var len = s.length();
+
+ assert (len & 1) == 0 : "length should be even";
+
+ var data = new byte[len / 2];
+
+ for (int i = 0; i < len; i += 2) {
+ data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
+ + Character.digit(s.charAt(i + 1), 16));
+ }
+
+ return data;
+ }
+
/**
* Appends {@code byte} in hexadecimal format.
*
diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/AbstractSchemaChangeTest.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/AbstractSchemaChangeTest.java
index 48ce85782..b26f3f7b9 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/AbstractSchemaChangeTest.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/AbstractSchemaChangeTest.java
@@ -138,7 +138,7 @@ abstract class AbstractSchemaChangeTest {
assertColumnChangeFailed(grid, "valStr", c -> c.changeType(t -> t.changeType("UNKNOWN_TYPE")));
assertColumnChangeFailed(grid, "valInt",
- colChanger -> colChanger.changeType(t -> t.changeType(ColumnType.blobOf().typeSpec().name())));
+ colChanger -> colChanger.changeType(t -> t.changeType(ColumnType.blob().typeSpec().name())));
assertColumnChangeFailed(grid, "valInt", colChanger -> colChanger.changeType(t -> t.changePrecision(10)));
assertColumnChangeFailed(grid, "valInt", colChanger -> colChanger.changeType(t -> t.changeScale(10)));
@@ -197,9 +197,9 @@ abstract class AbstractSchemaChangeTest {
TableDefinition schTbl1 = SchemaBuilders.tableBuilder("PUBLIC", "tbl1").columns(
SchemaBuilders.column("key", ColumnType.INT64).build(),
SchemaBuilders.column("valInt", ColumnType.INT32).asNullable(true).build(),
- SchemaBuilders.column("valBlob", ColumnType.blobOf()).asNullable(true).build(),
- SchemaBuilders.column("valDecimal", ColumnType.decimalOf()).asNullable(true).build(),
- SchemaBuilders.column("valBigInt", ColumnType.numberOf()).asNullable(true).build(),
+ SchemaBuilders.column("valBlob", ColumnType.blob()).asNullable(true).build(),
+ SchemaBuilders.column("valDecimal", ColumnType.decimal()).asNullable(true).build(),
+ SchemaBuilders.column("valBigInt", ColumnType.number()).asNullable(true).build(),
SchemaBuilders.column("valStr", ColumnType.string()).withDefaultValueExpression("default").build()
).withPrimaryKey("key").build();
diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/jdbc/ItJdbcMetadataSelfTest.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/jdbc/ItJdbcMetadataSelfTest.java
index 5b076a614..dbf94f3c6 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/jdbc/ItJdbcMetadataSelfTest.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/jdbc/ItJdbcMetadataSelfTest.java
@@ -163,7 +163,7 @@ public class ItJdbcMetadataSelfTest extends AbstractJdbcSelfTest {
TableDefinition metaTableDef = SchemaBuilders.tableBuilder("PUBLIC", "METATEST")
.columns(
- SchemaBuilders.column("DECIMAL_COL", ColumnType.decimalOf()).build(),
+ SchemaBuilders.column("DECIMAL_COL", ColumnType.decimal()).build(),
SchemaBuilders.column("DATE_COL", ColumnType.DATE).build(),
SchemaBuilders.column("ID", ColumnType.INT32).asNullable(false).build())
.withPrimaryKey("ID")
diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/jdbc/ItJdbcResultSetSelfTest.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/jdbc/ItJdbcResultSetSelfTest.java
index 97414417b..cd956683d 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/jdbc/ItJdbcResultSetSelfTest.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/jdbc/ItJdbcResultSetSelfTest.java
@@ -83,13 +83,13 @@ public class ItJdbcResultSetSelfTest extends AbstractJdbcSelfTest {
columns.add(SchemaBuilders.column("LONGVAL", ColumnType.INT64).asNullable(true).build());
columns.add(SchemaBuilders.column("FLOATVAL", ColumnType.FLOAT).asNullable(true).build());
columns.add(SchemaBuilders.column("DOUBLEVAL", ColumnType.DOUBLE).asNullable(true).build());
- columns.add(SchemaBuilders.column("BIGVAL", ColumnType.decimalOf()).asNullable(true).build());
+ columns.add(SchemaBuilders.column("BIGVAL", ColumnType.decimal()).asNullable(true).build());
columns.add(SchemaBuilders.column("STRVAL", ColumnType.string()).asNullable(true).build());
- columns.add(SchemaBuilders.column("ARRVAL", ColumnType.blobOf()).asNullable(true).build());
+ columns.add(SchemaBuilders.column("ARRVAL", ColumnType.blob()).asNullable(true).build());
columns.add(SchemaBuilders.column("DATEVAL", ColumnType.DATE).asNullable(true).build());
columns.add(SchemaBuilders.column("TIMEVAL", ColumnType.TemporalColumnType.time()).asNullable(true).build());
columns.add(SchemaBuilders.column("TSVAL", ColumnType.TemporalColumnType.timestamp()).asNullable(true).build());
- columns.add(SchemaBuilders.column("URLVAL", ColumnType.blobOf()).asNullable(true).build());
+ columns.add(SchemaBuilders.column("URLVAL", ColumnType.blob()).asNullable(true).build());
TableDefinition personTableDef = SchemaBuilders.tableBuilder("PUBLIC", "TEST")
.columns(columns)
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/configuration/SchemaConfigurationConverter.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/configuration/SchemaConfigurationConverter.java
index 485f3b4c4..3286f789c 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/configuration/SchemaConfigurationConverter.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/configuration/SchemaConfigurationConverter.java
@@ -17,17 +17,26 @@
package org.apache.ignite.internal.schema.configuration;
+import static java.math.RoundingMode.HALF_UP;
import static java.util.Arrays.asList;
import static org.apache.ignite.configuration.schemas.table.TableIndexConfigurationSchema.HASH_INDEX_TYPE;
import static org.apache.ignite.configuration.schemas.table.TableIndexConfigurationSchema.PARTIAL_INDEX_TYPE;
import static org.apache.ignite.configuration.schemas.table.TableIndexConfigurationSchema.SORTED_INDEX_TYPE;
import static org.apache.ignite.internal.util.IgniteUtils.capacity;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.BitSet;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.UUID;
import java.util.stream.Collectors;
import org.apache.ignite.configuration.NamedListView;
import org.apache.ignite.configuration.schemas.table.ColumnChange;
@@ -56,8 +65,10 @@ import org.apache.ignite.internal.schema.definition.index.PartialIndexDefinition
import org.apache.ignite.internal.schema.definition.index.PrimaryKeyDefinitionImpl;
import org.apache.ignite.internal.schema.definition.index.SortedIndexColumnDefinitionImpl;
import org.apache.ignite.internal.schema.definition.index.SortedIndexDefinitionImpl;
+import org.apache.ignite.internal.util.IgniteUtils;
import org.apache.ignite.schema.definition.ColumnDefinition;
import org.apache.ignite.schema.definition.ColumnType;
+import org.apache.ignite.schema.definition.ColumnType.DecimalColumnType;
import org.apache.ignite.schema.definition.PrimaryKeyDefinition;
import org.apache.ignite.schema.definition.TableDefinition;
import org.apache.ignite.schema.definition.index.HashIndexDefinition;
@@ -67,6 +78,7 @@ import org.apache.ignite.schema.definition.index.PartialIndexDefinition;
import org.apache.ignite.schema.definition.index.SortOrder;
import org.apache.ignite.schema.definition.index.SortedIndexColumnDefinition;
import org.apache.ignite.schema.definition.index.SortedIndexDefinition;
+import org.jetbrains.annotations.Nullable;
/**
* Configuration to schema and vice versa converter.
@@ -75,17 +87,13 @@ public class SchemaConfigurationConverter {
/**
* Types map.
*/
- private static final Map<String, ColumnType> types = new HashMap<>();
+ private static final Map<String, ColumnType> fixSizedTypes = new HashMap<>();
static {
putType(ColumnType.INT8);
putType(ColumnType.INT16);
putType(ColumnType.INT32);
putType(ColumnType.INT64);
- putType(ColumnType.UINT8);
- putType(ColumnType.UINT16);
- putType(ColumnType.UINT32);
- putType(ColumnType.UINT64);
putType(ColumnType.FLOAT);
putType(ColumnType.DOUBLE);
putType(ColumnType.UUID);
@@ -99,7 +107,7 @@ public class SchemaConfigurationConverter {
* @param type Column type.
*/
private static void putType(ColumnType type) {
- types.put(type.typeSpec().name(), type);
+ fixSizedTypes.put(type.typeSpec().name(), type);
}
/**
@@ -232,7 +240,7 @@ public class SchemaConfigurationConverter {
public static ColumnTypeChange convert(ColumnType colType, ColumnTypeChange colTypeChg) {
String typeName = colType.typeSpec().name().toUpperCase();
- if (types.containsKey(typeName)) {
+ if (fixSizedTypes.containsKey(typeName)) {
colTypeChg.changeType(typeName);
} else {
colTypeChg.changeType(typeName);
@@ -287,7 +295,7 @@ public class SchemaConfigurationConverter {
*/
public static ColumnType convert(ColumnTypeView colTypeView) {
String typeName = colTypeView.type().toUpperCase();
- ColumnType res = types.get(typeName);
+ ColumnType res = fixSizedTypes.get(typeName);
if (res != null) {
return res;
@@ -315,7 +323,7 @@ public class SchemaConfigurationConverter {
return ColumnType.decimalOf(prec, scale);
case "NUMBER":
- return colTypeView.precision() == 0 ? ColumnType.numberOf() : ColumnType.numberOf(colTypeView.precision());
+ return colTypeView.precision() == 0 ? ColumnType.number() : ColumnType.numberOf(colTypeView.precision());
case "TIME":
return ColumnType.time(colTypeView.precision());
@@ -343,7 +351,7 @@ public class SchemaConfigurationConverter {
colChg.changeType(colTypeInit -> convert(col.type(), colTypeInit));
if (col.defaultValue() != null) {
- colChg.changeDefaultValue(col.defaultValue().toString());
+ colChg.changeDefaultValue(convertDefaultToConfiguration(col.defaultValue(), col.type()));
}
colChg.changeNullable(col.nullable());
@@ -358,11 +366,14 @@ public class SchemaConfigurationConverter {
* @return Column.
*/
public static ColumnDefinition convert(ColumnView colView) {
+ var type = convert(colView.type());
+
return new ColumnDefinitionImpl(
colView.name(),
- convert(colView.type()),
+ type,
colView.nullable(),
- colView.defaultValue());
+ convertDefaultFromConfiguration(colView.defaultValue(), type)
+ );
}
/**
@@ -385,10 +396,8 @@ public class SchemaConfigurationConverter {
}
});
- tblChg.changePrimaryKey(pkCng -> {
- pkCng.changeColumns(tbl.keyColumns().toArray(String[]::new))
- .changeColocationColumns(tbl.colocationColumns().toArray(String[]::new));
- });
+ tblChg.changePrimaryKey(pkCng -> pkCng.changeColumns(tbl.keyColumns().toArray(String[]::new))
+ .changeColocationColumns(tbl.colocationColumns().toArray(String[]::new)));
return tblChg;
}
@@ -509,4 +518,75 @@ public class SchemaConfigurationConverter {
public static TableChange dropColumn(String columnName, TableChange tblChange) {
return tblChange.changeColumns(colChg -> colChg.delete(columnName));
}
+
+ private static String convertDefaultToConfiguration(Object defaultValue, ColumnType type) {
+ switch (type.typeSpec()) {
+ case INT8:
+ case INT16:
+ case INT32:
+ case INT64:
+ case FLOAT:
+ case DOUBLE:
+ case DECIMAL:
+ case DATE:
+ case TIME:
+ case DATETIME:
+ case TIMESTAMP:
+ case NUMBER:
+ case STRING:
+ case UUID:
+ return defaultValue.toString();
+ case BLOB:
+ return IgniteUtils.toHexString((byte[]) defaultValue);
+ case BITMASK:
+ return IgniteUtils.toHexString(((BitSet) defaultValue).toByteArray());
+ default:
+ throw new IllegalStateException("Unknown type [type=" + type + ']');
+ }
+ }
+
+ private static @Nullable Object convertDefaultFromConfiguration(String defaultValue, ColumnType type) {
+ if (defaultValue.isEmpty()) {
+ return null;
+ }
+
+ switch (type.typeSpec()) {
+ case INT8:
+ return Byte.parseByte(defaultValue);
+ case INT16:
+ return Short.parseShort(defaultValue);
+ case INT32:
+ return Integer.parseInt(defaultValue);
+ case INT64:
+ return Long.parseLong(defaultValue);
+ case FLOAT:
+ return Float.parseFloat(defaultValue);
+ case DOUBLE:
+ return Double.parseDouble(defaultValue);
+ case DECIMAL:
+ assert type instanceof DecimalColumnType;
+
+ return new BigDecimal(defaultValue).setScale(((DecimalColumnType) type).scale(), HALF_UP);
+ case DATE:
+ return LocalDate.parse(defaultValue);
+ case TIME:
+ return LocalTime.parse(defaultValue);
+ case DATETIME:
+ return LocalDateTime.parse(defaultValue);
+ case TIMESTAMP:
+ return Instant.parse(defaultValue);
+ case NUMBER:
+ return new BigInteger(defaultValue);
+ case STRING:
+ return defaultValue;
+ case UUID:
+ return UUID.fromString(defaultValue);
+ case BLOB:
+ return IgniteUtils.fromHexString(defaultValue);
+ case BITMASK:
+ return BitSet.valueOf(IgniteUtils.fromHexString(defaultValue));
+ default:
+ throw new IllegalStateException("Unknown type [type=" + type + ']');
+ }
+ }
}
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/configuration/SchemaDescriptorConverter.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/configuration/SchemaDescriptorConverter.java
index 38923018d..bcdeb768e 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/configuration/SchemaDescriptorConverter.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/configuration/SchemaDescriptorConverter.java
@@ -25,25 +25,15 @@ import static org.apache.ignite.internal.schema.NativeTypes.INT64;
import static org.apache.ignite.internal.schema.NativeTypes.INT8;
import static org.apache.ignite.internal.schema.NativeTypes.UUID;
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.math.RoundingMode;
-import java.time.Instant;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.function.Supplier;
import org.apache.ignite.internal.schema.Column;
-import org.apache.ignite.internal.schema.DecimalNativeType;
import org.apache.ignite.internal.schema.InvalidTypeException;
import org.apache.ignite.internal.schema.NativeType;
import org.apache.ignite.internal.schema.NativeTypes;
import org.apache.ignite.internal.schema.SchemaDescriptor;
-import org.apache.ignite.internal.schema.SchemaException;
import org.apache.ignite.schema.definition.ColumnDefinition;
import org.apache.ignite.schema.definition.ColumnType;
import org.apache.ignite.schema.definition.TableDefinition;
@@ -76,12 +66,6 @@ public class SchemaDescriptorConverter {
case INT64:
return INT64;
- case UINT8:
- case UINT16:
- case UINT32:
- case UINT64:
- throw new UnsupportedOperationException("Unsigned types are not supported yet.");
-
case FLOAT:
return FLOAT;
@@ -154,8 +138,7 @@ public class SchemaDescriptorConverter {
public static Column convert(int columnOrder, ColumnDefinition colCfg) {
NativeType type = convert(colCfg.type());
- return new Column(columnOrder, colCfg.name(), type, colCfg.nullable(),
- new ConstantSupplier(convertDefault(type, (String) colCfg.defaultValue())));
+ return new Column(columnOrder, colCfg.name(), type, colCfg.nullable(), new ConstantSupplier(colCfg.defaultValue()));
}
/**
@@ -190,65 +173,19 @@ public class SchemaDescriptorConverter {
valCols.toArray(Column[]::new));
}
- /**
- * TODO: https://issues.apache.org/jira/browse/IGNITE-14479 Fix default conversion.
- *
- * @param type Column type.
- * @param dflt Column default value.
- * @return Parsed object.
- */
- private static Serializable convertDefault(NativeType type, String dflt) {
- if (dflt == null || dflt.isEmpty()) {
- return null;
- }
-
- switch (type.spec()) {
- case INT8:
- return Byte.parseByte(dflt);
- case INT16:
- return Short.parseShort(dflt);
- case INT32:
- return Integer.parseInt(dflt);
- case INT64:
- return Long.parseLong(dflt);
- case FLOAT:
- return Float.parseFloat(dflt);
- case DOUBLE:
- return Double.parseDouble(dflt);
- case DECIMAL:
- return new BigDecimal(dflt).setScale(((DecimalNativeType) type).scale(), RoundingMode.HALF_UP);
- case NUMBER:
- return new BigInteger(dflt);
- case STRING:
- return dflt;
- case UUID:
- return java.util.UUID.fromString(dflt);
- case DATE:
- return LocalDate.parse(dflt);
- case TIME:
- return LocalTime.parse(dflt);
- case DATETIME:
- return LocalDateTime.parse(dflt);
- case TIMESTAMP:
- return Instant.parse(dflt);
- default:
- throw new SchemaException("Default value is not supported for type: type=" + type.toString());
- }
- }
-
/**
* Constant value supplier.
*/
- private static class ConstantSupplier implements Supplier<Object>, Serializable {
+ private static class ConstantSupplier implements Supplier<Object> {
/** Value. */
- private final Serializable val;
+ private final Object val;
/**
* Constructor.
*
* @param val Value.
*/
- ConstantSupplier(Serializable val) {
+ ConstantSupplier(Object val) {
this.val = val;
}
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/marshaller/schema/SchemaSerializerImpl.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/marshaller/schema/SchemaSerializerImpl.java
index d30c7ef88..2e04d9bb4 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/marshaller/schema/SchemaSerializerImpl.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/marshaller/schema/SchemaSerializerImpl.java
@@ -22,6 +22,10 @@ import static java.nio.charset.StandardCharsets.UTF_8;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.ByteBuffer;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
import java.util.BitSet;
import java.util.UUID;
import org.apache.ignite.internal.schema.BitmaskNativeType;
@@ -203,22 +207,22 @@ public class SchemaSerializerImpl extends AbstractSchemaSerializer {
+ BYTE //nullable flag
+ getStringSize(col.name())
+ getNativeTypeSize(col.type())
- + BYTE + getDefaultObjectSize(col.type(), col.defaultValue());
+ + BYTE + getDefaultObjectSize(col.type().spec(), col.defaultValue());
}
/**
* Gets default object size in bytes based on object native type.
*
* @param type Column native type.
- * @param val Object.
+ * @param val Object.
* @return Object size in bytes.
*/
- private int getDefaultObjectSize(NativeType type, Object val) {
+ private int getDefaultObjectSize(NativeTypeSpec type, Object val) {
if (val == null) {
return 0;
}
- switch (type.spec()) {
+ switch (type) {
case INT8:
return BYTE;
@@ -255,6 +259,19 @@ public class SchemaSerializerImpl extends AbstractSchemaSerializer {
case NUMBER:
return INT + ((BigInteger) val).toByteArray().length;
+ case DATE:
+ return INT + BYTE + BYTE;
+
+ case TIME:
+ return 3 * BYTE + INT;
+
+ case DATETIME:
+ return getDefaultObjectSize(NativeTypeSpec.DATE, val)
+ + getDefaultObjectSize(NativeTypeSpec.TIME, val);
+
+ case TIMESTAMP:
+ return LONG + INT;
+
default:
throw new InvalidTypeException("Unexpected type " + type);
}
@@ -456,6 +473,32 @@ public class SchemaSerializerImpl extends AbstractSchemaSerializer {
break;
}
+ case DATE: {
+ appendDate((LocalDate) val, buf);
+
+ break;
+ }
+ case TIME: {
+ appendTime((LocalTime) val, buf);
+
+ break;
+ }
+ case DATETIME: {
+ LocalDateTime date = (LocalDateTime) val;
+
+ appendDate(date.toLocalDate(), buf);
+ appendTime(date.toLocalTime(), buf);
+
+ break;
+ }
+ case TIMESTAMP: {
+ Instant timeStamp = (Instant) val;
+
+ buf.putLong(timeStamp.getEpochSecond());
+ buf.putInt(timeStamp.getNano());
+
+ break;
+ }
default:
throw new InvalidTypeException("Unexpected type " + type);
@@ -538,6 +581,31 @@ public class SchemaSerializerImpl extends AbstractSchemaSerializer {
buf.put(bytes);
}
+ /**
+ * Appends date to byte buffer.
+ *
+ * @param buf Byte buffer.
+ * @param date Date value to append.
+ */
+ private void appendDate(LocalDate date, ByteBuffer buf) {
+ buf.putInt(date.getYear());
+ buf.put((byte) date.getMonthValue());
+ buf.put((byte) date.getDayOfMonth());
+ }
+
+ /**
+ * Appends time to byte buffer.
+ *
+ * @param buf Byte buffer.
+ * @param time Time value to append.
+ */
+ private void appendTime(LocalTime time, ByteBuffer buf) {
+ buf.put((byte) time.getHour());
+ buf.put((byte) time.getMinute());
+ buf.put((byte) time.getSecond());
+ buf.putInt(time.getNano());
+ }
+
/**
* Reads column mapping from byte buffer.
*
@@ -661,6 +729,18 @@ public class SchemaSerializerImpl extends AbstractSchemaSerializer {
case NUMBER:
return new BigInteger(readByteArray(buf));
+ case DATE:
+ return readDate(buf);
+
+ case TIME:
+ return readTime(buf);
+
+ case DATETIME:
+ return LocalDateTime.of(readDate(buf), readTime(buf));
+
+ case TIMESTAMP:
+ return readTimestamp(buf);
+
default:
throw new InvalidTypeException("Unexpected type " + type);
}
@@ -772,4 +852,34 @@ public class SchemaSerializerImpl extends AbstractSchemaSerializer {
return arr;
}
+
+ /**
+ * Convert buffer into LocalDate representation.
+ *
+ * @param buf Byte buffer.
+ * @return LocalDate instance.
+ */
+ private LocalDate readDate(ByteBuffer buf) {
+ return LocalDate.of(buf.getInt(), buf.get(), buf.get());
+ }
+
+ /**
+ * Convert buffer into LocalTime representation.
+ *
+ * @param buf Byte buffer.
+ * @return LocalTime instance.
+ */
+ private LocalTime readTime(ByteBuffer buf) {
+ return LocalTime.of(buf.get(), buf.get(), buf.get(), buf.getInt());
+ }
+
+ /**
+ * Convert buffer into Instant representation.
+ *
+ * @param buf Byte buffer.
+ * @return Instant instance.
+ */
+ private Instant readTimestamp(ByteBuffer buf) {
+ return Instant.ofEpochSecond(buf.getLong(), buf.getInt());
+ }
}
diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/NativeTypeTest.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/NativeTypeTest.java
index a4bfd9c53..052f18fd1 100644
--- a/modules/schema/src/test/java/org/apache/ignite/internal/schema/NativeTypeTest.java
+++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/NativeTypeTest.java
@@ -170,7 +170,7 @@ public class NativeTypeTest {
assertEquals(FLOAT, from(ColumnType.FLOAT));
assertEquals(DOUBLE, from(ColumnType.DOUBLE));
assertEquals(DATE, from(ColumnType.DATE));
- assertEquals(BYTES, from(ColumnType.blobOf()));
+ assertEquals(BYTES, from(ColumnType.blob()));
assertEquals(STRING, from(ColumnType.string()));
assertEquals(time(), from(ColumnType.time(ColumnType.TemporalColumnType.DEFAULT_TIME_PRECISION)));
diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/AbstractSchemaConverterTest.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/AbstractSchemaConverterTest.java
new file mode 100644
index 000000000..f03ce50f6
--- /dev/null
+++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/AbstractSchemaConverterTest.java
@@ -0,0 +1,201 @@
+/*
+ * 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.schema.configuration;
+
+import static java.math.RoundingMode.HALF_UP;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.empty;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import org.apache.ignite.internal.util.ArrayUtils;
+import org.apache.ignite.schema.definition.ColumnType;
+import org.apache.ignite.schema.definition.ColumnType.ColumnTypeSpec;
+import org.apache.ignite.schema.definition.ColumnType.DecimalColumnType;
+
+/**
+ * Abstract class for schema converter tests.
+ */
+public class AbstractSchemaConverterTest {
+ protected static final Map<ColumnTypeSpec, List<Object>> DEFAULT_VALUES_TO_TEST;
+
+ static {
+ var tmp = new HashMap<ColumnTypeSpec, List<Object>>();
+
+ tmp.put(ColumnTypeSpec.INT8, Arrays.asList(null, Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 14));
+ tmp.put(ColumnTypeSpec.INT16, Arrays.asList(null, Short.MIN_VALUE, Short.MAX_VALUE, (short) 14));
+ tmp.put(ColumnTypeSpec.INT32, Arrays.asList(null, Integer.MIN_VALUE, Integer.MAX_VALUE, 14));
+ tmp.put(ColumnTypeSpec.INT64, Arrays.asList(null, Long.MIN_VALUE, Long.MAX_VALUE, 14L));
+ tmp.put(ColumnTypeSpec.FLOAT, Arrays.asList(null, Float.MIN_VALUE, Float.MAX_VALUE, Float.NaN,
+ Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, 14.14f));
+ tmp.put(ColumnTypeSpec.DOUBLE, Arrays.asList(null, Double.MIN_VALUE, Double.MAX_VALUE, Double.NaN,
+ Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 14.14));
+ tmp.put(ColumnTypeSpec.DECIMAL, Arrays.asList(null, BigDecimal.ONE, BigDecimal.ZERO, BigDecimal.valueOf(Long.MIN_VALUE),
+ BigDecimal.valueOf(Long.MAX_VALUE), new BigDecimal("10000000000000000000000000000000000000")));
+ tmp.put(ColumnTypeSpec.DATE, Arrays.asList(null, LocalDate.MIN, LocalDate.MAX, LocalDate.EPOCH, LocalDate.now()));
+ tmp.put(ColumnTypeSpec.TIME, Arrays.asList(null, LocalTime.MIN, LocalTime.MAX, LocalTime.MIDNIGHT,
+ LocalTime.NOON, LocalTime.now()));
+ tmp.put(ColumnTypeSpec.DATETIME, Arrays.asList(null, LocalDateTime.MIN, LocalDateTime.MAX, LocalDateTime.now()));
+ tmp.put(ColumnTypeSpec.TIMESTAMP, Arrays.asList(null, Instant.MIN, Instant.MAX, Instant.EPOCH, Instant.now()));
+ tmp.put(ColumnTypeSpec.UUID, Arrays.asList(null, UUID.randomUUID()));
+ tmp.put(ColumnTypeSpec.BITMASK, Arrays.asList(null, fromBinString(""), fromBinString("1"),
+ fromBinString("10101010101010101010101")));
+ tmp.put(ColumnTypeSpec.STRING, Arrays.asList(null, "", UUID.randomUUID().toString()));
+ tmp.put(ColumnTypeSpec.BLOB, Arrays.asList(null, ArrayUtils.BYTE_EMPTY_ARRAY,
+ UUID.randomUUID().toString().getBytes(StandardCharsets.UTF_8)));
+ tmp.put(ColumnTypeSpec.NUMBER, Arrays.asList(null, BigInteger.ONE, BigInteger.ZERO,
+ new BigInteger("10000000000000000000000000000000000000")));
+
+ var missedTypes = new HashSet<>(Arrays.asList(ColumnTypeSpec.values()));
+
+ missedTypes.removeAll(tmp.keySet());
+
+ assertThat(missedTypes, empty());
+
+ DEFAULT_VALUES_TO_TEST = Map.copyOf(tmp);
+ }
+
+ /** Creates a bit set from binary string. */
+ private static BitSet fromBinString(String binString) {
+ var bs = new BitSet();
+
+ var idx = 0;
+ for (var c : binString.toCharArray()) {
+ if (c == '1') {
+ bs.set(idx);
+ }
+
+ idx++;
+ }
+
+ return bs;
+ }
+
+ /**
+ * Adjust the given value.
+ *
+ * <p>Some values need to be adjusted before comparison. For example, decimal values should be adjusted
+ * in order to have the same scale, because '1.0' not equals to '1.00'.
+ *
+ * @param val Value to adjust.
+ * @param <T> Type of te value.
+ * @return Adjusted value.
+ */
+ @SuppressWarnings("unchecked")
+ protected static <T> T adjust(T val) {
+ if (val instanceof BigDecimal) {
+ return (T) ((BigDecimal) val).setScale(DecimalColumnType.DEFAULT_SCALE, HALF_UP);
+ }
+
+ return val;
+ }
+
+ /** Creates a column type from given type spec. */
+ protected static ColumnType specToType(ColumnTypeSpec spec) {
+ switch (spec) {
+ case INT8:
+ return ColumnType.INT8;
+ case INT16:
+ return ColumnType.INT16;
+ case INT32:
+ return ColumnType.INT32;
+ case INT64:
+ return ColumnType.INT64;
+ case FLOAT:
+ return ColumnType.FLOAT;
+ case DOUBLE:
+ return ColumnType.DOUBLE;
+ case DECIMAL:
+ return ColumnType.decimal();
+ case DATE:
+ return ColumnType.DATE;
+ case TIME:
+ return ColumnType.time();
+ case DATETIME:
+ return ColumnType.datetime();
+ case TIMESTAMP:
+ return ColumnType.timestamp();
+ case NUMBER:
+ return ColumnType.number();
+ case STRING:
+ return ColumnType.string();
+ case UUID:
+ return ColumnType.UUID;
+ case BLOB:
+ return ColumnType.blob();
+ case BITMASK:
+ return ColumnType.bitmaskOf(10);
+ default:
+ throw new IllegalStateException("Unknown type spec [spec=" + spec + ']');
+ }
+ }
+
+ /**
+ * Converts the given value to a string representation.
+ *
+ * <p>Convenient method to convert a value to a string. Some types don't override
+ * {@link Object#toString()} method (any array, for instance), hence should be converted to a string manually.
+ */
+ private static String toString(Object val) {
+ if (val instanceof byte[]) {
+ return Arrays.toString((byte[]) val);
+ }
+
+ if (val == null) {
+ return "null";
+ }
+
+ return val.toString();
+ }
+
+ /**
+ * Class represents a default value of particular type.
+ */
+ protected static class DefaultValueArg {
+ final ColumnType type;
+ final Object defaultValue;
+
+ /**
+ * Constructor.
+ *
+ * @param type Type of the value
+ * @param defaultValue value itself.
+ */
+ public DefaultValueArg(ColumnType type, Object defaultValue) {
+ this.type = type;
+ this.defaultValue = defaultValue;
+ }
+
+ @Override
+ public String toString() {
+ return type.typeSpec() + ": " + AbstractSchemaConverterTest.toString(defaultValue);
+ }
+ }
+}
diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/SchemaConfigurationConverterTest.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/SchemaConfigurationConverterTest.java
index 809329b15..f2b54e3b9 100644
--- a/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/SchemaConfigurationConverterTest.java
+++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/SchemaConfigurationConverterTest.java
@@ -18,10 +18,15 @@
package org.apache.ignite.internal.schema.configuration;
import static org.apache.ignite.configuration.annotation.ConfigurationType.DISTRIBUTED;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.util.ArrayList;
+import java.util.BitSet;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
@@ -40,6 +45,7 @@ import org.apache.ignite.internal.configuration.ConfigurationRegistry;
import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
import org.apache.ignite.schema.SchemaBuilders;
import org.apache.ignite.schema.definition.ColumnType;
+import org.apache.ignite.schema.definition.ColumnType.ColumnTypeSpec;
import org.apache.ignite.schema.definition.TableDefinition;
import org.apache.ignite.schema.definition.builder.HashIndexDefinitionBuilder;
import org.apache.ignite.schema.definition.builder.PartialIndexDefinitionBuilder;
@@ -55,12 +61,14 @@ import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
/**
* SchemaConfigurationConverter tests.
*/
@SuppressWarnings("InstanceVariableMayNotBeInitialized")
-public class SchemaConfigurationConverterTest {
+public class SchemaConfigurationConverterTest extends AbstractSchemaConverterTest {
/** Table builder. */
private TableDefinitionBuilder tblBuilder;
@@ -257,6 +265,48 @@ public class SchemaConfigurationConverterTest {
assertEquals(tbl.columns().size(), tbl2.columns().size());
}
+ /**
+ * Ensures that column default are properly converted from definition to configuration and vice versa.
+ *
+ * @param arg Argument object describing default value to verify.
+ */
+ @ParameterizedTest
+ @MethodSource("generateTestArguments")
+ public void convertDefaults(DefaultValueArg arg) {
+ final String keyColumnName = "ID";
+
+ var columnName = arg.type.typeSpec().name();
+
+ var tableDefinition = SchemaBuilders.tableBuilder("PUBLIC", "TEST")
+ .columns(
+ SchemaBuilders.column(keyColumnName, ColumnType.INT32).build(),
+ SchemaBuilders.column(columnName, arg.type).withDefaultValueExpression(arg.defaultValue).build()
+ )
+ .withPrimaryKey("ID")
+ .build();
+
+ confRegistry.getConfiguration(TablesConfiguration.KEY).change(
+ ch -> SchemaConfigurationConverter.createTable(tableDefinition, ch)
+ .changeTables(
+ tblsCh -> tblsCh.createOrUpdate(tableDefinition.canonicalName(), tblCh -> tblCh.changeReplicas(1))
+ )
+ ).join();
+
+ var tableConfiguration = confRegistry.getConfiguration(TablesConfiguration.KEY)
+ .tables().get(tableDefinition.canonicalName());
+
+ var columns = SchemaConfigurationConverter.convert(tableConfiguration.value()).columns();
+
+ assertThat(columns, hasSize(2));
+ assertThat(columns.get(0).name(), equalTo(keyColumnName));
+
+ var targetColumn = columns.get(1);
+
+ assertThat(targetColumn.name(), equalTo(columnName));
+ assertThat(targetColumn.type(), equalTo(arg.type));
+ assertThat(targetColumn.defaultValue(), equalTo(arg.defaultValue));
+ }
+
/**
* Get tests default table configuration.
*
@@ -276,4 +326,38 @@ public class SchemaConfigurationConverterTest {
private IndexDefinition getIdx(String name, Collection<IndexDefinition> idxs) {
return idxs.stream().filter(idx -> name.equals(idx.name())).findAny().orElse(null);
}
+
+ private static Iterable<DefaultValueArg> generateTestArguments() {
+ var paramList = new ArrayList<DefaultValueArg>();
+
+ for (var entry : DEFAULT_VALUES_TO_TEST.entrySet()) {
+ for (var defaultValue : entry.getValue()) {
+ if (skipValue(entry.getKey(), defaultValue)) {
+ continue;
+ }
+
+ paramList.add(
+ new DefaultValueArg(specToType(entry.getKey()), adjust(defaultValue))
+ );
+ }
+ }
+ return paramList;
+ }
+
+ // TODO: IGNITE-17370 remove this
+ private static boolean skipValue(ColumnTypeSpec type, Object value) {
+ if (value == null) {
+ return false;
+ }
+
+ if (type == ColumnTypeSpec.BLOB && ((byte[]) value).length == 0) {
+ return true;
+ }
+
+ if (type == ColumnTypeSpec.BITMASK && ((BitSet) value).isEmpty()) {
+ return true;
+ }
+
+ return type == ColumnTypeSpec.STRING && ((String) value).isEmpty();
+ }
}
diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/SchemaDescriptorConverterTest.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/SchemaDescriptorConverterTest.java
index 7aad67ba6..d9e4c49be 100644
--- a/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/SchemaDescriptorConverterTest.java
+++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/configuration/SchemaDescriptorConverterTest.java
@@ -17,10 +17,13 @@
package org.apache.ignite.internal.schema.configuration;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.Function;
import org.apache.ignite.internal.schema.Column;
@@ -34,11 +37,13 @@ import org.apache.ignite.schema.definition.TableDefinition;
import org.apache.ignite.schema.definition.builder.ColumnDefinitionBuilder;
import org.apache.ignite.schema.definition.builder.TableDefinitionBuilder;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
/**
* Tests for SchemaDescriptorConverter.
*/
-public class SchemaDescriptorConverterTest {
+public class SchemaDescriptorConverterTest extends AbstractSchemaConverterTest {
/** Total number of columns. */
private static final int columns = 15;
@@ -86,15 +91,58 @@ public class SchemaDescriptorConverterTest {
*/
@Test
public void convertNullable() {
- testConvert(true);
+ TableDefinition tblSchm = getBuilder(true, true).build();
+
+ SchemaDescriptor tblDscr = SchemaDescriptorConverter.convert(1, tblSchm);
+
+ assertEquals(1, tblDscr.keyColumns().length());
+ testCol(tblDscr.keyColumns(), "ID", NativeTypeSpec.UUID, false);
+
+ assertEquals(columns - 1, tblDscr.valueColumns().length());
+ testCol(tblDscr.valueColumns(), "INT8", NativeTypeSpec.INT8, true);
+ testCol(tblDscr.valueColumns(), "INT16", NativeTypeSpec.INT16, true);
+ testCol(tblDscr.valueColumns(), "INT32", NativeTypeSpec.INT32, true);
+ testCol(tblDscr.valueColumns(), "INT64", NativeTypeSpec.INT64, true);
+ testCol(tblDscr.valueColumns(), "FLOAT", NativeTypeSpec.FLOAT, true);
+ testCol(tblDscr.valueColumns(), "DOUBLE", NativeTypeSpec.DOUBLE, true);
+ testCol(tblDscr.valueColumns(), "UUID", NativeTypeSpec.UUID, true);
+ testCol(tblDscr.valueColumns(), "STRING", NativeTypeSpec.STRING, true);
+ testCol(tblDscr.valueColumns(), "STRING_FS10", NativeTypeSpec.STRING, true);
+ testCol(tblDscr.valueColumns(), "BLOB", NativeTypeSpec.BYTES, true);
+ testCol(tblDscr.valueColumns(), "DECIMAL", NativeTypeSpec.DECIMAL, true);
+ testCol(tblDscr.valueColumns(), "NUMBER", NativeTypeSpec.NUMBER, true);
+ testCol(tblDscr.valueColumns(), "DECIMAL", NativeTypeSpec.DECIMAL, true);
+ testCol(tblDscr.valueColumns(), "BITMASK_FS10", NativeTypeSpec.BITMASK, true);
}
- /**
- * Convert table with non nullable columns.
- */
- @Test
- public void convertTypes() {
- testConvert(false);
+ @ParameterizedTest
+ @MethodSource("generateTestArguments")
+ public void convertDefaultValues(DefaultValueArg arg) {
+ final String keyColumnName = "ID";
+
+ var columnName = arg.type.typeSpec().name();
+ var nullable = arg.defaultValue == null;
+
+ var tableDefinition = SchemaBuilders.tableBuilder("PUBLIC", "TEST")
+ .columns(
+ SchemaBuilders.column(keyColumnName, ColumnType.INT32).build(),
+ SchemaBuilders.column(columnName, arg.type)
+ .withDefaultValueExpression(arg.defaultValue)
+ .asNullable(nullable)
+ .build()
+ )
+ .withPrimaryKey("ID")
+ .build();
+
+ SchemaDescriptor schemaDescriptor = SchemaDescriptorConverter.convert(1, tableDefinition);
+
+ assertEquals(1, schemaDescriptor.valueColumns().length());
+
+ var column = schemaDescriptor.valueColumns().columns()[0];
+
+ assertThat(column.name(), equalTo(columnName));
+ assertThat(column.nullable(), equalTo(nullable));
+ assertThat(column.defaultValue(), equalTo(arg.defaultValue));
}
/**
@@ -134,36 +182,6 @@ public class SchemaDescriptorConverterTest {
tblDscr.columnNames().toArray(String[]::new));
}
- /**
- * Test set of columns.
- *
- * @param nullable Nullable flag.
- */
- private void testConvert(boolean nullable) {
- TableDefinition tblSchm = getBuilder(nullable, true).build();
-
- SchemaDescriptor tblDscr = SchemaDescriptorConverter.convert(1, tblSchm);
-
- assertEquals(1, tblDscr.keyColumns().length());
- testCol(tblDscr.keyColumns(), "ID", NativeTypeSpec.UUID, false);
-
- assertEquals(columns - 1, tblDscr.valueColumns().length());
- testCol(tblDscr.valueColumns(), "INT8", NativeTypeSpec.INT8, nullable);
- testCol(tblDscr.valueColumns(), "INT16", NativeTypeSpec.INT16, nullable);
- testCol(tblDscr.valueColumns(), "INT32", NativeTypeSpec.INT32, nullable);
- testCol(tblDscr.valueColumns(), "INT64", NativeTypeSpec.INT64, nullable);
- testCol(tblDscr.valueColumns(), "FLOAT", NativeTypeSpec.FLOAT, nullable);
- testCol(tblDscr.valueColumns(), "DOUBLE", NativeTypeSpec.DOUBLE, nullable);
- testCol(tblDscr.valueColumns(), "UUID", NativeTypeSpec.UUID, nullable);
- testCol(tblDscr.valueColumns(), "STRING", NativeTypeSpec.STRING, nullable);
- testCol(tblDscr.valueColumns(), "STRING_FS10", NativeTypeSpec.STRING, nullable);
- testCol(tblDscr.valueColumns(), "BLOB", NativeTypeSpec.BYTES, nullable);
- testCol(tblDscr.valueColumns(), "DECIMAL", NativeTypeSpec.DECIMAL, nullable);
- testCol(tblDscr.valueColumns(), "NUMBER", NativeTypeSpec.NUMBER, nullable);
- testCol(tblDscr.valueColumns(), "DECIMAL", NativeTypeSpec.DECIMAL, nullable);
- testCol(tblDscr.valueColumns(), "BITMASK_FS10", NativeTypeSpec.BITMASK, nullable);
- }
-
/**
* Get TableSchemaBuilder with default table.
*
@@ -187,7 +205,7 @@ public class SchemaDescriptorConverterTest {
postProcess.apply(SchemaBuilders.column("UUID", ColumnType.UUID)),
postProcess.apply(SchemaBuilders.column("STRING", ColumnType.string())),
postProcess.apply(SchemaBuilders.column("STRING_FS10", ColumnType.stringOf(10))),
- postProcess.apply(SchemaBuilders.column("BLOB", ColumnType.blobOf())),
+ postProcess.apply(SchemaBuilders.column("BLOB", ColumnType.blob())),
postProcess.apply(SchemaBuilders.column("BLOB_FS10", ColumnType.blobOf(10))),
postProcess.apply(SchemaBuilders.column("DECIMAL", ColumnType.decimalOf(1, 1))),
postProcess.apply(SchemaBuilders.column("NUMBER", ColumnType.numberOf(12))),
@@ -225,4 +243,17 @@ public class SchemaDescriptorConverterTest {
assertTrue(col.type().sizeInBytes() >= 0);
}
}
+
+ private static Iterable<DefaultValueArg> generateTestArguments() {
+ var paramList = new ArrayList<DefaultValueArg>();
+
+ for (var entry : DEFAULT_VALUES_TO_TEST.entrySet()) {
+ for (var defaultValue : entry.getValue()) {
+ paramList.add(
+ new DefaultValueArg(specToType(entry.getKey()), adjust(defaultValue))
+ );
+ }
+ }
+ return paramList;
+ }
}
diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/serializer/AbstractSerializerTest.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/serializer/AbstractSerializerTest.java
index d74073673..e9d07f796 100644
--- a/modules/schema/src/test/java/org/apache/ignite/internal/schema/serializer/AbstractSerializerTest.java
+++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/serializer/AbstractSerializerTest.java
@@ -17,29 +17,86 @@
package org.apache.ignite.internal.schema.serializer;
+import static java.math.RoundingMode.HALF_UP;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.empty;
+import static org.hamcrest.Matchers.equalTo;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNull;
import java.math.BigDecimal;
import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
import java.util.UUID;
import org.apache.ignite.internal.schema.Column;
+import org.apache.ignite.internal.schema.NativeType;
+import org.apache.ignite.internal.schema.NativeTypeSpec;
import org.apache.ignite.internal.schema.NativeTypes;
import org.apache.ignite.internal.schema.SchemaDescriptor;
import org.apache.ignite.internal.schema.mapping.ColumnMapper;
import org.apache.ignite.internal.schema.mapping.ColumnMapping;
import org.apache.ignite.internal.schema.marshaller.schema.AbstractSchemaSerializer;
import org.apache.ignite.internal.schema.marshaller.schema.SchemaSerializerImpl;
+import org.apache.ignite.internal.util.ArrayUtils;
+import org.apache.ignite.schema.definition.ColumnType.DecimalColumnType;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
/**
* SchemaDescriptor (de)serializer test.
*/
public class AbstractSerializerTest {
+ protected static final Map<NativeTypeSpec, List<Object>> DEFAULT_VALUES_TO_TEST;
+
+ static {
+ var tmp = new HashMap<NativeTypeSpec, List<Object>>();
+
+ tmp.put(NativeTypeSpec.INT8, Arrays.asList(null, Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 14));
+ tmp.put(NativeTypeSpec.INT16, Arrays.asList(null, Short.MIN_VALUE, Short.MAX_VALUE, (short) 14));
+ tmp.put(NativeTypeSpec.INT32, Arrays.asList(null, Integer.MIN_VALUE, Integer.MAX_VALUE, 14));
+ tmp.put(NativeTypeSpec.INT64, Arrays.asList(null, Long.MIN_VALUE, Long.MAX_VALUE, 14L));
+ tmp.put(NativeTypeSpec.FLOAT, Arrays.asList(null, Float.MIN_VALUE, Float.MAX_VALUE, Float.NaN,
+ Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, 14.14f));
+ tmp.put(NativeTypeSpec.DOUBLE, Arrays.asList(null, Double.MIN_VALUE, Double.MAX_VALUE, Double.NaN,
+ Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 14.14));
+ tmp.put(NativeTypeSpec.DECIMAL, Arrays.asList(null, BigDecimal.ONE, BigDecimal.ZERO, BigDecimal.valueOf(Long.MIN_VALUE),
+ BigDecimal.valueOf(Long.MAX_VALUE), new BigDecimal("10000000000000000000000000000000000000")));
+ tmp.put(NativeTypeSpec.DATE, Arrays.asList(null, LocalDate.MIN, LocalDate.MAX, LocalDate.EPOCH, LocalDate.now()));
+ tmp.put(NativeTypeSpec.TIME, Arrays.asList(null, LocalTime.MIN, LocalTime.MAX, LocalTime.MIDNIGHT,
+ LocalTime.NOON, LocalTime.now()));
+ tmp.put(NativeTypeSpec.DATETIME, Arrays.asList(null, LocalDateTime.MIN, LocalDateTime.MAX, LocalDateTime.now()));
+ tmp.put(NativeTypeSpec.TIMESTAMP, Arrays.asList(null, Instant.MIN, Instant.MAX, Instant.EPOCH, Instant.now()));
+ tmp.put(NativeTypeSpec.UUID, Arrays.asList(null, UUID.randomUUID()));
+ tmp.put(NativeTypeSpec.BITMASK, Arrays.asList(null, fromBinString(""), fromBinString("1"),
+ fromBinString("10101010101010101010101")));
+ tmp.put(NativeTypeSpec.STRING, Arrays.asList(null, "", UUID.randomUUID().toString()));
+ tmp.put(NativeTypeSpec.BYTES, Arrays.asList(null, ArrayUtils.BYTE_EMPTY_ARRAY, UUID.randomUUID().toString().getBytes(
+ StandardCharsets.UTF_8)));
+ tmp.put(NativeTypeSpec.NUMBER, Arrays.asList(null, BigInteger.ONE, BigInteger.ZERO,
+ new BigInteger("10000000000000000000000000000000000000")));
+
+ var missedTypes = new HashSet<>(Arrays.asList(NativeTypeSpec.values()));
+
+ missedTypes.removeAll(tmp.keySet());
+
+ assertThat(missedTypes, empty());
+
+ DEFAULT_VALUES_TO_TEST = Map.copyOf(tmp);
+ }
+
/**
* (de)Serialize schema test.
*/
@@ -122,26 +179,20 @@ public class AbstractSerializerTest {
/**
* (de)Serialize default value test.
*/
- @Test
- public void defaultValueSerializeTest() {
+ @ParameterizedTest
+ @MethodSource("generateTestArguments")
+ public void defaultValueSerialization(DefaultValueArg arg) {
AbstractSchemaSerializer assembler = SchemaSerializerImpl.INSTANCE;
+ var columnName = arg.type.spec().name();
+ var nullable = arg.defaultValue == null;
+
SchemaDescriptor desc = new SchemaDescriptor(100500,
new Column[]{
- new Column("A", NativeTypes.INT8, false, () -> (byte) 1),
- new Column("B", NativeTypes.INT16, false, () -> (short) 1),
- new Column("C", NativeTypes.INT32, false, () -> 1),
- new Column("D", NativeTypes.INT64, false, () -> 1L),
- new Column("E", NativeTypes.UUID, false, () -> new UUID(12, 34)),
- new Column("F", NativeTypes.FLOAT, false, () -> 1.0f),
- new Column("G", NativeTypes.DOUBLE, false, () -> 1.0d),
- new Column("H", NativeTypes.DATE, false),
+ new Column("ID", NativeTypes.INT8, false)
},
new Column[]{
- new Column("A1", NativeTypes.stringOf(128), false, () -> "test"),
- new Column("B1", NativeTypes.numberOf(255), false, () -> BigInteger.TEN),
- new Column("C1", NativeTypes.decimalOf(128, 64), false, () -> BigDecimal.TEN),
- new Column("D1", NativeTypes.bitmaskOf(256), false, BitSet::new)
+ new Column(columnName, arg.type, nullable, () -> arg.defaultValue)
}
);
@@ -149,21 +200,13 @@ public class AbstractSerializerTest {
SchemaDescriptor deserialize = assembler.deserialize(serialize);
- //key columns
- assertEquals(deserialize.column("A").defaultValue(), (byte) 1);
- assertEquals(deserialize.column("B").defaultValue(), (short) 1);
- assertEquals(deserialize.column("C").defaultValue(), 1);
- assertEquals(deserialize.column("D").defaultValue(), 1L);
- assertEquals(deserialize.column("E").defaultValue(), new UUID(12, 34));
- assertEquals(deserialize.column("F").defaultValue(), 1.0f);
- assertEquals(deserialize.column("G").defaultValue(), 1.0d);
- assertNull(deserialize.column("H").defaultValue());
-
- //value columns
- assertEquals(deserialize.column("A1").defaultValue(), "test");
- assertEquals(deserialize.column("B1").defaultValue(), BigInteger.TEN);
- assertEquals(deserialize.column("C1").defaultValue(), BigDecimal.TEN);
- assertEquals(deserialize.column("D1").defaultValue(), new BitSet());
+ assertThat(deserialize.keyColumns().length(), equalTo(1));
+
+ var column = deserialize.valueColumns().columns()[0];
+
+ assertThat(column.name(), equalTo(columnName));
+ assertThat(column.nullable(), equalTo(nullable));
+ assertThat(column.defaultValue(), equalTo(arg.defaultValue));
}
/**
@@ -202,4 +245,134 @@ public class AbstractSerializerTest {
assertEquals(1, mapper1.map(0));
assertEquals(c1, mapper1.mappedColumn(2));
}
+
+ private static Iterable<DefaultValueArg> generateTestArguments() {
+ var paramList = new ArrayList<DefaultValueArg>();
+
+ for (var entry : DEFAULT_VALUES_TO_TEST.entrySet()) {
+ for (var defaultValue : entry.getValue()) {
+ paramList.add(
+ new DefaultValueArg(specToType(entry.getKey()), adjust(defaultValue))
+ );
+ }
+ }
+ return paramList;
+ }
+
+ /**
+ * Adjust the given value.
+ *
+ * <p>Some values need to be adjusted before comparison. For example, decimal values should be adjusted
+ * in order to have the same scale, because '1.0' not equals to '1.00'.
+ *
+ * @param val Value to adjust.
+ * @param <T> Type of te value.
+ * @return Adjusted value.
+ */
+ @SuppressWarnings("unchecked")
+ protected static <T> T adjust(T val) {
+ if (val instanceof BigDecimal) {
+ return (T) ((BigDecimal) val).setScale(DecimalColumnType.DEFAULT_SCALE, HALF_UP);
+ }
+
+ return val;
+ }
+
+ /** Creates a column type from given type spec. */
+ protected static NativeType specToType(NativeTypeSpec spec) {
+ switch (spec) {
+ case INT8:
+ return NativeTypes.INT8;
+ case INT16:
+ return NativeTypes.INT16;
+ case INT32:
+ return NativeTypes.INT32;
+ case INT64:
+ return NativeTypes.INT64;
+ case FLOAT:
+ return NativeTypes.FLOAT;
+ case DOUBLE:
+ return NativeTypes.DOUBLE;
+ case DECIMAL:
+ return NativeTypes.decimalOf(DecimalColumnType.DEFAULT_PRECISION, DecimalColumnType.DEFAULT_SCALE);
+ case DATE:
+ return NativeTypes.DATE;
+ case TIME:
+ return NativeTypes.time();
+ case DATETIME:
+ return NativeTypes.datetime();
+ case TIMESTAMP:
+ return NativeTypes.timestamp();
+ case NUMBER:
+ return NativeTypes.numberOf(DecimalColumnType.DEFAULT_PRECISION);
+ case STRING:
+ return NativeTypes.stringOf(Byte.MAX_VALUE);
+ case UUID:
+ return NativeTypes.UUID;
+ case BYTES:
+ return NativeTypes.blobOf(Byte.MAX_VALUE);
+ case BITMASK:
+ return NativeTypes.bitmaskOf(Byte.MAX_VALUE);
+ default:
+ throw new IllegalStateException("Unknown type spec [spec=" + spec + ']');
+ }
+ }
+
+ /** Creates a bit set from binary string. */
+ private static BitSet fromBinString(String binString) {
+ var bs = new BitSet();
+
+ var idx = 0;
+ for (var c : binString.toCharArray()) {
+ if (c == '1') {
+ bs.set(idx);
+ }
+
+ idx++;
+ }
+
+ return bs;
+ }
+
+ /**
+ * Converts the given value to a string representation.
+ *
+ * <p>Convenient method to convert a value to a string. Some types don't override
+ * {@link Object#toString()} method (any array, for instance), hence should be converted to a string manually.
+ */
+ private static String toString(Object val) {
+ if (val instanceof byte[]) {
+ return Arrays.toString((byte[]) val);
+ }
+
+ if (val == null) {
+ return "null";
+ }
+
+ return val.toString();
+ }
+
+ /**
+ * Class represents a default value of particular type.
+ */
+ private static class DefaultValueArg {
+ final NativeType type;
+ final Object defaultValue;
+
+ /**
+ * Constructor.
+ *
+ * @param type Type of the value
+ * @param defaultValue value itself.
+ */
+ public DefaultValueArg(NativeType type, Object defaultValue) {
+ this.type = type;
+ this.defaultValue = defaultValue;
+ }
+
+ @Override
+ public String toString() {
+ return type.spec().name() + ": " + AbstractSerializerTest.toString(defaultValue);
+ }
+ }
}
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 fe9455d2d..f798c3154 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
@@ -226,7 +226,7 @@ public class IgniteTypeFactory extends JavaTypeFactoryImpl {
ColumnType.stringOf(relType.getPrecision());
case BINARY:
case VARBINARY:
- return relType.getPrecision() == PRECISION_NOT_SPECIFIED ? ColumnType.blobOf() :
+ return relType.getPrecision() == PRECISION_NOT_SPECIFIED ? ColumnType.blob() :
ColumnType.blobOf(relType.getPrecision());
default:
throw new IllegalArgumentException("Type is not supported.");
diff --git a/modules/storage-rocksdb/src/test/java/org/apache/ignite/internal/storage/rocksdb/index/RocksDbSortedIndexStorageTest.java b/modules/storage-rocksdb/src/test/java/org/apache/ignite/internal/storage/rocksdb/index/RocksDbSortedIndexStorageTest.java
index e659875af..1c6cde603 100644
--- a/modules/storage-rocksdb/src/test/java/org/apache/ignite/internal/storage/rocksdb/index/RocksDbSortedIndexStorageTest.java
+++ b/modules/storage-rocksdb/src/test/java/org/apache/ignite/internal/storage/rocksdb/index/RocksDbSortedIndexStorageTest.java
@@ -180,9 +180,9 @@ public class RocksDbSortedIndexStorageTest {
ColumnType.DATE,
ColumnType.bitmaskOf(32),
ColumnType.string(),
- ColumnType.blobOf(),
- ColumnType.numberOf(),
- ColumnType.decimalOf(),
+ ColumnType.blob(),
+ ColumnType.number(),
+ ColumnType.decimal(),
ColumnType.time(),
ColumnType.datetime(),
ColumnType.timestamp()