Laten we samen een transactie opzetten op basis van de `BankAccounts`-tabel die in het vorige hoofdstuk is beschreven.

We voeren een eenvoudige financiële transactie uit: het overboeken van geld van de ene rekening naar de andere. Het waarborgen dat beide stappen als één logische eenheid plaatsvinden, illustreert een echte transactie.

We werken met rekeningnummers `101` en `789` en het beginsaldo is als volgt:

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

Begin een boeiende reis door SQL met Geavanceerde Technieken in SQL. Leer over de belangrijke ACID-eigenschappen die de nauwkeurigheid van gegevens waarborgen bij databasetransacties. Ontdek geavanceerde methoden om je queries te optimaliseren en de databaseprestaties te verbeteren. Verken speciale SQL-functies zoals windowfuncties, triggers, Data Control Language (DCL) en NoSQL-databases. Dit helpt je om moderne databasebeheer effectief en vol vertrouwen aan te pakken.

Nu verkennen we de basisprincipes van ACID (Atomiciteit, Consistentie, Isolatie, Duurzaamheid) in databasebeheer. Deze principes waarborgen betrouwbare transacties door volledige bewerkingen te garanderen, gegevens consistent te houden, gelijktijdige transacties te isoleren en permanente gegevensopslag te verzekeren.

Ontdek hoe u de efficiëntie van SQL-query's kunt verbeteren door indexoptimalisatie. Verdiep u in het belang van indexen voor databaseprestaties en leer hoe u deze effectief ontwerpt, implementeert en gebruikt. Ontdek strategieën voor het kiezen van geschikte indexen, begrijp hun invloed op query-uitvoeringsplannen en optimaliseer de queryprestaties door middel van indexselectie en -gebruik.

Deze sectie behandelt essentiële onderwerpen zoals triggers, windowfuncties en DCL (Data Control Language), en biedt diepgaande inzichten in hun implementatie en optimalisatiestrategieën. Daarnaast wordt het landschap van NoSQL-DBMS verkend, met een grondig begrip van de architectuur, voordelen en praktische toepassingen.

Uitdaging: Transactie Aanmaken

Oplossing

Uitdaging: Transactie Aanmaken

Oplossing