fabric-dw 2026.6.0a1.dev182__tar.gz → 2026.6.0a1.dev184__tar.gz

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabric-dw
-Version: 2026.6.0a1.dev182
+Version: 2026.6.0a1.dev184
 Summary: Python CLI + MCP server for administering Microsoft Fabric Data Warehouses and SQL Analytics Endpoints
 Project-URL: Homepage, https://fdw.debruyn.dev
 Project-URL: Documentation, https://fdw.debruyn.dev
@@ -89,6 +89,8 @@ pip install fabric-dw
 uvx fabric-dw --help
 ```
 
+After installation, the `fdw` command is a short alias for `fabric-dw` — both invoke the same entry point.
+
 ## Quick Start
 
 ### CLI

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/README.md

@@ -34,6 +34,8 @@ pip install fabric-dw
 uvx fabric-dw --help
 ```
 
+After installation, the `fdw` command is a short alias for `fabric-dw` — both invoke the same entry point.
+
 ## Quick Start
 
 ### CLI

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/docs/install.md

@@ -39,6 +39,9 @@ fabric-dw --help
 
 You should see the top-level help output listing available commands.
 
+!!! tip "Short alias"
+    `fdw` is an equivalent short alias for `fabric-dw` — both commands invoke the same entry point.
+
 ---
 
 See also the [Authentication](authentication.md) page for the full credential chain and the [Troubleshooting](troubleshooting.md) page for common failure modes such as expired tokens and 403 permission errors.

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/pyproject.toml

@@ -75,6 +75,7 @@ Issues = "https://github.com/sdebruyn/fabric-dw-mcp-cli/issues"
 [project.scripts]
 fabric-dw = "fabric_dw.cli:main"
 fabric-dw-mcp = "fabric_dw.mcp.server:run"
