snowflake-connector-python 3.16.0__cp313-cp313-win_amd64.whl

snowflake/connector/nanoarrow_cpp/ArrowIterator/TimeStampConverter.cpp

@@ -0,0 +1,346 @@
+#include "TimeStampConverter.hpp"
+
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <type_traits>
+
+#include "Python/Helpers.hpp"
+#include "Util/time.hpp"
+
+template <typename T>
+constexpr char toType() {
+  static_assert(
+      std::is_same<T, signed char>::value || std::is_same<T, short>::value ||
+          std::is_same<T, int>::value || std::is_same<T, long>::value ||
+          std::is_same<T, long long>::value,
+      "Unknown type");
+  return std::is_same<T, signed char>::value ? 'b'
+         : std::is_same<T, short>::value     ? 'h'
+         : std::is_same<T, int>::value       ? 'i'
+         : std::is_same<T, long>::value      ? 'l'
+         : std::is_same<T, long long>::value ? 'L'
+                                             // Should not get here. Error.
+                                             : '?';
+}
+
+template <typename T1>
+struct FormatArgs1 {
+  char format[2];
+  constexpr FormatArgs1() : format{toType<T1>(), '\0'} {}
+};
+template <typename T1, typename T2>
+struct FormatArgs2 {
+  char format[3];
+  constexpr FormatArgs2() : format{toType<T1>(), toType<T2>(), '\0'} {}
+};
+template <typename T1, typename T2, typename T3>
+struct FormatArgs3 {
+  char format[4];
+  constexpr FormatArgs3()
+      : format{toType<T1>(), toType<T2>(), toType<T3>(), '\0'} {}
+};
+
+namespace sf {
+
+Logger* TwoFieldTimeStampNTZConverter::logger =
+    new Logger("snowflake.connector.TwoFieldTimeStampNTZConverter");
+Logger* NumpyTwoFieldTimeStampNTZConverter::logger =
+    new Logger("snowflake.connector.NumpyTwoFieldTimeStampNTZConverter");
+Logger* TwoFieldTimeStampLTZConverter::logger =
+    new Logger("snowflake.connector.TwoFieldTimeStampLTZConverter");
+Logger* TwoFieldTimeStampTZConverter::logger =
+    new Logger("snowflake.connector.TwoFieldTimeStampTZConverter");
+Logger* ThreeFieldTimeStampTZConverter::logger =
+    new Logger("snowflake.connector.ThreeFieldTimeStampTZConverter");
+
+TimeStampBaseConverter::TimeStampBaseConverter(PyObject* context, int32_t scale)
+    : m_context(context), m_scale(scale) {}
+
+OneFieldTimeStampNTZConverter::OneFieldTimeStampNTZConverter(
+    ArrowArrayView* array, int32_t scale, PyObject* context)
+    : TimeStampBaseConverter(context, scale), m_array(array) {}
+
+PyObject* OneFieldTimeStampNTZConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t val = ArrowArrayViewGetIntUnsafe(m_array, rowIndex);
+  internal::TimeSpec ts(val, m_scale);
+
+  static constexpr FormatArgs2<decltype(ts.seconds), decltype(ts.microseconds)>
+      format;
+#ifdef _WIN32
+  return PyObject_CallMethod(m_context, "TIMESTAMP_NTZ_to_python_windows",
+                             format.format, ts.seconds, ts.microseconds);
+#else
+  return PyObject_CallMethod(m_context, "TIMESTAMP_NTZ_to_python",
+                             format.format, ts.seconds, ts.microseconds);
+#endif
+}
+
+NumpyOneFieldTimeStampNTZConverter::NumpyOneFieldTimeStampNTZConverter(
+    ArrowArrayView* array, int32_t scale, PyObject* context)
+    : TimeStampBaseConverter(context, scale), m_array(array) {}
+
+PyObject* NumpyOneFieldTimeStampNTZConverter::toPyObject(
+    int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t val = ArrowArrayViewGetIntUnsafe(m_array, rowIndex);
+  return PyObject_CallMethod(m_context,
+                             "TIMESTAMP_NTZ_ONE_FIELD_to_numpy_datetime64",
+                             "Li", val, m_scale);
+}
+
+TwoFieldTimeStampNTZConverter::TwoFieldTimeStampNTZConverter(
+    ArrowArrayView* array, ArrowSchemaView* schema, int32_t scale,
+    PyObject* context)
+    : TimeStampBaseConverter(context, scale), m_array(array) {
+  if (schema->schema->n_children != 2) {
+    std::string errorInfo = Logger::formatString(
+        "[Snowflake Exception] arrow schema field number does not match, "
+        "expected 2 but got %d instead",
+        schema->schema->n_children);
+    logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+    PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+    return;
+  }
+  for (int i = 0; i < schema->schema->n_children; i += 1) {
+    ArrowSchema* c_schema = schema->schema->children[i];
+    if (std::strcmp(c_schema->name, internal::FIELD_NAME_EPOCH.c_str()) == 0) {
+      m_epoch = m_array->children[i];
+    } else if (std::strcmp(c_schema->name,
+                           internal::FIELD_NAME_FRACTION.c_str()) == 0) {
+      m_fraction = m_array->children[i];
+    } else {
+      // do nothing
+    }
+  }
+}
+
+PyObject* TwoFieldTimeStampNTZConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t seconds = ArrowArrayViewGetIntUnsafe(m_epoch, rowIndex);
+  int64_t microseconds =
+      ArrowArrayViewGetIntUnsafe(m_fraction, rowIndex) / 1000;
+
+  static constexpr FormatArgs2<decltype(seconds), decltype(microseconds)>
+      format;
+#ifdef _WIN32
+  return PyObject_CallMethod(m_context, "TIMESTAMP_NTZ_to_python_windows",
+                             format.format, seconds, microseconds);
+#else
+  return PyObject_CallMethod(m_context, "TIMESTAMP_NTZ_to_python",
+                             format.format, seconds, microseconds);
+#endif
+}
+
+NumpyTwoFieldTimeStampNTZConverter::NumpyTwoFieldTimeStampNTZConverter(
+    ArrowArrayView* array, ArrowSchemaView* schema, int32_t scale,
+    PyObject* context)
+    : TimeStampBaseConverter(context, scale), m_array(array) {
+  if (schema->schema->n_children != 2) {
+    std::string errorInfo = Logger::formatString(
+        "[Snowflake Exception] arrow schema field number does not match, "
+        "expected 2 but got %d instead",
+        schema->schema->n_children);
+    logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+    PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+    return;
+  }
+  for (int i = 0; i < schema->schema->n_children; i += 1) {
+    ArrowSchema* c_schema = schema->schema->children[i];
+    if (std::strcmp(c_schema->name, internal::FIELD_NAME_EPOCH.c_str()) == 0) {
+      m_epoch = m_array->children[i];
+    } else if (std::strcmp(c_schema->name,
+                           internal::FIELD_NAME_FRACTION.c_str()) == 0) {
+      m_fraction = m_array->children[i];
+    } else {
+      // do nothing
+    }
+  }
+}
+
+PyObject* NumpyTwoFieldTimeStampNTZConverter::toPyObject(
+    int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t epoch = ArrowArrayViewGetIntUnsafe(m_epoch, rowIndex);
+  int32_t frac = ArrowArrayViewGetIntUnsafe(m_fraction, rowIndex);
+  return PyObject_CallMethod(m_context,
+                             "TIMESTAMP_NTZ_TWO_FIELD_to_numpy_datetime64",
+                             "Li", epoch, frac);
+}
+
+OneFieldTimeStampLTZConverter::OneFieldTimeStampLTZConverter(
+    ArrowArrayView* array, int32_t scale, PyObject* context)
+    : TimeStampBaseConverter(context, scale), m_array(array) {}
+
+PyObject* OneFieldTimeStampLTZConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t val = ArrowArrayViewGetIntUnsafe(m_array, rowIndex);
+  internal::TimeSpec ts(val, m_scale);
+
+  static constexpr FormatArgs2<decltype(ts.seconds), decltype(ts.microseconds)>
+      format;
+
+#ifdef _WIN32
+  return PyObject_CallMethod(m_context, "TIMESTAMP_LTZ_to_python_windows",
+                             format.format, ts.seconds, ts.microseconds);
+#else
+  return PyObject_CallMethod(m_context, "TIMESTAMP_LTZ_to_python",
+                             format.format, ts.seconds, ts.microseconds);
+#endif
+}
+
+TwoFieldTimeStampLTZConverter::TwoFieldTimeStampLTZConverter(
+    ArrowArrayView* array, ArrowSchemaView* schema, int32_t scale,
+    PyObject* context)
+    : TimeStampBaseConverter(context, scale), m_array(array) {
+  if (schema->schema->n_children != 2) {
+    std::string errorInfo = Logger::formatString(
+        "[Snowflake Exception] arrow schema field number does not match, "
+        "expected 2 but got %d instead",
+        schema->schema->n_children);
+    logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+    PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+    return;
+  }
+  for (int i = 0; i < schema->schema->n_children; i += 1) {
+    ArrowSchema* c_schema = schema->schema->children[i];
+    if (std::strcmp(c_schema->name, internal::FIELD_NAME_EPOCH.c_str()) == 0) {
+      m_epoch = m_array->children[i];
+    } else if (std::strcmp(c_schema->name,
+                           internal::FIELD_NAME_FRACTION.c_str()) == 0) {
+      m_fraction = m_array->children[i];
+    } else {
+      // do nothing
+    }
+  }
+}
+
+PyObject* TwoFieldTimeStampLTZConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t seconds = ArrowArrayViewGetIntUnsafe(m_epoch, rowIndex);
+  int64_t microseconds =
+      ArrowArrayViewGetIntUnsafe(m_fraction, rowIndex) / 1000;
+
+  static constexpr FormatArgs2<decltype(seconds), decltype(microseconds)>
+      format;
+#ifdef _WIN32
+  return PyObject_CallMethod(m_context, "TIMESTAMP_LTZ_to_python_windows",
+                             format.format, seconds, microseconds);
+#else
+  return PyObject_CallMethod(m_context, "TIMESTAMP_LTZ_to_python",
+                             format.format, seconds, microseconds);
+#endif
+}
+
+TwoFieldTimeStampTZConverter::TwoFieldTimeStampTZConverter(
+    ArrowArrayView* array, ArrowSchemaView* schema, int32_t scale,
+    PyObject* context)
+    : TimeStampBaseConverter(context, scale), m_array(array) {
+  if (schema->schema->n_children != 2) {
+    std::string errorInfo = Logger::formatString(
+        "[Snowflake Exception] arrow schema field number does not match, "
+        "expected 2 but got %d instead",
+        schema->schema->n_children);
+    logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+    PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+    return;
+  }
+  for (int i = 0; i < schema->schema->n_children; i += 1) {
+    ArrowSchema* c_schema = schema->schema->children[i];
+    if (std::strcmp(c_schema->name, internal::FIELD_NAME_EPOCH.c_str()) == 0) {
+      m_epoch = m_array->children[i];
+    } else if (std::strcmp(c_schema->name,
+                           internal::FIELD_NAME_TIME_ZONE.c_str()) == 0) {
+      m_timezone = m_array->children[i];
+    } else {
+      // do nothing
+    }
+  }
+}
+
+PyObject* TwoFieldTimeStampTZConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+
+  int32_t timezone = ArrowArrayViewGetIntUnsafe(m_timezone, rowIndex);
+  internal::TimeSpec ts(ArrowArrayViewGetIntUnsafe(m_epoch, rowIndex), m_scale);
+
+  static constexpr FormatArgs3<decltype(ts.seconds), decltype(ts.microseconds),
+                               decltype(timezone)>
+      format;
+#if _WIN32
+  return PyObject_CallMethod(m_context, "TIMESTAMP_TZ_to_python_windows",
+                             format.format, ts.seconds, ts.microseconds,
+                             timezone);
+#else
+  return PyObject_CallMethod(m_context, "TIMESTAMP_TZ_to_python", format.format,
+                             ts.seconds, ts.microseconds, timezone);
+#endif
+}
+
+ThreeFieldTimeStampTZConverter::ThreeFieldTimeStampTZConverter(
+    ArrowArrayView* array, ArrowSchemaView* schema, int32_t scale,
+    PyObject* context)
+    : TimeStampBaseConverter(context, scale), m_array(array) {
+  if (schema->schema->n_children != 3) {
+    std::string errorInfo = Logger::formatString(
+        "[Snowflake Exception] arrow schema field number does not match, "
+        "expected 3 but got %d instead",
+        schema->schema->n_children);
+    logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+    PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+    return;
+  }
+  for (int i = 0; i < schema->schema->n_children; i += 1) {
+    ArrowSchema* c_schema = schema->schema->children[i];
+    if (std::strcmp(c_schema->name, internal::FIELD_NAME_EPOCH.c_str()) == 0) {
+      m_epoch = m_array->children[i];
+    } else if (std::strcmp(c_schema->name,
+                           internal::FIELD_NAME_TIME_ZONE.c_str()) == 0) {
+      m_timezone = m_array->children[i];
+    } else if (std::strcmp(c_schema->name,
+                           internal::FIELD_NAME_FRACTION.c_str()) == 0) {
+      m_fraction = m_array->children[i];
+    } else {
+      // do nothing
+    }
+  }
+}
+
+PyObject* ThreeFieldTimeStampTZConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+
+  int32_t timezone = ArrowArrayViewGetIntUnsafe(m_timezone, rowIndex);
+  int64_t seconds = ArrowArrayViewGetIntUnsafe(m_epoch, rowIndex);
+  int64_t microseconds =
+      ArrowArrayViewGetIntUnsafe(m_fraction, rowIndex) / 1000;
+
+  static constexpr FormatArgs3<decltype(seconds), decltype(microseconds),
+                               decltype(timezone)>
+      format;
+#ifdef _WIN32
+  return PyObject_CallMethod(m_context, "TIMESTAMP_TZ_to_python_windows",
+                             format.format, seconds, microseconds, timezone);
+#else
+  return PyObject_CallMethod(m_context, "TIMESTAMP_TZ_to_python", format.format,
+                             seconds, microseconds, timezone);
+#endif
+}
+
+}  // namespace sf

