common-lisp
Travailler avec des bases de données

Utilisation simple de PostgreSQL avec Postmodern

Postmodern est une bibliothèque pour interfacer la base de données relationnelle PostgreSQL . Il offre plusieurs niveaux d’accès à PostgreSQL, de l’exécution de requêtes SQL représentées sous forme de chaînes, ou de listes, à un mappage objet-relationnel.

La base de données utilisée dans les exemples suivants peut être créée avec ces instructions SQL:

create table employees
  (empid integer not null primary key,
   name text not null,
   birthdate date not null,
   skills text[] not null);
insert into employees (empid, name, birthdate, skills) values
  (1, 'John Orange', '1991-07-26', '{C, Java}'),
  (2, 'Mary Red', '1989-04-14', '{C, Common Lisp, Hunchentoot}'),
  (3, 'Ron Blue', '1974-01-17', '{JavaScript, Common Lisp}'),
  (4, 'Lucy Green', '1968-02-02', '{Java, JavaScript}');

Le premier exemple montre le résultat d'une simple requête renvoyant une relation:

CL-USER> (ql:quickload "postmodern")   ; load the system postmodern (nickname: pomo)
("postmodern")
CL-USER> (let ((parameters '("database" "dbuser" "dbpass" "localhost")))
           (pomo:with-connection parameters
             (pomo:query "select name, skills from employees")))
(("John Orange" #("C" "Java"))                  ; output manually edited!
 ("Mary Red" #("C" "Common Lisp" "Hunchentoot"))
 ("Ron Blue" #("JavaScript" "Common Lisp"))
 ("Lucy Green" #("Java" "JavaScript")))
4                                               ; the second value is the size of the result

Notez que le résultat peut être renvoyé sous la forme d'une liste d'alist ou de plists ajoutant les paramètres facultatifs :alists ou :plists à la fonction de requête.

Une alternative à la query est doquery , pour parcourir les résultats d'une requête. Ses paramètres sont query (&rest names) &body body , où les noms sont liés aux valeurs de la ligne à chaque itération:

CL-USER> (let ((parameters '("database" "dbuser" "dbpass" "localhost")))
           (pomo:with-connection parameters
             (format t "The employees that knows Java are:~%")
             (pomo:doquery "select empid, name from employees where skills @> '{Java}'" (i n)
               (format t "~a (id = ~a)~%" n i))))
The employees that knows Java are:
John Orange (id = 1)
Lucy Green (id = 4)
NIL
2

Lorsque la requête nécessite des paramètres, on peut utiliser des instructions préparées:

CL-USER> (let ((parameters '("database" "dbuser" "dbpass" "localhost")))
           (pomo:with-connection parameters
             (funcall
               (pomo:prepare "select name, skills from employees where skills @> $1")
               #("Common Lisp"))))    ; find employees with skills including Common Lisp
(("Mary Red" #("C" "Common Lisp" "Hunchentoot"))
 ("Ron Blue" #("JavaScript" "Common Lisp")))
2

La fonction prepare reçoit une requête avec des espaces réservés $1 , $2 , etc.

En cas de mises à jour, la fonction exec renvoie le nombre de tuples modifiés (les deux instructions DDL sont incluses dans une transaction):

CL-USER> (let ((parameters '("database" "dbuser" "dbpass" "localhost")))
           (pomo:with-connection parameters
             (pomo:ensure-transaction
               (values
                 (pomo:execute "alter table employees add column salary integer")
                 (pomo:execute "update employees set salary =
                                     case when skills @> '{Common Lisp}'
                                     then 100000 else 50000 end")))))
0
4

En plus d'écrire des requêtes SQL sous forme de chaînes, on peut utiliser des listes de mots-clés, de symboles et de constantes, avec une syntaxe rappelant celle de lisp (S-SQL):

CL-USER> (let ((parameters '("database" "dbuser" "dbpass" "localhost")))
           (pomo:with-connection parameters
             (pomo:query (:select 'name :from 'employees :where (:> 'salary 60000)))))
(("Mary Red") ("Ron Blue"))
2