MySQL ohne Komponenten

[Chewie]

Zugriff auf MySQL mit der MySQL-C-API

Fast jeder, der schon mit PHP gearbeitet hat, kennt wohl den Datenbankserver MySQl, und die meisten von euch werden wohl auch schon von PHP aus damit gearbeitet haben.
Während das mit PHP sehr einfach und unkompliziert ist, erscheint es mit Delphi am Anfang recht kompliziert. Gerade wenn man noch keine Datenbankerfahrungen mit Delphi verbuchen kann, erscheint die Benutzung der Zeos-Komponenten oder auch der ODBC-Schnittstelle aufwändig und kompliziert. Ganz zu schweigen von der Tatsache, dass Komponenten, die von Zeos benötigt werden, bei den Standard- und Personal-Versionen von Delphi nicht dabei sind.
Was liegt also näher, als auf diese Komponenten zu verzichten und eine Alternative zu suchen? Besonders, wenn man bereits mit PHP und MySQL gearbeitet hat, dürfte man sehr gut mit der hier vorgestellten Methode zurechtkommen.

Das Tutorial handelt davon, wie man die C-API von MySQL in Delphi einsetzt. Ja, ihr habt richtig gelesen, C-API, so heißt es auf der MySQL-Website. Nichtsdestotrotz kann man diese API (= Application Programming Interface) natürlich auch mit Delphi verwenden.
Anmerkung: SQL-Kenntnisse werden hier nicht vermittelt. Die sind Voraussetzung zum Begreifen dieses Tutorials.
Dafür notwendig sind in erster Linie einmal die Pascal-Übersetzungen der C-Header für die MySQL-Bibliothek (und natürlich die Bibliothek selbst). Die Header findet man unter http://www.audio-data.de/mysql.html, die Bibliothek libmysql.dll ist bei dem MySQL-Server dabei.
Die Pascal-Unit mysql.pas importiert die Funktionen von libmysql.dll und stellt sie Programmmierern zur Verfügung. Um auf die DLL zugreifen zu können, muss sie entweder im Programmverzeichnis liegen oder aber im Verzeichnis Windows, Windows\System oder Windows\System32.

Nachdem das getan ist, können wir die DLL verwenden. Dazu muss die Unit mysql.pas in unser Projektverzeichnis gelegt werden und per uses-Klausel eingebunden werden. Unsere Unit sieht also so aus:

Code:

unit MysqlTest;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, [b]mySQL[/b];
  
{ ... }

Bevor wir anfangen, mit dem SQL-Server zu arbeiten, kommen einige kleine Anmerkungen.
Eine Übersicht und Dokumentation der Funktion ist auf http://www.mysql.com/documentation/m...ction_overview verfügbar.
Von diesen werden in diesem Tutorial aber nur folgende verwendet:

mysql_close()
mysql_error()
mysql_fetch_row()
mysql_free_result()
mysql_init()
mysql_real_connect()
mysql_real_query()
mysql_store_result()

Die Verwendung der übrigen Funktionen sollte aber kaum Mühe bereiten, schon gar nicht, wenn man sie aus PHP kennt, da, wie man an der Auflistung sehen kann, die C-API und die PHP-API recht ähnlich sind.

Neben den Funktionen werden noch folgende Datentypen, die in mysql.pas definiert sind, benutzt:

PMySQL
PMySQL_Res
PMySQL_Rows


So, es kann nun losgehen.

Im nachfolgenden Beispiel werden wir uns zu einem MySQL-Server verbinden und ihn nach dem aktuellen Datum fragen.
Die einzelnen Schritte werden zunächst erläutert, bevor anschließend ein kurzes Code-Beispiel erklärt wird.

Bevor wir überhaupt eine Verbindung herstellen können, müssen wir unseren Verbindungsdeskriptor initialisieren. Dieser ist vom Typ PMySQL.

Ist dies getan, können wir die Verbindung herstellen.Dafür wird mysql_real_connect() benutzt.