snowflake/connector/nanoarrow_cpp/ArrowIterator/TimeStampConverter.hpp

@@ -0,0 +1,145 @@
+#ifndef PC_TIMESTAMPCONVERTER_HPP
+#define PC_TIMESTAMPCONVERTER_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "Python/Common.hpp"
+#include "Python/Helpers.hpp"
+#include "Util/time.hpp"
+#include "logging.hpp"
+#include "nanoarrow.h"
+
+namespace sf {
+
+// correspond to python datetime.time and datetime.time has only support 6 bit
+// precision, which is millisecond
+
+class TimeStampBaseConverter : public IColumnConverter {
+ public:
+  TimeStampBaseConverter(PyObject* context, int32_t scale);
+  virtual ~TimeStampBaseConverter() = default;
+
+ protected:
+  PyObject* m_context;
+
+  int32_t m_scale;
+};
+
+class OneFieldTimeStampNTZConverter : public TimeStampBaseConverter {
+ public:
+  explicit OneFieldTimeStampNTZConverter(ArrowArrayView* array, int32_t scale,
+                                         PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+};
+
+class NumpyOneFieldTimeStampNTZConverter : public TimeStampBaseConverter {
+ public:
+  explicit NumpyOneFieldTimeStampNTZConverter(ArrowArrayView* array,
+                                              int32_t scale, PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+};
+
+class TwoFieldTimeStampNTZConverter : public TimeStampBaseConverter {
+ public:
+  explicit TwoFieldTimeStampNTZConverter(ArrowArrayView* array,
+                                         ArrowSchemaView* schema, int32_t scale,
+                                         PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  ArrowArrayView* m_epoch;
+  ArrowArrayView* m_fraction;
+
+  static Logger* logger;
+};
+
+class NumpyTwoFieldTimeStampNTZConverter : public TimeStampBaseConverter {
+ public:
+  explicit NumpyTwoFieldTimeStampNTZConverter(ArrowArrayView* array,
+                                              ArrowSchemaView* schema,
+                                              int32_t scale, PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  ArrowArrayView* m_epoch;
+  ArrowArrayView* m_fraction;
+
+  static Logger* logger;
+};
+
+class OneFieldTimeStampLTZConverter : public TimeStampBaseConverter {
+ public:
+  explicit OneFieldTimeStampLTZConverter(ArrowArrayView* array, int32_t scale,
+                                         PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+};
+
+class TwoFieldTimeStampLTZConverter : public TimeStampBaseConverter {
+ public:
+  explicit TwoFieldTimeStampLTZConverter(ArrowArrayView* array,
+                                         ArrowSchemaView* schema, int32_t scale,
+                                         PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  ArrowArrayView* m_epoch;
+  ArrowArrayView* m_fraction;
+
+  static Logger* logger;
+};
+
+class TwoFieldTimeStampTZConverter : public TimeStampBaseConverter {
+ public:
+  explicit TwoFieldTimeStampTZConverter(ArrowArrayView* array,
+                                        ArrowSchemaView* schema, int32_t scale,
+                                        PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  ArrowArrayView* m_epoch;
+  ArrowArrayView* m_timezone;
+
+  static Logger* logger;
+};
+
+class ThreeFieldTimeStampTZConverter : public TimeStampBaseConverter {
+ public:
+  explicit ThreeFieldTimeStampTZConverter(ArrowArrayView* array,
+                                          ArrowSchemaView* schema,
+                                          int32_t scale, PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  ArrowArrayView* m_epoch;
+  ArrowArrayView* m_fraction;
+  ArrowArrayView* m_timezone;
+
+  static Logger* logger;
+};
+
+}  // namespace sf
+
+#endif  // PC_TIMESTAMPCONVERTER_HPP

snowflake/connector/nanoarrow_cpp/ArrowIterator/Util/macros.hpp

@@ -0,0 +1,14 @@
+#ifndef PC_UTIL_MACROS_HPP
+#define PC_UTIL_MACROS_HPP
+
+/** the same macros as linux kernel's likely and unlikely. can help specific
+ * compiler to make branch prediction */
+#if defined(__GNUC__)
+#define LIKELY(x) (__builtin_expect(!!(x), 1))
+#define UNLIKELY(x) (__builtin_expect(!!(x), 0))
+#else
+#define LIKELY(x) x
+#define UNLIKELY(x) x
+#endif  // __GNUC__
+
+#endif  // PC_UTIL_MACROS_HPP

snowflake/connector/nanoarrow_cpp/ArrowIterator/Util/time.cpp

@@ -0,0 +1,65 @@
+#include "time.hpp"
+
+namespace sf {
+
+namespace internal {
+
+int32_t getHourFromSeconds(int64_t seconds, int32_t scale) {
+  return seconds / powTenSB4[scale] / SECONDS_PER_HOUR;
+}
+
+int32_t getHourFromSeconds(int32_t seconds, int32_t scale) {
+  return seconds / powTenSB4[scale] / SECONDS_PER_HOUR;
+}
+
+int32_t getMinuteFromSeconds(int64_t seconds, int32_t scale) {
+  return seconds / powTenSB4[scale] % SECONDS_PER_HOUR / SECONDS_PER_MINUTE;
+}
+
+int32_t getMinuteFromSeconds(int32_t seconds, int32_t scale) {
+  return seconds / powTenSB4[scale] % SECONDS_PER_HOUR / SECONDS_PER_MINUTE;
+}
+
+int32_t getSecondFromSeconds(int64_t seconds, int32_t scale) {
+  return seconds / powTenSB4[scale] % SECONDS_PER_MINUTE;
+}
+
+int32_t getSecondFromSeconds(int32_t seconds, int32_t scale) {
+  return seconds / powTenSB4[scale] % SECONDS_PER_MINUTE;
+}
+
+int32_t getMicrosecondFromSeconds(int64_t seconds, int32_t scale) {
+  int32_t microsec = seconds % powTenSB4[scale];
+  return scale > PYTHON_DATETIME_TIME_MICROSEC_DIGIT
+             ? microsec /=
+               powTenSB4[scale - PYTHON_DATETIME_TIME_MICROSEC_DIGIT]
+             : microsec *=
+               powTenSB4[PYTHON_DATETIME_TIME_MICROSEC_DIGIT - scale];
+}
+
+TimeSpec::TimeSpec(int64_t units, int32_t scale) {
+  if (scale == 0) {
+    seconds = units;
+    microseconds = 0;
+  } else if (scale == 6) {
+    seconds = 0;
+    microseconds = units;
+  } else if (scale > 6) {
+    seconds = 0;
+    const int divider = internal::powTenSB4[scale - 6];
+    if (units < 0) {
+      units -= divider - 1;
+    }
+    microseconds = units / divider;
+  } else {
+    seconds = units / internal::powTenSB4[scale];
+    int64_t fractions = std::abs(units % internal::powTenSB4[scale]);
+    microseconds = fractions * internal::powTenSB4[6 - scale];
+    if (units < 0) {
+      microseconds = -microseconds;
+    }
+  }
+}
+
+}  // namespace internal
+}  // namespace sf

snowflake/connector/nanoarrow_cpp/ArrowIterator/Util/time.hpp

@@ -0,0 +1,68 @@
+#ifndef PC_UTIL_TIME_HPP
+#define PC_UTIL_TIME_HPP
+
+#include <string>
+
+#include "Python/Common.hpp"
+
+#ifdef _WIN32
+#include <algorithm>
+#endif
+
+namespace sf {
+
+namespace internal {
+/** python datetime.time has only support 6 bit precision, which is formated
+ * double in this file */
+
+constexpr int SECONDS_PER_MINUTE = 60;
+constexpr int MINUTES_PER_HOUR = 60;
+constexpr int HOURS_PER_DAY = 24;
+constexpr int SECONDS_PER_HOUR = MINUTES_PER_HOUR * SECONDS_PER_MINUTE;
+
+constexpr int32_t PYTHON_DATETIME_TIME_MICROSEC_DIGIT = 6;
+constexpr int32_t NANOSEC_DIGIT = 9;
+
+constexpr int powTenSB4[]{1,      10,      100,      1000,      10000,
+                          100000, 1000000, 10000000, 100000000, 1000000000};
+
+/** if we use c++17 some day in the future, we can use 'constexpr
+ * std::string_view sv = "hello, world";' to replace this */
+const std::string FIELD_NAME_EPOCH = "epoch";
+const std::string FIELD_NAME_TIME_ZONE = "timezone";
+const std::string FIELD_NAME_FRACTION = "fraction";
+
+/** pow10Int means the return value should be int type. So user needs to take
+ * care not to cause int overflow by a huge parameter n.
+ * And since we are using -stdc++11 now, we can only use constexpr in this way.
+ * When we move to -stdc++14, we can have a more elegant way, e.g., loop. */
+constexpr int pow10Int(int n) { return n == 0 ? 1 : 10 * pow10Int(n - 1); }
+
+struct TimeSpec {
+  int64_t seconds;
+  int64_t microseconds;
+  TimeSpec(int64_t units, int32_t scale);
+};
+
+// TODO: I think we can just keep int64_t version, since we can call the
+//  function with implicit conversion from int32 to int64
+int32_t getHourFromSeconds(int64_t seconds, int32_t scale);
+
+int32_t getMinuteFromSeconds(int64_t seconds, int32_t scale);
+
+int32_t getSecondFromSeconds(int64_t seconds, int32_t scale);
+
+int32_t getMicrosecondFromSeconds(int64_t seconds, int32_t scale);
+
+int32_t getHourFromSeconds(int32_t seconds, int32_t scale);
+
+int32_t getMinuteFromSeconds(int32_t seconds, int32_t scale);
+
+int32_t getSecondFromSeconds(int32_t seconds, int32_t scale);
+
+int32_t getMicrosecondFromSeconds(int32_t seconds, int32_t scale);
+
+}  // namespace internal
+}  // namespace sf
+
+#endif  // PC_UTIL_TIME_HPP