common-lisp
डेटाबेस के साथ काम करना

Postmodern के साथ PostgreSQL का सरल उपयोग

पोस्टमॉडर्न रिलेशनल डेटाबेस को पोस्टग्रेज करने के लिए एक लाइब्रेरी है। यह एक वस्तु-संबंधपरक मैपिंग के लिए स्ट्रिंग के रूप में या सूचियों के रूप में प्रतिनिधित्व SQL प्रश्नों के निष्पादन से, PostgreSQL तक पहुंच के कई स्तर प्रदान करता है।

निम्नलिखित उदाहरणों में उपयोग किया जाने वाला डेटाबेस इन 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}');

पहला उदाहरण एक साधारण क्वेरी के रिलेशन को वापस करने का परिणाम दिखाता है:

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

ध्यान दें कि परिणाम को वैकल्पिक मापदंडों को जोड़ते हुए एलिस्ट या प्लिस्ट की सूची के रूप में वापस किया जा सकता है :alists या :plists क्वेरी फ़ंक्शन के लिए।

query के परिणामों पर पुनरावृति करने के लिए query का विकल्प doquery । इसके पैरामीटर query (&rest names) &body body , जहां नाम प्रत्येक पुनरावृत्ति पर पंक्ति में मानों से बंधे हैं:

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

जब क्वेरी को पैरामीटर की आवश्यकता होती है, तो कोई तैयार किए गए कथनों का उपयोग कर सकता है:

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

फ़ंक्शन prepare प्लेसहोल्डर्स के साथ $1 , $2 , आदि की एक क्वेरी प्राप्त होती है और एक नया फ़ंक्शन देता है जिसमें प्रत्येक प्लेसहोल्डर के लिए एक पैरामीटर की आवश्यकता होती है और सही संख्या में तर्कों के साथ कॉल करने पर क्वेरी को निष्पादित करता है।

अद्यतनों के मामले में, फ़ंक्शन exec ट्यूपलों की संख्या को संशोधित करता है (दो डीडीएल विवरण लेनदेन में संलग्न हैं):

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

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