Merge branch 'master' into case-insensitive-column-matching

2024-11-22 15:42:02 +00:00 · 2022-03-24 08:00:42 +00:00 · 2022-03-24 08:00:42 +00:00 · bf90edc362
commit bf90edc362
parent e9520335df d6f5583820
41 changed files with 1407 additions and 431 deletions
--- a/docker/test/stress/run.sh
+++ b/docker/test/stress/run.sh
@ -131,9 +131,6 @@ function start()
        # use root to match with current uid
        clickhouse start --user root >/var/log/clickhouse-server/stdout.log 2>>/var/log/clickhouse-server/stderr.log
        sleep 0.5
-        cat /var/log/clickhouse-server/stdout.log
-        tail -n200 /var/log/clickhouse-server/stderr.log
-        tail -n200 /var/log/clickhouse-server/clickhouse-server.log
        counter=$((counter + 1))
    done

@ -211,14 +208,12 @@ stop
 start

 clickhouse-client --query "SELECT 'Server successfully started', 'OK'" >> /test_output/test_results.tsv \
-                       || echo -e 'Server failed to start\tFAIL' >> /test_output/test_results.tsv
+                       || (echo -e 'Server failed to start (see application_errors.txt)\tFAIL' >> /test_output/test_results.tsv \
+                       && grep -Fa "<Error>.*Application" /var/log/clickhouse-server/clickhouse-server.log > /test_output/application_errors.txt)

 [ -f /var/log/clickhouse-server/clickhouse-server.log ] || echo -e "Server log does not exist\tFAIL"
 [ -f /var/log/clickhouse-server/stderr.log ] || echo -e "Stderr log does not exist\tFAIL"

-# Print Fatal log messages to stdout
-zgrep -Fa " <Fatal> " /var/log/clickhouse-server/clickhouse-server.log*
-
 # Grep logs for sanitizer asserts, crashes and other critical errors

 # Sanitizer asserts
@ -235,20 +230,26 @@ zgrep -Fa " <Fatal> Application: Child process was terminated by signal 9" /var/
    || echo -e 'No OOM messages in clickhouse-server.log\tOK' >> /test_output/test_results.tsv

 # Logical errors
-zgrep -Fa "Code: 49, e.displayText() = DB::Exception:" /var/log/clickhouse-server/clickhouse-server.log* > /dev/null \
-    && echo -e 'Logical error thrown (see clickhouse-server.log)\tFAIL' >> /test_output/test_results.tsv \
+zgrep -Fa "Code: 49, e.displayText() = DB::Exception:" /var/log/clickhouse-server/clickhouse-server.log* > /test_output/logical_errors.txt \
+    && echo -e 'Logical error thrown (see clickhouse-server.log or logical_errors.txt)\tFAIL' >> /test_output/test_results.tsv \
    || echo -e 'No logical errors\tOK' >> /test_output/test_results.tsv

+# Remove file logical_errors.txt if it's empty
+[ -s /test_output/logical_errors.txt ] || rm /test_output/logical_errors.txt
+
 # Crash
 zgrep -Fa "########################################" /var/log/clickhouse-server/clickhouse-server.log* > /dev/null \
    && echo -e 'Killed by signal (in clickhouse-server.log)\tFAIL' >> /test_output/test_results.tsv \
    || echo -e 'Not crashed\tOK' >> /test_output/test_results.tsv

 # It also checks for crash without stacktrace (printed by watchdog)
-zgrep -Fa " <Fatal> " /var/log/clickhouse-server/clickhouse-server.log* > /dev/null \
-    && echo -e 'Fatal message in clickhouse-server.log\tFAIL' >> /test_output/test_results.tsv \
+zgrep -Fa " <Fatal> " /var/log/clickhouse-server/clickhouse-server.log* > /test_output/fatal_messages.txt \
+    && echo -e 'Fatal message in clickhouse-server.log (see fatal_messages.txt)\tFAIL' >> /test_output/test_results.tsv \
    || echo -e 'No fatal messages in clickhouse-server.log\tOK' >> /test_output/test_results.tsv

