openmetadata-ingestion 1.7.0.1__py3-none-any.whl → 1.7.1.1__py3-none-any.whl

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

@@ -76,7 +76,6 @@ from metadata.ingestion.source.dashboard.tableau.models import (
     DatasourceField,
     TableAndQuery,
     TableauDashboard,
-    TableauTag,
     UpstreamTable,
 )
 from metadata.ingestion.source.database.column_type_parser import ColumnTypeParser
@@ -128,13 +127,6 @@ class TableauSource(DashboardServiceSource):
             )
         return cls(config, metadata)
 
-    def prepare(self):
-        """
-        Prepare the source before ingestion
-        we will fetch the custom sql tables from the tableau server
-        """
-        self.client.cache_custom_sql_tables()
-
     def get_dashboards_list(self) -> Optional[List[TableauDashboard]]:
         return self.client.get_workbooks()
 
@@ -145,18 +137,6 @@ class TableauSource(DashboardServiceSource):
         """
         Get Dashboard Details including the dashboard charts and datamodels
         """
-
-        # Get the tableau views/sheets
-        dashboard.charts = self.client.get_workbook_charts(dashboard_id=dashboard.id)
-
-        # Get the tableau data sources
-        dashboard.dataModels = self.client.get_datasources(dashboard_id=dashboard.id)
-
-        # Get custom SQL queries
-        dashboard.custom_sql_queries = self.client.get_custom_sql_table_queries(
-            dashboard_id=dashboard.id
-        )
-
         return dashboard
 
     def get_owner_ref(
@@ -200,16 +180,14 @@ class TableauSource(DashboardServiceSource):
         Method to yield tags related to specific dashboards
         """
         if self.source_config.includeTags:
-            tags: Set[TableauTag] = set()
+            tags: Set = set()
             for container in [[dashboard_details], dashboard_details.charts or []]:
                 for elem in container:
                     tags.update(elem.tags)
-
-            _tags = {tag.label for tag in tags}
             # retrieve tags from data models
             _data_models_tags = self._get_data_models_tags(dashboard_details.dataModels)
 
-            _all_tags = _tags.union(_data_models_tags)
+            _all_tags = tags.union(_data_models_tags)
 
             yield from get_ometa_tag_and_classification(
                 tags=[tag for tag in _all_tags],
@@ -219,9 +197,7 @@ class TableauSource(DashboardServiceSource):
                 include_tags=self.source_config.includeTags,
             )
 
-    def _get_datamodel_sql_query(
-        self, data_model: DataSource, dashboard_details: TableauDashboard
-    ) -> Optional[str]:
+    def _get_datamodel_sql_query(self, data_model: DataSource) -> Optional[str]:
         """
         Method to fetch the custom sql query from the tableau datamodels
         """
@@ -231,8 +207,8 @@ class TableauSource(DashboardServiceSource):
                 for referenced_query in table.referencedByQueries or []:
                     sql_queries.add(referenced_query.query)
             if not sql_queries:
-                if dashboard_details and dashboard_details.custom_sql_queries:
-                    sql_queries.update(dashboard_details.custom_sql_queries)
+                if query := self.client.get_custom_sql_table_queries(data_model.id):
+                    sql_queries.update(query)
             return "\n\n".join(sql_queries) or None
         except Exception as exc:
             logger.debug(traceback.format_exc())
@@ -274,9 +250,7 @@ class TableauSource(DashboardServiceSource):
                     classification_name=TABLEAU_TAG_CATEGORY,
                     include_tags=self.source_config.includeTags,
                 ),
-                sql=self._get_datamodel_sql_query(
-                    data_model=data_model, dashboard_details=dashboard_details
-                ),
+                sql=self._get_datamodel_sql_query(data_model=data_model),
                 owners=self.get_owner_ref(dashboard_details=dashboard_details),
             )
             yield Either(right=data_model_request)
@@ -359,7 +333,7 @@ class TableauSource(DashboardServiceSource):
                 ],
                 tags=get_tag_labels(
                     metadata=self.metadata,
-                    tags=[tag.label for tag in dashboard_details.tags],
+                    tags=list(dashboard_details.tags),
                     classification_name=TABLEAU_TAG_CATEGORY,
                     include_tags=self.source_config.includeTags,
                 ),
@@ -394,7 +368,7 @@ class TableauSource(DashboardServiceSource):
                     columns.append(child_column.fullyQualifiedName.root)
         return columns
 
-    def _get_column_lineage(  # pylint: disable=arguments-differ
+    def _get_column_lineage(
         self,
         upstream_table: UpstreamTable,
         table_entity: Table,
@@ -617,59 +591,13 @@ class TableauSource(DashboardServiceSource):
                         db_service_name=db_service_name,
                         upstream_data_model_entity=upstream_data_model_entity,
                     )
-            except Exception as err:
-                yield Either(
-                    left=StackTraceError(
-                        name="Lineage",
-                        error=(
-                            "Error to yield datamodel table lineage details for DB "
-                            f"service name [{db_service_name}]: {err}"
-                        ),
-                        stackTrace=traceback.format_exc(),
-                    )
-                )
-
-    def yield_dashboard_lineage_details(
-        self,
-        dashboard_details: TableauDashboard,
-        db_service_name: Optional[str] = None,
-    ) -> Iterable[Either[AddLineageRequest]]:
-        """
-        This method creates the lineage between tables and datamodels
 
-        Args:
-            dashboard_details: Tableau Dashboard
-            db_service_name: database service where look up for lineage
-
-        Returns:
-            Lineage request between Data Models and Database tables
-        """
-        for datamodel in dashboard_details.dataModels or []:
-            try:
-                data_model_entity = self._get_datamodel(datamodel=datamodel)
-                if data_model_entity:
-                    if datamodel.upstreamDatasources:
-                        # if we have upstreamDatasources(Published Datasources), create lineage in below format
-                        # Table<->Published Datasource<->Embedded Datasource
-                        yield from self._get_datamodel_table_lineage(
-                            datamodel=datamodel,
-                            data_model_entity=data_model_entity,
-                            db_service_name=db_service_name,
-                        )
-                    else:
-                        # else we'll create lineage only using Embedded Datasources in below format
-                        # Table<->Embedded Datasource
-                        yield from self._get_table_datamodel_lineage(
-                            upstream_data_model=datamodel,
-                            datamodel=datamodel,
-                            db_service_name=db_service_name,
-                            upstream_data_model_entity=data_model_entity,
-                        )
-
-                # Process custom SQL queries if available
-                if dashboard_details.custom_sql_queries:
-                    for query in dashboard_details.custom_sql_queries:
-                        try:
+                    # Process custom SQL queries if available
+                    custom_sql_queries = self.client.get_custom_sql_table_queries(
+                        datasource_id=upstream_data_model.id
+                    )
+                    if custom_sql_queries:
+                        for query in custom_sql_queries or []:
                             db_service_entity = None
                             if db_service_name:
                                 db_service_entity = self.metadata.get_by_name(
@@ -714,15 +642,59 @@ class TableauSource(DashboardServiceSource):
                                 )
                                 for table_entity in from_entities:
                                     yield self._get_add_lineage_request(
-                                        to_entity=data_model_entity,
+                                        to_entity=upstream_data_model_entity,
                                         from_entity=table_entity,
                                         sql=query,
                                     )
-                        except Exception as err:
-                            logger.debug(traceback.format_exc())
-                            logger.error(
-                                f"Error processing custom SQL query lineage: {err}"
-                            )
+
+            except Exception as err:
+                yield Either(
+                    left=StackTraceError(
+                        name="Lineage",
+                        error=(
+                            "Error to yield datamodel table lineage details for DB "
+                            f"service name [{db_service_name}]: {err}"
+                        ),
+                        stackTrace=traceback.format_exc(),
+                    )
+                )
+
+    def yield_dashboard_lineage_details(
+        self,
+        dashboard_details: TableauDashboard,
+        db_service_name: Optional[str] = None,
+    ) -> Iterable[Either[AddLineageRequest]]:
+        """
+        This method creates the lineage between tables and datamodels
+
+        Args:
+            dashboard_details: Tableau Dashboard
+            db_service_name: database service where look up for lineage
+
+        Returns:
+            Lineage request between Data Models and Database tables
+        """
+        for datamodel in dashboard_details.dataModels or []:
+            try:
+                data_model_entity = self._get_datamodel(datamodel=datamodel)
+                if data_model_entity:
+                    if datamodel.upstreamDatasources:
+                        # if we have upstreamDatasources(Published Datasources), create lineage in below format
+                        # Table<->Published Datasource<->Embedded Datasource
+                        yield from self._get_datamodel_table_lineage(
+                            datamodel=datamodel,
+                            data_model_entity=data_model_entity,
+                            db_service_name=db_service_name,
+                        )
+                    else:
+                        # else we'll create lineage only using Embedded Datasources in below format
+                        # Table<->Embedded Datasource
+                        yield from self._get_table_datamodel_lineage(
+                            upstream_data_model=datamodel,
+                            datamodel=datamodel,
+                            db_service_name=db_service_name,
+                            upstream_data_model_entity=data_model_entity,
+                        )
 
             except Exception as err:
                 yield Either(
@@ -748,8 +720,8 @@ class TableauSource(DashboardServiceSource):
                     self.status.filter(chart.name, "Chart Pattern not allowed")
                     continue
                 site_url = (
-                    f"/site/{self.service_connection.siteUrl}/"
-                    if self.service_connection.siteUrl
+                    f"/site/{self.service_connection.siteName}/"
+                    if self.service_connection.siteName
                     else ""
                 )
                 workbook_chart_name = ChartUrl(chart.contentUrl)
@@ -768,7 +740,7 @@ class TableauSource(DashboardServiceSource):
                     sourceUrl=SourceUrl(chart_url),
                     tags=get_tag_labels(
                         metadata=self.metadata,
-                        tags=[tag.label for tag in chart.tags],
+                        tags=list(chart.tags),
                         classification_name=TABLEAU_TAG_CATEGORY,
                         include_tags=self.source_config.includeTags,
                     ),
@@ -1007,7 +979,7 @@ class TableauSource(DashboardServiceSource):
             )
         return None
 
-    def yield_dashboard_usage(  # pylint: disable=W0221
+    def yield_dashboard_usage(
         self, dashboard_details: TableauDashboard
     ) -> Iterable[Either[DashboardUsage]]:
         """
@@ -1027,9 +999,11 @@ class TableauSource(DashboardServiceSource):
                 fields=["usageSummary"],
             )
 
