Vi går igenom hur man skapar en transaktion baserat på tabellen `BankAccounts` som beskrevs i föregående kapitel.

Vi kommer att utföra en enkel finansiell transaktion: överföring av medel från ett konto till ett annat. Att säkerställa att båda stegen sker som en enda logisk enhet illustrerar en verklig transaktion.

Vi kommer att arbeta med kontonummer `101` och `789` och ingående saldo kommer att vara följande:

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

Påbörja en spännande resa genom SQL med Avancerade tekniker i SQL. Lär dig om de viktiga ACID-egenskaperna som säkerställer datakvalitet i databastransaktioner. Upptäck avancerade metoder för att optimera dina frågor och förbättra databasens prestanda. Utforska särskilda SQL-funktioner såsom fönsterfunktioner, triggers, Data Control Language (DCL) och NoSQL-databaser. Detta hjälper dig att hantera modern databashantering med självförtroende och effektivitet.

Nu utforskar vi de grundläggande principerna för ACID (Atomicitet, Konsistens, Isolering, Beständighet) inom databashantering. Dessa principer säkerställer tillförlitliga transaktioner genom att garantera fullständiga operationer, bibehålla datakonsistens, isolera samtidiga transaktioner och säkerställa permanent datalagring.

Utforska hur du kan förbättra effektiviteten i dina SQL-frågor genom indexoptimering. Fördjupa dig i indexens betydelse för databasprestanda och lär dig hur du utformar, implementerar och använder dem på ett effektivt sätt. Upptäck strategier för att välja lämpliga index, förstå deras påverkan på frågeexekveringsplaner samt optimera frågeprestanda genom val och användning av index.

Detta avsnitt utforskar centrala ämnen såsom triggers, fönsterfunktioner och DCL (Data Control Language), och erbjuder djupgående insikter i deras implementering och optimeringsstrategier. Vidare behandlas landskapet för NoSQL DBMS, med en grundlig genomgång av dess arkitektur, fördelar och praktiska tillämpningar.

Utmaning: Skapande av Transaktion

Lösning

Utmaning: Skapande av Transaktion

Lösning