openmetadata-ingestion 1.7.0.0rc2__py3-none-any.whl → 1.7.0.1__py3-none-any.whl

metadata/generated/schema/type/tableQuery.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  type/tableQuery.json
-#   timestamp: 2025-04-14T07:35:48+00:00
+#   timestamp: 2025-05-15T07:28:23+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/type/tableUsageCount.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  type/tableUsageCount.json
-#   timestamp: 2025-04-14T07:35:48+00:00
+#   timestamp: 2025-05-15T07:28:23+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/type/tagLabel.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  type/tagLabel.json
-#   timestamp: 2025-04-14T07:35:48+00:00
+#   timestamp: 2025-05-15T07:28:23+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/type/usageDetails.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  type/usageDetails.json
-#   timestamp: 2025-04-14T07:35:48+00:00
+#   timestamp: 2025-05-15T07:28:23+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/type/usageRequest.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  type/usageRequest.json
-#   timestamp: 2025-04-14T07:35:48+00:00
+#   timestamp: 2025-05-15T07:28:23+00:00
 
 from __future__ import annotations
 

metadata/generated/schema/type/votes.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  type/votes.json
-#   timestamp: 2025-04-14T07:35:48+00:00
+#   timestamp: 2025-05-15T07:28:23+00:00
 
 from __future__ import annotations
 

metadata/ingestion/api/topology_runner.py

@@ -71,14 +71,22 @@ class TopologyRunnerMixin(Generic[C]):
     cache = defaultdict(dict)
     queue = Queue()
 
+    def _run_node_producer(self, node: TopologyNode) -> Iterable[Entity]:
+        """Run the node producer"""
+        try:
+            node_producer = getattr(self, node.producer)
+            yield from node_producer() or []
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.error(f"Error running node producer: {exc}")
+
     def _multithread_process_node(
         self, node: TopologyNode, threads: int
     ) -> Iterable[Entity]:
         """Multithread Processing of a Node"""
-        node_producer = getattr(self, node.producer)
         child_nodes = self._get_child_nodes(node)
 
-        node_entities = list(node_producer() or [])
+        node_entities = list(self._run_node_producer(node) or [])
         node_entities_length = len(node_entities)
 
         if node_entities_length == 0:
@@ -120,10 +128,9 @@ class TopologyRunnerMixin(Generic[C]):
 
     def _process_node(self, node: TopologyNode) -> Iterable[Entity]:
         """Processing of a Node in a single thread."""
-        node_producer = getattr(self, node.producer)
         child_nodes = self._get_child_nodes(node)
 
-        for node_entity in node_producer() or []:
+        for node_entity in self._run_node_producer(node) or []:
             for stage in node.stages:
                 yield from self._process_stage(
                     stage=stage, node_entity=node_entity, child_nodes=child_nodes
@@ -217,6 +224,17 @@ class TopologyRunnerMixin(Generic[C]):
             else []
         )
 
+    def _run_stage_processor(
+        self, stage: NodeStage, node_entity: Any
+    ) -> Iterable[Entity]:
+        """Run the stage processor"""
+        try:
+            stage_fn = getattr(self, stage.processor)
+            yield from stage_fn(node_entity) or []
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.error(f"Error running stage processor: {exc}")
+
     def _process_stage(
         self, stage: NodeStage, node_entity: Any, child_nodes: List[TopologyNode]
     ) -> Iterable[Entity]:
@@ -230,8 +248,9 @@ class TopologyRunnerMixin(Generic[C]):
         """
         logger.debug(f"Processing stage: {stage}")
 
-        stage_fn = getattr(self, stage.processor)
-        for entity_request in stage_fn(node_entity) or []:
+        for entity_request in (
+            self._run_stage_processor(stage=stage, node_entity=node_entity) or []
+        ):
             try:
                 # yield and make sure the data is updated
                 yield from self.sink_request(stage=stage, entity_request=entity_request)

metadata/ingestion/lineage/parser.py

@@ -453,6 +453,7 @@ class LineageParser:
             lr_sqlparser.get_column_lineage()
             return lr_sqlparser
 
+        lr_sqlparser = None
         try:
             lr_sqlparser = get_sqlparser_lineage_runner(query)
             _ = len(lr_sqlparser.get_column_lineage()) + len(
@@ -472,7 +473,7 @@ class LineageParser:
         except Exception:
             # if both runner have failed we return the usual one
             logger.debug(f"Failed to parse query with sqlparse & sqlfluff: {query}")
-            return lr_sqlfluff if lr_sqlfluff else lr_sqlparser
+            return lr_sqlfluff if lr_sqlfluff else None
 
         self.masked_query = mask_query(self._clean_query, parser=lr_sqlparser)
         logger.debug(

metadata/ingestion/models/custom_pydantic.py

@@ -46,6 +46,29 @@ class BaseModel(PydanticBaseModel):
     Specified as `--base-class BASE_CLASS` in the generator.
     """
 
