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

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

@@ -0,0 +1,90 @@
+#include "DecimalConverter.hpp"
+
+#include <memory>
+#include <mutex>
+#include <string>
+
+#include "Python/Common.hpp"
+#include "Python/Helpers.hpp"
+
+namespace sf {
+
+DecimalBaseConverter::DecimalBaseConverter() : m_pyDecimalConstructor(initPyDecimalConstructor()) {}
+
+py::UniqueRef& DecimalBaseConverter::initPyDecimalConstructor() {
+  static py::UniqueRef pyDecimalConstructor;
+  // The empty check races when the GIL does not serialize this init.
+  static std::once_flag onceFlag;
+  std::call_once(onceFlag, []() {
+    py::UniqueRef decimalModule;
+    py::importPythonModule("decimal", decimalModule);
+    py::importFromModule(decimalModule, "Decimal", pyDecimalConstructor);
+    Py_XINCREF(pyDecimalConstructor.get());
+  });
+
+  return pyDecimalConstructor;
+}
+
+DecimalFromIntConverter::DecimalFromIntConverter(ArrowArrayView* array, int /* precision */, int scale)
+    : m_array(array), m_scale(scale) {}
+
+PyObject* DecimalFromIntConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t val = ArrowArrayViewGetIntUnsafe(m_array, rowIndex);
+  py::UniqueRef decimal(PyObject_CallFunction(m_pyDecimalConstructor.get(), "L", val));
+  return PyObject_CallMethod(decimal.get(), "scaleb", "i", -m_scale);
+}
+
+NumpyDecimalConverter::NumpyDecimalConverter(ArrowArrayView* array, int /* precision */, int scale,
+                                             PyObject* context)
+    : m_array(array), m_scale(scale), m_context(context) {}
+
+PyObject* NumpyDecimalConverter::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, "FIXED_to_numpy_float64", "Li", val, m_scale);
+}
+
+DecimalFromDecimalConverter::DecimalFromDecimalConverter(PyObject* context, ArrowArrayView* array,
+                                                         int scale)
+    : m_array(array), m_context(context), m_scale(scale) {}
+
+PyObject* DecimalFromDecimalConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t bytes_start = 16 * (m_array->array->offset + rowIndex);
+  const char* ptr_start = m_array->buffer_views[1].data.as_char;
+  PyObject* int128_bytes = PyBytes_FromStringAndSize(&(ptr_start[bytes_start]), 16);
+  /**
+  # Alternatively, the decimal conversion can be implemented using the
+  ArrowDecimal related APIs in the following # code snippets, however, it's less
+  performant than the direct memory manipulation. # The code snippets here is
+  for context reference.
+
+  ArrowDecimal arrowDecimal;
+  ArrowDecimalInit(&arrowDecimal, 128, precision, scale);
+  ArrowArrayViewGetDecimalUnsafe(m_array, rowIndex, &arrowDecimal);
+  uint8_t outBytes[16];
+  ArrowDecimalGetBytes(&arrowDecimal, outBytes);
+  PyObject* int128_bytes = PyBytes_FromStringAndSize(&outBytes, 16);
+  */
+  PyObject* return_object =
+      PyObject_CallMethod(m_context, "DECIMAL128_to_decimal_or_int", "Si", int128_bytes, m_scale);
+  /**
+  int128_bytes is a new referenced created by PyBytes_FromStringAndSize,
+  to avoid memory leak we need to free it after usage
+  check docs:
+     https://docs.python.org/3/c-api/bytes.html#c.PyBytes_FromStringAndSize
+     https://docs.python.org/3/c-api/refcounting.html#c.Py_XDECREF
+
+  */
+  Py_XDECREF(int128_bytes);
+  return return_object;
+}
+
+}  // namespace sf

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

