Python MariaDB tutoriál: Připojení, CRUD, transakce a zpracování chyb

1. Úvod

Pro ty, kteří chtějí pracovat s MariaDB v Pythonu

Mnoho lidí chce připojit se k MariaDB pomocí Pythonu a manipulovat s daty. V tomto článku vysvětlíme vše od základů po pokročilejší témata pro práci s MariaDB v Pythonu.

Máte některý z těchto problémů?

• Nevíte, jak se připojit k MariaDB z Pythonu
• Chcete snadno vytvářet, číst, aktualizovat a mazat data v MariaDB pomocí Pythonu
• Chcete se seznámit s běžnými chybami a jak je opravit

Co se v tomto článku naučíte

• Jak snadno připojit se k MariaDB z Pythonu
• Jak implementovat CRUD (Create, Read, Update, Delete)
• Běžné chyby a jejich řešení
• Jak chránit integritu dat pomocí transakcí

Po přečtení tohoto článku budete schopni plynule pracovat s MariaDB pomocí Pythonu. Pojďme se tedy ponořit do detailů.

2. Nastavení prostředí (Instalace MariaDB a Pythonu)

Co je MariaDB?

MariaDB je open-source relační systém pro správu databází (RDBMS), který je široce používán jako nástupce MySQL. Přičemž si zachovává vysokou kompatibilitu s MySQL, MariaDB nabízí lepší výkon a přidává nové funkce.

Požadované nástroje

Pro práci s MariaDB v Pythonu musíte připravit následující nástroje:

• Python (verze 3.x nebo novější, doporučeno)
• MariaDB (server)
• MariaDB Python connector (knihovna mariadb)

Jak nainstalovat MariaDB (podle OS)

Pro Windows

1. Stáhněte si instalátor MariaDB z oficiálních stránek .
2. Spusťte instalátor a postupujte podle pokynů k dokončení instalace.
3. Po instalaci ověřte, že MariaDB funguje, spuštěním následujícího příkazu:

   mysql -u root -p
   

4. Pokud se můžete úspěšně přihlásit, instalace je dokončena.

Pro Mac

Na Macu můžete snadno nainstalovat MariaDB pomocí Homebrew.

1. Pokud není Homebrew nainstalován, nainstalujte jej následujícím příkazem:

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

2. Nainstalujte MariaDB:

   brew install mariadb
   

3. Spusťte MariaDB:

   brew services start mariadb
   

4. Ověřte instalaci:

   mysql -u root -p
   

Pro Linux (Ubuntu)

1. Aktualizujte seznam balíčků a nainstalujte MariaDB:

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

2. Spusťte MariaDB:

   sudo systemctl start mariadb
   

3. Povolení MariaDB (automatické spouštění při startu systému):

   sudo systemctl enable mariadb
   

4. Spusťte skript pro zabezpečenou instalaci:

   sudo mysql_secure_installation
   

Tím můžete nastavit heslo pro uživatele root a odstranit zbytečná výchozí nastavení.

Instalace Pythonu a požadované knihovny

Pro integraci MariaDB s Pythonem musíte nainstalovat knihovnu mariadb.

1. Nainstalujte knihovnu mariadb pomocí pip :

   pip install mariadb
   

2. Ověřte instalaci:

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

Pokud nedojde k žádné chybě, instalace byla úspěšná.

Nyní je nastavení vašeho prostředí pro používání Pythonu s MariaDB dokončeno. Dále vysvětlíme, jak se připojit k MariaDB z Pythonu.

3. Připojení k MariaDB

Jak se připojit k MariaDB pomocí Pythonu

Import požadované knihovny

Pro připojení k MariaDB importujte Python knihovnu mariadb.

import mariadb

Základní kód pro připojení k databázi

