openmetadata-ingestion 1.4.7.2__py3-none-any.whl → 1.5.0.0__py3-none-any.whl

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

@@ -11,12 +11,22 @@
 """
 MSSQL lineage module
 """
+from datetime import datetime
+
 from metadata.ingestion.source.database.lineage_source import LineageSource
+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,
+)
 
 
 class MssqlLineageSource(MssqlQueryParserSource, LineageSource):
+
     sql_stmt = MSSQL_SQL_STATEMENT
 
     filters = """
@@ -30,3 +40,18 @@ class MssqlLineageSource(MssqlQueryParserSource, LineageSource):
         AND lower(t.text) NOT LIKE '%%create%%function%%'
         AND lower(t.text) NOT LIKE '%%declare%%'
     """
+
+    def get_sql_statement(self, start_time: datetime, end_time: datetime) -> str:
+        """
+        returns sql statement to fetch query logs.
+        """
+        server_date_format = get_sqlalchemy_engine_dateformat(self.engine)
+        current_datetime_format = MSSQL_DATEFORMAT_DATETIME_MAP.get(
+            server_date_format, DEFAULT_DATETIME_FORMAT
+        )
+        return self.sql_stmt.format(
+            start_time=start_time.strftime(current_datetime_format),
+            end_time=end_time.strftime(current_datetime_format),
+            filters=self.get_filters(),
+            result_limit=self.source_config.resultLimit,
+        )

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

