View source for 105 Shells, Skripte und Datenverwaltung

=105.1 Die Shell Umgebung anpassen und verwenden=
Kandidaten sollten in der Lage sein, Shellumgebungen gemäß der Anforderungen von Benutzern anzupassen. Kandidaten sollten in der Lage sein, globale Voreinstellungen und die von Benutzern zu ändern.

Ein ganz netter Link:
*http://www.cyberciti.biz/tips/howto-linux-unix-bash-shell-setup-prompt.html

==Wichtigste Wissensgebiete==
*Umgebungsvariable (etwa PATH) beim Anmelden oder Erzeugen einer neuen Shell setzen
*Bash-Funktionen für häufig gebrauchte Kommandofolgen erstellen
*Skelett-Verzeichnisse für neue Benutzerkonten warten
*Den Kommando-Suchpfad mit den richtigen Verzeichnissen setzen

<pre>
/etc/profile
env
set
unset
export
~/.bash_profile
~/.bash_login
~/.profile
~/.bashrc
~/.bash_logout
function
alias
lists
</pre>

===export===
*Ein Export kann NIE an eine übergeordnete Shell erfolgen!
<pre>
root:~# TEST=Hallo
root:~# bash
root:~# echo $TEST

root:~# export TEST=Hallo
root:~# bash
root:~# echo $TEST
Hallo
</pre>

===env===
*env − ein Programm in einer veränderten Umgebung laufen lassen
<pre>
ÜBERSICHT
      env [OPTION]... [−] [NAME=WERT]... [BEFEHL [ARG]...]
BESCHREIBUNG
      Jeden NAMEn in der Umgebung auf WERT setzen und BEFEHL ausführen.
      −i, −−ignore−environment
               Mit einer leeren Umgebung beginnen
      −0, −−null
               Jede Ausgabezeile mit einem Nullbyte statt des Zeilenumbruchs abschließen
      −u, −−unset=NAME
               Variable aus der Umgebung entfernen
      −−help Diese Hilfe anzeigen und beenden
      −−version
               Versionsinformation anzeigen und beenden
      Ein einzelnes »−« impliziert −i. Wenn kein BEFEHL angegeben ist, wird die resultierende Umgebung aus-
      gegeben.

SIEHE AUCH
      Die vollständige Dokumentation für env wird als Texinfo−Handbuch gepflegt. Wenn die Programme info
      und env auf Ihrem Rechner ordnungsgemäß installiert sind, können Sie mit dem Befehl
               info coreutils 'env invocation'
      auf das vollständige Handbuch zugreifen.
</pre>

===set===
*Umgebungsvariablen einsehen
*set | less

<pre>
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HISTSIZE=500
...
</pre>

===unset===
*Umgebungsvariablen löschen

===alias===
*Mehrere Kommandos per ; trennen
*alias zum anzeigen aller aliase
<pre>
alias ..='cd ..'
alias ...='cd ../..'
alias dir='cd ../..'
alias ls='ls --color=auto'
</pre>

*Which kann ein alias sein auf "type -p". Allerings nicht unter debian
====Aliase escapen====
<pre>
alias ls='ls --color=auto'
'ls'
#oder
\ls
</pre>

===function===
<pre>
function Funktionsname()
{
  kommando1
  kommando2
  kommandon
}
</pre>
*function kann weggelassen werden (die Bash erkennt die beiden Klammern)
*Rechenoperationen:
<pre>
function addiere()
{
  let summe=$1+$2
  echo Das Ergebnis lautet "$summe"
}

funtion addiere() { let summe=$1+$2; echo Die Summe lautet $summe; }
</pre>
*builtin : bash internes Kommando, damit Funktionen sich nicht selbst aufrufen:
<pre>
function ls()
{
builtin ls -lisa
}

unter bt:
root@bt:~# function ls() { builtin ls -lisa; }
root@bt:~# ls
bash: builtin: ls: not a shell builtin