mysql_real_connect() ist folgendermaßen augebaut:

Delphi-Quellcode:

mysql_real_connect: function(_mysql: PMYSQL; const host, user, passwd, db: pChar; port: longword; const unix_socket: pChar; clientflag: longword): PMYSQL; stdcall;

Die Erklärung der einzelnen Parameter findet sich auf http://www.mysql.com/documentation/m...l_real_connect.

Als Rückgabe erhalten wir erneut unseren Verbindungsdeskriptor, der jetzt (hoffentlich) eine aktive Verbindung beschreibt.
Dies ist der Fall, wenn er ungleich nil ist.

Mit den eigentlichen Transaktionen beschäftigen wir uns im nächsten Kapitel, deshalb wird jetzt lediglich die Verbindung getrennt.
Das geschieht mittels mysql_close().


Das Beispiel:

Delphi-Quellcode:

var
  _myCon: PMySQL;       //unseren Verbindungsdeskriptor
  host, user, pass, db: PChar;       //die Anmeldedaten
begin
  //wir werden uns als Root-Benutzer in localhost einloggen, ohne eine
  //bestimmte Datenbank auszuwählen
  host := 'localhost';
  user := 'root';
  pass := nil;
  db := nil;
  
  //jetzt wird _myCon initialisiert
  _myCon := mysql_init(nil);
  if _myCon = nil then
  begin
    ShowMessage('Nicht genug freier Speicher, um Verbindungsdeskriptor zu initialisieren');
    Exit;
  end;
  
  //anschließend wird die Verbindung hergestellt
  if mysql_real_connect(_myCon, host, user, pass, db, 3306, nil, 0) = nil then
  begin
    ShowMessage('Die Verbindung konnte nicht hergestellt werden. Ursache: ' + mysql_error(_myCon));
    Exit;
  end;
  
  ShowMessage('Verbindung hergestellt');
  
  //zum Schluss wird die Verbindung wieder geschlossen
  mysql_close(_myCon);
end;

Im nächsten Teil werden wir ein paar einfache SELECT, INSERT, UPDATE und DELETE-Transmissionen durchführen.

[edit=Matze]Link korrigiert. MfG, Matze[/edit]

[Alexander]

freue mich schon auf den nächsten Teil, dann setze ich die Admin-zone meiner HP in Delphi um.
Danke schon mal.

[Chewie]

So, nachdem wir jetzt wissen, wie wir eine Verbindung herstellen (und auch wieder trennen) können, werden wir jetzt einige einfache Transaktionen durchführen.

Wir werden zunächst eine neue Datenbank erstellen und ihr gleich einige Tabellen hinzufügen. In diese Tabellen fügen wir einige Datensätze ein und löschen und modifizieren einige. Außerdem werden wir uns natürlich auch Datensätze zurückgegeben lassen.


1. Das Erstellen der Datenbank

Wir wollen eine Datenbank mit dem Namen APITest erstellen. Dazu benutzen wir folgendes SQL-Statement:

SQL-Code:

CREATE DATABASE APITest

Dieses verwenden wir folgendermaßen:

Delphi-Quellcode:

var
  query: PChar;
  _myCon: PMySQL;
begin
  {...}
  {Verbindung herstellen, wie in Kapitel1 beschrieben}
  {...}
  
  query := 'CREATE DATABASE APITest';
  mysql_real_query(_myCon, query, Length(query));
end;

Transaktionen werden also mit [/b]mysql_real_query()[/b] durchgeführt. Der dritte Parameter, der die Anzahl Zeichen des SQL-Statements angibt, wird benötigt, da auch binäre Daten, die Nullen enthalten, in SQL-Statement enthalten sein können. Mit Length(query) übergeben wir immer genau die richtige Anzahl Zeichen.


2. Das Erzeugen der Tabellen

Nun, da die Datenbank erzeugt ist, benötigen wir noch Tabellen, um damit arbeiten zu können. Also erzeugen wir ein paar.

