9. Verwendung des MySQL-DBMS

9.1. Installation des MySQLdb-Moduls

Wir werden Skripte unter Verwendung einer MySQL-Datenbank schreiben:

Die Python-Funktionen zur Verwaltung einer MySQL-Datenbank sind in einem MySQLdb-Modul zusammengefasst, das nicht in der Standard-Python-Distribution enthalten ist. Sie müssen das Modul daher herunterladen und installieren. Hier ist eine Möglichkeit, dies zu tun:

Wählen Sie im Menü „Programme“ [1] den Python-Paketmanager aus. Das Befehlsfenster [2] wird daraufhin angezeigt.

Suchen Sie in den Paketen nach dem Stichwort mysql:


C:\Documents and Settings\st>pypm search mysql
Get: [pypm-be.activestate.com] :repository-index:
Get: [pypm-free.activestate.com] :repository-index:
autosync: synced 2 repositories
  chartio                    Setup wizard and connection client for connecting
  chartio-setup              Setup wizard and connection client for connecting
  cns.recipe.zmysqlda        Recipe for installing ZMySQLDA
  collective.recipe.zmysqlda Recipe for installing ZMySQLDA
  django-mysql-manager       DESCRIPTION_DESCRIPTION_DESCRIPTION
  jaraco.mysql               MySQLDB-compatible MySQL wrapper by Jason R. Coomb
  lovely.testlayers          mysql, postgres nginx, memcached cassandra test la
  mtstat-mysql               MySQL Plugins for mtstat
  mysql-autodoc              Generate HTML documentation from a mysql database
  mysql-python               Python interface to MySQL
  mysqldbda                  MySQL Database adapter
  products.zmysqlda          MySQL Zope2 adapter.
  pymysql                    Pure Python MySQL Driver
  pymysql-sa                 PyMySQL dialect for SQLAlchemy.
  pymysql3                   Pure Python MySQL Driver
  sa-mysql-dt                Alternative implementation of DateTime column for
  schemaobject               Iterate over a MySQL database schema as a Python o
  schemasync                 A MySQL Schema Synchronization Utility
  simplestore                A datastore layer built on top of MySQL in Python.
  sqlbean                    A auto maping ORM for MYSQL and can bind with memc
  sqlwitch                   sqlwitch offers idiomatic SQL generation on top of
  tiddlywebplugins.mysql     MySQL-based store for tiddlyweb
  tiddlywebplugins.mysql2    MySQL-based store for tiddlyweb
zest.recipe.mysql          A Buildout recipe to setup a MySQL database.

Alle Module, deren Name oder Beschreibung das Schlüsselwort „mysql“ enthält, wurden aufgelistet. Dasjenige, das uns interessiert, ist [mysql-python], Zeile 14. Installieren wir es:


C:\Documents and Settings\st>pypm install mysql-python
The following packages will be installed into "%APPDATA%\Python" (2.7):
 mysql-python-1.2.3
Hit: [pypm-free.activestate.com] mysql-python 1.2.3
Installing mysql-python-1.2.3
 
C:\Documents and Settings\st>echo %APPDATA%
C:\Documents and Settings\st\Application Data

Zeile 5: Das Paket „mysql-python-1.2.3“ wurde im Ordner „%APPDATA%\Python“ installiert, wobei APPDATA der in Zeile 8 angegebene Ordner ist.

Dieser Vorgang kann fehlschlagen, wenn:

der verwendete Python-Interpreter eine 64-Bit-Version ist;
der Pfad %APPDATA% Zeichen mit Akzenten enthält.

9.2. MySQL installieren

Es gibt verschiedene Möglichkeiten, das DBMS MySQL zu installieren. Hier haben wir WampServer verwendet, ein Paket, das mehrere Softwarekomponenten vereint:

einen Apache-Webserver. Wir werden ihn verwenden, um Webskripte in Python zu schreiben;
das Datenbankmanagementsystem MySQL;
die Skriptsprache PHP;
ein in PHP geschriebenes MySQL-Datenbankverwaltungstool: phpMyAdmin.