@@ -35,6 +35,10 @@ from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.common_db_source import CommonDbSourceService
+from metadata.ingestion.source.database.mssql.constants import (
+    DEFAULT_DATETIME_FORMAT,
+    MSSQL_DATEFORMAT_DATETIME_MAP,
+)
 from metadata.ingestion.source.database.mssql.models import (
     STORED_PROC_LANGUAGE_MAP,
     MssqlStoredProcedure,
@@ -48,6 +52,7 @@ from metadata.ingestion.source.database.mssql.utils import (
     get_columns,
     get_foreign_keys,
     get_pk_constraint,
+    get_sqlalchemy_engine_dateformat,
     get_table_comment,
     get_table_names,
     get_unique_constraints,
@@ -105,8 +110,8 @@ class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
         """Create class instance"""
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: MssqlConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: MssqlConnection = config.serviceConnection.root.config
         if not isinstance(connection, MssqlConnection):
             raise InvalidSourceException(
                 f"Expected MssqlConnection, but got {connection}"
@@ -122,8 +127,8 @@ class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
         yield from self._execute_database_query(MSSQL_GET_DATABASE)
 
     def get_database_names(self) -> Iterable[str]:
-        if not self.config.serviceConnection.__root__.config.ingestAllDatabases:
-            configured_db = self.config.serviceConnection.__root__.config.database
+        if not self.config.serviceConnection.root.config.ingestAllDatabases:
+            configured_db = self.config.serviceConnection.root.config.database
             self.set_inspector(database_name=configured_db)
             yield configured_db
         else:
@@ -164,7 +169,7 @@ class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
             ).all()
             for row in results:
                 try:
-                    stored_procedure = MssqlStoredProcedure.parse_obj(dict(row))
+                    stored_procedure = MssqlStoredProcedure.model_validate(dict(row))
                     yield stored_procedure
                 except Exception as exc:
                     logger.error()
@@ -183,7 +188,7 @@ class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
 
         try:
             stored_procedure_request = CreateStoredProcedureRequest(
-                name=EntityName(__root__=stored_procedure.name),
+                name=EntityName(stored_procedure.name),
                 description=None,
                 storedProcedureCode=StoredProcedureCode(
                     language=STORED_PROC_LANGUAGE_MAP.get(stored_procedure.language),
@@ -215,12 +220,27 @@ class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
         queries they triggered
         """
         start, _ = get_start_and_end(self.source_config.queryLogDuration)
+        server_date_format = get_sqlalchemy_engine_dateformat(self.engine)
+        current_datetime_format = MSSQL_DATEFORMAT_DATETIME_MAP.get(
+            server_date_format, DEFAULT_DATETIME_FORMAT
+        )
+        start = start.strftime(current_datetime_format)
         query = MSSQL_GET_STORED_PROCEDURE_QUERIES.format(
             start_date=start,
         )
-
-        queries_dict = self.procedure_queries_dict(
-            query=query,
-        )
+        try:
+            queries_dict = self.procedure_queries_dict(
+                query=query,
+            )
+        except Exception as ex:  # pylint: disable=broad-except
+            logger.debug(f"Error runnning query:\n{query}")
+            self.status.failed(
+                StackTraceError(
+                    name="Stored Procedure",
+                    error=f"Error trying to get stored procedure queries: {ex}",
+                    stackTrace=traceback.format_exc(),
+                )
+            )
+            return {}
 
         return queries_dict

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

@@ -265,3 +265,5 @@ order by PROCEDURE_START_TIME desc
 ;
     """
 )
+
+GET_DB_CONFIGS = textwrap.dedent("DBCC USEROPTIONS;")

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

@@ -37,8 +37,8 @@ class MssqlQueryParserSource(QueryParserSource, ABC):
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
         """Create class instance"""
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: MssqlConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: MssqlConnection = config.serviceConnection.root.config
         if not isinstance(connection, MssqlConnection):
             raise InvalidSourceException(
                 f"Expected MssqlConnection, but got {connection}"

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/mssql/utils.py

@@ -12,6 +12,8 @@
 MSSQL SQLAlchemy Helper Methods
 """
 
+from typing import Optional
+
 from sqlalchemy import Column, Integer, MetaData, String, Table, alias, sql, text
 from sqlalchemy import types as sqltypes
 from sqlalchemy import util
@@ -29,12 +31,13 @@ from sqlalchemy.dialects.mssql.base import (
     _switch_db,
     update_wrapper,
 )
-from sqlalchemy.engine import reflection
+from sqlalchemy.engine import Engine, reflection
 from sqlalchemy.sql import func
 from sqlalchemy.types import NVARCHAR
 from sqlalchemy.util import compat
 
 from metadata.ingestion.source.database.mssql.queries import (
+    GET_DB_CONFIGS,
     MSSQL_ALL_VIEW_DEFINITIONS,
     MSSQL_GET_FOREIGN_KEY,
     MSSQL_GET_TABLE_COMMENTS,
@@ -488,3 +491,15 @@ def get_view_names(
     )
     view_names = [r[0] for r in connection.execute(query_)]
     return view_names
+
+
+def get_sqlalchemy_engine_dateformat(engine: Engine) -> Optional[str]:
+    """
+    returns sqlaclhemdy engine date format by running config query
+    """
+    result = engine.execute(GET_DB_CONFIGS)
+    for row in result:
+        row_dict = dict(row)
+        if row_dict.get("Set Option") == "dateformat":
+            return row_dict.get("Value")
+    return

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

@@ -48,8 +48,8 @@ class MysqlSource(CommonDbSourceService):
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection = cast(MysqlConnection, config.serviceConnection.__root__.config)
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection = cast(MysqlConnection, config.serviceConnection.root.config)
         if not isinstance(connection, MysqlConnection):
             raise InvalidSourceException(
                 f"Expected MysqlConnection, but got {connection}"

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):
     """
@@ -112,8 +119,8 @@ class OracleSource(StoredProcedureMixin, CommonDbSourceService):
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config = WorkflowSource.parse_obj(config_dict)
-        connection: OracleConnection = config.serviceConnection.__root__.config
+        config = WorkflowSource.model_validate(config_dict)
+        connection: OracleConnection = config.serviceConnection.root.config
         if not isinstance(connection, OracleConnection):
             raise InvalidSourceException(
                 f"Expected OracleConnection, but got {connection}"
@@ -154,20 +161,23 @@ class OracleSource(StoredProcedureMixin, CommonDbSourceService):
                 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
+                )
 
-            else:
-                definition_fn = inspector.get_view_definition
-                if table_type == TableType.MaterializedView:
-                    definition_fn = inspector.get_mview_definition
+            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)
+            schema_definition = definition_fn(table_name, schema_name)
 
-            schema_definition = (
-                str(schema_definition.strip())
+            return (
+                str(schema_definition).strip()
                 if schema_definition is not None
                 else None
             )
-            return schema_definition
 
         except NotImplementedError:
             logger.warning("Schema definition not implemented")
@@ -214,13 +224,13 @@ class OracleSource(StoredProcedureMixin, CommonDbSourceService):
 
         try:
             stored_procedure_request = CreateStoredProcedureRequest(
-                name=EntityName(__root__=stored_procedure.name),
+                name=EntityName(stored_procedure.name),
                 storedProcedureCode=StoredProcedureCode(
                     language=Language.SQL,
                     code=stored_procedure.definition,
                 ),
-                owner=self.metadata.get_reference_by_name(
-                    name=stored_procedure.owner.lower()
+                owners=self.metadata.get_reference_by_name(
+                    name=stored_procedure.owner.lower(), is_owner=True
                 ),
                 databaseSchema=fqn.build(
                     metadata=self.metadata,

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

@@ -20,7 +20,7 @@ class OracleStoredProcedure(BaseModel):
 class FetchProcedure(BaseModel):
     """Oracle Fetch Stored Procedure Raw Model"""
 
-    owner: Optional[str]
+    owner: Optional[str] = None
     name: str
     line: int
     text: str

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/query_parser.py

@@ -39,8 +39,8 @@ class OracleQueryParserSource(QueryParserSource, ABC):
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: OracleConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: OracleConnection = config.serviceConnection.root.config
         if not isinstance(connection, OracleConnection):
             raise InvalidSourceException(
                 f"Expected OracleConnection, but got {connection}"

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/pinotdb/metadata.py

@@ -32,8 +32,8 @@ class PinotdbSource(CommonDbSourceService):
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: PinotDBConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: PinotDBConnection = config.serviceConnection.root.config
         if not isinstance(connection, PinotDBConnection):
             raise InvalidSourceException(
                 f"Expected PinotdbConnection, but got {connection}"

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/lineage.py

@@ -19,6 +19,7 @@ from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
 from metadata.generated.schema.entity.services.connections.database.postgresConnection import (
     PostgresScheme,
 )
+from metadata.generated.schema.type.basic import DateTime
 from metadata.generated.schema.type.tableQuery import TableQuery
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.source.connections import get_connection
@@ -83,7 +84,7 @@ class PostgresLineageSource(PostgresQueryParserSource, LineageSource):
                         yield TableQuery(
                             query=row["query_text"],
                             userName=row["usename"],
-                            analysisDate=datetime.now(),
+                            analysisDate=DateTime(datetime.now()),
                             aborted=self.get_aborted_status(row),
                             databaseName=self.get_database_name(row),
                             serviceName=self.config.serviceName,