Hol' Dir diese Lernkarten, lerne & bestehe Prüfungen. Kostenlos! Auch auf iPhone/Android!

Antwort

zentrale Aufgabe: optimale Struktur für Datenbank finden, vor dem Programmieren

1. Fachliche Analyse und fachlicher Entwurf (ER-Datenmodell ohne Berücksichtigung von DV-Aspekten)
2. DV-technischer Entwurf (Relationales Datenmodell)
3. Codierung (SQL-Anweisungen)
3a. Datendefinition (Basisrelationen, Benutzersichten, Indexe)
3b Datenabfrage und Datenmanipulation

-konsistente Datenhaltung (Redundanzfreiheit, Mehrbenutzerkontrolle, Recovery)
-hohe Verfügbarkeit und Absturzsicherheit
-Zugriffsschutz
-schneller Datenzugriff
-zentrale Daenverarbeitung mit unterschiedlichen Anwendersichten
-einfache, umfassende Datenbanksprache SQL
-standardisierte Zugriffsschnittstellen

->nur voll ausschöpfbar, wenn Struktur im Hintergrund optimal

• Greift Datenbankmodelle auf, die in der Vergangenheit aus verschiedensten Gründen in Vergessenheit
geraten sind
• Grundlegene Idee: Verzicht auf die starren Schemata der Tabellen ihrer relationalen Pendants
• NoSQL-Ausprägungen lassen sich in vier Hauptkategorien aufteilen:
- dokumentenorientierte Datenbanken ("document stores")
- Key-Value-Datenbanken
- spaltenorientierte Datenbanken
- Graphendatenbanken
• Stärken in bestimmten Bereichen: flexibler Umgang mit variablen Daten (dokumentorientierte
Datenbanken), das Abbilden von Beziehungen (Graphen-Datenbanken) oder auch die Reduzierung einer
Datenbank auf einen Behälter für Schlüssel-Werte-Paare (Key-Value-Datenbanken).
Dennoch: Für unternehmenskritische Speicheranwendungen wird das relationale SQL-Modell noch
lange Zeit maßgebend sein.

-Modellierung von Datenbank ohne spezifisches technisches Wissen über Zieldatenbank zu haben.
-Strukturierte Beschreibung gleichartiger Informationsobjekte (Entitäten)

Attribut:
-atomar (z.B. Geschlecht)
-zusammengesetzt (z.B. Name aus Vor- und Nachname)
-abgeleitete Atribute nicht erlaubt

Wertebereich:
-Zahl
-Zeichen
-Datum
-Zeit,
-Boolean {männlich / weiblich}
-Aufzählung {deutsch, englisch,spanisch)

Primärschlüssel:
-alle Entitäten müssen eindeutig identifizierbar sein
-in ER-Modell unterstreichen
-Schlüsselkandidat: minimale Attributkombination mit identifizierender Eigenschaft

Weak-Entitätstyp:
-von anderen Entitätstypen abhängig (Angestellter->weak Kind)
-kein eigener Primärschlüssel

