lunar.lu

TTF in GDF konvertieren

admin — Tue, 08 Sep 2009 12:06:21 +0000

In letzter Zeit habe ich mich sehr viel mit der dynamischen Erstellung von Schritzügen mittels imageloadfont beschäftigt.

Das ist an sich kein Problem, nur arbeitet imageloadfont mit Schriften im GDF Format und das Angebot solcher Schriften im Internet ist leider sehr begrenzt. TTF-Schriften hingegen findet man im Internet an jeder Ecke und ausserdem auch im Windows-Ordner Windows\Fonts\.

Ich habe mich daher drangesetzt und ein Konversionsprogramm geschrieben, mit dem man TrueType (TTF) Schriften in GDFs umwandeln kann.

Das Tool ist ist über folgende Adresse erreichbar: http://www.lunar.lu/ttf-to-gdf/convert.php

Über Feedback und Verbesserungsvorschläge würde ich mich freuen

Prozess mitsamt allen Unterprozessen beenden

admin — Thu, 03 Sep 2009 09:54:34 +0000

Auf einem meiner Server hat vor kurzem ein Script verrückt gespielt, was zu einer sehr grossen Anzahl an Prozessen (mitsamt Unterprozessen) in der Warteschlange geführt hat. Um mir die Aufräumarbeiten etwas zu erleichtern, habe ich mir folgendes Script geschrieben.

#!/bin/ksh
 
# Löscht einen Prozess mitsamt allen Unterprozessen
# Der PID eines Prozesses muss als erster Parameter angegeben werden
 
ppid=$1
 
if [ -z $ppid ] ; then
   echo "Usage: $0 PID"
   exit;
fi
 
 
function kill_process_recursive
{
        for i in `pgrep -P $1`
        do
                kill_process_recursive $i
        done
 
        echo $1
        #kill $1
}
 
kill_process_recursive $ppid
 
exit;

Beispiel :

claude@hades /home/claude # sh kill_process_tree.sh 32461
2364
2363
24324
24334
24323
32461

Im Beispielscript habe ich kill $1 kommentiert und durch echo $1 ersetzt.
Damit die Prozesse auch wirklich beendet werden, muss man diese Änderung natürlich umdrehen

Geschwindigkeit eines PHP Scripts messen

admin — Wed, 08 Jul 2009 17:49:51 +0000

Zur Zeit arbeite ich an einem objekt-orientierten Framework und habe, in diesem Zuge, eine Vielzahl von interessanten Klassen programmiert. Eine kleine Auswahl dieser Klassen werde ich in nächster Zeit in meinem Blog vorstellen.

Der Anfang macht hierbei die Klasse timer, mit welcher man die Geschwindigkeit eines PHP Scriptes messen kann. Hier ein Beispiel welches die Funktionsweise der Klasse verdeutlichen soll:

$timer = new timer();
 
for ($i = 0; $i < 4; $i++)
{
	sleep (rand(2,3));
	echo "Vergangene Zeit seit der letzten Messung : ".$timer->measure_intermediate()." Sekunden 
";
	echo "Insgesamt vergangene Zeit: ".$timer->measure_elapsed()." Sekunden

";	
}

Ausgabe:

Vergangene Zeit seit der letzten Messung : 2.001 Sekunden
Insgesamt vergangene Zeit: 2.001 Sekunden
 
Vergangene Zeit seit der letzten Messung : 3 Sekunden
Insgesamt vergangene Zeit: 5 Sekunden
 
Vergangene Zeit seit der letzten Messung : 3 Sekunden
Insgesamt vergangene Zeit: 8.001 Sekunden
 
Vergangene Zeit seit der letzten Messung : 2.193 Sekunden
Insgesamt vergangene Zeit: 10.193 Sekunden

Die Klasser timer:


//Measure executing time
class timer
{
	private $time;
	private $last_time;
 