@@ -0,0 +1,63 @@
+#ifndef PC_DECIMALCONVERTER_HPP
+#define PC_DECIMALCONVERTER_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "Python/Common.hpp"
+#include "nanoarrow.h"
+
+namespace sf {
+
+class DecimalBaseConverter : public IColumnConverter {
+ public:
+  DecimalBaseConverter();
+  virtual ~DecimalBaseConverter() = default;
+
+ protected:
+  py::UniqueRef& m_pyDecimalConstructor;
+
+ private:
+  static py::UniqueRef& initPyDecimalConstructor();
+};
+
+class DecimalFromDecimalConverter : public DecimalBaseConverter {
+ public:
+  explicit DecimalFromDecimalConverter(PyObject* context, ArrowArrayView* array, int scale);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  PyObject* m_context;
+  int m_scale;
+  /** no need for this converter to store precision*/
+};
+
+class DecimalFromIntConverter : public DecimalBaseConverter {
+ public:
+  explicit DecimalFromIntConverter(ArrowArrayView* array, int precision, int scale);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  int m_scale;
+};
+
+class NumpyDecimalConverter : public IColumnConverter {
+ public:
+  explicit NumpyDecimalConverter(ArrowArrayView* array, int precision, int scale,
+                                 PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  int m_scale;
+  PyObject* m_context;
+};
+
+}  // namespace sf
+
+#endif  // PC_DECIMALCONVERTER_HPP

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

@@ -0,0 +1,62 @@
+#include "FixedSizeListConverter.hpp"
+
+namespace sf {
+Logger* FixedSizeListConverter::logger = new Logger("snowflake.connector.FixedSizeListConverter");
+
+FixedSizeListConverter::FixedSizeListConverter(ArrowArrayView* array) : m_array(array) {}
+
+void FixedSizeListConverter::generateError(const std::string& msg) const {
+  logger->error(__FILE__, __func__, __LINE__, msg.c_str());
+  PyErr_SetString(PyExc_Exception, msg.c_str());
+}
+
+PyObject* FixedSizeListConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+
+  if (m_array->n_children != 1) {
+    std::string errorInfo = Logger::formatString(
+        "[Snowflake Exception] invalid arrow element schema for fixed size "
+        "list: got (%d) "
+        "children",
+        m_array->n_children);
+    this->generateError(errorInfo);
+    return nullptr;
+  }
+
+  // m_array->length represents the number of fixed size lists in the array
+  // m_array->children[0] has a buffer view that contains the actual data of
+  // each list, back-to-back m_array->children[0]->length represents the sum of
+  // the lengths of the fixed size lists in the array.
+
+  ArrowArrayView* elements = m_array->children[0];
+  const auto fixedSizeArrayLength = elements->length / m_array->length;
+  PyObject* list = PyList_New(fixedSizeArrayLength);
+
+  const int64_t startIndexWithoutOffset = rowIndex * fixedSizeArrayLength;
+  for (int64_t i = 0; i < fixedSizeArrayLength; ++i) {
+    const auto bufferIndexWithoutOffset = startIndexWithoutOffset + i;
+    switch (elements->storage_type) {
+      case NANOARROW_TYPE_INT32: {
+        const auto value = ArrowArrayViewGetIntUnsafe(elements, bufferIndexWithoutOffset);
+        PyList_SetItem(list, i, PyLong_FromLongLong(value));
+      } break;
+      case NANOARROW_TYPE_FLOAT: {
+        const auto value = ArrowArrayViewGetDoubleUnsafe(elements, bufferIndexWithoutOffset);
+        PyList_SetItem(list, i, PyFloat_FromDouble(value));
+      } break;
+      default:
+        std::string errorInfo = Logger::formatString(
+            "[Snowflake Exception] invalid arrow element type for fixed size "
+            "list: got (%s)",
+            ArrowTypeString(elements->storage_type));
+        this->generateError(errorInfo);
+        return nullptr;
+    }
+  }
+
+  return list;
+}
+
+}  // namespace sf

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

@@ -0,0 +1,28 @@
+#ifndef PC_FIXEDSIZELISTCONVERTER_HPP
+#define PC_FIXEDSIZELISTCONVERTER_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "logging.hpp"
+#include "nanoarrow.h"
+#include "nanoarrow.hpp"
+
+namespace sf {
+
+class FixedSizeListConverter : public IColumnConverter {
+ public:
+  explicit FixedSizeListConverter(ArrowArrayView* array);
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  void generateError(const std::string& msg) const;
+
+  ArrowArrayView* m_array;
+
+  static Logger* logger;
+};
+
+}  // namespace sf
+
+#endif  // PC_FIXEDSIZELISTCONVERTER_HPP

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