bash-builtins (7)    - bash built-in commands, see bash(1)
builtins (7)         - bash built-in commands, see bash(1)

man 7 builtins
</pre>

===declare===
*<b>declare -f</b> zeigt verfügbare Funktionen an
<pre>
Declare variables and give them attributes.

SYNTAX
      declare [-afFrxi] [-p] [name[=value]]

OPTIONS

      -a  Each name is an array variable.

      -f   Use function names only.

      -F   Inhibit the display of function definitions; 
           only the function name and attributes are printed. 
           (implies -f)

      -i   The variable is to be treated as an integer; 
           arithmetic evaluation is performed when the 
           variable is assigned a value.

      -p   Display the attributes and values of each name. 
           When `-p' is used, additional options are ignored.

      -r   Make names readonly. These names cannot then 
           be assigned values by subsequent assignment statements 
           or unset.

      -x   Mark each name for export to subsequent commands 
           via the environment.

If no names are given, then `declare' will display the values of variables instead.

Using `+' instead of `-' turns off the attribute instead.

When used in a function, declare makes each name local, as with the local command.

The typeset command is supplied for compatibility with the Korn shell; however, it has been deprecated in favor of the declare builtin command.

The return status is zero unless an invalid option is encountered, an attempt is made to define a function using `-f foo=bar', an attempt is made to assign a value to a readonly variable, an attempt is made to assign a value to an array variable without using the compound assignment syntax , one of the names is not a valid shell variable name, an attempt is made to turn off readonly status for a readonly variable, an attempt is made to turn off array status for an array variable, or an attempt is made to display a non-existent function with `-f'.

"My mother never saw the irony in calling me a son-of-a-bitch." - Jack Nicholson

Related:
alias - Create an alias
env - Display, set, or remove environment variables
echo - Display message on screen
export - Set an environment variable
hostname - Print or set system name
local - Create variables
printenv - Print environment variables
readonly - Mark variables/functions as readonly
shift - Shift positional parameters
Equivalent Windows command: SET - Display, set, or remove Windows environment variables
</pre>

===Konfigrationsdateien der Bash===
====Systemweit====
*beginnen NIE mit einem Punkt

*/etc/profile - erfordert erneutes Anmelden nach Änderungen
<pre>
# /etc/profile: system-wide .profile file for the Bourne shell (sh(1))
# and Bourne compatible shells (bash(1), ksh(1), ash(1), ...).

if [ "`id -u`" -eq 0 ]; then
  PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
else
  PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
fi
export PATH
...
</pre>
*/etc/bashrc - wird beim Start jeder Shell neu eingelesen
*/etc/bash.bashrc bzw. /etc/bash.bashrc.local - gilt nur für z.B. Debian und SuSE
====Benutzer====
*~/.bash_profile - wird nur bei neuanmeldung eingelesen
*~/.bash_login - wird nur abgearbeitet wenn .bash_profile nicht existiert
*~/.profile - ursprünglich Config der Bash, wird nur von der Loginshell eingelesen und das auch nur wenn weder .bash_profile noch .bash_login existieren.
*~/.bashrc - die andere ursprünglich Config der Bash, wird immer eingelesen auch beim Aufruf einer neuen Shell
*~/.bash_logout - optionale Datei, wird beim Abmelden des Benutzers ausgeführt. z.B. den Monitor löschen.
*~/.inputrc - Definitionen, die die Tastatur betreffen. z.B. Control-h: "cd ~"

===/etc/skel===
*Das "Knochengerüst" für neue User
*useradd -m hans - kopiert die Dateien und Ordner von /etc/skel nach /home/hans
<pre>
homaar@bl01:/etc/skel$ ls -lah
total 28K
drwxr-xr-x   2 root root 4.0K Apr 22  2011 .
drwxr-xr-x 117 root root  12K Dec 23 17:14 ..
-rw-r--r--   1 root root  220 May 12  2008 .bash_logout
-rw-r--r--   1 root root 3.2K Apr 10  2010 .bashrc
-rw-r--r--   1 root root  675 May 12  2008 .profile
</pre>

