informatica-python 1.0.0__py3-none-any.whl

informatica_python/parser.py

@@ -0,0 +1,468 @@
+import xml.etree.ElementTree as ET
+from typing import Optional
+from informatica_python.models import (
+    PowermartDef, RepositoryDef, FolderDef, SourceDef, TargetDef,
+    MappingDef, TransformationDef, ConnectorDef, InstanceDef,
+    FieldDef, TableAttribute, SessionDef, WorkflowDef,
+    TaskInstanceDef, WorkflowLink, WorkflowVariable,
+    MappingVariable, TargetLoadOrder, SessionTransformInst,
+    ConnectionRef, ConfigDef, SchedulerDef, MappletDef,
+    ShortcutDef, TaskDef,
+)
+
+
+class InformaticaParser:
+    def __init__(self):
+        self.errors = []
+        self.warnings = []
+
+    def parse_file(self, file_path: str) -> PowermartDef:
+        try:
+            tree = ET.parse(file_path)
+            root = tree.getroot()
+            return self._parse_powermart(root)
+        except ET.ParseError as e:
+            self.errors.append(f"XML parse error: {e}")
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                content = self._strip_dtd(content)
+                root = ET.fromstring(content)
+                return self._parse_powermart(root)
+            except Exception as e2:
+                self.errors.append(f"Fallback parse also failed: {e2}")
+                return PowermartDef()
+
+    def parse_string(self, xml_string: str) -> PowermartDef:
+        try:
+            cleaned = self._strip_dtd(xml_string)
+            root = ET.fromstring(cleaned)
+            return self._parse_powermart(root)
+        except ET.ParseError as e:
+            self.errors.append(f"XML parse error: {e}")
+            return PowermartDef()
+
+    def _strip_dtd(self, content: str) -> str:
+        import re
+        content = re.sub(r'<!DOCTYPE[^>]*>', '', content)
+        return content
+
+    def _attr(self, elem, name, default=""):
+        val = elem.get(name, default)
+        return val.strip() if val else default
+
+    def _parse_powermart(self, elem) -> PowermartDef:
+        pm = PowermartDef(
+            creation_date=self._attr(elem, "CREATION_DATE"),
+            repository_version=self._attr(elem, "REPOSITORY_VERSION"),
+        )
+        for repo_elem in elem.findall("REPOSITORY"):
+            pm.repositories.append(self._parse_repository(repo_elem))
+        return pm
+
+    def _parse_repository(self, elem) -> RepositoryDef:
+        repo = RepositoryDef(
+            name=self._attr(elem, "NAME"),
+            version=self._attr(elem, "VERSION"),
+            codepage=self._attr(elem, "CODEPAGE"),
+            database_type=self._attr(elem, "DATABASETYPE"),
+        )
+        for folder_elem in elem.findall("FOLDER"):
+            repo.folders.append(self._parse_folder(folder_elem))
+        return repo
+
+    def _parse_folder(self, elem) -> FolderDef:
+        folder = FolderDef(
+            name=self._attr(elem, "NAME"),
+            owner=self._attr(elem, "OWNER"),
+            description=self._attr(elem, "DESCRIPTION"),
+            group=self._attr(elem, "GROUP"),
+            shared=self._attr(elem, "SHARED", "NOTSHARED"),
+            permissions=self._attr(elem, "PERMISSIONS"),
+        )
+
+        for src in elem.findall("SOURCE"):
+            folder.sources.append(self._parse_source(src))
+
+        for tgt in elem.findall("TARGET"):
+            folder.targets.append(self._parse_target(tgt))
+
+        for mapping in elem.findall("MAPPING"):
+            folder.mappings.append(self._parse_mapping(mapping))
+
+        for mapplet in elem.findall("MAPPLET"):
+            folder.mapplets.append(self._parse_mapplet(mapplet))
+
+        for session in elem.findall("SESSION"):
+            folder.sessions.append(self._parse_session(session))
+
+        for wf in elem.findall("WORKFLOW"):
+            folder.workflows.append(self._parse_workflow(wf))
+
+        for task in elem.findall("TASK"):
+            folder.tasks.append(self._parse_task(task))
+
+        for cfg in elem.findall("CONFIG"):
+            folder.configs.append(self._parse_config(cfg))
+
+        for sched in elem.findall("SCHEDULER"):
+            folder.schedulers.append(self._parse_scheduler(sched))
+
+        for sc in elem.findall("SHORTCUT"):
+            folder.shortcuts.append(self._parse_shortcut(sc))
+
+        for tx in elem.findall("TRANSFORMATION"):
+            folder.transformations.append(self._parse_transformation(tx))
+
+        for worklet in elem.findall("WORKLET"):
+            wf_def = self._parse_workflow(worklet)
+            wf_def.metadata["is_worklet"] = "YES"
+            folder.workflows.append(wf_def)
+
+        return folder
+
+    def _parse_source(self, elem) -> SourceDef:
+        src = SourceDef(
+            name=self._attr(elem, "NAME"),
+            database_type=self._attr(elem, "DATABASETYPE"),
+            db_name=self._attr(elem, "DBDNAME"),
+            owner_name=self._attr(elem, "OWNERNAME"),
+            description=self._attr(elem, "DESCRIPTION"),
+            business_name=self._attr(elem, "BUSINESSNAME"),
+        )
+        for sf in elem.findall("SOURCEFIELD"):
+            src.fields.append(self._parse_source_field(sf))
+        for ta in elem.findall("TABLEATTRIBUTE"):
+            src.attributes.append(self._parse_table_attribute(ta))
+        for fa in elem.findall("FIELDATTRIBUTE"):
+            src.attributes.append(self._parse_table_attribute(fa))
+        for me in elem.findall("METADATAEXTENSION"):
+            src.attributes.append(self._parse_table_attribute(me))
+        return src
+
+    def _parse_source_field(self, elem) -> FieldDef:
+        return FieldDef(
+            name=self._attr(elem, "NAME"),
+            datatype=self._attr(elem, "DATATYPE"),
+            precision=int(self._attr(elem, "PRECISION", "0") or "0"),
+            scale=int(self._attr(elem, "SCALE", "0") or "0"),
+            nullable=self._attr(elem, "NULLABLE", "NULL"),
+            keytype=self._attr(elem, "KEYTYPE", "NOT A KEY"),
+            field_number=int(self._attr(elem, "FIELDNUMBER", "0") or "0"),
+            hidden=self._attr(elem, "HIDDEN", "NO"),
+            business_name=self._attr(elem, "BUSINESSNAME"),
+            description=self._attr(elem, "DESCRIPTION"),
+        )
+
+    def _parse_target(self, elem) -> TargetDef:
+        tgt = TargetDef(
+            name=self._attr(elem, "NAME"),
+            database_type=self._attr(elem, "DATABASETYPE"),
+            description=self._attr(elem, "DESCRIPTION"),
+            business_name=self._attr(elem, "BUSINESSNAME"),
+            constraint=self._attr(elem, "CONSTRAINT"),
+            table_options=self._attr(elem, "TABLEOPTIONS"),
+        )
+        for tf in elem.findall("TARGETFIELD"):
+            tgt.fields.append(self._parse_target_field(tf))
+        for ta in elem.findall("TABLEATTRIBUTE"):
+            tgt.attributes.append(self._parse_table_attribute(ta))
+        for ti in elem.findall("TARGETINDEX"):
+            tgt.attributes.append(TableAttribute(
+                name=f"INDEX_{self._attr(ti, 'NAME')}",
+                value=self._attr(ti, 'DESCRIPTION'),
+            ))
+        return tgt
+
+    def _parse_target_field(self, elem) -> FieldDef:
+        return FieldDef(
+            name=self._attr(elem, "NAME"),
+            datatype=self._attr(elem, "DATATYPE"),
+            precision=int(self._attr(elem, "PRECISION", "0") or "0"),
+            scale=int(self._attr(elem, "SCALE", "0") or "0"),
+            nullable=self._attr(elem, "NULLABLE", "NULL"),
+            keytype=self._attr(elem, "KEYTYPE", "NOT A KEY"),
+            field_number=int(self._attr(elem, "FIELDNUMBER", "0") or "0"),
+            description=self._attr(elem, "DESCRIPTION"),
+            business_name=self._attr(elem, "BUSINESSNAME"),
+        )
+
+    def _parse_transformation(self, elem) -> TransformationDef:
+        tx = TransformationDef(
+            name=self._attr(elem, "NAME"),
+            type=self._attr(elem, "TYPE"),
+            description=self._attr(elem, "DESCRIPTION"),
+            reusable=self._attr(elem, "REUSABLE", "NO"),
+        )
+        for tf in elem.findall("TRANSFORMFIELD"):
+            tx.fields.append(self._parse_transform_field(tf))
+        for ta in elem.findall("TABLEATTRIBUTE"):
+            tx.attributes.append(self._parse_table_attribute(ta))
+
+        for child_tag in ["TRANSFORMFIELDATTR", "TRANSFORMFIELDATTRDEF", "INITPROP", "ERPINFO"]:
+            for child in elem.findall(child_tag):
+                tx.metadata[f"{child_tag}_{self._attr(child, 'NAME', child_tag)}"] = self._attr(child, "VALUE", str(child.attrib))
+
+        return tx
+
+    def _parse_transform_field(self, elem) -> FieldDef:
+        return FieldDef(
+            name=self._attr(elem, "NAME"),
+            datatype=self._attr(elem, "DATATYPE"),
+            precision=int(self._attr(elem, "PRECISION", "0") or "0"),
+            scale=int(self._attr(elem, "SCALE", "0") or "0"),
+            default_value=self._attr(elem, "DEFAULTVALUE"),
+            expression=self._attr(elem, "EXPRESSION"),
+            expression_type=self._attr(elem, "EXPRESSIONTYPE"),
+            porttype=self._attr(elem, "PORTTYPE"),
+            description=self._attr(elem, "DESCRIPTION"),
+        )
+
+    def _parse_table_attribute(self, elem) -> TableAttribute:
+        return TableAttribute(
+            name=self._attr(elem, "NAME"),
+            value=self._attr(elem, "VALUE"),
+        )
+
+    def _parse_connector(self, elem) -> ConnectorDef:
+        return ConnectorDef(
+            from_field=self._attr(elem, "FROMFIELD"),
+            from_instance=self._attr(elem, "FROMINSTANCE"),
+            from_instance_type=self._attr(elem, "FROMINSTANCETYPE"),
+            to_field=self._attr(elem, "TOFIELD"),
+            to_instance=self._attr(elem, "TOINSTANCE"),
+            to_instance_type=self._attr(elem, "TOINSTANCETYPE"),
+        )
+
+    def _parse_instance(self, elem) -> InstanceDef:
+        return InstanceDef(
+            name=self._attr(elem, "NAME"),
+            type=self._attr(elem, "TYPE"),
+            transformation_name=self._attr(elem, "TRANSFORMATION_NAME"),
+            transformation_type=self._attr(elem, "TRANSFORMATION_TYPE"),
+            description=self._attr(elem, "DESCRIPTION"),
+            reusable=self._attr(elem, "REUSABLE", "NO"),
+        )
+
+    def _parse_mapping(self, elem) -> MappingDef:
+        mapping = MappingDef(
+            name=self._attr(elem, "NAME"),
+            description=self._attr(elem, "DESCRIPTION"),
+            is_valid=self._attr(elem, "ISVALID", "YES"),
+        )
+
+        for tx in elem.findall("TRANSFORMATION"):
+            mapping.transformations.append(self._parse_transformation(tx))
+
+        for conn in elem.findall("CONNECTOR"):
+            mapping.connectors.append(self._parse_connector(conn))
+
+        for inst in elem.findall("INSTANCE"):
+            mapping.instances.append(self._parse_instance(inst))
+
+        for tlo in elem.findall("TARGETLOADORDER"):
+            order = TargetLoadOrder(
+                order=int(self._attr(tlo, "ORDER", "1") or "1"),
+                target_instance=self._attr(tlo, "TARGETINSTANCE"),
+            )
+            mapping.target_load_orders.append(order)
+
+        for mv in elem.findall("MAPPINGVARIABLE"):
+            mapping.variables.append(MappingVariable(
+                name=self._attr(mv, "NAME"),
+                datatype=self._attr(mv, "DATATYPE", "string"),
+                default_value=self._attr(mv, "DEFAULTVALUE"),
+                description=self._attr(mv, "DESCRIPTION"),
+                is_expression_variable=self._attr(mv, "ISEXPRESSIONVARIABLE", "NO"),
+                is_persistent=self._attr(mv, "ISPERSISTENT", "NO"),
+                precision=int(self._attr(mv, "PRECISION", "0") or "0"),
+                scale=int(self._attr(mv, "SCALE", "0") or "0"),
+                usage_type=self._attr(mv, "USAGETYPE"),
+            ))
+
+        for me in elem.findall("METADATAEXTENSION"):
+            mapping.metadata[self._attr(me, "NAME")] = self._attr(me, "VALUE")
+
+        return mapping
+
+    def _parse_mapplet(self, elem) -> MappletDef:
+        mapplet = MappletDef(
+            name=self._attr(elem, "NAME"),
+            description=self._attr(elem, "DESCRIPTION"),
+            is_valid=self._attr(elem, "ISVALID", "YES"),
+        )
+        for tx in elem.findall("TRANSFORMATION"):
+            mapplet.transformations.append(self._parse_transformation(tx))
+        for conn in elem.findall("CONNECTOR"):
+            mapplet.connectors.append(self._parse_connector(conn))
+        for inst in elem.findall("INSTANCE"):
+            mapplet.instances.append(self._parse_instance(inst))
+        return mapplet
+
+    def _parse_session(self, elem) -> SessionDef:
+        session = SessionDef(
+            name=self._attr(elem, "NAME"),
+            mapping_name=self._attr(elem, "MAPPINGNAME"),
+            description=self._attr(elem, "DESCRIPTION"),
+            is_valid=self._attr(elem, "ISVALID", "YES"),
+            reusable=self._attr(elem, "REUSABLE", "NO"),
+        )
+
+        for ta in elem.findall(".//ATTRIBUTE"):
+            session.attributes.append(self._parse_table_attribute(ta))
+
+        for cr in elem.findall(".//CONFIGREFERENCE"):
+            session.config_references.append({
+                "name": self._attr(cr, "REFOBJECTNAME"),
+                "type": self._attr(cr, "TYPE"),
+            })
+
+        for sti in elem.findall(".//SESSTRANSFORMATIONINST"):
+            st = SessionTransformInst(
+                instance_name=self._attr(sti, "SINSTANCENAME"),
+                pipeline=self._attr(sti, "PIPELINE"),
+                stage=self._attr(sti, "STAGE"),
+                transformation_name=self._attr(sti, "TRANSFORMATIONNAME"),
+                transformation_type=self._attr(sti, "TRANSFORMATIONTYPE"),
+                is_partitionable=self._attr(sti, "ISREPARTITIONPOINT", "NO"),
+            )
+            for ta in sti.findall("ATTRIBUTE"):
+                st.attributes.append(self._parse_table_attribute(ta))
+            for cr in sti.findall("CONNECTIONREFERENCE"):
+                st.connections.append(ConnectionRef(
+                    connection_name=self._attr(cr, "CONNECTIONNAME"),
+                    connection_type=self._attr(cr, "CONNECTIONTYPE"),
+                    connection_subtype=self._attr(cr, "CONNECTIONSUBTYPE"),
+                    variable=self._attr(cr, "VARIABLE"),
+                ))
+            session.transform_instances.append(st)
+
+        for comp in elem.findall(".//SESSIONCOMPONENT"):
+            comp_data = {
+                "name": self._attr(comp, "REFOBJECTNAME"),
+                "type": self._attr(comp, "TYPE"),
+                "attributes": [],
+            }
+            for ta in comp.findall("ATTRIBUTE"):
+                comp_data["attributes"].append({
+                    "name": self._attr(ta, "NAME"),
+                    "value": self._attr(ta, "VALUE"),
+                })
+            session.components.append(comp_data)
+
+        return session
+
+    def _parse_workflow(self, elem) -> WorkflowDef:
+        wf = WorkflowDef(
+            name=self._attr(elem, "NAME"),
+            description=self._attr(elem, "DESCRIPTION"),
+            is_valid=self._attr(elem, "ISVALID", "YES"),
+            reusable=self._attr(elem, "REUSABLE", "NO"),
+            scheduler_name=self._attr(elem, "SCHEDULERNAME"),
+        )
+
+        for ti in elem.findall("TASKINSTANCE"):
+            wf.task_instances.append(self._parse_task_instance(ti))
+
+        for link in elem.findall("WORKFLOWLINK"):
+            wf.links.append(WorkflowLink(
+                from_instance=self._attr(link, "FROMTASK"),
+                to_instance=self._attr(link, "TOTASK"),
+                condition=self._attr(link, "CONDITION"),
+                link_type=self._attr(link, "LINKTYPE"),
+            ))
+
+        for wv in elem.findall("WORKFLOWVARIABLE"):
+            wf.variables.append(WorkflowVariable(
+                name=self._attr(wv, "NAME"),
+                datatype=self._attr(wv, "DATATYPE", "string"),
+                default_value=self._attr(wv, "DEFAULTVALUE"),
+                description=self._attr(wv, "DESCRIPTION"),
+                is_null=self._attr(wv, "ISNULL", "NO"),
+                is_persistent=self._attr(wv, "ISPERSISTENT", "NO"),
+                is_user_defined=self._attr(wv, "ISUSERDEFINED", "YES"),
+                precision=int(self._attr(wv, "PRECISION", "0") or "0"),
+                scale=int(self._attr(wv, "SCALE", "0") or "0"),
+                usage_type=self._attr(wv, "USAGETYPE"),
+            ))
+
+        for ta in elem.findall("ATTRIBUTE"):
+            wf.attributes.append(self._parse_table_attribute(ta))
+
+        for me in elem.findall("METADATAEXTENSION"):
+            wf.metadata[self._attr(me, "NAME")] = self._attr(me, "VALUE")
+
+        for session in elem.findall("SESSION"):
+            pass
+
+        return wf
+
+    def _parse_task_instance(self, elem) -> TaskInstanceDef:
+        ti = TaskInstanceDef(
+            name=self._attr(elem, "NAME"),
+            task_name=self._attr(elem, "TASKNAME"),
+            task_type=self._attr(elem, "TASKTYPE"),
+            description=self._attr(elem, "DESCRIPTION"),
+            is_valid=self._attr(elem, "ISVALID", "YES"),
+            reusable=self._attr(elem, "REUSABLE", "NO"),
+            fail_parent_if_instance_fails=self._attr(elem, "FAIL_PARENT_IF_INSTANCE_FAILS", "YES"),
+            fail_parent_if_instance_did_not_run=self._attr(elem, "FAIL_PARENT_IF_INSTANCE_DID_NOT_RUN", "NO"),
+            treat_input_link_as_and=self._attr(elem, "TREAT_INPUTLINKS_AS_AND", "YES"),
+        )
+        for ta in elem.findall("ATTRIBUTE"):
+            ti.attributes.append(self._parse_table_attribute(ta))
+        return ti
+
+    def _parse_config(self, elem) -> ConfigDef:
+        cfg = ConfigDef(
+            name=self._attr(elem, "NAME"),
+            description=self._attr(elem, "DESCRIPTION"),
+            is_valid=self._attr(elem, "ISVALID", "YES"),
+        )
+        for ta in elem.findall("ATTRIBUTE"):
+            cfg.attributes.append(self._parse_table_attribute(ta))
+        return cfg
+
+    def _parse_scheduler(self, elem) -> SchedulerDef:
+        sched = SchedulerDef(
+            name=self._attr(elem, "NAME"),
+            description=self._attr(elem, "DESCRIPTION"),
+            reusable=self._attr(elem, "REUSABLE", "NO"),
+        )
+        for ta in elem.findall("ATTRIBUTE"):
+            sched.attributes.append(self._parse_table_attribute(ta))
+        for child_tag in ["SCHEDULEINFO", "STARTOPTIONS", "ENDOPTIONS",
+                          "SCHEDULEOPTIONS", "RECURRING", "CUSTOM",
+                          "DAILYFREQUENCY", "REPEAT", "FILTER"]:
+            for child in elem.findall(f".//{child_tag}"):
+                for k, v in child.attrib.items():
+                    sched.attributes.append(TableAttribute(
+                        name=f"{child_tag}_{k}",
+                        value=v,
+                    ))
+        return sched
+
+    def _parse_shortcut(self, elem) -> ShortcutDef:
+        return ShortcutDef(
+            name=self._attr(elem, "NAME"),
+            shortcut_type=self._attr(elem, "OBJECTSUBTYPE"),
+            reference_name=self._attr(elem, "REFOBJECTNAME"),
+            folder_name=self._attr(elem, "FOLDERNAME"),
+            repository_name=self._attr(elem, "REPOSITORYNAME"),
+        )
+
+    def _parse_task(self, elem) -> TaskDef:
+        task = TaskDef(
+            name=self._attr(elem, "NAME"),
+            type=self._attr(elem, "TYPE"),
+            description=self._attr(elem, "DESCRIPTION"),
+            reusable=self._attr(elem, "REUSABLE", "NO"),
+        )
+        for ta in elem.findall("ATTRIBUTE"):
+            task.attributes.append(self._parse_table_attribute(ta))
+        for vp in elem.findall("VALUEPAIR"):
+            task.attributes.append(TableAttribute(
+                name=self._attr(vp, "NAME"),
+                value=self._attr(vp, "VALUE"),
+            ))
+        return task