	//Constructor
	public function __construct ($start = true)
	{
		$this->start();
	}
 
 
	//Return the time
	private function get_time()
	{
		return $this->time;
	}	
 
 
	//Return the last time
	private function get_last_time()
	{
		return $this->last_time;
	}	
 
 
	//Start timer and set time
	private function start()
	{
		$this->time = $this->last_time = $this->get_current_time();
		return true;
	}		
 
 
	//Return the current time in microseconds
	private function get_current_time()
	{
		//Return time
		$mtime = explode(" ",microtime());
		return $mtime[1] + $mtime[0];
	}
 
	//Measure total time elapsed since last time
	public function measure_intermediate ($round = 3)
	{
		$time = round ($this->get_current_time() - $this->get_last_time(), $round);
		$this->last_time = $this->get_current_time();
		return $time;
	}		
 
 
	//Measure total time 
	public function measure_elapsed ($round = 3)
	{
		return round ($this->get_current_time() - $this->get_time(), $round);
	}	
}

Eine recht einfach gestrickte Klasse, dafür aber nicht minder nützlich

Selektives Kopieren von Tabellen

admin — Wed, 08 Jul 2009 16:51:27 +0000

Ich habe vor einigen Tagen folgende Email eines Besuchers erhalten:

Ich möchte von db1 nach db2 ganz bestimmte einzelne Tabellen mit dem kompletten Inhalt kopieren und das per Cronjob zu bestimmten Zeiten. Dabei dürfen in db2 die bestimmten einzelnen Tabellen mit dem kompletten Inhalt überschrieben werden. [...] Dann wäre es toll wenn ich im Skript [...] auch die einzelnen Tabellen konfigurieren kann.

Hier ein Skript welches die beschriebene Aufgabe lösen sollte

Man kann hierbei die Tabellen einzeln angegeben …

1
2
3

$table_pattern_arr = array();
$table_pattern_arr[] = 'tabelle1';
$table_pattern_arr[] = 'tabelle2';

… oder aber Platzhalter verwenden:

1 2	$table_pattern_arr = array(); $table_pattern_arr[] = 'tabelle%';

Das vollständige Script:


 
//Verbindungsdaten
$database_server = 'localhost';
$database_username = 'root';
$database_password = '';
 
//Datenbanken
$database_source = 'phpbb';
$database_target = 'test';
 
//Zu kopierende Tabellen - Wildcards erlaubt
$table_pattern_arr = array();
$table_pattern_arr[] = 'phpbb_acl%';
 
//Nicht vorhandene Tabellen ignorieren?
$ignore_non_existing_tables = false;
 
//Mit Datenbank-Server verbinden
if ( ($database_handle = mysql_connect($database_server, $database_username, $database_password)) === false)
{
	die(get_database_error($database_handle));
}
 
//Überprüfen ob Datenbanken vorhanden sind
foreach (array ($database_source, $database_target) AS $database)
{
	$sql = "SHOW DATABASES LIKE '".$database."'";
	$query = mysql_query($sql, $database_handle) or die('['.__LINE__.']'.get_database_error($database_handle));
 
	if (mysql_num_rows ($query) <> 1)
	{
		die ("Datenbank [".$database."] wurde nicht gefunden");
	}
}
 
 
//Tabellen durchgehen
foreach ($table_pattern_arr AS $table_pattern)
{
	//Überprüfen ob die Tabelle vorhanden ist
	$sql = "SHOW TABLES IN ".$database_source." LIKE '".addslashes ($table_pattern)."'";
	$query = mysql_query($sql, $database_handle) or die('['.__LINE__.']'.get_database_error($database_handle));
 
	//Keine Tabellen vorhanden
	if (mysql_num_rows ($query) == 0)
	{
		if ( ! $ignore_non_existing_tables)
		{
			die ("Keine Tabellen die dem Filter [".$table_pattern."] entsprechen in der Datenbank [".$database_source."]");
		}
	}
	//Tabellen vorhanden
	else
	{
		//Gefundene Tabellen duchgehen
		while ($row = mysql_fetch_row ($query))
		{
			//Name der Tabelle
			$table_name = $row[0];		
 
		 	//Ziel Tabelle löschen falls vorhanden
		 	$sql = "DROP TABLE IF EXISTS ".$database_target.".".$table_name;
		 	$sub_query = mysql_query($sql, $database_handle) or die('['.__LINE__.']'.get_database_error($database_handle));
 
			//Query zur Erstellung der Tabelle auslesen
			$sql = "SHOW CREATE TABLE ".$database_source.".".$table_name;
 
			$sub_query = mysql_query($sql, $database_handle) or die('['.__LINE__.']'.get_database_error($database_handle));
			$sub_query_data_arr = mysql_fetch_row($sub_query);	
 
			//Query zur Erstellung der neuen Tabelle konstruieren
			$sql = str_replace("`".$table_name."`",$database_target.".".$table_name, $sub_query_data_arr[1]);
 
			//Tabelle in Ziel-Datenbank erstellen
			$sub_query = mysql_query($sql, $database_handle) or die('['.__LINE__.']'.get_database_error($database_handle));
 
			//Daten Einfügen
			$sql = "INSERT INTO ".$database_target.".".$table_name." SELECT * FROM ".$database_source.".".$table_name;
			$sub_query = mysql_query($sql, $database_handle) or die('['.__LINE__.']'.get_database_error($database_handle));
		}		
	}
}
 
