bulk delete

Author: Max Wang

README.md

@@ -39,7 +39,7 @@ Auth:
 | `update` | `update(logical_name, list[id], patch)` | `None` | Broadcast; same patch applied to all IDs (UpdateMultiple). |
 | `update` | `update(logical_name, list[id], list[patch])` | `None` | 1:1 patches; lengths must match (UpdateMultiple). |
 | `delete` | `delete(logical_name, id)` | `None` | Delete one record. |
-| `delete` | `delete(logical_name, list[id])` | `None` | Delete many (sequential). |
+| `delete` | `delete(logical_name, list[id], ..., wait_poll_interval_seconds=2.0)` | `Optional[str]` | Delete many with async BulkDelete. |
 | `query_sql` | `query_sql(sql)` | `list[dict]` | Constrained read-only SELECT via `?sql=`. |
 | `create_table` | `create_table(tablename, schema, solution_unique_name=None)` | `dict` | Creates custom table + columns. Friendly name (e.g. `SampleItem`) becomes schema `new_SampleItem`; explicit schema name (contains `_`) used as-is. Pass `solution_unique_name` to attach the table to a specific solution instead of the default solution. |
 | `create_column` | `create_column(tablename, columns)` | `list[str]` | Adds columns using a `{name: type}` mapping (same shape as `create_table` schema). Returns schema names for the created columns. |
@@ -54,8 +54,10 @@ Auth:
 
 Guidelines:
 - `create` always returns a list of GUIDs (1 for single, N for bulk).
-- `update`/`delete` always return `None` (single and multi forms).
+- `update` always returns `None`.
 - Bulk update chooses broadcast vs per-record by the type of `changes` (dict vs list).
+- `delete` returns `None` for single-record delete and the BulkDelete async job ID for multi-record delete.
+- By default multi-record delete doesn't wait for the async job to complete. User can optionally wait for the job to complete.,klmmm 
 - Paging and SQL operations never mutate inputs.
 - Metadata lookups for logical name stamping cached per entity set (in-memory).
 
@@ -143,9 +145,12 @@ client.update("account", ids, [
 ])
 print({"multi_update": "ok"})
 
-# Delete
+# Delete (single)
 client.delete("account", account_id)
 
+# Bulk delete (schedules BulkDelete and returns job id)
+job_id = client.delete("account", ids)
+
 # SQL (read-only) via Web API `?sql=`
 rows = client.query_sql("SELECT TOP 3 accountid, name FROM account ORDER BY createdon DESC")
 for r in rows:
@@ -334,7 +339,7 @@ client.delete_table("SampleItem")       # delete table (friendly name or explici
 
 Notes:
 - `create` always returns a list of GUIDs (length 1 for single input).
-- `update` and `delete` return `None` for both single and multi.
+- `update` returns `None`. `delete` returns `None` for single-record delete and the BulkDelete async job ID for multi-record delete.
 - Passing a list of payloads to `create` triggers bulk create and returns `list[str]` of IDs.
 - `get` supports single record retrieval with record id or paging through result sets (prefer `select` to limit columns).
 - For CRUD methods that take a record id, pass the GUID string (36-char hyphenated). Parentheses around the GUID are accepted but not required.
@@ -350,7 +355,6 @@ VS Code Tasks
 
 ## Limitations / Future Work
 - No general-purpose OData batching, upsert, or association operations yet.
-- `DeleteMultiple` not yet exposed.
 - Minimal retry policy in library (network-error only); examples include additional backoff for transient Dataverse consistency.
 
 ## Contributing

examples/quickstart.py

@@ -14,7 +14,6 @@
 import requests
 import time
 from datetime import date, timedelta
-from concurrent.futures import ThreadPoolExecutor, as_completed
 
 
 entered = input("Enter Dataverse org URL (e.g. https://yourorg.crm.dynamics.com): ").strip()
