snowflake-connector-python 5.0.0rc2__tar.gz → 5.0.0rc3__tar.gz

{snowflake_connector_python-5.0.0rc2 → snowflake_connector_python-5.0.0rc3}/Cargo.lock

@@ -3920,6 +3920,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
 dependencies = [
+ "chrono",
  "libc",
  "once_cell",
  "portable-atomic",
@@ -3990,16 +3991,19 @@ name = "python_bridge"
 version = "0.1.0"
 dependencies = [
  "arrow",
+ "chrono",
  "error_trace",
  "futures",
  "proto_utils",
  "pyo3",
  "pyo3-async-runtimes",
  "sf_core",
+ "sf_types",
  "snafu 0.8.9",
  "tokio",
  "tokio-util",
  "tracing",
+ "tracing-subscriber",
 ]
 
 [[package]]
@@ -4709,6 +4713,7 @@ dependencies = [
  "arrow",
  "arrow-ipc",
  "arrow_deserialize_macro",
+ "async-trait",
  "aws-config",
  "aws-credential-types",
  "aws-lc-rs",
@@ -4811,6 +4816,16 @@ dependencies = [
 name = "sf_params_spec"
 version = "0.0.0"
 
+[[package]]
+name = "sf_types"
+version = "0.1.0"
+dependencies = [
+ "arrow",
+ "chrono",
+ "error_trace",
+ "snafu 0.8.9",
+]
+
 [[package]]
 name = "sha1"
 version = "0.10.6"

{snowflake_connector_python-5.0.0rc2 → snowflake_connector_python-5.0.0rc3}/Cargo.toml

@@ -5,6 +5,7 @@ members = [
     "python_bridge",
     "python_bridge/stub_gen",
     "sf_params_spec",
+    "sf_types",
     "proto_utils",
     "error_trace",
     "error_trace_derive",

{snowflake_connector_python-5.0.0rc2 → snowflake_connector_python-5.0.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: snowflake-connector-python
-Version: 5.0.0rc2
+Version: 5.0.0rc3
 Summary: Snowflake DB driver for Python
 Project-URL: Homepage, https://github.com/snowflakedb/drivers
 Project-URL: Bug Reports, https://github.com/snowflakedb/drivers/issues
@@ -12,16 +12,15 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Database
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: cryptography>=46.0.5
-Requires-Dist: protobuf>=6.32.1
+Requires-Dist: protobuf<7,>=6.32.1
 Requires-Dist: pytz
 Requires-Dist: tomlkit>=0.13
 Provides-Extra: dev
@@ -70,13 +69,13 @@ using the Snowflake JDBC or ODBC drivers.
 
 The connector has **no** dependencies on JDBC or ODBC.
 It can be installed using ``pip`` on Linux, Mac OSX, and Windows platforms
-where Python 3.10.0 (or higher) is installed.
+where Python 3.11.0 (or higher) is installed.
 
 
 ## Development
 
 ### Prerequisites
-- Python 3.10+
+- Python 3.11+
 - [uv](https://docs.astral.sh/uv/) package manager
 - [Hatch](https://hatch.pypa.io/) build tool
 - Rust toolchain (for building core library)
@@ -115,7 +114,7 @@ The `dev` environment is designed for **human developers** during active develop
 - Installs from sources (`skip-install = false`)
 - Editable mode enabled (`dev-mode = true`)
 - Changes to source code are immediately available
-- Supports Python matrix: 3.10, 3.11, 3.12, 3.13, 3.14
+- Supports Python matrix: 3.11, 3.12, 3.13, 3.14
 
 **Usage:**
 ```bash

{snowflake_connector_python-5.0.0rc2 → snowflake_connector_python-5.0.0rc3}/README.md

@@ -12,13 +12,13 @@ using the Snowflake JDBC or ODBC drivers.
 
 The connector has **no** dependencies on JDBC or ODBC.
 It can be installed using ``pip`` on Linux, Mac OSX, and Windows platforms
-where Python 3.10.0 (or higher) is installed.
+where Python 3.11.0 (or higher) is installed.
 
 
 ## Development
 
 ### Prerequisites
-- Python 3.10+
+- Python 3.11+
 - [uv](https://docs.astral.sh/uv/) package manager
 - [Hatch](https://hatch.pypa.io/) build tool
 - Rust toolchain (for building core library)
@@ -57,7 +57,7 @@ The `dev` environment is designed for **human developers** during active develop
 - Installs from sources (`skip-install = false`)
 - Editable mode enabled (`dev-mode = true`)
 - Changes to source code are immediately available
-- Supports Python matrix: 3.10, 3.11, 3.12, 3.13, 3.14
+- Supports Python matrix: 3.11, 3.12, 3.13, 3.14
 
 **Usage:**
 ```bash

snowflake_connector_python-5.0.0rc3/ci/anaconda/recipe/README.md

@@ -0,0 +1,39 @@
+# Conda recipe
+
+Builds `snowflake-connector-python` from this repository. The package is not
+`noarch`: it ships two ABI-tagged native extensions (the PyO3 core bridge and
+the Cython/C++ Arrow reader), so it is built per Python version and per
+architecture.
+
+`source.path` is the repository root. The Python wrapper reaches the Rust
+workspace through relative symlinks (`python/Cargo.toml`, `python/sf_core`,
+`python/python_bridge`) that only resolve when the whole workspace is present.
+Build from a clean checkout, or remove `target/` first — conda-build copies the
+source tree.
+
+## Build
+
+From the repository root, with conda-build installed (`conda install -c
+conda-forge conda-build`):
+
+```bash
+conda build python/ci/anaconda/recipe --python 3.12
+```
+
+The C/C++ and Rust toolchains come from `requirements.build`. Version is read
+from `python/src/snowflake/connector/version.py`; override with
+`SNOWFLAKE_CONNECTOR_PYTHON_VERSION`. Build number defaults to `0`; override
+with `UNIVERSAL_DRIVER_BUILD_NUMBER`.
+
+`conda_build_config.yaml` pins the sysroot (glibc floor) to 2.17. That is the
+oldest conda-forge publishes for both `linux-64` and `linux-aarch64`. Without
+it, current compilers select sysroot 2.34.
+
+`libprotobuf` is capped to match the runtime available in Snowflake's
+in-platform channel.
+
+Optional `script_env` passthroughs for iteration: `SKIP_CORE_BUILD`,
+`SNOWFLAKE_DISABLE_COMPILE_ARROW_EXTENSIONS`, `SKIP_PROTO_GENERATION`,
+`CORE_CARGO_TARGET_DIR`, `PROTO_CARGO_TARGET_DIR`, `CARGO_NET_OFFLINE`. A
+`_core/` binary is tagged with `sysconfig` `EXT_SUFFIX`, so a 3.13 build is not
+reusable for 3.12. `test.imports` fails the package if an extension is missing.

{snowflake_connector_python-5.0.0rc2 → snowflake_connector_python-5.0.0rc3}/protobuf/database_driver_v1.proto

@@ -139,6 +139,12 @@ message ColumnMetadata {
   bool is_auto_increment = 13;
   string ext_col_type_name = 14;
   string udt_output_type = 15;
+  // Nested column metadata for structured types. Carries the element type for
+  // VECTOR and ARRAY, the key and value types for MAP, and one entry per
+  // attribute for structured OBJECT. Empty for every other type, and also for
+  // semi-structured (unstructured) ARRAY/OBJECT/MAP, which the server sends
+  // without a nested field list.
+  repeated ColumnMetadata fields = 16;
 }
 
 // DML operation statistics

{snowflake_connector_python-5.0.0rc2 → snowflake_connector_python-5.0.0rc3}/pyproject.toml

@@ -16,16 +16,20 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = [
     "cryptography>=46.0.5",
-    "protobuf>=6.32.1",
+    # Snowflake's in-platform Anaconda channel (Python UDF / stored-procedure
+    # resolve) tops out at protobuf 6.33.5; 7.x is not mirrored. A 7.x protoc
+    # bakes gencode that fails sproc import with
+    # VersionError: gencode 7.x runtime 6.33.5. Cap here so conda recipe run
+    # deps stay in lockstep (validate_deps_sync.py) and pip cannot pull 7.x.
+    "protobuf>=6.32.1,<7",
     "pytz",
     "tomlkit>=0.13",
 ]
@@ -85,6 +89,7 @@ include = [
     "sf_core/",
     "python_bridge/",
     "sf_params_spec/",
+    "sf_types/",
     "proto_utils/",
     "proto_generator/",
     "protobuf/",
@@ -98,6 +103,7 @@ exclude = [
     "sf_core/target/",
     "python_bridge/target/",
     "sf_params_spec/target/",
+    "sf_types/target/",
     "proto_utils/target/",
     # Exclude sf_core tests (except arrow_deserialize_macro which is a dev-dependency)
     "sf_core/tests/e2e/",
@@ -125,6 +131,9 @@ path = "hatch_build.py"
 
 [tool.hatch.build.hooks.custom]
 
+[tool.cibuildwheel.windows]
+repair-wheel-command = "delvewheel repair --namespace-pkg snowflake -w {dest_dir} -v {wheel}"
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]
@@ -183,7 +192,7 @@ exclude_lines = [
 ]
 
 [tool.mypy]
-python_version = "3.10"
+python_version = "3.11"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true
@@ -240,13 +249,13 @@ dependencies = [
     # Keep in sync with `[project].dependencies` plus numpy (referenced by
     # arrow_context.py type hints).
     "cryptography>=46.0.5",
-    "protobuf>=6.32.1",
+    "protobuf>=6.32.1,<7",
     "pytz",
     "tomlkit>=0.13",
-    # Cap < 2.3 to match the mypy `python_version = "3.10"` target: numpy 2.3
-    # dropped 3.10 and its stubs use PEP-695 `type` statements mypy rejects
-    # under a 3.10 target. A real 3.10 install resolves numpy <= 2.2, so this is
-    # the numpy we should type-check against.
+    # Cap < 2.3 to match the mypy `python_version = "3.11"` target: numpy 2.3+
+    # stubs use PEP-695 `type` statements, which mypy rejects below a 3.12
+    # target. A 3.11 install still resolves numpy < 2.3, so this is the numpy
+    # we should type-check against.
     "numpy>=2.1.0,<2.3",
 ]
 
@@ -284,7 +293,7 @@ PARAMETER_PATH = "{env:PARAMETER_PATH:../parameters.json}"
 SKIP_CORE_BUILD = "{env:SKIP_CORE_BUILD:1}"
 
 [[tool.hatch.envs.dev.matrix]]
-python = ["3.10", "3.11", "3.12", "3.13", "3.14"]
+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)
@@ -308,7 +317,7 @@ skip-install = true
 dev-mode = false
 
 [[tool.hatch.envs.test.matrix]]
-python = ["3.10", "3.11", "3.12", "3.13", "3.14"]
+python = ["3.11", "3.12", "3.13", "3.14"]
 
 [tool.hatch.envs.test.scripts]
 # Install from wheel
@@ -340,7 +349,9 @@ install-wheel = [
   "uv pip install {env:WHEEL_PATH:dist/*.whl}",
   "python hatch_native_arrow.py",
 ]
-cov = "true {args}"
+# BOOLEAN, REAL, TEXT, BINARY, NUMBER, DECFLOAT, DATE, and TIME converters are live.
+# Table and insert cases can run because execute_query status rows are NUMBER.
+cov = "pytest 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 --cov=src/snowflake --cov-report=xml --cov-report=html {args}"
 
 # Pandas-specific CI test environment
 [tool.hatch.envs.test-pandas]
@@ -348,7 +359,7 @@ template = "test"
 features = ["test", "dev", "pandas"]
 
 [[tool.hatch.envs.test-pandas.matrix]]
-python = ["3.10", "3.11", "3.12", "3.13", "3.14"]
+python = ["3.11", "3.12", "3.13", "3.14"]
 
 [tool.hatch.envs.test-pandas.scripts]
 cov = "pytest tests/e2e/pandas --cov=src/snowflake --cov-report=xml --cov-report=html {args}"

{snowflake_connector_python-5.0.0rc2 → snowflake_connector_python-5.0.0rc3}/python_bridge/Cargo.toml

@@ -11,12 +11,14 @@ crate-type = ["cdylib", "rlib"]
 default = ["extension-module"]
 extension-module = ["pyo3/extension-module"]
 vendored-openssl = ["sf_core/vendored-openssl"]
-native-arrow = ["dep:arrow", "dep:snafu", "dep:error_trace"]
+native-arrow = ["dep:arrow", "dep:snafu", "dep:error_trace", "dep:sf_types", "dep:chrono", "pyo3/chrono"]
 
 [dependencies]
 arrow = { version = ">=54.0.0, <59", features = ["ffi"], optional = true }
 snafu = { version = "0.8", optional = true }
 error_trace = { path = "../error_trace", optional = true }
+sf_types = { path = "../sf_types", optional = true }
+chrono = { version = "0.4.43", optional = true }
 
 sf_core = { path = "../sf_core" }
 proto_utils = { path = "../proto_utils" }
@@ -31,3 +33,4 @@ tracing = "0.1.41"
 # Tests for the native path use --features native-arrow (activates optional arrow).
 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.0rc3/python_bridge/src/arrow/converters/binary.rs

@@ -0,0 +1,58 @@
+use arrow::array::{ArrayRef, BinaryArray};
+use pyo3::prelude::*;
+use pyo3::types::PyByteArray;
+use sf_types::SnowflakeBinary;
+
+use super::Column;
+use super::decode::{PyMaterializer, TypedColumn};
+use crate::arrow::converters::util::downcast_column;
+use crate::arrow::plan::SnowflakeFieldType;
+
+pub(super) fn from_column(array: &ArrayRef, field_type: &SnowflakeFieldType) -> PyResult<Column> {
+    downcast_column::<BinaryArray>(array, field_type)
+        .map(|array| Column::Binary(TypedColumn::new(array, SnowflakeBinary, BinaryMaterializer)))
+}
+
+pub(crate) struct BinaryMaterializer;
+
+impl PyMaterializer<SnowflakeBinary> for BinaryMaterializer {
+    fn materialize<'py>(&self, py: Python<'py>, value: &[u8]) -> PyResult<Bound<'py, PyAny>> {
+        Ok(PyByteArray::new(py, value).into_any())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow::array::{ArrayRef, BinaryArray};
+    use arrow::datatypes::Schema;
+    use pyo3::prelude::*;
+
+    use crate::arrow::converters::ConversionContext;
+    use crate::arrow::converters::test_util::{assert_py_bytes, assert_py_none};
+    use crate::arrow::plan::SnowflakeFieldType;
+
+    fn binary() -> SnowflakeFieldType {
+        SnowflakeFieldType::Binary { len: 8_388_608 }
+    }
+
+    #[test]
+    fn binary_converts_to_python_bytearray() {
+        Python::initialize();
+        let ctx = ConversionContext::new(&Schema::empty()).unwrap();
+
+        let array: ArrayRef = Arc::new(BinaryArray::from_opt_vec(vec![
+            Some(b"hello".as_slice()),
+            None,
+            Some(b"".as_slice()),
+        ]));
+        let column = ctx.converter_from_column(&array, &binary()).unwrap();
+
+        Python::attach(|py| {
+            assert_py_bytes(&column.to_py(py, 0).unwrap(), b"hello");
+            assert_py_none(&column.to_py(py, 1).unwrap());
+            assert_py_bytes(&column.to_py(py, 2).unwrap(), b"");
+        });
+    }
+}

snowflake_connector_python-5.0.0rc3/python_bridge/src/arrow/converters/boolean.rs

@@ -0,0 +1,52 @@
+use arrow::array::{ArrayRef, BooleanArray};
+use pyo3::prelude::*;
+use pyo3::types::PyBool;
+use sf_types::SnowflakeBoolean;
+
+use super::Column;
+use super::decode::{PyMaterializer, TypedColumn};
+use crate::arrow::converters::util::downcast_column;
+use crate::arrow::plan::SnowflakeFieldType;
+
+pub(super) fn from_column(array: &ArrayRef, field_type: &SnowflakeFieldType) -> PyResult<Column> {
+    downcast_column::<BooleanArray>(array, field_type)
+        .map(|array| Column::Bool(TypedColumn::new(array, SnowflakeBoolean, BoolMaterializer)))
+}
+
+pub(crate) struct BoolMaterializer;
+
+impl PyMaterializer<SnowflakeBoolean> for BoolMaterializer {
+    fn materialize<'py>(&self, py: Python<'py>, value: bool) -> PyResult<Bound<'py, PyAny>> {
+        Ok(PyBool::new(py, value).to_owned().into_any())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow::array::{ArrayRef, BooleanArray};
+    use arrow::datatypes::Schema;
+    use pyo3::prelude::*;
+
+    use crate::arrow::converters::ConversionContext;
+    use crate::arrow::converters::test_util::{assert_py_bool, assert_py_none};
+    use crate::arrow::plan::SnowflakeFieldType;
+
+    #[test]
+    fn boolean_array_converts_to_python_bool() {
+        Python::initialize();
+        let ctx = ConversionContext::new(&Schema::empty()).unwrap();
+
+        let array: ArrayRef = Arc::new(BooleanArray::from(vec![Some(true), None, Some(false)]));
+        let column = ctx
+            .converter_from_column(&array, &SnowflakeFieldType::Boolean)
+            .unwrap();
+
+        Python::attach(|py| {
+            assert_py_bool(&column.to_py(py, 0).unwrap(), true);
+            assert_py_none(&column.to_py(py, 1).unwrap());
+            assert_py_bool(&column.to_py(py, 2).unwrap(), false);
+        });
+    }
+}

{snowflake_connector_python-5.0.0rc2 → snowflake_connector_python-5.0.0rc3}/python_bridge/src/arrow/converters/context.rs

@@ -7,6 +7,15 @@ use crate::arrow::batch_converter::BatchConverter;
 use crate::arrow::plan::{LogicalPlan, SnowflakeFieldType};
 
 use super::Column;
+use super::binary;
+use super::boolean;
+use super::date;
+use super::decfloat;
+use super::number;
+use super::real;
+use super::text;
+use super::time;
+use super::timestamp_ntz;
 
 pub(crate) struct ConversionContext {
     plan: LogicalPlan,
@@ -32,21 +41,25 @@ impl ConversionContext {
 
     pub(crate) fn converter_from_column(
         &self,
-        _array: &ArrayRef,
+        array: &ArrayRef,
         field_type: &SnowflakeFieldType,
     ) -> PyResult<Column> {
         match *field_type {
-            SnowflakeFieldType::Varchar { .. }
-            | SnowflakeFieldType::Number { .. }
-            | SnowflakeFieldType::Date
-            | SnowflakeFieldType::Time { .. }
-            | SnowflakeFieldType::TimestampNtz { .. }
-            | SnowflakeFieldType::TimestampLtz { .. }
+            SnowflakeFieldType::Boolean => boolean::from_column(array, field_type),
+            SnowflakeFieldType::Number { scale, .. } => {
+                number::from_column(array, field_type, scale)
+            }
+            SnowflakeFieldType::Real => real::from_column(array, field_type),
+            SnowflakeFieldType::Varchar { .. } => text::from_column(array, field_type),
+            SnowflakeFieldType::Binary { .. } => binary::from_column(array, field_type),
+            SnowflakeFieldType::Decfloat { .. } => decfloat::from_column(array, field_type),
+            SnowflakeFieldType::Date => date::from_column(array, field_type),
+            SnowflakeFieldType::Time { scale } => time::from_column(array, field_type, scale),
+            SnowflakeFieldType::TimestampNtz { scale } => {
+                timestamp_ntz::from_column(array, field_type, scale)
+            }
+            SnowflakeFieldType::TimestampLtz { .. }
             | SnowflakeFieldType::TimestampTz { .. }
-            | SnowflakeFieldType::Boolean
-            | SnowflakeFieldType::Binary { .. }
-            | SnowflakeFieldType::Real
-            | SnowflakeFieldType::Decfloat { .. }
             | SnowflakeFieldType::Vector { .. } => Err(PyNotImplementedError::new_err(format!(
                 "native Arrow conversion is not implemented for logical type {}",
                 field_type.logical_type_name()

snowflake_connector_python-5.0.0rc3/python_bridge/src/arrow/converters/date.rs

@@ -0,0 +1,140 @@
+use arrow::array::{ArrayRef, Date32Array};
+use chrono::{Datelike, NaiveDate};
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+use sf_types::SnowflakeDate;
+
+use super::Column;
+use super::decode::{PyMaterializer, TypedColumn};
+use crate::arrow::converters::util::downcast_column;
+use crate::arrow::plan::SnowflakeFieldType;
+
+pub(super) fn from_column(array: &ArrayRef, field_type: &SnowflakeFieldType) -> PyResult<Column> {
+    downcast_column::<Date32Array>(array, field_type)
+        .map(|array| Column::Date(TypedColumn::new(array, SnowflakeDate, DateMaterializer)))
+}
+
+pub(crate) struct DateMaterializer;
+
+impl PyMaterializer<SnowflakeDate> for DateMaterializer {
+    fn materialize<'py>(&self, py: Python<'py>, value: NaiveDate) -> PyResult<Bound<'py, PyAny>> {
+        let year = value.year();
+        if !(1..=9999).contains(&year) {
+            return Err(PyValueError::new_err(format!(
+                "DATE {value} is outside the datetime.date year range 1..=9999"
+            )));
+        }
+        Ok(value.into_pyobject(py)?.into_any())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow::array::{ArrayRef, Date32Array, Int32Array};
+    use arrow::datatypes::Schema;
+    use pyo3::exceptions::PyValueError;
+    use pyo3::prelude::*;
+
+    use crate::arrow::converters::ConversionContext;
+    use crate::arrow::converters::test_util::{assert_py_date, assert_py_none};
+    use crate::arrow::plan::SnowflakeFieldType;
+
+    #[test]
+    fn date_converts_to_python_date_with_nulls() {
+        Python::initialize();
+        let ctx = ConversionContext::new(&Schema::empty()).unwrap();
+
+        let array: ArrayRef = Arc::new(Date32Array::from(vec![
+            Some(0),
+            None,
+            Some(-1),
+            Some(-719162),
+            Some(2932896),
+        ]));
+        let column = ctx
+            .converter_from_column(&array, &SnowflakeFieldType::Date)
+            .unwrap();
+
+        Python::attach(|py| {
+            assert_py_date(&column.to_py(py, 0).unwrap(), 1970, 1, 1);
+            assert_py_none(&column.to_py(py, 1).unwrap());
+            assert_py_date(&column.to_py(py, 2).unwrap(), 1969, 12, 31);
+            assert_py_date(&column.to_py(py, 3).unwrap(), 1, 1, 1);
+            assert_py_date(&column.to_py(py, 4).unwrap(), 9999, 12, 31);
+        });
+    }
+
+    #[test]
+    fn rejects_physical_mismatch_for_date() {
+        Python::initialize();
+        let ctx = ConversionContext::new(&Schema::empty()).unwrap();
+        let array: ArrayRef = Arc::new(Int32Array::from(vec![Some(0)]));
+        let err = match ctx.converter_from_column(&array, &SnowflakeFieldType::Date) {
+            Ok(_) => panic!("expected physical mismatch for Int32 DATE"),
+            Err(err) => err,
+        };
+        Python::attach(|py| {
+            assert!(
+                err.is_instance_of::<PyValueError>(py),
+                "expected PyValueError, got {err}"
+            );
+            let text = err.value(py).str().unwrap().to_string_lossy().into_owned();
+            assert!(
+                text.contains("logical/physical type mismatch")
+                    && text.contains("DATE")
+                    && text.contains("Int32"),
+                "got {text}"
+            );
+        });
+    }
+
+    #[test]
+    fn rejects_day_offset_outside_calendar_range() {
+        Python::initialize();
+        let ctx = ConversionContext::new(&Schema::empty()).unwrap();
+        let array: ArrayRef = Arc::new(Date32Array::from(vec![Some(i32::MAX)]));
+        let column = ctx
+            .converter_from_column(&array, &SnowflakeFieldType::Date)
+            .unwrap();
+
+        Python::attach(|py| {
+            let err = column.to_py(py, 0).unwrap_err();
+            assert!(
+                err.is_instance_of::<PyValueError>(py),
+                "expected PyValueError, got {err}"
+            );
+            let text = err.value(py).str().unwrap().to_string_lossy().into_owned();
+            assert!(
+                text.contains("Invalid Arrow value") && text.contains("DATE"),
+                "got {text}"
+            );
+        });
+    }
+
+    #[test]
+    fn rejects_dates_outside_python_date_year_range() {
+        Python::initialize();
+        let ctx = ConversionContext::new(&Schema::empty()).unwrap();
+        let array: ArrayRef = Arc::new(Date32Array::from(vec![Some(-719163), Some(2932897)]));
+        let column = ctx
+            .converter_from_column(&array, &SnowflakeFieldType::Date)
+            .unwrap();
+
+        Python::attach(|py| {
+            for row in [0, 1] {
+                let err = column.to_py(py, row).unwrap_err();
+                assert!(
+                    err.is_instance_of::<PyValueError>(py),
+                    "expected PyValueError, got {err}"
+                );
+                let text = err.value(py).str().unwrap().to_string_lossy().into_owned();
+                assert!(
+                    text.contains("datetime.date year range 1..=9999"),
+                    "got {text}"
+                );
+            }
+        });
+    }
+}