CodesBDD

UserPreferences

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

1. Généralités
2. SQLITE, embarquez une base SQL facilement
3. Manipuler Microsoft SQL Server en Python
4. Accéder à une base de données MySQL
5. Accéder à une base de données par ODBC
6. Accéder à une base de données par ADO
7. Accéder à une base de données PostgreSQL
1. Avec psycopg
2. Avec pyPgSQL
3. Avec pygresql

1. 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.

2. 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

  1 
  2 
  3 
  4 
  5 
  6 
  7 
  8 
  9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
#!/usr/bin/python
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.

3. Manipuler Microsoft SQL Server en Python

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.

4. 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.

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

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.

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

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

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

7.1. Avec psycopg

http://initd.org/software/psycopg

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

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

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/).

7.2. Avec pyPgSQL

http://pypgsql.sourceforge.net/

  1 
  2 
  3 
  4 
  5 
  6 
  7 
  8 
  9 
from pyPgSQL import PgSQL
db = PgSQL.connect("nom_serveur::nom_base:nom_user")

id = 2662
cursor = db.cursor()
qu = "SELECT * FROM table WHERE id ='%s'"
cursor.execute(qu % demande_id)
r = cursor.fetchone()
print r.nom_du_champ

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.

7.3. Avec pygresql

http://www.pygresql.org/

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

  1 
  2 
  3 
  4 
  5 
  6 
  7 
  8 
  9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
#!/usr/bin/python
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"]