bpmn-lib 4.0.5__py3-none-any.whl

bpmn_lib/__init__.py

@@ -0,0 +1,38 @@
+"""
+BPMN Process Navigation Library.
+
+This library provides classes for navigating and managing BPMN element hierarchies,
+database schema definitions, and validation utilities.
+"""
+
+from bpmn_lib.navigator.bpmn_hierarchy_navigator import BPMNHierarchyNavigator
+from bpmn_lib.database.instance.database_instance import DatabaseInstance
+from bpmn_lib.database.instance.database_builder import DatabaseBuilder
+from bpmn_lib.database.schema.database_schema import DatabaseSchema
+from bpmn_lib.database.schema.database_schema_parser import DatabaseSchemaParser
+from bpmn_lib.database.schema.table_definition import TableDefinition
+from bpmn_lib.database.schema.column_definition import ColumnDefinition
+from bpmn_lib.database.schema.foreign_key_relationship import ForeignKeyRelationship
+from bpmn_lib.utils.validation_result import ValidationResult
+from basic_framework import MarkdownDocument
+
+__all__ = [
+    # Navigator
+    "BPMNHierarchyNavigator",
+    # Database Instance
+    "DatabaseInstance",
+    "DatabaseBuilder",
+    # Database Schema
+    "DatabaseSchema",
+    "DatabaseSchemaParser",
+    "TableDefinition",
+    "ColumnDefinition",
+    "ForeignKeyRelationship",
+    # Utils
+    "ValidationResult",
+    "MarkdownDocument",
+]
+
+from importlib.metadata import version
+
+__version__: str = version("bpmn-lib")

bpmn_lib/database/__init__.py

@@ -0,0 +1,25 @@
+"""Database module for schema and instance management."""
+
+from bpmn_lib.database.schema.database_schema import DatabaseSchema
+from bpmn_lib.database.schema.database_schema_parser import DatabaseSchemaParser
+from bpmn_lib.database.schema.table_definition import TableDefinition
+from bpmn_lib.database.schema.column_definition import ColumnDefinition
+from bpmn_lib.database.schema.foreign_key_relationship import ForeignKeyRelationship
+from bpmn_lib.database.instance.database_instance import DatabaseInstance
+from bpmn_lib.database.instance.database_builder import DatabaseBuilder
+from bpmn_lib.database.instance.database_bulk_validator import DatabaseBulkValidator
+from bpmn_lib.database.instance.database_index_builder import DatabaseIndexBuilder
+
+__all__ = [
+    # Schema
+    "DatabaseSchema",
+    "DatabaseSchemaParser",
+    "TableDefinition",
+    "ColumnDefinition",
+    "ForeignKeyRelationship",
+    # Instance
+    "DatabaseInstance",
+    "DatabaseBuilder",
+    "DatabaseBulkValidator",
+    "DatabaseIndexBuilder",
+]

bpmn_lib/database/instance/__init__.py

@@ -0,0 +1,13 @@
+"""Database instance module."""
+
+from bpmn_lib.database.instance.database_instance import DatabaseInstance
+from bpmn_lib.database.instance.database_builder import DatabaseBuilder
+from bpmn_lib.database.instance.database_bulk_validator import DatabaseBulkValidator
+from bpmn_lib.database.instance.database_index_builder import DatabaseIndexBuilder
+
+__all__ = [
+    "DatabaseInstance",
+    "DatabaseBuilder",
+    "DatabaseBulkValidator",
+    "DatabaseIndexBuilder",
+]

bpmn_lib/database/instance/database_builder.py

