snowflake-connector-python 5.2.0__cp315-cp315-win_amd64.whl

snowflake/connector/_internal/nanoarrow_cpp/ArrowIterator/SnowflakeType.hpp

@@ -0,0 +1,48 @@
+#ifndef PC_SNOWFLAKETYPE_HPP
+#define PC_SNOWFLAKETYPE_HPP
+
+#include <algorithm>
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+
+namespace sf {
+
+class SnowflakeType {
+ public:
+  enum class Type : uint8_t {
+    ANY = 0,
+    ARRAY = 1,
+    BINARY = 2,
+    BOOLEAN = 3,
+    CHAR = 4,
+    DATE = 5,
+    FIXED = 6,
+    OBJECT = 7,
+    REAL = 8,
+    TEXT = 9,
+    TIME = 10,
+    TIMESTAMP = 11,
+    TIMESTAMP_LTZ = 12,
+    TIMESTAMP_NTZ = 13,
+    TIMESTAMP_TZ = 14,
+    VARIANT = 15,
+    VECTOR = 16,
+    MAP = 17,
+    DECFLOAT = 18,
+    INTERVAL_YEAR_MONTH = 19,
+    INTERVAL_DAY_TIME = 20,
+  };
+
+  static SnowflakeType::Type snowflakeTypeFromString(std::string str) {
+    std::transform(str.begin(), str.end(), str.begin(), ::toupper);
+    return m_strEnumIndex.at(str);
+  }
+
+ private:
+  static std::unordered_map<std::string, SnowflakeType::Type> m_strEnumIndex;
+};
+
+}  // namespace sf
+
+#endif  // PC_SNOWFLAKETYPE_HPP

snowflake/connector/_internal/nanoarrow_cpp/ArrowIterator/StringConverter.cpp

@@ -0,0 +1,18 @@
+#include "StringConverter.hpp"
+
+#include <memory>
+
+namespace sf {
+Logger* StringConverter::logger = new Logger("snowflake.connector.StringConverter");
+
+StringConverter::StringConverter(ArrowArrayView* array) : m_array(array) {}
+
+PyObject* StringConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  ArrowStringView stringView = ArrowArrayViewGetStringUnsafe(m_array, rowIndex);
+  return PyUnicode_FromStringAndSize(stringView.data, stringView.size_bytes);
+}
+
+}  // namespace sf

snowflake/connector/_internal/nanoarrow_cpp/ArrowIterator/StringConverter.hpp

@@ -0,0 +1,26 @@
+#ifndef PC_STRINGCONVERTER_HPP
+#define PC_STRINGCONVERTER_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "logging.hpp"
+#include "nanoarrow.h"
+#include "nanoarrow.hpp"
+
+namespace sf {
+
+class StringConverter : public IColumnConverter {
+ public:
+  explicit StringConverter(ArrowArrayView* array);
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+
+  static Logger* logger;
+};
+
+}  // namespace sf
+
+#endif  // PC_STRINGCONVERTER_HPP

snowflake/connector/_internal/nanoarrow_cpp/ArrowIterator/TimeConverter.cpp

@@ -0,0 +1,39 @@
+#include "TimeConverter.hpp"
+
+#include <mutex>
+
+namespace sf {
+
+TimeConverter::TimeConverter(ArrowArrayView* array, int32_t scale)
+    : m_array(array), m_scale(scale) {}
+
+PyObject* TimeConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+
+  int64_t seconds = ArrowArrayViewGetIntUnsafe(m_array, rowIndex);
+  using namespace internal;
+  py::PyUniqueLock lock;
+  return PyObject_CallFunction(
+      m_pyDatetimeTime().get(), "iiii", getHourFromSeconds(seconds, m_scale),
+      getMinuteFromSeconds(seconds, m_scale), getSecondFromSeconds(seconds, m_scale),
+      getMicrosecondFromSeconds(seconds, m_scale));
+}
+
+py::UniqueRef& TimeConverter::m_pyDatetimeTime() {
+  static py::UniqueRef pyDatetimeTime;
+  // The empty check races when the GIL does not serialize this init.
+  static std::once_flag onceFlag;
+  std::call_once(onceFlag, []() {
+    py::PyUniqueLock lock;
+    py::UniqueRef pyDatetimeModule;
+    py::importPythonModule("datetime", pyDatetimeModule);
+    /** TODO : to check status here */
+
+    py::importFromModule(pyDatetimeModule, "time", pyDatetimeTime);
+  });
+  return pyDatetimeTime;
+}
+
+}  // namespace sf

snowflake/connector/_internal/nanoarrow_cpp/ArrowIterator/TimeConverter.hpp

@@ -0,0 +1,31 @@
+#ifndef PC_TIMECONVERTER_HPP
+#define PC_TIMECONVERTER_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "Python/Common.hpp"
+#include "Python/Helpers.hpp"
+#include "Util/time.hpp"
+#include "nanoarrow.h"
+
+namespace sf {
+
+class TimeConverter : public IColumnConverter {
+ public:
+  explicit TimeConverter(ArrowArrayView* array, int32_t scale);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  /** can be arrow::Int32Array and arrow::Int64Array */
+  ArrowArrayView* m_array;
+
+  int32_t m_scale;
+
+  static py::UniqueRef& m_pyDatetimeTime();
+};
+
+}  // namespace sf
+
+#endif  // PC_TIMECONVERTER_HPP

snowflake/connector/_internal/nanoarrow_cpp/ArrowIterator/TimeStampConverter.cpp

@@ -0,0 +1,326 @@
+#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/_internal/nanoarrow_cpp/ArrowIterator/TimeStampConverter.hpp

@@ -0,0 +1,138 @@
+#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/_internal/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