openmetadata-ingestion 1.9.1.0__py3-none-any.whl → 1.9.2.1__py3-none-any.whl

metadata/ingestion/source/database/saphana/cdata_parser.py

@@ -18,9 +18,10 @@ import xml.etree.ElementTree as ET
 from collections import defaultdict
 from enum import Enum
 from functools import lru_cache
-from typing import Dict, Iterable, List, NewType, Optional, Set
+from typing import Dict, Iterable, List, NewType, Optional, Set, Tuple
 
 from pydantic import Field, computed_field
+from sqlalchemy.engine import Engine
 from typing_extensions import Annotated
 
 from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
@@ -44,6 +45,7 @@ from metadata.ingestion.source.database.saphana.models import (
     SYS_BIC_SCHEMA_NAME,
     ViewType,
 )
+from metadata.ingestion.source.database.saphana.queries import SAPHANA_SCHEMA_MAPPING
 from metadata.utils import fqn
 from metadata.utils.constants import ENTITY_REFERENCE_TYPE_MAP
 from metadata.utils.dispatch import enum_register
@@ -158,6 +160,7 @@ class DataSource(BaseModel):
     def get_entity(
         self,
         metadata: OpenMetadata,
+        engine: Engine,
         service_name: str,
     ) -> Table:
         """Build the Entity Reference for this DataSource"""
@@ -168,13 +171,14 @@ class DataSource(BaseModel):
             )
 
         if self.source_type == ViewType.DATA_BASE_TABLE:
+            schema_name = _get_mapped_schema(engine=engine, schema_name=self.location)
             # The source is a table, so the location is the schema
             fqn_ = fqn.build(
                 metadata=metadata,
                 entity_type=Table,
                 service_name=service_name,
                 database_name=None,  # TODO: Can we assume HXE?
-                schema_name=self.location,
+                schema_name=schema_name,
                 table_name=self.name,
             )
         else:
@@ -243,17 +247,67 @@ class ParsedLineage(BaseModel):
         return id(self)
 
     def to_request(
-        self, metadata: OpenMetadata, service_name: str, to_entity: Table
+        self,
+        metadata: OpenMetadata,
+        engine: Engine,
+        service_name: str,
+        to_entity: Table,
     ) -> Iterable[Either[AddLineageRequest]]:
         """Given the target entity, build the AddLineageRequest based on the sources in `self`"""
         for source in self.sources:
             try:
                 source_table = source.get_entity(
-                    metadata=metadata, service_name=service_name
+                    metadata=metadata, engine=engine, service_name=service_name
                 )
                 if not source_table:
                     logger.warning(f"Can't find table for source [{source}]")
                     continue
+
+                column_lineage = []
+                for mapping in self.mappings:
+                    if mapping.data_source != source:
+                        continue
+
+                    from_columns = []
+                    for source_col in mapping.sources:
+                        from_column_fqn = get_column_fqn(
+                            table_entity=source_table,
+                            column=source_col,
+                        )
+                        if not from_column_fqn:
+                            logger.warning(
+                                f"Can't find source column [{source_col}] in [{source_table}]"
+                            )
+                            continue
+
+                        from_columns.append(
+                            FullyQualifiedEntityName(
+                                from_column_fqn,
+                            )
+                        )
+
+                    to_column_fqn = get_column_fqn(
+                        table_entity=to_entity,
+                        column=mapping.target,
+                    )
+                    if not to_column_fqn:
+                        logger.warning(
+                            f"Can't find target column [{mapping.target}] in [{to_entity}]."
+                            f" For source columns: {from_columns}"
+                        )
+                        continue
+
+                    to_column = FullyQualifiedEntityName(
+                        to_column_fqn,
+                    )
+                    column_lineage.append(
+                        ColumnLineage(
+                            fromColumns=from_columns,
+                            toColumn=to_column,
+                            function=mapping.formula,
+                        )
+                    )
+
                 yield Either(
                     right=AddLineageRequest(
                         edge=EntitiesEdge(
@@ -267,30 +321,7 @@ class ParsedLineage(BaseModel):
                             ),
                             lineageDetails=LineageDetails(
                                 source=Source.ViewLineage,
-                                columnsLineage=[
-                                    ColumnLineage(
-                                        fromColumns=[
-                                            FullyQualifiedEntityName(
-                                                get_column_fqn(
-                                                    table_entity=source_table,
-                                                    column=source_col,
-                                                )
-                                            )
-                                            for source_col in mapping.sources
-                                        ],
-                                        toColumn=FullyQualifiedEntityName(
-                                            get_column_fqn(
-                                                table_entity=to_entity,
-                                                column=mapping.target,
-                                            )
-                                        ),
-                                        function=mapping.formula
-                                        if mapping.formula
-                                        else None,
-                                    )
-                                    for mapping in self.mappings
-                                    if mapping.data_source == source
-                                ],
+                                columnsLineage=column_lineage,
                             ),
                         )
                     )
