Python MariaDB Tutorial: Verbinden, CRUD, Transaktionen und Fehlerbehandlung

1. Einführung

Für diejenigen, die mit MariaDB in Python arbeiten möchten

Viele Menschen möchten sich mit Python mit MariaDB verbinden und Daten manipulieren. In diesem Artikel erklären wir alles von den Grundlagen bis zu fortgeschritteneren Themen für die Arbeit mit MariaDB unter Python.

Haben Sie eines dieser Probleme?

• Sie wissen nicht, wie Sie sich von Python aus mit MariaDB verbinden
• Sie möchten Daten in MariaDB mit Python einfach erstellen, lesen, aktualisieren und löschen
• Sie möchten gängige Fehler kennenlernen und wissen, wie man sie behebt

Was Sie in diesem Artikel lernen werden

• Wie Sie sich einfach von Python aus mit MariaDB verbinden
• Wie Sie CRUD (Create, Read, Update, Delete) implementieren
• Häufige Fehler und deren Lösungen
• Wie Sie die Datenintegrität mit Transaktionen schützen

Nach dem Lesen dieses Artikels können Sie reibungslos mit MariaDB unter Python arbeiten. Jetzt tauchen wir in die Details ein.

2. Umgebung einrichten (Installation von MariaDB & Python)

Was ist MariaDB?

MariaDB ist ein Open‑Source‑relationales Datenbankmanagementsystem (RDBMS), das weit verbreitet als Nachfolger von MySQL eingesetzt wird. Während es eine hohe Kompatibilität zu MySQL beibehält, bietet MariaDB verbesserte Leistung und neue Funktionen.

Erforderliche Werkzeuge

Um mit MariaDB in Python zu arbeiten, müssen Sie die folgenden Werkzeuge vorbereiten:

• Python (Version 3.x oder neuer empfohlen)
• MariaDB (Server)
• MariaDB Python‑Connector (die mariadb‑Bibliothek)

Wie man MariaDB installiert (nach Betriebssystem)

Für Windows

1. Laden Sie den MariaDB‑Installer von der offiziellen Website herunter.
2. Führen Sie den Installer aus und folgen Sie den Anweisungen, um die Installation abzuschließen.
3. Nach der Installation prüfen Sie, ob MariaDB funktioniert, indem Sie den folgenden Befehl ausführen:

   mysql -u root -p
   

4. Wenn Sie sich erfolgreich anmelden können, ist die Installation abgeschlossen.

Für Mac

Unter macOS können Sie MariaDB einfach mit Homebrew installieren.

1. Falls Homebrew nicht installiert ist, installieren Sie es mit dem folgenden Befehl:

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
   

2. Installieren Sie MariaDB:

   brew install mariadb
   

3. Starten Sie MariaDB:

   brew services start mariadb
   

4. Überprüfen Sie die Installation:

   mysql -u root -p
   

Für Linux (Ubuntu)

1. Aktualisieren Sie die Paketliste und installieren Sie MariaDB:

   sudo apt update
   sudo apt install mariadb-server mariadb-client
   

2. Starten Sie MariaDB:

   sudo systemctl start mariadb
   

3. Aktivieren Sie MariaDB (automatischer Start beim Booten):

   sudo systemctl enable mariadb
   

4. Führen Sie das Skript für die sichere Installation aus:

   sudo mysql_secure_installation
   

Damit können Sie das Root‑Passwort festlegen und unnötige Standardeinstellungen entfernen.

Installation von Python und der erforderlichen Bibliothek

Um MariaDB mit Python zu integrieren, müssen Sie die Bibliothek mariadb installieren.

1. Installieren Sie die Bibliothek mariadb mit pip:

   pip install mariadb
   

2. Überprüfen Sie die Installation:

   import mariadb
   print("The MariaDB library was installed successfully.")
   

Wenn kein Fehler auftritt, war die Installation erfolgreich.

Jetzt ist Ihre Umgebung für die Nutzung von Python mit MariaDB eingerichtet. Als Nächstes erklären wir, wie Sie sich von Python aus mit MariaDB verbinden.

3. Verbindung zu MariaDB herstellen

Wie man sich mit Python zu MariaDB verbindet

Importieren der erforderlichen Bibliothek

Um sich mit MariaDB zu verbinden, importieren Sie die Python‑Bibliothek mariadb.

import mariadb

