[BUG] ORC writer can generate bad results for timestamp column when read by cpu/gpu orc readers

[kuhushukla]

Describe the bug
When an orc file is written with a column of timestamps, it seems to return incorrect values when read back using the orc reader in cudf. It also fails when the file is read by the cpu orc reader.

Steps/Code to reproduce bug

Below is the test case I wrote using the cudf java api and spark api. Note the difference in input and output. If there are bits missing in how the timestamp was passed to the orc writer, I appreciate any guidance on that. I am also attaching the orc file generated by this test(rename to *.orc)

cudf-low-level-write-1752173860964.orc.txt

Output from GPU and input is :

+--------------------------+
|LONG                      |
+--------------------------+
|1780-02-20 03:02:11.654891|
|2017-11-22 01:48:37.52192 |
+--------------------------+

.............................
dataStrings: Seq[String] = List(2364-09-10 02:36:45.364442, 3187-01-01 00:57:44.941024)

import ai.rapids.cudf.{ColumnVector, DType, HostColumnVector, Table, ORCWriterOptions, TableWriter, CompressionType, ColumnWriterOptions}
import org.apache.spark.sql.{SparkSession, Row, SaveMode}
import org.apache.spark.sql.types.{StructType, StructField, StringType, TimestampType}
import org.apache.spark.sql.functions.col
import java.io.File
import java.time.{LocalDateTime, ZoneOffset}
import java.time.format.DateTimeFormatter

// This script combines low-level and high-level APIs to debug a timestamp write issue.
// 1. Low-Level: Dumps raw nanosecond values and writes an ORC file using a structured options builder.
// 2. High-Level: Reproduces the failing CPU read on the file created in Part 1.

object WriterOptionsHelper {
  // Define an enumeration to replace the Java enum
  object Columns extends Enumeration {
    type Columns = Value
    val BOOL, INT, LONG, FLOAT, DOUBLE, BYTE, STRING, DECIMAL64, DECIMAL128,
        STRUCT, LIST, LIST_STRUCT, STRUCT_DEC128, LIST_DEC128 = Value
  }

  def structBuilder(name: String): ColumnWriterOptions.StructBuilder = ColumnWriterOptions.structBuilder(name)
  def listBuilder(name: String): ColumnWriterOptions.ListBuilder = ColumnWriterOptions.listBuilder(name)
  // FIX: Added wildcard type parameters `[_, _]` to NestedBuilder because it is a generic class.
  def buildWriterOptions(builder: ColumnWriterOptions.NestedBuilder[_, _], colName: String): Unit = {
    Columns.withName(colName) match {
      case Columns.BOOL | Columns.INT | Columns.LONG | Columns.FLOAT |
           Columns.DOUBLE | Columns.BYTE | Columns.STRING =>
        builder.withColumns(false, colName)
      case Columns.DECIMAL64 =>
        builder.withDecimalColumn(colName, DType.DECIMAL64_MAX_PRECISION)
      case Columns.DECIMAL128 =>
        builder.withDecimalColumn(colName, DType.DECIMAL128_MAX_PRECISION)
      case Columns.STRUCT =>
        builder.withStructColumn(structBuilder(colName)
            .withNullableColumns("ch_int")
            .withNullableColumns("ch_str")
            .withDecimalColumn("ch_dec64", DType.DECIMAL64_MAX_PRECISION, true)
            .build())
      case Columns.LIST =>
        builder.withListColumn(listBuilder(colName)
            .withNonNullableColumns("ch_int")
            .build())
      case Columns.LIST_STRUCT =>
        builder.withListColumn(listBuilder(colName)
            .withStructColumn(structBuilder(colName)
                .withNullableColumns("ch_int")
                .withNullableColumns("ch_str")
                .withDecimalColumn("ch_dec64", DType.DECIMAL64_MAX_PRECISION, true)
                .build())
            .build())
      case Columns.STRUCT_DEC128 =>
        builder.withStructColumn(structBuilder(colName)
            .withDecimalColumn("ch_dec128", DType.DECIMAL128_MAX_PRECISION, true)
            .build())
      case Columns.LIST_DEC128 =>
        builder.withListColumn(listBuilder(colName)
            .withStructColumn(structBuilder(colName)
                .withDecimalColumn("ch_dec128", DType.DECIMAL128_MAX_PRECISION, true)
                .build())
            .build())
      case _ =>
        throw new IllegalArgumentException("should NOT reach here")
    }
  }
}

