snowflake-connector-python 5.0.0rc4__tar.gz → 5.0.0rc5__tar.gz

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/Cargo.lock

@@ -4452,7 +4452,6 @@ dependencies = [
  "futures",
  "glob",
  "hex",
- "hmac",
  "html-escape",
  "http 1.3.1",
  "http-body 1.0.1",
@@ -4515,6 +4514,7 @@ dependencies = [
  "urlencoding",
  "uuid",
  "webbrowser",
+ "webpki-roots",
  "wiremock",
  "x509-cert",
  "x509-parser",

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: snowflake-connector-python
-Version: 5.0.0rc4
+Version: 5.0.0rc5
 Summary: Snowflake DB driver for Python
 Project-URL: Homepage, https://github.com/snowflakedb/drivers
 Project-URL: Bug Reports, https://github.com/snowflakedb/drivers/issues
@@ -45,6 +45,7 @@ Requires-Dist: numpy>=2.1.0; (python_version >= '3.13') and extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
 Requires-Dist: pytest-json-report; extra == 'test'
 Requires-Dist: pytest-randomly; extra == 'test'
+Requires-Dist: pytest-rerunfailures; extra == 'test'
 Requires-Dist: pytest-split; extra == 'test'
 Requires-Dist: pytest-timeout; extra == 'test'
 Requires-Dist: pytest-xdist; extra == 'test'

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/hatch_build.py

@@ -380,10 +380,6 @@ class BuildHook(BuildHookInterface):
         if os.environ.get("SF_PERF_METRICS", "").lower() in ("1", "true"):
             extra_cargo_args.extend(["--features", "sf_core/perf_timing"])
 
-        # Opt-in PyO3-based nanoarrow replacement.
-        if os.environ.get("SF_NATIVE_ARROW", "").lower() in ("1", "true"):
-            extra_cargo_args.extend(["--features", "native-arrow"])
-
         # Use a stable target dir when CORE_CARGO_TARGET_DIR is set (enables
         # incremental Rust compilation and CI caching). Otherwise fall back to a
         # temporary directory that is cleaned up after the build.

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/protobuf/database_driver_v1.proto

@@ -37,6 +37,18 @@ enum ErrorKind {
   ERROR_KIND_STAGE_BINDING = 15;
 }
 
+// Distinguishes ERROR_KIND_IO failures that share one kind but different
+// legacy JDBC vendor codes. Unset when kind is not ERROR_KIND_IO, and when
+// an I/O failure has no JDBC vendor code.
+enum IoClass {
+  IO_CLASS_UNSPECIFIED = 0;
+  IO_CLASS_GENERIC = 1;
+  IO_CLASS_NETWORK = 2;
+  IO_CLASS_FILE_UPLOAD = 3;
+  IO_CLASS_FILE_DOWNLOAD = 4;
+  IO_CLASS_NO_SPACE_LEFT = 5;
+}
+
 // Info codes corresponding to Thrift InfoCode enum
 enum InfoCode {
   INFO_CODE_UNSPECIFIED = 0;
@@ -120,6 +132,8 @@ message DriverException {
   // What the abort-request fired on cancellation achieved. Set only when kind is
   // ERROR_KIND_CANCELLED *and* an abort was actually issued; unset otherwise.
   optional CancellationAbortOutcome cancellation_abort_outcome = 13;
+  // Present when kind is ERROR_KIND_IO and the failure has a legacy JDBC vendor code.
+  optional IoClass io_class = 14;
 }
 
 // Column metadata for description
@@ -1015,6 +1029,17 @@ message ConfigGetPathsResponse {
   string connections_file = 2;
 }
 
+// Reports this build's linked TLS provider only. These fields do not establish
+// that every operation or the complete driver artifact is FIPS compliant.
+message DriverGetTlsStatusRequest {}
+
+message DriverGetTlsStatusResponse {
+  // Rustls's FIPS verdict for the linked TLS crypto provider.
+  bool tls_provider_is_fips = 1;
+  // Whether sf_core was compiled with the fips-tls feature.
+  bool fips_tls_build_enabled = 2;
+}
+
 // =============================================================================
 // WORKLOAD IDENTITY FEDERATION (WIF) - standalone attestation
 // =============================================================================
@@ -1081,6 +1106,9 @@ message TelemetrySendLogRequest {
 // Database Driver service definition
 service DatabaseDriver {
   option (service_error) = "DriverException";
+  // Available without a database or connection handle, even in standard builds.
+  rpc DriverGetTlsStatus(DriverGetTlsStatusRequest) returns (DriverGetTlsStatusResponse);
+
   // Database operations
   rpc DatabaseNew(DatabaseNewRequest) returns (DatabaseNewResponse);
   rpc DatabaseSetOptions(DatabaseSetOptionsRequest) returns (DatabaseSetOptionsResponse);

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/pyproject.toml

@@ -57,6 +57,7 @@ test = [
     "pytest-xdist",
     "pytest-randomly",
     "pytest-timeout",
+    "pytest-rerunfailures",
     "hypothesis",
     "requests",
     "brotli",
@@ -139,6 +140,8 @@ testpaths = ["tests"]
 python_files = ["test_*.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
+# Dedicated plugin dir only — do not put all of scripts/ on pythonpath (import shadow).
+pythonpath = ["../scripts/pytest_junit_retry_plugin"]
 addopts = [
     "--strict-markers",
     "--strict-config",
@@ -147,6 +150,10 @@ addopts = [
     # minimum 8 workers configured via pytest_xdist_auto_num_workers in conftest.py
     "-n", "auto",
     "--max-worker-restart=4",
+    # Two extra attempts after the first failure (3 total).
+    "--reruns", "2",
+    # Stock junitxml keeps only the last attempt; this plugin writes flakyFailure.
+    "-p", "pytest_junit_retry_plugin",
     # Flaky tests are excluded by default; the python_flaky_tests CI job
     # overrides this with `-m flaky` to run them in isolation.
     "-m", "not flaky and not requires_no_mfa",
@@ -296,10 +303,9 @@ SKIP_CORE_BUILD = "{env:SKIP_CORE_BUILD:1}"
 python = ["3.11", "3.12", "3.13", "3.14"]
 
 [tool.hatch.envs.dev.scripts]
-# Unit / integ: on failure, once-rerun last-failed tests (cap at 5 failures)
-# via pytest cache --lf / --maxfail. https://docs.pytest.org/en/stable/how-to/cache.html
-unit = "pytest tests/unit {args} || pytest tests/unit --lf --maxfail=5 {args}"
-integ = "pytest tests/integ {args} || pytest tests/integ --lf --maxfail=5 {args}"
+# Per-test retries come from addopts --reruns 2 (not a second whole-suite run).
+unit = "pytest tests/unit {args}"
+integ = "pytest tests/integ {args}"
 # End-to-end tests
 e2e = "pytest tests/e2e {args}"
 # All tests
@@ -322,9 +328,8 @@ python = ["3.11", "3.12", "3.13", "3.14"]
 [tool.hatch.envs.test.scripts]
 # Install from wheel
 install-wheel = "uv pip install {env:WHEEL_PATH:dist/*.whl}"
-# Split suites used by CI (no auto --lf; merge-group last-failed is a separate step).
-# Override the `dev` template scripts: those `|| pytest --lf` wrappers hide
-# failures from GitHub Actions, and `dev:e2e` does not ignore pandas.
+# Split suites used by CI. Override the `dev` template so `dev:e2e` does not
+# ignore pandas. Per-test retries come from addopts --reruns 2.
 unit = "pytest tests/unit {args}"
 integ = "pytest tests/integ {args}"
 e2e = "pytest tests/e2e --ignore=tests/e2e/pandas --ignore=tests/e2e/numpy {args}"
@@ -335,24 +340,15 @@ flaky = "pytest tests/ --ignore=tests/packaging --ignore=tests/e2e/pandas --igno
 # Runs @pytest.mark.requires_no_mfa tests (parameters_aws_local.json).
 no_mfa = "pytest tests/e2e/authentication/test_user_password.py -m requires_no_mfa -n 0 --no-cov {args}"
 
-# Native-arrow overlays python_bridge in install-wheel, then runs :cov.
+# Same unit/integ/e2e split as `test`. The harness sets use_core_arrow.
 [tool.hatch.envs.test-native-arrow]
 template = "test"
-features = ["test", "dev", "pyarrow"]
 
 [[tool.hatch.envs.test-native-arrow.matrix]]
 python = ["3.13"]
 
-[tool.hatch.envs.test-native-arrow.scripts]
-# Production wheel, then cargo-test + native-arrow overlay in this env's Python.
-install-wheel = [
-  "uv pip install {env:WHEEL_PATH:dist/*.whl}",
-  "python hatch_native_arrow.py",
-]
-# BOOLEAN, REAL, TEXT, BINARY, NUMBER, DECFLOAT, DATE, TIME, TIMESTAMP_LTZ, VECTOR,
-# DictCursor, and numpy (NUMBER/REAL/DECFLOAT, DATE, TIMESTAMP_NTZ, INTERVAL) are live.
-# Table and insert cases can run because execute_query status rows are NUMBER.
-cov = "pytest tests/unit/test_arrow_stream_utils.py tests/integ/test_cursor.py::TestDictCursorCreation tests/integ/test_cursor.py::TestDictCursorFetchOne tests/integ/test_cursor.py::TestDictCursorFetchMany tests/integ/test_cursor.py::TestDictCursorFetchAll tests/integ/test_cursor.py::TestDictCursorIteration tests/integ/test_cursor.py::TestDictCursorLargeResults tests/integ/test_cursor.py::TestDictCursorMultipleQueries tests/e2e/types/test_boolean.py tests/e2e/types/test_float.py tests/e2e/types/test_string.py tests/e2e/types/test_binary.py tests/e2e/types/test_number.py tests/e2e/types/test_int.py tests/e2e/types/test_decfloat.py tests/e2e/types/test_date.py tests/e2e/types/test_time.py tests/e2e/types/test_timestamp_ltz.py tests/e2e/types/test_vector.py tests/e2e/types/numpy/test_number_numpy.py tests/e2e/types/numpy/test_float_numpy.py tests/e2e/types/numpy/test_decfloat_numpy.py tests/e2e/types/numpy/test_date_numpy.py tests/e2e/types/numpy/test_timestamp_ntz_numpy.py tests/e2e/types/numpy/test_interval_numpy.py --cov=src/snowflake --cov-report=xml --cov-report=html {args}"
+[tool.hatch.envs.test-native-arrow.env-vars]
+SNOWFLAKE_TEST_USE_CORE_ARROW = "1"
 
 # Pandas and NumPy consumer CI test environment
 [tool.hatch.envs.test-pandas]

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/python_bridge/Cargo.toml

@@ -8,7 +8,7 @@ name = "sf_core_python"
 crate-type = ["cdylib", "rlib"]
 
 [features]
-default = ["extension-module"]
+default = ["extension-module", "native-arrow"]
 extension-module = ["pyo3/extension-module"]
 native-arrow = ["dep:arrow", "dep:snafu", "dep:error_trace", "dep:sf_types", "dep:chrono", "pyo3/chrono"]
 # Links the FIPS-mode crypto module (aws-lc-fips-sys) instead of
@@ -35,7 +35,7 @@ futures = "0.3"
 tracing = "0.1.41"
 
 [dev-dependencies]
-# Tests for the native path use --features native-arrow (activates optional arrow).
+# `native-arrow` is a default feature. `--no-default-features` drops it.
 pyo3 = { version = "0.29.0", features = ["auto-initialize"] }
 arrow = { version = ">=54.0.0, <59", features = ["ffi"] }
 tracing-subscriber = { version = "0.3.19", features = ["fmt"] }

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/python_bridge/src/arrow/converters/context.rs

@@ -14,6 +14,7 @@ use super::boolean;
 use super::date;
 use super::decfloat;
 use super::interval;
+use super::map;
 use super::number;
 use super::numpy::NumpyProvider;
 use super::real;
@@ -167,6 +168,7 @@ impl ConversionContext {
                 self.use_numpy,
             ),
             SnowflakeFieldType::Vector { .. } => vector::from_column(array, field_type),
+            SnowflakeFieldType::ArrowMap => map::from_column(self, array),
         }
     }
 }

snowflake_connector_python-5.0.0rc5/python_bridge/src/arrow/converters/map.rs

@@ -0,0 +1,187 @@
+use std::sync::Arc;
+
+use arrow::array::{Array, ArrayRef, MapArray};
+use arrow::datatypes::{DataType, FieldRef};
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+
+use super::Column;
+use super::context::ConversionContext;
+use super::util::{downcast_column, py_none};
+use crate::arrow::error::{InvalidMapSchemaSnafu, PlanError};
+use crate::arrow::plan::SnowflakeFieldType;
+
+pub(crate) struct MapColumn {
+    map: MapArray,
+    // MapColumn is a column so this has to be boxed to not have a circular reference
+    key: Box<Column>,
+    value: Box<Column>,
+}
+
+impl MapColumn {
+    pub(super) fn to_py<'py>(&self, py: Python<'py>, row: usize) -> PyResult<Bound<'py, PyAny>> {
+        if self.map.is_null(row) {
+            return Ok(py_none(py));
+        }
+        let offsets = self.map.offsets();
+        let start = map_offset(offsets, row)?;
+        let end = map_offset(offsets, row + 1)?;
+        if start > end || end > self.map.entries().len() {
+            return Err(PyValueError::new_err(
+                "[Snowflake Exception] map offsets are out of range",
+            ));
+        }
+        let dict = PyDict::new(py);
+        for index in start..end {
+            dict.set_item(self.key.to_py(py, index)?, self.value.to_py(py, index)?)?;
+        }
+        Ok(dict.into_any())
+    }
+}
+
+pub(super) fn from_column(context: &ConversionContext, array: &ArrayRef) -> PyResult<Column> {
+    let map = downcast_column::<MapArray>(array, &SnowflakeFieldType::ArrowMap)?;
+    let [key_field, value_field] = entry_fields(map.data_type())?;
+    let key_type = SnowflakeFieldType::from_field(key_field.as_ref())?;
+    let value_type = SnowflakeFieldType::from_field(value_field.as_ref())?;
+    let key = context.converter_from_column(map.keys(), &key_type)?;
+    let value = context.converter_from_column(map.values(), &value_type)?;
+    Ok(Column::Map(MapColumn {
+        map,
+        key: Box::new(key),
+        value: Box::new(value),
+    }))
+}
+
+fn entry_fields(data_type: &DataType) -> Result<[FieldRef; 2], PlanError> {
+    let DataType::Map(entries, _) = data_type else {
+        return InvalidMapSchemaSnafu { count: 0usize }.fail();
+    };
+    let DataType::Struct(fields) = entries.data_type() else {
+        return InvalidMapSchemaSnafu { count: 0usize }.fail();
+    };
+    let [key_field, value_field] = fields.as_ref() else {
+        return InvalidMapSchemaSnafu {
+            count: fields.len(),
+        }
+        .fail();
+    };
+    Ok([Arc::clone(key_field), Arc::clone(value_field)])
+}
+
+fn map_offset(offsets: &[i32], index: usize) -> PyResult<usize> {
+    let raw = offsets.get(index).copied().ok_or_else(|| {
+        PyValueError::new_err(format!(
+            "[Snowflake Exception] map offset index {index} is out of range"
+        ))
+    })?;
+    usize::try_from(raw).map_err(|_| {
+        PyValueError::new_err(format!(
+            "[Snowflake Exception] map offset {raw} is negative"
+        ))
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::sync::Arc;
+
+    use arrow::array::{Decimal128Array, MapArray, StringArray, StructArray};
+    use arrow::buffer::{NullBuffer, OffsetBuffer, ScalarBuffer};
+    use arrow::datatypes::{DataType, Field, Schema};
+    use pyo3::prelude::*;
+    use pyo3::types::PyDict;
+    use snafu::ResultExt;
+
+    use super::*;
+    use crate::arrow::converters::test_util::{assert_py_int, assert_py_none, assert_py_str};
+    use crate::arrow::error::ColumnConvertSnafu;
+
+    fn meta(logical_type: &str, extra: &[(&str, &str)]) -> HashMap<String, String> {
+        let mut metadata = HashMap::from([("logicalType".to_string(), logical_type.to_string())]);
+        for (key, value) in extra {
+            metadata.insert((*key).to_string(), (*value).to_string());
+        }
+        metadata
+    }
+
+    fn varchar_int_map(values: Vec<Option<i128>>, nulls: Option<Vec<bool>>) -> ArrayRef {
+        let key_field = Field::new("key", DataType::Utf8, false).with_metadata(meta("TEXT", &[]));
+        let value_field = Field::new("value", DataType::Decimal128(38, 0), true)
+            .with_metadata(meta("FIXED", &[("scale", "0"), ("precision", "38")]));
+        let keys = Arc::new(StringArray::from(
+            values
+                .iter()
+                .enumerate()
+                .map(|(index, value)| value.map(|_| format!("{}", (b'a' + index as u8) as char)))
+                .collect::<Vec<_>>(),
+        ));
+        let decimals = Arc::new(
+            Decimal128Array::from(values)
+                .with_precision_and_scale(38, 0)
+                .unwrap(),
+        );
+        let entries = StructArray::try_new(
+            vec![key_field.clone(), value_field.clone()].into(),
+            vec![keys, decimals],
+            None,
+        )
+        .unwrap();
+        let mut offsets = Vec::with_capacity(entries.len() + 1);
+        offsets.push(0i32);
+        for index in 0..entries.len() {
+            offsets.push((index + 1) as i32);
+        }
+        let nulls = nulls.map(NullBuffer::from);
+        let entries_field = Arc::new(Field::new(
+            "entries",
+            DataType::Struct(vec![key_field, value_field].into()),
+            false,
+        ));
+        Arc::new(
+            MapArray::try_new(
+                entries_field,
+                OffsetBuffer::new(ScalarBuffer::from(offsets)),
+                entries,
+                nulls,
+                false,
+            )
+            .context(ColumnConvertSnafu)
+            .unwrap(),
+        )
+    }
+
+    #[test]
+    fn map_row_is_dict_and_null_is_none() {
+        Python::initialize();
+        let context = ConversionContext::new(&Schema::empty()).unwrap();
+        let array = varchar_int_map(vec![Some(1), Some(2)], Some(vec![true, false]));
+        let column = context
+            .converter_from_column(&array, &SnowflakeFieldType::ArrowMap)
+            .unwrap();
+
+        Python::attach(|py| {
+            let dict = column.to_py(py, 0).unwrap();
+            let dict = dict.cast::<PyDict>().unwrap();
+            assert_eq!(dict.len(), 1);
+            assert_py_int(&dict.get_item("a").unwrap().unwrap(), 1);
+            assert_py_none(&column.to_py(py, 1).unwrap());
+        });
+    }
+
+    #[test]
+    fn utf8_map_stays_json_string() {
+        Python::initialize();
+        let field = Field::new("m", DataType::Utf8, true).with_metadata(meta("MAP", &[]));
+        let field_type = SnowflakeFieldType::from_field(&field).unwrap();
+        let context = ConversionContext::new(&Schema::empty()).unwrap();
+        let array: ArrayRef = Arc::new(StringArray::from(vec![Some("{\"a\": 1}")]));
+        let column = context.converter_from_column(&array, &field_type).unwrap();
+
+        Python::attach(|py| {
+            assert_py_str(&column.to_py(py, 0).unwrap(), "{\"a\": 1}");
+        });
+    }
+}

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/python_bridge/src/arrow/converters/mod.rs

@@ -5,6 +5,7 @@ mod date;
 mod decfloat;
 mod decode;
 mod interval;
+mod map;
 mod number;
 mod numpy;
 mod real;
@@ -15,6 +16,8 @@ mod timestamp_ntz;
 mod timestamp_tz;
 mod timezone;
 mod util;
+
+pub(crate) use timezone::TimezoneProvider;
 mod vector;
 
 #[cfg(test)]
@@ -40,8 +43,10 @@ use self::interval::{
     IntervalNumpyColumn, IntervalYearMonthColumn, IntervalYearMonthNumpyMMaterializer,
     IntervalYearMonthNumpyYMaterializer,
 };
+use self::map::MapColumn;
 use self::number::{
-    NumberColumn, NumberMaterializer, NumberNumpyFloatMaterializer, NumberNumpyIntMaterializer,
+    NumberColumn, NumberI64Column, NumberMaterializer, NumberNumpyFloatMaterializer,
+    NumberNumpyIntMaterializer,
 };
 use self::real::{RealMaterializer, RealNumpyMaterializer};
 use self::text::TextMaterializer;
@@ -56,6 +61,7 @@ pub(crate) use context::{ConversionContext, RowShape};
 pub(crate) enum Column {
     Bool(TypedColumn<BooleanArray, SnowflakeBoolean, BoolMaterializer>),
     Number(NumberColumn<NumberMaterializer>),
+    NumberI64(NumberI64Column),
     NumberNumpyInt(NumberColumn<NumberNumpyIntMaterializer>),
     NumberNumpyFloat(NumberColumn<NumberNumpyFloatMaterializer>),
     Real(TypedColumn<Float64Array, SnowflakeReal, RealMaterializer>),
@@ -78,6 +84,7 @@ pub(crate) enum Column {
     IntervalDayTimeNumpyNs(IntervalNumpyColumn<IntervalDayTimeNumpyNsMaterializer>),
     IntervalDayTimeNumpyMs(IntervalNumpyColumn<IntervalDayTimeNumpyMsMaterializer>),
     Vector(TypedColumn<FixedSizeListArray, SnowflakeVector, VectorMaterializer>),
+    Map(MapColumn),
 }
 
 impl Column {
@@ -85,6 +92,7 @@ impl Column {
         match self {
             Self::Bool(column) => column.to_py(py, row),
             Self::Number(column) => column.to_py(py, row),
+            Self::NumberI64(column) => column.to_py(py, row),
             Self::NumberNumpyInt(column) => column.to_py(py, row),
             Self::NumberNumpyFloat(column) => column.to_py(py, row),
             Self::Real(column) => column.to_py(py, row),
@@ -107,6 +115,7 @@ impl Column {
             Self::IntervalDayTimeNumpyNs(column) => column.to_py(py, row),
             Self::IntervalDayTimeNumpyMs(column) => column.to_py(py, row),
             Self::Vector(column) => column.to_py(py, row),
+            Self::Map(column) => column.to_py(py, row),
         }
     }
 }

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/python_bridge/src/arrow/converters/number.rs

@@ -1,14 +1,18 @@
 use std::sync::Arc;
 
+use std::ffi::c_longlong;
+
 use arrow::array::ArrayRef;
+use arrow::datatypes::DataType;
 use pyo3::exceptions::PyValueError;
+use pyo3::ffi::PyLong_FromLongLong;
 use pyo3::prelude::*;
 use sf_types::{ReadArrowError, SnowflakeFixed};
 
 use super::Column;
 use super::decode::PyMaterializer;
 use super::numpy::NumpyProvider;
-use crate::arrow::converters::util::{IntColumn, py_decimal_from_coeff_exp, py_none};
+use crate::arrow::converters::util::{IntColumn, IntColumn64, py_decimal_from_coeff_exp, py_none};
 use crate::arrow::plan::SnowflakeFieldType;
 use crate::arrow::scaled_f64::scaled_f64;
 
@@ -27,6 +31,26 @@ impl<M: PyMaterializer<SnowflakeFixed>> NumberColumn<M> {
     }
 }
 
+pub(crate) struct NumberI64Column {
+    values: IntColumn64,
+}
+
+impl NumberI64Column {
+    pub(crate) fn to_py<'py>(&self, py: Python<'py>, row: usize) -> PyResult<Bound<'py, PyAny>> {
+        match self.values.get(row) {
+            Ok(value) => py_long_from_i64(py, value),
+            Err(ReadArrowError::NullValue { .. }) => Ok(py_none(py)),
+            Err(err) => Err(PyValueError::new_err(err.to_string())),
+        }
+    }
+}
+
+fn py_long_from_i64<'py>(py: Python<'py>, value: i64) -> PyResult<Bound<'py, PyAny>> {
+    // SAFETY: `PyLong_FromLongLong` returns a new reference, or NULL when allocation fails.
+    // `from_owned_ptr_or_err` takes that reference and turns NULL into the current Python error.
+    unsafe { Bound::from_owned_ptr_or_err(py, PyLong_FromLongLong(value as c_longlong)) }
+}
+
 pub(super) fn from_column(
     array: &ArrayRef,
     field_type: &SnowflakeFieldType,
@@ -34,6 +58,11 @@ pub(super) fn from_column(
     numpy: Arc<NumpyProvider>,
     use_numpy: bool,
 ) -> PyResult<Column> {
+    if scale == 0 && !use_numpy && is_i64_width(array) {
+        return Ok(Column::NumberI64(NumberI64Column {
+            values: IntColumn64::from_fixed(array, field_type)?,
+        }));
+    }
     let values = IntColumn::from_fixed(array, field_type)?;
     // Numpy FIXED uses the same scale split as Python FIXED, but only on
     // integer physical widths: scale 0 is numpy.int64, scale > 0 is
@@ -57,6 +86,13 @@ pub(super) fn from_column(
     }))
 }
 
+fn is_i64_width(array: &ArrayRef) -> bool {
+    matches!(
+        array.data_type(),
+        DataType::Int8 | DataType::Int16 | DataType::Int32 | DataType::Int64
+    )
+}
+
 pub(crate) struct NumberMaterializer {
     scale: u32,
 }

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/python_bridge/src/arrow/converters/timezone.rs

@@ -2,20 +2,24 @@ use pyo3::prelude::*;
 use pyo3::sync::PyOnceLock;
 use pyo3::types::PyTzInfo;
 
-pub(super) struct TimezoneProvider {
+pub(crate) struct TimezoneProvider {
     name: Option<String>,
     tz: PyOnceLock<Py<PyTzInfo>>,
 }
 
 impl TimezoneProvider {
-    pub(super) fn new(name: Option<String>) -> Self {
+    pub(crate) fn new(name: Option<String>) -> Self {
         Self {
             name,
             tz: PyOnceLock::new(),
         }
     }
 
-    pub(super) fn get<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyTzInfo>> {
+    pub(crate) fn name(&self) -> Option<&str> {
+        self.name.as_deref().filter(|name| !name.is_empty())
+    }
+
+    pub(crate) fn get<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyTzInfo>> {
         self.tz
             .get_or_try_init(py, || resolve_session_timezone(py, self.name.as_deref()))
             .map(|tz| tz.bind(py).clone())

{snowflake_connector_python-5.0.0rc4 → snowflake_connector_python-5.0.0rc5}/python_bridge/src/arrow/converters/util.rs

@@ -1,5 +1,6 @@
 use arrow::array::{
-    Array, ArrayRef, Decimal128Array, Int8Array, Int16Array, Int32Array, Int64Array, StructArray,
+    Array, ArrayRef, ArrowPrimitiveType, Decimal128Array, Int8Array, Int16Array, Int32Array,
+    Int64Array, PrimitiveArray, StructArray,
 };
 use arrow::datatypes::DataType;
 use chrono::NaiveDateTime;
@@ -8,7 +9,7 @@ use pyo3::prelude::*;
 use pyo3::sync::PyOnceLock;
 use pyo3::types::{PyNone, PyTuple};
 use sf_types::{
-    ReadArrowError, ReadArrowType, SnowflakeFixed, read_scaled_timestamp,
+    NullValueSnafu, ReadArrowError, ReadArrowType, SnowflakeFixed, read_scaled_timestamp,
     read_scaled_timestamp_nanos, read_struct_timestamp, read_struct_timestamp_nanos,
 };
 
@@ -63,6 +64,45 @@ impl IntColumn {
     }
 }
 
+pub(super) enum IntColumn64 {
+    I8(Int8Array),
+    I16(Int16Array),
+    I32(Int32Array),
+    I64(Int64Array),
+}
+
+impl IntColumn64 {
+    pub(super) fn from_fixed(array: &ArrayRef, field_type: &SnowflakeFieldType) -> PyResult<Self> {
+        Ok(match array.data_type() {
+            DataType::Int8 => Self::I8(downcast_column(array, field_type)?),
+            DataType::Int16 => Self::I16(downcast_column(array, field_type)?),
+            DataType::Int32 => Self::I32(downcast_column(array, field_type)?),
+            DataType::Int64 => Self::I64(downcast_column(array, field_type)?),
+            other => return Err(logical_mismatch_err(field_type, other)),
+        })
+    }
+
+    pub(super) fn get(&self, row: usize) -> Result<i64, ReadArrowError> {
+        match self {
+            Self::I8(array) => read_widened_i64(array, row),
+            Self::I16(array) => read_widened_i64(array, row),
+            Self::I32(array) => read_widened_i64(array, row),
+            Self::I64(array) => read_widened_i64(array, row),
+        }
+    }
+}
+
+fn read_widened_i64<T>(array: &PrimitiveArray<T>, row: usize) -> Result<i64, ReadArrowError>
+where
+    T: ArrowPrimitiveType,
+    T::Native: Into<i64>,
+{
+    if array.is_null(row) {
+        return Err(NullValueSnafu.build());
+    }
+    Ok(array.value(row).into())
+}
+
 pub(super) enum TimestampColumn {
     Int64(Int64Array),
     Struct(StructArray),
@@ -133,11 +173,12 @@ fn decimal_type(py: Python<'_>) -> PyResult<&Bound<'_, PyAny>> {
 mod tests {
     use std::sync::Arc;
 
-    use arrow::array::{ArrayRef, Int32Array, Int64Array};
+    use arrow::array::{ArrayRef, Int8Array, Int32Array, Int64Array};
     use pyo3::exceptions::PyValueError;
     use pyo3::prelude::*;
+    use sf_types::ReadArrowError;
 
-    use super::downcast_column;
+    use super::{IntColumn64, downcast_column};
     use crate::arrow::plan::SnowflakeFieldType;
 
     #[test]
@@ -175,4 +216,20 @@ mod tests {
             );
         });
     }
+
+    #[test]
+    fn int_column64_widens_to_i64_and_reports_null() {
+        let field_type = SnowflakeFieldType::Number {
+            scale: 0,
+            precision: 38,
+        };
+        let array: ArrayRef = Arc::new(Int8Array::from(vec![Some(i8::MIN), None, Some(i8::MAX)]));
+        let column = IntColumn64::from_fixed(&array, &field_type).unwrap();
+        assert_eq!(column.get(0).unwrap(), i64::from(i8::MIN));
+        assert!(matches!(
+            column.get(1),
+            Err(ReadArrowError::NullValue { .. })
+        ));
+        assert_eq!(column.get(2).unwrap(), i64::from(i8::MAX));
+    }
 }