Informatik - Exam.pdf

Aufgabe 1)

Datenmodellierung und Datenbankdesign: Entwirf und entwickle eine relationale Datenbank für ein mittelständisches Unternehmen. Das Unternehmen benötigt eine Datenbank zur Verwaltung von Kunden, Bestellungen und Produkten. Konzentriere dich auf die Erstellung eines ER-Modells, die Normalisierung der Tabellen und die Gestaltung von SQL-Abfragen zur Datenmanipulation und Abfrage.

a)

Erstelle ein ER-Diagramm für das obige Szenario des Unternehmens. Identifiziere dabei die wesentlichen Entitäten (z.B. Kunde, Bestellung, Produkt) und deren Attribute. Stelle auch die Beziehungen zwischen den Entitäten dar. Vergiss nicht, Primärschlüssel für jede Entität festzulegen.

Lösung:

• Entitäten und Attribute:

• Kunde:
  • KundenID (Primärschlüssel)
  • Vorname
  • Nachname
  • Email
  • Telefonnummer
  • Adresse
• Bestellung:
  • BestellungsID (Primärschlüssel)
  • Bestelldatum
  • KundenID (Fremdschlüssel, verweist auf Kunde)
• Produkt:
  • ProduktID (Primärschlüssel)
  • Produktname
  • Beschreibung
  • Preis
  • Lagermenge
• Bestellungsposition: (Diese Entität wird benötigt, um die vielen-zu-vielen Beziehung zwischen Bestellungen und Produkten abzubilden)
  • PositionsID (Primärschlüssel)
  • BestellungsID (Fremdschlüssel, verweist auf Bestellung)
  • ProduktID (Fremdschlüssel, verweist auf Produkt)
  • Menge

• Beziehungen und Kardinalitäten:

• Kunde - Bestellung: Ein Kunde kann viele Bestellungen aufgeben (1:n Beziehung).
• Bestellung - Produkt: Eine Bestellung kann viele Produkte enthalten und ein Produkt kann in vielen Bestellungen vorkommen (m:n Beziehung), abgebildet durch die Entität Bestellungsposition.

• ER-Diagramm:

b)

Normalisiere das Datenbankschema bis hin zur dritten Normalform (3NF). Begründe jeden Normalisierungsschritt von 1NF zu 3NF und beschreibe, wie Redundanzen reduziert und Anomalien vermieden werden. Gib konkrete Beispiele aus dem obigen Unternehmensszenario.

Lösung:

• Normalisierungsschritte:

• Erste Normalform (1NF):
  • Kriterium: Alle Attribute enthalten nur atomare (unteilbare) Werte und jede Zelle enthält nur einen Wert.
  • Beispiel: Im Schema für das Unternehmen darf eine Tabelle wie Kunde keine mehrfachen Werte in einem Feld haben. Das bedeutet:

  Kunde(KundenID, Vorname, Nachname, Email, Telefonnummer, Adresse)

• Zweite Normalform (2NF):
  • Kriterium: Die Tabelle muss in 1NF sein und jedes Nicht-Schlüssel-Attribut muss voll funktional von jedem Kandidatenschlüssel der Tabelle abhängen.
  • Beispiel: Eine zusammengesetzte Primärschlüssel-Situation könnte in der Bestellungsposition Tabelle auftreten. In 2NF ist gewährleistet, dass alle Nicht-Schlüssel-Attribute voll funktional abhängig von der gesamten Primärschlüssel sind.
  • Entitäten sind jetzt:

    Bestellungsposition (PositionsID, BestellungsID, ProduktID, Menge)

    Bestellung(BestellungsID, Bestelldatum, KundenID)

    Produkt(ProduktID, Produktname, Beschreibung, Preis, Lagermenge)

    Kunde(KundenID, Vorname, Nachname, Email, Telefonnummer, Adresse)

• Dritte Normalform (3NF):
  • Kriterium: Die Tabelle muss in 2NF sein und alle Attribute müssen nur vom Primärschlüssel abhängig sein (es gibt keine funktionalen Abhängigkeiten zwischen Nicht-Schlüssel-Attributen).
  • Beispiel: Es gibt bei den obigen Tabellen keine Nicht-Schlüssel-Attribut-Abhängigkeiten, die zu brechen sind (z.B. in der Produkt-Tabelle hängt keiner der Attribute von den anderen Attributen ab).
  • Endgültige normalisierte Tabellen:

    Bestellungsposition (PositionsID, BestellungsID, ProduktID, Menge)

    Bestellung(BestellungsID, Bestelldatum, KundenID)

    Produkt(ProduktID, Produktname, Beschreibung, Preis, Lagermenge)

    Kunde(KundenID, Vorname, Nachname, Email, Telefonnummer, Adresse)

• Reduzierung von Redundanzen und Vermeidung von Anomalien:
  • Durch die Normalisierung wurden redundante Daten entfernt. Zum Beispiel wird die Kunde-Information in der Bestellung Tabelle nicht wiederholt, sondern durch die KundenID referenziert.
  • Update-Anomalien werden vermieden, weil jede Information nur an einem Ort gespeichert wird. Zum Beispiel, wenn die Adresse eines Kunden aktualisiert wird, muss dies nur in der Kunden Tabelle gemacht werden.
  • Delete-Anomalien werden vermieden, weil das Löschen einer Bestellung nicht zur unerwünschten Löschung von Kundendaten führt.
  • Insert-Anomalien werden vermieden, weil keine unnötigen Informationen fehlen müssen, um eine Reihe von Attributen korrekt füllen zu können.