println("--- Part 1: Low-Level Data Inspection and ORC Write (CUDF JNI) ---")

val dataStrings = Seq(
  // "1107-05-10 12:00:23.316538",
  // "9999-12-30 23:59:59.999999",
  // "1301-03-04 18:03:01.352251",
  "2364-09-10 02:36:45.364442",
  "3187-01-01 00:57:44.941024"
)
val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSS")
val tempFile = new File(System.getProperty("java.io.tmpdir"), "cudf-low-level-write-" + System.currentTimeMillis() + ".orc")
// tempFile.deleteOnExit()
val orcPath = tempFile.getAbsolutePath

var initialHostVector: HostColumnVector = null
var deviceVector: ColumnVector = null
var roundtripHostVector: HostColumnVector = null
var table: Table = null
var writer: TableWriter = null

try {
  // Step 1a: Create the vector on the host (CPU).
  println("\nStep 1a: Creating initial HostColumnVector (CPU)...")
  val builder = HostColumnVector.builder(DType.TIMESTAMP_NANOSECONDS, dataStrings.length)
  dataStrings.foreach { str =>
      val ldt = LocalDateTime.parse(str, formatter)
      val nanos = ldt.toEpochSecond(ZoneOffset.UTC) * 1000000000L + ldt.getNano()
      builder.append(nanos)
  }
  initialHostVector = builder.build()

  // Step 1b: DUMP BUFFER from the initial CPU vector.
  println("\nStep 1b: Dumping buffer from initial CPU data...")
  (0L until initialHostVector.getRowCount).foreach { i =>
    println(f"  - CPU Row $i: ${initialHostVector.getLong(i)}%20d L")
  }

  // Step 1c: Copy to GPU and back to CPU for verification.
  println("\nStep 1c: Copying data to GPU and back to CPU...")
  deviceVector = initialHostVector.copyToDevice()
  roundtripHostVector = deviceVector.copyToHost()
  println("  - Roundtrip complete.")

  // Step 1d: A bit redudant DUMP BUFFER from the round-tripped CPU vector.
  println("\nStep 1d: Dumping buffer from round-tripped CPU data...")
  (0L until roundtripHostVector.getRowCount).foreach { i =>
    val originalNanos = initialHostVector.getLong(i)
    val roundtripNanos = roundtripHostVector.getLong(i)
    val status = if (originalNanos == roundtripNanos) "OK" else "CORRUPTED"
    println(f"  - Roundtrip Row $i: ${roundtripNanos}%20d L (Status: $status)")
  }

  // Step 1e: Drive the deviceVector to a Table and write to ORC.
  println(s"\nStep 1e: Writing low-level CUDF Table to ORC file at: $orcPath")
  table = new Table(deviceVector)
  deviceVector = null // The table now owns the vector.

  // Use the helper function to configure the ORC writer options
  val writerOptionsBuilder = ORCWriterOptions.builder()
  WriterOptionsHelper.buildWriterOptions(writerOptionsBuilder, "LONG")
  val writerOptions = writerOptionsBuilder.build()
  
  // Create the writer targeting the file directly.
  writer = Table.writeORCChunked(writerOptions, tempFile)
  writer.write(table)
  println("  - Successfully wrote table to file.")

} finally {
  println("\nStep 1f: Cleaning up low-level resources...")
  if (writer != null) writer.close()
  if (table != null) table.close()
  if (deviceVector != null) deviceVector.close()
  if (initialHostVector != null) initialHostVector.close()
  if (roundtripHostVector != null) roundtripHostVector.close()
}