@@ -0,0 +1,29 @@
+#include "FloatConverter.hpp"
+
+#include <memory>
+
+namespace sf {
+
+/** snowflake float is 64-precision, which refers to double here */
+FloatConverter::FloatConverter(ArrowArrayView* array) : m_array(array) {}
+
+PyObject* FloatConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  return PyFloat_FromDouble(ArrowArrayViewGetDoubleUnsafe(m_array, rowIndex));
+}
+
+NumpyFloat64Converter::NumpyFloat64Converter(ArrowArrayView* array, PyObject* context)
+    : m_array(array), m_context(context) {}
+
+PyObject* NumpyFloat64Converter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+
+  double val = ArrowArrayViewGetDoubleUnsafe(m_array, rowIndex);
+  return PyObject_CallMethod(m_context, "REAL_to_numpy_float64", "d", val);
+}
+
+}  // namespace sf

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

@@ -0,0 +1,35 @@
+#ifndef PC_FLOATCONVERTER_HPP
+#define PC_FLOATCONVERTER_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "nanoarrow.h"
+
+namespace sf {
+
+class FloatConverter : public IColumnConverter {
+ public:
+  explicit FloatConverter(ArrowArrayView* array);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+};
+
+class NumpyFloat64Converter : public IColumnConverter {
+ public:
+  explicit NumpyFloat64Converter(ArrowArrayView* array, PyObject* context);
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+
+  PyObject* m_context;
+};
+
+}  // namespace sf
+
+#endif  // PC_FLOATCONVERTER_HPP

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

@@ -0,0 +1,17 @@
+#ifndef PC_ICOLUMNCONVERTER_HPP
+#define PC_ICOLUMNCONVERTER_HPP
+
+#include "Python/Common.hpp"
+
+namespace sf {
+
+class IColumnConverter {
+ public:
+  IColumnConverter() = default;
+  virtual ~IColumnConverter() = default;
+  // The caller is responsible for calling DECREF on the returned pointer
+  virtual PyObject* toPyObject(int64_t rowIndex) const = 0;
+};
+}  // namespace sf
+
+#endif  // PC_ICOLUMNCONVERTER_HPP

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

@@ -0,0 +1,23 @@
+#include "IntConverter.hpp"
+
+namespace sf {
+/** this file is here for future use and if this is useless at the end, it will
+ * be removed */
+
+PyObject* IntConverter::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t val = ArrowArrayViewGetIntUnsafe(m_array, rowIndex);
+  return pyLongForward(val);
+}
+
+PyObject* NumpyIntConverter::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, "FIXED_to_numpy_int64", "L", val);
+}
+
+}  // namespace sf

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

@@ -0,0 +1,41 @@
+#ifndef PC_INTCONVERTER_HPP
+#define PC_INTCONVERTER_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "nanoarrow.h"
+#include "nanoarrow.hpp"
+
+namespace sf {
+
+class IntConverter : public IColumnConverter {
+ public:
+  explicit IntConverter(ArrowArrayView* array) : m_array(array) {}
+
+  PyObject* pyLongForward(int64_t value) const { return PyLong_FromLongLong(value); }
+
+  PyObject* pyLongForward(int32_t value) const { return PyLong_FromLong(value); }
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+};
+
+class NumpyIntConverter : public IColumnConverter {
+ public:
+  explicit NumpyIntConverter(ArrowArrayView* array, PyObject* context)
+      : m_array(array), m_context(context) {}
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+
+  PyObject* m_context;
+};
+
+}  // namespace sf
+
+#endif  // PC_INTCONVERTER_HPP

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