+# Remove file fatal_messages.txt if it's empty
+[ -s /test_output/fatal_messages.txt ] || rm /test_output/fatal_messages.txt
+
 zgrep -Fa "########################################" /test_output/* > /dev/null \
    && echo -e 'Killed by signal (output files)\tFAIL' >> /test_output/test_results.tsv

@ -259,12 +260,12 @@ echo -e "Backward compatibility check\n"

 echo "Download previous release server"
 mkdir previous_release_package_folder
-clickhouse-client --query="SELECT version()" | ./download_previous_release && echo -e 'Download script exit code\tOK' >> /test_output/backward_compatibility_check_results.tsv \
-    || echo -e 'Download script failed\tFAIL' >> /test_output/backward_compatibility_check_results.tsv
+clickhouse-client --query="SELECT version()" | ./download_previous_release && echo -e 'Download script exit code\tOK' >> /test_output/test_results.tsv \
+    || echo -e 'Download script failed\tFAIL' >> /test_output/test_results.tsv

 if [ "$(ls -A previous_release_package_folder/clickhouse-common-static_*.deb && ls -A previous_release_package_folder/clickhouse-server_*.deb)" ]
 then
-    echo -e "Successfully downloaded previous release packets\tOK" >> /test_output/backward_compatibility_check_results.tsv
+    echo -e "Successfully downloaded previous release packets\tOK" >> /test_output/test_results.tsv
    stop

    # Uninstall current packages
@ -290,8 +291,8 @@ then
    mkdir tmp_stress_output
    
    ./stress --backward-compatibility-check --output-folder tmp_stress_output --global-time-limit=1200 \
-        && echo -e 'Test script exit code\tOK' >> /test_output/backward_compatibility_check_results.tsv \
-        || echo -e 'Test script failed\tFAIL' >> /test_output/backward_compatibility_check_results.tsv
+        && echo -e 'Backward compatibility check: Test script exit code\tOK' >> /test_output/test_results.tsv \
+        || echo -e 'Backward compatibility check: Test script failed\tFAIL' >> /test_output/test_results.tsv
    rm -rf tmp_stress_output

    clickhouse-client --query="SELECT 'Tables count:', count() FROM system.tables"
@ -301,8 +302,9 @@ then
    # Start new server
    configure
    start 500
-    clickhouse-client --query "SELECT 'Server successfully started', 'OK'" >> /test_output/backward_compatibility_check_results.tsv \
-        || echo -e 'Server failed to start\tFAIL' >> /test_output/backward_compatibility_check_results.tsv
+    clickhouse-client --query "SELECT 'Backward compatibility check: Server successfully started', 'OK'" >> /test_output/test_results.tsv \
+        || (echo -e 'Backward compatibility check: Server failed to start\tFAIL' >> /test_output/test_results.tsv \
+        && grep -Fa "<Error>.*Application" /var/log/clickhouse-server/clickhouse-server.log >> /test_output/bc_check_application_errors.txt)

    clickhouse-client --query="SELECT 'Server version: ', version()"

@ -312,10 +314,12 @@ then
    stop

    # Error messages (we should ignore some errors)
+    echo "Check for Error messages in server log:"
    zgrep -Fav -e "Code: 236. DB::Exception: Cancelled merging parts" \
               -e "Code: 236. DB::Exception: Cancelled mutating parts" \
               -e "REPLICA_IS_ALREADY_ACTIVE" \
               -e "REPLICA_IS_ALREADY_EXIST" \
+               -e "ALL_REPLICAS_LOST" \
               -e "DDLWorker: Cannot parse DDL task query" \
               -e "RaftInstance: failed to accept a rpc connection due to error 125" \
               -e "UNKNOWN_DATABASE" \
@ -328,47 +332,53 @@ then
               -e "Code: 1000, e.code() = 111, Connection refused" \
               -e "UNFINISHED" \
               -e "Renaming unexpected part" \
-        /var/log/clickhouse-server/clickhouse-server.log | zgrep -Fa "<Error>" > /dev/null \
-        && echo -e 'Error message in clickhouse-server.log\tFAIL' >> /test_output/backward_compatibility_check_results.tsv \
-        || echo -e 'No Error messages in clickhouse-server.log\tOK' >> /test_output/backward_compatibility_check_results.tsv
+        /var/log/clickhouse-server/clickhouse-server.log | zgrep -Fa "<Error>" > /test_output/bc_check_error_messages.txt \
+        && echo -e 'Backward compatibility check: Error message in clickhouse-server.log (see bc_check_error_messages.txt)\tFAIL' >> /test_output/test_results.tsv \
+        || echo -e 'Backward compatibility check: No Error messages in clickhouse-server.log\tOK' >> /test_output/test_results.tsv
+
+    # Remove file bc_check_error_messages.txt if it's empty
+    [ -s /test_output/bc_check_error_messages.txt ] || rm /test_output/bc_check_error_messages.txt

    # Sanitizer asserts
    zgrep -Fa "==================" /var/log/clickhouse-server/stderr.log >> /test_output/tmp
    zgrep -Fa "WARNING" /var/log/clickhouse-server/stderr.log >> /test_output/tmp
    zgrep -Fav "ASan doesn't fully support makecontext/swapcontext functions" /test_output/tmp > /dev/null \
-        && echo -e 'Sanitizer assert (in stderr.log)\tFAIL' >> /test_output/backward_compatibility_check_results.tsv \
-        || echo -e 'No sanitizer asserts\tOK' >> /test_output/backward_compatibility_check_results.tsv
+        && echo -e 'Backward compatibility check: Sanitizer assert (in stderr.log)\tFAIL' >> /test_output/test_results.tsv \
+        || echo -e 'Backward compatibility check: No sanitizer asserts\tOK' >> /test_output/test_results.tsv
    rm -f /test_output/tmp

    # OOM
    zgrep -Fa " <Fatal> Application: Child process was terminated by signal 9" /var/log/clickhouse-server/clickhouse-server.log > /dev/null \
-        && echo -e 'OOM killer (or signal 9) in clickhouse-server.log\tFAIL' >> /test_output/backward_compatibility_check_results.tsv \
-        || echo -e 'No OOM messages in clickhouse-server.log\tOK' >> /test_output/backward_compatibility_check_results.tsv
+        && echo -e 'Backward compatibility check: OOM killer (or signal 9) in clickhouse-server.log\tFAIL' >> /test_output/test_results.tsv \
+        || echo -e 'Backward compatibility check: No OOM messages in clickhouse-server.log\tOK' >> /test_output/test_results.tsv

    # Logical errors
-    zgrep -Fa "Code: 49, e.displayText() = DB::Exception:" /var/log/clickhouse-server/clickhouse-server.log > /dev/null \
-        && echo -e 'Logical error thrown (see clickhouse-server.log)\tFAIL' >> /test_output/backward_compatibility_check_results.tsv \
-        || echo -e 'No logical errors\tOK' >> /test_output/backward_compatibility_check_results.tsv
+    echo "Check for Logical errors in server log:"
+    zgrep -Fa -A20 "Code: 49, e.displayText() = DB::Exception:" /var/log/clickhouse-server/clickhouse-server.log > /test_output/bc_check_logical_errors.txt \
+        && echo -e 'Backward compatibility check: Logical error thrown (see clickhouse-server.log or bc_check_logical_errors.txt)\tFAIL' >> /test_output/test_results.tsv \
+        || echo -e 'Backward compatibility check: No logical errors\tOK' >> /test_output/test_results.tsv
+
+    # Remove file bc_check_logical_errors.txt if it's empty
+    [ -s /test_output/bc_check_logical_errors.txt ] || rm /test_output/bc_check_logical_errors.txt

    # Crash
    zgrep -Fa "########################################" /var/log/clickhouse-server/clickhouse-server.log > /dev/null \
-        && echo -e 'Killed by signal (in clickhouse-server.log)\tFAIL' >> /test_output/backward_compatibility_check_results.tsv \
-        || echo -e 'Not crashed\tOK' >> /test_output/backward_compatibility_check_results.tsv
+        && echo -e 'Backward compatibility check: Killed by signal (in clickhouse-server.log)\tFAIL' >> /test_output/test_results.tsv \
+        || echo -e 'Backward compatibility check: Not crashed\tOK' >> /test_output/test_results.tsv

    # It also checks for crash without stacktrace (printed by watchdog)
-    zgrep -Fa " <Fatal> " /var/log/clickhouse-server/clickhouse-server.log > /dev/null \
-        && echo -e 'Fatal message in clickhouse-server.log\tFAIL' >> /test_output/backward_compatibility_check_results.tsv \
-        || echo -e 'No fatal messages in clickhouse-server.log\tOK' >> /test_output/backward_compatibility_check_results.tsv
+    echo "Check for Fatal message in server log:"
+    zgrep -Fa " <Fatal> " /var/log/clickhouse-server/clickhouse-server.log > /test_output/bc_check_fatal_messages.txt \
+        && echo -e 'Backward compatibility check: Fatal message in clickhouse-server.log (see bc_check_fatal_messages.txt)\tFAIL' >> /test_output/test_results.tsv \
+        || echo -e 'Backward compatibility check: No fatal messages in clickhouse-server.log\tOK' >> /test_output/test_results.tsv
+
+    # Remove file bc_check_fatal_messages.txt if it's empty
+    [ -s /test_output/bc_check_fatal_messages.txt ] || rm /test_output/bc_check_fatal_messages.txt

 else
-    echo -e "Failed to download previous release packets\tFAIL" >> /test_output/backward_compatibility_check_results.tsv
+    echo -e "Backward compatibility check: Failed to download previous release packets\tFAIL" >> /test_output/test_results.tsv
 fi

-zgrep -Fa "FAIL" /test_output/backward_compatibility_check_results.tsv > /dev/null \
-        && echo -e 'Backward compatibility check\tFAIL' >> /test_output/test_results.tsv \
-        || echo -e 'Backward compatibility check\tOK' >> /test_output/test_results.tsv
-
-
 # Put logs into /test_output/
 for log_file in /var/log/clickhouse-server/clickhouse-server.log*
 do
--- a/docs/en/introduction/adopters.md
+++ b/docs/en/introduction/adopters.md
@ -195,5 +195,6 @@ toc_title: Adopters
 | <a href="https://shop.okraina.ru/" class="favicon">ООО «МПЗ Богородский»</a> | Agriculture | — | — | — | [Article in Russian, November 2020](https://cloud.yandex.ru/cases/okraina) |
 | <a href="https://domclick.ru/" class="favicon">ДомКлик</a> | Real Estate | — | — | — | [Article in Russian, October 2021](https://habr.com/ru/company/domclick/blog/585936/) |
 | <a href="https://magenta-technology.ru/sistema-upravleniya-marshrutami-inkassacii-as-strela/" class="favicon">АС "Стрела"</a> | Transportation | — | — | — | [Job posting, Jan 2022](https://vk.com/topic-111905078_35689124?post=3553) |
+| <a href="https://piwik.pro/" class="favicon">Piwik PRO</a> | Web Analytics | — | — | — | [Official website, Dec 2018](https://piwik.pro/blog/piwik-pro-clickhouse-faster-efficient-reports/) |

 [Original article](https://clickhouse.com/docs/en/introduction/adopters/) <!--hide-->
--- a/docs/en/operations/caches.md
+++ b/docs/en/operations/caches.md
@ -5,7 +5,7 @@ toc_title: Caches

 # Cache Types {#cache-types}

-When performing queries, ClichHouse uses different caches.
+When performing queries, ClickHouse uses different caches.

 Main cache types:

--- a/src/Common/IntervalKind.cpp
+++ b/src/Common/IntervalKind.cpp
@ -13,6 +13,9 @@ Int32 IntervalKind::toAvgSeconds() const
 {
    switch (kind)
    {
+        case IntervalKind::Nanosecond: return 0;    /// fractional parts of seconds have 0 seconds
+        case IntervalKind::Microsecond: return 0;
+        case IntervalKind::Millisecond: return 0;
        case IntervalKind::Second: return 1;
        case IntervalKind::Minute: return 60;
        case IntervalKind::Hour: return 3600;
@ -52,6 +55,9 @@ const char * IntervalKind::toKeyword() const
 {
    switch (kind)
    {
+        case IntervalKind::Nanosecond: return "NANOSECOND";
+        case IntervalKind::Microsecond: return "MICROSECOND";
+        case IntervalKind::Millisecond: return "MILLISECOND";
        case IntervalKind::Second: return "SECOND";
        case IntervalKind::Minute: return "MINUTE";
        case IntervalKind::Hour: return "HOUR";
@ -69,6 +75,9 @@ const char * IntervalKind::toLowercasedKeyword() const
 {
    switch (kind)
    {
+        case IntervalKind::Nanosecond: return "nanosecond";
+        case IntervalKind::Microsecond: return "microsecond";
+        case IntervalKind::Millisecond: return "millisecond";
        case IntervalKind::Second: return "second";
        case IntervalKind::Minute: return "minute";
        case IntervalKind::Hour: return "hour";
@ -86,6 +95,12 @@ const char * IntervalKind::toDateDiffUnit() const
 {
    switch (kind)
    {
+        case IntervalKind::Nanosecond:
+            return "nanosecond";
+        case IntervalKind::Microsecond:
+            return "microsecond";
+        case IntervalKind::Millisecond:
+            return "millisecond";
        case IntervalKind::Second:
            return "second";
        case IntervalKind::Minute:
@ -111,6 +126,12 @@ const char * IntervalKind::toNameOfFunctionToIntervalDataType() const
 {
    switch (kind)
    {
+        case IntervalKind::Nanosecond:
+            return "toIntervalNanosecond";
+        case IntervalKind::Microsecond:
+            return "toIntervalMicrosecond";
+        case IntervalKind::Millisecond:
+            return "toIntervalMillisecond";
        case IntervalKind::Second:
            return "toIntervalSecond";
        case IntervalKind::Minute:
@ -136,6 +157,12 @@ const char * IntervalKind::toNameOfFunctionExtractTimePart() const
 {
    switch (kind)
    {
+        case IntervalKind::Nanosecond:
+            return "toNanosecond";
+        case IntervalKind::Microsecond:
+            return "toMicrosecond";
+        case IntervalKind::Millisecond:
+            return "toMillisecond";
        case IntervalKind::Second:
            return "toSecond";
        case IntervalKind::Minute:
@ -162,6 +189,21 @@ const char * IntervalKind::toNameOfFunctionExtractTimePart() const

 bool IntervalKind::tryParseString(const std::string & kind, IntervalKind::Kind & result)
 {
+    if ("nanosecond" == kind)
+    {
+        result = IntervalKind::Nanosecond;
+        return true;
+    }
+    if ("microsecond" == kind)
+    {
+        result = IntervalKind::Microsecond;
+        return true;
+    }
+    if ("millisecond" == kind)
+    {
+        result = IntervalKind::Millisecond;
+        return true;
+    }
    if ("second" == kind)
    {
        result = IntervalKind::Second;
--- a/src/Common/IntervalKind.h
+++ b/src/Common/IntervalKind.h
@ -10,6 +10,9 @@ struct IntervalKind
 {
    enum Kind
    {
+        Nanosecond,
+        Microsecond,
+        Millisecond,
        Second,
        Minute,
        Hour,
@ -61,6 +64,9 @@ struct IntervalKind

 /// NOLINTNEXTLINE
 #define FOR_EACH_INTERVAL_KIND(M) \
+    M(Nanosecond) \
+    M(Microsecond) \
+    M(Millisecond) \
    M(Second) \
    M(Minute) \
    M(Hour) \
--- a/src/Common/RadixSort.h
+++ b/src/Common/RadixSort.h
@ -515,6 +515,11 @@ public:
        radixSortLSDInternal<false>(arr, size, false, nullptr);
    }

+    static void executeLSD(Element * arr, size_t size, bool reverse)
+    {
+        radixSortLSDInternal<false>(arr, size, reverse, nullptr);
+    }
+
    /** This function will start to sort inplace (modify 'arr')
      *  but on the last step it will write result directly to the destination
      *  instead of finishing sorting 'arr'.
--- a/src/DataTypes/DataTypeFactory.cpp
+++ b/src/DataTypes/DataTypeFactory.cpp
@ -33,7 +33,7 @@ DataTypePtr DataTypeFactory::get(const String & full_name) const
    /// Value 315 is known to cause stack overflow in some test configurations (debug build, sanitizers)
    /// let's make the threshold significantly lower.
    /// It is impractical for user to have complex data types with this depth.
-    static constexpr size_t data_type_max_parse_depth = 200;
+    static constexpr size_t data_type_max_parse_depth = 150;

    ParserDataType parser;
    ASTPtr ast = parseQuery(parser, full_name.data(), full_name.data() + full_name.size(), "data type", 0, data_type_max_parse_depth);
--- a/src/DataTypes/DataTypeInterval.cpp
+++ b/src/DataTypes/DataTypeInterval.cpp
@ -13,6 +13,9 @@ bool DataTypeInterval::equals(const IDataType & rhs) const

 void registerDataTypeInterval(DataTypeFactory & factory)
 {
+    factory.registerSimpleDataType("IntervalNanosecond", [] { return DataTypePtr(std::make_shared<DataTypeInterval>(IntervalKind::Nanosecond)); });
+    factory.registerSimpleDataType("IntervalMicrosecond", [] { return DataTypePtr(std::make_shared<DataTypeInterval>(IntervalKind::Microsecond)); });
+    factory.registerSimpleDataType("IntervalMillisecond", [] { return DataTypePtr(std::make_shared<DataTypeInterval>(IntervalKind::Millisecond)); });
    factory.registerSimpleDataType("IntervalSecond", [] { return DataTypePtr(std::make_shared<DataTypeInterval>(IntervalKind::Second)); });
    factory.registerSimpleDataType("IntervalMinute", [] { return DataTypePtr(std::make_shared<DataTypeInterval>(IntervalKind::Minute)); });
    factory.registerSimpleDataType("IntervalHour", [] { return DataTypePtr(std::make_shared<DataTypeInterval>(IntervalKind::Hour)); });
--- a/src/Functions/DateTimeTransforms.h
+++ b/src/Functions/DateTimeTransforms.h
@ -41,6 +41,11 @@ namespace ErrorCodes
        throw Exception("Illegal type Date of argument for function " + std::string(name), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
    }

+    static inline UInt32 dateTimeIsNotSupported(const char * name)
+    {
+        throw Exception("Illegal type DateTime of argument for function " + std::string(name), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+
 /// This factor transformation will say that the function is monotone everywhere.
 struct ZeroTransform
 {
@ -311,6 +316,133 @@ struct ToStartOfSecondImpl
    using FactorTransform = ZeroTransform;
 };

+struct ToStartOfMillisecondImpl
+{
+    static constexpr auto name = "toStartOfMillisecond";
+
+    static inline DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
+    {
+        // given that scale is 6, scale_multiplier is 1000000
+        // for DateTime64 value of 123.456789:
+        // 123456789 - 789 = 123456000
+        // for DateTime64 value of -123.456789:
+        // -123456789 - (1000 + (-789)) = -123457000
+
+        if (scale_multiplier == 1000)
+        {
+            return datetime64;
+        }
+        else if (scale_multiplier <= 1000)
+        {
+            return datetime64 * (1000 / scale_multiplier);
+        }
+        else
+        {
+        auto droppable_part_with_sign = DecimalUtils::getFractionalPartWithScaleMultiplier<DateTime64, true>(datetime64, scale_multiplier / 1000);
+
+        if (droppable_part_with_sign < 0)
+            droppable_part_with_sign += scale_multiplier;
+
+        return datetime64 - droppable_part_with_sign;
+        }
+    }
+
+    static inline UInt32 execute(UInt32, const DateLUTImpl &)
+    {
+        throw Exception("Illegal type DateTime of argument for function " + std::string(name), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    {
+        return dateIsNotSupported(name);
+    }
+    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    {
+        return dateIsNotSupported(name);
+    }
+
+    using FactorTransform = ZeroTransform;
+};
+
+struct ToStartOfMicrosecondImpl
+{
+    static constexpr auto name = "toStartOfMicrosecond";
+
+    static inline DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
+    {
+        // @see ToStartOfMillisecondImpl
+
+        if (scale_multiplier == 1000000)
+        {
+            return datetime64;
+        }
+        else if (scale_multiplier <= 1000000)
+        {
+            return datetime64 * (1000000 / scale_multiplier);
+        }
+        else
+        {
+            auto droppable_part_with_sign = DecimalUtils::getFractionalPartWithScaleMultiplier<DateTime64, true>(datetime64, scale_multiplier / 1000000);
+
+            if (droppable_part_with_sign < 0)
+                droppable_part_with_sign += scale_multiplier;
+
+            return datetime64 - droppable_part_with_sign;
+        }
+    }
+
+    static inline UInt32 execute(UInt32, const DateLUTImpl &)
+    {
+        throw Exception("Illegal type DateTime of argument for function " + std::string(name), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    {
+        return dateIsNotSupported(name);
+    }
+    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    {
+        return dateIsNotSupported(name);
+    }
+
+    using FactorTransform = ZeroTransform;
+};
+
+struct ToStartOfNanosecondImpl
+{
+    static constexpr auto name = "toStartOfNanosecond";
+
+    static inline DateTime64 execute(const DateTime64 & datetime64, Int64 scale_multiplier, const DateLUTImpl &)
+    {
+        // @see ToStartOfMillisecondImpl
+        if (scale_multiplier == 1000000000)
+        {
+            return datetime64;
+        }
+        else if (scale_multiplier <= 1000000000)
+        {
+            return datetime64 * (1000000000 / scale_multiplier);
+        }
+        else
+        {
+            throw Exception("Illegal type of argument for function " + std::string(name) + ", DateTime64 expected", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        }
+    }
+
+    static inline UInt32 execute(UInt32, const DateLUTImpl &)
+    {
+        throw Exception("Illegal type DateTime of argument for function " + std::string(name), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+    static inline UInt32 execute(Int32, const DateLUTImpl &)
+    {
+        return dateIsNotSupported(name);
+    }
+    static inline UInt32 execute(UInt16, const DateLUTImpl &)
+    {
+        return dateIsNotSupported(name);
+    }
+
+    using FactorTransform = ZeroTransform;
+};
+
 struct ToStartOfFiveMinuteImpl
 {
    static constexpr auto name = "toStartOfFiveMinute";
--- a/src/Functions/FunctionDateOrDateTimeAddInterval.h
+++ b/src/Functions/FunctionDateOrDateTimeAddInterval.h
@ -40,26 +40,158 @@ namespace ErrorCodes
 ///  - 'AddSecondsImpl::execute(UInt32, ...) -> UInt32' is available to the ClickHouse users as 'addSeconds(DateTime, ...) -> DateTime'
 ///  - 'AddSecondsImpl::execute(UInt16, ...) -> UInt32' is available to the ClickHouse users as 'addSeconds(Date, ...) -> DateTime'

+struct AddNanosecondsImpl
+{
+    static constexpr auto name = "addNanoseconds";
+
+    static inline NO_SANITIZE_UNDEFINED DecimalUtils::DecimalComponents<DateTime64>
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl &, UInt16 scale = DataTypeDateTime64::default_scale)
+    {
+        Int64 multiplier = DecimalUtils::scaleMultiplier<DateTime64>(9 - scale);
+        auto division = std::div(t.fractional * multiplier + delta, static_cast<Int64>(1000000000));
+        return {t.whole * multiplier + division.quot, t.fractional * multiplier + delta};
+    }
+
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int64 delta, const DateLUTImpl &, UInt16 scale = 0)
+    {
+        Int64 multiplier = DecimalUtils::scaleMultiplier<DateTime64>(9 - scale);
+        return t * multiplier + delta;
+    }
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &, UInt16 = 0)
+    {
+        Int64 multiplier = DecimalUtils::scaleMultiplier<DateTime64>(9);
+        return t * multiplier + delta;
+    }
+
+    static inline NO_SANITIZE_UNDEFINED DateTime64 execute(UInt16, Int64, const DateLUTImpl &, UInt16 = 0)
+    {
+        throw Exception("addNanoSeconds() cannot be used with Date", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+
+    static inline NO_SANITIZE_UNDEFINED DateTime64 execute(Int32, Int64, const DateLUTImpl &, UInt16 = 0)
+    {
+        throw Exception("addNanoSeconds() cannot be used with Date32", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+};
+
+struct AddMicrosecondsImpl
+{
+    static constexpr auto name = "addMicroseconds";
+
+    static inline NO_SANITIZE_UNDEFINED DecimalUtils::DecimalComponents<DateTime64>
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl &, UInt16 scale = 0)
+    {
+        Int64 multiplier = DecimalUtils::scaleMultiplier<DateTime64>(std::abs(6 - scale));
+        if (scale <= 6)
+        {
+            auto division = std::div((t.fractional + delta), static_cast<Int64>(10e6));
+            return {t.whole * multiplier + division.quot, division.rem};
+        }
+        else
+        {
+            auto division = std::div((t.fractional + delta * multiplier), static_cast<Int64>(10e6 * multiplier));
+            return {t.whole + division.quot, division.rem};
+        }
+    }
+
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int64 delta, const DateLUTImpl &, UInt16 scale = 0)
+    {
+        Int64 multiplier = DecimalUtils::scaleMultiplier<DateTime64>(std::abs(6 - scale));
+        return scale <= 6 ? t * multiplier + delta : t + delta * multiplier;
+    }
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &, UInt16 = 0)
+    {
+        Int64 multiplier = DecimalUtils::scaleMultiplier<DateTime64>(6);
+        return t * multiplier + delta;
+    }
+
+    static inline NO_SANITIZE_UNDEFINED DateTime64 execute(UInt16, Int64, const DateLUTImpl &, UInt16 = 0)
+    {
+        throw Exception("addMicroSeconds() cannot be used with Date", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+
+    static inline NO_SANITIZE_UNDEFINED DateTime64 execute(Int32, Int64, const DateLUTImpl &, UInt16 = 0)
+    {
+        throw Exception("addMicroSeconds() cannot be used with Date32", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+};
+
+struct AddMillisecondsImpl
+{
+    static constexpr auto name = "addMilliseconds";
+
+    static inline NO_SANITIZE_UNDEFINED DecimalUtils::DecimalComponents<DateTime64>
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl &, UInt16 scale = DataTypeDateTime64::default_scale)
+    {
+        Int64 multiplier = DecimalUtils::scaleMultiplier<DateTime64>(std::abs(3 - scale));
+        if (scale <= 3)
+        {
+            auto division = std::div((t.fractional + delta), static_cast<Int64>(1000));
+            return {t.whole * multiplier + division.quot, division.rem};
+        }
+        else
+        {
+            auto division = std::div((t.fractional + delta * multiplier), static_cast<Int64>(1000 * multiplier));
+            return {t.whole + division.quot,division.rem};
+        }
+    }
+
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int64 delta, const DateLUTImpl &, UInt16 scale = 0)
+    {
+        Int64 multiplier = DecimalUtils::scaleMultiplier<DateTime64>(std::abs(3 - scale));
+        return scale <= 3 ? t * multiplier + delta : t + delta * multiplier;
+    }
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &, UInt16 = 0)
+    {
+        Int64 multiplier = DecimalUtils::scaleMultiplier<DateTime64>(3);
+        return t * multiplier + delta;
+    }
+
+    static inline NO_SANITIZE_UNDEFINED DateTime64 execute(UInt16, Int64, const DateLUTImpl &, UInt16 = 0)
+    {
+        throw Exception("addMilliSeconds() cannot be used with Date", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+
+    static inline NO_SANITIZE_UNDEFINED DateTime64 execute(Int32, Int64, const DateLUTImpl &, UInt16 = 0)
+    {
+        throw Exception("addMilliSeconds() cannot be used with Date32", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+};
+
 struct AddSecondsImpl
 {
    static constexpr auto name = "addSeconds";

    static inline NO_SANITIZE_UNDEFINED DecimalUtils::DecimalComponents<DateTime64>
-    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl &)
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl &, UInt16 = 0)
    {
        return {t.whole + delta, t.fractional};
    }

-    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &)
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int64 delta, const DateLUTImpl &, UInt16 scale = 0)
+    {
+        return t + delta * DecimalUtils::scaleMultiplier<DateTime64>(scale);
+    }
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &, UInt16 = 0)
    {
        return t + delta;
    }
-    static inline NO_SANITIZE_UNDEFINED Int64 execute(Int32 d, Int64 delta, const DateLUTImpl & time_zone)
+
+    static inline NO_SANITIZE_UNDEFINED Int64 execute(Int32 d, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        // use default datetime64 scale
        return (time_zone.fromDayNum(ExtendedDayNum(d)) + delta) * 1000;
    }
-    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt16 d, Int64 delta, const DateLUTImpl & time_zone)
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt16 d, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.fromDayNum(DayNum(d)) + delta;
    }
@ -70,21 +202,29 @@ struct AddMinutesImpl
    static constexpr auto name = "addMinutes";

    static inline NO_SANITIZE_UNDEFINED DecimalUtils::DecimalComponents<DateTime64>
-    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl &)
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl &, UInt16 = 0)
    {
        return {t.whole + delta * 60, t.fractional};
    }

-    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &)
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int64 delta, const DateLUTImpl &, UInt16 scale = 0)
+    {
+        return t + 60 * delta * DecimalUtils::scaleMultiplier<DateTime64>(scale);
+    }
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &, UInt16 = 0)
    {
        return t + delta * 60;
    }
-    static inline NO_SANITIZE_UNDEFINED Int64 execute(Int32 d, Int64 delta, const DateLUTImpl & time_zone)
+
+    static inline NO_SANITIZE_UNDEFINED Int64 execute(Int32 d, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        // use default datetime64 scale
        return (time_zone.fromDayNum(ExtendedDayNum(d)) + delta * 60) * 1000;
    }
-    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt16 d, Int64 delta, const DateLUTImpl & time_zone)
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt16 d, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.fromDayNum(DayNum(d)) + delta * 60;
    }
@ -95,20 +235,29 @@ struct AddHoursImpl
    static constexpr auto name = "addHours";

    static inline NO_SANITIZE_UNDEFINED DecimalUtils::DecimalComponents<DateTime64>
-    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl &)
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl &, UInt16 = 0)
    {
        return {t.whole + delta * 3600, t.fractional};
    }
-    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &)
+
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int64 delta, const DateLUTImpl &, UInt16 scale = 0)
+    {
+        return t + 3600 * delta * DecimalUtils::scaleMultiplier<DateTime64>(scale);
+    }
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl &, UInt16 = 0)
    {
        return t + delta * 3600;
    }
-    static inline NO_SANITIZE_UNDEFINED Int64 execute(Int32 d, Int64 delta, const DateLUTImpl & time_zone)
+
+    static inline NO_SANITIZE_UNDEFINED Int64 execute(Int32 d, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        // use default datetime64 scale
        return (time_zone.fromDayNum(ExtendedDayNum(d)) + delta * 3600) * 1000;
    }
-    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt16 d, Int64 delta, const DateLUTImpl & time_zone)
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt16 d, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.fromDayNum(DayNum(d)) + delta * 3600;
    }
@ -119,22 +268,30 @@ struct AddDaysImpl
    static constexpr auto name = "addDays";

    static inline NO_SANITIZE_UNDEFINED DecimalUtils::DecimalComponents<DateTime64>
-    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl & time_zone)
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return {time_zone.addDays(t.whole, delta), t.fractional};
    }

-    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int64 delta, const DateLUTImpl & time_zone, UInt16 scale = 0)
+    {
+        auto multiplier = DecimalUtils::scaleMultiplier<DateTime64>(scale);
+        auto d = std::div(t, multiplier);
+        return time_zone.addDays(d.quot, delta) * multiplier + d.rem;
+    }
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addDays(t, delta);
    }

-    static inline NO_SANITIZE_UNDEFINED UInt16 execute(UInt16 d, Int64 delta, const DateLUTImpl &)
+    static inline NO_SANITIZE_UNDEFINED UInt16 execute(UInt16 d, Int64 delta, const DateLUTImpl &, UInt16 = 0)
    {
        return d + delta;
    }

-    static inline NO_SANITIZE_UNDEFINED Int32 execute(Int32 d, Int64 delta, const DateLUTImpl &)
+    static inline NO_SANITIZE_UNDEFINED Int32 execute(Int32 d, Int64 delta, const DateLUTImpl &, UInt16 = 0)
    {
        return d + delta;
    }
@ -145,22 +302,30 @@ struct AddWeeksImpl
    static constexpr auto name = "addWeeks";

    static inline NO_SANITIZE_UNDEFINED DecimalUtils::DecimalComponents<DateTime64>
-    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int32 delta, const DateLUTImpl & time_zone)
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int32 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return {time_zone.addWeeks(t.whole, delta), t.fractional};
    }

-    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int32 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int32 delta, const DateLUTImpl & time_zone, UInt16 scale = 0)
+    {
+        auto multiplier = DecimalUtils::scaleMultiplier<DateTime64>(scale);
+        auto d = std::div(t, multiplier);
+        return time_zone.addDays(d.quot, delta * 7) * multiplier + d.rem;
+    }
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int32 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addWeeks(t, delta);
    }

-    static inline NO_SANITIZE_UNDEFINED UInt16 execute(UInt16 d, Int32 delta, const DateLUTImpl &)
+    static inline NO_SANITIZE_UNDEFINED UInt16 execute(UInt16 d, Int32 delta, const DateLUTImpl &, UInt16 = 0)
    {
        return d + delta * 7;
    }

-    static inline NO_SANITIZE_UNDEFINED Int32 execute(Int32 d, Int32 delta, const DateLUTImpl &)
+    static inline NO_SANITIZE_UNDEFINED Int32 execute(Int32 d, Int32 delta, const DateLUTImpl &, UInt16 = 0)
    {
        return d + delta * 7;
    }
@ -170,23 +335,31 @@ struct AddMonthsImpl
 {
    static constexpr auto name = "addMonths";

-    static inline DecimalUtils::DecimalComponents<DateTime64>
-    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED DecimalUtils::DecimalComponents<DateTime64>
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return {time_zone.addMonths(t.whole, delta), t.fractional};
    }

-    static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int64 delta, const DateLUTImpl & time_zone, UInt16 scale = 0)
+    {
+        auto multiplier = DecimalUtils::scaleMultiplier<DateTime64>(scale);
+        auto d = std::div(t, multiplier);
+        return time_zone.addMonths(d.quot, delta) * multiplier + d.rem;
+    }
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addMonths(t, delta);
    }

-    static inline UInt16 execute(UInt16 d, Int64 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED UInt16 execute(UInt16 d, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addMonths(DayNum(d), delta);
    }

-    static inline Int32 execute(Int32 d, Int64 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED Int32 execute(Int32 d, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addMonths(ExtendedDayNum(d), delta);
    }
@ -197,22 +370,30 @@ struct AddQuartersImpl
    static constexpr auto name = "addQuarters";

    static inline DecimalUtils::DecimalComponents<DateTime64>
-    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int32 delta, const DateLUTImpl & time_zone)
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int32 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return {time_zone.addQuarters(t.whole, delta), t.fractional};
    }

-    static inline UInt32 execute(UInt32 t, Int32 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int32 delta, const DateLUTImpl & time_zone, UInt16 scale = 0)
+    {
+        auto multiplier = DecimalUtils::scaleMultiplier<DateTime64>(scale);
+        auto d = std::div(t, multiplier);
+        return time_zone.addQuarters(d.quot, delta) * multiplier + d.rem;
+    }
+
+    static inline UInt32 execute(UInt32 t, Int32 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addQuarters(t, delta);
    }

-    static inline UInt16 execute(UInt16 d, Int32 delta, const DateLUTImpl & time_zone)
+    static inline UInt16 execute(UInt16 d, Int32 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addQuarters(DayNum(d), delta);
    }

-    static inline Int32 execute(Int32 d, Int32 delta, const DateLUTImpl & time_zone)
+    static inline Int32 execute(Int32 d, Int32 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addQuarters(ExtendedDayNum(d), delta);
    }
@ -222,23 +403,31 @@ struct AddYearsImpl
 {
    static constexpr auto name = "addYears";

-    static inline DecimalUtils::DecimalComponents<DateTime64>
-    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED DecimalUtils::DecimalComponents<DateTime64>
+    execute(DecimalUtils::DecimalComponents<DateTime64> t, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return {time_zone.addYears(t.whole, delta), t.fractional};
    }

-    static inline UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED DateTime64
+    execute(DateTime64 t, Int64 delta, const DateLUTImpl & time_zone, UInt16 scale = 0)
+    {
+        auto multiplier = DecimalUtils::scaleMultiplier<DateTime64>(scale);
+        auto d = std::div(t, multiplier);
+        return time_zone.addYears(d.quot, delta) * multiplier + d.rem;
+    }
+
+    static inline NO_SANITIZE_UNDEFINED UInt32 execute(UInt32 t, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addYears(t, delta);
    }

-    static inline UInt16 execute(UInt16 d, Int64 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED UInt16 execute(UInt16 d, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addYears(DayNum(d), delta);
    }

-    static inline Int32 execute(Int32 d, Int64 delta, const DateLUTImpl & time_zone)
+    static inline NO_SANITIZE_UNDEFINED Int32 execute(Int32 d, Int64 delta, const DateLUTImpl & time_zone, UInt16 = 0)
    {
        return time_zone.addYears(ExtendedDayNum(d), delta);
    }
@ -250,13 +439,16 @@ struct SubtractIntervalImpl : public Transform
    using Transform::Transform;

    template <typename T>
-    inline NO_SANITIZE_UNDEFINED auto execute(T t, Int64 delta, const DateLUTImpl & time_zone) const
+    inline NO_SANITIZE_UNDEFINED auto execute(T t, Int64 delta, const DateLUTImpl & time_zone, UInt16 scale) const
    {
        /// Signed integer overflow is Ok.
-        return Transform::execute(t, -delta, time_zone);
+        return Transform::execute(t, -delta, time_zone, scale);
    }
 };

+struct SubtractNanosecondsImpl : SubtractIntervalImpl<AddNanosecondsImpl> { static constexpr auto name = "subtractNanoseconds"; };
+struct SubtractMicrosecondsImpl : SubtractIntervalImpl<AddMicrosecondsImpl> { static constexpr auto name = "subtractMicroseconds"; };
+struct SubtractMillisecondsImpl : SubtractIntervalImpl<AddMillisecondsImpl> { static constexpr auto name = "subtractMilliseconds"; };
 struct SubtractSecondsImpl : SubtractIntervalImpl<AddSecondsImpl> { static constexpr auto name = "subtractSeconds"; };
 struct SubtractMinutesImpl : SubtractIntervalImpl<AddMinutesImpl> { static constexpr auto name = "subtractMinutes"; };
 struct SubtractHoursImpl : SubtractIntervalImpl<AddHoursImpl> { static constexpr auto name = "subtractHours"; };
@ -277,17 +469,17 @@ struct Adder
    {}

    template <typename FromVectorType, typename ToVectorType>
-    void NO_INLINE vectorConstant(const FromVectorType & vec_from, ToVectorType & vec_to, Int64 delta, const DateLUTImpl & time_zone) const
+    void NO_INLINE vectorConstant(const FromVectorType & vec_from, ToVectorType & vec_to, Int64 delta, const DateLUTImpl & time_zone, UInt16 scale) const
    {
        size_t size = vec_from.size();
        vec_to.resize(size);

        for (size_t i = 0; i < size; ++i)
-            vec_to[i] = transform.execute(vec_from[i], checkOverflow(delta), time_zone);
+            vec_to[i] = transform.execute(vec_from[i], checkOverflow(delta), time_zone, scale);
    }

    template <typename FromVectorType, typename ToVectorType>
-    void vectorVector(const FromVectorType & vec_from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone) const
+    void vectorVector(const FromVectorType & vec_from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone, UInt16 scale) const
    {
        size_t size = vec_from.size();
        vec_to.resize(size);
@ -296,11 +488,11 @@ struct Adder
            ColumnUInt8, ColumnUInt16, ColumnUInt32, ColumnUInt64,
            ColumnInt8, ColumnInt16, ColumnInt32, ColumnInt64,
            ColumnFloat32, ColumnFloat64>(
-            &delta, [&](const auto & column){ vectorVector(vec_from, vec_to, column, time_zone, size); return true; });
+            &delta, [&](const auto & column){ vectorVector(vec_from, vec_to, column, time_zone, scale, size); return true; });
    }

    template <typename FromType, typename ToVectorType>
-    void constantVector(const FromType & from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone) const
+    void constantVector(const FromType & from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone, UInt16 scale) const
    {
        size_t size = delta.size();
        vec_to.resize(size);
@ -309,7 +501,7 @@ struct Adder
            ColumnUInt8, ColumnUInt16, ColumnUInt32, ColumnUInt64,
            ColumnInt8, ColumnInt16, ColumnInt32, ColumnInt64,
            ColumnFloat32, ColumnFloat64>(
-            &delta, [&](const auto & column){ constantVector(from, vec_to, column, time_zone, size); return true; });
+            &delta, [&](const auto & column){ constantVector(from, vec_to, column, time_zone, scale, size); return true; });
    }

 private:
@ -325,18 +517,18 @@ private:

    template <typename FromVectorType, typename ToVectorType, typename DeltaColumnType>
    NO_INLINE NO_SANITIZE_UNDEFINED void vectorVector(
-        const FromVectorType & vec_from, ToVectorType & vec_to, const DeltaColumnType & delta, const DateLUTImpl & time_zone, size_t size) const
+        const FromVectorType & vec_from, ToVectorType & vec_to, const DeltaColumnType & delta, const DateLUTImpl & time_zone, UInt16 scale, size_t size) const
    {
        for (size_t i = 0; i < size; ++i)
-            vec_to[i] = transform.execute(vec_from[i], checkOverflow(delta.getData()[i]), time_zone);
+            vec_to[i] = transform.execute(vec_from[i], checkOverflow(delta.getData()[i]), time_zone, scale);
    }

    template <typename FromType, typename ToVectorType, typename DeltaColumnType>
    NO_INLINE NO_SANITIZE_UNDEFINED void constantVector(
-        const FromType & from, ToVectorType & vec_to, const DeltaColumnType & delta, const DateLUTImpl & time_zone, size_t size) const
+        const FromType & from, ToVectorType & vec_to, const DeltaColumnType & delta, const DateLUTImpl & time_zone, UInt16 scale, size_t size) const
    {
        for (size_t i = 0; i < size; ++i)
-            vec_to[i] = transform.execute(from, checkOverflow(delta.getData()[i]), time_zone);
+            vec_to[i] = transform.execute(from, checkOverflow(delta.getData()[i]), time_zone, scale);
    }
 };

@ -344,7 +536,7 @@ private:
 template <typename FromDataType, typename ToDataType, typename Transform>
 struct DateTimeAddIntervalImpl
 {
-    static ColumnPtr execute(Transform transform, const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type)
+    static ColumnPtr execute(Transform transform, const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, UInt16 scale = 0)
    {
        using FromValueType = typename FromDataType::FieldType;
        using FromColumnType = typename FromDataType::ColumnType;
@ -363,16 +555,15 @@ struct DateTimeAddIntervalImpl
        if (const auto * sources = checkAndGetColumn<FromColumnType>(source_col.get()))
        {
            if (const auto * delta_const_column = typeid_cast<const ColumnConst *>(&delta_column))
-                op.vectorConstant(sources->getData(), col_to->getData(), delta_const_column->getInt(0), time_zone);
+                op.vectorConstant(sources->getData(), col_to->getData(), delta_const_column->getInt(0), time_zone, scale);
            else
-                op.vectorVector(sources->getData(), col_to->getData(), delta_column, time_zone);
+                op.vectorVector(sources->getData(), col_to->getData(), delta_column, time_zone, scale);
        }
        else if (const auto * sources_const = checkAndGetColumnConst<FromColumnType>(source_col.get()))
        {
            op.constantVector(
                sources_const->template getValue<FromValueType>(),
-                col_to->getData(),
-                delta_column, time_zone);
+                col_to->getData(), delta_column, time_zone, scale);
        }
        else
        {
@ -463,18 +654,10 @@ public:
        }
    }

-    // TransformDateTime64 helps choosing correct overload of exec and does some transformations
-    // on input and output parameters to simplify support of DateTime64 in concrete Transform.
-    template <typename FieldType>
-    using TransformType = std::conditional_t<
-        std::is_same_v<FieldType, DateTime64>,
-        TransformDateTime64<Transform>,
-        Transform>;
-
    /// Helper templates to deduce return type based on argument type, since some overloads may promote or denote types,
    /// e.g. addSeconds(Date, 1) => DateTime
    template <typename FieldType>
-    using TransformExecuteReturnType = decltype(std::declval<TransformType<FieldType>>().execute(FieldType(), 0, std::declval<DateLUTImpl>()));
+    using TransformExecuteReturnType = decltype(std::declval<Transform>().execute(FieldType(), 0, std::declval<DateLUTImpl>(), 0));

    // Deduces RETURN DataType from INPUT DataType, based on return type of Transform{}.execute(INPUT_TYPE, UInt64, DateLUTImpl).
    // e.g. for Transform-type that has execute()-overload with 'UInt16' input and 'UInt32' return,
@ -500,11 +683,33 @@ public:
            if (typeid_cast<const DataTypeDateTime64 *>(arguments[0].type.get()))
            {
                const auto & datetime64_type = assert_cast<const DataTypeDateTime64 &>(*arguments[0].type);
-                return std::make_shared<DataTypeDateTime64>(datetime64_type.getScale(), extractTimeZoneNameFromFunctionArguments(arguments, 2, 0));
+
+                auto from_scale = datetime64_type.getScale();
+                auto scale = from_scale;
+
+                if (std::is_same_v<Transform, AddNanosecondsImpl>)
+                    scale = 9;
+                else if (std::is_same_v<Transform, AddMicrosecondsImpl>)
+                    scale = 6;
+                else if (std::is_same_v<Transform, AddMillisecondsImpl>)
+                    scale = 3;
+
+                scale = std::max(scale, from_scale);
+
+                return std::make_shared<DataTypeDateTime64>(scale, extractTimeZoneNameFromFunctionArguments(arguments, 2, 0));
            }
            else
            {
-                return std::make_shared<DataTypeDateTime64>(DataTypeDateTime64::default_scale, extractTimeZoneNameFromFunctionArguments(arguments, 2, 0));
+                auto scale = DataTypeDateTime64::default_scale;
+
+                if (std::is_same_v<Transform, AddNanosecondsImpl>)
+                    scale = 9;
+                else if (std::is_same_v<Transform, AddMicrosecondsImpl>)
+                    scale = 6;
+                else if (std::is_same_v<Transform, AddMillisecondsImpl>)
+                    scale = 3;
+
+                return std::make_shared<DataTypeDateTime64>(scale, extractTimeZoneNameFromFunctionArguments(arguments, 2, 0));
            }
        }
        else
@ -541,9 +746,9 @@ public:
        }
        else if (const auto * datetime64_type = assert_cast<const DataTypeDateTime64 *>(from_type))
        {
-            using WrappedTransformType = TransformType<typename DataTypeDateTime64::FieldType>;
-            return DateTimeAddIntervalImpl<DataTypeDateTime64, TransformResultDataType<DataTypeDateTime64>, WrappedTransformType>::execute(
-                    WrappedTransformType{datetime64_type->getScale()}, arguments, result_type);
+            auto from_scale = datetime64_type->getScale();
+            return DateTimeAddIntervalImpl<DataTypeDateTime64, TransformResultDataType<DataTypeDateTime64>, Transform>::execute(
+                Transform{}, arguments, result_type, from_scale);
        }
        else
            throw Exception("Illegal type " + arguments[0].type->getName() + " of first argument of function " + getName(),
--- a/src/Functions/FunctionDateOrDateTimeToSomething.h
+++ b/src/Functions/FunctionDateOrDateTimeToSomething.h
@ -88,6 +88,20 @@ public:
            Int64 scale = DataTypeDateTime64::default_scale;
            if (const auto * dt64 =  checkAndGetDataType<DataTypeDateTime64>(arguments[0].type.get()))
                scale = dt64->getScale();
+            auto source_scale = scale;
+
+            if constexpr (std::is_same_v<ToStartOfMillisecondImpl, Transform>)
+            {
+                scale = std::max(source_scale, static_cast<Int64>(3));
+            }
+            else if constexpr (std::is_same_v<ToStartOfMicrosecondImpl, Transform>)
+            {
+                scale = std::max(source_scale, static_cast<Int64>(6));
+            }
+            else if constexpr (std::is_same_v<ToStartOfNanosecondImpl, Transform>)
+            {
+                scale = std::max(source_scale, static_cast<Int64>(9));
+            }

            return std::make_shared<ToDataType>(scale, extractTimeZoneNameFromFunctionArguments(arguments, 1, 0));
        }
--- a/src/Functions/FunctionsConversion.cpp
+++ b/src/Functions/FunctionsConversion.cpp
@ -112,6 +112,9 @@ void registerFunctionsConversion(FunctionFactory & factory)
    factory.registerFunction<FunctionParseDateTime64BestEffortOrZero>();
    factory.registerFunction<FunctionParseDateTime64BestEffortOrNull>();

+    factory.registerFunction<FunctionConvert<DataTypeInterval, NameToIntervalNanosecond, PositiveMonotonicity>>();
+    factory.registerFunction<FunctionConvert<DataTypeInterval, NameToIntervalMicrosecond, PositiveMonotonicity>>();
+    factory.registerFunction<FunctionConvert<DataTypeInterval, NameToIntervalMillisecond, PositiveMonotonicity>>();
    factory.registerFunction<FunctionConvert<DataTypeInterval, NameToIntervalSecond, PositiveMonotonicity>>();
    factory.registerFunction<FunctionConvert<DataTypeInterval, NameToIntervalMinute, PositiveMonotonicity>>();
    factory.registerFunction<FunctionConvert<DataTypeInterval, NameToIntervalHour, PositiveMonotonicity>>();
--- a/src/Functions/FunctionsConversion.h
+++ b/src/Functions/FunctionsConversion.h
@ -1487,6 +1487,9 @@ struct NameToDecimal256 { static constexpr auto name = "toDecimal256"; };
        static constexpr auto kind = IntervalKind::INTERVAL_KIND; \
    };

+DEFINE_NAME_TO_INTERVAL(Nanosecond)
+DEFINE_NAME_TO_INTERVAL(Microsecond)
+DEFINE_NAME_TO_INTERVAL(Millisecond)
 DEFINE_NAME_TO_INTERVAL(Second)
 DEFINE_NAME_TO_INTERVAL(Minute)
 DEFINE_NAME_TO_INTERVAL(Hour)
@ -2703,13 +2706,10 @@ private:
        return createWrapper<ToDataType>(from_type, to_type, requested_result_is_nullable);
    }

-    WrapperType createUInt8ToUInt8Wrapper(const DataTypePtr from_type, const DataTypePtr to_type) const
+    WrapperType createUInt8ToBoolWrapper(const DataTypePtr from_type, const DataTypePtr to_type) const
    {
        return [from_type, to_type] (ColumnsWithTypeAndName & arguments, const DataTypePtr &, const ColumnNullable *, size_t /*input_rows_count*/) -> ColumnPtr
        {
-            if (isBool(from_type) || !isBool(to_type))
-                return arguments.front().column;
-
            /// Special case when we convert UInt8 column to Bool column.
            /// both columns have type UInt8, but we shouldn't use identity wrapper,
            /// because Bool column can contain only 0 and 1.
@ -3506,15 +3506,19 @@ private:
    /// 'requested_result_is_nullable' is true if CAST to Nullable type is requested.
    WrapperType prepareImpl(const DataTypePtr & from_type, const DataTypePtr & to_type, bool requested_result_is_nullable) const
    {
-        bool convert_to_ipv6 = to_type->getCustomName() && to_type->getCustomName()->getName() == "IPv6";
+        if (isUInt8(from_type) && isBool(to_type))
+            return createUInt8ToBoolWrapper(from_type, to_type);

-        if (from_type->equals(*to_type) && !convert_to_ipv6)
-        {
-            if (isUInt8(from_type))
-                return createUInt8ToUInt8Wrapper(from_type, to_type);
+        /// We can cast IPv6 into IPv6, IPv4 into IPv4, but we should not allow to cast FixedString(16) into IPv6 as part of identity cast
+        bool safe_convert_custom_types = true;

+        if (const auto * to_type_custom_name = to_type->getCustomName())
+            safe_convert_custom_types = from_type->getCustomName() && from_type->getCustomName()->getName() == to_type_custom_name->getName();
+        else if (const auto * from_type_custom_name = from_type->getCustomName())
+            safe_convert_custom_types = to_type->getCustomName() && from_type_custom_name->getName() == to_type->getCustomName()->getName();
+
+        if (from_type->equals(*to_type) && safe_convert_custom_types)
            return createIdentityWrapper(from_type);
-        }
        else if (WhichDataType(from_type).isNothing())
            return createNothingWrapper(to_type.get());

--- a/src/Functions/FunctionsTimeWindow.cpp
+++ b/src/Functions/FunctionsTimeWindow.cpp
@ -20,6 +20,7 @@ namespace ErrorCodes
    extern const int ILLEGAL_COLUMN;
    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
    extern const int ARGUMENT_OUT_OF_BOUND;
+    extern const int SYNTAX_ERROR;
 }

 namespace
@ -167,6 +168,13 @@ struct TimeWindowImpl<TUMBLE>

        switch (std::get<0>(interval))
        {
+                //TODO: add proper support for fractional seconds
+//            case IntervalKind::Nanosecond:
+//                return executeTumble<UInt32, IntervalKind::Nanosecond>(*time_column_vec, std::get<1>(interval), time_zone);
+//            case IntervalKind::Microsecond:
+//                return executeTumble<UInt32, IntervalKind::Microsecond>(*time_column_vec, std::get<1>(interval), time_zone);
+//            case IntervalKind::Millisecond:
+//                return executeTumble<UInt32, IntervalKind::Millisecond>(*time_column_vec, std::get<1>(interval), time_zone);
            case IntervalKind::Second:
                return executeTumble<UInt32, IntervalKind::Second>(*time_column_vec, std::get<1>(interval), time_zone);
            case IntervalKind::Minute:
@ -183,6 +191,8 @@ struct TimeWindowImpl<TUMBLE>
                return executeTumble<UInt16, IntervalKind::Quarter>(*time_column_vec, std::get<1>(interval), time_zone);
            case IntervalKind::Year:
                return executeTumble<UInt16, IntervalKind::Year>(*time_column_vec, std::get<1>(interval), time_zone);
+            default:
+                throw Exception("Fraction seconds are unsupported by windows yet", ErrorCodes::SYNTAX_ERROR);
        }
        __builtin_unreachable();
    }