c)

Erstelle anhand des normalisierten Schemas die notwendigen SQL-Statements zur Erstellung der Tabellen (inklusive Primär- und Fremdschlüssel). Hier ist ein Beispiel für die Erstellung einer Tabelle:

CREATE TABLE Kunde (Kundennummer INT PRIMARY KEY, Name VARCHAR(100), Adresse VARCHAR(255));

Lösung:

• SQL-Statements zur Erstellung der Tabellen:

• Tabelle Kunde:

CREATE TABLE Kunde (    KundenID INT PRIMARY KEY,    Vorname VARCHAR(50),    Nachname VARCHAR(50),    Email VARCHAR(100),    Telefonnummer VARCHAR(20),    Adresse VARCHAR(255));

• Tabelle Bestellung:

CREATE TABLE Bestellung (    BestellungsID INT PRIMARY KEY,    Bestelldatum DATE,    KundenID INT,    FOREIGN KEY (KundenID) REFERENCES Kunde(KundenID));

• Tabelle Produkt:

CREATE TABLE Produkt (    ProduktID INT PRIMARY KEY,    Produktname VARCHAR(100),    Beschreibung TEXT,    Preis DECIMAL(10, 2),    Lagermenge INT);

• Tabelle Bestellungsposition:

CREATE TABLE Bestellungsposition (    PositionsID INT PRIMARY KEY,    BestellungsID INT,    ProduktID INT,    Menge INT,    FOREIGN KEY (BestellungsID) REFERENCES Bestellung(BestellungsID),    FOREIGN KEY (ProduktID) REFERENCES Produkt(ProduktID));

d)

Formuliere drei SQL-Abfragen zur Datenmanipulation und Abfrage. Beispiele:

• Füge einen neuen Kunden hinzu.
• Füge eine neue Bestellung für einen vorhandenen Kunden hinzu.
• Gib eine Liste aller Bestellungen für einen bestimmten Kunden aus.

INSERT INTO Kunde (Kundennummer, Name, Adresse) VALUES (1, 'Max Mustermann', 'Musterstraße 1, 12345 Musterstadt');

Lösung:

• SQL-Abfragen zur Datenmanipulation und Abfrage:

1. Füge einen neuen Kunden hinzu:

INSERT INTO Kunde (KundenID, Vorname, Nachname, Email, Telefonnummer, Adresse)VALUES (1, 'Hans', 'Müller', 'hans.mueller@example.com', '01234-567890', 'Beispielstraße 1, 12345 Beispielstadt');

2. Füge eine neue Bestellung für einen vorhandenen Kunden hinzu:

INSERT INTO Bestellung (BestellungsID, Bestelldatum, KundenID)VALUES (1, '2023-10-15', 1);

3. Gib eine Liste aller Bestellungen für einen bestimmten Kunden aus:

SELECT Bestellung.BestellungsID, Bestellung.Bestelldatum, Kunde.Vorname, Kunde.NachnameFROM BestellungJOIN Kunde ON Bestellung.KundenID = Kunde.KundenIDWHERE Kunde.KundenID = 1;

Aufgabe 2)

Ein Unternehmen betreibt zwei Datenbanksysteme: Ein relationales Datenbanksystem (RDBMS) mit SQL und ein NoSQL-Datenbanksystem. Die SQL-Datenbank speichert strukturierte Produktdaten, während die NoSQL-Datenbank für unstrukturierte Benutzerbewertungen verwendet wird. Es soll eine Analyse der beiden Systeme durchgeführt und verschiedene Fragestellungen beantwortet werden.

a)

Du sollst eine SQL-Abfrage erstellen, um die folgenden Informationen aus der Produktdatenbank abzurufen: Alle Produkte, die mehr als 50 Einheiten auf Lager haben, sortiert nach dem Produktnamen in aufsteigender Reihenfolge. Zeige die Spalten Produktname und Lagerbestand an.

Lösung:

Um die gewünschten Informationen aus der Produktdatenbank abzurufen, musst Du eine SQL-Abfrage erstellen, die die Produkte nach Lagerbestand filtert und anschließend nach Produktnamen sortiert. Hier ist die SQL-Abfrage, die diese Anforderungen erfüllt:

 SELECT Produktname, Lagerbestand  FROM Produkte  WHERE Lagerbestand > 50  ORDER BY Produktname ASC; 

Die Abfrage besteht aus folgenden Schritten:

• SELECT: Wählt die Spalten Produktname und Lagerbestand aus der Tabelle aus.
• FROM: Gibt die Tabelle an, aus der die Daten abgerufen werden (in diesem Fall die Tabelle Produkte).
• WHERE: Filtert die Daten und zeigt nur die Produkte an, bei denen der Lagerbestand mehr als 50 Einheiten beträgt.
• ORDER BY: Sortiert die Ergebnisse nach Produktname in aufsteigender Reihenfolge.