=105.2 Einfache Skripte anpassen oder schreiben=
Kandidaten sollten in der Lage sein, existierende Skripte anzupassen oder einfache neue BASH-Skripte zu schreiben.

==Wichtigste Wissensgebiete==
*Standard-sh-Syntax verwenden (Schleifen, Fallunterscheidungen)
*Kommandosubstitution verwenden
*Rückgabewerte auf Erfolg, Misserfolg oder andere von einem Programm gelieferte Informationen prüfen
*Situationsabhängig Mail an den Superuser senden
*Den richtigen Skript-Interpreter über die Shebang-Zeile (#!) wählen
*Den Ort, die Eigentümerschaft, die Ausführungs- und SUID-Rechte von Skripten verwalten

<pre>
for
while
test
if
read
seq
</pre>

===Allgemeines===
*Shebang 
<pre>
#!/path/to/interpreter
</pre>
* Drei Ausführungsmethoden:
<pre>
1.) /bin/bash /path/to/script
2.) source /path/to/script
3.) chmod a+x /path/to/script & /path/to/script
</pre>

===Ausführungsberechtigungen===
====chmod 600====
*Ein administratives Script sollte immer die Berechtigungsstufe 600 haben

====SUID Bit====
*Das Programm wird im Sicherheitskontext des Besitzes ausgeführt
*Dies ist als gefährlich einzustufen!
<pre>
chmod 4700 /path/to/script
ls -lah
-rws------  1 root root   26 24. Dez 10:15 test
</pre>

====Sticky Bit====
*https://de.wikipedia.org/wiki/Sticky_Bit

*Verhindert das Löschen oder umbenennen von Ordnern und Dateien

<pre>
ls -lah . | grep test
drwxr-xr-x  2 homaar homaar 4,0K Sep 24 10:00 test

chmod 1700 test

ls -lah . | grep test
drwx-----T  2 homaar homaar 4,0K Sep 24 10:00 test
</pre>

===Position eines Scripts===
====im Dateisystem====
*Wird ein Script häufig genutzt, so sollte es in einem Ordner der PATH Variable liegen
*echo $PATH
*z.B. /usr/bin für Userscripts und /usr/sbin für Adminscripts

====im Prozessbaum====
*Das Script wird in einem neuen Bash Prozess gestartet. D.h. es stehen nur exportierte Variablen zur Verfügung.
*Nochmal: ein export bezieht sich nur auf untergeordnete Shells!!!
* D.h. Variablen müssen für die spätere Verwendung zwischengespeichert werden, z.B. unter /tmp.

===Übergabevariablen und Rückgabewerte===

* $0 = Name des Programms inkl. Pfad
* $1-$n = Übergabeparamter
* $# = Anzahl der Parameter
* $? = Errorlevel (command not found = 127, Genereller Fehler= 1, OK = 0)

===Schleifen und Bedingungen===
==== while, test, do, done, shift, let ====
*shift verschiebt die Übergabeparamter um eine Stelle:
<pre>
#!/bin/bash
summe=0
while test $# -gt 0
do
        let summe=summe+$1
        shift
done
echo Die Summe lautet $summe
unset summe
exit 0
</pre>

=====Dateioperatoren=====
*Überprüfung von Dateien hinsichtlich bestimmter Eigenschaften:
<pre>
-r 	ist die Datei lesbar? 
-w	ist die Datei beschreibbar?
-x	ist die Datei ausführbar?
-d	existiert das Verzeichnis?
-b	ist die Datei in blockorientiertes Gerät?
-c	ist die Datei in zeichenorientiertes Gerät?
-g	ist das SGID-Bit gesetzt?
-k	ist das Sticky-Bit gesetzt?

