<?xml version="1.0" encoding="UTF-8"?>
<!-- generator="FeedCreator 1.8" -->
<?xml-stylesheet href="https://www.proggen.org/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="https://www.proggen.org/feed.php">
        <title>proggen.org dbs:sql</title>
        <description></description>
        <link>https://www.proggen.org/</link>
        <image rdf:resource="https://www.proggen.org/lib/tpl/proggenX/images/favicon.ico" />
       <dc:date>2026-04-12T11:13:07+0200</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:addmany&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:addone&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:alias&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:arithmfu&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:basesyntax&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:bcnf&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:befehlabf&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:changetable&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:corsubsel&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:create&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:createdb&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:createtable&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:datfu&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:dbtrans&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:delete&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:dreiebsch&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:firstowncreate&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:firstsolution&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:firsttable&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:funkab&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:groupby&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:grupfunk&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:having&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:hierm&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:index&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:insert&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:join&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:key&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:konvfu&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:nf&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:nf1&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:nf2&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:nf3&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:nf4&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:nwm&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:operatoren&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:orderby&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:preparation&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:requirement&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:select&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:seq&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:setop&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:source&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:sql&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:start&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:subsel&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:synonym&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:transa&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:unterabfr&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:update&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:vfa&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:views&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:where&amp;rev=1663869536"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:why&amp;rev=1663869537"/>
                <rdf:li rdf:resource="https://www.proggen.org/doku.php?id=dbs:sql:zeichfu&amp;rev=1663869537"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="https://www.proggen.org/lib/tpl/proggenX/images/favicon.ico">
        <title>proggen.org</title>
        <link>https://www.proggen.org/</link>
        <url>https://www.proggen.org/lib/tpl/proggenX/images/favicon.ico</url>
    </image>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:addmany&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Mehrere Zeilen in eine Tabelle einfügen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:addmany&amp;rev=1663869537</link>
        <description>Mehrere Zeilen in eine Tabelle einfügen

Syntax


INSERT INTO Tabellenname
[(Spaltenname1, Spaltenname2, ...)]
AS SELECT Selectliste from Tabelle ...



Bei dieser Methode des Einfügens werden mithilfe eines SELECT Befehls mehrere Zeilen in eine, meist neue und damit leere, Tabelle eingefügt. Die Zeile mit den Spaltennamen kann wieder weggelassen werden, wenn die Anzahl und Typen der im SELECT geforderten Spalten mit der Spaltenanzahl und den Typen, der Tabelle in der die Werte eingefügt werden,…</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:addone&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Einzelne Zeilen in Tabellen einfügen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:addone&amp;rev=1663869536</link>
        <description>Einzelne Zeilen in Tabellen einfügen

Mit dem „INSERT“ Befehl, ist es möglich, Daten in eine Tabelle einzufügen.

Syntax


INSERT INTO tabellenname
[(Spaltenname1, Spaltenname2, ...)]
VALUES(Wert1, Wert2, Wert3, ...)


Die Anzahl und der Typ von Spaltennamen und Werten muss übereinstimmen.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:alias&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Alias</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:alias&amp;rev=1663869537</link>
        <description>Alias

Ein Alias, ist ein vom Benutzer definierter Name für eine Spalte. Im vorigen Beispiel haben wir schon mit dem AS Operator und somit mit Aliase gearbeitet.

Man kann aber nicht nur Spaltenüberschriften mit Aliase ändern sondern vieles mehr.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:arithmfu&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Arithmetische Funktionen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:arithmfu&amp;rev=1663869537</link>
        <description>Arithmetische Funktionen

Mit arithmetischen (mathemtatischen/numerischen) Funktionen wird es dem Benutzer ermöglicht, die Darstellung von Zahlen zu ändenr (z.B. Werte runden)</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:basesyntax&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Basis SQL Select Syntax</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:basesyntax&amp;rev=1663869537</link>
        <description>Basis SQL Select Syntax

