apache-airflow-providers-google 10.26.0rc1__py3-none-any.whl → 11.0.0__py3-none-any.whl

airflow/providers/google/cloud/hooks/bigquery.py

@@ -26,10 +26,10 @@ import logging
 import re
 import time
 import uuid
+from collections.abc import Iterable, Mapping, Sequence
 from copy import deepcopy
 from datetime import datetime, timedelta
-from functools import cached_property
-from typing import TYPE_CHECKING, Any, Iterable, Mapping, NoReturn, Sequence, Union, cast
+from typing import TYPE_CHECKING, Any, NoReturn, Union, cast
 
 from aiohttp import ClientSession as ClientSession
 from gcloud.aio.bigquery import Job, Table as Table_async
@@ -37,7 +37,6 @@ from google.cloud.bigquery import (
     DEFAULT_RETRY,
     Client,
     CopyJob,
-    ExternalConfig,
     ExtractJob,
     LoadJob,
     QueryJob,
@@ -47,14 +46,13 @@ from google.cloud.bigquery import (
 from google.cloud.bigquery.dataset import AccessEntry, Dataset, DatasetListItem, DatasetReference
 from google.cloud.bigquery.retry import DEFAULT_JOB_RETRY
 from google.cloud.bigquery.table import (
-    EncryptionConfiguration,
     Row,
     RowIterator,
     Table,
     TableReference,
 )
 from google.cloud.exceptions import NotFound
-from googleapiclient.discovery import Resource, build
+from googleapiclient.discovery import build
 from pandas_gbq import read_gbq
 from pandas_gbq.gbq import GbqConnector  # noqa: F401 used in ``airflow.contrib.hooks.bigquery``
 from requests import Session
@@ -159,11 +157,6 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
         labels: dict | None = None,
         **kwargs,
     ) -> None:
-        if kwargs.get("delegate_to") is not None:
-            raise RuntimeError(
-                "The `delegate_to` parameter has been deprecated before and finally removed in this version"
-                " of Google Provider. You MUST convert it to `impersonate_chain`"
-            )
         super().__init__(**kwargs)
         self.use_legacy_sql: bool = self._get_field("use_legacy_sql", use_legacy_sql)
         self.location: str | None = self._get_field("location", location)
@@ -173,15 +166,6 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
         self.labels = self._get_field("labels", labels or {})
         self.impersonation_scopes: str | Sequence[str] | None = impersonation_scopes
 
-    @cached_property
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        reason="This property is no longer in actual use. ",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def credentials_path(self) -> str:
-        return "bigquery_hook_credentials.json"
-
     def get_conn(self) -> BigQueryConnection:
         """Get a BigQuery PEP 249 connection object."""
         http_authorized = self._authorize()
@@ -195,16 +179,6 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
             hook=self,
         )
 
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_client.",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def get_service(self) -> Resource:
-        """Get a BigQuery service object. Deprecated."""
-        http_authorized = self._authorize()
-        return build("bigquery", "v2", http=http_authorized, cache_discovery=False)
-
     def get_client(self, project_id: str = PROVIDE_PROJECT_ID, location: str | None = None) -> Client:
         """
         Get an authenticated BigQuery Client.
@@ -602,165 +576,6 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
             not_found_ok=True,
         )
 
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.create_empty_table",
-        instructions="Use the replacement method with passing the `table_resource` object. "
-        "This gives more flexibility.",
-        category=AirflowProviderDeprecationWarning,
-    )
-    @GoogleBaseHook.fallback_to_default_project_id
-    def create_external_table(
-        self,
-        external_project_dataset_table: str,
-        schema_fields: list,
-        source_uris: list,
-        source_format: str = "CSV",
-        autodetect: bool = False,
-        compression: str = "NONE",
-        ignore_unknown_values: bool = False,
-        max_bad_records: int = 0,
-        skip_leading_rows: int = 0,
-        field_delimiter: str = ",",
-        quote_character: str | None = None,
-        allow_quoted_newlines: bool = False,
-        allow_jagged_rows: bool = False,
-        encoding: str = "UTF-8",
-        src_fmt_configs: dict | None = None,
-        labels: dict | None = None,
-        description: str | None = None,
-        encryption_configuration: dict | None = None,
-        location: str | None = None,
-        project_id: str = PROVIDE_PROJECT_ID,
-    ) -> Table:
-        """
-        Create an external table in the dataset with data from Google Cloud Storage.
-
-        .. seealso:: https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#resource
-
-        This method is deprecated. Please use :func:`.create_empty_table` with
-        the ``table_resource`` object. See function documentation for more
-        details about these parameters.
-
-        :param external_project_dataset_table:
-            The dotted ``(<project>.|<project>:)<dataset>.<table>($<partition>)`` BigQuery
-            table name to create external table.
-            If ``<project>`` is not included, project will be the
-            project defined in the connection json.
-        :param schema_fields: The schema field list as defined here:
-            https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#resource
-        :param source_uris: The source Google Cloud
-            Storage URI (e.g. gs://some-bucket/some-file.txt). A single wild
-            per-object name can be used.
-        :param source_format: File format to export.
-        :param autodetect: Try to detect schema and format options automatically.
-            Any option specified explicitly will be honored.
-        :param compression: [Optional] The compression type of the data source.
-            Possible values include GZIP and NONE.
-            The default value is NONE.
-            This setting is ignored for Google Cloud Bigtable,
-            Google Cloud Datastore backups and Avro formats.
-        :param ignore_unknown_values: [Optional] Indicates if BigQuery should allow
-            extra values that are not represented in the table schema.
-            If true, the extra values are ignored. If false, records with extra columns
-            are treated as bad records, and if there are too many bad records, an
-            invalid error is returned in the job result.
-        :param max_bad_records: The maximum number of bad records that BigQuery can
-            ignore when running the job.
-        :param skip_leading_rows: Number of rows to skip when loading from a CSV.
-        :param field_delimiter: The delimiter to use when loading from a CSV.
-        :param quote_character: The value that is used to quote data sections in a CSV
-            file.
-        :param allow_quoted_newlines: Whether to allow quoted newlines (true) or not
-            (false).
-        :param allow_jagged_rows: Accept rows that are missing trailing optional columns.
-            The missing values are treated as nulls. If false, records with missing
-            trailing columns are treated as bad records, and if there are too many bad
-            records, an invalid error is returned in the job result. Only applicable when
-            source_format is CSV.
-        :param encoding: The character encoding of the data. See:
-
-            .. seealso::
-                https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#externalDataConfiguration.csvOptions.encoding
-        :param src_fmt_configs: configure optional fields specific to the source format
-        :param labels: A dictionary containing labels for the BiqQuery table.
-        :param description: A string containing the description for the BigQuery table.
-        :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys).
-
-            .. code-block:: python
-
-                encryption_configuration = {
-                    "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key",
-                }
-        """
-        location = location or self.location
-        src_fmt_configs = src_fmt_configs or {}
-        source_format = source_format.upper()
-        compression = compression.upper()
-
-        external_config_api_repr = {
-            "autodetect": autodetect,
-            "sourceFormat": source_format,
-            "sourceUris": source_uris,
-            "compression": compression,
-            "ignoreUnknownValues": ignore_unknown_values,
-        }
-
-        # if following fields are not specified in src_fmt_configs,
-        # honor the top-level params for backward-compatibility
-        backward_compatibility_configs = {
-            "skipLeadingRows": skip_leading_rows,
-            "fieldDelimiter": field_delimiter,
-            "quote": quote_character,
-            "allowQuotedNewlines": allow_quoted_newlines,
-            "allowJaggedRows": allow_jagged_rows,
-            "encoding": encoding,
-        }
-        src_fmt_to_param_mapping = {"CSV": "csvOptions", "GOOGLE_SHEETS": "googleSheetsOptions"}
-        src_fmt_to_configs_mapping = {
-            "csvOptions": [
-                "allowJaggedRows",
-                "allowQuotedNewlines",
-                "fieldDelimiter",
-                "skipLeadingRows",
-                "quote",
-                "encoding",
-            ],
-            "googleSheetsOptions": ["skipLeadingRows"],
-        }
-        if source_format in src_fmt_to_param_mapping:
-            valid_configs = src_fmt_to_configs_mapping[src_fmt_to_param_mapping[source_format]]
-            src_fmt_configs = _validate_src_fmt_configs(
-                source_format, src_fmt_configs, valid_configs, backward_compatibility_configs
-            )
-            external_config_api_repr[src_fmt_to_param_mapping[source_format]] = src_fmt_configs
-
-        # build external config
-        external_config = ExternalConfig.from_api_repr(external_config_api_repr)
-        if schema_fields:
-            external_config.schema = [SchemaField.from_api_repr(f) for f in schema_fields]
-        if max_bad_records:
-            external_config.max_bad_records = max_bad_records
-
-        # build table definition
-        table = Table(table_ref=TableReference.from_string(external_project_dataset_table, project_id))
-        table.external_data_configuration = external_config
-        if labels:
-            table.labels = labels
-
-        if description:
-            table.description = description
-
-        if encryption_configuration:
-            table.encryption_configuration = EncryptionConfiguration.from_api_repr(encryption_configuration)
-
-        self.log.info("Creating external table: %s", external_project_dataset_table)
-        table_object = self.create_empty_table(
-            table_resource=table.to_api_repr(), project_id=project_id, location=location, exists_ok=True
-        )
-        self.log.info("External table created successfully: %s", external_project_dataset_table)
-        return table_object
-
     @GoogleBaseHook.fallback_to_default_project_id
     def update_table(
         self,
@@ -804,113 +619,6 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
         self.log.info("Table %s.%s.%s updated successfully", project_id, dataset_id, table_id)
         return table_object.to_api_repr()
 
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.update_table",
-        category=AirflowProviderDeprecationWarning,
-    )
-    @GoogleBaseHook.fallback_to_default_project_id
-    def patch_table(
-        self,
-        dataset_id: str,
-        table_id: str,
-        project_id: str = PROVIDE_PROJECT_ID,
-        description: str | None = None,
-        expiration_time: int | None = None,
-        external_data_configuration: dict | None = None,
-        friendly_name: str | None = None,
-        labels: dict | None = None,
-        schema: list | None = None,
-        time_partitioning: dict | None = None,
-        view: dict | None = None,
-        require_partition_filter: bool | None = None,
-        encryption_configuration: dict | None = None,
-    ) -> None:
-        """
-        Patch information in an existing table.
-
-        It only updates fields that are provided in the request object. This
-        method is deprecated. Please use :func:`.update_table` instead.
-
-        Reference: https://cloud.google.com/bigquery/docs/reference/rest/v2/tables/patch
-
-        :param dataset_id: The dataset containing the table to be patched.
-        :param table_id: The Name of the table to be patched.
-        :param project_id: The project containing the table to be patched.
-        :param description: [Optional] A user-friendly description of this table.
-        :param expiration_time: [Optional] The time when this table expires,
-            in milliseconds since the epoch.
-        :param external_data_configuration: [Optional] A dictionary containing
-            properties of a table stored outside of BigQuery.
-        :param friendly_name: [Optional] A descriptive name for this table.
-        :param labels: [Optional] A dictionary containing labels associated with this table.
-        :param schema: [Optional] If set, the schema field list as defined here:
-            https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.load.schema
-            The supported schema modifications and unsupported schema modification are listed here:
-            https://cloud.google.com/bigquery/docs/managing-table-schemas
-
-            .. code-block:: python
-
-                schema = [
-                    {"name": "emp_name", "type": "STRING", "mode": "REQUIRED"},
-                    {"name": "salary", "type": "INTEGER", "mode": "NULLABLE"},
-                ]
-
-        :param time_partitioning: [Optional] A dictionary containing time-based partitioning
-             definition for the table.
-        :param view: [Optional] A dictionary containing definition for the view.
-            If set, it will patch a view instead of a table:
-            https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#ViewDefinition
-
-            .. code-block:: python
-
-                view = {
-                    "query": "SELECT * FROM `test-project-id.test_dataset_id.test_table_prefix*` LIMIT 500",
-                    "useLegacySql": False,
-                }
-
-        :param require_partition_filter: [Optional] If true, queries over the this table require a
-            partition filter. If false, queries over the table
-        :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys).
-
-            .. code-block:: python
-
-                encryption_configuration = {
-                    "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key",
-                }
-
-        """
-        table_resource: dict[str, Any] = {}
-
-        if description is not None:
-            table_resource["description"] = description
-        if expiration_time is not None:
-            table_resource["expirationTime"] = expiration_time
-        if external_data_configuration:
-            table_resource["externalDataConfiguration"] = external_data_configuration
-        if friendly_name is not None:
-            table_resource["friendlyName"] = friendly_name
-        if labels:
-            table_resource["labels"] = labels
-        if schema:
-            table_resource["schema"] = {"fields": schema}
-        if time_partitioning:
-            table_resource["timePartitioning"] = time_partitioning
-        if view:
-            table_resource["view"] = view
-        if require_partition_filter is not None:
-            table_resource["requirePartitionFilter"] = require_partition_filter
-        if encryption_configuration:
-            table_resource["encryptionConfiguration"] = encryption_configuration
-
-        self.update_table(
-            table_resource=table_resource,
-            fields=list(table_resource.keys()),
-            project_id=project_id,
-            dataset_id=dataset_id,
-            table_id=table_id,
-        )
-
     @GoogleBaseHook.fallback_to_default_project_id
     def insert_all(
         self,
@@ -1014,96 +722,6 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
         self.log.info("Dataset successfully updated: %s", dataset)
         return dataset
 
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.update_dataset",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def patch_dataset(
-        self, dataset_id: str, dataset_resource: dict, project_id: str = PROVIDE_PROJECT_ID
-    ) -> dict:
-        """
-        Patches information in an existing dataset.
-
-        It only replaces fields that are provided in the submitted dataset resource.
-
-        This method is deprecated. Please use :func:`.update_dataset` instead.
-
-        More info:
-        https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets/patch
-
-        :param dataset_id: The BigQuery Dataset ID
-        :param dataset_resource: Dataset resource that will be provided
-            in request body.
-            https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#resource
-        :param project_id: The Google Cloud Project ID
-        """
-        project_id = project_id or self.project_id
-        if not dataset_id or not isinstance(dataset_id, str):
-            raise ValueError(
-                f"dataset_id argument must be provided and has a type 'str'. You provided: {dataset_id}"
-            )
-
-        service = self.get_service()
-        dataset_project_id = project_id or self.project_id
-
-        self.log.info("Start patching dataset: %s:%s", dataset_project_id, dataset_id)
-        dataset = (
-            service.datasets()
-            .patch(
-                datasetId=dataset_id,
-                projectId=dataset_project_id,
-                body=dataset_resource,
-            )
-            .execute(num_retries=self.num_retries)
-        )
-        self.log.info("Dataset successfully patched: %s", dataset)
-
-        return dataset
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_dataset_tables",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def get_dataset_tables_list(
-        self,
-        dataset_id: str,
-        project_id: str = PROVIDE_PROJECT_ID,
-        table_prefix: str | None = None,
-        max_results: int | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        List tables of a BigQuery dataset.
-
-        If a table prefix is specified, only tables beginning by it are
-        returned. This method is deprecated. Please use
-        :func:`.get_dataset_tables` instead.
-
-        For more information, see:
-        https://cloud.google.com/bigquery/docs/reference/rest/v2/tables/list
-
-        :param dataset_id: The BigQuery Dataset ID
-        :param project_id: The Google Cloud Project ID
-        :param table_prefix: Tables must begin by this prefix to be returned (case sensitive)
-        :param max_results: The maximum number of results to return in a single response page.
-            Leverage the page tokens to iterate through the entire collection.
-        :return: List of tables associated with the dataset
-        """
-        project_id = project_id or self.project_id
-        tables = self.get_client().list_tables(
-            dataset=DatasetReference(project=project_id, dataset_id=dataset_id),
-            max_results=max_results,
-        )
-
-        if table_prefix:
-            result = [t.reference.to_api_repr() for t in tables if t.table_id.startswith(table_prefix)]
-        else:
-            result = [t.reference.to_api_repr() for t in tables]
-
-        self.log.info("%s tables found", len(result))
-        return result
-
     @GoogleBaseHook.fallback_to_default_project_id
     def get_datasets_list(
         self,
@@ -1266,29 +884,6 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
             ).to_api_repr()
         return table
 
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.delete_table",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_table_delete(self, deletion_dataset_table: str, ignore_if_missing: bool = False) -> None:
-        """
-        Delete an existing table from the dataset.
-
-        If the table does not exist, return an error unless *ignore_if_missing*
-        is set to True.
-
-        This method is deprecated. Please use :func:`.delete_table` instead.
-
-        :param deletion_dataset_table: A dotted
-            ``(<project>.|<project>:)<dataset>.<table>`` that indicates which table
-            will be deleted.
-        :param ignore_if_missing: if True, then return success even if the
-            requested table does not exist.
-        :return:
-        """
-        return self.delete_table(table_id=deletion_dataset_table, not_found_ok=ignore_if_missing)
-
     @GoogleBaseHook.fallback_to_default_project_id
     def delete_table(
         self,
@@ -1314,47 +909,6 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
         )
         self.log.info("Deleted table %s", table_id)
 
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.list_rows",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def get_tabledata(
-        self,
-        dataset_id: str,
-        table_id: str,
-        max_results: int | None = None,
-        selected_fields: str | None = None,
-        page_token: str | None = None,
-        start_index: int | None = None,
-    ) -> list[dict]:
-        """
-        Get data from given table.
-
-        This method is deprecated. Please use :func:`.list_rows` instead.
-
-        .. seealso:: https://cloud.google.com/bigquery/docs/reference/v2/tabledata/list
-
-        :param dataset_id: the dataset ID of the requested table.
-        :param table_id: the table ID of the requested table.
-        :param max_results: the maximum results to return.
-        :param selected_fields: List of fields to return (comma-separated). If
-            unspecified, all fields are returned.
-        :param page_token: page token, returned from a previous call,
-            identifying the result set.
-        :param start_index: zero based index of the starting row to read.
-        :return: list of rows
-        """
-        rows = self.list_rows(
-            dataset_id=dataset_id,
-            table_id=table_id,
-            max_results=max_results,
-            selected_fields=selected_fields,
-            page_token=page_token,
-            start_index=start_index,
-        )
-        return [dict(r) for r in rows]
-
     @GoogleBaseHook.fallback_to_default_project_id
     def list_rows(
         self,
@@ -1551,18 +1105,6 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
         job = self.get_client(project_id=project_id, location=location).get_job(job_id=job_id)
         return job.done(retry=retry)
 
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.cancel_job",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def cancel_query(self) -> None:
-        """Cancel all started queries that have not yet completed."""
-        if self.running_job_id:
-            self.cancel_job(job_id=self.running_job_id)
-        else:
-            self.log.info("No running BigQuery jobs to cancel.")
-
     @GoogleBaseHook.fallback_to_default_project_id
     def cancel_job(
         self,
@@ -1705,701 +1247,51 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
             job_api_repr.result(timeout=timeout, retry=retry)
         return job_api_repr
 
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.insert_job",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_with_configuration(self, configuration: dict) -> str:
-        """
-        Execute a BigQuery SQL query.
-
-        .. seealso:: https://cloud.google.com/bigquery/docs/reference/v2/jobs
-
-        This method is deprecated. Please use :func:`.insert_job` instead.
-
-        :param configuration: The configuration parameter maps directly to
-            BigQuery's configuration field in the job object. See
-            https://cloud.google.com/bigquery/docs/reference/v2/jobs for
-            details.
-        """
-        job = self.insert_job(configuration=configuration, project_id=self.project_id)
-        self.running_job_id = job.job_id
-        return job.job_id
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.insert_job",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_load(
-        self,
-        destination_project_dataset_table: str,
-        source_uris: list,
-        schema_fields: list | None = None,
-        source_format: str = "CSV",
-        create_disposition: str = "CREATE_IF_NEEDED",
-        skip_leading_rows: int = 0,
-        write_disposition: str = "WRITE_EMPTY",
-        field_delimiter: str = ",",
-        max_bad_records: int = 0,
-        quote_character: str | None = None,
-        ignore_unknown_values: bool = False,
-        allow_quoted_newlines: bool = False,
-        allow_jagged_rows: bool = False,
-        encoding: str = "UTF-8",
-        schema_update_options: Iterable | None = None,
-        src_fmt_configs: dict | None = None,
-        time_partitioning: dict | None = None,
-        cluster_fields: list | None = None,
-        autodetect: bool = False,
-        encryption_configuration: dict | None = None,
-        labels: dict | None = None,
-        description: str | None = None,
-    ) -> str:
-        """
-        Load data from Google Cloud Storage to BigQuery.
-
-        .. seealso:: https://cloud.google.com/bigquery/docs/reference/v2/jobs
-
-        This method is deprecated. Please use :func:`.insert_job` instead.
-
-        :param destination_project_dataset_table:
-            The dotted ``(<project>.|<project>:)<dataset>.<table>($<partition>)`` BigQuery
-            table to load data into. If ``<project>`` is not included, project will be the
-            project defined in the connection json. If a partition is specified the
-            operator will automatically append the data, create a new partition or create
-            a new DAY partitioned table.
-        :param schema_fields: The schema field list as defined here:
-            https://cloud.google.com/bigquery/docs/reference/v2/jobs#configuration.load
-            Required if autodetect=False; optional if autodetect=True.
-        :param autodetect: Attempt to autodetect the schema for CSV and JSON
-            source files.
-        :param source_uris: The source Google Cloud
-            Storage URI (e.g. gs://some-bucket/some-file.txt). A single wild
-            per-object name can be used.
-        :param source_format: File format to export.
-        :param create_disposition: The create disposition if the table doesn't exist.
-        :param skip_leading_rows: Number of rows to skip when loading from a CSV.
-        :param write_disposition: The write disposition if the table already exists.
-        :param field_delimiter: The delimiter to use when loading from a CSV.
-        :param max_bad_records: The maximum number of bad records that BigQuery can
-            ignore when running the job.
-        :param quote_character: The value that is used to quote data sections in a CSV
-            file.
-        :param ignore_unknown_values: [Optional] Indicates if BigQuery should allow
-            extra values that are not represented in the table schema.
-            If true, the extra values are ignored. If false, records with extra columns
-            are treated as bad records, and if there are too many bad records, an
-            invalid error is returned in the job result.
-        :param allow_quoted_newlines: Whether to allow quoted newlines (true) or not
-            (false).
-        :param allow_jagged_rows: Accept rows that are missing trailing optional columns.
-            The missing values are treated as nulls. If false, records with missing
-            trailing columns are treated as bad records, and if there are too many bad
-            records, an invalid error is returned in the job result. Only applicable when
-            source_format is CSV.
-        :param encoding: The character encoding of the data.
+    def generate_job_id(self, job_id, dag_id, task_id, logical_date, configuration, force_rerun=False) -> str:
+        if force_rerun:
+            hash_base = str(uuid.uuid4())
+        else:
+            hash_base = json.dumps(configuration, sort_keys=True)
 
-            .. seealso::
-                https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#externalDataConfiguration.csvOptions.encoding
-        :param schema_update_options: Allows the schema of the destination
-            table to be updated as a side effect of the load job.
-        :param src_fmt_configs: configure optional fields specific to the source format
-        :param time_partitioning: configure optional time partitioning fields i.e.
-            partition by field, type and  expiration as per API specifications.
-        :param cluster_fields: Request that the result of this load be stored sorted
-            by one or more columns. BigQuery supports clustering for both partitioned and
-            non-partitioned tables. The order of columns given determines the sort order.
-        :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys).
+        uniqueness_suffix = md5(hash_base.encode()).hexdigest()
 
-            .. code-block:: python
+        if job_id:
+            return f"{job_id}_{uniqueness_suffix}"
 
-                encryption_configuration = {
-                    "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key",
-                }
+        exec_date = logical_date.isoformat()
+        job_id = f"airflow_{dag_id}_{task_id}_{exec_date}_{uniqueness_suffix}"
+        return re.sub(r"[:\-+.]", "_", job_id)
 
-        :param labels: A dictionary containing labels for the BiqQuery table.
-        :param description: A string containing the description for the BigQuery table.
-        """
-        if not self.project_id:
-            raise ValueError("The project_id should be set")
+    def split_tablename(
+        self, table_input: str, default_project_id: str, var_name: str | None = None
+    ) -> tuple[str, str, str]:
+        if "." not in table_input:
+            raise ValueError(f"Expected table name in the format of <dataset>.<table>. Got: {table_input}")
 
-        # To provide backward compatibility
-        schema_update_options = list(schema_update_options or [])
+        if not default_project_id:
+            raise ValueError("INTERNAL: No default project is specified")
 
-        # bigquery only allows certain source formats
-        # we check to make sure the passed source format is valid
-        # if it's not, we raise a ValueError
-        # Refer to this link for more details:
-        #   https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.query.tableDefinitions.(key).sourceFormat
-
-        if schema_fields is None and not autodetect:
-            raise ValueError("You must either pass a schema or autodetect=True.")
-
-        if src_fmt_configs is None:
-            src_fmt_configs = {}
-
-        source_format = source_format.upper()
-        allowed_formats = [
-            "CSV",
-            "NEWLINE_DELIMITED_JSON",
-            "AVRO",
-            "GOOGLE_SHEETS",
-            "DATASTORE_BACKUP",
-            "PARQUET",
-        ]
-        if source_format not in allowed_formats:
-            raise ValueError(
-                f"{source_format} is not a valid source format. "
-                f"Please use one of the following types: {allowed_formats}."
-            )
+        def var_print(var_name):
+            if var_name is None:
+                return ""
+            else:
+                return f"Format exception for {var_name}: "
 
-        # bigquery also allows you to define how you want a table's schema to change
-        # as a side effect of a load
-        # for more details:
-        # https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.load.schemaUpdateOptions
-        allowed_schema_update_options = ["ALLOW_FIELD_ADDITION", "ALLOW_FIELD_RELAXATION"]
-        if not set(allowed_schema_update_options).issuperset(set(schema_update_options)):
+        if table_input.count(".") + table_input.count(":") > 3:
+            raise ValueError(f"{var_print(var_name)}Use either : or . to specify project got {table_input}")
+        cmpt = table_input.rsplit(":", 1)
+        project_id = None
+        rest = table_input
+        if len(cmpt) == 1:
+            project_id = None
+            rest = cmpt[0]
+        elif len(cmpt) == 2 and cmpt[0].count(":") <= 1:
+            if cmpt[-1].count(".") != 2:
+                project_id = cmpt[0]
+                rest = cmpt[1]
+        else:
             raise ValueError(
-                f"{schema_update_options} contains invalid schema update options. "
-                f"Please only use one or more of the following options: {allowed_schema_update_options}"
-            )
-
-        destination_project, destination_dataset, destination_table = self.split_tablename(
-            table_input=destination_project_dataset_table,
-            default_project_id=self.project_id,
-            var_name="destination_project_dataset_table",
-        )
-
-        configuration: dict[str, Any] = {
-            "load": {
-                "autodetect": autodetect,
-                "createDisposition": create_disposition,
-                "destinationTable": {
-                    "projectId": destination_project,
-                    "datasetId": destination_dataset,
-                    "tableId": destination_table,
-                },
-                "sourceFormat": source_format,
-                "sourceUris": source_uris,
-                "writeDisposition": write_disposition,
-                "ignoreUnknownValues": ignore_unknown_values,
-            }
-        }
-
-        time_partitioning = _cleanse_time_partitioning(destination_project_dataset_table, time_partitioning)
-        if time_partitioning:
-            configuration["load"].update({"timePartitioning": time_partitioning})
-
-        if cluster_fields:
-            configuration["load"].update({"clustering": {"fields": cluster_fields}})
-
-        if schema_fields:
-            configuration["load"]["schema"] = {"fields": schema_fields}
-
-        if schema_update_options:
-            if write_disposition not in ["WRITE_APPEND", "WRITE_TRUNCATE"]:
-                raise ValueError(
-                    "schema_update_options is only "
-                    "allowed if write_disposition is "
-                    "'WRITE_APPEND' or 'WRITE_TRUNCATE'."
-                )
-            else:
-                self.log.info("Adding experimental 'schemaUpdateOptions': %s", schema_update_options)
-                configuration["load"]["schemaUpdateOptions"] = schema_update_options
-
-        if max_bad_records:
-            configuration["load"]["maxBadRecords"] = max_bad_records
-
-        if encryption_configuration:
-            configuration["load"]["destinationEncryptionConfiguration"] = encryption_configuration
-
-        if labels or description:
-            configuration["load"].update({"destinationTableProperties": {}})
-
-            if labels:
-                configuration["load"]["destinationTableProperties"]["labels"] = labels
-
-            if description:
-                configuration["load"]["destinationTableProperties"]["description"] = description
-
-        src_fmt_to_configs_mapping = {
-            "CSV": [
-                "allowJaggedRows",
-                "allowQuotedNewlines",
-                "autodetect",
-                "fieldDelimiter",
-                "skipLeadingRows",
-                "ignoreUnknownValues",
-                "nullMarker",
-                "quote",
-                "encoding",
-                "preserveAsciiControlCharacters",
-            ],
-            "DATASTORE_BACKUP": ["projectionFields"],
-            "NEWLINE_DELIMITED_JSON": ["autodetect", "ignoreUnknownValues"],
-            "PARQUET": ["autodetect", "ignoreUnknownValues"],
-            "AVRO": ["useAvroLogicalTypes"],
-        }
-
-        valid_configs = src_fmt_to_configs_mapping[source_format]
-
-        # if following fields are not specified in src_fmt_configs,
-        # honor the top-level params for backward-compatibility
-        backward_compatibility_configs = {
-            "skipLeadingRows": skip_leading_rows,
-            "fieldDelimiter": field_delimiter,
-            "ignoreUnknownValues": ignore_unknown_values,
-            "quote": quote_character,
-            "allowQuotedNewlines": allow_quoted_newlines,
-            "encoding": encoding,
-        }
-
-        src_fmt_configs = _validate_src_fmt_configs(
-            source_format, src_fmt_configs, valid_configs, backward_compatibility_configs
-        )
-
-        configuration["load"].update(src_fmt_configs)
-
-        if allow_jagged_rows:
-            configuration["load"]["allowJaggedRows"] = allow_jagged_rows
-
-        job = self.insert_job(configuration=configuration, project_id=self.project_id)
-        self.running_job_id = job.job_id
-        return job.job_id
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.insert_job",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_copy(
-        self,
-        source_project_dataset_tables: list | str,
-        destination_project_dataset_table: str,
-        write_disposition: str = "WRITE_EMPTY",
-        create_disposition: str = "CREATE_IF_NEEDED",
-        labels: dict | None = None,
-        encryption_configuration: dict | None = None,
-    ) -> str:
-        """
-        Copy data from one BigQuery table to another.
-
-        .. seealso:: https://cloud.google.com/bigquery/docs/reference/v2/jobs#configuration.copy
-
-        This method is deprecated. Please use :func:`.insert_job` instead.
-
-        :param source_project_dataset_tables: One or more dotted
-            ``(project:|project.)<dataset>.<table>``
-            BigQuery tables to use as the source data. Use a list if there are
-            multiple source tables.
-            If ``<project>`` is not included, project will be the project defined
-            in the connection json.
-        :param destination_project_dataset_table: The destination BigQuery
-            table. Format is: ``(project:|project.)<dataset>.<table>``
-        :param write_disposition: The write disposition if the table already exists.
-        :param create_disposition: The create disposition if the table doesn't exist.
-        :param labels: a dictionary containing labels for the job/query,
-            passed to BigQuery
-        :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys).
-
-            .. code-block:: python
-
-                    encryption_configuration = {
-                        "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key",
-                    }
-        """
-        if not self.project_id:
-            raise ValueError("The project_id should be set")
-
-        source_project_dataset_tables = (
-            [source_project_dataset_tables]
-            if not isinstance(source_project_dataset_tables, list)
-            else source_project_dataset_tables
-        )
-
-        source_project_dataset_tables_fixup = []
-        for source_project_dataset_table in source_project_dataset_tables:
-            source_project, source_dataset, source_table = self.split_tablename(
-                table_input=source_project_dataset_table,
-                default_project_id=self.project_id,
-                var_name="source_project_dataset_table",
-            )
-            source_project_dataset_tables_fixup.append(
-                {"projectId": source_project, "datasetId": source_dataset, "tableId": source_table}
-            )
-
-        destination_project, destination_dataset, destination_table = self.split_tablename(
-            table_input=destination_project_dataset_table, default_project_id=self.project_id
-        )
-        configuration = {
-            "copy": {
-                "createDisposition": create_disposition,
-                "writeDisposition": write_disposition,
-                "sourceTables": source_project_dataset_tables_fixup,
-                "destinationTable": {
-                    "projectId": destination_project,
-                    "datasetId": destination_dataset,
-                    "tableId": destination_table,
-                },
-            }
-        }
-
-        if labels:
-            configuration["labels"] = labels
-
-        if encryption_configuration:
-            configuration["copy"]["destinationEncryptionConfiguration"] = encryption_configuration
-
-        job = self.insert_job(configuration=configuration, project_id=self.project_id)
-        self.running_job_id = job.job_id
-        return job.job_id
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.insert_job",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_extract(
-        self,
-        source_project_dataset_table: str,
-        destination_cloud_storage_uris: list[str],
-        compression: str = "NONE",
-        export_format: str = "CSV",
-        field_delimiter: str = ",",
-        print_header: bool = True,
-        labels: dict | None = None,
-        return_full_job: bool = False,
-    ) -> str | BigQueryJob:
-        """
-        Copy data from BigQuery to Google Cloud Storage.
-
-        .. seealso:: https://cloud.google.com/bigquery/docs/reference/v2/jobs
-
-        This method is deprecated. Please use :func:`.insert_job` instead.
-
-        :param source_project_dataset_table: The dotted ``<dataset>.<table>``
-            BigQuery table to use as the source data.
-        :param destination_cloud_storage_uris: The destination Google Cloud
-            Storage URI (e.g. gs://some-bucket/some-file.txt). Follows
-            convention defined here:
-            https://cloud.google.com/bigquery/exporting-data-from-bigquery#exportingmultiple
-        :param compression: Type of compression to use.
-        :param export_format: File format to export.
-        :param field_delimiter: The delimiter to use when extracting to a CSV.
-        :param print_header: Whether to print a header for a CSV file extract.
-        :param labels: a dictionary containing labels for the job/query,
-            passed to BigQuery
-        :param return_full_job: return full job instead of job id only
-        """
-        if not self.project_id:
-            raise ValueError("The project_id should be set")
-
-        source_project, source_dataset, source_table = self.split_tablename(
-            table_input=source_project_dataset_table,
-            default_project_id=self.project_id,
-            var_name="source_project_dataset_table",
-        )
-
-        configuration: dict[str, Any] = {
-            "extract": {
-                "sourceTable": {
-                    "projectId": source_project,
-                    "datasetId": source_dataset,
-                    "tableId": source_table,
-                },
-                "compression": compression,
-                "destinationUris": destination_cloud_storage_uris,
-                "destinationFormat": export_format,
-            }
-        }
-
-        if labels:
-            configuration["labels"] = labels
-
-        if export_format == "CSV":
-            # Only set fieldDelimiter and printHeader fields if using CSV.
-            # Google does not like it if you set these fields for other export
-            # formats.
-            configuration["extract"]["fieldDelimiter"] = field_delimiter
-            configuration["extract"]["printHeader"] = print_header
-
-        job = self.insert_job(configuration=configuration, project_id=self.project_id)
-        self.running_job_id = job.job_id
-        if return_full_job:
-            return job
-        return job.job_id
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.insert_job",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_query(
-        self,
-        sql: str,
-        destination_dataset_table: str | None = None,
-        write_disposition: str = "WRITE_EMPTY",
-        allow_large_results: bool = False,
-        flatten_results: bool | None = None,
-        udf_config: list | None = None,
-        use_legacy_sql: bool | None = None,
-        maximum_billing_tier: int | None = None,
-        maximum_bytes_billed: float | None = None,
-        create_disposition: str = "CREATE_IF_NEEDED",
-        query_params: list | None = None,
-        labels: dict | None = None,
-        schema_update_options: Iterable | None = None,
-        priority: str | None = None,
-        time_partitioning: dict | None = None,
-        api_resource_configs: dict | None = None,
-        cluster_fields: list[str] | None = None,
-        location: str | None = None,
-        encryption_configuration: dict | None = None,
-    ) -> str:
-        """
-        Execute a BigQuery SQL query.
-
-        Optionally persists results in a BigQuery table.
-
-        .. seealso:: https://cloud.google.com/bigquery/docs/reference/v2/jobs
-
-        This method is deprecated. Please use :func:`.insert_job` instead.
-
-        For more details about these parameters.
-
-        :param sql: The BigQuery SQL to execute.
-        :param destination_dataset_table: The dotted ``<dataset>.<table>``
-            BigQuery table to save the query results.
-        :param write_disposition: What to do if the table already exists in
-            BigQuery.
-        :param allow_large_results: Whether to allow large results.
-        :param flatten_results: If true and query uses legacy SQL dialect, flattens
-            all nested and repeated fields in the query results. ``allowLargeResults``
-            must be true if this is set to false. For standard SQL queries, this
-            flag is ignored and results are never flattened.
-        :param udf_config: The User Defined Function configuration for the query.
-            See https://cloud.google.com/bigquery/user-defined-functions for details.
-        :param use_legacy_sql: Whether to use legacy SQL (true) or standard SQL (false).
-            If `None`, defaults to `self.use_legacy_sql`.
-        :param api_resource_configs: a dictionary that contain params
-            'configuration' applied for Google BigQuery Jobs API:
-            https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs
-            for example, {'query': {'useQueryCache': False}}. You could use it
-            if you need to provide some params that are not supported by the
-            BigQueryHook like args.
-        :param maximum_billing_tier: Positive integer that serves as a
-            multiplier of the basic price.
-        :param maximum_bytes_billed: Limits the bytes billed for this job.
-            Queries that will have bytes billed beyond this limit will fail
-            (without incurring a charge). If unspecified, this will be
-            set to your project default.
-        :param create_disposition: Specifies whether the job is allowed to
-            create new tables.
-        :param query_params: a list of dictionary containing query parameter types and
-            values, passed to BigQuery
-        :param labels: a dictionary containing labels for the job/query,
-            passed to BigQuery
-        :param schema_update_options: Allows the schema of the destination
-            table to be updated as a side effect of the query job.
-        :param priority: Specifies a priority for the query.
-            Possible values include INTERACTIVE and BATCH.
-            If `None`, defaults to `self.priority`.
-        :param time_partitioning: configure optional time partitioning fields i.e.
-            partition by field, type and expiration as per API specifications.
-        :param cluster_fields: Request that the result of this query be stored sorted
-            by one or more columns. BigQuery supports clustering for both partitioned and
-            non-partitioned tables. The order of columns given determines the sort order.
-        :param location: The geographic location of the job. Required except for
-            US and EU. See details at
-            https://cloud.google.com/bigquery/docs/locations#specifying_your_location
-        :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys).
-
-            .. code-block:: python
-
-                    encryption_configuration = {
-                        "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key",
-                    }
-        """
-        if not self.project_id:
-            raise ValueError("The project_id should be set")
-
-        labels = labels or self.labels
-        schema_update_options = list(schema_update_options or [])
-
-        priority = priority or self.priority
-
-        if time_partitioning is None:
-            time_partitioning = {}
-
-        if not api_resource_configs:
-            api_resource_configs = self.api_resource_configs
-        else:
-            _validate_value("api_resource_configs", api_resource_configs, dict)
-        configuration = deepcopy(api_resource_configs)
-        if "query" not in configuration:
-            configuration["query"] = {}
-
-        else:
-            _validate_value("api_resource_configs['query']", configuration["query"], dict)
-
-        if sql is None and not configuration["query"].get("query", None):
-            raise TypeError("`BigQueryBaseCursor.run_query` missing 1 required positional argument: `sql`")
-
-        # BigQuery also allows you to define how you want a table's schema to change
-        # as a side effect of a query job
-        # for more details:
-        #   https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.query.schemaUpdateOptions
-
-        allowed_schema_update_options = ["ALLOW_FIELD_ADDITION", "ALLOW_FIELD_RELAXATION"]
-
-        if not set(allowed_schema_update_options).issuperset(set(schema_update_options)):
-            raise ValueError(
-                f"{schema_update_options} contains invalid schema update options."
-                f" Please only use one or more of the following options: {allowed_schema_update_options}"
-            )
-
-        if schema_update_options:
-            if write_disposition not in ["WRITE_APPEND", "WRITE_TRUNCATE"]:
-                raise ValueError(
-                    "schema_update_options is only "
-                    "allowed if write_disposition is "
-                    "'WRITE_APPEND' or 'WRITE_TRUNCATE'."
-                )
-
-        if destination_dataset_table:
-            destination_project, destination_dataset, destination_table = self.split_tablename(
-                table_input=destination_dataset_table, default_project_id=self.project_id
-            )
-
-            destination_dataset_table = {  # type: ignore
-                "projectId": destination_project,
-                "datasetId": destination_dataset,
-                "tableId": destination_table,
-            }
-
-        if cluster_fields:
-            cluster_fields = {"fields": cluster_fields}  # type: ignore
-
-        query_param_list: list[tuple[Any, str, str | bool | None | dict, type | tuple[type]]] = [
-            (sql, "query", None, (str,)),
-            (priority, "priority", priority, (str,)),
-            (use_legacy_sql, "useLegacySql", self.use_legacy_sql, bool),
-            (query_params, "queryParameters", None, list),
-            (udf_config, "userDefinedFunctionResources", None, list),
-            (maximum_billing_tier, "maximumBillingTier", None, int),
-            (maximum_bytes_billed, "maximumBytesBilled", None, float),
-            (time_partitioning, "timePartitioning", {}, dict),
-            (schema_update_options, "schemaUpdateOptions", None, list),
-            (destination_dataset_table, "destinationTable", None, dict),
-            (cluster_fields, "clustering", None, dict),
-        ]
-
-        for param, param_name, param_default, param_type in query_param_list:
-            if param_name not in configuration["query"] and param in [None, {}, ()]:
-                if param_name == "timePartitioning":
-                    param_default = _cleanse_time_partitioning(destination_dataset_table, time_partitioning)
-                param = param_default
-
-            if param in [None, {}, ()]:
-                continue
-
-            _api_resource_configs_duplication_check(param_name, param, configuration["query"])
-
-            configuration["query"][param_name] = param
-
-            # check valid type of provided param,
-            # it last step because we can get param from 2 sources,
-            # and first of all need to find it
-
-            _validate_value(param_name, configuration["query"][param_name], param_type)
-
-            if param_name == "schemaUpdateOptions" and param:
-                self.log.info("Adding experimental 'schemaUpdateOptions': %s", schema_update_options)
-
-            if param_name == "destinationTable":
-                for key in ["projectId", "datasetId", "tableId"]:
-                    if key not in configuration["query"]["destinationTable"]:
-                        raise ValueError(
-                            "Not correct 'destinationTable' in "
-                            "api_resource_configs. 'destinationTable' "
-                            "must be a dict with {'projectId':'', "
-                            "'datasetId':'', 'tableId':''}"
-                        )
-                else:
-                    configuration["query"].update(
-                        {
-                            "allowLargeResults": allow_large_results,
-                            "flattenResults": flatten_results,
-                            "writeDisposition": write_disposition,
-                            "createDisposition": create_disposition,
-                        }
-                    )
-
-        if (
-            "useLegacySql" in configuration["query"]
-            and configuration["query"]["useLegacySql"]
-            and "queryParameters" in configuration["query"]
-        ):
-            raise ValueError("Query parameters are not allowed when using legacy SQL")
-
-        if labels:
-            _api_resource_configs_duplication_check("labels", labels, configuration)
-            configuration["labels"] = labels
-
-        if encryption_configuration:
-            configuration["query"]["destinationEncryptionConfiguration"] = encryption_configuration
-
-        job = self.insert_job(configuration=configuration, project_id=self.project_id, location=location)
-        self.running_job_id = job.job_id
-        return job.job_id
-
-    def generate_job_id(self, job_id, dag_id, task_id, logical_date, configuration, force_rerun=False) -> str:
-        if force_rerun:
-            hash_base = str(uuid.uuid4())
-        else:
-            hash_base = json.dumps(configuration, sort_keys=True)
-
-        uniqueness_suffix = md5(hash_base.encode()).hexdigest()
-
-        if job_id:
-            return f"{job_id}_{uniqueness_suffix}"
-
-        exec_date = logical_date.isoformat()
-        job_id = f"airflow_{dag_id}_{task_id}_{exec_date}_{uniqueness_suffix}"
-        return re.sub(r"[:\-+.]", "_", job_id)
-
-    def split_tablename(
-        self, table_input: str, default_project_id: str, var_name: str | None = None
-    ) -> tuple[str, str, str]:
-        if "." not in table_input:
-            raise ValueError(f"Expected table name in the format of <dataset>.<table>. Got: {table_input}")
-
-        if not default_project_id:
-            raise ValueError("INTERNAL: No default project is specified")
-
-        def var_print(var_name):
-            if var_name is None:
-                return ""
-            else:
-                return f"Format exception for {var_name}: "
-
-        if table_input.count(".") + table_input.count(":") > 3:
-            raise ValueError(f"{var_print(var_name)}Use either : or . to specify project got {table_input}")
-        cmpt = table_input.rsplit(":", 1)
-        project_id = None
-        rest = table_input
-        if len(cmpt) == 1:
-            project_id = None
-            rest = cmpt[0]
-        elif len(cmpt) == 2 and cmpt[0].count(":") <= 1:
-            if cmpt[-1].count(".") != 2:
-                project_id = cmpt[0]
-                rest = cmpt[1]
-        else:
-            raise ValueError(
-                f"{var_print(var_name)}Expect format of (<project:)<dataset>.<table>, got {table_input}"
+                f"{var_print(var_name)}Expect format of (<project:)<dataset>.<table>, got {table_input}"
             )
 
         cmpt = rest.split(".")
