Add update_multiple

Author: tpellissier

README.md

@@ -5,6 +5,7 @@ A minimal Python SDK to use Microsoft Dataverse as a database for Azure AI Found
 - Read (SQL) — Execute read-only T‑SQL via the McpExecuteSqlQuery Custom API. Returns `list[dict]`.
 - OData CRUD — Thin wrappers over Dataverse Web API (create/get/update/delete).
 - Bulk create — Pass a list of records to `create(...)` to invoke the bound `CreateMultiple` action; returns `list[str]` of GUIDs. If `@odata.type` is absent the SDK resolves the logical name from metadata (cached).
+- Bulk update — Call `update_multiple(entity_set, records)` to invoke the bound `UpdateMultiple` action; returns nothing (transactional fire-and-forget). Each record must include the real primary key attribute (e.g. `accountid`).
 - Retrieve multiple (paging) — Generator-based `get_multiple(...)` that yields pages, supports `$top` and Prefer: `odata.maxpagesize` (`page_size`).
 - Metadata helpers — Create/inspect/delete simple custom tables (EntityDefinitions + Attributes).
 - Pandas helpers — Convenience DataFrame oriented wrappers for quick prototyping/notebooks.
@@ -16,6 +17,7 @@ A minimal Python SDK to use Microsoft Dataverse as a database for Azure AI Found
 - SQL-over-API: T-SQL routed through Custom API endpoint (no ODBC / TDS driver required).
 - Table metadata ops: create simple custom tables with primitive columns (string/int/decimal/float/datetime/bool) and delete them.
 - Bulk create via `CreateMultiple` (collection-bound) by passing `list[dict]` to `create(entity_set, payloads)`; returns list of created IDs.
+- Bulk update via `UpdateMultiple` by calling `update_multiple(entity_set, records)` with primary key attribute present in each record; returns nothing.
 - Retrieve multiple with server-driven paging: `get_multiple(...)` yields lists (pages) following `@odata.nextLink`. Control total via `$top` and per-page via `page_size` (Prefer: `odata.maxpagesize`).
 - Optional pandas integration (`PandasODataClient`) for DataFrame based create / get / query.
 
@@ -100,6 +102,13 @@ account = client.get("accounts", account_id)
 # Update (returns updated record)
 updated = client.update("accounts", account_id, {"telephone1": "555-0199"})
 
+# Bulk update (collection-bound UpdateMultiple)
+# Each record must include the primary key attribute (accountid). The call returns None.
+client.update_multiple("accounts", [
+	{"accountid": account_id, "telephone1": "555-0200"},
+])
+print({"bulk_update": "ok"})
+
 # Delete
 client.delete("accounts", account_id)
 