-u	ist das SUID-Bit gesetzt? //WICHTIG

-e	die Datei existiert?
-f	es handelt sich um eine reguläre Datei?
-L	es handelt sich um einen Symlink?

file1 -nt file2		ist die Datei neuer als ... ?
file1 -ot file2		ist die Datei älter als ... ?
</pre>

=====Variablenoperatoren=====
*Überprüfung von Variablen hinsichtlich bestimmter Eigenschaften:
<pre>
WertA -eq WertB		Equal
WertA -ne WertB		Not equal
WertA -gt WertB		Greater than
WertA -ge WertB		Greater or equal
WertA -lt WertB		Less then
WertA -le WertB		Less or equal
</pre>

====Schleifen mit for, Befehlssubstitution, echo, find====

<pre>
#!/bin/bash

#Home nach *.old durchsuchen
#for z in $(find /home -name *.old)
for z in `find ~ -type f -name *.old`
do
        echo -e "\nDie Datei $z kann vermutlich gelöscht werden"
done
unset z
exit 0
</pre>
*Die Ausgabe des find Befehls wird einzeln an die Variable z übergeben
*echo -e aktiviert Escapesequenzen -> so ist es möglich mit \n eine Leerzeile am Anfang einzufügen

=====Weitere Escapezeichen=====
*\\	Escapter Backslash
*\a	Alert - piepst einmal
*\b	Backspace
*\c	Unterdrückt das "Newline-Zeichen"
*\f	Form feed - Leerseite
*\n	Newline
*\r	Carriage return
*\t	Horizontal tabulator (8 Leerzeichen breit)
*\v	Vertical tabulator (8 Leerzeichen hoch)

=====mail=====
<pre>
echo "Test" | mail -s Test root
</pre>

====if, fi, elif, else, read, clear und einfaches Rechnen in der Bash====
<pre>
#!/bin/bash

#Die 4 Grundrechenarten
clear; echo -e "Welche Rechenart?\nBiite den ersten Buchstaben eingeben und mit Enter bestätigen!\n"
echo -e "[a]ddieren
[s]ubtrahieren
[d]ividieren
[m]ultiplizieren "
read operator

clear; echo -e "\nBitte erste Zahl eingeben"
read a

clear; echo -e "\nBitte zweite Zahl eingeben"
read b

if [ $operator = a ]; then
        let c=a+b
        clear; echo -e "\nAddition $a + $b = $c"
elif [ $operator = s ]; then
        let c=a-b
        clear; echo -e "\nSubtration $a - $b = $c"
elif [ $operator = m ]; then
        let c=a*b
        clear; echo -e "\nMultiplikation $a * $b = $c"
elif [ $operator = d ]; then
        let c=a\b
        clear; echo -e "\nDivision $a / %b = $c"
else clear; echo -e "\nKein gueltiger Operator"
exit 1
fi
</pre>

====case, esac, read, clear und einfaches Rechnen in der Bash====
* Ein case muss immer mit ";;" geschlossen werden
* Entsprechend zum else steht das *)
* case esac
<pre>
#!/bin/bash

#Die 4 Grundrechenarten
clear; echo -e "Welche Rechenart?\nBiite den ersten Buchstaben eingeben und mit Enter bestätigen!\n"
echo -e "[a]ddieren
[s]ubtrahieren
[d]ividieren
[m]ultiplizieren "
read operator

clear; echo -e "\nBitte erste Zahl eingeben"
read a

clear; echo -e "\nBitte zweite Zahl eingeben"
read b

case "$operator" in
        a)
        let c=a+b
        clear; echo $c;;
        s)
        let c=a-s
        clear; echo $c;;
        m)
        let c=a*s
        clear; echo $c;;
        d)
        let c=a/s
        clear; echo $c;;
        *)
        clear; echo -e "\nKein gueltiger Operator"
        exit1;;
esac
</pre>