Als Beispiel nehmen wir einmal ein einfaches Forum mit einer Tabelle, in der die Einträge gespeichert werden und einer, in der die Daten der Benutzer gespeichert sind. Der Einfachheit halber muss jeder Forumseintrag von einem registrierten Benutzer verfasst sein.

Die Tabelle mit den Forumsbeiträgen benötigt 4 Felder: die ID des Eintrags, die ID des Verfassers, das Eintragedatum und den eingetragenen Text.
Als SQL-Statement bedeutet das:

SQL-Code:

CREATE TABLE posts (
  id int,
  author int,
  date datetime,
  entry text
)

Außerdem benötigen wir noch eine kleine Benutzerverwaltung. Diese kommt in eine eigene Tabelle mit Feldern für die ID des Benutzers, dem Namen und das Passwort.
Die Tabelle wird mit folgendem SQL-Statement erstellt:

SQL-Code:

CREATE TABLE users (
  id int,
  name varchar(50),
  pass varchar(50),
)

So, nachdem der theoretische Teil vorbei ist, machen wir uns an die Arbeit.
Die Tabellen werden in einer eigenen Prozedur erstellt. Die Prozedur benötigt als Parameter einen Verbindungsdeskriptor (vom Typ PMySQL), der eine bereits aktive Verbindung beschreibt.

Delphi-Quellcode:

procedure MakeTables(_myCon: PMySQL);
var
  query: PChar;