-            current_views = self.client.get_workbook_view_count_by_id(
-                workbook_id=dashboard_details.id
-            )
+            if not dashboard:
+                logger.debug(f"Dashboard {dashboard_fqn} not found, skipping usage")
+                return
+
+            current_views = dashboard_details.user_views
 
             if not current_views:
                 logger.debug(f"No usage to report for {dashboard_details.name}")

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

@@ -13,7 +13,7 @@
 Tableau Source Model module
 """
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Dict, List, Optional, Set, Union
 
 from pydantic import BaseModel, ConfigDict, Field, validator
 
@@ -75,21 +75,12 @@ class TableauOwner(TableauBaseModel):
     email: Optional[str] = None
 
 
-def transform_tags(raw: Union[Dict[str, Any], List[TableauTag]]) -> List[TableauTag]:
-    if isinstance(raw, List):
-        return raw
-    tags = []
-    for tag in raw.get("tag", []):
-        tags.append(TableauTag(**tag))
-    return tags
-
-
-class TableauWorkbook(BaseModel):
+class TableauDatasource(BaseModel):
     """
-    Model for downstream workbook information
+    Model for downstream datasource information
     """
 
-    luid: Optional[str] = None
+    id: Optional[str] = None
     name: Optional[str] = None
 
 
@@ -99,7 +90,7 @@ class CustomSQLTable(TableauBaseModel):
     https://help.tableau.com/current/api/metadata_api/en-us/reference/customsqltable.doc.html
     """
 