=105.3 SQL-Datenverwaltung=
Kandidaten sollten in der Lage sein, mit einfachen SQL-Kommandos Datenbanken abzufragen und Daten zu manipulieren. Dieses Lernziel umfasst auch Anfragen, die 2 Tabellen verbinden und/oder Subselects verwenden.

==Wichtigste Wissensgebiete==
*Gebrauch einfacher SQL-Kommandos
*Einfache Datenmanipulation
<pre>
insert
update
select
delete
from
where
group by
order by
join
</pre>

===Allgemeines===
*SQL = Structured Query Language
*SQL ist von ISO und ANSI standardisiert

*http://dev.mysql.com/doc/refman/5.5/en/mysql.html
<pre>
yum/apt-get install mysql-server mysql-client

mysql -u root -pPASS -h localhost

mysql --user=user_name --password=your_password db_name

mysql db_name < script.sql > output.tab

mysql> status
--------------
mysql  Ver 14.14 Distrib 5.1.49, for debian-linux-gnu (x86_64) using readline 6.1

Connection id:          24642
Current database:
Current user:           root@localhost
SSL:                    Not in use
Current pager:          stdout
Using outfile:          ''
Using delimiter:        ;
Server version:         5.1.49-3 (Debian)
Protocol version:       10
Connection:             Localhost via UNIX socket
Server characterset:    latin1
Db     characterset:    latin1
Client characterset:    latin1
Conn.  characterset:    latin1
UNIX socket:            /var/run/mysqld/mysqld.sock
Uptime:                 46 days 6 hours 38 min 7 sec

Threads: 16  Questions: 13853122  Slow queries: 82  Opens: 9748  Flush tables: 1  Open tables: 64  Queries per second avg: 3.464
--------------

</pre>

===Hilfe===
<pre>
mysql> \h oder help
mysql> help contents
You asked for help about help category: "Contents"
For more information, type 'help <item>', where <item> is one of the following
categories:
   Account Management
   Administration
   Compound Statements
   Data Definition
   Data Manipulation
   Data Types
   Functions
   Functions and Modifiers for Use with GROUP BY
   Geographic Features
   Help Metadata
   Language Structure
   Plugins
   Table Maintenance
   Transactions
   User-Defined Functions
   Utility
mysql> help data types
...
mysql> help VARCHAR
</pre>

===SQL Befehlstypen - Query, Manipulation, Definition & Control===
*DQL - SELECT, ORDER BY, DISTINCT - Data Query Language (DISTINCT = keine Dubletten)
*DML - INSET, UPDATE, COMMIT, ROLLBACK - Data Manipulation Language
*DDL - CREATE TABLE, ALTER TABLE, DROP TABLE - Data Definition Langunage
*DCL - GRANT, REVOKE - Data Control Language

===Datenbank anzeigen, etc.===
*SHOW DATABASES;
*CREATE DATABASE kontake;
*USE kontakte;
*DESCRIBE rufnummern;

===CREATE TABLE===
*Es folgt immer ein Komma auf eine Definition, es darf aber nicht mit Komma abgeschlossen werden!
*AUTO_INCREMENT = erster freier Wert
*NOT NULL = nicht leer (es handelt sich NICHT um den numerischen Wert 0!)
*PRIMARY KEY = Primärschlüssel

<pre>
mysql> CREATE TABLE rufnummern (
	id INT(10) NOT NULL AUTO_INCREMENT PRIMARY KEY,
	vorname VARCHAR(128),
	nachname VARCHAR(128),
	vorwahl VARCHAR(32),
	rufnummer VARCHAR(32)
);
</pre>

===INSERT===
* VARCHAR Values immer Quoten
<pre>
mysql> INSERT INTO
rufnummern (id,vorname,nachname,vorwahl,rufnummer)
VALUES 
(1, 
'Hans', 
'Wurst', 
'12345', 
'67890' 
);

oder