WampServer kann (Stand: Juni 2011) unter folgender Adresse heruntergeladen werden:

http://www.wampserver.com/download.php

Laden Sie unter [1] die passende Version von WampServer herunter;
Starten Sie ihn nach der Installation unter [2]. Dadurch werden der Apache-Webserver und das Datenbankmanagementsystem MySQL gestartet;
in [3] kann WampServer nach dem Start über ein Symbol [3] unten rechts in der Taskleiste verwaltet werden;
Starten Sie in [4] das MySQL-Verwaltungstool.

Erstellen Sie eine Datenbank [dbpersonnes]:

Erstellen Sie einen Benutzer [admpersonnes] mit dem Passwort [nobody]:

in [1] der Benutzername;
in [2] den DBMS-Server, auf dem Sie ihm Berechtigungen erteilen;
in [3] das Passwort [nobody];
in [4], wie oben;
in [5] erteilen wir diesem Benutzer keine Berechtigungen;
in [6], den Benutzer anlegen.

in [7] kehren Sie zur Startseite von phpMyAdmin zurück;
in [8] verwenden Sie den Link [Berechtigungen] auf dieser Seite, um die Berechtigungen für den Benutzer [admpersonnes] [9] zu ändern.

Geben Sie in [10] an, dass Sie dem Benutzer [admpersonnes] Rechte für die Datenbank [dbpersonnes] gewähren möchten;
Bestätigen Sie in [11] die Auswahl.

Verwenden Sie den Link [12] [Alle auswählen], um dem Benutzer [admpersonnes] alle Rechte an der Datenbank [dbpersonnes] zu erteilen [13];
Wir bestätigen dies in [14].

Nun haben wir:

eine MySQL-Datenbank [dbpersonnes];
einen Benutzer [admpersonnes / nobody], der vollen Zugriff auf diese Datenbank hat.

Wir werden Python-Skripte schreiben, um mit der Datenbank zu arbeiten.

9.3. Verbindung zu einer MySQL-Datenbank herstellen – 1

Programm (mysqldb_01)


# import du module MySQLdb
import sys
sys.path.append("D:\Programs\ActivePython\site-packages")
import MySQLdb
 
# connexion à une base MySQL
....

Hinweise:

Zeilen 2–4: Skripte, die Operationen mit dem MySQL-DBMS enthalten, müssen das MySQLdb-Modul importieren. Erinnern Sie sich daran, dass wir dieses Modul im Ordner [%APPDATA%\Python] installiert haben. Der Ordner [%APPDATA%\Python] wird automatisch durchsucht, wenn ein Python-Skript ein Modul anfordert. Tatsächlich werden alle in sys.path aufgeführten Ordner durchsucht. Hier ist ein Beispiel, das diese Ordner anzeigt:

#    -*- coding=utf-8 -*-

import sys

#    display of sys.path files
for dossier in sys.path:
    print dossier

Die Bildschirmausgabe sieht wie folgt aus:

D:\data\istia-1112\python\tutoriel
C:\Windows\system32\python27.zip
D:\Programs\ActivePython\Python2.7.2\DLLs
D:\Programs\ActivePython\Python2.7.2\lib
D:\Programs\ActivePython\Python2.7.2\lib\plat-win
D:\Programs\ActivePython\Python2.7.2\lib\lib-tk
D:\Programs\ActivePython\Python2.7.2
C:\Users\Serge TahÚ\AppData\Roaming\Python\Python27\site-packages
D:\Programs\ActivePython\Python2.7.2\lib\site-packages
D:\Programs\ActivePython\Python2.7.2\lib\site-packages\win32
D:\Programs\ActivePython\Python2.7.2\lib\site-packages\win32\lib
D:\Programs\ActivePython\Python2.7.2\lib\site-packages\Pythonwin
D:\Programs\ActivePython\Python2.7.2\lib\site-packages\setuptools-0.6c11-py2.7.egg-info

Zeile 8, der Ordner [site-packages], in dem MySQLdb ursprünglich installiert wurde. Wir verschieben den Ordner [site-packages], in dem das Dienstprogramm pypm Python-Module installiert. Um einen neuen Ordner hinzuzufügen, in dem Python nach Modulen sucht, fügen wir ihn zur Liste sys.path hinzu:


# import du module MySQLdb
import sys
sys.path.append("D:\Programs\ActivePython\site-packages")
import MySQLdb
 
# connexion à une base MySQL
....

In Zeile 3 fügen wir den Ordner hinzu, in den das MySQLdb-Modul verschoben wurde.

Der vollständige Code für das Beispiel lautet wie folgt:


# import du module MySQLdb
import sys
sys.path.append("D:\Programs\ActivePython\site-packages")
import MySQLdb
 
# connexion à une base MySQL
# l'identité de l'utilisateur est (admpersonnes,nobody)
user="admpersonnes"
pwd="nobody"
host="localhost"
connexion=None
try:
    print "connexion..."
    # connexion
    connexion=MySQLdb.connect(host=host,user=user,passwd=pwd)
    # suivi
    print "Connexion a MySQL reussie sous l'identite host={0},user={1},passwd={2}".format(host,user,pwd)
except MySQLdb.OperationalError,message:
    print "Erreur : {0}".format(message)
finally:
    try:
        connexion.close()
    except:
        pass

Zeilen 8–11: Das Skript verbindet (Zeile 15) den Benutzer [admpersonnes / nobody] mit der MySQL-Datenbank auf dem Rechner [localhost]. Es stellt keine Verbindung zu einer bestimmten Datenbank her;
Zeilen 12–24: Die Verbindung kann fehlschlagen. Daher wird sie in einen try/except/finally-Block eingeschlossen;
Zeile 15: Die connect-Methode des MySQLdb-Moduls akzeptiert verschiedene benannte Parameter:
- user: der Benutzer, der die Verbindung besitzt [admpersonnes];
- pwd: das Passwort des Benutzers [nobody];
- host: der Rechner, auf dem das MySQL-DBMS läuft [localhost];
- db: die Datenbank, zu der eine Verbindung hergestellt werden soll. Optional.
Zeile 18: Wenn eine Ausnahme ausgelöst wird, ist sie vom Typ [MySQLdb.OperationalError] und die zugehörige Fehlermeldung befindet sich in der Variablen [message];
Zeilen 20–23: In der [finally]-Klausel wird die Verbindung geschlossen. Tritt eine Ausnahme auf, wird sie abgefangen (Zeile 23), es werden jedoch keine Maßnahmen ergriffen (Zeile 24).

Ergebnisse

connexion...
Connexion a MySQL reussie sous l'identite host=localhost,user=admpersonnes,passwd=nobody

9.4. Verbindung zu einer MySQL-Datenbank herstellen – 2

Programm (mysqldb_02)

#    import module MySQLdb
import sys
sys.path.append("D:\Programs\ActivePython\site-packages")
import MySQLdb

# ---------------------------------------------------------------------------------
def testeConnexion(hote,login,pwd):
    #  connect then disconnect (login,pwd) mysql sgbd from host server
    #    launches eception MySQLdb.operationalError
    #    connection
    connexion=MySQLdb.connect(host=hote,user=login,passwd=pwd)
    print "Connexion a MySQL reussie sous l'identite (%s,%s,%s)" % (hote,login,passwd)
    #  close the connection
    connexion.close()
    print "Fermeture connexion MySQL reussie\n"


#    ---------------------------------------------- main
#  connection to the MySQL database
#    user identity
user="admpersonnes"
passwd="nobody"
host="localhost"
#    test connection
try:
    testeConnexion(host,user,passwd)
except MySQLdb.OperationalError,message:
    print message
#  with a non-existent user
try:
    testeConnexion(host,"xx","xx")
except MySQLdb.OperationalError,message:
    print message

Anmerkungen:

Zeilen 7–15: Eine Funktion, die versucht, eine Verbindung zu einem MySQL-DBMS herzustellen und diese anschließend wieder zu trennen. Zeigt das Ergebnis an;
Zeilen 18–34: Hauptprogramm – ruft die Methode testConnection zweimal auf und zeigt etwaige Ausnahmen an.

