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

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

@@ -0,0 +1,439 @@
+#include "ConverterUtil.hpp"
+
+#include <memory>
+#include <string>
+
+#include "ArrayConverter.hpp"
+#include "BinaryConverter.hpp"
+#include "BooleanConverter.hpp"
+#include "CArrowIterator.hpp"
+#include "DateConverter.hpp"
+#include "DecFloatConverter.hpp"
+#include "DecimalConverter.hpp"
+#include "FixedSizeListConverter.hpp"
+#include "FloatConverter.hpp"
+#include "IntConverter.hpp"
+#include "IntervalConverter.hpp"
+#include "MapConverter.hpp"
+#include "ObjectConverter.hpp"
+#include "SnowflakeType.hpp"
+#include "StringConverter.hpp"
+#include "TimeConverter.hpp"
+#include "TimeStampConverter.hpp"
+#include "nanoarrow.hpp"
+
+namespace sf {
+
+std::shared_ptr<sf::IColumnConverter> getConverterFromSchema(ArrowSchema* schema,
+                                                             ArrowArrayView* array,
+                                                             PyObject* context, bool useNumpy,
+                                                             Logger* logger) {
+  std::shared_ptr<sf::IColumnConverter> converter = nullptr;
+  ArrowSchemaView schemaView;
+  ArrowError error;
+  int returnCode = 0;
+
+  returnCode = ArrowSchemaViewInit(&schemaView, schema, &error);
+  SF_CHECK_ARROW_RC_AND_RETURN(returnCode, nullptr,
+                               "[Snowflake Exception] error initializing "
+                               "ArrowSchemaView: %s, error code: %d",
+                               ArrowErrorMessage(&error), returnCode);
+
+  struct ArrowStringView snowflakeLogicalType = ArrowCharView(nullptr);
+  const char* metadata = schema->metadata;
+  returnCode = ArrowMetadataGetValue(metadata, ArrowCharView("logicalType"), &snowflakeLogicalType);
+
+  SF_CHECK_ARROW_RC_AND_RETURN(returnCode, nullptr,
+                               "[Snowflake Exception] error getting 'logicalType' from "
+                               "Arrow metadata, error code: %d",
+                               returnCode);
+
+  SnowflakeType::Type sfType = SnowflakeType::snowflakeTypeFromString(
+      std::string(snowflakeLogicalType.data, snowflakeLogicalType.size_bytes));
+
+  switch (sfType) {
+    case SnowflakeType::Type::FIXED: {
+      struct ArrowStringView scaleString = ArrowCharView(nullptr);
+      struct ArrowStringView precisionString = ArrowCharView(nullptr);
+      int scale = 0;
+      int precision = 38;
+      if (metadata != nullptr) {
+        returnCode = ArrowMetadataGetValue(metadata, ArrowCharView("scale"), &scaleString);
+        SF_CHECK_ARROW_RC_AND_RETURN(returnCode, nullptr,
+                                     "[Snowflake Exception] error getting 'scale' from "
+                                     "Arrow metadata, error code: %d",
+                                     returnCode);
+        returnCode = ArrowMetadataGetValue(metadata, ArrowCharView("precision"), &precisionString);
+        SF_CHECK_ARROW_RC_AND_RETURN(returnCode, nullptr,
+                                     "[Snowflake Exception] error getting 'precision' "
+                                     "from Arrow metadata, error code: %d",
+                                     returnCode);
+        scale = std::stoi(std::string(scaleString.data, scaleString.size_bytes));
+        precision = std::stoi(std::string(precisionString.data, precisionString.size_bytes));
+      }
+
+      switch (schemaView.type) {
+#define _SF_INIT_FIXED_CONVERTER(ARROW_TYPE)                                                       \
+  case ArrowType::ARROW_TYPE: {                                                                    \
+    if (scale > 0) {                                                                               \
+      if (useNumpy) {                                                                              \
+        converter = std::make_shared<sf::NumpyDecimalConverter>(array, precision, scale, context); \
+      } else {                                                                                     \
+        converter = std::make_shared<sf::DecimalFromIntConverter>(array, precision, scale);        \
+      }                                                                                            \
+    } else {                                                                                       \
+      if (useNumpy) {                                                                              \
+        converter = std::make_shared<sf::NumpyIntConverter>(array, context);                       \
+      } else {                                                                                     \
+        converter = std::make_shared<sf::IntConverter>(array);                                     \
+      }                                                                                            \
+    }                                                                                              \
+    break;                                                                                         \
+  }
+        _SF_INIT_FIXED_CONVERTER(NANOARROW_TYPE_INT8)
+        _SF_INIT_FIXED_CONVERTER(NANOARROW_TYPE_INT16)
+        _SF_INIT_FIXED_CONVERTER(NANOARROW_TYPE_INT32)
+        _SF_INIT_FIXED_CONVERTER(NANOARROW_TYPE_INT64)
+#undef _SF_INIT_FIXED_CONVERTER
+
+        case ArrowType::NANOARROW_TYPE_DECIMAL128: {
+          converter = std::make_shared<sf::DecimalFromDecimalConverter>(context, array, scale);
+          break;
+        }
+
+        default: {
+          std::string errorInfo = Logger::formatString(
+              "[Snowflake Exception] unknown arrow internal data type(%d) "
+              "for FIXED data",
+              NANOARROW_TYPE_ENUM_STRING[schemaView.type]);
+          logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+          PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+          break;
+        }
+      }
+      break;
+    }
+
+    case SnowflakeType::Type::ANY:
+    case SnowflakeType::Type::CHAR:
+    case SnowflakeType::Type::TEXT:
+    case SnowflakeType::Type::VARIANT: {
+      converter = std::make_shared<sf::StringConverter>(array);
+      break;
+    }
+
+    case SnowflakeType::Type::BOOLEAN: {
+      converter = std::make_shared<sf::BooleanConverter>(array);
+      break;
+    }
+
+    case SnowflakeType::Type::REAL: {
+      if (useNumpy) {
+        converter = std::make_shared<sf::NumpyFloat64Converter>(array, context);
+      } else {
+        converter = std::make_shared<sf::FloatConverter>(array);
+      }
+      break;
+    }
+
+    case SnowflakeType::Type::DATE: {
+      if (useNumpy) {
+        converter = std::make_shared<sf::NumpyDateConverter>(array, context);
+      } else {
+        converter = std::make_shared<sf::DateConverter>(array);
+      }
+      break;
+    }
+
+    case SnowflakeType::Type::BINARY: {
+      converter = std::make_shared<sf::BinaryConverter>(array);
+      break;
+    }
+
+    case SnowflakeType::Type::TIME: {
+      int scale = 9;
+      if (metadata != nullptr) {
+        struct ArrowStringView scaleString = ArrowCharView(nullptr);
+        returnCode = ArrowMetadataGetValue(metadata, ArrowCharView("scale"), &scaleString);
+        SF_CHECK_ARROW_RC_AND_RETURN(returnCode, nullptr,
+                                     "[Snowflake Exception] error getting 'scale' from "
+                                     "Arrow metadata, error code: %d",
+                                     returnCode);
+        scale = std::stoi(std::string(scaleString.data, scaleString.size_bytes));
+      }
+      switch (schemaView.type) {
+        case NANOARROW_TYPE_INT32:
+        case NANOARROW_TYPE_INT64: {
+          converter = std::make_shared<sf::TimeConverter>(array, scale);
+          break;
+        }
+
+        default: {
+          std::string errorInfo = Logger::formatString(
+              "[Snowflake Exception] unknown arrow internal data type(%d) "
+              "for TIME data",
+              NANOARROW_TYPE_ENUM_STRING[schemaView.type]);
+          logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+          PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+          return nullptr;
+        }
+      }
+      break;
+    }
+
+    case SnowflakeType::Type::TIMESTAMP_NTZ: {
+      int scale = 9;
+      if (metadata != nullptr) {
+        struct ArrowStringView scaleString = ArrowCharView(nullptr);
+        returnCode = ArrowMetadataGetValue(metadata, ArrowCharView("scale"), &scaleString);
+        SF_CHECK_ARROW_RC_AND_RETURN(returnCode, nullptr,
+                                     "[Snowflake Exception] error getting 'scale' from "
+                                     "Arrow metadata, error code: %d",
+                                     returnCode);
+        scale = std::stoi(std::string(scaleString.data, scaleString.size_bytes));
+      }
+      switch (schemaView.type) {
+        case NANOARROW_TYPE_INT64: {
+          if (useNumpy) {
+            converter =
+                std::make_shared<sf::NumpyOneFieldTimeStampNTZConverter>(array, scale, context);
+          } else {
+            converter = std::make_shared<sf::OneFieldTimeStampNTZConverter>(array, scale, context);
+          }
+          break;
+        }
+
+        case NANOARROW_TYPE_STRUCT: {
+          if (useNumpy) {
+            converter = std::make_shared<sf::NumpyTwoFieldTimeStampNTZConverter>(array, &schemaView,
+                                                                                 scale, context);
+          } else {
+            converter = std::make_shared<sf::TwoFieldTimeStampNTZConverter>(array, &schemaView,
+                                                                            scale, context);
+          }
+          break;
+        }
+
+        default: {
+          std::string errorInfo = Logger::formatString(
+              "[Snowflake Exception] unknown arrow internal data type(%d) "
+              "for TIMESTAMP_NTZ data",
+              NANOARROW_TYPE_ENUM_STRING[schemaView.type]);
+          logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+          PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+          break;
+        }
+      }
+      break;
+    }
+
+    case SnowflakeType::Type::TIMESTAMP_LTZ: {
+      int scale = 9;
+      if (metadata != nullptr) {
+        struct ArrowStringView scaleString = ArrowCharView(nullptr);
+        returnCode = ArrowMetadataGetValue(metadata, ArrowCharView("scale"), &scaleString);
+        SF_CHECK_ARROW_RC_AND_RETURN(returnCode, nullptr,
+                                     "[Snowflake Exception] error getting 'scale' from "
+                                     "Arrow metadata, error code: %d",
+                                     returnCode);
+        scale = std::stoi(std::string(scaleString.data, scaleString.size_bytes));
+      }
+      switch (schemaView.type) {
+        case NANOARROW_TYPE_INT64: {
+          converter = std::make_shared<sf::OneFieldTimeStampLTZConverter>(array, scale, context);
+          break;
+        }
+
+        case NANOARROW_TYPE_STRUCT: {
+          converter = std::make_shared<sf::TwoFieldTimeStampLTZConverter>(array, &schemaView, scale,
+                                                                          context);
+          break;
+        }
+
+        default: {
+          std::string errorInfo = Logger::formatString(
+              "[Snowflake Exception] unknown arrow internal data type(%d) "
+              "for TIMESTAMP_LTZ data",
+              NANOARROW_TYPE_ENUM_STRING[schemaView.type]);
+          logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+          PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+          break;
+        }
+      }
+      break;
+    }
+
+    case SnowflakeType::Type::TIMESTAMP_TZ: {
+      struct ArrowStringView scaleString = ArrowCharView(nullptr);
+      struct ArrowStringView byteLengthString = ArrowCharView(nullptr);
+      int scale = 9;
+      int byteLength = 16;
+      if (metadata != nullptr) {
+        returnCode = ArrowMetadataGetValue(metadata, ArrowCharView("scale"), &scaleString);
+        SF_CHECK_ARROW_RC_AND_RETURN(returnCode, nullptr,
+                                     "[Snowflake Exception] error getting 'scale' from "
+                                     "Arrow metadata, error code: %d",
+                                     returnCode);
+        returnCode =
+            ArrowMetadataGetValue(metadata, ArrowCharView("byteLength"), &byteLengthString);
+        SF_CHECK_ARROW_RC_AND_RETURN(returnCode, nullptr,
+                                     "[Snowflake Exception] error getting 'byteLength' "
+                                     "from Arrow metadata, error code: %d",
+                                     returnCode);
+        scale = std::stoi(std::string(scaleString.data, scaleString.size_bytes));
+
+        // Byte Length may be unset if TIMESTAMP_TZ is the child of a structured
+        // type. In this case rely on the default value.
+        if (byteLengthString.data != nullptr) {
+          byteLength = std::stoi(std::string(byteLengthString.data, byteLengthString.size_bytes));
+        }
+      }
+      switch (byteLength) {
+        case 8: {
+          converter = std::make_shared<sf::TwoFieldTimeStampTZConverter>(array, &schemaView, scale,
+                                                                         context);
+          break;
+        }
+
+        case 16: {
+          converter = std::make_shared<sf::ThreeFieldTimeStampTZConverter>(array, &schemaView,
+                                                                           scale, context);
+          break;
+        }
+
+        default: {
+          std::string errorInfo = Logger::formatString(
+              "[Snowflake Exception] unknown arrow internal data type(%d) "
+              "for TIMESTAMP_TZ data",
+              NANOARROW_TYPE_ENUM_STRING[schemaView.type]);
+          logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+          PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+          break;
+        }
+      }
+
+      break;
+    }
+
+    case SnowflakeType::Type::ARRAY: {
+      switch (schemaView.type) {
+        case NANOARROW_TYPE_STRING:
+          converter = std::make_shared<sf::StringConverter>(array);
+          break;
+        case NANOARROW_TYPE_LIST:
+          converter = std::make_shared<sf::ArrayConverter>(&schemaView, array, context, useNumpy);
+          break;
+        default: {
+          std::string errorInfo = Logger::formatString(
+              "[Snowflake Exception] unknown arrow internal data type(%d) "
+              "for ARRAY data in %s",
+              NANOARROW_TYPE_ENUM_STRING[schemaView.type], schemaView.schema->name);
+          logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+          PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+          break;
+        }
+      }
+      break;
+    }
+
+    case SnowflakeType::Type::MAP: {
+      switch (schemaView.type) {
+        case NANOARROW_TYPE_STRING:
+          converter = std::make_shared<sf::StringConverter>(array);
+          break;
+        case NANOARROW_TYPE_MAP:
+          converter = std::make_shared<sf::MapConverter>(&schemaView, array, context, useNumpy);
+          break;
+        default: {
+          std::string errorInfo = Logger::formatString(
+              "[Snowflake Exception] unknown arrow internal data type(%s) "
+              "for MAP data in %s",
+              NANOARROW_TYPE_ENUM_STRING[schemaView.type], schemaView.schema->name);
+          logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+          PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+          break;
+        }
+      }
+      break;
+    }
+
+    case SnowflakeType::Type::OBJECT: {
+      switch (schemaView.type) {
+        case NANOARROW_TYPE_STRING:
+          converter = std::make_shared<sf::StringConverter>(array);
+          break;
+        case NANOARROW_TYPE_STRUCT:
+          converter = std::make_shared<sf::ObjectConverter>(&schemaView, array, context, useNumpy);
+          break;
+        default: {
+          std::string errorInfo = Logger::formatString(
+              "[Snowflake Exception] unknown arrow internal data type(%d) "
+              "for OBJECT data in %s",
+              NANOARROW_TYPE_ENUM_STRING[schemaView.type], schemaView.schema->name);
+          logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+          PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+          break;
+        }
+      }
+      break;
+    }
+
+    case SnowflakeType::Type::VECTOR: {
+      converter = std::make_shared<sf::FixedSizeListConverter>(array);
+      break;
+    }
+
+    case SnowflakeType::Type::DECFLOAT: {
+      converter = std::make_shared<sf::DecFloatConverter>(*array, schemaView, *context, useNumpy);
+      break;
+    }
+
+    case SnowflakeType::Type::INTERVAL_YEAR_MONTH: {
+      int scale = 0;
+      if (metadata != nullptr) {
+        ArrowStringView scaleString = ArrowCharView(nullptr);
+        returnCode = ArrowMetadataGetValue(metadata, ArrowCharView("scale"), &scaleString);
+        SF_CHECK_ARROW_RC_AND_RETURN(
+          returnCode, nullptr,
+          "[Snowflake Exception] error getting 'scale' from Arrow metadata, error code: %d", returnCode);
+        scale = std::stoi(std::string(scaleString.data, scaleString.size_bytes));
+      }
+      converter = std::make_shared<sf::IntervalYearMonthConverter>(array, context, useNumpy, scale);
+      break;
+    }
+
+    case SnowflakeType::Type::INTERVAL_DAY_TIME: {
+      switch (schemaView.type) {
+        case NANOARROW_TYPE_INT64:
+          converter = std::make_shared<sf::IntervalDayTimeConverterInt>(array, context, useNumpy);
+          break;
+        case NANOARROW_TYPE_DECIMAL128:
+          converter =
+              std::make_shared<sf::IntervalDayTimeConverterDecimal>(array, context, useNumpy);
+          break;
+        default: {
+          std::string errorInfo = Logger::formatString(
+              "[Snowflake Exception] unknown arrow internal data type(%d) "
+              "for INTERVAL_DAY_TIME data in %s",
+              NANOARROW_TYPE_ENUM_STRING[schemaView.type], schemaView.schema->name);
+          logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+          PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+          break;
+        }
+      }
+      break;
+    }
+
+    default: {
+      std::string errorInfo =
+          Logger::formatString("[Snowflake Exception] unknown snowflake data type : %d", sfType);
+      logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+      PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+      break;
+    }
+  }
+  return converter;
+}
+
+}  // namespace sf
+

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