@@ -2548,343 +1440,6 @@ class BigQueryBaseCursor(LoggingMixin):
         self.labels = labels
         self.hook = hook
 
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.create_empty_table",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def create_empty_table(self, *args, **kwargs):
-        """
-        Create empty table. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.create_empty_table`
-        instead.
-        """
-        return self.hook.create_empty_table(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.create_empty_dataset",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def create_empty_dataset(self, *args, **kwargs) -> dict[str, Any]:
-        """
-        Create empty dataset. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.create_empty_dataset`
-        instead.
-        """
-        return self.hook.create_empty_dataset(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_dataset_tables",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def get_dataset_tables(self, *args, **kwargs) -> list[dict[str, Any]]:
-        """
-        Get dataset tables. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_dataset_tables`
-        instead.
-        """
-        return self.hook.get_dataset_tables(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.delete_dataset",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def delete_dataset(self, *args, **kwargs) -> None:
-        """
-        Delete dataset. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.delete_dataset`
-        instead.
-        """
-        return self.hook.delete_dataset(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.create_external_table",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def create_external_table(self, *args, **kwargs):
-        """
-        Create external table. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.create_external_table`
-        instead.
-        """
-        return self.hook.create_external_table(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.patch_table",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def patch_table(self, *args, **kwargs) -> None:
-        """
-        Patch table. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.patch_table`
-        instead.
-        """
-        return self.hook.patch_table(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.insert_all",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def insert_all(self, *args, **kwargs) -> None:
-        """
-        Insert all. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.insert_all`
-        instead.
-        """
-        return self.hook.insert_all(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.update_dataset",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def update_dataset(self, *args, **kwargs) -> dict:
-        """
-        Update dataset. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.update_dataset`
-        instead.
-        """
-        return Dataset.to_api_repr(self.hook.update_dataset(*args, **kwargs))
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.patch_dataset",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def patch_dataset(self, *args, **kwargs) -> dict:
-        """
-        Patch dataset. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.patch_dataset`
-        instead.
-        """
-        return self.hook.patch_dataset(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_dataset_tables_list",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def get_dataset_tables_list(self, *args, **kwargs) -> list[dict[str, Any]]:
-        """
-        Get dataset tables list. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_dataset_tables_list`
-        instead.
-        """
-        return self.hook.get_dataset_tables_list(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_datasets_list",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def get_datasets_list(self, *args, **kwargs) -> list | HTTPIterator:
-        """
-        Get datasets list. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_datasets_list`
-        instead.
-        """
-        return self.hook.get_datasets_list(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_dataset",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def get_dataset(self, *args, **kwargs) -> Dataset:
-        """
-        Get dataset. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_dataset`
-        instead.
-        """
-        return self.hook.get_dataset(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_grant_dataset_view_access",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_grant_dataset_view_access(self, *args, **kwargs) -> dict:
-        """
-        Grant view access to dataset. DEPRECATED.
-
-        Please use
-        :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_grant_dataset_view_access`
-        instead.
-        """
-        return self.hook.run_grant_dataset_view_access(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_table_upsert",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_table_upsert(self, *args, **kwargs) -> dict:
-        """
-        Upsert table. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_table_upsert`
-        instead.
-        """
-        return self.hook.run_table_upsert(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_table_delete",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_table_delete(self, *args, **kwargs) -> None:
-        """
-        Delete table. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_table_delete`
-        instead.
-        """
-        return self.hook.run_table_delete(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_tabledata",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def get_tabledata(self, *args, **kwargs) -> list[dict]:
-        """
-        Get table data. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_tabledata`
-        instead.
-        """
-        return self.hook.get_tabledata(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_schema",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def get_schema(self, *args, **kwargs) -> dict:
-        """
-        Get Schema. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_schema`
-        instead.
-        """
-        return self.hook.get_schema(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.poll_job_complete",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def poll_job_complete(self, *args, **kwargs) -> bool:
-        """
-        Poll for job completion.DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.poll_job_complete`
-        instead.
-        """
-        return self.hook.poll_job_complete(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.cancel_query",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def cancel_query(self, *args, **kwargs) -> None:
-        """
-        Cancel query. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.cancel_query`
-        instead.
-        """
-        return self.hook.cancel_query(*args, **kwargs)  # type: ignore
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_with_configuration",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_with_configuration(self, *args, **kwargs) -> str:
-        """
-        Run with configuration. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_with_configuration`
-        instead.
-        """
-        return self.hook.run_with_configuration(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_load",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_load(self, *args, **kwargs) -> str:
-        """
-        Run load. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_load`
-        instead.
-        """
-        return self.hook.run_load(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_copy",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_copy(self, *args, **kwargs) -> str:
-        """
-        Run copy. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_copy`
-        instead.
-        """
-        return self.hook.run_copy(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_extract",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_extract(self, *args, **kwargs) -> str | BigQueryJob:
-        """
-        Run extraction. DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_extract`
-        instead.
-        """
-        return self.hook.run_extract(*args, **kwargs)
-
-    @deprecated(
-        planned_removal_date="November 01, 2024",
-        use_instead="airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_query",
-        category=AirflowProviderDeprecationWarning,
-    )
-    def run_query(self, *args, **kwargs) -> str:
-        """
-        Run query.  DEPRECATED.
-
-        Please use :func:`~airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_query`
-        instead.
-        """
-        return self.hook.run_query(*args, **kwargs)
-
 
 class BigQueryCursor(BigQueryBaseCursor):
     """
@@ -3541,7 +2096,7 @@ class BigQueryAsyncHook(GoogleBaseAsyncHook):
             query_request = {
                 "query": "SELECT partition_id "
                 f"FROM `{project_id}.{dataset_id}.INFORMATION_SCHEMA.PARTITIONS`"
-                + (f" WHERE table_id={table_id}" if table_id else ""),
+                + (f" WHERE table_name='{table_id}'" if table_id else ""),
                 "useLegacySql": False,
             }
             job_query_resp = await job_client.query(query_request, cast(Session, session))