arrowsql 0.1.0__tar.gz → 0.3.0__tar.gz

arrowsql-0.3.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.3.0/CHANGELOG.md

@@ -0,0 +1,184 @@
+# Changelog
+
+All notable changes to this project. Format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
+[SemVer](https://semver.org/) once 1.0 is reached (0.x may break).
+
+Version numbers in this project are deliberately three different things:
+
+| what | value | meaning |
+|---|---|---|
+| distribution `arrowsql` | 0.3.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.3.0] - 2026-11-07
+
+### Added
+
+- `crates/arrowsql-core`: the driver core as a Rust crate without pyo3
+  (connect, execute, fetch, Arrow decoding, pooling), with a public API for
+  other Rust crates: `Connection::connect` / `execute`, `Statement::next_batch`
+  / `into_reader`, and `read_arrow_stream(options, query, Partitioning,
+  ReadOptions)`, a cancellable, `Send` Arrow `RecordBatchReader` over a
+  partitioned parallel read. The Python extension is a pyo3 layer over it; no
+  behaviour change for Python.
+- `arrowsql-core`: the partitions of a read as separate readers or Arrow C
+  streams. `plan_partitions` returns the planned `Slice`s, each opens on its
+  own connection (`Slice::open`, `Slice::open_ffi_stream`), so Spark tasks or
+  pyarrow in another shared library read them zero-copy;
+  `ParallelReader::into_ffi_stream` / `StatementReader::into_ffi_stream`
+  export the merged and single-statement readers the same way.
+- `crates/arrowsql-rowcount`: a pure-Rust example and integration test of the
+  core API (single, merged parallel and per-partition Arrow C stream reads).
+- Process-wide DNS cache for connects (`DnsCacheTTL=<seconds>` keyword, env
+  `ARROWSQL_DNS_CACHE_TTL`, default 300 s, 0 disables). A host that resolved
+  once is not resolved again for every connection (Spark tasks, parallel read
+  slices, pool members, reconnects), like the JDBC driver's long-lived cache.
+  An expired entry is served at once while one background thread refreshes it
+  (up to an hour past its TTL), so a slow or failing resolver ("Temporary
+  failure in name resolution") no longer costs each connection seconds or a
+  failed connect. Concurrent lookups of one host share a single resolver call;
+  each resolver call is bounded (`ARROWSQL_DNS_RESOLVE_TIMEOUT`, default 10 s)
+  and a temporary failure is retried once. Failures are never cached; if no
+  cached address accepts, the entry is dropped and the host is resolved once
+  more. IP literals and connection diagnostics bypass the cache.
+  `ddbc_bindings.dns_cache_stats()` reports its counters. Vendored mssql-tds
+  patch 15.
+
+### Changed
+
+- `read_arrow` / `read_arrow_stream`: slice planning, the MIN/MAX and catalog
+  probes, the worker threads and the merge run in Rust (`arrowsql-core`);
+  `arrow_parallel.py` only checks arguments. Same plans, rows and exception
+  classes as before (parity tests against the previous implementation in
+  `tests/common_issues/test_rs_read_arrow_parity.py`); invalid
+  `partition_bounds` now fail before the first connection is opened. The
+  UTF-8 transfer rewrite (`utf8_strings`) moved to Rust as well.
+- Rust dependents of `arrowsql-core`: the core declares no global allocator
+  (mimalloc is the `ddbc_bindings` default feature `mimalloc`), and both
+  crates depend on `vendor/mssql-tds` by path instead of a `[patch]`, so a git
+  dependency on the core builds the patched TDS crate without a patch section
+  of its own. Workspace-wide `cargo test` / `clippy` take `--exclude mssql-tds`.
+
+### Fixed
+
+- `write_arrow(..., workers > 1)` accepts an iterable of record batches (list, generator, objects
+  with `__arrow_c_array__`) like `workers=1`, without pyarrow (r5 F9).
+- `write_arrow(..., workers > 1)` reads a native `cursor.arrow_stream()` on demand instead of
+  draining it into memory before the workers start; the drain remains for single-connection
+  `bulkcopy_arrow`, where it avoids a deadlock (r5 F15).
+- Async `executemany` with a leading NULL decimal no longer declares the whole
+  batch `decimal(18,10)` (later values lost digits).
+- Async manual-commit `BEGIN` obeys cancellation.
+- After a server-side rollback under XACT_ABORT, writes stay rejected (25000)
+  until `commit()`/`rollback()`: the guard sees through comments, CTEs and
+  `BEGIN TRY` blocks, is no longer consumed by the first rejection and also
+  covers the async API.
+
+## [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
+  `cursor.execute_arrow(sql, params=None, *, utf8_strings=True, batch_size=...)` describe the
+  result and cast nvarchar/nchar/ntext columns to a UTF-8 collated varchar on the server (query
+  wrapping is built in Rust: `ddbc_bindings.utf8_wrap_query`). About half the string bytes on
+  the wire; same Arrow result. Needs SQL Server 2019+/Azure SQL; falls back to the original
+  query on ORDER BY, parameters, duplicate/empty column names, describe failures, a small
+  string share of the row, or when the first 256 rows are not at least 10% smaller in UTF-8 (CJK
+  grows). `utf8_strings=False` opts out.
+- Bulk copy writes each DECIMAL cell at the shortest legal magnitude width (4/8/12/16 bytes)
+  instead of the width implied by the column precision. SQL Server accepts this; 1M rows of nine
+  `decimal(38,2)` columns with small values upload 55 MB instead of 163 MB. `ARROWSQL_DECIMAL_FIXED=1`
+  restores precision-width cells.
+- The project is called **arrowsql** (distribution and import name `arrowsql`,
+  repository github.com/bmsuisse/arrowsql). A `mssql_python` alias package keeps
+  `import mssql_python` working: its modules are the `arrowsql` modules.
+- PyO3 extension `arrowsql.ddbc_bindings` over Microsoft's `mssql-tds`
+  (vendored, with local patches, in `vendor/mssql-tds`): no ODBC driver, same
+  Python API as upstream mssql-python 1.16.0.
+- Native Arrow: `cursor.arrow()`, `arrow_batch()`, `arrow_reader()`,
+  `fetchall_arrow()`, `fetchmany_arrow()`, `arrow_stream()`, `read_arrow()`
+  (partitioned parallel reads).
+- Agent mode (`arrowsql.agent`, `python -m arrowsql.agent`, console script
+  `arrowsql-agent`), ported from arrowbricks: `query()` / `query_cursor()` return
+  a compact typed TSV (or Markdown) preview with a strict byte ceiling, row and
+  cell limits, an optional head/tail sample, a footer that never claims an
+  unknown total, `-- rows_affected` / `-- message` lines and every result set;
+  failures are JSON with a category, the server's own message and a recovery
+  hint (SQL Server error number, then SQLSTATE). Rendering is Rust
+  (`ddbc_bindings.AgentRender`) over the Arrow sink; `sql_variant` is now
+  readable through it.
+- `read_arrow_stream()`: partitioned parallel read as a bounded, unordered Arrow
+  stream (`__arrow_c_stream__`; native `ArrowMergeStream` fed by one connection
+  per worker) so DuckDB / deltalake overlap with the read and memory stays
+  bounded. `close()` or an early-stopping consumer cancels the statements and
+  closes the worker connections; the first worker error reaches the consumer.
+  `read_arrow()` is now built on it. `partition_bounds=` (and
+  `partition_nullable=`) take typed boundaries (int, date/datetime, Decimal,
+  str) as disjoint half-open slices plus a NULL slice, bound as parameters,
+  with no MIN/MAX or size probe.
+- Native bulk copy (rows and Arrow), `write_arrow()` parallel loads.
+- Native asyncio (`arrowsql.aio`) with a built-in pool (Unix only).
+- `sqlstate` and `native_error` on every exception
+  ([upstream #581](https://github.com/microsoft/mssql-python/issues/581));
+  bulk copy on the cursor's own connection, so `#temp` tables work
+  ([#492](https://github.com/microsoft/mssql-python/issues/492)).
+- Type stubs for the port-specific API (`ddbc_bindings.pyi`, RUST-PORT section of
+  `mssql_python.pyi`).
+- CI (`.github/workflows/ci.yml`) and a wheel/sdist build workflow
+  (`wheels.yml`, artifacts only, no publishing).
+- Project metadata: SPDX license, classifiers, URLs; CONTRIBUTING.
+
+### Changed
+
+- `-z pack-relative-relocs` moved out of `.cargo/config.toml` into the local
+  release scripts, so CI manylinux_2_28 wheels do not require glibc 2.36.
+- The `async-preview` extra pins `mssql-python-rs==0.4.0` (was 0.3.0).
+- The sdist now carries `vendor/mssql-tds`.
+
+### Known gaps
+
+- 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 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.3.0}/CONTRIBUTING.md

@@ -20,7 +20,8 @@ anyone else can just set `DB_CONNECTION_STRING`.
 ```bash
 python -m pytest -q --timeout 120 tests/common_issues tests/port
 python scripts/check_upstream_baseline.py     # vendored upstream suite vs tests/upstream_passing_baseline.txt
-cargo test --lib
+cargo test --workspace --exclude mssql-tds --lib
+cargo test -p arrowsql-core --test live && cargo test -p arrowsql-rowcount   # Rust API, needs DB_CONNECTION_STRING
 ```
 
 Scope and rules for the three suites: [docs/TEST_SCOPE.md](docs/TEST_SCOPE.md). A new
@@ -29,7 +30,7 @@ add it to `tests/upstream_excluded.txt` with a one-line reason.
 
 ## Code
 
-- `cargo clippy --all-targets` should not add warnings; run `cargo fmt` on files you touch.
+- `cargo clippy --workspace --exclude mssql-tds --all-targets` should not add warnings; run `cargo fmt` on files you touch.
 - Edits to the vendored Python layer (`python/arrowsql`) and to `vendor/mssql-tds`
   are marked `RUST-PORT` and listed in `docs/PYTHON_LAYER_CHANGES.md` /
   `vendor/mssql-tds/VENDOR.md`. Keep upstream's lines unchanged where you can.

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

@@ -78,6 +78,30 @@ dependencies = [
  "bitflags",
 ]
 
+[[package]]
+name = "arrowsql-core"
+version = "0.3.0"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-schema",
+ "async-trait",
+ "encoding_rs",
+ "log",
+ "mssql-tds",
+ "parking_lot",
+ "tokio",
+ "uuid",
+]
+
+[[package]]
+name = "arrowsql-rowcount"
+version = "0.3.0"
+dependencies = [
+ "arrow-array",
+ "arrowsql-core",
+]
+
 [[package]]
 name = "asn1-rs"
 version = "0.7.2"
@@ -274,17 +298,20 @@ checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
 
 [[package]]
 name = "ddbc_bindings"
-version = "0.1.0"
+version = "0.3.0"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
  "arrow-schema",
+ "arrowsql-core",
  "async-trait",
  "encoding_rs",
+ "log",
  "mimalloc",
  "mssql-tds",
  "parking_lot",
  "pyo3",
+ "pyo3-build-config",
  "tokio",
  "uuid",
 ]

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

@@ -1,29 +1,45 @@
 [package]
 name = "ddbc_bindings"
-version = "0.1.0"
+version = "0.3.0"
 edition = "2024"
 license = "MIT"
 description = "Rust (PyO3 + mssql-tds) replacement for mssql-python's ODBC-based ddbc_bindings"
 publish = false
 readme = "README.md"
 
+[workspace]
+members = ["crates/*"]
+# vendor/mssql-tds is a member too (a path dependency under the root), but its
+# tests need dev-dependencies the vendored copy leaves out: workspace-wide
+# cargo test / clippy runs pass `--exclude mssql-tds`.
+resolver = "3"
+
 [lib]
 name = "ddbc_bindings"
 crate-type = ["cdylib", "rlib"]
 
 [features]
+default = ["mimalloc"]
+# mimalloc as the process allocator of the extension module (the core
+# declares none, so a Rust dependent keeps its own).
+mimalloc = ["dep:mimalloc"]
 # Legacy TLS: native-tls (OpenSSL) + OpenSSL Always Encrypted crypto instead of rustls.
 # Adds ~8 MB (libssl, libcrypto, libzstd) to the wheel. Build: maturin build --features native-tls
-native-tls = ["mssql-tds/native-tls-backend"]
+native-tls = ["mssql-tds/native-tls-backend", "arrowsql-core/native-tls"]
 
 [dependencies]
 pyo3 = { version = "0.29.0", features = ["extension-module"] }
-# Microsoft's native TDS implementation (MIT). Pinned: the API is pre-1.0.
-mssql-tds = { git = "https://github.com/microsoft/mssql-rs", rev = "6b6b48ecbbbdad297039d1641e2be4775eed998b", default-features = false, features = ["gssapi", "rustls-tls"] }
+# Connect/execute/fetch, Arrow decoding and the parallel read, without pyo3.
+arrowsql-core = { path = "crates/arrowsql-core" }
+log = "0.4"
+# Microsoft's native TDS implementation (MIT), vendored with local patches
+# (vendor/mssql-tds/VENDOR.md). A path dependency, so crates that depend on
+# arrowsql-core by git get the patched copy without a [patch] of their own.
+mssql-tds = { path = "vendor/mssql-tds", default-features = false, features = ["gssapi", "rustls-tls"] }
 tokio = { version = "1", features = ["rt", "rt-multi-thread", "net", "time", "sync", "macros"] }
 parking_lot = "0.12"
 uuid = "1"
-mimalloc = { version = "0.1", default-features = false }
+mimalloc = { version = "0.1", default-features = false, optional = true }
 # Arrow arrays + the C Data / C Stream interfaces (src/arrow/). Columns are
 # built with our own buffers and only wrapped as arrow-rs arrays for export.
 arrow-array = { version = "60", default-features = false, features = ["ffi"] }
@@ -37,13 +53,16 @@ async-trait = "0.1"
 # Windows: in-tree Schannel TLS (msodbcsql's stack) instead of rustls, which fails the
 # handshake with SQL Server's self-generated certificate on Windows.
 [target.'cfg(windows)'.dependencies]
-mssql-tds = { git = "https://github.com/microsoft/mssql-rs", rev = "6b6b48ecbbbdad297039d1641e2be4775eed998b", default-features = false, features = ["gssapi", "rustls-tls", "tls-schannel-direct-on-windows"] }
+mssql-tds = { path = "vendor/mssql-tds", default-features = false, features = ["gssapi", "rustls-tls", "tls-schannel-direct-on-windows"] }
 
 # musl cannot load a shared library that uses initial-exec TLS through dlopen
 # ("initial-exec TLS resolves to dynamic definition"): mimalloc's thread-local
 # heap pointer has to use the local-dynamic model there.
 [target.'cfg(target_env = "musl")'.dependencies]
-mimalloc = { version = "0.1", default-features = false, features = ["local_dynamic_tls"] }
+mimalloc = { version = "0.1", default-features = false, features = ["local_dynamic_tls"], optional = true }
+
+[build-dependencies]
+pyo3-build-config = "0.29.0"
 
 [profile.dev]
 opt-level = 1
@@ -62,11 +81,6 @@ panic = "unwind"
 # Stripped symbols: smaller .so, no effect on speed (no runtime symbolication needed).
 strip = true
 
-# Microsoft's mssql-tds at the pinned rev, with one local patch (see
-# vendor/mssql-tds/VENDOR.md). Remove when the fix is upstream.
-[patch."https://github.com/microsoft/mssql-rs"]
-mssql-tds = { path = "vendor/mssql-tds" }
-
 # Hot crates at opt-level 3: the bindings with the inlined mssql-tds, pyo3 and
 # tokio, plus allocator, text decoding, buffers and record-layer crypto.
 [profile.release.package.mimalloc]
@@ -91,6 +105,8 @@ opt-level = 3
 opt-level = 3
 [profile.release.package.ddbc_bindings]
 opt-level = 3
+[profile.release.package.arrowsql-core]
+opt-level = 3
 [profile.release.package.mssql-tds]
 opt-level = 3
 [profile.release.package.pyo3]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrowsql
-Version: 0.1.0
+Version: 0.3.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: POSIX :: Linux
@@ -61,6 +61,8 @@ Project-URL: Upstream, https://github.com/microsoft/mssql-python
 - **2-7x faster than mssql-python**, up to 10x faster than pyodbc on large reads.
 - **Arrow out of the box:** results go straight to DuckDB, polars, pyarrow and Delta, no pyarrow required.
 - **Parallel reads and bulk loads** over several connections.
+- **Rust core crate:** `crates/arrowsql-core` (no pyo3) exposes connect, execute and the parallel Arrow read to other Rust programs.
+- **DNS cache:** resolved hosts are reused and served stale while refreshing (`DnsCacheTTL=<seconds>`, default 300, `0` disables).
 - **No ODBC driver:** native TDS in Rust, zero required dependencies, wheels for Linux, macOS and Windows.
 - **Drop-in:** same DB-API, same connection strings; `import mssql_python` keeps working.
 

{arrowsql-0.1.0 → arrowsql-0.3.0}/README.md

@@ -20,6 +20,8 @@
 - **2-7x faster than mssql-python**, up to 10x faster than pyodbc on large reads.
 - **Arrow out of the box:** results go straight to DuckDB, polars, pyarrow and Delta, no pyarrow required.
 - **Parallel reads and bulk loads** over several connections.
+- **Rust core crate:** `crates/arrowsql-core` (no pyo3) exposes connect, execute and the parallel Arrow read to other Rust programs.
+- **DNS cache:** resolved hosts are reused and served stale while refreshing (`DnsCacheTTL=<seconds>`, default 300, `0` disables).
 - **No ODBC driver:** native TDS in Rust, zero required dependencies, wheels for Linux, macOS and Windows.
 - **Drop-in:** same DB-API, same connection strings; `import mssql_python` keeps working.
 

arrowsql-0.3.0/build.rs

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

arrowsql-0.3.0/crates/arrowsql-core/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "arrowsql-core"
+version = "0.3.0"
+edition = "2024"
+license = "MIT"
+description = "SQL Server over TDS into Arrow record batches: the Python-free core of arrowsql"
+publish = false
+
+[features]
+# Legacy TLS: native-tls (OpenSSL) + OpenSSL Always Encrypted crypto instead of rustls.
+native-tls = ["mssql-tds/native-tls-backend"]
+
+[dependencies]
+# Microsoft's native TDS implementation (MIT), vendored with local patches
+# (vendor/mssql-tds/VENDOR.md): a path dependency, so a git dependent of this
+# crate builds the patched copy without a [patch] section.
+mssql-tds = { path = "../../vendor/mssql-tds", default-features = false, features = ["gssapi", "rustls-tls"] }
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "net", "time", "sync", "macros"] }
+parking_lot = "0.12"
+uuid = "1"
+arrow-array = { version = "60", default-features = false, features = ["ffi"] }
+arrow-buffer = "60"
+arrow-schema = { version = "60", features = ["ffi"] }
+encoding_rs = "0.8"
+async-trait = "0.1"
+log = "0.4"
+
+# Windows: in-tree Schannel TLS (msodbcsql's stack) instead of rustls, which fails the
+# handshake with SQL Server's self-generated certificate on Windows.
+[target.'cfg(windows)'.dependencies]
+mssql-tds = { path = "../../vendor/mssql-tds", default-features = false, features = ["gssapi", "rustls-tls", "tls-schannel-direct-on-windows"] }