@ -350,6 +360,16 @@ struct TimeWindowImpl<HOP>

        switch (std::get<0>(window_interval))
        {
+                //TODO: add proper support for fractional seconds
+//            case IntervalKind::Nanosecond:
+//                return executeHop<UInt32, IntervalKind::Nanosecond>(
+//                    *time_column_vec, std::get<1>(hop_interval), std::get<1>(window_interval), time_zone);
+//            case IntervalKind::Microsecond:
+//                return executeHop<UInt32, IntervalKind::Microsecond>(
+//                    *time_column_vec, std::get<1>(hop_interval), std::get<1>(window_interval), time_zone);
+//            case IntervalKind::Millisecond:
+//                return executeHop<UInt32, IntervalKind::Millisecond>(
+//                    *time_column_vec, std::get<1>(hop_interval), std::get<1>(window_interval), time_zone);
            case IntervalKind::Second:
                return executeHop<UInt32, IntervalKind::Second>(
                    *time_column_vec, std::get<1>(hop_interval), std::get<1>(window_interval), time_zone);
@ -374,6 +394,8 @@ struct TimeWindowImpl<HOP>
            case IntervalKind::Year:
                return executeHop<UInt16, IntervalKind::Year>(
                    *time_column_vec, std::get<1>(hop_interval), std::get<1>(window_interval), time_zone);
+            default:
+                throw Exception("Fraction seconds are unsupported by windows yet", ErrorCodes::SYNTAX_ERROR);
        }
        __builtin_unreachable();
    }