Grundlegender Code zum Verbinden mit der Datenbank

Der folgende Code zeigt die grundlegende Methode, um sich mit MariaDB über Python zu verbinden.

import mariadb

# Database connection settings
config = {
    "host": "localhost",   # Hostname of the MariaDB server
    "user": "root",        # MariaDB username
    "password": "password", # MariaDB password
    "database": "sample_db" # Database name to connect to
}

try:
    # Connect to MariaDB
    conn = mariadb.connect(**config)
    print("Connected to MariaDB!")

    # Einen Cursor erstellen
    cursor = conn.cursor()

    # Wenn die Verbindung erfolgreich ist, schließen Sie sie
    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Verbindungsfehler: {e}")

About the arguments of connect()

If the server is remote, specify an IP address or domain name in host.

A secure connection method using environment variables

Hardcoding sensitive information such as passwords directly in your code is a security risk. By using environment variables, you can manage them more safely.

Install python-dotenv

First, install a library to manage environment variables.

pip install python-dotenv

Create a .env file and write your connection settings

Create a .env file in your project folder and add your connection settings like this:

DB_HOST=localhost
DB_USER=root
DB_PASSWORD=password
DB_NAME=sample_db

Load environment variables in your Python script

To load the .env file in a Python script, write the following:

import mariadb
import os
from dotenv import load_dotenv

# Die .env-Datei laden
load_dotenv()

config = {
    "host": os.getenv("DB_HOST"),
    "user": os.getenv("DB_USER"),
    "password": os.getenv("DB_PASSWORD"),
    "database": os.getenv("DB_NAME")
}

try:
    conn = mariadb.connect(**config)
    print("Sicher mit MariaDB verbunden!")
    conn.close()
except mariadb.Error as e:
    print(f"Verbindungsfehler: {e}")

Common connection errors and how to fix them

Below are some errors you may encounter when connecting Python to MariaDB, along with their solutions.

Access denied for user 'root'@'localhost'

Error message

mariadb.OperationalError: Access denied for user 'root'@'localhost' (using password: YES)

Causes

• The user’s credentials are incorrect
• MariaDB authentication settings are not configured properly

Solutions

1. Log in to MariaDB and check the user’s privileges.

   mysql -u root -p
   

2. Grant the required privileges to the user.

   GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
   FLUSH PRIVILEGES;
   

3. Try connecting again.

Can't connect to MySQL server on 'localhost'

Error message

mariadb.OperationalError: Can't connect to MySQL server on 'localhost' (10061)

Causes

• The MariaDB server is not running
• The host setting is incorrect

Solutions

1. Check whether the server is running.

   sudo systemctl status mariadb
   

2. If the server is stopped, start it.

   sudo systemctl start mariadb
   

3. Check that the host setting is correct.

Summary

In this section, we explained how to connect to MariaDB from Python.

• Basic connection method using mariadb.connect()
• A secure connection method using a .env file
• Common connection errors and how to fix them

4. Creating Databases and Tables

Creating a database

In MariaDB, you need to create a database to store data. Let’s look at how to create a database using Python.

Create a database using a MariaDB management tool

You can create a database using the MariaDB command line (or GUI tools such as MySQL Workbench).

CREATE DATABASE sample_db;

To view the list of databases you created, use the following command:

SHOW DATABASES;

Create a database using Python

To create a database using Python, run the following code:

import mariadb

