Cette page donne des exemples de code Python pour accéder à diverses bases de données.

Généralités

L'ensemble des infos de l'accès à des bases de données à partir de Python peut être trouvé ici : http://python.org/topics/database/.

Les classes, méthodes, etc utilisées pour l'accès aux bases de données sont normalisées. La pluspart des modules d'accès sont donc faits selon les prérogatives de la DB API 2.0 : http://python.org/peps/pep-0249.html.

SQLITE, embarquez une base SQL facilement

SQLite est une bibliothèque qui permet de créer instantanément une base de données sur disque ou en mémoire.

Inconvénients de SQLite:

• pas conçu pour les accès concurrents
• ne fonctionne qu'en local (pas de service réseau)
• ne gère pas les clés étrangères.
• pas de gestion des droits (grant/revoke)

Avantages:

• très performante (plus rapide que mySQL)
• supporte la quasi-totalité du SQL-92
• l'utilisation de SQLite ne nécessite pas l'installation et l'administation d'un serveur SQL
• les bases sont compactes
• Une base = 1 fichier (facile à sauvegarder/restaurer)
• les bases sont portables entre systèmes (Windows, MacOS, Linux, PDA...)
• ACID (intégrité des données)
• Supporte les transactions
• peut gérer jusqu'à 2 Tera-octets de données.

De par ses performances et sa simplicité d'administration, SQLite est un excellent choix pour beaucoup de projets, même les sites web.

http://pysqlite.org

import sqlite
#Pour créer une base de donnée en mémoire
cx = sqlite.connect(":memory:")

# OU
#Sur disque (un seul fichier sera écrit)
cx = sqlite.connect("madatabase.db3", autocommit=True)
cur = cx.cursor()

#création d'une table répertoire
cur.execute("create table repertoire (rowid integer primary key, nom char(20), prenom char(20))")

#écriture de deux enregistrements
cur.execute("insert into repertoire (nom,prenom) values (%s,%s)", ("toto", "lito"))
cur.execute("insert into repertoire (nom,prenom) values (%s,%s)", ("titi", "liti"))

#affichage des enregistrements
cur.execute("select * from repertoire")
for row in cur.fetchall():
    print row.nom, row.prenom

Pour manager vos bases SQLite, vous pouvez utiliser des freewares comme SQLiteSpy.

Manipuler Microsoft SQL Server en Python

[Spécifique Windows]
Avec Python, il est possible de scripter tout ce que vous feriez dans la MMC (Enterprise Manager) : lister le contenu des bases, tables, modifier les droits, ajouter/supprimer des indexes, procédures stockées, vues, tables ou logins, générer les scripts des bases, lancer un backup, programmer un job, modifier la configuration du serveur, etc.

Ceci nécessite l'installation des extensions Win32 pour Python (http://starship.python.net/crew/mhammond/win32/).

Par exemple pour avoir la liste des bases d'un serveur:

{{{from win32com.client import gencache s = gencache.EnsureDispatch('SQLDMO.SQLServer') s.Connect('servername','login','password') for i in range(1,s.Databases.Count):

• print s.Databases.Item(i).Name}}}

Ou bien récupérer le script d'une table:

{{{database = s.Databases('COMMERCE') script = database.Tables('CLIENTS').Script() print script}}}