@@ -0,0 +1,30 @@
+#ifndef PC_CONVERTERUTIL_HPP
+#define PC_CONVERTERUTIL_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "logging.hpp"
+#include "nanoarrow.h"
+
+namespace sf {
+
+/**
+ * Factory function to create appropriate column converter based on Arrow schema.
+ *
+ * @param schema Arrow schema for the column
+ * @param array Arrow array view for the column data
+ * @param context Python context object for conversions
+ * @param useNumpy Whether to use numpy types for numeric data
+ * @param logger Logger instance for error reporting
+ * @return Shared pointer to column converter, or nullptr on error
+ */
+std::shared_ptr<sf::IColumnConverter> getConverterFromSchema(ArrowSchema* schema,
+                                                             ArrowArrayView* array,
+                                                             PyObject* context, bool useNumpy,
+                                                             Logger* logger);
+
+}  // namespace sf
+
+#endif  // PC_CONVERTERUTIL_HPP
+

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

@@ -0,0 +1,48 @@
+#include "DateConverter.hpp"
+
+#include <memory>
+#include <mutex>
+
+#include "Python/Helpers.hpp"
+
+namespace sf {
+Logger* DateConverter::logger = new Logger("snowflake.connector.DateConverter");
+
+py::UniqueRef& DateConverter::initPyDatetimeDate() {
+  static py::UniqueRef pyDatetimeDate;
+  // The empty check races when the GIL does not serialize this init.
+  static std::once_flag onceFlag;
+  std::call_once(onceFlag, []() {
+    py::UniqueRef pyDatetimeModule;
+    py::importPythonModule("datetime", pyDatetimeModule);
+    py::importFromModule(pyDatetimeModule, "date", pyDatetimeDate);
+    Py_XINCREF(pyDatetimeDate.get());
+  });
+  return pyDatetimeDate;
+}
+
+DateConverter::DateConverter(ArrowArrayView* array)
+    : m_array(array), m_pyDatetimeDate(initPyDatetimeDate()) {}
+
+PyObject* DateConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+
+  int64_t deltaDays = ArrowArrayViewGetIntUnsafe(m_array, rowIndex);
+  return PyObject_CallMethod(m_pyDatetimeDate.get(), "fromordinal", "i", epochDay + deltaDays);
+}
+
+NumpyDateConverter::NumpyDateConverter(ArrowArrayView* array, PyObject* context)
+    : m_array(array), m_context(context) {}
+
+PyObject* NumpyDateConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+
+  int64_t deltaDays = ArrowArrayViewGetIntUnsafe(m_array, rowIndex);
+  return PyObject_CallMethod(m_context, "DATE_to_numpy_datetime64", "i", deltaDays);
+}
+
+}  // namespace sf

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

