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()