La oss gå gjennom hvordan vi selv kan opprette en transaksjon basert på `BankAccounts`-tabellen som ble beskrevet i forrige kapittel.

Vi skal utføre en enkel finansiell transaksjon: overføring av midler fra én konto til en annen. Å sikre at begge trinnene skjer som en enkelt logisk enhet, illustrerer en reell transaksjon.

Vi skal arbeide med kontonumrene `101` og `789`, og startsaldoen vil være som følger:

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

Start på en spennende reise gjennom SQL med avanserte teknikker i SQL. Lær om de viktige ACID-egenskapene som bidrar til å opprettholde datanøyaktighet i databasetransaksjoner. Oppdag avanserte metoder for å optimalisere spørringer for å forbedre databaseytelsen. Utforsk spesielle SQL-funksjoner som vindusfunksjoner, triggere, Data Control Language (DCL) og NoSQL-databaser. Dette vil hjelpe deg å håndtere moderne databaseadministrasjon trygt og effektivt.

Nå utforsker vi de grunnleggende prinsippene for ACID (Atomicity, Consistency, Isolation, Durability) i databasehåndtering. Disse prinsippene sikrer pålitelige transaksjoner ved å garantere fullstendige operasjoner, opprettholde datakonsistens, isolere samtidige transaksjoner og sikre permanent datalagring.

Utforsk hvordan du kan forbedre effektiviteten til SQL-spørringer gjennom indeksoptimalisering. Fordyp deg i betydningen av indekser for databaseytelse, og lær hvordan du designer, implementerer og bruker dem effektivt. Oppdag strategier for å velge riktige indekser, forstå deres innvirkning på spørringsutførelsesplaner, og optimalisere spørringsytelse gjennom valg og bruk av indekser.

Denne delen utforsker sentrale emner som triggere, vindusfunksjoner og DCL (Data Control Language), og gir grundig innsikt i implementering og optimaliseringsstrategier. Videre belyses landskapet for NoSQL DBMS, med en grundig forståelse av arkitektur, fordeler og praktiske anvendelser.

Utfordring: Opprettelse av Transaksjon

Løsning

Utfordring: Opprettelse av Transaksjon

Løsning