openmetadata-ingestion 1.1.4.0__py3-none-any.whl → 1.1.6.0__py3-none-any.whl

metadata/generated/schema/type/votes.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  type/votes.json
-#   timestamp: 2023-08-31T15:54:58+00:00
+#   timestamp: 2023-09-25T11:57:29+00:00
 
 from __future__ import annotations
 

metadata/ingestion/lineage/sql_lineage.py

@@ -12,7 +12,7 @@
 Helper functions to handle SQL lineage operations
 """
 import traceback
-from typing import Any, Iterable, Iterator, List, Optional
+from typing import Any, Iterable, Iterator, List, Optional, Tuple
 
 from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
 from metadata.generated.schema.entity.data.table import Table
@@ -118,6 +118,34 @@ def search_table_entities(
         return None
 
 
+def get_table_fqn_from_query_name(
+    table_name: str,
+) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    """
+    Method to extract database, schema and table name
+    from raw table name used in query
+    """
+
+    split_table = table_name.split(".")
+    empty_list: List[Any] = [None]  # Otherwise, there's a typing error in the concat
+
+    if len(split_table) > 3:
+        # In case of bigquery, it is possible that tables within information schema when
+        # referred with their fully qualified name may look like this
+        # `project-id.dataset-id.information_schema.table-name` in such cases there
+        # will be 4 values to unpack vs the expected 3 values, hence in such case we
+        # just pick the table name and keep the database and schema name as none
+
+        table = split_table[-1]
+        database_query, schema_query = None, None
+    else:
+        database_query, schema_query, table = (
+            empty_list * (3 - len(split_table))
+        ) + split_table
+
+    return database_query, schema_query, table
+
+
 def get_table_entities_from_query(
     metadata: OpenMetadata,
     service_name: str,
@@ -141,12 +169,7 @@ def get_table_entities_from_query(
     # First try to find the data from the given db and schema (with table name as given or uppercase)
     # Otherwise, pick it up from the table_name str (with table name as given or uppercase)
 
-    split_table = table_name.split(".")
-    empty_list: List[Any] = [None]  # Otherwise, there's a typing error in the concat
-
-    database_query, schema_query, table = (
-        empty_list * (3 - len(split_table))
-    ) + split_table
+    database_query, schema_query, table = get_table_fqn_from_query_name(table_name)
 
     table_entities = search_table_entities(
         metadata=metadata,

metadata/ingestion/ometa/mixins/data_insight_mixin.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 from typing import List, Optional
 
 from metadata.generated.schema.analytics.basic import WebAnalyticEventType
-from metadata.generated.schema.analytics.reportData import ReportData
+from metadata.generated.schema.analytics.reportData import ReportData, ReportDataType
 from metadata.generated.schema.analytics.webAnalyticEventData import (
     WebAnalyticEventData,
 )
@@ -174,3 +174,14 @@ class DataInsightMixin:
         """
         event_type_value = event_type.value
         self.client.delete(f"/analytics/web/events/{event_type_value}/{tmsp}/collect")
+
+    def delete_report_data(self, report_data_type: ReportDataType, date: str) -> None:
+        """Delete report data at a specific date for a specific report data type
+
+        Args:
+            report_data_type (ReportDataType): report date type to delete
+            date (str): date for which to delete the report data
+        """
+        self.client.delete(
+            f"/analytics/dataInsights/data/{report_data_type.value}/{date}"
+        )

metadata/ingestion/ometa/mixins/query_mixin.py

@@ -13,7 +13,8 @@ Mixin class containing Query specific methods
 
 To be used by OpenMetadata class
 """
-
+import hashlib
+import json
 from typing import List, Optional, Union
 
 from metadata.generated.schema.api.data.createQuery import CreateQueryRequest
@@ -22,6 +23,7 @@ from metadata.generated.schema.entity.data.query import Query
 from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.type.basic import Uuid
 from metadata.generated.schema.type.entityReference import EntityReference
+from metadata.ingestion.ometa.client import REST
 from metadata.ingestion.ometa.utils import model_str
 
 
@@ -32,6 +34,21 @@ class OMetaQueryMixin:
     To be inherited by OpenMetadata
     """
 