Integritätsbedingungen
-garantieren ordnungsgemäßen Zustand, Integrität einer DB
-Angaben für Attribute (Wertebereich und Primärschlüssel, EINDEUTIG, [min .. max], Standard = <Wert>, CHECK (<Bedingung>)


Entität:

Objekt:

-Entitätstypen mit Verbidung zu anderen Entitätstypen
-Beschreibung mittels Strukturierunselemente
->Grad
->Beziehungstypen (Assoziation, Abhängigkeit, Aggregation, Generalisierung)
->Beziehungsentitätstyp
->Multiplizität
->Rolle
->Attribut
->Fremdschlüssel
->Primärschlüssel

-Verben als Bezeichner (bei Entitätstypen = Substantive) zwecks natürlichsprachlichen Lesen
->im ER-Diagramm: Verbindungslinien zwischen den Entitätstypen
->bei Grad > 2 Verbindungslinien zentral in einer Raute sammeln

Spezielle Beziehungstypen:
Abhängigkeit:
-zwischen normalen Entitätstyp und Existenz-abhängigem Weak-Entitätstyp
Aggregation/Komposition:
-Verbindung zwischen einem Ganzen (Aggregat) und dessen Bestandteilen (Komponenten)
-normale Aggregation -> Komponente gehört zu keinem, einem oder mehreren Aggregaten [1->0..*]
leere Raute
-starke Aggregation (Komposition) -> Komponente existiert nur mit genau einem Aggregat [1->1]
gefüllte Raute

Abhängigkeit
-Zwischen Weak-Entitätytyp und Entitätstyp
-Existenz eines Informationsobjektes des Weak-Entitätstyps hängt von Existenz eines Informationsobjektes des Entitätstyps ab
->gestrichelter Pfeil in ER-Diagramm

Aggregation/Komposition
-"ist Teil von"-Beziehungstyp
-Verbindung zwischen einem Ganzen und dessen Betandteilen
-normale Aggregation: ein konkretes Komponent-Informationobjekt kann zu einem oder mehrerern Ganzes-Informationsobjekten gehören
->Unausgefüllte Raute bei Aggregat-Entitätstyp
-starke Aggregation: Komposition jedes konkrete Komponent-Informationsobjekt gehört zu genau einem Ganzes-Informationsobjekt
->Ausgefüllte Raute bei Aggregat-Entitätstyp
->Multiplizität immer 1

Generalisierung
-bestimmte Entitätstypen werden zu allgemeinem Entitätstyp zusammengefasst (Konzept der Vererbung)
-Super-Entitätstyp und Sub-Entitätstyp
->unausgefülltes Dreieck zu Super-Entitätstyp
Spezialisierung Sub-Entitätstyp unterscheidet sich, ist also spezialisiert

-wie viele konkrete Beziehungen ein Informationsobjekt des einen Typs mit einem Informationsobjekt des anderen Typs haben kann
-Angabe mithilfe von Unter- und Obergrenze

keine oder eine Beziehung 0..1
genau eine Beziehung 1..1
keine oder mehrere Beziehungen 0..*
eine oder mehrere Beziehungen 1..*
spezielle Anzahl 3..3
spezieller Bereich 3..5

-bei Entitätstypen kann Rolle angegeben werden
-sehr hilfreich bei rekursiven Beziehungstypen

Angeben bei Beziehungstyp

Total: alle Entitätstypen sind abgebildet
partiell: nicht alle Entitiätstypen sind aufgeführt

disjunkt: klar getrennte Entitäten (Professor kann nicht Verwaltungsangesteller sein)
nicht disjunkt: (Kunde kann auch Angestellter sein)

ER-Modell muss in Relationales Datenmodell überführt und normalisiert werden, um in SQL umgesetzt werden zu können

Entitäts -> Relation (in Tabellenform)
Attribute -> atomare, einwertige Attribute in normalisierter Relation
Beziehungstyp -> PS, FS referenziert <Relation> (<Attribut>)

Wertebereich
-INTEGER, DECIMAL [(4,2)]
-CHAR, VARCHAR
-DATE
-TIME
-BOOLEAN
-Aufzählungen müssen mit CHECK(VALUE IN(...)) umgesetzt werden
-WEAK-Entitätstyp bekommt in Relation künstlichen Primärschlüssel

-NOT NULL (bei PS implizit)
-UNIQUE (bei PS implizit)
-DEFAULT = <Wert>
-CHECK (<Bedingung>)

Normalisierungsregeln helfen dabei, Datenunstimmigkeiten/Inkonsistenzen zu vermeiden
->Anomalien beim Einfügen, Ändern, Löschen

Letztendlich werden bei der Normalisierung die voneinander abhängigen Attribute in eine gemeinsame Relation zusammengefasst
->zunächst muss geklärt werden, welche Attribute von welchen anderen Attribute abhängen

Funktionale Abhängigkeiten
Attribut A bestimmt ein anderes Attribut B in der weise, dass alle Datensätze die den gleichen Wert für A aufweisen, auch immer den gleichen Wert für B aufweisen
->B ist funktional abhängig von A
-transitive Schlüsse: A->B und B->C gilt also auch A->C

Mehrwertige Abhängigkeiten
Ein Attribut A bestimmt ein mehrwertiges Attribut (z.B. PNr bestimmt mehrere Ausprägungen von Student)
A1,...,An -> -> B

1. Normalform
-Relation darf nur atomare, einwertige Attribute aufweisen
->Lagere das mehrwertige Attribut in eine eigene, zusätzliche Relation aus
->Ist das mehrwertige Attribut strukturiert, löse es in seine Einzelattribute auf
->Ergänze die zusätzliche Relation mit dem PS der Ursprungsrelation als FS, um Beziehung herzustellen
->Bestimme in der Zusatzrelation einen geeigneten Primärschlüssel

2. Normalform
-1. Normalform liegt vor
-alle Nichtschlüsselattribute sind nur von jedem Schlüsselkandidaten voll funktional abhängig
->Lagere alle Nichtschlüsselattribute, die von einem bestimmten Teilschlüssel abhängig sind, in eine eigene zusätzliche Relation aus
->Ergänze die zusätzliche Relation mit dem betreffenden Teilschlüssel und definierte ihn dort als PS
->In der Ausgangsrelation wird der betreffende Teilschlüssel als FS verwendet, um die Beziehung zur neuen Zusatzrelation hertzstellen

3. Normalform
-1. und 2. Normalform liegt vor
-kein Nichtschlüsselattribut ist funktional abhängig von einem anderen Nichtschlüsselattribut
->Lagere alle Nichtschlüsselattribute, die von einem bestimmten Nichtschlüsselattribut abhängig sind in eine eigene, zusätzliche Relation aus
->Ergänze die zusätzliche Relation mit den jeweils bestimmenden Nichtschlüsselattributen und definiere sie dort als PS
->In der Ausgangsrelation werden die jeweils bestimmenden Nichtschlüsselattribute als FS verwendet, um die Beziehung zur neuen Zusatzrelation herzustellen

Boyce-Codd-Normalform
-3. Normalform liegt vor
-Relation weist keine Teilschlüsselabhängigkeiten auf
->Lagere alle Attribute, die von einem bestimmten Teilschlüssel abhängig sind in eine eigene zusätzliche Relation aus
->Ergänze die zusätzliche Relation mit dem betreffenden Teilschlüssel und definiere ihn dort als Primärschlüssel
->In der Ausgangsrelation wird der betreffende Teilschlüssel als Fremdschlüssel verwendet um die Beziehung zur neuen Zusatzrelation herzstellen

4. Normalform
-Boye-Codd-Normalform liegt vor
-Relation weist keine mehrwertigen Abhängigkeiten auf
->Zerlegungsvefahren wie bei 1NF

1. NF: mehrwertige Attribute in gesonderte Relation auslagern

2. NF: Teilschlüsselabhängigkeiten beseitigen

3. NF: Nichtschlüsselabhängigkeiten beseitigen

Relationales Datenmodell wird nun mithilfe von SQL in Zieldatenbank umgesetzt

SQL = Structured Query Language, gilt für alle Datenbanken aber teilweise noch durch Hersteller erweitert

-Datendefinition (DDL) CREATE SHEMA
-Datenmanipulation (DML) = Create, Update, Delete, Alter
-Datenabfrage (DQL) SELECT

alle Definitionen für rel. Datenbank werden in relationalem Schema gesammelt

Definition leeres Schema
CREATE SCHEMA <Schema-Name>
Löschen von Datenbankschema
DROP SCHEMA <Schema-Name>

Tabelle erstellen:
CREATE TABLE <Tabellenname> (<Attributname> <Datentyp> [<Attribut-Integritätsbedingungen>])

• INT (Ganzzahl)
• SMALLINT(Ganzzahl klein)
• DECIMAL(p,[q]) (insgesamt p stellen, q davon Dezimalstellen)
• CHAR(n) (alphanummerische Zeichenkette mit fester länge
• VARCHAR(n) (alphanummerische Zeichenkette mit variabler länge)
• CLOB (m [K|M|G])
• BOOLEAN (Wahrheitswerte)
• DATE (Datum als Zeichenkette JJJJ-MM-TT)
• TIME (Uhrzeit als Zeichenkette HH:MM:SS)
• TIMESTAMP (Zeitstempel als Zeichenkette JJJJ-MM-TT HH:MM:SS)

• UNIQUE
• NOT NULL (implizit bei PRIMARY KEY)
• DEFAULT <Default-Wert>
• CHECK (<<Attributname> <Prüfbedingung>)
• PRIMARY KEY
• FOREIGN KEY REFERENCES <Tabellen-Name> (<Attribut-Name>)

• <Vergleichsoperator> <Wert-Ausdruck>
mit:
<Vergleichsoperator>: = | < | <= | > | >= | <>
<Wert-Ausdruck>: <konkreter Wert>

• [NOT] IN (<Werte-Aufzählung> | <SELECT-Anweisung>)
• [NOT] BETWEEN <Untergrenze> AND <Obergrenze>
• [NOT] LIKE <Textmuster> [ESCAPE <Sonderzeichen>]

<Textmuster>
'_blaa' genau eine Stelle
'%blaa' beliebig viele Stellen

ALTER TABLE <Tabellenname>
ADD [COLUMN] <Attribut-Name> <Datentyp> [<Attribut-Integritätsbedingungen>]|
DROP [COLUMN] <Attribut-Name> CASCADE | RESTRICT

->wird benötigt wenn sich Relationen mit FS gegenseitig referenzieren

"virtuelle" Tabelle (Benutzersicht) aus verschiedenen realen Tabellen, um Nutzer die geeignete Sicht geben zu können

CREATE VIEW <View-Name> [(<Liste Attribut-Namen>)] AS <SELECT-Anweisung>

-in großen relationalen Datenbeständen brauchen bestimmte Attribute einen Index, um schnell darauf zugreifen zu können

CREATE [UNIQUE] INDEX <Index-Name> ON <Tabellen-Name> (<Attribut-Name> [ASC|DESC])

DROP TABLE <Tabellen-Name> CASCADE | RESTRICT

Löscht nicht nur Inhalt einer Tabelle sondern auch deren Definition

Datensätze suchen
SELECT [DISTINCT] * | <Attribut1> [AS <neuer Attr.-Name1>] [, ...]

FROM <Tabelle1> [,..]

[WHERE <Verknüpfungs- und Selektionsbedingungen>]
[GROUP BY <Liste Attribut-Namen>]
[ORDER BY <Attribut-Name1> [ASC|DESC]
->Alle Datensätze mit den gleichen Werten bei den im GROUP BY Teil genannten Attributen kommen in eine Gruppe)

Selektionsbedingungen
- <Attribut-Name> <Verleichsoperator> <Wert-Ausdruck>
- <Attribut-Name> [NOT] IN (<Werte-Aufzählung>|<Subabfrage>)
- <Attribut-Name> [NOT] BETWEEN <Untergrenze> AND <Obergrenze>
- <Attribut-Name> [NOT] LIKE <Textmuster>
- [NOT] EXISTS (<Subabfrage>)

COUNT(*)
COUNT ([DISTINCT] <Attribut-Name>)
SUM ([DISTINCT] <Attribut-Name>)
AVG ([DISTINCT] <Attribut-Name>)
MIN (<Attribut-Name>)
MAX (<Attribut-Name>)

Daten
"eine wieder interpretierbare Darstellung von Informationen in formalisierter Art, geeignet zur Kommunikation, Interpretation, Verarbeitung

Datenbank
logisch zusammenhängender Datenbestand

Datenbankmanagementsystem (DBMS)
Verwaltungssoftware zum Betreiben der Datenbank
->über SQL bedient
->Oracle, SQL Server, DB2, MySQL

Datenbanksystem (DBS)
DBMS + DB

CREATE TABLE <table> (<columns>)
Erzeugt eine neue Tabelle mit den angegebenen Spaltendefinitionen.

INSERT INTO <table> (<columns>) values (<values>)
Fügt einen neuen Datensatz in die angebene Tabelle ein.

UPDATE <table> SET <column>=<value> WHERE<constraint>
ändert in den vorhandenen, über die Bedingung ausgewählten Datensätzen die angegebene(n) Spalte(n).

DELETE FROM <table> where <constraint>
entfernt die betreffenden Datensätze.

SELECT <column> FROM <table>
fragt Datensätze ab, optional eingeschränkt mit
WHERE <constraint>
und geordnet gemäß
ORDER BY <column>

-fungiert als Vermittler zwischen Java-Programm und DBS
-Der Kern besteht aus einer Sammlung von Klassen und Interfaces in den Paketen java.sql / javax.sql
-mit JDBC enthält keinen DBspezifischen Code
-JDBC ist eine ABstraktionsschicht und ermöglicht DBneutralität bzw. einfachen Austausch des DBMS
-DBMS-Anbieter implementieren und Erweitern den Standard mit eigenen JDBC-Treibern

Verschiedene Typen von Treibern.
Typ3 sehr flexibel mit Middleware (DBMS kann ersetzt werden), aber auch komplex
Typ4 am einfachsten aber DBMS abhängig

C(onnection), S(tatement), R(esultSet)
0. Parameter Definieren:
String ConnectionURL ="jdbc:mysql://localhost:3306/dhbw";
String user = "root";
String pw="";
String query1 ="SELECT * FROM Student";

1. Connection
Connection con = null;
con = DriverManager.getConnection(ConnectionURL,user,pw);

2. Statement erstellen
Statement stmt1 = con.createStatement();

3. Statement ausführen
ResultSet rset1 = stmt1.executeQuery(query1);
bzw.
executeQuery (SELECT)
executeUpdate (DELETE, INSERT, UPDATE)

4. ResultSet auswerten
getXXX("Spalte"); Methoden für alle primitiven Java-Datentypen
->getString() funktioniert immer!

while (rset.next()) {
System.out.println(“MNr.: ”+rset.getInt(‚MNr‘)+“ Land: “+rset.getString(2));
}

5. Ressourcen freigebe
close(); Methode
rset1.close();
stmt1.close();
con.close();

-JDBC-Methoden müssen immer in try & catch construkt

try {
// Aufruf von JDBC-Methoden
...
} catch (SQLException exc) {
System.out.println("SQLException: "+
exc.getMessage());
}

ResultSetMetaData rsetmeta = rset1.getMetaData();

Dort dann Methoden wie "getColumnCount()" ausführen.
while(rset1.next())
{
for(int i=1; i<=rsetmeta.getColumnCount();i++)
{
System.out.print(rset1.getString(i));
}
System.out.println();
}

SQL
Statement s = cd.createStatement();
ResultSet r = s.executeQuery("SELECT COUNT(*) AS rowcount FROM TableName");
r.next(); //immer eins weiter, da sonst null
int count = r.getInt("rowcount");
r.close();
System.out.println("MyTable has " + count + " row(s).");

COUNTER
int counter =0;
while (rset.next())
{
counter ++
}
System.out.println("MyTable has " + counter + " row(s).");

Cursor
rs.last();
int rows = rs.getRow();
System.out.println("MyTable has " + rows+ " row(s).");

-Erzeugen des Statements mit Paramtern:
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE); //Standard TYPE FORWARD ONLY, READ ONLY

1. Paramter
TYPE_FORWARD_ONLY (default)
ResultSet wird sequenziell durchgeführt

TYPE_SCROLL_INSENSITIVE
Es kann beliebig im ResultSet manövriert werden, Änderungen in der Datenbank am ursprünglich berechneten Ergebnis werden nicht bemerkt

TYPE_SCROLL_SENSITIVE
Es kann beliebig im ResultSet manövriert werden, Änderungen in der Datenbank am ursprünglich berechneten Ergebnis werden bemerkt
2. Parameter
CONCUR_READ_ONLY (default)
Es wird nur im ResultSet gelesen

CONCUR_UPDATABLE
ResultSet kann bearbeitet werden

An gewünschte Position springen

Ändern:
rset.updateString(„Name“, „Müller“)
ODER
rset.updateInt(2, 42)
Zeile Löschen
rset.deleteRow()
kein rset.upgdateRow() erforderlich
Neue virtuelle Zeile konsturieren und in DB eintragen
rset.moveToInsertRow()
rset.insertRow()
Auf Datenbank "pushen"
rset.updateRow()

Beispiel1
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE); Standard TYPE FORWARD ONLY, READ ONLY
Übung 1: Bestandmenge um 10, Preis*2
{
SQL Query ausführen und in ein ResultSet zurückschreiben
ResultSet rset = stmt.executeQuery(query);
Curser auf die Position 1 setzen
rset.next(); oder rset.absolute(1) oder rset.first())
Lagerbestand auf 10 setzen
rset.updateInt("quantityInStock", 10); wo und dann neuer Wert
Preis verändern
double neuerPreis = rset.getDouble("buyPrice") *2; Preis verdoppeln
rset.updateDouble("buyPrice", neuerPreis); in ResultSet eintragen
ResultSet mit DB syncen
rset.updateRow();


