Schreiben MySQL Schriften mit Python DB-API

Schreiben MySQL Skripten mit Python DB-API
Copyright © kitebird.com
For original English text, go to: http://www.kitebird.com
Translated by M.Dmitrieva

Paul DuBois
paul@kitebird.com

Dokumentenrevision: 1.02
Letzte Aktualisierung: 2006-09-17

Inhaltsverzeichnis

Python ist eine der populäreren Open Sources Programmiersprachen, größtenteils für seinen eigenen Ausdrucksmächtigkeit sowie die Vielfalt von Unterstützungsmodulen, die verfügbar sind, um seine Fähigkeiten zu erweitern. Eines dieser Module ist DB-API, weil der Name eine Datenbank- Programmierschnittstelle einbezieht und besorgt. DB-API wird entworfen, unabhängig von spezifischen Details bei jedem gegebenen Datenbank-Suchmaschine zu sein, Ihnen zu helfen, Datenbankzugriff -Schriften zu schreiben, portabel zwischen Suchmaschinen.

DB-APIs Design ist ähnlich dem beim Perl und Ruby DBI Module, die PHP PEAR DB-Klasse und Java JDBC Schnittstelle verwendet: Es verwendet eine Zwei-Niveaus-Architektur, in der das Spitzenniveau eine abstrakte Schnittstelle besorgt, ähnlich für alle unterstützten Datenbanksuchmaschinen, und eine niedrigere Ebene, bestehend aus Treibern für spezifische Motoren bei Handlung von motorabhängig Details. Natürlich bedeutet das nicht, dass die Verwendung DB-API für Schreibung Python-Schriften, müssen Sie einen Treiber für Ihr besonderes Datenbanksystem besitzen. Für MySQL, DB-API liefert Datenbankzugriff mit Hilfe von MySQLdb. Dieses Dokument beginnt durch das Besprechen über die Gerättreiber-Installation (im Falle besitzen kein  MySQLdb), dann geht weiter um behandeln, wie man DB-API Schriften schreiben soll.

MySQLdb Installation

Schreiben von MySQL, die DB-API verwenden, muss Python selbst installiert werden. Das wird fast sicher durch Verwendung Unix, aber ist weniger wahrscheinlich für Windows. Installationen für jede Plattform können bei der Python-Website gefunden werden (siehe die “Mittel”-Abteilung am Ende dieses Dokumentes).

