bigquery-adbc 0.1.0__py3-none-win_amd64.whl

bigquery_adbc/__init__.py

@@ -0,0 +1,146 @@
+"""Python bindings for the BigQuery ADBC driver."""
+
+from __future__ import annotations
+
+import functools
+import importlib.metadata
+import os
+from collections.abc import Mapping
+from pathlib import Path
+
+import adbc_driver_manager
+
+from ._options import (
+    AuthenticationType,
+    BulkIngestMethod,
+    ConnectionOptions,
+    CreateDisposition,
+    CredentialsType,
+    DatabaseOptions,
+    ParameterMode,
+    QueryPriority,
+    StatementOptions,
+    WriteDisposition,
+)
+
+ENTRYPOINT = "AdbcDriverBigqueryInit"
+
+_DISTRIBUTION_NAME = "bigquery-adbc"
+_LIBRARY_ENV = "BIGQUERY_ADBC_LIBRARY"
+_LIBRARY_FILENAMES = (
+    "libadbc_driver_bigquery.so",
+    "libadbc_driver_bigquery.dylib",
+    "adbc_driver_bigquery.dll",
+)
+_PACKAGE_DIR = Path(__file__).resolve().parent
+# The option values adbc_driver_manager accepts: a bool becomes "true" or "false", an int,
+# float or bytes value sets a typed option, and a path is passed as its string.
+_OptionValue = str | bytes | int | float | Path
+
+try:
+    __version__ = importlib.metadata.version(_DISTRIBUTION_NAME)
+except importlib.metadata.PackageNotFoundError:
+    # Only an uninstalled source tree lacks distribution metadata.
+    __version__ = "0.0.0+unknown"
+
+
+def _validated_library_path(path: Path, source: str) -> str:
+    try:
+        is_file = path.is_file()
+    except OSError as error:
+        raise FileNotFoundError(
+            f"Could not inspect the BigQuery ADBC driver library from {source}: {path} ({error})"
+        ) from error
+
+    if not is_file:
+        raise FileNotFoundError(f"The BigQuery ADBC driver library from {source} is not a regular file: {path}")
+
+    return str(path.resolve(strict=True))
+
+
+@functools.lru_cache(maxsize=1)
+def _bundled_library_path(package_dir: Path) -> str:
+    """Resolve once per package directory; installed libraries are immutable."""
+
+    candidates = [path for filename in _LIBRARY_FILENAMES if (path := package_dir / filename).is_file()]
+    if not candidates:
+        expected = ", ".join(_LIBRARY_FILENAMES)
+        raise FileNotFoundError(
+            "No bundled BigQuery ADBC driver library was found beside the Python "
+            f"package (expected one of: {expected}). Install a platform wheel, or "
+            f"set {_LIBRARY_ENV} to an absolute path for development."
+        )
+    if len(candidates) > 1:
+        found = ", ".join(path.name for path in candidates)
+        raise RuntimeError(f"Expected exactly one bundled BigQuery ADBC driver library, but found: {found}")
+
+    return _validated_library_path(candidates[0], "the installed Python package")
+
+
+def driver_path() -> str:
+    """Return the absolute path of the native BigQuery ADBC driver library.
+
+    ``BIGQUERY_ADBC_LIBRARY``, if set, names a development build to use instead of
+    the library bundled beside this module. It is read on every call, so a running
+    session can switch builds; the bundled path is cached.
+    """
+
+    override = os.environ.get(_LIBRARY_ENV)
+    if override:
+        return _validated_library_path(Path(override).expanduser(), f"the {_LIBRARY_ENV} environment variable")
+
+    return _bundled_library_path(_PACKAGE_DIR)
+
+
+def connect(
+    uri: str | None = None,
+    # Mapping keys are invariant, so enum-keyed mappings need their own member.
+    db_kwargs: Mapping[str, _OptionValue] | Mapping[DatabaseOptions, _OptionValue] | None = None,
+) -> adbc_driver_manager.AdbcDatabase:
+    """Create a low-level ADBC database for BigQuery.
+
+    Configure the driver with ``uri``, ``db_kwargs``, or both. Explicit options
+    override URI parameters. Omitting ``uri`` leaves the native option unset.
+    """
+
+    options: dict[str, _OptionValue] = dict(db_kwargs.items()) if db_kwargs else {}
+    configured_uri = options.get(DatabaseOptions.URI)
+    if uri is not None and configured_uri is not None and configured_uri != uri:
+        raise ValueError(
+            "Conflicting BigQuery URIs were provided as 'uri' and db_kwargs['uri']; "
+            "provide the URI once, or use the same value in both places"
+        )
+    reserved = {"driver", "entrypoint"}.intersection(options)
+    if reserved:
+        names = ", ".join(sorted(reserved))
+        raise ValueError(
+            f"db_kwargs must not set {names}: bigquery_adbc.connect() supplies the "
+            f"bundled driver library path and the {ENTRYPOINT} entrypoint. Set "
+            f"{_LIBRARY_ENV} to load a different library."
+        )
+
+    if uri is not None:
+        options[DatabaseOptions.URI] = uri
+    return adbc_driver_manager.AdbcDatabase(
+        driver=driver_path(),
+        entrypoint=ENTRYPOINT,
+        **options,
+    )
+
+
+__all__ = [
+    "ENTRYPOINT",
+    "AuthenticationType",
+    "BulkIngestMethod",
+    "ConnectionOptions",
+    "CreateDisposition",
+    "CredentialsType",
+    "DatabaseOptions",
+    "ParameterMode",
+    "QueryPriority",
+    "StatementOptions",
+    "WriteDisposition",
+    "__version__",
+    "connect",
+    "driver_path",
+]

