openmetadata-ingestion 1.6.2.1.dev0__py3-none-any.whl → 1.6.3.0__py3-none-any.whl

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

@@ -15,7 +15,7 @@ DBT source methods.
 import traceback
 from copy import deepcopy
 from datetime import datetime
-from typing import Any, Iterable, List, Optional, Union
+from typing import Any, Iterable, List, Optional
 
 from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
 from metadata.generated.schema.api.tests.createTestCase import CreateTestCaseRequest
@@ -63,6 +63,7 @@ from metadata.ingestion.lineage.sql_lineage import get_lineage_by_query
 from metadata.ingestion.models.ometa_classification import OMetaTagAndClassification
 from metadata.ingestion.models.patch_request import PatchedEntity, PatchRequest
 from metadata.ingestion.models.table_metadata import ColumnDescription
+from metadata.ingestion.ometa.client import APIError
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.column_type_parser import ColumnTypeParser
 from metadata.ingestion.source.database.database_service import DataModelLink
@@ -98,7 +99,7 @@ from metadata.utils.elasticsearch import get_entity_from_es_result
 from metadata.utils.entity_link import get_table_fqn
 from metadata.utils.logger import ingestion_logger
 from metadata.utils.tag_utils import get_ometa_tag_and_classification, get_tag_labels
-from metadata.utils.time_utils import convert_timestamp_to_milliseconds
+from metadata.utils.time_utils import datetime_to_timestamp
 
 logger = ingestion_logger()
 
@@ -326,11 +327,14 @@ class DbtSource(DbtServiceSource):
             None,
         )
 
-    def _add_dbt_freshness_test_from_sources(
+    def add_dbt_sources(
         self, key: str, manifest_node, manifest_entities, dbt_objects: DbtObjects
-    ):
-        # in dbt manifest sources node name is table/view name (not test name like with test nodes)
-        # so in order for the test creation to be named precisely I am amending manifest node name within it's deepcopy
+    ) -> None:
+        """
+        Method to append dbt test cases based on sources file for later processing
+        In dbt manifest sources node name is table/view name (not test name like with test nodes)
+        So in order for the test creation to be named precisely I am amending manifest node name within it's deepcopy
+        """
         manifest_node_new = deepcopy(manifest_node)
         manifest_node_new.name = manifest_node_new.name + "_freshness"
 
@@ -350,17 +354,57 @@ class DbtSource(DbtServiceSource):
                 DbtCommonEnum.RESULTS.value
             ] = freshness_test_result
 
-    def add_dbt_sources(
-        self, key: str, manifest_node, manifest_entities, dbt_objects: DbtObjects
-    ) -> None:
-        """
-        Method to append dbt test cases based on sources file for later processing
-        """
-        self._add_dbt_freshness_test_from_sources(
-            key, manifest_node, manifest_entities, dbt_objects
-        )
+    def _get_table_entity(self, table_fqn) -> Optional[Table]:
+        def search_table(fqn_search_string: str) -> Optional[Table]:
+            table_entities = get_entity_from_es_result(
+                entity_list=self.metadata.es_search_from_fqn(
+                    entity_type=Table,
+                    fqn_search_string=fqn_search_string,
+                    fields="sourceHash",
+                ),
+                fetch_multiple_entities=True,
+            )
+            logger.debug(
+                f"Found table entities from {fqn_search_string}: {table_entities}"
+            )
+            return next(iter(filter(None, table_entities)), None)
+
+        try:
+            table_entity = search_table(table_fqn)
+            if table_entity:
+                return table_entity
 
-    # pylint: disable=too-many-locals, too-many-branches, too-many-statements
+            if self.source_config.searchAcrossDatabases:
+                logger.warning(
+                    f"Table {table_fqn} not found under service: {self.config.serviceName}."
+                    "Trying to find table across services"
+                )
+                _, database_name, schema_name, table_name = fqn.split(table_fqn)
+                table_fqn = fqn.build(
+                    self.metadata,
+                    entity_type=Table,
+                    service_name="*",
+                    database_name=database_name,
+                    schema_name=schema_name,
+                    table_name=table_name,
+                )
+                table_entity = search_table(table_fqn)
+                if table_entity:
+                    return table_entity
+
+            logger.warning(
+                f"Unable to find the table '{table_fqn}' in OpenMetadata. "
+                "Please check if the table exists and is ingested in OpenMetadata. "
+                "Also, ensure the name, database, and schema of the manifest node"
+                "match the table present in OpenMetadata."
+            )
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.warning(f"Failed to get table entity from OpenMetadata: {exc}")
+
+        return None
+
+    # pylint: disable=too-many-locals, too-many-branches
     def yield_data_models(
         self, dbt_objects: DbtObjects
     ) -> Iterable[Either[DataModelLink]]:
@@ -471,28 +515,19 @@ class DbtSource(DbtServiceSource):
                     dbt_compiled_query = get_dbt_compiled_query(manifest_node)
                     dbt_raw_query = get_dbt_raw_query(manifest_node)
 
-                    # Get the table entity from ES
                     table_fqn = fqn.build(
                         self.metadata,
                         entity_type=Table,
-                        service_name="*",
+                        service_name=self.config.serviceName,
                         database_name=get_corrected_name(manifest_node.database),
                         schema_name=get_corrected_name(manifest_node.schema_),
                         table_name=model_name,
                     )
 
-                    table_entity: Optional[
-                        Union[Table, List[Table]]
-                    ] = get_entity_from_es_result(
-                        entity_list=self.metadata.es_search_from_fqn(
-                            entity_type=Table,
-                            fqn_search_string=table_fqn,
-                            fields="sourceHash",
-                        ),
-                        fetch_multiple_entities=False,
-                    )
-
-                    if table_entity:
+                    if table_entity := self._get_table_entity(table_fqn=table_fqn):
+                        logger.debug(
+                            f"Using Table Entity for datamodel: {table_entity}"
+                        )
                         data_model_link = DataModelLink(
                             table_entity=table_entity,
                             datamodel=DataModel(
@@ -523,13 +558,7 @@ class DbtSource(DbtServiceSource):
                         )
                         yield Either(right=data_model_link)
                         self.context.get().data_model_links.append(data_model_link)
-                    else:
-                        logger.warning(
-                            f"Unable to find the table '{table_fqn}' in OpenMetadata"
-                            "Please check if the table exists and is ingested in OpenMetadata"
-                            "Also name, database, schema of the manifest node matches with the table present "
-                            "in OpenMetadata"
-                        )
+
                 except Exception as exc:
                     yield Either(
                         left=StackTraceError(
@@ -573,22 +602,14 @@ class DbtSource(DbtServiceSource):
                         parent_fqn = fqn.build(
                             self.metadata,
                             entity_type=Table,
-                            service_name="*",
+                            service_name=self.config.serviceName,
                             database_name=get_corrected_name(parent_node.database),
                             schema_name=get_corrected_name(parent_node.schema_),
                             table_name=table_name,
                         )
 
                         # check if the parent table exists in OM before adding it to the upstream list
-                        parent_table_entity: Optional[
-                            Union[Table, List[Table]]
-                        ] = get_entity_from_es_result(
-                            entity_list=self.metadata.es_search_from_fqn(
-                                entity_type=Table, fqn_search_string=parent_fqn
-                            ),
-                            fetch_multiple_entities=False,
-                        )
-                        if parent_table_entity:
+                        if self._get_table_entity(table_fqn=parent_fqn):
                             upstream_nodes.append(parent_fqn)
                 except Exception as exc:  # pylint: disable=broad-except
                     logger.debug(traceback.format_exc())
@@ -601,22 +622,14 @@ class DbtSource(DbtServiceSource):
             parent_fqn = fqn.build(
                 self.metadata,
                 entity_type=Table,
-                service_name="*",
+                service_name=self.config.serviceName,
                 database_name=get_corrected_name(dbt_node.database),
                 schema_name=get_corrected_name(dbt_node.schema_),
                 table_name=dbt_node.name,
             )
 
             # check if the parent table exists in OM before adding it to the upstream list
-            parent_table_entity: Optional[
-                Union[Table, List[Table]]
-            ] = get_entity_from_es_result(
-                entity_list=self.metadata.es_search_from_fqn(
-                    entity_type=Table, fqn_search_string=parent_fqn
-                ),
-                fetch_multiple_entities=False,
-            )
-            if parent_table_entity:
+            if self._get_table_entity(table_fqn=parent_fqn):
                 upstream_nodes.append(parent_fqn)
 
         return upstream_nodes
@@ -708,14 +721,8 @@ class DbtSource(DbtServiceSource):
 
         for upstream_node in data_model_link.datamodel.upstream:
             try:
-                from_es_result = self.metadata.es_search_from_fqn(
-                    entity_type=Table,
-                    fqn_search_string=upstream_node,
-                )
-                from_entity: Optional[
-                    Union[Table, List[Table]]
-                ] = get_entity_from_es_result(
-                    entity_list=from_es_result, fetch_multiple_entities=False
+                from_entity: Optional[Table] = self._get_table_entity(
+                    table_fqn=upstream_node
                 )
                 if from_entity and to_entity:
                     yield Either(
@@ -989,6 +996,7 @@ class DbtSource(DbtServiceSource):
                         self.metadata, entity_link_str
                     )
                     table_fqn = get_table_fqn(entity_link_str)
+                    logger.debug(f"Table fqn found: {table_fqn}")
                     source_elements = table_fqn.split(fqn.FQN_SEPARATOR)
                     test_case_fqn = fqn.build(
                         self.metadata,
@@ -1024,6 +1032,7 @@ class DbtSource(DbtServiceSource):
                                 owners=None,
                             )
                         )
+                    logger.debug(f"Test case Already Exists: {test_case_fqn}")
         except Exception as err:  # pylint: disable=broad-except
             yield Either(
                 left=StackTraceError(
@@ -1084,9 +1093,7 @@ class DbtSource(DbtServiceSource):
 
                 # Create the test case result object
                 test_case_result = TestCaseResult(
-                    timestamp=Timestamp(
-                        convert_timestamp_to_milliseconds(dbt_timestamp.timestamp())
-                    ),
+                    timestamp=Timestamp(datetime_to_timestamp(dbt_timestamp)),
                     testCaseStatus=test_case_status,
                     testResultValue=[
                         TestResultValue(
@@ -1113,13 +1120,20 @@ class DbtSource(DbtServiceSource):
                         else None,
                         test_case_name=manifest_node.name,
                     )
-                    self.metadata.add_test_case_results(
-                        test_results=test_case_result,
-                        test_case_fqn=test_case_fqn,
-                    )
+
+                    logger.debug(f"Adding test case results to {test_case_fqn} ")
+                    try:
+                        self.metadata.add_test_case_results(
+                            test_results=test_case_result,
+                            test_case_fqn=test_case_fqn,
+                        )
+                    except APIError as err:
+                        if err.code != 409:
+                            raise APIError(err) from err
+
         except Exception as err:  # pylint: disable=broad-except
             logger.debug(traceback.format_exc())
-            logger.error(
+            logger.debug(
                 f"Failed to capture tests results for node: {manifest_node.name} {err}"
             )
 

metadata/ingestion/source/database/lineage_source.py

@@ -13,11 +13,12 @@ Lineage Source Module
 """
 import csv
 import os
+import time
 import traceback
 from abc import ABC
-from concurrent.futures import ThreadPoolExecutor, as_completed
+from concurrent.futures import ThreadPoolExecutor
 from functools import partial
-from typing import Callable, Iterable, Iterator, Union
+from typing import Any, Callable, Iterable, Iterator, List, Union
 
 from metadata.generated.schema.api.data.createQuery import CreateQueryRequest
 from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
@@ -27,6 +28,7 @@ from metadata.ingestion.api.models import Either
 from metadata.ingestion.lineage.models import ConnectionTypeDialectMapper, Dialect
 from metadata.ingestion.lineage.sql_lineage import get_lineage_by_query
 from metadata.ingestion.models.ometa_lineage import OMetaLineageRequest
+from metadata.ingestion.models.topology import Queue
 from metadata.ingestion.source.database.query_parser_source import QueryParserSource
 from metadata.ingestion.source.models import TableView
 from metadata.utils import fqn
@@ -36,6 +38,9 @@ from metadata.utils.logger import ingestion_logger
 logger = ingestion_logger()
 
 
+CHUNK_SIZE = 200
+
+
 class LineageSource(QueryParserSource, ABC):
     """
     This is the base source to handle Lineage-only ingestion.
@@ -96,27 +101,57 @@ class LineageSource(QueryParserSource, ABC):
             )
             yield from self.yield_table_query()
 
-    def generate_lineage_in_thread(self, producer_fn: Callable, processor_fn: Callable):
-        with ThreadPoolExecutor(max_workers=self.source_config.threads) as executor:
-            futures = []
+    def generate_lineage_in_thread(
+        self,
+        producer_fn: Callable[[], Iterable[Any]],
+        processor_fn: Callable[[Any], Iterable[Any]],
+        chunk_size: int = CHUNK_SIZE,
+    ):
+        """
+        Optimized multithreaded lineage generation with improved error handling and performance.
 
-            for produced_input in producer_fn():
-                futures.append(executor.submit(processor_fn, produced_input))
+        Args:
+            producer_fn: Function that yields input items
+            processor_fn: Function to process each input item
+            chunk_size: Optional batching to reduce thread creation overhead
+        """
 
-            # Handle remaining futures after the loop
-            for future in as_completed(
-                futures, timeout=self.source_config.parsingTimeoutLimit
-            ):
-                try:
-                    results = future.result(
-                        timeout=self.source_config.parsingTimeoutLimit
-                    )
-                    yield from results
-                except Exception as exc:
-                    logger.debug(traceback.format_exc())
-                    logger.warning(
-                        f"Error processing result for {produced_input}: {exc}"
-                    )
+        def chunk_generator():
+            temp_chunk = []
+            for chunk in producer_fn():
+                temp_chunk.append(chunk)
+                if len(temp_chunk) >= chunk_size:
+                    yield temp_chunk
+                    temp_chunk = []
+
+            if temp_chunk:
+                yield temp_chunk
+
+        thread_pool = ThreadPoolExecutor(max_workers=self.source_config.threads)
+        queue = Queue()
+
+        futures = [
+            thread_pool.submit(
+                processor_fn,
+                chunk,
+                queue,
+            )
+            for chunk in chunk_generator()
+        ]
+        while True:
+            if queue.has_tasks():
+                yield from queue.process()
+
+            else:
+                if not futures:
+                    break
+
+                for i, future in enumerate(futures):
+                    if future.done():
+                        future.result()
+                        futures.pop(i)
+
+            time.sleep(0.01)
 
     def yield_table_query(self) -> Iterator[TableQuery]:
         """
@@ -158,33 +193,38 @@ class LineageSource(QueryParserSource, ABC):
         return fqn.get_query_checksum(table_query.query) in checksums or {}
 
     def query_lineage_generator(
-        self, table_query: TableQuery
+        self, table_queries: List[TableQuery], queue: Queue
     ) -> Iterable[Either[Union[AddLineageRequest, CreateQueryRequest]]]:
-        if not self._query_already_processed(table_query):
-            lineages: Iterable[Either[AddLineageRequest]] = get_lineage_by_query(
-                self.metadata,
-                query=table_query.query,
-                service_name=table_query.serviceName,
-                database_name=table_query.databaseName,
-                schema_name=table_query.databaseSchema,
-                dialect=self.dialect,
-                timeout_seconds=self.source_config.parsingTimeoutLimit,
-            )
+        for table_query in table_queries or []:
+            if not self._query_already_processed(table_query):
+                lineages: Iterable[Either[AddLineageRequest]] = get_lineage_by_query(
+                    self.metadata,
+                    query=table_query.query,
+                    service_name=table_query.serviceName,
+                    database_name=table_query.databaseName,
+                    schema_name=table_query.databaseSchema,
+                    dialect=self.dialect,
+                    timeout_seconds=self.source_config.parsingTimeoutLimit,
+                )
 
-            for lineage_request in lineages or []:
-                yield lineage_request
+                for lineage_request in lineages or []:
+                    queue.put(lineage_request)
 
-                # If we identified lineage properly, ingest the original query
-                if lineage_request.right:
-                    yield Either(
-                        right=CreateQueryRequest(
-                            query=SqlQuery(table_query.query),
-                            query_type=table_query.query_type,
-                            duration=table_query.duration,
-                            processedLineage=True,
-                            service=FullyQualifiedEntityName(self.config.serviceName),
+                    # If we identified lineage properly, ingest the original query
+                    if lineage_request.right:
+                        queue.put(
+                            Either(
+                                right=CreateQueryRequest(
+                                    query=SqlQuery(table_query.query),
+                                    query_type=table_query.query_type,
+                                    duration=table_query.duration,
+                                    processedLineage=True,
+                                    service=FullyQualifiedEntityName(
+                                        self.config.serviceName
+                                    ),
+                                )
+                            )
                         )
-                    )
 
     def yield_query_lineage(
         self,
@@ -197,28 +237,33 @@ class LineageSource(QueryParserSource, ABC):
         self.dialect = ConnectionTypeDialectMapper.dialect_of(connection_type)
         producer_fn = self.get_table_query
         processor_fn = self.query_lineage_generator
-        yield from self.generate_lineage_in_thread(producer_fn, processor_fn)
+        yield from self.generate_lineage_in_thread(
+            producer_fn, processor_fn, CHUNK_SIZE
+        )
 
     def view_lineage_generator(
-        self, view: TableView
+        self, views: List[TableView], queue: Queue
     ) -> Iterable[Either[AddLineageRequest]]:
         try:
-            for lineage in get_view_lineage(
-                view=view,
-                metadata=self.metadata,
-                service_name=self.config.serviceName,
-                connection_type=self.service_connection.type.value,
-                timeout_seconds=self.source_config.parsingTimeoutLimit,
-            ):
-                if lineage.right is not None:
-                    yield Either(
-                        right=OMetaLineageRequest(
-                            lineage_request=lineage.right,
-                            override_lineage=self.source_config.overrideViewLineage,
+            for view in views:
+                for lineage in get_view_lineage(
+                    view=view,
+                    metadata=self.metadata,
+                    service_name=self.config.serviceName,
+                    connection_type=self.service_connection.type.value,
+                    timeout_seconds=self.source_config.parsingTimeoutLimit,
+                ):
+                    if lineage.right is not None:
+                        queue.put(
+                            Either(
+                                right=OMetaLineageRequest(
+                                    lineage_request=lineage.right,
+                                    override_lineage=self.source_config.overrideViewLineage,
+                                )
+                            )
                         )
-                    )
-                else:
-                    yield lineage
+                    else:
+                        queue.put(lineage)
         except Exception as exc:
             logger.debug(traceback.format_exc())
             logger.warning(f"Error processing view {view}: {exc}")

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

@@ -14,7 +14,7 @@ Mariadb lineage module
 from typing import Optional
 
 from metadata.generated.schema.entity.services.connections.database.mariaDBConnection import (
-    MariadbConnection,
+    MariaDBConnection,
 )
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
@@ -38,8 +38,8 @@ class MariadbLineageSource(LineageSource):
     ):
         """Create class instance"""
         config: WorkflowSource = WorkflowSource.model_validate(config_dict)
-        connection: MariadbConnection = config.serviceConnection.root.config
-        if not isinstance(connection, MariadbConnection):
+        connection: MariaDBConnection = config.serviceConnection.root.config
+        if not isinstance(connection, MariaDBConnection):
             raise InvalidSourceException(
                 f"Expected MariadbConnection, but got {connection}"
             )

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

@@ -20,8 +20,8 @@ MSSQL_SQL_STATEMENT = textwrap.dedent(
         db.NAME database_name,
         t.text query_text,
         s.last_execution_time start_time,
-        DATEADD(s, s.total_elapsed_time/1000, s.last_execution_time) end_time,
-        s.total_elapsed_time/1000 duration,
+        DATEADD(s, s.last_elapsed_time/1000000, s.last_execution_time) end_time,
+        s.last_elapsed_time/1000000 duration,
         NULL schema_name,
         NULL query_type,
         NULL user_name,
@@ -209,7 +209,7 @@ MSSQL_GET_STORED_PROCEDURE_QUERIES = textwrap.dedent(
 WITH SP_HISTORY (start_time, end_time, procedure_name, query_text) AS (
   select 
     s.last_execution_time start_time,
-    DATEADD(s, s.total_elapsed_time/1000, s.last_execution_time) end_time,
+    DATEADD(s, s.last_elapsed_time/1000000, s.last_execution_time) end_time,
     OBJECT_NAME(object_id, database_id) as procedure_name,
     text as query_text
   from sys.dm_exec_procedure_stats s
@@ -222,8 +222,8 @@ Q_HISTORY (database_name, query_text, start_time, end_time, duration,query_type,
     db.NAME database_name,
     t.text query_text,
     s.last_execution_time start_time,
-    DATEADD(s, s.total_elapsed_time/1000, s.last_execution_time) end_time,
-    s.total_elapsed_time/1000 duration,
+    DATEADD(s, s.last_elapsed_time/1000000, s.last_execution_time) end_time,
+    s.last_elapsed_time/1000000 duration,
     case
         when t.text LIKE '%%MERGE%%' then 'MERGE'
         when t.text LIKE '%%UPDATE%%' then 'UPDATE'

metadata/ingestion/source/database/postgres/metadata.py

@@ -67,7 +67,6 @@ from metadata.ingestion.source.database.postgres.utils import (
     get_columns,
     get_etable_owner,
     get_foreign_keys,
-    get_json_fields_and_type,
     get_table_comment,
     get_table_owner,
     get_view_definition,
@@ -147,7 +146,6 @@ PGDialect.ischema_names = ischema_names
 Inspector.get_all_table_ddls = get_all_table_ddls
 Inspector.get_table_ddl = get_table_ddl
 Inspector.get_table_owner = get_etable_owner
-Inspector.get_json_fields_and_type = get_json_fields_and_type
 
 PGDialect.get_foreign_keys = get_foreign_keys
 

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

@@ -193,7 +193,7 @@ POSTGRES_SQL_COLUMNS = """
     """
 
 POSTGRES_GET_SERVER_VERSION = """
-show server_version
+show server_version_num
 """
 
 POSTGRES_FETCH_FK = """
@@ -212,91 +212,6 @@ POSTGRES_FETCH_FK = """
     ORDER BY 1
 """
 
-POSTGRES_GET_JSON_FIELDS = """
-    WITH RECURSIVE json_hierarchy AS (
-        SELECT
-            key AS path,
-            json_typeof(value) AS type,
-            value,
-            json_build_object() AS properties,
-            key AS title
-        FROM
-            {table_name} tbd,
-            LATERAL json_each({column_name}::json)
-    ),
-    build_hierarchy AS (
-        SELECT
-            path,
-            type,
-            title,
-            CASE
-                WHEN type = 'object' THEN
-                    json_build_object(
-                        'title', title,
-                        'type', 'object',
-                        'properties', (
-                            SELECT json_object_agg(
-                                key,
-                                json_build_object(
-                                    'title', key,
-                                    'type', json_typeof(value),
-                                    'properties', (
-                                        CASE
-                                            WHEN json_typeof(value) = 'object' THEN
-                                                (
-                                                    SELECT json_object_agg(
-                                                        key,
-                                                        json_build_object(
-                                                            'title', key,
-                                                            'type', json_typeof(value),
-                                                            'properties',
-                                                            json_build_object()
-                                                        )
-                                                    )
-                                                    FROM json_each(value::json) AS sub_key_value
-                                                )
-                                            ELSE json_build_object()
-                                        END
-                                    )
-                                )
-                            )
-                            FROM json_each(value::json) AS key_value
-                        )
-                    )
-                WHEN type = 'array' THEN
-                    json_build_object(
-                        'title', title,
-                        'type', 'array',
-                        'properties', json_build_object()
-                    )
-                ELSE
-                    json_build_object(
-                        'title', title,
-                        'type', type
-                    )
-            END AS hierarchy
-        FROM
-            json_hierarchy
-    ),
-    aggregate_hierarchy AS (
-        select
-            json_build_object(
-            'title','{column_name}',
-            'type','object',
-            'properties',
-            json_object_agg(
-                path,
-                hierarchy
-            )) AS result
-        FROM
-            build_hierarchy
-    )
-    SELECT
-        result
-    FROM
-        aggregate_hierarchy;
-"""
-
 POSTGRES_GET_STORED_PROCEDURES = """
     SELECT proname AS procedure_name,
         nspname AS schema_name,