Der grundlegende Befehl in SQL ist der SELECT-Befehl. Mit ihm ist es uns möglich, Daten aus der Datenbank auszulesen. Der einfachste SELECT-Befehl besteht aus 2 Teilen. Dem SELECT-Teil, bei dem wir auswählen welche Elemente angezeigt werden sollen und der FROM-Teil unserer Abfrage. In diesem Teil des Befehls sagen wir der Datenbank, aus welchen Tabellen wir lesen wollen.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:bcnf&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>BCNF - Boyce/Codd Normalform</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:bcnf&amp;rev=1663869536</link>
        <description>BCNF - Boyce/Codd Normalform

Die BCNF ist eine Weiterentwicklung der 3. Normalform. 

Definition

Eine Relation befindet sich in BCNF, wenn sie in der 3. Normalform ist und jede Determinante, Schlüsselkandidat ist. (Es darf keine Determinante geben, die nicht Schlüsselkandidat ist).</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:befehlabf&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Abfolge einer SQL Anweisung</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:befehlabf&amp;rev=1663869537</link>
        <description>Abfolge einer SQL Anweisung</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:changetable&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Tabellen ändern</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:changetable&amp;rev=1663869537</link>
        <description>Tabellen ändern

Tabellennamen ändern

Den Tabellennamen kann man mit dem Schlüsselwort RENAME ändern.

Syntax


RENAME alter_tabellenname TO neuer_tabellenname


Beispiel

Ändere den Namen der Mitarbeitertabelle von „Mitarbeiter“ auf „Personen</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:corsubsel&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Correlated Sub-Selects</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:corsubsel&amp;rev=1663869537</link>
        <description>Correlated Sub-Selects

Beispiel: Zeige den Namen, das Gehalt und die Abteilungsnummer jener Personen an, die in ihrer Abteilung am wenigsten verdienen.

Das Problem hierbei ist aber, dass auch Datensätze ausgewählt werden, die in ihrer Abteilung nicht das Mindestgehalt darstellen (Gehalt wird mit irgendeinem Mindestgehalt verglichen)</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:create&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Tabellen erstellen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:create&amp;rev=1663869536</link>
        <description>Tabellen erstellen

Syntax