Beispiel2
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE); //Standard TYPE FORWARD ONLY, READ ONLY
{

ResultSet rset = stmt.executeQuery(query);
rset.moveToInsertRow();
rset.updateInt("customerNumber",103);
rset.updateString("checkNumber","HQ336337");
rset.updateString("paymentDate","2014-10-23");
rset.updateDouble("amount", 313.37);
rset.insertRow();

-Ausnutzen von Sicherheitslücken im Zusammenhang mit SQL-Datenbanken
-tritt meist durch mangelnde Maskierung/Überprüfung von Benutzereingaben auf, die direkt zum SQL-Interpreter gelangen
-Angreifer versucht eigene SQL Funktionen in Datenbank einzuschleußen

-Prepared Statement ist fest vorgegebenes Statement mit offenen Werten (?).
-DBMS bereitet Ausführung vor
-Offenen Werte werden nachtrgälich definiert
-Statement wird ausgeführt
-Ressourcen werden über clearParameters() wieder freigegeben

String multiQ="SELECT * FROM konto WHERE Name  = ? AND Passwort = ?";
PreparedStatement pStat1 = con.prepareStatement(multiQ);
pStat1.setString(1, "wasnlos"); //Kann beliebig oft wiederholt werden
pStat1.setString(2, passwd);
ResultSet rset1 = pStat1.executeQuery();
clearParameters()

->SQL Injektions erschwert, da DBMS schon weiß was kommen müsste!

-Funktionen (Routine mit Rückgabewert) oder Prozeduren (Routine eist ohne Rückgabewert)
-Stored Procedures/Functions wird Logik direkt durch das DBMS ausgeführt

->Kommunikation zwischen Client und Server wird minimiert (schnellere Verarbeitung der SQL-Statements)
->Routinen sichern Datenintegrität
->beliebig viele Anweisungen können in einer Routine zusammengefasst werden (Verringern der Komplexität bei Ausführung)
->Routinen können Bedingungen zur Ablaufsteuerung enthalten
->Clients benötigen keine echte für INSER, DELETE oder UPDATE Anweisungen
->Gefahr von SQL-Injektions wird stark verringert

Vorgehen:
-Routine muss in DBMS erstellt werden
DELIMITER $
CREATE PROCEDURE updateAll()
  BEGIN
    ...
  END$
DELIMITER ;

-Routine wird (z.B. durch Java) aufgerufen
CallableStatement cstmt = con.prepareCall(“{CALL updateALL()}“);
cstmt.execueQuery();

-Folge von Atomaren Datenbankoperationen
-Anweisungen werden entweder alle ausgeführt und abgeschlossene (commited) oder alle zurückgenommen (rolled back) -> ACID(Atomicity, Consistency, Isolation und Durability)-Prinzip
-Anweisungen können automatisch oder manuell gestartet werden (Standard Auto-Commit-Modus)

1. Auto-Commit-Deaktivieren
con.setAutoCommit(false);
2. Datenbankoperationen werden ausgeführt
stmt.executeQuery(sql1);
stmt.executeQuery(sql2);
3. Transaktionen werden abgeschlossen und permanent gespeichert
con.commit();
4. Transaktionen werden rückgängig gemacht
con.rollback();