//Fertig
mysql_close($database_handle);
 
 
//Funktionen
function get_database_error ($resource)
{
	return mysql_errno($resource).' :: '.mysql_error ($resource);
}

Hier zum Beispiel ein Cronjob um das Script stündlich auszuführen:

00 */1 * * * php /var/www/lunar/local/scripts/copy_tables.php

Für Anregungen und Fragen könnt Ihr mir gerne einen Kommentar hinterlassen, oder eine Frage an den Experten stellen.

Testsystem per Cronjob neu aufsetzen

admin — Tue, 14 Apr 2009 11:55:00 +0000

Ich habe vor Ostern von einem meiner Leser folgende Frage erhalten:

Ich möchte ein CMS für Besucher als Testsystem anbieten. Dadurch wird dieses System aber immer von den Besuchern umkonfiguriert und hin und wieder unbrauchbar gemacht.

Bis jetzt habe ich immer einen Dump der Datenbank gemacht und von Hand täglich zurück geschrieben. Ebenso auch eine Kopie von den dazu gehörenden Template-Files. Könnte man dies nicht über ein Script automatisieren?

Ja, diesen Prozess kann man automatisieren, ich habe dieses Problem wie folgt gelöst:

1. Das Script

Über dieses Script werden sowohl die Dateien als auch die Datenbank des Testsystems gesichert und bei Bedarf wiederhergestellt. Ich habe das Script an meinem Blog getestet, die Benutzerdaten sowie die Ordner müsst Ihr natürlich an Eure eigene Umgebung anpassen. Weitere Erklärungen befinden sich unterhalb des Scriptes

#!/bin/sh
 
#Zugangsdaten der Datenbank
mysql_user="BENUTZERNAME"
mysql_pass="PASSWORT"
mysql_host="HOST"
mysql_database="DATENBANK"
 
#Ordner der Webseite, von der das Backup angelegt wird
original_folder=/var/www/lunar/public/htdocs
 
#Log Ordner
backup_log_folder=/var/www/lunar/local/scripts/website_backup/logs
 
#Log Dateien
backup_log_info=$backup_log_folder/backup.log
backup_log_error=$backup_lof_folder/backup.err
backup_log_date_format="%d.%m.%Y %R";
 
#Backup Ordner
backup_file_folder=/var/www/lunar/local/scripts/website_backup/backup
 
#Backup Dateien
backup_file_system=$backup_file_folder/backup_system.tar.gz
backup_file_database=$backup_file_folder/backup_database.sql.gz
 
#Vergangene Zeit berechnen
backup_start_time=`date +%s`
 
