AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Tutorials Delphi MySQL ohne Komponenten

MySQL ohne Komponenten

Ein Tutorial von Chewie · begonnen am 14. Jul 2003 · letzter Beitrag vom 30. Mär 2020
Antwort Antwort
Seite 1 von 36  1 2311     Letzte » 
Chewie
Registriert seit: 10. Jun 2002
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:
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]
Egal wie dumm man selbst ist, es gibt immer andere, die noch dümmer sind

Geändert von Matze (24. Jul 2010 um 14:25 Uhr)
 
Alexander

 
Turbo Delphi für .NET
 
#2
  Alt 14. Jul 2003, 16:39
freue mich schon auf den nächsten Teil, dann setze ich die Admin-zone meiner HP in Delphi um.
Danke schon mal.
Alexander
  Mit Zitat antworten Zitat
Chewie

 
Turbo Delphi für Win32
 
#3
  Alt 4. Aug 2003, 11:13
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:
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:
SELECT * FROM posts ORDER BY id Und so wird der Namen ermittelt
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.
Martin Leim
  Mit Zitat antworten Zitat
Benutzerbild von Wormid
Wormid

 
Delphi XE2 Professional
 
#4
  Alt 15. Sep 2003, 21:57
Nice tut! *fettes lob*

Aber (ein "aber" gibts es immer ), 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
  Mit Zitat antworten Zitat
Chewie

 
Turbo Delphi für Win32
 
#5
  Alt 15. Sep 2003, 23:10
Hi, was genau meinst du in diesem Fall mit Subquery ?
Martin Leim
  Mit Zitat antworten Zitat
Benutzerbild von Wormid
Wormid

 
Delphi XE2 Professional
 
#6
  Alt 16. Sep 2003, 21:47
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... 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 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
  Mit Zitat antworten Zitat
Chewie

 
Turbo Delphi für Win32
 
#7
  Alt 16. Sep 2003, 21:53
Du hast Recht, das mysql_real_query() fehlt. Verdammt, das ist jetzt aber peinlich, wie konnte ich das nur vergessen
Martin Leim
  Mit Zitat antworten Zitat
Benutzerbild von Wormid
Wormid

 
Delphi XE2 Professional
 
#8
  Alt 16. Sep 2003, 22:03
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 )
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.

Gruß

Wormid
  Mit Zitat antworten Zitat
bender251
 
#9
  Alt 14. Okt 2003, 10:46
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

Für eine Antowrt wäre ich sehr dankbar


Gruß bender251
  Mit Zitat antworten Zitat
Benutzerbild von Wormid
Wormid

 
Delphi XE2 Professional
 
#10
  Alt 14. Okt 2003, 11:16
Also mit nem Editor in den Files rumwuseln, das halte ich ja nicht für ganz so glücklich...

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 ! 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!

INSERT INTO Namen (id, name) VALUES (NULL, 'Test') Und das updaten funzt dann so:

UPDATE Namen SET name= 'Test100WHERE id=1 Beim Updaten NIE die Where-Bedingung vergessen, sonst werden ALLE Datensätze geändert!

Gruß

Wormid
  Mit Zitat antworten Zitat
Themen-Optionen Tutorial durchsuchen
Tutorial durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 20:32 Uhr.
Powered by vBulletin® Copyright ©2000 - 2020, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2020 by Daniel R. Wolf