b)

Beschreibe die Acid-Eigenschaften (Atomicity, Consistency, Isolation, Durability) einer SQL-Datenbank und erläutere deren Bedeutung anhand eines Beispiels, bei dem ein Benutzer eine Bestellung aufgibt.

Lösung:

Die ACID-Eigenschaften sind grundlegende Prinzipien, die in relationalen Datenbanksystemen (RDBMS) verwendet werden, um sicherzustellen, dass Transaktionen korrekt und zuverlässig ausgeführt werden. Diese Eigenschaften sind Atomicity (Atomarität), Consistency (Konsistenz), Isolation (Isolation) und Durability (Dauerhaftigkeit).

• Atomicity (Atomarität): Eine Transaktion wird entweder vollständig durchgeführt oder gar nicht. Das bedeutet, dass alle Änderungen, die eine Transaktion vornimmt, als eine einzige, unteilbare Operation betrachtet werden. Beispiel: Wenn ein Benutzer eine Bestellung aufgibt, umfasst die Transaktion das Update des Lagerbestands, das Erstellen des Bestelleintrags und die Aktualisierung des Benutzerkontos. Wenn einer dieser Schritte fehlschlägt, werden alle Änderungen zurückgesetzt (Roll-Back).
• Consistency (Konsistenz): Eine Transaktion bringt die Datenbank von einem konsistenten Zustand in einen anderen konsistenten Zustand. Das bedeutet, dass alle definierten Regeln, wie Constraints, Integritätsregeln und Datenbanktriggers, eingehalten werden. Beispiel: Wenn ein Benutzer eine Bestellung aufgibt, wird sichergestellt, dass der Lagerbestand nicht negativ wird und alle referenziellen Integritätsregeln eingehalten werden.
• Isolation (Isolation): Isolierung bedeutet, dass gleichzeitige Transaktionen sich gegenseitig nicht beeinflussen sollen. Jede Transaktion läuft so, als wäre sie die einzige, die auf die Datenbank zugreift. Beispiel: Wenn zwei Benutzer gleichzeitig Bestellungen aufgeben, wird sichergestellt, dass jede Bestellung korrekt verarbeitet wird, ohne die Daten der anderen Transaktion zu beeinträchtigen. Dies verhindert Probleme wie Dirty Reads und Lost Updates.
• Durability (Dauerhaftigkeit): Dauerhaftigkeit stellt sicher, dass sobald eine Transaktion abgeschlossen ist, die Änderungen dauerhaft gespeichert bleiben und auch bei einem Systemausfall nicht verloren gehen. Beispiel: Wenn ein Benutzer eine Bestellung aufgibt und die Transaktion erfolgreich abgeschlossen wird, bleiben die Änderungen permanent in der Datenbank gespeichert, auch wenn das System unmittelbar danach abstürzt.

Diese vier Prinzipien gewährleisten die Zuverlässigkeit und Integrität der Daten, wodurch sichergestellt wird, dass Transaktionen korrekt und sicher in einer SQL-Datenbank durchgeführt werden können.

c)

Konvertiere die folgende SQL-Abrage in eine entsprechende MongoDB-Abfrage. Die SQL-Abfrage lautet:

'SELECT Produktname, Preis FROM Produkte WHERE Preis > 100 ORDER BY Preis DESC;'

Lösung:

Um die angegebene SQL-Abfrage in eine entsprechende MongoDB-Abfrage zu konvertieren, kannst Du die MongoDB/JS-Syntax verwenden. Hier ist die MongoDB-Abfrage:

 db.Produkte.find(     { Preis: { $gt: 100 } },     { Produktname: 1, Preis: 1 }  ).sort( { Preis: -1 } ); 

Die Abfrage besteht aus folgenden Schritten:

• db.Produkte.find: Ruft die Daten aus der Produkte-Kollektion ab.
• filter: Das erste Argument der find-Methode enthält das Filterkriterium, in diesem Fall { Preis: { $gt: 100 } }, was bedeutet, dass nur Produkte mit einem Preis über 100 ausgewählt werden.
• projection: Das zweite Argument der find-Methode spezifiziert die Felder, die angezeigt werden sollen. { Produktname: 1, Preis: 1 } bedeutet, dass nur die Felder Produktname und Preis in den Ergebnissen enthalten sein sollen.
• sort: Mit der sort-Methode werden die Ergebnisse nach dem Preis in absteigender Reihenfolge ({ Preis: -1 }) sortiert.

d)

Ein NoSQL-System folgt dem CAP-Theorem. Erkläre die Bedeutung der drei Eigenschaften (Consistency, Availability, Partition Tolerance) im Zusammenhang mit einem NoSQL-Datenbanksystem. Nutze dabei das Beispiel einer global verteilten Datenbank, die Benutzerdaten speichert.

Lösung:

Das CAP-Theorem ist ein grundlegendes Prinzip im Design verteilter Systeme, insbesondere solcher, die NoSQL-Datenbanken verwenden. Das Theorem besagt, dass eine verteilte Datenbank höchstens zwei der drei folgenden Eigenschaften gleichzeitig gewährleisten kann: Consistency (Konsistenz), Availability (Verfügbarkeit) und Partition Tolerance (Partitionstoleranz). Hier ist eine Erklärung der drei Eigenschaften im Zusammenhang mit einer global verteilten Datenbank, die Benutzerdaten speichert:

• Consistency (Konsistenz): Konsistenz bedeutet, dass alle Knoten im verteilten System jederzeit denselben Datenstand darstellen. Wenn ein Benutzer seine Daten in einem Teil der Welt aktualisiert, stellen alle anderen Teile der Welt sofort den neuen Datenstand dar. Beispiel: Wenn ein Benutzer sein Profilbild aktualisiert, wird das geänderte Profilbild sofort und überall angezeigt. Dies stellt sicher, dass alle Leseoperationen nach einer Schreiboperation den neuesten Datenstand erhalten.
• Availability (Verfügbarkeit): Verfügbarkeit bedeutet, dass das System jederzeit auf Anfragen antworten kann. Selbst wenn Teile des Systems ausfallen, muss das System weiterhin funktionsfähig bleiben. Beispiel: Wenn ein Benutzer seine Benutzerdaten auf einem Server in Europa abruft und dieser Server ausfällt, kann ein anderer Server, z. B. in den USA, die Daten des Benutzers bereitstellen. Dies stellt sicher, dass der Dienst für den Benutzer immer verfügbar bleibt.
• Partition Tolerance (Partitionstoleranz): Partitionstoleranz bedeutet, dass das System weiterhin funktioniert, auch wenn die Kommunikation zwischen den Knoten unterbrochen ist. Solche Unterbrechungen können durch Netzwerkprobleme oder andere technische Störungen verursacht werden. Beispiel: Wenn ein Netzwerkproblem die Verbindung zwischen Servern in Asien und Servern in Europa unterbricht, sollten beide Server weiterhin unabhängig voneinander arbeiten können, und die Datenbank sollte weiterhin Daten verarbeiten und Anfragen beantworten können.

Aufgrund des CAP-Theorems kann ein verteiltes NoSQL-Datenbanksystem nicht alle drei Eigenschaften gleichzeitig gewährleisten. Es muss also manchmal ein Kompromiss gefunden werden, um den Anforderungen der speziellen Anwendung gerecht zu werden. Zum Beispiel könnte eine Anwendung mehr Wert auf Konsistenz und Partitionstoleranz legen, während eine andere Anwendung mehr Wert auf Verfügbarkeit und Partitionstoleranz legt.

Aufgabe 3)

Ein E-Commerce-Unternehmen verwendet ein Datenbanksystem, um Transaktionsdaten zu verwalten. Um sicherzustellen, dass Transaktionen sicher und effizient durchgeführt werden, müssen die ACID-Prinzipien eingehalten werden. Betrachte folgende Situation: Ein Kunde kauft ein Produkt, und während des Kaufprozesses werden Transaktionen zur Aktualisierung der Bestandsmenge und zur Verbuchung der Zahlung durchgeführt.

Das Unternehmen benötigt Mechanismen zur Durchführung und Verwaltung dieser Transaktionen und zur Einhaltung der ACID-Prinzipien.

a)

Beschreibe die Bedeutung der Atomicity im Kontext der Transaktionsverwaltung für die oben beschriebene Kaufsituation.

Erläutere, wie das Datenbanksystem sicherstellen kann, dass der Kauf entweder vollständig erfolgreich ist oder vollständig scheitert, ohne Zwischenzustände zu hinterlassen.

Lösung:

Atomicity im Kontext der Transaktionsverwaltung

Atomicity ist eine der vier zentralen ACID-Eigenschaften (Atomicity, Consistency, Isolation, Durability), die sicherstellen, dass Datenbanktransaktionen sicher und korrekt ausgeführt werden. Im Kontext der Transaktionsverwaltung eines E-Commerce-Unternehmens bedeutet Atomicity, dass jede Transaktion entweder vollständig abgeschlossen wird oder gar nicht durchgeführt wird.

Das bedeutet für die beschriebene Kaufsituation: Wenn ein Kunde ein Produkt kauft, werden mehrere Operationen ausgeführt, wie z.B. die Aktualisierung der Bestandsmenge des Produkts und die Verbuchung der Zahlung. Atomicity garantiert, dass diese beiden Operationen als eine untrennbare Einheit behandelt werden. Entweder beide Operationen werden erfolgreich abgeschlossen, oder keine davon wird geändert.

Das Datenbanksystem kann Atomicity auf folgende Weise sicherstellen:

• Transaktionsprotokollierung (Logging): Das System protokolliert jede Operation, die Teil der Transaktion ist. Bei einem Systemausfall kann das System das Transaktionsprotokoll verwenden, um unvollständige Transaktionen zurückzusetzen.
• Commit und Rollback: Eine Transaktion beginnt mit einem „Start“-Befehl und erstreckt sich über mehrere Operationen. Nachdem alle Operationen erfolgreich ausgeführt wurden, wird ein „Commit“-Befehl ausgelöst, der die Transaktion bestätigt. Falls eine der Operationen fehlschlägt, wird ein „Rollback“-Befehl ausgeführt, um alle Operationen der Transaktion rückgängig zu machen.
• Zwischenspeicherung: Vor dem Commit werden Änderungen nur in einem temporären Speicher oder Cache vorgenommen. Erst nach einem erfolgreichen Commit werden die Änderungen dauerhaft in der Datenbank gespeichert.