+    def model_post_init(self, context: Any, /):
+        """
+        This function is used to parse the FilterPattern fields for the Connection classes.
+        This is needed because dict is defined in the JSON schema for the FilterPattern field,
+        but a FilterPattern object is required in the generated code.
+        """
+        # pylint: disable=import-outside-toplevel
+        try:
+            if not self.__class__.__name__.endswith("Connection"):
+                # Only parse FilterPattern for Connection classes
+                return
+            for field in self.__pydantic_fields__:
+                if field.endswith("FilterPattern"):
+                    from metadata.generated.schema.type.filterPattern import (
+                        FilterPattern,
+                    )
+
+                    value = getattr(self, field)
+                    if isinstance(value, dict):
+                        setattr(self, field, FilterPattern(**value))
+        except Exception as exc:
+            logger.warning(f"Exception while parsing FilterPattern: {exc}")
+
     @model_validator(mode="after")
     @classmethod
     def parse_name(cls, values):  # pylint: disable=inconsistent-return-statements
@@ -70,7 +93,7 @@ class BaseModel(PydanticBaseModel):
             raise exc
         return values
 
-    def model_dump_json(  # pylint: disable=too-many-arguments,unused-argument
+    def model_dump_json(  # pylint: disable=too-many-arguments
         self,
         *,
         mask_secrets: Optional[bool] = None,
@@ -83,7 +106,7 @@ class BaseModel(PydanticBaseModel):
         exclude_defaults: bool = False,
         exclude_none: bool = True,
         round_trip: bool = False,
-        warnings: Union[bool, Literal["none", "warn", "error"]] = True,
+        warnings: Union[bool, Literal["none", "warn", "error"]] = "none",
         fallback: Optional[Callable[[Any], Any]] = None,
         serialize_as_any: bool = False,
     ) -> str:
@@ -127,12 +150,17 @@ class BaseModel(PydanticBaseModel):
         self,
         *,
         mask_secrets: bool = False,
+        warnings: Union[bool, Literal["none", "warn", "error"]] = "none",
         **kwargs,
     ) -> Dict[str, Any]:
         if mask_secrets:
             context = kwargs.pop("context", None) or {}
             context["mask_secrets"] = True
             kwargs["context"] = context
+
+        if "warnings" not in kwargs:
+            kwargs["warnings"] = warnings
+
         return super().model_dump(**kwargs)
 
 

metadata/ingestion/source/api/rest/connection.py

@@ -30,8 +30,6 @@ from metadata.ingestion.connections.test_connections import test_connection_step
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.utils.constants import THREE_MIN
 
-ACCEPTED_CONTENT_TYPES = ["application/json", "application/vnd.oai.openapi+json"]
-
 
 class SchemaURLError(Exception):
     """
@@ -68,21 +66,25 @@ def test_connection(
     """
 
     def custom_url_exec():
-        if client.status_code == 200 and any(
-            content_type in client.headers.get("content-type")
-            for content_type in ACCEPTED_CONTENT_TYPES
-        ):
+        if client.status_code == 200:
             return []
         raise SchemaURLError(
-            "Failed to parse JSON schema url. Please check if provided url is valid JSON schema."
+            "Failed to connect to the JSON schema url. Please check the url and credentials. Status Code was: "
+            + str(client.status_code)
         )
 
     def custom_schema_exec():
-        if client.json().get("openapi") is not None:
-            return []
-        raise InvalidOpenAPISchemaError(
-            "Provided schema is not valid OpenAPI JSON schema"
-        )
+        try:
+            if client.json() is not None and client.json().get("openapi") is not None:
+                return []
+
+            raise InvalidOpenAPISchemaError(
+                "Provided schema is not valid OpenAPI JSON schema"
+            )
+        except:
+            raise InvalidOpenAPISchemaError(
+                "Provided schema is not valid OpenAPI JSON schema"
+            )
 
     test_fn = {"CheckURL": custom_url_exec, "CheckSchema": custom_schema_exec}
 

metadata/ingestion/source/dashboard/dashboard_service.py

@@ -612,6 +612,7 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
         patch_request = PatchRequest(
             original_entity=original_entity,
             new_entity=original_entity.model_copy(update=create_request.__dict__),
+            override_metadata=self.source_config.overrideMetadata,
         )
         if isinstance(original_entity, Dashboard):
             # For patch the charts need to be entity ref instead of fqn

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