-    downstreamWorkbooks: Optional[List[TableauWorkbook]] = None
+    downstreamDatasources: Optional[List[TableauDatasource]] = None
     query: Optional[str] = None
 
 
@@ -178,8 +169,7 @@ class TableauChart(TableauBaseModel):
     """
 
     owner: Optional[TableauOwner] = None
-    tags: Optional[List[TableauTag]] = []
-    _extract_tags = validator("tags", pre=True, allow_reuse=True)(transform_tags)
+    tags: Optional[Set] = []
     contentUrl: Optional[str] = ""
     sheetType: Optional[str] = ChartType.Other.value
 
@@ -194,12 +184,12 @@ class TableauDashboard(TableauBaseModel):
     project: Optional[TableauBaseModel] = None
     description: Optional[str] = None
     owner: Optional[TableauOwner] = None
-    tags: Optional[List[TableauTag]] = []
-    _extract_tags = validator("tags", pre=True, allow_reuse=True)(transform_tags)
+    tags: Optional[Set] = []
     webpageUrl: Optional[str] = None
     charts: Optional[List[TableauChart]] = None
     dataModels: List[DataSource] = []
     custom_sql_queries: Optional[List[str]] = None
+    user_views: Optional[int] = None
 
 
 class TableAndQuery(BaseModel):

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

@@ -83,8 +83,8 @@ TALEAU_GET_CUSTOM_SQL_QUERY = """
   customSQLTables {
     name
     id
-    downstreamWorkbooks {
-      luid
+    downstreamDatasources{
+      id
       name
     }
     query

metadata/ingestion/source/database/athena/metadata.py

@@ -17,6 +17,7 @@ from typing import Iterable, Optional, Tuple
 from pyathena.sqlalchemy.base import AthenaDialect
 from sqlalchemy.engine.reflection import Inspector
 
+from metadata.clients.aws_client import AWSClient
 from metadata.generated.schema.entity.data.databaseSchema import DatabaseSchema
 from metadata.generated.schema.entity.data.table import (
     Column,
@@ -53,6 +54,7 @@ from metadata.ingestion.source.database.common_db_source import (
 from metadata.ingestion.source.database.external_table_lineage_mixin import (
     ExternalTableLineageMixin,
 )
+from metadata.ingestion.source.database.glue.models import DatabasePage
 from metadata.utils import fqn
 from metadata.utils.logger import ingestion_logger
 from metadata.utils.sqlalchemy_utils import get_all_table_ddls, get_table_ddl
@@ -112,6 +114,29 @@ class AthenaSource(ExternalTableLineageMixin, CommonDbSourceService):
             connection=self.service_connection
         )
         self.external_location_map = {}
+        self.schema_description_map = {}
+
+    def prepare(self):
+        """
+        Prepare the source by fetching the schema descriptions from the AWS Glue service.
+        """
+        try:
+            super().prepare()
+            glue_client = AWSClient(self.service_connection.awsConfig).get_glue_client()
+            paginator = glue_client.get_paginator("get_databases")
+            for page in paginator.paginate():
+                database_page = DatabasePage(**page)
+                for database in database_page.DatabaseList or []:
+                    if database.Description:
+                        self.schema_description_map[
+                            database.Name
+                        ] = database.Description
+        except Exception as exc:
+            logger.warning(f"Error preparing Athena source: {exc}")
+            logger.debug(traceback.format_exc())
+
+    def get_schema_description(self, schema_name: str) -> Optional[str]:
+        return self.schema_description_map.get(schema_name)
 
     def query_table_names_and_types(
         self, schema_name: str
@@ -259,6 +284,7 @@ class AthenaSource(ExternalTableLineageMixin, CommonDbSourceService):
                     )
                 )
 
+    # pylint: disable=arguments-differ
     def get_table_description(
         self, schema_name: str, table_name: str, inspector: Inspector
     ) -> str:

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

@@ -89,9 +89,14 @@ def get_connection_url(connection: BigQueryConnection) -> str:
         isinstance(connection.credentials.gcpConfig, GcpCredentialsPath)
         and connection.credentials.gcpConfig.projectId
     ):
-        return (
-            f"{connection.scheme.value}://{connection.credentials.gcpConfig.projectId}"
-        )
+        if isinstance(  # pylint: disable=no-else-return
+            connection.credentials.gcpConfig.projectId, SingleProjectId
+        ):
+            return f"{connection.scheme.value}://{connection.credentials.gcpConfig.projectId.root}"
+
+        elif isinstance(connection.credentials.gcpConfig.projectId, MultipleProjectId):
+            for project_id in connection.credentials.gcpConfig.projectId.root:
+                return f"{connection.scheme.value}://{project_id}"
 
     return f"{connection.scheme.value}://"
 

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

@@ -14,6 +14,7 @@ Source connection helper
 """
 import re
 import traceback
+from copy import deepcopy
 from typing import Any, List, Tuple
 
 from pydantic import BaseModel
@@ -54,24 +55,25 @@ def get_inspector_details(
     """
     # TODO support location property in JSON Schema
     # TODO support OAuth 2.0 scopes
+    new_service_connection = deepcopy(service_connection)
     kwargs = {}
-    if isinstance(service_connection.credentials.gcpConfig, GcpCredentialsValues):
-        service_connection.credentials.gcpConfig.projectId = SingleProjectId(
+    if isinstance(new_service_connection.credentials.gcpConfig, GcpCredentialsValues):
+        new_service_connection.credentials.gcpConfig.projectId = SingleProjectId(
             database_name
         )
-        if service_connection.credentials.gcpImpersonateServiceAccount:
+        if new_service_connection.credentials.gcpImpersonateServiceAccount:
             kwargs[
                 "impersonate_service_account"
             ] = (
-                service_connection.credentials.gcpImpersonateServiceAccount.impersonateServiceAccount
+                new_service_connection.credentials.gcpImpersonateServiceAccount.impersonateServiceAccount
             )
 
             kwargs[
                 "lifetime"
-            ] = service_connection.credentials.gcpImpersonateServiceAccount.lifetime
+            ] = new_service_connection.credentials.gcpImpersonateServiceAccount.lifetime
 
     client = get_bigquery_client(project_id=database_name, **kwargs)
-    engine = get_connection(service_connection)
+    engine = get_connection(new_service_connection)
     inspector = inspect(engine)
 
     return InspectorWrapper(client=client, engine=engine, inspector=inspector)

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

@@ -154,6 +154,18 @@ def _array_sys_data_type_repr(col_type):
     )
 
 