Prüfen Sie nach Ihrer Python Version 2.3.4 oder später ist, und das MySQLdb Modul installiert wird. Sie können beide dieser Voraussetzungen überprüfen, indem Sie Python in der interaktiven Weise von der Befehlszeile schnell (ungefähr % für Unix oder C:\> für Windows) ausführen:

   % python
   Python 2.4.3 (#1, Aug 29 2006, 14:45:33)
   [GCC 3.4.6 (Gentoo 3.4.6-r1, ssp-3.4.5-1.0, pie-8.7.9)] on linux2
   Type "help", "copyright", "credits" or "license" for more information.
   >>> import MySQLdb

Das Annehmen, Sie besitzen eine genug neue Python Version, und kein Fehler vorkommt, wenn Sie den Import MySQLdb Statement ausgeben, sind Sie bereit zu beginnen Datenbankzugriff-Schriften zu schreiben, und Sie können zur folgenden Abteilung überspringen. Jedoch, wenn Sie den folgenden Fehler bekommen, müssen Sie zuerst MySQLdb erhalten und installieren:

   >>> import MySQLdb
   Traceback (most recent call last):
     File "<stdin>", line 1, in ?
   ImportError: No module named MySQLdb

Um MySQLdb zu erhalten, besuchen Sie die “Mittel”-Abteilung, zu sehen, wo man eine Distribution für Ihr passendes System Vertrieb herbeiholen soll. Vorkompilierte Binäre können verfügbar für Ihre Plattform sein, oder Sie können von der Quelle installieren. Wenn Sie eine binäre Distribution verwenden, installieren durch Ihren üblichen Paket-Installationsverfahren. Aus dem Quelle zu bilden und zu installieren, ziehen ins Top-Level-Verzeichnis von MySQLdb Distribution um, und geben Sie die folgenden Befehle aus. (Unter Unix wahrscheinlich brauchen Sie den zweiten Befehl als Stammverzeichnis auszuführen, so dass die Treiber-Dateien in Ihre Python-Installation kopiert werden können.)

   % python setup.py build
   % python setup.py install

Wenn Sie sich auf Probleme stoßen, überprüfen README Datei eingeschlossen mit der MySQLdb Distribution.

Eine kurze DB-API Schrift

Schriften, dass MySQL mittels des DB-API zugreifen, durch Verwendung MySQLdb führen im allgemein die folgenden Schritte durch:

  • Importieren das MySQLdb Modul
  • Bauen eine Verbindung zum MySQL Server auf
  • Abgabe einer Anweisung und bekommen ihre Ergebnisse wieder
  • Schließen die Server-Verbindung

Der Rest dieser Abteilung stellt eine kurze DB-API Schrift dar, die die Grundelemente dieser Schritte illustriert. Spätere Abteilungen besprechen die spezifischen Aspekte des Schrift-Schreibens ausführlicher.

Schreiben der Schrift

Verwenden einen Textaufbereiter für das Bilden einer Datei, genannt server_version.py, der die folgende Schrift enthält. Diese Schrift verwendet MySQLdb, um mit dem MySQL Server aufeinander zu wirken, obgleich auf die relativ rudimentäre Mode – alles was es tut, ist, fragen den Server auf seine Versionsstring:

   # server_version.py - retrieve and display database server version

   import MySQLdb

   conn = MySQLdb.connect (host = "localhost",
                           user = "testuser",
                           passwd = "testpass",
                           db = "test")
   cursor = conn.cursor ()
   cursor.execute ("SELECT VERSION()")
   row = cursor.fetchone ()
   print "server version:", row[0]
   cursor.close ()
   conn.close ()

Die Importanweisung sagt Python die Schrift braucht den Code im MySQLdb Modul zu verwenden. Diese Anweisung muss jedem Versuch vorangehen, bei MySQL Server in Verbindung zu stehen. Dann wird die Verbindung durch das Hervorrufen von connenct() Methode des MySQLdb Treibers mit den richtigen Verbindungsrahmen hergestellt. Diese schließen den hostname ein, wohin der Server ausführt, der Benutzername und das Passwort für Ihren MySQL Account, und der Datenbank-Name, den Sie verwenden wollen. conect() Argument-Listensyntax ändert sich unter Treibern; für MySQLdb, werden den Argumenten erlaubt, im Namen = Wertformat gegeben zu werden, hat den Vorteil, Sie können sie in jeder Ordnung angeben. server_version.py macht eine Verbindung zum MySQL Server nach lokalhost, um auf die Testdatenbank mit einem Benutzernamen und Passwort von testuser und testpass zuzugreifen:

   conn = MySQLdb.connect (host = "localhost",
                           user = "testuser",
                           passwd = "testpass",
                           db = "test")

Wenn connect () Anspruch erfolgreich ist, kehrt es eine Verbindung zurück, das dient als Grundlage für die weitere Interaktion mit MySQL. Wenn der Anspruch scheitert, erhebt er eine Ausnahme. (server_version.py behandelt keine Ausnahme, so ein Fehler begrenzt an diesem Punkt die Schrift. Die Fehlerbehandlung wird später in diesem Dokument bedeckt.)

Nach der Verbindungsobjekt erhalten worden ist, ruft server_version.py seiner cursor() Methode auf, ein Cursor-Objekt zu bilden für Bearbeitung der Anweisungen. Die Schrift verwendet diesen Cursor, um eine AUSGEWÄHLTE VERSION() Anweisungen auszugeben, die eine Zeichenfolge zurückgibt, enthaltend die Server-Versionsinformation:

   cursor = conn.cursor ()
   cursor.execute ("SELECT VERSION()")
   row = cursor.fetchone ()
   print "server version:", row[0]
   cursor.close ()

Das Cursor-Objekt execute() Methode sendet die Anweisung an Server, und fetchone() bekommt eine Reihe als ein Tupel wieder. Angezeigt hier für die Anweisung das Tupel enthält einen einzelnen Wert, den die Schrift druckt. (Wenn keine Reihe verfügbar ist, fetchone() wird wirklich den Wert None zurückgeben; server_version.py nimmt vergnügt an, dass eine Annahme nicht geschehen wird, dass Sie normalerweise das nicht machen sollten. In nächsten Beispielen werden wir diesen Fall behandeln.) Das Cursor-Objekt kann für Ausgabe von vielfachen Erklärungen verwendet werden, aber server_version.py hat kein Bedürfnis mehr nach dem Cursor nachdem Bekommen der Versionsstring, so schließt es das.

Schließlich ruft die Schrift das Verbindungsobjekt close() Methode auf, vom Server zu trennen:

   conn.close ()

Danach, die Verbindung wird ungültig und sollte nicht bei dem Durchgriff von Server verwendet werden.

Ausführen der Schrift

Um die server_version.py Schrift abzulaufen, rufen Sie Python von der Befehlszeilenaufforderung auf, und geben ihm den Schrift-Namen. Sie sollten ein Ergebnis etwas wie das sehen:

   % python server_version.py
   server version: 5.1.12-beta-log

Das zeigt an, dass die MySQL Server-Version 5.1.12 ist; -beta und -log Suffixen gibt uns das Distributionsstabilitätsniveau, und dass Anfragenprotokollierung ermöglicht wird. (Sie könnten andere Suffixen sehen als diejenigen, die hier gezeigt sind. Zum Beispiel, wenn Sie Debugging aktiviert haben, werden Sie sehen, a-Debug-Suffix. )

Es ist möglich die Schrift aufzustellen, so dass es namentlich geführt werden kann, ohne Python ausführlich aufzurufen. Unter Unix, fügen Sie eine Initiale #! Linie bei der Schrift hinzu, die den vollen Pfadnamen des Python-Interpreters angibt. Das befiehlt dem System, welches Programm die Schrift durchführen sollte. Zum Beispiel, wenn Python sich bei /usr/bin/python auf Ihrem System befindet, fügen die folgenden wie die erste Linie der Schrift hinzu:

   #!/usr/bin/python

Dann verwenden chmod, um die Schrift ausführbar zu machen, und Sie werden fähig es direkt durchzuführen:

   % chmod +x server_version.py
   % ./server_version.py

(Die Führung “. /” berichtet Ihrem Befehl-Interpreter ausführlich, dass die Schrift in Ihrem aktuellen Verzeichnis gelegen wird. Viele Unix-Accounts werden aufgestellt, nicht nach der Suche des aktuellen Verzeichnisses, wenn man nach Befehlen sucht. )

Unter Windows, dem #! Linie ist unnötig (obwohl es harmlos ist, so brauchen Sie es nicht zu entfernen, wenn Sie die Schrift über ein Unix System schreiben und sie dann bei einem Windows-Kasten bewegen). Stattdessen können Sie eine Dateinamenvereinigung aufstellen, so dass .py Schriften mit der Python vereinigt werden. Anstatt chmod zu verwenden, um die Schrift ausführbar zu machen, öffnen Sie den Mappe-Optionsartikel im Bedienungsfeld und wählen Sie seine Registerkarte File Types aus. File Types ermöglichen Ihnen eine Vereinigung für Dateien aufzustellen, die mit .py enden, und befiehlt Windows mit der Python durchzuführen. Dann können Sie die Schrift namentlich aufrufen:

   C:\> server_version.py

Wenn Sie ActiveState Python auf Windows installieren, das ActiveState Installationsprogramm stellt die Vereinigung automatisch als ein Teil des Installationsprozesses auf.

Eine ausführlichere DB-API-Schrift

server_version.py enthält mehrere Mängel. Zum Beispiel fängt es Ausnahmen nicht ab, oder anzuzeigen, was schief gegangen ist, wenn ein Fehler vorkommt, und gibt die Möglichkeit nicht berücksichtigt zu werden, dass die Anweisung das ausführt, dann könnte keine Ergebnisse zurückgeben. Diese Abteilung zeigt, wie man diese Probleme mit einer mehr wohl durchdachten Schrift richten soll, animal.py verwendet eine Tabelle, enthaltend die Kategorien- und Tiernamen:

   CREATE TABLE animal
   (
     name     CHAR(40),
     category CHAR(40)
   )

Wenn Sie das PEAR DB Dokument verfügbar bei der Kitebird Seite gelesen haben (siehe “Mittel”), Sie könnten diese Tabelle und einige ausgegebenen Anweisungen durch animal.py anerkennen; sie wurden in diesem Dokument auch verwendet.

Die animal.py Schrift beginnt somit (fasen #! Linie um, sollte Sie vorhaben, die Schrift auf einem Unix System durchzuführen):

   #!/usr/bin/python
   # animal.py - create animal table and
   # retrieve information from it

   import sys
   import MySQLdb

Wie bei server_version.py importiert die Schrift MySQLdb, aber auch importiert das sys Modul für den Gebrauch in der Fehlerbehandlung. (animal.py verwendet sys.exit (), um 1 zurückzukehren, um anomale Beendigung anzuzeigen, wenn ein Fehler vorkommt.)

Fehlerbehandlung

Nach dem Importieren der notwendigen Module stellt animal.py eine Verbindung bei dem Server mit dem connect() Aufruf her. Zieht die Möglichkeit der Verbindungsstörung in Betracht (zum Beispiel, kann man den Grund für den Misserfolg anzeigen), ist es notwendig Ausnahmen abzufangen. Um Ausnahmen in der Python zu behandeln, stellen Sie Ihren Code in einer Versuch-Anweisung und schließen Sie außer der Klausel ein, die den fehlerbehandelnden Code enthält. Die resultierende Verbindungsfolge sieht wie das aus:

   try:
     conn = MySQLdb.connect (host = "localhost",
                             user = "testuser",
                             passwd = "testpass",
                             db = "test")
   except MySQLdb.Error, e:
     print "Error %d: %s" % (e.args[0], e.args[1])
     sys.exit (1)

Die Ausnahme-Klausel nennt eine Ausnahme-Klasse (MySQLdb.Error in diesem Beispiel), um die datenbankspezifische Fehlerauskunft zu erhalten, das MySQLdb besorgen kann, sowie eine Variable (e) in dem man die Information versorgt. Wenn eine Ausnahme vorkommt, MySQLdb stellt diese Information in e.args bereit, ein Zwei-Elemente-Tupel, das den numerischen Fehlercode und eine String enthält, die den Fehler beschreibt. Die Ausnahme-Klausel angezeigten im Beispiel druckt sowohl Werte als auch Ausgänge.

Irgendwelche datenbankzusammenhängenden Anweisungen können in eine ähnliche try / except-Struktur gelegt werden, um Fehler zu fangen und auszugeben; die folgende Diskussion zeigt keinen Ausnahmebehandlung-Code. (Der ganze Text von animal.py wird im Anhang verzeichnet.)

Methoden für Abgabe von Anweisungen

Die folgende Abteilung animal.py schafft ein Cursor-Objekt und verwendet ihn, um Anweisungen auszugeben, das eingerichtet und bevölkern das animal Tabelle:

   cursor = conn.cursor ()
   cursor.execute ("DROP TABLE IF EXISTS animal")
   cursor.execute ("""
       CREATE TABLE animal
       (
         name     CHAR(40),
         category CHAR(40)
       )
     """)
   cursor.execute ("""
       INSERT INTO animal (name, category)
       VALUES
         ('snake', 'reptile'),
         ('frog', 'amphibian'),
         ('tuna', 'fish'),
         ('racoon', 'mammal')
     """)
   print "Number of rows inserted: %d" % cursor.rowcount

Bemerken Sie, dieser Code enthält keinen Fehler durch Überprüfung. (Merken Sie sich, es wird in einem Versuch-Statement gelegt; Fehler werden Ausnahmen auslösen, die gefangen und behandelt in der entsprechenden Ausnahme-Klausel werden, die dem Hauptfluss des Codes erlaubt, glatter zu lesen.) Die Statements führen die folgenden Handlungen durch:

  • Lassen Sie die animal Tabelle weg, wenn diese bereits besteht, um mit einer unbeschriebenen Tafel zu beginnen.
  • Bilden Sie die animal Tabelle.
  • Fügen Sie einige Daten in der Tabelle ein und melden Sie die Zahl von hinzugefügten Reihen.

Jedes Statement wird durch das Hervorrufen des Cursor-Objekts execute() Methode. Die ersten zwei Erklärungen erzeugen kein Ergebnis, aber das dritte erzeugt eine Zählung, die die Zahl von eingefügten Reihen anzeigt. Die Zählung ist im Rowcount-Attribut des Cursors verfügbar. (Einige Datenbankschnittstellen stellen dieser Zählung als der Rückwert des Erklärungsausführungsaufrufs zur Verfügung, aber das ist für DB-API nicht wahr.)

Die animal Tabelle wird an dieser Stelle aufgestellt, so können wir AUSGEWÄHLT Anweisungen ausgeben, um Information davon wiederzubekommen. Wie bei den vorhergehenden Anweisungen, AUSGEWÄHLTE Anweisungen werden durch execute() ausgestellt. Jedoch, verschieden Statements wie DROP oder INSERT, SELECT Anweisungen erzeugen einen Ergebnis-Satz, den Sie wiederbekommen müssen. D. h. execute() stellt nur die Anweisungen aus, sie gibt den Ergebnis-Satz nicht zurück. Sie können fetchone() verwenden, um die Reihen einer nach dem anderen oder fetchall() sie plötzlich bekommen. animal.py verwendet beide Ansätze. Hier gibt es wie man fetchone() für die Reihe auf einmal Wiederauffindung verwendet:

   cursor.execute ("SELECT name, category FROM animal")
   while (1):
     row = cursor.fetchone ()
     if row == None:
       break
     print "%s, %s" % (row[0], row[1])
   print "Number of rows returned: %d" % cursor.rowcount

fetchone() gibt die folgende Reihe des Ergebnis-Satzes als ein Tupel oder der Wert None zurück, wenn keine Reihen mehr verfügbar sind. Die Programmschleife überprüft dafür und beendet, wenn das Ergebnis-Set ausgeschöpft wurde. Für jede zurückgegebene Reihe enthält das Tupel zwei Werte (sowie viele Säulen SELECT Statements gefragt sind), welcher animal.py druckt. Die Druckstatements angezeigt über Zugängen die individuellen Tupel-Elemente. Jedoch, weil sie in der Größenordnung vom Ereignis innerhalb des Tupels verwendet werden, könnte die Druckstatement genauso gut wie dieses:

   cursor.execute ("SELECT name, category FROM animal")
   rows = cursor.fetchall ()
   for row in rows:
     print "%s, %s" % (row[0], row[1])
   print "Number of rows returned: %d" % cursor.rowcount

Nach der Darstellung von Statementsergebnis, die Schrift druckt auch die Zahl von zurückgekehrten Reihen (verfügbar als der Wert des Rowcount-Attributes).

fetchall() gibt den kompletten Ergebnis-Satz plötzlich als ein Tupel von Tupeln, oder als ein leeres Tupel zurück, wenn der Ergebnis-Satz leer ist. Um auf die individuellen Reihe-Tupel zuzugreifen, wiederholen Sie durch den Reihe-Satz, den fetchall() zurückgibt:

   print "%d rows were returned" % len (rows)

Dieser Code druckt die Reihe-Zählung durch das Zugreifen rowcount, ebenso für den fetchone() Programmschleife. Eine andere Weise für Bestimmung der Reihe, zählt, wenn Sie fetchall() verwenden, ist durch die Einnahme der Länge des Werts, den es zurückgibt:

   cursor.close ()
   cursor = conn.cursor (MySQLdb.cursors.DictCursor)
   cursor.execute ("SELECT name, category FROM animal")
   result_set = cursor.fetchall ()
   for row in result_set:
     print "%s, %s" % (row["name"], row["category"])
   print "Number of rows returned: %d" % cursor.rowcount

Die FETCH-Schleifen haben dadurch weit abgerufene Reihen als Tupel bis zu diesem Moment angezeigt. Es ist auch möglich, Reihen als Wörterbücher herbeizuholen, der Ihnen zu Zugriffssäulenwerten namentlich ermöglicht. Der folgende Code zeigt, wie man das tut. Bemerken Sie, dass diesen Wörterbuch-Zugang eine verschiedene Art des Cursors verlangt, so schließt das Beispiel den Cursor und erhält einen neuen, der einen verschiedenen Cursor-Klasse verwendet:

   cursor.execute ("""
         UPDATE animal SET name = 'turtle'
         WHERE name = 'snake'
       """)
   print "Number of rows updated: %d" % cursor.rowcount

NULL Werte in einem Ergebnis-Satz werden als None in Ihr Programm zurückgegeben.

MySQLdb unterstützt eine Platzhalter-Fähigkeit, die Ihnen die Möglichkeit gibt, Datenwerte zu speziellen Marker innerhalb der Anweisungszeichenfolge zu binden. Das besorgt eine Alternative zum Einbetten der Werte direkt in die Anweisung. Der Platzhalter-Vorgang handelt mit der Hinzufügung der Anführungszeichen um Datenwerte, und entkommt es irgendwelchen speziellen Charakteren, die innerhalb von Werten vorkommen. Die folgenden Beispiele demonstrieren eine AKTUALISIERUNGS-Anweisung, die Schlange zur Schildkröte verändert, zuerst mit wörtlichen Werten und dann mit Platzhaltern. Die wörtliche-Wert-Anweisung sieht wie folgt aus:

   cursor.execute ("""
         UPDATE animal SET name = 'turtle'
         WHERE name = 'snake'
       """)
   print "Number of rows updated: %d" % cursor.rowcount

Wechselweise können Sie dieselbe Anweisung ausgeben, indem Sie %s Platzhalter-Marker verwenden und verbinden die entsprechenden Werte zu ihnen:

   cursor.execute ("""
         UPDATE animal SET name = %s
         WHERE name = %s
       """, ("snake", "turtle"))
   print "Number of rows updated: %d" % cursor.rowcount

Beachten die folgenden Punkte über die Form des vorherigen execute() Aufrufs:

  • Der %s Platzhalter-Marker sollte einmal für jeden Wert vorkommen, der in die Anweisungszeichenfolge eingefügt werden soll.
  • Keine Anführungszeichen sollten um das %s Marker gelegt werden; MySQLdb liefert Notierungen für Sie als notwendig.
  • Im Anschluss an das Anweisungszeichenfolge-Argument execute(), stellen Sie ein Tupel bereit, das die Werte enthält, die zu den Platzhaltern verbindet zu sein, in der Ordnung sie sollten innerhalb der Zeichenfolge erscheinen. Wenn Sie nur einen einzelnen Wert x haben, geben Sie es als (x) an, um ein Tupel des einzelnen Elements anzuzeigen.
  • Binden der Python None-Wert bei einem Platzhalter, um einen SQL NULL Wert in die Anweisung einzufügen.

Nach der Ausgabe der Anweisungen schließt animal.py den Cursor, fixiert die Änderungen, und trennt vom Server:

   cursor.close ()
   conn.commit ()
   conn.close ()

Das Anschluss-Objekt commit() Methode fixiert irgendwelche hervorragenden Änderungen in der aktuellen Transaktion, um sie dauerhaft in der Datenbank zu machen. In der DB-API, die Anschlüsse beginnen damit autocommit deaktivierten Verfahren, so müssen Sie commit() bevor das Abschalten aufrufen, oder die Änderungen können verloren werden.

Wenn die animal Tabelle eine MyISAM Tabelle vertritt, commit() hat keine Wirkung: MyISAM ist ein nichttransaktionalen Storage-Engine, so die Änderungen bei der MyISAM Tabelle wirken sofort unabhängig von dem autocommit Modul. Jedoch, wenn animal einen transaktionalen Storage-Engine wie InnoDB verwendet, die Fehlfunktion commit() aufzurufen, führt zu einem impliziten Transaktions-Rollback, wenn Sie die Verbindung trennen. Zum Beispiel, wenn Sie ENGINE=InnoDB zum Ende der CREATE TABLE-Anweisung hinzufügen und den commit() Aufruf in der Nähe vom Ende der Schrift entfernen, finden Sie der Rang nach den Schrift-Ausführen leer ist.

Für Schriften, die nur Daten wiederbekommen, keine Änderungen sollten begangen zu werden und commit() ist unnötig.

Portabilitätszeichen

Wenn Sie eine MySQLdb-basierte DB-API Schrift für den Gebrauch mit einer verschiedenen Datenbank übertragen wollen, kommen Quellen der Nichtbeweglichkeit überall vor, sodass der Treiber-Name verwendet werden könnte:

  • Die Importanweisung, die das Treiber-Modul importiert. Das muss geändert werden, um einen verschiedenen Treiber zu importieren.
  • Das connect() Aufruf, der zum Datenbankserver in Verbindung steht. Die connect() Methode wird durch den Namen der Treiber-Module zugegriffen, so muss der Treiber-Name geändert werden. Außerdem kann sich die connect() Argument-Syntax zwischen Treibern ändern.
  • Ausnahme Behandlung. In der Ausnahme-Klasse genannt nach der Ausnahme-Klausel, wird durch den Treiber-Namen Verweise angebracht.

Ein anderer Typ der Non-Portabilität, die den Treiber-Namen nicht einschließt, betrifft den Gebrauch von Platzhaltern. Die DB-API Spezifizierung berücksichtigt mehrere Platzhalter-Syntaxen, und einige Treiber verwenden eine Syntax, die sich von demjenigen von unterstütztem MySQLdb unterscheidet.

Mittel

Die verwendeten Schriften für die Beispiele in diesem Dokument, können von der folgenden Position heruntergeladen werden:

   http://www.kitebird.com/articles/

Sie können die folgenden zusätzlichen Mittel nützlich finden, bei Verwendung von Python-DB-API und den MySQLdb Treiber zu verwenden:

http://dustman.net/andy/python/

Andy Dustman, Autor des MySQLdb Moduls, hat eine Seite bei:

   http://sourceforge.net/projects/mysql-python

Diese Seite ist der beste Platz, die MySQLdb Dokumentation und FAQ online zu lesen. Es enthält auch Links zu Debian und Windows Binärdistributionen. Um Quellcode oder Linux RPMs zu bekommen, besuchen Sie MySQLdb Behältnis von SourceForge bei:

 http://www.kitebird.com/mysql-cookbook   
 http://www.oreilly.com/catalog/mysqlckbk/

MySQL Kochbuch enthält Python DB-API unter den Datenbank-Programmierschnittstellen, dass es umfasst Die Python-Website besitzt Monteure für den Python-Sprachprozessor, sollte auf einem System ausführen, das es noch nicht installiert hat:

http://www.python.org/ 

Die Datenbank SIG (spezielle Interesse-Gruppe) Fläche auf der Python-Webseite enthält zusätzliche DB-API Information:

 http://www.python.org/sigs/db-sig/

Die animal Tabelle verwendet durch die animal.py Schrift wird auch im PEAR-DB-Dokument unter der Seite von Kitebird verwendet:

   http://www.kitebird.com/articles/

Sie könnten es instruktiv finden, durch Vergleichung dieses Dokument mit diesem, zu sehen die Ähnlichkeit zwischen DB-API und PEAR-DB, oder die Unterscheidung in ihren Ansätzen zu dem Datenbankzugriff.

Anhang

Der volle Quellcode für die animal.py Schrift wird hier gezeigt:

   #!/usr/bin/python
   # animal.py - create animal table and
   # retrieve information from it

   import sys
   import MySQLdb

   # connect to the MySQL server

   try:
     conn = MySQLdb.connect (host = "localhost",
                             user = "testuser",
                             passwd = "testpass",
                             db = "test")
   except MySQLdb.Error, e:
     print "Error %d: %s" % (e.args[0], e.args[1])
     sys.exit (1)

   # create the animal table and populate it

   try:
     cursor = conn.cursor ()
     cursor.execute ("DROP TABLE IF EXISTS animal")
     cursor.execute ("""
         CREATE TABLE animal
         (
           name     CHAR(40),
           category CHAR(40)
         )
       """)
     cursor.execute ("""
         INSERT INTO animal (name, category)
         VALUES
           ('snake', 'reptile'),
           ('frog', 'amphibian'),
           ('tuna', 'fish'),
           ('racoon', 'mammal')
       """)
     print "Number of rows inserted: %d" % cursor.rowcount

   # perform a fetch loop using fetchone()

     cursor.execute ("SELECT name, category FROM animal")
     while (1):
       row = cursor.fetchone ()
       if row == None:
         break
       print "%s, %s" % (row[0], row[1])
     print "Number of rows returned: %d" % cursor.rowcount

   # perform a fetch loop using fetchall()

     cursor.execute ("SELECT name, category FROM animal")
     rows = cursor.fetchall ()
     for row in rows:
       print "%s, %s" % (row[0], row[1])
     print "Number of rows returned: %d" % cursor.rowcount

   # issue a statement that changes the name by including data values
   # literally in the statement string, then change the name back
   # by using placeholders

     cursor.execute ("""
           UPDATE animal SET name = 'turtle'
           WHERE name = 'snake'
         """)
     print "Number of rows updated: %d" % cursor.rowcount

     cursor.execute ("""
           UPDATE animal SET name = %s
           WHERE name = %s
         """, ("snake", "turtle"))
     print "Number of rows updated: %d" % cursor.rowcount

   # create a dictionary cursor so that column values
   # can be accessed by name rather than by position

     cursor.close ()
     cursor = conn.cursor (MySQLdb.cursors.DictCursor)
     cursor.execute ("SELECT name, category FROM animal")
     result_set = cursor.fetchall ()
     for row in result_set:
       print "%s, %s" % (row["name"], row["category"])
     print "Number of rows returned: %d" % cursor.rowcount

     cursor.close ()

   except MySQLdb.Error, e:
     print "Error %d: %s" % (e.args[0], e.args[1])
     sys.exit (1)

   conn.commit ()
   conn.close ()

Anerkennung

Die ursprüngliche Version dieses Dokumentes wurde für NuSphere Corporation geschrieben. Die jetzige Version ist eine aktualisierte Revision des Originals.

Revisionsgeschichte

1.00 – Ursprüngliche Version.

1.01, am 2003-01-24 – Geringe Revisionen.

1.02, am 2006-09-17 – Aktualisieren MySQLdb 1.2.1. Fügen Information über das autocommit Verfahren und die commit() Methode hinzu.