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

metadata/ingestion/source/database/iceberg/metadata.py

@@ -42,7 +42,8 @@ from metadata.generated.schema.metadataIngestion.databaseServiceMetadataPipeline
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
-from metadata.generated.schema.type.entityReference import EntityReference
+from metadata.generated.schema.type.basic import EntityName, FullyQualifiedEntityName
+from metadata.generated.schema.type.entityReferenceList import EntityReferenceList
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.models.ometa_classification import OMetaTagAndClassification
@@ -75,7 +76,7 @@ class IcebergSource(DatabaseServiceSource):
             self.config.sourceConfig.config
         )
         self.metadata = metadata
-        self.service_connection = self.config.serviceConnection.__root__.config
+        self.service_connection = self.config.serviceConnection.root.config
         self.iceberg = get_connection(self.service_connection)
 
         self.connection_obj = self.iceberg
@@ -85,8 +86,8 @@ class IcebergSource(DatabaseServiceSource):
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: IcebergConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: IcebergConnection = config.serviceConnection.root.config
         if not isinstance(connection, IcebergConnection):
             raise InvalidSourceException(
                 f"Expected GlueConnection, but got {connection}"
@@ -158,12 +159,14 @@ class IcebergSource(DatabaseServiceSource):
         """
         yield Either(
             right=CreateDatabaseSchemaRequest(
-                name=schema_name,
-                database=fqn.build(
-                    metadata=self.metadata,
-                    entity_type=Database,
-                    service_name=self.context.get().database_service,
-                    database_name=self.context.get().database,
+                name=EntityName(schema_name),
+                database=FullyQualifiedEntityName(
+                    fqn.build(
+                        metadata=self.metadata,
+                        entity_type=Database,
+                        service_name=self.context.get().database_service,
+                        database_name=self.context.get().database,
+                    )
                 ),
             )
         )
@@ -178,7 +181,8 @@ class IcebergSource(DatabaseServiceSource):
         for table_identifier in self.iceberg.list_tables(namespace):
             try:
                 table = self.iceberg.load_table(table_identifier)
-                table_name = get_table_name_as_str(table)
+                # extract table name from table identifier, which does not include catalog name
+                table_name = get_table_name_as_str(table_identifier)
                 table_fqn = fqn.build(
                     self.metadata,
                     entity_type=Table,
@@ -224,7 +228,7 @@ class IcebergSource(DatabaseServiceSource):
                     )
                 )
 
-    def get_owner_ref(self, table_name: str) -> Optional[EntityReference]:
+    def get_owner_ref(self, table_name: str) -> Optional[EntityReferenceList]:
         owner = get_owner_from_table(
             self.context.get().iceberg_table, self.service_connection.ownershipProperty
         )
@@ -249,23 +253,25 @@ class IcebergSource(DatabaseServiceSource):
         table_name, table_type = table_name_and_type
         iceberg_table = self.context.get().iceberg_table
         try:
-            owner = self.get_owner_ref(table_name)
+            owners = self.get_owner_ref(table_name)
             table = IcebergTable.from_pyiceberg(
-                table_name, table_type, owner, iceberg_table
+                table_name, table_type, owners, iceberg_table
             )
             table_request = CreateTableRequest(
-                name=table.name,
+                name=EntityName(table.name),
                 tableType=table.tableType,
                 description=table.description,
-                owner=table.owner,
+                owners=table.owners,
                 columns=table.columns,
                 tablePartition=table.tablePartition,
-                databaseSchema=fqn.build(
-                    metadata=self.metadata,
-                    entity_type=DatabaseSchema,
-                    service_name=self.context.get().database_service,
-                    database_name=self.context.get().database,
-                    schema_name=self.context.get().database_schema,
+                databaseSchema=FullyQualifiedEntityName(
+                    fqn.build(
+                        metadata=self.metadata,
+                        entity_type=DatabaseSchema,
+                        service_name=self.context.get().database_service,
+                        database_name=self.context.get().database,
+                        schema_name=self.context.get().database_schema,
+                    )
                 ),
             )
             yield Either(right=table_request)

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

@@ -24,7 +24,7 @@ from metadata.generated.schema.entity.data.table import (
     TablePartition,
     TableType,
 )
-from metadata.generated.schema.type.entityReference import EntityReference
+from metadata.generated.schema.type.entityReferenceList import EntityReferenceList
 from metadata.ingestion.source.database.iceberg.helper import (
     IcebergColumnParser,
     get_column_from_partition,
@@ -35,17 +35,17 @@ from metadata.ingestion.source.database.iceberg.helper import (
 class IcebergTable(BaseModel):
     name: str
     tableType: TableType
-    description: Optional[str]
-    owner: Optional[EntityReference]
+    description: Optional[str] = None
+    owners: Optional[EntityReferenceList] = None
     columns: List[Column] = []
-    tablePartition: Optional[TablePartition]
+    tablePartition: Optional[TablePartition] = None
 
     @classmethod
     def from_pyiceberg(
         cls,
         name: str,
         table_type: TableType,
-        owner: Optional[EntityReference],
+        owners: Optional[EntityReferenceList],
         table: pyiceberg.table.Table,
     ) -> IcebergTable:
         """Responsible for parsing the needed information from a PyIceberg Table."""
@@ -55,7 +55,7 @@ class IcebergTable(BaseModel):
             name=name,
             tableType=table_type,
             description=table.properties.get("comment"),
-            owner=owner,
+            owners=owners,
             columns=[IcebergColumnParser.parse(column) for column in iceberg_columns],
             tablePartition=TablePartition(
                 columns=[

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

@@ -80,21 +80,21 @@ def get_connection(connection: ImpalaConnection) -> Engine:
     if connection.authMechanism:
         if not connection.connectionArguments:
             connection.connectionArguments = init_empty_connection_arguments()
-        connection.connectionArguments.__root__[
+        connection.connectionArguments.root[
             "auth_mechanism"
         ] = connection.authMechanism.value
 
     if connection.kerberosServiceName:
         if not connection.connectionArguments:
             connection.connectionArguments = init_empty_connection_arguments()
-        connection.connectionArguments.__root__[
+        connection.connectionArguments.root[
             "kerberos_service_name"
         ] = connection.kerberosServiceName
 
     if connection.useSSL:
         if not connection.connectionArguments:
             connection.connectionArguments = init_empty_connection_arguments()
-        connection.connectionArguments.__root__["use_ssl"] = connection.useSSL
+        connection.connectionArguments.root["use_ssl"] = connection.useSSL
 
     return create_generic_db_connection(
         connection=connection,

metadata/ingestion/source/database/impala/metadata.py

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

metadata/ingestion/source/database/incremental_metadata_extraction.py

@@ -97,7 +97,7 @@ class IncrementalConfigCreator:
         """Filter the pipeline statuses to get the last time the pipeline was run succesfully."""
         return max(  # pylint: disable=R1728
             [
-                pipeline.startDate.__root__
+                pipeline.startDate.root
                 for pipeline in pipeline_statuses
                 if pipeline.pipelineState == PipelineState.success
                 and pipeline.startDate

metadata/ingestion/source/database/life_cycle_query_mixin.py

@@ -17,7 +17,7 @@ from datetime import datetime
 from functools import lru_cache
 from typing import Dict, Iterable, List, Optional, Type
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 from sqlalchemy.engine import Engine
 
 from metadata.generated.schema.entity.data.table import Table
@@ -27,6 +27,7 @@ from metadata.generated.schema.entity.services.ingestionPipelines.status import
 from metadata.generated.schema.metadataIngestion.databaseServiceMetadataPipeline import (
     DatabaseServiceMetadataPipeline,
 )
+from metadata.generated.schema.type.basic import Timestamp
 from metadata.generated.schema.type.lifeCycle import AccessDetails, LifeCycle
 from metadata.ingestion.api.models import Either, Entity
 from metadata.ingestion.api.status import Status
@@ -45,11 +46,10 @@ class LifeCycleQueryByTable(BaseModel):
     Query executed get life cycle
     """
 
-    table_name: str = Field(..., alias="TABLE_NAME")
-    created_at: Optional[datetime] = Field(..., alias="CREATED_AT")
+    model_config = ConfigDict(populate_by_name=True)
 
-    class Config:
-        allow_population_by_field_name = True
+    table_name: str = Field(..., alias="TABLE_NAME")
+    created_at: Optional[datetime] = Field(None, alias="CREATED_AT")
 
 
 class LifeCycleQueryMixin:
@@ -79,7 +79,7 @@ class LifeCycleQueryMixin:
 
         for row in results:
             try:
-                life_cycle_by_table = LifeCycleQueryByTable.parse_obj(dict(row))
+                life_cycle_by_table = LifeCycleQueryByTable.model_validate(dict(row))
                 queries_dict[life_cycle_by_table.table_name] = life_cycle_by_table
             except Exception as exc:
                 self.status.failed(
@@ -103,8 +103,12 @@ class LifeCycleQueryMixin:
             if life_cycle_data:
                 life_cycle = LifeCycle(
                     created=AccessDetails(
-                        timestamp=convert_timestamp_to_milliseconds(
-                            life_cycle_data.created_at.timestamp()
+                        timestamp=Timestamp(
+                            int(
+                                convert_timestamp_to_milliseconds(
+                                    life_cycle_data.created_at.timestamp()
+                                )
+                            )
                         )
                     )
                 )

metadata/ingestion/source/database/lineage_source.py

@@ -12,6 +12,7 @@
 Lineage Source Module
 """
 import csv
+import os
 import traceback
 from abc import ABC
 from typing import Iterable, Iterator, Union
@@ -47,17 +48,28 @@ class LineageSource(QueryParserSource, ABC):
         Method to handle the usage from query logs
         """
         try:
-            with open(
-                self.config.sourceConfig.config.queryLogFilePath, "r", encoding="utf-8"
-            ) as file:
-                for row in csv.DictReader(file):
-                    query_dict = dict(row)
-                    yield TableQuery(
-                        query=query_dict["query_text"],
-                        databaseName=self.get_database_name(query_dict),
-                        serviceName=self.config.serviceName,
-                        databaseSchema=self.get_schema_name(query_dict),
-                    )
+            query_log_path = self.config.sourceConfig.config.queryLogFilePath
+            if os.path.isfile(query_log_path):
+                file_paths = [query_log_path]
+            elif os.path.isdir(query_log_path):
+                file_paths = [
+                    os.path.join(query_log_path, f)
+                    for f in os.listdir(query_log_path)
+                    if f.endswith(".csv")
+                ]
+            else:
+                raise ValueError(f"{query_log_path} is neither a file nor a directory.")
+
+            for file_path in file_paths:
+                with open(file_path, "r", encoding="utf-8") as file:
+                    for row in csv.DictReader(file):
+                        query_dict = dict(row)
+                        yield TableQuery(
+                            query=query_dict["query_text"],
+                            databaseName=self.get_database_name(query_dict),
+                            serviceName=self.config.serviceName,
+                            databaseSchema=self.get_schema_name(query_dict),
+                        )
         except Exception as err:
             logger.debug(traceback.format_exc())
             logger.warning(f"Failed to read queries form log file due to: {err}")
@@ -143,12 +155,12 @@ class LineageSource(QueryParserSource, ABC):
                     if lineage_request.right:
                         yield Either(
                             right=CreateQueryRequest(
-                                query=SqlQuery(__root__=table_query.query),
+                                query=SqlQuery(table_query.query),
                                 query_type=table_query.query_type,
                                 duration=table_query.duration,
                                 processedLineage=True,
                                 service=FullyQualifiedEntityName(
-                                    __root__=self.config.serviceName
+                                    self.config.serviceName
                                 ),
                             )
                         )

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

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

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

@@ -51,7 +51,7 @@ def test_connection(
     """
 
     class SchemaHolder(BaseModel):
-        database: Optional[str]
+        database: Optional[str] = None
 
     holder = SchemaHolder()
 

metadata/ingestion/source/database/mongodb/metadata.py

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

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

@@ -0,0 +1,23 @@
+#  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.
+"""
+MSSQL constants
+"""
+
+DEFAULT_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+MSSQL_DATEFORMAT_DATETIME_MAP = {
+    "dmy": "%d-%m-%Y %H:%M:%S",
+    "dym": "%d-%Y-%m %H:%M:%S",
+    "ymd": DEFAULT_DATETIME_FORMAT,
+    "ydm": "%Y-%d-%m %H:%M:%S",
+    "mdy": "%m-%d-%Y %H:%M:%S",
+    "myd": "%m-%Y-%d %H:%M:%S",
+}

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

@@ -11,12 +11,26 @@
 """
 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):
+    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
 
     filters = """
@@ -30,3 +44,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.replace(tzinfo=None).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/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

@@ -112,8 +112,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 +154,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 +217,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