arrowsql 0.1.0__tar.gz → 0.2.0__tar.gz

arrowsql-0.2.0/AGENTS.md

@@ -0,0 +1,27 @@
+# Rules for agents working in this repository
+
+1. **Version trio.** Three different numbers: `pyproject.toml` `version` and `Cargo.toml`
+   `version` are the distribution release and must be bumped together (plus a CHANGELOG
+   entry). `arrowsql.__version__` (`python/arrowsql/__init__.py`) deliberately reports the
+   upstream `mssql-python` release the Python layer is vendored from (currently 1.16.0);
+   do not bump it for a release of this project. `ddbc_bindings.__version__` is the Rust
+   binding contract version (`docs/CONTRACT.md`).
+2. **Vendor patches.** Every change to vendored Python (upstream-derived files) is marked
+   `RUST-PORT` in the code and listed in `docs/PYTHON_LAYER_CHANGES.md`. Every change to
+   `vendor/mssql-tds` gets an entry in `vendor/mssql-tds/VENDOR.md`.
+3. **Upstream baseline gate.** `tests/upstream_passing_baseline.txt` lists upstream tests
+   that must keep passing. Run `scripts/check_upstream_baseline.py` (or the baseline
+   snippet from the PR template) before pushing; 0 baseline tests may be missing and
+   teardown ERRORs count as failures. Never edit the baseline or `upstream_excluded.txt`
+   to hide a regression.
+4. **Stay in Rust.** Put new behaviour in the Rust core (`src/`) and keep the Python layer
+   thin. Python is for the DB-API surface, argument validation and glue.
+5. **Tests.** Each fix gets a regression test in `tests/common_issues` (or `tests/port`,
+   `tests/mock`). Run tests with `python scripts/run_tests.py <id> <paths>`, which uses a
+   private database per id. Full suites run in CI.
+6. **Secrets.** Never print, cat or commit `.env.local` or the SA password; connection
+   strings in logs and error messages must not contain values. Check
+   `git log -p origin/main..HEAD` for the password before every push.
+7. **Git.** Never push to `main`; work on a branch and open a PR. Do not restart
+   containers or touch other sessions' processes. Use `nice -n 19` for builds and tests
+   while benchmarks run.

{arrowsql-0.1.0 → arrowsql-0.2.0}/CHANGELOG.md

@@ -8,12 +8,46 @@ Version numbers in this project are deliberately three different things:
 
 | what | value | meaning |
 |---|---|---|
-| distribution `arrowsql` | 0.1.0 | this project's release number (`pyproject.toml`) |
+| distribution `arrowsql` | 0.2.0 | this project's release number (`pyproject.toml`) |
 | `arrowsql.__version__` | 1.16.0 | the upstream `mssql-python` release the Python layer is vendored from; kept so code that checks the upstream version keeps working |
 | `arrowsql.ddbc_bindings.__version__` | 1.0.0 | version of the Rust binding contract (`docs/CONTRACT.md`) |
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-11-01
+
+### Added
+
+- `write_arrow()` no longer needs pyarrow: any Arrow PyCapsule source (`__arrow_c_stream__` /
+  `__arrow_c_array__`: polars, DuckDB, nanoarrow, pyarrow) is loaded by the parallel bulk copy
+  in Rust (`DDBCBulkCopyArrowParallel`).
+- DB-API exceptions are raised from Rust: the SQLSTATE-to-class table, the 1222 / 2628 / 8114
+  promotions and the `driver_error` / `ddbc_error` / `sqlstate` / `native_error` attributes are
+  built natively (`DDBCRaiseFor`). The native `Connection` and `getinfo` raise typed exceptions.
+- `Row` is backed by a Rust core (`RowCore`): indexing, attribute access, copy and pickle run
+  natively.
+
+### Changed
+
+- Faster LOB row fetch: large pure-ASCII values are narrowed when they are pushed, and the row
+  arena is sized once (fetchmany over LOB columns about 2.5x faster).
+
+### Fixed
+
+- Arrow reads decoded OEM 437/850 `varchar` lossily; every fetch path now decodes it the same.
+- A forked child closing an inherited connection no longer shuts down the parent's session.
+- `round_to_scale` / money rounding: exponent text is rounded, ties round half away from zero on
+  every path, independent of the ambient decimal context.
+- Row bulk copy without column mappings rejects extra source columns instead of dropping them;
+  ragged `executemany` rows raise a DB-API error instead of a panic.
+- Closing a partly read result no longer blocks on a locked row.
+- asyncio: `fetch_arrow` raises the drained error, cancellation and pool races, drain budget and
+  stale cursor state after errors.
+- Request timeout accounting and cancel-handle publish order in the vendored `mssql-tds`.
+- Security and CI hardening: release publishing only from `main`, actions pinned to SHAs.
+
+## [0.1.0] - 2026-11-01
+
 ### Added
 
 - UTF-8 transfer for Arrow reads: `read_arrow(..., utf8_strings=True)` and the new