@@ -0,0 +1,65 @@
+#include "IntervalConverter.hpp"
+
+#include <memory>
+#include <string>
+
+#include "Python/Common.hpp"
+#include "Python/Helpers.hpp"
+
+namespace sf {
+
+static constexpr char INTERVAL_DT_DECIMAL_TO_NUMPY_TIMEDELTA[] =
+    "INTERVAL_DAY_TIME_decimal_to_numpy_timedelta";
+static constexpr char INTERVAL_DT_DECIMAL_TO_TIMEDELTA[] = "INTERVAL_DAY_TIME_decimal_to_timedelta";
+static constexpr char INTERVAL_DT_INT_TO_NUMPY_TIMEDELTA[] =
+    "INTERVAL_DAY_TIME_int_to_numpy_timedelta";
+static constexpr char INTERVAL_DT_INT_TO_TIMEDELTA[] = "INTERVAL_DAY_TIME_int_to_timedelta";
+static constexpr char INTERVAL_YEAR_MONTH_TO_NUMPY_TIMEDELTA[] =
+    "INTERVAL_YEAR_MONTH_to_numpy_timedelta";
+// Python timedelta does not support year-month intervals. Use ANSI SQL
+// formatted string instead.
+static constexpr char INTERVAL_YEAR_MONTH_TO_STR[] = "INTERVAL_YEAR_MONTH_to_str";
+
+IntervalYearMonthConverter::IntervalYearMonthConverter(ArrowArrayView* array, PyObject* context, bool useNumpy, int scale)
+    : m_array(array), m_context(context), m_scale(scale) {
+  m_method = useNumpy ? INTERVAL_YEAR_MONTH_TO_NUMPY_TIMEDELTA : INTERVAL_YEAR_MONTH_TO_STR;
+}
+
+PyObject* IntervalYearMonthConverter::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, m_method, "Li", val, m_scale);
+}
+
+IntervalDayTimeConverterInt::IntervalDayTimeConverterInt(ArrowArrayView* array, PyObject* context,
+                                                         bool useNumpy)
+    : m_array(array), m_context(context) {
+  m_method = useNumpy ? INTERVAL_DT_INT_TO_NUMPY_TIMEDELTA : INTERVAL_DT_INT_TO_TIMEDELTA;
+}
+
+PyObject* IntervalDayTimeConverterInt::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, m_method, "L", val);
+}
+
+IntervalDayTimeConverterDecimal::IntervalDayTimeConverterDecimal(ArrowArrayView* array,
+                                                                 PyObject* context, bool useNumpy)
+    : m_array(array), m_context(context) {
+  m_method = useNumpy ? INTERVAL_DT_DECIMAL_TO_NUMPY_TIMEDELTA : INTERVAL_DT_DECIMAL_TO_TIMEDELTA;
+}
+
+PyObject* IntervalDayTimeConverterDecimal::toPyObject(int64_t rowIndex) const {
+  if (ArrowArrayViewIsNull(m_array, rowIndex)) {
+    Py_RETURN_NONE;
+  }
+  int64_t bytes_start = 16 * (m_array->array->offset + rowIndex);
+  const char* ptr_start = m_array->buffer_views[1].data.as_char;
+  PyObject* int128_bytes = PyBytes_FromStringAndSize(&(ptr_start[bytes_start]), 16);
+  return PyObject_CallMethod(m_context, m_method, "S", int128_bytes);
+}
+}  // namespace sf

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

@@ -0,0 +1,54 @@
+#ifndef PC_INTERVALCONVERTER_HPP
+#define PC_INTERVALCONVERTER_HPP
+
+#include <memory>
+
+#include "IColumnConverter.hpp"
+#include "nanoarrow.h"
+#include "nanoarrow.hpp"
+
+namespace sf {
+
+class IntervalYearMonthConverter : public IColumnConverter {
+ public:
+  explicit IntervalYearMonthConverter(ArrowArrayView* array, PyObject* context, bool useNumpy, int scale);
+  virtual ~IntervalYearMonthConverter() = default;
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  PyObject* m_context;
+  const char* m_method;
+  int m_scale;
+};
+
+class IntervalDayTimeConverterInt : public IColumnConverter {
+ public:
+  explicit IntervalDayTimeConverterInt(ArrowArrayView* array, PyObject* context, bool useNumpy);
+  virtual ~IntervalDayTimeConverterInt() = default;
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  PyObject* m_context;
+  const char* m_method;
+};
+
+class IntervalDayTimeConverterDecimal : public IColumnConverter {
+ public:
+  explicit IntervalDayTimeConverterDecimal(ArrowArrayView* array, PyObject* context, bool useNumpy);
+  virtual ~IntervalDayTimeConverterDecimal() = default;
+
+  PyObject* toPyObject(int64_t rowIndex) const override;
+
+ private:
+  ArrowArrayView* m_array;
+  PyObject* m_context;
+  const char* m_method;
+};
+
+}  // namespace sf
+
+#endif  // PC_INTERVALCONVERTER_HPP