mysql> INSET INTO rufnummern (id, vorname, nachname, vorwahl, rufnummer) VALUES (2, 'Peter', 'Lustig', '54321', '0988776651');
</pre>

*Hier noch mal ein besseres Beispiel von diesem Thread:
http://www.daniweb.com/web-development/databases/mysql/threads/72364
<pre>
create table TEST
( 
column1 int AUTO_INCREMENT,
column2 varchar(10)
)

Methode A:
insert into TEST values(1, 'apple')
insert into TEST values(2, 'strawbery')

Methode B: // Autmoatische Vergabe des AUTO_INCREMENT Wertes
INSERT INTO TABLE table_name (column1, column3, column8) values(value1, value3, value8)

</pre>

===Textdatei in MySQL einlesen===
<pre>
CREATE DATABASE dummy;
USE dummy;
CREATE TABLE dummytable(
	id INT(10) NOT NULL AUTO_INCREMENT PRIMARY KEY,
	value VARCHAR(32)
);
INSERT INTO dummytable (value) VALUES('value1');
INSERT INTO dummytable (value) VALUES('value2');
</pre>

<pre>
mysql> source /path/to/file

windows:
mysql> source c:/file/to/path
</pre>

===SELECT und WHERE===
*Leere Werte werden als NULL dargestellt.
<pre>
mysql>  SELECT * FROM rufnummern

mysql> SELECT vorname, nachname FROM rufnummern;
ODER > SELECT rufnummern.vorname, rufnummern.nachname FROM rufnummern;
+---------+----------+
| vorname | nachname |
+---------+----------+
| hans    | Wurst    |
| hans    | Wurst    |
| peter   | lustig   |
+---------+----------+
3 rows in set (0.00 sec)

mysql> SELECT vorwahl,rufnummmer FROM rufnummern WHERE vorname='peter';

mysql> SELECT * FROM rufnummern WHERE id > 2 and id < 4;
</pre>

===UPDATE===

<pre>
mysql> UPDATE rufnummern set test = 'y', rn = 'lalala' WHERE id = 3;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from rufnummern where id = 3;
+----+---------+----------+---------+------------+------+--------+
| id | vorname | nachname | vorwahl | rufnummmer | test | rn     |
+----+---------+----------+---------+------------+------+--------+
|  3 | peter   | lustig   | 123     | 321        | y    | lalala |
+----+---------+----------+---------+------------+------+--------+
1 row in set (0.00 sec)


mysql> UPDATE rufnummern SET rufnummer = '1234567890', kategorie_id = 2, vorname = 'Peter' WHERE vorname = 'peter';
</pre>

===ORDER BY===
<pre>
mysql> SELECT * FROM rufnummern ORDER BY vorname;
+----+---------+----------+---------+------------+------+--------+
| id | vorname | nachname | vorwahl | rufnummmer | test | rn     |
+----+---------+----------+---------+------------+------+--------+
|  2 | Egon    | Wurm     | NULL    | NULL       | NULL | NULL   |
|  1 | hans    | Wurst    | 123     | 321        | NULL | NULL   |
|  3 | peter   | lustig   | 123     | 321        | y    | lalala |
+----+---------+----------+---------+------------+------+--------+
3 rows in set (0.00 sec)
</pre>
===LIMIT===
<pre>
mysql> SELECT * FROM rufnummern ORDER BY vorname LIMIT 1;
+----+---------+----------+---------+------------+------+------+
| id | vorname | nachname | vorwahl | rufnummmer | test | rn   |
+----+---------+----------+---------+------------+------+------+
|  2 | Egon    | Wurm     | NULL    | NULL       | NULL | NULL |
+----+---------+----------+---------+------------+------+------+
1 row in set (0.00 sec)
</pre>
===GROUP BY===
* Nur der erste gefundene Treffer wird ausgegeben.
* ORDER BY + GROUP BY zusammen = crash :)
<pre>
mysql> SELECT * FROM rufnummern GROUP BY vorwahl;
+----+---------+----------+---------+------------+------+------+
| id | vorname | nachname | vorwahl | rufnummmer | test | rn   |
+----+---------+----------+---------+------------+------+------+
|  2 | Egon    | Wurm     | NULL    | NULL       | NULL | NULL |
|  1 | hans    | Wurst    | 123     | 321        | NULL | NULL |
+----+---------+----------+---------+------------+------+------+
2 rows in set (0.00 sec)
</pre>