@@ -0,0 +1,151 @@
+"""
+DatabaseBuilder - Koordiniert den Aufbau der Datenbank in Phasen.
+"""
+
+from typing import Dict
+from basic_framework.proc_frame import log_msg, log_and_raise
+from basic_framework.container_utils.container_in_memory import ContainerInMemory
+from basic_framework.container_utils.abstract_container import AbstractContainer
+from bpmn_lib.database.schema.database_schema import DatabaseSchema
+from bpmn_lib.database.instance.database_instance import DatabaseInstance
+from bpmn_lib.utils.validation_result import ValidationResult
+from bpmn_lib.database.instance.database_bulk_validator import DatabaseBulkValidator
+from bpmn_lib.database.instance.database_index_builder import DatabaseIndexBuilder
+
+
+class DatabaseBuilder:
+    """Koordiniert den Aufbau der Datenbank in Phasen."""
+
+    def __init__(self, schema: DatabaseSchema, result: ValidationResult) -> None:
+        """
+        Initialisiert den DatabaseBuilder.
+
+        Args:
+            schema: DatabaseSchema mit Tabellendefinitionen
+            result: ValidationResult für Fehlerberichte
+
+        Raises:
+            TypeError: Wenn schema oder result None ist (Python's Typsystem)
+        """
+        self._schema: DatabaseSchema = schema
+
+        # DatabaseInstance erstellen mit neuem Konstruktor
+        self._instance: DatabaseInstance = DatabaseInstance(self._schema)
+
+        # Validator und IndexBuilder erstellen mit neuen Konstruktoren
+        self._bulk_validator: DatabaseBulkValidator = DatabaseBulkValidator(self._instance, result)
+        self._index_builder: DatabaseIndexBuilder = DatabaseIndexBuilder(self._instance)
+
+        log_msg(f"DatabaseBuilder fuer Schema '{self._schema.get_schema_name()}' initialisiert.")
+
+    def load_all_data(self, o_data_source: Dict[str, ContainerInMemory]) -> None:
+        """Laedt alle Daten ohne Constraint-Pruefung."""
+        log_msg("Starte Bulk-Load der Daten...")
+        self._load_from_container_dictionary(o_data_source)
+
+    def _load_from_container_dictionary(self, o_container_dict: Dict[str, ContainerInMemory]) -> None:
+        """Laedt Daten aus einem Dictionary von ContainerInMemory-Objekten."""
+        n_total_rows = 0
+
+        # Fuer jede Tabelle im Dictionary
+        for v_table_name in o_container_dict.keys():
+            s_table_name = str(v_table_name)
+
+            # Pruefen ob Tabelle im Schema existiert
+            if not self._table_exists_in_schema(s_table_name):
+                log_msg(f"WARNUNG: Tabelle '{s_table_name}' existiert nicht im Schema und wird uebersprungen.")
+                continue
+
+            # Source Container holen
+            o_source_container = o_container_dict[s_table_name]
+
+            # Iterator fuer Source erstellen
+            o_source_iterator = o_source_container.create_iterator()
+
+            # Zeilen kopieren
+            n_row_count = 0
+
+            while not o_source_iterator.is_empty():
+                # Zeile in Ziel-Tabelle einfuegen
+                if self._instance.insert_row_from_iterator(s_table_name, o_source_iterator):
+                    n_row_count += 1
+
+                o_source_iterator.pp()
+
+                # Log-Nachricht alle 1000 Zeilen
+                if n_row_count % 1000 == 0:
+                    pass  # log_msg(f"Tabelle '{s_table_name}': {n_row_count} Zeilen geladen")
+
+            # log_msg(f"Tabelle '{s_table_name}': {n_row_count} Zeilen geladen.")
+            n_total_rows += n_row_count
+
+        # log_msg(f"Bulk-Load abgeschlossen. Insgesamt {n_total_rows} Zeilen geladen.")
+
+    def load_table_data(self, s_table_name: str, o_source_container: AbstractContainer) -> None:
+        """Laedt Daten fuer eine einzelne Tabelle."""
+        # Pruefen ob Tabelle im Schema existiert
+        if not self._table_exists_in_schema(s_table_name):
+            log_and_raise(f"Tabelle '{s_table_name}' existiert nicht im Schema.")
+
+        # log_msg(f"Lade Daten fuer Tabelle '{s_table_name}'...")
+
+        # Iterator fuer Source erstellen
+        o_source_iterator = o_source_container.create_iterator()
+
+        # Zeilen kopieren
+        n_row_count = 0
+
+        while not o_source_iterator.is_empty():
+            # Zeile in Ziel-Tabelle einfuegen
+            if self._instance.insert_row_from_iterator(s_table_name, o_source_iterator):
+                n_row_count += 1
+
+            o_source_iterator.pp()
+
+            # Log-Nachricht alle 1000 Zeilen
+            if n_row_count % 1000 == 0:
+                pass  # log_msg(f"Tabelle '{s_table_name}': {n_row_count} Zeilen geladen")
+
+        # log_msg(f"Tabelle '{s_table_name}': {n_row_count} Zeilen geladen.")
+
+    def validate_all_constraints(self) -> None:
+        """Prueft nachtraeglich alle Constraints."""
+        log_msg("Starte Validierung aller Constraints...")
+
+        # BulkValidator ausfuehren
+        self._bulk_validator.validate_all()
+
+    def build_indexes_if_valid(self) -> None:
+        """Erstellt Indizes nur bei erfolgreicher Validierung."""
+        # log_msg("Erstelle Indizes...")
+
+        # IndexBuilder ausfuehren
+        self._index_builder.build_all_indexes()
+
+        # log_msg("Indizes erfolgreich erstellt.")
+
+    def create_read_only_database(self) -> DatabaseInstance:
+        """Gibt fertige DatabaseInstance zurueck."""
+        # Pruefen ob alle Schritte durchgefuehrt wurden
+        if not self._instance.is_finalized():
+            log_and_raise("create_read_only_database: Indizes wurden nicht erstellt.")
+
+        # Instanz auf Read-Only setzen
+        self._instance.set_read_only()
+
+        log_msg("Read-Only Datenbank erfolgreich erstellt.")
+        return self._instance
+
+    def _table_exists_in_schema(self, s_table_name: str) -> bool:
+        """Hilfsmethode - Prueft ob Tabelle im Schema existiert."""
+        o_table_names = self._schema.get_table_names()
+
+        for v_name in o_table_names:
+            if str(v_name) == s_table_name:
+                return True
+
+        return False
+
+    def get_instance(self) -> DatabaseInstance:
+        """Gibt die DatabaseInstance zurueck (auch vor Finalisierung)."""
+        return self._instance

