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

snowflake/connector/nanoarrow_cpp/ArrowIterator/Python/Common.hpp

@@ -0,0 +1,95 @@
+#ifndef PC_PYTHON_COMMON_HPP
+#define PC_PYTHON_COMMON_HPP
+
+// Support for not having PY_SSIZE_T_CLEAN defined will end in Python 3.10. It
+// causes
+//  argument parsing to not accept integers, leaving only Py_ssize_t as an
+//  option
+#define PY_SSIZE_T_CLEAN
+
+// We have to make sure that we import Python.h once for special flags that need
+// to be
+//  set before importing it
+#include <Python.h>
+
+#include "Util/macros.hpp"
+
+namespace sf {
+
+namespace py {
+inline bool checkPyError() { return UNLIKELY(PyErr_Occurred()); }
+
+/**
+ * A RAII class to wrap the PyObject*. The semantics are like std::unique_ptr.
+ */
+class UniqueRef {
+ public:
+  UniqueRef(const UniqueRef&) = delete;
+  UniqueRef& operator=(const UniqueRef&) = delete;
+
+  UniqueRef() : m_pyObj(nullptr) {}
+
+  explicit UniqueRef(PyObject* pyObj) : m_pyObj(pyObj) {}
+
+  UniqueRef(UniqueRef&& other) : UniqueRef(other.release()) {}
+
+  UniqueRef& operator=(UniqueRef&& other) {
+    reset(other.release());
+    return *this;
+  }
+
+  ~UniqueRef() { reset(); }
+
+  // Make this `UniqueRef` take ownership of the reference
+  // `pyObj`, if it is not null. If this `UniqueRef` previously
+  // owned a reference, it is released (via decrementing the
+  // refcount).
+  //
+  // This provides a similar guarantee as `Py_SETREF()` or
+  // `Py_CLEAR()`, by setting the new reference before
+  // decrementing the old reference.
+  void reset(PyObject* pyObj = nullptr) {
+    PyObject* toDelete = m_pyObj;
+    m_pyObj = pyObj;
+    Py_XDECREF(toDelete);
+  }
+
+  PyObject* release() noexcept {
+    PyObject* tmp = m_pyObj;
+    m_pyObj = nullptr;
+    return tmp;
+  }
+
+  PyObject* get() const noexcept { return m_pyObj; }
+
+  bool empty() const noexcept { return m_pyObj == nullptr; }
+
+ private:
+  PyObject* m_pyObj;
+};
+
+/**
+ * A RAII class to help us acquire the python GIL. The semantics are like
+ * std::unique_lock.
+ * We have to acquire the python GIL every time we call a Python/C API to ensure
+ * there is only one python thread running all the time.
+ */
+class PyUniqueLock {
+ public:
+  PyUniqueLock(const PyUniqueLock&) = delete;
+  PyUniqueLock& operator=(const PyUniqueLock&) = delete;
+  PyUniqueLock(PyUniqueLock&&) = delete;
+  PyUniqueLock& operator=(PyUniqueLock&&) = delete;
+
+  PyUniqueLock() { m_state = PyGILState_Ensure(); }
+
+  ~PyUniqueLock() { PyGILState_Release(m_state); }
+
+ private:
+  PyGILState_STATE m_state;
+};
+
+}  // namespace py
+}  // namespace sf
+
+#endif  // PC_PYTHON_COMMON_HPP

snowflake/connector/nanoarrow_cpp/ArrowIterator/Python/Helpers.cpp

@@ -0,0 +1,57 @@
+#include "Helpers.hpp"
+
+#include <string>
+
+#include "Common.hpp"
+
+namespace sf {
+
+namespace py {
+
+using Logger = ::sf::Logger;
+
+void importPythonModule(const std::string& moduleName, UniqueRef& ref) {
+  PyObject* module = PyImport_ImportModule(moduleName.c_str());
+  if (checkPyError()) {
+    return;
+  }
+  ref.reset(module);
+  return;
+}
+
+void importPythonModule(const std::string& moduleName, UniqueRef& ref,
+                        Logger& logger) {
+  PyObject* module = PyImport_ImportModule(moduleName.c_str());
+  if (checkPyError()) {
+    logger.error(__FILE__, __func__, __LINE__,
+                 "import python module '%s' failed", moduleName.c_str());
+    return;
+  }
+  ref.reset(module);
+  return;
+}
+
+void importFromModule(const UniqueRef& moduleRef, const std::string& name,
+                      UniqueRef& ref) {
+  PyObject* attr = PyObject_GetAttrString(moduleRef.get(), name.c_str());
+  if (checkPyError()) {
+    return;
+  }
+  ref.reset(attr);
+  return;
+}
+
+void importFromModule(const UniqueRef& moduleRef, const std::string& name,
+                      UniqueRef& ref, Logger& logger) {
+  PyObject* attr = PyObject_GetAttrString(moduleRef.get(), name.c_str());
+  if (checkPyError()) {
+    logger.error(__FILE__, __func__, __LINE__,
+                 "import python attribute '%s' failed", name.c_str());
+    return;
+  }
+  ref.reset(attr);
+  return;
+}
+
+}  // namespace py
+}  // namespace sf

