common-lisp
Lavorare con i database

Semplice utilizzo di PostgreSQL con Postmodern

Postmodern è una libreria per interfacciare il database relazionale PostgreSQL . Offre diversi livelli di accesso a PostgreSQL, dall'esecuzione di query SQL rappresentate come stringhe, o come elenchi, a una mappatura relazionale a oggetti.

Il database utilizzato nei seguenti esempi può essere creato con queste istruzioni 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}');

Il primo esempio mostra il risultato di una semplice query che restituisce una relazione:

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

Si noti che il risultato può essere restituito come elenco di alists o plists aggiungendo i parametri opzionali :alists o :plists alla funzione di interrogazione.

Un'alternativa alla query è doquery , per iterare sui risultati di una query. I suoi parametri sono query (&rest names) &body body , dove i nomi sono legati ai valori nella riga ad ogni iterazione:

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

Quando la query richiede parametri, è possibile utilizzare istruzioni preparate:

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 funzione prepare riceve una query con segnaposto $1 , $2 , ecc. E restituisce una nuova funzione che richiede un parametro per ogni segnaposto ed esegue la query quando viene chiamata con il giusto numero di argomenti.

In caso di aggiornamenti, la funzione exec restituisce il numero di tuple modificate (le due istruzioni DDL sono racchiuse in una transazione):

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

Oltre a scrivere query SQL come stringhe, è possibile utilizzare elenchi di parole chiave, simboli e costanti, con una sintassi che richiama il 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