text: Die MySQL C-API ist eine Bibliothek, welche in C geschrieben wurde und die es Ihnen erlaubt, Client-Programme mit Zugriff auf die MySQL-Datenbank zu erstellen.
  Abgesehen von der MySQL C-API gibt es noch MySQL APIs zu Perl, PHP, C++, Python, Tcl und einen Eiffel-Wrapper, welche aber alle - wie auch die C API - die mysqlclient-Bibliothek verwenden. Eine Ausnahme stellt hierbei nur JAVA dar. Um mit JAVA auf den MySQL-Server zuzugreifen, wird der JDBC-Treiber benötigt.
  28.4.1 Grundlagen zur Programmierung eines MySQL-Clients
  Bevor Sie beginnen eigene Client-Programme zu schreiben, sollten Sie zunächst in Erfahrung bringen, wie Sie ein solches Programm erstellen können. Das Kompilieren und Linken eines Client-Programms ist gerade unter Windows recht umständlich. Umständlich daher, weil die Bibliothek libmysql.lib mit dem Visual C++-Compiler erzeugt wurde. Für denjenigen, der diesen Compiler unter Windows verwendet, kann das egal sein. Aber viele Benutzer mit anderen Compilern werden recht schnell frustriert aufgeben, eigene MySQL-Client-Programme zu schreiben, wenn sich die Bibliothek nicht mit dem Compiler verträgt.
  Dabei darf neidisch auf die Linux-Anwender geschaut werden, da es auf diesem System überhaupt keine Probleme gibt, denn dort wird der Compiler gcc verwendet. Die Auswahl des Compilers und das Herumärgern mit der Bibliothek fällt also schon einmal weg.
  Damit Sie einen MySQL-Client programmieren können, benötigen Sie Folgendes:
  Die MySQL Bibliothek (lib)
  Die MySQL Headerdateien (include)
  Unter Windows ist bei einer Standardinstallation von MySQL in der Regel beides vorhanden. Die Bibliothek sollten Sie dabei im Verzeichnis ("c:" sei das Laufwerk) c:\mysql\lib\opt vorfinden und die Headerdateien im Verzeichnis c:\mysql\include.
  Bei Linux sollten Sie die Bibliothek im Verzeichnis /usr/lib oder /usr/lib/mysql oder auch /usr/local/lib/mysql finden. Die Headerdatei ist in der Regel unter /usr/include/mysql oder auch /usr/local/include/mysql abgelegt. Bei einer RPM-Installation unter Linux kann es auch sein, dass Sie zur Entwicklung eigener Clients noch ein extra RPM installieren müssen (Developer RPM).
  Bei Windows müssen Sie außerdem die DLL libmysql.dll in ein Systemverzeichnis kopieren. Zumeist sollte dies das Verzeichnis c:\Windows\system32 sein. Außerdem sollten Sie in der Quelldatei unter Windows den Header <windows.h> noch vor der Headerdatei <mysql.h> inkludieren. Etwa so:
  28.4.2 Client-Programm mit dem gcc- unter Linux und dem Cygwin gcc-Compiler unter Windows
  Zuerst kompilieren Sie das geschriebene Client-Programm, in dem Sie mit dem Compilerflag -I (Include) angeben, an welcher Stelle sich die Headerdateien von MySQL befinden. Bei Linux mit gcc:
  Windows unter der Cygwin-Umgebung mit gcc:
  Jetzt verfügen Sie über eine Objektdatei in dem Verzeichnis, in welchem Sie den Quellcode kompiliert haben. Als Nächstes müssen Sie diese Objektdatei zu einer ausführbaren Datei linken. Damit dies auch klappt, müssen Sie dem Linker mitteilen, wo sich die Client-Bibliothek von MySQL befindet. Dies erledigen Sie mit dem Compilerflag -L, mit dem der Pfad zur Bibliothek angegeben wird, und dem Flag -l, mit dem Sie die Bibliothek angeben, welche hinzugelinkt werden soll. Die Eingabe für Linux lautet:
  Bei Windows sollten Sie die dynamische Bibliothek libmySQL hinzulinken, welche ein Wrapper zum Laden von libmySQL.dll ist. Es ist aber auch möglich, die statische Bibliothek mysqlclient.lib hinzuzulinken. Wenn alles bis hierher glatt verlaufen ist, können Sie den Client beim Namen aufrufen.
  28.4.3 MySQL Client-Programme mit dem VC++ Compiler und dem Borland Freeware Compiler
  Bei beiden Compilern wird davon ausgegangen, dass diese bereits auf Ihrem System installiert sind. Installationsanleitungen diverser Compiler finden Sie unter http://www.pronix.de/Einstieg/.
  Erstellen Sie wie gewöhnlich ein leeres Win32-Konsolen-Fensterprojekt. Fügen Sie dem Projekt eine C++-Datei hinzu. In diese Datei können Sie jetzt wie gewohnt Ihren Quellcode eingeben. Binden Sie die Headerdatei <mysql.h> über die Pfadangabe mit ein:
  Jetzt können Sie den Quellcode kompilieren, aber noch nicht linken. Zuvor müssen Sie dem Linker noch den Pfad zur mysql-Bibliothek mitteilen. Dies realisieren Sie über Projekt · Einstellungen. Im Register Linker im Feld Objekt-/Bibliothek-Module fügen Sie jetzt am Ende folgenden Pfad hinzu:
  c:\mysql\lib\opt\libmysql.lib
  Abbildung 28.xx: Pfadangabe zur MySQL-Bibliothek für den Linker
  Jetzt können Sie das Programm linken und ausführen. Voraussetzung ist natürlich auch, dass Sie die DLL libmySQL.dll in ein Systemverzeichnis kopiert haben (bspw. system32).
  Im bin-Verzeichnis des Borland-Compilers befindet sich das Tool coff2omf, mit dem Sie die im Microsoft-Croff-Format vorliegende libmysql in ein für Borland übliches Format, dem omf, konvertieren können:
  coff2omf c:\mysql\lib\opt\libmysql.lib c:\borland\bcc55\lib\libmysql.lib
  Nun befindet sich eine Objektdatei im entsprechenden Verzeichnis, welche Sie mit den Dateien c0x32.obj, import32.lib sowie cw32.lib und der Bibliothek libmysql zusammenlinken. Die Objektdatei c0x32 und die beiden Bibliotheken import32 und cw32 sind notwendig für eine Konsolenanwendung. Hier die vollständige Linkeranweisung zu einer ausführbaren Datei:
  ilink32 c0x32.obj  myclient.obj ,  myclient.exe ,  , import32.lib  cw32.lib libmysql.lib
  28.4.4 Troubleshooting
  Die MySQL C-API verwendet auch Funktionen aus der Headerdatei <math.h> (floor()). Bei manchen Linux-Distributionen müssen Sie <math.h> mit dem Compilerflag -lm hinzulinken:
  gcc -o myclient myclient.o -L/usr/lib/mysql -lmysqlclient -lm -lsocket -lnsl
  Erhalten Sie einen undefined reference-Fehler bei den Funktionen compress und uncompress, müssen Sie die Bibliothek zlib mit -lz hinzulinken:
  gcc -o myclient myclient.o -L/usr/lib/mysql -lmysqlclient -lm -lsocket -lnsl -lz
  Erhalten Sie vom Compiler hingegen undefined reference-Fehler auf verschiedene Funktionen, dann verträgt sich die mysqlclient-Bibliothek nicht mit dem Compiler. Dann müssen Sie sich entweder einen Compiler besorgen, mit dem sich diese Bibliothek verträgt, oder Sie laden sich die Quellcode-Distribution herunter und übersetzen sich die Bibliothek für Ihren Compiler selbst. Wie Sie dabei vorgehen, können Sie dem MySQL-Manual entnehmen.
  28.4.5 Das erste Client-Programm - Verbindung mit dem MySQL-Server herstellen
  Die Struktur MYSQL repräsentiert einen Handle für eine Datenbankverbindung, welchen Sie für fast alle MySQL-Funktionen benötigen. Die Struktur MYSQL können Sie sich in der Headerdatei <mysql.h> gern genauer ansehen.
  Um für diesen Handle jetzt Speicherplatz zu reservieren und zu initialisieren, wird die Funktion mysql_init() verwendet. Hier die Syntax zu dieser Funktion:
  Wird diese Funktion mit einem NULL-Zeiger aufgerufen, wird zuerst Speicherplatz für ein MYSQL-Objekt allloziert und gleich darauf initialisiert. Zurück gibt diese Funktion dann ein neues MYSQL-Objekt. Rufen Sie diese Funktion hingegen mit einem MYSQL-Objekt auf, wird nur das Objekt initialisiert und die Adresse des Objekts zurückgegeben. In beiden Fällen gibt diese Funktion entweder einen initialisierten MYSQL-Handle zurück oder im Fehlerfall den (C-typischen) NULL-Zeiger.
  if(my == NULL)
  Ohne erfolgreiche Ausführung dieser Funktion ist es nicht möglich, irgendeine weitere Funktion aus der C-API zu verwenden (mit Ausnahme von mysql_get_client_info()). In der folgenden Tabelle finden Sie die Bedeutungen der einzelnen Parameter der Funktion mysql_real_connect().
  MYSQL *mysql Die Adresse einer existierenden MYSQL-Struktur, welche zuvor mit der Funktion mysql_init() initialisiert wurde.
  const char *host Ein Hostname oder eine IP-Adresse; wird hierfür NULL oder "localhost" angegeben, wird versucht, eine Verbindung zum lokalen Host aufzubauen. Bei Betriebssystemen mit Sockets und Named Pipes werden diese Verbindungen statt TCP/IP verwendet, um eine Verbindung mit dem Server aufzubauen.
  const char *user Der Username, welcher beim MySQL-Login verwendet wird; bei Angabe von NULL wird der aktuell eingeloggte User verwendet.
  const char *passwort Das Passwort für den user; wird hier NULL angegeben, kann nur auf die user-Tabellen zugegriffen werden, welche ein leeres Passwort-Feld besitzen.
  const char *db Name der Datenbank (Datenbank muss existieren); bei NULL wird eine vorgegebene Datenbank verwendet.
  unsigned int port Es wird die Portnummer der TCP/IP-Verbindung verwendet, welche der host-Parameter festlegt. Ansonsten wird dabei Port 0 verwendet.
  const char *unix_socket Entweder NULL oder ein String, der ein Socket oder Named Pipe festlegt; der Verbindungstyp wird dabei vom host-Parameter festgelegt.
  unsigned int client_flag In der Regel wird hierfür der Wert 0 angegeben. Es sind aber auch spezielle Optionen, einzeln oder kombiniert, möglich:CLIENT_COMPRESS, CLIENT_FOUND_ROWS, CLIENT_IGNORE_SPACE, CLIENT_INTER_ACTIVE, CLIENT_NO_SCHEMA, CLIENT_ODBC, CLIENT_SSL
  Tabelle 28.8: Bedeutung der Parameter der Funktion mysql_real_connect()
  Die Funktion mysql_real_connect() gibt als Rückgabewert bei Erfolg den MYSQL-Handle des ersten Parameters zurück. Bei Fehler wird NULL zurückgeliefert. Somit sieht der vorzeitige Code folgendermaßen aus:
  my,            /* Zeiger auf MYSQL-Handler*/
  def_host_name, /* Host-Name*/
  def_user_name, /* User-Name*/
  def_db_name,   /* Name der Datenbank*/
  NULL,          /* Socket (default=NULL)*/
  Zum Glück müssen Sie hierfür keine spezielle Routine schreiben, welche die einzelnen Fehler abfragt. Sie können die Funktion mysql_errno() und mysql_error() verwenden. Zuerst die Syntax der Funktion mysql_errno():
  Fehler, die bei einem Client-Programm auftreten können, finden Sie in der Headerdatei <errmsg.h>, welche sich im selben Verzeichnis wie <mysql.h> befindet. Fehler des Serverprogramms befinden sich in der Headerdatei <mysqld_error.h>.
  Ein Fehlerstatuscode alleine nützt dem Anwender des Client-Programms allerdings recht wenig. Sie könnten jetzt die einzelnen symbolischen Konstanten der Headerdatei <errmsg.h> auswerten, etwa so:
  Diese Funktion gibt eine entsprechende Fehlermeldung auf dem Bildschirm aus, die von der zuletzt aufgerufenen API-Funktion provoziert wurde. Trat kein Fehler auf, gibt die Funktion einen leeren String (Index[0] == '\0') zurück.
  Somit können Sie, falls die Funktion mysql_real_connect() NULL zurückgibt, folgendermaßen eine Fehlermeldung auf dem Bildschirm ausgeben (my sei der MYSQL-Handle):
  Hiermit wird im Fall eines Fehlers der Statuscode und ein String mit entsprechender Fehlermeldung ausgegeben.
  Jetzt haben Sie eine Verbindung mit dem MySQL-Server hergestellt und könnten damit arbeiten. Aber dazu mehr im nächsten Abschnitt.
  Wollen Sie sich die Fehlermeldungen in deutscher Sprache ausgeben lassen, geben Sie Folgendes in der Kommandozeile ein: mysqld --language=german
  Dies sind die grundlegenden Aufgaben, um eine Verbindung mit dem MySQL-Server herzustellen und am Ende auch wieder zu beenden. Dazu jetzt alle Funktionen als ausführbares Programm:
  NULL, /* Host-Name*/
  NULL, /* User-Name*/
  NULL,  /* Name der Datenbank*/
  0      /* keine Flags */  )  == NULL)
  /* Hier befindet sich der Code für die Arbeit mit MySQL */
  28.4.6 MySQL-Kommandozeilen-Optionen
  Im Listing zuvor wurde die Verbindung zum MySQL-Server über die Funktion mysql_real_connect() mit Default-Werten bzw. NULL-Zeigern aufgebaut. Das dies in der Praxis häufig nicht so ist, dürfte klar sein. Dieses Thema ist im Prin-zip nicht Teil dieses Buchs, doch einige Worte sollen hierzu trotzdem gesagt werden. Vielleicht erinnern Sie sich noch, wie der mysql-Client aufgerufen wurde:
  Die Bedeutung dieser einzelnen Flags und aller weiteren finden Sie in der fol-genden Tabelle:
  Hostname -h host_name --host=host_name
  Username -u user_name --user=user_name
  Passwort -p oder-p your_password --password oder-password=your_password
  Portnummer -P port_num --port=port_num
  Socket Name -S socket_name --socket=socket_name
  Tabelle 28.9: MySQL-Kommandozeilen-Optionen (Flags)
  Damit Ihr Client, den Sie programmieren, ebenso Flags auswerten kann wie der mysql-Client, müssen Sie entweder die Argumente aus der Kommandozeile selbst auswerten oder die einzelnen Argumente im Programm abfragen. Sollten Sie auf einem System arbeiten, welches die Bibliothek getopt() beinhaltet, rate ich Ihnen, diese dafür zu verwenden.
  Wollen Sie wissen, wie die Default-Optionen für die aktuelle Verbindung mit MySQL lauten, können Sie die Funktion load_defaults() einsetzen. Die Syn-tax lautet:
  void load_defaults(const char *conf_file, const char **groups, int *argc, char ***argv);
  Mit dieser Funktion laden Sie aus conf_file - unter Linux die Datei my.cnf und unter Windows my.ini - die Optionen der Gruppen groups. Zusätzlich werden noch die Kommandozeilenargumente zur Auswertung verwendet. Für die Variable groups können Sie einen oder mehrere Strings angeben. Dies sind die Zeilen, welche in den eben genannten Konfigurations-Files zwischen eckigen Klammen stehen, bspw. unter Windows:
  char *groups[] = { "client", "WinMySQLadmin", NULL };
  Für den String conf_file wird in der Regel immer "my" verwendet. Bevor Sie jetzt die Funktion load_default() verwenden können, müssen Sie noch die Funktion my_init() aufrufen. Hierzu das Listing zu load_default():
  Abbildung 28.xx: Angepasste Argumente mit load_default()
  socket_name,  /* Socket*/
  28.4.7 Anfrage an den Server
  Ich empfehle Ihnen jetzt eine nochmalige Wiederholung der SQL-Anweisungen, da Sie einige davon auf den nächsten Seiten mit der C-API wieder verwenden werden. Als Beispiel soll hier gezeigt werden, wie Sie auf eine bereits vorhandene Datenbank zugreifen können. Dabei dient die Datenbank dvd_archiv als Grundlage, welche Sie im MySQL-Crashkurs erstellt haben. Falls Sie diese bereits gelöscht haben, erstellen Sie diese bitte nochmals. Hier die einzelnen Schritte dafür:
  Zum Schluss dieses Kapitels werden Sie dazu ein etwas umfangreicheres Beispiel erstellen. Wie schon beim mysql-Client-Programm gibt es auch bei der C-API zwei Arten von Anfragen an den Server:
  Wenn Sie wollen, können Sie sich dies wie bei den Funktionen vorstellen. Es gibt Funktionen mit einem und Funktionen ohne einen Rückgabewert.
  Eine Anfrage an den Server können Sie mit der Funktion mysql_query() stellen. Jede Anfrage an den Server läuft folgendermaßen ab:
  Sie erstellen eine SQL-Anfrage an den Server.
  Der Server erhält die Anfrage und überprüft diese auf syntaktische Fehler.
  Der Server führt die Anfrage aus und gibt das Resultat zurück. Ob ein Wert zurückgegeben wird, hängt von der Art der Anfrage ab. So gibt beispielsweise die Anfrage INSERT keinen Rückgabewert zurück, im Gegensatz zu einer Anfrage mit dem Kommando SELECT.
  Zuerst die Syntax der Funktion für das Stellen einer Anfrage:
  Damit wird die SQL-Anweisung anfrage ausgeführt, welche allerdings im Gegensatz zur Anfrage, die Sie beim MySQL-Crashkurs kennen gelernt haben, kein Semikolon am Ende haben darf. Bei dem String anfrage handelt es sich außerdem um einen nullterminierten String. Der Rückgabewert dieser Funktion lautet 0, wenn alles glatt verlief, ansonsten ungleich 0.
  Für den Fall, dass Sie eine Anfrage mit Binärdaten stellen wollen, müssen Sie die Funktion mysql_real_query() verwenden. Dies ist erforderlich, da Binärdaten das Stringende-Zeichen '\0' enthalten können, was bei mysql_query() das Ende der Anfrage bedeutet. Da allerdings mysql_query() einfacher zu handhaben ist, wird diese Funktion zumeist bevorzugt, obwohl mysql_real_query() um ein paar Prozent schneller abliefe, da mysql_query() zuvor noch die Funktion strlen() zum Zählen der Zeichen aufruft.
  Wenn Sie eine Anfrage an den Server mit der Funktion mysql_query() stellen, und es will nicht klappen, könnte es an einem der folgenden Fehler liegen:
  Der MySQL-Server ist gar nicht in Betrieb. Klingt banal, aber kommt häufig vor.
  Jetzt folgt auf den nächsten Seiten das versprochene Programm, womit Sie auf die im Crashkurs erstellte Datenbank dvd_archiv zugreifen. Einen ersten Überblick, welche Funktionen auf den folgenden Seiten erstellt werden, können Sie den Angaben der Funktionsprototypen und der main()-Funktion des Programms entnehmen:
  wurde hier zur Verkürzung des Listings ein Makro
  geschrieben, welches aber keine Schule machen soll!!
  void filmdaten_anfuegen();
  void filmdaten_loeschen();
  void filmdaten_aendern();
  void alle_daten_ausgeben();
  * Ab hier können Sie die einzelnen Funktion der
  kommenden Seiten einfügen
  if( (ptr = (char *)
  strchr(darsteller, '\n')) != NULL)
  }while(auswahl != 6);
  Auf den ersten Blick sieht das Programm noch nicht wie ein MySQL-Client-Programm aus. Die API-Funktionen zum Verbinden mit dem Server, die Fehlerüberpüfung und das Schließen einer Verbindung wurden aus der main()-Funktion entfernt und sind somit modular verfügbar. Hier die Funktionen verbinden(), check_error(), verbindung_schliessen() und db_waehlen():
  * andere Parameter benötigt werden, diese Ihren
  * Umständen selbst an
  Die einzelnen Funktionen stellen bis auf der Funktion db_waehlen() nichts Neues mehr für Sie dar. In der Funktion db_waehlen() finden Sie die API-Funktion mysql_select_db(), welche die folgende Syntax hat:
  Mit dieser Funktion wechseln Sie in die Datenbank mit dem Namen db. Mit dem MYSQL-Handle mysql können Sie jetzt auf diese Datenbank mit weiteren Operationen zugreifen. Haben Sie keine Zugriffsrechte oder existiert diese Datenbank nicht, liefert sie einen Wert ungleich 0 zurück. Bei Erfolg hingegen ist der Rückgabewert 0. Diese Funktion entspricht also der SQL-Anweisung USE. Jetzt werden Sie eine einfache Anfrage an den Server stellen. Es sollen dabei neue Daten in die Datenbank mit der SQL-Anweisung INSERT eingefügt werden. Damit Sie jetzt nicht mehr so weit zurückblättern müssen, hier noch einmal das erforderliche SQL-Kommando:
  ('Der Patriot', 'Mel Gibson', 16, 2001);
  void filmdaten_anfuegen()
  if( (ptr = (char *) strchr(titel, '\n')) != NULL)
  if( (ptr = (char *) strchr(hauptrolle, '\n')) != NULL)
  if( (ptr = (char *) strchr(temp, '\n')) != NULL)
  sscanf(temp, "%d", &fsk);
  sscanf(temp, "%d", &gedreht);
  str[0] = "INSERT INTO filmdaten (titel, hauptrolle, fsk, "
  str[1] =(char *) malloc(strlen(titel)+1);
  str[3] =(char *) malloc(strlen(hauptrolle)+1);
  str[5] =(char *) malloc(3);
  sprintf(str[5], "%2d", fsk);
  str[7] =(char *) malloc(5);
  sprintf(str[7], "%4d", gedreht);
  query =(char *) malloc(size + 1);
  Der Großteil dieser Funktion vollführt nichts anderes, als den Anfragestring für die Funktion mysql_query() dynamisch zu erstellen. Es wird hierbei davon ausgegangen, dass Sie mittlerweile gute Kenntnisse in C besitzen, sonst hätte es wohl kaum Sinn, sich mit dem Thema MySQL und C zu befassen. Wenn alles glatt verlief, befindet sich in der Datenbank dvd_archiv ein neuer Eintrag in der Tabelle filmdaten. Diese Funktion beachtet auch Einträge, bei denen Sie zum Beispiel keine Daten eingeben und einfach mit ENTER quittieren, damit dieses Feld leer bleibt.
  Wollen Sie vermeiden, dass keine NULL-Werte oder doppelte Einträge in der MySQL-Datenbank vorgenommen werden, so können Sie jeden Datensatz in einer Tabelle mit einem Schlüssel, dem so genannten Primärschlüssel, belegen. Dieser Schlüssel wird bei Erstellung der Tabelle mit CREATE TABLE-Kommando übergeben. Mit der Option NOT NULL sorgen Sie dafür, dass keine leeren Werte gespeichert werden, und mit PRIMARY KEY legen Sie fest, dass keine doppelten Einträge für ein bestimmtes Feld gespeichert werden dürfen. Genaueres dazu entnehmen Sie bitte der MySQL-Dokumentation oder entsprechender Literatur.
  void filmdaten_loeschen()
  char *item[] = {"titel", "hauptrolle", "fsk", "gedreht" };
  if(auswahl > 0 && auswahl < 5)
  str[1] =(char *) malloc(strlen(item[auswahl-1])+1);
  printf("Bitte angaben fuer \'%s\' machen: ", item[auswahl-1]);
  if( (ptr = (char *) strchr(del, '\n')) != NULL)
  str[3] =(char *) malloc(strlen(del)+1);
  /* Als Test */
  if((affected=(unsigned long)mysql_affected_rows(mysql)) <= 0 )
  printf("%d %s von dieser Anfrage betroffen\n\n",
  affected, (affected == 1)?
  "Datensatz war":"Datensaetze waren");
  Auch hier dient der Löwenanteil der Funktion dazu, den Anfragestring für die Funktion mysql_query() dynamisch zu erstellen. Neu in der Funktion filmdaten_loeschen ist die API-Funktion mysql_affected_rows(), welche nach der Funktion mysql_query() aufgerufen wurde. Die Syntax dieser Funktion lautet:
  Diese Funktion gibt die Anzahl der Zeilen zurück, welche von der letzten SQL-Anweisung wie DELETE, INSERT oder UPDATE betroffen war. Meistens wird diese Funktion unmittelbar nach einem Aufruf von mysql_query() verwendet. War kein Datensatz von der letzen Anfrage betroffen, liefert diese Funktion 0 zurück. Trat ein Fehler bei der Funktion auf, ist der Rückgabewert -1.
  Als Nächstes die vollständige Funktion filmdaten_aendern():
  void filmdaten_aendern()
  printf("Welchen Inhalt suchen Sie fuer %s:",item[auswahl1-1]);
  if( (ptr = (char *) strchr(change, '\n')) != NULL)
  " (Ersetzkriterium)\n");
  if( (ptr = (char *) strchr(replace, '\n')) != NULL)
  if(auswahl2 > 0 && auswahl2 < 5)
  str[1] =(char *) malloc(strlen(item[auswahl2-1])+1);
  /* Integerwerte ? */
  if(auswahl2==3 || auswahl2==4)
  sscanf(replace, "%d", &integer);
  str[3] =(char *) malloc(5);
  else /* ... dann ist es ein str */
  str[3] =(char *) malloc(strlen(replace)+3);
  if(auswahl1 > 0 && auswahl1 < 5)
  str[5] =(char *) malloc(strlen(item[auswahl1-1])+1);
  if(auswahl1==3 || auswahl1==4)
  sscanf(change, "%d", &integer);
  str[7] =(char *) malloc(strlen(change)+3);
  Der Vorgang, Daten vom Server zu empfangen, wird ebenfalls mit der Funktion mysql_query() ausgelöst. Danach folgt ein Aufruf der API-Funktion mysql_store_result(), welche alle angeforderten Daten vom Server in den Speicher des Client-Programms lädt. Hier die Syntax der Funktion:
  Diese Funktion ließt Zeile für Zeile aus der Struktur MYSQL_RES ein, bis ein NULL-Zeiger zurückgegeben wird; also ähnlich wie die Standardfunktion fgets(), nur nicht bis zum nächsten Newline, sondern bis zum nächsten Datensatz. NULL wird auch zurückgegeben, wenn ein Fehler aufgetreten ist. MYSQL_ROW präsentiert eine Zeile von Daten, welche als Array-gezählte Byte-Zeichenkette implementiert ist.
  Sind Sie fertig mit den Daten der Struktur MYSQL_RES, dann sollten Sie den Speicher wieder freigeben, um Memory Leaks zu vermeiden. Die Syntax dazu lautet:
  Zugegeben, dass war jetzt ein ziemlicher Brocken, der Ihnen hier vor die Füße geschmissen wurde. Daher nochmals eine kurze Zusammenfassung, wie Sie die Anfrage vom Server abholen und bearbeiten können:
  Anfrage an den Server (mysql_query)
  void schauspieler_suchen(char *name)
  string =(char *) malloc(strlen(name)+2);
  query =(char *) malloc(strlen(select)+strlen(string)+1);
  In dieser Funktion wird in der Datenbank nach Filmen eines bestimmten Schauspielers gesucht und ausgegeben. Zuvor wird wieder der Anfragestring erstellt.
  Um jetzt die Feldwerte eines einzelnen Felds zu ermitteln, verwenden Sie die Funktion mysql_fetch_field(), welche die folgende Syntax besitzt:
  Die Informationen des Felds werden in der Struktur MYSQL_FIELD gespeichert. Hierzu ein kurzer Überblick, welche Daten Sie aus dieser Struktur entnehmen können.
  char *name; Name des Felds als String, nicht zu verwechseln mit dem Inhalt des Felds. Im Programmbeispiel sind dies titel, hauptrolle, fsk und gedreht.
  char *table; Name der Tabelle, welche dieses Feld enthält als String. Im Programmbeispiel ist der Name filmdaten.
  char *def; Der Vorgabewert des Felds als String. Wird nur gesetzt, wenn die Funktion mysql_list_fields() verwendet wird.
  enum enum_field_types; Der Datentyp des Felds. Folgende Werte können dies sein: FIELD_TYPE_DECIMAL, FIELD_TYPE_TINY,FIELD_TYPE_SHORT, FIELD_TYPE_LONG, FIELD_TYPE_FLOAT, FIELD_TYPE_DOUBLE,FIELD_TYPE_NULL, FIELD_TYPE_TIMESTAMP,FIELD_TYPE_LONGLONG, FIELD_TYPE_INT24, FIELD_TYPE_DATE, FIELD_TYPE_TIME,FIELD_TYPE_DATETIME, FIELD_TYPE_YEAR,FIELD_TYPE_NEWDATE, FIELD_TYPE_ENUM,FIELD_TYPE_SET, FIELD_TYPE_TINY_BLOB, FIELD_TYPE_MEDIUM_BLOB, FIELD_TYPE_LONG_BLOB, FIELD_TYPE_BLOB, FIELD_TYPE_VAR_STRING, FIELD_TYPE_STRING, FIELD_TYPE_GEOMETRY
  unsigned int length; Die Breite des Felds, die Sie in der Tabellendefinition festgelegt haben. Im Programmbeispiel ist dies für titel 255, für hauptrolle 255 und für fsk, gedreht jeweils 4.
  unsigned int max_length; Maximale Breite des Felds. Diese Funktion ist ideal zur Ausgabe einer Tabelle auf dem Bildschirm.
  unsigned int flags; Einige Bit-Flags für das Feld. Folgende Flags können das sein:NOT_NULL_FLAG, PRI_KEY_FLAG,UNIQUE_KEY_FLAG,MULTIPLE_KEY_FLAG. BLOB_FLAG,UNSIGNED_FLAG, ZEROFILL_FLAGBINARY_FLAG, ENUM_FLAG,AUTO_INCREMENT_FLAG, TIMESTAMP_FLAGSET_FLAG, NUM_FLAG, PART_KEY_FLAGGROUP_FLAG, UNIQUE_FLAGDie Bedeutung der einzelnen Flags spricht teilweise für sich. Für genauere Informationen sei die C-API-Dokumentation empfohlen. Um die einzelnen Flags zu testen, können die IS_-Makros verwendet werden. Beispiel, ob der Inhalt eines Felds nicht NULL ist:IS_NOT_NULL(flag);
  unsigned int decimals; Anzahl von Dezimalstellen für numerische Felder
  Tabelle 28.10: Variablen der Struktur MYSQL_FIELD
  void alle_daten_ausgeben()
  mysql_query(mysql, "SELECT * FROM filmdaten");
  /* offset = 0 bedeutet auf den Anfang der Zeile setzen */
  sollen die Daten für die max. Länge einer Spalte bei jeder
  einzelnen (MYSQL_FIELD)-Spalte verändert werden */
  die max. Länge ... */
  /* ... dann bekommt col_len den Wert der max. erl. Länge
  der Spalte */
  /* col_len bekommt den Wert 4 für den String
  "NULL" ->kein Daten */
  /* max. Länge von Spalten-Info verändern */
  gedreht) */
  for (i = 0; i < mysql_num_fields (res); i++)
  einlesen */
  while ((row = mysql_fetch_row (res)) != NULL)
  { /* Spalte für Spalte abarbeiten */
  /* Handelt es sich um ein numerisches Feld */
  linksbündige Ausgabe */
  void print_line(MYSQL_RES *res)
  Mit diesen beiden Funktionen werden alle Daten der Tabelle filmdaten sauber in Tabellenform auf dem Bildschirm ausgegeben. Zusätzlich wurde hier die Funktion mysql_field_seek() verwendet, womit der Feldcursor auf das angegebene Offset gesetzt wird. Da hier als Offset 0 angegeben wurde, wird immer bis zum Anfang einer Zeile gesucht. Die Funktion mysql_fetch_field(), welche danach aufgerufen wird, ruft die Felddefinition der Spalte ab, die mit dem Offset MYSQL_FIELD_OFFSET verknüpft ist. Wollen Sie beispielsweise an eine Position des letzten mysql_fetch_field() zurückspringen, können Sie sich eine Position mit der Funktion mysql_field_tell() merken und den Rückgabewert dieser Funktion als Offset an die Funktion mysql_field_seek() übergeben.