openmetadata-ingestion 1.5.13.0__py3-none-any.whl → 1.6.0.0rc2__py3-none-any.whl

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

@@ -14,7 +14,7 @@ Snowflake source module
 import json
 import traceback
 from datetime import datetime
-from typing import Dict, Iterable, List, Optional, Tuple
+from typing import Iterable, List, Optional, Tuple
 
 import sqlparse
 from snowflake.sqlalchemy.custom_types import VARIANT
@@ -27,10 +27,7 @@ from metadata.generated.schema.api.data.createStoredProcedure import (
 )
 from metadata.generated.schema.entity.data.database import Database
 from metadata.generated.schema.entity.data.databaseSchema import DatabaseSchema
-from metadata.generated.schema.entity.data.storedProcedure import (
-    StoredProcedureCode,
-    StoredProcedureType,
-)
+from metadata.generated.schema.entity.data.storedProcedure import StoredProcedureCode
 from metadata.generated.schema.entity.data.table import (
     PartitionColumnDetails,
     PartitionIntervalTypes,
@@ -74,7 +71,6 @@ from metadata.ingestion.source.database.snowflake.models import (
     SnowflakeStoredProcedure,
 )
 from metadata.ingestion.source.database.snowflake.queries import (
-    SNOWFLAKE_DESC_FUNCTION,
     SNOWFLAKE_DESC_STORED_PROCEDURE,
     SNOWFLAKE_FETCH_ALL_TAGS,
     SNOWFLAKE_GET_CLUSTER_KEY,
@@ -82,10 +78,8 @@ from metadata.ingestion.source.database.snowflake.queries import (
     SNOWFLAKE_GET_DATABASE_COMMENTS,
     SNOWFLAKE_GET_DATABASES,
     SNOWFLAKE_GET_EXTERNAL_LOCATIONS,
-    SNOWFLAKE_GET_FUNCTIONS,
     SNOWFLAKE_GET_ORGANIZATION_NAME,
     SNOWFLAKE_GET_SCHEMA_COMMENTS,
-    SNOWFLAKE_GET_STORED_PROCEDURE_QUERIES,
     SNOWFLAKE_GET_STORED_PROCEDURES,
     SNOWFLAKE_LIFE_CYCLE_QUERY,
     SNOWFLAKE_SESSION_TAG_QUERY,
@@ -107,13 +101,8 @@ from metadata.ingestion.source.database.snowflake.utils import (
     get_view_names_reflection,
     normalize_names,
 )
-from metadata.ingestion.source.database.stored_procedures_mixin import (
-    QueryByProcedure,
-    StoredProcedureMixin,
-)
 from metadata.utils import fqn
 from metadata.utils.filters import filter_by_database
-from metadata.utils.helpers import get_start_and_end
 from metadata.utils.logger import ingestion_logger
 from metadata.utils.sqlalchemy_utils import get_all_table_comments, get_all_table_ddls
 from metadata.utils.tag_utils import get_ometa_tag_and_classification
@@ -150,7 +139,6 @@ SnowflakeDialect._get_schema_foreign_keys = get_schema_foreign_keys
 
 
 class SnowflakeSource(
-    StoredProcedureMixin,
     ExternalTableLineageMixin,
     CommonDbSourceService,
     MultiDBSource,
@@ -635,34 +623,26 @@ class SnowflakeSource(
 
         return views
 
-    def _get_stored_procedures_internal(
-        self, query: str
-    ) -> Iterable[SnowflakeStoredProcedure]:
-        results = self.engine.execute(
-            query.format(
-                database_name=self.context.get().database,
-                schema_name=self.context.get().database_schema,
-            )
-        ).all()
-        for row in results:
-            stored_procedure = SnowflakeStoredProcedure.model_validate(dict(row))
-            if stored_procedure.definition is None:
-                logger.debug(
-                    f"Missing ownership permissions on procedure {stored_procedure.name}."
-                    " Trying to fetch description via DESCRIBE."
-                )
-                stored_procedure.definition = self.describe_procedure_definition(
-                    stored_procedure
-                )
-            yield stored_procedure
-
     def get_stored_procedures(self) -> Iterable[SnowflakeStoredProcedure]:
         """List Snowflake stored procedures"""
         if self.source_config.includeStoredProcedures:
-            yield from self._get_stored_procedures_internal(
-                SNOWFLAKE_GET_STORED_PROCEDURES
-            )
-            yield from self._get_stored_procedures_internal(SNOWFLAKE_GET_FUNCTIONS)
+            results = self.engine.execute(
+                SNOWFLAKE_GET_STORED_PROCEDURES.format(
+                    database_name=self.context.get().database,
+                    schema_name=self.context.get().database_schema,
+                )
+            ).all()
+            for row in results:
+                stored_procedure = SnowflakeStoredProcedure.model_validate(dict(row))
+                if stored_procedure.definition is None:
+                    logger.debug(
+                        f"Missing ownership permissions on procedure {stored_procedure.name}."
+                        " Trying to fetch description via DESCRIBE."
+                    )
+                    stored_procedure.definition = self.describe_procedure_definition(
+                        stored_procedure
+                    )
+                yield stored_procedure
 
     def describe_procedure_definition(
         self, stored_procedure: SnowflakeStoredProcedure
@@ -674,12 +654,8 @@ class SnowflakeSource(
         Then, if the procedure is created with `EXECUTE AS CALLER`, we can still try to
         get the definition with a DESCRIBE.
         """
-        if stored_procedure.procedure_type == StoredProcedureType.StoredProcedure.value:
-            query = SNOWFLAKE_DESC_STORED_PROCEDURE
-        else:
-            query = SNOWFLAKE_DESC_FUNCTION
         res = self.engine.execute(
-            query.format(
+            SNOWFLAKE_DESC_STORED_PROCEDURE.format(
                 database_name=self.context.get().database,
                 schema_name=self.context.get().database_schema,
                 procedure_name=stored_procedure.name,
@@ -701,8 +677,6 @@ class SnowflakeSource(
                     language=STORED_PROC_LANGUAGE_MAP.get(stored_procedure.language),
                     code=stored_procedure.definition,
                 ),
-                storedProcedureType=stored_procedure.procedure_type
-                or StoredProcedureType.StoredProcedure.value,
                 databaseSchema=fqn.build(
                     metadata=self.metadata,
                     entity_type=DatabaseSchema,
@@ -731,22 +705,6 @@ class SnowflakeSource(
                 )
             )
 
-    def get_stored_procedure_queries_dict(self) -> Dict[str, List[QueryByProcedure]]:
-        """
-        Return the dictionary associating stored procedures to the
-        queries they triggered
-        """
-        start, _ = get_start_and_end(self.source_config.queryLogDuration)
-        query = SNOWFLAKE_GET_STORED_PROCEDURE_QUERIES.format(
-            start_date=start,
-        )
-
-        queries_dict = self.procedure_queries_dict(
-            query=query,
-        )
-
-        return queries_dict
-
     def mark_tables_as_deleted(self):
         """
         Use the current inspector to mark tables as deleted

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

@@ -15,11 +15,19 @@ import urllib
 from datetime import datetime
 from typing import List, Optional
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, TypeAdapter, field_validator
 from requests.utils import quote
+from sqlalchemy import text
+from sqlalchemy.orm import Session
 
 from metadata.generated.schema.entity.data.storedProcedure import Language
+from metadata.ingestion.source.database.snowflake.queries import (
+    SNOWFLAKE_QUERY_LOG_QUERY,
+)
+from metadata.profiler.metrics.system.dml_operation import DatabaseDMLOperations
+from metadata.utils.dict import ExtendedDict
 from metadata.utils.logger import ingestion_logger
+from metadata.utils.profiler_utils import QueryResult
 
 logger = ingestion_logger()
 
@@ -42,7 +50,6 @@ class SnowflakeStoredProcedure(BaseModel):
         None, alias="SIGNATURE", description="Used to build the source URL"
     )
     comment: Optional[str] = Field(None, alias="COMMENT")
-    procedure_type: Optional[str] = Field(None, alias="PROCEDURE_TYPE")
 
     # Update the signature to clean it up on read
     @field_validator("signature")
@@ -96,3 +103,44 @@ class SnowflakeTableList(BaseModel):
 
     def get_not_deleted(self) -> List[SnowflakeTable]:
         return [table for table in self.tables if not table.deleted]
+
+
+class SnowflakeQueryLogEntry(BaseModel):
+    """Entry for a Snowflake query log at SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
+    More info at: https://docs.snowflake.com/en/sql-reference/account-usage/query_history
+    """
+
+    query_id: str
+    database_name: Optional[str] = None
+    schema_name: Optional[str] = None
+    query_type: str
+    start_time: datetime
+    query_text: Optional[str] = None
+    rows_inserted: Optional[int] = None
+    rows_updated: Optional[int] = None
+    rows_deleted: Optional[int] = None
+
+    @staticmethod
+    def get_for_table(session: Session, tablename: str):
+        rows = session.execute(
+            text(
+                SNOWFLAKE_QUERY_LOG_QUERY.format(
+                    tablename=tablename,  # type: ignore
+                    insert=DatabaseDMLOperations.INSERT.value,
+                    update=DatabaseDMLOperations.UPDATE.value,
+                    delete=DatabaseDMLOperations.DELETE.value,
+                    merge=DatabaseDMLOperations.MERGE.value,
+                )
+            )
+        )
+        return TypeAdapter(List[SnowflakeQueryLogEntry]).validate_python(
+            [ExtendedDict(r).lower_case_keys() for r in rows]
+        )
+
+
+class SnowflakeQueryResult(QueryResult):
+    """Snowflake system metric query result"""
+
+    rows_inserted: Optional[int] = None
+    rows_updated: Optional[int] = None
+    rows_deleted: Optional[int] = None

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

@@ -0,0 +1,26 @@
+#  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.
+
+"""
+Profiler for Snowflake
+"""
+from metadata.ingestion.source.database.snowflake.profiler.system import (
+    SnowflakeSystemMetricsComputer,
+)
+from metadata.profiler.interface.sqlalchemy.snowflake.profiler_interface import (
+    SnowflakeProfilerInterface,
+)
+from metadata.profiler.metrics.system.system import SystemMetricsComputer
+
+
+class SnowflakeProfiler(SnowflakeProfilerInterface):
+    def initialize_system_metrics_computer(self) -> SystemMetricsComputer:
+        return SnowflakeSystemMetricsComputer(session=self.session)

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

@@ -0,0 +1,436 @@
+"""Snowflake system metrics source"""
+
+import hashlib
+import re
+import traceback
+from typing import List, Optional, Tuple
+
+import sqlalchemy.orm
+from pydantic import TypeAdapter
+
+from metadata.generated.schema.entity.data.table import DmlOperationType, SystemProfile
+from metadata.ingestion.source.database.snowflake.models import (
+    SnowflakeQueryLogEntry,
+    SnowflakeQueryResult,
+)
+from metadata.profiler.metrics.system.dml_operation import DatabaseDMLOperations
+from metadata.profiler.metrics.system.system import (
+    CacheProvider,
+    EmptySystemMetricsSource,
+    SQASessionProvider,
+    SystemMetricsComputer,
+)
+from metadata.utils.collections import CaseInsensitiveString
+from metadata.utils.logger import profiler_logger
+from metadata.utils.lru_cache import LRU_CACHE_SIZE, LRUCache
+from metadata.utils.profiler_utils import get_identifiers_from_string
+from metadata.utils.time_utils import datetime_to_timestamp
+
+PUBLIC_SCHEMA = "PUBLIC"
+logger = profiler_logger()
+RESULT_SCAN = """
+    SELECT *
+    FROM TABLE(RESULT_SCAN('{query_id}'));
+    """
+QUERY_PATTERN = r"(?:(INSERT\s*INTO\s*|INSERT\s*OVERWRITE\s*INTO\s*|UPDATE\s*|MERGE\s*INTO\s*|DELETE\s*FROM\s*))([\w._\"\'()]+)(?=[\s*\n])"  # pylint: disable=line-too-long
+IDENTIFIER_PATTERN = r"(IDENTIFIER\(\')([\w._\"]+)(\'\))"
+
+
+def sha256_hash(text: str) -> str:
+    """Return the SHA256 hash of the text"""
+
+    return hashlib.sha256(text.encode()).hexdigest()
+
+
+cache = LRUCache(LRU_CACHE_SIZE)
+
+
+@cache.wrap(key_func=lambda query: sha256_hash(query.strip()))
+def _parse_query(query: str) -> Optional[str]:
+    """Parse snowflake queries to extract the identifiers"""
+    match = re.match(QUERY_PATTERN, query, re.IGNORECASE)
+    try:
+        # This will match results like `DATABASE.SCHEMA.TABLE1` or IDENTIFIER('TABLE1')
+        # If we have `IDENTIFIER` type of queries coming from Stored Procedures, we'll need to further clean it up.
+        identifier = match.group(2)
+
+        match_internal_identifier = re.match(
+            IDENTIFIER_PATTERN, identifier, re.IGNORECASE
+        )
+        internal_identifier = (
+            match_internal_identifier.group(2) if match_internal_identifier else None
+        )
+        if internal_identifier:
+            return internal_identifier
+
+        return identifier
+    except (IndexError, AttributeError):
+        logger.debug("Could not find identifier in query. Skipping row.")
+        return None
+
+
+class SnowflakeTableResovler:
+    """A class the resolves snowflake tables by mimicking snowflake's default resolution logic:
+    https://docs.snowflake.com/en/sql-reference/name-resolution
+
+    This default specification searches in the following order:
+    - The explicitly provided schema
+    - The current schema
+    - The public schema
+
+    This can be altered by changing the SEARCH_PATH session parameter. If the users change
+    this paramter, this resolver will might return wrong values.
+
+    There is no way to extract the SEARCH_PATH from the query after it has been executed. Hence, we can
+    only rely on the default behavior and maybe allow the users to configure the search path
+    at the connection level (TODO).
+    """
+
+    def __init__(self, session: sqlalchemy.orm.Session):
+        self._cache = LRUCache[bool](LRU_CACHE_SIZE)
+        self.session = session
+
+    def show_tables(self, db, schema, table):
+        return self.session.execute(
+            f'SHOW TABLES LIKE \'{table}\' IN SCHEMA "{db}"."{schema}" LIMIT 1;'
+        ).fetchone()
+
+    def table_exists(self, db, schema, table):
+        """Return True if the table exists in Snowflake. Uses cache to store the results.
+
+        Args:
+            db (str): Database name
+            schema (str): Schema name
+            table (str): Table name
+
+        Returns:
+            bool: True if the table exists in Snowflake
+        """
+        if f"{db}.{schema}.{table}" in self._cache:
+            return self._cache.get(f"{db}.{schema}.{table}")
+        table = self.show_tables(db, schema, table)
+        if table:
+            self._cache.put(f"{db}.{schema}.{table}", True)
+            return True
+        return False
+
+    def resolve_implicit_fqn(
+        self,
+        context_database: str,
+        context_schema: Optional[str],
+        table_name: str,
+    ) -> Tuple[str, str, str]:
+        """Resolve the fully qualified name of the table from snowflake based on the following logic:
+        1. If the schema is provided:
+            a. search for the table in the schema
+            b. if not found, go to (2)
+        2. Search for the table in the public schema.
+
+        Args:
+            context_database (str): Database name
+            context_schema (Optional[str]): Schema name. If not provided, we'll search in the public schema.
+            table_name (str): Table name
+        Returns:
+            tuple: Tuple of database, schema and table names
+        Raises:
+            RuntimeError: If the table is not found in the metadata or if there are duplicate results
+            (there shouldn't be)
+
+        """
+        search_paths = []
+        if context_schema and self.table_exists(
+            context_database, context_schema, table_name
+        ):
+            search_paths += ".".join([context_database, context_schema, table_name])
+            return context_database, context_schema, table_name
+        if context_schema != PUBLIC_SCHEMA and self.table_exists(
+            context_database, PUBLIC_SCHEMA, table_name
+        ):
+            search_paths += ".".join([context_database, PUBLIC_SCHEMA, table_name])
+            return context_database, PUBLIC_SCHEMA, table_name
+        raise RuntimeError(
+            "Could not find the table {search_paths}.".format(  # pylint: disable=consider-using-f-string
+                search_paths=" OR ".join(map(lambda x: f"[{x}]", search_paths))
+            )
+        )
+
+    def resolve_snowflake_fqn(
+        self,
+        context_database: str,
+        context_schema: Optional[str],
+        identifier: str,
+    ) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """Get query identifiers from the query text. If the schema is not provided in the query, we'll look for
+        the table under "PUBLIC" in Snowflake.
+        Database can be retrieved from the query or the query context.
+        If the schema doesnt exist in the query but does in the context, we need to check with Snowflake if table
+        exists in (1) the context schema or ib (2) the public schema in order to imitate the behavior of the query
+        engine. There are edge cases where the table was deleted (and hence not found in the metadata). In such cases,
+        the function will raise an error. It is advised to set the profier window such that there will be minimal
+        drift between the query execution and the profiler run.
+
+        Args:
+            context_database (str): Database name from the query context
+            context_schema (Optional[str]): Schema name from the query context
+            identifier (str): Identifier string extracted from a query (can be
+             'db.schema.table', 'schema.table' or just 'table')
+        Returns:
+            Tuple[Optional[str], Optional[str], Optional[str]]: Tuple of database, schema and table names
+        Raises:
+            RuntimeError: If the table name is not found in the query or if fqn resolution fails
+        """
+        (
+            database_identifier,
+            schema_identifier,
+            table_name,
+        ) = get_identifiers_from_string(identifier)
+        if not table_name:
+            raise RuntimeError("Could not extract the table name.")
+        if not context_database and not database_identifier:
+            logger.debug(
+                f"Could not resolve database name. {identifier=}, {context_database=}"
+            )
+            raise RuntimeError("Could not resolve database name.")
+        if schema_identifier is not None:
+            return (
+                database_identifier or context_database,
+                schema_identifier,
+                table_name,
+            )
+        logger.debug(
+            "Missing schema info from the query. We'll look for it in Snowflake for [%s] or [%s]",
+            (
+                ".".join(
+                    [
+                        database_identifier or context_database,
+                        context_schema,
+                        table_name,
+                    ]
+                )
+                if context_schema
+                else None
+            ),
+            ".".join(
+                [database_identifier or context_database, PUBLIC_SCHEMA, table_name]
+            ),
+        )
+        # If the schema is not explicitly provided in the query, we'll need to resolve it from OpenMetadata
+        # by cascading the search from the context to the public schema.
+        result = self.resolve_implicit_fqn(
+            context_database=context_database,
+            context_schema=context_schema,
+            table_name=table_name,
+        )
+        logger.debug("Resolved table [%s]", ".".join(result))
+        return result
+
+
+def get_snowflake_system_queries(
+    query_log_entry: SnowflakeQueryLogEntry,
+    resolver: SnowflakeTableResovler,
+) -> Optional[SnowflakeQueryResult]:
+    """
+    Run a regex lookup on the query to identify which operation ran against the table.
+
+    If the query does not have the complete set of `database.schema.table` when it runs,
+    we'll use ES to pick up the table, if we find it.
+
+    Args:
+        query_log_entry (dict): row from the snowflake system queries table
+        resolver (SnowflakeTableResolver): resolver to get the table identifiers
+    Returns:
+        QueryResult: namedtuple with the query result
+    """
+
+    try:
+        logger.debug(f"Parsing snowflake query [{query_log_entry.query_id}]")
+        identifier = _parse_query(query_log_entry.query_text)
+        if not identifier:
+            raise RuntimeError("Could not identify the table from the query.")
+
+        database_name, schema_name, table_name = resolver.resolve_snowflake_fqn(
+            identifier=identifier,
+            context_database=query_log_entry.database_name,
+            context_schema=query_log_entry.schema_name,
+        )
+
+        if not all([database_name, schema_name, table_name]):
+            raise RuntimeError(
+                f"Could not extract the identifiers from the query [{query_log_entry.query_id}]."
+            )
+
+        return SnowflakeQueryResult(
+            query_id=query_log_entry.query_id,
+            database_name=database_name.lower(),
+            schema_name=schema_name.lower(),
+            table_name=table_name.lower(),
+            query_text=query_log_entry.query_text,
+            query_type=query_log_entry.query_type,
+            start_time=query_log_entry.start_time,
+            rows_inserted=query_log_entry.rows_inserted,
+            rows_updated=query_log_entry.rows_updated,
+            rows_deleted=query_log_entry.rows_deleted,
+        )
+    except Exception as exc:
+        logger.debug(traceback.format_exc())
+        logger.warning(
+            f"""Error while processing query with id [{query_log_entry.query_id}]: {exc}\n
+            To investigate the query run:
+            SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY WHERE query_id = '{query_log_entry.query_id}'
+            """
+        )
+    return None
+
+
+class SnowflakeSystemMetricsSource(
+    SQASessionProvider, EmptySystemMetricsSource, CacheProvider[SnowflakeQueryLogEntry]
+):
+    """Snowflake system metrics source"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.resolver = SnowflakeTableResovler(
+            session=super().get_session(),
+        )
+
+    def get_kwargs(self, **kwargs):
+        table = kwargs.get("table")
+        return {
+            "table": table.__table__.name,
+            "database": self.get_session().get_bind().url.database,
+            "schema": table.__table__.schema,
+        }
+
+    def get_inserts(self, **kwargs) -> List[SystemProfile]:
+        database, schema, table = (
+            kwargs.get("database"),
+            kwargs.get("schema"),
+            kwargs.get("table"),
+        )
+        return self.get_system_profile(
+            database,
+            schema,
+            table,
+            list(
+                self.get_queries_by_operation(
+                    table,
+                    [
+                        DatabaseDMLOperations.INSERT,
+                        DatabaseDMLOperations.MERGE,
+                    ],
+                )
+            ),
+            "rows_inserted",
+            DmlOperationType.INSERT,
+        )
+
+    def get_updates(self, **kwargs) -> List[SystemProfile]:
+        database, schema, table = (
+            kwargs.get("database"),
+            kwargs.get("schema"),
+            kwargs.get("table"),
+        )
+        return self.get_system_profile(
+            database,
+            schema,
+            table,
+            list(
+                self.get_queries_by_operation(
+                    table,
+                    [
+                        DatabaseDMLOperations.UPDATE,
+                        DatabaseDMLOperations.MERGE,
+                    ],
+                )
+            ),
+            "rows_updated",
+            DmlOperationType.UPDATE,
+        )
+
+    def get_deletes(self, **kwargs) -> List[SystemProfile]:
+        database, schema, table = (
+            kwargs.get("database"),
+            kwargs.get("schema"),
+            kwargs.get("table"),
+        )
+        return self.get_system_profile(
+            database,
+            schema,
+            table,
+            list(
+                self.get_queries_by_operation(
+                    table,
+                    [
+                        DatabaseDMLOperations.DELETE,
+                    ],
+                )
+            ),
+            "rows_deleted",
+            DmlOperationType.DELETE,
+        )
+
+    @staticmethod
+    def get_system_profile(
+        db: str,
+        schema: str,
+        table: str,
+        query_results: List[SnowflakeQueryResult],
+        rows_affected_field: str,
+        operation: DmlOperationType,
+    ) -> List[SystemProfile]:
+        if not SnowflakeQueryResult.model_fields.get(rows_affected_field):
+            raise ValueError(
+                f"rows_affected_field [{rows_affected_field}] is not a valid field in SnowflakeQueryResult."
+            )
+        return TypeAdapter(List[SystemProfile]).validate_python(
+            [
+                {
+                    "timestamp": datetime_to_timestamp(q.start_time, milliseconds=True),
+                    "operation": operation,
+                    "rowsAffected": getattr(q, rows_affected_field),
+                }
+                for q in query_results
+                if getattr(q, rows_affected_field) > 0
+                # snowflake SQL identifiers are case insensitive. All identifiers are stored in upper case.
+                and (
+                    CaseInsensitiveString(db),
+                    CaseInsensitiveString(schema),
+                    CaseInsensitiveString(table),
+                )
+                == (
+                    q.database_name,
+                    q.schema_name,
+                    q.table_name,
+                )
+            ]
+        )
+
+    def get_queries_by_operation(
+        self, table: str, operations: List[DatabaseDMLOperations]
+    ):
+        ops = [op.value for op in operations]
+        yield from (
+            query for query in self.get_queries(table) if query.query_type in ops
+        )
+
+    def get_queries(self, table: str) -> List[SnowflakeQueryResult]:
+        queries = self.get_or_update_cache(
+            table,
+            SnowflakeQueryLogEntry.get_for_table,
+            session=super().get_session(),
+            tablename=table,
+        )
+        results = [
+            get_snowflake_system_queries(
+                query_log_entry=row,
+                resolver=self.resolver,
+            )
+            for row in queries
+        ]
+        return [result for result in results if result is not None]
+
+
+class SnowflakeSystemMetricsComputer(
+    SystemMetricsComputer, SnowflakeSystemMetricsSource
+):
+    pass