Toutes ces manipulation se font en utilisant les objets SQL-DMO de Microsoft. La doc (http://msdn.microsoft.com/library/en-us/sqldmo/dmoref_ob_s_7igk.asp) vous indiquera tout ce que vous pouvez modifier (objets, attributs et méthodes), et il y a le choix !

ça permet potentiellement de scripter tout ce qui nécessite des interventions manuelles dans la MMC.

Accéder à une base de données MySQL

Necessite le module MySQLdb pour la dernière version (http://sourceforge.net/project/showfiles.php?group_id=22307).

Ce module se base sur la PEP 249 ou si vous preferez "Python Database API Specification v2.0".

Pour plus d'info sur les méthodes disponibles : http://www.python.org/peps/pep-0249.html

Une autre piste : http://sourceforge.net/docman/display_doc.php?docid=26238&group_id=22307 (en date du 28/04/05)

Un court exemple:

{{{#!/usr/bin/env python

import MySQLdb, pprint

connectionObject = MySQLdb.connect(host='172.17.2.1', user='toto', passwd='123', db='mycollection')

c = connectionObject.cursor()

nom_auteur = "Shakespeare"

c.execute(""" SELECT title, description FROM books WHERE author = %s """ % (nom_auteur,))

pprint.pprint(c.fetchall())

c.query("update books set title='toto' where author='titi'")

c.commit()

}}}

Où 'host' est l'adresse du serveur MySQL, 'user', votre nom de login, 'passwd', votre mot de passe et 'db', le nom de la base de données.

PS: pprint permet juste d'obtenir une sortie un peu plus jolie.

Accéder à une base de données par ODBC

[Spécifique Windows]
Sous Windows, le module ODBC permet d'accéder facilement à n'importe quel type de serveur de base de données.
ODBC est accessible de Python si vous avez installé le module win32all ou activePython.

Créez d'abord un DSN (Panneau de configuration) (ici, 'mondsn'), puis:

import dbi, odbc
conn = odbc.odbc('mondsn/monlogin/monpassword')
c = conn.cursor()
c.execute('select clientid, name, city from client')
print c.fetchall()

fetchall() ramène en une fois tous les enregistrements. Vous pouvez utiliser fetchone() pour lire enregistrement par enregistrement, ou bien fetchmany(x) pour lire x enregistrements à la fois.

Accéder à une base de données par ADO

[Spécifique Windows]
Sous Windows, vous avez la possibilité d'utiliser ADO (Microsoft ActiveX Data Objects) à la place d'ODBC pour accéder à une base de données (ADO est plus rapide qu'ODBC).

Ceci nécessite l'installation des extensions Win32 pour Python (http://starship.python.net/crew/mhammond/win32/).

Le code suivant va utiliser l'objet COM ADO pour se connecter à un serveur Microsoft SQL Server, et récupérer (et afficher) le contenu d'une table:

import win32com.client
connexion = win32com.client.gencache.EnsureDispatch('ADODB.Connection')
connexion.Open("Provider='SQLOLEDB';Data Source='monserveur';Initial Catalog='mabase';User ID='monlogin';Password='monmotdepasse';")
recordset = connexion.Execute('SELECT clientid, clientName FROM clients')[0]
while not recordset.EOF:
    print 'clientid=',recordset.Fields(0).Value,'  nom du client=',recordset.Fields(1).Value
    recordset.MoveNext()
connexion.Close()

Pour la documentation d'ADO, voir http://msdn.microsoft.com/library/en-us/ado270/htm/mdaobj01.asp

Il est également possible d'utiliser http://adodbapi.sf.net pour accéder à une base ado à l'aide d'une interface respectant les normes python DBAPI2.0

Accéder à une base de données PostgreSQL

Voici deux modules pour accéder à PostgreSQL depuis Python. Tous deux implémentent la DB API 2.0.

Avec psycopg

http://initd.org/software/psycopg

psycopg est censé être l'API PostgreSQL la plus rapide en Python.

   1 import psycopg
   2 db = psycopg.connect("dbname=nom_base user=nom_user")
   3 id = 2662
   4 cursor = db.cursor()
   5 qu = "SELECT * FROM table WHERE id ='%s'"
   6 cursor.execute(qu % id)
   7 r = cursor.fetchone()
   8 print r[0]

L'objet renvoyé par la méthode fetchone() de psycopg est un tuple on doit donc y accéder par son index. Si on veut y accéder par le nom du champ on peut utiliser un module comme db_row (http://opensource.theopalgroup.com/).

Avec pyPgSQL

http://pypgsql.sourceforge.net/

   1 from pyPgSQL import PgSQL
   2 db = PgSQL.connect("nom_serveur::nom_base:nom_user")
   3 
   4 id = 2662
   5 cursor = db.cursor()
   6 qu = "SELECT * FROM table WHERE id ='%s'"
   7 cursor.execute(qu % demande_id)
   8 r = cursor.fetchone()
   9 print r.nom_du_champ
  10 print r[0]

L'objet renvoyé par la méthode fetchone() de pyPgSQL est une instance de classe. On peut accéder aux valeurs par leur index mais également par leur nom en récupérant la valeur des attributs portant le même nom que les champs de resultats.

Pour les requêtes qui écrivent dans la base (INSERT, UPDATE, DELETE) ne pas oublier de faire un db.commit() pour rendre les modification effectives.

Avec pygresql

http://www.pygresql.org/

Documentation en ligne: http://www.postgresql.org/docs/7.3/static/pygresql.html

import pg
db = pg.connect(DataBaseName, host=NomHote, user=NomUser, passwd=Pass)
id = 2662
sql="SELECT * FROM table WHERE id =%i"%id
res=db.query(sql)

ListeEnregistrements=res.getresult()

# Premier enregistrement
print ListeEnregistrements[0]
# Premier champ du premier enregistrement
print ListeEnregistrements[0][0]

# On peut aussi récupérer les enregistrements sous forme de dictionnaires (un dictionnaire par ligne).
# Les clés des dictionnaires sont les noms des champs
ListeEnregistrements=res.dictresult()
# Premier enregistrement
print ListeEnregistrements[0]
# Champ "nom_du_champ" de l'enregistrement
print ListeEnregistrements[0]["nom_du_champ"]