@ -487,6 +509,16 @@ struct TimeWindowImpl<WINDOW_ID>

        switch (std::get<0>(window_interval))
        {
+                //TODO: add proper support for fractional seconds
+//            case IntervalKind::Nanosecond:
+//                return executeHopSlice<UInt32, IntervalKind::Nanosecond>(
+//                    *time_column_vec, std::get<1>(hop_interval), std::get<1>(window_interval), time_zone);
+//            case IntervalKind::Microsecond:
+//                return executeHopSlice<UInt32, IntervalKind::Microsecond>(
+//                    *time_column_vec, std::get<1>(hop_interval), std::get<1>(window_interval), time_zone);
+//            case IntervalKind::Millisecond:
+//                return executeHopSlice<UInt32, IntervalKind::Millisecond>(
+//                    *time_column_vec, std::get<1>(hop_interval), std::get<1>(window_interval), time_zone);
            case IntervalKind::Second:
                return executeHopSlice<UInt32, IntervalKind::Second>(
                    *time_column_vec, std::get<1>(hop_interval), std::get<1>(window_interval), time_zone);
@ -511,6 +543,8 @@ struct TimeWindowImpl<WINDOW_ID>
            case IntervalKind::Year:
                return executeHopSlice<UInt16, IntervalKind::Year>(
                    *time_column_vec, std::get<1>(hop_interval), std::get<1>(window_interval), time_zone);
+            default:
+                throw Exception("Fraction seconds are unsupported by windows yet", ErrorCodes::SYNTAX_ERROR);
        }
        __builtin_unreachable();
    }
--- a/src/Functions/FunctionsTimeWindow.h
+++ b/src/Functions/FunctionsTimeWindow.h
@ -80,7 +80,32 @@ struct ToStartOfTransform;
    TRANSFORM_TIME(Hour)
    TRANSFORM_TIME(Minute)
    TRANSFORM_TIME(Second)
-#undef TRANSFORM_DATE
+#undef TRANSFORM_TIME
+
+#define TRANSFORM_SUBSECONDS(INTERVAL_KIND, DEF_SCALE) \
+template<> \
+    struct ToStartOfTransform<IntervalKind::INTERVAL_KIND> \
+    { \
+        static Int64 execute(Int64 t, UInt64 delta, const UInt32 scale) \
+        { \
+            if (scale <= DEF_SCALE) \
+            { \
+                auto val = t * DecimalUtils::scaleMultiplier<DateTime64>(DEF_SCALE - scale); \
+                if (delta == 1) \
+                    return val; \
+                else \
+                    return val - (val % delta); \
+            } \
+            else \
+            { \
+                return t - (t % (delta * DecimalUtils::scaleMultiplier<DateTime64>(scale - DEF_SCALE))) ; \
+            } \
+        } \
+    };
+    TRANSFORM_SUBSECONDS(Millisecond, 3)
+    TRANSFORM_SUBSECONDS(Microsecond, 6)
+    TRANSFORM_SUBSECONDS(Nanosecond, 9)
+#undef TRANSFORM_SUBSECONDS

    template <IntervalKind::Kind unit>
    struct AddTime;
@ -117,6 +142,25 @@ struct ToStartOfTransform;
    ADD_TIME(Second, 1)
 #undef ADD_TIME

+#define ADD_SUBSECONDS(INTERVAL_KIND, DEF_SCALE) \
+template <> \
+    struct AddTime<IntervalKind::INTERVAL_KIND> \
+    { \
+        static inline NO_SANITIZE_UNDEFINED Int64 execute(Int64 t, UInt64 delta, const UInt32 scale) \
+        { \
+            if (scale < DEF_SCALE) \
+            { \
+                return t + delta * DecimalUtils::scaleMultiplier<DateTime64>(DEF_SCALE - scale); \
+            } \
+            else \
+                return t + delta * DecimalUtils::scaleMultiplier<DateTime64>(scale - DEF_SCALE); \
+        } \
+    };
+    ADD_SUBSECONDS(Millisecond, 3)
+    ADD_SUBSECONDS(Microsecond, 6)
+    ADD_SUBSECONDS(Nanosecond, 9)
+#undef ADD_SUBSECONDS
+
 template <TimeWindowFunctionName type>
 struct TimeWindowImpl
 {
--- a/src/Functions/SubtractSubSeconds.cpp
+++ b/src/Functions/SubtractSubSeconds.cpp
@ -0,0 +1,28 @@
+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionDateOrDateTimeAddInterval.h>
+
+
+namespace DB
+{
+
+using FunctionSubtractNanoseconds = FunctionDateOrDateTimeAddInterval<SubtractNanosecondsImpl>;
+void registerFunctionSubtractNanoseconds(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionSubtractNanoseconds>();
+};
+
+using FunctionSubtractMicroseconds = FunctionDateOrDateTimeAddInterval<SubtractMicrosecondsImpl>;
+void registerFunctionSubtractMicroseconds(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionSubtractMicroseconds>();
+};
+
+using FunctionSubtractMilliseconds = FunctionDateOrDateTimeAddInterval<SubtractMillisecondsImpl>;
+void registerFunctionSubtractMilliseconds(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionSubtractMilliseconds>();
+};
+
+}
+
+
--- a/src/Functions/TransformDateTime64.h
+++ b/src/Functions/TransformDateTime64.h
@ -13,7 +13,7 @@ namespace DB
 * * DateTime64 value and scale factor (2)
 * * DateTime64 broken down to components, result of execute is then re-assembled back into DateTime64 value (3)
 *
- * Suitable Transfotm-types are commonly used in Date/DateTime manipulation functions,
+ * Suitable Transform-types are commonly used in Date/DateTime manipulation functions,
 * and should implement static (or const) function with following signatures:
 * 1:
 *     R execute(Int64 whole_value, ... )
--- a/src/Functions/addSubSeconds.cpp
+++ b/src/Functions/addSubSeconds.cpp
@ -0,0 +1,28 @@
+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionDateOrDateTimeAddInterval.h>
+
+
+namespace DB
+{
+
+using FunctionAddNanoseconds = FunctionDateOrDateTimeAddInterval<AddNanosecondsImpl>;
+void registerFunctionAddNanoseconds(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionAddNanoseconds>();
+};
+
+using FunctionAddMicroseconds = FunctionDateOrDateTimeAddInterval<AddMicrosecondsImpl>;
+void registerFunctionAddMicroseconds(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionAddMicroseconds>();
+};
+
+using FunctionAddMilliseconds = FunctionDateOrDateTimeAddInterval<AddMillisecondsImpl>;
+void registerFunctionAddMilliseconds(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionAddMilliseconds>();
+};
+
+}
+
+
--- a/src/Functions/registerFunctionsDateTime.cpp
+++ b/src/Functions/registerFunctionsDateTime.cpp
@ -11,6 +11,9 @@ void registerFunctionToDayOfWeek(FunctionFactory &);
 void registerFunctionToDayOfYear(FunctionFactory &);
 void registerFunctionToHour(FunctionFactory &);
 void registerFunctionToMinute(FunctionFactory &);
+void registerFunctionToStartOfNanosecond(FunctionFactory &);
+void registerFunctionToStartOfMicrosecond(FunctionFactory &);
+void registerFunctionToStartOfMillisecond(FunctionFactory &);
 void registerFunctionToStartOfSecond(FunctionFactory &);
 void registerFunctionToSecond(FunctionFactory &);
 void registerFunctionToStartOfDay(FunctionFactory &);
@ -47,6 +50,9 @@ void registerFunctionTimeSlots(FunctionFactory &);
 void registerFunctionToYYYYMM(FunctionFactory &);
 void registerFunctionToYYYYMMDD(FunctionFactory &);
 void registerFunctionToYYYYMMDDhhmmss(FunctionFactory &);
+void registerFunctionAddNanoseconds(FunctionFactory &);
+void registerFunctionAddMicroseconds(FunctionFactory &);
+void registerFunctionAddMilliseconds(FunctionFactory &);
 void registerFunctionAddSeconds(FunctionFactory &);
 void registerFunctionAddMinutes(FunctionFactory &);
 void registerFunctionAddHours(FunctionFactory &);
@ -55,6 +61,9 @@ void registerFunctionAddWeeks(FunctionFactory &);
 void registerFunctionAddMonths(FunctionFactory &);
 void registerFunctionAddQuarters(FunctionFactory &);
 void registerFunctionAddYears(FunctionFactory &);
+void registerFunctionSubtractNanoseconds(FunctionFactory &);
+void registerFunctionSubtractMicroseconds(FunctionFactory &);
+void registerFunctionSubtractMilliseconds(FunctionFactory &);
 void registerFunctionSubtractSeconds(FunctionFactory &);
 void registerFunctionSubtractMinutes(FunctionFactory &);
 void registerFunctionSubtractHours(FunctionFactory &);
@ -93,6 +102,9 @@ void registerFunctionsDateTime(FunctionFactory & factory)
    registerFunctionToStartOfMonth(factory);
    registerFunctionToStartOfQuarter(factory);
    registerFunctionToStartOfYear(factory);
+    registerFunctionToStartOfNanosecond(factory);
+    registerFunctionToStartOfMicrosecond(factory);
+    registerFunctionToStartOfMillisecond(factory);
    registerFunctionToStartOfSecond(factory);
    registerFunctionToStartOfMinute(factory);
    registerFunctionToStartOfFiveMinute(factory);
@ -119,6 +131,9 @@ void registerFunctionsDateTime(FunctionFactory & factory)
    registerFunctionToYYYYMM(factory);
    registerFunctionToYYYYMMDD(factory);
    registerFunctionToYYYYMMDDhhmmss(factory);
+    registerFunctionAddNanoseconds(factory);
+    registerFunctionAddMicroseconds(factory);
+    registerFunctionAddMilliseconds(factory);
    registerFunctionAddSeconds(factory);
    registerFunctionAddMinutes(factory);
    registerFunctionAddHours(factory);
@ -127,6 +142,9 @@ void registerFunctionsDateTime(FunctionFactory & factory)
    registerFunctionAddMonths(factory);
    registerFunctionAddQuarters(factory);
    registerFunctionAddYears(factory);
+    registerFunctionSubtractNanoseconds(factory);
+    registerFunctionSubtractMicroseconds(factory);
+    registerFunctionSubtractMilliseconds(factory);
    registerFunctionSubtractSeconds(factory);
    registerFunctionSubtractMinutes(factory);
    registerFunctionSubtractHours(factory);
--- a/src/Functions/toStartOfInterval.cpp
+++ b/src/Functions/toStartOfInterval.cpp
@ -33,184 +33,273 @@ namespace
    template <>
    struct Transform<IntervalKind::Year>
    {
-        static constexpr auto name = function_name;
-
-        static UInt16 execute(UInt16 d, UInt64 years, const DateLUTImpl & time_zone)
+        static UInt16 execute(UInt16 d, Int64 years, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfYearInterval(DayNum(d), years);
        }

-        static UInt16 execute(Int32 d, UInt64 years, const DateLUTImpl & time_zone)
+        static UInt16 execute(Int32 d, Int64 years, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfYearInterval(ExtendedDayNum(d), years);
        }

-        static UInt16 execute(UInt32 t, UInt64 years, const DateLUTImpl & time_zone)
+        static UInt16 execute(UInt32 t, Int64 years, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfYearInterval(time_zone.toDayNum(t), years);
        }

-        static UInt16 execute(Int64 t, UInt64 years, const DateLUTImpl & time_zone)
+        static UInt16 execute(Int64 t, Int64 years, const DateLUTImpl & time_zone, Int64 scale_multiplier)
        {
-            return time_zone.toStartOfYearInterval(time_zone.toDayNum(t), years);
+            return time_zone.toStartOfYearInterval(time_zone.toDayNum(t / scale_multiplier), years);
        }
    };

    template <>
    struct Transform<IntervalKind::Quarter>
    {
-        static constexpr auto name = function_name;
-
-        static UInt16 execute(UInt16 d, UInt64 quarters, const DateLUTImpl & time_zone)
+        static UInt16 execute(UInt16 d, Int64 quarters, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfQuarterInterval(DayNum(d), quarters);
        }

-        static UInt16 execute(Int32 d, UInt64 quarters, const DateLUTImpl & time_zone)
+        static UInt16 execute(Int32 d, Int64 quarters, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfQuarterInterval(ExtendedDayNum(d), quarters);
        }

-        static UInt16 execute(UInt32 t, UInt64 quarters, const DateLUTImpl & time_zone)
+        static UInt16 execute(UInt32 t, Int64 quarters, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfQuarterInterval(time_zone.toDayNum(t), quarters);
        }

-        static UInt16 execute(Int64 t, UInt64 quarters, const DateLUTImpl & time_zone)
+        static UInt16 execute(Int64 t, Int64 quarters, const DateLUTImpl & time_zone, Int64 scale_multiplier)
        {
-            return time_zone.toStartOfQuarterInterval(time_zone.toDayNum(t), quarters);
+            return time_zone.toStartOfQuarterInterval(time_zone.toDayNum(t / scale_multiplier), quarters);
        }
    };

    template <>
    struct Transform<IntervalKind::Month>
    {
-        static constexpr auto name = function_name;
-
-        static UInt16 execute(UInt16 d, UInt64 months, const DateLUTImpl & time_zone)
+        static UInt16 execute(UInt16 d, Int64 months, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfMonthInterval(DayNum(d), months);
        }

-        static UInt16 execute(Int32 d, UInt64 months, const DateLUTImpl & time_zone)
+        static UInt16 execute(Int32 d, Int64 months, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfMonthInterval(ExtendedDayNum(d), months);
        }

-        static UInt16 execute(UInt32 t, UInt64 months, const DateLUTImpl & time_zone)
+        static UInt16 execute(UInt32 t, Int64 months, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfMonthInterval(time_zone.toDayNum(t), months);
        }

-        static UInt16 execute(Int64 t, UInt64 months, const DateLUTImpl & time_zone)
+        static UInt16 execute(Int64 t, Int64 months, const DateLUTImpl & time_zone, Int64 scale_multiplier)
        {
-            return time_zone.toStartOfMonthInterval(time_zone.toDayNum(t), months);
+            return time_zone.toStartOfMonthInterval(time_zone.toDayNum(t / scale_multiplier), months);
        }
    };

    template <>
    struct Transform<IntervalKind::Week>
    {
-        static constexpr auto name = function_name;
-
-        static UInt16 execute(UInt16 d, UInt64 weeks, const DateLUTImpl & time_zone)
+        static UInt16 execute(UInt16 d, Int64 weeks, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfWeekInterval(DayNum(d), weeks);
        }

-        static UInt16 execute(Int32 d, UInt64 weeks, const DateLUTImpl & time_zone)
+        static UInt16 execute(Int32 d, Int64 weeks, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfWeekInterval(ExtendedDayNum(d), weeks);
        }

-        static UInt16 execute(UInt32 t, UInt64 weeks, const DateLUTImpl & time_zone)
+        static UInt16 execute(UInt32 t, Int64 weeks, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfWeekInterval(time_zone.toDayNum(t), weeks);
        }

-        static UInt16 execute(Int64 t, UInt64 weeks, const DateLUTImpl & time_zone)
+        static UInt16 execute(Int64 t, Int64 weeks, const DateLUTImpl & time_zone, Int64 scale_multiplier)
        {
-            return time_zone.toStartOfWeekInterval(time_zone.toDayNum(t), weeks);
+            return time_zone.toStartOfWeekInterval(time_zone.toDayNum(t / scale_multiplier), weeks);
        }
    };

    template <>
    struct Transform<IntervalKind::Day>
    {
-        static constexpr auto name = function_name;
-
-        static UInt32 execute(UInt16 d, UInt64 days, const DateLUTImpl & time_zone)
+        static UInt32 execute(UInt16 d, Int64 days, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfDayInterval(ExtendedDayNum(d), days);
        }

-        static UInt32 execute(Int32 d, UInt64 days, const DateLUTImpl & time_zone)
+        static UInt32 execute(Int32 d, Int64 days, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfDayInterval(ExtendedDayNum(d), days);
        }

-        static UInt32 execute(UInt32 t, UInt64 days, const DateLUTImpl & time_zone)
+        static UInt32 execute(UInt32 t, Int64 days, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfDayInterval(time_zone.toDayNum(t), days);
        }

-        static UInt32 execute(Int64 t, UInt64 days, const DateLUTImpl & time_zone)
+        static Int64 execute(Int64 t, Int64 days, const DateLUTImpl & time_zone, Int64 scale_multiplier)
        {
-            return time_zone.toStartOfDayInterval(time_zone.toDayNum(t), days);
+            return time_zone.toStartOfDayInterval(time_zone.toDayNum(t / scale_multiplier), days);
        }
    };

    template <>
    struct Transform<IntervalKind::Hour>
    {
-        static constexpr auto name = function_name;
+        static UInt32 execute(UInt16, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }

-        static UInt32 execute(UInt16, UInt64, const DateLUTImpl &) { return dateIsNotSupported(function_name); }
-        static UInt32 execute(Int32, UInt64, const DateLUTImpl &) { return dateIsNotSupported(function_name); }
-        static UInt32 execute(UInt32 t, UInt64 hours, const DateLUTImpl & time_zone) { return time_zone.toStartOfHourInterval(t, hours); }
-        static UInt32 execute(Int64 t, UInt64 hours, const DateLUTImpl & time_zone) { return time_zone.toStartOfHourInterval(t, hours); }
+        static UInt32 execute(Int32, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }
+
+        static UInt32 execute(UInt32 t, Int64 hours, const DateLUTImpl & time_zone, Int64)
+        {
+            return time_zone.toStartOfHourInterval(t, hours);
+        }
+
+        static UInt32 execute(Int64 t, Int64 hours, const DateLUTImpl & time_zone, Int64 scale_multiplier)
+        {
+            return time_zone.toStartOfHourInterval(t / scale_multiplier, hours);
+        }
    };

    template <>
    struct Transform<IntervalKind::Minute>
    {
-        static constexpr auto name = function_name;
+        static UInt32 execute(UInt16, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }

-        static UInt32 execute(UInt16, UInt64, const DateLUTImpl &) { return dateIsNotSupported(function_name); }
+        static UInt32 execute(Int32, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }

-        static UInt32 execute(Int32, UInt64, const DateLUTImpl &) { return dateIsNotSupported(function_name); }
-
-        static UInt32 execute(UInt32 t, UInt64 minutes, const DateLUTImpl & time_zone)
+        static UInt32 execute(UInt32 t, Int64 minutes, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfMinuteInterval(t, minutes);
        }

-        static UInt32 execute(Int64 t, UInt64 minutes, const DateLUTImpl & time_zone)
+        static UInt32 execute(Int64 t, Int64 minutes, const DateLUTImpl & time_zone, Int64 scale_multiplier)
        {
-            return time_zone.toStartOfMinuteInterval(t, minutes);
+            return time_zone.toStartOfMinuteInterval(t / scale_multiplier, minutes);
        }
    };

    template <>
    struct Transform<IntervalKind::Second>
    {
-        static constexpr auto name = function_name;
+        static UInt32 execute(UInt16, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }

-        static UInt32 execute(UInt16, UInt64, const DateLUTImpl &) { return dateIsNotSupported(function_name); }
+        static UInt32 execute(Int32, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }

-        static UInt32 execute(Int32, UInt64, const DateLUTImpl &) { return dateIsNotSupported(function_name); }
-
-        static UInt32 execute(UInt32 t, UInt64 seconds, const DateLUTImpl & time_zone)
+        static UInt32 execute(UInt32 t, Int64 seconds, const DateLUTImpl & time_zone, Int64)
        {
            return time_zone.toStartOfSecondInterval(t, seconds);
        }

-        static Int64 execute(Int64 t, UInt64 seconds, const DateLUTImpl & time_zone)
+        static UInt32 execute(Int64 t, Int64 seconds, const DateLUTImpl & time_zone, Int64 scale_multiplier)
        {
-            return time_zone.toStartOfSecondInterval(t, seconds);
+            return time_zone.toStartOfSecondInterval(t / scale_multiplier, seconds);
        }
    };

+    template <>
+    struct Transform<IntervalKind::Millisecond>
+    {
+        static UInt32 execute(UInt16, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }
+
+        static UInt32 execute(Int32, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }
+
+        static UInt32 execute(UInt32, Int64, const DateLUTImpl &, Int64) { return dateTimeIsNotSupported(function_name); }
+
+        static Int64 execute(Int64 t, Int64 milliseconds, const DateLUTImpl &, Int64 scale_multiplier)
+        {
+            if (scale_multiplier < 1000)
+            {
+                Int64 t_milliseconds = t * (static_cast<Int64>(1000) / scale_multiplier);
+                if (likely(t >= 0))
+                    return t_milliseconds / milliseconds * milliseconds;
+                else
+                    return ((t_milliseconds + 1) / milliseconds - 1) * milliseconds;
+            }
+            else if (scale_multiplier > 1000)
+            {
+                Int64 scale_diff = scale_multiplier / static_cast<Int64>(1000);
+                if (likely(t >= 0))
+                    return t / milliseconds / scale_diff * milliseconds;
+                else
+                    return ((t + 1) / milliseconds / scale_diff - 1) * milliseconds;
+            }
+            else
+                if (likely(t >= 0))
+                    return t / milliseconds * milliseconds;
+                else
+                    return ((t + 1) / milliseconds - 1) * milliseconds;
+        }
+    };
+
+    template <>
+    struct Transform<IntervalKind::Microsecond>
+    {
+        static UInt32 execute(UInt16, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }
+
+        static UInt32 execute(Int32, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }
+
+        static UInt32 execute(UInt32, Int64, const DateLUTImpl &, Int64) { return dateTimeIsNotSupported(function_name); }
+
+        static Int64 execute(Int64 t, Int64 microseconds, const DateLUTImpl &, Int64 scale_multiplier)
+        {
+            if (scale_multiplier < 1000000)
+            {
+                Int64 t_microseconds = t * (static_cast<Int64>(1000000) / scale_multiplier);
+                if (likely(t >= 0))
+                    return t_microseconds / microseconds * microseconds;
+                else
+                    return ((t_microseconds + 1) / microseconds - 1) * microseconds;
+            }
+            else if (scale_multiplier > 1000000)
+            {
+                Int64 scale_diff = scale_multiplier / static_cast<Int64>(1000000);
+                if (likely(t >= 0))
+                    return t / microseconds / scale_diff * microseconds;
+                else
+                    return ((t + 1) / microseconds / scale_diff - 1) * microseconds;
+            }
+            else
+                if (likely(t >= 0))
+                    return t / microseconds * microseconds;
+                else
+                    return ((t + 1) / microseconds - 1) * microseconds;
+        }
+    };
+
+    template <>
+    struct Transform<IntervalKind::Nanosecond>
+    {
+        static UInt32 execute(UInt16, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }
+
+        static UInt32 execute(Int32, Int64, const DateLUTImpl &, Int64) { return dateIsNotSupported(function_name); }
+
+        static UInt32 execute(UInt32, Int64, const DateLUTImpl &, Int64) { return dateTimeIsNotSupported(function_name); }
+
+        static Int64 execute(Int64 t, Int64 nanoseconds, const DateLUTImpl &, Int64 scale_multiplier)
+        {
+            if (scale_multiplier < 1000000000)
+            {
+                Int64 t_nanoseconds = t * (static_cast<Int64>(1000000000) / scale_multiplier);
+                if (likely(t >= 0))
+                    return t_nanoseconds / nanoseconds * nanoseconds;
+                else
+                    return ((t_nanoseconds + 1) / nanoseconds - 1) * nanoseconds;
+            }
+            else
+                if (likely(t >= 0))
+                    return t / nanoseconds * nanoseconds;
+                else
+                    return ((t + 1) / nanoseconds - 1) * nanoseconds;
+        }
+    };

 class FunctionToStartOfInterval : public IFunction
 {
@ -240,6 +329,7 @@ public:

        const DataTypeInterval * interval_type = nullptr;
        bool result_type_is_date = false;
+        bool result_type_is_datetime = false;
        auto check_interval_argument = [&]
        {
            interval_type = checkAndGetDataType<DataTypeInterval>(arguments[1].type.get());
@ -251,6 +341,8 @@ public:
            result_type_is_date = (interval_type->getKind() == IntervalKind::Year)
                || (interval_type->getKind() == IntervalKind::Quarter) || (interval_type->getKind() == IntervalKind::Month)
                || (interval_type->getKind() == IntervalKind::Week);
+            result_type_is_datetime = (interval_type->getKind() == IntervalKind::Day) || (interval_type->getKind() == IntervalKind::Hour)
+                || (interval_type->getKind() == IntervalKind::Minute) || (interval_type->getKind() == IntervalKind::Second);
        };

        auto check_timezone_argument = [&]
@ -263,7 +355,7 @@ public:
            if (first_argument_is_date && result_type_is_date)
                throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
                    "The timezone argument of function {} with interval type {} is allowed only when the 1st argument "
-                    "has the type DateTime",
+                    "has the type DateTime or DateTime64",
                        getName(), interval_type->getKind().toString());
        };

@ -288,19 +380,33 @@ public:

        if (result_type_is_date)
            return std::make_shared<DataTypeDate>();
-        else
+        else if (result_type_is_datetime)
            return std::make_shared<DataTypeDateTime>(extractTimeZoneNameFromFunctionArguments(arguments, 2, 0));
+        else
+        {
+            auto scale = 0;
+
+            if (interval_type->getKind() == IntervalKind::Nanosecond)
+                scale = 9;
+            else if (interval_type->getKind() == IntervalKind::Microsecond)
+                scale = 6;
+            else if (interval_type->getKind() == IntervalKind::Millisecond)
+                scale = 3;
+
+            return std::make_shared<DataTypeDateTime64>(scale, extractTimeZoneNameFromFunctionArguments(arguments, 2, 0));
+        }
+
    }

    bool useDefaultImplementationForConstants() const override { return true; }
    ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1, 2}; }

-    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /* input_rows_count */) const override
+    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t /* input_rows_count */) const override
    {
        const auto & time_column = arguments[0];
        const auto & interval_column = arguments[1];
        const auto & time_zone = extractTimeZoneFromFunctionArguments(arguments, 2, 0);
-        auto result_column = dispatchForColumns(time_column, interval_column, time_zone);
+        auto result_column = dispatchForColumns(time_column, interval_column, result_type, time_zone);
        return result_column;
    }

@ -316,33 +422,36 @@ public:

 private:
    ColumnPtr dispatchForColumns(
-        const ColumnWithTypeAndName & time_column, const ColumnWithTypeAndName & interval_column, const DateLUTImpl & time_zone) const
+        const ColumnWithTypeAndName & time_column, const ColumnWithTypeAndName & interval_column, const DataTypePtr & result_type, const DateLUTImpl & time_zone) const
    {
        const auto & from_datatype = *time_column.type.get();
        const auto which_type = WhichDataType(from_datatype);
+
+        if (which_type.isDateTime64())
+        {
+            const auto * time_column_vec = checkAndGetColumn<DataTypeDateTime64::ColumnType>(time_column.column.get());
+            auto scale = assert_cast<const DataTypeDateTime64 &>(from_datatype).getScale();
+
+            if (time_column_vec)
+                return dispatchForIntervalColumn(assert_cast<const DataTypeDateTime64&>(from_datatype), *time_column_vec, interval_column, result_type, time_zone, scale);
+        }
        if (which_type.isDateTime())
        {
            const auto * time_column_vec = checkAndGetColumn<ColumnUInt32>(time_column.column.get());
            if (time_column_vec)
-                return dispatchForIntervalColumn(assert_cast<const DataTypeDateTime&>(from_datatype), *time_column_vec, interval_column, time_zone);
+                return dispatchForIntervalColumn(assert_cast<const DataTypeDateTime&>(from_datatype), *time_column_vec, interval_column, result_type, time_zone);
        }
        if (which_type.isDate())
        {
            const auto * time_column_vec = checkAndGetColumn<ColumnUInt16>(time_column.column.get());
            if (time_column_vec)
-                return dispatchForIntervalColumn(assert_cast<const DataTypeDate&>(from_datatype), *time_column_vec, interval_column, time_zone);
+                return dispatchForIntervalColumn(assert_cast<const DataTypeDate&>(from_datatype), *time_column_vec, interval_column, result_type, time_zone);
        }
        if (which_type.isDate32())
        {
            const auto * time_column_vec = checkAndGetColumn<ColumnInt32>(time_column.column.get());
            if (time_column_vec)
-                return dispatchForIntervalColumn(assert_cast<const DataTypeDate32&>(from_datatype), *time_column_vec, interval_column, time_zone);
-        }
-        if (which_type.isDateTime64())
-        {
-            const auto * time_column_vec = checkAndGetColumn<DataTypeDateTime64::ColumnType>(time_column.column.get());
-            if (time_column_vec)
-                return dispatchForIntervalColumn(assert_cast<const DataTypeDateTime64&>(from_datatype), *time_column_vec, interval_column, time_zone);
+                return dispatchForIntervalColumn(assert_cast<const DataTypeDate32&>(from_datatype), *time_column_vec, interval_column, result_type, time_zone);
        }
        throw Exception(
            "Illegal column for first argument of function " + getName() + ". Must contain dates or dates with time",
@ -351,7 +460,8 @@ private:

    template <typename ColumnType, typename FromDataType>
    ColumnPtr dispatchForIntervalColumn(
-        const FromDataType & from, const ColumnType & time_column, const ColumnWithTypeAndName & interval_column, const DateLUTImpl & time_zone) const
+        const FromDataType & from, const ColumnType & time_column, const ColumnWithTypeAndName & interval_column,
+        const DataTypePtr & result_type, const DateLUTImpl & time_zone, const UInt16 scale = 1) const
    {
        const auto * interval_type = checkAndGetDataType<DataTypeInterval>(interval_column.type.get());
        if (!interval_type)
@ -368,49 +478,52 @@ private:

        switch (interval_type->getKind())
        {
+            case IntervalKind::Nanosecond:
+                return execute<FromDataType, DataTypeDateTime64, IntervalKind::Nanosecond>(from, time_column, num_units, result_type, time_zone, scale);
+            case IntervalKind::Microsecond:
+                return execute<FromDataType, DataTypeDateTime64, IntervalKind::Microsecond>(from, time_column, num_units, result_type, time_zone, scale);
+            case IntervalKind::Millisecond:
+                return execute<FromDataType, DataTypeDateTime64, IntervalKind::Millisecond>(from, time_column, num_units, result_type, time_zone, scale);
            case IntervalKind::Second:
-                return execute<FromDataType, UInt32, IntervalKind::Second>(from, time_column, num_units, time_zone);
+                return execute<FromDataType, DataTypeDateTime, IntervalKind::Second>(from, time_column, num_units, result_type, time_zone, scale);
            case IntervalKind::Minute:
-                return execute<FromDataType, UInt32, IntervalKind::Minute>(from, time_column, num_units, time_zone);
+                return execute<FromDataType, DataTypeDateTime, IntervalKind::Minute>(from, time_column, num_units, result_type, time_zone, scale);
            case IntervalKind::Hour:
-                return execute<FromDataType, UInt32, IntervalKind::Hour>(from, time_column, num_units, time_zone);
+                return execute<FromDataType, DataTypeDateTime, IntervalKind::Hour>(from, time_column, num_units, result_type, time_zone, scale);
            case IntervalKind::Day:
-                return execute<FromDataType, UInt32, IntervalKind::Day>(from, time_column, num_units, time_zone);
+                return execute<FromDataType, DataTypeDateTime, IntervalKind::Day>(from, time_column, num_units, result_type, time_zone, scale);
            case IntervalKind::Week:
-                return execute<FromDataType, UInt16, IntervalKind::Week>(from, time_column, num_units, time_zone);
+                return execute<FromDataType, DataTypeDate, IntervalKind::Week>(from, time_column, num_units, result_type, time_zone, scale);
            case IntervalKind::Month:
-                return execute<FromDataType, UInt16, IntervalKind::Month>(from, time_column, num_units, time_zone);
+                return execute<FromDataType, DataTypeDate, IntervalKind::Month>(from, time_column, num_units, result_type, time_zone, scale);
            case IntervalKind::Quarter:
-                return execute<FromDataType, UInt16, IntervalKind::Quarter>(from, time_column, num_units, time_zone);
+                return execute<FromDataType, DataTypeDate, IntervalKind::Quarter>(from, time_column, num_units, result_type, time_zone, scale);
            case IntervalKind::Year:
-                return execute<FromDataType, UInt16, IntervalKind::Year>(from, time_column, num_units, time_zone);
+                return execute<FromDataType, DataTypeDate, IntervalKind::Year>(from, time_column, num_units, result_type, time_zone, scale);
        }

        __builtin_unreachable();
    }

-
-    template <typename FromDataType, typename ToType, IntervalKind::Kind unit, typename ColumnType>
-    ColumnPtr execute(const FromDataType & from_datatype, const ColumnType & time_column, UInt64 num_units, const DateLUTImpl & time_zone) const
+    template <typename FromDataType, typename ToDataType, IntervalKind::Kind unit, typename ColumnType>
+    ColumnPtr execute(const FromDataType &, const ColumnType & time_column_type, Int64 num_units, const DataTypePtr & result_type, const DateLUTImpl & time_zone, const UInt16 scale) const
    {
-        const auto & time_data = time_column.getData();
-        size_t size = time_column.size();
-        auto result = ColumnVector<ToType>::create();
-        auto & result_data = result->getData();
+        using ToColumnType = typename ToDataType::ColumnType;
+
+        const auto & time_data = time_column_type.getData();
+        size_t size = time_data.size();
+
+        auto result_col = result_type->createColumn();
+        auto *col_to = assert_cast<ToColumnType *>(result_col.get());
+        auto & result_data = col_to->getData();
        result_data.resize(size);

-        if constexpr (std::is_same_v<FromDataType, DataTypeDateTime64>)
-        {
-            const auto transform = TransformDateTime64<Transform<unit>>{from_datatype.getScale()};
-            for (size_t i = 0; i != size; ++i)
-                result_data[i] = transform.execute(time_data[i], num_units, time_zone);
-        }
-        else
-        {
-            for (size_t i = 0; i != size; ++i)
-                result_data[i] = Transform<unit>::execute(time_data[i], num_units, time_zone);
-        }
-        return result;
+        Int64 scale_multiplier = DecimalUtils::scaleMultiplier<DateTime64>(scale);
+
+        for (size_t i = 0; i != size; ++i)
+            result_data[i] = Transform<unit>::execute(time_data[i], num_units, time_zone, scale_multiplier);
+
+        return result_col;
    }
 };

--- a/src/Functions/toStartOfSubsecond.cpp
+++ b/src/Functions/toStartOfSubsecond.cpp
@ -0,0 +1,30 @@
+#include <Functions/FunctionFactory.h>
+#include <Functions/DateTimeTransforms.h>
+#include <Functions/FunctionDateOrDateTimeToSomething.h>
+
+
+namespace DB
+{
+
+using FunctionToStartOfMillisecond = FunctionDateOrDateTimeToSomething<DataTypeDateTime64, ToStartOfMillisecondImpl>;
+
+void registerFunctionToStartOfMillisecond(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionToStartOfMillisecond>();
+}
+
+using FunctionToStartOfMicrosecond = FunctionDateOrDateTimeToSomething<DataTypeDateTime64, ToStartOfMicrosecondImpl>;
+
+void registerFunctionToStartOfMicrosecond(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionToStartOfMicrosecond>();
+}
+
+using FunctionToStartOfNanosecond = FunctionDateOrDateTimeToSomething<DataTypeDateTime64, ToStartOfNanosecondImpl>;
+
+void registerFunctionToStartOfNanosecond(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionToStartOfNanosecond>();
+}
+
+}
--- a/src/Interpreters/CatBoostModel.cpp
+++ b/src/Interpreters/CatBoostModel.cpp
@ -26,10 +26,10 @@ extern const int CANNOT_LOAD_CATBOOST_MODEL;
 extern const int CANNOT_APPLY_CATBOOST_MODEL;
 }

-
 /// CatBoost wrapper interface functions.
-struct CatBoostWrapperAPI
+class CatBoostWrapperAPI
 {
+public:
    using ModelCalcerHandle = void;

    ModelCalcerHandle * (* ModelCalcerCreate)(); // NOLINT
@ -68,9 +68,6 @@ struct CatBoostWrapperAPI
 };


-namespace
-{
-
 class CatBoostModelHolder
 {
 private:
@ -84,7 +81,61 @@ public:
 };


-class CatBoostModelImpl : public ICatBoostModel
+/// Holds CatBoost wrapper library and provides wrapper interface.
+class CatBoostLibHolder
+{
+public:
+    explicit CatBoostLibHolder(std::string lib_path_) : lib_path(std::move(lib_path_)), lib(lib_path) { initAPI(); }
+
+    const CatBoostWrapperAPI & getAPI() const { return api; }
+    const std::string & getCurrentPath() const { return lib_path; }
+
+private:
+    CatBoostWrapperAPI api;
+    std::string lib_path;
+    SharedLibrary lib;
+
+    void initAPI()
+    {
+        load(api.ModelCalcerCreate, "ModelCalcerCreate");
+        load(api.ModelCalcerDelete, "ModelCalcerDelete");
+        load(api.GetErrorString, "GetErrorString");
+        load(api.LoadFullModelFromFile, "LoadFullModelFromFile");
+        load(api.CalcModelPredictionFlat, "CalcModelPredictionFlat");
+        load(api.CalcModelPrediction, "CalcModelPrediction");
+        load(api.CalcModelPredictionWithHashedCatFeatures, "CalcModelPredictionWithHashedCatFeatures");
+        load(api.GetStringCatFeatureHash, "GetStringCatFeatureHash");
+        load(api.GetIntegerCatFeatureHash, "GetIntegerCatFeatureHash");
+        load(api.GetFloatFeaturesCount, "GetFloatFeaturesCount");
+        load(api.GetCatFeaturesCount, "GetCatFeaturesCount");
+        tryLoad(api.CheckModelMetadataHasKey, "CheckModelMetadataHasKey");
+        tryLoad(api.GetModelInfoValueSize, "GetModelInfoValueSize");
+        tryLoad(api.GetModelInfoValue, "GetModelInfoValue");
+        tryLoad(api.GetTreeCount, "GetTreeCount");
+        tryLoad(api.GetDimensionsCount, "GetDimensionsCount");
+    }
+
+    template <typename T>
+    void load(T& func, const std::string & name) { func = lib.get<T>(name); }
+
+    template <typename T>
+    void tryLoad(T& func, const std::string & name) { func = lib.tryGet<T>(name); }
+};
+
+std::shared_ptr<CatBoostLibHolder> getCatBoostWrapperHolder(const std::string & lib_path)
+{
+    static std::shared_ptr<CatBoostLibHolder> ptr;
+    static std::mutex mutex;
+
+    std::lock_guard lock(mutex);
+
+    if (!ptr || ptr->getCurrentPath() != lib_path)
+        ptr = std::make_shared<CatBoostLibHolder>(lib_path);
+
+    return ptr;
+}
+
+class CatBoostModelImpl
 {
 public:
    CatBoostModelImpl(const CatBoostWrapperAPI * api_, const std::string & model_path) : api(api_)
@ -92,13 +143,15 @@ public:
        handle = std::make_unique<CatBoostModelHolder>(api);
        if (!handle)
        {
-            std::string msg = "Cannot create CatBoost model: ";
-            throw Exception(msg + api->GetErrorString(), ErrorCodes::CANNOT_LOAD_CATBOOST_MODEL);
+            throw Exception(ErrorCodes::CANNOT_LOAD_CATBOOST_MODEL,
+                "Cannot create CatBoost model: {}",
+                api->GetErrorString());
        }
        if (!api->LoadFullModelFromFile(handle->get(), model_path.c_str()))
        {
-            std::string msg = "Cannot load CatBoost model: ";
-            throw Exception(msg + api->GetErrorString(), ErrorCodes::CANNOT_LOAD_CATBOOST_MODEL);
+            throw Exception(ErrorCodes::CANNOT_LOAD_CATBOOST_MODEL,
+                "Cannot load CatBoost model: {}",
+                api->GetErrorString());
        }

        float_features_count = api->GetFloatFeaturesCount(handle->get());
@ -108,32 +161,22 @@ public:
            tree_count = api->GetDimensionsCount(handle->get());
    }

-    ColumnPtr evaluate(const ColumnRawPtrs & columns) const override
+    ColumnPtr evaluate(const ColumnRawPtrs & columns) const
    {
        if (columns.empty())
-            throw Exception("Got empty columns list for CatBoost model.", ErrorCodes::BAD_ARGUMENTS);
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "Got empty columns list for CatBoost model.");

        if (columns.size() != float_features_count + cat_features_count)
-        {
-            std::string msg;
-            {
-                WriteBufferFromString buffer(msg);
-                buffer << "Number of columns is different with number of features: ";
-                buffer << columns.size() << " vs " << float_features_count << " + " << cat_features_count;
-            }
-            throw Exception(msg, ErrorCodes::BAD_ARGUMENTS);
-        }
+            throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                "Number of columns is different with number of features: columns size {} float features size {} + cat features size {}",
+                float_features_count,
+                cat_features_count);

        for (size_t i = 0; i < float_features_count; ++i)
        {
            if (!columns[i]->isNumeric())
            {
-                std::string msg;
-                {
-                    WriteBufferFromString buffer(msg);
-                    buffer << "Column " << i << " should be numeric to make float feature.";
-                }
-                throw Exception(msg, ErrorCodes::BAD_ARGUMENTS);
+                throw Exception(ErrorCodes::BAD_ARGUMENTS, "Column {} should be numeric to make float feature.", i);
            }
        }

@ -142,16 +185,13 @@ public:
        {
            const auto * column = columns[i];
            if (column->isNumeric())
+            {
                cat_features_are_strings = false;
+            }
            else if (!(typeid_cast<const ColumnString *>(column)
                       || typeid_cast<const ColumnFixedString *>(column)))
            {
-                std::string msg;
-                {
-                    WriteBufferFromString buffer(msg);
-                    buffer << "Column " << i << " should be numeric or string.";
-                }
-                throw Exception(msg, ErrorCodes::BAD_ARGUMENTS);
+                throw Exception(ErrorCodes::BAD_ARGUMENTS, "Column {} should be numeric or string.", i);
            }
        }

@ -187,9 +227,9 @@ public:
        return ColumnTuple::create(std::move(mutable_columns));
    }

-    size_t getFloatFeaturesCount() const override { return float_features_count; }
-    size_t getCatFeaturesCount() const override { return cat_features_count; }
-    size_t getTreeCount() const override { return tree_count; }
+    size_t getFloatFeaturesCount() const { return float_features_count; }
+    size_t getCatFeaturesCount() const { return cat_features_count; }
+    size_t getTreeCount() const { return tree_count; }

 private:
    std::unique_ptr<CatBoostModelHolder> handle;
@ -435,66 +475,6 @@ private:
    }
 };

-
-/// Holds CatBoost wrapper library and provides wrapper interface.
-class CatBoostLibHolder: public CatBoostWrapperAPIProvider
-{
-public:
-    explicit CatBoostLibHolder(std::string lib_path_) : lib_path(std::move(lib_path_)), lib(lib_path) { initAPI(); }
-
-    const CatBoostWrapperAPI & getAPI() const override { return api; }
-    const std::string & getCurrentPath() const { return lib_path; }
-
-private:
-    CatBoostWrapperAPI api;
-    std::string lib_path;
-    SharedLibrary lib;
-
-    void initAPI();
-
-    template <typename T>
-    void load(T& func, const std::string & name) { func = lib.get<T>(name); }
-
-    template <typename T>
-    void tryLoad(T& func, const std::string & name) { func = lib.tryGet<T>(name); }
-};
-
-void CatBoostLibHolder::initAPI()
-{
-    load(api.ModelCalcerCreate, "ModelCalcerCreate");
-    load(api.ModelCalcerDelete, "ModelCalcerDelete");
-    load(api.GetErrorString, "GetErrorString");
-    load(api.LoadFullModelFromFile, "LoadFullModelFromFile");
-    load(api.CalcModelPredictionFlat, "CalcModelPredictionFlat");
-    load(api.CalcModelPrediction, "CalcModelPrediction");
-    load(api.CalcModelPredictionWithHashedCatFeatures, "CalcModelPredictionWithHashedCatFeatures");
-    load(api.GetStringCatFeatureHash, "GetStringCatFeatureHash");
-    load(api.GetIntegerCatFeatureHash, "GetIntegerCatFeatureHash");
-    load(api.GetFloatFeaturesCount, "GetFloatFeaturesCount");
-    load(api.GetCatFeaturesCount, "GetCatFeaturesCount");
-    tryLoad(api.CheckModelMetadataHasKey, "CheckModelMetadataHasKey");
-    tryLoad(api.GetModelInfoValueSize, "GetModelInfoValueSize");
-    tryLoad(api.GetModelInfoValue, "GetModelInfoValue");
-    tryLoad(api.GetTreeCount, "GetTreeCount");
-    tryLoad(api.GetDimensionsCount, "GetDimensionsCount");
-}
-
-std::shared_ptr<CatBoostLibHolder> getCatBoostWrapperHolder(const std::string & lib_path)
-{
-    static std::shared_ptr<CatBoostLibHolder> ptr;
-    static std::mutex mutex;
-
-    std::lock_guard lock(mutex);
-
-    if (!ptr || ptr->getCurrentPath() != lib_path)
-        ptr = std::make_shared<CatBoostLibHolder>(lib_path);
-
-    return ptr;
-}
-
-}
-
-
 CatBoostModel::CatBoostModel(std::string name_, std::string model_path_, std::string lib_path_,
                             const ExternalLoadableLifetime & lifetime_)
    : name(std::move(name_)), model_path(std::move(model_path_)), lib_path(std::move(lib_path_)), lifetime(lifetime_)
@ -502,43 +482,28 @@ CatBoostModel::CatBoostModel(std::string name_, std::string model_path_, std::st
    api_provider = getCatBoostWrapperHolder(lib_path);
    api = &api_provider->getAPI();
    model = std::make_unique<CatBoostModelImpl>(api, model_path);
-    float_features_count = model->getFloatFeaturesCount();
-    cat_features_count = model->getCatFeaturesCount();
-    tree_count = model->getTreeCount();
 }