bigquery_adbc/_options.py

@@ -0,0 +1,431 @@
+"""Typed option names and values supported by the BigQuery driver.
+
+Generated from compiled Rust option metadata; run
+``cargo run --locked --features python-option-codegen --bin generate-python-options``
+after changing an option declaration. Do not edit this file manually.
+
+Every enum is a string: dictionary keys, option values, ``str()``, and formatting
+all use its wire value on every supported Python version.
+"""
+
+from __future__ import annotations
+
+import enum
+
+
+class DatabaseOptions(enum.StrEnum):
+    """Options accepted while initializing an ADBC database."""
+
+    #: The standard ADBC connection URI, `bigquery:///<project>?<key>=<value>`. Optional: every
+    #: setting a URI carries also has an option of its own.
+    URI = "uri"
+
+    #: How the driver authenticates: an `AuthenticationType` value. Unset resolves Google Cloud
+    #: Application Default Credentials.
+    AUTHENTICATION_TYPE = "bigquery.auth_type"
+
+    #: The JSON credential file path or credential document selected by `AUTHENTICATION_TYPE`.
+    #: Write-only and redacted from debug output; an error may quote a file path, never a
+    #: document.
+    AUTHENTICATION_CREDENTIALS = "bigquery.auth.credentials"
+
+    #: An optional `CredentialsType` value the JSON credential's `type` field must match; a
+    #: mismatch is rejected. It does not change how the document is parsed.
+    AUTHENTICATION_CREDENTIALS_TYPE = "bigquery.auth.credentials_type"
+
+    #: The OAuth client ID required by `user_authentication`.
+    AUTHENTICATION_CLIENT_ID = "bigquery.auth.client_id"
+
+    #: The OAuth client secret required by `user_authentication`. Write-only.
+    AUTHENTICATION_CLIENT_SECRET = "bigquery.auth.client_secret"
+
+    #: The OAuth refresh token required by `user_authentication`. Write-only.
+    AUTHENTICATION_REFRESH_TOKEN = "bigquery.auth.refresh_token"
+
+    #: The OAuth access token `temporary_access_token` sends as-is. Write-only. The driver never
+    #: refreshes it, so requests fail once it expires.
+    AUTHENTICATION_ACCESS_TOKEN = "bigquery.auth.access_token"
+
+    #: The OAuth token endpoint `user_authentication` redeems the refresh token at; unset uses
+    #: Google's default.
+    AUTHENTICATION_ACCESS_TOKEN_ENDPOINT = "bigquery.auth.access_token_endpoint"
+
+    #: The Workload Identity Federation provider resource required by `external_account`.
+    AUTHENTICATION_EXTERNAL_ACCOUNT_AUDIENCE = "bigquery.auth.external_account.audience"
+
+    #: The OAuth identity-provider URL required by `external_account`. Write-only, because its
+    #: query can carry secrets. HTTPS is required unless `ALLOW_UNTRUSTED_ENDPOINT` is set.
+    AUTHENTICATION_EXTERNAL_ACCOUNT_REQUEST_URL = "bigquery.auth.external_account.request_url"
+
+    #: The already form-encoded identity-provider POST body required by `external_account`, sent
+    #: unchanged. Write-only.
+    AUTHENTICATION_EXTERNAL_ACCOUNT_REQUEST_DATA = "bigquery.auth.external_account.request_data"
+
+    #: An optional standard IAM Credentials `generateAccessToken` URL for `external_account`.
+    AUTHENTICATION_EXTERNAL_ACCOUNT_IMPERSONATION_URL = "bigquery.auth.external_account.impersonation_url"
+
+    #: How Google's Security Token Service interprets the token the identity provider returns:
+    #: `urn:ietf:params:oauth:token-type:jwt`, the default, or
+    #: `urn:ietf:params:oauth:token-type:access_token` for an opaque token.
+    AUTHENTICATION_EXTERNAL_ACCOUNT_SUBJECT_TOKEN_TYPE = "bigquery.auth.external_account.subject_token_type"
+
+    #: Overrides `https://sts.googleapis.com/v1/token`, where the `external_account` subject
+    #: token is exchanged. An override must still be HTTPS on `googleapis.com` unless
+    #: `ALLOW_UNTRUSTED_ENDPOINT` is set.
+    AUTHENTICATION_EXTERNAL_ACCOUNT_TOKEN_URL = "bigquery.auth.external_account.token_url"
+
+    #: The project API quota and billing are attributed to, applied to the shared credentials.
+    AUTHENTICATION_QUOTA_PROJECT = "bigquery.auth.quota_project"
+
+    #: Comma-separated base OAuth scopes. Without an impersonation layer, unset falls back to
+    #: `IMPERSONATION_SCOPES`, then the credential default: `cloud-platform` for service
+    #: accounts, or the original consent grant for user credentials. User credentials can
+    #: request a subset of their consented scopes. External tables over Google Sheets or Drive
+    #: also need `https://www.googleapis.com/auth/drive`, with prior consent for user
+    #: credentials.
+    AUTHENTICATION_SCOPES = "bigquery.auth.scopes"
+
+    #: The project queries run and are billed in. Only a database sets it; on a connection it
+    #: reads back the current catalog.
+    PROJECT_ID = "bigquery.project_id"
+
+    #: The initial dataset unqualified table names resolve in. Only a database sets it; on a
+    #: connection it reads back the current schema.
+    DATASET_ID = "bigquery.dataset_id"
+
+    #: Overrides `https://bigquery.googleapis.com`, the BigQuery REST endpoint. A bare
+    #: `host[:port]` is HTTPS; an emulator needs an explicit `http://`. Set as an option, the
+    #: endpoint is trusted to receive credentials on any host and scheme, unlike the host of a
+    #: `bigquery://` URI.
+    ENDPOINT = "bigquery.endpoint"
+
+    #: Overrides the BigQuery Storage API endpoint, shared by the Read and Write halves of that
+    #: API.
+    STORAGE_ENDPOINT = "bigquery.storage_endpoint"
+
+    #: Overrides `https://storage.googleapis.com`, the Cloud Storage JSON API host the
+    #: python-model upload is sent to.
+    GCS_ENDPOINT = "bigquery.gcs_endpoint"
+
+    #: Overrides `https://{region}-dataproc.googleapis.com`, the regional Dataproc host. An
+    #: override replaces the whole host, region included.
+    DATAPROC_ENDPOINT = "bigquery.dataproc_endpoint"
+
+    #: Overrides `https://{region}-aiplatform.googleapis.com`, the regional Vertex AI host. An
+    #: override replaces the whole host, region included.
+    VERTEX_ENDPOINT = "bigquery.vertex_endpoint"
+
+    #: Boolean string, default `false`: permits a `bigquery://` URI host, auxiliary service and
+    #: credential-exchange endpoint overrides, and credential-document destinations that are not
+    #: HTTPS Google API hosts. A BigQuery REST endpoint set as an option is already explicitly
+    #: trusted. It cannot be set through a URI.
+    ALLOW_UNTRUSTED_ENDPOINT = "bigquery.allow_untrusted_endpoint"
+
+    #: The comma-separated service-account delegation chain used to impersonate.
+    IMPERSONATION_DELEGATES = "bigquery.impersonate.delegates"
+
+    #: The impersonated token's lifetime, a positive Go duration up to 12 hours; unset is one
+    #: hour. Over one hour also needs an organization policy, which IAM checks at the first
+    #: query.
+    IMPERSONATION_LIFETIME = "bigquery.impersonate.lifetime"
+
+    #: Comma-separated OAuth scopes for the impersonated token. Without an impersonation layer,
+    #: also the base credential's fallback when `AUTHENTICATION_SCOPES` is unset. Discrete
+    #: external-account credentials use that fallback even with an impersonation layer. Scopes
+    #: alone do not turn impersonation on; temporary access tokens remain unchanged.
+    IMPERSONATION_SCOPES = "bigquery.impersonate.scopes"
+
+    #: The service account to impersonate; required when delegates or a lifetime are configured.
+    #: Scopes alone do not enable impersonation.
+    IMPERSONATION_TARGET_PRINCIPAL = "bigquery.impersonate.target_principal"
+
+    #: The default location applied to every query and transaction path.
+    LOCATION = "bigquery.location"
+
+    #: Text such as `my-app/1.0` appended to the `bigquery-adbc/<version>` user agent of REST
+    #: and Storage Read requests, which Cloud Audit Logs record.
+    USER_AGENT = "bigquery.user_agent"
+
+
+class ConnectionOptions(enum.StrEnum):
+    """Options accepted by an ADBC connection."""
+
+    #: Standard ADBC boolean string. With `false`, the first query that needs a session opens
+    #: one for the transaction, kept until autocommit is re-enabled or the connection is
+    #: released.
+    AUTOCOMMIT = "adbc.connection.autocommit"
+
+    #: Standard ADBC current catalog: the project unqualified names resolve in. A connection
+    #: also reports it under `DatabaseOptions.PROJECT_ID`.
+    CURRENT_CATALOG = "adbc.connection.catalog"
+
+    #: Standard ADBC current schema: the dataset unqualified names resolve in. A connection also
+    #: reports it under `DatabaseOptions.DATASET_ID`.
+    CURRENT_DB_SCHEMA = "adbc.connection.db_schema"
+
+    #: Standard ADBC boolean string. Only `false` is supported; use IAM permissions to restrict
+    #: writes.
+    READ_ONLY = "adbc.connection.readonly"
+
+    #: Standard ADBC transaction isolation level. Accepts
+    #: `adbc.connection.transaction.isolation.default` or
+    #: `adbc.connection.transaction.isolation.snapshot`; always reports the latter.
+    ISOLATION_LEVEL = "adbc.connection.transaction.isolation_level"
+
+    #: The bulk-ingest implementation: a `BulkIngestMethod` value.
+    BULK_INGEST_METHOD = "bigquery.bulk_ingest.method"
+
+    #: Boolean string, default `true`: list tables without fetching their constraints. Setting
+    #: `false` includes constraints at tables depth. Column/all depth is unaffected.
+    GET_OBJECTS_SKIP_TABLE_METADATA = "bigquery.get_objects.skip_table_metadata"
+
+    #: Boolean string, default `false`: match GetObjects filters as exact, case-sensitive names,
+    #: treating `%` and `_` literally. GetStatistics is unaffected.
+    GET_OBJECTS_DISABLE_WILDCARDS = "bigquery.get_objects.disable_wildcards"
+
+    #: The maximum number of REST row batches one reader converts concurrently: a positive
+    #: integer, default `10`, also capped by available parallelism. Storage Read ignores it.
+    QUERY_PREFETCH_CONCURRENCY = "bigquery.query.prefetch_concurrency"
+
+    #: Boolean string, default `false`: lets the Storage Read path read several streams in
+    #: parallel and return batches as they arrive, ignoring `ORDER BY`. Rows are never lost or
+    #: duplicated.
+    QUERY_UNORDERED_READ = "bigquery.query.unordered_read"
+
+    #: Boolean string, default `false`: forces query results through REST when `true`. Reports
+    #: the configured value even after automatic fallback. Setting `false` on a connection also
+    #: clears the billing project's cached Storage Read refusal.
+    QUERY_USE_STORAGE_API_DISABLED_CLIENT = "bigquery.query.use_storage_api_disabled_client"
+
+
+class StatementOptions(enum.StrEnum):
+    """Options accepted by an ADBC statement."""
+
+    #: Standard ADBC boolean string, and the portable spelling of `QUERY_PARAMETER_MODE`: `true`
+    #: binds parameters by the bound stream's field names, `false` by position. The two options
+    #: read each other back.
+    BIND_BY_NAME = "adbc.statement.bind_by_name"
+
+    #: The bulk-ingest implementation: a `BulkIngestMethod` value.
+    BULK_INGEST_METHOD = "bigquery.bulk_ingest.method"
+
+    #: Whether the query may create its destination table: a `CreateDisposition` value.
+    QUERY_CREATE_DISPOSITION = "bigquery.query.create_disposition"
+
+    #: Boolean string: asks BigQuery to create a session, independently of the sessions ADBC
+    #: transactions use.
+    QUERY_CREATE_SESSION = "bigquery.query.create_session"
+
+    #: The dataset unqualified names resolve in for this statement; empty restores the
+    #: connection's current schema.
+    QUERY_DEFAULT_DATASET_ID = "bigquery.query.default_dataset_id"
+
+    #: The project of this statement's default dataset; empty restores the connection's current
+    #: catalog.
+    QUERY_DEFAULT_PROJECT_ID = "bigquery.query.default_project_id"
+
+    #: Where the query writes its result, as `[[project.]dataset.]table` completed from the
+    #: effective defaults; empty clears it.
+    QUERY_DESTINATION_TABLE = "bigquery.query.destination_table"
+
+    #: Boolean string: when true the query does not use BigQuery's query cache.
+    QUERY_DISABLE_QUERY_CACHE = "bigquery.query.disable_query_cache"
+
+    #: Boolean string: validates the statement without running it, returning an empty stream
+    #: with the inferred schema. `execute_partitions` rejects it with `INVALID_STATE`.
+    QUERY_DRY_RUN = "bigquery.query.dry_run"
+
+    #: The job timeout in milliseconds; zero clears the override and a negative value is
+    #: rejected.
+    QUERY_JOB_TIMEOUT = "bigquery.query.job_timeout"
+
+    #: Reservation resource name
+    #: `projects/{project}/locations/{location}/reservations/{reservation}`. Empty clears the
+    #: override; `none` requests on-demand billing when permitted by the project's or
+    #: organization's reservation override policy. BigQuery validates the value.
+    QUERY_RESERVATION = "bigquery.query.reservation"
+
+    #: A JSON object of string labels for every query job, such as `{"team":"data"}`; empty or
+    #: `{}` clears them, and `key=value` or comma-separated strings are rejected. Reads back as
+    #: canonical JSON sorted by key.
+    QUERY_LABELS = "bigquery.query.labels"
+
+    #: Boolean string accepted for Go-driver compatibility, but a no-op: a failed job's error
+    #: message ends with its console link either way.
+    QUERY_LINK_FAILED_JOB = "bigquery.query.link_failed_job"
+
+    #: Recognized but returns `NOT_IMPLEMENTED`, because Google deprecated the field. Cap cost
+    #: with `QUERY_MAXIMUM_BYTES_BILLED` instead.
+    QUERY_MAXIMUM_BILLING_TIER = "bigquery.query.max_billing_tier"
+
+    #: The maximum bytes the query may bill; zero clears the override and a negative value is
+    #: rejected.
+    QUERY_MAXIMUM_BYTES_BILLED = "bigquery.query.max_bytes_billed"
+
+    #: How bound parameters are sent: a `ParameterMode` value, `positional` by default.
+    QUERY_PARAMETER_MODE = "bigquery.query.parameter_mode"
+
+    #: Overrides `ConnectionOptions.QUERY_PREFETCH_CONCURRENCY` for one statement.
+    QUERY_PREFETCH_CONCURRENCY = "bigquery.query.prefetch_concurrency"
+
+    #: The query's scheduling priority: a `QueryPriority` value.
+    QUERY_PRIORITY = "bigquery.query.priority"
+
+    #: Overrides `ConnectionOptions.QUERY_UNORDERED_READ` for one statement.
+    QUERY_UNORDERED_READ = "bigquery.query.unordered_read"
+
+    #: Overrides `ConnectionOptions.QUERY_USE_STORAGE_API_DISABLED_CLIENT` for one statement.
+    QUERY_USE_STORAGE_API_DISABLED_CLIENT = "bigquery.query.use_storage_api_disabled_client"
+
+    #: How the query writes to an existing destination table: a `WriteDisposition` value.
+    QUERY_WRITE_DISPOSITION = "bigquery.query.write_disposition"
+
+    #: Standard ADBC bulk-ingest mode: whether the target table is created, appended to,
+    #: replaced, or created and appended to.
+    INGEST_MODE = "adbc.ingest.mode"
+
+    #: Standard ADBC bulk-ingest target table name.
+    INGEST_TARGET_TABLE = "adbc.ingest.target_table"
+
+    #: Standard ADBC bulk-ingest target catalog: the BigQuery project.
+    INGEST_TARGET_CATALOG = "adbc.ingest.target_catalog"
+
+    #: Standard ADBC bulk-ingest target schema: the BigQuery dataset.
+    INGEST_TARGET_DB_SCHEMA = "adbc.ingest.target_db_schema"
+
+    #: Standard ADBC boolean string. Only `false` is supported: bulk ingest writes into a named
+    #: table, never a temporary one.
+    INGEST_TEMPORARY = "adbc.ingest.temporary"
+
+    #: Standard ADBC boolean string. Only `false` is supported: execution returns all partitions
+    #: together.
+    INCREMENTAL = "adbc.statement.exec.incremental"
+
+    #: Read-only double: processed bytes reported at query response boundaries. Read with
+    #: `get_option_float(member.value)`.
+    PROGRESS = "adbc.statement.exec.progress"
+
+    #: Read-only double: final processed bytes, or `0.0` while unknown. Read with
+    #: `get_option_float(member.value)`.
+    MAX_PROGRESS = "adbc.statement.exec.max_progress"
+
+
+class ParameterMode(enum.StrEnum):
+    """BigQuery query parameter binding modes."""
+
+    #: Send bound parameters in field order, for SQL that spells its placeholders `?`. The
+    #: default.
+    POSITIONAL = "positional"
+
+    #: Send each bound parameter under the name of the field it came from, for SQL that spells
+    #: its placeholders `@name`.
+    NAMED = "named"
+
+
+class BulkIngestMethod(enum.StrEnum):
+    """Supported BigQuery bulk-ingest implementations."""
+
+    #: Append rows through the BigQuery Storage Write API. The default, and the only implemented
+    #: method.
+    STORAGE_WRITE = "storage_write"
+
+
+class AuthenticationType(enum.StrEnum):
+    """Supported Google Cloud authentication modes."""
+
+    #: Google Cloud Application Default Credentials, under the Go driver's `auth_bigquery`
+    #: spelling. What an unconfigured database uses.
+    DEFAULT = "auth_bigquery"
+
+    #: Google Cloud Application Default Credentials, under the `app_default_credentials`
+    #: spelling. The same code path as `DEFAULT`.
+    APPLICATION_DEFAULT = "app_default_credentials"
+
+    #: A Google Cloud JSON credential document read from the file path in
+    #: `DatabaseOptions.AUTHENTICATION_CREDENTIALS`.
+    JSON_CREDENTIAL_FILE = "json_credential_file"
+
+    #: A Google Cloud JSON credential document passed inline in
+    #: `DatabaseOptions.AUTHENTICATION_CREDENTIALS`.
+    JSON_CREDENTIAL_STRING = "json_credential_string"
+
+    #: An OAuth client ID, client secret and refresh token, which the driver redeems for access
+    #: tokens.
+    USER_AUTHENTICATION = "user_authentication"
+
+    #: Workload Identity Federation using an OAuth identity-provider token request, configured
+    #: with the `AUTHENTICATION_EXTERNAL_ACCOUNT_*` options.
+    EXTERNAL_ACCOUNT = "external_account"
+
+    #: A caller-supplied short-lived OAuth access token, used as-is. The driver never refreshes
+    #: it, so requests fail once it expires.
+    TEMPORARY_ACCESS_TOKEN = "temporary_access_token"
+
+    #: No credentials at all: requests carry no token. For emulators and for offline tests, and
+    #: incompatible with quota project and impersonation.
+    ANONYMOUS = "anonymous"
+
+
+class CredentialsType(enum.StrEnum):
+    """Supported Google Cloud JSON credential document types."""
+
+    #: A service-account key document.
+    SERVICE_ACCOUNT = "service_account"
+
+    #: A user credential document, as `gcloud auth application-default login` writes.
+    AUTHORIZED_USER = "authorized_user"
+
+    #: A service-account impersonation document, naming a source credential and a target
+    #: principal.
+    IMPERSONATED_SERVICE_ACCOUNT = "impersonated_service_account"
+
+    #: A Workload Identity Federation external-account document.
+    EXTERNAL_ACCOUNT = "external_account"
+
+
+class QueryPriority(enum.StrEnum):
+    """BigQuery query scheduling priorities."""
+
+    #: Queue the query until BigQuery has idle resources for it, outside the concurrent-rate
+    #: limit interactive queries share.
+    BATCH = "BATCH"
+
+    #: Run the query as soon as possible. The default.
+    INTERACTIVE = "INTERACTIVE"
+
+
+class CreateDisposition(enum.StrEnum):
+    """BigQuery destination-table creation behavior."""
+
+    #: Create the destination table if it does not exist. The default.
+    IF_NEEDED = "CREATE_IF_NEEDED"
+
+    #: Require the destination table to exist already, failing the job if it does not.
+    NEVER = "CREATE_NEVER"
+
+
+class WriteDisposition(enum.StrEnum):
+    """BigQuery destination-table write behavior."""
+
+    #: Append the rows to the destination table's existing data.
+    APPEND = "WRITE_APPEND"
+
+    #: Replace the destination table's existing data with the rows written.
+    TRUNCATE = "WRITE_TRUNCATE"
+
+    #: Fail the job unless the destination table is empty. The default.
+    EMPTY = "WRITE_EMPTY"
+
+
+__all__ = [
+    "AuthenticationType",
+    "BulkIngestMethod",
+    "ConnectionOptions",
+    "CreateDisposition",
+    "CredentialsType",
+    "DatabaseOptions",
+    "ParameterMode",
+    "QueryPriority",
+    "StatementOptions",
+    "WriteDisposition",
+]