@@ -0,0 +1,46 @@
+#ifndef PC_DATECONVERTER_HPP
+#define PC_DATECONVERTER_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "Python/Common.hpp"
+#include "logging.hpp"
+#include "nanoarrow.h"
+
+namespace sf {
+
+class DateConverter : public IColumnConverter {
+ public:
+  explicit DateConverter(ArrowArrayView* array);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  static py::UniqueRef& initPyDatetimeDate();
+
+  ArrowArrayView* m_array;
+
+  /** from Python Ordinal to 1970-01-01 */
+  static constexpr int epochDay = 719163;
+
+  static Logger* logger;
+
+  py::UniqueRef& m_pyDatetimeDate;
+};
+
+class NumpyDateConverter : public IColumnConverter {
+ public:
+  explicit NumpyDateConverter(ArrowArrayView* array, PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+
+  PyObject* m_context;
+};
+
+}  // namespace sf
+
+#endif  // PC_DATECONVERTER_HPP

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

@@ -0,0 +1,76 @@
+
+#include "DecFloatConverter.hpp"
+
+#include <cstring>
+#include <memory>
+
+#include "Python/Helpers.hpp"
+
+namespace sf {
+
+Logger* DecFloatConverter::logger = new Logger("snowflake.connector.DecFloatConverter");
+
+const std::string DecFloatConverter::FIELD_NAME_EXPONENT = "exponent";
+const std::string DecFloatConverter::FIELD_NAME_SIGNIFICAND = "significand";
+
+DecFloatConverter::DecFloatConverter(ArrowArrayView& array, ArrowSchemaView& schema,
+                                     PyObject& context, bool useNumpy)
+    : m_context(context),
+      m_array(array),
+      m_exponent(nullptr),
+      m_significand(nullptr),
+      m_useNumpy(useNumpy) {
+  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, DecFloatConverter::FIELD_NAME_EXPONENT.c_str()) == 0) {
+      m_exponent = m_array.children[i];
+    } else if (std::strcmp(c_schema->name, DecFloatConverter::FIELD_NAME_SIGNIFICAND.c_str()) ==
+               0) {
+      m_significand = m_array.children[i];
+    }
+  }
+  if (!m_exponent || !m_significand) {
+    std::string errorInfo = Logger::formatString(
+        "[Snowflake Exception] arrow schema field names do not match, "
+        "expected %s and %s, but got %s and %s instead",
+        DecFloatConverter::FIELD_NAME_EXPONENT.c_str(),
+        DecFloatConverter::FIELD_NAME_SIGNIFICAND.c_str(), schema.schema->children[0]->name,
+        schema.schema->children[1]->name);
+    logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+    PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+    return;
+  }
+}
+
+PyObject* DecFloatConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(&m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t exponent = ArrowArrayViewGetIntUnsafe(m_exponent, rowIndex);
+  ArrowStringView stringView = ArrowArrayViewGetStringUnsafe(m_significand, rowIndex);
+  if (stringView.size_bytes > 16) {
+    std::string errorInfo = Logger::formatString(
+        "[Snowflake Exception] only precisions up to 38 supported. "
+        "Please update to a newer version of the connector.");
+    logger->error(__FILE__, __func__, __LINE__, errorInfo.c_str());
+    PyErr_SetString(PyExc_Exception, errorInfo.c_str());
+    return nullptr;
+  }
+  PyObject* significand = PyBytes_FromStringAndSize(stringView.data, stringView.size_bytes);
+
+  PyObject* result = PyObject_CallMethod(
+      &m_context, m_useNumpy ? "DECFLOAT_to_numpy_float64" : "DECFLOAT_to_decimal", "iS", exponent,
+      significand);
+  Py_XDECREF(significand);
+  return result;
+}
+}  // namespace sf

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

@@ -0,0 +1,35 @@
+
+#ifndef PC_DECFLOATCONVERTER_HPP
+#define PC_DECFLOATCONVERTER_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "logging.hpp"
+#include "nanoarrow.h"
+
+namespace sf {
+
+class DecFloatConverter : public IColumnConverter {
+ public:
+  static const std::string FIELD_NAME_EXPONENT;
+  static const std::string FIELD_NAME_SIGNIFICAND;
+
+  explicit DecFloatConverter(ArrowArrayView& array, ArrowSchemaView& schema, PyObject& context,
+                             bool useNumpy);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  PyObject& m_context;
+  ArrowArrayView& m_array;
+  ArrowArrayView* m_exponent;
+  ArrowArrayView* m_significand;
+  bool m_useNumpy;
+
+  static Logger* logger;
+};
+
+}  // namespace sf
+
+#endif  // PC_DECFLOATCONVERTER_HPP