Wir werden gemeinsam eine Transaktion basierend auf der im vorherigen Kapitel beschriebenen Tabelle `BankAccounts` erstellen.

Wir führen eine einfache finanzielle Transaktion durch: die Überweisung von Geld von einem Konto auf ein anderes. Die Sicherstellung, dass beide Schritte als eine einzige logische Einheit ausgeführt werden, veranschaulicht eine reale Transaktion.

Wir arbeiten mit den Kontonummern `101` und `789` und der Anfangssaldo ist wie folgt:

import unittest
import psycopg2
import pandas as pd

class TestPostgresQuery(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.connection = psycopg2.connect(
            host="localhost",
            user="agent",
            password="qwerty",
            dbname="testdb",
            sslmode="disable"
        )
        cls.cursor = cls.connection.cursor()

    def test_balances_after_transaction(self):
        """Check if balances for accounts 101 and 789 are updated correctly after transferring 500 from 101 to 789."""
        with open("query.sql", "r") as file:
            query = file.read()
        self.cursor.execute("UPDATE BankAccounts SET balance = 4500 WHERE account_number = 101;")
        self.cursor.execute("UPDATE BankAccounts SET balance = 3500 WHERE account_number = 789;")
        self.connection.commit()
        self.cursor.execute(query)
        rows = self.cursor.fetchall()
        columns = [desc[0] for desc in self.cursor.description]
        result_df = pd.DataFrame(rows, columns=columns)
        result_df = result_df.set_index('account_number')
        expected_balances = {101: 4000.00, 789: 4000.00}
        correct = True
        for acc, expected in expected_balances.items():
            if acc not in result_df.index or float(result_df.loc[acc, 'balance']) != expected:
                correct = False
        _dynamic_test(
            self,
            correct,
            "Balances are updated correctly after transaction.",
            f"Balances are not updated correctly.\\nExpected: {expected_balances}\\nGot: {result_df['balance'].to_dict()}"
        )

    def test_transaction_committed(self):
        """Check that the transaction is committed and balances persist after reconnect."""
        with open("query.sql", "r") as file:
            query = file.read()
        # Reset balances
        self.cursor.execute("UPDATE BankAccounts SET balance = 4500 WHERE account_number = 101;")
        self.cursor.execute("UPDATE BankAccounts SET balance = 3500 WHERE account_number = 789;")
        self.connection.commit()
        self.cursor.execute(query)
        self.connection.commit()
        # Reconnect to check persistence
        self.cursor.close()
        self.connection.close()
        connection2 = psycopg2.connect(
            host="localhost",
            user="agent",
            password="qwerty",
            dbname="testdb",
            sslmode="disable"
        )
        cursor2 = connection2.cursor()
        cursor2.execute("SELECT account_number, balance FROM BankAccounts WHERE account_number IN (101, 789);")
        rows = cursor2.fetchall()
        result_df = pd.DataFrame(rows, columns=['account_number', 'balance']).set_index('account_number')
        expected_balances = {101: 4000.00, 789: 4000.00}
        correct = True
        for acc, expected in expected_balances.items():
            if acc not in result_df.index or float(result_df.loc[acc, 'balance']) != expected:
                correct = False
        _dynamic_test(
            self,
            correct,
            "Transaction was committed and balances persisted.",
            f"Transaction was not committed or balances did not persist.\\nExpected: {expected_balances}\\nGot: {result_df['balance'].to_dict()}"
        )
        cursor2.close()
        connection2.close()
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

if __name__ == "__main__":
    unittest.main()


test_solution.py

Beginnen Sie eine spannende Reise durch SQL mit fortgeschrittenen Techniken in SQL. Lernen Sie die wichtigen ACID-Eigenschaften kennen, die die Datenintegrität bei Datenbanktransaktionen gewährleisten. Entdecken Sie fortgeschrittene Methoden zur Optimierung Ihrer Abfragen, um die Datenbankleistung zu verbessern. Erkunden Sie spezielle SQL-Funktionen wie Window Functions, Trigger, Data Control Language (DCL) und NoSQL-Datenbanken. Dies ermöglicht Ihnen einen sicheren und effektiven Umgang mit moderner Datenbankverwaltung.

Nun untersuchen wir die grundlegenden Prinzipien von ACID (Atomarität, Konsistenz, Isolation, Dauerhaftigkeit) im Datenbankmanagement. Diese Prinzipien gewährleisten zuverlässige Transaktionen, indem sie vollständige Operationen sicherstellen, Daten konsistent halten, gleichzeitige Transaktionen isolieren und eine dauerhafte Datenspeicherung garantieren.

Erfahren Sie, wie die Effizienz von SQL-Abfragen durch Indexoptimierung gesteigert werden kann. Vertiefen Sie das Verständnis für die Bedeutung von Indizes in der Datenbankleistung und lernen Sie, wie diese effektiv entworfen, implementiert und genutzt werden. Entdecken Sie Strategien zur Auswahl geeigneter Indizes, zum Verständnis ihrer Auswirkungen auf Ausführungspläne von Abfragen sowie zur Optimierung der Abfrageleistung durch gezielte Indexauswahl und -nutzung.

Dieser Abschnitt behandelt zentrale Themen wie Trigger, Window Functions und DCL (Data Control Language) und bietet umfassende Einblicke in deren Implementierung und Optimierungsstrategien. Darüber hinaus wird das Umfeld von NoSQL-DBMS beleuchtet, um ein fundiertes Verständnis von deren Architektur, Vorteilen und praktischen Anwendungen zu vermitteln.

Herausforderung: Transaktionserstellung

Lösung

Herausforderung: Transaktionserstellung

Lösung