impl(bq_driver): Picosecond support

Author: Khushikathuria008

google/cloud/odbc/bq_driver/internal/data_translation.cc

@@ -935,26 +935,79 @@ odbc_internal::StatusRecord ConvertFromTimeDSValue(DSValue const& src_dsval,
   return status_record;
 }
 
+odbc_internal::StatusRecord ConvertTimestampStringToChar(
+    const std::string& timestamp_src_str,
+    void* dest_buf,
+    SQLLEN buffer_length,
+    SQLLEN* res_len) {
+
+    constexpr SQLLEN k_timestamp_src_len = 64; // adjust if needed
+    auto* dest = reinterpret_cast<char*>(dest_buf);
+    StatusRecord status_record;
+
+    if (buffer_length > k_timestamp_src_len) {
+        if (res_len) *res_len = k_timestamp_src_len;
+        std::strncpy(dest, timestamp_src_str.c_str(), k_timestamp_src_len);
+        dest[k_timestamp_src_len] = '\0';
+    } else if (20 <= buffer_length && buffer_length <= k_timestamp_src_len) {
+        if (res_len) *res_len = buffer_length;
+        std::strncpy(dest, timestamp_src_str.c_str(), buffer_length - 1);
+        dest[buffer_length - 1] = '\0';
+        status_record = StatusRecord{SQLStates::k_01004(), "Data truncated"};
+    } else {
+        status_record =
+            StatusRecord{SQLStates::k_22003(), "Buffer length is insufficient"};
+    }
+    return status_record;
+}
+
+odbc_internal::StatusRecord ConvertTimestampStringToWChar(
+    const std::string& timestamp_src_str,
+    void* dest_buf,
+    SQLLEN buffer_length,
+    SQLLEN* res_len) {
+
+    StatusRecord status_record;
+    auto wstr_or = Utf8ToUtf16(timestamp_src_str);
+    if (!wstr_or) {
+        return StatusRecord{SQLStates::k_HY000(), "DSValueToWchar Conversion Failed"};
+    }
+
+    std::vector<SQLWCHAR> wstr_data(wstr_or->begin(), wstr_or->end());
+    wstr_data.emplace_back(L'\0');
+
+    auto* dest = reinterpret_cast<SQLWCHAR*>(dest_buf);
+
+    if (buffer_length > static_cast<SQLLEN>(wstr_or->size())) {
+        if (res_len) *res_len = wstr_or->size() * sizeof(SQLWCHAR);
+        std::memcpy(dest, wstr_data.data(), wstr_or->size() * sizeof(SQLWCHAR));
+        dest[wstr_or->size()] = L'\0';
+    } else if (20 <= buffer_length && buffer_length <= static_cast<SQLLEN>(wstr_or->size())) {
+        if (res_len) *res_len = buffer_length * sizeof(SQLWCHAR);
+        std::memcpy(dest, wstr_data.data(), buffer_length * sizeof(SQLWCHAR));
+        dest[buffer_length - 1] = L'\0';
+        status_record = StatusRecord{SQLStates::k_01004(), "Data truncated"};
+    } else {
+        status_record =
+            StatusRecord{SQLStates::k_22003(), "Buffer length is insufficient"};
+    }
+
+    return status_record;
+}
 odbc_internal::StatusRecord ConvertFromTimestampDSValue(
     DSValue const& src_dsval, DataBuffer& dest_data) {
-  using odbc_internal::SQLStates;
-  using odbc_internal::StatusRecord;
-  using odbc_internal::StatusRecordOr;
 
-  SQL_TIMESTAMP_STRUCT timestamp_src_struct;
-  DSValueToTimestamp(src_dsval, timestamp_src_struct);
+    using odbc_internal::SQLStates;
+    using odbc_internal::StatusRecord;
 
-  std::string timestamp_src_str;
-  timestamp_src_str = FormatTimestampToString(timestamp_src_struct);
+    std::string str_val;
+    DSValueToString(src_dsval, str_val);
+    std::string timestamp_src_str;
 
-  SQLSMALLINT dest_type = dest_data.type;
-  SQLPOINTER dest_buf = dest_data.buf;
-  SQLLEN buffer_length = dest_data.buflen;
-  SQLLEN* res_len = dest_data.result_len;
-
-  // Define length variables
-  int k_timestamp_src_len = timestamp_src_str.length();
-  constexpr int kTimestampBinaryLength = sizeof(SQL_TIMESTAMP_STRUCT);
+    SQLSMALLINT dest_type = dest_data.type;
+    SQLPOINTER dest_buf = dest_data.buf;
+    SQLLEN buffer_length = dest_data.buflen;
+    SQLLEN* res_len = dest_data.result_len;
 
   if (!dest_buf) {
     return StatusRecord::Ok();
@@ -1040,7 +1093,7 @@ odbc_internal::StatusRecord ConvertFromTimestampDSValue(
         if (res_len) {
           *res_len = kTimestampBinaryLength;
         }
-        timestamp_src_struct.fraction = timestamp_src_struct.fraction * 1000;
+        timestamp_src_struct.fraction = timestamp_src_struct.fraction;
         std::memcpy(dest_buf, &timestamp_src_struct, kTimestampBinaryLength);
 
       } else {

google/cloud/odbc/bq_driver/internal/odbc_conn_handle.cc

@@ -160,6 +160,12 @@ void ConnectionHandle::SetUp(Section& dsn_section,
   std::string job_creation_mode = dsn_section["JOBCREATIONMODE"];
   dsn_.is_job_creation_required = (job_creation_mode == "1");
 
+std::string timestamp_output_format =dsn_section["TIMESTAMPOUTPUTFORMAT"];
+if (!timestamp_output_format.empty()) {
+  dsn_.format_options.timestamp_output_format = timestamp_output_format;
+}
+
+
   if (attribute_str_values_.count(SQL_ATTR_CURRENT_CATALOG) == 0) {
     attribute_str_values_.insert({SQL_ATTR_CURRENT_CATALOG, dsn_.catalog});
   }

google/cloud/odbc/bq_driver/internal/odbc_conn_handle.h

@@ -73,6 +73,7 @@ struct Dsn {
   std::vector<ConnectionProperty> connection_properties;
   std::uint32_t row_fetched_per_block = 100000;
   std::uint32_t default_string_column_length = 16384;
+  google::cloud::bigquery_v2_minimal_internal::DataFormatOptions format_options;
   /////////////////////////////////////////////////////////////////
   // Optional Properties needed for HTAPI.
   /////////////////////////////////////////////////////////////////

google/cloud/odbc/bq_driver/internal/odbc_internal_commons.cc

@@ -166,6 +166,66 @@ int DaysInMonth(int year, int month) {
   return kDaysInMonth[month - 1];
 }
 
+std::string FloatTimestampToString(const std::string& ts) {
+  double seconds_since_epoch = std::stod(ts);
+  time_t sec = static_cast<time_t>(seconds_since_epoch);
+  double fractional = seconds_since_epoch - static_cast<double>(sec);
+  std::tm tm{};
+#ifdef _WIN32
+  gmtime_s(&tm, &sec);
+#else
+  gmtime_r(&sec, &tm);
+#endif
+
+  int microseconds = static_cast<int>(std::round(fractional * 1'000'000));
+  if (microseconds == 1'000'000) {
+    microseconds = 0;
+    sec += 1;
+#ifdef _WIN32
+    gmtime_s(&tm, &sec);
+#else
+    gmtime_r(&sec, &tm);
+#endif
+  }
+
+  std::ostringstream out;
+  out << std::put_time(&tm, "%Y-%m-%d %H:%M:%S")
+      << "." << std::setw(6) << std::setfill('0') << microseconds;
+
+  return out.str();
+}
+
+SQL_TIMESTAMP_STRUCT ConvertStrToTimestampStruct(std::string const& str) {
+  SQL_TIMESTAMP_STRUCT ts = {};
+  int micro = 0;
+  int matched = 0;
+
+  static constexpr const char* kFormats[] = {
+      // ISO 8601: YYYY-MM-DDTHH:MM:SS[.ffffff]
+      "%4hd-%2hd-%2hdT%2hd:%2hd:%2hd.%6d",
+      // Space-separated: YYYY-MM-DD HH:MM:SS[.ffffff]
+      "%4hd-%2hd-%2hd %2hd:%2hd:%2hd.%6d",
+      // Compact (legacy): YYYY-MM-DDHH:MM:SS[.ffffff]
+      "%4hd-%2hd-%2hd%2hd:%2hd:%2hd.%6d",
+  };
+
+  for (const char* fmt : kFormats) {
+    matched = sscanf(str.c_str(), fmt,
+                     &ts.year, &ts.month, &ts.day,
+                     &ts.hour, &ts.minute, &ts.second, &micro);
+    if (matched >= 6) {
+      break;
+    }
+  }
+
+  if (matched < 6) {
+    throw std::invalid_argument("Invalid timestamp: " + str);
+  }
+
+  ts.fraction = (matched == 7) ? micro : 0;
+  return ts;
+}
+
 StatusRecord ConvertUnixTimestampToTimestampStruct(
     double unix_timestamp, SQL_TIMESTAMP_STRUCT& timestamp_struct) {
   // Check for invalid timestamp (e.g., negative or non-finite)
@@ -483,9 +543,54 @@ std::string FormatNumericToString(SQL_NUMERIC_STRUCT numeric) {
   return result;
 }
 
+SQL_TIMESTAMP_STRUCT ConvertEpochStringToTimestamp(
+    const std::string& epoch_str) {
+    long double epoch = std::stold(epoch_str);
+    long long epoch_seconds = static_cast<long long>(epoch);
+    long double fractional_part = epoch - epoch_seconds;
+    long long fraction_ns =
+        static_cast<long long>(fractional_part * 1'000'000'000.0L);
+    if (fraction_ns < 0) {
+        fraction_ns += 1'000'000'000;
+        epoch_seconds -= 1;
+    }
+
+    time_t raw_time = static_cast<time_t>(epoch_seconds);
+    std::tm* timeinfo = std::gmtime(&raw_time);
+
+    SQL_TIMESTAMP_STRUCT ts{};
+    ts.year   = timeinfo->tm_year + 1900;
+    ts.month  = timeinfo->tm_mon + 1;
+    ts.day    = timeinfo->tm_mday;
+    ts.hour   = timeinfo->tm_hour;
+    ts.minute = timeinfo->tm_min;
+    ts.second = timeinfo->tm_sec;
+    ts.fraction = static_cast<SQLUINTEGER>(fraction_ns);  // ✅ exact fraction
+
+    return ts;
+}
+
 StatusRecordOr<SQL_TIMESTAMP_STRUCT> ConvertStringToTimestampStruct(
     std::string const& date_str) {
+  using odbc_internal::SQLStates;
+  using odbc_internal::StatusRecord;
   std::string cleaned_date_str = date_str;
+  bool looks_like_epoch =
+    cleaned_date_str.find('-') == std::string::npos &&
+    cleaned_date_str.find(':') == std::string::npos;
+
+  if (looks_like_epoch) {
+  try {
+    auto ts = ConvertEpochStringToTimestamp(cleaned_date_str);
+    return ts;
+  } catch (const std::exception& ex) {
+    return StatusRecord{SQLStates::k_HY000(),
+                        "Epoch conversion failed"};
+  }
+}
+  if (!cleaned_date_str.empty() && cleaned_date_str.back() == 'Z') {
+    cleaned_date_str.pop_back();
+  }
   std::replace(cleaned_date_str.begin(), cleaned_date_str.end(), 'T', ' ');
 
   SQL_TIMESTAMP_STRUCT date_struct = {};
@@ -495,10 +600,10 @@ StatusRecordOr<SQL_TIMESTAMP_STRUCT> ConvertStringToTimestampStruct(
   int hour;
   int minute;
   int second;
-  char fraction_str[10] = "0";
+  char fraction_str[13] = "0";
 
   int matched =
-      std::sscanf(cleaned_date_str.c_str(), "%4d-%2d-%2d %2d:%2d:%2d.%6s",
+      std::sscanf(cleaned_date_str.c_str(), "%4d-%2d-%2d %2d:%2d:%2d.%12s",
                   &year, &month, &day, &hour, &minute, &second, fraction_str);
 
   if (matched < 6) {
@@ -520,12 +625,16 @@ StatusRecordOr<SQL_TIMESTAMP_STRUCT> ConvertStringToTimestampStruct(
         return StatusRecord{SQLStates::k_HY000(),
                             "Fractional part is not a valid number"};
       }
-      fraction = fraction * 10 + (ch - '0');
-      ++len;
     }
-    for (; len < 6; ++len) {
-      fraction *= 10;
+    std::string frac_str(fraction_str);
+    // Truncate or pad to 9 digits (nanoseconds)
+    if (frac_str.size() > 7) {
+      frac_str.resize(6);  // truncate picoseconds
+    } else {
+      frac_str.append(6 - frac_str.size(), '0'); // pad to nanoseconds
     }
+
+    fraction = static_cast<SQLUINTEGER>(std::stoul(frac_str));
   }
 
   date_struct.year = static_cast<SQLSMALLINT>(year);
@@ -632,16 +741,27 @@ StatusRecordOr<ResultSet> ProcessResultSetRows(
             break;
           }
           case BQDataType::kTimeStamp: {
-            double unix_timestamp;
-            try {
-              unix_timestamp = std::stod(data);
-            } catch (std::exception const& ex) {
-              return StatusRecord{SQLStates::k_HY000(),
-                                  "data cannot be parsed as double"};
+            // Check if the string has a fraction part longer than 9 digits
+            auto dot_pos = data.find('.');
+            bool long_fraction = false;
+            if (dot_pos != std::string::npos) {
+                std::size_t fraction_length = data.size() - dot_pos - 1;
+                if (fraction_length > 9) {
+                    long_fraction = true;
+                }
             }
-            SQL_TIMESTAMP_STRUCT time_struct;
-            ConvertUnixTimestampToTimestampStruct(unix_timestamp, time_struct);
-            TimestampToDSValue(time_struct, row_val);
+
+            if (long_fraction) {
+                StringToDSValue(data,row_val);
+                break;
+            }
+            // Normal timestamp parsing
+            StatusRecordOr<SQL_TIMESTAMP_STRUCT> ts_status = ConvertStringToTimestampStruct(data);
+            if (!ts_status) {
+                return ts_status.GetStatusRecord();
+            }
+            const SQL_TIMESTAMP_STRUCT& ts = *ts_status;
+            TimestampToDSValue(ts, row_val);
             break;
           }
           case BQDataType::kInterval: {
@@ -1052,7 +1172,10 @@ PostQueryRequest ConstructBasicPostQueryRequest(
   bool is_query_cache = conn_handle.GetDsn().is_query_cache;
   PostQueryRequest post_request;
   QueryRequest query_request;
-  // Construct query request.
+  auto format_options = conn_handle.GetDsn().format_options;
+  if (!format_options.timestamp_output_format.empty()) {
+    query_request.set_format_options(format_options);
+  }
   query_request.set_dry_run(false);
   query_request.set_location(std::move(location));
   query_request.set_query(query_str);

google/cloud/odbc/bq_driver/internal/odbc_internal_commons.h

@@ -317,6 +317,10 @@ inline std::string FormatDatetimeToString(
   return buffer;
 }
 
+std::string FloatTimestampToString(const std::string& ts);
+
+SQL_TIMESTAMP_STRUCT ConvertStrToTimestampStruct(std::string const& str);
+
 inline void TimestampToDSValue(const SQL_TIMESTAMP_STRUCT& timestamp,
                                DSValue& value) {
   value.resize(sizeof(SQL_TIMESTAMP_STRUCT));

google/cloud/odbc/bq_driver/internal/odbc_sql_type_info.cc

@@ -16,20 +16,32 @@
 
 namespace google::cloud::odbc_bq_driver_internal {
 
-DSRow CreateDSRowFromTypeInfo(TypeInfoRow const& type_info) {
+bool IsTimeRelated(TypeInfoRow const& type_info) {
+  return type_info.sql_data_type == SQL_TYPE_TIMESTAMP ||
+         type_info.sql_data_type == SQL_TIMESTAMP ;
+}
+
+DSRow CreateDSRowFromTypeInfo(TypeInfoRow const& type_info, bool timestamp_format) {
+  TypeInfoRow adjusted = type_info;
+    if (timestamp_format && 
+        IsTimeRelated(type_info)) {
+      adjusted.sql_data_type = SQL_VARCHAR;
+      adjusted.data_type     = SQL_VARCHAR;
+      adjusted.col_size      = 16384;
+    }
   DSRow ds_row;
 
   DSValue type_name;
   StringToDSValue(type_info.type_name, type_name);
   ds_row.emplace_back(type_name);
 
   DSValue data_type;
-  ArithmeticToDSValue<SQLBIGINT>(static_cast<SQLBIGINT>(type_info.data_type),
+  ArithmeticToDSValue<SQLBIGINT>(static_cast<SQLBIGINT>(adjusted.data_type),
                                  data_type);
   ds_row.emplace_back(data_type);
 
   DSValue col_size;
-  ArithmeticToDSValue<SQLBIGINT>(static_cast<SQLBIGINT>(type_info.col_size),
+  ArithmeticToDSValue<SQLBIGINT>(static_cast<SQLBIGINT>(adjusted.col_size),
                                  col_size);
   ds_row.emplace_back(col_size);
 
@@ -96,7 +108,7 @@ DSRow CreateDSRowFromTypeInfo(TypeInfoRow const& type_info) {
   ds_row.emplace_back(maximum_scale);
 
   DSValue sql_data_type;
-  ArithmeticToDSValue<SQLBIGINT>(type_info.sql_data_type, sql_data_type);
+  ArithmeticToDSValue<SQLBIGINT>(adjusted.sql_data_type, sql_data_type);
   ds_row.emplace_back(sql_data_type);
 
   DSValue sql_datetime_sub;

google/cloud/odbc/bq_driver/internal/odbc_sql_type_info.h

@@ -527,7 +527,7 @@ std::map<SQLSMALLINT, std::map<std::string, TypeInfoRow>> const
                               {"BIGNUMERIC", kBqBignumericTypeInfoRow},
                           }}};
 
-DSRow CreateDSRowFromTypeInfo(TypeInfoRow const& type_info);
+DSRow CreateDSRowFromTypeInfo(TypeInfoRow const& type_info, bool timestamp_format = false);
 
 void CreateTypeInfoRowSchema(ResultSet& result_set);