begin
  mysql_select_db(_myCon, 'APITest');     //zu Datenbank "APITest" wechseln
  mysql_real_query(_myCon, 'CREATE TABLE posts(id int, author int, date datetime, entry text)', Length(query);
  mysql_real_query(_myCon, 'CREATE TABLE users(id int, name varchar(50), pass varchar(50))', Length(query));
end;

Nach Aufruf dieser Prozedur sollten die Tabellen erstellt sein. Falls sie bereits erstellt sein sollten, wird die Transaktion vom Server als ungültig angesehen und nicht ausgeführt. Eine Abfrage, ob die Tabelle bereits existiert, ist also nicht zwingend notwendig.


3. Das Ermitteln der bisherigen Einträge

Um uns alle Einträge des Gästebuchs anzeigen zu lassen, brauchen wir eine SELECT-Abfrage. Wir erstellen uns ein Record, das alle Daten eines Gästebucheintrags enthält, dieses Record speichern wir in einem Array. Anstelle der ID des Verfassers wird der Namen gespeichert.

Unsere Abfrage der Einträge sieht so aus:

SQL-Code:

SELECT * FROM posts ORDER BY id

Und so wird der Namen ermittelt

SQL-Code:

SELECT name FROM users WHERE id=IDdesUsers

Folgendermaßen sieht unser Record aus:

Delphi-Quellcode:

type
  TPostEntry = record
    id: Integer;
    author: String[50];
    time: String[255];
    text: String;
  end;
  TPostEntries = Array of TPostEntry;

Und nun erfolgt das Einlesen:

Delphi-Quellcode:

var
  Posts: TPostEntries;
  idAuthor: String;   //zum Zwischenspeichern der Verfasser-ID
  query: PChar;
  _myCon: PMySQL;
  _myRes: PMySQL_Res; //hier wird der gesamte Ergebnissatz gespeichert
  _mySubRes: PMySQL_Res;  //benötigt, um Autor zu ermmitteln
  _myRow: PMySQL_Row; //enthält den aktuellen Datensatz
  _mySubRow: PMySQL_Row;  //benötigt, um Autor zu ermmitteln
  i: Integer;
begin
  
  {...}
  {Verbindung herstellen wie in Kap. 1 beschrieben}
  
  query := 'SELECT * FROM posts ORDER BY id';
  mysql_real_query(_myCon, query, Length(query));
  
  _myRes := mysql_store_result(_myCon);  //alle Datensätze vom Server anfordern
  if _myRes = nil then
  begin
    ShowMessage('Es konnten keine Datensätze zurückgebenen werden. Ursache: ' + mysql_error(_myCon));
    Exit;
  end;
  
  SetLength(Posts, mysql_num_rows(_myRes););  //Posts-Array-Größe auf Anzahl der Datensätze setzen
  
  for i := 0 to High(Posts) do
  begin
    _myRow := mysql_fetch_row(_myRes);   //Datensatz abholen
    Posts[i].id := InttoStr(_myRow[0]);  //ID des Posts ist erstes Feld im Datensatz
    Posts[i].time := _myRow[2];          //Zeitpunkt ist drittes Feld
    Posts[i].text := _myRow[3];          //Text ist viertes Feld
    
    idAuthor := _myRow[1];
    query := PChar('SELECT name FROM users WHERE id=' + idAuthor);
    _mySubRes := mysql_store_result(_myCon);
    _mySubRow := mysql_fetch_row(_mySubRes);
    Posts[i].author := _mySubRow[0];
    
    mysql_free_result(_mySubRes);        //Ergebnissatz löschen  
  end;
  
  mysql_free_result(_myRes);             //Ergebnissätze löschen
  
  {...}
  {Verbindung schließen oder etwas anderes machen}
end;

Einige Anmmerkungen: Die zurückgebenen Daten sind alle Strings (oder besser gesagt PChars). Um sie in Zalen umzuwandeln, muss InttoStr() genutzt werden.
Jedes Ergebnis (also jede Variable vom Typ PMySQL_Res) muss mit mysql_free_result freigegeben werden, natürlich erst, wenn sie nicht mehr benötigt wird.


4. Das Ändern vorhandener Datensätze, das Hinzufügen von neuen und das Löschen von vorhanden

Um DELETE, INSERT und UPDATE-Statements durchzuführen, wird, man glaubt es kaum, wiederum die Funktion mysql_real_query benutzt. Da dies bekannt ist, gehe ich nicht per Code näher darauf ein.
Interessant ist hier lediglich noch mysql_affected_rows: Sie gibt die Anzahl der betroffenen Zeilen eines Statements an. Genaueres ist nachzulesen unter http://www.mysql.com/documentation/m..._affected_rows.


So, das war unser kleines Tutorial. Wenn ihr noch Fragen habt, dann sagt Bescheid.

[Wormid]

Nice tut! *fettes lob*

Aber (ein "aber" gibts es immer :D), ist es möglich, das die Subquery im letzten Beispiel niemals ausgeführt wird, oder irre ich mich da?

(Ich gehe jetzt eh mal davon aus, das die Subquery nur aus Demo-Zwecken eingebaut wurde, oder?)

Gruß

Wormid

[Chewie]

Hi, was genau meinst du in diesem Fall mit Subquery :gruebel:?

[Wormid]

Hier mal der betreffende Codeabschnitt, von dem ich sabbel:

Delphi-Quellcode:

    {...}    

    idAuthor := _myRow[1]; 
    query := PChar('SELECT name FROM users WHERE id=' + idAuthor);
    _mySubRes := mysql_store_result(_myCon); 
    _mySubRow := mysql_fetch_row(_mySubRes); 
    Posts[i].author := _mySubRow[0]; 
    
    mysql_free_result(_mySubRes);        //Ergebnissatz löschen  
  end; 
  
  {...} 
  {Verbindung schließen oder etwas anderes machen} 
end;

Meiner Meinung nach, dürfte man mit diesem Code niemals erfahren, wer denn nun der Autor war... :wink: Irgendwie fehlt da doch noch ein "mysql_real_query(_myCon, query, Length(query));" vor dem mysql_store_result, oder irre ich mich da jetzt?

Um nochmal kurz darauf zurückzukommen:

Zitat:

Zitat von Wormid

(Ich gehe jetzt eh mal davon aus, das die Subquery nur aus Demo-Zwecken eingebaut wurde, oder?)

Ich würde die oben beschriebene Aufgabe wahrscheinlich eher mit folgendem Statement lösen:

SQL-Code:

SELECT posts.id, author, name, date, entry 
FROM posts, users 
WHERE users.id = posts.id 
ORDER BY posts.id

Der Vorteil ist der, das nicht für jeden Datensatz 2 Abfragen gestartet werden müssen.... (Performance!) Aber wie ich schon sagte, gehe ich eigentlich davon aus, das das bekannt ist und das die 2te Abfrage nur aus Demonstrationsgründen eingebaut wurde. (Weil manchmal geht es ja in der Tat nicht anders...)


Gruß,

Wormid

[Chewie]

Du hast Recht, das mysql_real_query() fehlt. Verdammt, das ist jetzt aber peinlich, wie konnte ich das nur vergessen :oops:

[Wormid]

Macht ja nix, ich wollte es der vollständigkeit halber mal gesagt haben, ich bin ja auch so mit dem Beispiel klar gekommen.
(Es zeigt Dir ja auch, das sich jemand eingehend mit deinem Tutorial befasst hat :coder: )
Mir war vorher gar nicht bewusst, das es so einfach ist, einen mysql-Client in Delphi zu basteln, ohne myODBC oder irgendwelche Komponenten zu benutzen. :thuimb:

Gruß

Wormid

[bender251]

Hallo

soweit so gut. Hab denke mal alles nachvollziehen können. Nur hab ich noch ein Problem beim Datenbank schreiben. Irgendwie führt der den Befehl Update net so wirklich aus. Ich wollte Testweise mal Namen eingeben. habe ich folgendermaßen versucht:

Delphi-Quellcode:

 mysql_select_db(_myCon, 'APIText');
 query := 'UPDATE Namen SET name = hallo';
 mysql_real_query(_myCon, query, Length(query));

Der hat das aber nicht gespeichert. Also der String "name" ist in der Datenbankdatei nicht zu finden, wenn ich sie mit dem Editor öffne.

Die Verbindung hat bestanden und die Datenbank war auch ausgewählt.

Wie mache ich denn eine ausgabe unter Delphi? in meiner Datenbank sind die Felder "name" und "nummer".
Muss ich immer zur Abfrage ein Record verwenden?

Ich wollte also Testweise mal den Namen auf "hallo" setzen. Das Feld Nummer hab ich weggelassen.

Und noch eine Frage wie definiere ich einen Primärschlüssel, oder brauche ich das hierbei gar nicht?


Ich weiß, viele Fragen, aber ich peils halt net so ganz :oops:

Für eine Antowrt wäre ich sehr dankbar


Gruß bender251

[Wormid]

Also mit nem Editor in den Files rumwuseln, das halte ich ja nicht für ganz so glücklich... :shock:

Falls Du dies Tool (MySQL-Front 2.5) hier noch nicht hast, empfehle ich Dir, es mal runterzuladen und zu installieren.
Es bietet Dir eigentlich alles, was man zur Wartung und Pflege einer MySQL-Datenbank braucht.
Damit kann man Datenbanken anlegen, Tabellen anlegen, erweitern, löschen etc.

Und vor allem: Man kann damit Testdaten pflegen und muss nicht mit dem Editor irgendwo rumsuchen :zwinker: ! Ausserdem zeigt es dir immer brav an, wie die SQL-Statements aussehen, die das Tool so absetzt... Damit kann man das wunderbar lernen (ich spreche da aus Erfahrung *g*).


Um auf Dein Problem zurückzukommen:

Es ist sicher, das es die Datenbank "APIText" gibt? Und die Tabelle "Namen" hast Du auch angelegt?

Und was mir gerade auffällt, wenn Du Daten anlegen willst, dann muss das mit INSERT passieren!

SQL-Code:

INSERT INTO Namen (id, name) VALUES (NULL, 'Test')

Und das updaten funzt dann so:

SQL-Code:

UPDATE Namen SET name= 'Test100' WHERE id=1

Beim Updaten NIE die Where-Bedingung vergessen, sonst werden ALLE Datensätze geändert!

Gruß

Wormid