+def get_system_data_type(col_type):
+    """
+    Get the system data type for the column type
+    """
+    if isinstance(col_type, String):
+        return "string"
+    if str(col_type) == "ARRAY":
+        return _array_sys_data_type_repr(col_type)
+
+    return str(col_type)
+
+
 def get_columns(bq_schema):
     """
     get_columns method overwritten to include tag details
@@ -170,11 +182,7 @@ def get_columns(bq_schema):
             "precision": field.precision,
             "scale": field.scale,
             "max_length": field.max_length,
-            "system_data_type": (
-                _array_sys_data_type_repr(col_type)
-                if str(col_type) == "ARRAY"
-                else str(col_type)
-            ),
+            "system_data_type": get_system_data_type(col_type),
             "is_complex": is_complex_type(str(col_type)),
             "policy_tags": None,
         }

metadata/ingestion/source/database/dbt/metadata.py

@@ -150,29 +150,37 @@ class DbtSource(DbtServiceSource):
         Returns dbt owner
         """
         try:
-            owner = None
+            owner_ref = None
             dbt_owner = None
             if catalog_node:
                 dbt_owner = catalog_node.metadata.owner
             if manifest_node:
                 dbt_owner = manifest_node.meta.get(DbtCommonEnum.OWNER.value)
-            if dbt_owner:
-                owner = self.metadata.get_reference_by_name(
+            if dbt_owner and isinstance(dbt_owner, str):
+                owner_ref = self.metadata.get_reference_by_name(
                     name=dbt_owner, is_owner=True
+                ) or self.metadata.get_reference_by_email(email=dbt_owner)
+                if owner_ref:
+                    return owner_ref
+                logger.warning(
+                    "Unable to ingest owner from DBT since no user or"
+                    f" team was found with name {dbt_owner}"
                 )
-
-                if owner:
-                    return owner
-
-                # If owner is not found, try to find the owner in OMD using email
-                owner = self.metadata.get_reference_by_email(email=dbt_owner)
-
-                if not owner:
-                    logger.warning(
-                        "Unable to ingest owner from DBT since no user or"
-                        f" team was found with name {dbt_owner}"
-                    )
-            return owner
+            elif dbt_owner and isinstance(dbt_owner, list):
+                owner_list = EntityReferenceList(root=[])
+                for owner_name in dbt_owner:
+                    owner_ref = self.metadata.get_reference_by_name(
+                        name=owner_name, is_owner=True
+                    ) or self.metadata.get_reference_by_email(email=owner_name)
+                    if owner_ref:
+                        owner_list.root.extend(owner_ref.root)
+                    else:
+                        logger.warning(
+                            "Unable to ingest owner from DBT since no user or"
+                            f" team was found with name {owner_name}"
+                        )
+                if owner_list.root:
+                    return owner_list
         except Exception as exc:
             logger.debug(traceback.format_exc())
             logger.warning(f"Unable to ingest owner from DBT due to: {exc}")
@@ -741,7 +749,12 @@ class DbtSource(DbtServiceSource):
                                     type="table",
                                 ),
                                 lineageDetails=LineageDetails(
-                                    source=LineageSource.DbtLineage
+                                    source=LineageSource.DbtLineage,
+                                    sqlQuery=SqlQuery(
+                                        data_model_link.datamodel.sql.root
+                                    )
+                                    if data_model_link.datamodel.sql
+                                    else None,
                                 ),
                             )
                         )