Im Falle eines erfolgreichen Kaufs, aktualisiert das System sowohl die Bestandsmenge als auch die Verbuchung der Zahlung. Sollte jedoch ein Fehler auftreten, z.B. wenn die Zahlung nicht verarbeitet werden kann, stellt das System sicher, dass auch die Bestandsmenge nicht geändert wird. Dadurch wird garantiert, dass kein inkonsistenter Zustand in der Datenbank entsteht und der Kunde keine fehlerhaften Informationen erhält.

b)

Erkläre den Unterschied zwischen den Isolation Levels Read Uncommitted und Serializable.

Gib Beispiele dafür, welche Art von Inkonsistenzen auftreten können, wenn das Isolation Level Read Uncommitted verwendet wird, und wie Serializable diese verhindern kann.

Lösung:

Unterschied zwischen den Isolation Levels Read Uncommitted und Serializable

In Datenbankmanagementsystemen bestimmt das Isolation Level, inwieweit parallel ausgeführte Transaktionen voneinander getrennt werden. Die Isolation Levels beeinflussen, wie und wann die Änderungen einer Transaktion für andere Transaktionen sichtbar werden.

Hier ist der Unterschied zwischen den Isolation Levels Read Uncommitted und Serializable:

• Read Uncommitted: Bei diesem Isolation Level können Transaktionen dirty reads durchführen. Das bedeutet, dass eine Transaktion ungefilterten Zugriff auf die Änderungen einer anderen Transaktion hat, die noch nicht abgeschlossen ist (d.h. noch kein Commit durchgeführt wurde). Inkonsistenzen und Fehlverhalten können auftreten, da unvollständige oder fehlerhafte Daten gelesen werden können.
• Serializable: Dies ist das strengste Isolation Level. Es stellt sicher, dass Transaktionen vollständig isoliert voneinander ablaufen, als ob sie in einer sequentiellen Reihenfolge ausgeführt würden. Keine Transaktion kann die Änderungen einer anderen Transaktion sehen, bis diese vollständig abgeschlossen und bestätigt wurde. Dies verhindert alle möglichen Arten von Inkonsistenzen und Anomalien (wie dirty reads, non-repeatable reads und phantom reads).

Beispiele für Inkonsistenzen bei Read Uncommitted und wie Serializable diese verhindert:

• Dirty Reads: Angenommen, Transaktion A aktualisiert die Bestandsmenge eines Produkts von 10 auf 5, hat ihre Änderung aber noch nicht festgeschrieben (Commit). Wenn Transaktion B gleichzeitig die Bestandsmenge liest, könnte sie den Wert 5 lesen. Sollte Transaktion A später fehlschlagen und zurückgerollt werden, ist die Information, die Transaktion B gelesen hat, inkorrekt. Bei Serializable würde Transaktion B die Änderungen von Transaktion A erst dann sehen, wenn A ihren Commit durchgeführt hat und vollständig abgeschlossen ist.
• Non-repeatable Reads: Angenommen, Transaktion A liest die Bestandsmenge eines Produkts zweimal (zu Beginn und am Ende der Transaktion) und erwartet denselben Wert. Wenn Transaktion B dazwischen die Bestandsmenge aktualisiert und committed, könnte Transaktion A bei Read Uncommitted unterschiedliche Werte lesen. Mit Serializable würde Transaktion A in einer vollständig isolierten Umgebung arbeiten und stets konsistente Daten lesen.
• Phantom Reads: Wenn Transaktion A eine Abfrage durchführt, die basierend auf bestimmten Kriterien Bestellungen eines Kunden zählt, und Transaktion B dazwischen neue Bestellungen hinzufügt und committed, könnte Transaktion A bei erneuter Ausführung der Abfrage mehr Bestellungen als zuvor zählen, obwohl sich ihre eigene Aktion nicht verändert hat. Bei Serializable würde Transaktion A keine anderen Änderungen sehen, bis sie vollständig abgeschlossen ist.

Wie diese Beispiele zeigen, stellt das Isolation Level Serializable sicher, dass Transaktionen in einer sicheren und konsistenten Reihenfolge ausgeführt werden, wodurch sämtliche Arten von Anomalien und Inkonsistenzen vermieden werden.

c)

Diskutiere die Rolle von Consistency im Zusammenhang mit der Vermeidung von Regelverletzungen in der Datenbank.

Beziehe Dich auf mögliche Konsistenzregeln, die im E-Commerce-Datenbanksystem relevant sein könnten, wie z. B. Vermeidung von Negativbeständen und korrekte Verbuchung der Zahlungsdaten.

Lösung:

Die Rolle von Consistency und die Vermeidung von Regelverletzungen