// --- Part 2: High-Level Failure Reproduction (Spark RAPIDS) ---
println("\n\n--- Part 2: High-Level Failure Reproduction (Spark RAPIDS) ---")

// Use the same data to create a DataFrame
val dataRows = dataStrings.map(Row(_))
val schema = new StructType().add(StructField("timestamp_str", StringType, nullable = true))
val initialDf = spark.createDataFrame(spark.sparkContext.parallelize(dataRows), schema)
val df = initialDf.withColumn("timestamp_col", col("timestamp_str").cast("timestamp")).drop("timestamp_str")

println(s"\nStep 2a: Attempting to read ORC file from '$orcPath' with CPU Spark...")
println("  - This is where the 'nanos > 999999999' error is expected to occur.")

try {
  spark.conf.set("spark.rapids.sql.enabled", "false")
  val dfReadCpu = spark.read.orc(orcPath)
  dfReadCpu.show(false)
} catch {
  case e: Exception =>
    println("\nERROR: As expected, the CPU read failed.")
    e.printStackTrace()
} finally {
  spark.conf.set("spark.rapids.sql.enabled", true)
  val dfReadGpu = spark.read.orc(orcPath)
  dfReadGpu.show(false)
}

Sample output that shows the mismatch:

Step 1e: Writing low-level CUDF Table to ORC file at: /tmp/cudf-low-level-write-1752173860964.orc
  - Successfully wrote table to file.

Step 1f: Cleaning up low-level resources...


--- Part 2: High-Level Failure Reproduction (Spark RAPIDS) ---

Step 2a: Attempting to read ORC file from '/tmp/cudf-low-level-write-1752173860964.orc' with CPU Spark...
  - This is where the 'nanos > 999999999' error is expected to occur.
25/07/10 18:57:41 ERROR Executor: Exception in task 0.0 in stage 20.0 (TID 20)
java.lang.IllegalArgumentException: nanos > 999999999 or < 0
	at java.sql/java.sql.Timestamp.setNanos(Timestamp.java:336)
	at org.apache.hadoop.hive.ql.exec.vector.TimestampColumnVector.asScratchTimestamp(TimestampColumnVector.java:139)
	at org.apache.spark.sql.execution.datasources.orc.OrcAtomicColumnVector.getLong(OrcAtomicColumnVector.java:107)
	at org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage1.processNext(Unknown Source)
	at org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)
	at org.apache.spark.sql.execution.WholeStageCodegenEvaluatorFactory$WholeStageCodegenPartitionEvaluator$$anon$1.hasNext(WholeStageCodegenEvaluatorFactory.scala:43)
	at org.apache.spark.sql.execution.SparkPlan.$anonfun$getByteArrayRdd$1(SparkPlan.scala:388)
	at org.apache.spark.rdd.RDD.$anonfun$mapPartitionsInternal$2(RDD.scala:893)
	at org.apache.spark.rdd.RDD.$anonfun$mapPartitionsInternal$2$adapted(RDD.scala:893)
	at org.apache.spark.rdd.MapPartitionsRDD.compute(MapPartitionsRDD.scala:52)
	at org.apache.spark.rdd.RDD.computeOrReadCheckpoint(RDD.scala:367)
	at org.apache.spark.rdd.RDD.iterator(RDD.scala:331)
	at org.apache.spark.scheduler.ResultTask.runTask(ResultTask.scala:93)
	at org.apache.spark.TaskContext.runTaskWithListeners(TaskContext.scala:166)
	at org.apache.spark.scheduler.Task.run(Task.scala:141)
	at org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$4(Executor.scala:620)
	at org.apache.spark.util.SparkErrorUtils.tryWithSafeFinally(SparkErrorUtils.scala:64)
	at org.apache.spark.util.SparkErrorUtils.tryWithSafeFinally$(SparkErrorUtils.scala:61)
	at org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:94)
	at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:623)
	at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
	at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
	at java.base/java.lang.Thread.run(Thread.java:829)

	.....................................................................................
        .....................................................................................

