openmetadata-ingestion 1.5.0.0rc1__py3-none-any.whl → 1.5.1.0__py3-none-any.whl

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

@@ -1,3 +1,4 @@
+#  pylint: disable=too-many-lines
 #  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.
@@ -156,6 +157,13 @@ class DbtSource(DbtServiceSource):
                 owner = self.metadata.get_reference_by_name(
                     name=dbt_owner, is_owner=True
                 )
+
+                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"
@@ -312,7 +320,8 @@ class DbtSource(DbtServiceSource):
         self.context.get().dbt_tests[key][DbtCommonEnum.RESULTS.value] = next(
             (
                 item
-                for item in dbt_objects.dbt_run_results.results
+                for run_result in dbt_objects.dbt_run_results
+                for item in run_result.results
                 if item.unique_id == key
             ),
             None,
@@ -340,12 +349,14 @@ class DbtSource(DbtServiceSource):
             self.context.get().data_model_links = []
             self.context.get().dbt_tests = {}
             self.context.get().run_results_generate_time = None
+            # Since we'll be processing multiple run_results for a single project
+            # we'll only consider the first run_results generated_at time
             if (
                 dbt_objects.dbt_run_results
-                and dbt_objects.dbt_run_results.metadata.generated_at
+                and dbt_objects.dbt_run_results[0].metadata.generated_at
             ):
                 self.context.get().run_results_generate_time = (
-                    dbt_objects.dbt_run_results.metadata.generated_at
+                    dbt_objects.dbt_run_results[0].metadata.generated_at
                 )
             for key, manifest_node in manifest_entities.items():
                 try:

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

@@ -20,13 +20,13 @@ from pydantic import BaseModel
 class DbtFiles(BaseModel):
     dbt_catalog: Optional[dict] = None
     dbt_manifest: dict
-    dbt_run_results: Optional[dict] = None
+    dbt_run_results: Optional[List[dict]] = None
 
 
 class DbtObjects(BaseModel):
     dbt_catalog: Optional[Any] = None
     dbt_manifest: Any
-    dbt_run_results: Optional[Any] = None
+    dbt_run_results: Optional[List[Any]] = None
 
 
 class DbtFilteredModel(BaseModel):

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

@@ -26,10 +26,6 @@ from metadata.ingestion.source.database.mssql.utils import (
 
 
 class MssqlLineageSource(MssqlQueryParserSource, LineageSource):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.start = self.start.replace(tzinfo=None)
-        self.end = self.end.replace(tzinfo=None)
 
     sql_stmt = MSSQL_SQL_STATEMENT
 

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

@@ -224,7 +224,7 @@ class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
         current_datetime_format = MSSQL_DATEFORMAT_DATETIME_MAP.get(
             server_date_format, DEFAULT_DATETIME_FORMAT
         )
-        start = start.replace(tzinfo=None).strftime(current_datetime_format)
+        start = start.strftime(current_datetime_format)
         query = MSSQL_GET_STORED_PROCEDURE_QUERIES.format(
             start_date=start,
         )

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

@@ -11,8 +11,21 @@
 """
 MSSQL usage module
 """
+from datetime import datetime
+
+from metadata.generated.schema.metadataIngestion.workflow import (
+    Source as WorkflowSource,
+)
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.source.database.mssql.constants import (
+    DEFAULT_DATETIME_FORMAT,
+    MSSQL_DATEFORMAT_DATETIME_MAP,
+)
 from metadata.ingestion.source.database.mssql.queries import MSSQL_SQL_STATEMENT
 from metadata.ingestion.source.database.mssql.query_parser import MssqlQueryParserSource
+from metadata.ingestion.source.database.mssql.utils import (
+    get_sqlalchemy_engine_dateformat,
+)
 from metadata.ingestion.source.database.usage_source import UsageSource
 
 
@@ -24,3 +37,32 @@ class MssqlUsageSource(MssqlQueryParserSource, UsageSource):
         AND lower(t.text) NOT LIKE '%%create%%function%%'
         AND lower(t.text) NOT LIKE '%%declare%%'
         """
+
+    def __init__(
+        self,
+        config: WorkflowSource,
+        metadata: OpenMetadata,
+        get_engine: bool = True,
+    ):
+        super().__init__(config, metadata, get_engine)
+
+        self.dt_format = DEFAULT_DATETIME_FORMAT
+
+        if self.engine:
+            server_date_format = get_sqlalchemy_engine_dateformat(self.engine)
+            self.dt_format = MSSQL_DATEFORMAT_DATETIME_MAP.get(
+                server_date_format, DEFAULT_DATETIME_FORMAT
+            )
+
+    def get_sql_statement(self, start_time: datetime, end_time: datetime) -> str:
+        """
+        returns sql statement to fetch query logs.
+
+        Override if we have specific parameters
+        """
+        return self.sql_stmt.format(
+            start_time=start_time.strftime(self.dt_format),
+            end_time=end_time.strftime(self.dt_format),
+            filters=self.get_filters(),
+            result_limit=self.source_config.resultLimit,
+        )

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

@@ -54,6 +54,7 @@ from metadata.ingestion.source.database.oracle.queries import (
 )
 from metadata.ingestion.source.database.oracle.utils import (
     _get_col_type,
+    _get_constraint_data,
     get_columns,
     get_mview_definition,
     get_mview_names,
@@ -61,6 +62,8 @@ from metadata.ingestion.source.database.oracle.utils import (
     get_table_comment,
     get_table_names,
     get_view_definition,
+    get_view_names,
+    get_view_names_dialect,
 )
 from metadata.ingestion.source.database.stored_procedures_mixin import (
     QueryByProcedure,
@@ -97,10 +100,14 @@ 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
 
 Inspector.get_all_table_ddls = get_all_table_ddls
 Inspector.get_table_ddl = get_table_ddl
 
+OracleDialect._get_constraint_data = _get_constraint_data
+
 
 class OracleSource(StoredProcedureMixin, CommonDbSourceService):
     """

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

@@ -20,7 +20,7 @@ SELECT
 	comments table_comment,
 	LOWER(table_name) "table_name",
 	LOWER(owner) "schema" 	
-FROM ALL_TAB_COMMENTS
+FROM DBA_TAB_COMMENTS
 where comments is not null and owner not in ('SYSTEM', 'SYS')
 """
 )
@@ -32,33 +32,39 @@ SELECT
 LOWER(view_name) AS "view_name",
 LOWER(owner) AS "schema",
 DBMS_METADATA.GET_DDL('VIEW', view_name, owner) AS view_def
-FROM ALL_VIEWS
+FROM DBA_VIEWS
 WHERE owner NOT IN ('SYSTEM', 'SYS')
 UNION ALL
 SELECT
 LOWER(mview_name) AS "view_name",
 LOWER(owner) AS "schema",
 DBMS_METADATA.GET_DDL('MATERIALIZED_VIEW', mview_name, owner) AS view_def
-FROM ALL_MVIEWS
+FROM DBA_MVIEWS
 WHERE owner NOT IN ('SYSTEM', 'SYS')
 """
 )
 
+GET_VIEW_NAMES = textwrap.dedent(
+    """
+SELECT view_name FROM DBA_VIEWS WHERE owner = :owner
+"""
+)
+
 GET_MATERIALIZED_VIEW_NAMES = textwrap.dedent(
     """
-SELECT mview_name FROM ALL_MVIEWS WHERE owner = :owner
+SELECT mview_name FROM DBA_MVIEWS WHERE owner = :owner
 """
 )
 
 ORACLE_GET_TABLE_NAMES = textwrap.dedent(
     """
-SELECT table_name FROM ALL_TABLES WHERE 
+SELECT table_name FROM DBA_TABLES WHERE 
 {tablespace}
 OWNER = :owner  
 AND IOT_NAME IS NULL 
 AND DURATION IS NULL
 AND TABLE_NAME NOT IN 
-(SELECT mview_name FROM ALL_MVIEWS WHERE owner = :owner)
+(SELECT mview_name FROM DBA_MVIEWS WHERE owner = :owner)
 """
 )
 
@@ -67,7 +73,7 @@ ORACLE_IDENTITY_TYPE = textwrap.dedent(
 col.default_on_null,
 (
 	SELECT id.generation_type || ',' || id.IDENTITY_OPTIONS
-	FROM ALL_TAB_IDENTITY_COLS{dblink} id
+	FROM DBA_TAB_IDENTITY_COLS{dblink} id
 	WHERE col.table_name = id.table_name
 	AND col.column_name = id.column_name
 	AND col.owner = id.owner
@@ -83,12 +89,12 @@ SELECT
     LINE,
     TEXT
 FROM
-    ALL_SOURCE
+    DBA_SOURCE
 WHERE
     type = 'PROCEDURE' and owner = '{schema}'
 """
 )
-CHECK_ACCESS_TO_ALL = "SELECT table_name FROM ALL_TABLES where ROWNUM < 2"
+CHECK_ACCESS_TO_ALL = "SELECT table_name FROM DBA_TABLES where ROWNUM < 2"
 ORACLE_GET_STORED_PROCEDURE_QUERIES = textwrap.dedent(
     """
 WITH SP_HISTORY AS (SELECT
@@ -153,8 +159,8 @@ ORACLE_GET_COLUMNS = textwrap.dedent(
             com.comments,
             col.virtual_column,
             {identity_cols}
-        FROM ALL_TAB_COLS{dblink} col
-        LEFT JOIN ALL_COL_COMMENTS{dblink} com
+        FROM DBA_TAB_COLS{dblink} col
+        LEFT JOIN DBA_COL_COMMENTS{dblink} com
         ON col.table_name = com.table_name
         AND col.column_name = com.column_name
         AND col.owner = com.owner
@@ -163,6 +169,34 @@ ORACLE_GET_COLUMNS = textwrap.dedent(
     """
 )
 
+ORACLE_ALL_CONSTRAINTS = textwrap.dedent(
+    """
+        SELECT
+            ac.constraint_name,
+            ac.constraint_type,
+            loc.column_name AS local_column,
+            rem.table_name AS remote_table,
+            rem.column_name AS remote_column,
+            rem.owner AS remote_owner,
+            loc.position as loc_pos,
+            rem.position as rem_pos,
+            ac.search_condition,
+            ac.delete_rule
+        FROM DBA_CONSTRAINTS{dblink} ac,
+            DBA_CONS_COLUMNS{dblink} loc,
+            DBA_CONS_COLUMNS{dblink} rem
+        WHERE ac.table_name = CAST(:table_name AS VARCHAR2(128))
+            AND ac.constraint_type IN ('R','P', 'U', 'C')
+            AND ac.owner = CAST(:owner AS VARCHAR2(128))
+            AND ac.owner = loc.owner
+            AND ac.constraint_name = loc.constraint_name
+            AND ac.r_owner = rem.owner(+)
+            AND ac.r_constraint_name = rem.constraint_name(+)
+            AND (rem.position IS NULL or loc.position=rem.position)
+        ORDER BY ac.constraint_name, loc.position
+    """
+)
+
 ORACLE_QUERY_HISTORY_STATEMENT = textwrap.dedent(
     """
 SELECT 

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

@@ -21,6 +21,8 @@ from sqlalchemy.sql import sqltypes
 
 from metadata.ingestion.source.database.oracle.queries import (
     GET_MATERIALIZED_VIEW_NAMES,
+    GET_VIEW_NAMES,
+    ORACLE_ALL_CONSTRAINTS,
     ORACLE_ALL_TABLE_COMMENTS,
     ORACLE_ALL_VIEW_DEFINITIONS,
     ORACLE_GET_COLUMNS,
@@ -222,6 +224,26 @@ def get_table_names(self, connection, schema=None, **kw):
     return [row[0] for row in cursor]
 
 
+def get_view_names(self, schema=None):
+    """Return all materialized view names in `schema`.
+
+    :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_names(conn, schema, info_cache=self.info_cache)
+
+
+@reflection.cache
+def get_view_names_dialect(self, connection, schema=None, **kw):
+    schema = self.denormalize_name(schema or self.default_schema_name)
+    sql_query = sql.text(GET_VIEW_NAMES)
+    cursor = connection.execute(sql_query, {"owner": self.denormalize_name(schema)})
+    return [self.normalize_name(row[0]) for row in cursor]
+
+
 def get_mview_names(self, schema=None):
     """Return all materialized view names in `schema`.
 
@@ -254,3 +276,14 @@ def get_mview_definition(self, mview_name, schema=None):
         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):
+
+    params = {"table_name": table_name, "owner": schema}
+    text = ORACLE_ALL_CONSTRAINTS.format(dblink=dblink)
+
+    rp = connection.execute(sql.text(text), params)
+    constraint_data = rp.fetchall()
+    return constraint_data

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

@@ -0,0 +1,52 @@
+#  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.
+
+"""
+Converter logic to transform an OpenMetadata Table Entity for Redshift
+to an SQLAlchemy ORM class.
+"""
+
+from typing import Dict, Set
+
+from sqlalchemy.sql.sqltypes import TypeEngine
+
+from metadata.generated.schema.entity.data.table import Column, DataType
+from metadata.generated.schema.entity.services.databaseService import (
+    DatabaseServiceType,
+)
+from metadata.ingestion.source.database.postgres.types.money import PostgresMoney
+from metadata.profiler.orm.converter.common import CommonMapTypes
+from metadata.profiler.orm.converter.converter_registry import converter_registry
+
+_CUSTOM_TYPE_MAP = {DataType.MONEY: PostgresMoney}
+_CUSTOM_TYPE_MAP_reversed = {v: {k} for k, v in _CUSTOM_TYPE_MAP.items()}
+
+
+class PostgrestMapTypes(CommonMapTypes):
+    """Postgres type mapper, inherits from CommonMapTypes"""
+
+    def return_custom_type(self, col: Column, table_service_type):
+        return _CUSTOM_TYPE_MAP.get(
+            col.dataType, super().return_custom_type(col, table_service_type)
+        )
+
+    @staticmethod
+    def map_sqa_to_om_types() -> Dict[TypeEngine, Set[DataType]]:
+        """returns an ORM type"""
+        # pylint: disable=import-outside-toplevel
+
+        return {
+            **CommonMapTypes.map_sqa_to_om_types(),
+            **_CUSTOM_TYPE_MAP_reversed,
+        }
+
+
+converter_registry[DatabaseServiceType.Postgres] = PostgrestMapTypes

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

@@ -65,6 +65,7 @@ from metadata.ingestion.source.database.postgres.utils import (
 )
 from metadata.utils import fqn
 from metadata.utils.filters import filter_by_database
+from metadata.utils.importer import import_side_effects
 from metadata.utils.logger import ingestion_logger
 from metadata.utils.sqlalchemy_utils import (
     get_all_table_comments,
@@ -76,6 +77,11 @@ from metadata.utils.sqlalchemy_utils import (
 )
 from metadata.utils.tag_utils import get_ometa_tag_and_classification
 
+import_side_effects(
+    "metadata.ingestion.source.database.postgres.converter_orm",
+    "metadata.ingestion.source.database.postgres.metrics",
+)
+
 TableKey = namedtuple("TableKey", ["schema", "table_name"])
 
 logger = ingestion_logger()

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

@@ -0,0 +1,42 @@
+from sqlalchemy.ext.compiler import compiles
+
+from metadata.ingestion.source.database.postgres.types.money import PostgresMoney
+from metadata.profiler.metrics.static.mean import AvgFn
+from metadata.profiler.metrics.static.stddev import StdDevFn
+from metadata.profiler.orm.functions.median import MedianFn
+from metadata.profiler.orm.registry import Dialects
+
+
+@compiles(AvgFn, Dialects.Postgres)
+def avg(element, compiler, **kw):
+    """
+    Cast to decimal to get around potential integer overflow error
+    """
+    proc = compiler.process(element.clauses, **kw)
+    if isinstance(list(element.clauses)[0].type, PostgresMoney):
+        return f"{element.name}({PostgresMoney.compile_as_float(proc)})"
+    return f"{element.name}({proc})"
+
+
+@compiles(StdDevFn, Dialects.Postgres)
+def stddev(element, compiler, **kw):
+    """Returns stdv for clickhouse database and handle empty tables.
+    If table is empty, clickhouse returns NaN.
+    """
+    proc = compiler.process(element.clauses, **kw)
+    if isinstance(list(element.clauses)[0].type, PostgresMoney):
+        return f"STDDEV_POP({PostgresMoney.compile_as_float(proc)})"
+    return f"STDDEV_POP({proc})"
+
+
+@compiles(MedianFn, Dialects.Postgres)
+def median(elements, compiler, **kwargs):  # pylint: disable=unused-argument
+    col, _, percentile = [
+        compiler.process(element, **kwargs) for element in elements.clauses
+    ]
+    if isinstance(list(elements.clauses)[0], PostgresMoney):
+        return "percentile_cont(%.2f) WITHIN GROUP (ORDER BY %s ASC)" % (
+            percentile,
+            PostgresMoney.compile_as_float(col),
+        )
+    return MedianFn.default_fn(elements, compiler, **kwargs)

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

@@ -0,0 +1,37 @@
+#  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.
+
+"""
+Custom sqlalchemy type for Postgres MONEY type
+"""
+
+
+from sqlalchemy.dialects.postgresql import MONEY
+from sqlalchemy.sql.sqltypes import String
+
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
+
+
+class PostgresMoney(MONEY):
+    """Wrapper for Postgres MONEY type"""
+
+    impl = String
+    cache_ok = True
+
+    @property
+    def quantifiable(self):
+        return True
+
+    @staticmethod
+    def compile_as_float(expr: str) -> str:
+        return f"(({expr})::numeric::float8)"

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

@@ -73,3 +73,9 @@ class PostgresUsageSource(PostgresQueryParserSource, UsageSource):
                 )
             logger.error(f"Source usage processing error - {err}")
             logger.debug(traceback.format_exc())
+
+    def get_filters(self) -> str:
+        if filter_condition := self.source_config.filterCondition:
+            filter_condition = filter_condition.replace("%", "%%")
+            return f"{self.filters} AND s.{filter_condition}"
+        return self.filters

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

@@ -12,6 +12,7 @@
 """
 Source connection handler
 """
+from functools import partial
 from typing import Optional
 
 from sqlalchemy.engine import Engine
@@ -27,8 +28,15 @@ from metadata.ingestion.connections.builders import (
     get_connection_args_common,
     get_connection_url_common,
 )
-from metadata.ingestion.connections.test_connections import test_connection_db_common
+from metadata.ingestion.connections.test_connections import (
+    SourceConnectionException,
+    execute_inspector_func,
+    test_connection_engine_step,
+    test_connection_steps,
+    test_query,
+)
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.source.connections import kill_active_connections
 from metadata.ingestion.source.database.redshift.queries import (
     REDSHIFT_GET_DATABASE_NAMES,
     REDSHIFT_TEST_GET_QUERIES,
@@ -57,15 +65,35 @@ def test_connection(
     Test connection. This can be executed either as part
     of a metadata workflow or during an Automation Workflow
     """
-    queries = {
-        "GetQueries": REDSHIFT_TEST_GET_QUERIES,
-        "GetDatabases": REDSHIFT_GET_DATABASE_NAMES,
-        "GetPartitionTableDetails": REDSHIFT_TEST_PARTITION_DETAILS,
+
+    def test_get_queries_permissions(engine_: Engine):
+        """Check if we have the right permissions to list queries"""
+        with engine_.connect() as conn:
+            res = conn.execute(REDSHIFT_TEST_GET_QUERIES).fetchone()
+            if not all(res):
+                raise SourceConnectionException(
+                    f"We don't have the right permissions to list queries - {res}"
+                )
+
+    test_fn = {
+        "CheckAccess": partial(test_connection_engine_step, engine),
+        "GetSchemas": partial(execute_inspector_func, engine, "get_schema_names"),
+        "GetTables": partial(execute_inspector_func, engine, "get_table_names"),
+        "GetViews": partial(execute_inspector_func, engine, "get_view_names"),
+        "GetQueries": partial(test_get_queries_permissions, engine),
+        "GetDatabases": partial(
+            test_query, statement=REDSHIFT_GET_DATABASE_NAMES, engine=engine
+        ),
+        "GetPartitionTableDetails": partial(
+            test_query, statement=REDSHIFT_TEST_PARTITION_DETAILS, engine=engine
+        ),
     }
-    test_connection_db_common(
+
+    test_connection_steps(
         metadata=metadata,
-        engine=engine,
-        service_connection=service_connection,
+        test_fn=test_fn,
+        service_type=service_connection.type.value,
         automation_workflow=automation_workflow,
-        queries=queries,
     )
+
+    kill_active_connections(engine)

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

@@ -222,11 +222,10 @@ SELECT datname FROM pg_database
 """
 
 REDSHIFT_TEST_GET_QUERIES = """
-(select 1 from pg_catalog.svv_table_info limit 1)
-UNION
-(select 1 from pg_catalog.stl_querytext limit 1)
-UNION
-(select 1 from pg_catalog.stl_query limit 1)
+SELECT 
+    has_table_privilege('svv_table_info', 'SELECT') as can_access_svv_table_info,
+    has_table_privilege('stl_querytext', 'SELECT') as can_access_stl_querytext,
+    has_table_privilege('stl_query', 'SELECT') as can_access_stl_query;
 """
 
 

metadata/ingestion/source/database/unitycatalog/client.py

@@ -14,6 +14,8 @@ Client to interact with databricks apis
 import json
 import traceback
 
+from requests import HTTPError
+
 from metadata.ingestion.source.database.databricks.client import (
     API_TIMEOUT,
     DatabricksClient,
@@ -27,6 +29,7 @@ from metadata.utils.logger import ingestion_logger
 logger = ingestion_logger()
 TABLE_LINEAGE_PATH = "/lineage-tracking/table-lineage/get"
 COLUMN_LINEAGE_PATH = "/lineage-tracking/column-lineage/get"
+TABLES_PATH = "/unity-catalog/tables"
 
 
 class UnityCatalogClient(DatabricksClient):
@@ -85,3 +88,21 @@ class UnityCatalogClient(DatabricksClient):
             logger.error(exc)
 
         return LineageColumnStreams()
+
+    def get_owner_info(self, full_table_name: str) -> str:
+        """
+        get owner info from tables API
+        """
+        try:
+            response = self.client.get(
+                f"{self.base_url}{TABLES_PATH}/{full_table_name}",
+                headers=self.headers,
+                timeout=API_TIMEOUT,
+            )
+            if response.status_code != 200:
+                raise HTTPError(response.text)
+            return response.json().get("owner")
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.error(exc)
+        return