-const ExternalLoadableLifetime & CatBoostModel::getLifetime() const
-{
-    return lifetime;
-}
-
-bool CatBoostModel::isModified() const
-{
-    return true;
-}
-
-std::shared_ptr<const IExternalLoadable> CatBoostModel::clone() const
-{
-    return std::make_shared<CatBoostModel>(name, model_path, lib_path, lifetime);
-}
+CatBoostModel::~CatBoostModel() = default;

 size_t CatBoostModel::getFloatFeaturesCount() const
 {
-    return float_features_count;
+    return model->getFloatFeaturesCount();
 }

 size_t CatBoostModel::getCatFeaturesCount() const
 {
-    return cat_features_count;
+    return model->getCatFeaturesCount();
 }

 size_t CatBoostModel::getTreeCount() const
 {
-    return tree_count;
+    return model->getTreeCount();
 }

 DataTypePtr CatBoostModel::getReturnType() const
 {
+    size_t tree_count = getTreeCount();
    auto type = std::make_shared<DataTypeFloat64>();
    if (tree_count == 1)
        return type;
@ -552,6 +517,7 @@ ColumnPtr CatBoostModel::evaluate(const ColumnRawPtrs & columns) const
 {
    if (!model)
        throw Exception("CatBoost model was not loaded.", ErrorCodes::LOGICAL_ERROR);
+
    return model->evaluate(columns);
 }

--- a/src/Interpreters/CatBoostModel.h
+++ b/src/Interpreters/CatBoostModel.h
@ -8,47 +8,32 @@
 namespace DB
 {

-/// CatBoost wrapper interface functions.
-struct CatBoostWrapperAPI;
-class CatBoostWrapperAPIProvider
-{
-public:
-    virtual ~CatBoostWrapperAPIProvider() = default;
-    virtual const CatBoostWrapperAPI & getAPI() const = 0;
-};
-
-/// CatBoost model interface.
-class ICatBoostModel
-{
-public:
-    virtual ~ICatBoostModel() = default;
-    /// Evaluate model. Use first `float_features_count` columns as float features,
-    /// the others `cat_features_count` as categorical features.
-    virtual ColumnPtr evaluate(const ColumnRawPtrs & columns) const = 0;
-
-    virtual size_t getFloatFeaturesCount() const = 0;
-    virtual size_t getCatFeaturesCount() const = 0;
-    virtual size_t getTreeCount() const = 0;
-};
+class CatBoostLibHolder;
+class CatBoostWrapperAPI;
+class CatBoostModelImpl;

 class IDataType;
 using DataTypePtr = std::shared_ptr<const IDataType>;

 /// General ML model evaluator interface.
-class IModel : public IExternalLoadable
+class IMLModel : public IExternalLoadable
 {
 public:
+    IMLModel() = default;
    virtual ColumnPtr evaluate(const ColumnRawPtrs & columns) const = 0;
    virtual std::string getTypeName() const = 0;
    virtual DataTypePtr getReturnType() const = 0;
+    virtual ~IMLModel() override = default;
 };

-class CatBoostModel : public IModel
+class CatBoostModel : public IMLModel
 {
 public:
    CatBoostModel(std::string name, std::string model_path,
                  std::string lib_path, const ExternalLoadableLifetime & lifetime);

+    ~CatBoostModel() override;
+
    ColumnPtr evaluate(const ColumnRawPtrs & columns) const override;
    std::string getTypeName() const override { return "catboost"; }

@ -59,29 +44,28 @@ public:

    /// IExternalLoadable interface.

-    const ExternalLoadableLifetime & getLifetime() const override;
+    const ExternalLoadableLifetime & getLifetime() const override { return lifetime; }

    std::string getLoadableName() const override { return name; }

    bool supportUpdates() const override { return true; }

-    bool isModified() const override;
+    bool isModified() const override { return true; }

-    std::shared_ptr<const IExternalLoadable> clone() const override;
+    std::shared_ptr<const IExternalLoadable> clone() const override
+    {
+        return std::make_shared<CatBoostModel>(name, model_path, lib_path, lifetime);
+    }

 private:
    const std::string name;
    std::string model_path;
    std::string lib_path;
    ExternalLoadableLifetime lifetime;
-    std::shared_ptr<CatBoostWrapperAPIProvider> api_provider;
+    std::shared_ptr<CatBoostLibHolder> api_provider;
    const CatBoostWrapperAPI * api;

-    std::unique_ptr<ICatBoostModel> model;
-
-    size_t float_features_count;
-    size_t cat_features_count;
-    size_t tree_count;
+    std::unique_ptr<CatBoostModelImpl> model;

    void init();
 };
--- a/src/Interpreters/ExternalModelsLoader.h
+++ b/src/Interpreters/ExternalModelsLoader.h
@ -15,14 +15,14 @@ namespace DB
 class ExternalModelsLoader : public ExternalLoader, WithContext
 {
 public:
-    using ModelPtr = std::shared_ptr<const IModel>;
+    using ModelPtr = std::shared_ptr<const IMLModel>;

    /// Models will be loaded immediately and then will be updated in separate thread, each 'reload_period' seconds.
    explicit ExternalModelsLoader(ContextPtr context_);

    ModelPtr getModel(const std::string & model_name) const
    {
-        return std::static_pointer_cast<const IModel>(load(model_name));
+        return std::static_pointer_cast<const IMLModel>(load(model_name));
    }

    void reloadModel(const std::string & model_name) const
--- a/src/Interpreters/HashJoin.cpp
+++ b/src/Interpreters/HashJoin.cpp
@ -1237,16 +1237,16 @@ NO_INLINE IColumn::Filter joinRightColumns(
                {
                    const IColumn & left_asof_key = added_columns.leftAsofKey();

-                    auto [block, row_num] = mapped->findAsof(left_asof_key, i);
-                    if (block)
+                    auto row_ref = mapped->findAsof(left_asof_key, i);
+                    if (row_ref.block)
                    {
                        setUsed<need_filter>(filter, i);
                        if constexpr (multiple_disjuncts)
-                            used_flags.template setUsed<jf.need_flags, multiple_disjuncts>(block, row_num, 0);
+                            used_flags.template setUsed<jf.need_flags, multiple_disjuncts>(row_ref.block, row_ref.row_num, 0);
                        else
                            used_flags.template setUsed<jf.need_flags, multiple_disjuncts>(find_result);

-                        added_columns.appendFromBlock<jf.add_missing>(*block, row_num);
+                        added_columns.appendFromBlock<jf.add_missing>(*row_ref.block, row_ref.row_num);
                    }
                    else
                        addNotFoundRow<jf.add_missing, jf.need_replication>(added_columns, current_offset);
--- a/src/Interpreters/RowRefs.cpp
+++ b/src/Interpreters/RowRefs.cpp
@ -1,5 +1,6 @@
 #include <Interpreters/RowRefs.h>

+#include <Common/RadixSort.h>
 #include <AggregateFunctions/Helpers.h>
 #include <Columns/IColumn.h>
 #include <DataTypes/IDataType.h>
@ -44,38 +45,52 @@ class SortedLookupVector : public SortedLookupVectorBase
 {
    struct Entry
    {
-        /// We don't store a RowRef and instead keep it's members separately (and return a tuple) to reduce the memory usage.
-        /// For example, for sizeof(T) == 4 => sizeof(Entry) == 16 (while before it would be 20). Then when you put it into a vector, the effect is even greater
-        decltype(RowRef::block) block;
-        decltype(RowRef::row_num) row_num;
-        TKey asof_value;
+        TKey value;
+        uint32_t row_ref_index;

        Entry() = delete;
-        Entry(TKey v, const Block * b, size_t r) : block(b), row_num(r), asof_value(v) { }
+        Entry(TKey value_, uint32_t row_ref_index_)
+            : value(value_)
+            , row_ref_index(row_ref_index_)
+        { }

-        bool operator<(const Entry & other) const { return asof_value < other.asof_value; }
+    };
+
+    struct LessEntryOperator
+    {
+        ALWAYS_INLINE bool operator()(const Entry & lhs, const Entry & rhs) const
+        {
+            return lhs.value < rhs.value;
+        }
    };

    struct GreaterEntryOperator
    {
-        bool operator()(Entry const & a, Entry const & b) const { return a.asof_value > b.asof_value; }
+        ALWAYS_INLINE bool operator()(const Entry & lhs, const Entry & rhs) const
+        {
+            return lhs.value > rhs.value;
+        }
    };


 public:
-    using Base = std::vector<Entry>;
    using Keys = std::vector<TKey>;
-    static constexpr bool isDescending = (inequality == ASOF::Inequality::Greater || inequality == ASOF::Inequality::GreaterOrEquals);
-    static constexpr bool isStrict = (inequality == ASOF::Inequality::Less) || (inequality == ASOF::Inequality::Greater);
+    using Entries = PaddedPODArray<Entry>;
+    using RowRefs = PaddedPODArray<RowRef>;
+
+    static constexpr bool is_descending = (inequality == ASOF::Inequality::Greater || inequality == ASOF::Inequality::GreaterOrEquals);
+    static constexpr bool is_strict = (inequality == ASOF::Inequality::Less) || (inequality == ASOF::Inequality::Greater);

    void insert(const IColumn & asof_column, const Block * block, size_t row_num) override
    {
        using ColumnType = ColumnVectorOrDecimal<TKey>;
        const auto & column = assert_cast<const ColumnType &>(asof_column);
-        TKey k = column.getElement(row_num);
+        TKey key = column.getElement(row_num);

        assert(!sorted.load(std::memory_order_acquire));
-        array.emplace_back(k, block, row_num);
+
+        entries.emplace_back(key, row_refs.size());
+        row_refs.emplace_back(RowRef(block, row_num));
    }

    /// Unrolled version of upper_bound and lower_bound
@ -84,30 +99,30 @@ public:
    /// at https://en.algorithmica.org/hpc/data-structures/s-tree/
    size_t boundSearch(TKey value)
    {
-        size_t size = array.size();
+        size_t size = entries.size();
        size_t low = 0;

        /// This is a single binary search iteration as a macro to unroll. Takes into account the inequality:
-        /// isStrict -> Equal values are not requested
-        /// isDescending -> The vector is sorted in reverse (for greater or greaterOrEquals)
+        /// is_strict -> Equal values are not requested
+        /// is_descending -> The vector is sorted in reverse (for greater or greaterOrEquals)
 #define BOUND_ITERATION \
    { \
        size_t half = size / 2; \
        size_t other_half = size - half; \
        size_t probe = low + half; \
        size_t other_low = low + other_half; \
-        TKey v = array[probe].asof_value; \
+        TKey & v = entries[probe].value; \
        size = half; \
-        if constexpr (isDescending) \
+        if constexpr (is_descending) \
        { \
-            if constexpr (isStrict) \
+            if constexpr (is_strict) \
                low = value <= v ? other_low : low; \
            else \
                low = value < v ? other_low : low; \
        } \
        else \
        { \
-            if constexpr (isStrict) \
+            if constexpr (is_strict) \
                low = value >= v ? other_low : low; \
            else \
                low = value > v ? other_low : low; \
@ -130,7 +145,7 @@ public:
        return low;
    }

-    std::tuple<decltype(RowRef::block), decltype(RowRef::row_num)> findAsof(const IColumn & asof_column, size_t row_num) override
+    RowRef findAsof(const IColumn & asof_column, size_t row_num) override
    {
        sort();

@ -139,8 +154,11 @@ public:
        TKey k = column.getElement(row_num);

        size_t pos = boundSearch(k);
-        if (pos != array.size())
-            return std::make_tuple(array[pos].block, array[pos].row_num);
+        if (pos != entries.size())
+        {
+            size_t row_ref_index = entries[pos].row_ref_index;
+            return row_refs[row_ref_index];
+        }

        return {nullptr, 0};
    }
@ -148,7 +166,8 @@ public:
 private:
    std::atomic<bool> sorted = false;
    mutable std::mutex lock;
-    Base array;
+    Entries entries;
+    RowRefs row_refs;

    // Double checked locking with SC atomics works in C++
    // https://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11/
@ -160,12 +179,37 @@ private:
        if (!sorted.load(std::memory_order_acquire))
        {
            std::lock_guard<std::mutex> l(lock);
+
            if (!sorted.load(std::memory_order_relaxed))
            {
-                if constexpr (isDescending)
-                    ::sort(array.begin(), array.end(), GreaterEntryOperator());
+                if constexpr (std::is_arithmetic_v<TKey> && !std::is_floating_point_v<TKey>)
+                {
+                    if (likely(entries.size() > 256))
+                    {
+                        struct RadixSortTraits : RadixSortNumTraits<TKey>
+                        {
+                            using Element = Entry;
+                            using Result = Element;
+
+                            static TKey & extractKey(Element & elem) { return elem.value; }
+                            static Element extractResult(Element & elem) { return elem; }
+                        };
+
+                        if constexpr (is_descending)
+                            RadixSort<RadixSortTraits>::executeLSD(entries.data(), entries.size(), true);
+                        else
+                            RadixSort<RadixSortTraits>::executeLSD(entries.data(), entries.size(), false);
+
+                        sorted.store(true, std::memory_order_release);
+                        return;
+                    }
+                }
+
+                if constexpr (is_descending)
+                    ::sort(entries.begin(), entries.end(), GreaterEntryOperator());
                else
-                    ::sort(array.begin(), array.end());
+                    ::sort(entries.begin(), entries.end(), LessEntryOperator());
+
                sorted.store(true, std::memory_order_release);
            }
        }
--- a/src/Interpreters/RowRefs.h
+++ b/src/Interpreters/RowRefs.h
@ -146,7 +146,7 @@ private:
 struct SortedLookupVectorBase
 {
    SortedLookupVectorBase() = default;
-    virtual ~SortedLookupVectorBase() { }
+    virtual ~SortedLookupVectorBase() = default;

    static std::optional<TypeIndex> getTypeSize(const IColumn & asof_column, size_t & type_size);

@ -154,7 +154,7 @@ struct SortedLookupVectorBase
    virtual void insert(const IColumn &, const Block *, size_t) = 0;

    // This needs to be synchronized internally
-    virtual std::tuple<decltype(RowRef::block), decltype(RowRef::row_num)> findAsof(const IColumn &, size_t) = 0;
+    virtual RowRef findAsof(const IColumn &, size_t) = 0;
 };


--- a/src/Parsers/parseIntervalKind.cpp
+++ b/src/Parsers/parseIntervalKind.cpp
@ -7,6 +7,27 @@ namespace DB
 {
 bool parseIntervalKind(IParser::Pos & pos, Expected & expected, IntervalKind & result)
 {
+    if (ParserKeyword("NANOSECOND").ignore(pos, expected) || ParserKeyword("SQL_TSI_NANOSECOND").ignore(pos, expected)
+        || ParserKeyword("NS").ignore(pos, expected))
+    {
+        result = IntervalKind::Nanosecond;
+        return true;
+    }
+
+    if (ParserKeyword("MICROSECOND").ignore(pos, expected) || ParserKeyword("SQL_TSI_MICROSECOND").ignore(pos, expected)
+        || ParserKeyword("MCS").ignore(pos, expected))
+    {
+        result = IntervalKind::Microsecond;
+        return true;
+    }
+
+    if (ParserKeyword("MILLISECOND").ignore(pos, expected) || ParserKeyword("SQL_TSI_MILLISECOND").ignore(pos, expected)
+        || ParserKeyword("MS").ignore(pos, expected))
+    {
+        result = IntervalKind::Millisecond;
+        return true;
+    }
+
    if (ParserKeyword("SECOND").ignore(pos, expected) || ParserKeyword("SQL_TSI_SECOND").ignore(pos, expected)
        || ParserKeyword("SS").ignore(pos, expected) || ParserKeyword("S").ignore(pos, expected))
    {
--- a/src/Processors/Formats/Impl/TSKVRowInputFormat.cpp
+++ b/src/Processors/Formats/Impl/TSKVRowInputFormat.cpp
@ -4,7 +4,6 @@
 #include <Formats/EscapingRuleUtils.h>
 #include <DataTypes/Serializations/SerializationNullable.h>
 #include <DataTypes/DataTypeString.h>
-#include <DataTypes/DataTypeNullable.h>


 namespace DB
@ -242,15 +241,16 @@ std::unordered_map<String, DataTypePtr> TSKVSchemaReader::readRowAndGetNamesAndD

    std::unordered_map<String, DataTypePtr> names_and_types;
    StringRef name_ref;
-    String name_tmp;
+    String name_buf;
    String value;
    do
    {
-        bool has_value = readName(in, name_ref, name_tmp);
+        bool has_value = readName(in, name_ref, name_buf);
+        String name = String(name_ref);
        if (has_value)
        {
            readEscapedString(value, in);
-            names_and_types[String(name_ref)] = determineDataTypeByEscapingRule(value, format_settings, FormatSettings::EscapingRule::Escaped);
+            names_and_types[std::move(name)] = determineDataTypeByEscapingRule(value, format_settings, FormatSettings::EscapingRule::Escaped);
        }
        else
        {
--- a/src/Processors/Transforms/FillingTransform.cpp
+++ b/src/Processors/Transforms/FillingTransform.cpp
@ -34,16 +34,16 @@ Block FillingTransform::transformHeader(Block header, const SortDescription & so

 template <typename T>
 static FillColumnDescription::StepFunction getStepFunction(
-    IntervalKind kind, Int64 step, const DateLUTImpl & date_lut)
+    IntervalKind kind, Int64 step, const DateLUTImpl & date_lut, UInt16 scale = DataTypeDateTime64::default_scale)
 {
    switch (kind)
    {
-        #define DECLARE_CASE(NAME) \
+#define DECLARE_CASE(NAME) \
        case IntervalKind::NAME: \
-            return [step, &date_lut](Field & field) { field = Add##NAME##sImpl::execute(get<T>(field), step, date_lut); };
+            return [step, scale, &date_lut](Field & field) { field = Add##NAME##sImpl::execute(get<T>(field), step, date_lut, scale); };

        FOR_EACH_INTERVAL_KIND(DECLARE_CASE)
-        #undef DECLARE_CASE
+#undef DECLARE_CASE
    }
    __builtin_unreachable();
 }
@ -92,7 +92,7 @@ static bool tryConvertFields(FillColumnDescription & descr, const DataTypePtr &
            Int64 avg_seconds = get<Int64>(descr.fill_step) * descr.step_kind->toAvgSeconds();
            if (avg_seconds < 86400)
                throw Exception(ErrorCodes::INVALID_WITH_FILL_EXPRESSION,
-                    "Value of step is to low ({} seconds). Must be >= 1 day", avg_seconds);
+                                "Value of step is to low ({} seconds). Must be >= 1 day", avg_seconds);
        }

        if (which.isDate())
@ -108,25 +108,23 @@ static bool tryConvertFields(FillColumnDescription & descr, const DataTypePtr &

            switch (*descr.step_kind)
            {
-                #define DECLARE_CASE(NAME) \
+#define DECLARE_CASE(NAME) \
                case IntervalKind::NAME: \
                    descr.step_func = [step, &time_zone = date_time64->getTimeZone()](Field & field) \
                    { \
                        auto field_decimal = get<DecimalField<DateTime64>>(field); \
-                        auto components = DecimalUtils::splitWithScaleMultiplier(field_decimal.getValue(), field_decimal.getScaleMultiplier()); \
-                        auto res = Add##NAME##sImpl::execute(components, step, time_zone); \
-                        auto res_decimal = decimalFromComponentsWithMultiplier<DateTime64>(res, field_decimal.getScaleMultiplier()); \
-                        field = DecimalField(res_decimal, field_decimal.getScale()); \
+                        auto res = Add##NAME##sImpl::execute(field_decimal.getValue(), step, time_zone, field_decimal.getScale()); \
+                        field = DecimalField(res, field_decimal.getScale()); \
                    }; \
                    break;

                FOR_EACH_INTERVAL_KIND(DECLARE_CASE)
-                #undef DECLARE_CASE
+#undef DECLARE_CASE
            }
        }
        else
            throw Exception(ErrorCodes::INVALID_WITH_FILL_EXPRESSION,
-                "STEP of Interval type can be used only with Date/DateTime types, but got {}", type->getName());
+                            "STEP of Interval type can be used only with Date/DateTime types, but got {}", type->getName());
    }
    else
    {
@ -140,12 +138,12 @@ static bool tryConvertFields(FillColumnDescription & descr, const DataTypePtr &
 }

 FillingTransform::FillingTransform(
-        const Block & header_, const SortDescription & sort_description_, bool on_totals_)
-        : ISimpleTransform(header_, transformHeader(header_, sort_description_), true)
-        , sort_description(sort_description_)
-        , on_totals(on_totals_)
-        , filling_row(sort_description_)
-        , next_row(sort_description_)
+    const Block & header_, const SortDescription & sort_description_, bool on_totals_)
+    : ISimpleTransform(header_, transformHeader(header_, sort_description_), true)
+    , sort_description(sort_description_)
+    , on_totals(on_totals_)
+    , filling_row(sort_description_)
+    , next_row(sort_description_)
 {
    if (on_totals)
        return;
@ -162,14 +160,14 @@ FillingTransform::FillingTransform(

        if (!tryConvertFields(descr, type))
            throw Exception("Incompatible types of WITH FILL expression values with column type "
-                + type->getName(), ErrorCodes::INVALID_WITH_FILL_EXPRESSION);
+                                + type->getName(), ErrorCodes::INVALID_WITH_FILL_EXPRESSION);

        if (type->isValueRepresentedByUnsignedInteger() &&
            ((!descr.fill_from.isNull() && less(descr.fill_from, Field{0}, 1)) ||
-                (!descr.fill_to.isNull() && less(descr.fill_to, Field{0}, 1))))
+             (!descr.fill_to.isNull() && less(descr.fill_to, Field{0}, 1))))
        {
            throw Exception("WITH FILL bound values cannot be negative for unsigned type "
-                + type->getName(), ErrorCodes::INVALID_WITH_FILL_EXPRESSION);
+                                + type->getName(), ErrorCodes::INVALID_WITH_FILL_EXPRESSION);
        }
    }

@ -214,7 +212,7 @@ void FillingTransform::transform(Chunk & chunk)
    MutableColumns res_other_columns;

    auto init_columns_by_positions = [](const Columns & old_columns, Columns & new_columns,
-        MutableColumns & new_mutable_columns, const Positions & positions)
+                                        MutableColumns & new_mutable_columns, const Positions & positions)
    {
        for (size_t pos : positions)
        {
--- a/src/Storages/System/StorageSystemModels.cpp
+++ b/src/Storages/System/StorageSystemModels.cpp
@ -38,7 +38,7 @@ void StorageSystemModels::fillData(MutableColumns & res_columns, ContextPtr cont

        if (load_result.object)
        {
-            const auto model_ptr = std::static_pointer_cast<const IModel>(load_result.object);
+            const auto model_ptr = std::static_pointer_cast<const IMLModel>(load_result.object);
            res_columns[3]->insert(model_ptr->getTypeName());
        }
        else
--- a/src/Storages/WindowView/StorageWindowView.cpp
+++ b/src/Storages/WindowView/StorageWindowView.cpp
@ -57,6 +57,7 @@ namespace ErrorCodes
 {
    extern const int ARGUMENT_OUT_OF_BOUND;
    extern const int BAD_ARGUMENTS;
+    extern const int SYNTAX_ERROR;
    extern const int ILLEGAL_COLUMN;
    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
    extern const int INCORRECT_QUERY;
@ -262,7 +263,13 @@ namespace

    IntervalKind strToIntervalKind(const String& interval_str)
    {
-        if (interval_str == "Second")
+        if (interval_str == "Nanosecond")
+            return IntervalKind::Nanosecond;
+        else if (interval_str == "Microsecond")
+            return IntervalKind::Microsecond;
+        else if (interval_str == "Millisecond")
+            return IntervalKind::Millisecond;
+        else if (interval_str == "Second")
            return IntervalKind::Second;
        else if (interval_str == "Minute")
            return IntervalKind::Minute;
@ -307,6 +314,12 @@ namespace
    {
        switch (kind)
        {
+            case IntervalKind::Nanosecond:
+                throw Exception("Fractional seconds are not supported by windows yet", ErrorCodes::SYNTAX_ERROR);
+            case IntervalKind::Microsecond:
+                throw Exception("Fractional seconds are not supported by windows yet", ErrorCodes::SYNTAX_ERROR);
+            case IntervalKind::Millisecond:
+                throw Exception("Fractional seconds are not supported by windows yet", ErrorCodes::SYNTAX_ERROR);
 #define CASE_WINDOW_KIND(KIND) \
    case IntervalKind::KIND: { \
        return AddTime<IntervalKind::KIND>::execute(time_sec, num_units, time_zone); \
@ -738,6 +751,12 @@ UInt32 StorageWindowView::getWindowLowerBound(UInt32 time_sec)

    switch (window_interval_kind)
    {
+        case IntervalKind::Nanosecond:
+            throw Exception("Fractional seconds are not supported by windows yet", ErrorCodes::SYNTAX_ERROR);
+        case IntervalKind::Microsecond:
+            throw Exception("Fractional seconds are not supported by windows yet", ErrorCodes::SYNTAX_ERROR);
+        case IntervalKind::Millisecond:
+            throw Exception("Fractional seconds are not supported by windows yet", ErrorCodes::SYNTAX_ERROR);
 #define CASE_WINDOW_KIND(KIND) \
    case IntervalKind::KIND: \
    { \
@ -773,6 +792,13 @@ UInt32 StorageWindowView::getWindowUpperBound(UInt32 time_sec)

    switch (window_interval_kind)
    {
+        case IntervalKind::Nanosecond:
+            throw Exception("Fractional seconds are not supported by window view yet", ErrorCodes::SYNTAX_ERROR);
+        case IntervalKind::Microsecond:
+            throw Exception("Fractional seconds are not supported by window view yet", ErrorCodes::SYNTAX_ERROR);
+        case IntervalKind::Millisecond:
+            throw Exception("Fractional seconds are not supported by window view yet", ErrorCodes::SYNTAX_ERROR);
+
 #define CASE_WINDOW_KIND(KIND) \
    case IntervalKind::KIND: \
    { \
--- a/tests/integration/test_system_logs_comment/test.py
+++ b/tests/integration/test_system_logs_comment/test.py
@ -6,9 +6,10 @@ import pytest
 from helpers.cluster import ClickHouseCluster

 cluster = ClickHouseCluster(__file__)
-node = cluster.add_instance('node_default', stay_alive=True)
+node = cluster.add_instance("node_default", stay_alive=True)

-@pytest.fixture(scope='module', autouse=True)
+
+@pytest.fixture(scope="module", autouse=True)
 def start_cluster():
    try:
        cluster.start()
@ -18,7 +19,11 @@ def start_cluster():


 def test_system_logs_comment():
-    node.exec_in_container(['bash', '-c', f"""echo "
+    node.exec_in_container(
+        [
+            "bash",
+            "-c",
+            f"""echo "
        <clickhouse>
            <query_log>
                <engine>ENGINE = MergeTree
@ -32,11 +37,13 @@ def test_system_logs_comment():
            </query_log>
        </clickhouse>
        " > /etc/clickhouse-server/config.d/yyy-override-query_log.xml
-        """])
+        """,
+        ]
+    )
    node.restart_clickhouse()

    node.query("select 1")
    node.query("system flush logs")

    comment = node.query("SELECT comment FROM system.tables WHERE name = 'query_log'")
-    assert comment =='test_comment\n'
+    assert comment == "test_comment\n"
--- a/tests/queries/0_stateless/01675_data_type_coroutine.reference
+++ b/tests/queries/0_stateless/01675_data_type_coroutine.reference
@ -1 +1,2 @@
 Ok
+Ok
--- a/tests/queries/0_stateless/01675_data_type_coroutine.sh
+++ b/tests/queries/0_stateless/01675_data_type_coroutine.sh
@ -16,3 +16,15 @@ done

 #echo "I = ${I}"
 echo 'Ok'
+
+counter=0
+I=0
+while [[ $counter -lt $retries ]]; do
+    I=$((I + 1))
+    TYPE=$(perl -e "print 'Array(' x $I; print 'UInt8'; print ')' x $I")
+    ${CLICKHOUSE_CLIENT} --prefer_localhost_replica=0 --max_parser_depth 1000000 --query "SELECT * FROM remote('127.0.0.{1,2}', generateRandom('x $TYPE', 1, 1, 1)) LIMIT 1 FORMAT Null" 2>&1 | grep -q -F 'Maximum parse depth' && break;
+    ((++counter))
+done
+
+#echo "I = ${I}"
+echo 'Ok'
--- a/tests/queries/0_stateless/02207_subseconds_intervals.reference
+++ b/tests/queries/0_stateless/02207_subseconds_intervals.reference
@ -0,0 +1,62 @@
+test intervals
+- test nanoseconds
+1980-12-12 12:12:12.123456789
+1980-12-12 12:12:12.123456700
+1980-12-12 12:12:12.123456789
+1930-12-12 12:12:12.123456789
+1930-12-12 12:12:12.123456700
+2220-12-12 12:12:12.123456789
+2220-12-12 12:12:12.123456700
+- test microseconds
+1980-12-12 12:12:12.123456
+1980-12-12 12:12:12.123400
+1980-12-12 12:12:12.123456
+1980-12-12 12:12:12.123456
+1930-12-12 12:12:12.123456
+1930-12-12 12:12:12.123400
+1930-12-12 12:12:12.123457
+2220-12-12 12:12:12.123456
+2220-12-12 12:12:12.123400
+2220-12-12 12:12:12.123456
+- test milliseconds
+1980-12-12 12:12:12.123
+1980-12-12 12:12:12.120
+1980-12-12 12:12:12.123
+1980-12-12 12:12:12.123
+1930-12-12 12:12:12.123
+1930-12-12 12:12:12.120
+1930-12-12 12:12:12.124
+2220-12-12 12:12:12.123
+2220-12-12 12:12:12.120
+2220-12-12 12:12:12.123
+test add[...]seconds()
+- test nanoseconds
+1980-12-12 12:12:12.123456790
+1980-12-12 12:12:12.123456701
+1980-12-12 12:12:12.123456790
+1930-12-12 12:12:12.123456788
+1930-12-12 12:12:12.123456699
+2220-12-12 12:12:12.123456790
+2220-12-12 12:12:12.123456701
+- test microseconds
+1980-12-12 12:12:12.123457
+1980-12-12 12:12:12.123401
+1980-12-12 12:12:12.12345778
+1980-12-12 12:12:12.123457
+1930-12-12 12:12:12.123455
+1930-12-12 12:12:12.123399
+1930-12-12 12:12:12.12345578
+2220-12-12 12:12:12.123457
+2220-12-12 12:12:12.123401
+2220-12-12 12:12:12.12345778
+- test milliseconds
+1980-12-12 12:12:12.124
+1980-12-12 12:12:12.121
+1980-12-12 12:12:12.124456
+1980-12-12 12:12:12.124
+1930-12-12 12:12:12.122
+1930-12-12 12:12:12.119
+1930-12-12 12:12:12.122456
+2220-12-12 12:12:12.124
+2220-12-12 12:12:12.121
+2220-12-12 12:12:12.124456
--- a/tests/queries/0_stateless/02207_subseconds_intervals.sql
+++ b/tests/queries/0_stateless/02207_subseconds_intervals.sql
@ -0,0 +1,94 @@
+SELECT 'test intervals';
+
+SELECT '- test nanoseconds';
+select toStartOfInterval(toDateTime64('1980-12-12 12:12:12.123456789', 9), INTERVAL 1 NANOSECOND); -- In normal range, source scale matches result
+select toStartOfInterval(toDateTime64('1980-12-12 12:12:12.1234567', 7), INTERVAL 1 NANOSECOND); -- In normal range, source scale less than result
+
+select toStartOfInterval(a, INTERVAL 1 NANOSECOND) from ( select toDateTime64('1980-12-12 12:12:12.123456789', 9) AS a ); -- Non-constant argument
+
+select toStartOfInterval(toDateTime64('1930-12-12 12:12:12.123456789', 9), INTERVAL 1 NANOSECOND); -- Below normal range, source scale matches result
+select toStartOfInterval(toDateTime64('1930-12-12 12:12:12.1234567', 7), INTERVAL 1 NANOSECOND); -- Below normal range, source scale less than result
+
+select toStartOfInterval(toDateTime64('2220-12-12 12:12:12.123456789', 9), INTERVAL 1 NANOSECOND); -- Above normal range, source scale matches result
+select toStartOfInterval(toDateTime64('2220-12-12 12:12:12.1234567', 7), INTERVAL 1 NANOSECOND); -- Above normal range, source scale less than result
+
+
+SELECT '- test microseconds';
+select toStartOfInterval(toDateTime64('1980-12-12 12:12:12.123456', 6), INTERVAL 1 MICROSECOND); -- In normal range, source scale matches result
+select toStartOfInterval(toDateTime64('1980-12-12 12:12:12.1234', 4), INTERVAL 1 MICROSECOND); -- In normal range, source scale less than result
+select toStartOfInterval(toDateTime64('1980-12-12 12:12:12.12345678', 8), INTERVAL 1 MICROSECOND); -- In normal range, source scale greater than result
+
+select toStartOfInterval(a, INTERVAL 1 MICROSECOND) from ( select toDateTime64('1980-12-12 12:12:12.12345678', 8) AS a ); -- Non-constant argument
+
+select toStartOfInterval(toDateTime64('1930-12-12 12:12:12.123456', 6), INTERVAL 1 MICROSECOND); -- Below normal range, source scale matches result
+select toStartOfInterval(toDateTime64('1930-12-12 12:12:12.1234', 4), INTERVAL 1 MICROSECOND); -- Below normal range, source scale less than result
+select toStartOfInterval(toDateTime64('1930-12-12 12:12:12.12345678', 8), INTERVAL 1 MICROSECOND); -- Below normal range, source scale greater than result
+
+
+select toStartOfInterval(toDateTime64('2220-12-12 12:12:12.123456', 6), INTERVAL 1 MICROSECOND); -- Above normal range, source scale matches result
+select toStartOfInterval(toDateTime64('2220-12-12 12:12:12.1234', 4), INTERVAL 1 MICROSECOND); -- Above normal range, source scale less than result
+select toStartOfInterval(toDateTime64('2220-12-12 12:12:12.12345678', 8), INTERVAL 1 MICROSECOND); -- Above normal range, source scale greater than result
+
+
+SELECT '- test milliseconds';
+select toStartOfInterval(toDateTime64('1980-12-12 12:12:12.123', 3), INTERVAL 1 MILLISECOND); -- In normal range, source scale matches result
+select toStartOfInterval(toDateTime64('1980-12-12 12:12:12.12', 2), INTERVAL 1 MILLISECOND); -- In normal range, source scale less than result
+select toStartOfInterval(toDateTime64('1980-12-12 12:12:12.123456', 6), INTERVAL 1 MILLISECOND); -- In normal range, source scale greater than result
+
+select toStartOfInterval(a, INTERVAL 1 MILLISECOND) from ( select toDateTime64('1980-12-12 12:12:12.123456', 6) AS a ); -- Non-constant argument
+
+select toStartOfInterval(toDateTime64('1930-12-12 12:12:12.123', 3), INTERVAL 1 MILLISECOND); -- Below normal range, source scale matches result
+select toStartOfInterval(toDateTime64('1930-12-12 12:12:12.12', 2), INTERVAL 1 MILLISECOND); -- Below normal range, source scale less than result
+select toStartOfInterval(toDateTime64('1930-12-12 12:12:12.123456', 6), INTERVAL 1 MILLISECOND); -- Below normal range, source scale greater than result
+
+select toStartOfInterval(toDateTime64('2220-12-12 12:12:12.123', 3), INTERVAL 1 MILLISECOND); -- Above normal range, source scale matches result
+select toStartOfInterval(toDateTime64('2220-12-12 12:12:12.12', 2), INTERVAL 1 MILLISECOND); -- Above normal range, source scale less than result
+select toStartOfInterval(toDateTime64('2220-12-12 12:12:12.123456', 6), INTERVAL 1 MILLISECOND); -- Above normal range, source scale greater than result
+
+
+SELECT 'test add[...]seconds()';
+
+
+SELECT '- test nanoseconds';
+select addNanoseconds(toDateTime64('1980-12-12 12:12:12.123456789', 9), 1); -- In normal range, source scale matches result
+select addNanoseconds(toDateTime64('1980-12-12 12:12:12.1234567', 7), 1); -- In normal range, source scale less than result
+
+select addNanoseconds(a, 1) from ( select toDateTime64('1980-12-12 12:12:12.123456789', 9) AS a ); -- Non-constant argument
+
+select addNanoseconds(toDateTime64('1930-12-12 12:12:12.123456789', 9), 1); -- Below normal range, source scale matches result
+select addNanoseconds(toDateTime64('1930-12-12 12:12:12.1234567', 7), 1); -- Below normal range, source scale less than result
+
+select addNanoseconds(toDateTime64('2220-12-12 12:12:12.123456789', 9), 1); -- Above normal range, source scale matches result
+select addNanoseconds(toDateTime64('2220-12-12 12:12:12.1234567', 7), 1); -- Above normal range, source scale less than result
+
+
+SELECT '- test microseconds';
+select addMicroseconds(toDateTime64('1980-12-12 12:12:12.123456', 6), 1); -- In normal range, source scale matches result
+select addMicroseconds(toDateTime64('1980-12-12 12:12:12.1234', 4), 1); -- In normal range, source scale less than result
+select addMicroseconds(toDateTime64('1980-12-12 12:12:12.12345678', 8), 1); -- In normal range, source scale greater than result
+
+select addMicroseconds(a, 1) from ( select toDateTime64('1980-12-12 12:12:12.123456', 6) AS a ); -- Non-constant argument
+
+select addMicroseconds(toDateTime64('1930-12-12 12:12:12.123456', 6), 1); -- Below normal range, source scale matches result
+select addMicroseconds(toDateTime64('1930-12-12 12:12:12.1234', 4), 1); -- Below normal range, source scale less than result
+select addMicroseconds(toDateTime64('1930-12-12 12:12:12.12345678', 8), 1); -- Below normal range, source scale greater than result
+
+select addMicroseconds(toDateTime64('2220-12-12 12:12:12.123456', 6), 1); -- Above normal range, source scale matches result
+select addMicroseconds(toDateTime64('2220-12-12 12:12:12.1234', 4), 1); -- Above normal range, source scale less than result
+select addMicroseconds(toDateTime64('2220-12-12 12:12:12.12345678', 8), 1); -- Above normal range, source scale greater than result
+
+
+SELECT '- test milliseconds';
+select addMilliseconds(toDateTime64('1980-12-12 12:12:12.123', 3), 1); -- In normal range, source scale matches result
+select addMilliseconds(toDateTime64('1980-12-12 12:12:12.12', 2), 1); -- In normal range, source scale less than result
+select addMilliseconds(toDateTime64('1980-12-12 12:12:12.123456', 6), 1); -- In normal range, source scale greater than result
+
+select addMilliseconds(a, 1) from ( select toDateTime64('1980-12-12 12:12:12.123', 3) AS a ); -- Non-constant argument
+
+select addMilliseconds(toDateTime64('1930-12-12 12:12:12.123', 3), 1); -- Below normal range, source scale matches result
+select addMilliseconds(toDateTime64('1930-12-12 12:12:12.12', 2), 1); -- Below normal range, source scale less than result
+select addMilliseconds(toDateTime64('1930-12-12 12:12:12.123456', 6), 1); -- Below normal range, source scale greater than result
+
+select addMilliseconds(toDateTime64('2220-12-12 12:12:12.123', 3), 1); -- Above normal range, source scale matches result
+select addMilliseconds(toDateTime64('2220-12-12 12:12:12.12', 2), 1); -- Above normal range, source scale less than result
+select addMilliseconds(toDateTime64('2220-12-12 12:12:12.123456', 6), 1); -- Above normal range, source scale greater than result
--- a/tests/queries/0_stateless/02240_tskv_schema_inference_bug.reference
+++ b/tests/queries/0_stateless/02240_tskv_schema_inference_bug.reference
@ -0,0 +1,8 @@
+b	Nullable(String)					
+c	Nullable(String)					
+a	Nullable(String)					
+s1	\N	1
+}	[2]	2
+\N	\N	\N
+\N	\N	\N
+\N	[3]	\N
--- a/tests/queries/0_stateless/02240_tskv_schema_inference_bug.sh
+++ b/tests/queries/0_stateless/02240_tskv_schema_inference_bug.sh
@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Tags: no-parallel, no-fasttest
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+
+USER_FILES_PATH=$(clickhouse-client --query "select _path,_file from file('nonexist.txt', 'CSV', 'val1 char')" 2>&1 | grep Exception | awk '{gsub("/nonexist.txt","",$9); print $9}')
+FILE_NAME=test_02240.data
+DATA_FILE=${USER_FILES_PATH:?}/$FILE_NAME
+
+touch $DATA_FILE
+
+echo -e 'a=1\tb=s1\tc=\N
+c=[2]\ta=2\tb=\N}
+
+a=\N
+c=[3]\ta=\N'  > $DATA_FILE
+$CLICKHOUSE_CLIENT --max_read_buffer_size=4 -q "desc file('$FILE_NAME', 'TSKV')"
+$CLICKHOUSE_CLIENT --max_read_buffer_size=4 -q "select * from file('$FILE_NAME', 'TSKV')"
+
--- a/tests/queries/0_stateless/02243_in_ip_address.reference
+++ b/tests/queries/0_stateless/02243_in_ip_address.reference
@ -0,0 +1,2 @@
+0
+0
--- a/tests/queries/0_stateless/02243_in_ip_address.sql
+++ b/tests/queries/0_stateless/02243_in_ip_address.sql
@ -0,0 +1,9 @@
+DROP TABLE IF EXISTS test_table;
+CREATE TABLE test_table (id UInt64, value_ipv4 IPv4, value_ipv6 IPv6) ENGINE=MergeTree ORDER BY id;
+
+INSERT INTO test_table VALUES (0, '127.0.0.1', '127.0.0.1');
+
+SELECT id FROM test_table WHERE value_ipv4 IN (SELECT value_ipv4 FROM test_table);
+SELECT id FROM test_table WHERE value_ipv6 IN (SELECT value_ipv6 FROM test_table);
+
+DROP TABLE test_table;