===Anpassen von Datenbanken===

<pre>
ALTER TABLE kategorie RENAME TO kategorien;
</pre>

<pre>
mysql> ALTER TABLE rufnummern ADD (kategorie_id INT(5));
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> ALTER TABLE rufnummern ADD COLUMN rufnummer VARCHAR(32) AFTER vorwahl;
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> ALTER TABLE rufnummern DROP COLUMN rn;
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0
</pre>

<pre>
mysql> UPDATE rufnummern set kategorie_id = 1 WHERE vorname = 'hans';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
</pre>

===Überprüfung von Tabellen===

<pre>
mysql> CHECK TABLE rufnummern EXTENDED;
+---------------------+-------+----------+----------+
| Table               | Op    | Msg_type | Msg_text |
+---------------------+-------+----------+----------+
| kontakte.rufnummern | check | status   | OK       |
+---------------------+-------+----------+----------+
1 row in set (0.00 sec)
</pre>
* EXTENDED kann bei großen Datenbanken sehr lange dauern!
<pre>
mysql> help CHECK TABLE
CHECK TABLE tbl_name [, tbl_name] ... [option] ...

option = {FOR UPGRADE | QUICK | FAST | MEDIUM | EXTENDED | CHANGED}

CHECK TABLE checks a table or tables for errors. CHECK TABLE works for
MyISAM, InnoDB, and ARCHIVE tables. Starting with MySQL 5.1.9, CHECK
TABLE is also valid for CSV tables, see
http://dev.mysql.com/doc/refman/5.1/en/csv-storage-engine.html. For
MyISAM tables, the key statistics are updated as well.

CHECK TABLE can also check views for problems, such as tables that are
referenced in the view definition that no longer exist.

Beginning with MySQL 5.1.27, CHECK TABLE is also supported for
partitioned tables. Also beginning with MySQL 5.1.27, you can use ALTER
TABLE ... CHECK PARTITION to check one or more partitions; for more
information, see [HELP ALTER TABLE], and
http://dev.mysql.com/doc/refman/5.1/en/partitioning-maintenance.html.

URL: http://dev.mysql.com/doc/refman/5.1/en/check-table.html
</pre>

===Subselects===
* SELECT feld FROM tabelle WHERE bedingung IN (SUBSELECT);
<pre>
mysql> SELECT vorname,nachname FROM rufnummern WHERE kategorie_id IN (SELECT id FROM kategorien WHERE kategorie = 'Nase');
ODER > SELECT rufnummern.vorname,rufnummern.nachname FROM rufnummern WHERE kategorie_id IN (SELECT id FROM kategorien WHERE kategorie = 'Nase');
+---------+----------+
| vorname | nachname |
+---------+----------+
| hans    | Wurst    |
+---------+----------+
1 row in set (0.00 sec)
</pre>


===Aliase in SQL===
*Tabellennamen mit z.B. "FROM tabellenname t" mit einem Alias versehen.
*Die Aliase gelten im Statement auch rückwirkend.
*Die ausgeschriebenen Tabellennamen können nicht mehr verwendet werden.
<pre>
mysql> SELECT r.vorname, r.nachname, r.vorwahl, r.rufnummer FROM rufnummern r;
</pre>