bpmn_lib/database/instance/database_bulk_validator.py

@@ -0,0 +1,350 @@
+"""
+DatabaseBulkValidator - Nachtraegliche Validierung aller Daten.
+"""
+
+from typing import List
+from basic_framework.proc_frame import log_msg, log_and_raise
+from basic_framework import is_effectively_null
+from basic_framework.container_utils.abstract_iterator import AbstractIterator
+from bpmn_lib.database.schema.database_schema import DatabaseSchema
+from bpmn_lib.database.instance.database_instance import DatabaseInstance
+from bpmn_lib.utils.validation_result import ValidationResult
+
+
+class DatabaseBulkValidator:
+    """Nachtraegliche Validierung aller Daten."""
+
+    def __init__(self, instance: DatabaseInstance, result: ValidationResult) -> None:
+        """
+        Initialisiert den BulkValidator.
+
+        Args:
+            instance: DatabaseInstance mit den zu validierenden Daten
+            result: ValidationResult für Fehlerberichte
+
+        Raises:
+            TypeError: Wenn instance oder result None ist (Python's Typsystem)
+        """
+        self._schema: DatabaseSchema = instance.get_schema()
+        self._instance: DatabaseInstance = instance
+        self._result: ValidationResult = result
+
+    def validate_all(self) -> None:
+        """Fuehrt alle Validierungen durch."""
+        log_msg("Starte Bulk-Validierung der Datenbank...")
+
+        # 1. Primary Key Validierung
+        log_msg("1. Validiere Primary Keys...")
+        self.validate_primary_keys()
+
+        # 2. Foreign Key Validierung
+        # log_msg("2. Validiere Foreign Keys...")
+        self.validate_foreign_keys()
+
+        # 3. Not Null Validierung
+        # log_msg("3. Validiere NOT NULL Constraints...")
+        self.validate_not_null_constraints()
+
+        # 4. Unique Constraints Validierung
+        # log_msg("4. Validiere UNIQUE Constraints...")
+        self.validate_unique_constraints()
+
+        # 5. Value Domain Validierung
+        # log_msg("5. Validiere Value Domains...")
+        self.validate_value_domains()
+
+        # 6. Datentyp Validierung
+        # log_msg("6. Validiere Datentypen...")
+        self.validate_data_types()
+
+    def validate_primary_keys(self) -> bool:
+        """Validiert Primary Keys (Eindeutigkeit)."""
+        # log_msg("Validiere Primary Keys...")
+        b_success = True
+
+        # Fuer jede Tabelle
+        o_table_names = self._schema.get_table_names()
+
+        for v_table_name in o_table_names:
+            s_table_name = str(v_table_name)
+
+            o_table_def = self._schema.get_table_definition(s_table_name)
+            o_pk_columns = o_table_def.get_primary_key_columns()
+
+            if len(o_pk_columns) > 0:
+                # Container holen
+                o_container = self._instance.get_table(s_table_name)
+
+                # Temporaerer Index fuer PK-Pruefung
+                o_pk_values = {}
+
+                # Durch alle Zeilen iterieren
+                o_iterator = o_container.create_iterator()
+
+                while not o_iterator.is_empty():
+                    # PK-Wert(e) zusammenbauen
+                    s_pk_value = self._build_key_string(o_iterator, o_pk_columns)
+
+                    # Pruefen ob PK bereits existiert
+                    if s_pk_value in o_pk_values:
+                        self._add_validation_error(f"Primary Key Verletzung in Tabelle '{s_table_name}': "
+                                                 f"Doppelter Wert '{s_pk_value}' in Zeile {o_iterator.position()}")
+                        b_success = False
+                    else:
+                        o_pk_values[s_pk_value] = o_iterator.position()
+
+                    o_iterator.pp()
+
+        return b_success
+
+    def validate_not_null_constraints(self) -> bool:
+        """Validiert NOT NULL Constraints."""
+        # log_msg("Validiere NOT NULL Constraints...")
+        b_success = True
+
+        # Fuer jede Tabelle
+        o_table_names = self._schema.get_table_names()
+
+        for v_table_name in o_table_names:
+            s_table_name = str(v_table_name)
+
+            o_table_def = self._schema.get_table_definition(s_table_name)
+
+            # NOT NULL Spalten sammeln
+            o_not_null_columns: List[str] = []
+
+            for v_col_name in o_table_def.get_column_names():
+                o_col_def = o_table_def.get_column(str(v_col_name))
+
+                if o_col_def is None:
+                    log_and_raise(ValueError(f"Column '{v_col_name}' not found in table '{s_table_name}'"))
+
+                if not o_col_def.is_nullable():
+                    o_not_null_columns.append(str(v_col_name))
+
+            if len(o_not_null_columns) > 0:
+                # Container holen
+                o_container = self._instance.get_table(s_table_name)
+
+                # Durch alle Zeilen iterieren
+                o_iterator = o_container.create_iterator()
+
+                n_violations = 0
+
+                while not o_iterator.is_empty():
+                    # NOT NULL Spalten pruefen
+                    for v_col in o_not_null_columns:
+                        v_value = o_iterator.value(str(v_col))
+
+                        if v_value is None or str(v_value) == "":
+                            self._add_validation_error(f"NOT NULL Verletzung in Tabelle '{s_table_name}', "
+                                                     f"Spalte '{v_col}', Zeile {o_iterator.position()}")
+                            b_success = False
+                            n_violations += 1
+
+                    o_iterator.pp()
+
+                if n_violations == 0:
+                    pass
+
+        return b_success
+
+    def validate_unique_constraints(self) -> bool:
+        """Validiert Unique Constraints."""
+        # log_msg("Validiere Unique Constraints...")
+        b_success = True
+
+        # Fuer jede Tabelle
+        o_table_names = self._schema.get_table_names()
+
+        for v_table_name in o_table_names:
+            s_table_name = str(v_table_name)
+
+            o_table_def = self._schema.get_table_definition(s_table_name)
+            o_unique_constraints = o_table_def.get_unique_constraints()
+
+            if len(o_unique_constraints) > 0:
+                # Container holen
+                o_container = self._instance.get_table(s_table_name)
+
+                # Fuer jeden Unique Constraint
+                n_constraint_index = 1
+
+                for o_constraint in o_unique_constraints:
+                    o_unique_columns = o_constraint
+
+                    # Temporaerer Index fuer Unique-Pruefung
+                    o_unique_values = {}
+
+                    # Durch alle Zeilen iterieren
+                    o_iterator = o_container.create_iterator()
+
+                    while not o_iterator.is_empty():
+                        # Unique-Wert(e) zusammenbauen
+                        s_unique_value = self._build_key_string(o_iterator, o_unique_columns)
+
+                        # Nur pruefen wenn nicht alle Werte NULL sind
+                        if s_unique_value != "":
+                            # Pruefen ob Wert bereits existiert
+                            if s_unique_value in o_unique_values:
+                                self._add_validation_error(f"Unique Constraint #{n_constraint_index} verletzt in Tabelle "
+                                                         f"'{s_table_name}': Doppelter Wert '{s_unique_value}' "
+                                                         f"in Zeile {o_iterator.position()}")
+                                b_success = False
+                            else:
+                                o_unique_values[s_unique_value] = o_iterator.position()
+
+                        o_iterator.pp()
+
+                    n_constraint_index += 1
+
+        return b_success
+
+    def validate_foreign_keys(self) -> bool:
+        """Validiert Foreign Key Constraints."""
+        # log_msg("Validiere Foreign Keys...")
+        b_success = True
+
+        # Alle FK-Beziehungen durchgehen
+        o_relationships = self._schema.get_relationships()
+
+        for o_rel in o_relationships:
+            o_fk_rel = o_rel
+
+            # Container fuer Source und Target holen
+            o_source_container = self._instance.get_table(o_fk_rel.get_source_table())
+            o_target_container = self._instance.get_table(o_fk_rel.get_target_table())
+
+            # Alle Werte aus Target-Tabelle sammeln (fuer Performance)
+            o_target_values = {}
+
+            o_target_iterator = o_target_container.create_iterator()
+
+            while not o_target_iterator.is_empty():
+                s_target_value = o_target_iterator.value(o_fk_rel.get_target_column())
+
+                if not is_effectively_null(s_target_value):
+                    s_target_key = str(s_target_value)
+                    if s_target_key not in o_target_values:
+                        o_target_values[s_target_key] = True
+                else:
+                    pass
+
+                o_target_iterator.pp()
+
+            # Durch Source-Tabelle iterieren und FK pruefen
+            o_source_iterator = o_source_container.create_iterator()
+
+            n_violations = 0
+
+            while not o_source_iterator.is_empty():
+                v_source_value = o_source_iterator.value(o_fk_rel.get_source_column())
+
+                # NULL-Werte sind erlaubt fuer FK
+                if not is_effectively_null(v_source_value):
+                    s_source_key = str(v_source_value)
+
+                    # Pruefen ob Wert in Target existiert
+                    if s_source_key not in o_target_values:
+                        self._add_validation_error(f"Foreign Key Verletzung: '{o_fk_rel.get_description()}' - "
+                                                 f"Wert '{s_source_key}' existiert nicht in Zieltabelle, "
+                                                 f"Zeile {o_source_iterator.position()} in '{o_fk_rel.get_source_table()}'")
+                        b_success = False
+                        n_violations += 1
+
+                o_source_iterator.pp()
+
+            if n_violations > 0:
+                log_msg(f"FK '{o_fk_rel.get_description()}': Ungültige Referenzen gefunden.")
+
+        return b_success
+
+    def validate_value_domains(self) -> bool:
+        """Validiert Value Domains."""
+        # log_msg("Validiere Value Domains...")
+        b_success = True
+
+        # Fuer jede Tabelle
+        o_table_names = self._schema.get_table_names()
+
+        for v_table_name in o_table_names:
+            s_table_name = str(v_table_name)
+
+            o_table_def = self._schema.get_table_definition(s_table_name)
+
+            # Spalten mit Value Domain sammeln
+            o_value_domain_columns: List[str] = []
+
+            for v_col_name in o_table_def.get_column_names():
+                if o_table_def.has_value_domain(str(v_col_name)):
+                    o_value_domain_columns.append(str(v_col_name))
+
+            if len(o_value_domain_columns) > 0:
+                # Container holen
+                o_container = self._instance.get_table(s_table_name)
+
+                # Durch alle Zeilen iterieren
+                o_iterator = o_container.create_iterator()
+
+                while not o_iterator.is_empty():
+                    # Value Domain Spalten pruefen
+                    for v_col in o_value_domain_columns:
+                        v_value = o_iterator.value(str(v_col))
+
+                        # NULL ist erlaubt
+                        if v_value is not None and str(v_value) != "":
+                            # Erlaubte Werte holen
+                            o_allowed_values = o_table_def.get_value_domain(str(v_col))
+
+                            if o_allowed_values is None:
+                                log_and_raise(ValueError(f"Value domain for column '{v_col}' in table '{s_table_name}' not found"))
+
+                            # Pruefen ob Wert erlaubt ist
+                            if not self._is_value_in_collection(str(v_value), o_allowed_values):
+                                self._add_validation_error(f"Value Domain Verletzung in Tabelle '{s_table_name}', "
+                                                         f"Spalte '{v_col}': Wert '{v_value}' nicht erlaubt, "
+                                                         f"Zeile {o_iterator.position()}")
+                                b_success = False
+
+                    o_iterator.pp()
+
+        return b_success
+
+    def validate_data_types(self) -> bool:
+        """Validiert Datentypen (Stichproben)."""
+        # log_msg("Validiere Datentypen (Stichproben)...")
+        # Hier koennten Stichproben-Validierungen durchgefuehrt werden
+        # Fuer diese Version gehen wir davon aus, dass beim Import bereits geprueft wurde
+        return True
+
+    def _build_key_string(self, o_iterator: AbstractIterator, o_columns: List[str]) -> str:
+        """Hilfsfunktion zum Erstellen von Schluesseln."""
+        s_key = ""
+
+        for v_col in o_columns:
+            v_value = o_iterator.value(str(v_col))
+
+            if s_key != "":
+                s_key += "|"
+
+            if v_value is None:
+                s_key += "[NULL]"
+            else:
+                s_key += str(v_value)
+
+        return s_key
+
+    def _is_value_in_collection(self, s_value: str, o_collection: List[str]) -> bool:
+        """Hilfsfunktion zum Pruefen ob Wert in Collection enthalten ist."""
+        for v_item in o_collection:
+            if str(v_item) == s_value:
+                return True
+        return False
+
+    def _add_validation_error(self, s_message: str) -> None:
+        """Fuegt einen Validierungsfehler hinzu."""
+        self._result.add_error(s_message)
+
+    def _add_validation_warning(self, s_message: str) -> None:
+        """Fuegt eine Validierungswarnung hinzu."""
+        self._result.add_warning(s_message)