# Datenbankverbindung (keine Datenbank angegeben)
config = {
    "host": "localhost",
    "user": "root",
    "password": "password"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Die Datenbank erstellen
    cursor.execute("CREATE DATABASE IF NOT EXISTS sample_db")

    print("Datenbank 'sample_db' erstellt.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Fehler aufgetreten: {e}")

By adding IF NOT EXISTS, you can prevent errors if a database with the same name already exists.

Creating a table

After creating the database, the next step is to create a table to store data.

Basic table structure

A table typically has a structure like the following:

Create a table with SQL

If you create a table using MariaDB SQL commands, write the following:

USE sample_db;

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

To view the list of tables, run:

SHOW TABLES;

Create a table using Python

Here is how to create the same table using a Python script.

import mariadb

# Datenbankverbindung
config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # SQL zur Tabellenerstellung
    table_creation_query = """
    CREATE TABLE IF NOT EXISTS users (
        id INT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(100) NOT NULL,
        email VARCHAR(100) UNIQUE NOT NULL,
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
    )
    """

    cursor.execute(table_creation_query)
    print("Tabelle 'users' erstellt.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Fehler aufgetreten: {e}")

By adding IF NOT EXISTS, you can prevent errors if the table already exists.

How to choose data types

When designing tables, it is important to choose appropriate data types. Below is a summary of commonly used data types in MariaDB.

For example, it is common to use VARCHAR(100) for the name field, but if you need a longer string, TEXT can be a good option.

How to check and drop existing tables

Check existing tables

To check the tables in a database, use the following SQL:

SHOW TABLES;

To view a table’s detailed structure, run the DESCRIBE command:

DESCRIBE users;

Drop a table

To drop a table, use DROP TABLE:

DROP TABLE users;

To drop a table from Python, run the following code:

cursor.execute("DROP TABLE IF EXISTS users")

Summary

In this section, we explained how to create databases and tables in MariaDB to store data.

• How to create a database in MariaDB
• How to create a table using Python
• How to choose appropriate data types
• How to check and drop existing tables

Now the basic setup for MariaDB is complete. In the next section, we will explain CRUD operations (Create, Read, Update, Delete) in detail.

5. CRUD Operations (Create, Read, Update, Delete)

After creating the MariaDB database and tables, the next step is to perform CRUD operations. CRUD stands for Create, Read, Update, and Delete, which are the basic operations of a database.

In this section, we will explain how to manipulate MariaDB data using Python.

Inserting data (INSERT)

To add a new record to the database, use the INSERT statement.

Insert data using SQL

To insert data using MariaDB SQL, execute the following command:

INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com');

To verify the inserted data, use the SELECT statement:

SELECT * FROM users;

Insert data using Python

To insert data using Python, run the following code:

import mariadb

# Einstellungen für die Datenbankverbindung
config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Daten einfügen
    insert_query = "INSERT INTO users (name, email) VALUES (?, ?)"
    data = ("Alice", "alice@example.com")
    cursor.execute(insert_query, data)

    # Änderungen speichern
    conn.commit()
    print("Daten erfolgreich eingefügt!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Fehler aufgetreten: {e}")

Key points:

• Using ? placeholders helps prevent SQL injection.
• If you do not execute conn.commit() , the data will not be saved to the database.

Retrieving data (SELECT)

To retrieve registered data, use the SELECT statement.

Retrieve data using SQL

To retrieve data using MariaDB SQL:

SELECT * FROM users;

To retrieve data with conditions, use the WHERE clause:

SELECT * FROM users WHERE email = 'alice@example.com';

Retrieve data using Python

To retrieve data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Daten abrufen
    select_query = "SELECT id, name, email FROM users"
    cursor.execute(select_query)

    # Abgerufene Daten anzeigen
    for (id, name, email) in cursor:
        print(f"ID: {id}, Name: {name}, Email: {email}")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Fehler aufgetreten: {e}")

Key points:

• Execute SQL with cursor.execute(select_query) and retrieve data from the cursor object.
• You can process records one by one using a for loop.

Updating data (UPDATE)

To modify registered data, use the UPDATE statement.

Update data using SQL

To update data using MariaDB SQL, execute:

UPDATE users SET name = 'Alice Smith' WHERE email = 'alice@example.com';

Update data using Python

To update data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Daten aktualisieren
    update_query = "UPDATE users SET name = ? WHERE email = ?"
    data = ("Alice Smith", "alice@example.com")
    cursor.execute(update_query, data)

    # Änderungen speichern
    conn.commit()
    print("Daten erfolgreich aktualisiert!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Fehler aufgetreten: {e}")

Deleting data (DELETE)

To remove unnecessary data, use the DELETE statement.

Delete data using SQL

To delete data using MariaDB SQL, execute:

DELETE FROM users WHERE email = 'alice@example.com';

Delete data using Python

To delete data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Daten löschen
    delete_query = "DELETE FROM users WHERE email = ?"
    data = ("alice@example.com",)
    cursor.execute(delete_query, data)

    # Änderungen speichern
    conn.commit()
    print("Daten erfolgreich gelöscht!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Fehler aufgetreten: {e}")

Summary

In this section, we explained how to manipulate MariaDB data using Python.

• Insert data (INSERT)
• Retrieve data (SELECT)
• Update data (UPDATE)
• Delete data (DELETE)

You can now perform basic data operations in MariaDB using Python.

6. Transactions and Rollback (Ensuring Data Integrity)

Beim Arbeiten mit einer Datenbank ist es wichtig, Transaktionen zu verwenden, um Datenintegrität zu gewährleisten.
Insbesondere die Fähigkeit, Daten bei einem Fehler während der Verarbeitung in ihren ursprünglichen Zustand zurückzusetzen (Rollback), ist entscheidend für die Aufrechterhaltung der Konsistenz.

In diesem Abschnitt erklären wir, wie man Transaktionen in MariaDB mit Python verwaltet.

Was ist eine Transaktion?

Eine Transaktion ist ein Mechanismus, der eine Reihe von Datenbankoperationen zu einer einzigen Einheit zusammenfasst, alle Änderungen committet, wenn jeder Prozess erfolgreich ist, und alle Änderungen zurücksetzt, wenn ein Fehler auftritt.

Eigenschaften von Transaktionen

• ACID-Eigenschaften
• Atomarität : Alle Vorgänge werden entweder vollständig erfolgreich abgeschlossen oder keiner wird angewendet.
• Konsistenz : Die Datenintegrität wird gewährleistet.
• Isolation : Gleichzeitige Transaktionen beeinflussen sich nicht gegenseitig.
• Dauerhaftigkeit : Sobald sie committet sind, werden Änderungen dauerhaft gespeichert.

Grundlegende Transaktionsoperationen (COMMIT und ROLLBACK)

MariaDB‑Transaktionen können mit den folgenden Befehlen gesteuert werden:

Verwendung von Transaktionen in Python

Im Folgenden finden Sie ein einfaches Beispiel zur Verwaltung von MariaDB‑Transaktionen mit Python.

Verwaltung mehrerer Operationen innerhalb einer einzigen Transaktion

Der folgende Code behandelt mehrere Einfüge‑Operationen als eine Transaktion und committet nur, wenn alle Operationen erfolgreich sind.

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Start transaction
    conn.start_transaction()

    # Insert data
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Bob", "bob@example.com"))
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Charlie", "charlie@example.com"))

    # Commit if all operations succeed
    conn.commit()
    print("Data added successfully.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Error occurred: {e}")
    conn.rollback()  # Roll back if an error occurs

Wichtige Punkte

• Verwenden Sie conn.start_transaction(), um eine Transaktion zu starten.
• Verwenden Sie conn.commit(), um Änderungen abzuschließen (nach dem Commit kann es nicht rückgängig gemacht werden).
• Wenn ein Fehler auftritt, verwenden Sie conn.rollback(), um Änderungen zu annullieren und den ursprünglichen Zustand wiederherzustellen.

Transaktionsbasierte Fehlerbehandlung

Fehler können bei Datenbankoperationen auftreten.
Zum Beispiel kann eine doppelte E‑Mail‑Adresse (Verstoß gegen die UNIQUE‑Einschränkung) oder ein Server‑Timeout auftreten.

Transaktionsverwaltung mit Fehlerbehandlung

Der folgende Code fügt Logik hinzu, um Änderungen zurückzusetzen und den ursprünglichen Zustand wiederherzustellen, wenn während der Verarbeitung ein Fehler auftritt.

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Start transaction
    conn.start_transaction()

    try:
        # First insert succeeds
        cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Dave", "dave@example.com"))

        # Second insert causes an error (duplicate email)
        cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Eve", "dave@example.com"))

        # Commit if all operations succeed
        conn.commit()
        print("Data inserted successfully.")

    except mariadb.Error as e:
        print(f"Error occurred during data processing: {e}")
        conn.rollback()  # Roll back on error
        print("Transaction rolled back.")

    cursor.close()
    conn.close()

except mariadb.Error as e:
    print(f"Database connection error: {e}")

Zusammenfassung

In diesem Abschnitt haben wir die Grundlagen von Transaktionen und deren Implementierung in Python erklärt.

• Die Bedeutung von Transaktionen und ACID‑Eigenschaften
• Wie man commit() und rollback() in Python verwendet
• Transaktionsverwaltung kombiniert mit Fehlerbehandlung

7. Fehlerbehandlung (häufige Fehler und Lösungen)

Beim Arbeiten mit MariaDB in Python können Fehler auftreten.
Insbesondere Datenbankverbindungsfehler, SQL‑Syntaxfehler und Datenintegritätsfehler sind häufig, daher ist es wichtig, ihre Ursachen und Lösungen zu verstehen.

In diesem Abschnitt stellen wir die Ursachen häufiger Fehler und deren Behebung vor.

Access denied for user (Authentifizierungsfehler)

Fehlermeldung

mariadb.OperationalError: Access denied for user 'root'@'localhost' (using password: YES)

Ursache

• Der Benutzername oder das Passwort ist falsch
• Der MariaDB‑Benutzer hat nicht die entsprechenden Rechte

Lösung

1. Melden Sie sich bei MariaDB an und prüfen Sie die Benutzerrechte

   mysql -u root -p
   

2. Gewähren Sie dem Benutzer die erforderlichen Rechte

   GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
   FLUSH PRIVILEGES;
   

3. Starten Sie MariaDB neu

   sudo systemctl restart mariadb
   

Can't connect to MySQL server on 'localhost' (Verbindungsfehler)

Fehlermeldung

mariadb.OperationalError: Can't connect to MySQL server on 'localhost' (10061)

Ursache

• Der MariaDB‑Server läuft nicht
• Die Einstellung host ist falsch

Lösung

1. Überprüfen Sie, ob der MariaDB‑Server läuft

   sudo systemctl status mariadb
   

2. Falls der Server gestoppt ist, starten Sie ihn

   sudo systemctl start mariadb
   

3. Stellen Sie sicher, dass der Server automatisch startet

   sudo systemctl enable mariadb
   

Unknown database 'sample_db' (Datenbank existiert nicht)

Fehlermeldung

mariadb.ProgrammingError: Unknown database 'sample_db'

Ursache

• Die angegebene Datenbank existiert nicht
• Im Datenbanknamen ist ein Tippfehler

Lösung

1. Überprüfen Sie die Liste der Datenbanken

   SHOW DATABASES;
   

2. Erstellen Sie die Datenbank, falls sie nicht existiert

   CREATE DATABASE sample_db;
   

Table doesn't exist (Tabelle existiert nicht)

Fehlermeldung

mariadb.ProgrammingError: Table 'sample_db.users' doesn't exist

Ursache

• Die angegebene Tabelle existiert nicht
• Die Datenbank wurde nicht mit USE sample_db; ausgewählt

Lösung

1. Überprüfen Sie die Liste der Tabellen

   SHOW TABLES;
   

2. Erstellen Sie die Tabelle, falls sie nicht existiert

   CREATE TABLE users (
       id INT AUTO_INCREMENT PRIMARY KEY,
       name VARCHAR(100) NOT NULL,
       email VARCHAR(100) UNIQUE NOT NULL,
       created_at DATETIME DEFAULT CURRENT_TIMESTAMP
   );
   

Duplicate entry (Duplikat-Datenfehler)

Fehlermeldung

mariadb.IntegrityError: Duplicate entry 'alice@example.com' for key 'users.email'

Ursache

• Die Spalte email hat eine UNIQUE‑Einschränkung, sodass doppelte Werte nicht eingefügt werden können

Lösung

• Prüfen Sie auf Duplikate, bevor Sie Daten einfügen
• Verwenden Sie ON DUPLICATE KEY UPDATE

Python‑Code zur Vermeidung von Duplikaten

try:
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))
    conn.commit()