metadata/ingestion/source/database/life_cycle_query_mixin.py

@@ -128,6 +128,15 @@ class LifeCycleQueryMixin:
                 )
             )
 
+    def get_life_cycle_query(self):
+        """
+        Get the life cycle query
+        """
+        return self.life_cycle_query.format(
+            database_name=self.context.get().database,
+            schema_name=self.context.get().database_schema,
+        )
+
     def yield_life_cycle_data(self, _) -> Iterable[Either[OMetaLifeCycleData]]:
         """
         Get the life cycle data of the table

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

@@ -38,7 +38,10 @@ from metadata.ingestion.connections.test_connections import (
     test_connection_db_schema_sources,
 )
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
-from metadata.ingestion.source.database.mysql.queries import MYSQL_TEST_GET_QUERIES
+from metadata.ingestion.source.database.mysql.queries import (
+    MYSQL_TEST_GET_QUERIES,
+    MYSQL_TEST_GET_QUERIES_SLOW_LOGS,
+)
 from metadata.utils.constants import THREE_MIN
 
 
@@ -50,7 +53,10 @@ def get_connection(connection: MysqlConnection) -> Engine:
         azure_client = AzureClient(connection.authType.azureConfig).create_client()
         if not connection.authType.azureConfig.scopes:
             raise ValueError(
-                "Azure Scopes are missing, please refer https://learn.microsoft.com/en-gb/azure/mysql/flexible-server/how-to-azure-ad#2---retrieve-microsoft-entra-access-token and fetch the resource associated with it, for e.g. https://ossrdbms-aad.database.windows.net/.default"
+                "Azure Scopes are missing, please refer https://learn.microsoft.com/"
+                "en-gb/azure/mysql/flexible-server/how-to-azure-ad#2---retrieve-micr"
+                "osoft-entra-access-token and fetch the resource associated with it,"
+                " for e.g. https://ossrdbms-aad.database.windows.net/.default"
             )
         access_token_obj = azure_client.get_token(
             *connection.authType.azureConfig.scopes.split(",")
@@ -75,7 +81,9 @@ def test_connection(
     of a metadata workflow or during an Automation Workflow
     """
     queries = {
-        "GetQueries": MYSQL_TEST_GET_QUERIES,
+        "GetQueries": MYSQL_TEST_GET_QUERIES
+        if not service_connection.useSlowLogs
+        else MYSQL_TEST_GET_QUERIES_SLOW_LOGS,
     }
     return test_connection_db_schema_sources(
         metadata=metadata,

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

@@ -20,9 +20,9 @@ class MysqlLineageSource(MysqlQueryParserSource, LineageSource):
     sql_stmt = MYSQL_SQL_STATEMENT
     filters = """
         AND (
-            lower(argument) LIKE '%%create%%table%%select%%'
-            OR lower(argument) LIKE '%%insert%%into%%select%%'
-            OR lower(argument) LIKE '%%update%%'
-            OR lower(argument) LIKE '%%merge%%'
+            lower({sql_column}) LIKE '%%create%%table%%select%%'
+            OR lower({sql_column}) LIKE '%%insert%%into%%select%%'
+            OR lower({sql_column}) LIKE '%%update%%'
+            OR lower({sql_column}) LIKE '%%merge%%'
         )
     """