bpmn_lib/database/instance/database_index_builder.py

@@ -0,0 +1,112 @@
+"""
+DatabaseIndexBuilder - Erstellt Indizes nach erfolgreicher Validierung.
+"""
+
+from typing import List
+from basic_framework.proc_frame import log_msg
+from bpmn_lib.database.schema.database_schema import DatabaseSchema
+from bpmn_lib.database.instance.database_instance import DatabaseInstance
+
+
+class DatabaseIndexBuilder:
+    """Erstellt Indizes nach erfolgreicher Validierung."""
+
+    def __init__(self, instance: DatabaseInstance) -> None:
+        """
+        Initialisiert den IndexBuilder.
+
+        Args:
+            instance: DatabaseInstance mit den zu indizierenden Daten
+
+        Raises:
+            TypeError: Wenn instance None ist (Python's Typsystem)
+        """
+        self._schema: DatabaseSchema = instance.get_schema()
+        self._instance: DatabaseInstance = instance
+        self._index_count: int = 0
+
+    def build_all_indexes(self) -> None:
+        """Erstellt alle Indizes."""
+        # log_msg("IndexBuilder: Starte Index-Erstellung...")
+
+        self._index_count = 0
+
+        # Delegiere an DatabaseInstance
+        self._instance.create_indexes()
+
+        # log_msg("IndexBuilder: Index-Erstellung abgeschlossen.")
+
+    def verify_index_integrity(self) -> bool:
+        """Verifiziert die Integritaet der erstellten Indizes."""
+        log_msg("Verifiziere Index-Integritaet...")
+
+        b_success = True
+
+        # Pruefungen wuerden hier implementiert
+        # Fuer diese Version gehen wir davon aus, dass die Indizes korrekt sind
+
+        log_msg("Index-Integritaet verifiziert.")
+        return b_success
+
+    def get_index_statistics(self) -> str:
+        """Gibt Statistiken ueber die erstellten Indizes zurueck."""
+        s_stats = "INDEX-STATISTIKEN\n"
+        s_stats += "=================\n"
+
+        # Detaillierte Statistiken koennten hier gesammelt werden
+        s_stats += "Indizes wurden von DatabaseInstance erstellt.\n"
+
+        return s_stats
+
+    def generate_index_report(self) -> str:
+        """Erstellt einen Report ueber alle Indizes."""
+        s_report = "INDEX-REPORT\n"
+        s_report += "============\n\n"
+
+        # Fuer jede Tabelle Index-Informationen sammeln
+        o_table_names = self._schema.get_table_names()
+
+        for v_table_name in o_table_names:
+            s_report += f"Tabelle: {v_table_name}\n"
+
+            o_table_def = self._schema.get_table_definition(str(v_table_name))
+
+            # Primary Key
+            o_pk_columns = o_table_def.get_primary_key_columns()
+            if len(o_pk_columns) > 0:
+                s_report += f"  - Primary Key Index: {self._collection_to_string(o_pk_columns)}\n"
+
+            # Foreign Keys
+            o_fks = o_table_def.get_foreign_keys()
+            if len(o_fks) > 0:
+                for o_fk in o_fks:
+                    o_fk_rel = o_fk
+                    s_report += f"  - Foreign Key Index: {o_fk_rel.get_source_column()}\n"
+
+            # Unique Constraints
+            o_uniques = o_table_def.get_unique_constraints()
+            if len(o_uniques) > 0:
+                n_index = 1
+                for o_unique in o_uniques:
+                    o_col = o_unique
+                    s_report += f"  - Unique Index #{n_index}: {self._collection_to_string(o_col)}\n"
+                    n_index += 1
+
+            s_report += "\n"
+
+        return s_report
+
+    def _collection_to_string(self, o_col: List[str]) -> str:
+        """Hilfsfunktion: Collection zu String."""
+        s_result = "("
+
+        b_first = True
+
+        for v_item in o_col:
+            if not b_first:
+                s_result += ", "
+            s_result += str(v_item)
+            b_first = False
+
+        s_result += ")"
+        return s_result