except mariadb.IntegrityError:
    print("Error: The email address already exists.")

Oder verwenden Sie ON DUPLICATE KEY UPDATE

INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
ON DUPLICATE KEY UPDATE name = 'Alice Updated';

Incorrect number of bindings (Parameteranzahl stimmt nicht überein)

Fehlermeldung

mariadb.ProgrammingError: Incorrect number of bindings supplied. The current statement uses 2, and there are 1 supplied.

Ursache

• Die Anzahl der vom SQL‑Statement benötigten Parameter stimmt nicht mit der Anzahl der übergebenen Argumente überein

Lösung

• Stellen Sie sicher, dass die Anzahl der Platzhalter mit der Anzahl der Parameter übereinstimmt

Fehlerhafter Code

cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice"))

Korrekter Code

cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))

Zusammenfassung

In diesem Abschnitt haben wir häufige Fehler erklärt, die bei der Arbeit mit MariaDB in Python auftreten, und wie man sie behebt.

• Access denied for user (Authentifizierungsfehler)
• Can't connect to MySQL server (Verbindungsfehler)
• Unknown database (Datenbank existiert nicht)
• Table doesn't exist (Tabelle existiert nicht)
• Duplicate entry (Duplikat-Datenfehler)
• Incorrect number of bindings (Parameteranzahl stimmt nicht überein)