Consistency, oder Konsistenz, ist eines der zentralen ACID-Prinzipien, die sicherstellen, dass jede Datenbanktransaktion einen konsistenten Zustand der Datenbank hinterlässt. Im Kontext eines E-Commerce-Unternehmens bedeutet dies, dass nach Abschluss einer Transaktion alle definierten Geschäftsregeln und Datenbankbeschränkungen erfüllt sein müssen.

Konsistenzregeln im E-Commerce-Datenbanksystem:

Im E-Commerce-Datenbanksystem können folgende Konsistenzregeln relevant sein:

• Vermeidung von Negativbeständen: Eine Regel könnte besagen, dass die Bestandsmenge eines Produkts nicht negativ werden darf. Das Datenbanksystem muss sicherstellen, dass eine Transaktion, die die Bestandsmenge eines Produkts reduziert, nur dann erfolgreich ist, wenn genügend Bestand vorhanden ist, um die Transaktion abzuwickeln. Werden 5 Einheiten eines Produkts mit einem aktuellen Bestand von 3 verkauft, sollte die Transaktion abgelehnt werden, um Konsistenz zu gewährleisten.
• Korrekte Verbuchung der Zahlungsdaten: Eine weitere wichtige Konsistenzregel ist, dass die Zahlung korrekt verbucht wird und mit der Bestellinformation übereinstimmt. Dies bedeutet, dass der Zahlbetrag auf dem Kontoauszug des Kunden und in der Buchhaltung des Unternehmens übereinstimmen muss. Jeder Kaufprozess sollte sicherstellen, dass die Zahlung erfolgreich verarbeitet und bestätigt wird, bevor die Bestandsmenge reduziert wird.
• Referenzielle Integrität: Die Datenbank muss sicherstellen, dass alle Fremdschlüssel-Beziehungen intakt sind. Bei einer Bestellung muss sichergestellt werden, dass der Kunde existiert und das bestellte Produkt im Sortiment verfügbar ist.
• Validierung von Daten: Jede Transaktion sollte sicherstellen, dass alle eingegebenen Daten valide und im richtigen Format vorliegen. Beispielsweise muss die eingegebene Kreditkartennummer im korrekten Format und gültig sein.

Wie das Datenbanksystem Konsistenz sicherstellt:

• Transaktionen: Alle Operationen, die durch eine Transaktion ausgeführt werden, sollten so gestaltet sein, dass sie nur dann vollständig sind, wenn alle Operationen erfolgreich abgeschlossen sind. Falls eine Operation fehlschlägt, wird die gesamte Transaktion zurückgesetzt (Rollback), um sicherzustellen, dass die Datenbanken konsistent bleiben.
• Constraints und Trigger: Das Datenbanksystem kann Constraints (Einschränkungen) und Trigger verwenden, um Konsistenzregeln durchzusetzen. Constraints wie CHECK, NOT NULL, UNIQUE und Fremdschlüssel-Beziehungen stellen sicher, dass nur gültige Daten in die Datenbank eingegeben werden. Trigger können verwendet werden, um zusätzliche Logik anzuwenden, z. B. das Abfangen und Prüfen von Bestandsänderungen vor dem Commit einer Transaktion.
• Stored Procedures: Die Verwendung von Stored Procedures kann komplexe Geschäftslogik umsetzen, um sicherzustellen, dass alle Konsistenzregeln beachtet werden. Jede Bestellung und Zahlungstransaktion kann durch eine Stored Procedure abgewickelt werden, die alle relevanten Prüfungen durchführt.

Durch die Fähigkeit, diese Konsistenzregeln umzusetzen, stellt das Datenbanksystem sicher, dass jede Transaktion den Übergang von einem gültigen Zustand in einen anderen gültigen Zustand ermöglicht, ohne Regelverletzungen zu verursachen. Dies ist entscheidend für den reibungslosen und vertrauenswürdigen Betrieb eines E-Commerce-Unternehmens.

d)

Eine Transaktion, die den Lagerbestand für ein Produkt aktualisiert, wird erfolgreich abgeschlossen und ein Commit wird ausgeführt.

Erkläre, wie die Prinzipien der Durability sicherstellen, dass diese Änderung auch im Falle eines Systemabsturzes dauerhaft bestehen bleibt. Vergleiche dies mit einer Situation, in der ein Rollback durchgeführt wird.

Lösung:

Rolle der Durability bei der Sicherstellung dauerhafter Änderungen

Durability, oder Beständigkeit, ist eine der vier ACID-Eigenschaften von Datenbanktransaktionen und stellt sicher, dass einmal bestätigte (commit) Änderungen dauerhaft gespeichert werden, selbst im Falle eines Systemabsturzes oder anderer Fehler. Dies bedeutet, dass nach dem erfolgreichen Abschluss und Commit einer Transaktion die durchgeführten Änderungen nicht verloren gehen.

Durability im Kontext der Bestandsaktualisierung

Wenn eine Transaktion zur Aktualisierung des Lagerbestands eines Produkts erfolgreich ist und ein Commit ausgeführt wird, wird die Bestandsänderung dauerhaft gespeichert. Selbst wenn unmittelbar nach dem Commit ein Systemabsturz auftritt, stellt das ACID-Prinzip der Durability sicher, dass die Änderung nach dem Neustart des Systems noch vorhanden ist.