@@ -79,5 +113,8 @@ Version numbers in this project are deliberately three different things:
 - Pool checkout does not probe an idle connection with a timeout (upstream
   GH #854), and `set_attr(SQL_ATTR_CONNECTION_TIMEOUT)` is not carried across
   pool reuse. See `tests/upstream_excluded.txt`.
-- Always Encrypted, `ActiveDirectoryPassword` and NTLM are not supported.
-- Only Linux x86_64 has been exercised against a database.
+- Always Encrypted and NTLM are not supported.
+- Linux x86_64 is the platform exercised daily against a database. CI also builds and runs
+  the DB-free tests on macOS, Windows (x64, arm64) and Linux arm64, and runs the DB suite
+  against SQL Server Express on `windows-latest` (the `windows-db` job; Windows is not a
+  required gate).

{arrowsql-0.1.0 → arrowsql-0.2.0}/Cargo.lock

@@ -274,7 +274,7 @@ checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
 
 [[package]]
 name = "ddbc_bindings"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -285,6 +285,7 @@ dependencies = [
  "mssql-tds",
  "parking_lot",
  "pyo3",
+ "pyo3-build-config",
  "tokio",
  "uuid",
 ]

{arrowsql-0.1.0 → arrowsql-0.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ddbc_bindings"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 license = "MIT"
 description = "Rust (PyO3 + mssql-tds) replacement for mssql-python's ODBC-based ddbc_bindings"
@@ -45,6 +45,9 @@ mssql-tds = { git = "https://github.com/microsoft/mssql-rs", rev = "6b6b48ecbbbd
 [target.'cfg(target_env = "musl")'.dependencies]
 mimalloc = { version = "0.1", default-features = false, features = ["local_dynamic_tls"] }
 
+[build-dependencies]
+pyo3-build-config = "0.29.0"
+
 [profile.dev]
 opt-level = 1
 

{arrowsql-0.1.0 → arrowsql-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrowsql
-Version: 0.1.0
+Version: 0.2.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: POSIX :: Linux

arrowsql-0.2.0/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    pyo3_build_config::use_pyo3_cfgs();
+}

{arrowsql-0.1.0 → arrowsql-0.2.0}/docs/AGENT_MODE.md

@@ -50,3 +50,17 @@ text = query(conn_or_connection_string, "SELECT TOP 100 * FROM dbo.orders WHERE
   a partial result with a success footer. Bad arguments exit 2, Ctrl-C exits 130.
 - `query_cursor(cursor, sql)` runs on an existing cursor; `render_cursor(cursor)`
   renders one that has just executed. String connections use autocommit.
+
+## Credentials and least privilege
+
+- The CLI accepts a full connection string with `--connection-string` / `--conn`.
+  Anything on the command line is visible to other local users (`ps`, `/proc`) and ends up
+  in shell history and agent transcripts, so do **not** put the password there. Pass it
+  through the environment instead: `MSSQL_CONNECTION_STRING` or `DB_CONNECTION_STRING`
+  (read when `--connection-string` is absent), set from a secret store or an untracked
+  `.env` file the agent never prints.
+- Give the agent its own SQL login or Entra principal with the least privilege that the
+  task needs, ideally read-only (`db_datareader`, `VIEW DEFINITION`) on one database. The
+  tool runs the SQL it is given unchanged and does not make an unsafe statement safe.
+- Prefer `Authentication=ActiveDirectoryServicePrincipal`-style or token credentials with
+  short lifetimes over long-lived `sa` passwords; never use `sa`.

{arrowsql-0.1.0 → arrowsql-0.2.0}/docs/PACKAGING.md

@@ -9,7 +9,7 @@ brings only the compiled `ddbc_bindings` extension and the vendored
 | (none) | nothing | `connect()`, the DB-API cursor/row path, `aio`, `read_arrow` on the native Arrow stream |
 | `arrow` | `pyarrow>=14` | `cursor.arrow()`, `arrow_batch()`, `arrow_reader()` (upstream API surface) |
 | `azure` | `azure-identity` | `auth=` / `token_provider=` with azure-identity credentials |
-| `async-preview` | `mssql-python-rs==0.4.0` (Microsoft `mssql_py_core`, ~30 MB) | `bulkcopy()`, `bulkcopy_arrow()`, upstream `async_query` preview |
+| `async-preview` | `mssql-python-rs==0.4.0` (Microsoft `mssql_py_core`, ~30 MB) | upstream `async_query` preview; fallback for `bulkcopy()` / `bulkcopy_arrow()` only on cursors without a native handle (bulk copy itself runs in the Rust core) |
 
 ## Wheels, sdist and versions
 
@@ -66,9 +66,10 @@ stack. Every optional import is lazy:
   Arrow fetch/insert methods (`TYPE_CHECKING` guard at module top).
 * `auth.py`, `db_connection.py`: `azure.identity` / `azure.core` are imported
   inside the functions that build those credentials.
-* `cursor.py` bulkcopy: `mssql_py_core` is imported in
-  `_bulkcopy_import_core()`. A missing package raises an `ImportError`
-  that names the `async-preview` extra.
+* `cursor.py` bulkcopy: bulk copy runs natively (`DDBCBulkCopyRows` /
+  `DDBCBulkCopyArrow`); `mssql_py_core` is imported in
+  `_bulkcopy_import_core()` only for cursors without a native handle. A
+  missing package raises an `ImportError` that names the `async-preview` extra.
 * `odbc_provider.py`: the provider package (`mssql_python_odbc` / `mssql_py_core`)
   is imported only when the upstream ODBC provider is selected. The Rust
   port path (`ddbc_bindings.__rust_port__`) skips that import.

{arrowsql-0.1.0 → arrowsql-0.2.0}/docs/ROADMAP.md

@@ -9,11 +9,11 @@ compatibility.
 | | upstream mssql-python 1.16 | this project today | target |
 |---|---:|---:|---:|
 | driver | 9.4 MB (`mssql_python`) | 4.7 MB extension + 0.6 MB Python | ~2-3 MB |
-| `mssql_py_core` (Rust TDS, via `mssql-python-rs`) | 30 MB | 30 MB (bulkcopy, async preview) | 0 (optional extra) |
+| `mssql_py_core` (Rust TDS, via `mssql-python-rs`) | 30 MB | 0 core, 30 MB with the `async-preview` extra (async preview; bulkcopy fallback only) | 0 (optional extra) |
 | `mssql_python_odbc` (ODBC driver) | 7 MB | 0 | 0 |
 | required runtime deps | 2 | 1 | **0** |
 
-Plan: own bulk copy in the Rust core (drops `mssql_py_core` for bulkcopy), the
+Done: bulk copy runs in the Rust core (`mssql_py_core` is no longer needed for bulkcopy). Plan: the
 upstream async preview moves behind an extra, `pyarrow` and `azure-identity`
 stay optional, one abi3 wheel per platform if the measured cost is nil,
 stripped release builds.

{arrowsql-0.1.0 → arrowsql-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "arrowsql"
-version = "0.1.0"
+version = "0.2.0"
 description = "mssql-python with its ODBC/C++ core replaced by Rust (PyO3 + mssql-tds)"
 requires-python = ">=3.10"
 readme = "README.md"
@@ -36,7 +36,8 @@ classifiers = [
 dependencies = []
 
 [project.optional-dependencies]
-# Upstream async_query preview and bulkcopy() (still served by Microsoft's mssql_py_core).
+# Upstream async_query preview. bulkcopy()/bulkcopy_arrow() run natively; mssql_py_core is
+# only a fallback for cursors without a native handle (the upstream ODBC provider path).
 async-preview = ["mssql-python-rs==0.4.0"]
 # Arrow fetch (arrow(), arrow_batch(), read_arrow()) and Arrow bulk insert.
 arrow = ["pyarrow>=14"]

{arrowsql-0.1.0 → arrowsql-0.2.0}/python/arrowsql/_rust_auth.py

@@ -13,6 +13,7 @@ through to a SQL login with the client id or UPN. This module keeps auth.py
 
 from __future__ import annotations
 
+import hashlib
 import sys
 from typing import Callable, Dict, Optional
 
@@ -81,25 +82,39 @@ def make_password_token_factory(username: str, password: str) -> Callable[[str,
     if not username or not password:
         raise ValueError("ActiveDirectoryPassword auth requires UID (user principal name) and PWD")
 
+    secret_hash = hashlib.sha256(password.encode("utf-8")).hexdigest()
+
     def _factory(spn: str, sts_url: str, _auth_method: str) -> bytes:
         # pylint: disable=import-outside-toplevel
         from azure.identity import UsernamePasswordCredential
         from azure.core.exceptions import ClientAuthenticationError
-        from arrowsql.auth import _parse_tenant_id
+        from azure.core.pipeline.transport import RequestsTransport
+        from arrowsql import auth as _auth
 
         if not spn:
             raise RuntimeError("ActiveDirectoryPassword: empty SPN from server")
-        tenant_id = _parse_tenant_id(sts_url)
+        tenant_id = _auth._parse_tenant_id(sts_url)
         if not tenant_id:
             raise RuntimeError(f"Could not extract tenant_id from STS URL: {sts_url!r}")
-        scope = spn if spn.endswith("/.default") else spn.rstrip("/") + "/.default"
+        scope = _auth._scope_from_server_spn(spn)
         try:
-            credential = UsernamePasswordCredential(
-                client_id=_PASSWORD_CLIENT_ID,
-                username=username,
-                password=password,
-                tenant_id=tenant_id,
+            cache_key = _auth._credential_cache_key(
+                _AD_PASSWORD,
+                {"tenant_id": tenant_id, "username": username, "secret_hash": secret_hash},
             )
+            with _auth._credential_cache_lock:
+                credential = _auth._credential_cache.get(cache_key)
+                if credential is None:
+                    # The factory runs on a blocking-pool worker of the core;
+                    # bound the Entra round-trip like the service-principal path.
+                    credential = UsernamePasswordCredential(
+                        client_id=_PASSWORD_CLIENT_ID,
+                        username=username,
+                        password=password,
+                        tenant_id=tenant_id,
+                        transport=RequestsTransport(connection_timeout=10, read_timeout=15),
+                    )
+                    _auth._credential_cache[cache_key] = credential
             token = credential.get_token(scope).token
         except ClientAuthenticationError:
             # The provider text can echo the account; keep it out of the exception chain.

{arrowsql-0.1.0 → arrowsql-0.2.0}/python/arrowsql/aio.py

@@ -122,6 +122,16 @@ class AsyncCursor:
     def connection(self) -> "AsyncConnection":
         return self._conn
 
+    def _retire(self) -> None:
+        """Forget the current result: no row, description or count survives it."""
+        self._batch = None
+        self._rows = []
+        self._pos = 0
+        self._done = True
+        self.description = None
+        self.rowcount = -1
+        self.messages = []
+
     def _install(self, result) -> None:
         shape, batch, done, rowcount, messages = result
         self._batch = batch
@@ -135,9 +145,12 @@ class AsyncCursor:
     def _check(self) -> None:
         if self._closed:
             raise _interface_error("Cursor is closed")
+        if self._conn._closed:
+            raise _interface_error("Connection is closed")
 
     async def execute(self, operation: str, *parameters: Any) -> "AsyncCursor":
         self._check()
+        self._retire()  # a failed or cancelled execute leaves no stale rows behind
         params = _params(parameters) if parameters else None
         result = await _wait(self._c, self._c.execute(_hub(), self._id, operation, params))
         self._install(result)
@@ -145,10 +158,8 @@ class AsyncCursor:
 
     async def executemany(self, operation: str, seq_of_parameters: Sequence[Sequence[Any]]) -> None:
         self._check()
+        self._retire()
         rows = await _wait(self._c, self._c.executemany(_hub(), self._id, operation, seq_of_parameters))
-        self._batch = None
-        self._done = True
-        self.description = None
         self.rowcount = rows
 
     async def _more(self, n: int) -> list:
@@ -172,6 +183,7 @@ class AsyncCursor:
         return out
 
     async def fetchone(self) -> Optional[Any]:
+        self._check()
         batch = self._batch
         if batch is not None:
             row = batch.next()
@@ -189,6 +201,7 @@ class AsyncCursor:
         return await self.fetchone()
 
     async def fetchmany(self, size: Optional[int] = None) -> list:
+        self._check()
         size = self.arraysize if size is None else size
         out = self._local(size)
         while len(out) < size and not self._done:
@@ -200,6 +213,7 @@ class AsyncCursor:
         return out
 
     async def fetchall(self) -> list:
+        self._check()
         out = self._local(2**62)
         while not self._done:  # a result that fails after some rows ends with the error
             more = await self._more(2**62)
@@ -227,9 +241,7 @@ class AsyncCursor:
         self._check()
         result = await _wait(self._c, self._c.nextset(_hub(), self._id))
         if result is None:
-            self._batch = None
-            self._done = True
-            self.description = None
+            self._retire()
             return None
         self._install(result)
         return True
@@ -237,7 +249,7 @@ class AsyncCursor:
     async def close(self) -> None:
         if not self._closed:
             self._closed = True
-            self._batch = None
+            self._retire()
             self._c.close_cursor(self._id)
 
     def __del__(self):
@@ -253,6 +265,7 @@ class AsyncCursor:
         return self
 
     async def __anext__(self):
+        self._check()
         batch = self._batch
         if batch is not None:
             row = batch.next()

{arrowsql-0.1.0 → arrowsql-0.2.0}/python/arrowsql/arrow_parallel.py

@@ -27,6 +27,7 @@ import weakref
 from typing import Any, List, Optional, Sequence, Tuple
 
 from arrowsql import ddbc_bindings
+from arrowsql.logging import logger
 from arrowsql.db_connection import connect
 from arrowsql._utf8_strings import utf8_query
 from arrowsql.exceptions import raise_exception
@@ -136,7 +137,10 @@ def read_arrow_stream(
     ``>= bk`` (plus an ``IS NULL`` slice when the column is nullable), each
     bound as a typed parameter. No MIN/MAX or size probe is run, so the first
     batch comes sooner, and skew can be handled by passing quantiles. Bounds
-    must ascend in the column's own ordering (for strings: its collation); a
+    must ascend in the column's own ordering (for strings: its collation). Only
+    Python code-point order is checked here, not the server collation: a list
+    that ascends in Python but not in the collation yields overlapping or empty
+    slices (duplicate or missing rows), so order string bounds by the collation; a
     ``str`` bound is sent as nvarchar, so a ``varchar`` column is compared
     after an implicit conversion (no index seek). ``partition_nullable`` says
     whether the column may hold NULL (default: asked from the server, one
@@ -405,13 +409,16 @@ def _probe_meta(cursor, query, column, plain=None, with_rows: bool = True) -> Tu
             cursor.execute(f"SELECT {_ROWS_SQL}, {_NULLABLE_SQL}", (match.group(1),) + describe)
             rows, nullable = cursor.fetchone()
             return (None if rows is None else int(rows)), nullable is None or bool(nullable)
-        except Exception:
-            pass
+        except Exception as exc:  # pylint: disable=broad-exception-caught
+            logger.debug("parallel read: catalog probe failed, falling back: %s", type(exc).__name__)
     try:
         cursor.execute(f"SELECT {_NULLABLE_SQL}", describe)
         row = cursor.fetchone()
         return None, row is None or row[0] is None or bool(row[0])
-    except Exception:
+    except Exception as exc:  # pylint: disable=broad-exception-caught
+        logger.debug(
+            "parallel read: nullability probe failed, assuming nullable: %s", type(exc).__name__
+        )
         return None, True
 
 

{arrowsql-0.1.0 → arrowsql-0.2.0}/python/arrowsql/auth.py

@@ -81,6 +81,42 @@ class TokenInfo(NamedTuple):
 # audience is rejected by SQL Server at login.
 _SQL_SCOPE = "https://database.windows.net/.default"
 
+# Resource hosts a SQL server may name in FEDAUTHINFO. The SPN comes from the
+# (possibly untrusted) server, so a token is only requested for these audiences;
+# anything else fails closed instead of minting a token for an arbitrary resource.
+_ALLOWED_SQL_RESOURCE_HOSTS = frozenset(
+    {
+        "database.windows.net",
+        "database.chinacloudapi.cn",
+        "database.usgovcloudapi.net",
+        "database.cloudapi.de",
+        "database.fabric.microsoft.com",
+    }
+)
+
+
+def _scope_from_server_spn(spn: str) -> str:
+    """Return the ``.default`` scope for a server-supplied resource SPN.
+
+    Raises ``RuntimeError`` unless the SPN is an https URL on an allow-listed
+    SQL resource host. Only the host is used; any path or query is dropped.
+    """
+    # pylint: disable=import-outside-toplevel
+    from urllib.parse import urlparse
+
+    try:
+        parsed = urlparse(spn or "")
+        host = (parsed.hostname or "").lower()
+    except ValueError:
+        host = ""
+    if parsed.scheme != "https" or host not in _ALLOWED_SQL_RESOURCE_HOSTS or parsed.port not in (None, 443):
+        raise RuntimeError(
+            "Refusing to request an Entra token: the server named a resource that is not a "
+            "known SQL resource host"
+        )
+    return f"https://{host}/.default"
+
+
 # One-time guard so the DefaultAzureCredential multi-user pooling caveat is
 # logged at most once per process rather than on every token acquisition.
 _dac_pooling_warned = False
@@ -443,6 +479,7 @@ class ServicePrincipalAuth:
             tenant_id = _parse_tenant_id(sts_url)
             if not tenant_id:
                 raise RuntimeError(f"Could not extract tenant_id from STS URL: {sts_url!r}")
+            scope = _scope_from_server_spn(spn)
 
             try:
                 # Reuse the shared credential cache (introduced for MSI in PR #573)
@@ -508,7 +545,6 @@ class ServicePrincipalAuth:
                         )
                         _credential_cache[cache_key] = credential
                 # mssql-tds passes the resource SPN; azure-identity wants a scope.
-                scope = spn if spn.endswith("/.default") else spn.rstrip("/") + "/.default"
                 token = credential.get_token(scope).token
                 logger.info(
                     "ServicePrincipal token factory: token acquired, length=%d chars",

{arrowsql-0.1.0 → arrowsql-0.2.0}/python/arrowsql/bulk_parallel.py

@@ -28,10 +28,11 @@ import queue
 import threading
 import time
 import warnings
-from contextlib import closing
+from contextlib import ExitStack, closing
 from concurrent.futures import ThreadPoolExecutor, wait
 from typing import Any, Optional
 
+from arrowsql import ddbc_bindings
 from arrowsql.db_connection import connect
 
 # Cap on rows per slice. Smaller slices spread work across workers; larger
@@ -94,8 +95,9 @@ def write_arrow(
     ``rows_per_second`` and ``workers`` (connections used).
 
     Raises the first error from any worker or from reading the source. The
-    other workers stop taking new slices. ``workers > 1`` needs pyarrow to cut
-    the source.
+    other workers stop taking new slices. No Arrow library is needed: the
+    source is imported once through the Arrow C stream and cut into slices in
+    Rust (a streaming source is read on demand, not materialized).
     """
     _check_args(workers, batch_size, timeout)
     bulk_options = {
@@ -117,15 +119,8 @@ def write_arrow(
         result = _load_single(connection_str, table, source, table_lock, bulk_options, connect_kwargs)
         return _summarize([result], 1, started)
 
-    slice_rows = _slice_rows(source, workers)
-    results = _load_parallel(
-        connection_str,
-        workers,
-        _slices(source, slice_rows),
-        lambda cursor, first, pieces: _load_arrow_pieces(
-            cursor, table, first, pieces, table_lock, bulk_options
-        ),
-        connect_kwargs,
+    results = _load_native_parallel(
+        connection_str, table, source, workers, table_lock, bulk_options, connect_kwargs
     )
     return _summarize(results, workers, started)
 
@@ -235,19 +230,46 @@ def _slice_size(count, workers):
     return max(1, min(_MAX_SLICE_ROWS, -(-count // (workers * _SLICES_PER_WORKER))))
 
 
-def _slice_rows(source, workers):
-    num_rows = getattr(source, "num_rows", None)
-    if isinstance(num_rows, int) and num_rows > 0:
-        return _slice_size(num_rows, workers)
-    return _MAX_SLICE_ROWS
-
-
 def _load_single(connection_str, table, source, table_lock, bulk_options, connect_kwargs):
     with connect(connection_str, autocommit=True, **connect_kwargs) as conn:
         with closing(conn.cursor()) as cursor:
             return cursor.bulkcopy_arrow(table, source, table_lock=table_lock, **bulk_options)
 
 
+def _load_native_parallel(connection_str, table, source, workers, table_lock, bulk_options, connect_kwargs):
+    """One Rust call: N connections pull slices of ``source`` from a shared cursor."""
+    from arrowsql.cursor import _raise_native_bulk_error
+
+    with ExitStack() as stack:
+        with ThreadPoolExecutor(max_workers=workers, thread_name_prefix="mssql-bulk-connect") as pool:
+            futures = [
+                pool.submit(connect, connection_str, autocommit=True, **connect_kwargs)
+                for _ in range(workers)
+            ]
+        connections = []
+        failure = None
+        for future in futures:
+            try:
+                connections.append(stack.enter_context(future.result()))
+            except BaseException as exc:
+                failure = failure or exc
+        if failure is not None:
+            raise failure
+        cursors = [stack.enter_context(closing(conn.cursor())) for conn in connections]
+        handles = [cursor._native_bulk_handle("DDBCBulkCopyArrowParallel") for cursor in cursors]
+        if any(handle is None for handle in handles):
+            raise RuntimeError("write_arrow with workers > 1 needs the native (Rust) driver")
+        for cursor in cursors:
+            cursor._check_closed()
+            cursor._bulkcopy_connection_params()
+        try:
+            return ddbc_bindings.DDBCBulkCopyArrowParallel(
+                handles, table, source, table_lock=table_lock, **bulk_options
+            )
+        except RuntimeError as err:
+            _raise_native_bulk_error(err)
+
+
 def _load_parallel(connection_str, workers, pieces, load, connect_kwargs):
     """Feed ``pieces`` to ``workers`` connections. ``load(cursor, first, pieces)``
     runs one bulk copy over the pieces a worker pulls and returns its result."""
@@ -300,15 +322,6 @@ def _load_worker(connection_str, pending, stop, load, connect_kwargs):
             return load(cursor, first, pieces())
 
 
-def _load_arrow_pieces(cursor, table, first, pieces, table_lock, bulk_options):
-    import pyarrow as pa
-
-    # A RecordBatchReader is an Arrow C stream, which the native bulk
-    # copy consumes directly; a bare generator would need mssql_py_core.
-    reader = pa.RecordBatchReader.from_batches(first.schema, pieces)
-    return cursor.bulkcopy_arrow(table, reader, table_lock=table_lock, **bulk_options)
-
-
 def _load_row_pieces(cursor, table, first, pieces, table_lock, bulk_options):
     rows = itertools.chain.from_iterable(pieces)
     return cursor.bulkcopy(table, rows, table_lock=table_lock, **bulk_options)
@@ -330,27 +343,6 @@ def _row_slices(rows, workers):
         yield chunk
 
 
-def _slices(source, slice_rows):
-    """Yield non-empty RecordBatch slices of at most ``slice_rows`` rows."""
-    for batch in _record_batches(source):
-        for offset in range(0, batch.num_rows, slice_rows):
-            yield batch.slice(offset, slice_rows)
-
-
-def _record_batches(source):
-    import pyarrow as pa
-
-    if isinstance(source, pa.Table):
-        return source.to_batches()
-    if isinstance(source, pa.RecordBatch):
-        return [source]
-    if isinstance(source, pa.RecordBatchReader) or hasattr(source, "__arrow_c_stream__"):
-        return pa.RecordBatchReader.from_stream(source)
-    if hasattr(source, "__arrow_c_array__"):
-        return [pa.record_batch(source)]
-    return source
-
-
 def _put(pending, item, stop):
     """Put ``item`` unless the load was stopped. Returns False if stopped."""
     while not stop.is_set():