CREATE Table Tabellenname
(
 --Folgende Constraintart nennt man &quot;Spaltenconstraints&quot;
 Spaltenname1 Spaltentyp [[Constraintname1] Constrainttyp [ON DELETE | ON UPDATE],
 Spaltenname2 Spaltentyp [Constraintname2] Constrainttyp [ON DELETE | ON UPDATE],
 ...]
   
 --Diese Constraints nennt man Tabellenconstraints
 [CONSTRAINT Constraintname Constrainttyp (Spaltenname) [ON DELETE | ON UPDATE]
); --Strichpunkt zum Schluss ist wichtig, 
--da oft mehrere Tabellen hintereinan…</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:createdb&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Datenbanken anlegen und löschen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:createdb&amp;rev=1663869537</link>
        <description>Datenbanken anlegen und löschen

Nachdem wir den MySQL-Service ans Laufen gebracht haben, starten wir den Client. Dafür gehen wir in die Konsole (Start-Menü öffnen und „cmd“ eingeben) und tippen in der Konsole „mysql“ ein. Wenn alles geklappt hat, sieht das etwa so aus:</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:createtable&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Tabellen anlegen und löschen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:createtable&amp;rev=1663869537</link>
        <description>Tabellen anlegen und löschen

Eine Tabelle beschreibt im Prinzip das gleiche wie eine Klasse in C++, bzw. eine Struktur in C: einen Datensatz. Dabei ist eine Tabelle eine Art Liste über eine Vielzahl von Datensätzen, genauso wie eine Klassendeklaration nur beschreibt, wie eine Objekt der jeweiligen Klasse auszusehen hat und es beliebig viele Instanzen dieses Typs geben kann. Prinzipiell kann man Tabellen genauso modellieren wie Klassen. Wie in C/C++ gibt es</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:datfu&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Datumsfunktionen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:datfu&amp;rev=1663869537</link>
        <description>Datumsfunktionen

Datumsarithmetik
 Operation  Ergebnis  Beschreibung  Datum + Zahl  Datum  Addiert eine Anzahl von Tagen zu einem Datum  Datum – Zahl  Datum  Subtrahiert eine Anzahl von Tagen von Datum  Datum – Datum  Anzahl der Tage  Subtrahiert ein Datum von einem anderen</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:dbtrans&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Transaktionen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:dbtrans&amp;rev=1663869537</link>
        <description>Transaktionen

Transaktionen - Was ist das?

Eine Transaktion ist eine Anzahl von DML - Befehlen (INSERT, UPDATE, DELETE) die eine Datenbank von einem konsistenten (alle Daten der Datenbank in einwandfreiem/fehlerlosen Zustand) Zustand in einen anderen konsistenten Zustand überführt. Sie sind nur ganz oder gar nicht möglich. Bei Problemen innerhalb der Transaktionen müssel alle (auch bereits ausgeführten Befehle) zurückgenommen (zurückgerollt -</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:delete&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Daten löschen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:delete&amp;rev=1663869537</link>
        <description>Daten löschen

Wir können bisher Daten hinzufügen, aber manchmal verlieren Daten auch ihre Gültigkeit. Ein Kunde verlangt die Löschung seiner Kundendaten oder ein Artikel wird nicht mehr länger geführt. In dem Fall müssen wir der Datenbank erklären, dass wir Daten löschen wollen.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:dreiebsch&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Das Drei-Ebenen-Schema</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:dreiebsch&amp;rev=1663869537</link>
        <description>Das Drei-Ebenen-Schema

Zur Unterstützung der Datenunabhängigkeit wurde das Drei-Ebenen-Schema entwickelt.

[Drei-Ebenen-Schema]

Konzeptionelle Ebene

Die Konzeptionelle Ebene bildet die Basis für die interne bzw. die externe Ebene des Schemas. Hier hat man eine logische Gesamtsicht auf die Daten. 
Dieser Teil des Schemas wird mit der DDL (Data Description Language) beschrieben.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:firstowncreate&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Meine erste Tabelle</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:firstowncreate&amp;rev=1663869537</link>
        <description>Meine erste Tabelle

Erzeuge eine Tabelle die „Person“ heißt. Sie soll die Spalten „Name“, „Age“ und „Place“ haben. Die Typen darfst du dir aussuchen. ;-)

 Hier gehts zur Lösung.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:firstsolution&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lösung</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:firstsolution&amp;rev=1663869536</link>
        <description>Lösung



CREATE TABLE Person (
    name VARCHAR2(30),
    age INTEGER,
    place VARCHAR2(30)
);</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:firsttable&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Der erste Codeabschnitt</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:firsttable&amp;rev=1663869537</link>
        <description>Der erste Codeabschnitt

Bei den heutigen Datenbanken werden alle Informationen in Tabellen gespeichert. Um eine einfache Tabelle anzulegen benötigt man folgenden Code:



CREATE TABLE MyFirstTable (
    one INTEGER,
    two DOUBLE,
    three VARCHAR2(30)
);</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:funkab&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Funktionale Abhängigkeit</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:funkab&amp;rev=1663869537</link>
        <description>Funktionale Abhängigkeit

Definition

Eine Attributkombination (AK) B ist von einer AK A funktional abhängig, wenn zu jedem Wert von A genau ein Wert von B gehört. (Aus A folgt eindeutig B)

Schreibweise: A -&gt; B 
Sprechweise: B ist funktional abhängig von A</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:groupby&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Daten gruppieren - GROUP BY Klausel</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:groupby&amp;rev=1663869537</link>
        <description>Daten gruppieren - GROUP BY Klausel

Definition

Mit der GROUP BY Klausel, lassen sich die Zeilen einer Tabelle zu Gruppen zusammenfügen. Danach kann man diese Gruppen einzeln auswerten. Am einfachsten wird dies mit einem Beispiel verdeutlicht.

Wir haben folgende Tabelle gegeben:</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:grupfunk&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Gruppenfunktionen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:grupfunk&amp;rev=1663869537</link>
        <description>Gruppenfunktionen

Syntax


Gruppenfunktion ([DISTINCT | ALL] Ausdruck) --DISTINCT oder ALL können benutzt werden
--DISTINCT -&gt; Gleiche Zeilen werden nur 1 mal angezeigt
--ALL (Standard) -&gt; Jede Ergebniszeile die die Datenbank liefert wird ausgegeben</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:having&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>HAVING Klausel</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:having&amp;rev=1663869537</link>
        <description>HAVING Klausel

Die HAVING - Klausel beschränkt das Ergebnis auf diejenigen Gruppen für die die angegebene Bedingung „true“ liefert. Man kann sie wie eine zweite WHERE - Klausel ansehen.

Beispiel

Zeige alle maximalen Abteilungsgehälter die größer als 2000 sind.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:hierm&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hierarchisches Modell</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:hierm&amp;rev=1663869537</link>
        <description>Hierarchisches Modell

In einem hierarchischem Modell hat jedes Objekt höchstens einen übergeordnetes Objekttyp (Vater, Vorgänger). Würde man ein solches Datenbankmodell aufzeichnen, erhielt man einen sogenannten Assoziationsgraphen - einen gerichteten Baum. Das Problem dieses Modells ist es, dass nur 1:n Beziehungen möglich sind (1 Objekt kann beliebig viele Nachfolger aber nur EINEN Vorgänger haben). Somit ist es sehr schwer, n:m Beziehungen darzustellen.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:index&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SQL</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:index&amp;rev=1663869536</link>
        <description>SQL

	*  Anforderungen an eine SQL-Datenbank
	*  Das Drei-Ebenen-Schema
	*  Datenbankmodelle
		*  Hierarchisches Modell
		*  Netzwerkmodell
		*  Relationenmodell

	*  Überblick SQL

Schlüsselkonzept und Abhängigkeiten

	*  Schlüsselkonzept
	*  Funktionale Abhängigkeit
	*   Voll funktionale Abhängigkeit
	*  Transitive Abhängigkeit

Normalisierung

	*  Warum normalisieren?
	*  1. Normalform
	*  2. Normalform
	*  3. Normalform
	*  BCNF
	*  4. Normalform

IQL

	*  Basis Syntax
	*  Alias Name
	*  Whe…</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:insert&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Daten in eine Tabelle hochladen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:insert&amp;rev=1663869537</link>
        <description>Daten in eine Tabelle hochladen

Wir wissen nun, dass es einen Unterschied zwischen einer Datenbank und einer Tabelle gibt, ein Datenbank-Service mehrere Datenbanken halten kann und eine Datenbank mehrere Tabellen halten kann - ähnlich eines Computers (Servers), der mehrere Festplatten (Datenbanken) enthalten kann, jede Festplatte mehrere Verzeichnisse (Tabellen) haben kann und in jedem Verzeichnis mehrere Dateien (Datensätze) beinhalten kann.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:join&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Joins</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:join&amp;rev=1663869537</link>
        <description>Joins

Ein Join ist eine Verbindung von zwei oder mehr Tabellen zu einer großen. Dies geschieht meist über den Primärschlüssel bzw. über Fremdschlüssel. Grafisch sieht ein Join wie folgt aus:



Es gibt 3 Arten von Joins:

	*  Cross Join
	*  Inner Join
	*  Outer Join</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:key&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Schlüsselkonzept - Was ist ein Schlüssel und wie wähle ich ihn richtig aus?</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:key&amp;rev=1663869537</link>
        <description>Schlüsselkonzept - Was ist ein Schlüssel und wie wähle ich ihn richtig aus?

(Primär-)Schlüssel

Ein Schlüssel (oder auch Primärschlüssel genannt) ist eine Menge von Attributen die einen Datensatz (eine Zeile) einer Tabelle eindeutig identifiziert. Setzt sich der Schlüssel aus mehreren Elementen zusammen nennt man ihn einen zusammengesetzten (Primär-)Schlüssel. Alle anderen Attribute bezeichnet man als</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:konvfu&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Konvertierungsfunktionen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:konvfu&amp;rev=1663869536</link>
        <description>Konvertierungsfunktionen</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:nf&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Normalisierung</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:nf&amp;rev=1663869537</link>
        <description>Normalisierung

Unter Normalisierung versteht man, die Umwandlung komplexer Tabellen in einfachere. Dies wird durch Aufteilung der Attribute auf mehrere Tabellen erreicht. 
Das Ziel dabei ist, stabile und flexible Datenstrukturen (einfache Fehlersuche, leichte Erweiterbarkeit) zu schaffen.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:nf1&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>1. Normalform</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:nf1&amp;rev=1663869536</link>
        <description>1. Normalform

Eine Relation (Tabelle) befindet sich in 1. Normalform wenn:

	*  Alle Attribute atomar (nicht weiter teilbar) sind
	*  Es keine Wiederholgruppen gibt

Auflösen nicht-atomarer Elemente

Person (Name, Beruf)



Der Name ist in diesem Beispiel NICHT atomar, wir machen aus dem einem Element einfach zwei und schon haben wir das Problem gelöst.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:nf2&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>2. Normalform</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:nf2&amp;rev=1663869537</link>
        <description>2. Normalform

Eine Relation ist in 2. Normalform wenn:

	*  sie in 1. Normalform ist
	*  jedes nicht-Schlüsselattribut voll funktional von jedem Schlüsselkandidaten abhängig ist



Falls nicht:

	*  Jede Attributgruppe bildet gemeinsam mit jenem Teil des Schlüsselkandidaten von dem sie voll funktional abhängig ist eine neue Relation (Tabelle)</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:nf3&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>3. Normalform</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:nf3&amp;rev=1663869537</link>
        <description>3. Normalform

Eine Tabelle ist in 3. Normalform wenn:

	*  sie in 2. Normalform ist
	*  alle Nichtschlüsselattribute von keinem Schlüsselkandidaten transitiv abhängig sind

Auflösung

A -&gt; B -&gt; C
A -&gt; B -&gt; C
... ... ... ...
A -&gt; B -&gt; C

Alle über das selbe Zwischenattribut (B) transitiv abhängigen Attribute werden in eine neue Relation ausgelagert. Das Zwischenattribut stellt die Verbindung zwischen den beiden Relationen her (Primär- bzw. Fremdschlüssel)</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:nf4&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>4. Normalform</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:nf4&amp;rev=1663869536</link>
        <description>4. Normalform

In der 4. Normalform geht es um „Mehrwertige Abhängigkeiten“ (engl. multivalued dependencies).

Bis jetzt kannten wir nur einfache Abhängigkeiten wie „B ist funktional abhängig von A“. Dies bedeutet A -&gt; B und, dass aus einem A genau ein B folgt.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:nwm&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Das Netzwerkmodell</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:nwm&amp;rev=1663869537</link>
        <description>Das Netzwerkmodell

Diese Modellart ermöglicht auch n:m Beziehungen. Ein Objekt kann beliebig viele Vorgänger bzw. Nachfolger haben. Als Beispiel nehmen wir wieder unsere Universität:

Assoziationsgraph:



Realisierungsgraph:





Trotz dieser Verbesserungen sind die Nachteile die gleichen wie beim</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:operatoren&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Operatoren</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:operatoren&amp;rev=1663869537</link>
        <description>Operatoren

In der WHERE-Klausel kann mithilfe von 3 verschiedenen Operatorengruppen verglichen werden:

	*  Vergleichsoperatoren
	*  Logische Operatoren
	*  Spezielle Operatoren

Vergleichsoperatoren





Logische Operatoren



Spezielle Operatoren</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:orderby&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Ergebnisse sortieren - ORDER BY</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:orderby&amp;rev=1663869537</link>
        <description>Ergebnisse sortieren - ORDER BY

Natürlich ist es in SQL auch möglich, Ergebnisse nach gewissen Kriterien zu sortieren. Hierfür stellt SQL die ORDER BY Klausel zur Verfügung. Sie wird, genau wie die WHERE-Klausel, einfach immer zum Schluss hinzugeschrieben.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:preparation&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Vorbereitung</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:preparation&amp;rev=1663869537</link>
        <description>Vorbereitung

Wir wollen zügig mit praktischen Dingen anfangen und uns die Theorie gleich in der Praxis ansehen. Dafür benötigen wir ein SQL-fähigen Datenbank-Managementsystem auf unserem Computer. Wir werden hier mit MySQL arbeiten.

Die Installationsbeschreibung findet sich im MySQL-Tutorial. Das MySQL-Tutorial beschäftigt sich mit der Programmierung von MySQL über C.
Nach der Installation geht es also erstmal hier weiter, um SQL zu verstehen.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:requirement&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Anforderungen an eine Datenbank</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:requirement&amp;rev=1663869536</link>
        <description>Anforderungen an eine Datenbank

Minimalanforderungen an eine DB laut Codd

Einer der führende Köpfe, der an der Entwicklung der Datenbank mitgearbeitet hat war Edgar F. Codd. Er formulierte die Mindestanforderungen an eine relationale Datenbank wie folgt:

	*</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:select&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Daten abrufen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:select&amp;rev=1663869536</link>
        <description>Daten abrufen

Nachdem wir zuvor gelernt haben, wie wir eine Tabelle mit Daten versorgen, wollen wir nun unsere Daten wieder abfragen.

Ungefiltert

Die einfachste Möglichkeit, um Daten abzurufen ist sich alles Anzeigen zu lassen. Gib bitte folgenden Befehl in die Konsole ein:</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:seq&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Sequenzen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:seq&amp;rev=1663869537</link>
        <description>Sequenzen

Sequenzen sind Datenbankobjekte die zum Hochzählen von ganzzahligen Werten verwendet werden. Meist werden sie für einen automatischen, numerischen Primärschlüssel verwendet.

Eine Sequenz wird wie folgt erzeugt:


CREATE SEQUENCE Sequenzname
[INCREMENT BY Wert] --Standard: 1
[START WITH Wert] --Standard: 0
[MAXVAL {Wert | NOMAXVALUE} --NOMAXVALUE = keine Obergrenze (Standard)
[MINVAL {Wert | NOMINVALUE} --NOMINVALUE = keine Untergrenze (Standard)
[{NO CICLE | CICLE]} --Ob, wenn Obergr…</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:setop&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Set - Operatoren (Mengenoperationen)</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:setop&amp;rev=1663869537</link>
        <description>Set - Operatoren (Mengenoperationen)

Mit Set-Operatoren wird das Ergebnis mehrerer Abfragen zu einem Ergebnis zusammengefasst. Der Operator bestimmt die Auswahl.





	*  Alle Set-Operatoren haben gleiche Priorität
	*  Abarbeitungsreihenfolge von oben nach unten bzw. Klammern</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:source&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SQL-Dateien ausführen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:source&amp;rev=1663869537</link>
        <description>SQL-Dateien ausführen

In dieser kurzen Lektion werden wir uns ein SQL-Skript schreiben und den mysql-Client auffordern, dieses auszuführen.

Das SQL-Skript

Ich möchte Dich jetzt bitten, Dir ein „sql“-Verzeichnis anzulegen und diesen Text 


/* Staff Skript

   proggen.org SQL-Tutorial
*/

# Datenbank leeren

DROP DATABASE IF EXISTS proggenorg;
CREATE DATABASE proggenorg;
USE proggenorg;

# Tabellen erstellen

CREATE TABLE Staff
(
  Department        SMALLINT UNSIGNED,
  Salary            DECIM…</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:sql&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SQL</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:sql&amp;rev=1663869537</link>
        <description>SQL

Mithilfe der SQL (Structured Query Language) ist es möglich mit einer Datenbank zu kommunizieren und ihre Daten abzufragen, diese zu löschen, neue Daten einzufügen bzw. Daten upzudaten.

Die SQL setzt sich aus mehreren Teilsprachen zusammen:</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:start&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Datenbanksysteme</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:start&amp;rev=1663869537</link>
        <description>Datenbanksysteme

Die Datenbank

	*  Warum SQL?
	*  Vorbereitung Installation des MySQL-Services

Grundlagen mit SQL

Wir beginnen mit einem praktischen Teil, um eine erste Vorstellung von Datenbanken zu erhalten und deren Verwendung zu erhalten.

	*  Datenbanken anlegen, nutzen und löschen</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:subsel&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Sub-Select</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:subsel&amp;rev=1663869537</link>
        <description>Sub-Select

Ein Subselect ist eine Selectanweisung die in der  unterschieden. Beide Arten unterscheiden sich in den erlaubten Operatoren die auf das Ergebnis angewendet werden dürfen.

Richtlinien

	*  Sub-Select immer in Klammern 
	*  kein ORDER BY</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:synonym&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Synonyme</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:synonym&amp;rev=1663869537</link>
        <description>[=]

Synonyme

Definition

Ein Synonym ist ein anderer Name für eine Tabelle und wird wie folgt erzeugt.

Erzeugung


CREATE SYNONYM neuer_name FOR tabellenname


Wird ein Synonym geändert, dann ändert sich auch automtatisch die Originaltabelle mit.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:transa&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Transitive Abhängigkeit</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:transa&amp;rev=1663869537</link>
        <description>Transitive Abhängigkeit

Ein Attribut C ist von einem Attribut A transitiv abhängig, wenn ein Attribut B von A funktional abhängig und C von B funktional abhängig ist.

-&gt;-&gt;-&gt;-&gt;-&gt;</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:unterabfr&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Tabellen mittels Unterabfrage erstellen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:unterabfr&amp;rev=1663869536</link>
        <description>Tabellen mittels Unterabfrage erstellen


CREATE TABLE Tabellenname
[(Spaltenname1, Spaltenname2, ...)]
AS SELECT ...


Die Anzahl der Spaltennamen muss mit der Anzahl der selektierten Spalten übereinstimmen. Werden keine Spaltennamen angegeben, bestimmt die SELECT-Klausel der Unterabfrage Spaltenanzahl und Spaltennamen. Die neu erzeugte Tabelle wird mit den Daten aus der Unterabfrage gefüllt. Constraints werden nicht kopiert.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:update&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Datensätze ändern</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:update&amp;rev=1663869537</link>
        <description>Datensätze ändern

Um Datensätze zu verändern, müssen wir sie bisher löschen und neu anlegen. Das ist allerdings viel zu viel Aufwand, wir können den vorhandenen Datensatz auch überarbeiten. Dies geschieht mit dem Befehl UPDATE.

Eine Spalte ändern</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:vfa&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Voll funktionale Abhängigkeit</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:vfa&amp;rev=1663869537</link>
        <description>Voll funktionale Abhängigkeit

A ist ein zusammengesetztes Attribut, dass aus A und A besteht. In einer Relation R() ist das Attribut B voll funktional abhängig von A, wenn B von A funktional abhängig ist, nicht aber von .

Sprich, B wird nur durch die Kombination von</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:views&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Views</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:views&amp;rev=1663869537</link>
        <description>Views

Eigenschaften von Views

	*  Sie sind viertuelle Tabellen die spezielle Sichten auf die Datenbanktabellen darstellen
	*  Durch sie können Tabellen angezeigt oder (eingeschränkt) verändert werden
	*  Sie basieren auf anderen Views bzw. Tabellen</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:where&amp;rev=1663869536">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:56+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>WHERE Klausel</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:where&amp;rev=1663869536</link>
        <description>WHERE Klausel

Die WHERE Klausel dient dazu, die SELECT Anweisung zu verfeiner und nur Werte anzeigen zu lassen, die ein bestimmtes Kriterium erfüllen. Sie kann wie eine Ausmusterung angesehen werden.

Syntax

Die WHERE Klausel wird einfach nach dem FROM hinzugefügt.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:why&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Warum SQL?</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:why&amp;rev=1663869537</link>
        <description>Warum SQL?

Um große Datenmengen zu verwalten, bieten sich Datenbanken an, da man die Verwaltung der Daten, das Laden und Speichern, das Ändern und Löschen, damit an die Datenbank auslagern kann: Man muss es also nicht selbst programmieren. Das ist zum einen eine Arbeitsersparnis, die für den Einsatz von Datenbanken spricht. Die Frage, die übrig bleibt ist, wie man dann eigentlich mit der Datenbank kommuniziert.</description>
    </item>
    <item rdf:about="https://www.proggen.org/doku.php?id=dbs:sql:zeichfu&amp;rev=1663869537">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:58:57+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Zeichenkettenfunktionen</title>
        <link>https://www.proggen.org/doku.php?id=dbs:sql:zeichfu&amp;rev=1663869537</link>
        <description>Zeichenkettenfunktionen

Mit folgenden Single-Row Funktionen kann man Strings- und Characterdarstellung modifizieren.</description>
    </item>
</rdf:RDF>
