apache-airflow-providers-google 12.0.0rc2__py3-none-any.whl → 13.0.0__py3-none-any.whl

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

@@ -27,10 +27,6 @@ from collections.abc import Sequence
 from functools import cached_property
 from typing import TYPE_CHECKING, Any, SupportsAbs
 
-from google.api_core.exceptions import Conflict
-from google.cloud.bigquery import DEFAULT_RETRY, CopyJob, ExtractJob, LoadJob, QueryJob, Row
-from google.cloud.bigquery.table import RowIterator
-
 from airflow.configuration import conf
 from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning, AirflowSkipException
 from airflow.providers.common.sql.operators.sql import (  # type: ignore[attr-defined] # for _parse_boolean
@@ -43,8 +39,12 @@ from airflow.providers.common.sql.operators.sql import (  # type: ignore[attr-de
 )
 from airflow.providers.google.cloud.hooks.bigquery import BigQueryHook, BigQueryJob
 from airflow.providers.google.cloud.hooks.gcs import GCSHook, _parse_gcs_url
-from airflow.providers.google.cloud.links.bigquery import BigQueryDatasetLink, BigQueryTableLink
-from airflow.providers.google.cloud.openlineage.mixins import _BigQueryOpenLineageMixin
+from airflow.providers.google.cloud.links.bigquery import (
+    BigQueryDatasetLink,
+    BigQueryJobDetailLink,
+    BigQueryTableLink,
+)
+from airflow.providers.google.cloud.openlineage.mixins import _BigQueryInsertJobOperatorOpenLineageMixin
 from airflow.providers.google.cloud.operators.cloud_base import GoogleCloudBaseOperator
 from airflow.providers.google.cloud.triggers.bigquery import (
     BigQueryCheckTrigger,
@@ -54,15 +54,19 @@ from airflow.providers.google.cloud.triggers.bigquery import (
     BigQueryValueCheckTrigger,
 )
 from airflow.providers.google.cloud.utils.bigquery import convert_job_id
+from airflow.providers.google.common.deprecated import deprecated
 from airflow.providers.google.common.hooks.base_google import PROVIDE_PROJECT_ID
 from airflow.utils.helpers import exactly_one
+from google.api_core.exceptions import Conflict
+from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
+from google.cloud.bigquery import DEFAULT_RETRY, CopyJob, ExtractJob, LoadJob, QueryJob, Row
+from google.cloud.bigquery.table import RowIterator, Table, TableListItem, TableReference
 
 if TYPE_CHECKING:
+    from airflow.utils.context import Context
     from google.api_core.retry import Retry
     from google.cloud.bigquery import UnknownJob
 
-    from airflow.utils.context import Context
-
 
 BIGQUERY_JOB_DETAILS_LINK_FMT = "https://console.cloud.google.com/bigquery?j={job_id}"
 
@@ -1158,6 +1162,185 @@ class BigQueryGetDataOperator(GoogleCloudBaseOperator, _BigQueryOperatorsEncrypt
         return event["records"]
 
 
+class BigQueryCreateTableOperator(GoogleCloudBaseOperator):
+    """
+    Creates a new table in the specified BigQuery dataset, optionally with schema.
+
+    The schema to be used for the BigQuery table may be specified in one of
+    two ways. You may either directly pass the schema fields in, or you may
+    point the operator to a Google Cloud Storage object name. The object in
+    Google Cloud Storage must be a JSON file with the schema fields in it.
+    You can also create a table without schema.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:BigQueryCreateTableOperator`
+
+    :param project_id: Optional. The project to create the table into.
+    :param dataset_id: Required. The dataset to create the table into.
+    :param table_id: Required. The Name of the table to be created.
+    :param table_resource: Required. Table resource as described in documentation:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#Table
+        If ``table`` is a reference, an empty table is created with the specified ID. The dataset that
+        the table belongs to must already exist.
+    :param if_exists: Optional. What should Airflow do if the table exists. If set to `log`,
+        the TI will be passed to success and an error message will be logged. Set to `ignore` to ignore
+        the error, set to `fail` to fail the TI, and set to `skip` to skip it.
+    :param gcs_schema_object: Optional. Full path to the JSON file containing schema. For
+        example: ``gs://test-bucket/dir1/dir2/employee_schema.json``
+    :param gcp_conn_id: Optional. The connection ID used to connect to Google Cloud and
+        interact with the Bigquery service.
+    :param google_cloud_storage_conn_id: Optional. The connection ID used to connect to Google Cloud.
+        and interact with the Google Cloud Storage service.
+    :param location: Optional. The location used for the operation.
+    :param retry: Optional. A retry object used  to retry requests. If `None` is specified, requests
+            will not be retried.
+    :param timeout: Optional. The amount of time, in seconds, to wait for the request to complete.
+        Note that if `retry` is specified, the timeout applies to each individual attempt.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account.
+    """
+
+    template_fields: Sequence[str] = (
+        "dataset_id",
+        "table_id",
+        "table_resource",
+        "project_id",
+        "gcs_schema_object",
+        "impersonation_chain",
+    )
+    template_fields_renderers = {"table_resource": "json"}
+    ui_color = BigQueryUIColors.TABLE.value
+    operator_extra_links = (BigQueryTableLink(),)
+
+    def __init__(
+        self,
+        *,
+        dataset_id: str,
+        table_id: str,
+        table_resource: dict[str, Any] | Table | TableReference | TableListItem,
+        project_id: str = PROVIDE_PROJECT_ID,
+        location: str | None = None,
+        gcs_schema_object: str | None = None,
+        gcp_conn_id: str = "google_cloud_default",
+        google_cloud_storage_conn_id: str = "google_cloud_default",
+        impersonation_chain: str | Sequence[str] | None = None,
+        if_exists: str = "log",
+        retry: Retry | _MethodDefault = DEFAULT,
+        timeout: float | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.project_id = project_id
+        self.location = location
+        self.dataset_id = dataset_id
+        self.table_id = table_id
+        self.table_resource = table_resource
+        self.if_exists = IfExistAction(if_exists)
+        self.gcs_schema_object = gcs_schema_object
+        self.gcp_conn_id = gcp_conn_id
+        self.google_cloud_storage_conn_id = google_cloud_storage_conn_id
+        self.impersonation_chain = impersonation_chain
+        self.retry = retry
+        self.timeout = timeout
+        self._table: Table | None = None
+
+    def execute(self, context: Context) -> None:
+        bq_hook = BigQueryHook(
+            gcp_conn_id=self.gcp_conn_id,
+            location=self.location,
+            impersonation_chain=self.impersonation_chain,
+        )
+        if self.gcs_schema_object:
+            gcs_bucket, gcs_object = _parse_gcs_url(self.gcs_schema_object)
+            gcs_hook = GCSHook(
+                gcp_conn_id=self.google_cloud_storage_conn_id,
+                impersonation_chain=self.impersonation_chain,
+            )
+            schema_fields_string = gcs_hook.download_as_byte_array(gcs_bucket, gcs_object).decode("utf-8")
+            schema_fields = json.loads(schema_fields_string)
+        else:
+            schema_fields = None
+
+        try:
+            self.log.info("Creating table...")
+            self._table = bq_hook.create_table(
+                project_id=self.project_id,
+                dataset_id=self.dataset_id,
+                table_id=self.table_id,
+                schema_fields=schema_fields,
+                table_resource=self.table_resource,
+                exists_ok=self.if_exists == IfExistAction.IGNORE,
+                timeout=self.timeout,
+                location=self.location,
+            )
+            if self._table:
+                persist_kwargs = {
+                    "context": context,
+                    "task_instance": self,
+                    "project_id": self._table.to_api_repr()["tableReference"]["projectId"],
+                    "dataset_id": self._table.to_api_repr()["tableReference"]["datasetId"],
+                    "table_id": self._table.to_api_repr()["tableReference"]["tableId"],
+                }
+                self.log.info(
+                    "Table %s.%s.%s created successfully",
+                    self._table.project,
+                    self._table.dataset_id,
+                    self._table.table_id,
+                )
+            else:
+                raise AirflowException("Table creation failed.")
+        except Conflict:
+            error_msg = f"Table {self.dataset_id}.{self.table_id} already exists."
+            if self.if_exists == IfExistAction.LOG:
+                self.log.info(error_msg)
+                persist_kwargs = {
+                    "context": context,
+                    "task_instance": self,
+                    "project_id": self.project_id or bq_hook.project_id,
+                    "dataset_id": self.dataset_id,
+                    "table_id": self.table_id,
+                }
+            elif self.if_exists == IfExistAction.FAIL:
+                raise AirflowException(error_msg)
+            else:
+                raise AirflowSkipException(error_msg)
+
+        BigQueryTableLink.persist(**persist_kwargs)
+
+    def get_openlineage_facets_on_complete(self, _):
+        """Implement _on_complete as we will use table resource returned by create method."""
+        from airflow.providers.common.compat.openlineage.facet import Dataset
+        from airflow.providers.google.cloud.openlineage.utils import (
+            BIGQUERY_NAMESPACE,
+            get_facets_from_bq_table,
+        )
+        from airflow.providers.openlineage.extractors import OperatorLineage
+
+        if not self._table:
+            self.log.debug("OpenLineage did not find `self._table` attribute.")
+            return OperatorLineage()
+
+        output_dataset = Dataset(
+            namespace=BIGQUERY_NAMESPACE,
+            name=f"{self._table.project}.{self._table.dataset_id}.{self._table.table_id}",
+            facets=get_facets_from_bq_table(self._table),
+        )
+
+        return OperatorLineage(outputs=[output_dataset])
+
+
+@deprecated(
+    planned_removal_date="July 30, 2025",
+    use_instead="airflow.providers.google.cloud.operators.bigquery.BigQueryCreateTableOperator",
+    category=AirflowProviderDeprecationWarning,
+)
 class BigQueryCreateEmptyTableOperator(GoogleCloudBaseOperator):
     """
     Creates a new table in the specified BigQuery dataset, optionally with schema.
@@ -1335,6 +1518,7 @@ class BigQueryCreateEmptyTableOperator(GoogleCloudBaseOperator):
         self.cluster_fields = cluster_fields
         self.table_resource = table_resource
         self.impersonation_chain = impersonation_chain
+        self._table: Table | None = None
         if exists_ok is not None:
             warnings.warn(
                 "`exists_ok` parameter is deprecated, please use `if_exists`",
@@ -1365,6 +1549,7 @@ class BigQueryCreateEmptyTableOperator(GoogleCloudBaseOperator):
 
         try:
             self.log.info("Creating table")
+            # Save table as attribute for further use by OpenLineage
             self._table = bq_hook.create_empty_table(
                 project_id=self.project_id,
                 dataset_id=self.dataset_id,
@@ -1379,19 +1564,22 @@ class BigQueryCreateEmptyTableOperator(GoogleCloudBaseOperator):
                 table_resource=self.table_resource,
                 exists_ok=self.if_exists == IfExistAction.IGNORE,
             )
-            persist_kwargs = {
-                "context": context,
-                "task_instance": self,
-                "project_id": self._table.to_api_repr()["tableReference"]["projectId"],
-                "dataset_id": self._table.to_api_repr()["tableReference"]["datasetId"],
-                "table_id": self._table.to_api_repr()["tableReference"]["tableId"],
-            }
-            self.log.info(
-                "Table %s.%s.%s created successfully",
-                self._table.project,
-                self._table.dataset_id,
-                self._table.table_id,
-            )
+            if self._table:
+                persist_kwargs = {
+                    "context": context,
+                    "task_instance": self,
+                    "project_id": self._table.to_api_repr()["tableReference"]["projectId"],
+                    "dataset_id": self._table.to_api_repr()["tableReference"]["datasetId"],
+                    "table_id": self._table.to_api_repr()["tableReference"]["tableId"],
+                }
+                self.log.info(
+                    "Table %s.%s.%s created successfully",
+                    self._table.project,
+                    self._table.dataset_id,
+                    self._table.table_id,
+                )
+            else:
+                raise AirflowException("Table creation failed.")
         except Conflict:
             error_msg = f"Table {self.dataset_id}.{self.table_id} already exists."
             if self.if_exists == IfExistAction.LOG:
@@ -1410,7 +1598,8 @@ class BigQueryCreateEmptyTableOperator(GoogleCloudBaseOperator):
 
         BigQueryTableLink.persist(**persist_kwargs)
 
-    def get_openlineage_facets_on_complete(self, task_instance):
+    def get_openlineage_facets_on_complete(self, _):
+        """Implement _on_complete as we will use table resource returned by create method."""
         from airflow.providers.common.compat.openlineage.facet import Dataset
         from airflow.providers.google.cloud.openlineage.utils import (
             BIGQUERY_NAMESPACE,
@@ -1418,17 +1607,24 @@ class BigQueryCreateEmptyTableOperator(GoogleCloudBaseOperator):
         )
         from airflow.providers.openlineage.extractors import OperatorLineage
 
-        table_info = self._table.to_api_repr()["tableReference"]
-        table_id = ".".join((table_info["projectId"], table_info["datasetId"], table_info["tableId"]))
+        if not self._table:
+            self.log.debug("OpenLineage did not find `self._table` attribute.")
+            return OperatorLineage()
+
         output_dataset = Dataset(
             namespace=BIGQUERY_NAMESPACE,
-            name=table_id,
+            name=f"{self._table.project}.{self._table.dataset_id}.{self._table.table_id}",
             facets=get_facets_from_bq_table(self._table),
         )
 
         return OperatorLineage(outputs=[output_dataset])
 
 
+@deprecated(
+    planned_removal_date="July 30, 2025",
+    use_instead="airflow.providers.google.cloud.operators.bigquery.BigQueryCreateTableOperator",
+    category=AirflowProviderDeprecationWarning,
+)
 class BigQueryCreateExternalTableOperator(GoogleCloudBaseOperator):
     """
     Create a new external table with data from Google Cloud Storage.
@@ -1645,6 +1841,7 @@ class BigQueryCreateExternalTableOperator(GoogleCloudBaseOperator):
         self.encryption_configuration = encryption_configuration
         self.location = location
         self.impersonation_chain = impersonation_chain
+        self._table: Table | None = None
 
     def execute(self, context: Context) -> None:
         bq_hook = BigQueryHook(
@@ -1653,16 +1850,18 @@ class BigQueryCreateExternalTableOperator(GoogleCloudBaseOperator):
             impersonation_chain=self.impersonation_chain,
         )
         if self.table_resource:
+            # Save table as attribute for further use by OpenLineage
             self._table = bq_hook.create_empty_table(
                 table_resource=self.table_resource,
             )
-            BigQueryTableLink.persist(
-                context=context,
-                task_instance=self,
-                dataset_id=self._table.to_api_repr()["tableReference"]["datasetId"],
-                project_id=self._table.to_api_repr()["tableReference"]["projectId"],
-                table_id=self._table.to_api_repr()["tableReference"]["tableId"],
-            )
+            if self._table:
+                BigQueryTableLink.persist(
+                    context=context,
+                    task_instance=self,
+                    dataset_id=self._table.dataset_id,
+                    project_id=self._table.project,
+                    table_id=self._table.table_id,
+                )
             return
 
         if not self.schema_fields and self.schema_object and self.source_format != "DATASTORE_BACKUP":
@@ -1712,19 +1911,19 @@ class BigQueryCreateExternalTableOperator(GoogleCloudBaseOperator):
             "encryptionConfiguration": self.encryption_configuration,
         }
 
-        self._table = bq_hook.create_empty_table(
-            table_resource=table_resource,
-        )
-
-        BigQueryTableLink.persist(
-            context=context,
-            task_instance=self,
-            dataset_id=self._table.to_api_repr()["tableReference"]["datasetId"],
-            project_id=self._table.to_api_repr()["tableReference"]["projectId"],
-            table_id=self._table.to_api_repr()["tableReference"]["tableId"],
-        )
+        # Save table as attribute for further use by OpenLineage
+        self._table = bq_hook.create_empty_table(table_resource=table_resource)
+        if self._table:
+            BigQueryTableLink.persist(
+                context=context,
+                task_instance=self,
+                dataset_id=self._table.dataset_id,
+                project_id=self._table.project,
+                table_id=self._table.table_id,
+            )
 
-    def get_openlineage_facets_on_complete(self, task_instance):
+    def get_openlineage_facets_on_complete(self, _):
+        """Implement _on_complete as we will use table resource returned by create method."""
         from airflow.providers.common.compat.openlineage.facet import Dataset
         from airflow.providers.google.cloud.openlineage.utils import (
             BIGQUERY_NAMESPACE,
@@ -1732,11 +1931,9 @@ class BigQueryCreateExternalTableOperator(GoogleCloudBaseOperator):
         )
         from airflow.providers.openlineage.extractors import OperatorLineage
 
-        table_info = self._table.to_api_repr()["tableReference"]
-        table_id = ".".join((table_info["projectId"], table_info["datasetId"], table_info["tableId"]))
         output_dataset = Dataset(
             namespace=BIGQUERY_NAMESPACE,
-            name=table_id,
+            name=f"{self._table.project}.{self._table.dataset_id}.{self._table.table_id}",
             facets=get_facets_from_bq_table(self._table),
         )
 
@@ -2129,6 +2326,7 @@ class BigQueryUpdateTableOperator(GoogleCloudBaseOperator):
         self.gcp_conn_id = gcp_conn_id
         self.table_resource = table_resource
         self.impersonation_chain = impersonation_chain
+        self._table: dict | None = None
         super().__init__(**kwargs)
 
     def execute(self, context: Context):
@@ -2137,7 +2335,8 @@ class BigQueryUpdateTableOperator(GoogleCloudBaseOperator):
             impersonation_chain=self.impersonation_chain,
         )
 
-        table = bq_hook.update_table(
+        # Save table as attribute for further use by OpenLineage
+        self._table = bq_hook.update_table(
             table_resource=self.table_resource,
             fields=self.fields,
             dataset_id=self.dataset_id,
@@ -2145,15 +2344,34 @@ class BigQueryUpdateTableOperator(GoogleCloudBaseOperator):
             project_id=self.project_id,
         )
 
-        BigQueryTableLink.persist(
-            context=context,
-            task_instance=self,
-            dataset_id=table["tableReference"]["datasetId"],
-            project_id=table["tableReference"]["projectId"],
-            table_id=table["tableReference"]["tableId"],
+        if self._table:
+            BigQueryTableLink.persist(
+                context=context,
+                task_instance=self,
+                dataset_id=self._table["tableReference"]["datasetId"],
+                project_id=self._table["tableReference"]["projectId"],
+                table_id=self._table["tableReference"]["tableId"],
+            )
+
+        return self._table
+
+    def get_openlineage_facets_on_complete(self, _):
+        """Implement _on_complete as we will use table resource returned by update method."""
+        from airflow.providers.common.compat.openlineage.facet import Dataset
+        from airflow.providers.google.cloud.openlineage.utils import (
+            BIGQUERY_NAMESPACE,
+            get_facets_from_bq_table,
+        )
+        from airflow.providers.openlineage.extractors import OperatorLineage
+
+        table = Table.from_api_repr(self._table)
+        output_dataset = Dataset(
+            namespace=BIGQUERY_NAMESPACE,
+            name=f"{table.project}.{table.dataset_id}.{table.table_id}",
+            facets=get_facets_from_bq_table(table),
         )
 
-        return table
+        return OperatorLineage(outputs=[output_dataset])
 
 
 class BigQueryUpdateDatasetOperator(GoogleCloudBaseOperator):
@@ -2287,15 +2505,47 @@ class BigQueryDeleteTableOperator(GoogleCloudBaseOperator):
         self.ignore_if_missing = ignore_if_missing
         self.location = location
         self.impersonation_chain = impersonation_chain
+        self.hook: BigQueryHook | None = None
 
     def execute(self, context: Context) -> None:
         self.log.info("Deleting: %s", self.deletion_dataset_table)
-        hook = BigQueryHook(
+        # Save hook as attribute for further use by OpenLineage
+        self.hook = BigQueryHook(
             gcp_conn_id=self.gcp_conn_id,
             location=self.location,
             impersonation_chain=self.impersonation_chain,
         )
-        hook.delete_table(table_id=self.deletion_dataset_table, not_found_ok=self.ignore_if_missing)
+        self.hook.delete_table(table_id=self.deletion_dataset_table, not_found_ok=self.ignore_if_missing)
+
+    def get_openlineage_facets_on_complete(self, _):
+        """Implement _on_complete as we need default project_id from hook."""
+        from airflow.providers.common.compat.openlineage.facet import (
+            Dataset,
+            LifecycleStateChange,
+            LifecycleStateChangeDatasetFacet,
+            PreviousIdentifier,
+        )
+        from airflow.providers.google.cloud.openlineage.utils import BIGQUERY_NAMESPACE
+        from airflow.providers.openlineage.extractors import OperatorLineage
+
+        bq_table_id = str(
+            TableReference.from_string(self.deletion_dataset_table, default_project=self.hook.project_id)
+        )
+        ds = Dataset(
+            namespace=BIGQUERY_NAMESPACE,
+            name=bq_table_id,
+            facets={
+                "lifecycleStateChange": LifecycleStateChangeDatasetFacet(
+                    lifecycleStateChange=LifecycleStateChange.DROP.value,
+                    previousIdentifier=PreviousIdentifier(
+                        namespace=BIGQUERY_NAMESPACE,
+                        name=bq_table_id,
+                    ),
+                )
+            },
+        )
+
+        return OperatorLineage(inputs=[ds])
 
 
 class BigQueryUpsertTableOperator(GoogleCloudBaseOperator):
@@ -2354,6 +2604,7 @@ class BigQueryUpsertTableOperator(GoogleCloudBaseOperator):
         self.gcp_conn_id = gcp_conn_id
         self.location = location
         self.impersonation_chain = impersonation_chain
+        self._table: dict | None = None
 
     def execute(self, context: Context) -> None:
         self.log.info("Upserting Dataset: %s with table_resource: %s", self.dataset_id, self.table_resource)
@@ -2362,18 +2613,38 @@ class BigQueryUpsertTableOperator(GoogleCloudBaseOperator):
             location=self.location,
             impersonation_chain=self.impersonation_chain,
         )
-        table = hook.run_table_upsert(
+        # Save table as attribute for further use by OpenLineage
+        self._table = hook.run_table_upsert(
             dataset_id=self.dataset_id,
             table_resource=self.table_resource,
             project_id=self.project_id,
         )
-        BigQueryTableLink.persist(
-            context=context,
-            task_instance=self,
-            dataset_id=table["tableReference"]["datasetId"],
-            project_id=table["tableReference"]["projectId"],
-            table_id=table["tableReference"]["tableId"],
+        if self._table:
+            BigQueryTableLink.persist(
+                context=context,
+                task_instance=self,
+                dataset_id=self._table["tableReference"]["datasetId"],
+                project_id=self._table["tableReference"]["projectId"],
+                table_id=self._table["tableReference"]["tableId"],
+            )
+
+    def get_openlineage_facets_on_complete(self, _):
+        """Implement _on_complete as we will use table resource returned by upsert method."""
+        from airflow.providers.common.compat.openlineage.facet import Dataset
+        from airflow.providers.google.cloud.openlineage.utils import (
+            BIGQUERY_NAMESPACE,
+            get_facets_from_bq_table,
         )
+        from airflow.providers.openlineage.extractors import OperatorLineage
+
+        table = Table.from_api_repr(self._table)
+        output_dataset = Dataset(
+            namespace=BIGQUERY_NAMESPACE,
+            name=f"{table.project}.{table.dataset_id}.{table.table_id}",
+            facets=get_facets_from_bq_table(table),
+        )
+
+        return OperatorLineage(outputs=[output_dataset])
 
 
 class BigQueryUpdateTableSchemaOperator(GoogleCloudBaseOperator):
@@ -2462,6 +2733,7 @@ class BigQueryUpdateTableSchemaOperator(GoogleCloudBaseOperator):
         self.gcp_conn_id = gcp_conn_id
         self.impersonation_chain = impersonation_chain
         self.location = location
+        self._table: dict | None = None
         super().__init__(**kwargs)
 
     def execute(self, context: Context):
@@ -2469,25 +2741,44 @@ class BigQueryUpdateTableSchemaOperator(GoogleCloudBaseOperator):
             gcp_conn_id=self.gcp_conn_id, impersonation_chain=self.impersonation_chain, location=self.location
         )
 
-        table = bq_hook.update_table_schema(
+        # Save table as attribute for further use by OpenLineage
+        self._table = bq_hook.update_table_schema(
             schema_fields_updates=self.schema_fields_updates,
             include_policy_tags=self.include_policy_tags,
             dataset_id=self.dataset_id,
             table_id=self.table_id,
             project_id=self.project_id,
         )
+        if self._table:
+            BigQueryTableLink.persist(
+                context=context,
+                task_instance=self,
+                dataset_id=self._table["tableReference"]["datasetId"],
+                project_id=self._table["tableReference"]["projectId"],
+                table_id=self._table["tableReference"]["tableId"],
+            )
+        return self._table
 
-        BigQueryTableLink.persist(
-            context=context,
-            task_instance=self,
-            dataset_id=table["tableReference"]["datasetId"],
-            project_id=table["tableReference"]["projectId"],
-            table_id=table["tableReference"]["tableId"],
+    def get_openlineage_facets_on_complete(self, _):
+        """Implement _on_complete as we will use table resource returned by update method."""
+        from airflow.providers.common.compat.openlineage.facet import Dataset
+        from airflow.providers.google.cloud.openlineage.utils import (
+            BIGQUERY_NAMESPACE,
+            get_facets_from_bq_table,
+        )
+        from airflow.providers.openlineage.extractors import OperatorLineage
+
+        table = Table.from_api_repr(self._table)
+        output_dataset = Dataset(
+            namespace=BIGQUERY_NAMESPACE,
+            name=f"{table.project}.{table.dataset_id}.{table.table_id}",
+            facets=get_facets_from_bq_table(table),
         )
-        return table
+
+        return OperatorLineage(outputs=[output_dataset])
 
 
-class BigQueryInsertJobOperator(GoogleCloudBaseOperator, _BigQueryOpenLineageMixin):
+class BigQueryInsertJobOperator(GoogleCloudBaseOperator, _BigQueryInsertJobOperatorOpenLineageMixin):
     """
     Execute a BigQuery job.
 
@@ -2554,7 +2845,7 @@ class BigQueryInsertJobOperator(GoogleCloudBaseOperator, _BigQueryOpenLineageMix
     )
     template_fields_renderers = {"configuration": "json", "configuration.query.query": "sql"}
     ui_color = BigQueryUIColors.QUERY.value
-    operator_extra_links = (BigQueryTableLink(),)
+    operator_extra_links = (BigQueryTableLink(), BigQueryJobDetailLink())
 
     def __init__(
         self,
@@ -2664,6 +2955,8 @@ class BigQueryInsertJobOperator(GoogleCloudBaseOperator, _BigQueryOpenLineageMix
         try:
             self.log.info("Executing: %s'", self.configuration)
             # Create a job
+            if self.job_id is None:
+                raise ValueError("job_id cannot be None")
             job: BigQueryJob | UnknownJob = self._submit_job(hook, self.job_id)
         except Conflict:
             # If the job already exists retrieve it
@@ -2726,6 +3019,15 @@ class BigQueryInsertJobOperator(GoogleCloudBaseOperator, _BigQueryOpenLineageMix
             )
             context["ti"].xcom_push(key="job_id_path", value=job_id_path)
 
+        persist_kwargs = {
+            "context": context,
+            "task_instance": self,
+            "project_id": self.project_id,
+            "location": self.location,
+            "job_id": self.job_id,
+        }
+        BigQueryJobDetailLink.persist(**persist_kwargs)
+
         # Wait for the job to complete
         if not self.deferrable:
             job.result(timeout=self.result_timeout, retry=self.result_retry)
@@ -2749,6 +3051,7 @@ class BigQueryInsertJobOperator(GoogleCloudBaseOperator, _BigQueryOpenLineageMix
                 )
             self.log.info("Current state of job %s is %s", job.job_id, job.state)
             self._handle_job_error(job)
+            return self.job_id
 
     def execute_complete(self, context: Context, event: dict[str, Any]) -> str | None:
         """