@@ -339,6 +370,39 @@ def _get_column_datasources(
     }
 
 
+def _get_column_datasources_with_names(
+    entry: ET.Element, datasource_map: Optional[DataSourceMap] = None
+) -> List[Tuple[DataSource, str]]:
+    """
+    Get the DataSource and the actual source column name after traversal.
+    Returns a list of tuples (DataSource, column_name).
+    """
+    if (
+        datasource_map
+        and entry.get(CDATAKeys.COLUMN_OBJECT_NAME.value) in datasource_map
+    ):
+        # Traverse to get the actual sources and column names
+        ds_col_pairs = _traverse_ds_with_columns(
+            current_column=entry.get(CDATAKeys.COLUMN_NAME.value),
+            ds_origin_list=[],
+            current_ds=datasource_map[entry.get(CDATAKeys.COLUMN_OBJECT_NAME.value)],
+            datasource_map=datasource_map,
+        )
+        return ds_col_pairs
+
+    # If we don't have any logical sources, use the column name as-is
+    return [
+        (
+            DataSource(
+                name=entry.get(CDATAKeys.COLUMN_OBJECT_NAME.value),
+                location=entry.get(CDATAKeys.SCHEMA_NAME.value),
+                source_type=ViewType.DATA_BASE_TABLE,
+            ),
+            entry.get(CDATAKeys.COLUMN_NAME.value),
+        )
+    ]
+
+
 def _traverse_ds(
     current_column: str,
     ds_origin_list: List[DataSource],
@@ -355,7 +419,9 @@ def _traverse_ds(
 
     else:
         # Based on our current column, find the parents from the mappings in the current_ds
-        current_ds_mapping: DataSourceMapping = current_ds.mapping.get(current_column)
+        current_ds_mapping: Optional[DataSourceMapping] = current_ds.mapping.get(
+            current_column
+        )
 
         if current_ds_mapping:
             for parent in current_ds_mapping.parents:
@@ -381,6 +447,54 @@ def _traverse_ds(
     return ds_origin_list
 
 
+def _traverse_ds_with_columns(
+    current_column: str,
+    ds_origin_list: List[Tuple[DataSource, str]],
+    current_ds: DataSource,
+    datasource_map: Optional[DataSourceMap],
+) -> List[Tuple[DataSource, str]]:
+    """
+    Traverse the ds dict jumping from target -> source columns and getting the right parent.
+    We keep inspecting current datasources and will append to the origin list the ones
+    that are not LOGICAL, along with the final column name.
+    Returns a list of tuples (DataSource, column_name).
+    """
+    if current_ds.source_type != ViewType.LOGICAL:
+        # This is a final datasource, append it with the current column name
+        ds_origin_list.append((current_ds, current_column))
+
+    else:
+        # Based on our current column, find the parents from the mappings in the current_ds
+        current_ds_mapping: Optional[DataSourceMapping] = current_ds.mapping.get(
+            current_column
+        )
+
+        if current_ds_mapping:
+            for parent in current_ds_mapping.parents:
+                parent_ds = datasource_map.get(parent.parent)
+                if not parent_ds:
+                    raise CDATAParsingError(
+                        f"Can't find parent [{parent.parent}] for column [{current_column}]"
+                    )
+
+                # Traverse from the source column in the parent mapping
+                # Note: parent.source is the column name in the parent datasource
+                _traverse_ds_with_columns(
+                    current_column=parent.source,
+                    ds_origin_list=ds_origin_list,
+                    current_ds=parent_ds,
+                    datasource_map=datasource_map,
+                )
+        else:
+            # Current column not in mapping. This can happen for calculated view attributes
+            logger.info(
+                f"Can't find mapping for column [{current_column}] in [{current_ds}]. "
+                f"We still have to implement `calculatedViewAttributes`."
+            )
+
+    return ds_origin_list
+
+
 def _read_attributes(
     tree: ET.Element, ns: dict, datasource_map: Optional[DataSourceMap] = None
 ) -> ParsedLineage:
@@ -392,17 +506,20 @@ def _read_attributes(
 
     for attribute in attribute_list.findall(CDATAKeys.ATTRIBUTE.value, ns):
         key_mapping = attribute.find(CDATAKeys.KEY_MAPPING.value, ns)
-        data_sources = _get_column_datasources(
+
+        # Get the actual source datasources and their column names
+        data_sources_with_columns = _get_column_datasources_with_names(
             entry=key_mapping, datasource_map=datasource_map
         )
+
         attr_lineage = ParsedLineage(
             mappings=[
                 ColumnMapping(
-                    data_source=ds,
-                    sources=[key_mapping.get(CDATAKeys.COLUMN_NAME.value)],
+                    data_source=ds_info[0],  # The datasource
+                    sources=[ds_info[1]],  # The actual source column name
                     target=attribute.get(CDATAKeys.ID.value),
                 )
-                for ds in data_sources
+                for ds_info in data_sources_with_columns
             ]
         )
         lineage += attr_lineage
@@ -456,17 +573,20 @@ def _read_base_measures(
 
     for measure in base_measures.findall(CDATAKeys.MEASURE.value, ns):
         measure_mapping = measure.find(CDATAKeys.MEASURE_MAPPING.value, ns)
-        data_sources = _get_column_datasources(
+
+        # Get the actual source datasources and their column names
+        data_sources_with_columns = _get_column_datasources_with_names(
             entry=measure_mapping, datasource_map=datasource_map
         )
+
         measure_lineage = ParsedLineage(
             mappings=[
                 ColumnMapping(
-                    data_source=ds,
-                    sources=[measure_mapping.get(CDATAKeys.COLUMN_NAME.value)],
+                    data_source=ds_info[0],  # The datasource
+                    sources=[ds_info[1]],  # The actual source column name
                     target=measure.get(CDATAKeys.ID.value),
                 )
-                for ds in data_sources
+                for ds_info in data_sources_with_columns
             ]
         )
         lineage += measure_lineage
@@ -519,7 +639,12 @@ def _(cdata: str) -> ParsedLineage:
     tree = ET.fromstring(cdata)
     measure_group = tree.find(CDATAKeys.PRIVATE_MEASURE_GROUP.value, ns)
     # TODO: Handle lineage from calculatedMeasures, restrictedMeasures and sharedDimensions
-    return _read_attributes(measure_group, ns)
+    attribute_lineage = _read_attributes(measure_group, ns)
+    base_measure_lineage = _read_base_measures(
+        tree=measure_group, ns=ns, datasource_map=None
+    )
+
+    return attribute_lineage + base_measure_lineage
 
 
 @parse_registry.add(ViewType.ATTRIBUTE_VIEW.value)
@@ -643,10 +768,17 @@ def _parse_cv_data_sources(tree: ET.Element, ns: dict) -> DataSourceMap:
 
     for cv in calculation_views.findall(CDATAKeys.CALCULATION_VIEW.value, ns):
         mappings = _build_mappings(calculation_view=cv, ns=ns)
+        # Build mapping dict, keeping only the first occurrence of each target
+        # (subsequent ones are typically for join conditions)
+        mapping_dict = {}
+        for mapping in mappings:
+            if mapping.target not in mapping_dict:
+                mapping_dict[mapping.target] = mapping
+
         datasource_map[cv.get(CDATAKeys.ID.value)] = DataSource(
             name=cv.get(CDATAKeys.ID.value),
             location=None,
-            mapping={mapping.target: mapping for mapping in mappings},
+            mapping=mapping_dict,
             source_type=ViewType.LOGICAL,
         )
 
@@ -690,28 +822,48 @@ def _build_mappings(calculation_view: ET.Element, ns: dict) -> List[DataSourceMa
 def _build_input_mappings(
     calculation_view: ET.Element, ns: dict
 ) -> List[DataSourceMapping]:
-    """Map input nodes"""
+    """
+    Map input nodes preserving the exact target-to-source relationships.
+
+    IMPORTANT: Each target column should map to exactly one source.
+    When there are multiple inputs with the same source column name,
+    they map to different target columns (e.g., PRICE vs PRICE_1).
+    """
     mappings = []
     for input_node in calculation_view.findall(CDATAKeys.INPUT.value, ns):
+        input_node_name = input_node.get(CDATAKeys.NODE.value).replace("#", "")
+
         for mapping in input_node.findall(CDATAKeys.MAPPING.value, ns):
-            if mapping.get(CDATAKeys.SOURCE.value) and mapping.get(
-                CDATAKeys.TARGET.value
-            ):
+            source_col = mapping.get(CDATAKeys.SOURCE.value)
+            target_col = mapping.get(CDATAKeys.TARGET.value)
+
+            if source_col and target_col:
+                # Each target column gets its own mapping entry
+                # We don't group here because each target maps to a specific source
                 mappings.append(
                     DataSourceMapping(
-                        target=mapping.get(CDATAKeys.TARGET.value),
+                        target=target_col,
                         parents=[
                             ParentSource(
-                                source=mapping.get(CDATAKeys.SOURCE.value),
-                                parent=input_node.get(CDATAKeys.NODE.value).replace(
-                                    "#", ""
-                                ),
+                                source=source_col,
+                                parent=input_node_name,
                             )
                         ],
                     )
                 )
 
-    return _group_mappings(mappings)
+    # For Union views, we need to group because multiple inputs can map to the same target
+    # For Join views, we should NOT group because each target has a unique source
+    calculation_view_type = calculation_view.get(
+        "{http://www.w3.org/2001/XMLSchema-instance}type"
+    )
+
+    if calculation_view_type and "UnionView" in calculation_view_type:
+        return _group_mappings(mappings)
+    else:
+        # For Join, Projection, Aggregation views - each target has exactly one source
+        # We still return the list but don't group
+        return mappings
 
 
 def _build_cv_attributes(
@@ -770,3 +922,22 @@ def _group_mappings(mappings: List[DataSourceMapping]) -> List[DataSourceMapping
     ]
 
     return grouped_data
+
+
+@lru_cache(maxsize=256)
+def _get_mapped_schema(
+    engine: Engine,
+    schema_name: str,
+) -> str:
+    """
+    Get the physical schema for a given authoring schema
+    If schema is not mapped, then consider it as the physical schema
+    """
+    with engine.connect() as conn:
+        result = conn.execute(
+            SAPHANA_SCHEMA_MAPPING.format(authoring_schema=schema_name)
+        )
+        row = result.fetchone()
+        if row is not None:
+            return row[0]
+    return schema_name

metadata/ingestion/source/database/saphana/lineage.py

@@ -37,6 +37,7 @@ from metadata.ingestion.source.database.saphana.cdata_parser import (
 )
 from metadata.ingestion.source.database.saphana.models import SapHanaLineageModel
 from metadata.ingestion.source.database.saphana.queries import SAPHANA_LINEAGE
+from metadata.utils.filters import filter_by_table
 from metadata.utils.logger import ingestion_logger
 from metadata.utils.ssl_manager import get_ssl_connection
 
@@ -108,6 +109,16 @@ class SaphanaLineageSource(Source):
                 try:
                     lineage_model = SapHanaLineageModel.validate(dict(row))
 
+                    if filter_by_table(
+                        self.source_config.tableFilterPattern,
+                        lineage_model.object_name,
+                    ):
+                        self.status.filter(
+                            lineage_model.object_name,
+                            "View Object Filtered Out",
+                        )
+                        continue
+
                     yield from self.parse_cdata(
                         metadata=self.metadata, lineage_model=lineage_model
                     )
@@ -138,6 +149,7 @@ class SaphanaLineageSource(Source):
             if to_entity:
                 yield from parsed_lineage.to_request(
                     metadata=metadata,
+                    engine=self.engine,
                     service_name=self.config.serviceName,
                     to_entity=to_entity,
                 )

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

@@ -21,3 +21,10 @@ SELECT
 FROM _SYS_REPO.ACTIVE_OBJECT
 WHERE OBJECT_SUFFIX IN ('analyticview', 'attributeview', 'calculationview');
 """
+
+SAPHANA_SCHEMA_MAPPING = """
+SELECT
+  PHYSICAL_SCHEMA
+FROM _SYS_BI.M_SCHEMA_MAPPING
+WHERE AUTHORING_SCHEMA = '{authoring_schema}';
+"""

metadata/ingestion/source/database/snowflake/constants.py

@@ -46,3 +46,6 @@ DEFAULT_STREAM_COLUMNS = [
         "primary_key": False,
     },
 ]
+
+SNOWFLAKE_TAG_DESCRIPTION = "SNOWFLAKE TAG VALUE"
+SNOWFLAKE_CLASSIFICATION_DESCRIPTION = "SNOWFLAKE TAG NAME"

metadata/ingestion/source/database/snowflake/metadata.py

@@ -54,6 +54,7 @@ from metadata.generated.schema.type.basic import (
     SourceUrl,
 )
 from metadata.generated.schema.type.entityReferenceList import EntityReferenceList
+from metadata.generated.schema.type.tagLabel import TagLabel
 from metadata.ingestion.api.delete import delete_entity_by_name
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
@@ -73,6 +74,8 @@ from metadata.ingestion.source.database.incremental_metadata_extraction import (
 from metadata.ingestion.source.database.multi_db_source import MultiDBSource
 from metadata.ingestion.source.database.snowflake.constants import (
     DEFAULT_STREAM_COLUMNS,
+    SNOWFLAKE_CLASSIFICATION_DESCRIPTION,
+    SNOWFLAKE_TAG_DESCRIPTION,
 )
 from metadata.ingestion.source.database.snowflake.models import (
     STORED_PROC_LANGUAGE_MAP,
@@ -81,7 +84,8 @@ from metadata.ingestion.source.database.snowflake.models import (
 from metadata.ingestion.source.database.snowflake.queries import (
     SNOWFLAKE_DESC_FUNCTION,
     SNOWFLAKE_DESC_STORED_PROCEDURE,
-    SNOWFLAKE_FETCH_ALL_TAGS,
+    SNOWFLAKE_FETCH_SCHEMA_TAGS,
+    SNOWFLAKE_FETCH_TABLE_TAGS,
     SNOWFLAKE_GET_CLUSTER_KEY,
     SNOWFLAKE_GET_CURRENT_ACCOUNT,
     SNOWFLAKE_GET_DATABASE_COMMENTS,
@@ -123,7 +127,7 @@ from metadata.utils.sqlalchemy_utils import (
     get_all_table_ddls,
     get_all_view_definitions,
 )
-from metadata.utils.tag_utils import get_ometa_tag_and_classification
+from metadata.utils.tag_utils import get_ometa_tag_and_classification, get_tag_label
 
 
 class MAP(StructuredType):
@@ -203,6 +207,7 @@ class SnowflakeSource(
         self.schema_desc_map = {}
         self.database_desc_map = {}
         self.external_location_map = {}
+        self.schema_tags_map = {}
 
         self._account: Optional[str] = None
         self._org_name: Optional[str] = None
@@ -299,6 +304,32 @@ class SnowflakeSource(
             for row in results
         }
 
+    def set_schema_tags_map(self, database_name: str) -> None:
+        """Fetch and store all schema-level tags for the current database"""
+        self.schema_tags_map.clear()
+        if not self.source_config.includeTags:
+            return
+
+        try:
+            results = self.engine.execute(
+                SNOWFLAKE_FETCH_SCHEMA_TAGS.format(
+                    database_name=database_name,
+                    account_usage=self.service_connection.accountUsageSchema,
+                )
+            ).all()
+
+            for row in results:
+                schema_name = row.SCHEMA_NAME
+                if schema_name not in self.schema_tags_map:
+                    self.schema_tags_map[schema_name] = []
+                self.schema_tags_map[schema_name].append(
+                    {"tag_name": row.TAG_NAME, "tag_value": row.TAG_VALUE}
+                )
+
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.warning(f"Failed to fetch schema tags: {exc}")
+
     def get_schema_description(self, schema_name: str) -> Optional[str]:
         """
         Method to fetch the schema description
@@ -329,6 +360,7 @@ class SnowflakeSource(
             self.set_schema_description_map()
             self.set_database_description_map()
             self.set_external_location_map(configured_db)
+            self.set_schema_tags_map(configured_db)
             yield configured_db
         else:
             for new_database in self.get_database_names_raw():
@@ -357,6 +389,7 @@ class SnowflakeSource(
                     self.set_schema_description_map()
                     self.set_database_description_map()
                     self.set_external_location_map(new_database)
+                    self.set_schema_tags_map(new_database)
                     yield new_database
                 except Exception as exc:
                     logger.debug(traceback.format_exc())
@@ -451,11 +484,14 @@ class SnowflakeSource(
     def yield_tag(
         self, schema_name: str
     ) -> Iterable[Either[OMetaTagAndClassification]]:
+        """
+        Yield tags for tables/columns and schemas.
+        """
         if self.source_config.includeTags:
             result = []
             try:
                 result = self.connection.execute(
-                    SNOWFLAKE_FETCH_ALL_TAGS.format(
+                    SNOWFLAKE_FETCH_TABLE_TAGS.format(
                         database_name=self.context.get().database,
                         schema_name=schema_name,
                         account_usage=self.service_connection.accountUsageSchema,
@@ -469,20 +505,15 @@ class SnowflakeSource(
                         f"Error fetching tags {exc}. Trying with quoted names"
                     )
                     result = self.connection.execute(
-                        SNOWFLAKE_FETCH_ALL_TAGS.format(
+                        SNOWFLAKE_FETCH_TABLE_TAGS.format(
                             database_name=f'"{self.context.get().database}"',
                             schema_name=f'"{self.context.get().database_schema}"',
                             account_usage=self.service_connection.accountUsageSchema,
                         )
                     )
                 except Exception as inner_exc:
-                    yield Either(
-                        left=StackTraceError(
-                            name="Tags and Classifications",
-                            error=f"Failed to fetch tags due to [{inner_exc}]",
-                            stackTrace=traceback.format_exc(),
-                        )
-                    )
+                    logger.debug(traceback.format_exc())
+                    logger.error(f"Failed to fetch tags due to [{inner_exc}]")
 
             for res in result:
                 row = list(res)
@@ -495,12 +526,32 @@ class SnowflakeSource(
                     ),
                     tags=[row[1]],
                     classification_name=row[0],
-                    tag_description="SNOWFLAKE TAG VALUE",
-                    classification_description="SNOWFLAKE TAG NAME",
+                    tag_description=SNOWFLAKE_TAG_DESCRIPTION,
+                    classification_description=SNOWFLAKE_CLASSIFICATION_DESCRIPTION,
                     metadata=self.metadata,
                     system_tags=True,
                 )
 
+            # Yield schema-level tags
+            if schema_name in self.schema_tags_map:
+                schema_fqn = fqn.build(
+                    self.metadata,
+                    entity_type=DatabaseSchema,
+                    service_name=self.context.get().database_service,
+                    database_name=self.context.get().database,
+                    schema_name=schema_name,
+                )
+                for tag_info in self.schema_tags_map[schema_name]:
+                    yield from get_ometa_tag_and_classification(
+                        tag_fqn=FullyQualifiedEntityName(schema_fqn),
+                        tags=[tag_info["tag_value"]],
+                        classification_name=tag_info["tag_name"],
+                        tag_description=SNOWFLAKE_TAG_DESCRIPTION,
+                        classification_description=SNOWFLAKE_CLASSIFICATION_DESCRIPTION,
+                        metadata=self.metadata,
+                        system_tags=True,
+                    )
+
     def _get_table_names_and_types(
         self, schema_name: str, table_type: TableType = TableType.Regular
     ) -> List[TableNameAndType]:
@@ -945,3 +996,49 @@ class SnowflakeSource(
         logger.debug(
             f"Processing ownership is not supported for {self.service_connection.type.name}"
         )
+
+    def get_schema_tag_labels(self, schema_name: str) -> Optional[List[TagLabel]]:
+        """
+        Return tags for schema entity including Snowflake schema-level tags.
+        """
+        schema_tags = []
+
+        if schema_name in self.schema_tags_map:
+            for tag_info in self.schema_tags_map[schema_name]:
+                tag_label = get_tag_label(
+                    metadata=self.metadata,
+                    tag_name=tag_info["tag_value"],
+                    classification_name=tag_info["tag_name"],
+                )
+                if tag_label:
+                    schema_tags.append(tag_label)
+
+        # Include parent tags from context
+        parent_tags = super().get_schema_tag_labels(schema_name) or []
+        for tag in parent_tags:
+            if tag not in schema_tags:
+                schema_tags.append(tag)
+
+        return schema_tags if schema_tags else None
+
+    def get_tag_labels(self, table_name: str) -> Optional[List[TagLabel]]:
+        """
+        Override to include schema-level tags inherited by tables.
+        This method combines:
+        1. Tags directly assigned to the table (from parent implementation)
+        2. Tags inherited from the schema level
+        """
+        table_tags = super().get_tag_labels(table_name) or []
+
+        schema_name = self.context.get().database_schema
+        if schema_name and schema_name in self.schema_tags_map:
+            for tag_info in self.schema_tags_map[schema_name]:
+                tag_label = get_tag_label(
+                    metadata=self.metadata,
+                    tag_name=tag_info["tag_value"],
+                    classification_name=tag_info["tag_name"],
+                )
+                if tag_label and tag_label not in table_tags:
+                    table_tags.append(tag_label)
+
+        return table_tags if table_tags else None