snowflake/connector/nanoarrow_cpp/ArrowIterator/Python/Helpers.hpp

@@ -0,0 +1,36 @@
+#ifndef PC_PYTHON_HELPERS_HPP
+#define PC_PYTHON_HELPERS_HPP
+
+#include <string>
+
+#include "logging.hpp"
+
+namespace sf {
+
+namespace py {
+
+class UniqueRef;
+
+using Logger = ::sf::Logger;
+
+/**
+ * \brief: import a python module
+ * \param moduleName: the name of the python module
+ * \param ref: the RAII object to manage the PyObject
+ * \return:
+ */
+void importPythonModule(const std::string& moduleName, UniqueRef& ref);
+
+void importPythonModule(const std::string& moduleName, UniqueRef& ref,
+                        const Logger& logger);
+
+void importFromModule(const UniqueRef& moduleRef, const std::string& name,
+                      UniqueRef& ref);
+
+void importFromModule(const UniqueRef& moduleRef, const std::string& name,
+                      UniqueRef& ref, const Logger& logger);
+
+}  // namespace py
+}  // namespace sf
+
+#endif  // PC_PYTHON_HELPERS_HPP

snowflake/connector/nanoarrow_cpp/ArrowIterator/SnowflakeType.cpp

@@ -0,0 +1,34 @@
+#include "SnowflakeType.hpp"
+
+namespace sf {
+
+std::unordered_map<std::string, SnowflakeType::Type>
+    SnowflakeType::m_strEnumIndex = {
+        {"ANY", SnowflakeType::Type::ANY},
+        {"ARRAY", SnowflakeType::Type::ARRAY},
+        {"BINARY", SnowflakeType::Type::BINARY},
+        {"BOOLEAN", SnowflakeType::Type::BOOLEAN},
+        {"CHAR", SnowflakeType::Type::CHAR},
+        {"DATE", SnowflakeType::Type::DATE},
+        {"DOUBLE PRECISION", SnowflakeType::Type::REAL},
+        {"DOUBLE", SnowflakeType::Type::REAL},
+        {"FIXED", SnowflakeType::Type::FIXED},
+        {"DECFLOAT", SnowflakeType::Type::DECFLOAT},
+        {"FLOAT", SnowflakeType::Type::REAL},
+        {"INTERVAL_YEAR_MONTH", SnowflakeType::Type::INTERVAL_YEAR_MONTH},
+        {"INTERVAL_DAY_TIME", SnowflakeType::Type::INTERVAL_DAY_TIME},
+        {"MAP", SnowflakeType::Type::MAP},
+        {"OBJECT", SnowflakeType::Type::OBJECT},
+        {"REAL", SnowflakeType::Type::REAL},
+        {"STRING", SnowflakeType::Type::TEXT},
+        {"TEXT", SnowflakeType::Type::TEXT},
+        {"TIME", SnowflakeType::Type::TIME},
+        {"TIMESTAMP", SnowflakeType::Type::TIMESTAMP},
+        {"TIMESTAMP_LTZ", SnowflakeType::Type::TIMESTAMP_LTZ},
+        {"TIMESTAMP_NTZ", SnowflakeType::Type::TIMESTAMP_NTZ},
+        {"TIMESTAMP_TZ", SnowflakeType::Type::TIMESTAMP_TZ},
+        {"VARCHAR", SnowflakeType::Type::TEXT},
+        {"VARIANT", SnowflakeType::Type::VARIANT},
+        {"VECTOR", SnowflakeType::Type::VECTOR}};
+
+}  // namespace sf

snowflake/connector/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/nanoarrow_cpp/ArrowIterator/StringConverter.cpp

@@ -0,0 +1,19 @@
+#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/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/nanoarrow_cpp/ArrowIterator/TimeConverter.cpp

@@ -0,0 +1,36 @@
+#include "TimeConverter.hpp"
+
+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;
+  if (pyDatetimeTime.empty()) {
+    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/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