8. Fazit

In diesem Artikel haben wir erklärt, wie man mit MariaDB unter Verwendung von Python arbeitet, von grundlegenden Konzepten bis zu fortgeschritteneren Themen. Durch das Verständnis grundlegender Datenbankoperationen und die korrekte Implementierung von Fehlerbehandlung und Transaktionsmanagement können Sie sicherere und effizientere Datenoperationen durchführen.

Artikel‑Zusammenfassung

Umgebung einrichten

• Wie man MariaDB installiert (Windows / Mac / Linux)
• Wie man die MariaDB‑Connector‑Bibliothek (mariadb) für Python installiert

Verbindung zu MariaDB herstellen

• Grundlegende Methoden zur Datenbankverbindung
• Sichere Verbindungen mittels Umgebungsvariablen
• Lösungen für häufige Verbindungsfehler

Datenbanken und Tabellen erstellen

• Datenbanken erstellen (SQL / Python)
• Tabellen erstellen und Datentypen auswählen
• Vorhandene Tabellen prüfen und löschen

CRUD‑Operationen (Create, Read, Update, Delete)

• Grundlegende Datenoperationen mit Python
• Platzhalter verwenden, um SQL‑Injection zu verhindern
• Korrekte Fehlerbehandlung

Transaktionen und Rollback