#Sicherheitskopie erstellen
if [ "$1" == "create" ]
then
        #Backup Ordner erstellen
        mkdir -p $backup_file_folder
 
        #Backup Ordner überprüfen
        if [ ! -d $backup_file_folder ]
        then
                echo "[`date +"$backup_log_date_format"`] Invalid directory $backup_file_folder, aborting" | tee -a $backup_log_error
                exit 1
        fi
 
        #Backup der Dateien anlegen
        #Hierbei wechselt tar zuerst in den Wurzelordner und erstellt dann das Backup
        #Damit dies funktioniert muss der erste Slash des Quellordners entfernt werden 
        #Diese Vorgehensweise verhindert den Hinweis "tar: Removing leading `/' from member names"
        tar -czf $backup_file_system -C / "${original_folder#"${original_folder%%[!/]*}"}"
 
        #Backup der Datenbank anlegen
        mysqldump --opt --add-drop-database  --password=$mysql_pass --user=$mysql_user --host=$mysql_host --databases $mysql_database | gzip > $backup_file_database
 
        #Falls der Fehler "Access denied...when using LOCK TABLES" auftreten sollte, dann hat der 
        #MySQL-Benutzer mit dem man arbeitet nicht die benötigten Benutzerrechte um Tabellen zu sperren.
        #Hier kann man den Parameter --lock-tables=false (hinter --opt anhängen) verwenden falls man keinen
        #Zugriff auf die Benutzerrechte hat
 
        #Loggen
        echo "[`date +"$backup_log_date_format"`] Backup of folder [$original_folder] and database [$mysql_database] created" | tee -a $backup_log_info
 
#Webseite wiederherstellen
elif [ "$1" == "restore" ]
then
        #Backup Dateien überprüfen
        if [ ! -f $backup_file_system ]
        then
                echo "[`date +"$backup_log_date_format"`] System backup file $backup_file_system not found, aborting" | tee -a $backup_log_error
                exit 1
        fi
 
        if [ ! -f $backup_file_database ]
        then
                echo "[`date +"$backup_log_date_format"`] Database backup file $backup_file_database not found, aborting" | tee -a $backup_log_error
                exit 1
        fi
 
        #Dateien wiederherstellen
        tar --recursive-unlink -xzf $backup_file_system -C /
 
        #Datenbank wiederherstellen
        gunzip < $backup_file_database | mysql --password=$mysql_pass --user=$mysql_user --host=$mysql_host
 
        #Loggen
        echo "[`date +"$backup_log_date_format"`] Backup of folder [$original_folder] and database [$mysql_database] restored" | tee -a $backup_log_info
 
#Falscher Parameter
else
        echo "Aufruf wie folgt:"
        echo " $0 create   : Sicherheitskopie der Webseite anlegen"
        echo " $0 restore  : Webseite anhand der Sicherheitskopie wiederherstellen"
        exit 1
fi
 
#Vergangene Zeit berechnen
backup_end_time=`date +%s`
backup_elapsed_time=`expr $backup_end_time - $backup_start_time`
echo -e "[`date +"$backup_log_date_format"`] Elapsed time "`date -d "1970-01-01 $backup_elapsed_time +sec" +"%H:%M:%S"`"" | tee -a $backup_log_info

Um das Script zu testen habe ich die folgenden Ordner angelegt:

/var/www/lunar/local/scripts/website_backup/
/var/www/lunar/local/scripts/website_backup/backup/
/var/www/lunar/local/scripts/website_backup/logs/

Das Script habe ich hier abgespeichert:

/var/www/lunar/local/scripts/website_backup/website_backup.sh

2. Das Testsystem abspeichern

Um das Testsystem abzuspeichern muss man das Script mit dem Parameter create aufrufen:

/var/www/lunar/local/scripts/website_backup # sh website_backup.sh create
[14.04.2009 13:20] Backup of folder [/var/www/lunar/public/htdocs] and database [lunar] created
[14.04.2009 13:20] Elapsed time 00:00:01

Hierbei wurden die folgenden Dateien angelegt:

/var/www/lunar/local/scripts/website_backup # ll backup/
total 3.0M
2009-04-14 13:20 backup_database.sql.gz
2009-04-14 13:20 backup_system.tar.gz

Noch ein kurzer Blick auf die Logs:

/var/www/lunar/local/scripts/website_backup # tail logs/backup.log 
[14.04.2009 13:20] Backup of folder [/var/www/lunar/public/htdocs] and database [lunar] created
[14.04.2009 13:20] Elapsed time 00:00:01

3. Das Testsystem wiederherstellen

Um das Testsystem wiederherzustellen muss man das Script mit dem Parameter restore aufrufen. Dies funktioniert natürlich nur dann, wenn bereits ein Backup vorhanden ist. Die Datenbank und Dateien des Testsystems werden hierbei komplett durch die gesicherten Versionen ersetzt.

/var/www/lunar/local/scripts/website_backup # sh website_backup.sh restore
[14.04.2009 13:31] Backup of folder [/var/www/lunar/public/htdocs] and database [lunar] restored
[14.04.2009 13:31] Elapsed time 00:00:01

4. Die Wiederherstellung automatisieren

Um die Wiederherstellung zu automatisieren bietet es sich an, zunächst eine Sicherheitskopie anzulegen (Siehe Punkt 2), und diese dann per Cronjob regelmässig neu aufzuspielen.

Hier zum Beispiel ein Cronjob, welcher das Testsystem stündlich wiederherstellen würde:

00 */1 * * * sh /var/www/lunar/local/scripts/website_backup/website_backup.sh

Für Anregungen und Fragen könnt Ihr mir gerne einen Kommentar hinterlassen, oder eine Frage an den Experten stellen.

MySQL - Datenbank Backup Script

admin — Wed, 08 Apr 2009 09:36:31 +0000

In einem meiner vorigen Beiträge habe ich beschrieben, wie man MySQL-Datenbanken mit mysqldump kopieren kann.

In Verbindung mit einem Cronjob eignet sich mysqldump aber auch hervorragend dazu, Sicherheitskopien von Datenbanken anzulegen. Das folgende Bash Script nutze ich, um täglich ein Backup aller MySQL-Datenbanken eines Servers anzulegen…

#!/bin/sh
 
#Zugangsdaten
mysql_user="MYSQL_BENUZERNAME"
mysql_pass="MYSQL_PASSWORT"
mysql_host="localhost"
 
#Log Dateien
backup_log_info=/var/log/mysql/mysql-backup.log
backup_log_error=/var/log/mysql/mysql-backup.err
backup_log_date_format="%d.%m.%Y %R";
 
#Vergangene Zeit berechnen
backup_start_time=`date +%s`
 
#Backup Wurzel Ordner
backup_root_dir=/var/mysql-backup
 
#Backup Tages Ordner
backup_day_dir=`date +%Y-%m-%d`
 
#Backups, die älter als X Tage sind, löschen
backup_keep_days=10
 
#Verschiedene Ordner, bei mehreren Backups an ein und dem selben Tag
i=1;
backup_version_dir=`printf "%03d" $i`
 
while [ -d $backup_root_dir/$backup_day_dir/$backup_version_dir ]
        do
                i=`expr $i + 1`
                backup_version_dir=`printf "%03d" $i`
        done
 
#In diesem Ordner wird das Backup gespeichert
backup_dir=$backup_root_dir/$backup_day_dir/$backup_version_dir
 
#Loggen
echo "[`date +"$backup_log_date_format"`] Creating backup" | tee -a $backup_log_info
echo "[`date +"$backup_log_date_format"`] Date: $backup_day_dir, iteration $backup_version_dir" | tee -a $backup_log_info
echo "[`date +"$backup_log_date_format"`] Backup to: $backup_dir" | tee -a $backup_log_info
 
#Backup Ordner erstellen
mkdir -p $backup_dir
 
#Backup Ordner überprüfen
if [ ! -d $backup_dir ]
        then
                echo "[`date +"$backup_log_date_format"`] Invalid directory $backup_dir, aborting" | tee -a $backup_log_error
                exit 1
        fi
 
#Alte Ordner löschen
find  $backup_root_dir -maxdepth 1 -mtime +$backup_keep_days -type d | xargs rm -rf
 
#Namen der Datenbank auslesen
for database in `mysql -s -u$mysql_user -p$mysql_pass -e "SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME NOT IN ('mysql','information_schema')"`;
        do
                #Log 
                echo "[`date +"$backup_log_date_format"`] Backing up $database" | tee -a $backup_log_info
 
				#Sichern
                mysqldump --opt --password=$mysql_pass --user=$mysql_user --host=$mysql_host $database | gzip  --rsyncable > $backup_dir/$database.sql.gz
        done
 
 
#Vergangene Zeit berechnen
backup_end_time=`date +%s`
backup_elapsed_time=`expr $backup_end_time - $backup_start_time`
echo -e "[`date +"$backup_log_date_format"`] Elapsed time "`date -d "1970-01-01 $backup_elapsed_time +sec" +"%H:%M:%S"`"\n\n" | tee -a $backup_log_info

Die Ordner werden von diesem Script automatisch angelegt, und stellen sich wie folgt dar:

/var/mysql-backup # ls -al
total 56K
drwxr-xr-x  3 root root 4.0K 2009-03-30 03:33 2009-03-30
drwxr-xr-x  3 root root 4.0K 2009-03-31 03:33 2009-03-31
drwxr-xr-x  3 root root 4.0K 2009-04-01 03:33 2009-04-01
drwxr-xr-x  3 root root 4.0K 2009-04-02 03:33 2009-04-02
drwxr-xr-x  3 root root 4.0K 2009-04-03 03:33 2009-04-03
drwxr-xr-x  3 root root 4.0K 2009-04-04 03:33 2009-04-04
drwxr-xr-x  3 root root 4.0K 2009-04-05 03:33 2009-04-05
drwxr-xr-x  3 root root 4.0K 2009-04-06 03:33 2009-04-06
drwxr-xr-x  3 root root 4.0K 2009-04-07 03:33 2009-04-07
drwxr-xr-x  4 root root 4.0K 2009-04-08 03:33 2009-04-08

Tagtäglich wird ein neuer Ordner hinzugefügt, und die Ordner, die älter als backup_keep_days Tage sind, gelöscht. Bei mehreren Backups an ein und dem gleichen Tag, werden verschiedene Unterverzeichnisse angelegt. Am 8. April wurden zum Beispiel zwei Backups gefahren:

/var/mysql-backup/2009-04-08 # ls -al
total 140K
drwxr-xr-x 2 root root 136K 2009-04-08 11:07 001
drwxr-xr-x 2 root root 136K 2009-04-08 11:53 002

Die Logs sehen wie folgt aus:

[31.03.2009 03:33] Creating backup
[31.03.2009 03:33] Date: 2009-03-31, iteration 001
[31.03.2009 03:33] Backup to: /var/mysql-backup/2009-03-31/001
[30.03.2009 03:33] Backing up lunar
[30.03.2009 03:33] Elapsed time 00:00:12

Der Cronjob sieht wie folgt aus:

#Datenbank Backup
33 3 * * * sh /root/mysql-backup/mysql-backup.sh

Viel Spass damit

MySQL - Benutzerrechte exportieren

admin — Fri, 03 Apr 2009 12:04:43 +0000

Ich wollte heute Morgen die Benutzerrechte (Privileges) der MySQL-Benutzerkonten eines Servers exportieren, und war recht erstaunt darüber, zu diesem Thema weder einen Eintrag im MySQL-Handbuch, noch eine Beschreibung über Google finden zu können.

Ich habe mich also drangesetzt, und nach einiger Überlegung, folgendes Script geschrieben:


 
//Mit Datenbank verbinden
if ( ($db_handle = mysql_connect('HOST', 'BENUTZERNAME', 'PASSWORT')) === false)
{
        die(mysql_error());
}
 
//Benutzer auslesen
$sql = "SELECT CONCAT(\"'\",User, \"'@'\", Host, \"'\") AS username, CONCAT(\"'\", Password, \"'\") AS password FROM mysql.user";
$query = mysql_query($sql, $db_handle) or die(mysql_error($db_handle));
 
while ($get = mysql_fetch_object ($query))
{
        //Query zur Erstellung des Benutzers
        echo "CREATE USER ".$get->username." IDENTIFIED BY ".$get->password.";\n";
 
        //Benutzerrechte auslesen
        $ssql = "SHOW GRANTS FOR ".$get->username;
        $squery = mysql_query($ssql, $db_handle) or die(mysql_error($db_handle));
 
        while ($srow = mysql_fetch_array ($squery))
        {
                //Query zur erstellung der Benutzerrechte
                echo $srow[0].";\n";
        }
}
?>

Wie kann man die Benutzerrechte über dieses Script exportieren?

Den Quelltext in einer Datei, zum Beispiel export_privileges.php, speichern
Die Rechte exportieren: export_privileges.php > privileges.sql
Die Rechte importieren: mysql < privileges.sql
Die Rechte neu laden: mysql -e "FLUSH PRIVILEGES;"

Zusammenfassung:

1
2
3

claude@localhost ~ $ export_privileges.php > privileges.sql
claude@localhost ~ $ mysql -uBENUTZERNAME -pPASSWORT -hHOST < privileges.sql
claude@localhost ~ $ mysql -uBENUTZERNAME -pPASSWORT -hHOST -e "FLUSH PRIVILEGES;"

Fertig

Cannot delete or update a parent row: a foreign key constraint fails

claude — Thu, 02 Apr 2009 09:51:59 +0000

Beim Importieren von InnoDB-Datenbanken kann es unter Umständen zu folgendem Fehler kommen:

ERROR 1217 (23000) at line 243: Cannot delete or update a parent row: a foreign key constraint fails

Wie kommt es zu diesem Fehler?

Wenn man eine Datenbank mit mysqldump exportiert, wird eine Datei mit SQL - Befehlen erzeugt. Wenn man diese Datei anschliessend importiert, werden diese Befehle nacheinander ausgeführt und erzeugen eine Datenbank, die identisch zu der exportierten Version ist.

Bei InnoDB-Tabellen mit Fremdschlüssel-Beschränkungen wird es aber mit Sicherheit zu dem oben gennanten Fehler kommen. Dies liegt daran, dass die SQL-Befehle ohne logischen Zusammenhang ausgeführt werden.

Das MySQL Handbuch schreibt:

InnoDB weist jede INSERT- oder UPDATE-Operation zurück, die versucht, einen Fremdschlüsselwert in einer Kindtabelle anzulegen, wenn kein passender Schlüsselwert in der Elterntabelle vorhanden ist.

Da die SQL-Befehle, wie gesagt, ohne logischen Zusammenhang (der Reihe nach) abgearbeitet werden, kann es gut sein, dass die Kindtabelle vor der entsprechenden Elterntabelle importiert wird.

Wie umgeht man dieses Problem?

Lösung 1:
Man editiert die Backup-Datei und fügt folgende Befehle hinzu:

SET FOREIGN_KEY_CHECKS=0; => An den Anfang der Datei
SET FOREIGN_KEY_CHECKS=1; => Ans Ende der Datei

echo "SET FOREIGN_KEY_CHECKS=0;" > backup_no_fkc.sql
cat backup.sql >> backup_no_fkc.sql
echo "SET FOREIGN_KEY_CHECKS=1;" >> backup_no_fkc.sql

Nach dieser Änderung kann die Datei wie gewohnt importiert werden.

In PHPMyAdmin ist es übrigens möglich beim Exportieren die Option Disable foreign key checks anzukreuzen, dann werden diese beiden Befehle automatisch zur Backup-Datei hinzugefügt.

Lösung 2:
Man arbeitet mit der Konsole und importiert die Datei wie folgt:

mysql> SET FOREIGN_KEY_CHECKS = 0;
mysql> SOURCE backup.sql
mysql> SET FOREIGN_KEY_CHECKS = 1;

MySQL - Spalten nach Typ gruppieren

claude — Wed, 01 Apr 2009 14:17:32 +0000

Ich habe mich heute mit einer etwas vernachlässigten Datenbank beschäftigt. Diese enthielt eine bunte Mischung von Spalten in den Formaten utf8_general_ci sowie latin1_swedish_ci.

Ziel der Aktion war es die Struktur erstmal zu analysieren und dann grundlegend zu überarbeiten.

Zuerst ging es also darum einen Überblick darüber zu erhalten, welche Spalten-Typen wie oft vorhanden waren. Zu diesem Zweck habe ich mir folgendes Script geschrieben:


//Mit Datenbank-Server verbinden
if ( ($db_handle = mysql_connect('SERVER', 'BENUTZER_NAME', 'PASSWORD')) === false)
{
        die(mysql_error());
}
 
//Datenbank
$database = 'DATENBANK';
 
//Tabellen auslesen
$tsql = "SHOW TABLES FROM ".$database;
$tquery = mysql_query($tsql, $db_handle) or die(mysql_error($db_handle));
 
while ($trow = mysql_fetch_array ($tquery))
{
        //Aktuelle Tabelle
        $table = $trow[0];
 
        //Spalten auslesen
        $csql = "SHOW FULL COLUMNS FROM ".$database.".".$table;
        $cquery = mysql_query($csql, $db_handle) or die(mysql_error($db_handle));
 
        while ($crow = mysql_fetch_row ($cquery))
        {
                if ( ! empty ($crow[2]))
                {
                        $column_arr[$crow[2]][] = $table.'.'.$crow[0];
                }
        }
}
 
print_r ($column_arr);
 
?>

In einem meiner nächsten Artikel, werde ich beschreiben wie man die Spalten bequem in ein anderes Format konvertieren kann

Auf die Datenbank meines Blogs angewendet, sieht die Ausgabe übrigens so aus:

MySQL - Datenbanken kopieren, duplizieren

claude — Tue, 24 Mar 2009 22:51:50 +0000

In einem meiner vorigen Artikel habe ich beschrieben, wie man mit mysqldump MySQL - Datenbanken von Server zu Server kopieren kann.

Es kommt jedoch auch oft vor, dass man eine MySQL - Datenbank duplizieren, sprich eine Kopie auf dem gleichen Server erstellen möchte.

Dies kann zum Beispiel der Fall sein, wenn man eine Änderung und/oder ein Script testen -dazu aber nicht die Hauptdatenbank verwenden möchte. Es gibt leider keinen direkten Befehl um eine Datenbank zu duplizieren, daher muss man leider den Umweg über, zum Beispiel, ein PHP-Script gehen.

Hier stelle ich ein PHP-Script vor, welches es ermöglicht, eine Kopie einer MySQL - Datenbank zu erstellen…


 
//Mit Datenbank-Server verbinden
if ( ($db_handle = mysql_connect('SERVER', 'BENUTZER_NAME', 'PASSWORD')) === false)
{
	die(mysql_error());
}
 
//Quell-Datenbank
$database_source = 'datenbank';
 
//Ziel-Datenbank
$database_target = 'datenbank_kopie';
 
//Ziel-Datenbank erstellen
$sql = "CREATE database ".$database_target;
$query = mysql_query($sql, $db_handle) or die(mysql_error($db_handle));
 
//Tabellen der Quell-Datenbank auslesen
$sql = "SHOW TABLES FROM ".$database_source;
$query = mysql_query($sql, $db_handle) or die(mysql_error($db_handle));
$num_tables = mysql_num_rows($query);
 
for($i = 0; $i < $num_tables; $i++)
{
	//Name der Tabelle
	$table_name = mysql_result($query, $i);			
 
	//Query zur Erstellung der Tabelle auslesen
	$sql = "SHOW CREATE TABLE ".$database_source.".".$table_name;
	$sub_query = mysql_query($sql, $db_handle) or die(mysql_error($db_handle));
	$sub_query_data_arr = mysql_fetch_row($sub_query);	
 
	//Query zur Erstellung der neuen Tabelle konstruieren
	$sql = str_replace("`".$table_name."`",$database_target.".".$table_name, $sub_query_data_arr[1]);
 
	//Tabelle in Ziel-Datenbank erstellen
	$sub_query = mysql_query($sql, $db_handle) or die(mysql_error($db_handle));
 
	//Daten Einfügen
	$sql = "INSERT INTO ".$database_target.".".$table_name." SELECT * FROM ".$database_source.".".$table_name;
	$sub_query = mysql_query($sql, $db_handle) or die(mysql_error($db_handle));
}
 
//Fertig
mysql_close($db_handle);
 
?>

Falls Ihnen dieses Script gefällt, und Sie es auf Ihrer Webseite einsetzen, so würde ich mich über einen Backlink zu meinem Blog freuen