25/07/10 18:57:41 WARN GpuOverrides: 
!Exec <CollectLimitExec> cannot run on GPU because the Exec CollectLimitExec has been disabled, and is disabled by default because Collect Limit replacement can be slower on the GPU, if huge number of rows in a batch it could help by limiting the number of rows transferred from GPU to CPU. Set spark.rapids.sql.exec.CollectLimitExec to true if you wish to enable it
  @Partitioning <SinglePartition$> could run on GPU

+--------------------------+
|LONG                      |
+--------------------------+
|1780-02-20 03:02:11.654891|
|2017-11-22 01:48:37.52192 |
+--------------------------+

.............................
dataStrings: Seq[String] = List(2364-09-10 02:36:45.364442, 3187-01-01 00:57:44.941024)

Expected behavior
GPU read result should match input. CPU side read should succeed past the assert failure.

Environment overview (please complete the following information)

• baremetal 25.08 release
  Environment details
  NA

Additional context
NA

[GregoryKimball]

Thank you @kuhushukla for posting this. Would you please clarify what you see happening to the data in this case? I'm not following the content you posted above.

When I study the file you posted in python, I don't see any issues between different readers and writers. For example:

print("1. Reading o.orc with cudf:")
df = cudf.read_orc("o.orc")
print(df)

print("2. Writing with pandas, reading back with cudf:")
df.to_pandas().to_orc("pandas_out.orc")
df_pandas_out = cudf.read_orc("pandas_out.orc")
print(df_pandas_out)

print("3. Writing with cudf, reading back with cudf:")
df.to_orc("cudf_out.orc")
df_cudf_out = cudf.read_orc("cudf_out.orc")
print(df_cudf_out)

print("4. Writing with pyarrow, reading back with cudf:")
df_pandas = df.to_pandas()
table = pa.Table.from_pandas(df_pandas)
orc.write_table(table, "pyarrow_out.orc")
df_pyarrow_out = cudf.read_orc("pyarrow_out.orc")
print(df_pyarrow_out)

1. Reading o.orc with cudf:
                           LONG
0 1780-02-20 03:02:11.654890384
1 2017-11-22 01:48:37.521920768
2. Writing with pandas, reading back with cudf:
                           LONG
0 1780-02-20 03:02:11.654890384
1 2017-11-22 01:48:37.521920768
3. Writing with cudf, reading back with cudf:
                           LONG
0 1780-02-20 03:02:11.654890384
1 2017-11-22 01:48:37.521920768
4. Writing with pyarrow, reading back with cudf:
                           LONG
0 1780-02-20 03:02:11.654890384
1 2017-11-22 01:48:37.521920768

[kuhushukla]

Thank you, @GregoryKimball . I'm using the input below in my test case and like in your test case, the output reads quite different from the input.

dataStrings: Seq[String] = List(2364-09-10 02:36:45.364442, 3187-01-01 00:57:44.941024) . In the test:

val dataStrings = Seq(
  // "1107-05-10 12:00:23.316538",
  // "9999-12-30 23:59:59.999999",
  // "1301-03-04 18:03:01.352251",
  "2364-09-10 02:36:45.364442",
  "3187-01-01 00:57:44.941024"
)

I should also clarify that this happens for certain inputs only but I am yet to find a pattern between the cases that trigger it versus not.
I'll try the python tests and try and repro it that way, if you don't see this issue with the input above.

[kuhushukla]

@GregoryKimball Here is the python test which seems to indicate that the issue shows up prior to orc write (notice the data and the gpu_df variables). However, something about this data also throws off a CPU side read in Spark as shown in the stack trace above on setNanos .

