JoeYing
Add ReScopeBench cases and task preview
f726fd6
Raw History Blame Contribute Delete
96.7 kB
"""Business logic for the cloud data warehouse tools.""" from __future__ import annotations from datetime import datetime from typing import Any, Dict, Iterable, List, Optional from mcp_servers.utils import ( build_humanized_id, datetime_gt, error_response, is_date, is_iso_datetime, now_iso, org_slug, safe_copy, slugify, success_response, ) ENTITY_TYPES = { "organization": ("organization", "org_id"), "user": ("user", "user_id"), "warehouse": ("warehouse", "warehouse_id"), "dataset": ("dataset", "dataset_id"), "table": ("table", "table_id"), "column": ("column", "column_id"), "access_grant": ("access_grant", "grant_id"), "query_job": ("query_job", "query_job_id"), "import_job": ("import_job", "import_job_id"), "export_job": ("export_job", "export_job_id"), "cost_usage_record": ("cost_usage_record", "usage_id"), "quota_policy": ("quota_policy", "quota_id"), } REGIONS = {"us-east", "us-west", "us-central", "eu-west", "eu-central"} RESOURCE_GROUPS = {"analytics", "finance", "operations", "ml", "etl"} WAREHOUSE_SIZES = {"xs": 0.75, "s": 1.5, "m": 3.0, "l": 6.0, "xl": 12.0} DATASET_CLASSIFICATIONS = {"internal", "confidential", "restricted", "public"} TABLE_TYPES = {"raw", "curated", "mart", "snapshot", "materialized_view"} COLUMN_TYPES = {"string", "int64", "float64", "numeric", "bool", "date", "timestamp"} SENSITIVITIES = {"none", "pii", "financial", "operational", "secret"} QUERY_STATUSES = {"queued", "running", "succeeded", "failed", "canceled"} PRIORITIES = {"low", "normal", "high", "urgent"} TRANSFER_FORMATS = {"csv", "json", "parquet", "avro"} EXPORT_FORMATS = {"csv", "parquet", "json"} GRANT_ROLES = {"reader", "writer", "admin", "owner"} GRANT_SCOPES = {"dataset", "table"} PRINCIPAL_TYPES = {"user", "group", "service_account"} ENFORCEMENT_MODES = {"monitor", "block", "throttle"} QUOTA_STATUSES = {"active", "disabled"} ALLOWED_STORAGE_SCHEMES = ("s3://", "gs://", "az://") def _err(code: str, text: str): return error_response(code, text) def _required(params: Dict[str, Any], fields: Iterable[str], code: str = "MISSING_FIELD"): for field in fields: value = params.get(field) if value is None or (isinstance(value, str) and not value.strip()) or (isinstance(value, list) and not value): return _err(code, f"{field} is required") return None def _get(sm, entity: str, entity_id: str): return sm.get_entity(entity, entity_id, id_field=ENTITY_TYPES[entity][1]) def _all(sm, entity: str) -> List[Dict[str, Any]]: return sm.list_entities(entity) def _org(sm, org_id: str): return _get(sm, "organization", org_id) def _user(sm, user_id: str): return _get(sm, "user", user_id) def _warehouse(sm, warehouse_id: str): return _get(sm, "warehouse", warehouse_id) def _dataset(sm, dataset_id: str): return _get(sm, "dataset", dataset_id) def _table(sm, table_id: str): return _get(sm, "table", table_id) def _column(sm, column_id: str): return _get(sm, "column", column_id) def _grant(sm, grant_id: str): return _get(sm, "access_grant", grant_id) def _query(sm, query_job_id: str): return _get(sm, "query_job", query_job_id) def _import(sm, import_job_id: str): return _get(sm, "import_job", import_job_id) def _export(sm, export_job_id: str): return _get(sm, "export_job", export_job_id) def _quota(sm, quota_id: str): return _get(sm, "quota_policy", quota_id) def _update(sm, entity: str, entity_id: str, patch: Dict[str, Any]): return sm.update_entity(entity, entity_id, patch, id_field=ENTITY_TYPES[entity][1]) def _save(sm, entity: str, record: Dict[str, Any]): return sm.replace_entity(entity, record[ENTITY_TYPES[entity][1]], record) def _same_org(row: Dict[str, Any], org_id: str) -> bool: return row.get("org_id") == org_id def _page(values: List[Dict[str, Any]], offset: Any = 0, limit: Any = 25, max_limit: int = 100): if not isinstance(offset, int) or offset < 0 or not isinstance(limit, int) or not (1 <= limit <= max_limit): return None return values[offset: offset + limit] def _sort(values: List[Dict[str, Any]], sort_by: str, sort_order: str, tie_key: str) -> List[Dict[str, Any]]: reverse = sort_order == "desc" return sorted(values, key=lambda row: (row.get(sort_by) is None, row.get(sort_by), row.get(tie_key)), reverse=reverse) def _valid_datetime_window(start: Any, end: Any) -> bool: if start is not None and not is_iso_datetime(start): return False if end is not None and not is_iso_datetime(end): return False return not (start and end and start > end) def _valid_date_window(start: Any, end: Any) -> bool: if start is not None and not is_date(start): return False if end is not None and not is_date(end): return False return not (start and end and start > end) def _columns_for_table(sm, table_id: str) -> List[Dict[str, Any]]: return [c for c in _all(sm, "column") if c.get("table_id") == table_id] def _active_grants(sm, dataset_id: str, user_id: str) -> List[Dict[str, Any]]: return [g for g in _all(sm, "access_grant") if g.get("dataset_id") == dataset_id and g.get("user_id") == user_id and g.get("status") == "active"] def _has_role_access(sm, dataset_id: str, user_id: str, allowed_roles: set[str], table_id: Optional[str] = None) -> bool: user = _user(sm, user_id) if user and user.get("role") in {"admin", "steward"}: return True for grant in _active_grants(sm, dataset_id, user_id): if grant.get("role") in allowed_roles and (grant.get("scope") == "dataset" or grant.get("table_id") == table_id): return True return False def _is_grantor(sm, dataset_id: str, user_id: str) -> bool: user = _user(sm, user_id) if user and user.get("role") in {"admin", "steward"}: return True return any(g.get("role") in {"owner", "admin"} for g in _active_grants(sm, dataset_id, user_id)) def _estimate_query(tables: List[Dict[str, Any]]) -> tuple[float, float, float]: scanned = round(sum(float(t.get("size_gb") or 0) * 1.15 + max(int(t.get("row_count") or 0), 1) / 250000.0 for t in tables), 3) credits = round(max(scanned * 0.07, 0.05), 3) cost = round(credits * 3.15, 2) return scanned, credits, cost def _new_usage_id(sm, org_id: str, date: str, group: str, usage_type: str) -> str: base = f"usage-{org_slug(org_id)}-{date}-{slugify(group)}-{usage_type}" existing = {u["usage_id"] for u in _all(sm, "cost_usage_record")} candidate = base idx = 2 while candidate in existing: candidate = f"{base}-{idx}" idx += 1 return candidate def _new_time_id(sm, entity: str, org_id: str, topic: str) -> str: prefix = {"query_job": "query", "import_job": "import", "export_job": "export"}[entity] base = f"{prefix}-{org_slug(org_id)}-2026-06-01t00-00-00-{slugify(topic)}" existing = {r[ENTITY_TYPES[entity][1]] for r in _all(sm, entity)} candidate = base idx = 2 while candidate in existing: candidate = f"{base}-{idx}" idx += 1 return candidate def get_entity(*, state_manager, entity_type=None, entity_id=None, **kwargs): if entity_type is None or entity_id is None: return _err("MISSING_FIELD", "entity_type and entity_id are required") if entity_type not in ENTITY_TYPES or not isinstance(entity_id, str): return _err("INVALID_PARAMETER", "unsupported entity_type or invalid entity_id") entity, _ = ENTITY_TYPES[entity_type] row = _get(state_manager, entity, entity_id.strip()) if row is None: return _err("NOT_FOUND", "no record matches the requested id") return success_response({"entity_type": entity_type, "entity": row}) def list_organizations(*, state_manager, status=None, compliance_region=None, billing_tier=None, sort_by="display_name", sort_order="asc", offset=0, limit=25, **kwargs): if status is not None and status not in {"active", "maintenance", "suspended"}: return _err("INVALID_PARAMETER", "invalid status") if compliance_region is not None and compliance_region not in REGIONS: return _err("INVALID_PARAMETER", "invalid compliance_region") if billing_tier is not None and billing_tier not in {"business", "enterprise"}: return _err("INVALID_PARAMETER", "invalid billing_tier") if sort_by not in {"display_name", "monthly_credit_limit", "storage_limit_gb", "updated_at"} or sort_order not in {"asc", "desc"}: return _err("INVALID_PARAMETER", "invalid sorting parameter") rows = [r for r in _all(state_manager, "organization") if (status is None or r["status"] == status) and (compliance_region is None or r["compliance_region"] == compliance_region) and (billing_tier is None or r["billing_tier"] == billing_tier)] rows = _sort(rows, sort_by, sort_order, "org_id") page = _page(rows, offset, limit) if page is None: return _err("OUT_OF_RANGE", "pagination bounds are invalid") fields = ["org_id", "display_name", "billing_tier", "compliance_region", "status", "monthly_credit_limit", "storage_limit_gb"] return success_response({"total_count": len(rows), "offset": offset, "limit": limit, "organizations": [{k: r.get(k) for k in fields} for r in page]}) def list_users(*, state_manager, org_id=None, role=None, status=None, department_keyword=None, search_text=None, sort_by="display_name", sort_order="asc", offset=0, limit=25, **kwargs): if not org_id: return _err("MISSING_ORG_ID", "org_id is required") if _org(state_manager, org_id) is None: return _err("ORG_NOT_FOUND", "organization not found") if role is not None and role not in {"analyst", "engineer", "admin", "viewer", "steward"}: return _err("INVALID_PARAMETER", "invalid role") if status is not None and status not in {"active", "invited", "suspended"}: return _err("INVALID_PARAMETER", "invalid status") if sort_by not in {"display_name", "department", "role", "updated_at"} or sort_order not in {"asc", "desc"}: return _err("INVALID_PARAMETER", "invalid sorting parameter") if (department_keyword is not None and not isinstance(department_keyword, str)) or (search_text is not None and not isinstance(search_text, str)): return _err("INVALID_PARAMETER", "search filters must be strings") rows = [u for u in _all(state_manager, "user") if u["org_id"] == org_id] if role: rows = [u for u in rows if u["role"] == role] if status: rows = [u for u in rows if u["status"] == status] if department_keyword: rows = [u for u in rows if department_keyword.lower() in u["department"].lower()] if search_text: needle = search_text.lower() rows = [u for u in rows if needle in u["display_name"].lower() or needle in u["email_address"].lower()] rows = _sort(rows, sort_by, sort_order, "user_id") page = _page(rows, offset, limit) if page is None: return _err("OUT_OF_RANGE", "pagination bounds are invalid") fields = ["user_id", "email_address", "display_name", "role", "department", "status"] return success_response({"total_count": len(rows), "offset": offset, "limit": limit, "users": [{k: r.get(k) for k in fields} for r in page]}) def list_warehouses(*, state_manager, org_id=None, resource_group=None, status=None, size=None, include_capacity=True, sort_by="name", sort_order="asc", offset=0, limit=25, **kwargs): if not org_id: return _err("MISSING_ORG_ID", "org_id is required") if _org(state_manager, org_id) is None: return _err("ORG_NOT_FOUND", "organization not found") if resource_group is not None and resource_group not in RESOURCE_GROUPS: return _err("INVALID_PARAMETER", "invalid resource_group") if status is not None and status not in {"active", "suspended", "resizing"}: return _err("INVALID_PARAMETER", "invalid status") if size is not None and size not in WAREHOUSE_SIZES: return _err("INVALID_PARAMETER", "invalid size") if not isinstance(include_capacity, bool) or sort_by not in {"name", "size", "running_queries", "credits_used_today", "updated_at"} or sort_order not in {"asc", "desc"}: return _err("INVALID_PARAMETER", "invalid list parameter") rows = [w for w in _all(state_manager, "warehouse") if w["org_id"] == org_id] if resource_group: rows = [w for w in rows if w["resource_group"] == resource_group] if status: rows = [w for w in rows if w["status"] == status] if size: rows = [w for w in rows if w["size"] == size] rows = _sort(rows, sort_by, sort_order, "warehouse_id") page = _page(rows, offset, limit) if page is None: return _err("OUT_OF_RANGE", "pagination bounds are invalid") fields = ["warehouse_id", "name", "resource_group", "size", "status", "max_concurrency"] if include_capacity: fields += ["running_queries", "queued_queries", "credits_used_today", "daily_credit_limit"] return success_response({"total_count": len(rows), "offset": offset, "limit": limit, "warehouses": [{k: r.get(k) for k in fields} for r in page]}) def list_datasets(*, state_manager, org_id=None, status=None, classification=None, region=None, owner_user_id=None, business_domain_keyword=None, sort_by="name", sort_order="asc", offset=0, limit=25, **kwargs): if not org_id: return _err("MISSING_ORG_ID", "org_id is required") if _org(state_manager, org_id) is None: return _err("ORG_NOT_FOUND", "organization not found") if status is not None and status not in {"active", "archived"}: return _err("INVALID_PARAMETER", "invalid status") if classification is not None and classification not in DATASET_CLASSIFICATIONS: return _err("INVALID_PARAMETER", "invalid classification") if region is not None and region not in REGIONS: return _err("INVALID_PARAMETER", "invalid region") if business_domain_keyword is not None and not isinstance(business_domain_keyword, str): return _err("INVALID_PARAMETER", "business_domain_keyword must be a string") if sort_by not in {"name", "storage_gb", "table_count", "updated_at"} or sort_order not in {"asc", "desc"}: return _err("INVALID_PARAMETER", "invalid sorting parameter") if owner_user_id and not (_user(state_manager, owner_user_id) and _user(state_manager, owner_user_id)["org_id"] == org_id): return _err("USER_NOT_FOUND", "owner user not found in organization") rows = [d for d in _all(state_manager, "dataset") if d["org_id"] == org_id] for key, value in [("status", status), ("classification", classification), ("region", region), ("owner_user_id", owner_user_id)]: if value: rows = [d for d in rows if d.get(key) == value] if business_domain_keyword: rows = [d for d in rows if business_domain_keyword.lower() in d["business_domain"].lower()] rows = _sort(rows, sort_by, sort_order, "dataset_id") page = _page(rows, offset, limit) if page is None: return _err("OUT_OF_RANGE", "pagination bounds are invalid") fields = ["dataset_id", "name", "business_domain", "classification", "status", "owner_user_id", "storage_gb", "table_count"] return success_response({"total_count": len(rows), "offset": offset, "limit": limit, "datasets": [{k: r.get(k) for k in fields} for r in page]}) def list_tables(*, state_manager, dataset_id=None, status=None, table_type=None, has_partition=None, min_size_gb=0, sort_by="name", sort_order="asc", offset=0, limit=25, **kwargs): if not dataset_id: return _err("MISSING_DATASET_ID", "dataset_id is required") if _dataset(state_manager, dataset_id) is None: return _err("DATASET_NOT_FOUND", "dataset not found") if status is not None and status not in {"active", "archived", "deprecated"}: return _err("INVALID_PARAMETER", "invalid status") if table_type is not None and table_type not in TABLE_TYPES: return _err("INVALID_PARAMETER", "invalid table_type") if has_partition is not None and not isinstance(has_partition, bool): return _err("INVALID_PARAMETER", "has_partition must be boolean") if not isinstance(min_size_gb, (int, float)) or min_size_gb < 0: return _err("OUT_OF_RANGE", "min_size_gb is invalid") if sort_by not in {"name", "row_count", "size_gb", "last_loaded_at", "updated_at"} or sort_order not in {"asc", "desc"}: return _err("INVALID_PARAMETER", "invalid sorting parameter") rows = [t for t in _all(state_manager, "table") if t["dataset_id"] == dataset_id and float(t.get("size_gb") or 0) >= min_size_gb] if status: rows = [t for t in rows if t["status"] == status] if table_type: rows = [t for t in rows if t["table_type"] == table_type] if has_partition is not None: rows = [t for t in rows if bool(t.get("partition_key")) is has_partition] rows = _sort(rows, sort_by, sort_order, "table_id") page = _page(rows, offset, limit) if page is None: return _err("OUT_OF_RANGE", "pagination bounds are invalid") fields = ["table_id", "name", "table_type", "status", "row_count", "size_gb", "column_count", "partition_key", "last_loaded_at"] return success_response({"total_count": len(rows), "offset": offset, "limit": limit, "tables": [{k: r.get(k) for k in fields} for r in page]}) def list_columns(*, state_manager, table_id=None, sensitivity=None, data_type=None, is_masked=None, sort_order="asc", **kwargs): if not table_id: return _err("MISSING_TABLE_ID", "table_id is required") if _table(state_manager, table_id) is None: return _err("TABLE_NOT_FOUND", "table not found") if sensitivity is not None and sensitivity not in SENSITIVITIES: return _err("INVALID_PARAMETER", "invalid sensitivity") if data_type is not None and data_type not in COLUMN_TYPES: return _err("INVALID_PARAMETER", "invalid data_type") if is_masked is not None and not isinstance(is_masked, bool): return _err("INVALID_PARAMETER", "is_masked must be boolean") if sort_order not in {"asc", "desc"}: return _err("INVALID_PARAMETER", "invalid sort_order") rows = _columns_for_table(state_manager, table_id) if sensitivity: rows = [c for c in rows if c["sensitivity"] == sensitivity] if data_type: rows = [c for c in rows if c["data_type"] == data_type] if is_masked is not None: rows = [c for c in rows if c["is_masked"] is is_masked] rows = sorted(rows, key=lambda c: c["ordinal"], reverse=sort_order == "desc") fields = ["column_id", "name", "data_type", "ordinal", "nullable", "is_masked", "sensitivity", "description"] return success_response({"total_count": len(rows), "columns": [{k: r.get(k) for k in fields} for r in rows]}) def list_access_grants(*, state_manager, org_id=None, dataset_id=None, user_id=None, role=None, scope=None, status=None, offset=0, limit=25, **kwargs): if not org_id: return _err("MISSING_ORG_ID", "org_id is required") if _org(state_manager, org_id) is None: return _err("ORG_NOT_FOUND", "organization not found") if role is not None and role not in GRANT_ROLES: return _err("INVALID_PARAMETER", "invalid role") if scope is not None and scope not in GRANT_SCOPES: return _err("INVALID_PARAMETER", "invalid scope") if status is not None and status not in {"active", "revoked", "expired"}: return _err("INVALID_PARAMETER", "invalid status") if dataset_id and not (_dataset(state_manager, dataset_id) and _dataset(state_manager, dataset_id)["org_id"] == org_id): return _err("DATASET_NOT_FOUND", "dataset not found in organization") if user_id and not (_user(state_manager, user_id) and _user(state_manager, user_id)["org_id"] == org_id): return _err("USER_NOT_FOUND", "user not found in organization") page_probe = _page([], offset, limit) if page_probe is None: return _err("OUT_OF_RANGE", "pagination bounds are invalid") rows = [g for g in _all(state_manager, "access_grant") if g["org_id"] == org_id] for key, value in [("dataset_id", dataset_id), ("user_id", user_id), ("role", role), ("scope", scope), ("status", status)]: if value: rows = [g for g in rows if g.get(key) == value] rows = sorted(rows, key=lambda g: (g.get("updated_at"), g.get("grant_id")), reverse=True) page = rows[offset: offset + limit] fields = ["grant_id", "dataset_id", "table_id", "user_id", "role", "scope", "status", "expires_at"] return success_response({"total_count": len(rows), "offset": offset, "limit": limit, "grants": [{k: r.get(k) for k in fields} for r in page]}) def search_query_jobs(*, state_manager, org_id=None, status=None, priority=None, warehouse_id=None, referenced_table_id=None, submitted_after=None, submitted_before=None, max_estimated_cost_usd=None, sort_by="submitted_at", sort_order="desc", offset=0, limit=25, **kwargs): if not org_id: return _err("MISSING_ORG_ID", "org_id is required") if _org(state_manager, org_id) is None: return _err("ORG_NOT_FOUND", "organization not found") if status is not None and status not in QUERY_STATUSES: return _err("INVALID_PARAMETER", "invalid status") if priority is not None and priority not in PRIORITIES: return _err("INVALID_PARAMETER", "invalid priority") if sort_by not in {"submitted_at", "estimated_cost_usd", "bytes_scanned_gb", "latency_ms"} or sort_order not in {"asc", "desc"}: return _err("INVALID_PARAMETER", "invalid sorting parameter") if not _valid_datetime_window(submitted_after, submitted_before): return _err("INVALID_PARAMETER", "invalid submitted time window") if max_estimated_cost_usd is not None and (not isinstance(max_estimated_cost_usd, (int, float)) or max_estimated_cost_usd < 0): return _err("OUT_OF_RANGE", "max_estimated_cost_usd is invalid") if warehouse_id and not (_warehouse(state_manager, warehouse_id) and _warehouse(state_manager, warehouse_id)["org_id"] == org_id): return _err("WAREHOUSE_NOT_FOUND", "warehouse not found in organization") if referenced_table_id and not (_table(state_manager, referenced_table_id) and _table(state_manager, referenced_table_id)["org_id"] == org_id): return _err("TABLE_NOT_FOUND", "referenced table not found in organization") rows = [q for q in _all(state_manager, "query_job") if q["org_id"] == org_id] for key, value in [("status", status), ("priority", priority), ("warehouse_id", warehouse_id)]: if value: rows = [q for q in rows if q.get(key) == value] if referenced_table_id: rows = [q for q in rows if referenced_table_id in q.get("referenced_table_ids", [])] if submitted_after: rows = [q for q in rows if q.get("submitted_at") >= submitted_after] if submitted_before: rows = [q for q in rows if q.get("submitted_at") <= submitted_before] if max_estimated_cost_usd is not None: rows = [q for q in rows if float(q.get("estimated_cost_usd") or 0) <= max_estimated_cost_usd] rows = _sort(rows, sort_by, sort_order, "query_job_id") page = _page(rows, offset, limit) if page is None: return _err("OUT_OF_RANGE", "pagination bounds are invalid") fields = ["query_job_id", "warehouse_id", "status", "priority", "bytes_scanned_gb", "credits_consumed", "estimated_cost_usd", "submitted_at", "error_message"] return success_response({"total_count": len(rows), "offset": offset, "limit": limit, "query_jobs": [{k: r.get(k) for k in fields} for r in page]}) def list_transfer_jobs(*, state_manager, org_id=None, job_type="both", status=None, table_id=None, format=None, scheduled_after=None, scheduled_before=None, sort_order="desc", offset=0, limit=25, **kwargs): if not org_id: return _err("MISSING_ORG_ID", "org_id is required") if _org(state_manager, org_id) is None: return _err("ORG_NOT_FOUND", "organization not found") if job_type not in {"import", "export", "both"}: return _err("INVALID_PARAMETER", "invalid job_type") if status is not None and status not in QUERY_STATUSES: return _err("INVALID_PARAMETER", "invalid status") if format is not None and format not in TRANSFER_FORMATS: return _err("INVALID_PARAMETER", "invalid format") if sort_order not in {"asc", "desc"} or not _valid_datetime_window(scheduled_after, scheduled_before): return _err("INVALID_PARAMETER", "invalid sort_order or time window") if table_id and not (_table(state_manager, table_id) and _table(state_manager, table_id)["org_id"] == org_id): return _err("TABLE_NOT_FOUND", "table not found in organization") rows = [] if job_type in {"import", "both"}: for job in _all(state_manager, "import_job"): if job["org_id"] == org_id: rows.append({"job_type": "import", "job_id": job["import_job_id"], "table_id": job["target_table_id"], "warehouse_id": job["warehouse_id"], "status": job["status"], "format": job["source_format"], "scheduled_at": job["scheduled_at"], "row_count": job.get("rows_loaded", 0), "bytes_gb": job.get("bytes_loaded_gb", 0)}) if job_type in {"export", "both"}: for job in _all(state_manager, "export_job"): if job["org_id"] == org_id: rows.append({"job_type": "export", "job_id": job["export_job_id"], "table_id": job["source_table_id"], "warehouse_id": job["warehouse_id"], "status": job["status"], "format": job["format"], "scheduled_at": job["scheduled_at"], "row_count": job.get("row_count", 0), "bytes_gb": job.get("bytes_exported_gb", 0)}) if status: rows = [r for r in rows if r["status"] == status] if table_id: rows = [r for r in rows if r["table_id"] == table_id] if format: rows = [r for r in rows if r["format"] == format] if scheduled_after: rows = [r for r in rows if r["scheduled_at"] >= scheduled_after] if scheduled_before: rows = [r for r in rows if r["scheduled_at"] <= scheduled_before] rows = sorted(rows, key=lambda r: (r["scheduled_at"], r["job_id"]), reverse=sort_order == "desc") page = _page(rows, offset, limit) if page is None: return _err("OUT_OF_RANGE", "pagination bounds are invalid") return success_response({"total_count": len(rows), "offset": offset, "limit": limit, "transfer_jobs": page}) def inspect_cost_usage(*, state_manager, org_id=None, usage_type=None, warehouse_id=None, dataset_id=None, usage_date_start=None, usage_date_end=None, group_by="none", offset=0, limit=50, **kwargs): if not org_id: return _err("MISSING_ORG_ID", "org_id is required") if _org(state_manager, org_id) is None: return _err("ORG_NOT_FOUND", "organization not found") if usage_type is not None and usage_type not in {"compute", "query", "import", "export", "storage"}: return _err("INVALID_PARAMETER", "invalid usage_type") if group_by not in {"none", "usage_type", "warehouse", "dataset", "day"} or not _valid_date_window(usage_date_start, usage_date_end): return _err("INVALID_PARAMETER", "invalid group_by or date window") if warehouse_id and not (_warehouse(state_manager, warehouse_id) and _warehouse(state_manager, warehouse_id)["org_id"] == org_id): return _err("WAREHOUSE_NOT_FOUND", "warehouse not found in organization") if dataset_id and not (_dataset(state_manager, dataset_id) and _dataset(state_manager, dataset_id)["org_id"] == org_id): return _err("DATASET_NOT_FOUND", "dataset not found in organization") rows = [r for r in _all(state_manager, "cost_usage_record") if r["org_id"] == org_id] for key, value in [("usage_type", usage_type), ("warehouse_id", warehouse_id), ("dataset_id", dataset_id)]: if value: rows = [r for r in rows if r.get(key) == value] if usage_date_start: rows = [r for r in rows if r["usage_date"] >= usage_date_start] if usage_date_end: rows = [r for r in rows if r["usage_date"] <= usage_date_end] summary = {"total_credits": round(sum(float(r.get("credits") or 0) for r in rows), 3), "total_cost_usd": round(sum(float(r.get("cost_usd") or 0) for r in rows), 2), "record_count": len(rows)} if group_by != "none": key_field = {"usage_type": "usage_type", "warehouse": "warehouse_id", "dataset": "dataset_id", "day": "usage_date"}[group_by] groups = {} for row in rows: key = row.get(key_field) or "unassigned" groups.setdefault(key, {"group_key": key, "credits": 0.0, "cost_usd": 0.0, "record_count": 0}) groups[key]["credits"] += float(row.get("credits") or 0) groups[key]["cost_usd"] += float(row.get("cost_usd") or 0) groups[key]["record_count"] += 1 result = [{**g, "credits": round(g["credits"], 3), "cost_usd": round(g["cost_usd"], 2)} for g in groups.values()] return success_response({"summary": summary, "groups": sorted(result, key=lambda g: str(g["group_key"]))}) rows = sorted(rows, key=lambda r: (r["usage_date"], r["usage_id"])) page = _page(rows, offset, limit, max_limit=200) if page is None: return _err("OUT_OF_RANGE", "pagination bounds are invalid") return success_response({"summary": summary, "offset": offset, "limit": limit, "usage_records": page}) def list_quota_policies(*, state_manager, org_id=None, resource_group=None, warehouse_id=None, enforcement_mode=None, status=None, offset=0, limit=25, **kwargs): if not org_id: return _err("MISSING_ORG_ID", "org_id is required") if _org(state_manager, org_id) is None: return _err("ORG_NOT_FOUND", "organization not found") if resource_group is not None and resource_group not in RESOURCE_GROUPS: return _err("INVALID_PARAMETER", "invalid resource_group") if enforcement_mode is not None and enforcement_mode not in ENFORCEMENT_MODES: return _err("INVALID_PARAMETER", "invalid enforcement_mode") if status is not None and status not in QUOTA_STATUSES: return _err("INVALID_PARAMETER", "invalid status") if warehouse_id and not (_warehouse(state_manager, warehouse_id) and _warehouse(state_manager, warehouse_id)["org_id"] == org_id): return _err("WAREHOUSE_NOT_FOUND", "warehouse not found in organization") rows = [q for q in _all(state_manager, "quota_policy") if q["org_id"] == org_id] for key, value in [("resource_group", resource_group), ("warehouse_id", warehouse_id), ("enforcement_mode", enforcement_mode), ("status", status)]: if value: rows = [q for q in rows if q.get(key) == value] rows = sorted(rows, key=lambda q: (q["resource_group"], q.get("warehouse_id") or "", q["quota_id"])) page = _page(rows, offset, limit) if page is None: return _err("OUT_OF_RANGE", "pagination bounds are invalid") fields = ["quota_id", "warehouse_id", "resource_group", "monthly_credit_limit", "daily_query_limit", "current_month_credits", "enforcement_mode", "status"] return success_response({"total_count": len(rows), "offset": offset, "limit": limit, "quota_policies": [{k: r.get(k) for k in fields} for r in page]}) def create_dataset(*, state_manager, org_id=None, name=None, business_domain=None, region=None, classification=None, retention_days=None, owner_user_id=None, **kwargs): missing = _required(locals(), ["org_id", "name", "business_domain", "region", "classification", "retention_days", "owner_user_id"]) if missing: return missing if region not in REGIONS or classification not in DATASET_CLASSIFICATIONS or not isinstance(name, str) or not isinstance(business_domain, str): return _err("INVALID_PARAMETER", "invalid dataset parameter") if not isinstance(retention_days, int) or not (1 <= retention_days <= 3650): return _err("OUT_OF_RANGE", "retention_days is outside the allowed range") org = _org(state_manager, org_id) if not org: return _err("ORG_NOT_FOUND", "organization not found") if org["status"] == "suspended": return _err("ORG_NOT_ACTIVE", "organization is suspended") owner = _user(state_manager, owner_user_id) if not owner or owner["org_id"] != org_id: return _err("USER_NOT_FOUND", "owner user not found in organization") if owner["status"] != "active": return _err("USER_NOT_ACTIVE", "owner user is not active") dataset_id = build_humanized_id("dataset", {"org_id": org_id, "business_domain": business_domain}, existing_ids=[]) if _dataset(state_manager, dataset_id): return _err("DUPLICATE_DATASET", "derived dataset id already exists") row = {"dataset_id": dataset_id, "org_id": org_id, "name": name.strip(), "business_domain": business_domain.strip(), "region": region, "classification": classification, "retention_days": retention_days, "storage_gb": 0.0, "table_count": 0, "owner_user_id": owner_user_id, "status": "active", "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("dataset", row) return success_response({"dataset": row}) def update_dataset_status(*, state_manager, dataset_id=None, new_status=None, reason=None, **kwargs): if not dataset_id or not new_status: return _err("MISSING_FIELD", "dataset_id and new_status are required") if new_status not in {"active", "archived"} or (reason is not None and not isinstance(reason, str)): return _err("INVALID_PARAMETER", "invalid status or reason") dataset = _dataset(state_manager, dataset_id) if not dataset: return _err("DATASET_NOT_FOUND", "dataset not found") previous = dataset["status"] changed = previous != new_status if changed: dataset["status"] = new_status dataset["updated_at"] = now_iso() _save(state_manager, "dataset", dataset) return success_response({"dataset_id": dataset_id, "previous_status": previous, "new_status": new_status, "changed": changed, "reason": reason, "dataset": dataset}) def create_table(*, state_manager, dataset_id=None, name=None, table_type=None, columns=None, partition_key=None, cluster_keys=None, initial_row_count=0, initial_size_gb=0, **kwargs): if not dataset_id or not name or not table_type or columns is None: return _err("MISSING_FIELD", "dataset_id, name, table_type, and columns are required") dataset = _dataset(state_manager, dataset_id) if not dataset: return _err("DATASET_NOT_FOUND", "dataset not found") if dataset["status"] != "active": return _err("DATASET_NOT_ACTIVE", "dataset is archived") if table_type not in TABLE_TYPES or not isinstance(columns, list): return _err("INVALID_PARAMETER", "invalid table_type or columns") if not (1 <= len(columns) <= 400) or not isinstance(initial_row_count, int) or initial_row_count < 0 or not isinstance(initial_size_gb, (int, float)) or initial_size_gb < 0: return _err("OUT_OF_RANGE", "column count or initial size is out of range") col_names = [] for col in columns: if not isinstance(col, dict) or not all(col.get(k) is not None for k in ["name", "data_type", "nullable", "sensitivity"]): return _err("MISSING_FIELD", "each column must include name, data_type, nullable, and sensitivity") if col["data_type"] not in COLUMN_TYPES or col["sensitivity"] not in SENSITIVITIES or not isinstance(col.get("nullable"), bool): return _err("INVALID_PARAMETER", "invalid column definition") col_names.append(col["name"]) if len(set(col_names)) != len(col_names): return _err("DUPLICATE_COLUMN", "column names must be unique") cluster_keys = cluster_keys or [] if partition_key and partition_key not in col_names: return _err("COLUMN_REFERENCE_NOT_FOUND", "partition_key is not a provided column") if not isinstance(cluster_keys, list) or any(key not in col_names for key in cluster_keys): return _err("COLUMN_REFERENCE_NOT_FOUND", "cluster key is not a provided column") table_id = build_humanized_id("table", {"dataset_id": dataset_id, "name": name}, existing_ids=[t["table_id"] for t in _all(state_manager, "table")]) if _table(state_manager, table_id): return _err("DUPLICATE_TABLE", "derived table id already exists") table = {"table_id": table_id, "org_id": dataset["org_id"], "dataset_id": dataset_id, "name": name.strip(), "table_type": table_type, "status": "active", "row_count": initial_row_count, "size_gb": round(float(initial_size_gb), 3), "column_count": len(columns), "partition_key": partition_key, "cluster_keys": cluster_keys, "retention_until": None, "last_loaded_at": now_iso(), "created_at": now_iso(), "updated_at": now_iso()} created_columns = [] for idx, col in enumerate(columns, start=1): column_id = f"col-{table_id[4:]}-{idx:02d}-{slugify(col['name'])}" column = {"column_id": column_id, "org_id": dataset["org_id"], "dataset_id": dataset_id, "table_id": table_id, "name": col["name"], "data_type": col["data_type"], "ordinal": idx, "nullable": col["nullable"], "is_masked": bool(col.get("is_masked", False)), "sensitivity": col["sensitivity"], "description": col.get("description") or f"{col['name']} for {name} analytics.", "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("column", column) created_columns.append(column) state_manager.add_entity("table", table) dataset["table_count"] = int(dataset.get("table_count") or 0) + 1 dataset["storage_gb"] = round(float(dataset.get("storage_gb") or 0) + float(initial_size_gb), 3) dataset["updated_at"] = now_iso() _save(state_manager, "dataset", dataset) return success_response({"table": table, "columns": created_columns}) def update_table_metadata(*, state_manager, table_id=None, name=None, table_type=None, status=None, row_count=None, size_gb=None, partition_key=None, cluster_keys=None, **kwargs): if not table_id: return _err("MISSING_TABLE_ID", "table_id is required") table = _table(state_manager, table_id) if not table: return _err("TABLE_NOT_FOUND", "table not found") provided = {k: v for k, v in {"name": name, "table_type": table_type, "status": status, "row_count": row_count, "size_gb": size_gb, "partition_key": partition_key, "cluster_keys": cluster_keys}.items() if v is not None} if not provided: return _err("NO_MUTABLE_FIELDS", "no mutable field was provided") if table["status"] == "archived": return _err("TABLE_ARCHIVED", "archived tables cannot be updated") if table_type is not None and table_type not in TABLE_TYPES: return _err("INVALID_PARAMETER", "invalid table_type") if status is not None and status not in {"active", "deprecated"}: return _err("INVALID_PARAMETER", "invalid status") if row_count is not None and (not isinstance(row_count, int) or row_count < 0): return _err("OUT_OF_RANGE", "row_count is invalid") if size_gb is not None and (not isinstance(size_gb, (int, float)) or size_gb < 0): return _err("OUT_OF_RANGE", "size_gb is invalid") col_names = {c["name"] for c in _columns_for_table(state_manager, table_id)} if partition_key is not None and partition_key not in col_names: return _err("COLUMN_REFERENCE_NOT_FOUND", "partition_key is not a table column") if cluster_keys is not None and (not isinstance(cluster_keys, list) or any(key not in col_names for key in cluster_keys)): return _err("COLUMN_REFERENCE_NOT_FOUND", "cluster key is not a table column") previous_size = float(table.get("size_gb") or 0) changed_fields = [] for key, value in provided.items(): if table.get(key) != value: table[key] = value changed_fields.append(key) table["updated_at"] = now_iso() _save(state_manager, "table", table) if size_gb is not None: dataset = _dataset(state_manager, table["dataset_id"]) if dataset: dataset["storage_gb"] = round(float(dataset.get("storage_gb") or 0) + float(size_gb) - previous_size, 3) dataset["updated_at"] = now_iso() _save(state_manager, "dataset", dataset) return success_response({"table_id": table_id, "changed_fields": changed_fields, "previous_size_gb": previous_size, "new_size_gb": table.get("size_gb"), "table": table}) def archive_table(*, state_manager, table_id=None, retention_until=None, reason=None, **kwargs): if not table_id or not retention_until: return _err("MISSING_FIELD", "table_id and retention_until are required") if not is_iso_datetime(retention_until) or not datetime_gt(retention_until, now_iso()) or (reason is not None and not isinstance(reason, str)): return _err("RETENTION_PRECONDITION_FAILED" if isinstance(retention_until, str) else "INVALID_PARAMETER", "retention deadline must be in the future") table = _table(state_manager, table_id) if not table: return _err("TABLE_NOT_FOUND", "table not found") if table["status"] == "archived": return _err("TABLE_ALREADY_ARCHIVED", "table is already archived") previous = table["status"] table["status"] = "archived" table["retention_until"] = retention_until table["updated_at"] = now_iso() _save(state_manager, "table", table) return success_response({"table_id": table_id, "previous_status": previous, "status": "archived", "retention_until": retention_until, "reason": reason, "table": table}) def submit_sql_query(*, state_manager, org_id=None, user_id=None, warehouse_id=None, sql_text=None, referenced_table_ids=None, priority="normal", max_billed_gb=1000, execution_mode="queued", **kwargs): missing = _required(locals(), ["org_id", "user_id", "warehouse_id", "sql_text", "referenced_table_ids"]) if missing: return missing if priority not in PRIORITIES or execution_mode not in {"queued", "run_now"} or not isinstance(referenced_table_ids, list) or not referenced_table_ids or not isinstance(sql_text, str) or "select" not in sql_text.lower(): return _err("INVALID_PARAMETER", "invalid SQL submission parameter") if not isinstance(max_billed_gb, (int, float)) or max_billed_gb <= 0: return _err("INVALID_PARAMETER", "max_billed_gb must be positive") org = _org(state_manager, org_id) if not org: return _err("ORG_NOT_FOUND", "organization not found") if org["status"] == "suspended": return _err("ORG_NOT_ACTIVE", "organization is suspended") user = _user(state_manager, user_id) if not user or user["org_id"] != org_id: return _err("USER_NOT_FOUND", "user not found in organization") if user["status"] != "active": return _err("USER_NOT_ACTIVE", "user is not active") warehouse = _warehouse(state_manager, warehouse_id) if not warehouse or warehouse["org_id"] != org_id: return _err("WAREHOUSE_NOT_FOUND", "warehouse not found in organization") if warehouse["status"] != "active": return _err("WAREHOUSE_NOT_ACTIVE", "warehouse is not active") tables = [] dataset_ids = [] for table_id in referenced_table_ids: table = _table(state_manager, table_id) if not table or table["org_id"] != org_id: return _err("TABLE_NOT_FOUND", "referenced table not found") if table["status"] != "active": return _err("TABLE_NOT_QUERYABLE", "referenced table is not active") tables.append(table) dataset_ids.append(table["dataset_id"]) scanned, credits, cost = _estimate_query(tables) if scanned > max_billed_gb: return _err("COST_LIMIT_EXCEEDED", "estimated scan size exceeds max_billed_gb") for policy in _all(state_manager, "quota_policy"): if policy["org_id"] == org_id and policy["status"] == "active" and policy["enforcement_mode"] == "block" and policy["resource_group"] == warehouse["resource_group"]: if float(policy["current_month_credits"]) + credits > float(policy["monthly_credit_limit"]) or int(policy["current_day_query_count"]) + 1 > int(policy["daily_query_limit"]): return _err("QUOTA_POLICY_BLOCKED", "active block-mode quota would be exceeded") status = "running" if execution_mode == "run_now" and int(warehouse.get("running_queries") or 0) < int(warehouse.get("max_concurrency") or 1) else "queued" job_id = _new_time_id(state_manager, "query_job", org_id, "interactive-query") job = {"query_job_id": job_id, "org_id": org_id, "user_id": user_id, "warehouse_id": warehouse_id, "dataset_ids": sorted(set(dataset_ids)), "referenced_table_ids": referenced_table_ids, "destination_table_id": None, "sql_text": sql_text.strip(), "status": status, "priority": priority, "bytes_scanned_gb": scanned, "credits_consumed": credits, "estimated_cost_usd": cost, "result_row_count": 0, "latency_ms": None, "error_message": None, "submitted_at": now_iso(), "started_at": now_iso() if status == "running" else None, "completed_at": None, "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("query_job", job) counter = "running_queries" if status == "running" else "queued_queries" warehouse[counter] = int(warehouse.get(counter) or 0) + 1 if status == "running": warehouse["credits_used_today"] = round(float(warehouse.get("credits_used_today") or 0) + credits, 3) usage = {"usage_id": _new_usage_id(state_manager, org_id, "2026-06-01", warehouse["resource_group"], "query"), "org_id": org_id, "warehouse_id": warehouse_id, "dataset_id": None, "query_job_id": job_id, "import_job_id": None, "export_job_id": None, "usage_type": "query", "usage_date": "2026-06-01", "credits": credits, "cost_usd": cost, "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("cost_usage_record", usage) _save(state_manager, "warehouse", warehouse) for policy in _all(state_manager, "quota_policy"): if policy["org_id"] == org_id and policy["status"] == "active" and policy["resource_group"] == warehouse["resource_group"]: policy["current_day_query_count"] = int(policy.get("current_day_query_count") or 0) + 1 policy["updated_at"] = now_iso() _save(state_manager, "quota_policy", policy) return success_response({"query_job": job, "quota_snapshot": {"resource_group": warehouse["resource_group"], "incremented": True}}) def cancel_query_job(*, state_manager, query_job_id=None, canceled_by_user_id=None, reason=None, **kwargs): if not query_job_id or not canceled_by_user_id: return _err("MISSING_FIELD", "query_job_id and canceled_by_user_id are required") query = _query(state_manager, query_job_id) if not query: return _err("QUERY_NOT_FOUND", "query job not found") user = _user(state_manager, canceled_by_user_id) if not user or user["org_id"] != query["org_id"]: return _err("USER_NOT_FOUND", "canceling user not found in query organization") if user["status"] != "active": return _err("USER_NOT_ACTIVE", "canceling user is not active") if query["status"] not in {"queued", "running"}: return _err("QUERY_NOT_CANCELABLE", "query status is not queued or running") if reason is not None and not isinstance(reason, str): return _err("INVALID_PARAMETER", "reason must be a string") previous = query["status"] query["status"] = "canceled" query["completed_at"] = now_iso() query["updated_at"] = now_iso() query["error_message"] = f"Canceled by {canceled_by_user_id}: {reason or 'No reason supplied'}" _save(state_manager, "query_job", query) warehouse = _warehouse(state_manager, query["warehouse_id"]) if warehouse: key = "running_queries" if previous == "running" else "queued_queries" warehouse[key] = max(0, int(warehouse.get(key) or 0) - 1) _save(state_manager, "warehouse", warehouse) return success_response({"query_job_id": query_job_id, "previous_status": previous, "status": "canceled", "canceled_by_user_id": canceled_by_user_id, "reason": reason, "query_job": query}) def retry_query_job(*, state_manager, query_job_id=None, warehouse_id=None, priority=None, **kwargs): if not query_job_id: return _err("MISSING_QUERY_JOB_ID", "query_job_id is required") original = _query(state_manager, query_job_id) if not original: return _err("QUERY_NOT_FOUND", "original query job not found") if priority is not None and priority not in PRIORITIES: return _err("INVALID_PARAMETER", "invalid priority") if original["status"] != "failed": return _err("QUERY_NOT_FAILED", "original query status is not failed") wh = _warehouse(state_manager, warehouse_id or original["warehouse_id"]) if not wh or wh["org_id"] != original["org_id"]: return _err("WAREHOUSE_NOT_FOUND", "replacement warehouse not found") if wh["status"] != "active": return _err("WAREHOUSE_NOT_ACTIVE", "replacement warehouse is not active") tables = [] for table_id in original.get("referenced_table_ids", []): table = _table(state_manager, table_id) if not table or table["status"] != "active": return _err("TABLE_NOT_QUERYABLE", "original referenced table is no longer active") tables.append(table) scanned, credits, cost = _estimate_query(tables) job_id = _new_time_id(state_manager, "query_job", original["org_id"], "retry-query") job = dict(original) job.update({"query_job_id": job_id, "warehouse_id": wh["warehouse_id"], "status": "queued", "priority": priority or original["priority"], "bytes_scanned_gb": scanned, "credits_consumed": credits, "estimated_cost_usd": cost, "error_message": None, "submitted_at": now_iso(), "started_at": None, "completed_at": None, "created_at": now_iso(), "updated_at": now_iso()}) state_manager.add_entity("query_job", job) wh["queued_queries"] = int(wh.get("queued_queries") or 0) + 1 _save(state_manager, "warehouse", wh) return success_response({"original_query_job_id": query_job_id, "retry_query_job": job}) def bulk_import_table(*, state_manager, target_table_id=None, warehouse_id=None, requested_by_user_id=None, source_uri=None, source_format=None, mode=None, scheduled_at=None, **kwargs): missing = _required(locals(), ["target_table_id", "warehouse_id", "requested_by_user_id", "source_uri", "source_format", "mode"]) if missing: return missing if source_format not in TRANSFER_FORMATS or mode not in {"append", "replace", "merge"} or (scheduled_at is not None and not is_iso_datetime(scheduled_at)): return _err("INVALID_PARAMETER", "invalid import parameter") table = _table(state_manager, target_table_id) if not table: return _err("TABLE_NOT_FOUND", "target table not found") dataset = _dataset(state_manager, table["dataset_id"]) if not dataset or dataset["status"] != "active": return _err("DATASET_NOT_ACTIVE", "target dataset is archived") if table["status"] != "active": return _err("TABLE_NOT_ACTIVE", "target table is not active") warehouse = _warehouse(state_manager, warehouse_id) if not warehouse or warehouse["org_id"] != table["org_id"]: return _err("WAREHOUSE_NOT_FOUND", "warehouse not found in organization") if warehouse["status"] != "active": return _err("WAREHOUSE_NOT_ACTIVE", "warehouse is not active") user = _user(state_manager, requested_by_user_id) if not user or user["org_id"] != table["org_id"]: return _err("USER_NOT_FOUND", "requesting user not found in organization") if user["status"] != "active": return _err("USER_NOT_ACTIVE", "requesting user is not active") if not _has_role_access(state_manager, dataset["dataset_id"], requested_by_user_id, {"writer", "admin", "owner"}, target_table_id): return _err("PERMISSION_DENIED", "user lacks write access") if not isinstance(source_uri, str) or not source_uri.startswith(ALLOWED_STORAGE_SCHEMES) or org_slug(table["org_id"]) not in source_uri: return _err("INVALID_PARAMETER", "source_uri must be an organization storage URI") job_id = _new_time_id(state_manager, "import_job", table["org_id"], table["name"]) job = {"import_job_id": job_id, "org_id": table["org_id"], "dataset_id": table["dataset_id"], "target_table_id": target_table_id, "warehouse_id": warehouse_id, "requested_by_user_id": requested_by_user_id, "source_uri": source_uri, "source_format": source_format, "mode": mode, "status": "queued", "bytes_loaded_gb": 0.0, "rows_loaded": 0, "error_message": None, "scheduled_at": scheduled_at or now_iso(), "completed_at": None, "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("import_job", job) warehouse["queued_queries"] = int(warehouse.get("queued_queries") or 0) + 1 _save(state_manager, "warehouse", warehouse) return success_response({"import_job": job}) def create_export_job(*, state_manager, source_table_id=None, warehouse_id=None, requested_by_user_id=None, destination_uri=None, format=None, compression="none", expires_at=None, scheduled_at=None, **kwargs): missing = _required(locals(), ["source_table_id", "warehouse_id", "requested_by_user_id", "destination_uri", "format", "expires_at"]) if missing: return missing scheduled_at = scheduled_at or now_iso() if format not in EXPORT_FORMATS or compression not in {"none", "gzip", "zstd"} or not is_iso_datetime(scheduled_at) or not is_iso_datetime(expires_at): return _err("INVALID_PARAMETER", "invalid export parameter") if not datetime_gt(expires_at, scheduled_at): return _err("EXPIRATION_PRECONDITION_FAILED", "expires_at must be later than scheduled_at") table = _table(state_manager, source_table_id) if not table: return _err("TABLE_NOT_FOUND", "source table not found") dataset = _dataset(state_manager, table["dataset_id"]) if not dataset or dataset["status"] != "active": return _err("DATASET_NOT_ACTIVE", "source dataset is archived") if table["status"] != "active": return _err("TABLE_NOT_ACTIVE", "source table is not active") warehouse = _warehouse(state_manager, warehouse_id) if not warehouse or warehouse["org_id"] != table["org_id"]: return _err("WAREHOUSE_NOT_FOUND", "warehouse not found in organization") if warehouse["status"] != "active": return _err("WAREHOUSE_NOT_ACTIVE", "warehouse is not active") user = _user(state_manager, requested_by_user_id) if not user or user["org_id"] != table["org_id"]: return _err("USER_NOT_FOUND", "requesting user not found in organization") if user["status"] != "active": return _err("USER_NOT_ACTIVE", "requesting user is not active") if not _has_role_access(state_manager, dataset["dataset_id"], requested_by_user_id, {"reader", "writer", "admin", "owner"}, source_table_id): return _err("PERMISSION_DENIED", "user lacks read access") if not isinstance(destination_uri, str) or not destination_uri.startswith(ALLOWED_STORAGE_SCHEMES) or org_slug(table["org_id"]) not in destination_uri: return _err("INVALID_PARAMETER", "destination_uri must be an organization storage URI") job_id = _new_time_id(state_manager, "export_job", table["org_id"], table["name"]) job = {"export_job_id": job_id, "org_id": table["org_id"], "source_table_id": source_table_id, "warehouse_id": warehouse_id, "requested_by_user_id": requested_by_user_id, "destination_uri": destination_uri, "format": format, "compression": compression, "status": "queued", "row_count": 0, "bytes_exported_gb": 0.0, "scheduled_at": scheduled_at, "completed_at": None, "expires_at": expires_at, "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("export_job", job) warehouse["queued_queries"] = int(warehouse.get("queued_queries") or 0) + 1 _save(state_manager, "warehouse", warehouse) return success_response({"export_job": job}) def update_warehouse_capacity(*, state_manager, warehouse_id=None, size=None, max_concurrency=None, auto_suspend_minutes=None, daily_credit_limit=None, status=None, **kwargs): if not warehouse_id: return _err("MISSING_WAREHOUSE_ID", "warehouse_id is required") warehouse = _warehouse(state_manager, warehouse_id) if not warehouse: return _err("WAREHOUSE_NOT_FOUND", "warehouse not found") provided = {k: v for k, v in {"size": size, "max_concurrency": max_concurrency, "auto_suspend_minutes": auto_suspend_minutes, "daily_credit_limit": daily_credit_limit, "status": status}.items() if v is not None} if not provided: return _err("NO_MUTABLE_FIELDS", "no mutable field was provided") if size is not None and size not in WAREHOUSE_SIZES: return _err("INVALID_PARAMETER", "invalid size") if status is not None and status not in {"active", "suspended", "resizing"}: return _err("INVALID_PARAMETER", "invalid status") if max_concurrency is not None and (not isinstance(max_concurrency, int) or not (1 <= max_concurrency <= 200)): return _err("OUT_OF_RANGE", "max_concurrency is invalid") if auto_suspend_minutes is not None and (not isinstance(auto_suspend_minutes, int) or not (1 <= auto_suspend_minutes <= 240)): return _err("OUT_OF_RANGE", "auto_suspend_minutes is invalid") if daily_credit_limit is not None and (not isinstance(daily_credit_limit, (int, float)) or daily_credit_limit < 0): return _err("OUT_OF_RANGE", "daily_credit_limit is invalid") if status == "suspended" and int(warehouse.get("running_queries") or 0) > 0: return _err("WAREHOUSE_BUSY", "warehouse has running queries") changed_fields = [] for key, value in provided.items(): if warehouse.get(key) != value: warehouse[key] = value changed_fields.append(key) if size is not None: warehouse["credits_per_hour"] = WAREHOUSE_SIZES[size] warehouse["updated_at"] = now_iso() _save(state_manager, "warehouse", warehouse) return success_response({"warehouse_id": warehouse_id, "changed": bool(changed_fields), "changed_fields": changed_fields, "warehouse": warehouse}) def set_quota_policy(*, state_manager, org_id=None, resource_group=None, warehouse_id=None, monthly_credit_limit=None, daily_query_limit=None, enforcement_mode=None, status="active", created_by_user_id=None, **kwargs): missing = _required(locals(), ["org_id", "resource_group", "monthly_credit_limit", "daily_query_limit", "enforcement_mode", "created_by_user_id"]) if missing: return missing if resource_group not in RESOURCE_GROUPS or enforcement_mode not in ENFORCEMENT_MODES or status not in QUOTA_STATUSES: return _err("INVALID_PARAMETER", "invalid quota enum") if not isinstance(monthly_credit_limit, (int, float)) or monthly_credit_limit < 0 or not isinstance(daily_query_limit, int) or daily_query_limit < 0: return _err("OUT_OF_RANGE", "quota limits are invalid") org = _org(state_manager, org_id) if not org: return _err("ORG_NOT_FOUND", "organization not found") if org["status"] == "suspended": return _err("ORG_NOT_ACTIVE", "organization is suspended") if warehouse_id: wh = _warehouse(state_manager, warehouse_id) if not wh or wh["org_id"] != org_id: return _err("WAREHOUSE_NOT_FOUND", "warehouse not found in organization") if wh["resource_group"] != resource_group: return _err("WAREHOUSE_GROUP_MISMATCH", "warehouse resource group does not match") user = _user(state_manager, created_by_user_id) if not user or user["org_id"] != org_id: return _err("USER_NOT_FOUND", "creator user not found") if user["status"] != "active": return _err("USER_NOT_ACTIVE", "creator user is not active") if user["role"] not in {"admin", "steward"}: return _err("PERMISSION_DENIED", "creator lacks admin or steward role") quota_id = build_humanized_id("quota_policy", {"org_id": org_id, "resource_group": resource_group, "warehouse_id": warehouse_id}, existing_ids=[]) existing = _quota(state_manager, quota_id) if existing: before = dict(existing) existing.update({"warehouse_id": warehouse_id, "resource_group": resource_group, "monthly_credit_limit": monthly_credit_limit, "daily_query_limit": daily_query_limit, "enforcement_mode": enforcement_mode, "status": status, "updated_at": now_iso()}) _save(state_manager, "quota_policy", existing) changed_fields = [k for k in ["monthly_credit_limit", "daily_query_limit", "enforcement_mode", "status", "warehouse_id"] if before.get(k) != existing.get(k)] op = "updated" if changed_fields else "unchanged" return success_response({"quota_policy": existing, "operation": op, "changed_fields": changed_fields}) row = {"quota_id": quota_id, "org_id": org_id, "warehouse_id": warehouse_id, "resource_group": resource_group, "monthly_credit_limit": monthly_credit_limit, "daily_query_limit": daily_query_limit, "current_month_credits": 0.0, "current_day_query_count": 0, "enforcement_mode": enforcement_mode, "status": status, "created_by_user_id": created_by_user_id, "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("quota_policy", row) return success_response({"quota_policy": row, "operation": "created", "changed_fields": ["quota_policy"]}) def add_dataset_access_grant(*, state_manager, dataset_id=None, user_id=None, granted_by_user_id=None, role=None, scope="dataset", table_id=None, expires_at=None, principal_type="user", **kwargs): missing = _required(locals(), ["dataset_id", "user_id", "granted_by_user_id", "role"]) if missing: return missing if role not in GRANT_ROLES or scope not in GRANT_SCOPES or principal_type not in PRINCIPAL_TYPES or (expires_at is not None and not is_iso_datetime(expires_at)): return _err("INVALID_PARAMETER", "invalid grant parameter") if expires_at is not None and not datetime_gt(expires_at, now_iso()): return _err("EXPIRATION_PRECONDITION_FAILED", "expiration is not in the future") dataset = _dataset(state_manager, dataset_id) if not dataset: return _err("DATASET_NOT_FOUND", "dataset not found") if dataset["status"] != "active": return _err("DATASET_NOT_ACTIVE", "dataset is archived") receiver = _user(state_manager, user_id) grantor = _user(state_manager, granted_by_user_id) if not receiver or receiver["org_id"] != dataset["org_id"] or not grantor or grantor["org_id"] != dataset["org_id"]: return _err("USER_NOT_FOUND", "receiving user or granting user is missing") if receiver["status"] != "active" or grantor["status"] != "active": return _err("USER_NOT_ACTIVE", "receiving user or granting user is not active") if not _is_grantor(state_manager, dataset_id, granted_by_user_id): return _err("PERMISSION_DENIED", "granting user is not allowed to grant access") if scope == "table": table = _table(state_manager, table_id) if table_id else None if not table or table["dataset_id"] != dataset_id: return _err("TABLE_NOT_FOUND", "table-scope table_id is missing from dataset") else: table_id = None matches = [g for g in _all(state_manager, "access_grant") if g["dataset_id"] == dataset_id and g["user_id"] == user_id and g["role"] == role and g["scope"] == scope and g.get("table_id") == table_id] if matches: grant = matches[0] if grant["status"] == "active": return success_response({"grant": grant, "operation": "unchanged", "changed": False}) grant["status"] = "active" grant["expires_at"] = expires_at grant["updated_at"] = now_iso() _save(state_manager, "access_grant", grant) return success_response({"grant": grant, "operation": "reactivated", "changed": True}) grant_id = f"grant-{dataset_id[3:]}-{slugify(user_id[5:] if user_id.startswith('user-') else user_id)}-{role}-{len(_all(state_manager, 'access_grant')) + 1}" grant = {"grant_id": grant_id, "org_id": dataset["org_id"], "dataset_id": dataset_id, "table_id": table_id, "user_id": user_id, "principal_type": principal_type, "role": role, "scope": scope, "granted_by_user_id": granted_by_user_id, "expires_at": expires_at, "status": "active", "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("access_grant", grant) return success_response({"grant": grant, "operation": "created", "changed": True}) def remove_access_grant(*, state_manager, grant_id=None, revoked_by_user_id=None, reason=None, **kwargs): if not grant_id or not revoked_by_user_id: return _err("MISSING_FIELD", "grant_id and revoked_by_user_id are required") grant = _grant(state_manager, grant_id) if not grant: return _err("GRANT_NOT_FOUND", "access grant not found") if grant["status"] != "active": return _err("GRANT_NOT_ACTIVE", "grant is not active") user = _user(state_manager, revoked_by_user_id) if not user or user["org_id"] != grant["org_id"]: return _err("USER_NOT_FOUND", "revoking user not found") if user["status"] != "active": return _err("USER_NOT_ACTIVE", "revoking user is not active") if not _is_grantor(state_manager, grant["dataset_id"], revoked_by_user_id): return _err("PERMISSION_DENIED", "revoking user lacks permission") if grant["role"] == "owner": active_owners = [g for g in _all(state_manager, "access_grant") if g["dataset_id"] == grant["dataset_id"] and g["role"] == "owner" and g["status"] == "active"] if len(active_owners) <= 1: return _err("LAST_OWNER_CONFLICT", "revocation would remove the final owner grant") if reason is not None and not isinstance(reason, str): return _err("INVALID_PARAMETER", "reason must be a string") previous = grant["status"] grant["status"] = "revoked" grant["updated_at"] = now_iso() _save(state_manager, "access_grant", grant) return success_response({"grant_id": grant_id, "previous_status": previous, "status": "revoked", "revoked_by_user_id": revoked_by_user_id, "reason": reason, "grant": grant}) def mark_column_sensitivity(*, state_manager, column_id=None, sensitivity=None, is_masked=None, reason=None, **kwargs): if not column_id or sensitivity is None or is_masked is None: return _err("MISSING_FIELD", "column_id, sensitivity, and is_masked are required") if sensitivity not in SENSITIVITIES or not isinstance(is_masked, bool) or (reason is not None and not isinstance(reason, str)): return _err("INVALID_PARAMETER", "invalid sensitivity, mask flag, or reason") column = _column(state_manager, column_id) if not column: return _err("COLUMN_NOT_FOUND", "column not found") table = _table(state_manager, column["table_id"]) if table and table["status"] == "archived": return _err("TABLE_ARCHIVED", "parent table is archived") if sensitivity in {"secret", "pii", "financial"} and not is_masked and not reason: return _err("MASKING_PRECONDITION_FAILED", "sensitive value requires masking or an explicit governance reason") prev_sens, prev_mask = column["sensitivity"], column["is_masked"] changed = prev_sens != sensitivity or prev_mask is not is_masked if changed: column["sensitivity"] = sensitivity column["is_masked"] = is_masked column["updated_at"] = now_iso() _save(state_manager, "column", column) if table: table["updated_at"] = now_iso() _save(state_manager, "table", table) return success_response({"column_id": column_id, "changed": changed, "previous_sensitivity": prev_sens, "new_sensitivity": sensitivity, "previous_is_masked": prev_mask, "new_is_masked": is_masked, "column": column}) def materialize_query_result(*, state_manager, query_job_id=None, destination_dataset_id=None, table_name=None, table_type="materialized_view", replace_existing=False, **kwargs): if not query_job_id or not destination_dataset_id or not table_name: return _err("MISSING_FIELD", "query_job_id, destination_dataset_id, and table_name are required") if table_type not in {"mart", "snapshot", "materialized_view"} or not isinstance(replace_existing, bool): return _err("INVALID_PARAMETER", "invalid materialization parameter") query = _query(state_manager, query_job_id) if not query: return _err("QUERY_NOT_FOUND", "query not found") if query["status"] != "succeeded": return _err("QUERY_NOT_SUCCEEDED", "query status is not succeeded") if int(query.get("result_row_count") or 0) <= 0: return _err("EMPTY_QUERY_RESULT", "query result is empty") dataset = _dataset(state_manager, destination_dataset_id) if not dataset: return _err("DATASET_NOT_FOUND", "destination dataset not found") if dataset["status"] != "active": return _err("DATASET_NOT_ACTIVE", "destination dataset is archived") if dataset["org_id"] != query["org_id"]: return _err("ORG_SCOPE_MISMATCH", "destination dataset belongs to another organization") table_id = build_humanized_id("table", {"dataset_id": destination_dataset_id, "name": table_name}, existing_ids=[]) existing = _table(state_manager, table_id) if existing and not replace_existing: return _err("DUPLICATE_TABLE", "destination table already exists") if existing and existing["status"] == "archived": return _err("TABLE_ARCHIVED", "archived destination table cannot be replaced") old_cols = _columns_for_table(state_manager, table_id) if existing else [] if existing: state_manager.delete_many("column", lambda c: c.get("table_id") == table_id) size = round(max(float(query.get("bytes_scanned_gb") or 1) * 0.18, 0.1), 3) table = {"table_id": table_id, "org_id": query["org_id"], "dataset_id": destination_dataset_id, "name": table_name.strip(), "table_type": table_type, "status": "active", "row_count": int(query["result_row_count"]), "size_gb": size, "column_count": 3, "partition_key": None, "cluster_keys": [], "retention_until": None, "last_loaded_at": now_iso(), "created_at": existing["created_at"] if existing else now_iso(), "updated_at": now_iso()} _save(state_manager, "table", table) if existing else state_manager.add_entity("table", table) cols = [] for idx, (name, dtype) in enumerate([("group_key", "string"), ("row_count", "int64"), ("computed_at", "timestamp")], start=1): col = {"column_id": f"col-{table_id[4:]}-{idx:02d}-{name.replace('_','-')}", "org_id": query["org_id"], "dataset_id": destination_dataset_id, "table_id": table_id, "name": name, "data_type": dtype, "ordinal": idx, "nullable": False, "is_masked": False, "sensitivity": "none", "description": f"Materialized query result field {name}.", "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("column", col) cols.append(col) query["destination_table_id"] = table_id query["updated_at"] = now_iso() _save(state_manager, "query_job", query) if not existing: dataset["table_count"] = int(dataset.get("table_count") or 0) + 1 dataset["storage_gb"] = round(float(dataset.get("storage_gb") or 0) + size - sum(float(c.get("size_gb") or 0) for c in old_cols), 3) dataset["updated_at"] = now_iso() _save(state_manager, "dataset", dataset) return success_response({"query_job_id": query_job_id, "destination_table": table, "columns": cols, "operation": "replaced" if existing else "created", "storage_delta_gb": size}) def clone_table_snapshot(*, state_manager, source_table_id=None, target_dataset_id=None, snapshot_name=None, copy_access_grants=False, retention_until=None, **kwargs): if not source_table_id or not target_dataset_id or not snapshot_name: return _err("MISSING_FIELD", "source_table_id, target_dataset_id, and snapshot_name are required") if not isinstance(copy_access_grants, bool) or (retention_until is not None and not is_iso_datetime(retention_until)): return _err("INVALID_PARAMETER", "invalid snapshot parameter") if retention_until is not None and not datetime_gt(retention_until, now_iso()): return _err("RETENTION_PRECONDITION_FAILED", "retention timestamp must be in the future") source = _table(state_manager, source_table_id) if not source: return _err("TABLE_NOT_FOUND", "source table not found") if source["status"] != "active": return _err("TABLE_NOT_ACTIVE", "source table is not active") dataset = _dataset(state_manager, target_dataset_id) if not dataset: return _err("DATASET_NOT_FOUND", "target dataset not found") if dataset["status"] != "active": return _err("DATASET_NOT_ACTIVE", "target dataset is archived") if dataset["org_id"] != source["org_id"]: return _err("ORG_SCOPE_MISMATCH", "source and target dataset belong to different organizations") snapshot_id = build_humanized_id("table", {"dataset_id": target_dataset_id, "name": snapshot_name}, existing_ids=[]) if _table(state_manager, snapshot_id): return _err("DUPLICATE_TABLE", "derived snapshot table id already exists") snapshot = dict(source) snapshot.update({"table_id": snapshot_id, "dataset_id": target_dataset_id, "name": snapshot_name.strip(), "table_type": "snapshot", "retention_until": retention_until, "created_at": now_iso(), "updated_at": now_iso()}) state_manager.add_entity("table", snapshot) copied_cols = [] for idx, col in enumerate(_columns_for_table(state_manager, source_table_id), start=1): new_col = dict(col) new_col.update({"column_id": f"col-{snapshot_id[4:]}-{idx:02d}-{slugify(col['name'])}", "dataset_id": target_dataset_id, "table_id": snapshot_id, "created_at": now_iso(), "updated_at": now_iso()}) state_manager.add_entity("column", new_col) copied_cols.append(new_col) copied_grants = 0 if copy_access_grants: for grant in _all(state_manager, "access_grant"): if grant.get("table_id") == source_table_id and grant.get("status") == "active" and grant.get("role") == "reader": new_grant = dict(grant) new_grant["grant_id"] = f"{grant['grant_id']}-snapshot-{copied_grants + 1}" new_grant["dataset_id"] = target_dataset_id new_grant["table_id"] = snapshot_id new_grant["created_at"] = now_iso() new_grant["updated_at"] = now_iso() state_manager.add_entity("access_grant", new_grant) copied_grants += 1 dataset["table_count"] = int(dataset.get("table_count") or 0) + 1 dataset["storage_gb"] = round(float(dataset.get("storage_gb") or 0) + float(source.get("size_gb") or 0), 3) dataset["updated_at"] = now_iso() _save(state_manager, "dataset", dataset) return success_response({"snapshot_table": snapshot, "copied_column_count": len(copied_cols), "copied_grant_count": copied_grants, "storage_delta_gb": source.get("size_gb")}) def execute_import_job(*, state_manager, import_job_id=None, result_status=None, rows_loaded=0, bytes_loaded_gb=0, error_message=None, **kwargs): if not import_job_id or not result_status: return _err("MISSING_FIELD", "import_job_id and result_status are required") if result_status not in {"succeeded", "failed"}: return _err("INVALID_PARAMETER", "invalid result_status") job = _import(state_manager, import_job_id) if not job: return _err("IMPORT_JOB_NOT_FOUND", "import job not found") if job["status"] not in {"queued", "running"}: return _err("IMPORT_JOB_NOT_ACTIVE", "import job is not queued or running") if result_status == "succeeded": if not isinstance(rows_loaded, int) or rows_loaded <= 0 or not isinstance(bytes_loaded_gb, (int, float)) or bytes_loaded_gb <= 0: return _err("OUT_OF_RANGE", "success row or byte counts are outside allowed bounds") table = _table(state_manager, job["target_table_id"]) if not table: return _err("TABLE_NOT_FOUND", "target table is missing") dataset = _dataset(state_manager, table["dataset_id"]) if not dataset or dataset["status"] != "active": return _err("DATASET_NOT_ACTIVE", "target dataset is archived") if table["status"] != "active": return _err("TABLE_NOT_ACTIVE", "target table is not active") warehouse = _warehouse(state_manager, job["warehouse_id"]) if not warehouse or warehouse["status"] != "active": return _err("WAREHOUSE_NOT_ACTIVE", "warehouse is not active") else: if not error_message or not isinstance(error_message, str): return _err("INVALID_PARAMETER", "failure requires error_message") table = _table(state_manager, job["target_table_id"]) dataset = _dataset(state_manager, job["dataset_id"]) warehouse = _warehouse(state_manager, job["warehouse_id"]) previous_status = job["status"] job.update({"status": result_status, "rows_loaded": rows_loaded if result_status == "succeeded" else 0, "bytes_loaded_gb": float(bytes_loaded_gb) if result_status == "succeeded" else 0.0, "error_message": None if result_status == "succeeded" else error_message, "completed_at": now_iso(), "updated_at": now_iso()}) _save(state_manager, "import_job", job) if warehouse: key = "queued_queries" if previous_status == "queued" else "running_queries" warehouse[key] = max(0, int(warehouse.get(key) or 0) - 1) credits = round(max(float(bytes_loaded_gb) * 0.05, 0.05), 3) warehouse["credits_used_today"] = round(float(warehouse.get("credits_used_today") or 0) + credits, 3) _save(state_manager, "warehouse", warehouse) else: credits = 0.05 table_delta = {"rows_loaded": 0, "bytes_loaded_gb": 0.0} dataset_delta = {"storage_gb": 0.0} if result_status == "succeeded": table["row_count"] = int(table.get("row_count") or 0) + rows_loaded table["size_gb"] = round(float(table.get("size_gb") or 0) + float(bytes_loaded_gb), 3) table["last_loaded_at"] = now_iso() table["updated_at"] = now_iso() _save(state_manager, "table", table) dataset["storage_gb"] = round(float(dataset.get("storage_gb") or 0) + float(bytes_loaded_gb), 3) dataset["updated_at"] = now_iso() _save(state_manager, "dataset", dataset) table_delta = {"rows_loaded": rows_loaded, "bytes_loaded_gb": float(bytes_loaded_gb)} dataset_delta = {"storage_gb": float(bytes_loaded_gb)} usage = {"usage_id": _new_usage_id(state_manager, job["org_id"], "2026-06-01", "etl", "import"), "org_id": job["org_id"], "warehouse_id": job["warehouse_id"], "dataset_id": job["dataset_id"], "query_job_id": None, "import_job_id": import_job_id, "export_job_id": None, "usage_type": "import", "usage_date": "2026-06-01", "credits": credits, "cost_usd": round(credits * 3.15, 2), "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("cost_usage_record", usage) return success_response({"import_job": job, "table_delta": table_delta, "dataset_delta": dataset_delta, "usage_record": usage, "result": result_status}) def finalize_export_job(*, state_manager, export_job_id=None, result_status=None, row_count=0, bytes_exported_gb=0, error_message=None, **kwargs): if not export_job_id or not result_status: return _err("MISSING_FIELD", "export_job_id and result_status are required") if result_status not in {"succeeded", "failed"}: return _err("INVALID_PARAMETER", "invalid result_status") job = _export(state_manager, export_job_id) if not job: return _err("EXPORT_JOB_NOT_FOUND", "export job not found") if job["status"] not in {"queued", "running"}: return _err("EXPORT_JOB_NOT_ACTIVE", "export job is not queued or running") table = _table(state_manager, job["source_table_id"]) warehouse = _warehouse(state_manager, job["warehouse_id"]) if result_status == "succeeded": if not table: return _err("TABLE_NOT_FOUND", "source table is missing") if table["status"] != "active": return _err("TABLE_NOT_ACTIVE", "source table is not active") if not warehouse or warehouse["status"] != "active": return _err("WAREHOUSE_NOT_ACTIVE", "warehouse is not active") if not isinstance(row_count, int) or row_count < 0 or row_count > int(table.get("row_count") or 0) or not isinstance(bytes_exported_gb, (int, float)) or bytes_exported_gb < 0: return _err("OUT_OF_RANGE", "exported row or byte count is outside allowed bounds") elif not error_message: return _err("INVALID_PARAMETER", "failure requires error_message") previous_status = job["status"] job.update({"status": result_status, "row_count": row_count if result_status == "succeeded" else 0, "bytes_exported_gb": float(bytes_exported_gb) if result_status == "succeeded" else 0.0, "completed_at": now_iso(), "updated_at": now_iso()}) _save(state_manager, "export_job", job) credits = round(max(float(bytes_exported_gb) * 0.04, 0.05), 3) if warehouse: key = "queued_queries" if previous_status == "queued" else "running_queries" warehouse[key] = max(0, int(warehouse.get(key) or 0) - 1) warehouse["credits_used_today"] = round(float(warehouse.get("credits_used_today") or 0) + credits, 3) _save(state_manager, "warehouse", warehouse) usage = {"usage_id": _new_usage_id(state_manager, job["org_id"], "2026-06-01", "operations", "export"), "org_id": job["org_id"], "warehouse_id": job["warehouse_id"], "dataset_id": table["dataset_id"] if table else None, "query_job_id": None, "import_job_id": None, "export_job_id": export_job_id, "usage_type": "export", "usage_date": "2026-06-01", "credits": credits, "cost_usd": round(credits * 3.15, 2), "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("cost_usage_record", usage) return success_response({"export_job": job, "usage_record": usage, "result": result_status}) def refresh_cost_usage_snapshot(*, state_manager, org_id=None, usage_date=None, mode="upsert", created_by_user_id=None, **kwargs): if not org_id or not usage_date or not created_by_user_id: return _err("MISSING_FIELD", "org_id, usage_date, and created_by_user_id are required") if not is_date(usage_date) or mode not in {"upsert", "replace"}: return _err("INVALID_PARAMETER", "invalid usage_date or mode") if not _org(state_manager, org_id): return _err("ORG_NOT_FOUND", "organization not found") user = _user(state_manager, created_by_user_id) if not user or user["org_id"] != org_id: return _err("USER_NOT_FOUND", "initiating user not found") if user["status"] != "active": return _err("USER_NOT_ACTIVE", "initiating user is not active") if user["role"] not in {"admin", "engineer", "steward"}: return _err("PERMISSION_DENIED", "initiating user lacks an allowed role") existing = [u for u in _all(state_manager, "cost_usage_record") if u["org_id"] == org_id and u["usage_date"] == usage_date] if mode == "replace" and any(q["status"] == "running" and q["query_job_id"] == u.get("query_job_id") for u in existing for q in _all(state_manager, "query_job")): return _err("REPLACE_CONFLICT", "replace mode would remove usage linked to active jobs") if mode == "replace": deleted = state_manager.delete_many("cost_usage_record", lambda u: u.get("org_id") == org_id and u.get("usage_date") == usage_date) else: deleted = 0 created = [] for wh in [w for w in _all(state_manager, "warehouse") if w["org_id"] == org_id][:3]: credits = round(float(wh.get("credits_used_today") or 0) + 1.25, 3) usage = {"usage_id": _new_usage_id(state_manager, org_id, usage_date, wh["resource_group"], "compute"), "org_id": org_id, "warehouse_id": wh["warehouse_id"], "dataset_id": None, "query_job_id": None, "import_job_id": None, "export_job_id": None, "usage_type": "compute", "usage_date": usage_date, "credits": credits, "cost_usd": round(credits * 3.15, 2), "created_at": now_iso(), "updated_at": now_iso()} state_manager.add_entity("cost_usage_record", usage) created.append(usage) return success_response({"org_id": org_id, "usage_date": usage_date, "mode": mode, "created_count": len(created), "updated_count": 0, "deleted_count": deleted, "credit_delta": round(sum(u["credits"] for u in created), 3), "cost_delta": round(sum(u["cost_usd"] for u in created), 2), "records": created}) def apply_quota_enforcement(*, state_manager, org_id=None, policy_scope="all", resource_group=None, warehouse_id=None, dry_run=False, **kwargs): if not org_id: return _err("MISSING_FIELD", "org_id is required") if policy_scope not in {"all", "resource_group", "warehouse"} or (resource_group is not None and resource_group not in RESOURCE_GROUPS) or not isinstance(dry_run, bool): return _err("INVALID_PARAMETER", "invalid enforcement parameter") if not _org(state_manager, org_id): return _err("ORG_NOT_FOUND", "organization not found") if policy_scope == "resource_group" and not resource_group: return _err("MISSING_FIELD", "resource_group is required for resource_group scope") scoped_wh = None if policy_scope == "warehouse": if not warehouse_id: return _err("MISSING_FIELD", "warehouse_id is required for warehouse scope") scoped_wh = _warehouse(state_manager, warehouse_id) if not scoped_wh or scoped_wh["org_id"] != org_id: return _err("WAREHOUSE_NOT_FOUND", "scoped warehouse not found") policies = [p for p in _all(state_manager, "quota_policy") if p["org_id"] == org_id and p["status"] == "active"] if policy_scope == "resource_group": policies = [p for p in policies if p["resource_group"] == resource_group] if policy_scope == "warehouse": policies = [p for p in policies if p.get("warehouse_id") == warehouse_id or (scoped_wh and p["resource_group"] == scoped_wh["resource_group"])] if not policies: return _err("NO_MATCHING_POLICY", "no active quota policy matches scope") actions = [] for policy in policies: over = float(policy.get("current_month_credits") or 0) >= float(policy.get("monthly_credit_limit") or 0) or int(policy.get("current_day_query_count") or 0) >= int(policy.get("daily_query_limit") or 0) if not over: actions.append({"quota_id": policy["quota_id"], "action": "none", "reason": "within_limit"}) continue whs = [w for w in _all(state_manager, "warehouse") if w["org_id"] == org_id and w["resource_group"] == policy["resource_group"] and (not policy.get("warehouse_id") or w["warehouse_id"] == policy["warehouse_id"])] if policy["enforcement_mode"] == "block": for wh in whs: queued = [q for q in _all(state_manager, "query_job") if q["warehouse_id"] == wh["warehouse_id"] and q["status"] == "queued"] actions.append({"quota_id": policy["quota_id"], "action": "cancel_queued_queries", "warehouse_id": wh["warehouse_id"], "query_count": len(queued)}) if not dry_run: for q in queued: q["status"] = "canceled" q["completed_at"] = now_iso() q["updated_at"] = now_iso() _save(state_manager, "query_job", q) wh["queued_queries"] = max(0, int(wh.get("queued_queries") or 0) - len(queued)) if int(wh.get("running_queries") or 0) == 0: wh["status"] = "suspended" _save(state_manager, "warehouse", wh) elif policy["enforcement_mode"] == "throttle": for wh in whs: actions.append({"quota_id": policy["quota_id"], "action": "throttle_concurrency", "warehouse_id": wh["warehouse_id"], "new_max_concurrency": max(1, int(wh.get("max_concurrency") or 1) // 2)}) if not dry_run: wh["max_concurrency"] = max(1, int(wh.get("max_concurrency") or 1) // 2) _save(state_manager, "warehouse", wh) else: actions.append({"quota_id": policy["quota_id"], "action": "monitor_only", "reason": "policy is monitor mode"}) if not dry_run: policy["updated_at"] = now_iso() _save(state_manager, "quota_policy", policy) return success_response({"org_id": org_id, "policy_scope": policy_scope, "dry_run": dry_run, "evaluated_policy_count": len(policies), "actions": actions, "mutated": not dry_run}) def promote_dataset_owner(*, state_manager, dataset_id=None, new_owner_user_id=None, promoted_by_user_id=None, revoke_previous_owner_grant=False, **kwargs): if not dataset_id or not new_owner_user_id or not promoted_by_user_id: return _err("MISSING_FIELD", "dataset_id, new_owner_user_id, and promoted_by_user_id are required") if not isinstance(revoke_previous_owner_grant, bool): return _err("INVALID_PARAMETER", "revoke_previous_owner_grant must be boolean") dataset = _dataset(state_manager, dataset_id) if not dataset: return _err("DATASET_NOT_FOUND", "dataset not found") if dataset["status"] != "active": return _err("DATASET_NOT_ACTIVE", "dataset is archived") new_owner = _user(state_manager, new_owner_user_id) promoter = _user(state_manager, promoted_by_user_id) if not new_owner or new_owner["org_id"] != dataset["org_id"] or not promoter or promoter["org_id"] != dataset["org_id"]: return _err("USER_NOT_FOUND", "new owner or promoter not found") if new_owner["status"] != "active" or promoter["status"] != "active": return _err("USER_NOT_ACTIVE", "new owner or promoter is not active") if new_owner["role"] not in {"admin", "engineer", "steward"}: return _err("OWNER_ROLE_PRECONDITION_FAILED", "new owner role cannot own datasets") if not _is_grantor(state_manager, dataset_id, promoted_by_user_id): return _err("PERMISSION_DENIED", "promoter lacks permission") previous = dataset["owner_user_id"] changed = previous != new_owner_user_id owner_grant = None revoked_previous = None if changed: dataset["owner_user_id"] = new_owner_user_id dataset["updated_at"] = now_iso() _save(state_manager, "dataset", dataset) owner_result = add_dataset_access_grant(state_manager=state_manager, dataset_id=dataset_id, user_id=new_owner_user_id, granted_by_user_id=promoted_by_user_id, role="owner", scope="dataset") owner_grant = owner_result["data"]["grant"] if owner_result["status"] == "success" else None if revoke_previous_owner_grant: previous_grants = [g for g in _all(state_manager, "access_grant") if g["dataset_id"] == dataset_id and g["user_id"] == previous and g["role"] == "owner" and g["status"] == "active"] if previous_grants: grant = previous_grants[0] grant["status"] = "revoked" grant["updated_at"] = now_iso() _save(state_manager, "access_grant", grant) revoked_previous = grant return success_response({"dataset_id": dataset_id, "previous_owner_user_id": previous, "new_owner_user_id": new_owner_user_id, "changed": changed, "owner_grant": owner_grant, "revoked_previous_owner_grant": revoked_previous}) def remove_dataset_cascade(*, state_manager, dataset_id=None, requested_by_user_id=None, cascade_mode=None, force=False, reason=None, **kwargs): if not dataset_id or not requested_by_user_id or not cascade_mode or not reason: return _err("MISSING_FIELD", "dataset_id, requested_by_user_id, cascade_mode, and reason are required") if cascade_mode not in {"archive", "hard_delete"} or not isinstance(force, bool) or not isinstance(reason, str): return _err("INVALID_PARAMETER", "invalid cascade parameter") dataset = _dataset(state_manager, dataset_id) if not dataset: return _err("DATASET_NOT_FOUND", "dataset not found") user = _user(state_manager, requested_by_user_id) if not user or user["org_id"] != dataset["org_id"]: return _err("USER_NOT_FOUND", "requester not found") if user["status"] != "active": return _err("USER_NOT_ACTIVE", "requester is not active") if not _is_grantor(state_manager, dataset_id, requested_by_user_id): return _err("PERMISSION_DENIED", "requester lacks permission") if cascade_mode == "archive" and dataset["status"] != "active": return _err("DATASET_NOT_ACTIVE", "archive mode requires active dataset") child_tables = [t for t in _all(state_manager, "table") if t["dataset_id"] == dataset_id] child_table_ids = {t["table_id"] for t in child_tables} active_queries = [q for q in _all(state_manager, "query_job") if q["status"] in {"queued", "running"} and (dataset_id in q.get("dataset_ids", []) or any(tid in child_table_ids for tid in q.get("referenced_table_ids", [])))] active_imports = [j for j in _all(state_manager, "import_job") if j["status"] in {"queued", "running"} and j.get("dataset_id") == dataset_id] active_exports = [j for j in _all(state_manager, "export_job") if j["status"] in {"queued", "running"} and j.get("source_table_id") in child_table_ids] if cascade_mode == "hard_delete" and (active_queries or active_imports or active_exports): return _err("ACTIVE_JOB_CONFLICT", "queued or running jobs still reference the dataset") history = [q for q in _all(state_manager, "query_job") if dataset_id in q.get("dataset_ids", []) and q["status"] == "succeeded"] if cascade_mode == "hard_delete" and history and not force: return _err("HISTORY_FORCE_REQUIRED", "hard delete with completed history requires force") archived_counts = {"datasets": 0, "tables": 0} deleted_counts = {"datasets": 0, "tables": 0, "columns": 0, "access_grants": 0} revoked_grant_count = 0 canceled_job_count = 0 if cascade_mode == "archive": dataset["status"] = "archived" dataset["updated_at"] = now_iso() _save(state_manager, "dataset", dataset) archived_counts["datasets"] = 1 for table in child_tables: if table["status"] == "active": table["status"] = "archived" table["retention_until"] = "2027-06-01T00:00:00Z" table["updated_at"] = now_iso() _save(state_manager, "table", table) archived_counts["tables"] += 1 for grant in [g for g in _all(state_manager, "access_grant") if g["dataset_id"] == dataset_id and g["status"] == "active"]: grant["status"] = "revoked" grant["updated_at"] = now_iso() _save(state_manager, "access_grant", grant) revoked_grant_count += 1 else: deleted_counts["columns"] = state_manager.delete_many("column", lambda c: c.get("dataset_id") == dataset_id) deleted_counts["access_grants"] = state_manager.delete_many("access_grant", lambda g: g.get("dataset_id") == dataset_id) deleted_counts["tables"] = state_manager.delete_many("table", lambda t: t.get("dataset_id") == dataset_id) deleted_counts["datasets"] = 1 if state_manager.delete_entity("dataset", dataset_id) else 0 for q in _all(state_manager, "query_job"): changed = False if dataset_id in q.get("dataset_ids", []): q["dataset_ids"] = [d for d in q["dataset_ids"] if d != dataset_id] changed = True if q.get("destination_table_id") in child_table_ids: q["destination_table_id"] = None changed = True if changed: q["updated_at"] = now_iso() _save(state_manager, "query_job", q) return success_response({"dataset_id": dataset_id, "cascade_mode": cascade_mode, "deleted_counts": deleted_counts, "archived_counts": archived_counts, "revoked_grant_count": revoked_grant_count, "canceled_job_count": canceled_job_count, "reason": reason})
"""Business logic for the cloud data warehouse tools."""
from __future__ import annotations
from datetime import datetime
from typing import Any, Dict, Iterable, List, Optional
from mcp_servers.utils import (
build_humanized_id,
datetime_gt,
error_response,
is_date,
is_iso_datetime,
now_iso,
org_slug,
safe_copy,
slugify,
success_response,
)
ENTITY_TYPES = {
"organization": ("organization", "org_id"),
"user": ("user", "user_id"),
"warehouse": ("warehouse", "warehouse_id"),
"dataset": ("dataset", "dataset_id"),
"table": ("table", "table_id"),
"column": ("column", "column_id"),
"access_grant": ("access_grant", "grant_id"),
"query_job": ("query_job", "query_job_id"),
"import_job": ("import_job", "import_job_id"),
"export_job": ("export_job", "export_job_id"),
"cost_usage_record": ("cost_usage_record", "usage_id"),
"quota_policy": ("quota_policy", "quota_id"),
}
REGIONS = {"us-east", "us-west", "us-central", "eu-west", "eu-central"}
RESOURCE_GROUPS = {"analytics", "finance", "operations", "ml", "etl"}
WAREHOUSE_SIZES = {"xs": 0.75, "s": 1.5, "m": 3.0, "l": 6.0, "xl": 12.0}
DATASET_CLASSIFICATIONS = {"internal", "confidential", "restricted", "public"}
TABLE_TYPES = {"raw", "curated", "mart", "snapshot", "materialized_view"}
COLUMN_TYPES = {"string", "int64", "float64", "numeric", "bool", "date", "timestamp"}
SENSITIVITIES = {"none", "pii", "financial", "operational", "secret"}
QUERY_STATUSES = {"queued", "running", "succeeded", "failed", "canceled"}
PRIORITIES = {"low", "normal", "high", "urgent"}
TRANSFER_FORMATS = {"csv", "json", "parquet", "avro"}
EXPORT_FORMATS = {"csv", "parquet", "json"}
GRANT_ROLES = {"reader", "writer", "admin", "owner"}
GRANT_SCOPES = {"dataset", "table"}
PRINCIPAL_TYPES = {"user", "group", "service_account"}
ENFORCEMENT_MODES = {"monitor", "block", "throttle"}
QUOTA_STATUSES = {"active", "disabled"}
ALLOWED_STORAGE_SCHEMES = ("s3://", "gs://", "az://")
def _err(code: str, text: str):
return error_response(code, text)
def _required(params: Dict[str, Any], fields: Iterable[str], code: str = "MISSING_FIELD"):
for field in fields:
value = params.get(field)
if value is None or (isinstance(value, str) and not value.strip()) or (isinstance(value, list) and not value):
return _err(code, f"{field} is required")
return None
def _get(sm, entity: str, entity_id: str):
return sm.get_entity(entity, entity_id, id_field=ENTITY_TYPES[entity][1])
def _all(sm, entity: str) -> List[Dict[str, Any]]:
return sm.list_entities(entity)
def _org(sm, org_id: str):
return _get(sm, "organization", org_id)
def _user(sm, user_id: str):
return _get(sm, "user", user_id)
def _warehouse(sm, warehouse_id: str):
return _get(sm, "warehouse", warehouse_id)
def _dataset(sm, dataset_id: str):
return _get(sm, "dataset", dataset_id)
def _table(sm, table_id: str):
return _get(sm, "table", table_id)
def _column(sm, column_id: str):
return _get(sm, "column", column_id)
def _grant(sm, grant_id: str):