r9260: 6 May 2004 Kevin Rosenberg (kevin@rosenberg.net)

        * tests/test-*.lisp: Rename fields so that joins occur on
        fields with different names. This ensures that join code is
        selecting the proper name.
        * test/test-init.lisp: Add :base-table for employee-address
        view class for testing.
        * sql/objects.lisp: Use view-table rather than name of table
        in a number of places to fix errors noted with using :base-table.

diff --git a/ChangeLog b/ChangeLog
index 173fce3e0209b0b98ba99329046755f5e02ef631..90803120810e525d4ddf11177b1d8ac11f8e8b91 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,11 @@
-4 May 2004 Kevin Rosenberg (kevin@rosenberg.net)
-       * tests/test-syntax.lisp: Add syntax tests for SQL-OBJECT-QUERY
+6 May 2004 Kevin Rosenberg (kevin@rosenberg.net)
+       * tests/test-*.lisp: Rename fields so that joins occur on
+       fields with different names. This ensures that join code is
+       selecting the proper name.
+       * test/test-init.lisp: Add :base-table for employee-address
+       view class for testing.
+       * sql/objects.lisp: Use view-table rather than name of table
+       in a number of places to fix errors noted with using :base-table.
        
 6 May 2004 Marcus Pearce (m.t.pearce@city.ac.uk) 
         * sql/objects.lisp: replace *update-records-on-make-instance* with 

diff --git a/sql/objects.lisp b/sql/objects.lisp
index 6b2fb4b0b892391a84bd15227ff298c98cd94b2e..90505559e6e466f4076a7f443eda47b38af7ca53 100644 (file)
--- a/sql/objects.lisp
+++ b/sql/objects.lisp
@@ -738,6 +738,8 @@ superclass of the newly-defined View Class."
   (let* ((dbi (view-class-slot-db-info slot-def))
         (ts (gethash :target-slot dbi))
         (jc (gethash :join-class dbi))
+        (ts-view-table (view-table (find-class ts)))
+        (jc-view-table (view-table (find-class jc)))
         (tdbi (view-class-slot-db-info 
                (find ts (class-slots (find-class jc))
                      :key #'slot-definition-name)))
@@ -749,11 +751,15 @@ superclass of the newly-defined View Class."
        (:immediate
         (let ((res
                (find-all (list ts) 
-                         :inner-join (sql-expression :attribute jc)
+                         :inner-join (sql-expression :table jc-view-table)
                          :on (sql-operation 
                               '==
-                              (sql-expression :attribute (gethash :foreign-key tdbi) :table ts)
-                              (sql-expression :attribute (gethash :home-key tdbi) :table jc))
+                              (sql-expression 
+                               :attribute (gethash :foreign-key tdbi) 
+                               :table ts-view-table)
+                              (sql-expression 
+                               :attribute (gethash :home-key tdbi) 
+                               :table jc-view-table))
                          :where jq
                          :result-types :auto)))
           (mapcar #'(lambda (i)
@@ -778,8 +784,8 @@ superclass of the newly-defined View Class."
                   (setf (slot-value jcc (gethash :home-key tdbi)) 
                         fk)
                   (list instance jcc)))
-            (select (sql-expression :attribute (gethash :foreign-key tdbi) :table jc)
-                    :from (sql-expression :table jc)
+            (select (sql-expression :attribute (gethash :foreign-key tdbi) :table jc-view-table)
+                    :from (sql-expression :table jc-view-table)
                     :where jq)))))))
 
 (defun update-object-joins (objects &key (slots t) (force-p t)
@@ -787,7 +793,7 @@ superclass of the newly-defined View Class."
   "Updates the remote join slots, that is those slots defined without :retrieval :immediate."
   (when objects
     (unless class-name
-      (class-name (class-of (first object))))
+      (class-name (class-of (first objects))))
     )
   )
 