@@ -57,10 +56,12 @@ def backoff_retry(op, *, delays=(0, 2, 5, 10, 20), retry_http_statuses=(400, 403
 			print(f'Request failed: {ex}')
 			last_exc = ex
 			if retry_if and retry_if(ex):
+				print("Retrying operation...")
 				continue
 			if isinstance(ex, requests.exceptions.HTTPError):
 				code = getattr(getattr(ex, 'response', None), 'status_code', None)
 				if code in retry_http_statuses:
+					print("Retrying operation...")
 					continue
 			break
 	if last_exc:
@@ -176,20 +177,6 @@ def print_line_summaries(label: str, summaries: list[dict]) -> None:
 			f"count={s.get('count')} amount={s.get('amount')} when={s.get('when')}"
 		)
 
-def _resolve_status_value(kind: str, raw_value, use_french: bool):
-	"""kind values:
-	  - 'label': English label
-	  - 'fr_label': French label if allowed, else fallback to English equivalent
-	  - 'int': the enum integer value
-	"""
-	if kind == "label":
-		return raw_value
-	if kind == "fr_label":
-		if use_french:
-			return raw_value
-		return "Active" if raw_value == "Actif" else "Inactive"
-	return raw_value
-
 def _has_installed_language(base_url: str, credential, lcid: int) -> bool:
 	try:
 		token = credential.get_token(f"{base_url}/.default").token
@@ -496,39 +483,64 @@ def run_paging_demo(label: str, *, top: Optional[int], page_size: Optional[int])
 	print(f"Retrieve multiple demos failed: {e}")
 # 5) Delete record
 print("Delete (OData):")
-# Show deletes to be executed (concurrently via SDK delete)
+# Show deletes to be executed (single + bulk)
 if 'record_ids' in locals() and record_ids:
 	print({"delete_count": len(record_ids)})
-pause("Execute Delete (concurrent SDK calls)")
+pause("Execute Delete (single then bulk)")
 try:
 	if record_ids:
-		max_workers = min(8, len(record_ids))
-		log_call(f"concurrent delete {len(record_ids)} items from '{logical}' (workers={max_workers})")
+		single_target = record_ids[0]
+		rest_targets = record_ids[1:]
+		single_error: Optional[str] = None
+		bulk_job_id: Optional[str] = None
+		bulk_error: Optional[str] = None
+		bulk_wait_job_id: Optional[str] = None
+		bulk_wait_error: Optional[str] = None
+		async_targets: list[str] = []
+		wait_targets: list[str] = []
+
+		try:
+			log_call(f"client.delete('{logical}', '{single_target}')")
+			backoff_retry(lambda: client.delete(logical, single_target))
+		except Exception as ex:
+			single_error = str(ex)
 
-		successes: list[str] = []
-		failures: list[dict] = []
+		if rest_targets:
+			half = len(rest_targets) // 2
+			async_targets = rest_targets[:half]
+			wait_targets = rest_targets[half:]
 
-		def _del_one(rid: str) -> tuple[str, bool, str | None]:
 			try:
-				log_call(f"client.delete('{logical}', '{rid}')")
-				backoff_retry(lambda: client.delete(logical, rid))
-				return (rid, True, None)
+				log_call(f"client.delete('{logical}', <{len(async_targets)} ids>) [fire-and-forget]")
+				bulk_job_id = client.delete(logical, async_targets)
 			except Exception as ex:
-				return (rid, False, str(ex))
-
-		with ThreadPoolExecutor(max_workers=max_workers) as executor:
-			future_map = {executor.submit(_del_one, rid): rid for rid in record_ids}
-			for fut in as_completed(future_map):
-				rid, ok, err = fut.result()
-				if ok:
-					successes.append(rid)
-				else:
-					failures.append({"id": rid, "error": err})
+				bulk_error = str(ex)
+			try:
+				log_call(f"client.delete('{logical}', <{len(wait_targets)} ids>, wait=True)")
+				bulk_wait_job_id = client.delete(
+					logical,
+					wait_targets,
+					wait=True,
+				)
+			except Exception as ex:
+				bulk_wait_error = str(ex)
 
 		print({
 			"entity": logical,
-			"delete_summary": {"requested": len(record_ids), "success": len(successes), "failures": len(failures)},
-			"failed": failures[:5],  # preview up to 5 failures
+			"delete_single": {
+				"id": single_target,
+				"error": single_error,
+			},
+			"delete_bulk_fire_and_forget": {
+				"count": len(async_targets) if rest_targets else 0,
+				"job_id": bulk_job_id,
+				"error": bulk_error,
+			},
+			"delete_bulk_wait": {
+				"count": len(wait_targets) if rest_targets else 0,
+				"job_id": bulk_wait_job_id,
+				"error": bulk_wait_error,
+			},
 		})
 	else:
 		raise RuntimeError("No record created; skipping delete.")
@@ -577,8 +589,22 @@ def _metadata_after_create():
 		if isinstance(raw_type, str):
 			attr_type_before = raw_type
 			lowered = raw_type.lower()
-	log_call(f"client.delete_column('{entity_schema}', '{scratch_column}')")
-	column_delete = client.delete_columns(entity_schema, scratch_column)
+	delete_target = attribute_schema or scratch_column
+	log_call(f"client.delete_column('{entity_schema}', '{delete_target}')")
+
+	def _delete_column():
+		return client.delete_columns(entity_schema, delete_target)
+
+	column_delete = backoff_retry(
+		_delete_column,
+		delays=(0, 1, 2, 4, 8),
+		retry_http_statuses=(),
+		retry_if=lambda exc: (
+			isinstance(exc, MetadataError)
+			or "not found" in str(exc).lower()
+			or "not yet available" in str(exc).lower()
+		),
+	)
 	if not isinstance(column_delete, list) or not column_delete:
 		raise RuntimeError("delete_column did not return schema list")
 	deleted_details = column_delete

src/dataverse_sdk/client.py

@@ -201,16 +201,32 @@ def update(self, logical_name: str, ids: Union[str, List[str]], changes: Union[D
         od._update_by_ids(logical_name, ids, changes)
         return None
 
-    def delete(self, logical_name: str, ids: Union[str, List[str]]) -> None:
+    def delete(
+        self,
+        logical_name: str,
+        ids: Union[str, List[str]],
+        wait: bool = False,
+        wait_timeout_seconds: Optional[int] = 300,
+        wait_poll_interval_seconds: float = 2.0,
+    ) -> Optional[str]:
         """
         Delete one or more records by GUID.
 
         :param logical_name: Logical (singular) entity name, e.g. ``"account"``.
         :type logical_name: str
         :param ids: Single GUID string or list of GUID strings to delete.
         :type ids: str or list[str]
-
+        :param wait: When deleting multiple records, wait for the background job to complete. Ignored for single deletes.
+        :type wait: bool
+        :param wait_timeout_seconds: Optional timeout applied when ``wait`` is True. ``None`` or
+            values ``<= 0`` wait indefinitely. Defaults to 300 seconds.
+        :type wait_timeout_seconds: int or None
+        :param wait_poll_interval_seconds: Poll interval used while waiting for job completion.
+        :type wait_poll_interval_seconds: float
         :raises TypeError: If ``ids`` is not str or list[str].
+        
+        :return: BulkDelete job ID when deleting multiple records; otherwise ``None``.
+        :rtype: str or None
 
         Example:
             Delete a single record::
@@ -219,16 +235,21 @@ def delete(self, logical_name: str, ids: Union[str, List[str]]) -> None:
 
             Delete multiple records::
 
-                client.delete("account", [id1, id2, id3])
+                job_id = client.delete("account", [id1, id2, id3])
         """
         od = self._get_odata()
         if isinstance(ids, str):
             od._delete(logical_name, ids)
             return None
         if not isinstance(ids, list):
             raise TypeError("ids must be str or list[str]")
-        od._delete_multiple(logical_name, ids)
-        return None
+        return od._delete_multiple(
+            logical_name,
+            ids,
+            wait=wait,
+            timeout_seconds=wait_timeout_seconds,
+            poll_interval_seconds=wait_poll_interval_seconds,
+        )
 
     def get(
         self,