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(