Processing math: 100%

Wiki

A universe of ideas

User Tools

Site Tools


uni:8:dbs2:zusammenfassung

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Next revision
Previous revision
uni:8:dbs2:zusammenfassung [2015-07-16 17:11] – created skrupellosuni:8:dbs2:zusammenfassung [2020-11-18 18:11] (current) – external edit 127.0.0.1
Line 1: Line 1:
 ====== Zusammenfassung ====== ====== Zusammenfassung ======
 +Die Mega-Übersicht
 +<code>
 +Synchronisation
 + Pessimistische Synchronisation mit Sperren
 + Sperrprotokolle
 + 2PL [deadlocks]
 + Konservatives 2PL
 + Striktes 2PL [deadlocks]
 + Konservatives + Striktes 2PL
 + Sperrverfahren
 + RX
 + RUX
 + RAX
 + RIX
 + RAC
 + Deadlocks
 + Vermeiden [konservatives 2PL/precaiming]
 + Erkennen
 + Wartegraph
 + Time-Out
 + wound-wait
 + wait-die
 + Pessimistische Synchronisation mit Zeitstempeln
 + Optimistische Synchronisation mit Zeitstempeln
 + BOCC
 + BOCC+
 + FOCC
 +</code>
 +
 +  * [[Synchronisation]]
 +
 +===== Grundbegriffe =====
 +==== Anforderungen (Codd) ====
 +  * **Integration** //einheitlicher// Zugriff auf //alle// Daten einer Anwendung
 +  * **Operationen** auf den Daten (ändern, löschen, ...)
 +  * **Data Dictionary** Schema anschauen
 +  * **Benutzersicheten** views
 +  * **Konsistenzüberwachung** bei Änderung
 +  * **Zugriffskontrolle**
 +  * **Transaktionen**
 +  * **Synchronisation** (Mehrbenutzersystem)
 +
 +==== Ebenen ====
 +|  Anwendungen (mehrere)                                       ||
 +^         Externe Ebene | Views (mehrere)                       |
 +^                        ↓↓ Logische Datenunabhängigkeit ↓↓   |
 +^  Konzeptionelle Ebene |                                       |
 +^                        ↓↓ Physische Datenunabhängigkeit ↓↓  |
 +^         Interne Ebene | Speicherformat                        |
 +
 +==== ACID ====
 +  * Atomic (Wenn, dann wird man als ganzes abgebrochen)
 +  * Consistency (Konsistenter Zystand -> Konsistenter Zustand)
 +  * Isolation (Man muss sich aleine fühlen)
 +  * Durability (Abgeschlossene Transaktionen sind von dauer)
 +
 +
 +==== Serialisierungs-Graph ====
 +^ x ^ y ^ z | <- Attribute |
 +r1  |  w2  |  r1  | <- OperationTransaktion |
 +r2  |  r3  |  w1  | ::: |
 +w2  |  w3  |  r4  | ::: |
 +|                  w3  | ::: |
 +
 +Spaltenweise von oben nach unten die wr(x),rw(x),ww(x)-Paare finden
 +
 +==== Anomalien ====
 +=== Lost update ===
 +^ t1 |  r(x)  |        |  w(x)  |
 +^ t2 |        |  w(x)  |        |
 +
 +=== Dirty read/write ===
 +^ t1 |  w(x)  |        |  w(x)  |
 +^ t2 |        |  r(x)  |        |
 +
 +=== Non-repeatable read ===
 +^ t1 |  r(x)  |        |  r(x)  |
 +^ t2 |        |  w(x)  |        |
 +
 +=== Phantom-Problem ===
 +//Non-repeatable read// mit Aggregiertem read
 +
 +==== Eigenschaften von Schedules ====
 +Eigenschaften eines Schedules:
 +^  Schedule ^ Beschreibung ^
 +| allgemein                     | Durcheinander                                              |
 +| seriell                       | Blockform                                                  |
 +| serialisierbar                | allgemein + seriell (Zyklenfrei)                           |
 +| rücksetzbar                   | ''commit'' erst nach ''commit'' von denen ich gelesen habe |
 +| ohne kaskadiertes \\ Rollback | Keine Daten einer laufenden TA lesen                       |
 +| strikt                        | Keine Daten einer laufenden TA lesen/schreiben             |
 +
 +
 +Eigenschaften zwischen Schedules:
 +^  Schedule ^ Beschreibung ^
 +| konfliktäquivalent | Gleiche Abhängigkeitsmengen |
 +
 +===== Integrität =====
 +  * Schlüssel-~
 +  * Referenzielle ~
 +  * Multiplititäten Constraints
 +  * Allgemeine Constraints
 +
 +===== Datenschutz =====
 +==== Discretionary Access Controll (DAC) ====
 +Explizite Autorisierung:
 +<blockquote>//Subjekt// bekommt //Zugriffsrecht// auf //Objekt//</blockquote>
 +  grant ... on ... to ...
 +  
 +==== Verfeinertes DAC ====
 +Implizite Autorisierung:
 +  * //starke// Autorisierung überschreibt //schwache// Autorisierung
 +  * Es gibt //positive// und //negative// Autorisierung
 +  * Subjekte, Objekte und Operationen haben eine Hierarchie
 +
 +
 +  * Implizite Weitergabe positiver Autorisierung in die eine Richtung
 +  * Implizite Weitergabe negativer Autorisierung in die andere Richtung
 +
 +==== Mandatory Access Control (MAC) ====
 +  * Sicherheitsklassen für //Subjekte// und //Objekte//
 +  * Objekte hochstufen (V)
 +  * Objekte runter stufen (X)
 +  * Zugriff wenn ''class(S) >= class(O)''
 +  * Angelegte Objekte ''class(S) =< class(O)''
 +
 +===== HW =====
 +B+
 +  * Directory/Index Seiten
 +  * Datenseiten
 +
 +  * **Sequenziell** \\ tscan=tseek+fttransfer+fcpuffertlat
 +  * **Wahlfrei** \\ trandom=(tseek+cindexttransfer+tlat)a
 +
 +===== Anfrageoptimierung =====
 +==== Arten ====
 +  * **Logische Anfrageoptimierung** \\ Auswertungsplan umbauen
 +  * **Physische Anfrageoptimierung** \\ Algorithmen auswählen
 +
 +==== Logische Anfrageoptimierung ====
 +=== Umformungsregeln ===
 +  * RS=SS
 +  * RS=SR
 +  * RS=SR
 +  * R×S=S×R
 +  * (RS)T=R(ST)
 +  * (RS)T=R(ST)
 +  * (RS)T=R(ST)
 +  * (R×S)×T=R×(S×T)
 +  * σA(σB(R))=σB(σA(R))
 +  * σAB(R)=σA(σB(R))
 +  * πA(πB(R))=πA(R) mit AB
 +  * πA(σB(R))=σB(πA(R)) mit attr(B)A
 +  * σB(RS)=σB(R)S mit attr(B) attr(R)
 +  * σB(R×S)=σB(R)×S mit attr(B) attr(R)
 +  * σB(RS)=σB(R)σB(S)
 +  * σB(RS)=σB(R)σB(S)
 +  * σB(RS)=σB(R)σB(S)
 +  * πB(RS)=πB(R)πB(S)
 +  * σA=B(R×S)=RA=BS
 +
 +=== Algo ===
 +  - σ splitten
 +  - σ nach unten
 +  - σ und × =>
 +  - π einfügen, um auf minimum beschränken
 +  - π nach unten
 +  - σ mergen
 +
 +===== Big Data =====
 +  * high-**volume**
 +  * high-**velocity**
 +  * high-**variety**
 +
 +==== Map-Reduce ====
 +  - **Map** \\ Data => KV-Pair
 +  - **Shuffle** \\ Same key to same node
 +  - **Reduce** \\ Marge Values per Key
 +
 +==== Zählanfrage auf unsicheren Daten ====
 +F=(1P(A)+xP(A))
 +
 +==== Data Warehouse ====
 +| OLTP                          | OLAP                         |
 +| Online Transaction Processing | Online Analytical Processing |
 +| Detail                        | Nur relevante                |
 +| Aktuelle                      | Historische                  |
 +| Ist eine quelle               | Hat viele quellen            |
 +| Veränderbar                   | Nur hinzufügen               |
 +
 +<blockquote>//Fakten// in //hierachischen// //Dimensionen//</blockquote>
 +
 +=== Relationales mapping ===
 +Faktentabelle in der Mitte
 +== Snowflake ==
 +Eine Tabelle pro Hierachieebene pro Dimension
 +
 +== Star ==
 +Eine Tabelle pro Dimension
 +
 +
 +===== Recovery =====
 +==== Fehlerarten ====
 +  * Transaktionsfehler => Rücksetzen
 +    * Lokales UNDO
 +  * Systemfehler => Warmstart
 +    * Globales UNDO
 +    * Globales REDO
 +  * Medienfehler => Geräte-Recovery
 +    * Globales REDO
 +
 +==== Logging ====
 +  * Physisch [Bit-Blöcke]
 +    * Übergangslogging [XOR]
 +    * Zustandslogging [Volle ...]
 +      * Seiten-Logging [... Seiten]
 +      * Eintrags-Logging [... Einträge]
 +  * Logisches Logging [Befehle/Parameter loggen]
 +  * Physiologisches Logging [Befehle/Parameter pro Seite]
 +
 +=== Aufbau Log-File ===
 +Ringbuffer
 +  * LSN (Fortlaufende Nummer)
 +  * TA-ID (Welche Transaktion)
 +  * Page-ID (Welche Seite)
 +  * REDO
 +  * UNDO
 +  * PrevLSN
 +
 +Log-Granularität <= Sperrgranularität
 +
 +=== Einbringungsstrategie (wo in DB) ===
 +  * Direkt (NonAtomic, Update in-place) => UNDO nötig
 +  * Indirektes Einbringen (Atomic) ["Daneben ablegen"] => Kein UNDO nötig
 +
 +=== Verdrängungsstrategien (wann frühestens Puffer -> DB) ===
 +  * No-Steal [Nach COMMIT] => Kein UNDO
 +  * Steal [egal] => UNDO
 +
 +WAL-Prinzip: UNDO muss vor Änderungen an DB im Log stehen
 +
 +=== Ausschreibungsstrategie (wann spätestens Puffer -> DB) ===
 +  * Force [Vor COMMIT] => Kein REDO
 +  * No-Force [egal] => REDO
 +
 +COMMIT-Regel: REDO muss vor COMMIT im Log stehen
 +
 +==== Sicherungen ====
 +=== Arten ===
 +  * TOC: Sicherung //einer// TA (entspricht Force)
 +  * TCC: Alle Änderungen raus schreiben, derweil keine //TA//.
 +  * ACC: Alle Änderungen raus schreiben, derweil keine //Operation//.
 +
 +=== Ablauf ===
 +| 1. Analyse   | Gewinner/Verlierer Bestimmen                    ||
 +| 2. REDO      | Vollständiges REDO          | Gewinner REDO      |
 +| 3. UNDO      | UNDO (damals) laufender TAs | UNDO verlierer TA  |
 +| 4. Abschluss | Sicherungspunkt erstellen                       ||
 +
 +  * Gewinner => COMMIT im log
 +  * Verlierer => Rest
uni/8/dbs2/zusammenfassung.1437059500.txt.gz · Last modified: 2020-11-18 18:10 (external edit)