diff --git a/tests/test-fddl.lisp b/tests/test-fddl.lisp
index e84bdad2b1fade6c49a95116deb7f7ac2d44876a..71094847f379cfaddac9f747d298b74dfda0d1fc 100644 (file)
--- a/tests/test-fddl.lisp
+++ b/tests/test-fddl.lisp
@@ -28,7 +28,7 @@
            (sort (mapcar #'string-downcase
                          (clsql:list-tables :owner *test-database-user*))
                  #'string<))
-  "address" "company" "employee" "employee_address" "type_table")
+  "address" "company" "ea_join" "employee" "type_table")
 
 ;; create a table, test for its existence, drop it and test again 
 (deftest :fddl/table/2
@@ -66,7 +66,7 @@
                     (clsql:list-attributes [employee]
                                           :owner *test-database-user*))
             #'string<))
-  "birthday" "companyid" "email" "emplid" "first_name" "groupid" "height"
+  "birthday" "ecompanyid" "email" "emplid" "first_name" "groupid" "height"
   "last_name" "managerid" "married")
 
 (deftest :fddl/attributes/2
@@ -76,7 +76,7 @@
                     (clsql:list-attribute-types [employee]
                                                :owner *test-database-user*))
             #'string<))
-  "birthday" "companyid" "email" "emplid" "first_name" "groupid" "height"
+  "birthday" "ecompanyid" "email" "emplid" "first_name" "groupid" "height"
   "last_name" "managerid" "married")
 
 ;; Attribute types are vendor specific so need to test a range

diff --git a/tests/test-fdml.lisp b/tests/test-fdml.lisp
index df9f28faf52bd6f90be6749dcd83e8d528ba3d6f..26e760e919937be497e3e54512b4725f478fc4a4 100644 (file)
--- a/tests/test-fdml.lisp
+++ b/tests/test-fdml.lisp
@@ -40,7 +40,7 @@
     (progn
       (clsql:insert-records :into [employee] 
                            :attributes '(emplid groupid first_name last_name
-                                         email companyid managerid)
+                                         email ecompanyid managerid)
                            :values '(11 1 "Yuri" "Gagarin" "gagarin@soviet.org"
                                      1 1))
       (values 
@@ -58,7 +58,7 @@
                                       (first_name "Yuri")
                                       (last_name "Gagarin")
                                       (email "gagarin@soviet.org")
-                                      (companyid 1) (managerid 1)))
+                                      (ecompanyid 1) (managerid 1)))
       (values 
        (clsql:select [first-name] [last-name] [email] :from [employee]
                     :where [= [emplid] 11])

diff --git a/tests/test-init.lisp b/tests/test-init.lisp
index 99c3a47c5abbd215a1f472ba7700d2d3c22fd097..a1f700e90c0f5374cf8d6ce087df1c2458c19cab 100644 (file)
--- a/tests/test-init.lisp
+++ b/tests/test-init.lisp
@@ -64,14 +64,14 @@
     :accessor employee-email
     :type (string 100)
     :initarg :email)
-   (companyid
+   (ecompanyid
     :type integer
     :initarg :companyid)
    (company
     :accessor employee-company
     :db-kind :join
     :db-info (:join-class company
-                         :home-key companyid
+                         :home-key ecompanyid
                          :foreign-key companyid
                          :set nil))
    (managerid
@@ -89,7 +89,7 @@
     :db-kind :join
     :db-info (:join-class employee-address
                          :home-key emplid
-                         :foreign-key emplid
+                         :foreign-key aemplid
                          :target-slot address
                          :set t)))
   (:base-table employee))
@@ -123,7 +123,7 @@
     :db-kind :join
     :db-info (:join-class employee
                          :home-key (companyid groupid)
-                         :foreign-key (companyid groupid)
+                         :foreign-key (ecompanyid groupid)
                          :set t)))
   (:base-table company))
 
