From c3834ee16af015c5d20332dacb77da6d000a9a65 Mon Sep 17 00:00:00 2001
From: jacktengg <tengjianping@selectdb.com>
Date: Mon, 7 Sep 2026 19:02:31 +0800
Subject: [PATCH] [feature](function) Support nanosecond precision for TIMEV2

Issue Number: None

Related PR: None

Problem Summary: Commit 23c83f48bceae6578b55dcfe9cae476b9c15fc8a added TIMESTAMP_NS with 9 fractional digits, but TIMEV2 was capped at scale 6 and time functions converted values through integral microseconds. This truncated submicrosecond results such as TIMEDIFF(TIMESTAMP_NS, TIMESTAMP_NS). Extend TIMEV2 to scale 9 while retaining its existing double microsecond-unit representation, and preserve exact nanoseconds in differences, conversions, formatting, constant folding, external TIME readers, arithmetic, and binary query results.

TIMEV2 supports scales up to 9, and time results such as TIMEDIFF on TIMESTAMP_NS preserve nanosecond precision.

- Test: Unit Test and Regression Test
    - ASAN BE and FE builds passed
    - 26 targeted BE unit tests passed
    - 108 targeted FE unit tests passed
    - Relevant timestamp_ns, TIME function, scalar function, binary protocol, and documentation regression suites passed
- Behavior changed: Yes (TIMEV2 supports nanosecond precision)
- Does this need documentation: No
---
 be/src/core/data_type/data_type_time.h        |   2 +-
 .../data_type_serde/data_type_time_serde.cpp  |  89 ++++---
 be/src/core/value/time_value.h                |  91 +++++--
 be/src/exprs/function/cast/cast_to_date.h     |  63 +----
 be/src/exprs/function/cast/cast_to_string.h   |   2 +-
 .../exprs/function/cast/cast_to_time_impl.hpp | 106 ++++----
 .../function/cast/cast_to_timestamp_ns.h      |  28 ++-
 be/src/exprs/function/date_time_transforms.h  |   5 +-
 .../function_date_or_datetime_computation.h   |  84 +++++--
 .../function/function_other_types_to_date.cpp |  13 +-
 be/src/format/parquet/schema_desc.cpp         |   8 +-
 .../format_v2/parquet/native_schema_desc.cpp  |   7 +-
 be/src/util/date_func.cpp                     |  61 +++--
 .../data_type/data_type_datetime_v2_test.cpp  |   5 +-
 .../data_type_serde_datetime_v2_test.cpp      |  16 ++
 .../data_type_serde_decoded_values_test.cpp   |   9 +
 .../data_type_serde_parquet_test.cpp          |  15 ++
 .../function/cast/cast_timestamp_ns_test.cpp  |  16 ++
 .../exprs/function/cast/cast_to_time_test.cpp |  10 +
 .../function/function_timestamp_ns_test.cpp   |  35 ++-
 .../format/parquet/parquet_thrift_test.cpp    |  45 ++++
 .../format_v2/parquet/parquet_schema_test.cpp |  45 ++++
 be/test/runtime/time_value_test.cpp           |  10 +
 .../apache/doris/analysis/TimeV2Literal.java  |  49 +++-
 .../apache/doris/mysql/MysqlSerializer.java   |  24 +-
 .../executable/DateTimeArithmetic.java        |  16 +-
 .../DateTimeExtractAndTransform.java          |  25 +-
 .../functions/scalar/CurrentTime.java         |   5 +-
 .../functions/scalar/TimeDiff.java            |   3 +-
 .../expressions/functions/scalar/UtcTime.java |   4 +-
 .../literal/TimeStampNsLiteral.java           |   7 +-
 .../expressions/literal/TimeV2Literal.java    | 234 +++++++++---------
 .../apache/doris/nereids/types/DataType.java  |  23 +-
 .../doris/nereids/types/DateTimeV2Type.java   |   2 +-
 .../doris/nereids/types/TimeV2Type.java       |   9 +-
 .../doris/nereids/util/TypeCoercionUtils.java |   9 +-
 .../mysql/MysqlSerializerDateTimeTest.java    |  17 ++
 .../TimestampNsFunctionSignatureTest.java     |   3 +-
 .../literal/TimeStampNsLiteralTest.java       |  11 +-
 .../literal/TimeV2LiteralTest.java            |  27 ++
 .../org/apache/doris/catalog/ScalarType.java  |   1 +
 .../data/correctness/test_time_function.out   |  16 +-
 .../test_timestamp_ns_binary_output.out       |   3 +
 .../test_timestamp_ns_expressions.out         |   6 +-
 .../test_timestamp_ns_functions.out           |  23 +-
 .../sql-functions/doc_date_functions_test.out |  10 +-
 .../nereids_function_p0/scalar_function/T.out | 192 +++++++-------
 .../test_timestamp_ns_binary_output.groovy    |  11 +
 .../test_timestamp_ns_functions.groovy        |  14 ++
 49 files changed, 981 insertions(+), 528 deletions(-)

diff --git a/be/src/core/data_type/data_type_time.h b/be/src/core/data_type/data_type_time.h
index 1a0e083a4ee1c2..f62a50597f2d46 100644
--- a/be/src/core/data_type/data_type_time.h
+++ b/be/src/core/data_type/data_type_time.h
@@ -40,7 +40,7 @@ class IColumn;
 
 class DataTypeTimeV2 final : public DataTypeNumberBase<PrimitiveType::TYPE_TIMEV2> {
 public:
-    static constexpr UInt32 MAX_SCALE = 6;
+    static constexpr UInt32 MAX_SCALE = 9;
 
     DataTypeTimeV2(int scale = 0) : _scale(scale) {
         if (UNLIKELY(scale > static_cast<int>(MAX_SCALE))) {
diff --git a/be/src/core/data_type_serde/data_type_time_serde.cpp b/be/src/core/data_type_serde/data_type_time_serde.cpp
index 566bd3982b4dda..1745c0f1fed1ae 100644
--- a/be/src/core/data_type_serde/data_type_time_serde.cpp
+++ b/be/src/core/data_type_serde/data_type_time_serde.cpp
@@ -20,7 +20,9 @@
 #include <arrow/array.h>
 #include <arrow/type.h>
 
+#include <algorithm>
 #include <limits>
+#include <utility>
 
 #include "common/config.h"
 #include "core/data_type/data_type_decimal.h"
@@ -30,6 +32,7 @@
 #include "core/data_type_serde/decoded_column_view.h"
 #include "core/data_type_serde/parquet_decode_source.h"
 #include "core/value/time_value.h"
+#include "exec/common/int_exp.h"
 #include "exprs/function/cast/cast_base.h"
 #include "exprs/function/cast/cast_to_time_impl.hpp"
 #include "util/unaligned.h"
@@ -37,40 +40,40 @@
 namespace doris {
 namespace {
 
-TimeValue::TimeType read_time_decoded_value(const DecodedColumnView& view, int64_t row) {
-    int64_t micros = 0;
+TimeValue::TimeType time_from_nanoseconds(int64_t nanoseconds, int scale) {
+    const int effective_scale = std::max(scale, static_cast<int>(TimeValue::MICROS_SCALE));
+    const int64_t divisor = common::exp10_i64(TimeValue::NANOS_SCALE - effective_scale);
+    return TimeValue::from_nanoseconds(nanoseconds / divisor * divisor);
+}
+
+TimeValue::TimeType read_time_decoded_value(const DecodedColumnView& view, int64_t row, int scale) {
     if (view.value_kind == DecodedValueKind::INT32) {
         const auto* values = reinterpret_cast<const int32_t*>(view.values);
-        micros = static_cast<int64_t>(values[row]) * 1000;
-    } else {
-        const auto* values = reinterpret_cast<const int64_t*>(view.values);
-        micros = values[row];
-        if (view.time_unit == DecodedTimeUnit::MILLIS) {
-            micros *= 1000;
-        } else if (view.time_unit == DecodedTimeUnit::NANOS) {
-            micros /= 1000;
-        }
+        return static_cast<TimeValue::TimeType>(values[row]) * 1000;
     }
-    const bool negative = micros < 0;
-    const int64_t abs_micros = std::abs(micros);
-    return TimeValue::make_time(
-            abs_micros / TimeValue::ONE_HOUR_MICROSECONDS,
-            (abs_micros % TimeValue::ONE_HOUR_MICROSECONDS) / TimeValue::ONE_MINUTE_MICROSECONDS,
-            (abs_micros % TimeValue::ONE_MINUTE_MICROSECONDS) / TimeValue::ONE_SECOND_MICROSECONDS,
-            abs_micros % TimeValue::ONE_SECOND_MICROSECONDS, negative);
+    const auto* values = reinterpret_cast<const int64_t*>(view.values);
+    if (view.time_unit == DecodedTimeUnit::MILLIS) {
+        return static_cast<TimeValue::TimeType>(values[row]) * 1000;
+    }
+    if (view.time_unit == DecodedTimeUnit::NANOS) {
+        return time_from_nanoseconds(values[row], scale);
+    }
+    return static_cast<TimeValue::TimeType>(values[row]);
 }
 
 class TimeV2ParquetConsumer final : public ParquetFixedValueConsumer {
 public:
-    TimeV2ParquetConsumer(IColumn& column, const ParquetDecodeContext& context,
+    TimeV2ParquetConsumer(IColumn& column, int scale, const ParquetDecodeContext& context,
                           ParquetMaterializationState* state = nullptr)
             : _data(assert_cast<ColumnTimeV2&>(column).get_data()),
+              _scale(scale),
               _context(context),
               _state(state) {}
 
-    TimeV2ParquetConsumer(ColumnTimeV2::Container& data, const ParquetDecodeContext& context,
+    TimeV2ParquetConsumer(ColumnTimeV2::Container& data, int scale,
+                          const ParquetDecodeContext& context,
                           ParquetMaterializationState* state = nullptr)
-            : _data(data), _context(context), _state(state) {}
+            : _data(data), _scale(scale), _context(context), _state(state) {}
 
     Status consume(const uint8_t* values, size_t num_values, size_t value_width) override {
         const size_t old_size = _data.size();
@@ -106,21 +109,20 @@ class TimeV2ParquetConsumer final : public ParquetFixedValueConsumer {
                 return Status::DataQualityError(
                         "Parquet TIME value {} is outside the one-day domain", raw_value);
             }
-            int64_t micros = raw_value;
+            TimeValue::TimeType time = raw_value;
             if (_context.time_unit == ParquetTimeUnit::MILLIS) {
-                micros *= 1000;
+                time *= 1000;
             } else if (_context.time_unit == ParquetTimeUnit::NANOS) {
-                micros /= 1000;
+                time = time_from_nanoseconds(raw_value, _scale);
             }
-            // Doris TIMEV2 stores signed microseconds in a double. Splitting into calendar fields
-            // and immediately recombining them is an identity operation with several divisions.
-            _data[old_size + row] = static_cast<TimeValue::TimeType>(micros);
+            _data[old_size + row] = time;
         }
         return Status::OK();
     }
 
 private:
     ColumnTimeV2::Container& _data;
+    const int _scale;
     const ParquetDecodeContext& _context;
     ParquetMaterializationState* _state;
 };
@@ -134,11 +136,12 @@ class RejectTimeV2BinaryConsumer final : public ParquetBinaryValueConsumer {
 
 class TimeV2PredicateParquetConsumer final : public ParquetFixedValueConsumer {
 public:
-    TimeV2PredicateParquetConsumer(const ParquetDecodeContext& context, bool enable_strict_mode,
-                                   ParquetLogicalValueConsumer& consumer,
+    TimeV2PredicateParquetConsumer(const ParquetDecodeContext& context, int scale,
+                                   bool enable_strict_mode, ParquetLogicalValueConsumer& consumer,
                                    ColumnTimeV2::Container& logical_values,
                                    IColumn::Filter& conversion_nulls)
             : _context(context),
+              _scale(scale),
               _enable_strict_mode(enable_strict_mode),
               _consumer(consumer),
               _logical_values(logical_values),
@@ -151,7 +154,7 @@ class TimeV2PredicateParquetConsumer final : public ParquetFixedValueConsumer {
         ParquetMaterializationState state;
         state.enable_strict_mode = _enable_strict_mode;
         state.conversion_failure_null_map = &_conversion_nulls;
-        TimeV2ParquetConsumer converter(_logical_values, _context, &state);
+        TimeV2ParquetConsumer converter(_logical_values, _scale, _context, &state);
         RETURN_IF_ERROR(converter.consume(values, num_values, value_width));
         return _consumer.consume(reinterpret_cast<const uint8_t*>(_logical_values.data()),
                                  num_values, sizeof(TimeValue::TimeType), _conversion_nulls.data());
@@ -159,6 +162,7 @@ class TimeV2PredicateParquetConsumer final : public ParquetFixedValueConsumer {
 
 private:
     const ParquetDecodeContext& _context;
+    const int _scale;
     bool _enable_strict_mode;
     ParquetLogicalValueConsumer& _consumer;
     ColumnTimeV2::Container& _logical_values;
@@ -173,7 +177,14 @@ Status DataTypeTimeV2SerDe::write_column_to_mysql_binary(const IColumn& column,
                                                          const FormatOptions& options) const {
     const auto& data = assert_cast<const ColumnTimeV2&>(column).get_data();
     const auto col_index = index_check_const(row_idx, col_const);
-    if (UNLIKELY(0 != result.push_timev2(data[col_index], _scale))) {
+    int push_result;
+    if (std::cmp_greater(_scale, TimeValue::MICROS_SCALE)) {
+        const auto value = TimeValue::to_string(data[col_index], _scale);
+        push_result = result.push_string(value.data(), value.size());
+    } else {
+        push_result = result.push_timev2(data[col_index], _scale);
+    }
+    if (UNLIKELY(push_result != 0)) {
         return Status::InternalError("pack mysql buffer failed.");
     }
     return Status::OK();
@@ -365,8 +376,10 @@ Status DataTypeTimeV2SerDe::read_column_from_arrow(IColumn& column, const arrow:
                         "Arrow Time64 value is outside the time-of-day range: row={}, value={}",
                         row, value);
             }
-            const int64_t micros = type->unit() == arrow::TimeUnit::NANO ? value / 1000 : value;
-            data.emplace_back(static_cast<TimeValue::TimeType>(micros));
+            const auto time = type->unit() == arrow::TimeUnit::NANO
+                                      ? time_from_nanoseconds(value, _scale)
+                                      : static_cast<TimeValue::TimeType>(value);
+            data.emplace_back(time);
         }
         return Status::OK();
     }
@@ -391,14 +404,14 @@ Status DataTypeTimeV2SerDe::read_column_from_decoded_values(IColumn& column,
             data.push_back(TimeValue::TimeType());
             continue;
         }
-        data.push_back(read_time_decoded_value(view, row));
+        data.push_back(read_time_decoded_value(view, row, _scale));
     }
     return Status::OK();
 }
 
 Status DataTypeTimeV2SerDe::read_parquet_dictionary(IColumn& column, ParquetDecodeSource& source,
                                                     const ParquetDecodeContext& context) const {
-    TimeV2ParquetConsumer consumer(column, context);
+    TimeV2ParquetConsumer consumer(column, _scale, context);
     RejectTimeV2BinaryConsumer binary_consumer;
     return source.decode_dictionary(consumer, binary_consumer);
 }
@@ -412,14 +425,14 @@ Status DataTypeTimeV2SerDe::read_column_from_parquet(IColumn& column, ParquetDec
         context.logical_type != ParquetLogicalType::TIME) {
         return Status::NotSupported("TIMEV2 expects Parquet TIME stored as INT32 or INT64");
     }
-    TimeV2ParquetConsumer consumer(column, context, &state);
+    TimeV2ParquetConsumer consumer(column, _scale, context, &state);
     if (context.encoding != ParquetValueEncoding::DICTIONARY) {
         return source.decode_fixed_values(num_values, consumer);
     }
     if (state.dictionary_generation != source.dictionary_generation()) {
         state.typed_dictionary = column.clone_empty();
         auto* output_null_map = state.begin_dictionary_conversion(source.dictionary_size());
-        TimeV2ParquetConsumer dictionary_consumer(*state.typed_dictionary, context, &state);
+        TimeV2ParquetConsumer dictionary_consumer(*state.typed_dictionary, _scale, context, &state);
         RejectTimeV2BinaryConsumer binary_consumer;
         const Status dictionary_status =
                 source.decode_dictionary(dictionary_consumer, binary_consumer);
@@ -445,7 +458,7 @@ Status DataTypeTimeV2SerDe::read_parquet_raw_predicate(
     if (!supports_parquet_raw_predicate(context)) {
         return Status::NotSupported("Unsupported Parquet raw predicate conversion for TIMEV2");
     }
-    TimeV2PredicateParquetConsumer predicate_consumer(context, enable_strict_mode, consumer,
+    TimeV2PredicateParquetConsumer predicate_consumer(context, _scale, enable_strict_mode, consumer,
                                                       _parquet_predicate_values,
                                                       _parquet_predicate_nulls);
     return source.decode_fixed_values(num_values, predicate_consumer);
diff --git a/be/src/core/value/time_value.h b/be/src/core/value/time_value.h
index 292151fb95e2e2..1dcdfab9df8588 100644
--- a/be/src/core/value/time_value.h
+++ b/be/src/core/value/time_value.h
@@ -39,9 +39,13 @@ class TimeValue {
     constexpr static int64_t ONE_SECOND_MICROSECONDS = 1000000;
     constexpr static int64_t ONE_MINUTE_MICROSECONDS = 60 * ONE_SECOND_MICROSECONDS;
     constexpr static int64_t ONE_HOUR_MICROSECONDS = 60 * ONE_MINUTE_MICROSECONDS;
+    constexpr static int64_t NANOS_PER_MICROSECOND = 1000;
+    constexpr static int64_t ONE_SECOND_NANOSECONDS =
+            ONE_SECOND_MICROSECONDS * NANOS_PER_MICROSECOND;
     constexpr static int64_t ONE_MINUTE_SECONDS = 60;
     constexpr static int64_t ONE_HOUR_SECONDS = 60 * ONE_MINUTE_SECONDS;
     constexpr static uint32_t MICROS_SCALE = 6;
+    constexpr static uint32_t NANOS_SCALE = 9;
     constexpr static int64_t MAX_TIME = 838 * ONE_HOUR_MICROSECONDS + 59 * ONE_MINUTE_MICROSECONDS +
                                         59 * ONE_SECOND_MICROSECONDS; // 838:59:59.000000
 
@@ -50,13 +54,13 @@ class TimeValue {
     using ColumnTimeV2 = typename PrimitiveTypeTraits<TYPE_TIMEV2>::ColumnType;
 
 #include "common/compile_check_avoid_begin.h"
-    static int64_t round_time(TimeType value, uint32_t scale) {
-        int64_t time = value;
-        DCHECK(scale <= MICROS_SCALE);
-        int64_t factor = std::pow(10, 6 - scale);
-        int64_t roundedValue = (time >= 0) ? (time + factor / 2) / factor * factor
-                                           : (time - factor / 2) / factor * factor;
-        return roundedValue;
+    static TimeType round_time(TimeType value, uint32_t scale) {
+        DCHECK(scale <= NANOS_SCALE);
+        int64_t time = to_nanoseconds(value);
+        int64_t factor = std::pow(10, NANOS_SCALE - scale);
+        int64_t rounded_value = (time >= 0) ? (time + factor / 2) / factor * factor
+                                            : (time - factor / 2) / factor * factor;
+        return from_nanoseconds(rounded_value);
     }
 
     // Construct time based on hour/minute/second/microsecond
@@ -80,6 +84,27 @@ class TimeValue {
         return static_cast<TimeType>(negative ? -value : value);
     }
 
+    // Construct time based on hour/minute/second/nanosecond.
+    template <bool CHECK = false>
+    static TimeType make_time_from_nanoseconds(int64_t hour, int64_t minute, int64_t second,
+                                               int64_t nanosecond = 0, bool negative = false) {
+        if constexpr (CHECK) {
+            if (std::abs(hour) > 838 || std::abs(minute) >= 60 || std::abs(second) >= 60 ||
+                std::abs(nanosecond) >= ONE_SECOND_NANOSECONDS) [[unlikely]] {
+                throw Exception(ErrorCode::INVALID_ARGUMENT,
+                                "Invalid time value: hour={}, minute={}, second={}, nanosecond={}",
+                                hour, minute, second, nanosecond);
+            }
+        }
+        DCHECK(hour >= 0 && minute >= 0 && second >= 0 && nanosecond >= 0)
+                << "Hour, minute, second and nanosecond must be non-negative but got " << hour
+                << ":" << minute << ":" << second << "." << nanosecond;
+        const int64_t value = ((hour * ONE_HOUR_SECONDS) + (minute * ONE_MINUTE_SECONDS) + second) *
+                                      ONE_SECOND_NANOSECONDS +
+                              nanosecond;
+        return from_nanoseconds(negative ? -value : value);
+    }
+
     // if time is negative, ms should be negative too. in existing scenario, we ensure microsecond's bound by caller.
     static TimeType init_microsecond(TimeType time, int32_t microsecond) {
         DCHECK(std::signbit(time) == std::signbit(microsecond) || !time || !microsecond)
@@ -88,6 +113,14 @@ class TimeValue {
 
         return static_cast<TimeType>(time + microsecond);
     }
+
+    // If time is negative, nanosecond should be negative too. Callers validate its bound.
+    static TimeType init_nanosecond(TimeType time, int64_t nanosecond) {
+        DCHECK(std::signbit(time) == std::signbit(nanosecond) || !time || !nanosecond)
+                << "Time and nanosecond must have the same sign but got " << time << " and "
+                << nanosecond;
+        return time + static_cast<TimeType>(nanosecond) / NANOS_PER_MICROSECOND;
+    }
 #include "common/compile_check_avoid_end.h"
 
     // in existing scenario, we ensure microsecond's bound by caller.
@@ -107,25 +140,45 @@ class TimeValue {
 
     /// Return the hour/minute/second part of the time, ignoring the sign
     static int32_t hour(TimeType time) {
-        return (int32_t)std::abs(
-                static_cast<int64_t>(limit_with_bound(time) / ONE_HOUR_MICROSECONDS));
+        return static_cast<int32_t>(
+                std::abs(to_nanoseconds(time) / (ONE_HOUR_MICROSECONDS * NANOS_PER_MICROSECOND)));
     }
 
     static int32_t minute(TimeType time) {
-        return (int32_t)std::abs(
-                (static_cast<int64_t>(limit_with_bound(time)) % ONE_HOUR_MICROSECONDS) /
-                ONE_MINUTE_MICROSECONDS);
+        return static_cast<int32_t>(
+                std::abs((to_nanoseconds(time) % (ONE_HOUR_MICROSECONDS * NANOS_PER_MICROSECOND)) /
+                         (ONE_MINUTE_MICROSECONDS * NANOS_PER_MICROSECOND)));
     }
 
     static int32_t second(TimeType time) {
-        return (int32_t)std::abs(
-                (static_cast<int64_t>(limit_with_bound(time)) / ONE_SECOND_MICROSECONDS) %
-                ONE_MINUTE_SECONDS);
+        return static_cast<int32_t>(
+                std::abs((to_nanoseconds(time) / ONE_SECOND_NANOSECONDS) % ONE_MINUTE_SECONDS));
     }
 
-    static int32_t microsecond(TimeType time) {
-        return (int32_t)std::abs(static_cast<int64_t>(limit_with_bound(time)) %
-                                 ONE_SECOND_MICROSECONDS);
+    static int32_t microsecond(TimeType time) { return nanosecond(time) / NANOS_PER_MICROSECOND; }
+
+    static int32_t nanosecond(TimeType time) {
+        return static_cast<int32_t>(std::abs(to_nanoseconds(time) % ONE_SECOND_NANOSECONDS));
+    }
+
+    static int64_t to_nanoseconds(TimeType time) {
+        return std::llround(limit_with_bound(time) * NANOS_PER_MICROSECOND);
+    }
+
+    static TimeType from_nanoseconds(int64_t nanoseconds) {
+        return static_cast<TimeType>(nanoseconds) / NANOS_PER_MICROSECOND;
+    }
+
+    static TimeType from_nanoseconds_with_limit(__int128 nanoseconds) {
+        constexpr __int128 max_time_nanoseconds =
+                static_cast<__int128>(MAX_TIME) * NANOS_PER_MICROSECOND;
+        if (nanoseconds > max_time_nanoseconds) {
+            return MAX_TIME;
+        }
+        if (nanoseconds < -max_time_nanoseconds) {
+            return -MAX_TIME;
+        }
+        return from_nanoseconds(static_cast<int64_t>(nanoseconds));
     }
 
     static int8_t sign(TimeType time) { return (time < 0) ? -1 : 1; }
@@ -167,7 +220,7 @@ class TimeValue {
         return DatetimeValueUtil::to_format_string_without_check<true>(
                 format, len, to, max_valid_length, 0, 0, 0, TimeValue::hour(time),
                 TimeValue::minute(time), TimeValue::second(time), TimeValue::microsecond(time),
-                nanosecond);
+                nanosecond < 0 ? TimeValue::nanosecond(time) : nanosecond);
     }
 };
 } // namespace doris
diff --git a/be/src/exprs/function/cast/cast_to_date.h b/be/src/exprs/function/cast/cast_to_date.h
index 903ef17083aa6b..f8e84197ec691c 100644
--- a/be/src/exprs/function/cast/cast_to_date.h
+++ b/be/src/exprs/function/cast/cast_to_date.h
@@ -165,31 +165,14 @@ class CastToImpl<CastMode, FromDataType, ToDataType> : public CastToBase {
             } else {
                 static_assert(IsTimeV2Type<ToDataType>);
                 const auto to_scale = block.get_by_position(result).type->get_scale();
-                const int64_t seconds = source.time_part_to_seconds();
-                uint32_t hour = static_cast<uint32_t>(seconds / 3600);
-                uint32_t minute = static_cast<uint32_t>(seconds / 60 % 60);
-                uint32_t second = static_cast<uint32_t>(seconds % 60);
-                uint32_t nanoseconds = source.nanosecond();
-                const auto divisor = static_cast<uint32_t>(common::exp10_i64(9 - to_scale));
-                const uint32_t remainder = nanoseconds % divisor;
-                nanoseconds = nanoseconds / divisor * divisor;
-                if (remainder >= divisor / 2) {
+                int64_t nanoseconds = source.time_part_to_nanosecond();
+                const int64_t divisor = common::exp10_i64(9 - to_scale);
+                const int64_t remainder = nanoseconds % divisor;
+                nanoseconds -= remainder;
+                if (remainder * 2 >= divisor) {
                     nanoseconds += divisor;
                 }
-                uint32_t microseconds = nanoseconds / TimeStampNsValue::NANOS_PER_MICROSECOND;
-                if (microseconds >= TimeValue::ONE_SECOND_MICROSECONDS) {
-                    microseconds = 0;
-                    if (++second == 60) {
-                        second = 0;
-                        if (++minute == 60) {
-                            minute = 0;
-                            ++hour;
-                        }
-                    }
-                }
-                col_to->get_data()[i] =
-                        ((hour * 60 + minute) * 60 + second) * TimeValue::ONE_SECOND_MICROSECONDS +
-                        microseconds;
+                col_to->get_data()[i] = TimeValue::from_nanoseconds(nanoseconds);
             }
         }
 
@@ -309,7 +292,7 @@ class CastToImpl<CastMode, FromDataType, ToDataType> : public CastToBase {
             } else if constexpr (IsTimeV2Type<FromDataType> && IsDateTimeV2Type<ToDataType>) {
                 const auto* type = assert_cast<const DataTypeTimeV2*>(
                         block.get_by_position(arguments[0]).type.get());
-                auto scale = type->get_scale();
+                auto scale = std::min(type->get_scale(), TimeValue::MICROS_SCALE);
 
                 DateV2Value<DateTimeV2ValueType> dtmv2;
                 dtmv2.from_unixtime(context->state()->timestamp_ms() / 1000,
@@ -385,35 +368,9 @@ class CastToImpl<CastMode, FromDataType, ToDataType> : public CastToBase {
                     // nothing to do, just copy
                     col_to->get_data()[i] = col_from->get_data()[i];
                 } else {
-                    double time = col_from->get_data()[i];
-                    auto sign = TimeValue::sign(time);
-                    time = std::abs(time);
-                    // e.g. scale reduce to 4, means we need to round the last 2 digits
-                    // 999956: 56 > 100/2, then round up to 1000000
-                    uint32_t microseconds = TimeValue::microsecond(time);
-                    auto divisor = (uint32_t)common::exp10_i64(6 - to_scale);
-                    uint32_t remainder = microseconds % divisor;
-
-                    if (remainder >= divisor / 2) { // need to round up
-                        // do rounding up
-                        uint32_t rounded_microseconds = ((microseconds / divisor) + 1) * divisor;
-                        // need carry on
-                        if (rounded_microseconds >= TimeValue::ONE_SECOND_MICROSECONDS) {
-                            DCHECK(rounded_microseconds == TimeValue::ONE_SECOND_MICROSECONDS);
-                            time = ((int64_t)time / TimeValue::ONE_SECOND_MICROSECONDS + 1) *
-                                   TimeValue::ONE_SECOND_MICROSECONDS;
-
-                            // the input data must be valid, so max to '838:59:59.0'. this value won't carry on
-                            // to second.
-                            DCHECK(TimeValue::valid(time)) << col_from->get_data()[i];
-                        } else {
-                            time = TimeValue::reset_microsecond(time, rounded_microseconds);
-                        }
-                    } else {
-                        // truncate
-                        time = TimeValue::reset_microsecond(time, microseconds / divisor * divisor);
-                    }
-                    col_to->get_data()[i] = sign * time;
+                    const auto time = TimeValue::round_time(col_from->get_data()[i], to_scale);
+                    DCHECK(TimeValue::valid(time)) << col_from->get_data()[i];
+                    col_to->get_data()[i] = time;
                 }
             } else if constexpr (IsDateTimeV2Type<FromDataType> && IsTimeV2Type<ToDataType>) {
                 // from Datetime to Time
diff --git a/be/src/exprs/function/cast/cast_to_string.h b/be/src/exprs/function/cast/cast_to_string.h
index 3e4e188b7ccf90..1a1f82dba1da79 100644
--- a/be/src/exprs/function/cast/cast_to_string.h
+++ b/be/src/exprs/function/cast/cast_to_string.h
@@ -160,7 +160,7 @@ template <>
 constexpr size_t CastToString::string_length<TYPE_DATETIMEV2> =
         sizeof("YYYY-MM-DD HH:MM:SS.ssssss") - 1;
 template <>
-constexpr size_t CastToString::string_length<TYPE_TIMEV2> = sizeof("-838:59:59.999999") - 1;
+constexpr size_t CastToString::string_length<TYPE_TIMEV2> = sizeof("-838:59:59.999999999") - 1;
 template <>
 constexpr size_t CastToString::string_length<TYPE_IPV4> = sizeof("255.255 .255.255") - 1;
 template <>
diff --git a/be/src/exprs/function/cast/cast_to_time_impl.hpp b/be/src/exprs/function/cast/cast_to_time_impl.hpp
index 475c91d8bd0486..c6952c382daac8 100644
--- a/be/src/exprs/function/cast/cast_to_time_impl.hpp
+++ b/be/src/exprs/function/cast/cast_to_time_impl.hpp
@@ -20,6 +20,7 @@
 #include <sys/types.h>
 
 #include <type_traits>
+#include <utility>
 
 #include "core/data_type/data_type_decimal.h" // IWYU pragma: keep
 #include "core/data_type/primitive_type.h"
@@ -34,11 +35,10 @@ namespace doris {
 // NOLINTBEGIN(readability-function-cognitive-complexity)
 
 template <DatelikeParseMode ParseMode>
-[[nodiscard]] [[maybe_unused]] static bool init_microsecond(int64_t frac_input,
-                                                            uint32_t frac_length,
-                                                            TimeValue::TimeType& val,
-                                                            uint32_t target_scale,
-                                                            CastParameters& params) {
+[[nodiscard]] [[maybe_unused]] static bool init_nanosecond(int64_t frac_input, uint32_t frac_length,
+                                                           TimeValue::TimeType& val,
+                                                           uint32_t target_scale,
+                                                           CastParameters& params) {
     constexpr bool IsStrict = is_datelike_parse_strict(ParseMode);
     if (frac_length > 0) {
         int sign = 1;
@@ -54,14 +54,14 @@ template <DatelikeParseMode ParseMode>
                         ? (uint32_t)(frac_input / common::exp10_i64(frac_length - target_scale))
                         : (uint32_t)(frac_input * common::exp10_i64(target_scale - frac_length));
 
-        if (frac_length > target_scale) { // to_scale is up to 6
+        if (frac_length > target_scale) {
             // round off to at most `to_scale` digits
             auto digit_next =
                     (uint32_t)(frac_input / common::exp10_i64(frac_length - target_scale - 1)) % 10;
             if (digit_next >= 5) {
                 in_scale_part++;
-                DCHECK(in_scale_part <= 1000000);
-                if (in_scale_part == common::exp10_i32(target_scale)) {
+                DCHECK(in_scale_part <= TimeValue::ONE_SECOND_NANOSECONDS);
+                if (std::cmp_equal(in_scale_part, common::exp10_i32(target_scale))) {
                     // overflow, round up to next second
                     val += sign * TimeValue::ONE_SECOND_MICROSECONDS;
                     SET_PARAMS_RET_FALSE_IFN(TimeValue::valid(val),
@@ -70,8 +70,8 @@ template <DatelikeParseMode ParseMode>
                 }
             }
         }
-        val = TimeValue::init_microsecond(
-                val, sign * in_scale_part * common::exp10_i32(6 - (int)target_scale));
+        val = TimeValue::init_nanosecond(
+                val, sign * in_scale_part * common::exp10_i32(9 - (int)target_scale));
     }
     return true;
 }
@@ -127,10 +127,12 @@ struct CastToTimeV2 {
         }
 
 #include "common/compile_check_avoid_begin.h"
-        int ms_part_7 = (float_value - (double)int_part) * common::exp10_i32(7);
+        int64_t ns_part_10 =
+                (float_value - (double)int_part) * common::exp10_i64(TimeValue::NANOS_SCALE + 1);
 #include "common/compile_check_avoid_end.h"
-        if (!init_microsecond<ParseMode>(ms_part_7, 7, val, to_scale, params)) {
-            return false; // status set in init_microsecond
+        if (!init_nanosecond<ParseMode>(ns_part_10, TimeValue::NANOS_SCALE + 1, val, to_scale,
+                                        params)) {
+            return false; // status set in init_nanosecond
         }
         return true;
     }
@@ -163,9 +165,9 @@ struct CastToTimeV2 {
             return false;
         }
 
-        if (!init_microsecond<ParseMode>((int64_t)frac_part, (uint32_t)decimal_scale, res, to_scale,
-                                         params)) {
-            return false; // status set in init_microsecond
+        if (!init_nanosecond<ParseMode>((int64_t)frac_part, (uint32_t)decimal_scale, res, to_scale,
+                                        params)) {
+            return false; // status set in init_nanosecond
         }
         return true;
     }
@@ -233,14 +235,14 @@ inline bool CastToTimeV2::from_integer(T input, TimeValue::TimeType& val, CastPa
 /**
 <time> ::= ("+" | "-")? (<colon-format> | <numeric-format>)
 
-<colon-format> ::= <hour> ":" <minute> (":" <second> (<microsecond>)?)?
+<colon-format> ::= <hour> ":" <minute> (":" <second> (<nanosecond>)?)?
 <hour> ::= <digit>+
 <minute> ::= <digit>{1,2}
 <second> ::= <digit>{1,2}
 
-<numeric-format> ::= <digit>+ (<microsecond>)?
+<numeric-format> ::= <digit>+ (<nanosecond>)?
 
-<microsecond> ::= "." <digit>*
+<nanosecond> ::= "." <digit>*
 
 <digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
 */
@@ -268,7 +270,7 @@ inline bool CastToTimeV2::from_string_strict_mode(const StringRef& str, TimeValu
 
     // Two possible formats: colon-format or numeric-format
     uint32_t hour = 0, minute = 0, second = 0;
-    uint32_t microsecond = 0;
+    uint32_t nanosecond = 0;
 
     // Check if we have colon format by looking ahead
     const char* temp = ptr;
@@ -308,7 +310,7 @@ inline bool CastToTimeV2::from_string_strict_mode(const StringRef& str, TimeValu
                                      std::string {ptr, end});
             SET_PARAMS_RET_FALSE_IFN(second < 60, "invalid second {}", second);
 
-            // Check if we have microseconds
+            // Check if we have nanoseconds
             if (ptr < end && *ptr == '.') {
                 ++ptr;
 
@@ -323,11 +325,11 @@ inline bool CastToTimeV2::from_string_strict_mode(const StringRef& str, TimeValu
                                              "invalid fractional part in time string '{}'",
                                              std::string {start, ptr});
 
-                    if (length > to_scale) { // to_scale is up to 6
+                    if (std::cmp_greater(length, to_scale)) {
                         // round off to at most `to_scale` digits
                         if (*(ms_start + to_scale) - '0' >= 5) {
                             frac_literal++;
-                            DCHECK(frac_literal <= 1000000);
+                            DCHECK(frac_literal <= TimeValue::ONE_SECOND_NANOSECONDS);
                             if (frac_literal == common::exp10_i32(to_scale)) {
                                 // overflow, round up to next second
                                 second++;
@@ -342,9 +344,9 @@ inline bool CastToTimeV2::from_string_strict_mode(const StringRef& str, TimeValu
                                 frac_literal = 0;
                             }
                         }
-                        microsecond = frac_literal * common::exp10_i32(6 - (int)to_scale);
+                        nanosecond = frac_literal * common::exp10_i32(9 - (int)to_scale);
                     } else {
-                        microsecond = frac_literal * common::exp10_i32(6 - (int)length);
+                        nanosecond = frac_literal * common::exp10_i32(9 - (int)length);
                     }
                 }
             }
@@ -381,7 +383,7 @@ inline bool CastToTimeV2::from_string_strict_mode(const StringRef& str, TimeValu
             SET_PARAMS_RET_FALSE_IFN(second < 60, "invalid second {}", second);
         }
 
-        // Check if we have microseconds
+        // Check if we have nanoseconds
         if (ptr < end && *ptr == '.') {
             ++ptr;
 
@@ -396,11 +398,11 @@ inline bool CastToTimeV2::from_string_strict_mode(const StringRef& str, TimeValu
                                          "invalid fractional part in time string '{}'",
                                          std::string {start, ptr});
 
-                if (length > to_scale) { // to_scale is up to 6
+                if (std::cmp_greater(length, to_scale)) {
                     // round off to at most `to_scale` digits
                     if (*(ms_start + to_scale) - '0' >= 5) {
                         frac_literal++;
-                        DCHECK(frac_literal <= 1000000);
+                        DCHECK(frac_literal <= TimeValue::ONE_SECOND_NANOSECONDS);
                         if (frac_literal == common::exp10_i32(to_scale)) {
                             // overflow, round up to next second
                             second++;
@@ -415,9 +417,9 @@ inline bool CastToTimeV2::from_string_strict_mode(const StringRef& str, TimeValu
                             frac_literal = 0;
                         }
                     }
-                    microsecond = frac_literal * common::exp10_i32(6 - (int)to_scale);
+                    nanosecond = frac_literal * common::exp10_i32(9 - (int)to_scale);
                 } else {
-                    microsecond = frac_literal * common::exp10_i32(6 - (int)length);
+                    nanosecond = frac_literal * common::exp10_i32(9 - (int)length);
                 }
             }
         }
@@ -427,25 +429,25 @@ inline bool CastToTimeV2::from_string_strict_mode(const StringRef& str, TimeValu
     SET_PARAMS_RET_FALSE_IFN(ptr == end, "invalid time string '{}', extra characters after parsing",
                              std::string {ptr, end});
 
-    // Convert to TimeValue's internal storage format (microseconds since 00:00:00)
-    SET_PARAMS_RET_FALSE_FROM_EXCEPTION(
-            res = TimeValue::make_time<true>(hour, minute, second, microsecond, negative));
+    // Convert to TimeValue's internal storage format (nanoseconds since 00:00:00)
+    SET_PARAMS_RET_FALSE_FROM_EXCEPTION(res = TimeValue::make_time_from_nanoseconds<true>(
+                                                hour, minute, second, nanosecond, negative));
     SET_PARAMS_RET_FALSE_IFN(TimeValue::valid(res), "invalid time value: {}:{}:{}.{}", hour, minute,
-                             second, microsecond);
+                             second, nanosecond);
     return true;
 }
 
 /**
 <time> ::= <whitespace>* ("+" | "-")? (<colon-format> | <numeric-format>) <whitespace>*
 
-<colon-format> ::= <hour> ":" <minute> (":" <second> (<microsecond>)?)?
+<colon-format> ::= <hour> ":" <minute> (":" <second> (<nanosecond>)?)?
 <hour> ::= <digit>+
 <minute> ::= <digit>{1,2}
 <second> ::= <digit>{1,2}
 
-<numeric-format> ::= <digit>+ (<microsecond>)?
+<numeric-format> ::= <digit>+ (<nanosecond>)?
 
-<microsecond> ::= "." <digit>*
+<nanosecond> ::= "." <digit>*
 
 <digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
 <whitespace> ::= " " | "\t" | "\n" | "\r" | "\v" | "\f"
@@ -476,7 +478,7 @@ inline bool CastToTimeV2::from_string_non_strict_mode_impl(const StringRef& str,
 
     // Two possible formats: colon-format or numeric-format
     uint32_t hour = 0, minute = 0, second = 0;
-    uint32_t microsecond = 0;
+    uint32_t nanosecond = 0;
 
     // Check if we have colon format by looking ahead
     const char* temp = ptr;
@@ -512,7 +514,7 @@ inline bool CastToTimeV2::from_string_non_strict_mode_impl(const StringRef& str,
             PROPAGATE_FALSE((consume_digit<uint32_t, 1, 2>(ptr, end, second)));
             SET_PARAMS_RET_FALSE_IFN(second < 60, "invalid second {}", second);
 
-            // Check if we have microseconds
+            // Check if we have nanoseconds
             if (ptr < end && *ptr == '.') {
                 ++ptr;
 
@@ -527,11 +529,11 @@ inline bool CastToTimeV2::from_string_non_strict_mode_impl(const StringRef& str,
                                              "invalid fractional part in time string '{}'",
                                              std::string {start, ptr});
 
-                    if (length > to_scale) { // to_scale is up to 6
+                    if (std::cmp_greater(length, to_scale)) {
                         // round off to at most `to_scale` digits
                         if (*(ms_start + to_scale) - '0' >= 5) {
                             frac_literal++;
-                            DCHECK(frac_literal <= 1000000);
+                            DCHECK(frac_literal <= TimeValue::ONE_SECOND_NANOSECONDS);
                             if (frac_literal == common::exp10_i32(to_scale)) {
                                 // overflow, round up to next second
                                 second++;
@@ -546,9 +548,9 @@ inline bool CastToTimeV2::from_string_non_strict_mode_impl(const StringRef& str,
                                 frac_literal = 0;
                             }
                         }
-                        microsecond = frac_literal * common::exp10_i32(6 - (int)to_scale);
+                        nanosecond = frac_literal * common::exp10_i32(9 - (int)to_scale);
                     } else {
-                        microsecond = frac_literal * common::exp10_i32(6 - (int)length);
+                        nanosecond = frac_literal * common::exp10_i32(9 - (int)length);
                     }
                 }
             }
@@ -585,7 +587,7 @@ inline bool CastToTimeV2::from_string_non_strict_mode_impl(const StringRef& str,
             SET_PARAMS_RET_FALSE_IFN(second < 60, "invalid second {}", second);
         }
 
-        // Check if we have microseconds
+        // Check if we have nanoseconds
         if (ptr < end && *ptr == '.') {
             ++ptr;
 
@@ -600,11 +602,11 @@ inline bool CastToTimeV2::from_string_non_strict_mode_impl(const StringRef& str,
                                          "invalid fractional part in time string '{}'",
                                          std::string {start, ptr});
 
-                if (length > to_scale) { // to_scale is up to 6
+                if (std::cmp_greater(length, to_scale)) {
                     // round off to at most `to_scale` digits
                     if (*(ms_start + to_scale) - '0' >= 5) {
                         frac_literal++;
-                        DCHECK(frac_literal <= 1000000);
+                        DCHECK(frac_literal <= TimeValue::ONE_SECOND_NANOSECONDS);
                         if (frac_literal == common::exp10_i32(to_scale)) {
                             // overflow, round up to next second
                             second++;
@@ -619,9 +621,9 @@ inline bool CastToTimeV2::from_string_non_strict_mode_impl(const StringRef& str,
                             frac_literal = 0;
                         }
                     }
-                    microsecond = frac_literal * common::exp10_i32(6 - (int)to_scale);
+                    nanosecond = frac_literal * common::exp10_i32(9 - (int)to_scale);
                 } else {
-                    microsecond = frac_literal * common::exp10_i32(6 - (int)length);
+                    nanosecond = frac_literal * common::exp10_i32(9 - (int)length);
                 }
             }
         }
@@ -632,11 +634,11 @@ inline bool CastToTimeV2::from_string_non_strict_mode_impl(const StringRef& str,
     SET_PARAMS_RET_FALSE_IFN(ptr == end, "invalid time string '{}', extra characters after parsing",
                              std::string {ptr, end});
 
-    // Convert to TimeValue's internal storage format (microseconds since 00:00:00)
-    SET_PARAMS_RET_FALSE_FROM_EXCEPTION(
-            res = TimeValue::make_time<true>(hour, minute, second, microsecond, negative));
+    // Convert to TimeValue's internal storage format (nanoseconds since 00:00:00)
+    SET_PARAMS_RET_FALSE_FROM_EXCEPTION(res = TimeValue::make_time_from_nanoseconds<true>(
+                                                hour, minute, second, nanosecond, negative));
     SET_PARAMS_RET_FALSE_IFN(TimeValue::valid(res), "invalid time value: {}:{}:{}.{}", hour, minute,
-                             second, microsecond);
+                             second, nanosecond);
     return true;
 }
 
diff --git a/be/src/exprs/function/cast/cast_to_timestamp_ns.h b/be/src/exprs/function/cast/cast_to_timestamp_ns.h
index 2ba379d940b979..a807063f0dc793 100644
--- a/be/src/exprs/function/cast/cast_to_timestamp_ns.h
+++ b/be/src/exprs/function/cast/cast_to_timestamp_ns.h
@@ -319,7 +319,8 @@ class CastToImpl<CastMode, FromDataType, DataTypeTimeStampNs> : public CastToBas
                 datetime = col_from.get_data()[i];
             } else {
                 static_assert(IsTimeV2Type<FromDataType>);
-                const auto scale = block.get_by_position(arguments[0]).type->get_scale();
+                const auto scale = std::min(block.get_by_position(arguments[0]).type->get_scale(),
+                                            TimeValue::MICROS_SCALE);
                 datetime.from_unixtime(context->state()->timestamp_ms() / 1000,
                                        context->state()->nano_seconds(),
                                        context->state()->timezone_obj(), scale);
@@ -345,6 +346,16 @@ class CastToImpl<CastMode, FromDataType, DataTypeTimeStampNs> : public CastToBas
                 }
                 col_nullmap->get_data()[i] = true;
             }
+            if constexpr (IsTimeV2Type<FromDataType>) {
+                if (!add_submicrosecond_part(col_from.get_data()[i], col_to->get_data()[i])) {
+                    if constexpr (CastMode == CastModeType::StrictMode) {
+                        return Status::InvalidArgument(
+                                "TIMESTAMP_NS overflow when casting row {} from {} to TIMESTAMP_NS",
+                                i, block.get_by_position(arguments[0]).type->get_name());
+                    }
+                    col_nullmap->get_data()[i] = true;
+                }
+            }
         }
 
         if constexpr (CastMode == CastModeType::StrictMode) {
@@ -355,6 +366,21 @@ class CastToImpl<CastMode, FromDataType, DataTypeTimeStampNs> : public CastToBas
         }
         return Status::OK();
     }
+
+private:
+    static bool add_submicrosecond_part(TimeValue::TimeType time_value,
+                                        TimeStampNsValue& timestamp) {
+        const int64_t remainder =
+                TimeValue::nanosecond(time_value) % TimeValue::NANOS_PER_MICROSECOND;
+        const __int128 epoch_nanos = static_cast<__int128>(timestamp.epoch_nanos()) +
+                                     TimeValue::sign(time_value) * remainder;
+        if (epoch_nanos < std::numeric_limits<int64_t>::min() ||
+            epoch_nanos > std::numeric_limits<int64_t>::max()) [[unlikely]] {
+            return false;
+        }
+        timestamp = TimeStampNsValue(static_cast<int64_t>(epoch_nanos));
+        return true;
+    }
 };
 
 template <CastModeType CastMode>
diff --git a/be/src/exprs/function/date_time_transforms.h b/be/src/exprs/function/date_time_transforms.h
index 3d738330584a9c..3f8ac528783125 100644
--- a/be/src/exprs/function/date_time_transforms.h
+++ b/be/src/exprs/function/date_time_transforms.h
@@ -846,8 +846,7 @@ class FunctionTimeFormat : public IFunction {
                     return TimeValue::to_format_string_conservative(
                             format.data, format.size, buf, 100 + SAFE_FORMAT_STRING_MARGIN, time,
                             datetime_val.nanosecond());
-                } else if constexpr (ArgPType == PrimitiveType::TYPE_DATETIMEV2 ||
-                                     ArgPType == PrimitiveType::TYPE_TIMEV2) {
+                } else if constexpr (ArgPType == PrimitiveType::TYPE_DATETIMEV2) {
                     return TimeValue::to_format_string_conservative(
                             format.data, format.size, buf, 100 + SAFE_FORMAT_STRING_MARGIN, time,
                             TimeValue::microsecond(time) * 1000);
@@ -874,7 +873,7 @@ class FunctionTimeFormat : public IFunction {
         if constexpr (ArgPType == PrimitiveType::TYPE_TIMEV2) {
             return static_cast<TimeValue::TimeType>(datetime_val);
         } else if constexpr (ArgPType == PrimitiveType::TYPE_TIMESTAMP_NS) {
-            return static_cast<TimeValue::TimeType>(datetime_val.time_part_to_microsecond());
+            return TimeValue::from_nanoseconds(datetime_val.time_part_to_nanosecond());
         } else {
             return TimeValue::make_time(datetime_val.hour(), datetime_val.minute(),
                                         datetime_val.second(), datetime_val.microsecond());
diff --git a/be/src/exprs/function/function_date_or_datetime_computation.h b/be/src/exprs/function/function_date_or_datetime_computation.h
index 9743ef79c55cc1..e836f4b6f5567b 100644
--- a/be/src/exprs/function/function_date_or_datetime_computation.h
+++ b/be/src/exprs/function/function_date_or_datetime_computation.h
@@ -672,7 +672,11 @@ struct TimeDiffImpl {
     static inline DataTypeTimeV2::FieldType execute(const ArgType& t0, const ArgType& t1) {
         const auto& ts0 = reinterpret_cast<const ValueType&>(t0);
         const auto& ts1 = reinterpret_cast<const ValueType&>(t1);
-        if constexpr (UsingTimev2) {
+        if constexpr (DateType == TYPE_TIMESTAMP_NS) {
+            const __int128 difference =
+                    static_cast<__int128>(ts0.epoch_nanos()) - ts1.epoch_nanos();
+            return TimeValue::from_nanoseconds_with_limit(difference);
+        } else if constexpr (UsingTimev2) {
             int64_t diff_m = ts0.datetime_diff_in_microseconds(ts1);
             return TimeValue::limit_with_bound(diff_m);
         } else {
@@ -710,7 +714,37 @@ struct MixedTimeDiffImpl : TimeDiffImpl<LeftType> {
                                                     const RightFieldType& right) {
         const auto& left_value = reinterpret_cast<const LeftValueType&>(left);
         const auto& right_value = reinterpret_cast<const RightValueType&>(right);
-        return TimeValue::limit_with_bound(left_value.datetime_diff_in_microseconds(right_value));
+        const auto left_datetime = [&] {
+            if constexpr (LeftType == TYPE_TIMESTAMP_NS) {
+                return left_value.to_datetime();
+            } else {
+                return left_value;
+            }
+        }();
+        const auto right_datetime = [&] {
+            if constexpr (RightType == TYPE_TIMESTAMP_NS) {
+                return right_value.to_datetime();
+            } else {
+                return right_value;
+            }
+        }();
+        const uint32_t left_nanosecond = [&] {
+            if constexpr (LeftType == TYPE_TIMESTAMP_NS) {
+                return left_value.nanosecond();
+            } else {
+                return left_value.microsecond() * TimeValue::NANOS_PER_MICROSECOND;
+            }
+        }();
+        const uint32_t right_nanosecond = [&] {
+            if constexpr (RightType == TYPE_TIMESTAMP_NS) {
+                return right_value.nanosecond();
+            } else {
+                return right_value.microsecond() * TimeValue::NANOS_PER_MICROSECOND;
+            }
+        }();
+        const __int128 difference = datetime_diff_in_nanoseconds(right_datetime, right_nanosecond,
+                                                                 left_datetime, left_nanosecond);
+        return TimeValue::from_nanoseconds_with_limit(difference);
     }
 
     static DataTypes get_variadic_argument_types() {
@@ -1379,15 +1413,18 @@ struct CurrentTimeImpl {
             const auto* col = assert_cast<const ColumnInt8*>(
                     block.get_by_position(arguments[0]).column.get());
             uint8_t precision = col->get_element(0);
-            if (precision <= 6) {
+            if (precision <= DataTypeTimeV2::MAX_SCALE) {
+                const int32_t factor = common::exp10_i32(TimeValue::NANOS_SCALE - precision);
+                const int32_t nanosecond = context->state()->nano_seconds() / factor * factor;
                 dtv.from_unixtime(context->state()->timestamp_ms() / 1000,
                                   context->state()->nano_seconds(),
-                                  context->state()->timezone_obj(), precision);
-                time = TimeValue::make_time(dtv.hour(), dtv.minute(), dtv.second(),
-                                            dtv.microsecond());
+                                  context->state()->timezone_obj(),
+                                  std::min<uint8_t>(precision, TimeValue::MICROS_SCALE));
+                time = TimeValue::make_time_from_nanoseconds(dtv.hour(), dtv.minute(), dtv.second(),
+                                                             nanosecond);
             } else {
                 return Status::InvalidArgument(
-                        "The precision in function CURTIME should be between 0 and 6, but got "
+                        "The precision in function CURTIME should be between 0 and 9, but got "
                         "{}",
                         precision);
             }
@@ -1589,7 +1626,8 @@ struct UtcImpl {
         auto col_to = PrimitiveTypeTraits<ReturnType>::ColumnType::create();
         DateV2Value<DateTimeV2ValueType> dtv;
         if (dtv.from_unixtime(context->state()->timestamp_ms() / 1000,
-                              context->state()->nano_seconds(), "+00:00", scale)) {
+                              context->state()->nano_seconds(), "+00:00",
+                              std::min(scale, DATETIMEV2_MAX_SCALE))) {
             if constexpr (ReturnType == TYPE_DATETIMEV2) {
                 col_to->insert_data(reinterpret_cast<char*>(&dtv), 0);
             } else if constexpr (ReturnType == TYPE_DATEV2) {
@@ -1597,8 +1635,10 @@ struct UtcImpl {
                 dv.assign_from(dtv);
                 col_to->insert_data(reinterpret_cast<char*>(&dv), 0);
             } else if constexpr (ReturnType == TYPE_TIMEV2) {
-                double time = TimeValue::make_time(dtv.hour(), dtv.minute(), dtv.second(),
-                                                   dtv.microsecond());
+                const int32_t factor = common::exp10_i32(TimeValue::NANOS_SCALE - scale);
+                const int32_t nanosecond = context->state()->nano_seconds() / factor * factor;
+                double time = TimeValue::make_time_from_nanoseconds(dtv.hour(), dtv.minute(),
+                                                                    dtv.second(), nanosecond);
                 col_to->insert_data(reinterpret_cast<char*>(&time), 0);
             }
         } else {
@@ -1935,9 +1975,8 @@ class FunctionTime : public IFunction {
         auto& res_data = res->get_data();
         for (size_t i = 0; i < arg.size(); ++i) {
             const auto& v = arg.get_element(i);
-            // TIMEV2 has microsecond precision, so TIMESTAMP_NS intentionally drops digits 7-9.
             if constexpr (PType == TYPE_TIMESTAMP_NS) {
-                res_data[i] = static_cast<TimeValue::TimeType>(v.time_part_to_microsecond());
+                res_data[i] = TimeValue::from_nanoseconds(v.time_part_to_nanosecond());
             } else {
                 res_data[i] =
                         TimeValue::make_time(v.hour(), v.minute(), v.second(), v.microsecond());
@@ -2187,14 +2226,14 @@ class AddTimeImplBase {
             const auto& arg2 = right_data[index_check_const(i, cols_info[1].is_const)];
 
             if constexpr (PType == TYPE_TIMESTAMP_NS) {
-                auto result = arg1;
-                auto tv2 = static_cast<TimeValue::TimeType>(arg2);
-                TimeInterval interval(TimeUnit::MICROSECOND, tv2, IsNegative);
-                if (!result.template date_add_interval<TimeUnit::MICROSECOND>(interval))
-                        [[unlikely]] {
+                const __int128 delta = TimeValue::to_nanoseconds(arg2);
+                const __int128 result_nanos =
+                        static_cast<__int128>(arg1.epoch_nanos()) + (IsNegative ? -delta : delta);
+                if (result_nanos < std::numeric_limits<int64_t>::min() ||
+                    result_nanos > std::numeric_limits<int64_t>::max()) [[unlikely]] {
                     throw_invalid_strings(name, arg1.to_string(), std::to_string(arg2));
                 }
-                res_col->insert_value(result);
+                res_col->insert_value(TimeStampNsValue(static_cast<int64_t>(result_nanos)));
             } else if constexpr (PType == TYPE_DATETIMEV2 || PType == TYPE_TIMESTAMPTZ) {
                 DateV2Value<DateTimeV2ValueType> dtv1(arg1.to_date_int_val());
                 auto tv2 = static_cast<TimeValue::TimeType>(arg2);
@@ -2205,10 +2244,11 @@ class AddTimeImplBase {
                 }
                 res_col->insert_value(dtv1);
             } else if constexpr (PType == TYPE_TIMEV2) {
-                auto tv1 = static_cast<TimeValue::TimeType>(arg1);
-                auto tv2 = static_cast<TimeValue::TimeType>(arg2);
-                double res = TimeValue::limit_with_bound(IsNegative ? tv1 - tv2 : tv1 + tv2);
-                res_col->insert_value(res);
+                const __int128 left_nanoseconds = TimeValue::to_nanoseconds(arg1);
+                const __int128 right_nanoseconds = TimeValue::to_nanoseconds(arg2);
+                res_col->insert_value(TimeValue::from_nanoseconds_with_limit(
+                        IsNegative ? left_nanoseconds - right_nanoseconds
+                                   : left_nanoseconds + right_nanoseconds));
             } else {
                 throw Exception(ErrorCode::FATAL_ERROR, "not support type for function {}", name);
             }
diff --git a/be/src/exprs/function/function_other_types_to_date.cpp b/be/src/exprs/function/function_other_types_to_date.cpp
index 04b60c9c78df6b..d7463bedf76f7a 100644
--- a/be/src/exprs/function/function_other_types_to_date.cpp
+++ b/be/src/exprs/function/function_other_types_to_date.cpp
@@ -427,8 +427,7 @@ struct MakeTimeImpl {
             return false;
         }
 
-        // Avoid overflow in `execute_single`
-        // the case {838, 59, 59.999999} will be slove in `TimeValue::from_double_with_limit`
+        // Avoid overflow in `execute_single`.
         if (std::abs(hour) > MAX_HOUR_FOR_MAKETIME) {
             hour = hour > 0 ? MAX_HOUR_FOR_MAKETIME : -MAX_HOUR_FOR_MAKETIME;
             minute = sec = 59;
@@ -438,11 +437,11 @@ struct MakeTimeImpl {
 
     static void execute_single(int64_t hour, int64_t minute, double sec,
                                PaddedPODArray<double>& res_data, size_t row) {
-        // Round sec to 6 decimal places (microsecond precision)
-        double total_sec =
-                std::abs(hour) * 3600 + minute * 60 + std::round(sec * 1000000.0) / 1000000.0;
-
-        res_data[row] = TimeValue::from_double_with_limit(total_sec * (hour < 0 ? -1 : 1));
+        const int64_t total_nanoseconds =
+                (std::abs(hour) * 3600 + minute * 60) * TimeValue::ONE_SECOND_NANOSECONDS +
+                std::llround(sec * TimeValue::ONE_SECOND_NANOSECONDS);
+        res_data[row] = TimeValue::from_nanoseconds_with_limit(
+                hour < 0 ? -static_cast<__int128>(total_nanoseconds) : total_nanoseconds);
     }
 };
 
diff --git a/be/src/format/parquet/schema_desc.cpp b/be/src/format/parquet/schema_desc.cpp
index 972ce6f969b74c..6543597969e6d5 100644
--- a/be/src/format/parquet/schema_desc.cpp
+++ b/be/src/format/parquet/schema_desc.cpp
@@ -305,7 +305,13 @@ std::pair<DataTypePtr, bool> FieldDescriptor::convert_to_doris_type(
             }
         }
     } else if (logicalType.__isset.TIME) {
-        ans.first = DataTypeFactory::instance().create_data_type(TYPE_TIMEV2, nullable);
+        int scale = 9;
+        if (logicalType.TIME.unit.__isset.MILLIS) {
+            scale = 3;
+        } else if (logicalType.TIME.unit.__isset.MICROS) {
+            scale = 6;
+        }
+        ans.first = DataTypeFactory::instance().create_data_type(TYPE_TIMEV2, nullable, 0, scale);
     } else if (logicalType.__isset.TIMESTAMP) {
         if (_enable_mapping_timestamp_tz) {
             if (logicalType.TIMESTAMP.isAdjustedToUTC) {
diff --git a/be/src/format_v2/parquet/native_schema_desc.cpp b/be/src/format_v2/parquet/native_schema_desc.cpp
index 16f4623bb1bafb..dc517ea561c01c 100644
--- a/be/src/format_v2/parquet/native_schema_desc.cpp
+++ b/be/src/format_v2/parquet/native_schema_desc.cpp
@@ -863,7 +863,12 @@ std::pair<DataTypePtr, bool> NativeFieldDescriptor::convert_to_doris_type(
             }
         }
     } else if (logicalType.__isset.TIME) {
-        const int scale = logicalType.TIME.unit.__isset.MILLIS ? 3 : 6;
+        int scale = 9;
+        if (logicalType.TIME.unit.__isset.MILLIS) {
+            scale = 3;
+        } else if (logicalType.TIME.unit.__isset.MICROS) {
+            scale = 6;
+        }
         // TIME stores an integer unit, so its Doris scale must preserve the footer unit or
         // sub-second values are silently truncated by the target SerDe.
         ans.first = DataTypeFactory::instance().create_data_type(TYPE_TIMEV2, nullable, 0, scale);
diff --git a/be/src/util/date_func.cpp b/be/src/util/date_func.cpp
index ac6e7d087bfa08..04fbf2376b81e0 100644
--- a/be/src/util/date_func.cpp
+++ b/be/src/util/date_func.cpp
@@ -28,10 +28,12 @@
 #include "core/types.h"
 #include "core/value/time_value.h"
 #include "core/value/vdatetime_value.h"
-#include "exec/common/int_exp.h"
 #include "exprs/function/cast/cast_to_timestamptz.h"
 
 namespace doris {
+constexpr int32_t NANOSECOND_SCALE_DIVISORS[] = {1000000000, 100000000, 10000000, 1000000, 100000,
+                                                 10000,      1000,      100,      10,      1};
+
 VecDateTimeValue timestamp_from_datetime(const std::string& datetime_str) {
     tm time_tm;
     char* res = strptime(datetime_str.c_str(), "%Y-%m-%d %H:%M:%S", &time_tm);
@@ -69,14 +71,16 @@ VecDateTimeValue timestamp_from_date(const std::string& date_str) {
 
 //FIXME: try to remove or refactor all those time input/output functions.
 uint8_t timev2_to_buffer_from_double(double time, char* buffer, int scale) {
+    DCHECK_GE(scale, 0);
+    DCHECK_LE(scale, static_cast<int>(TimeValue::NANOS_SCALE));
     char* begin = buffer;
     if (time < 0) {
         time = -time;
         *buffer++ = '-';
     }
-    auto m_time = (uint64_t)TimeValue::limit_with_bound(time);
+    auto m_time = static_cast<uint64_t>(TimeValue::to_nanoseconds(time));
 
-    auto hour = static_cast<uint16_t>(m_time / (3600ULL * 1000 * 1000));
+    auto hour = static_cast<uint16_t>(m_time / (3600ULL * 1000 * 1000 * 1000));
     if (hour >= 100) {
         buffer = fmt::format_to(buffer, FMT_COMPILE("{}"), hour);
     } else {
@@ -84,18 +88,18 @@ uint8_t timev2_to_buffer_from_double(double time, char* buffer, int scale) {
         *buffer++ = (char)('0' + (hour % 10));
     }
     *buffer++ = ':';
-    m_time %= 3600ULL * 1000 * 1000;
+    m_time %= 3600ULL * 1000 * 1000 * 1000;
 
-    auto minute = static_cast<uint8_t>(m_time / (60 * 1000 * 1000));
+    auto minute = static_cast<uint8_t>(m_time / (60ULL * 1000 * 1000 * 1000));
     *buffer++ = (char)('0' + (minute / 10));
     *buffer++ = (char)('0' + (minute % 10));
     *buffer++ = ':';
-    m_time %= 60 * 1000 * 1000;
+    m_time %= 60ULL * 1000 * 1000 * 1000;
 
-    auto second = static_cast<uint8_t>(m_time / (1000 * 1000));
+    auto second = static_cast<uint8_t>(m_time / (1000 * 1000 * 1000));
     *buffer++ = (char)('0' + (second / 10));
     *buffer++ = (char)('0' + (second % 10));
-    m_time %= 1000 * 1000;
+    m_time %= 1000 * 1000 * 1000;
     if (scale == 0) {
         return static_cast<uint8_t>(buffer - begin);
     }
@@ -103,19 +107,20 @@ uint8_t timev2_to_buffer_from_double(double time, char* buffer, int scale) {
     *buffer++ = '.';
     memset(buffer, '0', scale);
     buffer += scale;
-    int32_t micosecond = m_time % (1000 * 1000);
-    micosecond /= common::exp10_i32(6 - scale);
+    uint32_t nanosecond = static_cast<uint32_t>(m_time);
+    nanosecond /= NANOSECOND_SCALE_DIVISORS[scale];
     auto* it = buffer - 1;
-    while (micosecond) {
-        *it = (char)('0' + (micosecond % 10));
-        micosecond /= 10;
+    while (nanosecond) {
+        *it = (char)('0' + (nanosecond % 10));
+        nanosecond /= 10;
         it--;
     }
-    DCHECK_LT(scale, 10);
     return static_cast<uint8_t>(buffer - begin);
 }
 
 std::string timev2_to_buffer_from_double(double time, int scale) {
+    DCHECK_GE(scale, 0);
+    DCHECK_LE(scale, static_cast<int>(TimeValue::NANOS_SCALE));
     fmt::memory_buffer buffer;
     if (time < 0) {
         time = -time;
@@ -130,35 +135,47 @@ std::string timev2_to_buffer_from_double(double time, int scale) {
     }
     auto minute = TimeValue::minute(m_time);
     auto second = TimeValue::second(m_time);
-    auto micosecond = TimeValue::microsecond(m_time);
-    micosecond /= common::exp10_i32(6 - scale);
+    auto nanosecond = TimeValue::nanosecond(m_time);
+    nanosecond /= NANOSECOND_SCALE_DIVISORS[scale];
     switch (scale) {
     case 0:
         fmt::format_to(buffer, fmt::format(FMT_COMPILE(":{:02d}:{:02d}"), minute, second));
         break;
     case 1:
         fmt::format_to(buffer, fmt::format(FMT_COMPILE(":{:02d}:{:02d}.{:01d}"), minute, second,
-                                           micosecond));
+                                           nanosecond));
         break;
     case 2:
         fmt::format_to(buffer, fmt::format(FMT_COMPILE(":{:02d}:{:02d}.{:02d}"), minute, second,
-                                           micosecond));
+                                           nanosecond));
         break;
     case 3:
         fmt::format_to(buffer, fmt::format(FMT_COMPILE(":{:02d}:{:02d}.{:03d}"), minute, second,
-                                           micosecond));
+                                           nanosecond));
         break;
     case 4:
         fmt::format_to(buffer, fmt::format(FMT_COMPILE(":{:02d}:{:02d}.{:04d}"), minute, second,
-                                           micosecond));
+                                           nanosecond));
         break;
     case 5:
         fmt::format_to(buffer, fmt::format(FMT_COMPILE(":{:02d}:{:02d}.{:05d}"), minute, second,
-                                           micosecond));
+                                           nanosecond));
         break;
     case 6:
         fmt::format_to(buffer, fmt::format(FMT_COMPILE(":{:02d}:{:02d}.{:06d}"), minute, second,
-                                           micosecond));
+                                           nanosecond));
+        break;
+    case 7:
+        fmt::format_to(buffer, fmt::format(FMT_COMPILE(":{:02d}:{:02d}.{:07d}"), minute, second,
+                                           nanosecond));
+        break;
+    case 8:
+        fmt::format_to(buffer, fmt::format(FMT_COMPILE(":{:02d}:{:02d}.{:08d}"), minute, second,
+                                           nanosecond));
+        break;
+    case 9:
+        fmt::format_to(buffer, fmt::format(FMT_COMPILE(":{:02d}:{:02d}.{:09d}"), minute, second,
+                                           nanosecond));
         break;
     }
 
diff --git a/be/test/core/data_type/data_type_datetime_v2_test.cpp b/be/test/core/data_type/data_type_datetime_v2_test.cpp
index b3aeec27da2e8e..2da4754173b80a 100644
--- a/be/test/core/data_type/data_type_datetime_v2_test.cpp
+++ b/be/test/core/data_type/data_type_datetime_v2_test.cpp
@@ -123,7 +123,10 @@ TEST_F(DataTypeDateTimeV2Test, simple_func_test) {
     EXPECT_THROW(create_datetimev2(8), Exception);
     EXPECT_THROW(create_datetimev2(9), Exception);
     EXPECT_THROW(create_datetimev2(10), Exception);
-    EXPECT_THROW(DataTypeTimeV2(7), Exception);
+    EXPECT_NO_THROW(DataTypeTimeV2(7));
+    EXPECT_NO_THROW(DataTypeTimeV2(8));
+    EXPECT_NO_THROW(DataTypeTimeV2(9));
+    EXPECT_THROW(DataTypeTimeV2(10), Exception);
 }
 
 TEST_F(DataTypeDateTimeV2Test, get_field) {
diff --git a/be/test/core/data_type_serde/data_type_serde_datetime_v2_test.cpp b/be/test/core/data_type_serde/data_type_serde_datetime_v2_test.cpp
index 88b6dcba6aebc3..e3cb980efece14 100644
--- a/be/test/core/data_type_serde/data_type_serde_datetime_v2_test.cpp
+++ b/be/test/core/data_type_serde/data_type_serde_datetime_v2_test.cpp
@@ -423,6 +423,22 @@ TEST_F(DataTypeDateTimeV2SerDeTest, ArrowTimeToTimeV2) {
                                        arrow::default_memory_pool());
     ASSERT_TRUE(nanos_builder.Append(45296123456789).ok());
     read_time(&nanos_builder, 6, {45296123456.0});
+
+    arrow::Time64Builder exact_nanos_builder(arrow::time64(arrow::TimeUnit::NANO),
+                                             arrow::default_memory_pool());
+    ASSERT_TRUE(exact_nanos_builder.Append(45296123456789).ok());
+    read_time(&exact_nanos_builder, 9, {45296123456.789});
+}
+
+TEST_F(DataTypeDateTimeV2SerDeTest, MysqlBinaryNanosecondTimeAsString) {
+    auto column = ColumnTimeV2::create();
+    column->insert_value(TimeValue::make_time_from_nanoseconds(12, 34, 56, 123456789));
+    DataTypeTimeV2SerDe serde(9);
+    MysqlRowBinaryBuffer buffer;
+    DataTypeSerDe::FormatOptions options;
+    ASSERT_TRUE(serde.write_column_to_mysql_binary(*column, buffer, 0, false, options).ok());
+    ASSERT_EQ(static_cast<uint8_t>(buffer.buf()[0]), 18);
+    EXPECT_EQ(std::string(buffer.buf() + 1, 18), "12:34:56.123456789");
 }
 
 TEST_F(DataTypeDateTimeV2SerDeTest, RejectsInvalidArrowTimeValues) {
diff --git a/be/test/core/data_type_serde/data_type_serde_decoded_values_test.cpp b/be/test/core/data_type_serde/data_type_serde_decoded_values_test.cpp
index 1303fa1e29a032..4f1f9cabe5b1bd 100644
--- a/be/test/core/data_type_serde/data_type_serde_decoded_values_test.cpp
+++ b/be/test/core/data_type_serde/data_type_serde_decoded_values_test.cpp
@@ -1103,6 +1103,15 @@ TEST(DataTypeSerDeDecodedValuesTest, ReadTimeV2FromInt64Nanos) {
     ASSERT_TRUE(result.status.ok()) << result.status;
     expect_column_strings(*type, *result.column,
                           {"00:00:00.000001", "-00:00:00.000001", "01:01:01.000001"});
+
+    auto nanosecond_type = std::make_shared<DataTypeTimeV2>(9);
+    std::vector<int64_t> exact_values = {1, -1, 3661000001001LL};
+    auto exact_view = make_fixed_view(DecodedValueKind::INT64, exact_values);
+    exact_view.time_unit = DecodedTimeUnit::NANOS;
+    auto exact_result = read_column(nanosecond_type, exact_view);
+    ASSERT_TRUE(exact_result.status.ok()) << exact_result.status;
+    expect_column_strings(*nanosecond_type, *exact_result.column,
+                          {"00:00:00.000000001", "-00:00:00.000000001", "01:01:01.000001001"});
 }
 
 TEST(DataTypeSerDeDecodedValuesTest, TimeV2HandlesNulls) {
diff --git a/be/test/core/data_type_serde/data_type_serde_parquet_test.cpp b/be/test/core/data_type_serde/data_type_serde_parquet_test.cpp
index b7b664c7c78de2..2d6dd2dd277240 100644
--- a/be/test/core/data_type_serde/data_type_serde_parquet_test.cpp
+++ b/be/test/core/data_type_serde/data_type_serde_parquet_test.cpp
@@ -777,6 +777,21 @@ TEST(DataTypeSerDeParquetTest, MaterializesTimeUnitsDirectly) {
                              .ok());
         EXPECT_EQ(invalid_dictionary_column->size(), 0);
     }
+
+    TestParquetDecodeSource nanosecond_source;
+    nanosecond_source.set_fixed_values<int64_t>({1, 86399999999999});
+    const ParquetDecodeContext nanosecond_context {.physical_type = ParquetPhysicalType::INT64,
+                                                   .logical_type = ParquetLogicalType::TIME,
+                                                   .time_unit = ParquetTimeUnit::NANOS};
+    ParquetMaterializationState nanosecond_state;
+    DataTypeTimeV2 nanosecond_type(9);
+    auto nanosecond_column = nanosecond_type.create_column();
+    ASSERT_TRUE(nanosecond_type.get_serde()
+                        ->read_column_from_parquet(*nanosecond_column, nanosecond_source,
+                                                   nanosecond_context, 2, nanosecond_state)
+                        .ok());
+    EXPECT_EQ(nanosecond_type.to_string(*nanosecond_column, 0), "00:00:00.000000001");
+    EXPECT_EQ(nanosecond_type.to_string(*nanosecond_column, 1), "23:59:59.999999999");
 }
 
 TEST(DataTypeSerDeParquetTest, MaterializesTimestampTzDirectly) {
diff --git a/be/test/exprs/function/cast/cast_timestamp_ns_test.cpp b/be/test/exprs/function/cast/cast_timestamp_ns_test.cpp
index 633aa40f9a93c4..b0dad2d8c9ab73 100644
--- a/be/test/exprs/function/cast/cast_timestamp_ns_test.cpp
+++ b/be/test/exprs/function/cast/cast_timestamp_ns_test.cpp
@@ -154,6 +154,15 @@ TEST_F(FunctionCastTest, datelike_to_timestamp_ns) {
         };
         check_function_for_cast<DataTypeTimeStampNs>(input_types, data_set);
     }
+    {
+        const InputTypeSet input_types = {{PrimitiveType::TYPE_TIMEV2, 9}};
+        const DataSet data_set = {
+                {{std::string("23:59:59.123456789")}, std::string("2019-08-06 23:59:59.123456789")},
+                {{std::string("-00:00:00.000000001")},
+                 std::string("2019-08-05 23:59:59.999999999")},
+        };
+        check_function_for_cast<DataTypeTimeStampNs>(input_types, data_set);
+    }
 }
 
 TEST_F(FunctionCastTest, datetimev2_to_timestamp_ns_strict_overflow) {
@@ -229,6 +238,13 @@ TEST_F(FunctionCastTest, timestamp_ns_to_supported_scalar_types) {
     };
     check_function_for_cast<DataTypeTimeV2>(input_types, time_data, 6);
 
+    const DataSet time_ns_data = {
+            {{std::string("1677-09-21 00:12:43.145224192")}, std::string("00:12:43.145224192")},
+            {{std::string("1969-12-31 23:59:59.999999999")}, std::string("23:59:59.999999999")},
+            {{std::string("2024-02-29 12:34:56.123456789")}, std::string("12:34:56.123456789")},
+    };
+    check_function_for_cast<DataTypeTimeV2>(input_types, time_ns_data, 9);
+
     const DataSet integer_data = {
             {{std::string("1677-09-21 00:12:43.145224192")}, int64_t(16770921001243)},
             {{std::string("1970-01-01 00:00:00.000000000")}, int64_t(19700101000000)},
diff --git a/be/test/exprs/function/cast/cast_to_time_test.cpp b/be/test/exprs/function/cast/cast_to_time_test.cpp
index f2129fb444cf57..20ff2c3cd8806c 100644
--- a/be/test/exprs/function/cast/cast_to_time_test.cpp
+++ b/be/test/exprs/function/cast/cast_to_time_test.cpp
@@ -95,6 +95,16 @@ TEST_F(FunctionCastTest, test_from_string_non_strict_mode_to_time) {
     check_function_for_cast<DataTypeTimeV2>(input_types, data_set, 6);
 }
 
+TEST_F(FunctionCastTest, test_from_string_to_nanosecond_time) {
+    const InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
+    const DataSet data_set = {
+            {{std::string("12:34:56.123456789")}, std::string("12:34:56.123456789")},
+            {{std::string("-00:00:00.000000001")}, std::string("-00:00:00.000000001")},
+            {{std::string("12:34:56.1234567895")}, std::string("12:34:56.123456790")},
+    };
+    check_function_for_cast_strict_mode<DataTypeTimeV2>(input_types, data_set, "", 9);
+}
+
 TEST_F(FunctionCastTest, test_from_numeric_to_time) {
     // Test casting from Int64
     {
diff --git a/be/test/exprs/function/function_timestamp_ns_test.cpp b/be/test/exprs/function/function_timestamp_ns_test.cpp
index b9dd053e5c0a92..3dfb513ea1db5d 100644
--- a/be/test/exprs/function/function_timestamp_ns_test.cpp
+++ b/be/test/exprs/function/function_timestamp_ns_test.cpp
@@ -87,6 +87,13 @@ TEST(TimestampNsFunctionTest, calendar_extract_and_format) {
                          {{{std::string("12:34:56.123456"), std::string("%f|%n")},
                            std::string("123456|123456000")}})
                          .ok()));
+    const InputTypeSet timev2_scale9_format_arguments = {{PrimitiveType::TYPE_TIMEV2, 9},
+                                                         Consted {PrimitiveType::TYPE_VARCHAR}};
+    EXPECT_TRUE((check_function<DataTypeString, true>(
+                         "time_format", timev2_scale9_format_arguments,
+                         {{{std::string("12:34:56.123456789"), std::string("%f|%n")},
+                           std::string("123456|123456789")}})
+                         .ok()));
 
     EXPECT_TRUE((check_function<DataTypeString, true>(
                          "year_month", one_argument,
@@ -360,6 +367,24 @@ TEST(TimestampNsFunctionTest, arithmetic_preserves_nanoseconds_and_checks_range)
                            std::string("1969-12-31 23:59:59.999999001")}})
                          .ok()));
 
+    const InputTypeSet nanosecond_time_arguments = {{PrimitiveType::TYPE_TIMESTAMP_NS},
+                                                    {PrimitiveType::TYPE_TIMEV2, 9}};
+    EXPECT_TRUE((check_function<DataTypeTimeStampNs, true>(
+                         "add_time", nanosecond_time_arguments,
+                         {{{std::string("2024-02-29 12:34:56.123456789"),
+                            std::string("00:00:00.000000001")},
+                           std::string("2024-02-29 12:34:56.123456790")}})
+                         .ok()));
+
+    const InputTypeSet time_only_arguments = {{PrimitiveType::TYPE_TIMEV2, 9},
+                                              {PrimitiveType::TYPE_TIMEV2, 9}};
+    EXPECT_TRUE((check_function<DataTypeTimeV2, true>(
+                         "sub_time", time_only_arguments,
+                         {{{std::string("12:34:56.123456789"), std::string("00:00:00.000000001")},
+                           std::string("12:34:56.123456788")}},
+                         9)
+                         .ok()));
+
     EXPECT_FALSE((check_function<DataTypeTimeStampNs, true>(
                           "seconds_add", subday_arguments,
                           {{{std::string("2262-04-11 23:47:16.854775807"), int64_t(1)},
@@ -423,11 +448,11 @@ TEST(TimestampNsFunctionTest, differences_keep_submicrosecond_ordering) {
             (check_function<DataTypeTimeV2, true>("timediff", arguments,
                                                   {{{std::string("1970-01-01 00:00:00.000000000"),
                                                      std::string("1969-12-31 23:59:59.999999999")},
-                                                    std::string("0.0")},
+                                                    std::string("00:00:00.000000001")},
                                                    {{std::string("2024-02-29 12:34:56.123456789"),
                                                      std::string("2024-02-29 12:34:55.000000001")},
-                                                    std::string("00:00:01.123456")}},
-                                                  6)
+                                                    std::string("00:00:01.123456788")}},
+                                                  9)
                      .ok()));
     EXPECT_TRUE(
             (check_function<DataTypeInt64, true>("microseconds_diff", arguments,
@@ -476,8 +501,8 @@ TEST(TimestampNsFunctionTest, mixed_datetimev2_differences_do_not_narrow_datetim
             (check_function<DataTypeTimeV2, true>("timediff", timestamp_ns_first,
                                                   {{{std::string("2024-01-02 00:00:00.000001789"),
                                                      std::string("2024-01-02 00:00:00.000000")},
-                                                    std::string("00:00:00.000001")}},
-                                                  6)
+                                                    std::string("00:00:00.000001789")}},
+                                                  9)
                      .ok()));
 
     EXPECT_TRUE(
diff --git a/be/test/format/parquet/parquet_thrift_test.cpp b/be/test/format/parquet/parquet_thrift_test.cpp
index 0fe101db598138..4121f3cce50e03 100644
--- a/be/test/format/parquet/parquet_thrift_test.cpp
+++ b/be/test/format/parquet/parquet_thrift_test.cpp
@@ -96,6 +96,51 @@ TEST_F(ParquetThriftReaderTest, normal) {
     }
 }
 
+TEST_F(ParquetThriftReaderTest, timestampNanosMapsToTimestampNs) {
+    tparquet::SchemaElement root;
+    root.__set_name("schema");
+    root.__set_num_children(1);
+
+    tparquet::SchemaElement timestamp;
+    timestamp.__set_name("ts_ns");
+    timestamp.__set_type(tparquet::Type::INT64);
+    timestamp.__set_repetition_type(tparquet::FieldRepetitionType::OPTIONAL);
+    timestamp.__set_logicalType(tparquet::LogicalType());
+    timestamp.logicalType.__set_TIMESTAMP(tparquet::TimestampType());
+    timestamp.logicalType.TIMESTAMP.__set_isAdjustedToUTC(false);
+    timestamp.logicalType.TIMESTAMP.__set_unit(tparquet::TimeUnit());
+    timestamp.logicalType.TIMESTAMP.unit.__set_NANOS(tparquet::NanoSeconds());
+
+    FieldDescriptor descriptor;
+    ASSERT_TRUE(descriptor.parse_from_thrift({root, timestamp}).ok());
+    ASSERT_EQ(descriptor.size(), 1);
+    EXPECT_EQ(remove_nullable(descriptor.get_column(0)->data_type)->get_primitive_type(),
+              TYPE_TIMESTAMP_NS);
+}
+
+TEST_F(ParquetThriftReaderTest, timeNanosMapsToTimeV2ScaleNine) {
+    tparquet::SchemaElement root;
+    root.__set_name("schema");
+    root.__set_num_children(1);
+
+    tparquet::SchemaElement time;
+    time.__set_name("time_ns");
+    time.__set_type(tparquet::Type::INT64);
+    time.__set_repetition_type(tparquet::FieldRepetitionType::OPTIONAL);
+    time.__set_logicalType(tparquet::LogicalType());
+    time.logicalType.__set_TIME(tparquet::TimeType());
+    time.logicalType.TIME.__set_isAdjustedToUTC(false);
+    time.logicalType.TIME.__set_unit(tparquet::TimeUnit());
+    time.logicalType.TIME.unit.__set_NANOS(tparquet::NanoSeconds());
+
+    FieldDescriptor descriptor;
+    ASSERT_TRUE(descriptor.parse_from_thrift({root, time}).ok());
+    ASSERT_EQ(descriptor.size(), 1);
+    const auto type = remove_nullable(descriptor.get_column(0)->data_type);
+    EXPECT_EQ(type->get_primitive_type(), TYPE_TIMEV2);
+    EXPECT_EQ(type->get_scale(), 9);
+}
+
 TEST_F(ParquetThriftReaderTest, complex_nested_file) {
     // hive-complex.parquet is the part of following table:
     // complex_nested_table(
diff --git a/be/test/format_v2/parquet/parquet_schema_test.cpp b/be/test/format_v2/parquet/parquet_schema_test.cpp
index 35fa9f415525e1..842809bc789119 100644
--- a/be/test/format_v2/parquet/parquet_schema_test.cpp
+++ b/be/test/format_v2/parquet/parquet_schema_test.cpp
@@ -659,6 +659,51 @@ TEST(ParquetSchemaTest, NativeLogicalUtcTimeIsDeferredToProjectionValidation) {
               "Parquet TIME with isAdjustedToUTC=true is not supported");
 }
 
+TEST(ParquetSchemaTest, NativeTimestampNanosMapsToTimestampNs) {
+    tparquet::SchemaElement root;
+    root.__set_name("schema");
+    root.__set_num_children(1);
+
+    tparquet::SchemaElement timestamp;
+    timestamp.__set_name("ts_ns");
+    timestamp.__set_type(tparquet::Type::INT64);
+    timestamp.__set_repetition_type(tparquet::FieldRepetitionType::OPTIONAL);
+    timestamp.__set_logicalType(tparquet::LogicalType());
+    timestamp.logicalType.__set_TIMESTAMP(tparquet::TimestampType());
+    timestamp.logicalType.TIMESTAMP.__set_isAdjustedToUTC(false);
+    timestamp.logicalType.TIMESTAMP.__set_unit(tparquet::TimeUnit());
+    timestamp.logicalType.TIMESTAMP.unit.__set_NANOS(tparquet::NanoSeconds());
+
+    NativeFieldDescriptor descriptor;
+    ASSERT_TRUE(descriptor.parse_from_thrift({root, timestamp}).ok());
+    ASSERT_EQ(descriptor.size(), 1);
+    EXPECT_EQ(remove_nullable(descriptor.get_column(0)->data_type)->get_primitive_type(),
+              TYPE_TIMESTAMP_NS);
+}
+
+TEST(ParquetSchemaTest, NativeTimeNanosMapsToTimeV2ScaleNine) {
+    tparquet::SchemaElement root;
+    root.__set_name("schema");
+    root.__set_num_children(1);
+
+    tparquet::SchemaElement time;
+    time.__set_name("time_ns");
+    time.__set_type(tparquet::Type::INT64);
+    time.__set_repetition_type(tparquet::FieldRepetitionType::OPTIONAL);
+    time.__set_logicalType(tparquet::LogicalType());
+    time.logicalType.__set_TIME(tparquet::TimeType());
+    time.logicalType.TIME.__set_isAdjustedToUTC(false);
+    time.logicalType.TIME.__set_unit(tparquet::TimeUnit());
+    time.logicalType.TIME.unit.__set_NANOS(tparquet::NanoSeconds());
+
+    NativeFieldDescriptor descriptor;
+    ASSERT_TRUE(descriptor.parse_from_thrift({root, time}).ok());
+    ASSERT_EQ(descriptor.size(), 1);
+    const auto type = remove_nullable(descriptor.get_column(0)->data_type);
+    EXPECT_EQ(type->get_primitive_type(), TYPE_TIMEV2);
+    EXPECT_EQ(type->get_scale(), 9);
+}
+
 TEST(ParquetSchemaTest, NativeOversizedByteArrayDecimalIsDeferredToProjectionValidation) {
     tparquet::SchemaElement root;
     root.__set_name("schema");
diff --git a/be/test/runtime/time_value_test.cpp b/be/test/runtime/time_value_test.cpp
index 1e752c9140e562..b36f7abfbdea2a 100644
--- a/be/test/runtime/time_value_test.cpp
+++ b/be/test/runtime/time_value_test.cpp
@@ -56,6 +56,16 @@ TEST(TimeValueTest, to_string) {
     EXPECT_EQ(result, "01:02:03");
 }
 
+TEST(TimeValueTest, nanosecond_precision) {
+    const auto time = TimeValue::make_time_from_nanoseconds(1, 2, 3, 123456789);
+    EXPECT_EQ(TimeValue::to_nanoseconds(time), 3723123456789);
+    EXPECT_EQ(TimeValue::microsecond(time), 123456);
+    EXPECT_EQ(TimeValue::nanosecond(time), 123456789);
+    EXPECT_EQ(TimeValue::to_string(time, 9), "01:02:03.123456789");
+    EXPECT_EQ(TimeValue::to_string(-time, 9), "-01:02:03.123456789");
+    EXPECT_EQ(TimeValue::round_time(time, 6), TimeValue::make_time(1, 2, 3, 123457));
+}
+
 TEST(TimeValueTest, hour) {
     {
         TimeValue::TimeType time = 3723000000;
diff --git a/fe/fe-catalog/src/main/java/org/apache/doris/analysis/TimeV2Literal.java b/fe/fe-catalog/src/main/java/org/apache/doris/analysis/TimeV2Literal.java
index 96a4014bd59a00..22c6829602db6a 100644
--- a/fe/fe-catalog/src/main/java/org/apache/doris/analysis/TimeV2Literal.java
+++ b/fe/fe-catalog/src/main/java/org/apache/doris/analysis/TimeV2Literal.java
@@ -21,13 +21,14 @@
 import org.apache.doris.catalog.Type;
 
 public class TimeV2Literal extends LiteralExpr {
-    public static final TimeV2Literal MIN_VALUE = new TimeV2Literal(838, 59, 59, 999999, 6, true);
-    public static final TimeV2Literal MAX_VALUE = new TimeV2Literal(838, 59, 59, 999999, 6, false);
+    public static final TimeV2Literal MIN_VALUE = fromNanosecond(838, 59, 59, 999999999, 9, true);
+    public static final TimeV2Literal MAX_VALUE = fromNanosecond(838, 59, 59, 999999999, 9, false);
 
     protected int hour;
     protected int minute;
     protected int second;
     protected int microsecond;
+    protected int nanosecondRemainder;
     protected boolean negative;
 
     /**
@@ -40,24 +41,42 @@ public TimeV2Literal() {
         this.minute = 0;
         this.second = 0;
         this.microsecond = 0;
+        this.nanosecondRemainder = 0;
         this.negative = false;
     }
 
     // for -00:... so we need explicite negative
     public TimeV2Literal(int hour, int minute, int second, int microsecond, int scale, boolean negative) {
+        this(hour, minute, second, (long) microsecond * 1000, scale, negative);
+    }
+
+    private TimeV2Literal(int hour, int minute, int second, long nanosecond, int scale, boolean negative) {
         super();
         this.type = ScalarType.createTimeV2Type(scale);
         this.hour = hour;
         this.minute = minute;
         this.second = second;
-        this.microsecond = microsecond / (int) Math.pow(10, 6 - scale) * (int) Math.pow(10, 6 - scale);
+        if (scale > ScalarType.MAX_TIMEV2_SCALE || scale < 0) {
+            throw new RuntimeException("time literal scale is out of range [0, 9]");
+        }
+        int factor = (int) Math.pow(10, ScalarType.MAX_TIMEV2_SCALE - scale);
+        int truncatedNanosecond = (int) (nanosecond / factor * factor);
+        this.microsecond = truncatedNanosecond / 1000;
+        this.nanosecondRemainder = truncatedNanosecond % 1000;
         this.negative = negative;
-        if (checkRange(this.hour, this.minute, this.second, this.microsecond) || scale > 6 || scale < 0) {
-            throw new RuntimeException("time literal is out of range [-838:59:59.999999, 838:59:59.999999]");
+        if (checkRange(this.hour, this.minute, this.second, truncatedNanosecond)) {
+            throw new RuntimeException(
+                    "time literal is out of range [-838:59:59.999999999, 838:59:59.999999999]");
         }
         this.nullable = false;
     }
 
+    /** Create a TIMEV2 literal from a full nanosecond-of-second value. */
+    public static TimeV2Literal fromNanosecond(int hour, int minute, int second, int nanosecond,
+            int scale, boolean negative) {
+        return new TimeV2Literal(hour, minute, second, (long) nanosecond, scale, negative);
+    }
+
     protected TimeV2Literal(TimeV2Literal other) {
         super(other);
         this.type = other.type;
@@ -65,6 +84,7 @@ protected TimeV2Literal(TimeV2Literal other) {
         this.minute = other.getMinute();
         this.second = other.getSecond();
         this.microsecond = other.getMicroSecond();
+        this.nanosecondRemainder = other.nanosecondRemainder;
         this.negative = other.isNegative();
     }
 
@@ -121,14 +141,15 @@ public String getStringValue() {
         }
         int scale = ((ScalarType) type).getScalarScale();
         if (scale > 0) {
-            sb.append(String.format(".%0" + scale + "d", microsecond / (int) Math.pow(10, 6 - scale)));
+            sb.append(String.format(".%0" + scale + "d",
+                    getNanoSecond() / (int) Math.pow(10, ScalarType.MAX_TIMEV2_SCALE - scale)));
         }
         return sb.toString();
     }
 
-    protected static boolean checkRange(int hour, int minute, int second, int microsecond) {
-        return hour > 838 || minute > 59 || second > 59 || microsecond > 999999 || minute < 0 || second < 0
-                || microsecond < 0;
+    protected static boolean checkRange(int hour, int minute, int second, int nanosecond) {
+        return hour > 838 || minute > 59 || second > 59 || nanosecond > 999999999
+                || minute < 0 || second < 0 || nanosecond < 0;
     }
 
     public int getHour() {
@@ -147,14 +168,20 @@ public int getMicroSecond() {
         return microsecond;
     }
 
+    public int getNanoSecond() {
+        return microsecond * 1000 + nanosecondRemainder;
+    }
+
     public boolean isNegative() {
         return negative;
     }
 
     public double getValue() {
         if (negative) {
-            return (((double) (-hour * 60) - minute) * 60 - second) * 1000000 - microsecond;
+            return (((double) (-hour * 60) - minute) * 60 - second) * 1000000
+                    - microsecond - nanosecondRemainder / 1000.0;
         }
-        return (((double) (hour * 60) + minute) * 60 + second) * 1000000 + microsecond;
+        return (((double) (hour * 60) + minute) * 60 + second) * 1000000
+                + microsecond + nanosecondRemainder / 1000.0;
     }
 }
diff --git a/fe/fe-core/src/main/java/org/apache/doris/mysql/MysqlSerializer.java b/fe/fe-core/src/main/java/org/apache/doris/mysql/MysqlSerializer.java
index e67f843acefcdc..d65b151dff829a 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/mysql/MysqlSerializer.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/mysql/MysqlSerializer.java
@@ -19,6 +19,7 @@
 
 import org.apache.doris.catalog.Column;
 import org.apache.doris.catalog.MysqlColType;
+import org.apache.doris.catalog.PrimitiveType;
 import org.apache.doris.catalog.ScalarType;
 import org.apache.doris.catalog.Type;
 
@@ -295,6 +296,12 @@ int getMysqlTypeLength(Type type) {
             case TIMESTAMP_NS:
                 // yyyy-MM-dd HH:mm:ss.nnnnnnnnn
                 return 29;
+            case TIMEV2:
+                if (isNanosecondTime(type)) {
+                    // -838:59:59.nnnnnnnnn
+                    return 20;
+                }
+                return 10;
             case DATETIME:
             case DATETIMEV2: {
                 if (type.getPrimitiveType().isTimeType()) {
@@ -336,7 +343,7 @@ int getMysqlTypeLength(Type type) {
 
     // this is used for decimal scale
     public int getMysqlDecimals(Type type) {
-        if (isTimestampNs(type)) {
+        if (isNanosecondTemporalString(type)) {
             return 0;
         }
         switch (type.getPrimitiveType()) {
@@ -357,16 +364,25 @@ public int getMysqlDecimals(Type type) {
     }
 
     private MysqlColType getMysqlResultType(Type type) {
-        // MySQL's binary temporal value contains at most microseconds. TIMESTAMP_NS is
-        // serialized by BE as a length-encoded string so the metadata must advertise a string too.
-        return isTimestampNs(type) ? MysqlColType.MYSQL_TYPE_STRING
+        // MySQL's binary temporal values contain at most microseconds. Nanosecond temporal
+        // values are serialized by BE as length-encoded strings, so advertise them as strings.
+        return isNanosecondTemporalString(type) ? MysqlColType.MYSQL_TYPE_STRING
                 : type.getPrimitiveType().toMysqlType();
     }
 
+    private boolean isNanosecondTemporalString(Type type) {
+        return isTimestampNs(type) || isNanosecondTime(type);
+    }
+
     private boolean isTimestampNs(Type type) {
         return type.isTimeStampNs();
     }
 
+    private boolean isNanosecondTime(Type type) {
+        return type.getPrimitiveType() == PrimitiveType.TIMEV2
+                && ((ScalarType) type).decimalScale() > 6;
+    }
+
     // see https://github.com/mysql/mysql-server/blob/trunk/include/mysql_com.h#L161
     private int getMysqlFlags(Type type) {
         int flags = 0;
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/executable/DateTimeArithmetic.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/executable/DateTimeArithmetic.java
index c384e41468c433..08111b5fd05688 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/executable/DateTimeArithmetic.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/executable/DateTimeArithmetic.java
@@ -1187,8 +1187,8 @@ public static Expression time(DateTimeV2Literal date) {
 
     @ExecFunction(name = "time")
     public static Expression time(TimeStampNsLiteral date) {
-        return new TimeV2Literal((int) date.getHour(), (int) date.getMinute(), (int) date.getSecond(),
-                (int) date.getMicroSecond(), TimeV2Type.MAX_SCALE, false);
+        return TimeV2Literal.fromNanosecond((int) date.getHour(), (int) date.getMinute(),
+                (int) date.getSecond(), (int) date.getNanoSecond(), TimeV2Type.MAX_SCALE, false);
     }
 
     /**
@@ -1201,7 +1201,9 @@ public static Expression addTime(DateTimeV2Literal date, TimeV2Literal time) {
 
     @ExecFunction(name = "add_time")
     public static Expression addTime(TimeV2Literal t1, TimeV2Literal t2) {
-        return t1.plusMicroSeconds((long) t2.getValue());
+        int precision = Math.max(((TimeV2Type) t1.getDataType()).getScale(),
+                ((TimeV2Type) t2.getDataType()).getScale());
+        return t1.plusNanoSeconds(t2.getValueInNanoseconds(), precision);
     }
 
     @ExecFunction(name = "add_time")
@@ -1211,7 +1213,7 @@ public static Expression addTime(TimestampTzLiteral date, TimeV2Literal time) {
 
     @ExecFunction(name = "add_time")
     public static Expression addTime(TimeStampNsLiteral date, TimeV2Literal time) {
-        return date.plusMicroSeconds((long) time.getValue());
+        return date.plusNanoSeconds(time.getValueInNanoseconds());
     }
 
     /**
@@ -1224,7 +1226,9 @@ public static Expression subTime(DateTimeV2Literal date, TimeV2Literal time) {
 
     @ExecFunction(name = "sub_time")
     public static Expression subTime(TimeV2Literal t1, TimeV2Literal t2) {
-        return t1.plusMicroSeconds(-(long) t2.getValue());
+        int precision = Math.max(((TimeV2Type) t1.getDataType()).getScale(),
+                ((TimeV2Type) t2.getDataType()).getScale());
+        return t1.plusNanoSeconds(-t2.getValueInNanoseconds(), precision);
     }
 
     @ExecFunction(name = "sub_time")
@@ -1234,6 +1238,6 @@ public static Expression subTime(TimestampTzLiteral date, TimeV2Literal time) {
 
     @ExecFunction(name = "sub_time")
     public static Expression subTime(TimeStampNsLiteral date, TimeV2Literal time) {
-        return date.plusMicroSeconds(-(long) time.getValue());
+        return date.plusNanoSeconds(-time.getValueInNanoseconds());
     }
 }
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/executable/DateTimeExtractAndTransform.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/executable/DateTimeExtractAndTransform.java
index 8aa39312d7bab6..bf9a8c0ca71367 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/executable/DateTimeExtractAndTransform.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/executable/DateTimeExtractAndTransform.java
@@ -1021,18 +1021,19 @@ public static Expression makeTime(BigIntLiteral hour, BigIntLiteral minute, Doub
             secondValue = 59;
         }
 
-        long totalMicrosecond = Math.abs(hourValue) * 3600L * 1000000
-                + minuteValue * 60L * 1000000 + Math.round(secondValue * 1000000);
-        long maxMicrosecond = 838L * 3600L * 1000000 + 59L * 60L * 1000000 + 59999999L;
-        totalMicrosecond = Math.min(totalMicrosecond, maxMicrosecond);
+        long totalNanosecond = Math.abs(hourValue) * 3600L * 1000000000
+                + minuteValue * 60L * 1000000000 + Math.round(secondValue * 1000000000);
+        long maxNanosecond = (838L * 3600L + 59L * 60L + 59L) * 1000000000;
+        totalNanosecond = Math.min(totalNanosecond, maxNanosecond);
 
-        int newHour = (int) (totalMicrosecond / 3600L / 1000000);
-        totalMicrosecond %= 3600L * 1000000;
-        int newMinute = (int) (totalMicrosecond / 60L / 1000000);
-        totalMicrosecond %= 60L * 1000000;
-        int newSecond = (int) (totalMicrosecond / 1000000);
-        int microsecond = (int) (totalMicrosecond % 1000000);
-        return new TimeV2Literal(newHour, newMinute, newSecond, microsecond, 6, hourValue < 0);
+        int newHour = (int) (totalNanosecond / 3600L / 1000000000);
+        totalNanosecond %= 3600L * 1000000000;
+        int newMinute = (int) (totalNanosecond / 60L / 1000000000);
+        totalNanosecond %= 60L * 1000000000;
+        int newSecond = (int) (totalNanosecond / 1000000000);
+        int nanosecond = (int) (totalNanosecond % 1000000000);
+        return TimeV2Literal.fromNanosecond(
+                newHour, newMinute, newSecond, nanosecond, TimeV2Type.MAX_SCALE, hourValue < 0);
     }
 
     /**
@@ -1855,7 +1856,7 @@ public static Expression secToTime(IntegerLiteral sec) {
      */
     @ExecFunction(name = "sec_to_time")
     public static Expression secToTime(DoubleLiteral sec) {
-        return new TimeV2Literal(sec.getValue() * 1000000);
+        return new TimeV2Literal(sec.getValue() * 1000000, TimeV2Type.MAX_SCALE);
     }
 
     /**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/CurrentTime.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/CurrentTime.java
index c80c81f82ea435..7e7dbda68d88ee 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/CurrentTime.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/CurrentTime.java
@@ -68,8 +68,9 @@ private CurrentTime(ScalarFunctionParams functionParams) {
     public FunctionSignature computeSignature(FunctionSignature signature) {
         if (arity() == 1 && child(0) instanceof TinyIntLiteral) {
             byte precision = ((TinyIntLiteral) child(0)).getValue();
-            if (precision < 0 || precision > 6) {
-                throw new IllegalArgumentException("The precision must be between 0 and 6");
+            if (precision < 0 || precision > TimeV2Type.MAX_SCALE) {
+                throw new IllegalArgumentException("The precision must be between 0 and "
+                        + TimeV2Type.MAX_SCALE);
             }
             return FunctionSignature.ret(TimeV2Type.of(precision)).args(TinyIntType.INSTANCE);
         }
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimeDiff.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimeDiff.java
index 35b3c9042f4cc1..d0bc8cc793563d 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimeDiff.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimeDiff.java
@@ -89,8 +89,7 @@ public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
     @Override
     public FunctionSignature computeSignature(FunctionSignature signature) {
         signature = super.computeSignature(signature);
-        // TIMEV2 stores at most microseconds. A TIMESTAMP_NS operand therefore fixes the result
-        // at TIMEV2(6); do not feed its scale 9 into TimeV2Type.of().
+        // TIMESTAMP_NS has fixed scale 9, so its TIMEV2 difference keeps nanosecond precision.
         if (getArgument(0).getDataType() instanceof TimeStampNsType
                 || getArgument(1).getDataType() instanceof TimeStampNsType) {
             return signature.withReturnType(TimeV2Type.MAX);
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/UtcTime.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/UtcTime.java
index bc239d24cf8740..9842896dae68f5 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/UtcTime.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/UtcTime.java
@@ -73,8 +73,8 @@ public FunctionSignature computeSignature(FunctionSignature signature) {
         signature = super.computeSignature(signature);
         if (arity() == 1 && getArgument(0) instanceof IntegerLiteral) {
             int scale = ((IntegerLiteral) getArgument(0)).getValue();
-            if (scale < 0 || scale > 6) {
-                throw new AnalysisException("scale must be between 0 and 6");
+            if (scale < 0 || scale > TimeV2Type.MAX_SCALE) {
+                throw new AnalysisException("scale must be between 0 and " + TimeV2Type.MAX_SCALE);
             }
             return signature.withReturnType(TimeV2Type.of(scale));
         }
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/TimeStampNsLiteral.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/TimeStampNsLiteral.java
index 9e36fb6813defc..b39cd82b80f3e9 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/TimeStampNsLiteral.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/TimeStampNsLiteral.java
@@ -303,10 +303,9 @@ protected Expression uncheckedCastTo(DataType targetType) throws AnalysisExcepti
             int resultHour = (int) (timeNanos / NANOS_PER_SECOND / 60 / 60);
             int resultMinute = (int) (timeNanos / NANOS_PER_SECOND / 60 % 60);
             int resultSecond = (int) (timeNanos / NANOS_PER_SECOND % 60);
-            int resultMicroSecond = (int) (timeNanos % NANOS_PER_SECOND / 1000 / (factor / 1000)
-                    * (factor / 1000));
-            return new TimeV2Literal(resultHour, resultMinute, resultSecond,
-                    resultMicroSecond, scale, false);
+            int resultNanosecond = (int) (timeNanos % NANOS_PER_SECOND / factor * factor);
+            return TimeV2Literal.fromNanosecond(resultHour, resultMinute, resultSecond,
+                    resultNanosecond, scale, false);
         }
         if (targetType.isTimeStampTzType()) {
             int scale = ((TimeStampTzType) targetType).getScale();
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/TimeV2Literal.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/TimeV2Literal.java
index b400b5b4919b8c..5189eae3a0b8c8 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/TimeV2Literal.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/TimeV2Literal.java
@@ -26,6 +26,8 @@
 import org.apache.doris.nereids.types.TimeV2Type;
 import org.apache.doris.nereids.util.DateUtils;
 
+import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.time.LocalDateTime;
 
 /**
@@ -33,14 +35,15 @@
  */
 public class TimeV2Literal extends Literal {
     private static final LocalDateTime START_OF_A_DAY = LocalDateTime.of(0, 1, 1, 0, 0, 0);
-    private static final LocalDateTime END_OF_A_DAY = LocalDateTime.of(9999, 12, 31, 23, 59, 59, 999999000);
-    private static final TimeV2Literal MIN_VALUE = new TimeV2Literal(838, 59, 59, 0, 6, true);
-    private static final TimeV2Literal MAX_VALUE = new TimeV2Literal(838, 59, 59, 0, 6, false);
+    private static final LocalDateTime END_OF_A_DAY = LocalDateTime.of(9999, 12, 31, 23, 59, 59, 999999999);
+    private static final TimeV2Literal MIN_VALUE = new TimeV2Literal(838, 59, 59, 0, 9, true);
+    private static final TimeV2Literal MAX_VALUE = new TimeV2Literal(838, 59, 59, 0, 9, false);
 
     protected int hour;
     protected int minute;
     protected int second;
     protected int microsecond;
+    protected int nanosecondRemainder;
     protected boolean negative;
 
     public TimeV2Literal(TimeV2Type dataType, String s) {
@@ -58,19 +61,7 @@ public TimeV2Literal(String s) {
      */
     public TimeV2Literal(double value) throws AnalysisException {
         super(TimeV2Type.of(6));
-        if (value > (double) MAX_VALUE.getValue() || value < (double) MIN_VALUE.getValue()) {
-            throw new AnalysisException("The value " + value + " is out of range, expect value range is ["
-                    + (double) MIN_VALUE.getValue() + ", " + (double) MAX_VALUE.getValue() + "]");
-        }
-        this.negative = value < 0;
-        long v = (long) Math.abs(value);
-        this.microsecond = (int) (v % 1000000);
-        v /= 1000000;
-        this.second = (int) (v % 60);
-        v /= 60;
-        this.minute = (int) (v % 60);
-        v /= 60;
-        this.hour = (int) v;
+        init(value, 6);
     }
 
     /**
@@ -78,19 +69,7 @@ public TimeV2Literal(double value) throws AnalysisException {
      */
     public TimeV2Literal(double value, int scale) throws AnalysisException {
         super(TimeV2Type.of(scale));
-        if (value > (double) MAX_VALUE.getValue() || value < (double) MIN_VALUE.getValue()) {
-            throw new AnalysisException("The value " + value + " is out of range, expect value range is ["
-                + (double) MIN_VALUE.getValue() + ", " + (double) MAX_VALUE.getValue() + "]");
-        }
-        this.negative = value < 0;
-        long v = (long) Math.abs(value);
-        this.microsecond = (int) (v % 1000000);
-        v /= 1000000;
-        this.second = (int) (v % 60);
-        v /= 60;
-        this.minute = (int) (v % 60);
-        v /= 60;
-        this.hour = (int) v;
+        init(value, scale);
     }
 
     /**
@@ -99,17 +78,32 @@ public TimeV2Literal(double value, int scale) throws AnalysisException {
     // for -00:... so we need explicite negative
     public TimeV2Literal(int hour, int minute, int second, int microsecond, int scale, boolean negative)
             throws AnalysisException {
+        this(hour, minute, second, (long) microsecond * 1000, scale, negative);
+    }
+
+    private TimeV2Literal(int hour, int minute, int second, long nanosecond, int scale, boolean negative)
+            throws AnalysisException {
         super(TimeV2Type.of(scale));
         this.hour = hour;
         this.minute = minute;
         this.second = second;
-        this.microsecond = (int) (microsecond / Math.pow(10, 6 - scale)) * (int) Math.pow(10, 6 - scale);
+        int factor = (int) Math.pow(10, TimeV2Type.MAX_SCALE - scale);
+        int roundedNanosecond = (int) (nanosecond / factor * factor);
+        this.microsecond = roundedNanosecond / 1000;
+        this.nanosecondRemainder = roundedNanosecond % 1000;
         this.negative = negative;
-        if (checkRange(this.hour, this.minute, this.second, this.microsecond) || scale > 6 || scale < 0) {
-            throw new AnalysisException("time literal is out of range [-838:59:59.999999, 838:59:59.999999]");
+        if (checkRange(this.hour, this.minute, this.second, roundedNanosecond)) {
+            throw new AnalysisException(
+                    "time literal is out of range [-838:59:59.999999999, 838:59:59.999999999]");
         }
     }
 
+    /** Create a TIMEV2 literal from a full nanosecond-of-second value. */
+    public static TimeV2Literal fromNanosecond(int hour, int minute, int second, int nanosecond,
+            int scale, boolean negative) {
+        return new TimeV2Literal(hour, minute, second, (long) nanosecond, scale, negative);
+    }
+
     protected static String normalize(String s) {
         // remove suffix/prefix ' '
         s = s.trim();
@@ -146,61 +140,32 @@ protected static String normalize(String s) {
      * parse time string and avoid throw exception directly for better performance.
      */
     public static Result<TimeV2Literal, AnalysisException> parseTimeLiteral(String s) {
-        int hour;
-        int minute;
-        int second;
-        int microsecond;
-        boolean negative = false;
-        String normalized = normalize(s);
-        if (normalized.charAt(0) == '-') {
-            negative = true;
-            normalized = normalized.substring(1);
-        } else if (normalized.charAt(0) == '+') {
-            normalized = normalized.substring(1);
-        }
-        // start parse string
-        String[] parts = normalized.split(":");
-        if (parts.length != 3) {
-            return Result.err(() -> new AnalysisException("Invalid format, must have 3 parts separated by ':'"));
-        }
-        try {
-            hour = Integer.parseInt(parts[0]);
-        } catch (NumberFormatException e) {
-            return Result.err(() -> new AnalysisException("Invalid hour format"));
-        }
-
-        try {
-            minute = Integer.parseInt(parts[1]);
-        } catch (NumberFormatException e) {
-            return Result.err(() -> new AnalysisException("Invalid minute format"));
-        }
-        // if parts[2] is 60.000 it will cause judge feed execute error
-        if (parts[2].startsWith("60")) {
-            return Result.err(() -> new AnalysisException("second out of range"));
-        }
-        double secPart;
         try {
-            secPart = Double.parseDouble(parts[2]);
-        } catch (NumberFormatException e) {
-            return Result.err(() -> new AnalysisException("Invalid second format"));
-        }
-        secPart = secPart * (int) Math.pow(10, 6);
-        secPart = Math.round(secPart);
-        second = (int) (secPart / 1000000);
-        microsecond = (int) (secPart % 1000000);
-        if (second == 60) {
-            minute += 1;
-            second -= 60;
-            if (minute == 60) {
-                hour += 1;
-                minute -= 60;
-            }
+            int scale = determineScale(s);
+            return Result.ok(new TimeV2Literal(TimeV2Type.of(scale), s));
+        } catch (AnalysisException e) {
+            return Result.err(() -> e);
         }
+    }
 
-        if (checkRange(hour, minute, second, microsecond)) {
-            return Result.err(() -> new AnalysisException("time literal [" + s + "] is out of range"));
+    private void init(double value, int scale) {
+        if (value > (double) MAX_VALUE.getValue() || value < (double) MIN_VALUE.getValue()) {
+            throw new AnalysisException("The value " + value + " is out of range, expect value range is ["
+                + (double) MIN_VALUE.getValue() + ", " + (double) MAX_VALUE.getValue() + "]");
         }
-        return Result.ok(new TimeV2Literal(hour, minute, second, microsecond, 6, negative));
+        this.negative = value < 0;
+        long v = Math.round(Math.abs(value) * 1000);
+        long factor = (long) Math.pow(10, TimeV2Type.MAX_SCALE - scale);
+        v = (v + factor / 2) / factor * factor;
+        int nanosecond = (int) (v % 1000000000);
+        this.microsecond = nanosecond / 1000;
+        this.nanosecondRemainder = nanosecond % 1000;
+        v /= 1000000000;
+        this.second = (int) (v % 60);
+        v /= 60;
+        this.minute = (int) (v % 60);
+        v /= 60;
+        this.hour = (int) v;
     }
 
     // should like be/src/vec/runtime/time_value.h timev2_to_double_from_str
@@ -233,38 +198,36 @@ protected void init(String s) throws AnalysisException {
         if (parts[2].startsWith("60")) {
             throw new AnalysisException("second out of range");
         }
-        double secPart;
+        long scaledSecond;
         try {
-            secPart = Double.parseDouble(parts[2]);
-        } catch (NumberFormatException e) {
+            scaledSecond = new BigDecimal(parts[2]).movePointRight(scale)
+                    .setScale(0, RoundingMode.HALF_UP).longValueExact();
+        } catch (ArithmeticException | NumberFormatException e) {
             throw new AnalysisException("Invalid second format", e);
         }
-        secPart = secPart * (int) Math.pow(10, scale);
-        secPart = Math.round(secPart);
-        secPart = (long) secPart * (long) Math.pow(10, 6 - scale);
-        second = (int) (secPart / 1000000);
-        if (scale != 0) {
-            microsecond = (int) (secPart % 1000000);
-            if (second == 60) {
-                minute += 1;
-                second -= 60;
-                if (minute == 60) {
-                    hour += 1;
-                    minute -= 60;
-                }
+        long secondInNanoseconds = scaledSecond
+                * (long) Math.pow(10, TimeV2Type.MAX_SCALE - scale);
+        second = (int) (secondInNanoseconds / 1000000000);
+        int nanosecond = (int) (secondInNanoseconds % 1000000000);
+        microsecond = nanosecond / 1000;
+        nanosecondRemainder = nanosecond % 1000;
+        if (second == 60) {
+            minute += 1;
+            second -= 60;
+            if (minute == 60) {
+                hour += 1;
+                minute -= 60;
             }
-        } else {
-            microsecond = 0;
         }
 
-        if (checkRange(hour, minute, second, microsecond)) {
+        if (checkRange(hour, minute, second, nanosecond)) {
             throw new AnalysisException("time literal [" + s + "] is out of range");
         }
     }
 
-    protected static boolean checkRange(double hour, int minute, int second, int microsecond) {
-        return hour > 838 || minute > 59 || second > 59 || microsecond > 999999 || minute < 0 || second < 0
-                || microsecond < 0;
+    protected static boolean checkRange(double hour, int minute, int second, int nanosecond) {
+        return hour > 838 || minute > 59 || second > 59 || nanosecond > 999999999
+                || minute < 0 || second < 0 || nanosecond < 0;
     }
 
     /**
@@ -282,7 +245,7 @@ public static int determineScale(String s) {
         while (len > 0 && microPart.charAt(len - 1) == '0') {
             len--; // remove trailing zeros
         }
-        return Math.min(len, 6); // max scale is 6
+        return Math.min(len, TimeV2Type.MAX_SCALE);
     }
 
     public int getHour() {
@@ -301,13 +264,22 @@ public int getMicroSecond() {
         return microsecond;
     }
 
+    public int getNanoSecond() {
+        return microsecond * 1000 + nanosecondRemainder;
+    }
+
+    public long getValueInNanoseconds() {
+        long value = ((hour * 60L + minute) * 60L + second) * 1000000000L + getNanoSecond();
+        return negative ? -value : value;
+    }
+
     @Override
     protected Expression uncheckedCastTo(DataType targetType) throws AnalysisException {
-        long microsecondValue = ((Double) getValue()).longValue();
+        long nanosecondValue = getValueInNanoseconds();
         DateTimeV2Literal time = (DateTimeV2Literal) DateTimeV2Literal.fromJavaDateType(LocalDateTime
                 .now(DateUtils.getTimeZone()).withHour(0).withMinute(0).withSecond(0).withNano(0)
-                        .plusNanos(microsecondValue * 1000),
-                ((TimeV2Type) dataType).getScale());
+                        .plusNanos(nanosecondValue),
+                Math.min(((TimeV2Type) dataType).getScale(), 6));
         if (targetType.isDateType()) {
             return new DateLiteral(time.getYear(), time.getMonth(), time.getDay());
         } else if (targetType.isDateV2Type()) {
@@ -316,8 +288,11 @@ protected Expression uncheckedCastTo(DataType targetType) throws AnalysisExcepti
             return new DateTimeLiteral(time.getYear(), time.getMonth(), time.getDay(), time.getHour(), time.getMinute(),
                     time.getSecond());
         } else if (targetType instanceof TimeStampNsType) {
-            return new TimeStampNsLiteral(time.getYear(), time.getMonth(), time.getDay(),
-                    time.getHour(), time.getMinute(), time.getSecond(), time.getMicroSecond() * 1000L);
+            LocalDateTime timestamp = LocalDateTime.now(DateUtils.getTimeZone())
+                    .withHour(0).withMinute(0).withSecond(0).withNano(0).plusNanos(nanosecondValue);
+            return new TimeStampNsLiteral(timestamp.getYear(), timestamp.getMonthValue(),
+                    timestamp.getDayOfMonth(), timestamp.getHour(), timestamp.getMinute(),
+                    timestamp.getSecond(), timestamp.getNano());
         } else if (targetType.isDateTimeV2Type()) {
             return time;
         }
@@ -332,7 +307,8 @@ public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
     @Override
     public LiteralExpr toLegacyLiteral() {
         int scale = ((TimeV2Type) dataType).getScale();
-        return new org.apache.doris.analysis.TimeV2Literal(hour, minute, second, microsecond, scale, negative);
+        return org.apache.doris.analysis.TimeV2Literal.fromNanosecond(
+                hour, minute, second, getNanoSecond(), scale, negative);
     }
 
     @Override
@@ -346,12 +322,10 @@ public String getStringValue() {
         } else {
             sb.append(String.format("%02d:%02d:%02d", hour, minute, second));
         }
-        // why re caculate microsecond? example:
-        // the microsecond is 001000, it will parsed to 1000
-        // the scale is 3, we need make sure it not become start with 1
         int scale = ((TimeV2Type) dataType).getScale();
         if (scale > 0) {
-            sb.append(String.format(".%0" + scale + "d", microsecond / (int) Math.pow(10, 6 - scale)));
+            sb.append(String.format(".%0" + scale + "d",
+                    getNanoSecond() / (int) Math.pow(10, TimeV2Type.MAX_SCALE - scale)));
         }
         return sb.toString();
     }
@@ -380,19 +354,35 @@ public static Expression fromJavaDateType(LocalDateTime dateTime, int precision)
             throw new AnalysisException("datetime out of range" + dateTime.toString());
         }
         int value = (int) Math.pow(10, TimeV2Type.MAX_SCALE - precision);
-        return new TimeV2Literal(dateTime.getHour(), dateTime.getMinute(), dateTime.getSecond(),
-                (dateTime.getNano() / 1000) / value * value, precision, false);
+        return TimeV2Literal.fromNanosecond(dateTime.getHour(), dateTime.getMinute(), dateTime.getSecond(),
+                dateTime.getNano() / value * value, precision, false);
     }
 
     public LocalDateTime toJavaDateType() {
         return LocalDateTime.of(0, 1, 1, ((int) getHour()), ((int) getMinute()), ((int) getSecond()),
-                (int) getMicroSecond() * 1000);
+                getNanoSecond());
     }
 
     public Expression plusMicroSeconds(long microSeconds) {
         return fromJavaDateType(toJavaDateType().plusNanos(Math.multiplyExact(microSeconds, 1000L)));
     }
 
+    /** Add nanoseconds and retain the requested TIMEV2 precision. */
+    public Expression plusNanoSeconds(long nanoSeconds, int precision) {
+        long result = Math.addExact(getValueInNanoseconds(), nanoSeconds);
+        long maxValue = MAX_VALUE.getValueInNanoseconds();
+        result = Math.max(-maxValue, Math.min(maxValue, result));
+        boolean resultNegative = result < 0;
+        long absolute = Math.abs(result);
+        int resultNanosecond = (int) (absolute % 1000000000L);
+        long totalSeconds = absolute / 1000000000L;
+        int resultSecond = (int) (totalSeconds % 60);
+        int resultMinute = (int) (totalSeconds / 60 % 60);
+        int resultHour = (int) (totalSeconds / 3600);
+        return TimeV2Literal.fromNanosecond(resultHour, resultMinute, resultSecond,
+                resultNanosecond, precision, resultNegative);
+    }
+
     public Expression plusMilliSeconds(long milliSeconds) {
         return plusMicroSeconds(Math.multiplyExact(milliSeconds, 1000L));
     }
@@ -412,9 +402,11 @@ public Expression plusSeconds(long seconds) {
     @Override
     public Object getValue() {
         if (negative) {
-            return (((double) (-hour * 60) - minute) * 60 - second) * 1000000 - microsecond;
+            return (((double) (-hour * 60) - minute) * 60 - second) * 1000000
+                    - microsecond - nanosecondRemainder / 1000.0;
         }
-        return (((double) (hour * 60) + minute) * 60 + second) * 1000000 + microsecond;
+        return (((double) (hour * 60) + minute) * 60 + second) * 1000000
+                + microsecond + nanosecondRemainder / 1000.0;
     }
 
     @Override
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DataType.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DataType.java
index 8fd5b454b11549..35a9009c2c1e29 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DataType.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DataType.java
@@ -1134,8 +1134,7 @@ private static void validateScalarType(ScalarType scalarType) {
                 }
                 break;
             }
-            case TIMEV2:
-            case TIMESTAMPTZ: {
+            case TIMEV2: {
                 int precision = scalarType.decimalPrecision();
                 int scale = scalarType.decimalScale();
                 if (precision != ScalarType.DATETIME_PRECISION) {
@@ -1143,8 +1142,24 @@ private static void validateScalarType(ScalarType scalarType) {
                             "Precision of Time must be " + ScalarType.DATETIME_PRECISION
                                     + "." + " Precision was set to: " + precision + ".");
                 }
-                if (scale < 0 || scale > 6) {
-                    throw new AnalysisException("Scale of Time must between 0 and 6."
+                if (scale < 0 || scale > ScalarType.MAX_TIMEV2_SCALE) {
+                    throw new AnalysisException("Scale of Time must between 0 and "
+                            + ScalarType.MAX_TIMEV2_SCALE + "."
+                            + " Scale was set to: " + scale + ".");
+                }
+                break;
+            }
+            case TIMESTAMPTZ: {
+                int precision = scalarType.decimalPrecision();
+                int scale = scalarType.decimalScale();
+                if (precision != ScalarType.DATETIME_PRECISION) {
+                    throw new AnalysisException(
+                            "Precision of Timestamptz must be " + ScalarType.DATETIME_PRECISION
+                                    + ". Precision was set to: " + precision + ".");
+                }
+                if (scale < 0 || scale > ScalarType.MAX_DATETIMEV2_SCALE) {
+                    throw new AnalysisException("Scale of Timestamptz must between 0 and "
+                            + ScalarType.MAX_DATETIMEV2_SCALE + "."
                             + " Scale was set to: " + scale + ".");
                 }
                 break;
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DateTimeV2Type.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DateTimeV2Type.java
index 13097339554e3e..bc55595a7fbca0 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DateTimeV2Type.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DateTimeV2Type.java
@@ -91,7 +91,7 @@ public static DateTimeV2Type forType(DataType dataType) {
             return DateTimeV2Type.of(Math.min(((DecimalV2Type) dataType).getScale(), 6));
         }
         if (dataType instanceof TimeV2Type) {
-            return DateTimeV2Type.of(((TimeV2Type) dataType).getScale());
+            return DateTimeV2Type.of(Math.min(((TimeV2Type) dataType).getScale(), MAX_SCALE));
         }
         return MAX;
     }
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/types/TimeV2Type.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/types/TimeV2Type.java
index af758c02cb522b..08f7efb9d3876c 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/types/TimeV2Type.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/types/TimeV2Type.java
@@ -33,7 +33,7 @@
  */
 public class TimeV2Type extends PrimitiveType implements RangeScalable, ScaleTimeType {
 
-    public static final int MAX_SCALE = 6;
+    public static final int MAX_SCALE = ScalarType.MAX_TIMEV2_SCALE;
     public static final TimeV2Type SYSTEM_DEFAULT = new TimeV2Type(0);
     public static final TimeV2Type MAX = new TimeV2Type(MAX_SCALE);
     public static final TimeV2Type WILDCARD = new TimeV2Type(-1);
@@ -68,7 +68,8 @@ public Type toCatalogDataType() {
      */
     public static TimeV2Type of(int scale) {
         if (scale > MAX_SCALE || scale < 0) {
-            throw new AnalysisException("Scale of Datetime/Time must between 0 and 6. Scale was set to: " + scale);
+            throw new AnalysisException("Scale of Time must between 0 and " + MAX_SCALE
+                    + ". Scale was set to: " + scale);
         }
         return new TimeV2Type(scale);
     }
@@ -111,10 +112,10 @@ public static TimeV2Type forType(DataType dataType) {
             return SYSTEM_DEFAULT;
         }
         if (dataType instanceof DecimalV3Type) {
-            return TimeV2Type.of(Math.min(((DecimalV3Type) dataType).getScale(), 6));
+            return TimeV2Type.of(Math.min(((DecimalV3Type) dataType).getScale(), MAX_SCALE));
         }
         if (dataType instanceof DecimalV2Type) {
-            return TimeV2Type.of(Math.min(((DecimalV2Type) dataType).getScale(), 6));
+            return TimeV2Type.of(Math.min(((DecimalV2Type) dataType).getScale(), MAX_SCALE));
         }
         if (dataType instanceof DateTimeV2Type) {
             return TimeV2Type.of(((DateTimeV2Type) dataType).getScale());
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/TypeCoercionUtils.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/TypeCoercionUtils.java
index ec05d6c4b187a6..5ee925c91fdda0 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/TypeCoercionUtils.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/TypeCoercionUtils.java
@@ -441,9 +441,9 @@ public static DataType replaceTimesWithTargetPrecision(DataType dataType, int ta
         return replaceSpecifiedType(
                 replaceSpecifiedType(
                     replaceSpecifiedType(dataType, DateTimeV2Type.class,
-                            DateTimeV2Type.of(targetScale)),
-                        TimeV2Type.class, TimeV2Type.of(targetScale)),
-                    TimeStampTzType.class, TimeStampTzType.of(targetScale));
+                            DateTimeV2Type.of(Math.min(targetScale, DateTimeV2Type.MAX_SCALE))),
+                        TimeV2Type.class, TimeV2Type.of(Math.min(targetScale, TimeV2Type.MAX_SCALE))),
+                    TimeStampTzType.class, TimeStampTzType.of(Math.min(targetScale, TimeStampTzType.MAX_SCALE)));
     }
 
     /**
@@ -1114,7 +1114,8 @@ private static Optional<DataType> getCommonDataTypeWithDateTimeV2Type(
             }
         } else if (rightType instanceof TimeV2Type) {
             TimeV2Type timeV2Type = (TimeV2Type) rightType;
-            return Optional.of(DateTimeV2Type.of(Math.max(leftType.getScale(), timeV2Type.getScale())));
+            return Optional.of(DateTimeV2Type.of(Math.min(DateTimeV2Type.MAX_SCALE,
+                    Math.max(leftType.getScale(), timeV2Type.getScale()))));
         } else if (rightType.isStringLikeType()) {
             return Optional.of(DateTimeV2Type.MAX);
         }
diff --git a/fe/fe-core/src/test/java/org/apache/doris/mysql/MysqlSerializerDateTimeTest.java b/fe/fe-core/src/test/java/org/apache/doris/mysql/MysqlSerializerDateTimeTest.java
index 924e07755f66de..b750914772dfe9 100644
--- a/fe/fe-core/src/test/java/org/apache/doris/mysql/MysqlSerializerDateTimeTest.java
+++ b/fe/fe-core/src/test/java/org/apache/doris/mysql/MysqlSerializerDateTimeTest.java
@@ -69,4 +69,21 @@ public void testDatetimeV2MicrosecondMetadata() {
                     field[mysqlTypeOffset] & 0xFF);
         }
     }
+
+    @Test
+    public void testTimeV2NanosecondMetadata() {
+        MysqlSerializer serializer = MysqlSerializer.newInstance();
+        ScalarType type = ScalarType.createTimeV2Type(9);
+        Assertions.assertEquals(20, serializer.getMysqlTypeLength(type));
+        Assertions.assertEquals(0, serializer.getMysqlDecimals(type));
+
+        serializer.writeField("t", type);
+        byte[] field = serializer.toArray();
+        int metadataOffset = fieldMetadataOffset(field);
+        int mysqlTypeOffset = metadataOffset + 2 + 4;
+        Assertions.assertEquals(MysqlColType.MYSQL_TYPE_STRING.getCode(),
+                field[mysqlTypeOffset] & 0xFF);
+        int decimalsOffset = mysqlTypeOffset + 1 + 2;
+        Assertions.assertEquals(0, field[decimalsOffset] & 0xFF);
+    }
 }
diff --git a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimestampNsFunctionSignatureTest.java b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimestampNsFunctionSignatureTest.java
index 57b5fe5b3532ab..005b832d97a5c5 100644
--- a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimestampNsFunctionSignatureTest.java
+++ b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimestampNsFunctionSignatureTest.java
@@ -164,6 +164,7 @@ void testUntypedDatetimeExpressionsKeepDateTimeV2SignaturesAfterAnalysis() {
 
     @Test
     void testMixedDateTimeDifferenceFunctionsKeepDistinctPhysicalTypes() {
+        Assertions.assertEquals(9, TimeV2Type.MAX.getScale());
         Expression datetime = SlotReference.of("datetime", DateTimeV2Type.MAX);
         Expression timestampTz = SlotReference.of("timestamp_tz", TimeStampTzType.MAX);
         assertSignature(new DateDiff(timestampNs, datetime), IntegerType.INSTANCE,
@@ -199,7 +200,7 @@ void testDateTimeV2AndTimestampTzFunctionsUseDateTimeV2Signature() {
         Expression timestampTz = SlotReference.of("timestamp_tz", TimeStampTzType.MAX);
         assertSignature(new DateDiff(datetime, timestampTz), IntegerType.INSTANCE,
                 DateTimeV2Type.MAX, DateTimeV2Type.MAX);
-        assertSignature(new TimeDiff(timestampTz, datetime), TimeV2Type.MAX,
+        assertSignature(new TimeDiff(timestampTz, datetime), TimeV2Type.of(DateTimeV2Type.MAX_SCALE),
                 DateTimeV2Type.MAX, DateTimeV2Type.MAX);
         assertSignature(new SecondsDiff(datetime, timestampTz), BigIntType.INSTANCE,
                 DateTimeV2Type.MAX, DateTimeV2Type.MAX);
diff --git a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/literal/TimeStampNsLiteralTest.java b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/literal/TimeStampNsLiteralTest.java
index b2bdc40ca9814f..a603f461e77ec8 100644
--- a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/literal/TimeStampNsLiteralTest.java
+++ b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/literal/TimeStampNsLiteralTest.java
@@ -21,6 +21,7 @@
 import org.apache.doris.nereids.exceptions.AnalysisException;
 import org.apache.doris.nereids.exceptions.CastException;
 import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.functions.executable.DateTimeArithmetic;
 import org.apache.doris.nereids.types.BigIntType;
 import org.apache.doris.nereids.types.DateTimeV2Type;
 import org.apache.doris.nereids.types.DateV2Type;
@@ -196,8 +197,10 @@ void testSupportedOutboundCastsAndRounding() {
 
         Assertions.assertEquals("2024-02-29",
                 ((Literal) normal.checkedCastTo(DateV2Type.INSTANCE)).getStringValue());
-        Assertions.assertEquals("12:34:56.123457",
+        Assertions.assertEquals("12:34:56.123456789",
                 ((Literal) normal.checkedCastTo(TimeV2Type.MAX)).getStringValue());
+        Assertions.assertEquals("12:34:56.123457",
+                ((Literal) normal.checkedCastTo(TimeV2Type.of(6))).getStringValue());
         Assertions.assertEquals(20240229123456L,
                 ((BigIntLiteral) normal.checkedCastTo(BigIntType.INSTANCE)).getValue());
         Assertions.assertEquals("20240229123456",
@@ -208,6 +211,12 @@ void testSupportedOutboundCastsAndRounding() {
                 () -> normal.checkedCastTo(SmallIntType.INSTANCE));
         Assertions.assertThrowsExactly(AnalysisException.class,
                 () -> normal.checkedCastTo(IntegerType.INSTANCE));
+
+        Assertions.assertEquals("12:34:56.123456789",
+                ((TimeV2Literal) DateTimeArithmetic.time(normal)).getStringValue());
+        TimeV2Literal twoNanoseconds = TimeV2Literal.fromNanosecond(0, 0, 0, 2, 9, false);
+        Assertions.assertEquals("2024-02-29 12:34:56.123456791",
+                ((TimeStampNsLiteral) DateTimeArithmetic.addTime(normal, twoNanoseconds)).getStringValue());
     }
 
     @Test
diff --git a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/literal/TimeV2LiteralTest.java b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/literal/TimeV2LiteralTest.java
index 96775d44bfc628..210ae9603c4aef 100644
--- a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/literal/TimeV2LiteralTest.java
+++ b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/expressions/literal/TimeV2LiteralTest.java
@@ -19,6 +19,7 @@
 
 import org.apache.doris.nereids.exceptions.AnalysisException;
 import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.functions.executable.DateTimeExtractAndTransform;
 import org.apache.doris.nereids.types.DateTimeV2Type;
 import org.apache.doris.nereids.types.StringType;
 import org.apache.doris.nereids.types.TimeV2Type;
@@ -110,6 +111,32 @@ public void testTimeV2LiteralCreate() {
         Assertions.assertEquals(s, "12:00:00");
     }
 
+    @Test
+    public void testNanosecondPrecision() {
+        TimeV2Literal literal = new TimeV2Literal(TimeV2Type.of(9), "12:34:56.123456789");
+        Assertions.assertEquals("12:34:56.123456789", literal.getStringValue());
+        Assertions.assertEquals(123456789, literal.getNanoSecond());
+        Assertions.assertEquals(45296123456789L, literal.getValueInNanoseconds());
+
+        TimeV2Literal negative = new TimeV2Literal(TimeV2Type.of(9), "-00:00:00.000000001");
+        Assertions.assertEquals("-00:00:00.000000001", negative.getStringValue());
+        Assertions.assertEquals(-1L, negative.getValueInNanoseconds());
+
+        TimeV2Literal rounded = new TimeV2Literal(TimeV2Type.of(6), "12:34:56.123456789");
+        Assertions.assertEquals("12:34:56.123457", rounded.getStringValue());
+
+        TimeV2Literal sum = (TimeV2Literal) literal.plusNanoSeconds(1, 9);
+        Assertions.assertEquals("12:34:56.123456790", sum.getStringValue());
+
+        TimeV2Literal seconds = (TimeV2Literal) DateTimeExtractAndTransform.secToTime(
+                new DoubleLiteral(1.123456789));
+        Assertions.assertEquals("00:00:01.123456789", seconds.getStringValue());
+        TimeV2Literal made = (TimeV2Literal) DateTimeExtractAndTransform.makeTime(
+                new BigIntLiteral(1), new BigIntLiteral(2), new DoubleLiteral(3.123456789));
+        Assertions.assertEquals("01:02:03.123456789", made.getStringValue());
+        Assertions.assertThrows(AnalysisException.class, () -> TimeV2Type.of(10));
+    }
+
     @Test
     public void testTimeV2LiteralOutOfRange() {
         Assertions.assertThrows(AnalysisException.class, () -> {
diff --git a/fe/fe-type/src/main/java/org/apache/doris/catalog/ScalarType.java b/fe/fe-type/src/main/java/org/apache/doris/catalog/ScalarType.java
index b98f2e27f71268..b36c9a13b59f9e 100644
--- a/fe/fe-type/src/main/java/org/apache/doris/catalog/ScalarType.java
+++ b/fe/fe-type/src/main/java/org/apache/doris/catalog/ScalarType.java
@@ -81,6 +81,7 @@ public class ScalarType extends Type {
     public static final int MAX_DECIMAL256_PRECISION = 76;
     public static final int DEFAULT_MIN_AVG_DECIMAL128_SCALE = 4;
     public static final int MAX_DATETIMEV2_SCALE = 6;
+    public static final int MAX_TIMEV2_SCALE = 9;
     public static final int TIMESTAMP_NS_PRECISION = 29;
     public static final int TIMESTAMP_NS_SCALE = 9;
     public static final int MAX_PRECISION = MAX_DECIMAL256_PRECISION;
diff --git a/regression-test/data/correctness/test_time_function.out b/regression-test/data/correctness/test_time_function.out
index 96a4f818f33b5d..a9be345eda4335 100644
--- a/regression-test/data/correctness/test_time_function.out
+++ b/regression-test/data/correctness/test_time_function.out
@@ -54,38 +54,38 @@
 -838:59:59
 
 -- !select --
-09:46:51.789500
+09:46:51.789500000
 
 -- !select --
-09:46:51.000000
+09:46:51.000000000
 
 -- !select --
--09:46:51.789500
+-09:46:51.789500000
 
 -- !select --
 838:59:59
 
 -- !select --
-838:59:58.999999
+838:59:58.999999000
 
 -- !select --
 838:59:59
 
 -- !select --
-838:59:59.000000
+838:59:59.000000000
 
 -- !select --
-838:59:59.000000
+838:59:59.000000000
 
 -- !select --
 -838:59:58
 
 -- !select --
--838:59:58.999999
+-838:59:58.999999000
 
 -- !select --
 -838:59:59
 
 -- !select --
--838:59:59.000000
+-838:59:59.000000000
 
diff --git a/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_binary_output.out b/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_binary_output.out
index fe08ef9c96096e..c59b5b1968792d 100644
--- a/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_binary_output.out
+++ b/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_binary_output.out
@@ -14,3 +14,6 @@
 4	1970-01-01 00:00:00.000000001
 5	2262-04-11 23:47:16.854775807
 6	\N
+
+-- !timev2_binary_protocol --
+12:34:56.123456789
diff --git a/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_expressions.out b/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_expressions.out
index 172d957dee0e17..f6a3f2bf0d8d37 100644
--- a/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_expressions.out
+++ b/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_expressions.out
@@ -90,12 +90,12 @@ true	true
 3	2024-02-29 12:34:56.123456000	2024-02-29 12:34:56.123456000	12:34:56.123456	2024-02-29 12:34:56.123456000	2024-02-29 12:34:56.123456000	12:34:56.123456	2024-02-29 12:34:56.123456000	\N	\N	2024-02-29 12:34:56.123456000	12:34:56.123456
 
 -- !mixed_temporal_functions --
-1	0	00:00:00.000000	0	0	00:00:00.000000	0	0
-2	0	00:00:00.000000	0	0	00:00:00.000000	0	1
+1	0	00:00:00.000000789	0	0	00:00:00.000000789	0	0
+2	0	00:00:00.000000000	0	0	00:00:00.000000000	0	1
 3	\N	\N	\N	\N	\N	\N	\N
 
 -- !mixed_temporal_constants --
-true	true	true	2024-02-29 12:34:56.123456789	2024-02-29 12:34:56.123456789	12:34:56.123456	2024-02-29 12:34:56.123456000	2024-02-29 12:34:56.123456000	2024-02-29 12:34:56.123456789	0	00:00:00.000000	0
+true	true	true	2024-02-29 12:34:56.123456789	2024-02-29 12:34:56.123456789	12:34:56.123456	2024-02-29 12:34:56.123456000	2024-02-29 12:34:56.123456000	2024-02-29 12:34:56.123456789	0	00:00:00.000000789	0
 
 -- !folded_conditions --
 1970-01-01 00:00:00.000000001	1970-01-01 00:00:00.000000001	true
diff --git a/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_functions.out b/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_functions.out
index 383e08f891150e..becffd32083e1f 100644
--- a/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_functions.out
+++ b/regression-test/data/datatype_p0/timestamp_ns/test_timestamp_ns_functions.out
@@ -3,10 +3,13 @@
 2024-02-29 12:34:56.123456789	123456789	123456789	2024-02-29 12:34:56.123456789	2024-02-29T12:34:56.123456789
 
 -- !scalar_functions_fold --
-2024	2024-02-29 12:34:56.123456|123456789	12:34:56.123456|123456789	1970-01-01 08:00:00.123457	1970-01-01 08:00:00.123456789	000000000	000000001	12:34:56.123456	1970-01-01 00:00:00.999999999	00:00:01.123456	2024-02-29 12:34:56.000000000	2024-02-29 12:34:56.000000000	2024-02-29 12:34:57.000000000	2024-02-29 04:34:56.123456789	2	["1969-12-31 23:59:59.000000001", "1970-01-01 00:00:00.000000001", "1970-01-01 00:00:01.000000001"]
+2024	2024-02-29 12:34:56.123456|123456789	12:34:56.123456|123456789	1970-01-01 08:00:00.123457	1970-01-01 08:00:00.123456789	000000000	000000001	12:34:56.123456789	1970-01-01 00:00:00.999999999	00:00:01.123456790	2024-02-29 12:34:56.000000000	2024-02-29 12:34:56.000000000	2024-02-29 12:34:57.000000000	2024-02-29 04:34:56.123456789	2	["1969-12-31 23:59:59.000000001", "1970-01-01 00:00:00.000000001", "1970-01-01 00:00:01.000000001"]
 
 -- !scalar_functions_runtime --
-2024	2024-02-29 12:34:56.123456|123456789	12:34:56.123456|123456789	1970-01-01 08:00:00.123457	1970-01-01 08:00:00.123456789	000000000	000000001	12:34:56.123456	1970-01-01 00:00:00.999999999	00:00:01.123456	2024-02-29 12:34:56.000000000	2024-02-29 12:34:56.000000000	2024-02-29 12:34:57.000000000	2024-02-29 04:34:56.123456789	2	["1969-12-31 23:59:59.000000001", "1970-01-01 00:00:00.000000001", "1970-01-01 00:00:01.000000001"]
+2024	2024-02-29 12:34:56.123456|123456789	12:34:56.123456|123456789	1970-01-01 08:00:00.123457	1970-01-01 08:00:00.123456789	000000000	000000001	12:34:56.123456789	1970-01-01 00:00:00.999999999	00:00:01.123456790	2024-02-29 12:34:56.000000000	2024-02-29 12:34:56.000000000	2024-02-29 12:34:57.000000000	2024-02-29 04:34:56.123456789	2	["1969-12-31 23:59:59.000000001", "1970-01-01 00:00:00.000000001", "1970-01-01 00:00:01.000000001"]
+
+-- !timev2_nanosecond_precision --
+12:34:56.123456789	-00:00:00.000000001	12:34:56.123456789	123456|123456000	00:00:01.123456789	01:02:03.123456789	2024-02-29 12:34:56.123456790	2024-02-29 12:34:56.123456788
 
 -- !additional_calendar_functions_fold --
 1	0	2262-04-14	1677-09-20	2004	2009	45296
@@ -45,7 +48,7 @@ false	2
 2024	2024	2024	1970-01-01 00:00:00.999999999	1970-01-01 00:00:00.999999999	1970-01-01 00:00:00.999999999
 
 -- !nanosecond_boundaries --
-23:59:59.999999	23:59:59.999999	1677-09-21 00:12:43.145224|145224192	00:00:00.000000	0	1970-01-01 00:00:00.000000500
+23:59:59.999999499	23:59:59.999999500	1677-09-21 00:12:43.145224|145224192	00:00:00.000000001	0	1970-01-01 00:00:00.000000500
 
 -- !nanoseconds_add_constants --
 1970-01-01 00:00:00.000000000	1969-12-31 23:59:59.999999999	\N	\N
@@ -99,12 +102,12 @@ false	2
 7	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N
 
 -- !format_and_convert --
-1	1677-09-21 00:12:43.145224	1677-09-21 00:12:43.145224192	00:12:43.145224	00:12:43.145224192	1677-09-21T00:12:43.145224192	1677-09-21 00:12:43.145224192	1677-09-21	1677-09-21	1677-09-21	1677-09-21	1677-09-21 00:12:43.145224192	00:12:43.145224	612776	52943847163	0E-9	-9223400837	-9223400836855	-9223400836854776	1677-09-30	1677-09-20
-2	1969-12-31 23:59:59.999999	1969-12-31 23:59:59.999999999	23:59:59.999999	23:59:59.999999999	1969-12-31T23:59:59.999999999	1969-12-31 23:59:59.999999999	1969-12-31	1969-12-31	1969-12-31	1969-12-31	1969-12-31 23:59:59.999999999	23:59:59.999999	719527	62167219199	0E-9	-28801	-28800001	-28800000001	1969-12-31	1969-12-29
-3	1970-01-01 00:00:00.000000	1970-01-01 00:00:00.000000000	00:00:00.000000	00:00:00.000000000	1970-01-01T00:00:00.000000000	1970-01-01 00:00:00.000000000	1970-01-01	1970-01-01	1970-01-01	1970-01-01	1970-01-01 00:00:00.000000000	00:00:00.000000	719528	62167219200	0E-9	-28800	-28800000	-28800000000	1970-01-31	1970-01-01
-4	1970-01-01 00:00:00.000000	1970-01-01 00:00:00.000000001	00:00:00.000000	00:00:00.000000001	1970-01-01T00:00:00.000000001	1970-01-01 00:00:00.000000001	1970-01-01	1970-01-01	1970-01-01	1970-01-01	1970-01-01 00:00:00.000000001	00:00:00.000000	719528	62167219200	0E-9	-28800	-28800000	-28800000000	1970-01-31	1970-01-01
-5	2024-02-29 12:34:56.123456	2024-02-29 12:34:56.123456789	12:34:56.123456	12:34:56.123456789	2024-02-29T12:34:56.123456789	2024-02-29 12:34:56.123456789	2024-02-29	2024-02-29	2024-02-29	2024-02-29	2024-02-29 12:34:56.123456789	12:34:56.123456	739310	63876429296	1709181296.123456789	1709181296	1709181296123	1709181296123456	2024-02-29	2024-02-26
-6	2262-04-11 23:47:16.854775	2262-04-11 23:47:16.854775807	23:47:16.854775	23:47:16.854775807	2262-04-11T23:47:16.854775807	2262-04-11 23:47:16.854775807	2262-04-11	2262-04-11	2262-04-11	2262-04-11	2262-04-11 23:47:16.854775807	23:47:16.854775	826279	71390591236	9223343236.854775807	9223343236	9223343236854	9223343236854775	2262-04-30	2262-04-07
+1	1677-09-21 00:12:43.145224	1677-09-21 00:12:43.145224192	00:12:43.145224	00:12:43.145224192	1677-09-21T00:12:43.145224192	1677-09-21 00:12:43.145224192	1677-09-21	1677-09-21	1677-09-21	1677-09-21	1677-09-21 00:12:43.145224192	00:12:43.145224192	612776	52943847163	0E-9	-9223400837	-9223400836855	-9223400836854776	1677-09-30	1677-09-20
+2	1969-12-31 23:59:59.999999	1969-12-31 23:59:59.999999999	23:59:59.999999	23:59:59.999999999	1969-12-31T23:59:59.999999999	1969-12-31 23:59:59.999999999	1969-12-31	1969-12-31	1969-12-31	1969-12-31	1969-12-31 23:59:59.999999999	23:59:59.999999999	719527	62167219199	0E-9	-28801	-28800001	-28800000001	1969-12-31	1969-12-29
+3	1970-01-01 00:00:00.000000	1970-01-01 00:00:00.000000000	00:00:00.000000	00:00:00.000000000	1970-01-01T00:00:00.000000000	1970-01-01 00:00:00.000000000	1970-01-01	1970-01-01	1970-01-01	1970-01-01	1970-01-01 00:00:00.000000000	00:00:00.000000000	719528	62167219200	0E-9	-28800	-28800000	-28800000000	1970-01-31	1970-01-01
+4	1970-01-01 00:00:00.000000	1970-01-01 00:00:00.000000001	00:00:00.000000	00:00:00.000000001	1970-01-01T00:00:00.000000001	1970-01-01 00:00:00.000000001	1970-01-01	1970-01-01	1970-01-01	1970-01-01	1970-01-01 00:00:00.000000001	00:00:00.000000001	719528	62167219200	0E-9	-28800	-28800000	-28800000000	1970-01-31	1970-01-01
+5	2024-02-29 12:34:56.123456	2024-02-29 12:34:56.123456789	12:34:56.123456	12:34:56.123456789	2024-02-29T12:34:56.123456789	2024-02-29 12:34:56.123456789	2024-02-29	2024-02-29	2024-02-29	2024-02-29	2024-02-29 12:34:56.123456789	12:34:56.123456789	739310	63876429296	1709181296.123456789	1709181296	1709181296123	1709181296123456	2024-02-29	2024-02-26
+6	2262-04-11 23:47:16.854775	2262-04-11 23:47:16.854775807	23:47:16.854775	23:47:16.854775807	2262-04-11T23:47:16.854775807	2262-04-11 23:47:16.854775807	2262-04-11	2262-04-11	2262-04-11	2262-04-11	2262-04-11 23:47:16.854775807	23:47:16.854775807	826279	71390591236	9223343236.854775807	9223343236	9223343236854	9223343236854775	2262-04-30	2262-04-07
 7	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N
 
 -- !simple_add_sub --
@@ -123,7 +126,7 @@ false	2
 5	2024-02-29 13:36:59.246912789	2024-02-29 11:32:53.000000789
 
 -- !diff_units --
-00:00:01.123456	1	1	1	1	1	1	1	1	1	0	1
+00:00:01.123456790	1	1	1	1	1	1	1	1	1	0	1
 
 -- !trunc --
 2	1969-01-01 00:00:00.000000000	1969-10-01 00:00:00.000000000	1969-12-01 00:00:00.000000000	1969-12-29 00:00:00.000000000	1969-12-31 00:00:00.000000000	1969-12-31 23:00:00.000000000	1969-12-31 23:59:00.000000000	1969-12-31 23:59:59.000000000
diff --git a/regression-test/data/doc/sql-manual/sql-functions/doc_date_functions_test.out b/regression-test/data/doc/sql-manual/sql-functions/doc_date_functions_test.out
index 65f09452a2da76..4f7c6b549b9d8c 100644
--- a/regression-test/data/doc/sql-manual/sql-functions/doc_date_functions_test.out
+++ b/regression-test/data/doc/sql-manual/sql-functions/doc_date_functions_test.out
@@ -1875,7 +1875,7 @@ da fanadur
 00:00:00
 
 -- !sec_to_time_5 --
-01:01:01.900000
+01:01:01.900000000
 
 -- !sec_to_time_6 --
 \N
@@ -2499,10 +2499,10 @@ da fanadur
 202352
 
 -- !maketime_test_1 --
-12:15:30.000000
-111:00:23.123457
-838:59:59.000000
--838:59:59.000000
+12:15:30.000000000
+111:00:23.123456955
+838:59:59.000000000
+-838:59:59.000000000
 \N
 \N
 \N
diff --git a/regression-test/data/nereids_function_p0/scalar_function/T.out b/regression-test/data/nereids_function_p0/scalar_function/T.out
index 0940a68215240a..164e3e3d8a530c 100644
--- a/regression-test/data/nereids_function_p0/scalar_function/T.out
+++ b/regression-test/data/nereids_function_p0/scalar_function/T.out
@@ -103,18 +103,18 @@
 
 -- !sql_timediff_TimestampNs_TimestampNs --
 \N
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
 
 -- !sql_timediff_DateTimeV2_DateTimeV2_notnull --
 00:00:00
@@ -131,18 +131,18 @@
 00:00:00
 
 -- !sql_timediff_TimestampNs_TimestampNs_notnull --
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
-00:00:00.000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
+00:00:00.000000000
 
 -- !sql_timediff_DateTimeV2_DateV2 --
 \N
@@ -161,18 +161,18 @@
 
 -- !sql_timediff_TimestampNs_DateV2 --
 \N
--838:59:59.000000
--838:59:59.000000
--838:59:59.000000
-07:06:07.000000
-08:07:08.000001
-09:08:09.001000
-10:09:10.010203
-11:10:11.100000
-12:11:12.999999
-838:59:59.000000
-838:59:59.000000
-838:59:59.000000
+-838:59:59.000000000
+-838:59:59.000000000
+-838:59:59.000000000
+07:06:07.000000001
+08:07:08.000001000
+09:08:09.001000000
+10:09:10.010203040
+11:10:11.100000000
+12:11:12.999999999
+838:59:59.000000000
+838:59:59.000000000
+838:59:59.000000000
 
 -- !sql_timediff_DateTimeV2_DateV2_notnull --
 01:00:01
@@ -189,18 +189,18 @@
 12:11:12
 
 -- !sql_timediff_TimestampNs_DateV2_notnull --
--838:59:59.000000
--838:59:59.000000
--838:59:59.000000
-07:06:07.000000
-08:07:08.000001
-09:08:09.001000
-10:09:10.010203
-11:10:11.100000
-12:11:12.999999
-838:59:59.000000
-838:59:59.000000
-838:59:59.000000
+-838:59:59.000000000
+-838:59:59.000000000
+-838:59:59.000000000
+07:06:07.000000001
+08:07:08.000001000
+09:08:09.001000000
+10:09:10.010203040
+11:10:11.100000000
+12:11:12.999999999
+838:59:59.000000000
+838:59:59.000000000
+838:59:59.000000000
 
 -- !sql_timediff_DateV2_DateTimeV2 --
 \N
@@ -219,18 +219,18 @@
 
 -- !sql_timediff_DateV2_TimestampNs --
 \N
-838:59:59.000000
-838:59:59.000000
-838:59:59.000000
--838:59:59.000000
--838:59:59.000000
--838:59:59.000000
--07:06:07.000000
--08:07:08.000001
--09:08:09.001000
--10:09:10.010203
--11:10:11.100000
--12:11:12.999999
+838:59:59.000000000
+838:59:59.000000000
+838:59:59.000000000
+-838:59:59.000000000
+-838:59:59.000000000
+-838:59:59.000000000
+-07:06:07.000000001
+-08:07:08.000001000
+-09:08:09.001000000
+-10:09:10.010203040
+-11:10:11.100000000
+-12:11:12.999999999
 
 -- !sql_timediff_DateV2_DateTimeV2_notnull --
 -01:00:01
@@ -247,18 +247,18 @@
 -12:11:12
 
 -- !sql_timediff_DateV2_TimestampNs_notnull --
-838:59:59.000000
-838:59:59.000000
-838:59:59.000000
--838:59:59.000000
--838:59:59.000000
--838:59:59.000000
--07:06:07.000000
--08:07:08.000001
--09:08:09.001000
--10:09:10.010203
--11:10:11.100000
--12:11:12.999999
+838:59:59.000000000
+838:59:59.000000000
+838:59:59.000000000
+-838:59:59.000000000
+-838:59:59.000000000
+-838:59:59.000000000
+-07:06:07.000000001
+-08:07:08.000001000
+-09:08:09.001000000
+-10:09:10.010203040
+-11:10:11.100000000
+-12:11:12.999999999
 
 -- !sql_timediff_DateV2_DateV2 --
 \N
@@ -306,18 +306,18 @@
 
 -- !sql_timediff_TimestampNs_DateTime --
 \N
--838:59:59.000000
--838:59:59.000000
--838:59:59.000000
-00:00:00.000000
-00:00:00.000001
-00:00:00.001000
-00:00:00.010203
-00:00:00.100000
-00:00:00.999999
-838:59:59.000000
-838:59:59.000000
-838:59:59.000000
+-838:59:59.000000000
+-838:59:59.000000000
+-838:59:59.000000000
+00:00:00.000000001
+00:00:00.000001000
+00:00:00.001000000
+00:00:00.010203040
+00:00:00.100000000
+00:00:00.999999999
+838:59:59.000000000
+838:59:59.000000000
+838:59:59.000000000
 
 -- !sql_timediff_DateTimeV2_DateTime_notnull --
 00:00:00
@@ -334,18 +334,18 @@
 00:00:00
 
 -- !sql_timediff_TimestampNs_DateTime_notnull --
--838:59:59.000000
--838:59:59.000000
--838:59:59.000000
-00:00:00.000000
-00:00:00.000001
-00:00:00.001000
-00:00:00.010203
-00:00:00.100000
-00:00:00.999999
-838:59:59.000000
-838:59:59.000000
-838:59:59.000000
+-838:59:59.000000000
+-838:59:59.000000000
+-838:59:59.000000000
+00:00:00.000000001
+00:00:00.000001000
+00:00:00.001000000
+00:00:00.010203040
+00:00:00.100000000
+00:00:00.999999999
+838:59:59.000000000
+838:59:59.000000000
+838:59:59.000000000
 
 -- !sql_timediff_DateV2_DateTime --
 \N
diff --git a/regression-test/suites/datatype_p0/timestamp_ns/test_timestamp_ns_binary_output.groovy b/regression-test/suites/datatype_p0/timestamp_ns/test_timestamp_ns_binary_output.groovy
index 3d0a0fda568585..337efa513046df 100644
--- a/regression-test/suites/datatype_p0/timestamp_ns/test_timestamp_ns_binary_output.groovy
+++ b/regression-test/suites/datatype_p0/timestamp_ns/test_timestamp_ns_binary_output.groovy
@@ -60,4 +60,15 @@ suite("test_timestamp_ns_binary_output") {
         qe_binary_protocol stmt
         stmt.close()
     }
+
+    connect(user, password, url) {
+        PreparedStatement stmt = prepareStatement("""
+            select cast('12:34:56.123456789' as time(9)) where ? = 1
+        """)
+        assertEquals(ServerPreparedStatement, stmt.class)
+        assertEquals(Types.CHAR, stmt.metaData.getColumnType(1))
+        stmt.setInt(1, 1)
+        qe_timev2_binary_protocol stmt
+        stmt.close()
+    }
 }
diff --git a/regression-test/suites/datatype_p0/timestamp_ns/test_timestamp_ns_functions.groovy b/regression-test/suites/datatype_p0/timestamp_ns/test_timestamp_ns_functions.groovy
index 144306be9682d7..94cb367ab351d2 100644
--- a/regression-test/suites/datatype_p0/timestamp_ns/test_timestamp_ns_functions.groovy
+++ b/regression-test/suites/datatype_p0/timestamp_ns/test_timestamp_ns_functions.groovy
@@ -94,6 +94,20 @@ suite("test_timestamp_ns_functions") {
     sql "set debug_skip_fold_constant = false"
     testFoldConst(scalarFunctionConstantsSql)
 
+    order_qt_timev2_nanosecond_precision """
+        select
+            cast('12:34:56.123456789' as time(9)),
+            cast('-00:00:00.000000001' as time(9)),
+            cast(cast('2024-02-29 12:34:56.123456789' as timestamp_ns) as time(9)),
+            time_format(cast('12:34:56.123456789' as time(9)), '%f|%n'),
+            sec_to_time(1.123456789),
+            maketime(1, 2, 3.123456789),
+            add_time(cast('2024-02-29 12:34:56.123456789' as timestamp_ns),
+                     cast('00:00:00.000000001' as time(9))),
+            sub_time(cast('2024-02-29 12:34:56.123456789' as timestamp_ns),
+                     cast('00:00:00.000000001' as time(9)))
+    """
+
     def additionalCalendarFunctionsSql = """
         select
             months_between(