@@ -697,15 +697,16 @@ class BigquerySource(LifeCycleQueryMixin, CommonDbSourceService, MultiDBSource):
                 )
                 return view_definition
 
-            schema_definition = inspector.get_table_ddl(
-                self.connection, table_name, schema_name
-            )
-            schema_definition = (
-                str(schema_definition).strip()
-                if schema_definition is not None
-                else None
-            )
-            return schema_definition
+            if self.source_config.includeDDL:
+                schema_definition = inspector.get_table_ddl(
+                    self.connection, table_name, schema_name
+                )
+                schema_definition = (
+                    str(schema_definition).strip()
+                    if schema_definition is not None
+                    else None
+                )
+                return schema_definition
         except NotImplementedError:
             logger.warning("Schema definition not implemented")
         return None

metadata/ingestion/source/database/clickhouse/metadata.py

@@ -10,7 +10,6 @@
 #  limitations under the License.
 """Clickhouse source module"""
 
-import traceback
 from typing import Iterable, Optional
 
 from clickhouse_sqlalchemy.drivers.base import ClickHouseDialect
@@ -145,35 +144,3 @@ class ClickhouseSource(CommonDbSourceService):
         ]
 
         return regular_tables + material_tables + view_tables
-
-    def get_schema_definition(
-        self, table_type: str, table_name: str, schema_name: str, inspector: Inspector
-    ) -> Optional[str]:
-        """
-        Get the DDL statement or View Definition for a table
-        """
-        try:
-            if table_type in {TableType.View, TableType.MaterializedView}:
-                definition_fn = inspector.get_view_definition
-                schema_definition = definition_fn(table_name, schema_name)
-                return (
-                    str(schema_definition).strip()
-                    if schema_definition is not None
-                    else None
-                )
-            schema_definition = inspector.get_table_ddl(
-                self.connection, table_name, schema_name
-            )
-            return (
-                str(schema_definition).strip()
-                if schema_definition is not None
-                else None
-            )
-
-        except NotImplementedError:
-            logger.warning("Schema definition not implemented")
-
-        except Exception as exc:
-            logger.debug(traceback.format_exc())
-            logger.warning(f"Failed to fetch schema definition for {table_name}: {exc}")
-        return None

metadata/ingestion/source/database/common_db_source.py

@@ -69,7 +69,6 @@ from metadata.ingestion.source.database.database_service import DatabaseServiceS
 from metadata.ingestion.source.database.sql_column_handler import SqlColumnHandlerMixin
 from metadata.ingestion.source.database.sqlalchemy_source import SqlAlchemySource
 from metadata.ingestion.source.database.stored_procedures_mixin import QueryByProcedure