Hier sind einige Mechanismen, wie Datenbanksysteme Durability sicherstellen:

• Write-Ahead Logging (WAL): Bevor eine Änderung tatsächlich in der Datenbank festgeschrieben wird, wird sie zuerst in einem logischen Transaktionsprotokoll (Log) gespeichert. Dieses Protokoll wird sicher auf der Festplatte geschrieben. Im Falle eines Systemabsturzes kann das System dieses Protokoll verwenden, um alle bestätigten Transaktionen wiederherzustellen.
• Festplatten-Flush: Der Speichercontroller des Servers stellt sicher, dass alle Änderungen aus dem RAM auf die Festplatte geschrieben werden, bevor ein Commit als erfolgreich betrachtet wird. Dadurch wird sichergestellt, dass die Änderungen nicht nur im flüchtigen Speicher verbleiben.
• Redundante Arrays von unabhängigen Festplatten (RAID): Viele Datenbankserver verwenden RAID-Systeme, um Daten auf mehreren Festplatten zu spiegeln. Dadurch wird die Wahrscheinlichkeit des Datenverlusts im Falle eines einzelnen Hardwarefehlers verringert.
• Backup-Systeme: Regelmäßige Backups der Datenbank stellen sicher, dass Daten auch im Fall schwerwiegenderer Ausfälle wiederhergestellt werden können.

Vergleich mit einer Rollback-Situation

Im Vergleich dazu wird bei einem Rollback alle Änderungen, die Teil der Transaktion waren, rückgängig gemacht. Die Datenbank kehrt zu ihrem Zustand vor Beginn der Transaktion zurück. Folgende Punkte sind hierbei zu beachten:

• Rollback-Protokollierung: Ähnlich wie bei einem Commit, wird auch bei einem Rollback ein Protokoll gepflegt. Dieses Protokoll stellt sicher, dass alle durchgeführten Änderungen sicher zurückgesetzt werden können.
• Sicherheit und Korrektheit: Während eines Rollbacks werden inkonsistente Zustände vorübergehend, jedoch stellt das ACID-Prinzip der Consistency sicher, dass die Datenbank am Ende des Rollbacks wieder in einem konsistenten Zustand ist.
• Datenintegrität: Der Hauptunterschied besteht darin, dass bei einem Commit die Änderungen dauerhaft sind, während sie bei einem Rollback vollständig rückgängig gemacht werden. Dies gewährleistet, dass keine inkonsistenten oder halb abgeschlossenen Änderungen bestehen bleiben.

Durch die Umsetzung der Prinzipien der Durability stellt das Datenbanksystem sicher, dass alle bestätigten Änderungen auch nach unerwarteten Ereignissen wie einem Systemabsturz erhalten bleiben. Dies ist entscheidend für die Zuverlässigkeit und Vertrauenswürdigkeit eines E-Commerce-Systems, da es die Datenkonsistenz und -integrität gewährleistet.

Aufgabe 4)

Vergleiche die Unterschiede zwischen den Programmierkonzepten in Python und Java anhand der unten genannten Basiskonzepte:

• Datentypen: Python: `int`, `float`, `str`, `list`, Java: `int`, `double`, `String`, `ArrayList`
• Variablendeklaration: Python: `x = 5`, Java: `int x = 5`
• Konditionale: Python: `if`, `elif`, `else`, Java: `if`, `else if`, `else`
• Schleifen: Python: `for`, `while`, Java: `for`, `while`
• Funktionen/Methoden: Python: `def`, Java: `void` und Rückgabewert
• Klassen und Objekte: Syntax Unterschiede, OOP Konzepte

a)

Implementiere eine Funktion in Python, die die Summe aller geraden Zahlen in einer gegebenen Liste berechnet. Stelle dann die gleiche Funktion in Java dar.

• Python: Verwende eine `for`-Schleife und `if`-Konditionale.
• Java: Verwende eine `for`-Schleife und `if`-Konditionale. Deklariere alle notwendigen Variablen mit den entsprechenden Datentypen.

 # Python Code def sum_of_even_numbers(lst):     sum = 0     for num in lst:         if num % 2 == 0:             sum += num     return sum 

 // Java Code public class Main {     public static void main(String[] args) {         int[] array = {2, 4, 5, 6, 7};         System.out.println(sumOfEvenNumbers(array));     }      public static int sumOfEvenNumbers(int[] array) {         int sum = 0;         for (int num : array) {             if (num % 2 == 0) {                 sum += num;             }         }         return sum;     } } 

Lösung:

Vergleiche die Unterschiede zwischen den Programmierkonzepten in Python und Java anhand der unten genannten Basiskonzepte:

• Datentypen: Python: int, float, str, list, Java: int, double, String, ArrayList
• Variablendeklaration: Python: x = 5, Java: int x = 5
• Konditionale: Python: if, elif, else, Java: if, else if, else
• Schleifen: Python: for, while, Java: for, while
• Funktionen/Methoden: Python: def, Java: void und Rückgabewert
• Klassen und Objekte: Syntax Unterschiede, OOP Konzepte