import cudf
import os

# --- Part 1: Create a cuDF DataFrame from Timestamp Strings ---
# Input data as a list of strings
data = [
    "2364-09-10 02:36:45.364442",
    "3187-01-01 00:57:44.941024"
]

print("--- Step 1: Creating a cuDF DataFrame ---")
timestamp_series = cudf.to_datetime(data, format='%Y-%m-%d %H:%M:%S.%f')
gpu_df = cudf.DataFrame({'event_timestamp': timestamp_series})

print("\nOriginal DataFrame on GPU:")
print(gpu_df)
print("\nData types:")
print(gpu_df.dtypes)

# --- Part 2: Write the DataFrame to an ORC file ---
orc_file_path = 'timestamps.orc'
gpu_df.to_orc(orc_file_path)
print("Successfully wrote ORC file.")

# --- Part 3: Read the ORC file back into a new DataFrame ---
read_gpu_df = cudf.read_orc(orc_file_path)

print("DataFrame read back from ORC file:")
print(read_gpu_df)
print("\nData types of re-read DataFrame:")
print(read_gpu_df.dtypes)
if os.path.exists(orc_file_path):
    os.remove(orc_file_path)

The Output from cudf df creation:

>>> print(gpu_df)
                event_timestamp
0 1780-02-20 03:02:11.654890384
1 2017-11-22 01:48:37.521920768

[vuule]

I'm seeing something similar:

    df = cudf.DataFrame(
        {
            "a": [
                pd.Timestamp("2364-09-10 02:36:45.364442"),
            ]
        }
    )

fails with TypeError: Cannot convert a datetime of object type.
Based on #19350 (comment), this does not look like an ORC issue to me.
I suspect an int64 overflow; maybe cudf.to_datetime does not check the range, while cudf.DataFrame does.

[revans2]

I think that there is some confusion that is happening here. The repro code that @kuhushukla has produced is using nonosecond timestamps, which will have overflow issues for the timestamps provided. But internally Spark is using microsecond timestamps which does not have that overflow problem. My understanding is that we pass microsecond timestamps to CUDF when writing out ORC files, I need to confirm this, just because the code is really complex. So if there is an overflow happening, then it is happening in CUDF when trying to split the input timestamp into seconds and nono-seconds.

I spoke with @kuhushukla and she is going to try and come up with a simpler repro case where we just create the microsecond timestamps directly from the INT64 value that spark converts them to internally.

[kuhushukla]

@vuule , @GregoryKimball I have a repro (zip file attached with file names described here) ,where some values that lie beyond the range that pandas can take, the spark behavior with the GPU plugin differs when the files created are in ORC versus Parquet. The Spark parquet GPU read succeeds while the ORC read fails.

Original Input for the dataframe :

val dataStrings = Seq(
  "3397-06-08 14:54:45.074778",
  "5665-05-17 10:09:15.579786",
  "0910-10-03 16:34:41.942496",
  "1970-01-01 00:00:00.942496",
  "0251-11-16 16:37:28.776749"
)

compareOrc.scala writes ORC files using Spark CPU and spark GPU writers. It then reads it back with each of the readers. The CPU read of the GPU file fails and the log is at : orc_scala_output.log.

Caused by: java.lang.IllegalArgumentException: nanos > 999999999 or < 0
  at java.sql/java.sql.Timestamp.setNanos(Timestamp.java:336)
  at org.apache.hadoop.hive.ql.exec.vector.TimestampColumnVector.asScratchTimestamp(TimestampColumnVector.java:139)
  at org.apache.spark.sql.execution.datasources.orc.OrcAtomicColumnVector.getLong(OrcAtomicColumnVector.java:107)

compareParquet.scala writes Parquet files using Spark CPU and spark GPU writers. It then reads it back with each of the readers. All reads pass. Log is at : parquet_scala_output.log

The file outputs from above are spark_cpu.snappy.orc and spark_gpu.snappy.orc

