Code & Queries

1. ORM-Grundlagen in SQL

Erstellung des konzeptionellen Modells

Das konzeptionelle Modell stellt die Entitäten (Objekte) und ihre Rollen dar. In SQL wird dies durch Tabellen und Beziehungen abgebildet. Beispiel:

-- Tabelle für Objekte
CREATE TABLE Person (
    PersonID INT PRIMARY KEY,
    Name VARCHAR(100)
);

-- Tabelle für Rollen
CREATE TABLE Role (
    RoleID INT PRIMARY KEY,
    RoleName VARCHAR(50)
);

-- Verbindung von Personen und Rollen
CREATE TABLE PersonRole (
    PersonID INT,
    RoleID INT,
    PRIMARY KEY (PersonID, RoleID),
    FOREIGN KEY (PersonID) REFERENCES Person(PersonID),
    FOREIGN KEY (RoleID) REFERENCES Role(RoleID)
);

In diesem Beispiel repräsentiert Person das Objekt, Role die Rollen, und PersonRole modelliert die Beziehung zwischen beiden.

2. Datenverarbeitung mit DuckDB

DuckDB, eine leichte OLAP-Datenbank, kann für Analysen und schnelle Abfragen auf relationalen Modellen genutzt werden.

Datenimport

DuckDB kann direkt Parquet-, CSV- oder JSON-Dateien verarbeiten. Beispielsweise können Sie Ihre ORM-Daten direkt laden:

import duckdb

# Verbindung zur DuckDB herstellen
con = duckdb.connect('orm_example.db')

# Daten aus einer CSV-Datei laden
con.execute("""
CREATE TABLE Person AS 
SELECT * FROM 'path/to/person.csv'
""")

con.execute("""
CREATE TABLE Role AS 
SELECT * FROM 'path/to/role.csv'
""")

con.execute("""
CREATE TABLE PersonRole AS 
SELECT * FROM 'path/to/person_role.csv'
""")

Abfrage der Rollen von Personen

SELECT p.Name, r.RoleName
FROM PersonRole pr
JOIN Person p ON pr.PersonID = p.PersonID
JOIN Role r ON pr.RoleID = r.RoleID;

3. Dynamische Abfragen und ORM-Logik mit Python

Python eignet sich hervorragend für dynamische Datenmodellierung und ORM-ähnliche Funktionalität, z. B. durch Bibliotheken wie SQLAlchemy. Für eine leichtere Implementierung mit DuckDB können Sie jedoch eine eigene ORM-Schicht bauen.

Beispiel: ORM mit DuckDB in Python

class ORM:
    def __init__(self, db_path):
        self.con = duckdb.connect(db_path)

    def add_person(self, person_id, name):
        self.con.execute("INSERT INTO Person (PersonID, Name) VALUES (?, ?)", [person_id, name])

    def add_role(self, role_id, role_name):
        self.con.execute("INSERT INTO Role (RoleID, RoleName) VALUES (?, ?)", [role_id, role_name])

    def assign_role(self, person_id, role_id):
        self.con.execute("INSERT INTO PersonRole (PersonID, RoleID) VALUES (?, ?)", [person_id, role_id])

    def get_person_roles(self, person_id):
        return self.con.execute("""
            SELECT r.RoleName 
            FROM PersonRole pr
            JOIN Role r ON pr.RoleID = r.RoleID
            WHERE pr.PersonID = ?
        """, [person_id]).fetchall()

# Beispielnutzung
orm = ORM('orm_example.db')
orm.add_person(1, 'Max Muster')
orm.add_role(1, 'Data Scientist')
orm.assign_role(1, 1)
print(orm.get_person_roles(1))

4. Vorteile der Kombination von SQL, DuckDB und Python

• SQL bietet eine bewährte Grundlage für das relationale Modell.
• DuckDB ermöglicht schnelle Analysen und direkten Zugriff auf Parquet-, CSV- und JSON-Daten.
• Python ermöglicht dynamische Abfragen und bietet Flexibilität für komplexere Geschäftslogik.
• Mit der ORM-Struktur können Sie semantisch konsistente Modelle erstellen und einfach auf die Daten zugreifen.

5. Erweiterung

• Datenqualität: Validieren Sie die Objekt-Rollen-Zuordnung mithilfe von Constraints in SQL und Python.
• Machine Learning: Nutzen Sie die Daten in DuckDB direkt als Grundlage für ML-Modelle in Python.
• Datenvisualisierung: Verwenden Sie Python-Bibliotheken wie Plotly oder Dash, um ORM-Daten zu visualisieren.

Dieses Setup ist leichtgewichtig, performant und ideal für prototypische oder produktive Anwendungen geeignet!