Käydään läpi, kuinka luodaan transaktio itse aiemmassa luvussa kuvatun `BankAccounts`-taulun pohjalta.

Suoritamme yksinkertaisen rahansiirron: varojen siirron tililtä toiselle. Molempien vaiheiden toteuttaminen yhtenä loogisena kokonaisuutena havainnollistaa todellista transaktiota.

Työskentelemme tilinumeroiden `101` ja `789` kanssa, ja alkusaldo on seuraava:

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

Aloita jännittävä matka SQL:n parissa kurssilla Kehittyneet SQL-tekniikat. Opit tärkeistä ACID-ominaisuuksista, jotka varmistavat tietojen eheyden tietokantatransaktioissa. Tutustut edistyneisiin tapoihin optimoida kyselyitä ja parantaa tietokannan suorituskykyä. Perehdyt erityisiin SQL-ominaisuuksiin, kuten ikkuna-funktioihin, triggereihin, Data Control Languageen (DCL) ja NoSQL-tietokantoihin. Tämä auttaa sinua hallitsemaan nykyaikaista tietokantahallintaa luottavaisesti ja tehokkaasti.

Tässä osiossa tarkastellaan ACID-periaatteiden (atomisuus, konsistenssi, eristys, pysyvyys) perusteita tietokantahallinnassa. Näiden periaatteiden avulla varmistetaan luotettavat transaktiot takaamalla kokonaiset toiminnot, tietojen johdonmukaisuus, rinnakkaisten transaktioiden eristäminen sekä pysyvä tietojen tallennus.

Tutustu siihen, miten SQL-kyselyiden tehokkuutta voidaan parantaa indeksejä optimoimalla. Syvenny indeksien merkitykseen tietokannan suorituskyvyssä ja opi suunnittelemaan, toteuttamaan ja hyödyntämään niitä tehokkaasti. Selvitä strategioita sopivien indeksien valintaan, ymmärrä niiden vaikutus kyselyiden suorituskykysuunnitelmiin sekä optimoi kyselyiden suorituskykyä indeksien valinnan ja käytön avulla.

Tässä osiossa käsitellään keskeisiä aiheita, kuten triggereitä, ikkuna­funktioita ja DCL:ää (Data Control Language), tarjoten kattavaa tietoa niiden toteutuksesta ja optimointistrategioista. Lisäksi perehdytään NoSQL-tietokantajärjestelmiin, tarjoten perusteellinen ymmärrys niiden arkkitehtuurista, eduista ja käytännön sovelluksista.

Haaste: Transaktion Luominen

Ratkaisu