I read these files using cudf and pandas and the values are quite different given some of these are out of bounds.
Output for the df value above when read using pandas (excerpt from the log file)

Contents of GPU-written file (Pandas):
                  timestamp_col
0 2228-04-30 15:45:37.655674768
1 2158-01-19 12:41:53.322476304
2 2079-11-11 15:43:49.361599232
3 1970-01-01 00:00:00.942496000
4 2005-07-15 15:21:09.905403848

I, then, did a plain pandas write and read which fails for OOB values

pandas._libs.tslibs.np_datetime.OutOfBoundsDatetime: Out of bounds nanosecond timestamp: 3397-06-08 14:54:45.074778, at position 0

since the api converts to nanoseconds and there isn’t a way to do this with microseconds as far as I know.
cudf_issue_19350.zip

[GregoryKimball]

Thanks @kuhushukla for attempting to create a cuDF-python repro. I looks like microsecond timestamps are not working in the python layer, and creating a python repro may not be possible.

I believe the next step will be getting a C++ repro. I will update this issue when we have identified an owner for that.

[res-life]

Relevant issues:

• [BUG] ORC reader does not produce correct dates/timestamps for dates < 1590 or so cudf-spark#131
• [BUG] GPU generates a wrong file when writing timestamp < 1970 year. cudf-spark#13272

[kuhushukla]

@GregoryKimball Here is my attempt at a cpp repro for this: Note the outputs below for different input values in the second code block. If there is a better way to print these values back on host or if you see any issues, let me know and I can tweak the code.
This test was done with microseconds.

#include <cudf/column/column_factories.hpp>
#include <cudf/column/column_view.hpp>
#include <cudf/strings/convert/convert_datetime.hpp>
#include <cudf/strings/strings_column_view.hpp>
#include <cudf/table/table.hpp>
#include <cudf/types.hpp>

#include <rmm/device_uvector.hpp>
#include <rmm/mr/device/cuda_memory_resource.hpp>

#include <chrono>
#include <iomanip>
#include <iostream>
#include <memory>
#include <string>
#include <vector>