+    client: REST
+
+    def _get_query_hash(self, query: str) -> str:
+        result = hashlib.md5(query.encode())
+        return str(result.hexdigest())
+
+    def _get_or_create_query(self, query: CreateQueryRequest) -> Optional[Query]:
+        query_hash = self._get_query_hash(query=query.query.__root__)
+        query_entity = self.get_by_name(entity=Query, fqn=query_hash)
+        if query_entity is None:
+            resp = self.client.put(self.get_suffix(Query), data=query.json())
+            if resp and resp.get("id"):
+                query_entity = Query(**resp)
+        return query_entity
+
     def ingest_entity_queries_data(
         self, entity: Union[Table, Dashboard], queries: List[CreateQueryRequest]
     ) -> None:
@@ -42,16 +59,35 @@ class OMetaQueryMixin:
         :param queries: CreateQueryRequest to add
         """
         for create_query in queries:
-            query = self.client.put(self.get_suffix(Query), data=create_query.json())
-            if query and query.get("id"):
+            query = self._get_or_create_query(create_query)
+            if query:
+                # Add Query Usage
                 table_ref = EntityReference(id=entity.id.__root__, type="table")
                 # convert object to json array string
                 table_ref_json = "[" + table_ref.json() + "]"
                 self.client.put(
-                    f"{self.get_suffix(Query)}/{query.get('id')}/usage",
+                    f"{self.get_suffix(Query)}/{model_str(query.id)}/usage",
                     data=table_ref_json,
                 )
 
+                # Add Query Users
+                user_fqn_list = create_query.users
+                if user_fqn_list:
+                    self.client.put(
+                        f"{self.get_suffix(Query)}/{model_str(query.id)}/users",
+                        data=json.dumps(
+                            [model_str(user_fqn) for user_fqn in user_fqn_list]
+                        ),
+                    )
+
+                # Add Query used by
+                user_list = create_query.usedBy
+                if user_list:
+                    self.client.put(
+                        f"{self.get_suffix(Query)}/{model_str(query.id)}/usedBy",
+                        data=json.dumps(user_list),
+                    )
+
     def get_entity_queries(
         self, entity_id: Union[Uuid, str], fields: Optional[List[str]] = None
     ) -> Optional[List[Query]]:

metadata/ingestion/ometa/mixins/table_mixin.py

@@ -254,11 +254,6 @@ class OMetaTableMixin:
         url_after = f"&after={after}" if after else ""
         profile_type_url = profile_type.__name__[0].lower() + profile_type.__name__[1:]
 
-        # system profile uses milliseconds
-        if profile_type is not SystemProfile:
-            start_ts = start_ts // 1000
-            end_ts = end_ts // 1000
-
         resp = self.client.get(
             f"{self.get_suffix(Table)}/{fqn}/{profile_type_url}?limit={limit}{url_after}",
             data={"startTs": start_ts, "endTs": end_ts},

metadata/ingestion/processor/query_parser.py

@@ -20,6 +20,7 @@ from metadata.config.common import ConfigModel
 from metadata.generated.schema.entity.services.connections.metadata.openMetadataConnection import (
     OpenMetadataConnection,
 )
+from metadata.generated.schema.type.basic import DateTime
 from metadata.generated.schema.type.queryParserData import ParsedData, QueryParserData
 from metadata.generated.schema.type.tableQuery import TableQueries, TableQuery
 from metadata.ingestion.api.processor import Processor
@@ -40,11 +41,10 @@ def parse_sql_statement(record: TableQuery, dialect: Dialect) -> Optional[Parsed
     :return: QueryParserData
     """
 
-    start_date = record.analysisDate
-    if isinstance(record.analysisDate, str):
-        start_date = datetime.datetime.strptime(
-            str(record.analysisDate), "%Y-%m-%d %H:%M:%S"
-        ).date()
+    start_time = record.analysisDate
+    if isinstance(start_time, DateTime):
+        start_date = start_time.__root__.date()
+        start_time = datetime.datetime.strptime(str(start_date.isoformat()), "%Y-%m-%d")
 
     lineage_parser = LineageParser(record.query, dialect=dialect)
 