@@ -154,15 +154,16 @@
 
 ;; many employees can reside at many addressess
 (def-view-class employee-address ()
-  ((emplid :type integer
+  ((aemplid :type integer
           :initarg :emplid)
-   (addressid :type integer
+   (aaddressid :type integer
              :initarg :addressid)
    (address :db-kind :join
            :db-info (:join-class address
-                                 :home-key addressid
+                                 :home-key aaddressid
                                  :foreign-key addressid
-                                 :retrieval :immediate))))
+                                 :retrieval :immediate)))
+  (:base-table "ea_join"))
 
 (defun test-connect-to-database (db-type spec)
   (when (db-backend-has-create/destroy-db? db-type)

diff --git a/tests/test-ooddl.lisp b/tests/test-ooddl.lisp
index 497bef6099c10b9d5c4a33686cdc681e4c559555..48d1630fd6a815acb8636d491f2e390170c2cafd 100644 (file)
--- a/tests/test-ooddl.lisp
+++ b/tests/test-ooddl.lisp
@@ -48,9 +48,8 @@
   t t t)
 
 (deftest :ooddl/join/1
-    (mapcar #'(lambda (e)
-                (slot-value e 'companyid))
-            (company-employees company1))
+    (mapcar #'(lambda (e) (slot-value e 'ecompanyid))
+     (company-employees company1))
   (1 1 1 1 1 1 1 1 1 1))
 
 (deftest :ooddl/join/2

diff --git a/tests/test-oodml.lisp b/tests/test-oodml.lisp
index 804248bcb09ff262a94145124a828c2e16cd1df5..df55c38b4f282d15cf136a8a8f97f645f9271dc0 100644 (file)
--- a/tests/test-oodml.lisp
+++ b/tests/test-oodml.lisp
@@ -22,298 +22,300 @@
 (setq *rt-oodml*
       '(
        
-(deftest :oodml/select/1
-    (mapcar #'(lambda (e) (slot-value e 'last-name))
-            (clsql:select 'employee :order-by [last-name] :flatp t))
-  ("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Lenin" "Putin"
-              "Stalin" "Trotsky" "Yeltsin"))
+       (deftest :oodml/select/1
+           (mapcar #'(lambda (e) (slot-value e 'last-name))
+            (clsql:select 'employee :order-by [last-name] :flatp t))
+         ("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Lenin" "Putin"
+          "Stalin" "Trotsky" "Yeltsin"))
 
-(deftest :oodml/select/2
-    (mapcar #'(lambda (e) (slot-value e 'name))
-            (clsql:select 'company :flatp t))
-  ("Widgets Inc."))
+       (deftest :oodml/select/2
+           (mapcar #'(lambda (e) (slot-value e 'name))
+            (clsql:select 'company :flatp t))
+         ("Widgets Inc."))
 
-(deftest :oodml/select/3
-    (mapcar #'(lambda (e) (slot-value e 'companyid))
-            (clsql:select 'employee
-                         :where [and [= [slot-value 'employee 'companyid]
-                                        [slot-value 'company 'companyid]]
-                                     [= [slot-value 'company 'name]
-                                        "Widgets Inc."]]
-                          :flatp t))
-  (1 1 1 1 1 1 1 1 1 1))
+       (deftest :oodml/select/3
+           (mapcar #'(lambda (e) (slot-value e 'ecompanyid))
+            (clsql:select 'employee
+                          :where [and [= [slot-value 'employee 'ecompanyid]
+                                         [slot-value 'company 'companyid]]
+                                      [= [slot-value 'company 'name]
+                                         "Widgets Inc."]]
+                          :flatp t))
+         (1 1 1 1 1 1 1 1 1 1))
 
-(deftest :oodml/select/4
-    (mapcar #'(lambda (e)
-                (concatenate 'string (slot-value e 'first-name)
-                             " "
-                             (slot-value e 'last-name)))
-            (clsql:select 'employee :where [= [slot-value 'employee 'first-name]
-                                             "Vladamir"]
-                        :flatp t                    
-                         :order-by [last-name]))
-  ("Vladamir Lenin" "Vladamir Putin"))
+       (deftest :oodml/select/4
+           (mapcar #'(lambda (e)
+                       (concatenate 'string (slot-value e 'first-name)
+                                    " "
+                                    (slot-value e 'last-name)))
+            (clsql:select 'employee :where [= [slot-value 'employee 'first-name]
+                                              "Vladamir"]
+                          :flatp t                  
+                          :order-by [last-name]))
+         ("Vladamir Lenin" "Vladamir Putin"))
 
-(deftest :oodml/select/5
-    (length (clsql:select 'employee :where [married] :flatp t))
-  3)
+       (deftest :oodml/select/5
+           (length (clsql:select 'employee :where [married] :flatp t))
+         3)
 
-(deftest :oodml/select/6
-    (let ((a (caar (clsql:select 'address :where [= 1 [addressid]]))))
-      (values
-       (slot-value a 'street-number)
-       (slot-value a 'street-name)
-       (slot-value a 'city)
-       (slot-value a 'postal-code)))
-  10 "Park Place" "Leningrad" 123)
+       (deftest :oodml/select/6
+           (let ((a (caar (clsql:select 'address :where [= 1 [addressid]]))))
+             (values
+              (slot-value a 'street-number)
+              (slot-value a 'street-name)
+              (slot-value a 'city)
+              (slot-value a 'postal-code)))
+         10 "Park Place" "Leningrad" 123)
 
-(deftest :oodml/select/7
-    (let ((a (caar (clsql:select 'address :where [= 2 [addressid]]))))
-      (values
-       (slot-value a 'street-number)
-       (slot-value a 'street-name)
-       (slot-value a 'city)
-       (slot-value a 'postal-code)))
-  nil "" "no city" 0)
+       (deftest :oodml/select/7
+           (let ((a (caar (clsql:select 'address :where [= 2 [addressid]]))))
+             (values
+              (slot-value a 'street-number)
+              (slot-value a 'street-name)
+              (slot-value a 'city)
+              (slot-value a 'postal-code)))
+         nil "" "no city" 0)
 
-(deftest :oodml/select/8 
-    (mapcar #'(lambda (e) (slot-value e 'married)) 
-              (clsql:select 'employee :flatp t :order-by [emplid]))
-  (t t t nil nil nil nil nil nil nil))
+       (deftest :oodml/select/8 
+           (mapcar #'(lambda (e) (slot-value e 'married)) 
+            (clsql:select 'employee :flatp t :order-by [emplid]))
+         (t t t nil nil nil nil nil nil nil))
 
-(deftest :oodml/select/9
-    (mapcar #'(lambda (pair)
-               (list
-                (typep (car pair) 'address)
-                (typep (second pair) 'employee-address)
-                (slot-value (car pair) 'addressid)
-                (slot-value (second pair) 'addressid)))
-     (employee-addresses employee1))
-  ((t t 1 1) (t t 2 2)))
+       (deftest :oodml/select/9
+           (mapcar #'(lambda (pair)
+                       (list
+                        (typep (car pair) 'address)
+                        (typep (second pair) 'employee-address)
+                        (slot-value (car pair) 'addressid)
+                        (slot-value (second pair) 'aaddressid)
+                        (slot-value (second pair) 'aemplid)))
+            (employee-addresses employee1))
+         ((t t 1 1 1) (t t 2 2 1)))
 
-(deftest :oodml/select/10
-    (mapcar #'(lambda (pair)
-               (list
-                (typep (car pair) 'address)
-                (typep (second pair) 'employee-address)
-                (slot-value (car pair) 'addressid)
-                (slot-value (second pair) 'addressid)))
-     (employee-addresses employee2))
-  ((t t 2 2)))
+       (deftest :oodml/select/10
+           (mapcar #'(lambda (pair)
+                       (list
+                        (typep (car pair) 'address)
+                        (typep (second pair) 'employee-address)
+                        (slot-value (car pair) 'addressid)
+                        (slot-value (second pair) 'aaddressid)
+                        (slot-value (second pair) 'aemplid)))
+            (employee-addresses employee2))
+         ((t t 2 2 2)))
 
 
-;; tests update-records-from-instance 
-(deftest :oodml/update-records/1
-    (values
-     (progn
-       (let ((lenin (car (clsql:select 'employee
-                                      :where [= [slot-value 'employee 'emplid]
-                                                1]
-                                      :flatp t))))
-         (concatenate 'string
-                      (first-name lenin)
-                      " "
-                      (last-name lenin)
-                      ": "
-                      (employee-email lenin))))
-       (progn
-         (setf (slot-value employee1 'first-name) "Dimitriy" 
-               (slot-value employee1 'last-name) "Ivanovich"
-               (slot-value employee1 'email) "ivanovich@soviet.org")
-         (clsql:update-records-from-instance employee1)
-         (let ((lenin (car (clsql:select 'employee
-                                      :where [= [slot-value 'employee 'emplid]
-                                                1]
-                                     :flatp t))))
-           (concatenate 'string
-                        (first-name lenin)
-                        " "
-                        (last-name lenin)
-                        ": "
-                        (employee-email lenin))))
-       (progn 
-         (setf (slot-value employee1 'first-name) "Vladamir" 
-               (slot-value employee1 'last-name) "Lenin"
-               (slot-value employee1 'email) "lenin@soviet.org")
-         (clsql:update-records-from-instance employee1)
-         (let ((lenin (car (clsql:select 'employee
-                                      :where [= [slot-value 'employee 'emplid]
-                                                1]
-                                     :flatp t))))
-           (concatenate 'string
-                        (first-name lenin)
-                        " "
-                        (last-name lenin)
-                        ": "
-                        (employee-email lenin)))))
-  "Vladamir Lenin: lenin@soviet.org"
-  "Dimitriy Ivanovich: ivanovich@soviet.org"
-  "Vladamir Lenin: lenin@soviet.org")
+       ;; tests update-records-from-instance 
+       (deftest :oodml/update-records/1
+           (values
+            (progn
+              (let ((lenin (car (clsql:select 'employee
+                                              :where [= [slot-value 'employee 'emplid]
+                                                        1]
+                                              :flatp t))))
+                (concatenate 'string
+                             (first-name lenin)
+                             " "
+                             (last-name lenin)
+                             ": "
+                             (employee-email lenin))))
+            (progn
+              (setf (slot-value employee1 'first-name) "Dimitriy" 
+                    (slot-value employee1 'last-name) "Ivanovich"
+                    (slot-value employee1 'email) "ivanovich@soviet.org")
+              (clsql:update-records-from-instance employee1)
+              (let ((lenin (car (clsql:select 'employee
+                                              :where [= [slot-value 'employee 'emplid]
+                                                        1]
+                                              :flatp t))))
+                (concatenate 'string
+                             (first-name lenin)
+                             " "
+                             (last-name lenin)
+                             ": "
+                             (employee-email lenin))))
+            (progn 
+              (setf (slot-value employee1 'first-name) "Vladamir" 
+                    (slot-value employee1 'last-name) "Lenin"
+                    (slot-value employee1 'email) "lenin@soviet.org")
+              (clsql:update-records-from-instance employee1)
+              (let ((lenin (car (clsql:select 'employee
+                                              :where [= [slot-value 'employee 'emplid]
+                                                        1]
+                                              :flatp t))))
+                (concatenate 'string
+                             (first-name lenin)
+                             " "
+                             (last-name lenin)
+                             ": "
+                             (employee-email lenin)))))
+         "Vladamir Lenin: lenin@soviet.org"
+         "Dimitriy Ivanovich: ivanovich@soviet.org"
+         "Vladamir Lenin: lenin@soviet.org")
 
-;; tests update-record-from-slot 
-(deftest :oodml/update-records/2
-    (values
-     (employee-email
-      (car (clsql:select 'employee
-                        :where [= [slot-value 'employee 'emplid] 1]
-                        :flatp t)))
-     (progn
-       (setf (slot-value employee1 'email) "lenin-nospam@soviet.org")
-       (clsql:update-record-from-slot employee1 'email)
-       (employee-email
-        (car (clsql:select 'employee
-                          :where [= [slot-value 'employee 'emplid] 1]
-                         :flatp t))))
-     (progn 
-       (setf (slot-value employee1 'email) "lenin@soviet.org")
-       (clsql:update-record-from-slot employee1 'email)
-       (employee-email
-        (car (clsql:select 'employee
-                          :where [= [slot-value 'employee 'emplid] 1]
-                         :flatp t)))))
-  "lenin@soviet.org" "lenin-nospam@soviet.org" "lenin@soviet.org")
+       ;; tests update-record-from-slot 
+       (deftest :oodml/update-records/2
+           (values
+            (employee-email
+             (car (clsql:select 'employee
+                                :where [= [slot-value 'employee 'emplid] 1]
+                                :flatp t)))
+            (progn
+              (setf (slot-value employee1 'email) "lenin-nospam@soviet.org")
+              (clsql:update-record-from-slot employee1 'email)
+              (employee-email
+               (car (clsql:select 'employee
+                                  :where [= [slot-value 'employee 'emplid] 1]
+                                  :flatp t))))
+            (progn 
+              (setf (slot-value employee1 'email) "lenin@soviet.org")
+              (clsql:update-record-from-slot employee1 'email)
+              (employee-email
+               (car (clsql:select 'employee
+                                  :where [= [slot-value 'employee 'emplid] 1]
+                                  :flatp t)))))
+         "lenin@soviet.org" "lenin-nospam@soviet.org" "lenin@soviet.org")
 
-;; tests update-record-from-slots
-(deftest :oodml/update-records/3
-    (values
-     (let ((lenin (car (clsql:select 'employee
-                                    :where [= [slot-value 'employee 'emplid]
-                                              1]
-                                   :flatp t))))
-       (concatenate 'string
-                    (first-name lenin)
-                    " "
-                    (last-name lenin)
-                    ": "
-                    (employee-email lenin)))
-     (progn
-       (setf (slot-value employee1 'first-name) "Dimitriy" 
-             (slot-value employee1 'last-name) "Ivanovich"
-             (slot-value employee1 'email) "ivanovich@soviet.org")
-       (clsql:update-record-from-slots employee1 '(first-name last-name email))
-       (let ((lenin (car (clsql:select 'employee
-                                      :where [= [slot-value 'employee 'emplid]
-                                                1]
-                                     :flatp t))))
-         (concatenate 'string
-                      (first-name lenin)
-                      " "
-                      (last-name lenin)
-                      ": "
-                      (employee-email lenin))))
-     (progn 
-       (setf (slot-value employee1 'first-name) "Vladamir" 
-             (slot-value employee1 'last-name) "Lenin"
-             (slot-value employee1 'email) "lenin@soviet.org")
-       (clsql:update-record-from-slots employee1 '(first-name last-name email))
-       (let ((lenin (car (clsql:select 'employee
-                                      :where [= [slot-value 'employee 'emplid]
-                                                1]
-                                     :flatp t))))
-         (concatenate 'string
-                      (first-name lenin)
-                      " "
-                      (last-name lenin)
-                      ": "
-                      (employee-email lenin)))))
-  "Vladamir Lenin: lenin@soviet.org"
-  "Dimitriy Ivanovich: ivanovich@soviet.org"
-  "Vladamir Lenin: lenin@soviet.org")
+       ;; tests update-record-from-slots
+       (deftest :oodml/update-records/3
+           (values
+            (let ((lenin (car (clsql:select 'employee
+                                            :where [= [slot-value 'employee 'emplid]
+                                                      1]
+                                            :flatp t))))
+              (concatenate 'string
+                           (first-name lenin)
+                           " "
+                           (last-name lenin)
+                           ": "
+                           (employee-email lenin)))
+            (progn
+              (setf (slot-value employee1 'first-name) "Dimitriy" 
+                    (slot-value employee1 'last-name) "Ivanovich"
+                    (slot-value employee1 'email) "ivanovich@soviet.org")
+              (clsql:update-record-from-slots employee1 '(first-name last-name email))
+              (let ((lenin (car (clsql:select 'employee
+                                              :where [= [slot-value 'employee 'emplid]
+                                                        1]
+                                              :flatp t))))
+                (concatenate 'string
+                             (first-name lenin)
+                             " "
+                             (last-name lenin)
+                             ": "
+                             (employee-email lenin))))
+            (progn 
+              (setf (slot-value employee1 'first-name) "Vladamir" 
+                    (slot-value employee1 'last-name) "Lenin"
+                    (slot-value employee1 'email) "lenin@soviet.org")
+              (clsql:update-record-from-slots employee1 '(first-name last-name email))
+              (let ((lenin (car (clsql:select 'employee
+                                              :where [= [slot-value 'employee 'emplid]
+                                                        1]
+                                              :flatp t))))
+                (concatenate 'string
+                             (first-name lenin)
+                             " "
+                             (last-name lenin)
+                             ": "
+                             (employee-email lenin)))))
+         "Vladamir Lenin: lenin@soviet.org"
+         "Dimitriy Ivanovich: ivanovich@soviet.org"
+         "Vladamir Lenin: lenin@soviet.org")
 
-;; tests update-instance-from-records 
-(deftest :oodml/update-instance/1
-    (values
-     (concatenate 'string
-                  (slot-value employee1 'first-name)
-                  " "
-                  (slot-value employee1 'last-name)
-                  ": "
-                  (slot-value employee1 'email))
-     (progn
-       (clsql:update-records [employee] 
-                            :av-pairs '(([first-name] "Ivan")
-                                        ([last-name] "Petrov")
-                                        ([email] "petrov@soviet.org"))
-                            :where [= [emplid] 1])
-       (clsql:update-instance-from-records employee1)
-       (concatenate 'string
-                    (slot-value employee1 'first-name)
-                    " "
-                    (slot-value employee1 'last-name)
-                    ": "
-                    (slot-value employee1 'email)))
-     (progn 
-       (clsql:update-records [employee] 
-                            :av-pairs '(([first-name] "Vladamir")
-                                        ([last-name] "Lenin")
-                                        ([email] "lenin@soviet.org"))
-                            :where [= [emplid] 1])
-       (clsql:update-instance-from-records employee1)
-       (concatenate 'string
-                    (slot-value employee1 'first-name)
-                    " "
-                    (slot-value employee1 'last-name)
-                    ": "
-                    (slot-value employee1 'email))))
-  "Vladamir Lenin: lenin@soviet.org"
-  "Ivan Petrov: petrov@soviet.org"
-  "Vladamir Lenin: lenin@soviet.org")
+       ;; tests update-instance-from-records 
+       (deftest :oodml/update-instance/1
+           (values
+            (concatenate 'string
+                         (slot-value employee1 'first-name)
+                         " "
+                         (slot-value employee1 'last-name)
+                         ": "
+                         (slot-value employee1 'email))
+            (progn
+              (clsql:update-records [employee] 
+                                    :av-pairs '(([first-name] "Ivan")
+                                                ([last-name] "Petrov")
+                                                ([email] "petrov@soviet.org"))
+                                    :where [= [emplid] 1])
+              (clsql:update-instance-from-records employee1)
+              (concatenate 'string
+                           (slot-value employee1 'first-name)
+                           " "
+                           (slot-value employee1 'last-name)
+                           ": "
+                           (slot-value employee1 'email)))
+            (progn 
+              (clsql:update-records [employee] 
+                                    :av-pairs '(([first-name] "Vladamir")
+                                                ([last-name] "Lenin")
+                                                ([email] "lenin@soviet.org"))
+                                    :where [= [emplid] 1])
+              (clsql:update-instance-from-records employee1)
+              (concatenate 'string
+                           (slot-value employee1 'first-name)
+                           " "
+                           (slot-value employee1 'last-name)
+                           ": "
+                           (slot-value employee1 'email))))
+         "Vladamir Lenin: lenin@soviet.org"
+         "Ivan Petrov: petrov@soviet.org"
+         "Vladamir Lenin: lenin@soviet.org")
 
-;; tests update-slot-from-record 
-(deftest :oodml/update-instance/2
-    (values
-     (slot-value employee1 'email)
-     (progn
-       (clsql:update-records [employee] 
-                            :av-pairs '(([email] "lenin-nospam@soviet.org"))
-                            :where [= [emplid] 1])
-       (clsql:update-slot-from-record employee1 'email)
-       (slot-value employee1 'email))
-     (progn 
-       (clsql:update-records [employee] 
-                            :av-pairs '(([email] "lenin@soviet.org"))
-                            :where [= [emplid] 1])
-       (clsql:update-slot-from-record employee1 'email)
-       (slot-value employee1 'email)))
-  "lenin@soviet.org" "lenin-nospam@soviet.org" "lenin@soviet.org")
+       ;; tests update-slot-from-record 
+       (deftest :oodml/update-instance/2
+           (values
+            (slot-value employee1 'email)
+            (progn
+              (clsql:update-records [employee] 
+                                    :av-pairs '(([email] "lenin-nospam@soviet.org"))
+                                    :where [= [emplid] 1])
+              (clsql:update-slot-from-record employee1 'email)
+              (slot-value employee1 'email))
+            (progn 
+              (clsql:update-records [employee] 
+                                    :av-pairs '(([email] "lenin@soviet.org"))
+                                    :where [= [emplid] 1])
+              (clsql:update-slot-from-record employee1 'email)
+              (slot-value employee1 'email)))
+         "lenin@soviet.org" "lenin-nospam@soviet.org" "lenin@soviet.org")
 
 
-(deftest :oodml/do-query/1
-     (let ((result '()))
-       (clsql:do-query ((e) [select 'employee :order-by [emplid]])
-         (push (slot-value e 'last-name) result))
-       result)
-   ("Putin" "Yeltsin" "Gorbachev" "Chernenko" "Andropov" "Brezhnev" "Kruschev"
- "Trotsky" "Stalin" "Lenin"))
+       (deftest :oodml/do-query/1
+           (let ((result '()))
+             (clsql:do-query ((e) [select 'employee :order-by [emplid]])
+               (push (slot-value e 'last-name) result))
+             result)
+         ("Putin" "Yeltsin" "Gorbachev" "Chernenko" "Andropov" "Brezhnev" "Kruschev"
+          "Trotsky" "Stalin" "Lenin"))
 
-(deftest :oodml/do-query/2
-     (let ((result '()))
-       (clsql:do-query ((e c) [select 'employee 'company 
-                                 :where [= [slot-value 'employee 'last-name] 
-                                 "Lenin"]])
-         (push (list (slot-value e 'last-name) (slot-value c 'name))
-              result))
-       result)
- (("Lenin" "Widgets Inc.")))
+       (deftest :oodml/do-query/2
+           (let ((result '()))
+             (clsql:do-query ((e c) [select 'employee 'company 
+                                            :where [= [slot-value 'employee 'last-name] 
+                                                      "Lenin"]])
+               (push (list (slot-value e 'last-name) (slot-value c 'name))
+                     result))
+             result)
+         (("Lenin" "Widgets Inc.")))
 
-(deftest :oodml/map-query/1
-     (clsql:map-query 'list #'last-name [select 'employee :order-by [emplid]])
- ("Lenin" "Stalin" "Trotsky" "Kruschev" "Brezhnev" "Andropov" "Chernenko"
-  "Gorbachev" "Yeltsin" "Putin"))
+       (deftest :oodml/map-query/1
+           (clsql:map-query 'list #'last-name [select 'employee :order-by [emplid]])
+         ("Lenin" "Stalin" "Trotsky" "Kruschev" "Brezhnev" "Andropov" "Chernenko"
+          "Gorbachev" "Yeltsin" "Putin"))
 
-(deftest :oodml/map-query/2 
-     (clsql:map-query 'list #'(lambda (e c) (list (slot-value e 'last-name)
-                                                 (slot-value c 'name)))
-      [select 'employee 'company :where [= [slot-value 'employee 'last-name] 
-                                           "Lenin"]])
- (("Lenin" "Widgets Inc.")))
+       (deftest :oodml/map-query/2 
+           (clsql:map-query 'list #'(lambda (e c) (list (slot-value e 'last-name)
+                                                        (slot-value c 'name)))
+            [select 'employee 'company :where [= [slot-value 'employee 'last-name] 
+                                                 "Lenin"]])
+         (("Lenin" "Widgets Inc.")))
 
-(deftest :oodml/iteration/3
-    (loop for (e) being the records in 
-          [select 'employee :where [< [emplid] 4] :order-by [emplid]]
-       collect (slot-value e 'last-name))
-  ("Lenin" "Stalin" "Trotsky"))
+       (deftest :oodml/iteration/3
+           (loop for (e) being the records in 
+            [select 'employee :where [< [emplid] 4] :order-by [emplid]]
+            collect (slot-value e 'last-name))
+         ("Lenin" "Stalin" "Trotsky"))
 
-))
+       ))
 
 #.(clsql:restore-sql-reader-syntax-state)

diff --git a/tests/test-syntax.lisp b/tests/test-syntax.lisp
index 2329a6c5035a55aa7460b0e2abbabf2d445da784..9de62fe762a9b27adec21395b23091589d2fc73f 100644 (file)
--- a/tests/test-syntax.lisp
+++ b/tests/test-syntax.lisp
@@ -118,13 +118,6 @@
     (clsql:sql [select [count [*]] :from [emp]])
   "SELECT COUNT(*) FROM EMP")
   
-(deftest :syntax/query/5
-    (string-downcase (clsql:sql [select 'employee]))
-  "(employee)")
-
-(deftest :syntax/query/6
-    (string-downcase (clsql:sql [select 'employee 'address]))
-  "(employee address)")
 
 (deftest :syntax/expression1
     (clsql:sql