-from metadata.ingestion.source.models import TableView
 from metadata.utils import fqn
 from metadata.utils.constraints import get_relationship_type
 from metadata.utils.execution_time_tracker import (
@@ -143,7 +142,6 @@ class CommonDbSourceService(
         self._inspector_map = {}
         self.table_constraints = None
         self.database_source_state = set()
-        self.context.get_global().table_views = []
         self.context.get_global().table_constrains = []
         self.context.get_global().foreign_tables = []
         self.context.set_threads(self.source_config.threads)
@@ -424,7 +422,14 @@ class CommonDbSourceService(
         """
         try:
             schema_definition = None
-            if table_type in (TableType.View, TableType.MaterializedView):
+            # Lineage qualified table types to be considered for view definition
+            if table_type in (
+                TableType.View,
+                TableType.MaterializedView,
+                TableType.SecureView,
+                TableType.Dynamic,
+                TableType.Stream,
+            ):
                 schema_definition = inspector.get_view_definition(
                     table_name, schema_name
                 )
@@ -515,15 +520,11 @@ class CommonDbSourceService(
                 inspector=self.inspector,
             )
 
-            schema_definition = (
-                self.get_schema_definition(
-                    table_type=table_type,
-                    table_name=table_name,
-                    schema_name=schema_name,
-                    inspector=self.inspector,
-                )
-                if self.source_config.includeDDL
-                else None
+            schema_definition = self.get_schema_definition(
+                table_type=table_type,
+                table_name=table_name,
+                schema_name=schema_name,
+                inspector=self.inspector,
             )
 
             table_constraints = self.update_table_constraints(
@@ -590,20 +591,6 @@ class CommonDbSourceService(
             # Register the request that we'll handle during the deletion checks
             self.register_record(table_request=table_request)
 
-            # Flag view as visited
-            if (
-                table_type
-                in (TableType.View, TableType.MaterializedView, TableType.SecureView)
-                and schema_definition
-            ):
-                table_view = TableView(
-                    table_name=table_name,
-                    schema_name=schema_name,
-                    db_name=self.context.get().database,
-                    view_definition=schema_definition,
-                )
-                self.context.get_global().table_views.append(table_view)
-
         except Exception as exc:
             error = (
                 f"Unexpected exception to yield table "

metadata/ingestion/source/database/hive/metadata.py

@@ -18,6 +18,7 @@ from typing import Optional, Tuple
 from pyhive.sqlalchemy_hive import HiveDialect
 from sqlalchemy.engine.reflection import Inspector
 
+from metadata.generated.schema.entity.data.table import TableType
 from metadata.generated.schema.entity.services.connections.database.hiveConnection import (
     HiveConnection,
 )
@@ -106,7 +107,13 @@ class HiveSource(CommonDbSourceService):
         Get the DDL statement or View Definition for a table
         """
         try:
-            schema_definition = inspector.get_view_definition(table_name, schema_name)
+            if self.source_config.includeDDL or table_type in (
+                TableType.View,
+                TableType.MaterializedView,
+            ):
+                schema_definition = inspector.get_view_definition(
+                    table_name, schema_name
+                )
             schema_definition = (
                 str(schema_definition).strip()
                 if schema_definition is not None

metadata/ingestion/source/database/oracle/metadata.py

@@ -57,7 +57,6 @@ from metadata.ingestion.source.database.oracle.utils import (
     _get_col_type,
     _get_constraint_data,
     get_columns,
-    get_mview_definition,
     get_mview_names,
     get_mview_names_dialect,
     get_table_comment,
@@ -94,7 +93,6 @@ OracleDialect.get_all_view_definitions = get_all_view_definitions
 OracleDialect.get_all_table_comments = get_all_table_comments
 OracleDialect.get_table_names = get_table_names
 Inspector.get_mview_names = get_mview_names
-Inspector.get_mview_definition = get_mview_definition
 OracleDialect.get_mview_names = get_mview_names_dialect
 Inspector.get_view_names = get_view_names
 OracleDialect.get_view_names = get_view_names_dialect
@@ -146,43 +144,6 @@ class OracleSource(CommonDbSourceService):
 
         return regular_tables + material_tables
 
-    def get_schema_definition(
-        self, table_type: str, table_name: str, schema_name: str, inspector: Inspector
-    ) -> Optional[str]:
-        """
-        Get the DDL statement or View Definition for a table
-        """
-        try:
-            if table_type not in {TableType.View, TableType.MaterializedView}:
-                schema_definition = inspector.get_table_ddl(
-                    self.connection, table_name, schema_name
-                )
-                return (
-                    str(schema_definition).strip()
-                    if schema_definition is not None
-                    else None
-                )
-
-            definition_fn = inspector.get_view_definition
-            if table_type == TableType.MaterializedView:
-                definition_fn = inspector.get_mview_definition
-
-            schema_definition = definition_fn(table_name, schema_name)
-
-            return (
-                str(schema_definition).strip()
-                if schema_definition is not None
-                else None
-            )
-
-        except NotImplementedError:
-            logger.warning("Schema definition not implemented")
-
-        except Exception as exc:
-            logger.debug(traceback.format_exc())
-            logger.warning(f"Failed to fetch Schema definition for {table_name}: {exc}")
-        return None
-
     def process_result(self, data: FetchObjectList):
         """Process data as per our stored procedure format"""
         result_dict = {}

metadata/ingestion/source/database/oracle/utils.py

@@ -264,20 +264,6 @@ def get_mview_names_dialect(self, connection, schema=None, **kw):
     return [self.normalize_name(row[0]) for row in cursor]
 
 
-def get_mview_definition(self, mview_name, schema=None):
-    """Return definition for `mview_name`.
-
-    :param schema: Optional, retrieve names from a non-default schema.
-        For special quoting, use :class:`.quoted_name`.
-
-    """
-
-    with self._operation_context() as conn:
-        return self.dialect.get_view_definition(
-            conn, mview_name, schema, info_cache=self.info_cache
-        )
-
-
 @reflection.cache
 def _get_constraint_data(self, connection, table_name, schema=None, dblink="", **kw):
 

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

@@ -116,7 +116,11 @@ from metadata.ingestion.source.database.snowflake.utils import (
 from metadata.utils import fqn
 from metadata.utils.filters import filter_by_database
 from metadata.utils.logger import ingestion_logger
-from metadata.utils.sqlalchemy_utils import get_all_table_comments, get_all_table_ddls
+from metadata.utils.sqlalchemy_utils import (
+    get_all_table_comments,
+    get_all_table_ddls,
+    get_all_view_definitions,
+)
 from metadata.utils.tag_utils import get_ometa_tag_and_classification
 
 ischema_names["VARIANT"] = VARIANT
@@ -134,6 +138,7 @@ SnowflakeDialect.get_stream_names = get_stream_names
 SnowflakeDialect.get_all_table_comments = get_all_table_comments
 SnowflakeDialect.normalize_name = normalize_names
 SnowflakeDialect.get_table_comment = get_table_comment
+SnowflakeDialect.get_all_view_definitions = get_all_view_definitions
 SnowflakeDialect.get_view_definition = get_view_definition
 SnowflakeDialect.get_unique_constraints = get_unique_constraints
 SnowflakeDialect._get_schema_columns = (  # pylint: disable=protected-access
@@ -678,24 +683,28 @@ class SnowflakeSource(
     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,
-                account_usage=self.service_connection.accountUsageSchema,
-            )
-        ).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
+        try:
+            results = self.engine.execute(
+                query.format(
+                    database_name=self.context.get().database,
+                    schema_name=self.context.get().database_schema,
+                    account_usage=self.service_connection.accountUsageSchema,
                 )
-            yield stored_procedure
+            ).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
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.error(f"Error fetching stored procedures: {exc}")
 
     def get_stored_procedures(self) -> Iterable[SnowflakeStoredProcedure]:
         """List Snowflake stored procedures"""
@@ -715,19 +724,27 @@ 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(
-                database_name=self.context.get().database,
-                schema_name=self.context.get().database_schema,
-                procedure_name=stored_procedure.name,
-                procedure_signature=stored_procedure.unquote_signature(),
+        try:
+            if (
+                stored_procedure.procedure_type
+                == StoredProcedureType.StoredProcedure.value
+            ):
+                query = SNOWFLAKE_DESC_STORED_PROCEDURE
+            else:
+                query = SNOWFLAKE_DESC_FUNCTION
+            res = self.engine.execute(
+                query.format(
+                    database_name=self.context.get().database,
+                    schema_name=self.context.get().database_schema,
+                    procedure_name=stored_procedure.name,
+                    procedure_signature=stored_procedure.unquote_signature(),
+                )
             )
-        )
-        return dict(res.all()).get("body", "")
+            return dict(res.all()).get("body", "")
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.error(f"Error fetching stored procedure definition: {exc}")
+            return ""
 
     def yield_stored_procedure(
         self, stored_procedure: SnowflakeStoredProcedure
@@ -835,6 +852,21 @@ class SnowflakeSource(
     ) -> Optional[str]:
         """
         Get the DDL statement, View Definition or Stream Definition for a table
+
+        To fetch the view definition, we have followed an optimised approach
+        i.e. fetching view definition of all the views in schema storing it
+        in cache and using the same cache to fetch the view definition.
+
+        To fetch defintion for other types of tables, we have used the
+        get_ddl method, since this method only accepts string literal as arguments
+        it is not possible to do something like this:
+
+        select table_name, schema, get_ddl('table', table_name) from information_schema.tables
+        so we have to fetch the ddl for each table individually.
+
+        Alternavies are executing an stroed procedure to automate this but
+        it requires additional permissions like execute which users may not be comfortable doing.
+        Or reconstruct the ddl from column types, which we can explore in the future.
         """
         try:
             schema_definition = None
@@ -846,7 +878,7 @@ class SnowflakeSource(
                 schema_definition = inspector.get_stream_definition(
                     self.connection, table_name, schema_name
                 )
-            elif hasattr(inspector, "get_table_ddl") and self.source_config.includeDDL:
+            elif self.source_config.includeDDL or table_type == TableType.Dynamic:
                 schema_definition = inspector.get_table_ddl(
                     self.connection, table_name, schema_name
                 )

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

@@ -407,7 +407,11 @@ SELECT GET_DDL('TABLE','{table_name}') AS \"text\"
 """
 
 SNOWFLAKE_GET_VIEW_DEFINITION = """
-SELECT GET_DDL('VIEW','{view_name}') AS \"text\"
+SELECT table_name "view_name",
+    table_schema "schema",
+    view_definition "view_def"
+FROM information_schema.views
+WHERE view_definition is not null
 """
 
 SNOWFLAKE_GET_STREAM_DEFINITION = """