@@ -124,6 +133,29 @@ assert isinstance(ids, list) and all(isinstance(x, str) for x in ids)
 print({"created_ids": ids})
 ```
 
+## Bulk update (UpdateMultiple)
+
+Use `update_multiple(entity_set, records)` for a transactional batch update. The method returns `None` regardless of service response; this avoids exposing inconsistent behavior across environments that may or may not emit updated IDs.
+
+```python
+ids = client.create("accounts", [
+    {"name": "Fourth Coffee"},
+    {"name": "Tailspin"},
+])
+
+client.update_multiple("accounts", [
+    {"accountid": ids[0], "telephone1": "555-1111"},
+    {"accountid": ids[1], "telephone1": "555-2222"},
+])
+print({"bulk_update": "ok"})
+```
+
+Notes:
+- Each record must include the primary key attribute (e.g. `accountid`). No `id` alias yet.
+- If any payload omits `@odata.type`, the logical name is resolved once and stamped (same as bulk create).
+- Entire request fails (HTTP error) if any individual update fails; no partial success list is returned.
+- If you need refreshed records post-update, issue individual `get` calls or a `get_multiple` query.
+
 Notes:
 - The bulk create response typically includes IDs only; the SDK returns the list of GUID strings.
 - Single-record `create` still returns the full entity representation.
@@ -251,7 +283,7 @@ VS Code Tasks
 
 ## Limitations / Future Work
 - No general-purpose OData batching, upsert, or association operations yet.
-- `DeleteMultiple`/`UpdateMultiple` are not exposed; quickstart may demonstrate faster deletes using client-side concurrency only.
+- `DeleteMultiple` not yet exposed; `UpdateMultiple` is available but returns no IDs (fire-and-forget semantics in this SDK version).
 - Minimal retry policy in library (network-error only); examples include additional backoff for transient Dataverse consistency.
 - Entity naming conventions in Dataverse: for multi-create the SDK resolves logical names from entity set metadata.
 

examples/quickstart.py

@@ -286,6 +286,41 @@ def print_line_summaries(label: str, summaries: list[dict]) -> None:
 except Exception as e:
 	print(f"Update/verify failed: {e}")
 	sys.exit(1)
+
+# 3.6) Bulk update (UpdateMultiple) demo: update count field on up to first 5 remaining records
+print("Bulk update (UpdateMultiple) demo:")
+try:
+	if len(record_ids) > 1:
+		# Prepare a small subset to update (skip the first already updated one)
+		subset = record_ids[1:6]
+		bulk_updates = []
+		for idx, rid in enumerate(subset, start=1):
+			# Simple deterministic changes so user can observe
+			bulk_updates.append({
+				id_key: rid,
+				count_key: 100 + idx,  # new count values
+			})
+		log_call(f"client.update_multiple('{entity_set}', <{len(bulk_updates)} records>)")
+		# update_multiple returns nothing (fire-and-forget success semantics)
+		backoff_retry(lambda: client.update_multiple(entity_set, bulk_updates))
+		print({"bulk_update_requested": len(bulk_updates), "bulk_update_completed": True})
+		# Verify the updated count values by refetching the subset
+		# (Individual gets keep the example simple and avoid crafting a complex $filter.)
+		verification = []
+		# Small delay to reduce risk of any brief replication delay (usually unnecessary)
+		time.sleep(1)
+		for rid in subset:
+			rec = backoff_retry(lambda rid=rid: client.get(entity_set, rid))
+			verification.append({
+				"id": rid,
+				"count": rec.get(count_key),
+			})
+		print({"bulk_update_verification": verification})
+	else:
+		print({"bulk_update_skipped": True, "reason": "not enough records"})
+except Exception as e:
+	print(f"Bulk update failed: {e}")
+
 # 4) Query records via SQL Custom API
 print("Query (SQL via Custom API):")
 try:

src/dataverse_sdk/client.py

@@ -110,6 +110,25 @@ def update(self, entity: str, record_id: str, record_data: dict) -> dict:
         """
         return self._get_odata().update(entity, record_id, record_data)
 
+    def update_multiple(self, entity: str, records: List[Dict[str, Any]]) -> None:
+        """Bulk update multiple records via the bound UpdateMultiple action.
+
+        Parameters
+        ----------
+        entity : str
+            Entity set name (plural logical name).
+        records : list[dict]
+            Each record must include the primary key attribute (e.g. ``accountid``) plus fields to update.
+
+        Returns
+        -------
+        None
+            On success returns nothing. The underlying action does not reliably emit updated IDs across
+            environments; for predictable semantics the SDK returns None.
+        """
+        self._get_odata().update_multiple(entity, records)
+        return None
+
     def delete(self, entity: str, record_id: str) -> None:
         """Delete a record by ID.
 

src/dataverse_sdk/odata.py

@@ -196,6 +196,67 @@ def update(self, entity_set: str, key: str, data: Dict[str, Any]) -> Dict[str, A
         r.raise_for_status()
         return r.json()
 
+    def update_multiple(self, entity_set: str, records: List[Dict[str, Any]]) -> None:
+        """Bulk update existing records via the collection-bound UpdateMultiple action.
+
+        Parameters
+        ----------
+        entity_set : str
+            Entity set (plural logical name), e.g. "accounts".
+        records : list[dict]
+            Each dict must include the real primary key attribute for the entity (e.g. ``accountid``) and one or more
+            fields to update. If ``@odata.type`` is omitted in any payload, the logical name is resolved once and
+            stamped into those payloads as ``Microsoft.Dynamics.CRM.<logical>`` (same behaviour as bulk create).
+
+        Behaviour
+        ---------
+        - POST ``/{entity_set}/Microsoft.Dynamics.CRM.UpdateMultiple`` with body ``{"Targets": [...]}``.
+        - Expects Dataverse transactional semantics: if any individual update fails the entire request is rolled back
+          and an error HTTP status is returned (no partial success handling in V1).
+        - Response is expected to include an ``Ids`` list (mirrors CreateMultiple); if absent an empty list is
+          returned.
+
+        Returns
+        -------
+        None
+            This method does not return IDs or record bodies. The Dataverse UpdateMultiple action does not
+            consistently emit identifiers across environments; to keep semantics predictable the SDK returns
+            nothing on success. Use follow-up queries (e.g. get / get_multiple) if you need refreshed data.
+
+        Notes
+        -----
+        - Caller must include the correct primary key attribute (e.g. ``accountid``) in every record.
+        - No representation of updated records is returned; for a single record representation use ``update``.
+        """
+        if not isinstance(records, list) or not records or not all(isinstance(r, dict) for r in records):
+            raise TypeError("records must be a non-empty list[dict]")
+
+        # Determine whether we need logical name resolution (@odata.type missing in any payload)
+        need_logical = any("@odata.type" not in r for r in records)
+        logical: Optional[str] = None
+        if need_logical:
+            logical = self._logical_from_entity_set(entity_set)
+        enriched: List[Dict[str, Any]] = []
+        for r in records:
+            if "@odata.type" in r or not logical:
+                enriched.append(r)
+            else:
+                nr = r.copy()
+                nr["@odata.type"] = f"Microsoft.Dynamics.CRM.{logical}"
+                enriched.append(nr)
+
+        payload = {"Targets": enriched}
+        url = f"{self.api}/{entity_set}/Microsoft.Dynamics.CRM.UpdateMultiple"
+        headers = self._headers().copy()
+        r = self._request("post", url, headers=headers, json=payload)
+        r.raise_for_status()
+        try:
+            body = r.json() if r.text else {}
+        except ValueError:
+            body = {}
+        # Intentionally ignore response content: no stable contract for IDs across environments.
+        return None
+
     def delete(self, entity_set: str, key: str) -> None:
         """Delete a record by GUID or alternate key."""
         url = f"{self.api}/{entity_set}{self._format_key(key)}"