• Python: Verwende eine for-Schleife und if-Konditionale.
• Java: Verwende eine for-Schleife und if-Konditionale. Deklariere alle notwendigen Variablen mit den entsprechenden Datentypen.

# Python Codedef sum_of_even_numbers(lst):    sum = 0    for num in lst:        if num % 2 == 0:            sum += num    return sum

// Java Codepublic class Main {    public static void main(String[] args) {        int[] array = {2, 4, 5, 6, 7};        System.out.println(sumOfEvenNumbers(array));    }    public static int sumOfEvenNumbers(int[] array) {        int sum = 0;        for (int num : array) {            if (num % 2 == 0) {                sum += num;            }        }        return sum;    }}

b)

Erstelle eine Klasse `Rechteck` in Python und Java mit den Attributen `laenge` und `breite` sowie den folgenden Methoden:

• Eine Methode zur Berechnung der Fläche des Rechtecks.
• Eine Methode zur Berechnung des Umfangs des Rechtecks.

 # Python Code class Rechteck:     def __init__(self, laenge, breite):         self.laenge = laenge         self.breite = breite      def berechne_flaeche(self):         return self.laenge * self.breite      def berechne_umfang(self):         return 2 * (self.laenge + self.breite)  rechteck = Rechteck(5, 10) print(rechteck.berechne_flaeche()) print(rechteck.berechne_umfang()) 

 // Java Code public class Rechteck {     private double laenge;     private double breite;      public Rechteck(double laenge, double breite) {         this.laenge = laenge;         this.breite = breite;     }      public double berechneFlaeche() {         return this.laenge * this.breite;     }      public double berechneUmfang() {         return 2 * (this.laenge + this.breite);     }      public static void main(String[] args) {         Rechteck rechteck = new Rechteck(5, 10);         System.out.println(rechteck.berechneFlaeche());         System.out.println(rechteck.berechneUmfang());     } } 

Lösung:

Vergleiche die Unterschiede zwischen den Programmierkonzepten in Python und Java anhand der unten genannten Basiskonzepte:

• Datentypen: Python: int, float, str, list, Java: int, double, String, ArrayList
• Variablendeklaration: Python: x = 5, Java: int x = 5
• Konditionale: Python: if, elif, else, Java: if, else if, else
• Schleifen: Python: for, while, Java: for, while
• Funktionen/Methoden: Python: def, Java: void und Rückgabewert
• Klassen und Objekte: Syntax Unterschiede, OOP Konzepte

• Eine Methode zur Berechnung der Fläche des Rechtecks.
• Eine Methode zur Berechnung des Umfangs des Rechtecks.

# Python Codeclass Rechteck:     def __init__(self, laenge, breite):         self.laenge = laenge         self.breite = breite     def berechne_flaeche(self):         return self.laenge * self.breite     def berechne_umfang(self):         return 2 * (self.laenge + self.breite) rechteck = Rechteck(5, 10)print(rechteck.berechne_flaeche())print(rechteck.berechne_umfang())

// Java Codepublic class Rechteck {    private double laenge;    private double breite;    public Rechteck(double laenge, double breite) {        this.laenge = laenge;        this.breite = breite;    }    public double berechneFlaeche() {        return this.laenge * this.breite;    }    public double berechneUmfang() {        return 2 * (this.laenge + this.breite);    }    public static void main(String[] args) {        Rechteck rechteck = new Rechteck(5, 10);        System.out.println(rechteck.berechneFlaeche());        System.out.println(rechteck.berechneUmfang());    }}

c)

Beschreibe die Fehler- und Ausnahmebehandlung in Python und Java. Implementiere ein Beispiel in beiden Sprachen, das eine Division durch Null abfängt und eine entsprechende Fehlermeldung ausgibt.

• Python: Verwende `try` und `except`.
• Java: Verwende `try` und `catch`.

 # Python Code try:     result = 10 / 0 except ZeroDivisionError as e:     print('Fehler: Division durch Null ist nicht erlaubt.') 

 // Java Code public class Main {     public static void main(String[] args) {         try {             int result = 10 / 0;         } catch (ArithmeticException e) {             System.out.println('Fehler: Division durch Null ist nicht erlaubt.');         }     } } 

Lösung:

Vergleiche die Unterschiede zwischen den Programmierkonzepten in Python und Java anhand der unten genannten Basiskonzepte:

• Datentypen: Python: int, float, str, list, Java: int, double, String, ArrayList
• Variablendeklaration: Python: x = 5, Java: int x = 5
• Konditionale: Python: if, elif, else, Java: if, else if, else
• Schleifen: Python: for, while, Java: for, while
• Funktionen/Methoden: Python: def, Java: void und Rückgabewert
• Klassen und Objekte: Syntax Unterschiede, OOP Konzepte

• Python: Verwende try und except.
• Java: Verwende try und catch.

# Python Codetry:     result = 10 / 0except ZeroDivisionError as e:    print('Fehler: Division durch Null ist nicht erlaubt.')

// Java Codepublic class Main {    public static void main(String[] args) {        try {            int result = 10 / 0;        } catch (ArithmeticException e) {            System.out.println('Fehler: Division durch Null ist nicht erlaubt.');        }    }}