+fdw = "fabric_dw.cli:main"
 
 [dependency-groups]
 dev = [

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/src/fabric_dw/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2026.6.0a1.dev182'
-__version_tuple__ = version_tuple = (2026, 6, 0, 'a1', 'dev182')
+__version__ = version = '2026.6.0a1.dev184'
+__version_tuple__ = version_tuple = (2026, 6, 0, 'a1', 'dev184')
 
 __commit_id__ = commit_id = None

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/src/fabric_dw/services/load.py

@@ -762,11 +762,16 @@ async def copy_into_from_url(
     _logger.debug("copy_into_from_url: schema=%s table=%s file_type=%s", schema, table, file_type)
 
     def _run() -> tuple[int, int]:
-        # COPY INTO returns a result set with (rows_loaded, rows_rejected, …)
+        # mssql-python ≥ 1.9.0: COPY INTO produces NO result set.
+        # cursor.description is None and fetchall() raises
+        # ProgrammingError: Invalid cursor state.
+        # cursor.rowcount correctly equals the number of rows loaded.
+        # rows_rejected is not exposed via the ODBC rowcount API; it is
+        # always reported as 0 here (known limitation).
 
         _mode = mode if isinstance(mode, CredentialMode) else CredentialMode.DEFAULT
         try:
-            cols, rows = run_query(target, sql, mode=_mode, commit=True)
+            _cols, rows = run_query(target, sql, mode=_mode, commit=True, fetch="rowcount")
         except FabricError:
             # Already a mapped high-level error — re-raise as-is; it does not
             # contain the raw SQL statement text.
@@ -788,20 +793,16 @@ async def copy_into_from_url(
                 f"{type(exc).__name__} (details suppressed to protect credentials)"
             )
             raise FabricError(safe_msg) from exc
-        if rows:
-            row = rows[0]
-            # The result set columns vary slightly by Fabric version.
-            # Columns: rows_loaded, rows_rejected [, rejected_file_location]
-            try:
-                col_map = {c.lower(): i for i, c in enumerate(cols)}
-                loaded = int(row[col_map.get("rows_loaded", 0)] or 0)
-                rejected_idx = col_map.get("rows_rejected")
-                rejected = int(row[rejected_idx] or 0) if rejected_idx is not None else 0
-            except (IndexError, TypeError, ValueError):
-                loaded = int(row[0] or 0) if row else 0
-                rejected = 0
-            return loaded, rejected
-        return 0, 0
+        # rows[0][0] is cursor.rowcount from run_query fetch="rowcount".
+        # ODBC rowcount is -1 when the driver cannot determine the count;
+        # treat any negative value as 0.
+        rows_loaded = (
+            int(rows[0][0])
+            if rows and rows[0] and rows[0][0] is not None and rows[0][0] >= 0
+            else 0
+        )
+        rows_rejected = 0
+        return rows_loaded, rows_rejected
 
     rows_loaded, rows_rejected = await asyncio.to_thread(_run)
     return CopyIntoResult(

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/src/fabric_dw/services/sql_endpoints.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+from typing import Any, cast
 from uuid import UUID
 
 from fabric_dw.exceptions import FabricServerError, NotFoundError, PermissionDeniedError
@@ -17,7 +18,13 @@ _logger = logging.getLogger("fabric_dw.sql_endpoints")
 
 # Bounded polling for eventual-consistency fields (e.g. connection_string).
 _CONN_STRING_POLL_INTERVAL: float = 5.0
-_CONN_STRING_POLL_TIMEOUT: float = 600.0  # 10 min — Fabric preview eventual-consistency window
+# For lakehouse-derived endpoints the connection string lives on the *Lakehouse*
+# body (sqlEndpointProperties.connectionString) and is available within ~20s of
+# provisioning.  The GET /sqlEndpoints/{id} resource always returns an empty
+# connectionString for these endpoints — it never populates.  The fallback reads
+# from the parent Lakehouse instead, so the window needed is just the
+# provisioning time (≈20s), not the original 10-minute guess.
+_CONN_STRING_POLL_TIMEOUT: float = 120.0
 
 __all__ = [
     "get_endpoint",
@@ -107,10 +114,58 @@ async def list_all_workspaces(http: FabricHttpClient) -> list[Warehouse]:
     )
 
 
+async def _resolve_lakehouse_connection_string(
+    http: FabricHttpClient,
+    workspace_id: UUID,
+    endpoint_id: UUID,
+) -> str | None:
+    """Find the connection string for a lakehouse-derived SQL endpoint via the parent Lakehouse.
+
+    For lakehouse-derived SQL analytics endpoints, ``GET /sqlEndpoints/{id}``
+    permanently returns an empty ``connectionString`` — the value lives only on
+    the parent Lakehouse at
+    ``properties.sqlEndpointProperties.connectionString``.
+
+    This helper pages ``GET /workspaces/{ws}/lakehouses``, locates the lakehouse
+    whose ``properties.sqlEndpointProperties.id`` matches *endpoint_id*, and
+    returns that lakehouse's ``connectionString``.  Returns ``None`` when no
+    matching lakehouse is found (e.g. the endpoint belongs to a Warehouse, not a
+    Lakehouse).
+
+    Args:
+        http: An authenticated :class:`~fabric_dw.http_client.FabricHttpClient`.
+        workspace_id: The UUID of the workspace to search.
+        endpoint_id: The UUID of the SQL analytics endpoint whose connection
+            string we need.
+
+    Returns:
+        The non-empty connection string from the matching lakehouse, or ``None``
+        if no lakehouse in the workspace has a paired endpoint with this ID.
+    """
+    # str(UUID) is always lowercase; lowercase the API value too so the match is
+    # robust against Fabric returning an uppercase/mixed-case UUID string.
+    endpoint_id_str = str(endpoint_id).lower()
+    async for lh in http.iter_paginated(HttpBase.FABRIC, f"/workspaces/{workspace_id}/lakehouses"):
+        props = lh.get("properties")
+        props_dict = cast("dict[str, Any]", props) if isinstance(props, dict) else {}
+        sql_ep = props_dict.get("sqlEndpointProperties")
+        sql_ep_dict = cast("dict[str, Any]", sql_ep) if isinstance(sql_ep, dict) else {}
+        if str(sql_ep_dict.get("id", "")).lower() == endpoint_id_str:
+            conn = str(sql_ep_dict.get("connectionString", ""))
+            return conn or None
+    return None
+
+
 async def get_endpoint(http: FabricHttpClient, workspace_id: UUID, endpoint_id: UUID) -> Warehouse:
     """Fetch a single SQL analytics endpoint by ID.
 
-    Uses ``GET /workspaces/{ws}/sqlEndpoints/{id}``.
+    Uses ``GET /workspaces/{ws}/sqlEndpoints/{id}``.  When the endpoint's own
+    ``connectionString`` is empty (which is permanent for lakehouse-derived
+    endpoints), falls back to scanning ``GET /workspaces/{ws}/lakehouses`` for
+    the parent Lakehouse whose ``properties.sqlEndpointProperties.id`` matches
+    *endpoint_id* and reads the connection string from there.  No extra
+    lakehouse call is made when the endpoint resource already carries a
+    connection string.
 
     Args:
         http: An authenticated :class:`~fabric_dw.http_client.FabricHttpClient`.
@@ -119,7 +174,9 @@ async def get_endpoint(http: FabricHttpClient, workspace_id: UUID, endpoint_id:
 
     Returns:
         A populated :class:`~fabric_dw.models.Warehouse` instance with
-        ``kind == WarehouseKind.SQL_ENDPOINT``.
+        ``kind == WarehouseKind.SQL_ENDPOINT``.  The ``connection_string``
+        field is populated whenever the parent Lakehouse exposes it (i.e. after
+        ``provisioningStatus`` reaches ``"Success"``).
 
     Raises:
         NotFoundError: If the endpoint does not exist (404).
@@ -129,7 +186,27 @@ async def get_endpoint(http: FabricHttpClient, workspace_id: UUID, endpoint_id:
         HttpBase.FABRIC,
         f"/workspaces/{workspace_id}/sqlEndpoints/{endpoint_id}",
     )
-    return Warehouse.from_api(resp.json(), kind=WarehouseKind.SQL_ENDPOINT)
+    wh = Warehouse.from_api(resp.json(), kind=WarehouseKind.SQL_ENDPOINT)
+
+    if wh.connection_string:
+        # Fast path: endpoint resource already carries the connection string.
+        return wh
+
+    # Slow path: lakehouse-derived endpoints never populate connectionString on
+    # the /sqlEndpoints/{id} resource.  Look it up via the parent Lakehouse.
+    _logger.debug(
+        "endpoint %s has empty connectionString on /sqlEndpoints resource; "
+        "falling back to lakehouse scan for workspace %s",
+        endpoint_id,
+        workspace_id,
+    )
+    lh_conn = await _resolve_lakehouse_connection_string(http, workspace_id, endpoint_id)
+    if lh_conn:
+        # Return a copy with the connection string resolved from the lakehouse,
+        # preserving every other field (description, collation, created_date, …).
+        return wh.model_copy(update={"connection_string": lh_conn})
+
+    return wh
 
 
 async def get_endpoint_connection_string(
@@ -144,16 +221,19 @@ async def get_endpoint_connection_string(
 
     SQL analytics endpoints are provisioned with eventual consistency: the
     ``connectionString`` field may be empty or absent immediately after
-    the endpoint is created.  This function polls
-    ``GET /workspaces/{ws}/sqlEndpoints/{id}`` until the connection string
-    is non-empty, up to *timeout* seconds.
+    the endpoint is created.  This function calls :func:`get_endpoint`
+    (which includes the lakehouse-fallback for lakehouse-derived endpoints)
+    until the connection string is non-empty, up to *timeout* seconds.
+    For lakehouse-derived endpoints the value is available within ~20s of
+    ``provisioningStatus`` reaching ``"Success"``; the default timeout is
+    120 s, well above that window.
 
     Args:
         http: An authenticated :class:`~fabric_dw.http_client.FabricHttpClient`.
         workspace_id: The UUID of the workspace containing the endpoint.
         endpoint_id: The UUID of the SQL analytics endpoint.
         poll_interval: Seconds between polls (default 5.0).
-        timeout: Maximum wall-clock seconds to wait (default 600.0, i.e. 10 min).
+        timeout: Maximum wall-clock seconds to wait (default 120.0).
 
     Returns:
         The non-empty connection string.

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/src/fabric_dw/services/statistics.py

@@ -45,6 +45,7 @@ reject SQL Analytics Endpoint items client-side with a clear
 from __future__ import annotations
 
 import asyncio
+import time
 from datetime import UTC, datetime
 from typing import cast
 
@@ -80,6 +81,17 @@ _SQL_ENDPOINT_READONLY_MSG = (
 _SAMPLE_PERCENT_MIN = 1
 _SAMPLE_PERCENT_MAX = 100
 
+# Bounded retry for Fabric DW eventual-consistency: DBCC SHOW_STATISTICS may
+# return "Could not locate statistics" for a short window after CREATE STATISTICS
+# even though sys.stats already reflects the new statistic.  Poll until the
+# statistic becomes visible to DBCC, up to _DBCC_STAT_TIMEOUT seconds total.
+_DBCC_STAT_POLL_INTERVAL: float = 3.0
+_DBCC_STAT_TIMEOUT: float = 60.0
+
+# Substring matched (case-insensitive) against the exception message to
+# distinguish Fabric's eventual-consistency transient error from other errors.
+_DBCC_NOT_FOUND_MSG = "could not locate statistics"
+
 
 def _assert_not_sql_endpoint(kind: WarehouseKind) -> None:
     """Raise :class:`~fabric_dw.exceptions.ItemKindError` for SQL Endpoint items.
@@ -431,7 +443,8 @@ async def show_statistics(
     density_sql = _DBCC_DENSITY_SQL.format(table_s=table_s, stat_literal=stat_literal)
     histogram_sql = _DBCC_HISTOGRAM_SQL.format(table_s=table_s, stat_literal=stat_literal)
 
-    def _run() -> StatisticDetails:
+    def _run_once() -> StatisticDetails:
+        """Execute DBCC SHOW_STATISTICS queries once (no retry)."""
         if histogram_only:
             h_cols, h_rows = run_query(target, histogram_sql, mode=mode)
             return StatisticDetails(
@@ -455,7 +468,31 @@ async def show_statistics(
             histogram=[_row_to_histogram(h_cols, r) for r in h_rows],
         )
 
-    return await asyncio.to_thread(_run)
+    # Fabric DW eventual-consistency retry: DBCC SHOW_STATISTICS may raise
+    # "Could not locate statistics" for a short window after CREATE STATISTICS
+    # (the statistic is visible in sys.stats but not yet to DBCC).  Retry
+    # until visible or until the timeout expires, then raise NotFoundError.
+    # NOTE: the effective timeout can exceed _DBCC_STAT_TIMEOUT by up to one
+    # TDS round-trip (the time asyncio.to_thread(_run_once) takes to return).
+    deadline = time.monotonic() + _DBCC_STAT_TIMEOUT
+    while True:
+        try:
+            return await asyncio.to_thread(_run_once)
+        except Exception as exc:
+            # map_driver_error() inside run_query may promote the raw DBCC
+            # driver error to NotFoundError before it reaches us.  Check the
+            # message on ANY exception so that promoted NotFoundErrors are
+            # still retried.  The empty-rows NotFoundError has the message
+            # "Statistic [..] on [..] not found" (no "could not locate
+            # statistics"), so it correctly falls through to the re-raise below.
+            if _DBCC_NOT_FOUND_MSG not in str(exc).lower():
+                # Not the transient DBCC error — propagate immediately.
+                raise
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                msg = f"Statistic [{stat_name}] on [{schema}].[{table}] not found"
+                raise NotFoundError(msg) from exc
+            await asyncio.sleep(min(_DBCC_STAT_POLL_INTERVAL, remaining))
 
 
 async def create_statistics(

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/src/fabric_dw/sql.py

@@ -902,7 +902,7 @@ def run_query(  # noqa: PLR0913
     params: Sequence[object] | None = None,
     mode: CredentialMode = CredentialMode.DEFAULT,
     commit: bool = False,
-    fetch: Literal["all", "none", "one"] = "all",
+    fetch: Literal["all", "none", "one", "rowcount"] = "all",
     autocommit: bool = False,
 ) -> tuple[list[str], list[tuple[Any, ...]]]:
     """Open a connection, execute *statement*, fetch rows, close, and map errors.
@@ -945,9 +945,21 @@ def run_query(  # noqa: PLR0913
         fetch: One of:
             - ``"all"`` (default) — call ``fetchall()`` and return
               ``(columns, rows)``; columns are derived from ``cursor.description``.
+              If ``cursor.description`` is ``None`` (no result set), returns
+              ``([], [])`` without calling ``fetchall()`` (defensive guard against
+              ``ProgrammingError: Invalid cursor state``).
             - ``"one"`` — call ``fetchone()``; returns ``(columns, [row])``
-              or ``(columns, [])`` when no row is found.
+              or ``(columns, [])`` when no row is found.  Same ``description``
+              guard applies.
             - ``"none"`` — do not fetch; returns ``([], [])``.
+            - ``"rowcount"`` — read ``cursor.rowcount`` instead of fetching a
+              result set.  Returns ``([], [(rowcount,)])`` so callers read
+              ``rows[0][0]``.  Commits (when requested) AFTER reading rowcount.
+              Use for statements that produce no result set but report an affected-
+              row count via the ODBC ``SQLRowCount`` API (e.g. ``COPY INTO`` on
+              mssql-python ≥ 1.9.0 — ``cursor.description`` is ``None`` and
+              ``fetchall()`` raises ``ProgrammingError: Invalid cursor state``,
+              but ``cursor.rowcount`` correctly equals the rows loaded).
 
         autocommit: When ``True``, open the connection with ODBC-level autocommit
             so the driver does not wrap the statement in an explicit transaction.
@@ -977,20 +989,52 @@ def run_query(  # noqa: PLR0913
             cur.execute(statement, params)
         else:
             cur.execute(statement)
-        if commit and not autocommit:
-            c.commit()
 
         if fetch == "none":
+            # No result set to read; commit now (if requested) and return.
+            if commit and not autocommit:
+                c.commit()
+            return [], []
+
+        if fetch == "rowcount":
+            # Read cursor.rowcount immediately — COPY INTO (and similar
+            # statements) produce no result set on mssql-python ≥ 1.9.0:
+            # cursor.description is None and fetchall() raises
+            # ProgrammingError: Invalid cursor state.
+            # cursor.rowcount is correctly set to the number of affected rows.
+            rc = cur.rowcount
+            if commit and not autocommit:
+                c.commit()
+            return [], [(rc,)]
+
+        # Defensive guard: if the driver returns no result set (description is
+        # None) for an "all" or "one" fetch, commit (when requested) and return
+        # empty results instead of calling fetchall()/fetchone() which would
+        # raise "ProgrammingError: Invalid cursor state".
+        if cur.description is None:
+            if commit and not autocommit:
+                c.commit()
             return [], []
 
-        cols = [col[0] for col in (cur.description or [])]
+        # Fetch the result set BEFORE committing.  Committing first invalidates
+        # the cursor's prepared statement on mssql-python, which causes
+        # "Associated statement is not prepared" on the subsequent fetchall/
+        # fetchone call.
+        cols = [col[0] for col in cur.description]
 
         if fetch == "one":
             row = cur.fetchone()
-            return cols, ([row] if row is not None else [])
+            result: tuple[list[str], list[tuple[Any, ...]]] = (
+                cols,
+                ([row] if row is not None else []),
+            )
+        else:
+            rows: list[tuple[Any, ...]] = cur.fetchall()
+            result = cols, rows
 
-        rows: list[tuple[Any, ...]] = cur.fetchall()
-        return cols, rows
+        if commit and not autocommit:
+            c.commit()
+        return result
 
     conn, attempt, max_attempts, _ = _with_connect_retry(target, mode, autocommit)
     try:

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/tests/integration/conftest.py

@@ -26,13 +26,16 @@ from fabric_dw.sql import (
 logger = logging.getLogger(__name__)
 
 # Maximum time to wait for a SQL analytics endpoint to provision on a new lakehouse.
-_SQL_ENDPOINT_PROVISION_TIMEOUT_S = 600  # 10 min — Fabric preview provisioning can be slow
+# Live probes show provisioning completes in ~18s; 120s gives a generous margin.
+_SQL_ENDPOINT_PROVISION_TIMEOUT_S = 120  # 2 min — provisioning observed at ~18s
 # Polling interval between provisioning status checks.
 _SQL_ENDPOINT_POLL_INTERVAL_S = 5
 
 # Maximum time (seconds) to wait for a fresh warehouse/endpoint SQL database
 # to become connectable after creation.
-_SQL_READINESS_TIMEOUT_S = 600  # 10 min — warm-up window for Fabric preview SQL engine
+# 10 min — warm-up window for Fabric preview SQL engine
+# (DB provisioning + SP permission propagation)
+_SQL_READINESS_TIMEOUT_S = 600
 # Starting backoff delay (seconds) between readiness probe attempts.
 _SQL_READINESS_BACKOFF_INITIAL_S = 2.0
 # Maximum backoff delay cap (seconds).
@@ -665,28 +668,31 @@ async def ephemeral_sql_endpoint(
                     f"for lakehouse {lh_id}: {ep_id_raw!r}"
                 )
 
-            # Even after provisioningStatus=Success, the connectionString on the
-            # SQL endpoint resource itself can be empty due to eventual consistency.
-            # Poll GET /sqlEndpoints/{id} until connection_string is non-empty so
-            # that tests fetching the endpoint directly get a populated value.
-            from fabric_dw.services.sql_endpoints import (  # noqa: PLC0415
-                get_endpoint_connection_string,
-            )
-
-            try:
-                ep_conn = await get_endpoint_connection_string(
-                    http,
-                    workspace_id,
-                    ep_uuid,
-                    poll_interval=_SQL_ENDPOINT_POLL_INTERVAL_S,
-                    timeout=max(1.0, deadline - time.monotonic()),
-                )
-            except Exception as exc:
-                pytest.skip(
-                    f"SQL endpoint {ep_uuid} connection_string did not populate "
-                    f"within timeout: {exc}"
+            # The Lakehouse body already has connectionString at
+            # properties.sqlEndpointProperties.connectionString when
+            # provisioningStatus=Success.  Use it directly — it is available
+            # immediately at that point.  Only fall back to polling via
+            # get_endpoint_connection_string if the value happens to be absent
+            # (defensive guard; should not occur in practice).
+            if not ep_conn:
+                from fabric_dw.services.sql_endpoints import (  # noqa: PLC0415
+                    get_endpoint_connection_string,
                 )
 
+                try:
+                    ep_conn = await get_endpoint_connection_string(
+                        http,
+                        workspace_id,
+                        ep_uuid,
+                        poll_interval=_SQL_ENDPOINT_POLL_INTERVAL_S,
+                        timeout=max(1.0, deadline - time.monotonic()),
+                    )
+                except Exception as exc:
+                    pytest.skip(
+                        f"SQL endpoint {ep_uuid} connection_string did not populate "
+                        f"within timeout: {exc}"
+                    )
+
             wh = Warehouse.model_validate(
                 {
                     "id": str(ep_uuid),

{fabric_dw-2026.6.0a1.dev182 → fabric_dw-2026.6.0a1.dev184}/tests/unit/services/test_load.py

@@ -274,6 +274,12 @@ class TestCopyIntoFromUrlGuard:
 
 class TestCopyIntoFromUrl:
     async def test_returns_copy_into_result(self) -> None:
+        """copy_into_from_url must return rows_loaded from cursor.rowcount (fetch='rowcount').
+
+        mssql-python ≥ 1.9.0: COPY INTO returns no result set; run_query with
+        fetch='rowcount' returns ([], [(N,)]) where N is cursor.rowcount.
+        rows_rejected is always 0 (not exposed via ODBC rowcount).
+        """
         from fabric_dw.sql import SqlTarget  # noqa: PLC0415
 
         target = SqlTarget(
@@ -281,10 +287,8 @@ class TestCopyIntoFromUrl:
         )
 
         with patch("fabric_dw.services.load.run_query") as mock_run:
-            mock_run.return_value = (
-                ["rows_loaded", "rows_rejected"],
-                [(100, 2)],
-            )
+            # Simulate fetch="rowcount" return: ([], [(N,)])
+            mock_run.return_value = ([], [(100,)])
             result = await copy_into_from_url(
                 target,
                 "dbo",
@@ -295,8 +299,76 @@ class TestCopyIntoFromUrl:
 
         assert isinstance(result, CopyIntoResult)
         assert result.rows_loaded == 100
-        assert result.rows_rejected == 2
+        assert result.rows_rejected == 0  # not available via rowcount
         assert result.target == "dbo.sales"
+        # Verify fetch="rowcount" was requested
+        _call_kwargs = mock_run.call_args.kwargs
+        assert _call_kwargs.get("fetch") == "rowcount"
+        assert _call_kwargs.get("commit") is True
+
+    async def test_rowcount_negative_treated_as_zero(self) -> None:
+        """ODBC rowcount=-1 (unknown) must be treated as 0 rows loaded."""
+        from fabric_dw.sql import SqlTarget  # noqa: PLC0415
+
+        target = SqlTarget(
+            workspace_id="ws-id", database="db", connection_string="server=x;database=y"
+        )
+
+        with patch("fabric_dw.services.load.run_query") as mock_run:
+            # Simulate ODBC rowcount=-1 (driver cannot determine count)
+            mock_run.return_value = ([], [(-1,)])
+            result = await copy_into_from_url(
+                target,
+                "dbo",
+                "t",
+                "https://example.com/f.parquet",
+                file_type="PARQUET",
+            )
+
+        assert result.rows_loaded == 0
+        assert result.rows_rejected == 0
+
+    async def test_rowcount_none_treated_as_zero(self) -> None:
+        """rowcount=None in result rows must be treated as 0 rows loaded."""
+        from fabric_dw.sql import SqlTarget  # noqa: PLC0415
+
+        target = SqlTarget(
+            workspace_id="ws-id", database="db", connection_string="server=x;database=y"
+        )
+
+        with patch("fabric_dw.services.load.run_query") as mock_run:
+            mock_run.return_value = ([], [(None,)])
+            result = await copy_into_from_url(
+                target,
+                "dbo",
+                "t",
+                "https://example.com/f.parquet",
+                file_type="PARQUET",
+            )
+
+        assert result.rows_loaded == 0
+        assert result.rows_rejected == 0
+
+    async def test_empty_rows_treated_as_zero(self) -> None:
+        """Empty rows list from run_query must yield rows_loaded=0."""
+        from fabric_dw.sql import SqlTarget  # noqa: PLC0415
+
+        target = SqlTarget(
+            workspace_id="ws-id", database="db", connection_string="server=x;database=y"
+        )
+
+        with patch("fabric_dw.services.load.run_query") as mock_run:
+            mock_run.return_value = ([], [])
+            result = await copy_into_from_url(
+                target,
+                "dbo",
+                "t",
+                "https://example.com/f.parquet",
+                file_type="PARQUET",
+            )
+
+        assert result.rows_loaded == 0
+        assert result.rows_rejected == 0
 
     async def test_secret_not_logged(self, caplog: pytest.LogCaptureFixture) -> None:
         """Secret values must never appear in log output (happy path)."""
@@ -311,7 +383,7 @@ class TestCopyIntoFromUrl:
             caplog.at_level(logging.DEBUG, logger="fabric_dw"),
             patch("fabric_dw.services.load.run_query") as mock_run,
         ):
-            mock_run.return_value = (["rows_loaded"], [(5,)])
+            mock_run.return_value = ([], [(5,)])
             await copy_into_from_url(
                 target,
                 "dbo",