diff --git a/modules/api/src/main/java/org/apache/ignite/schema/ColumnType.java b/modules/api/src/main/java/org/apache/ignite/schema/ColumnType.java
index 9d69a14..d15e72f 100644
--- a/modules/api/src/main/java/org/apache/ignite/schema/ColumnType.java
+++ b/modules/api/src/main/java/org/apache/ignite/schema/ColumnType.java
@@ -57,10 +57,22 @@
     /** 128-bit UUID. */
     public static final ColumnType UUID = new ColumnType(ColumnTypeSpec.UUID);
 
+    /** Timezone-free three-part value representing a year, month, and day. */
+    public static final ColumnType DATE = new ColumnType(ColumnTypeSpec.DATE);
+
+    /** String varlen type of unlimited length. */
+    private static final VarLenColumnType UNLIMITED_STRING = stringOf(0);
+
+    /** Blob varlen type of unlimited length. */
+    private static final VarLenColumnType UNLIMITED_BLOB = blobOf(0);
+
+    /** Number type with unlimited precision. */
+    public static final NumberColumnType UNLIMITED_NUMBER = new NumberColumnType(ColumnTypeSpec.NUMBER, NumberColumnType.UNLIMITED_PRECISION);
+
     /**
-     * Bitmask type factory method.
+     * Returns bit mask type.
      *
-     * @param bits Bitmask size in bits.
+     * @param bits Bit mask size in bits.
      * @return Bitmap type.
      */
     public static VarLenColumnType bitmaskOf(int bits) {
@@ -68,16 +80,16 @@
     }
 
     /**
-     * String factory method.
+     * Returns string type of unlimited length.
      *
      * @return String type.
      */
     public static VarLenColumnType string() {
-        return stringOf(0);
+        return UNLIMITED_STRING;
     }
 
     /**
-     * String factory method for fix-sized string type.
+     * Return string type of limited size.
      *
      * @param length String length in chars.
      * @return String type.
@@ -87,16 +99,17 @@
     }
 
     /**
-     * Blob type factory method.
+     * Returns blob type of unlimited length.
      *
      * @return Blob type.
+     * @see #blobOf(int)
      */
     public static VarLenColumnType blobOf() {
-        return blobOf(0);
+        return UNLIMITED_BLOB;
     }
 
     /**
-     * Blob type factory method for fix-sized blob.
+     * Return blob type of limited length.
      *
      * @param length Blob length in bytes.
      * @return Blob type.
@@ -106,11 +119,11 @@
     }
 
     /**
-     * Number type factory method.
+     * Returns number type with given precision.
      *
      * @param precision Precision of value.
      * @return Number type.
-     * @throws IllegalArgumentException If precision is not positive.
+     * @throws IllegalArgumentException If precision value was invalid.
      */
     public static NumberColumnType numberOf(int precision) {
         if (precision <= 0)
@@ -120,21 +133,22 @@
     }
 
     /**
-     * Number type factory method.
+     * Returns number type with the default precision.
      *
      * @return Number type.
+     * @see #numberOf(int)
      */
     public static NumberColumnType numberOf() {
-        return new NumberColumnType(ColumnTypeSpec.NUMBER, NumberColumnType.UNLIMITED_PRECISION);
+        return UNLIMITED_NUMBER;
     }
 
     /**
-     * Decimal type factory method.
+     * Returns decimal type with given precision and scale.
      *
      * @param precision Precision.
      * @param scale Scale.
      * @return Decimal type.
-     * @throws IllegalArgumentException If precision or scale are invalid.
+     * @throws IllegalArgumentException If precision and/or scale values were invalid.
      */
     public static DecimalColumnType decimalOf(int precision, int scale) {
         if (precision <= 0)
@@ -145,15 +159,16 @@
 
         if (precision < scale)
             throw new IllegalArgumentException("Precision [" + precision + "] must be" +
-                " not lower than scale [ " + scale + " ].");
+                                                   " not lower than scale [ " + scale + " ].");
 
         return new DecimalColumnType(ColumnTypeSpec.DECIMAL, precision, scale);
     }
 
     /**
-     * Decimal type factory method with default precision and scale values.
+     * Returns decimal type with default precision and scale values.
      *
      * @return Decimal type.
+     * @see #decimalOf(int, int)
      */
     public static DecimalColumnType decimalOf() {
         return new DecimalColumnType(
@@ -164,6 +179,93 @@
     }
 
     /**
+     * Returns timezone-free type representing a time of day in hours, minutes, seconds, and fractional seconds
+     * with the default precision of 6 (microseconds).
+     *
+     * @return Native type.
+     * @see TemporalColumnType#DEFAULT_PRECISION
+     * @see #time(int)
+     */
+    public static TemporalColumnType time() {
+        return new TemporalColumnType(ColumnTypeSpec.TIME, TemporalColumnType.DEFAULT_PRECISION);
+    }
+
+    /**
+     * Returns timezone-free type representing a time of day in hours, minutes, seconds, and fractional seconds.
+     * <p>
+     * Precision is a number of digits in fractional seconds part,
+     * from 0 - whole seconds precision up to 9 - nanoseconds precision.
+     *
+     * @param precision The number of digits in fractional seconds part. Accepted values are in range [0-9].
+     * @return Native type.
+     * @throws IllegalArgumentException If precision value was invalid.
+     */
+    public static TemporalColumnType time(int precision) {
+        if (precision < 0 || precision > 9)
+            throw new IllegalArgumentException("Unsupported fractional seconds precision: " + precision);
+
+        return new TemporalColumnType(ColumnTypeSpec.TIME, precision);
+    }
+
+    /**
+     * Returns timezone-free datetime encoded as (date, time) with the default time precision of 6 (microseconds).
+     *
+     * @return Native type.
+     * @see TemporalColumnType#DEFAULT_PRECISION
+     * @see #datetime(int)
+     */
+    public static TemporalColumnType datetime() {
+        return new TemporalColumnType(ColumnTypeSpec.DATETIME, TemporalColumnType.DEFAULT_PRECISION);
+    }
+
+    /**
+     * Returns timezone-free datetime encoded as (date, time).
+     * <p>
+     * Precision is a number of digits in fractional seconds part of time,
+     * from 0 - whole seconds precision up to 9 - nanoseconds precision.
+     *
+     * @param precision The number of digits in fractional seconds part. Accepted values are in range [0-9].
+     * @return Native type.
+     * @throws IllegalArgumentException If precision value was invalid.
+     */
+    public static TemporalColumnType datetime(int precision) {
+        if (precision < 0 || precision > 9)
+            throw new IllegalArgumentException("Unsupported fractional seconds precision: " + precision);
+
+        return new TemporalColumnType(ColumnTypeSpec.DATETIME, precision);
+    }
+
+    /**
+     * Returns point in time as number of ticks since Jan 1, 1970 00:00:00.000 (with no timezone)
+     * with the default precision of 6 (microseconds).
+     *
+     * @return Native type.
+     * @see TemporalColumnType#DEFAULT_PRECISION
+     * @see #timestamp(int)
+     */
+    public static TemporalColumnType timestamp() {
+        return new TemporalColumnType(ColumnTypeSpec.TIMESTAMP, TemporalColumnType.DEFAULT_PRECISION);
+    }
+
+    /**
+     * Returns point in time as number of ticks since Jan 1, 1970 00:00:00.000 (with no timezone).
+     * Ticks that are stored can be precised to second, millisecond, microsecond or nanosecond.
+     * <p>
+     * Precision is a number of digits in fractional seconds part of time,
+     * from 0 - whole seconds precision up to 9 - nanoseconds precision.
+     *
+     * @param precision The number of digits in fractional seconds part. Accepted values are in range [0-9].
+     * @return Native type.
+     * @throws IllegalArgumentException If precision value was invalid.
+     */
+    public static TemporalColumnType timestamp(int precision) {
+        if (precision < 0 || precision > 9)
+            throw new IllegalArgumentException("Unsupported fractional seconds precision: " + precision);
+
+        return new TemporalColumnType(ColumnTypeSpec.TIMESTAMP, precision);
+    }
+
+    /**
      * Column type of variable length.
      */
     public static class VarLenColumnType extends ColumnType {
@@ -274,8 +376,7 @@
 
             DecimalColumnType type = (DecimalColumnType)o;
 
-            return precision == type.precision &&
-                scale == type.scale;
+            return precision == type.precision && scale == type.scale;
         }
 
         /** {@inheritDoc} */
@@ -289,7 +390,7 @@
      */
     public static class NumberColumnType extends ColumnType {
         /** Undefined precision. */
-        public static final int UNLIMITED_PRECISION = 0;
+        private static final int UNLIMITED_PRECISION = 0;
 
         /** Max precision of value. If -1, column has no precision restrictions. */
         private final int precision;
@@ -309,7 +410,7 @@
         /**
          * Returns column precision.
          *
-         * @return Max value precision.
+         * @return Max number of digits.
          */
         public int precision() {
             return precision;
@@ -319,11 +420,71 @@
         @Override public boolean equals(Object o) {
             if (this == o)
                 return true;
+
             if (o == null || getClass() != o.getClass())
                 return false;
+
             if (!super.equals(o))
                 return false;
+
             NumberColumnType type = (NumberColumnType)o;
+
+            return precision == type.precision;
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            return Objects.hash(super.hashCode(), precision);
+        }
+    }
+
+    /**
+     * Column type of variable length.
+     */
+    public static class TemporalColumnType extends ColumnType {
+        /** Default temporal type precision: microseconds. */
+        public static final int DEFAULT_PRECISION = 6;
+
+        /** Fractional seconds precision. */
+        private final int precision;
+
+        /**
+         * Creates temporal type.
+         *
+         * @param typeSpec Type spec.
+         * @param precision Fractional seconds meaningful digits. Allowed values are 0-9,
+         * where {@code 0} means second precision, {@code 9} means 1-ns precision.
+         */
+        private TemporalColumnType(ColumnTypeSpec typeSpec, int precision) {
+            super(typeSpec);
+
+            assert precision >= 0 && precision < 10;
+
+            this.precision = precision;
+        }
+
+        /**
+         * Return column precision.
+         *
+         * @return Number of fractional seconds meaningful digits.
+         */
+        public int precision() {
+            return precision;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean equals(Object o) {
+            if (this == o)
+                return true;
+
+            if (o == null || getClass() != o.getClass())
+                return false;
+
+            if (!super.equals(o))
+                return false;
+
+            TemporalColumnType type = (TemporalColumnType)o;
+
             return precision == type.precision;
         }
 
@@ -370,6 +531,18 @@
         /** A decimal floating-point number. */
         DECIMAL,
 
+        /** Timezone-free date. */
+        DATE,
+
+        /** Timezone-free time with precision. */
+        TIME,
+
+        /** Timezone-free datetime. */
+        DATETIME,
+
+        /** Number of ticks since Jan 1, 1970 00:00:00.000 (with no timezone). Tick unit depends on precision. */
+        TIMESTAMP,
+
         /** 128-bit UUID. */
         UUID,
 
diff --git a/modules/api/src/main/java/org/apache/ignite/table/Tuple.java b/modules/api/src/main/java/org/apache/ignite/table/Tuple.java
index adc38e4..fd0e346 100644
--- a/modules/api/src/main/java/org/apache/ignite/table/Tuple.java
+++ b/modules/api/src/main/java/org/apache/ignite/table/Tuple.java
@@ -17,6 +17,10 @@
 
 package org.apache.ignite.table;
 
+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.binary.BinaryObject;
@@ -237,4 +241,68 @@
      * @return Column value.
      */
     BitSet bitmaskValue(int columnIndex);
+
+    /**
+     * Gets {@code LocalDate} column value.
+     *
+     * @param columnName Column name.
+     * @return Column value.
+     */
+    LocalDate dateValue(String columnName);
+
+    /**
+     * Gets {@code LocalDate} column value.
+     *
+     * @param columnIndex Column index.
+     * @return Column value.
+     */
+    LocalDate dateValue(int columnIndex);
+
+    /**
+     * Gets {@code LocalTime} column value.
+     *
+     * @param columnName Column name.
+     * @return Column value.
+     */
+    LocalTime timeValue(String columnName);
+
+    /**
+     * Gets {@code LocalTime} column value.
+     *
+     * @param columnIndex Column index.
+     * @return Column value.
+     */
+    LocalTime timeValue(int columnIndex);
+
+    /**
+     * Gets {@code LocalDateTime} column value.
+     *
+     * @param columnName Column name.
+     * @return Column value.
+     */
+    LocalDateTime datetimeValue(String columnName);
+
+    /**
+     * Gets {@code LocalDateTime} column value.
+     *
+     * @param columnIndex Column index.
+     * @return Column value.
+     */
+    LocalDateTime datetimeValue(int columnIndex);
+
+    /**
+     * Gets {@code Instant} column value.
+     *
+     * @param columnName Column name.
+     * @return Column value.
+     */
+    Instant timestampValue(String columnName);
+
+    /**
+     * Gets {@code Instant} column value.
+     *
+     * @param columnIndex Column index.
+     * @return Column value.
+     */
+    Instant timestampValue(int columnIndex);
 }
diff --git a/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientDataType.java b/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientDataType.java
index 45d1280..dbda15f 100644
--- a/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientDataType.java
+++ b/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientDataType.java
@@ -53,4 +53,16 @@
 
     /** BitMask. */
     public static final int BITMASK = 11;
+
+    /** Date. */
+    public static final int DATE = 12;
+
+    /** Time. */
+    public static final int TIME = 13;
+
+    /** DateTime. */
+    public static final int DATETIME = 14;
+
+    /** Timestamp. */
+    public static final int TIMESTAMP = 15;
 }
diff --git a/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientMessagePacker.java b/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientMessagePacker.java
index facefa2..8b3254d 100644
--- a/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientMessagePacker.java
+++ b/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientMessagePacker.java
@@ -22,6 +22,10 @@
 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 io.netty.buffer.ByteBuf;
@@ -348,6 +352,59 @@
     }
 
     /**
+     * Writes a date.
+     *
+     * @param val Date value.
+     * @return This instance.
+     * @throws UnsupportedOperationException Not supported.
+     */
+    public ClientMessagePacker packDate(LocalDate val) {
+        assert !closed : "Packer is closed";
+
+        throw new UnsupportedOperationException("TODO: IGNITE-15163");
+    }
+
+    /**
+     * Writes a time.
+     *
+     * @param val Time value.
+     * @return This instance.
+     * @throws UnsupportedOperationException Not supported.
+     */
+    public ClientMessagePacker packTime(LocalTime val) {
+        assert !closed : "Packer is closed";
+
+        throw new UnsupportedOperationException("TODO: IGNITE-15163");
+    }
+
+    /**
+     * Writes a datetime.
+     *
+     * @param val Datetime value.
+     * @return This instance.
+     * @throws UnsupportedOperationException Not supported.
+     */
+    public ClientMessagePacker packDateTime(LocalDateTime val) {
+        packDate(val.toLocalDate());
+        packTime(val.toLocalTime());
+
+        return this;
+    }
+
+    /**
+     * Writes a timestamp.
+     *
+     * @param val Timestamp value.
+     * @return This instance.
+     * @throws UnsupportedOperationException Not supported.
+     */
+    public ClientMessagePacker packTimestamp(Instant val) {
+        assert !closed : "Packer is closed";
+
+        throw new UnsupportedOperationException("TODO: IGNITE-15163");
+    }
+
+    /**
      * Packs an object.
      *
      * @param val Object value.
@@ -384,6 +441,18 @@
         if (val instanceof BitSet)
             return packBitSet((BitSet) val);
 
+        if (val instanceof LocalDate)
+            return packDate((LocalDate)val);
+
+        if (val instanceof LocalTime)
+            return packTime((LocalTime)val);
+
+        if (val instanceof LocalDateTime)
+            return packDateTime((LocalDateTime)val);
+
+        if (val instanceof Instant)
+            return packTimestamp((Instant)val);
+
         // TODO: Support all basic types IGNITE-15163
         throw new UnsupportedOperationException("Unsupported type, can't serialize: " + val.getClass());
     }
diff --git a/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientMessageUnpacker.java b/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientMessageUnpacker.java
index a058c9c..cdf1e18 100644
--- a/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientMessageUnpacker.java
+++ b/modules/client-common/src/main/java/org/apache/ignite/client/proto/ClientMessageUnpacker.java
@@ -22,6 +22,10 @@
 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 io.netty.buffer.ByteBuf;
@@ -38,6 +42,8 @@
 
 import static org.apache.ignite.client.proto.ClientDataType.BITMASK;
 import static org.apache.ignite.client.proto.ClientDataType.BYTES;
+import static org.apache.ignite.client.proto.ClientDataType.DATE;
+import static org.apache.ignite.client.proto.ClientDataType.DATETIME;
 import static org.apache.ignite.client.proto.ClientDataType.DECIMAL;
 import static org.apache.ignite.client.proto.ClientDataType.DOUBLE;
 import static org.apache.ignite.client.proto.ClientDataType.FLOAT;
@@ -46,6 +52,8 @@
 import static org.apache.ignite.client.proto.ClientDataType.INT64;
 import static org.apache.ignite.client.proto.ClientDataType.INT8;
 import static org.apache.ignite.client.proto.ClientDataType.STRING;
+import static org.apache.ignite.client.proto.ClientDataType.TIME;
+import static org.apache.ignite.client.proto.ClientDataType.TIMESTAMP;
 
 /**
  * Ignite-specific MsgPack extension based on Netty ByteBuf.
@@ -362,6 +370,54 @@
     }
 
     /**
+     * Reads a date.
+     *
+     * @return Date value.
+     * @throws UnsupportedOperationException Not supported yet.
+     */
+    public LocalDate unpackDate() {
+        assert refCnt > 0 : "Unpacker is closed";
+
+        throw new UnsupportedOperationException("TODO: IGNITE-15163");
+    }
+
+    /**
+     * Reads a time.
+     *
+     * @return Time value.
+     * @throws UnsupportedOperationException Not supported yet.
+     */
+    public LocalTime unpackTime() {
+        assert refCnt > 0 : "Unpacker is closed";
+
+        throw new UnsupportedOperationException("TODO: IGNITE-15163");
+    }
+
+    /**
+     * Reads a datetime.
+     *
+     * @return Datetime value.
+     * @throws UnsupportedOperationException Not supported yet.
+     */
+    public LocalDateTime unpackDateTime() {
+        assert refCnt > 0 : "Unpacker is closed";
+
+        throw new UnsupportedOperationException("TODO: IGNITE-15163");
+    }
+
+    /**
+     * Reads a timestamp.
+     *
+     * @return Timestamp value.
+     * @throws UnsupportedOperationException Not supported yet.
+     */
+    public Instant unpackTimestamp() {
+        assert refCnt > 0 : "Unpacker is closed";
+
+        throw new UnsupportedOperationException("TODO: IGNITE-15163");
+    }
+
+    /**
      * Unpacks an object based on the specified type.
      *
      * @param dataType Data type code.
@@ -408,6 +464,18 @@
 
             case BITMASK:
                 return unpackBitSet();
+
+            case DATE:
+                return unpackDate();
+
+            case TIME:
+                return unpackTime();
+
+            case DATETIME:
+                return unpackDateTime();
+
+            case TIMESTAMP:
+                return unpackTimestamp();
         }
 
         throw new IgniteException("Unknown client data type: " + dataType);
diff --git a/modules/client-handler/src/main/java/org/apache/ignite/client/handler/requests/table/ClientTableCommon.java b/modules/client-handler/src/main/java/org/apache/ignite/client/handler/requests/table/ClientTableCommon.java
index 9cc3dc3..3bff8d6 100644
--- a/modules/client-handler/src/main/java/org/apache/ignite/client/handler/requests/table/ClientTableCommon.java
+++ b/modules/client-handler/src/main/java/org/apache/ignite/client/handler/requests/table/ClientTableCommon.java
@@ -18,6 +18,10 @@
 package org.apache.ignite.client.handler.requests.table;
 
 import java.math.BigDecimal;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
 import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.Collection;
@@ -49,7 +53,7 @@
      * @param schemaVer Schema version.
      * @param schema Schema.
      */
-    public static void writeSchema(ClientMessagePacker packer,int schemaVer, SchemaDescriptor schema) {
+    public static void writeSchema(ClientMessagePacker packer, int schemaVer, SchemaDescriptor schema) {
         packer.packInt(schemaVer);
 
         if (schema == null) {
@@ -85,7 +89,7 @@
             return;
         }
 
-        var schema = ((SchemaAware) tuple).schema();
+        var schema = ((SchemaAware)tuple).schema();
 
         writeTuple(packer, tuple, schema);
     }
@@ -99,9 +103,9 @@
      * @throws IgniteException on failed serialization.
      */
     public static void writeTuple(
-            ClientMessagePacker packer,
-            Tuple tuple,
-            SchemaDescriptor schema
+        ClientMessagePacker packer,
+        Tuple tuple,
+        SchemaDescriptor schema
     ) {
         writeTuple(packer, tuple, schema, false, false);
     }
@@ -116,10 +120,10 @@
      * @throws IgniteException on failed serialization.
      */
     public static void writeTuple(
-            ClientMessagePacker packer,
-            Tuple tuple,
-            SchemaDescriptor schema,
-            boolean skipHeader
+        ClientMessagePacker packer,
+        Tuple tuple,
+        SchemaDescriptor schema,
+        boolean skipHeader
     ) {
         writeTuple(packer, tuple, schema, skipHeader, false);
     }
@@ -135,11 +139,11 @@
      * @throws IgniteException on failed serialization.
      */
     public static void writeTuple(
-            ClientMessagePacker packer,
-            Tuple tuple,
-            SchemaDescriptor schema,
-            boolean skipHeader,
-            boolean keyOnly
+        ClientMessagePacker packer,
+        Tuple tuple,
+        SchemaDescriptor schema,
+        boolean skipHeader,
+        boolean keyOnly
     ) {
         if (tuple == null) {
             packer.packNil();
@@ -189,12 +193,13 @@
 
         for (Tuple tuple : tuples) {
             if (schema == null) {
-                schema = ((SchemaAware) tuple).schema();
+                schema = ((SchemaAware)tuple).schema();
 
                 packer.packInt(schema.version());
                 packer.packInt(tuples.size());
-            } else
-                assert schema.version() == ((SchemaAware) tuple).schema().version();
+            }
+            else
+                assert schema.version() == ((SchemaAware)tuple).schema().version();
 
             writeTuple(packer, tuple, schema, true, keyOnly);
         }
@@ -257,10 +262,10 @@
      * @return Tuple.
      */
     public static Tuple readTuple(
-            ClientMessageUnpacker unpacker,
-            TableImpl table,
-            boolean keyOnly,
-            SchemaDescriptor schema
+        ClientMessageUnpacker unpacker,
+        TableImpl table,
+        boolean keyOnly,
+        SchemaDescriptor schema
     ) {
         var builder = table.tupleBuilder();
 
@@ -367,6 +372,18 @@
 
             case BITMASK:
                 return ClientDataType.BITMASK;
+
+            case DATE:
+                return ClientDataType.DATE;
+
+            case TIME:
+                return ClientDataType.TIME;
+
+            case DATETIME:
+                return ClientDataType.DATETIME;
+
+            case TIMESTAMP:
+                return ClientDataType.TIMESTAMP;
         }
 
         throw new IgniteException("Unsupported native type: " + spec);
@@ -382,43 +399,43 @@
 
         switch (col.type().spec()) {
             case INT8:
-                packer.packByte((byte) val);
+                packer.packByte((byte)val);
                 break;
 
             case INT16:
-                packer.packShort((short) val);
+                packer.packShort((short)val);
                 break;
 
             case INT32:
-                packer.packInt((int) val);
+                packer.packInt((int)val);
                 break;
 
             case INT64:
-                packer.packLong((long) val);
+                packer.packLong((long)val);
                 break;
 
             case FLOAT:
-                packer.packFloat((float) val);
+                packer.packFloat((float)val);
                 break;
 
             case DOUBLE:
-                packer.packDouble((double) val);
+                packer.packDouble((double)val);
                 break;
 
             case DECIMAL:
-                packer.packDecimal((BigDecimal) val);
+                packer.packDecimal((BigDecimal)val);
                 break;
 
             case UUID:
-                packer.packUuid((UUID) val);
+                packer.packUuid((UUID)val);
                 break;
 
             case STRING:
-                packer.packString((String) val);
+                packer.packString((String)val);
                 break;
 
             case BYTES:
-                byte[] bytes = (byte[]) val;
+                byte[] bytes = (byte[])val;
                 packer.packBinaryHeader(bytes.length);
                 packer.writePayload(bytes);
                 break;
@@ -427,6 +444,22 @@
                 packer.packBitSet((BitSet)val);
                 break;
 
+            case DATE:
+                packer.packDate((LocalDate)val);
+                break;
+
+            case TIME:
+                packer.packTime((LocalTime)val);
+                break;
+
+            case DATETIME:
+                packer.packDateTime((LocalDateTime)val);
+                break;
+
+            case TIMESTAMP:
+                packer.packTimestamp((Instant)val);
+                break;
+
             default:
                 throw new IgniteException("Data type not supported: " + col.type());
         }
diff --git a/modules/client/src/main/java/org/apache/ignite/internal/client/table/ClientTupleBuilder.java b/modules/client/src/main/java/org/apache/ignite/internal/client/table/ClientTupleBuilder.java
index 62a49d6..97a97f9 100644
--- a/modules/client/src/main/java/org/apache/ignite/internal/client/table/ClientTupleBuilder.java
+++ b/modules/client/src/main/java/org/apache/ignite/internal/client/table/ClientTupleBuilder.java
@@ -17,6 +17,10 @@
 
 package org.apache.ignite.internal.client.table;
 
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
 import java.util.BitSet;
 import java.util.Iterator;
 import java.util.UUID;
@@ -212,6 +216,46 @@
     }
 
     /** {@inheritDoc} */
+    @Override public LocalDate dateValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDate dateValue(int columnIndex) {
+        return value(columnIndex);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalTime timeValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalTime timeValue(int columnIndex) {
+        return value(columnIndex);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDateTime datetimeValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDateTime datetimeValue(int columnIndex) {
+        return value(columnIndex);
+    }
+
+    /** {@inheritDoc} */
+    @Override public Instant timestampValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public Instant timestampValue(int columnIndex) {
+        return value(columnIndex);
+    }
+
+    /** {@inheritDoc} */
     @NotNull @Override public Iterator<Object> iterator() {
         return new Iterator<>() {
             /** Current column index. */
diff --git a/modules/client/src/test/java/org/apache/ignite/client/ClientTupleBuilderTest.java b/modules/client/src/test/java/org/apache/ignite/client/ClientTupleBuilderTest.java
index 592988f..dbde506 100644
--- a/modules/client/src/test/java/org/apache/ignite/client/ClientTupleBuilderTest.java
+++ b/modules/client/src/test/java/org/apache/ignite/client/ClientTupleBuilderTest.java
@@ -17,9 +17,13 @@
 
 package org.apache.ignite.client;
 
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
 import java.util.BitSet;
 import java.util.UUID;
-
 import org.apache.ignite.client.proto.ClientDataType;
 import org.apache.ignite.internal.client.table.ClientColumn;
 import org.apache.ignite.internal.client.table.ClientSchema;
@@ -138,10 +142,19 @@
                 new ClientColumn("uuid", ClientDataType.UUID, false, false, 6),
                 new ClientColumn("str", ClientDataType.STRING, false, false, 7),
                 new ClientColumn("bits", ClientDataType.BITMASK, false, false, 8),
+                new ClientColumn("time", ClientDataType.TIME, false, false, 9),
+                new ClientColumn("date", ClientDataType.DATE, false, false, 10),
+                new ClientColumn("datetime", ClientDataType.DATETIME, false, false, 11),
+                new ClientColumn("timestamp", ClientDataType.TIMESTAMP, false, false, 12)
         });
 
         var uuid = UUID.randomUUID();
 
+        var date = LocalDate.of(1995, Month.MAY, 23);
+        var time = LocalTime.of(17, 0, 1, 222_333_444);
+        var datetime = LocalDateTime.of(1995, Month.MAY, 23, 17, 0, 1, 222_333_444);
+        var timestamp = Instant.now();
+
         var builder = new ClientTupleBuilder(schema)
                 .set("i8", (byte)1)
                 .set("i16", (short)2)
@@ -151,7 +164,11 @@
                 .set("double", (double)6.6)
                 .set("uuid", uuid)
                 .set("str", "8")
-                .set("bits", new BitSet(3));
+                .set("bits", new BitSet(3))
+                .set("date", date)
+                .set("time", time)
+                .set("datetime", datetime)
+                .set("timestamp", timestamp);
 
         var tuple = builder.build();
 
@@ -181,6 +198,11 @@
 
         assertEquals(0, tuple.bitmaskValue(8).length());
         assertEquals(0, tuple.bitmaskValue("bits").length());
+
+        assertEquals(date, tuple.dateValue("date"));
+        assertEquals(time, tuple.timeValue("time"));
+        assertEquals(datetime, tuple.datetimeValue("datetime"));
+        assertEquals(timestamp, tuple.timestampValue("timestamp"));
     }
 
     private static ClientTupleBuilder getBuilder() {
diff --git a/modules/client/src/test/java/org/apache/ignite/client/CustomTuple.java b/modules/client/src/test/java/org/apache/ignite/client/CustomTuple.java
index b48a1da..81fa756 100644
--- a/modules/client/src/test/java/org/apache/ignite/client/CustomTuple.java
+++ b/modules/client/src/test/java/org/apache/ignite/client/CustomTuple.java
@@ -17,6 +17,10 @@
 
 package org.apache.ignite.client;
 
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
 import java.util.BitSet;
 import java.util.Iterator;
 import java.util.UUID;
@@ -51,8 +55,10 @@
 
     @Override public String columnName(int columnIndex) {
         switch (columnIndex) {
-            case 0: return "id";
-            case 1: return "name";
+            case 0:
+                return "id";
+            case 1:
+                return "name";
         }
 
         return null;
@@ -60,8 +66,10 @@
 
     @Override public Integer columnIndex(String columnName) {
         switch (columnName) {
-            case "id": return 0;
-            case "name": return 1;
+            case "id":
+                return 0;
+            case "name":
+                return 1;
         }
 
         return null;
@@ -69,8 +77,10 @@
 
     @Override public <T> T valueOrDefault(String columnName, T def) {
         switch (columnName) {
-            case "id": return (T) id;
-            case "name": return (T) name;
+            case "id":
+                return (T)id;
+            case "name":
+                return (T)name;
         }
 
         return def;
@@ -82,8 +92,10 @@
 
     @Override public <T> T value(int columnIndex) {
         switch (columnIndex) {
-            case 0: return (T) id;
-            case 1: return (T) name;
+            case 0:
+                return (T)id;
+            case 1:
+                return (T)name;
         }
 
         return null;
@@ -169,6 +181,38 @@
         throw new UnsupportedOperationException();
     }
 
+    @Override public LocalDate dateValue(String columnName) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override public LocalDate dateValue(int columnIndex) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override public LocalTime timeValue(String columnName) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override public LocalTime timeValue(int columnIndex) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override public LocalDateTime datetimeValue(String columnName) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override public LocalDateTime datetimeValue(int columnIndex) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override public Instant timestampValue(String columnName) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override public Instant timestampValue(int columnIndex) {
+        throw new UnsupportedOperationException();
+    }
+
     @NotNull @Override public Iterator<Object> iterator() {
         throw new UnsupportedOperationException();
     }
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/NativeTypeSpec.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/NativeTypeSpec.java
index 8624633..be3da0f 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/NativeTypeSpec.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/NativeTypeSpec.java
@@ -19,6 +19,10 @@
 
 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 org.apache.ignite.internal.schema.row.Row;
 import org.apache.ignite.internal.tostring.S;
@@ -150,6 +154,46 @@
         @Override public Object objectValue(Row tup, int colIdx) {
             return tup.numberValue(colIdx);
         }
+    },
+
+    /**
+     * Native type representing a timezone-free date.
+     */
+    DATE("date", true) {
+        /** {@inheritDoc} */
+        @Override public Object objectValue(Row tup, int colIdx) {
+            return tup.dateValue(colIdx);
+        }
+    },
+
+    /**
+     * Native type representing a timezone-free time.
+     */
+    TIME("time", true) {
+        /** {@inheritDoc} */
+        @Override public Object objectValue(Row tup, int colIdx) {
+            return tup.timeValue(colIdx);
+        }
+    },
+
+    /**
+     * Native type representing a timezone-free datetime.
+     */
+    DATETIME("datetime", true) {
+        /** {@inheritDoc} */
+        @Override public Object objectValue(Row tup, int colIdx) {
+            return tup.dateTimeValue(colIdx);
+        }
+    },
+
+    /**
+     * Native type representing a timestamp in milliseconds since Jan 1, 1970 00:00:00.000 (with no timezone).
+     */
+    TIMESTAMP("timestamp", true) {
+        /** {@inheritDoc} */
+        @Override public Object objectValue(Row tup, int colIdx) {
+            return tup.timestampValue(colIdx);
+        }
     };
 
     /** Flag indicating whether this type specifies a fixed-length type. */
@@ -234,7 +278,17 @@
         else if (cls == Double.class)
             return NativeTypeSpec.DOUBLE;
 
-        // Other types
+        // Temporal types.
+        else if (cls == LocalDate.class)
+            return NativeTypeSpec.DATE;
+        else if (cls == LocalTime.class)
+            return NativeTypeSpec.TIME;
+        else if (cls == LocalDateTime.class)
+            return NativeTypeSpec.DATETIME;
+        else if (cls == Instant.class)
+            return NativeTypeSpec.TIMESTAMP;
+
+        // Other types.
         else if (cls == byte[].class)
             return NativeTypeSpec.BYTES;
         else if (cls == String.class)
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/NativeTypes.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/NativeTypes.java
index 00fb486..508be27 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/NativeTypes.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/NativeTypes.java
@@ -53,6 +53,9 @@
     /** */
     public static final NativeType BYTES = new VarlenNativeType(NativeTypeSpec.BYTES, Integer.MAX_VALUE);
 
+    /** Timezone-free three-part value representing a year, month, and day. */
+    public static final NativeType DATE = new NativeType(NativeTypeSpec.DATE, 3);
+
     /** Don't allow to create an instance. */
     private NativeTypes() {
     }
@@ -109,6 +112,66 @@
     }
 
     /**
+     * Creates a TIME type with given precision.
+     *
+     * @param precision Fractional seconds meaningful digits. Allowed values are 0-9 for second to nanosecond precision.
+     * @return Native type.
+     */
+    public static NativeType time(int precision) {
+        return TemporalNativeType.time(precision);
+    }
+
+    /**
+     * Creates DATETIME type as pair (date, time).
+     *
+     * @param precision Fractional seconds meaningful digits. Allowed values are 0-9 for second to nanosecond precision.
+     * @return Native type.
+     */
+    public static NativeType datetime(int precision) {
+        return TemporalNativeType.datetime(precision);
+    }
+
+    /**
+     * Creates TIMESTAMP type.
+     *
+     * @param precision Fractional seconds meaningful digits. Allowed values are 0-9 for second to nanosecond precision.
+     * @return Native type.
+     */
+    public static NativeType timestamp(int precision) {
+        return TemporalNativeType.timestamp(precision);
+    }
+
+    /**
+     * Creates a TIME type with default precision.
+     *
+     * @return Native type.
+     * @see #time(int)
+     */
+    public static NativeType time() {
+        return TemporalNativeType.time(ColumnType.TemporalColumnType.DEFAULT_PRECISION);
+    }
+
+    /**
+     * Creates DATETIME type with default precision.
+     *
+     * @return Native type.
+     * @see #datetime(int)
+     */
+    public static NativeType datetime() {
+        return TemporalNativeType.datetime(ColumnType.TemporalColumnType.DEFAULT_PRECISION);
+    }
+
+    /**
+     * Creates TIMESTAMP type with default precision.
+     *
+     * @return Native type.
+     * @see #timestamp(int)
+     */
+    public static NativeType timestamp() {
+        return TemporalNativeType.timestamp(ColumnType.TemporalColumnType.DEFAULT_PRECISION);
+    }
+
+    /**
      * Return the native type for specified object.
      *
      * @param val Object to map to native type.
@@ -142,6 +205,18 @@
             case UUID:
                 return UUID;
 
+            case DATE:
+                return DATE;
+
+            case TIME:
+                return time();
+
+            case DATETIME:
+                return datetime();
+
+            case TIMESTAMP:
+                return timestamp();
+
             case STRING:
                 return stringOf(((CharSequence)val).length());
 
@@ -204,6 +279,18 @@
             case UUID:
                 return UUID;
 
+            case DATE:
+                return DATE;
+
+            case TIME:
+                return time(((ColumnType.TemporalColumnType)type).precision());
+
+            case DATETIME:
+                return datetime(((ColumnType.TemporalColumnType)type).precision());
+
+            case TIMESTAMP:
+                return timestamp(((ColumnType.TemporalColumnType)type).precision());
+
             case BITMASK:
                 return new BitmaskNativeType(((ColumnType.VarLenColumnType)type).length());
 
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/TemporalNativeType.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/TemporalNativeType.java
new file mode 100644
index 0000000..ec29856
--- /dev/null
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/TemporalNativeType.java
@@ -0,0 +1,98 @@
+/*
+ * 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;
+
+import org.apache.ignite.internal.tostring.S;
+
+/**
+ * Temporal native type.
+ */
+public class TemporalNativeType extends NativeType {
+    /**
+     * Creates TIME type.
+     *
+     * @param precision Fractional seconds precision.
+     * @return Native type.
+     */
+    static TemporalNativeType time(int precision) {
+        int size = (precision > 3) ? 6 : 4;
+
+        return new TemporalNativeType(NativeTypeSpec.TIME, size, precision);
+    }
+
+    /**
+     * Creates DATETIME type.
+     *
+     * @param precision Fractional seconds precision.
+     * @return Native type.
+     */
+    static TemporalNativeType datetime(int precision) {
+        int size = NativeTypes.DATE.sizeInBytes() + ((precision > 3) ? 6 : 4);
+
+        return new TemporalNativeType(NativeTypeSpec.DATETIME, size, precision);
+    }
+
+    /**
+     * Creates TIMESTAMP type.
+     *
+     * @param precision Fractional seconds precision.
+     * @return Native type.
+     */
+    static TemporalNativeType timestamp(int precision) {
+        int size = (precision == 0) ? 8 : 12;
+
+        return new TemporalNativeType(NativeTypeSpec.TIMESTAMP, size, precision);
+    }
+
+    /** Fractional seconds precision. */
+    private final int precision;
+
+    /**
+     * Creates temporal type.
+     *
+     * @param typeSpec Type spec.
+     * @param precision Fractional seconds precision.
+     */
+    private TemporalNativeType(NativeTypeSpec typeSpec, int size, int precision) {
+        super(typeSpec, size);
+
+        if (precision < 0 || precision > 9)
+            throw new IllegalArgumentException("Unsupported fractional seconds precision: " + precision);
+
+        this.precision = precision;
+    }
+
+    /**
+     * Return fractional seconds precision.
+     *
+     * @return Precicion;
+     */
+    public int precision() {
+        return precision;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean mismatch(NativeType type) {
+        return super.mismatch(type) || precision < ((TemporalNativeType)type).precision;
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(TemporalNativeType.class.getSimpleName(), "name", spec(), "precision", precision);
+    }
+}
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 0927c25..9b0c5ca 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
@@ -19,6 +19,10 @@
 
 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.ArrayList;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
@@ -90,15 +94,19 @@
         putType(ColumnType.FLOAT);
         putType(ColumnType.DOUBLE);
         putType(ColumnType.UUID);
+        putType(ColumnType.DATE);
     }
 
-    /** */
+    /**
+     * @param type Column type.
+     */
     private static void putType(ColumnType type) {
         types.put(type.typeSpec().name(), type);
     }
 
     /**
      * Convert SortedIndexColumn to IndexColumnChange.
+     *
      * @param col IndexColumnChange.
      * @param colInit IndexColumnChange to fulfill.
      * @return IndexColumnChange to get result from.
@@ -294,6 +302,15 @@
 
                     break;
 
+                case "TIME":
+                case "DATETIME":
+                case "TIMESTAMP":
+                    ColumnType.TemporalColumnType temporalColType = (ColumnType.TemporalColumnType)colType;
+
+                    colTypeChg.changePrecision(temporalColType.precision());
+
+                    break;
+
                 default:
                     throw new IllegalArgumentException("Unknown type " + colType.typeSpec().name());
             }
@@ -340,6 +357,15 @@
                 case "NUMBER":
                     return ColumnType.numberOf(colTypeView.precision());
 
+                case "TIME":
+                    return ColumnType.time(colTypeView.precision());
+
+                case "DATETIME":
+                    return ColumnType.datetime(colTypeView.precision());
+
+                case "TIMESTAMP":
+                    return ColumnType.timestamp(colTypeView.precision());
+
                 default:
                     throw new IllegalArgumentException("Unknown type " + typeName);
             }
@@ -455,7 +481,7 @@
 
         LinkedHashMap<String, Column> colsMap = new LinkedHashMap<>(colsView.size());
 
-        columns.forEach((i,v) -> colsMap.put(v.name(), v));
+        columns.forEach((i, v) -> colsMap.put(v.name(), v));
 
         return new SchemaTableImpl(schemaName, tableName, colsMap, indices);
     }
@@ -549,7 +575,7 @@
         else if (cls == double.class)
             return ColumnType.DOUBLE;
 
-            // Boxed primitives.
+        // Boxed primitives.
         else if (cls == Byte.class)
             return ColumnType.INT8;
         else if (cls == Short.class)
@@ -563,7 +589,17 @@
         else if (cls == Double.class)
             return ColumnType.DOUBLE;
 
-            // Other types
+        // Temporal types.
+        else if (cls == LocalDate.class)
+            return ColumnType.DATE;
+        else if (cls == LocalTime.class)
+            return ColumnType.time(ColumnType.TemporalColumnType.DEFAULT_PRECISION);
+        else if (cls == LocalDateTime.class)
+            return ColumnType.datetime(ColumnType.TemporalColumnType.DEFAULT_PRECISION);
+        else if (cls == Instant.class)
+            return ColumnType.timestamp(ColumnType.TemporalColumnType.DEFAULT_PRECISION);
+
+        // Other types
         else if (cls == String.class)
             return ColumnType.string();
         else if (cls == UUID.class)
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 8287a0d..059bb7c 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
@@ -21,6 +21,10 @@
 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.UUID;
@@ -95,21 +99,39 @@
             case BITMASK:
                 return NativeTypes.bitmaskOf(((ColumnType.VarLenColumnType)colType).length());
 
-            case STRING:
+            case STRING: {
                 int strLen = ((ColumnType.VarLenColumnType)colType).length();
 
                 if (strLen == 0)
                     strLen = Integer.MAX_VALUE;
 
                 return NativeTypes.stringOf(strLen);
-
-            case BLOB:
+            }
+            case BLOB: {
                 int blobLen = ((ColumnType.VarLenColumnType)colType).length();
 
                 if (blobLen == 0)
                     blobLen = Integer.MAX_VALUE;
 
                 return NativeTypes.blobOf(blobLen);
+            }
+            case DATE:
+                return NativeTypes.DATE;
+            case TIME: {
+                ColumnType.TemporalColumnType temporalType = (ColumnType.TemporalColumnType)colType;
+
+                return NativeTypes.time(temporalType.precision());
+            }
+            case DATETIME: {
+                ColumnType.TemporalColumnType temporalType = (ColumnType.TemporalColumnType)colType;
+
+                return NativeTypes.datetime(temporalType.precision());
+            }
+            case TIMESTAMP: {
+                ColumnType.TemporalColumnType temporalType = (ColumnType.TemporalColumnType)colType;
+
+                return NativeTypes.timestamp(temporalType.precision());
+            }
 
             case NUMBER: {
                 ColumnType.NumberColumnType numberType = (ColumnType.NumberColumnType)colType;
@@ -161,12 +183,20 @@
                 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 NUMBER:
-                return new BigInteger(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());
         }
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/registry/UpgradingRowAdapter.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/registry/UpgradingRowAdapter.java
index eccddcb..2c6b443 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/registry/UpgradingRowAdapter.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/registry/UpgradingRowAdapter.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.schema.registry;
 
 import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.util.BitSet;
 import java.util.UUID;
 import org.apache.ignite.internal.schema.BinaryRow;
@@ -72,13 +73,7 @@
         return mapper.map(colIdx);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public byte byteValue(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -90,13 +85,7 @@
         return mappedId < 0 ? (byte)column.defaultValue() : super.byteValue(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public Byte byteValueBoxed(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -108,13 +97,7 @@
         return mappedId < 0 ? (Byte)column.defaultValue() : super.byteValueBoxed(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public short shortValue(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -126,13 +109,7 @@
         return mappedId < 0 ? (short)column.defaultValue() : super.shortValue(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public Short shortValueBoxed(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -144,13 +121,7 @@
         return mappedId < 0 ? (Short)column.defaultValue() : super.shortValueBoxed(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public int intValue(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -162,13 +133,7 @@
         return mappedId < 0 ? (int)column.defaultValue() : super.intValue(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public Integer intValueBoxed(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -180,13 +145,7 @@
         return mappedId < 0 ? (Integer)column.defaultValue() : super.intValueBoxed(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public long longValue(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -198,13 +157,7 @@
         return mappedId < 0 ? (long)column.defaultValue() : super.longValue(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public Long longValueBoxed(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -216,13 +169,7 @@
         return mappedId < 0 ? (Long)column.defaultValue() : super.longValueBoxed(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public float floatValue(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -234,13 +181,7 @@
         return mappedId < 0 ? (float)column.defaultValue() : super.floatValue(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public Float floatValueBoxed(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -252,13 +193,7 @@
         return mappedId < 0 ? (Float)column.defaultValue() : super.floatValueBoxed(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public double doubleValue(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -270,13 +205,8 @@
         return mappedId < 0 ? (double)column.defaultValue() : super.doubleValue(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+
+    /** {@inheritDoc} */
     @Override public Double doubleValueBoxed(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -288,25 +218,31 @@
         return mappedId < 0 ? (Double)column.defaultValue() : super.doubleValueBoxed(mappedId);
     }
 
-    /**
-     * Reads value from specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public BigDecimal decimalValue(int colIdx) throws InvalidTypeException {
-        // TODO: IGNITE-13668 decimal support
-        return null;
+        int mappedId = mapColumn(colIdx);
+
+        Column column = mappedId < 0 ? mapper.mappedColumn(colIdx) : super.rowSchema().column(mappedId);
+
+        if (NativeTypeSpec.DECIMAL != column.type().spec())
+            throw new SchemaException("Type conversion is not supported yet.");
+
+        return mappedId < 0 ? (BigDecimal)column.defaultValue() : super.decimalValue(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
+    @Override public BigInteger numberValue(int colIdx) throws InvalidTypeException {
+        int mappedId = mapColumn(colIdx);
+
+        Column column = mappedId < 0 ? mapper.mappedColumn(colIdx) : super.rowSchema().column(mappedId);
+
+        if (NativeTypeSpec.NUMBER != column.type().spec())
+            throw new SchemaException("Type conversion is not supported yet.");
+
+        return mappedId < 0 ? (BigInteger)column.defaultValue() : super.numberValue(mappedId);
+    }
+
+    /** {@inheritDoc} */
     @Override public String stringValue(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -318,13 +254,7 @@
         return mappedId < 0 ? (String)column.defaultValue() : super.stringValue(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public byte[] bytesValue(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -336,13 +266,7 @@
         return mappedId < 0 ? (byte[])column.defaultValue() : super.bytesValue(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+    /** {@inheritDoc} */
     @Override public UUID uuidValue(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
@@ -354,13 +278,8 @@
         return mappedId < 0 ? (UUID)column.defaultValue() : super.uuidValue(mappedId);
     }
 
-    /**
-     * Reads value for specified column.
-     *
-     * @param colIdx Column index.
-     * @return Column value.
-     * @throws InvalidTypeException If actual column type does not match the requested column type.
-     */
+
+    /** {@inheritDoc} */
     @Override public BitSet bitmaskValue(int colIdx) throws InvalidTypeException {
         int mappedId = mapColumn(colIdx);
 
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/Row.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/Row.java
index 3cb1af4..c254fdc 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/Row.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/Row.java
@@ -22,6 +22,10 @@
 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.BinaryRow;
@@ -31,13 +35,19 @@
 import org.apache.ignite.internal.schema.InvalidTypeException;
 import org.apache.ignite.internal.schema.NativeTypeSpec;
 import org.apache.ignite.internal.schema.SchemaDescriptor;
+import org.apache.ignite.internal.schema.TemporalNativeType;
 
 /**
  * Schema-aware row.
  * <p>
  * The class contains non-generic methods to read boxed and unboxed primitives based on the schema column types.
  * Any type conversions and coercions should be implemented outside the row by the key-value or query runtime.
+ * <p>
  * When a non-boxed primitive is read from a null column value, it is converted to the primitive type default value.
+ * <p>
+ * Natively supported temporal types are decoded automatically after read.
+ *
+ * @see TemporalTypesHelper
  */
 public class Row implements BinaryRow {
     /** Schema descriptor. */
@@ -238,7 +248,7 @@
         long offLen = findColumn(col, NativeTypeSpec.DECIMAL);
 
         if (offLen < 0)
-            return offLen == -1 ? null : (BigDecimal)rowSchema().column(col).defaultValue();
+            return null;
 
         int off = offset(offLen);
         int len = length(offLen);
@@ -261,7 +271,7 @@
         long offLen = findColumn(col, NativeTypeSpec.NUMBER);
 
         if (offLen < 0)
-            return offLen == -1 ? null : (BigInteger)rowSchema().column(col).defaultValue();
+            return null;
 
         int off = offset(offLen);
         int len = length(offLen);
@@ -348,10 +358,121 @@
     }
 
     /**
-     * @return Row flags.
+     * Reads value for specified column.
+     *
+     * @param col Column index.
+     * @return Column value.
+     * @throws InvalidTypeException If actual column type does not match the requested column type.
      */
-    private boolean hasFlag(int flag) {
-        return ((readShort(FLAGS_FIELD_OFFSET) & flag)) != 0;
+    public LocalDate dateValue(int col) throws InvalidTypeException {
+        long offLen = findColumn(col, NativeTypeSpec.DATE);
+
+        if (offLen < 0)
+            return null;
+
+        int off = offset(offLen);
+
+        return readDate(off);
+    }
+
+    /**
+     * Reads value for specified column.
+     *
+     * @param col Column index.
+     * @return Column value.
+     * @throws InvalidTypeException If actual column type does not match the requested column type.
+     */
+    public LocalTime timeValue(int col) throws InvalidTypeException {
+        long offLen = findColumn(col, NativeTypeSpec.TIME);
+
+        if (offLen < 0)
+            return null;
+
+        int off = offset(offLen);
+
+        TemporalNativeType type = (TemporalNativeType)schema.column(col).type();
+
+        return readTime(off, type);
+    }
+
+    /**
+     * Reads value for specified column.
+     *
+     * @param col Column index.
+     * @return Column value.
+     * @throws InvalidTypeException If actual column type does not match the requested column type.
+     */
+    public LocalDateTime dateTimeValue(int col) throws InvalidTypeException {
+        long offLen = findColumn(col, NativeTypeSpec.DATETIME);
+
+        if (offLen < 0)
+            return null;
+
+        int off = offset(offLen);
+
+        TemporalNativeType type = (TemporalNativeType)schema.column(col).type();
+
+        return LocalDateTime.of(readDate(off), readTime(off + 3, type));
+    }
+
+    /**
+     * Reads value for specified column.
+     *
+     * @param col Column index.
+     * @return Column value.
+     * @throws InvalidTypeException If actual column type does not match the requested column type.
+     */
+    public Instant timestampValue(int col) throws InvalidTypeException {
+        long offLen = findColumn(col, NativeTypeSpec.TIMESTAMP);
+
+        if (offLen < 0)
+            return null;
+
+        int off = offset(offLen);
+
+        TemporalNativeType type = (TemporalNativeType)schema.column(col).type();
+
+        long seconds = readLong(off);
+        int nanos = 0;
+
+        if (type.precision() != 0)
+            nanos = readInteger(off + 8);
+
+        return Instant.ofEpochSecond(seconds, nanos);
+    }
+
+    /**
+     * Reads and decode time column value.
+     *
+     * @param off Offset
+     * @param type Temporal type precision.
+     * @return LocalTime value.
+     */
+    private LocalTime readTime(int off, TemporalNativeType type) {
+        long time = Integer.toUnsignedLong(readInteger(off));
+
+        if (type.precision() > 3) {
+            time <<= 16;
+            time |= Short.toUnsignedLong(readShort(off + 4));
+            time = (time >>> TemporalTypesHelper.NANOSECOND_PART_LEN) << 32 | (time & TemporalTypesHelper.NANOSECOND_PART_MASK);
+        }
+        else // Decompress
+            time = (time >>> TemporalTypesHelper.MILLISECOND_PART_LEN) << 32 | (time & TemporalTypesHelper.MILLISECOND_PART_MASK);
+
+        return TemporalTypesHelper.decodeTime(type, time);
+    }
+
+    /**
+     * Reads and decode date column value.
+     *
+     * @param off Offset
+     * @return LocalDate value.
+     */
+    private LocalDate readDate(int off) {
+        int date = Short.toUnsignedInt(readShort(off)) << 8;
+        date |= Byte.toUnsignedInt(readByte(off + 2));
+
+        return TemporalTypesHelper.decodeDate(date);
     }
 
     /**
@@ -364,10 +485,13 @@
      *
      * @param colIdx Column index.
      * @param type Expected column type.
-     * @return Encoded offset + length of the column.
+     * @return {@code -1} if value is {@code null} for a column,
+     * or {@link Long#MAX_VALUE} if column is unknown,
+     * otherwise encoded offset + length of the column.
      * @see #offset(long)
      * @see #length(long)
      * @see InvalidTypeException If actual column type does not match the requested column type.
+     * @see org.apache.ignite.internal.schema.registry.UpgradingRowAdapter
      */
     protected long findColumn(int colIdx, NativeTypeSpec type) throws InvalidTypeException {
         // Get base offset (key start or value start) for the given column.
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/RowAssembler.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/RowAssembler.java
index edd3c4e..261943e 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/RowAssembler.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/RowAssembler.java
@@ -23,6 +23,10 @@
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.CharsetEncoder;
 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.UUID;
@@ -39,6 +43,7 @@
 import org.apache.ignite.internal.schema.NativeTypes;
 import org.apache.ignite.internal.schema.NumberNativeType;
 import org.apache.ignite.internal.schema.SchemaDescriptor;
+import org.apache.ignite.internal.schema.TemporalNativeType;
 
 import static org.apache.ignite.internal.schema.BinaryRow.RowFlags.KEY_FLAGS_OFFSET;
 import static org.apache.ignite.internal.schema.BinaryRow.RowFlags.VAL_FLAGS_OFFSET;
@@ -46,8 +51,14 @@
 /**
  * Utility class to build rows using column appending pattern. The external user of this class must consult
  * with the schema and provide the columns in strict internal column sort order during the row construction.
+ * <p>
  * Additionally, the user of this class should pre-calculate the resulting row size when possible to avoid
- * unnecessary data copies and allow some size-optimizations can be applied.
+ * unnecessary data copies and allow some size optimizations to be applied.
+ * <p>
+ * Natively supported temporal types are encoded automatically with preserving sort order before writing.
+ *
+ * @see #utf8EncodedLength(CharSequence)
+ * @see TemporalTypesHelper
  */
 public class RowAssembler {
     /** Schema. */
@@ -593,6 +604,101 @@
     }
 
     /**
+     * Appends LocalDate value for the current column to the chunk.
+     *
+     * @param val Column value.
+     * @return {@code this} for chaining.
+     */
+    public RowAssembler appendDate(LocalDate val) {
+        checkType(NativeTypes.DATE);
+
+        int date = TemporalTypesHelper.encodeDate(val);
+
+        writeDate(curOff, date);
+
+        if (isKeyChunk())
+            keyHash += 31 * keyHash + val.hashCode();
+
+        shiftColumn(NativeTypes.DATE.sizeInBytes());
+
+        return this;
+    }
+
+    /**
+     * Appends LocalTime value for the current column to the chunk.
+     *
+     * @param val Column value.
+     * @return {@code this} for chaining.
+     */
+    public RowAssembler appendTime(LocalTime val) {
+        checkType(NativeTypeSpec.TIME);
+
+        TemporalNativeType type = (TemporalNativeType)curCols.column(curCol).type();
+
+        writeTime(buf, curOff, val, type);
+
+        if (isKeyChunk())
+            keyHash += 31 * keyHash + val.hashCode();
+
+        shiftColumn(type.sizeInBytes());
+
+        return this;
+    }
+
+    /**
+     * Appends LocalDateTime value for the current column to the chunk.
+     *
+     * @param val Column value.
+     * @return {@code this} for chaining.
+     */
+    public RowAssembler appendDateTime(LocalDateTime val) {
+        checkType(NativeTypeSpec.DATETIME);
+
+        TemporalNativeType type = (TemporalNativeType)curCols.column(curCol).type();
+
+        int date = TemporalTypesHelper.encodeDate(val.toLocalDate());
+
+        writeDate(curOff, date);
+        writeTime(buf, curOff + 3, val.toLocalTime(), type);
+
+        if (isKeyChunk())
+            keyHash += 31 * keyHash + val.hashCode();
+
+        shiftColumn(type.sizeInBytes());
+
+        return this;
+    }
+
+    /**
+     * Appends Instant value for the current column to the chunk.
+     *
+     * @param val Column value.
+     * @return {@code this} for chaining.
+     */
+    public RowAssembler appendTimestamp(Instant val) {
+        checkType(NativeTypeSpec.TIMESTAMP);
+
+        TemporalNativeType type = (TemporalNativeType)curCols.column(curCol).type();
+
+        long seconds = val.getEpochSecond();
+        int nanos = TemporalTypesHelper.normalizeNanos(val.getNano(), type.precision());
+
+        buf.putLong(curOff, seconds);
+
+        if (type.precision() != 0) // Write only meaningful bytes.
+            buf.putInt(curOff + 8, nanos);
+
+        if (isKeyChunk()) {
+            keyHash += 31 * keyHash + Long.hashCode(seconds);
+            keyHash += 31 * keyHash + Integer.hashCode(nanos);
+        }
+
+        shiftColumn(type.sizeInBytes());
+
+        return this;
+    }
+
+    /**
      * @return Serialized row.
      */
     public BinaryRow build() {
@@ -653,6 +759,41 @@
     }
 
     /**
+     * Writes date.
+     *
+     * @param off Offset.
+     * @param date Compacted date.
+     */
+    private void writeDate(int off, int date) {
+        buf.putShort(off, (short)(date >>> 8));
+        buf.put(off + 2, (byte)(date & 0xFF));
+    }
+
+    /**
+     * Writes time.
+     *
+     * @param buf
+     * @param off Offset.
+     * @param val Time.
+     * @param type Native type.
+     */
+    static void writeTime(ExpandableByteBuf buf, int off, LocalTime val, TemporalNativeType type) {
+        long time = TemporalTypesHelper.encodeTime(type, val);
+
+        if (type.precision() > 3) {
+            time = ((time >>> 32) << TemporalTypesHelper.NANOSECOND_PART_LEN) | (time & TemporalTypesHelper.NANOSECOND_PART_MASK);
+
+            buf.putInt(off, (int)(time >>> 16));
+            buf.putShort(off + 4, (short)(time & 0xFFFF_FFFFL));
+        }
+        else {
+            time = ((time >>> 32) << TemporalTypesHelper.MILLISECOND_PART_LEN) | (time & TemporalTypesHelper.MILLISECOND_PART_MASK);
+
+            buf.putInt(off, (int)time);
+        }
+    }
+
+    /**
      * Checks that the type being appended matches the column type.
      *
      * @param type Type spec that is attempted to be appended.
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/TemporalTypesHelper.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/TemporalTypesHelper.java
new file mode 100644
index 0000000..fce400d
--- /dev/null
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/row/TemporalTypesHelper.java
@@ -0,0 +1,296 @@
+/*
+ * 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.row;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import org.apache.ignite.internal.schema.TemporalNativeType;
+
+/**
+ * Helper class for temporal type conversions.
+ * <p>
+ * Provides methods to encode/decode temporal types in a compact way for further writing to row.
+ * Conversion preserves natural type order.
+ * <p>
+ * DATE is a fixed-length type which compacted representation keeps ordering, value is signed and fit into a 3-bytes.
+ * Thus, DATE value can be compared by bytes where first byte is signed and others - unsigned.
+ * Thus temporal functions, like YEAR(), can easily extracts fields with a mask,
+ * <p>
+ * Date compact structure:
+ * ┌──────────────┬─────────┬────────┐
+ * │ Year(signed) │ Month   │ Day    │
+ * ├──────────────┼─────────┼────────┤
+ * │ 15 bits      │ 4 bits  │ 5 bits │
+ * └──────────────┴─────────┴────────┘
+ * <p>
+ * TIME is a fixed-length type supporting accuracy from 1 second up to 1 nanosecond.
+ * Compacted time representation keeps ordering, values fits to 4-6 bytes value.
+ * The first 18 bits is used for hours, minutes and seconds, and the last bits for fractional seconds:
+ * 14 for millisecond precision and 30 for nanosecond.
+ * Values of a type of any intermediate precisions is normalized to the type,
+ * then stored as shortest possible structure without a precision lost.
+ * <p>
+ * Time compact structure:
+ * ┌─────────┬─────────┬──────────┬─────────────┐
+ * │ Hours   │ Minutes │ Seconds  │ Sub-seconds │
+ * ├─────────┼─────────┼──────────┼─────────────┤
+ * │ 6 bit   │ 6 bits  │ 6 bit    │ 14 bits     │ - 32-bits in total.
+ * │ 6 bit   │ 6 bits  │ 6 bit    │ 30 bits     │ - 48-bits in total.
+ * └─────────┴─────────┴──────────┴─────────────┘
+ * <p>
+ * DATETIME is just a concatenation of DATE and TIME values.
+ * <p>
+ * TIMESTAMP has similar structure to {@link java.time.Instant} and supports precision from 1 second up to 1 nanosecond.
+ * Fractional seconds part is stored in a separate bit sequence which is omitted for {@code 0} accuracy.
+ * <p>
+ * Total value size is 8/12 bytes depending on the type precision.
+ * <p>
+ * Timestamp compact structure:
+ * ┌──────────────────────────┬─────────────┐
+ * │ Seconds since the epoch  │ Sub-seconds │
+ * ├──────────────────────────┼─────────────┤
+ * │    64 bits               │ 0/32 bits   │
+ * └──────────────────────────┴─────────────┘
+ *
+ * @see org.apache.ignite.internal.schema.row.Row
+ * @see org.apache.ignite.internal.schema.row.RowAssembler
+ */
+public class TemporalTypesHelper {
+    /** Month field length. */
+    public static final int MONTH_FIELD_LENGTH = 4;
+
+    /** Day field length. */
+    public static final int DAY_FIELD_LENGTH = 5;
+
+    /** Hours field length. */
+    public static final int HOUR_FIELD_LENGTH = 5;
+
+    /** Minutes field length. */
+    public static final int MINUTES_FIELD_LENGTH = 6;
+
+    /** Seconds field length. */
+    public static final int SECONDS_FIELD_LENGTH = 6;
+
+    /** Max year boundary. */
+    public static final int MAX_YEAR = (1 << 14) - 1;
+
+    /** Min year boundary. */
+    public static final int MIN_YEAR = -(1 << 14);
+
+    /** Fractional part length for millis precision. */
+    public static final int MILLISECOND_PART_LEN = 14;
+
+    /** Fractional part mask for millis precision. */
+    public static final long MILLISECOND_PART_MASK = (1L << MILLISECOND_PART_LEN) - 1;
+
+    /** Fractional part length for nanos precision. */
+    public static final int NANOSECOND_PART_LEN = 30;
+
+    /** Fractional part mask for nanos precision. */
+    public static final long NANOSECOND_PART_MASK = (1L << NANOSECOND_PART_LEN) - 1;
+
+    /**
+     * @param len Mask length in bits.
+     * @return Mask.
+     */
+    private static int mask(int len) {
+        return (1 << len) - 1;
+    }
+
+    /**
+     * Compact LocalDate.
+     *
+     * @param date Date.
+     * @return Encoded date.
+     */
+    public static int encodeDate(LocalDate date) {
+        int val = date.getYear() << MONTH_FIELD_LENGTH;
+        val = (val | date.getMonthValue()) << DAY_FIELD_LENGTH;
+        val |= date.getDayOfMonth();
+
+        return val & (0x00FF_FFFF);
+    }
+
+    /**
+     * Expands to LocalDate.
+     *
+     * @param date Encoded date.
+     * @return LocalDate instance.
+     */
+    public static LocalDate decodeDate(int date) {
+        date = (date << 8) >> 8; // Restore sign.
+
+        int day = (date) & mask(DAY_FIELD_LENGTH);
+        int mon = (date >>= DAY_FIELD_LENGTH) & mask(MONTH_FIELD_LENGTH);
+        int year = (date >> MONTH_FIELD_LENGTH); // Sign matters.
+
+        return LocalDate.of(year, mon, day);
+    }
+
+    /**
+     * Encode LocalTime to long as concatenation of 2 int values:
+     * encoded time with precision of seconds and fractional seconds.
+     *
+     * @param type Native temporal type.
+     * @param localTime Time.
+     * @return Encoded local time.
+     * @see #NANOSECOND_PART_LEN
+     * @see #MILLISECOND_PART_LEN
+     */
+    public static long encodeTime(TemporalNativeType type, LocalTime localTime) {
+        int time = localTime.getHour() << (MINUTES_FIELD_LENGTH + SECONDS_FIELD_LENGTH);
+        time |= localTime.getMinute() << SECONDS_FIELD_LENGTH;
+        time |= localTime.getSecond();
+
+        int fractional = truncateTo(type.precision(), localTime.getNano());
+
+        return ((long)time << 32) | fractional;
+    }
+
+    /**
+     * Decode to LocalTime.
+     *
+     * @param type Type.
+     * @param time Encoded time.
+     * @return LocalTime instance.
+     */
+    public static LocalTime decodeTime(TemporalNativeType type, long time) {
+        int fractional = (int)time;
+        int time0 = (int)(time >>> 32);
+
+        int sec = time0 & mask(SECONDS_FIELD_LENGTH);
+        int min = (time0 >>>= SECONDS_FIELD_LENGTH) & mask(MINUTES_FIELD_LENGTH);
+        int hour = (time0 >>> MINUTES_FIELD_LENGTH) & mask(HOUR_FIELD_LENGTH);
+
+        // Convert to nanoseconds.
+        switch (type.precision()) {
+            case 0:
+                break;
+            case 1:
+            case 2:
+            case 3: {
+                fractional *= 1_000_000;
+                break;
+            }
+            case 4:
+            case 5:
+            case 6: {
+                fractional *= 1_000;
+                break;
+            }
+            default:
+                break;
+        }
+
+        return LocalTime.of(hour, min, sec, fractional);
+    }
+
+    /**
+     * Normalize nanoseconds regarding the precision.
+     *
+     * @param nanos Nanoseconds.
+     * @param precision Meaningful digits.
+     * @return Normalized nanoseconds.
+     */
+    public static int normalizeNanos(int nanos, int precision) {
+        switch (precision) {
+            case 0:
+                nanos = 0;
+                break;
+            case 1:
+                nanos = (nanos / 100_000_000) * 100_000_000; // 100ms precision.
+                break;
+            case 2:
+                nanos = (nanos / 10_000_000) * 10_000_000; // 10ms precision.
+                break;
+            case 3: {
+                nanos = (nanos / 1_000_000) * 1_000_000; // 1ms precision.
+                break;
+            }
+            case 4: {
+                nanos = (nanos / 100_000) * 100_000; // 100mcs precision.
+                break;
+            }
+            case 5: {
+                nanos = (nanos / 10_000) * 10_000; // 10mcs precision.
+                break;
+            }
+            case 6: {
+                nanos = (nanos / 1_000) * 1_000; // 1mcs precision.
+                break;
+            }
+            case 7: {
+                nanos = (nanos / 100) * 100; // 100ns precision.
+                break;
+            }
+            case 8: {
+                nanos = (nanos / 10) * 10; // 10ns precision.
+                break;
+            }
+            case 9: {
+                nanos = nanos; // 1ns precision
+                break;
+            }
+            default: // Should never get here.
+                throw new IllegalArgumentException("Unsupported fractional seconds precision: " + precision);
+        }
+
+        return nanos;
+    }
+
+    /**
+     * Normalize to given precision and truncate to meaningful time unit.
+     *
+     * @param precision Precision.
+     * @param nanos Seconds' fractional part.
+     * @return Truncated fractional seconds (millis, micros or nanos).
+     */
+    private static int truncateTo(int precision, int nanos) {
+        switch (precision) {
+            case 0:
+                return 0;
+            case 1:
+                return (nanos / 100_000_000) * 100; // 100ms precision.
+            case 2:
+                return (nanos / 10_000_000) * 10; // 10ms precision.
+            case 3: {
+                return nanos / 1_000_000; // 1ms precision.
+            }
+            case 4: {
+                return (nanos / 100_000) * 100; // 100mcs precision.
+            }
+            case 5: {
+                return (nanos / 10_000) * 10; // 10mcs precision.
+            }
+            case 6: {
+                return nanos / 1_000; // 1mcs precision.
+            }
+            case 7: {
+                return (nanos / 100) * 100; // 100ns precision.
+            }
+            case 8: {
+                return (nanos / 10) * 10; // 10ns precision.
+            }
+            case 9: {
+                return nanos; // 1ns precision
+            }
+            default: // Should never get here.
+                throw new IllegalArgumentException("Unsupported fractional seconds precision: " + precision);
+        }
+    }
+}
diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/ColumnTest.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/ColumnTest.java
index 1e3d845..c6d30bc 100644
--- a/modules/schema/src/test/java/org/apache/ignite/internal/schema/ColumnTest.java
+++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/ColumnTest.java
@@ -21,6 +21,7 @@
 import org.junit.jupiter.api.Test;
 
 import static org.apache.ignite.internal.schema.NativeTypes.BYTES;
+import static org.apache.ignite.internal.schema.NativeTypes.DATE;
 import static org.apache.ignite.internal.schema.NativeTypes.INT32;
 import static org.apache.ignite.internal.schema.NativeTypes.STRING;
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -37,15 +38,17 @@
         Column[] cols = new Column[] {
             new Column("C", BYTES, false),
             new Column("B", INT32, false),
+            new Column("A", DATE, false),
             new Column("AD", STRING, false),
             new Column("AA", STRING, false),
         };
 
         Arrays.sort(cols);
 
-        assertEquals("B", cols[0].name());
-        assertEquals("C", cols[1].name());
-        assertEquals("AA", cols[2].name());
-        assertEquals("AD", cols[3].name());
+        assertEquals("A", cols[0].name());
+        assertEquals("B", cols[1].name());
+        assertEquals("C", cols[2].name());
+        assertEquals("AA", cols[3].name());
+        assertEquals("AD", cols[4].name());
     }
 }
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 3876557..5c732bc 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
@@ -21,6 +21,7 @@
 import org.junit.jupiter.api.Test;
 
 import static org.apache.ignite.internal.schema.NativeTypes.BYTES;
+import static org.apache.ignite.internal.schema.NativeTypes.DATE;
 import static org.apache.ignite.internal.schema.NativeTypes.DOUBLE;
 import static org.apache.ignite.internal.schema.NativeTypes.FLOAT;
 import static org.apache.ignite.internal.schema.NativeTypes.INT16;
@@ -28,7 +29,18 @@
 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.STRING;
+import static org.apache.ignite.internal.schema.NativeTypes.UUID;
+import static org.apache.ignite.internal.schema.NativeTypes.bitmaskOf;
+import static org.apache.ignite.internal.schema.NativeTypes.blobOf;
+import static org.apache.ignite.internal.schema.NativeTypes.datetime;
+import static org.apache.ignite.internal.schema.NativeTypes.decimalOf;
+import static org.apache.ignite.internal.schema.NativeTypes.from;
+import static org.apache.ignite.internal.schema.NativeTypes.numberOf;
+import static org.apache.ignite.internal.schema.NativeTypes.stringOf;
+import static org.apache.ignite.internal.schema.NativeTypes.time;
+import static org.apache.ignite.internal.schema.NativeTypes.timestamp;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
@@ -43,14 +55,14 @@
         assertTrue(INT8.compareTo(STRING) < 0);
         assertTrue(INT8.compareTo(BYTES) < 0);
 
-        assertTrue(NativeTypes.INT32.compareTo(STRING) < 0);
-        assertTrue(NativeTypes.INT32.compareTo(BYTES) < 0);
+        assertTrue(INT32.compareTo(STRING) < 0);
+        assertTrue(INT32.compareTo(BYTES) < 0);
 
-        assertTrue(NativeTypes.INT64.compareTo(STRING) < 0);
-        assertTrue(NativeTypes.INT64.compareTo(BYTES) < 0);
+        assertTrue(INT64.compareTo(STRING) < 0);
+        assertTrue(INT64.compareTo(BYTES) < 0);
 
-        assertTrue(NativeTypes.UUID.compareTo(STRING) < 0);
-        assertTrue(NativeTypes.UUID.compareTo(BYTES) < 0);
+        assertTrue(UUID.compareTo(STRING) < 0);
+        assertTrue(UUID.compareTo(BYTES) < 0);
     }
 
     /**
@@ -58,9 +70,22 @@
      */
     @Test
     public void compareFixlenTypesBySize() {
-        assertTrue(NativeTypes.INT16.compareTo(NativeTypes.INT32) < 0);
-        assertTrue(NativeTypes.INT32.compareTo(NativeTypes.INT64) < 0);
-        assertTrue(NativeTypes.INT64.compareTo(NativeTypes.UUID) < 0);
+        assertTrue(INT16.compareTo(INT32) < 0);
+        assertTrue(INT32.compareTo(INT64) < 0);
+        assertTrue(INT64.compareTo(UUID) < 0);
+
+        assertTrue(INT16.compareTo(DATE) < 0);
+        assertTrue(DATE.compareTo(INT32) < 0);
+
+        assertTrue(DATE.compareTo(time(0)) < 0);
+        assertTrue(INT32.compareTo(time(4)) < 0);
+        assertTrue(time(3).compareTo(time(4)) < 0);
+        assertTrue(time(9).compareTo(datetime(0)) < 0);
+
+        assertTrue(datetime(3).compareTo(INT64) < 0);
+        assertTrue(INT64.compareTo(datetime(4)) < 0);
+
+        assertTrue(INT64.compareTo(timestamp(1)) < 0);
     }
 
     /**
@@ -68,7 +93,54 @@
      */
     @Test
     public void compareFixlenTypesByDesc() {
-        assertTrue(NativeTypes.FLOAT.compareTo(NativeTypes.INT32) < 0);
+        assertTrue(FLOAT.compareTo(INT32) < 0);
+        assertTrue(datetime(0).compareTo(INT64) < 0);
+        assertTrue(INT32.compareTo(time(0)) < 0);
+        assertTrue(INT32.compareTo(time(3)) < 0);
+        assertTrue(INT64.compareTo(timestamp(0)) < 0);
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void validateTemporalTypesLength() {
+        assertEquals(3, DATE.sizeInBytes());
+
+        assertEquals(6, time().sizeInBytes());
+        assertEquals(4, time(0).sizeInBytes());
+        assertEquals(4, time(3).sizeInBytes());
+        assertEquals(6, time(4).sizeInBytes());
+        assertEquals(6, time(9).sizeInBytes());
+
+        assertEquals(9, datetime().sizeInBytes());
+        assertEquals(7, datetime(0).sizeInBytes());
+        assertEquals(7, datetime(3).sizeInBytes());
+        assertEquals(9, datetime(4).sizeInBytes());
+        assertEquals(9, datetime(9).sizeInBytes());
+
+        assertEquals(12, timestamp().sizeInBytes());
+        assertEquals(8, timestamp(0).sizeInBytes());
+        assertEquals(12, timestamp(1).sizeInBytes());
+        assertEquals(12, timestamp(9).sizeInBytes());
+
+        assertEquals(0, datetime().compareTo(datetime(6)));
+        assertEquals(0, time().compareTo(time(6)));
+        assertEquals(0, timestamp().compareTo(timestamp(6)));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void invalidTemporalTypes() {
+        assertThrows(IllegalArgumentException.class, () -> time(-1));
+        assertThrows(IllegalArgumentException.class, () -> timestamp(-1));
+        assertThrows(IllegalArgumentException.class, () -> datetime(-1));
+
+        assertThrows(IllegalArgumentException.class, () -> time(10));
+        assertThrows(IllegalArgumentException.class, () -> timestamp(10));
+        assertThrows(IllegalArgumentException.class, () -> datetime(10));
     }
 
     /**
@@ -84,21 +156,32 @@
      */
     @Test
     public void createNativeTypeFromColumnType() {
-        assertEquals(INT8, NativeTypes.from(ColumnType.INT8));
-        assertEquals(INT16, NativeTypes.from(ColumnType.INT16));
-        assertEquals(INT32, NativeTypes.from(ColumnType.INT32));
-        assertEquals(INT64, NativeTypes.from(ColumnType.INT64));
-        assertEquals(FLOAT, NativeTypes.from(ColumnType.FLOAT));
-        assertEquals(DOUBLE, NativeTypes.from(ColumnType.DOUBLE));
-        assertEquals(BYTES, NativeTypes.from(ColumnType.blobOf()));
-        assertEquals(STRING, NativeTypes.from(ColumnType.string()));
+        assertEquals(INT8, from(ColumnType.INT8));
+        assertEquals(INT16, from(ColumnType.INT16));
+        assertEquals(INT32, from(ColumnType.INT32));
+        assertEquals(INT64, from(ColumnType.INT64));
+        assertEquals(FLOAT, from(ColumnType.FLOAT));
+        assertEquals(DOUBLE, from(ColumnType.DOUBLE));
+        assertEquals(DATE, from(ColumnType.DATE));
+        assertEquals(BYTES, from(ColumnType.blobOf()));
+        assertEquals(STRING, from(ColumnType.string()));
+
+        assertEquals(time(), from(ColumnType.time(ColumnType.TemporalColumnType.DEFAULT_PRECISION)));
+        assertEquals(datetime(), from(ColumnType.datetime(ColumnType.TemporalColumnType.DEFAULT_PRECISION)));
+        assertEquals(timestamp(), from(ColumnType.timestamp(ColumnType.TemporalColumnType.DEFAULT_PRECISION)));
 
         for (int i = 1; i < 800; i += 100) {
-            assertEquals(NativeTypes.blobOf(i), NativeTypes.from(ColumnType.blobOf(i)));
-            assertEquals(NativeTypes.stringOf(i), NativeTypes.from(ColumnType.stringOf(i)));
-            assertEquals(NativeTypes.bitmaskOf(i), NativeTypes.from(ColumnType.bitmaskOf(i)));
-            assertEquals(NativeTypes.numberOf(i), NativeTypes.from(ColumnType.numberOf(i)));
-            assertEquals(NativeTypes.decimalOf(i, i), NativeTypes.from(ColumnType.decimalOf(i, i)));
+            assertEquals(blobOf(i), from(ColumnType.blobOf(i)));
+            assertEquals(stringOf(i), from(ColumnType.stringOf(i)));
+            assertEquals(bitmaskOf(i), from(ColumnType.bitmaskOf(i)));
+            assertEquals(numberOf(i), from(ColumnType.numberOf(i)));
+            assertEquals(decimalOf(i, i), from(ColumnType.decimalOf(i, i)));
+        }
+
+        for (int i = 0; i <= 9; i++) {
+            assertEquals(time(i), from(ColumnType.time(i)));
+            assertEquals(datetime(i), from(ColumnType.datetime(i)));
+            assertEquals(timestamp(i), from(ColumnType.timestamp(i)));
         }
     }
 }
diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/RowTest.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/RowTest.java
index 59728f6..6244b2c 100644
--- a/modules/schema/src/test/java/org/apache/ignite/internal/schema/RowTest.java
+++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/RowTest.java
@@ -19,6 +19,10 @@
 
 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.Arrays;
 import java.util.BitSet;
 import java.util.Collections;
@@ -33,6 +37,7 @@
 import org.junit.jupiter.api.Test;
 
 import static org.apache.ignite.internal.schema.NativeTypes.BYTES;
+import static org.apache.ignite.internal.schema.NativeTypes.DATE;
 import static org.apache.ignite.internal.schema.NativeTypes.DOUBLE;
 import static org.apache.ignite.internal.schema.NativeTypes.FLOAT;
 import static org.apache.ignite.internal.schema.NativeTypes.INT16;
@@ -41,6 +46,9 @@
 import static org.apache.ignite.internal.schema.NativeTypes.INT8;
 import static org.apache.ignite.internal.schema.NativeTypes.STRING;
 import static org.apache.ignite.internal.schema.NativeTypes.UUID;
+import static org.apache.ignite.internal.schema.NativeTypes.datetime;
+import static org.apache.ignite.internal.schema.NativeTypes.time;
+import static org.apache.ignite.internal.schema.NativeTypes.timestamp;
 import static org.apache.ignite.internal.schema.TestUtils.randomBytes;
 import static org.apache.ignite.internal.schema.TestUtils.randomString;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
@@ -70,7 +78,7 @@
      */
     @Test
     public void nullableFixSizedColumns() {
-        Column[] keyCols = new Column[] {
+        Column[] keyCols = new Column[]{
             new Column("keyByteCol", INT8, false),
             new Column("keyShortCol", INT16, false),
             new Column("keyIntCol", INT32, false),
@@ -78,11 +86,15 @@
             new Column("keyFloatCol", FLOAT, false),
             new Column("keyDoubleCol", DOUBLE, false),
             new Column("keyUuidCol", UUID, false),
+            new Column("keyDateCol", DATE, false),
+            new Column("keyTimeCol", time(), false),
+            new Column("keyDateTimeCol", datetime(), false),
+            new Column("keyTimeStampCol", timestamp(), false),
             new Column("keyBitmask1Col", NativeTypes.bitmaskOf(4), false),
             new Column("keyBitmask2Col", NativeTypes.bitmaskOf(22), false)
         };
 
-        Column[] valCols = new Column[] {
+        Column[] valCols = new Column[]{
             new Column("valByteCol", INT8, false),
             new Column("valShortCol", INT16, false),
             new Column("valIntCol", INT32, false),
@@ -90,6 +102,10 @@
             new Column("valFloatCol", FLOAT, false),
             new Column("valDoubleCol", DOUBLE, false),
             new Column("valUuidCol", UUID, false),
+            new Column("valDateCol", DATE, false),
+            new Column("valTimeCol", time(), false),
+            new Column("valDateTimeCol", datetime(), false),
+            new Column("valTimeStampCol", timestamp(), false),
             new Column("valBitmask1Col", NativeTypes.bitmaskOf(4), false),
             new Column("valBitmask2Col", NativeTypes.bitmaskOf(22), false)
         };
@@ -102,7 +118,7 @@
      */
     @Test
     public void fixSizedColumns() {
-        Column[] keyCols = new Column[] {
+        Column[] keyCols = new Column[]{
             new Column("keyByteCol", INT8, true),
             new Column("keyShortCol", INT16, true),
             new Column("keyIntCol", INT32, true),
@@ -110,11 +126,15 @@
             new Column("keyFloatCol", FLOAT, true),
             new Column("keyDoubleCol", DOUBLE, true),
             new Column("keyUuidCol", UUID, true),
+            new Column("keyDateCol", DATE, true),
+            new Column("keyTimeCol", time(), true),
+            new Column("keyDateTimeCol", datetime(), true),
+            new Column("keyTimeStampCol", timestamp(), true),
             new Column("keyBitmask1Col", NativeTypes.bitmaskOf(4), true),
             new Column("keyBitmask2Col", NativeTypes.bitmaskOf(22), true),
         };
 
-        Column[] valCols = new Column[] {
+        Column[] valCols = new Column[]{
             new Column("valByteCol", INT8, true),
             new Column("valShortCol", INT16, true),
             new Column("valIntCol", INT32, true),
@@ -122,6 +142,10 @@
             new Column("valFloatCol", FLOAT, true),
             new Column("valDoubleCol", DOUBLE, true),
             new Column("valUuidCol", UUID, true),
+            new Column("valDateCol", DATE, true),
+            new Column("valTimeCol", time(), true),
+            new Column("valDateTimeCol", datetime(), true),
+            new Column("valTimeStampCol", timestamp(), true),
             new Column("valBitmask1Col", NativeTypes.bitmaskOf(4), true),
             new Column("valBitmask2Col", NativeTypes.bitmaskOf(22), true),
         };
@@ -134,22 +158,24 @@
      */
     @Test
     public void mixedColumns() {
-        Column[] keyCols = new Column[] {
+        Column[] keyCols = new Column[]{
             new Column("keyByteCol", INT8, false),
             new Column("keyShortCol", INT16, false),
             new Column("keyIntCol", INT32, false),
             new Column("keyLongCol", INT64, false),
+            new Column("keyDateTimeCol", datetime(), false),
             new Column("keyBytesCol", BYTES, false),
             new Column("keyStringCol", STRING, false),
             new Column("keyNumberCol", NativeTypes.numberOf(9), false),
             new Column("keyDecimalCol", NativeTypes.decimalOf(20, 3), false),
         };
 
-        Column[] valCols = new Column[] {
-            new Column("keyByteCol", INT8, true),
-            new Column("keyShortCol", INT16, true),
-            new Column("keyIntCol", INT32, true),
-            new Column("keyLongCol", INT64, true),
+        Column[] valCols = new Column[]{
+            new Column("valByteCol", INT8, true),
+            new Column("valShortCol", INT16, true),
+            new Column("valIntCol", INT32, true),
+            new Column("valLongCol", INT64, true),
+            new Column("valDateTimeCol", datetime(), true),
             new Column("valBytesCol", BYTES, true),
             new Column("valStringCol", STRING, true),
             new Column("valNumberCol", NativeTypes.numberOf(9), true),
@@ -160,18 +186,44 @@
     }
 
     /**
+     * Check row serialization for schema with various columns.
+     */
+    @Test
+    public void temporalColumns() {
+        Column[] keyCols = new Column[]{
+            new Column("keyTimestampCol1", timestamp(0), false),
+            new Column("keyTimestampCol2", timestamp(1), false),
+            new Column("keyTimestampCol3", timestamp(4), false),
+            new Column("keyTimestampCol4", timestamp(9), false),
+        };
+
+        Column[] valCols = new Column[]{
+            new Column("valDateTimeCol1", datetime(0), false),
+            new Column("valDateTimeCol2", datetime(1), true),
+            new Column("valDateTimeCol3", datetime(4), false),
+            new Column("valDateTimeCol4", datetime(9), true),
+            new Column("valTimeCol1", time(0), true),
+            new Column("valTimeCol2", time(1), true),
+            new Column("valTimeCol3", time(4), false),
+            new Column("valTimeCol4", time(9), false),
+        };
+
+        checkSchema(keyCols, valCols);
+    }
+
+    /**
      * Check row serialization for schema with non-nullable varlen columns only.
      */
     @Test
     public void varlenColumns() {
-        Column[] keyCols = new Column[] {
+        Column[] keyCols = new Column[]{
             new Column("keyBytesCol", BYTES, false),
             new Column("keyStringCol", STRING, false),
             new Column("keyNumberCol", NativeTypes.numberOf(9), false),
             new Column("keyDecimalCol", NativeTypes.decimalOf(20, 3), false),
         };
 
-        Column[] valCols = new Column[] {
+        Column[] valCols = new Column[]{
             new Column("valBytesCol", BYTES, false),
             new Column("valStringCol", STRING, false),
             new Column("valNumberCol", NativeTypes.numberOf(9), false),
@@ -186,12 +238,12 @@
      */
     @Test
     public void nullableVarlenColumns() {
-        Column[] keyCols = new Column[] {
+        Column[] keyCols = new Column[]{
             new Column("keyBytesCol", BYTES, true),
             new Column("keyStringCol", STRING, true),
         };
 
-        Column[] valCols = new Column[] {
+        Column[] valCols = new Column[]{
             new Column("valBytesCol", BYTES, true),
             new Column("valStringCol", STRING, true),
             new Column("valNumberCol", NativeTypes.numberOf(9), true),
@@ -520,6 +572,22 @@
                         asm.appendBitmask((BitSet)vals[i]);
                         break;
 
+                    case DATE:
+                        asm.appendDate((LocalDate)vals[i]);
+                        break;
+
+                    case TIME:
+                        asm.appendTime((LocalTime)vals[i]);
+                        break;
+
+                    case DATETIME:
+                        asm.appendDateTime((LocalDateTime)vals[i]);
+                        break;
+
+                    case TIMESTAMP:
+                        asm.appendTimestamp((Instant)vals[i]);
+                        break;
+
                     default:
                         throw new IllegalStateException("Unsupported test type: " + type);
                 }
diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/TemporalTypesTest.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/TemporalTypesTest.java
new file mode 100644
index 0000000..5c6bbe1
--- /dev/null
+++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/TemporalTypesTest.java
@@ -0,0 +1,84 @@
+/*
+ * 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;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.temporal.ChronoUnit;
+import org.apache.ignite.internal.schema.row.TemporalTypesHelper;
+import org.apache.ignite.schema.ColumnType;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * Test temporal type compaction.
+ */
+public class TemporalTypesTest {
+    /**
+     * Check date boundaries.
+     */
+    @Test
+    void testDate() {
+        checkDate(LocalDate.of(0, 1, 1));
+        checkDate(LocalDate.of(-1, 1, 11));
+
+        LocalDate maxDate = LocalDate.of(TemporalTypesHelper.MAX_YEAR, 12, 31);
+        LocalDate minDate = LocalDate.of(TemporalTypesHelper.MIN_YEAR, 1, 1);
+
+        checkDate(maxDate);
+        checkDate(minDate);
+
+        assertThrows(AssertionError.class, () -> checkDate(maxDate.plusDays(1)));
+        assertThrows(AssertionError.class, () -> checkDate(minDate.minusDays(1)));
+    }
+
+    /**
+     * Check time boundaries.
+     */
+    @Test
+    void testTime() {
+        for (int i = 0; i <= 9; i++) {
+            checkTime(TemporalNativeType.time(i), LocalTime.MAX.withNano(TemporalTypesHelper.normalizeNanos(LocalTime.MAX.getNano(), i))); // Seconds precision.
+            checkTime(TemporalNativeType.time(i), LocalTime.MIN);
+        }
+
+        checkTime(TemporalNativeType.time(ColumnType.TemporalColumnType.DEFAULT_PRECISION), LocalTime.MAX.truncatedTo(ChronoUnit.MICROS));
+        checkTime(TemporalNativeType.time(9), LocalTime.MAX);
+
+        assertThrows(AssertionError.class, () -> checkTime(TemporalNativeType.time(ColumnType.TemporalColumnType.DEFAULT_PRECISION), LocalTime.MAX));
+        assertThrows(AssertionError.class, () -> checkTime(TemporalNativeType.time(0), LocalTime.MAX));
+        assertThrows(AssertionError.class, () -> checkTime(TemporalNativeType.time(8), LocalTime.MAX));
+    }
+
+    /**
+     * @param date Date.
+     */
+    private void checkDate(LocalDate date) {
+        assertEquals(date, TemporalTypesHelper.decodeDate(TemporalTypesHelper.encodeDate(date)));
+    }
+
+    /**
+     * @param type Type to validate against.
+     * @param time Time value.
+     */
+    private void checkTime(TemporalNativeType type, LocalTime time) {
+        assertEquals(time, TemporalTypesHelper.decodeTime(type, TemporalTypesHelper.encodeTime(type, time)));
+    }
+}
diff --git a/modules/schema/src/test/java/org/apache/ignite/internal/schema/TestUtils.java b/modules/schema/src/test/java/org/apache/ignite/internal/schema/TestUtils.java
index 878fb76..6d7152f 100644
--- a/modules/schema/src/test/java/org/apache/ignite/internal/schema/TestUtils.java
+++ b/modules/schema/src/test/java/org/apache/ignite/internal/schema/TestUtils.java
@@ -19,9 +19,19 @@
 
 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.time.Year;
+import java.time.temporal.ChronoUnit;
 import java.util.BitSet;
 import java.util.Random;
 
+import static org.apache.ignite.internal.schema.row.TemporalTypesHelper.MAX_YEAR;
+import static org.apache.ignite.internal.schema.row.TemporalTypesHelper.MIN_YEAR;
+import static org.apache.ignite.internal.schema.row.TemporalTypesHelper.normalizeNanos;
+
 /**
  * Test utility class.
  */
@@ -74,6 +84,30 @@
                 return randomBitSet(rnd, maskType.bits());
             }
 
+            case DATE: {
+                Year year = Year.of(rnd.nextInt(MAX_YEAR - MIN_YEAR) + MIN_YEAR);
+
+                return LocalDate.ofYearDay(year.getValue(), rnd.nextInt(year.length()) + 1);
+            }
+
+            case TIME:
+                return LocalTime.of(rnd.nextInt(24), rnd.nextInt(60), rnd.nextInt(60),
+                    normalizeNanos(rnd.nextInt(1_000_000_000), ((TemporalNativeType)type).precision()));
+
+            case DATETIME: {
+                Year year = Year.of(rnd.nextInt(MAX_YEAR - MIN_YEAR) + MIN_YEAR);
+
+                LocalDate date = LocalDate.ofYearDay(year.getValue(), rnd.nextInt(year.length()) + 1);
+                LocalTime time = LocalTime.of(rnd.nextInt(24), rnd.nextInt(60), rnd.nextInt(60),
+                    normalizeNanos(rnd.nextInt(1_000_000_000), ((TemporalNativeType)type).precision()));
+
+                return LocalDateTime.of(date, time);
+            }
+
+            case TIMESTAMP:
+                return Instant.ofEpochMilli(rnd.nextLong()).truncatedTo(ChronoUnit.SECONDS)
+                    .plusNanos(normalizeNanos(rnd.nextInt(1_000_000_000), ((TemporalNativeType)type).precision()));
+
             default:
                 throw new IllegalArgumentException("Unsupported type: " + type);
         }
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/RowChunkAdapter.java b/modules/table/src/main/java/org/apache/ignite/internal/table/RowChunkAdapter.java
index d3ddd3a..a58d960 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/RowChunkAdapter.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/RowChunkAdapter.java
@@ -17,6 +17,10 @@
 
 package org.apache.ignite.internal.table;
 
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
 import java.util.BitSet;
 import java.util.Iterator;
 import java.util.UUID;
@@ -225,6 +229,66 @@
     }
 
     /** {@inheritDoc} */
+    @Override public LocalDate dateValue(String columnName) {
+        Column col = columnByName(columnName);
+
+        return row().dateValue(col.schemaIndex());
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDate dateValue(int columnIndex) {
+        schema().validateColumnIndex(columnIndex);
+
+        return row().dateValue(columnIndex);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalTime timeValue(String columnName) {
+        Column col = columnByName(columnName);
+
+        return row().timeValue(col.schemaIndex());
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalTime timeValue(int columnIndex) {
+        schema().validateColumnIndex(columnIndex);
+
+        return row().timeValue(columnIndex);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDateTime datetimeValue(String columnName) {
+        Column col = columnByName(columnName);
+
+        return row().dateTimeValue(col.schemaIndex());
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @return
+     */
+    @Override public LocalDateTime datetimeValue(int columnIndex) {
+        schema().validateColumnIndex(columnIndex);
+
+        return row().dateTimeValue(columnIndex);
+    }
+
+    /** {@inheritDoc} */
+    @Override public Instant timestampValue(String columnName) {
+        Column col = columnByName(columnName);
+
+        return row().timestampValue(col.schemaIndex());
+    }
+
+    /** {@inheritDoc} */
+    @Override public Instant timestampValue(int columnIndex) {
+        schema().validateColumnIndex(columnIndex);
+
+        return row().timestampValue(columnIndex);
+    }
+
+    /** {@inheritDoc} */
     @NotNull @Override public Iterator<Object> iterator() {
         return new Iterator<>() {
             /** Current column index. */
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/TupleBuilderImpl.java b/modules/table/src/main/java/org/apache/ignite/internal/table/TupleBuilderImpl.java
index d208129..4ced975 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/TupleBuilderImpl.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/TupleBuilderImpl.java
@@ -17,6 +17,10 @@
 
 package org.apache.ignite.internal.table;
 
+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.Iterator;
@@ -224,6 +228,46 @@
     }
 
     /** {@inheritDoc} */
+    @Override public LocalDate dateValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDate dateValue(int columnIndex) {
+        return value(columnIndex);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalTime timeValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalTime timeValue(int columnIndex) {
+        return value(columnIndex);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDateTime datetimeValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDateTime datetimeValue(int columnIndex) {
+        return value(columnIndex);
+    }
+
+    /** {@inheritDoc} */
+    @Override public Instant timestampValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public Instant timestampValue(int columnIndex) {
+        return value(columnIndex);
+    }
+
+    /** {@inheritDoc} */
     @Override public SchemaDescriptor schema() {
         return schemaDesc;
     }
diff --git a/modules/table/src/test/java/org/apache/ignite/internal/table/impl/TestTupleBuilder.java b/modules/table/src/test/java/org/apache/ignite/internal/table/impl/TestTupleBuilder.java
index 440d7b7..dceee30 100644
--- a/modules/table/src/test/java/org/apache/ignite/internal/table/impl/TestTupleBuilder.java
+++ b/modules/table/src/test/java/org/apache/ignite/internal/table/impl/TestTupleBuilder.java
@@ -17,6 +17,10 @@
 
 package org.apache.ignite.internal.table.impl;
 
+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.Iterator;
@@ -180,6 +184,46 @@
     }
 
     /** {@inheritDoc} */
+    @Override public LocalDate dateValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDate dateValue(int columnIndex) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalTime timeValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalTime timeValue(int columnIndex) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDateTime datetimeValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public LocalDateTime datetimeValue(int columnIndex) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public Instant timestampValue(String columnName) {
+        return value(columnName);
+    }
+
+    /** {@inheritDoc} */
+    @Override public Instant timestampValue(int columnIndex) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
     @NotNull @Override public Iterator<Object> iterator() {
         throw new UnsupportedOperationException();
     }