• Die Bedeutung von Transaktionen (ACID‑Eigenschaften)
• Wie man Daten bei einem Fehler wiederherstellt (Rollback)
• Transaktionen manuell verwalten, indem AutoCommit deaktiviert wird

Fehlerbehandlung (Häufige Fehler und Lösungen)

• Authentifizierungsfehler (Access denied for user)
• Verbindungsfehler (Can't connect to MySQL server)
• Fehler, wenn Datenbank oder Tabelle nicht gefunden wird
• Duplikat‑Datenfehler (Duplicate entry)
• Umgang mit Deadlocks und Implementierung von Wiederholungslogik

Wichtige Punkte bei der Kombination von Python und MariaDB

1. Platzhalter verwenden

   cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))
   

→ Bindungsvariablen verwenden, anstatt sie direkt in SQL‑Anweisungen einzubetten, um SQL‑Injection zu verhindern.

2. Transaktionen richtig verwalten

• Verwenden Sie conn.commit(), um Änderungen explizit zu committen .
• Verwenden Sie conn.rollback() bei einem Fehler, um die Datenintegrität zu wahren .

3. Umfassende Fehlerbehandlung implementieren

• Verwenden Sie try-except‑Blöcke, um potenzielle Fehler im Voraus abzufangen .
• Bereiten Sie spezifische Handhabungsstrategien für Fehler wie OperationalError und IntegrityError vor.

4. Performance berücksichtigen

• Massen‑Einfügungen (mehrere Datensätze auf einmal einfügen)
• Richtige Indizierung (Suchperformance verbessern)

Ressourcen für weiterführendes Lernen

Wenn Sie Ihr Verständnis der Integration von Python und MariaDB vertiefen möchten, berücksichtigen Sie die folgenden Ressourcen:

Offizielle Dokumentation

• MariaDB Official Documentation

Verwandte Lerninhalte

• SQL Basics (W3Schools)
• Database Operations with Python (Real Python)

Empfohlene Bücher

• SQL, 2nd Edition: Database Operations from Scratch – Erlernen Sie die SQL‑Grundlagen gründlich
• Effective Python: 90 Specific Ways to Improve Your Python Programs – Lernen Sie bewährte Python‑Praktiken

Zusammenfassung

Durch die Integration von MariaDB mit Python können Sie skriptbasierte Datenverwaltung und Automatisierung ermöglichen. Durch die Implementierung nicht nur grundlegender CRUD‑Operationen, sondern auch einer korrekten Fehlerbehandlung und Transaktionsverwaltung, können Sie ein sichereres und effizienteres System aufbauen.

Als nächster Schritt sollten Sie sich mit effizienter Datenverwaltung und API-Integration beschäftigen, um Ihr Wissen auf praktische Datenbankoperationen anzuwenden.