===JOIN===
*Bei LEFT und RIGHT JOINS spricht man von "Outer Joins". Diese liefern auch ein Ergebnis, wenn das überprüfte Feld leer ist.
====LEFT JOIN====
*Bei einem LEFT JOIN steht die Quelltabelle links von der Verknüpfungstabelle steht. (siehe Beispiel: ... FROM rufnummern r LEFT JOIN kategorien k ON ...) 
*Die Reihenfolge nach dem ON ist egal.
<pre>
mysql> SELECT r.vorname, r.nachname, r.vorwahl, r.rufnummer, k.kategorie FROM rufnummern r LEFT JOIN kategorien k ON r.kategorie_id = k.id;
+---------+----------+---------+------------+------------+
| vorname | nachname | vorwahl | rufnummer  | kategorie  |
+---------+----------+---------+------------+------------+
| Hans    | Wurst    | 123     | 1234567890 | Nase       |
| Egon    | Wurm     | NULL    | 1234567890 | Obernase   |
| Peter   | lustig   | 123     | 890123456  | Riesennase |
+---------+----------+---------+------------+------------+
3 rows in set (0.00 sec)
</pre>

====RIGHT JOIN====
*Analog zum LEFT JOIN, Die Quelltabelle steht rechts von der Verweistabelle 
<pre>
mysql> SELECT r.vorname, r.nachname, r.vorwahl, r.rufnummer, k.kategorie
    -> FROM kategorien k
    -> RIGHT JOIN rufnummern r ON k.id = r.kategorie_id;
+---------+----------+---------+------------+------------+
| vorname | nachname | vorwahl | rufnummer  | kategorie  |
+---------+----------+---------+------------+------------+
| Hans    | Wurst    | 123     | 1234567890 | Nase       |
| Egon    | Wurm     | NULL    | 1234567890 | Obernase   |
| Peter   | lustig   | 123     | 890123456  | Riesennase |
+---------+----------+---------+------------+------------+
3 rows in set (0.00 sec)
</pre>

====INNER JOIN====
*Outer Joins zeigen auch Datensätze an, bei denen die Referenz nicht stimmt, Beispiel:
<pre>
mysql> UPDATE rufnummern SET kategorie_id = 1337 WHERE vorname = 'Hans';

mysql> SELECT r.vorname, r.nachname, r.vorwahl, r.rufnummer, k.kategorie FROM kategorien k RIGHT JOIN rufnummern r ON k.id = r.kategorie_id;
+---------+----------+---------+------------+------------+
| vorname | nachname | vorwahl | rufnummer  | kategorie  |
+---------+----------+---------+------------+------------+
| Hans    | Wurst    | 123     | 1234567890 | NULL       |
| Egon    | Wurm     | NULL    | 1234567890 | Obernase   |
| Peter   | lustig   | 123     | 890123456  | Riesennase |
+---------+----------+---------+------------+------------+
3 rows in set (0.00 sec)
</pre>

Lösung:
*Bei einem INNERJOIN werden nur "valide Verknüpfungen" ausgegeben: 
<pre>
mysql> SELECT r.vorname, r.vorwahl, r.rufnummer, k.kategorie FROM rufnummern r INNER JOIN kategorien k ON k.id = r.kategorie_id;
+---------+---------+------------+------------+
| vorname | vorwahl | rufnummer  | kategorie  |
+---------+---------+------------+------------+
| Egon    | NULL    | 1234567890 | Obernase   |
| Peter   | 123     | 890123456  | Riesennase |
+---------+---------+------------+------------+
2 rows in set (0.00 sec)
</pre>

===Destruktive Kommandos===
Alle Datensätze löschen:
<pre>
mysql > DELETE FROM rufnummern;
</pre>

Einzelnen DS löschen:

<pre>
mysql > DELETE FROM rufnummern
WHERE vorname "Egon" AND nachname = "Wurm";
</pre>

Eine Tabelle löschen:
<pre>
mysql > DROP TABLE kontake;
</pre>

Datenbank droppen:
<pre>
mysql > DROP DATABASE kontakte;
</pre>