Ergebnisse

Connexion a MySQL reussie sous l'identite (localhost,admpersonnes,nobody)
Fermeture connexion MySQL reussie

Echec de la connexion a MySQL : (1045, "Access denied for user 'xx'@'localhost'(using password: YES)")

9.5. Erstellen einer MySQL-Tabelle

Nachdem wir nun wissen, wie man eine Verbindung zu einem MySQL-DBMS herstellt, werden wir damit beginnen, über diese Verbindung SQL-Befehle auszuführen. Dazu verbinden wir uns mit der erstellten Datenbank [dbpersonnes] und nutzen die Verbindung, um eine Tabelle in der Datenbank zu erstellen.

Programm (mysqldb_03)


# import du module MySQLdb
import sys
sys.path.append("D:\Programs\ActivePython\site-packages")
import MySQLdb
 
# ---------------------------------------------------------------------------------
def executeSQL(connexion,update):
    # exécute une requête update de mise à jour sur la connexion
    # on demande un curseur
    curseur=connexion.cursor()
    # exécute la requête sql sur la connexion
    try:
        curseur.execute(update)
        connexion.commit()
    except Exception, erreur:
        connexion.rollback()
        raise
    finally:
        curseur.close()
 
# ---------------------------------------------- main
# connexion à la base MySQL
# l'identité de l'utilisateur
ID="admpersonnes"
PWD="nobody"
# la machine hôte du sgbd
HOTE="localhost"
# identité de la base
BASE="dbpersonnes"
# connexion
try:
    connexion=MySQLdb.connect(host=HOTE,user=ID,passwd=PWD,db=BASE)
except MySQLdb.OperationalError,message:
    print message
    sys.exit()
 
# suppression de la table personnes si elle existe
# si elle n'existe pas une erreur se produira
# on l'ignore
requete="drop table personnes"
try:
    executeSQL(connexion,requete)
except:
    pass
# création de la table personnes
requete="create table personnes (prenom varchar(30) NOT NULL, nom varchar(30) NOT NULL, age integer NOT NULL, primary key(nom,prenom))"
try:
    executeSQL(connexion,requete)
except MySQLdb.OperationalError,message:
    print message
    sys.exit()
# on se deconnecte et on quitte
try:
    connexion.close()
except MySQLdb.OperationalError,message:
    print message
sys.exit()

Anmerkungen:

Zeile 7: Die Funktion executeSQL führt eine SQL-Abfrage über eine offene Verbindung aus;
Zeile 10: SQL-Operationen auf der Verbindung werden über ein spezielles Objekt namens Cursor ausgeführt;
Zeile 10: Einen Cursor abrufen;
Zeile 13: Führen Sie die SQL-Abfrage aus;
Zeile 14: Die aktuelle Transaktion wird bestätigt;
Zeile 15: Tritt eine Ausnahme auf, wird die Fehlermeldung in der Variablen „error“ gespeichert;
Zeile 16: Die aktuelle Transaktion wird zurückgesetzt;
Zeile 17: Die Ausnahme wird erneut ausgelöst;
Zeile 19: Unabhängig davon, ob ein Fehler vorliegt oder nicht, wird der Cursor geschlossen. Dadurch werden die damit verbundenen Ressourcen freigegeben.

Ergebnisse

create table personnes (prenom varchar(30) NOT NULL, nom varchar(30) NOT NULL, age integer NOT NULL, primary key(nom,prenom)) : requete reussie

Überprüfung mit phpMyAdmin:

Die Datenbank [dbpersonnes] [1] enthält eine Tabelle [personnes] [2] mit der Struktur [3] und dem Primärschlüssel [4].

9.6. Befüllen der Tabelle [people]

Nachdem wir zuvor die Tabelle [people] erstellt haben, füllen wir sie nun.

Programm (mysqldb_04)

#    import module MySQLdb
import sys
sys.path.append("D:\Programs\ActivePython\site-packages")
import MySQLdb
#    other modules
import re

