Lad os gennemgå oprettelsen af en transaktion baseret på tabellen `BankAccounts`, som blev beskrevet i det forrige kapitel.

Vi skal udføre en simpel finansiel transaktion: overførsel af midler fra én konto til en anden. At sikre, at begge trin udføres som en enkelt logisk enhed, illustrerer en reel transaktion.

Vi arbejder med kontonumrene `101` og `789`, og startsaldoen vil være følgende:

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

Begynd en spændende rejse gennem SQL med avancerede teknikker i SQL. Lær om de vigtige ACID-egenskaber, der sikrer datanøjagtighed i databasetransaktioner. Opdag avancerede metoder til at optimere dine forespørgsler for at forbedre databaseydelsen. Udforsk særlige SQL-funktioner som vinduesfunktioner, triggere, Data Control Language (DCL) og NoSQL-databaser. Dette vil hjælpe dig med at håndtere moderne databasestyring sikkert og effektivt.

Nu udforsker vi de grundlæggende principper for ACID (Atomicitet, Konsistens, Isolation, Varighed) i databasestyring. Disse principper sikrer pålidelige transaktioner ved at garantere fuldstændige operationer, opretholde datakonsistens, isolere samtidige transaktioner og sikre permanent datalagring.

Undersøg, hvordan effektiviteten af SQL-forespørgsler kan forbedres gennem optimering af indekser. Gå i dybden med betydningen af indekser for databaseydelse, og lær at designe, implementere og anvende dem effektivt. Opdag strategier til valg af passende indekser, forstå deres indvirkning på forespørgselsudførelsesplaner, og optimer forespørgselsydelse gennem valg og anvendelse af indekser.

Dette afsnit udforsker centrale emner såsom triggers, window functions og DCL (Data Control Language) og giver dybdegående indsigt i deres implementering og optimeringsstrategier. Derudover gennemgås landskabet for NoSQL DBMS med en grundig forståelse af dets arkitektur, fordele og praktiske anvendelser.

Udfordring: Oprettelse af Transaktion

Løsning

Udfordring: Oprettelse af Transaktion

Løsning