@@ -58,7 +58,7 @@ def parse_sql_statement(record: TableQuery, dialect: Dialect) -> Optional[Parsed
         databaseSchema=record.databaseSchema,
         sql=record.query,
         userName=record.userName,
-        date=int(start_date.__root__.timestamp()),
+        date=int(start_time.timestamp()),
         serviceName=record.serviceName,
         duration=record.duration,
     )

metadata/ingestion/source/dashboard/tableau/models.py

@@ -96,7 +96,6 @@ class DatasourceField(BaseModel):
     id: str
     name: Optional[str]
     upstreamColumns: Optional[List[Union[UpstreamColumn, None]]]
-    fullyQualifiedName: Optional[str]
     description: Optional[str]
 
 

metadata/ingestion/source/dashboard/tableau/queries.py

@@ -27,7 +27,6 @@ TABLEAU_DATASOURCES_QUERY = """
           name
           remoteType
         }}
-        fullyQualifiedName
         description
       }}
       workbook {{

metadata/ingestion/source/database/bigquery/connection.py

@@ -16,7 +16,6 @@ import os
 from functools import partial
 from typing import Optional
 
-from google import auth
 from google.cloud.datacatalog_v1 import PolicyTagManagerClient
 from sqlalchemy.engine import Engine
 
@@ -107,42 +106,32 @@ def test_connection(
             return policy_tags
 
     def test_tags():
-        list_project_ids = auth.default()
-        project_id = list_project_ids[1]
-
-        if isinstance(project_id, str):
-            taxonomies = PolicyTagManagerClient().list_taxonomies(
-                parent=f"projects/{project_id}/locations/{service_connection.taxonomyLocation}"
-            )
-            return get_tags(taxonomies)
+        taxonomies = PolicyTagManagerClient().list_taxonomies(
+            parent=f"projects/{engine.url.host}/locations/{service_connection.taxonomyLocation}"
+        )
+        return get_tags(taxonomies)
+
+    def test_connection_inner(engine):
+        test_fn = {
+            "CheckAccess": partial(test_connection_engine_step, engine),
+            "GetSchemas": partial(execute_inspector_func, engine, "get_schema_names"),
+            "GetTables": partial(execute_inspector_func, engine, "get_table_names"),
+            "GetViews": partial(execute_inspector_func, engine, "get_view_names"),
+            "GetTags": test_tags,
+            "GetQueries": partial(
+                test_query,
+                engine=engine,
+                statement=BIGQUERY_TEST_STATEMENT.format(
+                    region=service_connection.usageLocation
+                ),
+            ),
+        }
 
-        if isinstance(project_id, list):
-            taxonomies = PolicyTagManagerClient().list_taxonomies(
-                parent=f"projects/{project_id[0]}/locations/{service_connection.taxonomyLocation}"
-            )
+        test_connection_steps(
+            metadata=metadata,
+            test_fn=test_fn,
+            service_type=service_connection.type.value,
+            automation_workflow=automation_workflow,
+        )
 
-            return get_tags(taxonomies)
-
-        return None
-
-    test_fn = {
-        "CheckAccess": partial(test_connection_engine_step, engine),
-        "GetSchemas": partial(execute_inspector_func, engine, "get_schema_names"),
-        "GetTables": partial(execute_inspector_func, engine, "get_table_names"),
-        "GetViews": partial(execute_inspector_func, engine, "get_view_names"),
-        "GetTags": test_tags,
-        "GetQueries": partial(
-            test_query,
-            engine=engine,
-            statement=BIGQUERY_TEST_STATEMENT.format(
-                region=service_connection.usageLocation
-            ),
-        ),
-    }
-
-    test_connection_steps(
-        metadata=metadata,
-        test_fn=test_fn,
-        service_type=service_connection.type.value,
-        automation_workflow=automation_workflow,
-    )
+    test_connection_inner(engine)

metadata/ingestion/source/database/bigquery/helper.py

@@ -0,0 +1,66 @@
+#  Copyright 2021 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Source connection helper
+"""
+
+from typing import Any
+
+from pydantic import BaseModel
+from sqlalchemy import inspect
+
+from metadata.generated.schema.entity.services.connections.database.bigQueryConnection import (
+    BigQueryConnection,
+)
+from metadata.generated.schema.security.credentials.gcpValues import (
+    GcpCredentialsValues,
+    SingleProjectId,
+)
+from metadata.ingestion.source.connections import get_connection
+from metadata.utils.bigquery_utils import get_bigquery_client
+
+
+class InspectorWrapper(BaseModel):
+    client: Any
+    engine: Any
+    inspector: Any
+
+
+def get_inspector_details(
+    database_name: str, service_connection: BigQueryConnection
+) -> InspectorWrapper:
+    """
+    Method to get the bigquery inspector details
+    """
+    # TODO support location property in JSON Schema
+    # TODO support OAuth 2.0 scopes
+    kwargs = {}
+    if isinstance(service_connection.credentials.gcpConfig, GcpCredentialsValues):
+        service_connection.credentials.gcpConfig.projectId = SingleProjectId(
+            __root__=database_name
+        )
+        if service_connection.credentials.gcpImpersonateServiceAccount:
+            kwargs[
+                "impersonate_service_account"
+            ] = (
+                service_connection.credentials.gcpImpersonateServiceAccount.impersonateServiceAccount
+            )
+
+            kwargs[
+                "lifetime"
+            ] = service_connection.credentials.gcpImpersonateServiceAccount.lifetime
+
+    client = get_bigquery_client(project_id=database_name, **kwargs)
+    engine = get_connection(service_connection)
+    inspector = inspect(engine)
+
+    return InspectorWrapper(client=client, engine=engine, inspector=inspector)

metadata/ingestion/source/database/bigquery/metadata.py

@@ -17,7 +17,6 @@ from typing import Iterable, List, Optional, Tuple
 
 from google import auth
 from google.cloud.datacatalog_v1 import PolicyTagManagerClient
-from sqlalchemy import inspect
 from sqlalchemy.engine.reflection import Inspector
 from sqlalchemy.sql.sqltypes import Interval
 from sqlalchemy.types import String
@@ -44,12 +43,12 @@ from metadata.generated.schema.metadataIngestion.workflow import (
 )
 from metadata.generated.schema.security.credentials.gcpValues import (
     GcpCredentialsValues,
-    MultipleProjectId,
-    SingleProjectId,
 )
 from metadata.generated.schema.type.tagLabel import TagLabel
 from metadata.ingestion.api.source import InvalidSourceException
 from metadata.ingestion.models.ometa_classification import OMetaTagAndClassification
+from metadata.ingestion.source.connections import get_test_connection_fn
+from metadata.ingestion.source.database.bigquery.helper import get_inspector_details
 from metadata.ingestion.source.database.bigquery.queries import (
     BIGQUERY_SCHEMA_DESCRIPTION,
     BIGQUERY_TABLE_AND_TYPE,
@@ -60,7 +59,6 @@ from metadata.ingestion.source.database.common_db_source import (
     TableNameAndType,
 )
 from metadata.utils import fqn
-from metadata.utils.bigquery_utils import get_bigquery_client
 from metadata.utils.credentials import GOOGLE_CREDENTIALS
 from metadata.utils.filters import filter_by_database
 from metadata.utils.logger import ingestion_logger
@@ -200,9 +198,15 @@ class BigquerySource(CommonDbSourceService):
         return cls(config, metadata_config)
 
     @staticmethod
-    def set_project_id():
+    def set_project_id() -> List[str]:
         _, project_ids = auth.default()
-        return project_ids
+        return project_ids if isinstance(project_ids, list) else [project_ids]
+
+    def test_connection(self) -> None:
+        for project_id in self.set_project_id():
+            self.set_inspector(project_id)
+            test_connection_fn = get_test_connection_fn(self.service_connection)
+            test_connection_fn(self.metadata, self.engine, self.service_connection)
 
     def query_table_names_and_types(
         self, schema_name: str
@@ -222,7 +226,9 @@ class BigquerySource(CommonDbSourceService):
                 type_=_bigquery_table_types.get(table_type, TableType.Regular),
             )
             for table_name, table_type in self.engine.execute(
-                BIGQUERY_TABLE_AND_TYPE.format(schema_name)
+                BIGQUERY_TABLE_AND_TYPE.format(
+                    project_id=self.client.project, schema_name=schema_name
+                )
             )
             or []
         ]
@@ -319,12 +325,41 @@ class BigquerySource(CommonDbSourceService):
                 )
         yield database_schema_request_obj
 
+    def get_table_obj(self, table_name: str):
+        schema_name = self.context.database_schema.name.__root__
+        database = self.context.database.name.__root__
+        bq_table_fqn = fqn._build(database, schema_name, table_name)
+        return self.client.get_table(bq_table_fqn)
+
+    def yield_table_tag_details(self, table_name_and_type: Tuple[str, str]):
+        table_name, _ = table_name_and_type
+        table_obj = self.get_table_obj(table_name=table_name)
+        if table_obj.labels:
+            for key, value in table_obj.labels.items():
+                yield from get_ometa_tag_and_classification(
+                    tags=[value],
+                    classification_name=key,
+                    tag_description="Bigquery Table Label",
+                    classification_desciption="",
+                )
+
     def get_tag_labels(self, table_name: str) -> Optional[List[TagLabel]]:
         """
         This will only get executed if the tags context
         is properly informed
         """
-        return []
+        table_tag_labels = super().get_tag_labels(table_name) or []
+        table_obj = self.get_table_obj(table_name=table_name)
+        if table_obj.labels:
+            for key, _ in table_obj.labels.items():
+                tag_label = get_tag_label(
+                    metadata=self.metadata,
+                    tag_name=key,
+                    classification_name=key,
+                )
+                if tag_label:
+                    table_tag_labels.append(tag_label)
+        return table_tag_labels
 
     def get_column_tag_labels(
         self, table_name: str, column: dict
@@ -343,68 +378,36 @@ class BigquerySource(CommonDbSourceService):
         return None
 
     def set_inspector(self, database_name: str):
-        # TODO support location property in JSON Schema
-        # TODO support OAuth 2.0 scopes
-        kwargs = {}
-        if isinstance(
-            self.service_connection.credentials.gcpConfig, GcpCredentialsValues
-        ):
-            self.service_connection.credentials.gcpConfig.projectId = SingleProjectId(
-                __root__=database_name
-            )
-            if self.service_connection.credentials.gcpImpersonateServiceAccount:
-                kwargs[
-                    "impersonate_service_account"
-                ] = (
-                    self.service_connection.credentials.gcpImpersonateServiceAccount.impersonateServiceAccount
-                )
-
-                kwargs[
-                    "lifetime"
-                ] = (
-                    self.service_connection.credentials.gcpImpersonateServiceAccount.lifetime
-                )
+        inspector_details = get_inspector_details(
+            database_name=database_name, service_connection=self.service_connection
+        )
 
-        self.client = get_bigquery_client(project_id=database_name, **kwargs)
-        self.inspector = inspect(self.engine)
+        self.client = inspector_details.client
+        self.engine = inspector_details.engine
+        self.inspector = inspector_details.inspector
 
     def get_database_names(self) -> Iterable[str]:
-        if hasattr(
-            self.service_connection.credentials.gcpConfig, "projectId"
-        ) and isinstance(
-            self.service_connection.credentials.gcpConfig.projectId, MultipleProjectId
-        ):
-            for project_id in self.project_ids:
-                database_name = project_id
-                database_fqn = fqn.build(
-                    self.metadata,
-                    entity_type=Database,
-                    service_name=self.context.database_service.name.__root__,
-                    database_name=database_name,
-                )
-                if filter_by_database(
-                    self.source_config.databaseFilterPattern,
-                    database_fqn
-                    if self.source_config.useFqnForFiltering
-                    else database_name,
-                ):
-                    self.status.filter(database_fqn, "Database Filtered out")
-                    continue
-
+        for project_id in self.project_ids:
+            database_fqn = fqn.build(
+                self.metadata,
+                entity_type=Database,
+                service_name=self.context.database_service.name.__root__,
+                database_name=project_id,
+            )
+            if filter_by_database(
+                self.source_config.databaseFilterPattern,
+                database_fqn if self.source_config.useFqnForFiltering else project_id,
+            ):
+                self.status.filter(database_fqn, "Database Filtered out")
+            else:
                 try:
-                    self.set_inspector(database_name=database_name)
-                    self.project_id = (  # pylint: disable=attribute-defined-outside-init
-                        database_name
-                    )
-                    yield database_name
+                    self.set_inspector(database_name=project_id)
+                    yield project_id
                 except Exception as exc:
                     logger.debug(traceback.format_exc())
                     logger.error(
-                        f"Error trying to connect to database {database_name}: {exc}"
+                        f"Error trying to connect to database {project_id}: {exc}"
                     )
-        else:
-            self.set_inspector(database_name=self.project_ids)
-            yield self.project_ids
 
     def get_view_definition(
         self, table_type: str, table_name: str, schema_name: str, inspector: Inspector
@@ -412,7 +415,9 @@ class BigquerySource(CommonDbSourceService):
         if table_type == TableType.View:
             try:
                 view_definition = inspector.get_view_definition(
-                    f"{self.context.database.name.__root__}.{schema_name}.{table_name}"
+                    fqn._build(
+                        self.context.database.name.__root__, schema_name, table_name
+                    )
                 )
                 view_definition = (
                     "" if view_definition is None else str(view_definition)
@@ -430,7 +435,7 @@ class BigquerySource(CommonDbSourceService):
         check if the table is partitioned table and return the partition details
         """
         database = self.context.database.name.__root__
-        table = self.client.get_table(f"{database}.{schema_name}.{table_name}")
+        table = self.client.get_table(fqn._build(database, schema_name, table_name))
         if table.time_partitioning is not None:
             if table.time_partitioning.field:
                 table_partition = TablePartition(

metadata/ingestion/source/database/bigquery/queries.py

@@ -45,7 +45,7 @@ BIGQUERY_TEST_STATEMENT = textwrap.dedent(
 BIGQUERY_SCHEMA_DESCRIPTION = textwrap.dedent(
     """
     SELECT option_value as schema_description FROM
-    {project_id}.region-{region}.INFORMATION_SCHEMA.SCHEMATA_OPTIONS 
+    `{project_id}`.`region-{region}`.INFORMATION_SCHEMA.SCHEMATA_OPTIONS 
     where schema_name = '{schema_name}' and option_name = 'description' 
     and option_value is not null
     """
@@ -53,6 +53,6 @@ BIGQUERY_SCHEMA_DESCRIPTION = textwrap.dedent(
 
 BIGQUERY_TABLE_AND_TYPE = textwrap.dedent(
     """
-    select table_name, table_type from {}.INFORMATION_SCHEMA.TABLES where table_type != 'VIEW'
+    select table_name, table_type from `{project_id}`.{schema_name}.INFORMATION_SCHEMA.TABLES where table_type != 'VIEW'
     """
 )

metadata/ingestion/source/database/bigquery/query_parser.py

@@ -12,6 +12,7 @@
 Handle big query usage extraction
 """
 from abc import ABC
+from copy import deepcopy
 from datetime import datetime
 
 from google import auth
@@ -25,7 +26,9 @@ from metadata.generated.schema.entity.services.connections.metadata.openMetadata
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
-from metadata.ingestion.api.source import InvalidSourceException
+from metadata.generated.schema.security.credentials.gcpValues import MultipleProjectId
+from metadata.ingestion.api.steps import InvalidSourceException
+from metadata.ingestion.source.database.bigquery.helper import get_inspector_details
 from metadata.ingestion.source.database.query_parser_source import QueryParserSource
 
 
@@ -65,3 +68,18 @@ class BigqueryQueryParserSource(QueryParserSource, ABC):
     def set_project_id():
         _, project_id = auth.default()
         return project_id
+
+    def get_engine(self):
+        if isinstance(
+            self.service_connection.credentials.gcpConfig.projectId, MultipleProjectId
+        ):
+            project_ids = deepcopy(
+                self.service_connection.credentials.gcpConfig.projectId
+            )
+            for project_id in project_ids.__root__:
+                inspector_details = get_inspector_details(
+                    project_id, self.service_connection
+                )
+                yield inspector_details.engine
+        else:
+            yield self.engine

metadata/ingestion/source/database/common_db_source.py

@@ -523,9 +523,6 @@ class CommonDbSourceService(
         """
         return table
 
-    def yield_table_tag(self) -> Iterable[OMetaTagAndClassification]:
-        pass
-
     def get_source_url(
         self,
         database_name: Optional[str] = None,