# ---------------------------------------------------------------------------------
def executerCommandes(HOTE,ID,PWD,BASE,SQL,suivi=False,arret=True):
    #    uses connection (HOTE,ID,PWD,BASE)
    #  executes the SQL commands contained in the SQL text file on this connection
    #  this is a file of SQL commands to be executed one per line
    #  if followed=True then each execution of a SQL order is displayed, indicating success or failure
    #  if arret=True, the function stops on the 1st error encountered, otherwise it executes all sql commands
    #  the function returns a list (no. of errors, error1, error2, ...)

    #  check for the presence of the SQL file
    data=None
    try:
        data=open(SQL,"r")
    except:
        return [1,"Le fichier %s n'existe pas" % (SQL)]

    #    connection
    try:
        connexion=MySQLdb.connect(host=HOTE,user=ID,passwd=PWD,db=BASE)
    except MySQLdb.OperationalError,erreur:
        return [1,"Erreur lors de la connexion a MySQL sous l'identite (%s,%s,%s,%s) : %s" % (HOTE, ID, PWD, BASE, erreur)]

    #  a cursor is requested
    curseur=connexion.cursor()
    #  execution of SQL queries contained in the SQL file
    #  we put them in a table
    requetes=data.readlines()
    #    run them one by one - initially no errors
    erreurs=[0]
    for i in range(len(requetes)):
        #  store the current query
        requete=requetes[i]
        #  do we have an empty query? If so, move on to the next query
        if re.match(r"^\s*$",requete):
            continue
        #    query execution i
        erreur=""
        try:
            curseur.execute(requete)
        except Exception, erreur:
            pass
        #   was there a mistake?
        if erreur:
            #    one more mistake
            erreurs[0]+=1
            #  error msg
            msg="%s : Erreur (%s)" % (requete,erreur)
            erreurs.append(msg)
            #  screen tracking or not?
            if suivi:
                print msg
            #    shall we stop?
            if arret:
                return erreurs
        else:
            if suivi: 
                print "%s : Execution reussie" % (requete)
    #  close connection and release resources
    curseur.close()
    connexion.commit()
    #    we disconnect
    try:
        connexion.close()
    except MySQLdb.OperationalError,erreur:
        #    one more mistake
        erreurs[0]+=1
        #  error msg
        msg="%s : Erreur (%s)" % (requete,erreur)
        erreurs.append(msg)

    #    return
    return erreurs


#    ---------------------------------------------- main
#  connection to the MySQL database
#    user identity
ID="admpersonnes"
PWD="nobody"
#  the sgbd host machine
HOTE="localhost"
#    base identity
BASE="dbpersonnes"
#  identity of the SQL command text file to be executed
TEXTE="sql.txt";

#  table creation and filling
erreurs=executerCommandes(HOTE,ID,PWD,BASE,TEXTE,True,False)
# display number of errors
print "il y a eu %s erreur(s)" % (erreurs[0])
for i in range(1,len(erreurs)):
    print erreurs[i]

Ergebnisse

Die Datei „sql.txt“:

drop table personnes
create table personnes (prenom varchar(30) not null, nom varchar(30) not null, age integer not null, primary key (nom,prenom))
insert into personnes values('Paul','Langevin',48)
insert into personnes values ('Sylvie','Lefur',70)
xx

insert into personnes values ('Pierre','Nicazou',35)
insert into personnes values ('Geraldine','Colou',26)
insert into personnes values ('Paulette','Girond',56)

In Zeile 5 wurde absichtlich ein Fehler eingefügt.

Anzeige der Ergebnisse:

drop table personnes : Execution reussie
create table personnes (prenom varchar(30) not null, nom varchar(30) not null, age integer not null, primary key (nom,prenom)) : Execution reussie
insert into personnes values('Paul','Langevin',48) : Execution reussie
insert into personnes values ('Sylvie','Lefur',70) : Execution reussie
xx : Erreur ((1064, "You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'xx' at
 line 1"))
insert into personnes values ('Pierre','Nicazou',35) : Execution reussie
insert into personnes values ('Geraldine','Colou',26) : Execution reussie
insert into personnes values ('Paulette','Girond',56) : Execution reussie
il y a eu 1 erreur(s)
xx : Erreur ((1064, "You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'xx' at line 1"))

Überprüfung mit phpMyAdmin:

In [1] können Sie über den Link [Anzeigen] den Inhalt der Tabelle [people] einsehen [2].

9.7. Ausführen beliebiger SQL-Abfragen

Mit dem folgenden Skript können Sie eine SQL-Befehlsdatei ausführen und das Ergebnis jedes einzelnen Befehls anzeigen:

das Ergebnis des SELECT, wenn der Befehl ein SELECT ist;
die Anzahl der geänderten Zeilen, wenn der Befehl INSERT, UPDATE oder DELETE ist.

Programm (mysqldb_05)

#    import module MySQLdb
import sys
sys.path.append("D:\Programs\ActivePython\site-packages")
import MySQLdb
#    other modules
import re

def cutNewLineChar(ligne):
    #  delete the [line] end-of-line mark if it exists
    l=len(ligne)
    while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
        l-=1
    return(ligne[0:l])

# ---------------------------------------------------------------------------------
def afficherInfos(curseur):
    #  displays the result of an sql query
    #    was it a select?
    if curseur.description:
        #    there's a description - so it's a select
        #  description[i] is the description of column no. i in the select
        #  description[i][0] is the name of column no. i in the select
        #  displays field names
        titre=""
        for i in range(len(curseur.description)):
            titre+=curseur.description[i][0]+","
        #  displays the list of fields without the trailing comma
        print titre[0:len(titre)-1]
        #  dividing line
        print "-"*(len(titre)-1)
        #  current select line
        ligne=curseur.fetchone()
        while ligne:
            print ligne
            #  next line of the select
            ligne=curseur.fetchone()
    else:
        #  there are no fields - it wasn't a select
        print "%s lignes(s) a (ont) ete modifiee(s)" % (curseur.rowcount)


# ---------------------------------------------------------------------------------
def executerCommandes(HOTE,ID,PWD,BASE,SQL,suivi=False,arret=True):
    #    uses connection (HOTE,ID,PWD,BASE)
    #  executes the SQL commands contained in the SQL text file on this connection
    #  this is a file of SQL commands to be executed one per line
    #  if followed=1 then each execution of a SQL order is displayed, indicating success or failure
    #  if arret=1, the function stops on the 1st error encountered, otherwise it executes all sql commands
    #  the function returns an array (nb of errors, error1, error2, ...)

    #  check for the presence of the SQL file
    data=None
    try:
        data=open(SQL,"r")
    except:
        return [1,"Le fichier %s n'existe pas" % (SQL)]

    #    connection
    try:
        connexion=MySQLdb.connect(host=HOTE,user=ID,passwd=PWD,db=BASE)
    except MySQLdb.OperationalError,erreur:
        return [1,"Erreur lors de la connexion a MySQL sous l'identite (%s,%s,%s,%s) : %s" % (HOTE, ID, PWD, BASE, erreur)]

    #  a cursor is requested
    curseur=connexion.cursor()
    #  execution of SQL queries contained in the SQL file
    #  we put them in a table
    requetes=data.readlines()
    #    run them one by one - initially no errors
    erreurs=[0]
    for i in range(len(requetes)):
        #  store the current query
        requete=requetes[i]
        #  do we have an empty query? If so, move on to the next query
        if re.match(r"^\s*$",requete):
            continue
        #    query execution i
        erreur=""
        try:
            curseur.execute(requete)
        except Exception, erreur:
            pass
        #   was there a mistake?
        if erreur:
            #    one more mistake
            erreurs[0]+=1
            #  error msg
            msg="%s : Erreur (%s)" % (requete,erreur)
            erreurs.append(msg)
            #  screen tracking or not?
            if suivi:
                print msg
            #    shall we stop?
            if arret:
                return erreurs
        else:
            if suivi: 
                print "%s : Execution reussie" % (requete)
                #  information on the result of the query
                afficherInfos(curseur)

    #  close connection and release resources
    curseur.close()
    connexion.commit()
    #    we disconnect
    try:
        connexion.close()
    except MySQLdb.OperationalError,erreur:
        #    one more mistake
        erreurs[0]+=1
        #  error msg
        msg="%s : Erreur (%s)" % (requete,erreur)
        erreurs.append(msg)

    #    return
    return erreurs


#    ---------------------------------------------- main
#  connection to the MySQL database
#    user identity
ID="admpersonnes"
PWD="nobody"
#  the sgbd host machine
HOTE="localhost"
#    base identity
BASE="dbpersonnes"
#  identity of the SQL command text file to be executed
TEXTE="sql2.txt"


#  table creation and filling
erreurs=executerCommandes(HOTE,ID,PWD,BASE,TEXTE,True,False)
# display number of errors
print "il y a eu %s erreur(s)" % (erreurs[0])
for i in range(1,len(erreurs)):
    print erreurs[i]

Anmerkungen:

Die neue Funktion befindet sich in Zeile 100 des Skripts: Nach der Ausführung einer SQL-Anweisung fordern wir Informationen über den von dieser Abfrage verwendeten Cursor an. Diese Informationen werden von der Funktion displayInfo in den Zeilen 16–40 bereitgestellt;
Zeilen 19 und 39: Wenn es sich bei der ausgeführten SQL-Abfrage um eine SELECT-Abfrage handelte, ist das Attribut [cursor.description] ein Array, in dem das Element i das Feld i des SELECT-Ergebnisses beschreibt. Andernfalls ist das Attribut [cursor.rowcount] (Zeile 39) die Anzahl der Zeilen, die durch die INSERT-, UPDATE- oder DELETE-Abfrage geändert wurden;
Zeilen 32 und 36: Die Methode [cursor.fetchone] ruft die aktuelle Zeile der SELECT-Abfrage ab. Es gibt eine Methode [cursor.fetchall], die alle Zeilen auf einmal abruft.

Ergebnisse

Die Datei der ausgeführten Abfragen:

select * from personnes
select nom,prenom from personnes order by nom asc, prenom desc
select * from personnes where age between 20 and 40 order by age desc, nom asc, prenom asc
insert into personnes values('Josette','Bruneau',46)
update personnes set age=47 where nom='Bruneau'
select * from personnes where nom='Bruneau'
delete from personnes where nom='Bruneau'
select * from personnes where nom='Bruneau'
xselect * from personnes where nom='Bruneau'

Anzeige der Ergebnisse:

select * from personnes : Execution reussie
prenom,nom,age
---------------
('Geraldine', 'Colou', 26L)
('Paulette', 'Girond', 56L)
('Paul', 'Langevin', 48L)
('Sylvie', 'Lefur', 70L)
('Pierre', 'Nicazou', 35L)
select nom,prenom from personnes order by nom asc, prenom desc : Execution reussie
nom,prenom
-----------
('Colou', 'Geraldine')
('Girond', 'Paulette')
('Langevin', 'Paul')
('Lefur', 'Sylvie')
('Nicazou', 'Pierre')
select * from personnes where age between 20 and 40 order by age desc, nom asc,prenom asc : Execution reussie
prenom,nom,age
---------------
('Pierre', 'Nicazou', 35L)
('Geraldine', 'Colou', 26L)
insert into personnes values('Josette','Bruneau',46) : Execution reussie
1 lignes(s) a (ont) ete modifiee(s)
update personnes set age=47 where nom='Bruneau' : Execution reussie
1 lignes(s) a (ont) ete modifiee(s)
select * from personnes where nom='Bruneau' : Execution reussie
prenom,nom,age
---------------
('Josette', 'Bruneau', 47L)
delete from personnes where nom='Bruneau' : Execution reussie
1 lignes(s) a (ont) ete modifiee(s)
select * from personnes where nom='Bruneau' : Execution reussie
prenom,nom,age
---------------
xselect * from personnes where nom='Bruneau' : Erreur ((1064, "You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'xselect * from personnes where nom='Bruneau'' at line 1"))

PhpMyAdmin-Überprüfung: