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

metadata/ingestion/source/database/glue/metadata.py

@@ -39,6 +39,7 @@ from metadata.generated.schema.metadataIngestion.databaseServiceMetadataPipeline
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
+from metadata.generated.schema.type.basic import EntityName, FullyQualifiedEntityName
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.models.ometa_classification import OMetaTagAndClassification
@@ -74,7 +75,7 @@ class GlueSource(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.glue = get_connection(self.service_connection)
 
         self.connection_obj = self.glue
@@ -84,8 +85,8 @@ class GlueSource(DatabaseServiceSource):
     def create(
         cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
     ):
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: GlueConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: GlueConnection = config.serviceConnection.root.config
         if not isinstance(connection, GlueConnection):
             raise InvalidSourceException(
                 f"Expected GlueConnection, but got {connection}"
@@ -209,12 +210,14 @@ class GlueSource(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,
+                    )
                 ),
                 sourceUrl=self.get_source_url(
                     database_name=self.context.get().database,
@@ -283,7 +286,7 @@ class GlueSource(DatabaseServiceSource):
                     )
 
     def yield_table(
-        self, table_name_and_type: Tuple[str, str]
+        self, table_name_and_type: Tuple[str, TableType]
     ) -> Iterable[Either[CreateTableRequest]]:
         """
         From topology.
@@ -296,17 +299,19 @@ class GlueSource(DatabaseServiceSource):
             columns = self.get_columns(table.StorageDescriptor)
 
             table_request = CreateTableRequest(
-                name=table_name,
+                name=EntityName(table_name),
                 tableType=table_type,
                 description=table.Description,
-                columns=columns,
+                columns=list(columns),
                 tableConstraints=table_constraints,
-                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,
+                    )
                 ),
                 sourceUrl=self.get_source_url(
                     table_name=table_name,

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

@@ -18,7 +18,7 @@ from pydantic import BaseModel
 
 
 class GlueSchema(BaseModel):
-    CatalogId: Optional[str]
+    CatalogId: Optional[str] = None
     Name: str
 
 
@@ -27,13 +27,13 @@ class DatabasePage(BaseModel):
 
 
 class TableParameters(BaseModel):
-    table_type: Optional[str]
+    table_type: Optional[str] = None
 
 
 class Column(BaseModel):
     Type: str
     Name: str
-    Comment: Optional[str]
+    Comment: Optional[str] = None
 
 
 class StorageDetails(BaseModel):
@@ -41,10 +41,10 @@ class StorageDetails(BaseModel):
 
 
 class GlueTable(BaseModel):
-    Parameters: Optional[TableParameters]
+    Parameters: Optional[TableParameters] = None
     Name: str
-    TableType: Optional[str]
-    Description: Optional[str]
+    TableType: Optional[str] = None
+    Description: Optional[str] = None
     StorageDescriptor: Optional[StorageDetails] = StorageDetails()
     PartitionKeys: Optional[List[Column]] = []
 

metadata/ingestion/source/database/greenplum/metadata.py

@@ -124,8 +124,8 @@ class GreenplumSource(CommonDbSourceService, MultiDBSource):
         metadata: OpenMetadataConnection,
         pipeline_name: Optional[str] = None,
     ):
-        config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
-        connection: GreenplumConnection = config.serviceConnection.__root__.config
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: GreenplumConnection = config.serviceConnection.root.config
         if not isinstance(connection, GreenplumConnection):
             raise InvalidSourceException(
                 f"Expected GreenplumConnection, but got {connection}"
@@ -160,8 +160,8 @@ class GreenplumSource(CommonDbSourceService, MultiDBSource):
         yield from self._execute_database_query(GREENPLUM_GET_DB_NAMES)
 
     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:

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

@@ -100,12 +100,12 @@ def get_connection(connection: HiveConnection) -> Engine:
             in {HiveScheme.hive, HiveScheme.hive_http, HiveScheme.hive_https}
             else "auth_mechanism"
         )
-        connection.connectionArguments.__root__[auth_key] = connection.auth.value
+        connection.connectionArguments.root[auth_key] = connection.auth.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
 

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

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

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

@@ -39,7 +39,7 @@ class IcebergHiveCatalog(IcebergCatalogBase):
 
         parameters = {
             "warehouse": catalog.warehouseLocation,
-            "uri": catalog.connection.uri,
+            "uri": str(catalog.connection.uri),
         }
 
         if catalog.connection.fileSystem:

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

@@ -37,7 +37,7 @@ class IcebergRestCatalog(IcebergCatalogBase):
                 "'connection' is not an instance of 'RestCatalogConnection'"
             )
 
-        if catalog.connection.credential:
+        if catalog.connection.credential and catalog.connection.credential.clientSecret:
             client_id = catalog.connection.credential.clientId.get_secret_value()
             client_secret = (
                 catalog.connection.credential.clientSecret.get_secret_value()

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

@@ -46,7 +46,7 @@ class IcebergFileSystemFactory:
 
         if not file_system_type:
             raise NotImplementedError(
-                f"Iceberg File System otype ['{fs_config.__class__.__name__}'] Not Implemented."
+                f"Iceberg File System type ['{fs_config.__class__.__name__}'] Not Implemented."
             )
 
         return file_system_type.get_fs_params(fs_config)

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

@@ -56,7 +56,7 @@ class S3FileSystem(IcebergFileSystemBase):
 
         unused_keys = []
 
-        for key, value in fs_config.dict().items():
+        for key, value in fs_config.model_dump().items():
             if key not in SUPPORTED_KEYS and value:
                 unused_keys.append(key)
 

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

@@ -37,14 +37,14 @@ def namespace_to_str(namespace: tuple[str]) -> str:
     return ".".join(namespace)
 
 
-def get_table_name_as_str(table: pyiceberg.table.Table) -> str:
-    """Returns the Table Name as Tring from a PyIceberg Table.
+def get_table_name_as_str(table: Tuple[str]) -> str:
+    """Returns the Table Name as String from a PyIceberg table identifier tuple.
 
     The PyIceberg table name is returned as tuple and we turn them into a String
     concatenating the items with a '.' in between.
     """
     # We are skipping the first item because it is the schema name.
-    return ".".join(table.name()[1:])
+    return ".".join(table[1:])
 
 
 def get_column_from_partition(
@@ -94,7 +94,7 @@ def get_column_partition_type(
 def get_owner_from_table(
     table: pyiceberg.table.Table, property_key: str
 ) -> Optional[str]:
-    """Retrives the owner information from given Table Property."""
+    """Retrieves the owner information from given Table Property."""
     return table.properties.get(property_key)
 
 

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",
+}