int main()
{
  // Set up RMM
  rmm::mr::cuda_memory_resource cuda_mr;
  rmm::mr::set_current_device_resource(&cuda_mr);

  // Input data
  //uncomment for failure case 1
//  std::vector<std::string> data_strings = {"3397-06-08 14:54:45.074778",
//                                          "5665-05-17 10:09:15.579786",
//                                          "0910-10-03 16:34:41.942496",
//                                           "1970-01-01 00:00:00.942496",
//                                           "0251-11-16 16:37:28.776749"};
  //failure case 2
  std::vector<std::string> data_strings = {"2364-09-10 02:36:45.364442", "3187-01-01 00:57:44.941024"};
  // success case 
  //std::vector<std::string> data_strings = {"2025-09-10 02:36:45.364442", "2025-01-01 00:57:44.941024"};
  std::cout << "Input string data:\n";
  for (auto const& s : data_strings) {
    std::cout << "- " << s << "\n";
  }
  std::cout << "\n";

  //Create strings column from host data
  std::vector<cudf::size_type> offsets;
  offsets.push_back(0);
  std::string chars;
  for (auto const& s : data_strings) {
    chars.append(s);
    offsets.push_back(static_cast<cudf::size_type>(chars.size()));
  }

  rmm::device_uvector<cudf::size_type> d_offsets(offsets.size(), rmm::cuda_stream_default);
  RMM_CUDA_TRY(cudaMemcpy(d_offsets.data(),
                          offsets.data(),
                          offsets.size() * sizeof(cudf::size_type),
                          cudaMemcpyHostToDevice));
  rmm::device_buffer d_chars(chars.size(), rmm::cuda_stream_default);
  RMM_CUDA_TRY(
    cudaMemcpy(d_chars.data(), chars.data(), chars.size(), cudaMemcpyHostToDevice));
  auto offsets_col =
    std::make_unique<cudf::column>(std::move(d_offsets), rmm::device_buffer{}, 0);
  auto strings_col = cudf::make_strings_column(
    data_strings.size(), std::move(offsets_col), std::move(d_chars), 0, rmm::device_buffer{});

  //Convert strings to timestamps
  std::string const format = "%Y-%m-%d %H:%M:%S.%f";
  auto timestamps_col    = cudf::strings::to_timestamps(
    cudf::strings_column_view(strings_col->view()),
    cudf::data_type{cudf::type_id::TIMESTAMP_MICROSECONDS},
    format);
  std::cout << "Successfully converted strings to timestamps.\n\n";

  //Print the data
  std::cout << "--- Data After Conversion to Timestamp ---\n";
  auto const& final_col_view = timestamps_col->view();
  std::vector<int64_t> h_final_data(final_col_view.size());
  RMM_CUDA_TRY(cudaMemcpy(h_final_data.data(),
                          final_col_view.data<int64_t>(),
                          final_col_view.size() * sizeof(int64_t),
                          cudaMemcpyDeviceToHost));

  std::string print_format = format;
  auto pos                 = print_format.find(".%f");
  if (pos != std::string::npos) { print_format.erase(pos); }

  for (cudf::size_type i = 0; i < h_final_data.size(); ++i) {
    auto const micro_epoch = std::chrono::microseconds(h_final_data[i]);
    auto const time_point  = std::chrono::system_clock::from_time_t(0) + micro_epoch;
    auto const time_t_val  = std::chrono::system_clock::to_time_t(time_point);
    auto const micros      = h_final_data[i] % 1000000;

    std::tm* tm_val = std::gmtime(&time_t_val);

    std::cout << "- Row " << i << ": ";
    if (tm_val != nullptr) {
      std::cout << std::put_time(tm_val, print_format.c_str()) << "." << std::setw(6)
                << std::setfill('0') << micros;
    } else {
      std::cout << "INVALID TIMESTAMP (Out of range for std::gmtime)";
    }
    std::cout << " (Raw: " << h_final_data[i] << ")\n";
  }
  std::cout << "----------------------------------------\n";

  return 0;
}

Output Iterations:

$ ./datetime_example 
Input string data:
- 3397-06-08 14:54:45.074778
- 5665-05-17 10:09:15.579786
- 0910-10-03 16:34:41.942496
- 1970-01-01 00:00:00.942496
- 0251-11-16 16:37:28.776749

Successfully converted strings to timestamps.

--- Data After Conversion to Timestamp ---
- Row 0: 1925-11-29 11:51:17.674768 (Raw: 8152069537655674768)
- Row 1: 1795-06-13 18:39:49.476304 (Raw: 5934343313322476304)
- Row 2: 1936-11-21 18:05:05.599232 (Raw: 3466943029361599232)
- Row 3: 1970-01-01 00:15:42.496000 (Raw: 942496000)
- Row 4: 1849-04-01 18:36:50.403848 (Raw: 1121440869905403848)
----------------------------------------



$ ./datetime_example 
Input string data:
- 2364-09-10 02:36:45.364442
- 3187-01-01 00:57:44.941024

Successfully converted strings to timestamps.

--- Data After Conversion to Timestamp ---
- Row 0: 1780-02-20 03:02:12.364442 (Raw: 12455260605364442)
- Row 1: 2017-11-22 01:48:37.941024 (Raw: 38404803464941024)
----------------------------------------

Input string data:
- 2025-09-10 02:36:45.364442
- 2025-01-01 00:57:44.941024

Successfully converted strings to timestamps.

--- Data After Conversion to Timestamp ---
- Row 0: 2025-09-10 02:36:45.364442 (Raw: 1757471805364442)
- Row 1: 2025-01-01 00:57:44.941024 (Raw: 1735693064941024)
----------------------------------------