Následující kód ukazuje základní způsob, jak se připojit k MariaDB pomocí Pythonu.

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!")

    # Vytvořte kurzor
    cursor = conn.cursor()

    # Pokud se připojení podaří, zavřete jej
    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Connection error: {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

# Načtěte soubor .env
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("Connected securely to MariaDB!")
    conn.close()
except mariadb.Error as e:
    print(f"Connection error: {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

# Připojení k databázi (nebyla specifikována databáze)
config = {
    "host": "localhost",
    "user": "root",
    "password": "password"
}

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

    # Vytvořte databázi
    cursor.execute("CREATE DATABASE IF NOT EXISTS sample_db")

    print("Created database 'sample_db'.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Došlo k chybě: {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

# Připojení k databázi
config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

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

    # Vytvoření tabulky SQL
    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("Tabulka 'users' byla vytvořena.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Došlo k chybě: {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

# Nastavení připojení k databázi
config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

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

    # Vložení dat
    insert_query = "INSERT INTO users (name, email) VALUES (?, ?)"
    data = ("Alice", "alice@example.com")
    cursor.execute(insert_query, data)

    # Uložení změn
    conn.commit()
    print("Data úspěšně vložena!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Došlo k chybě: {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()

    # Načtení dat
    select_query = "SELECT id, name, email FROM users"
    cursor.execute(select_query)

    # Zobrazení načtených dat
    for (id, name, email) in cursor:
        print(f"ID: {id}, Jméno: {name}, E-mail: {email}")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Došlo k chybě: {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()

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

    # Uložení změn
    conn.commit()
    print("Data úspěšně aktualizována!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Došlo k chybě: {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()

    # Odstranění dat
    delete_query = "DELETE FROM users WHERE email = ?"
    data = ("alice@example.com",)
    cursor.execute(delete_query, data)

    # Uložení změn
    conn.commit()
    print("Data úspěšně odstraněna!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Došlo k chybě: {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)

When working with a database, it is important to use transactions to maintain data integrity.
In particular, the ability to restore data to its original state (rollback) when an error occurs during processing is essential for maintaining consistency.

In this section, we will explain how to manage transactions in MariaDB using Python.

What is a transaction?

A transaction is a mechanism that groups a series of database operations into a single unit, commits all changes if every process succeeds, and rolls back all changes if an error occurs.

Characteristics of transactions

• Vlastnosti ACID
• Atomickost : All operations either complete successfully or none are applied.
• Konzistence : Data integrity is maintained.
• Izolace : Concurrent transactions do not interfere with each other.
• Trvalost : Once committed, changes are permanently saved.

Basic transaction operations (COMMIT and ROLLBACK)

MariaDB transactions can be controlled with the following commands:

Using transactions in Python

Below is a basic example of managing MariaDB transactions using Python.

Managing multiple operations within a single transaction

The following code treats multiple insert operations as one transaction and commits only if all operations succeed.

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

Key points

• Use conn.start_transaction() to begin a transaction.
• Use conn.commit() to finalize changes (cannot be undone after commit).
• If an error occurs, use conn.rollback() to cancel changes and restore the original state.

Transaction-based error handling

Errors may occur during database operations.
For example, a duplicate email address (UNIQUE constraint violation) or a server timeout may happen.

Transaction management with error handling

The following code adds logic to roll back changes and restore the original state if an error occurs during processing.

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}")

Summary

In this section, we explained the basics of transactions and how to implement them in Python.

• The importance of transactions and ACID properties
• How to use commit() and rollback() in Python
• Transaction management combined with error handling

7. Zpracování chyb (Běžné chyby a řešení)

Při práci s MariaDB v Pythonu mohou nastat chyby.
Zejména chyby připojení k databázi, chyby syntaxe SQL a chyby integrity dat jsou běžné, proto je důležité pochopit jejich příčiny a řešení.

V této sekci představujeme příčiny běžných chyb a jak je opravit.

Access denied for user (Chyba autentizace)

Zpráva o chybě

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

Příčina

• Uživatelské jméno nebo heslo je nesprávné
• Uživatel MariaDB nemá příslušná oprávnění

Řešení

1. Přihlaste se do MariaDB a zkontrolujte oprávnění uživatele

   mysql -u root -p
   

2. Udělte oprávnění uživateli

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

3. Restartujte MariaDB

   sudo systemctl restart mariadb
   

Can't connect to MySQL server on 'localhost' (Chyba připojení)

Zpráva o chybě

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

Příčina

• Server MariaDB neběží
• Nastavení host je nesprávné

Řešení

1. Zkontrolujte, zda server MariaDB běží

   sudo systemctl status mariadb
   

2. Pokud je server zastaven, spusťte ho

   sudo systemctl start mariadb
   

3. Povolte serveru automatické spuštění

   sudo systemctl enable mariadb
   

Unknown database 'sample_db' (Databáze neexistuje)

Zpráva o chybě

mariadb.ProgrammingError: Unknown database 'sample_db'

Příčina

• Určená databáze neexistuje
• V názvu databáze je překlep

Řešení

1. Zkontrolujte seznam databází

   SHOW DATABASES;
   

2. Vytvořte databázi, pokud neexistuje

   CREATE DATABASE sample_db;
   

Table doesn't exist (Tabulka neexistuje)

Zpráva o chybě

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

Příčina

• Určená tabulka neexistuje
• Databáze nebyla vybrána pomocí USE sample_db;

Řešení

1. Zkontrolujte seznam tabulek

   SHOW TABLES;
   

2. Vytvořte tabulku, pokud neexistuje

   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 (Chyba duplicitních dat)

Zpráva o chybě

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

Příčina

• Sloupec email má omezení UNIQUE, takže nelze vložit duplicitní hodnoty

Řešení

• Zkontrolujte duplicity před vložením dat
• Použijte ON DUPLICATE KEY UPDATE

Kód Pythonu pro prevenci duplicit

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.")

Nebo použijte 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 (Nesoulad počtu parametrů)

Zpráva o chybě

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

Příčina

• Počet parametrů vyžadovaných SQL příkazem neodpovídá počtu poskytnutých argumentů

Řešení

• Ujistěte se, že počet placeholderů odpovídá počtu parametrů

Nesprávný kód

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

Správný kód

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

Shrnutí

V této sekci jsme vysvětlili běžné chyby, které se vyskytují při práci s MariaDB v Pythonu, a jak je řešit.

• Access denied for user (Chyba ověření)
• Can't connect to MySQL server (Chyba připojení)
• Unknown database (Databáze neexistuje)
• Table doesn't exist (Tabulka neexistuje)
• Duplicate entry (Chyba duplicitních dat)
• Incorrect number of bindings (Neshoda počtu parametrů)

8. Závěr

V tomto článku jsme vysvětlili jak pracovat s MariaDB pomocí Pythonu, od základních konceptů po pokročilejší témata.
Porozuměním základním operacím s databází a správnou implementací zpracování chyb a správy transakcí můžete provádět bezpečnější a efektivnější operace s daty.

Přehled článku

Nastavení prostředí

• Jak nainstalovat MariaDB (Windows / Mac / Linux)
• Jak nainstalovat knihovnu konektoru MariaDB (mariadb) pro Python

Připojení k MariaDB

• Základní metody připojení k databázi
• Bezpečná připojení pomocí proměnných prostředí
• Řešení běžných chyb připojení

Vytváření databází a tabulek

• Vytváření databází (SQL / Python)
• Vytváření tabulek a výběr datových typů
• Kontrola a odstraňování existujících tabulek

CRUD operace (Create, Read, Update, Delete)

• Základní operace s daty pomocí Pythonu
• Používání placeholderů k prevenci SQL injection
• Správné zpracování chyb

Transakce a rollback

• Důležitost transakcí (vlastnosti ACID)
• Jak obnovit data při chybě (rollback)
• Manuální správa transakcí vypnutím AutoCommit

Zpracování chyb (Běžné chyby a řešení)

• Chyby ověření (Access denied for user)
• Chyby připojení (Can't connect to MySQL server)
• Chyby nenalezení databáze nebo tabulky
• Chyby duplicitních dat (Duplicate entry)
• Řešení deadlocků a implementace logiky opakování

Klíčové body při kombinaci Pythonu a MariaDB

1. Používejte placeholdery

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

→ Vázané proměnné místo přímého vkládání do SQL příkazů, aby se zabránilo SQL injection.

2. Správně spravujte transakce

• Použijte conn.commit(), abyste explicitně potvrdili změny .
• Použijte conn.rollback() při chybě, aby zůstala integrita dat .

3. Implementujte důkladné zpracování chyb

• Použijte bloky try-except k předběžnému zachycení možných chyb .
• Připravte konkrétní strategie pro chyby jako OperationalError a IntegrityError .

4. Zvažte výkon

• Hromadné vkládání (vložit více záznamů najednou)
• Správné indexování (zlepšení výkonu vyhledávání)

Zdroje pro další učení

Pokud chcete prohloubit své znalosti o integraci Pythonu a MariaDB, zvažte následující zdroje:

Oficiální dokumentace

• MariaDB Official Documentation

Související výukový obsah

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

Doporučené knihy

• SQL, 2nd Edition: Database Operations from Scratch – Naučte se důkladně základy SQL
• Effective Python: 90 Specific Ways to Improve Your Python Programs – Naučte se osvědčené postupy v Pythonu

Shrnutí

Integrací MariaDB s Pythonem můžete umožnit správu dat pomocí skriptů a automatizaci. Implementací nejen základních CRUD operací, ale také správného zpracování chyb a správy transakcí, můžete vytvořit bezpečnější a efektivnější systém.

Jako další krok zvažte naučit se efektivní správu dat a integraci API, abyste své znalosti uplatnili v praktických databázových operacích.