informatica_python/utils/datatype_map.py

@@ -0,0 +1,105 @@
+INFORMATICA_TO_PYTHON = {
+    "bigint": "int",
+    "integer": "int",
+    "int": "int",
+    "small integer": "int",
+    "smallint": "int",
+    "tinyint": "int",
+    "numeric": "float",
+    "decimal": "float",
+    "float": "float",
+    "double": "float",
+    "real": "float",
+    "money": "float",
+    "smallmoney": "float",
+    "string": "str",
+    "nstring": "str",
+    "text": "str",
+    "ntext": "str",
+    "varchar": "str",
+    "nvarchar": "str",
+    "char": "str",
+    "nchar": "str",
+    "binary": "bytes",
+    "varbinary": "bytes",
+    "image": "bytes",
+    "date/time": "str",
+    "datetime": "str",
+    "datetime2": "str",
+    "date": "str",
+    "time": "str",
+    "timestamp": "str",
+    "bit": "bool",
+    "boolean": "bool",
+    "uniqueidentifier": "str",
+    "xml": "str",
+    "sql_variant": "str",
+}
+
+INFORMATICA_TO_SPARK = {
+    "bigint": "LongType()",
+    "integer": "IntegerType()",
+    "int": "IntegerType()",
+    "small integer": "ShortType()",
+    "smallint": "ShortType()",
+    "tinyint": "ByteType()",
+    "numeric": "DecimalType({precision}, {scale})",
+    "decimal": "DecimalType({precision}, {scale})",
+    "float": "FloatType()",
+    "double": "DoubleType()",
+    "real": "FloatType()",
+    "money": "DecimalType(19, 4)",
+    "smallmoney": "DecimalType(10, 4)",
+    "string": "StringType()",
+    "nstring": "StringType()",
+    "text": "StringType()",
+    "ntext": "StringType()",
+    "varchar": "StringType()",
+    "nvarchar": "StringType()",
+    "char": "StringType()",
+    "nchar": "StringType()",
+    "binary": "BinaryType()",
+    "varbinary": "BinaryType()",
+    "image": "BinaryType()",
+    "date/time": "TimestampType()",
+    "datetime": "TimestampType()",
+    "datetime2": "TimestampType()",
+    "date": "DateType()",
+    "time": "StringType()",
+    "timestamp": "TimestampType()",
+    "bit": "BooleanType()",
+    "boolean": "BooleanType()",
+    "uniqueidentifier": "StringType()",
+    "xml": "StringType()",
+    "sql_variant": "StringType()",
+}
+
+DB_TYPE_MAP = {
+    "Microsoft SQL Server": "mssql",
+    "Oracle": "oracle",
+    "Sybase": "sybase",
+    "Informix": "informix",
+    "DB2": "db2",
+    "Teradata": "teradata",
+    "ODBC": "odbc",
+    "Flat File": "flatfile",
+    "XML": "xml",
+    "SAP": "sap",
+    "": "unknown",
+}
+
+
+def get_python_type(informatica_type):
+    return INFORMATICA_TO_PYTHON.get(informatica_type.lower().strip(), "str")
+
+
+def get_spark_type(informatica_type, precision=10, scale=0):
+    key = informatica_type.lower().strip()
+    spark_type = INFORMATICA_TO_SPARK.get(key, "StringType()")
+    if "{precision}" in spark_type:
+        spark_type = spark_type.format(precision=precision, scale=scale)
+    return spark_type
+
+
+def get_db_type(database_type):
+    return DB_TYPE_MAP.get(database_type, database_type.lower() if database_type else "unknown")