whitespace-cleanup

diff --git a/tests/test-fdml.lisp b/tests/test-fdml.lisp
index 1737a0150b34b133c735b24bb0e5fd5d15aa8696..d2e70df49c6c4bcdec5d1b7c71ff9930a0b91e01 100644 (file)
--- a/tests/test-fdml.lisp
+++ b/tests/test-fdml.lisp
@@ -27,14 +27,14 @@
 (deftest :fdml/query/1
     (let ((count (caar (clsql:query "SELECT COUNT(*) FROM EMPLOYEE WHERE (EMAIL LIKE '%org')" :field-names nil))))
       (if (stringp count)
 (deftest :fdml/query/1
     (let ((count (caar (clsql:query "SELECT COUNT(*) FROM EMPLOYEE WHERE (EMAIL LIKE '%org')" :field-names nil))))
       (if (stringp count)

-          (nth-value 0 (parse-integer count))
-          (nth-value 0 (truncate count))))
+         (nth-value 0 (parse-integer count))
+         (nth-value 0 (truncate count))))

   10)
 
 (deftest :fdml/query/2
     (multiple-value-bind (rows field-names)
   10)
 
 (deftest :fdml/query/2
     (multiple-value-bind (rows field-names)

-        (clsql:query
-         "SELECT FIRST_NAME,LAST_NAME FROM EMPLOYEE WHERE (EMPLID <= 5) ORDER BY LAST_NAME")
+       (clsql:query
+        "SELECT FIRST_NAME,LAST_NAME FROM EMPLOYEE WHERE (EMPLID <= 5) ORDER BY LAST_NAME")

       (values rows (mapcar 'string-upcase field-names)))
   (("Leonid" "Brezhnev") ("Nikita" "Kruschev") ("Vladimir" "Lenin")
    ("Josef" "Stalin") ("Leon" "Trotsky"))
       (values rows (mapcar 'string-upcase field-names)))
   (("Leonid" "Brezhnev") ("Nikita" "Kruschev") ("Vladimir" "Lenin")
    ("Josef" "Stalin") ("Leon" "Trotsky"))


@@ -51,35 +51,35 @@
 
 (deftest :fdml/query/5
     (let ((res (clsql:query (clsql:sql [select [first-name] [sum [emplid]] :from [employee]]
 
 (deftest :fdml/query/5
     (let ((res (clsql:query (clsql:sql [select [first-name] [sum [emplid]] :from [employee]]

-                                       [group-by [first-name]] [order-by [sum [emplid]]])
-                            :field-names nil :result-types nil)))
+                                      [group-by [first-name]] [order-by [sum [emplid]]])
+                           :field-names nil :result-types nil)))

       (mapcar (lambda (p) (list (car p) (truncate (read-from-string (second p)))))
       (mapcar (lambda (p) (list (car p) (truncate (read-from-string (second p)))))

-              res))
+             res))

   (("Josef" 2) ("Leon" 3) ("Nikita" 4) ("Leonid" 5) ("Yuri" 6)
   ("Konstantin" 7) ("Mikhail" 8) ("Boris" 9) ("Vladimir" 11)))
 
 (deftest :fdml/query/6
     (let ((res (clsql:query (clsql:sql [union [select [emplid] :from [employee]]
   (("Josef" 2) ("Leon" 3) ("Nikita" 4) ("Leonid" 5) ("Yuri" 6)
   ("Konstantin" 7) ("Mikhail" 8) ("Boris" 9) ("Vladimir" 11)))
 
 (deftest :fdml/query/6
     (let ((res (clsql:query (clsql:sql [union [select [emplid] :from [employee]]

-                                       [select [groupid] :from [company]]])
-                            :field-names nil :result-types nil :flatp t)))
+                                      [select [groupid] :from [company]]])
+                           :field-names nil :result-types nil :flatp t)))

       (values (every #'stringp res)
       (values (every #'stringp res)

-              (mapcar #'(lambda (f) (truncate (read-from-string f))) res)))
+             (mapcar #'(lambda (f) (truncate (read-from-string f))) res)))

   t (1 2 3 4 5 6 7 8 9 10))
 
 (deftest :fdml/query/7
     (let ((res (car (clsql:query (clsql:sql [intersect [select [emplid] :from [employee]]
   t (1 2 3 4 5 6 7 8 9 10))
 
 (deftest :fdml/query/7
     (let ((res (car (clsql:query (clsql:sql [intersect [select [emplid] :from [employee]]

-                                            [select [groupid] :from [company]]])
-                                 :field-names nil :result-types nil :flatp t))))
+                                           [select [groupid] :from [company]]])
+                                :field-names nil :result-types nil :flatp t))))

       (values (stringp res)
       (values (stringp res)

-              (nth-value 0 (truncate (read-from-string res)))))
+             (nth-value 0 (truncate (read-from-string res)))))

   t 1)
 
 (deftest :fdml/query/8
     (let ((res (clsql:query (clsql:sql [except [select [emplid] :from [employee]]
   t 1)
 
 (deftest :fdml/query/8
     (let ((res (clsql:query (clsql:sql [except [select [emplid] :from [employee]]

-                                       [select [groupid] :from [company]]])
-                            :field-names nil :result-types nil :flatp t)))
+                                      [select [groupid] :from [company]]])
+                           :field-names nil :result-types nil :flatp t)))

       (values (every #'stringp res)
       (values (every #'stringp res)

-              (mapcar #'(lambda (f) (truncate (read-from-string f))) res)))
+             (mapcar #'(lambda (f) (truncate (read-from-string f))) res)))

   t (2 3 4 5 6 7 8 9 10))
 
 
   t (2 3 4 5 6 7 8 9 10))
 
 


@@ -99,75 +99,75 @@
 ;; these guys!)
 (deftest :fdml/select/1
     (let ((max (clsql:select [function "floor"
 ;; these guys!)
 (deftest :fdml/select/1
     (let ((max (clsql:select [function "floor"

-                             [/ [* [max [height]] 100] 2.54]]
-                             :from [employee]
-                             :result-types nil
-                             :flatp t))
-          (min (clsql:select [function "floor"
-                             [/ [* [min [height]] 100] 2.54]]
-                             :from [employee]
-                             :result-types nil
-                             :flatp t))
-          (avg (clsql:select [function "floor"
-                             [avg [/ [* [height] 100] 2.54]]]
-                             :from [employee]
-                             :result-types nil
-                             :flatp t)))
+                            [/ [* [max [height]] 100] 2.54]]
+                            :from [employee]
+                            :result-types nil
+                            :flatp t))
+         (min (clsql:select [function "floor"
+                            [/ [* [min [height]] 100] 2.54]]
+                            :from [employee]
+                            :result-types nil
+                            :flatp t))
+         (avg (clsql:select [function "floor"
+                            [avg [/ [* [height] 100] 2.54]]]
+                            :from [employee]
+                            :result-types nil
+                            :flatp t)))

       (apply #'< (mapcar #'(lambda (s) (parse-integer s :junk-allowed t))
       (apply #'< (mapcar #'(lambda (s) (parse-integer s :junk-allowed t))

-                         (append min avg max))))
+                        (append min avg max))))

  t)
 
 (deftest :fdml/select/2
  (clsql:select [first-name] :from [employee] :flatp t :distinct t
  t)
 
 (deftest :fdml/select/2
  (clsql:select [first-name] :from [employee] :flatp t :distinct t

-                            :field-names nil
-                            :result-types nil
-                            :order-by [first-name])
+                           :field-names nil
+                           :result-types nil
+                           :order-by [first-name])

  ("Boris" "Josef" "Konstantin" "Leon" "Leonid" "Mikhail" "Nikita" "Vladimir"
   "Yuri"))
 
 (deftest :fdml/select/3
     (let ((res (clsql:select [first-name] [count [*]] :from [employee]
  ("Boris" "Josef" "Konstantin" "Leon" "Leonid" "Mikhail" "Nikita" "Vladimir"
   "Yuri"))
 
 (deftest :fdml/select/3
     (let ((res (clsql:select [first-name] [count [*]] :from [employee]

-                             :result-types nil
-                             :group-by [first-name]
-                             :order-by [first-name]
-                             :field-names nil)))
+                            :result-types nil
+                            :group-by [first-name]
+                            :order-by [first-name]
+                            :field-names nil)))

       (mapcar (lambda (p) (list (car p) (truncate (read-from-string (second p)))))
       (mapcar (lambda (p) (list (car p) (truncate (read-from-string (second p)))))

-              res))
+             res))

   (("Boris" 1) ("Josef" 1) ("Konstantin" 1) ("Leon" 1) ("Leonid" 1)
    ("Mikhail" 1) ("Nikita" 1) ("Vladimir" 2) ("Yuri" 1)))
 
 (deftest :fdml/select/4
     (clsql:select [last-name] :from [employee]
   (("Boris" 1) ("Josef" 1) ("Konstantin" 1) ("Leon" 1) ("Leonid" 1)
    ("Mikhail" 1) ("Nikita" 1) ("Vladimir" 2) ("Yuri" 1)))
 
 (deftest :fdml/select/4
     (clsql:select [last-name] :from [employee]

-                          :where [like [email] "%org"]
-                          :order-by [last-name]
-                          :field-names nil
-                          :result-types nil
-                          :flatp t)
+                         :where [like [email] "%org"]
+                         :order-by [last-name]
+                         :field-names nil
+                         :result-types nil
+                         :flatp t)

  ("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Lenin" "Putin"
   "Stalin" "Trotsky" "Yeltsin"))
 
 (deftest :fdml/select/5
     (clsql:select [email] :from [employee] :flatp t :result-types nil
  ("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Lenin" "Putin"
   "Stalin" "Trotsky" "Yeltsin"))
 
 (deftest :fdml/select/5
     (clsql:select [email] :from [employee] :flatp t :result-types nil

-                          :where [in [employee emplid]
-                          [select [managerid] :from [employee]]]
-                          :field-names nil)
+                         :where [in [employee emplid]
+                         [select [managerid] :from [employee]]]
+                         :field-names nil)

   ("lenin@soviet.org"))
 
 (deftest :fdml/select/6
     (if (clsql-sys:db-type-has-fancy-math? *test-database-underlying-type*)
   ("lenin@soviet.org"))
 
 (deftest :fdml/select/6
     (if (clsql-sys:db-type-has-fancy-math? *test-database-underlying-type*)

-        (mapcar #'(lambda (s) (parse-integer s :junk-allowed t))
-                (clsql:select [function "trunc" [height]] :from [employee]
-                              :result-types nil
-                              :field-names nil
-                              :flatp t))
-        (mapcar #'(lambda (s) (truncate (parse-integer s :junk-allowed t)))
-                (clsql:select [height] :from [employee] :flatp t
-                              :field-names nil :result-types nil)))
+       (mapcar #'(lambda (s) (parse-integer s :junk-allowed t))
+               (clsql:select [function "trunc" [height]] :from [employee]
+                             :result-types nil
+                             :field-names nil
+                             :flatp t))
+       (mapcar #'(lambda (s) (truncate (parse-integer s :junk-allowed t)))
+               (clsql:select [height] :from [employee] :flatp t
+                             :field-names nil :result-types nil)))

  (1 1 1 1 1 1 1 1 1 1))
 
 (deftest :fdml/select/7
     (let ((result (car (clsql:select [max [emplid]] :from [employee] :flatp t
  (1 1 1 1 1 1 1 1 1 1))
 
 (deftest :fdml/select/7
     (let ((result (car (clsql:select [max [emplid]] :from [employee] :flatp t

-                                     :field-names nil :result-types nil))))
+                                    :field-names nil :result-types nil))))

       (values
        (stringp result)
        (nth-value 0 (truncate (read-from-string result)))))
       (values
        (stringp result)
        (nth-value 0 (truncate (read-from-string result)))))


@@ -175,7 +175,7 @@
 
 (deftest :fdml/select/8
     (let ((result (car (clsql:select [min [emplid]] :from [employee] :flatp t
 
 (deftest :fdml/select/8
     (let ((result (car (clsql:select [min [emplid]] :from [employee] :flatp t

-                                     :field-names nil :result-types nil))))
+                                    :field-names nil :result-types nil))))

       (values
        (stringp result)
        (nth-value 0 (truncate (read-from-string result)))))
       (values
        (stringp result)
        (nth-value 0 (truncate (read-from-string result)))))


@@ -185,50 +185,50 @@
     (subseq
      (car
       (clsql:select [avg [emplid]] :from [employee] :flatp t
     (subseq
      (car
       (clsql:select [avg [emplid]] :from [employee] :flatp t

-                    :field-names nil :result-types nil))
+                   :field-names nil :result-types nil))

      0 3)
   "5.5")
 
 (deftest :fdml/select/10
     (clsql:select [last-name] :from [employee]
      0 3)
   "5.5")
 
 (deftest :fdml/select/10
     (clsql:select [last-name] :from [employee]

-                  :where [not [in [emplid]
-                  [select [managerid] :from [company]]]]
-                  :result-types nil
-                  :field-names nil
-                  :flatp t
-                  :order-by [last-name])
+                 :where [not [in [emplid]
+                 [select [managerid] :from [company]]]]
+                 :result-types nil
+                 :field-names nil
+                 :flatp t
+                 :order-by [last-name])

  ("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Putin" "Stalin"
   "Trotsky" "Yeltsin"))
 
 (deftest :fdml/select/11
     (clsql:select [last-name] :from [employee] :where [married] :flatp t
  ("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Putin" "Stalin"
   "Trotsky" "Yeltsin"))
 
 (deftest :fdml/select/11
     (clsql:select [last-name] :from [employee] :where [married] :flatp t

-                  :field-names nil :order-by [emplid] :result-types nil)
+                 :field-names nil :order-by [emplid] :result-types nil)

   ("Lenin" "Stalin" "Trotsky"))
 
 (deftest :fdml/select/12
     (let ((v 1))
       (clsql:select [last-name] :from [employee] :where [= [emplid] v]
   ("Lenin" "Stalin" "Trotsky"))
 
 (deftest :fdml/select/12
     (let ((v 1))
       (clsql:select [last-name] :from [employee] :where [= [emplid] v]

-                    :field-names nil :result-types nil))
+                   :field-names nil :result-types nil))

   (("Lenin")))
 
 (deftest :fdml/select/13
      (multiple-value-bind (results field-names)
   (("Lenin")))
 
 (deftest :fdml/select/13
      (multiple-value-bind (results field-names)

-         (clsql:select [emplid] [last-name] :from [employee]
-                       :where [= [emplid] 1])
+        (clsql:select [emplid] [last-name] :from [employee]
+                      :where [= [emplid] 1])

        (values results (mapcar #'string-downcase field-names)))
  ((1 "Lenin"))
  ("emplid" "last_name"))
 
 (deftest :fdml/select/14
      (floatp (car (clsql:select [height] :from [employee] :where [= [emplid] 1]
        (values results (mapcar #'string-downcase field-names)))
  ((1 "Lenin"))
  ("emplid" "last_name"))
 
 (deftest :fdml/select/14
      (floatp (car (clsql:select [height] :from [employee] :where [= [emplid] 1]

-                                :flatp t)))
+                               :flatp t)))

   t)
 
 (deftest :fdml/select/15
     (multiple-value-bind (rows field-names)
   t)
 
 (deftest :fdml/select/15
     (multiple-value-bind (rows field-names)

-        (clsql:select [addressid] [street-number] [street-name] [city_field] [zip]
-         :from [addr]
-         :where [= 1 [addressid]])
+       (clsql:select [addressid] [street-number] [street-name] [city_field] [zip]
+        :from [addr]
+        :where [= 1 [addressid]])

       (values
        rows
        (mapcar #'string-downcase field-names)))
       (values
        rows
        (mapcar #'string-downcase field-names)))


@@ -252,40 +252,40 @@
 
 (deftest :fdml/select/19
     (clsql:select [emplid] :from [employee] :order-by [emplid]
 
 (deftest :fdml/select/19
     (clsql:select [emplid] :from [employee] :order-by [emplid]

-                           :where [between [* [emplid] 10] [* 5 10] [* 10 10]]
-                           :field-names nil :result-types nil :flatp t)
+                          :where [between [* [emplid] 10] [* 5 10] [* 10 10]]
+                          :field-names nil :result-types nil :flatp t)

  ("5" "6" "7" "8" "9" "10"))
 
 (deftest :fdml/select/20
     (clsql:select [emplid] :from [employee] :order-by [emplid]
  ("5" "6" "7" "8" "9" "10"))
 
 (deftest :fdml/select/20
     (clsql:select [emplid] :from [employee] :order-by [emplid]

-                           :where [not [between [* [emplid] 10] [* 5 10] [* 10 10]]]
-                           :field-names nil :result-types nil :flatp t)
+                          :where [not [between [* [emplid] 10] [* 5 10] [* 10 10]]]
+                          :field-names nil :result-types nil :flatp t)

  ("1" "2" "3" "4"))
 
 (deftest :fdml/select/21
   (clsql:select [substring [first-name] 1 4] :from [employee]
  ("1" "2" "3" "4"))
 
 (deftest :fdml/select/21
   (clsql:select [substring [first-name] 1 4] :from [employee]

-                :flatp t :order-by [emplid] :field-names nil)
+               :flatp t :order-by [emplid] :field-names nil)

  ("Vlad" "Jose" "Leon" "Niki" "Leon" "Yuri" "Kons" "Mikh" "Bori" "Vlad"))
 
 (deftest :fdml/select/22
    (case *test-database-underlying-type*
      (:mssql (clsql:select [+ [first-name] " " [last-name]] :from [employee]
  ("Vlad" "Jose" "Leon" "Niki" "Leon" "Yuri" "Kons" "Mikh" "Bori" "Vlad"))
 
 (deftest :fdml/select/22
    (case *test-database-underlying-type*
      (:mssql (clsql:select [+ [first-name] " " [last-name]] :from [employee]

-                           :flatp t :order-by [emplid] :field-names nil))
+                          :flatp t :order-by [emplid] :field-names nil))

      (t (clsql:select [|| [first-name] " " [last-name]] :from [employee]
      (t (clsql:select [|| [first-name] " " [last-name]] :from [employee]

-                      :flatp t :order-by [emplid] :field-names nil)))
+                     :flatp t :order-by [emplid] :field-names nil)))

  ("Vladimir Lenin" "Josef Stalin" "Leon Trotsky" "Nikita Kruschev"
  "Leonid Brezhnev" "Yuri Andropov" "Konstantin Chernenko" "Mikhail Gorbachev"
  "Boris Yeltsin" "Vladimir Putin"))
 
 (deftest :fdml/select/23
  (clsql:select [emplid] :from [employee] :where [in [emplid] '(1 2 3 4)]
  ("Vladimir Lenin" "Josef Stalin" "Leon Trotsky" "Nikita Kruschev"
  "Leonid Brezhnev" "Yuri Andropov" "Konstantin Chernenko" "Mikhail Gorbachev"
  "Boris Yeltsin" "Vladimir Putin"))
 
 (deftest :fdml/select/23
  (clsql:select [emplid] :from [employee] :where [in [emplid] '(1 2 3 4)]

-                        :flatp t :order-by [emplid] :field-names nil
-                        :result-types nil)
+                       :flatp t :order-by [emplid] :field-names nil
+                       :result-types nil)

  ("1" "2" "3" "4"))
 
 (deftest :fdml/select/24
  (clsql:select [distinct [first-name]] :from [employee] :flatp t
  ("1" "2" "3" "4"))
 
 (deftest :fdml/select/24
  (clsql:select [distinct [first-name]] :from [employee] :flatp t

-               :order-by [first-name] :field-names nil :result-types nil)
+              :order-by [first-name] :field-names nil :result-types nil)

  ("Boris" "Josef" "Konstantin" "Leon" "Leonid" "Mikhail" "Nikita" "Vladimir"
   "Yuri"))
 
  ("Boris" "Josef" "Konstantin" "Leon" "Leonid" "Mikhail" "Nikita" "Vladimir"
   "Yuri"))
 


@@ -302,9 +302,9 @@
  (clsql:select ["table" first-name] ["table" last-name]
   :from '([employee "table"] [employee "join"])
   :where [and [= ["table" first-name]
  (clsql:select ["table" first-name] ["table" last-name]
   :from '([employee "table"] [employee "join"])
   :where [and [= ["table" first-name]

-                 ["join" first-name]]
-              [not [= ["table" emplid]
-                      ["join" emplid]]]]
+                ["join" first-name]]
+             [not [= ["table" emplid]
+                     ["join" emplid]]]]

   :order-by '(["table" last-name])
   :result-types nil :field-names nil)
  (("Vladimir" "Lenin") ("Vladimir" "Putin")))
   :order-by '(["table" last-name])
   :result-types nil :field-names nil)
  (("Vladimir" "Lenin") ("Vladimir" "Putin")))


@@ -313,21 +313,21 @@
     (mapcar
      (lambda (f) (truncate (read-from-string f)))
      (clsql:select [coalesce [managerid] 10] :from [employee] :order-by [emplid]
     (mapcar
      (lambda (f) (truncate (read-from-string f)))
      (clsql:select [coalesce [managerid] 10] :from [employee] :order-by [emplid]

-                   :field-names nil :result-types nil :flatp t))
+                  :field-names nil :result-types nil :flatp t))

   (10 1 1 1 1 1 1 1 1 1))
 
 (deftest :fdml/select/28
     (mapcar
      (lambda (f) (truncate (read-from-string (car f))))
      (loop for column in `([*] [emplid]) collect
   (10 1 1 1 1 1 1 1 1 1))
 
 (deftest :fdml/select/28
     (mapcar
      (lambda (f) (truncate (read-from-string (car f))))
      (loop for column in `([*] [emplid]) collect

-           (clsql:select [count column] :from [employee]
-                         :flatp t :result-types nil :field-names nil)))
+          (clsql:select [count column] :from [employee]
+                        :flatp t :result-types nil :field-names nil)))

  (10 10))
 
 (deftest :fdml/select/29
  (clsql:select [first-name] [last-name] :from [employee]
  (10 10))
 
 (deftest :fdml/select/29
  (clsql:select [first-name] [last-name] :from [employee]

-                       :result-types nil :field-names nil
-                       :order-by '(([first-name] :asc) ([last-name] :desc)))
+                      :result-types nil :field-names nil
+                      :order-by '(([first-name] :asc) ([last-name] :desc)))

  (("Boris" "Yeltsin") ("Josef" "Stalin") ("Konstantin" "Chernenko")
   ("Leon" "Trotsky") ("Leonid" "Brezhnev") ("Mikhail" "Gorbachev")
   ("Nikita" "Kruschev") ("Vladimir" "Putin") ("Vladimir" "Lenin")
  (("Boris" "Yeltsin") ("Josef" "Stalin") ("Konstantin" "Chernenko")
   ("Leon" "Trotsky") ("Leonid" "Brezhnev") ("Mikhail" "Gorbachev")
   ("Nikita" "Kruschev") ("Vladimir" "Putin") ("Vladimir" "Lenin")


@@ -335,8 +335,8 @@
 
 (deftest :fdml/select/30
  (clsql:select [first-name] [last-name] :from [employee]
 
 (deftest :fdml/select/30
  (clsql:select [first-name] [last-name] :from [employee]

-                       :result-types nil :field-names nil
-                       :order-by '(([first-name] :asc) ([last-name] :asc)))
+                      :result-types nil :field-names nil
+                      :order-by '(([first-name] :asc) ([last-name] :asc)))

  (("Boris" "Yeltsin") ("Josef" "Stalin") ("Konstantin" "Chernenko")
   ("Leon" "Trotsky") ("Leonid" "Brezhnev") ("Mikhail" "Gorbachev")
   ("Nikita" "Kruschev") ("Vladimir" "Lenin") ("Vladimir" "Putin")
  (("Boris" "Yeltsin") ("Josef" "Stalin") ("Konstantin" "Chernenko")
   ("Leon" "Trotsky") ("Leonid" "Brezhnev") ("Mikhail" "Gorbachev")
   ("Nikita" "Kruschev") ("Vladimir" "Lenin") ("Vladimir" "Putin")


@@ -344,26 +344,26 @@
 
 (deftest :fdml/select/31
  (clsql:select [last-name] :from [employee]
 
 (deftest :fdml/select/31
  (clsql:select [last-name] :from [employee]

-              :set-operation [union [select [first-name] :from [employee]
-                                            :order-by [last-name]]]
-              :flatp t
-              :result-types nil
-              :field-names nil)
+             :set-operation [union [select [first-name] :from [employee]
+                                           :order-by [last-name]]]
+             :flatp t
+             :result-types nil
+             :field-names nil)

  ("Andropov" "Boris" "Brezhnev" "Chernenko" "Gorbachev" "Josef" "Konstantin"
  "Kruschev" "Lenin" "Leon" "Leonid" "Mikhail" "Nikita" "Putin" "Stalin"
  "Trotsky" "Vladimir" "Yeltsin" "Yuri"))
 
 (deftest :fdml/select/32
     (clsql:select [emplid] :from [employee]
  ("Andropov" "Boris" "Brezhnev" "Chernenko" "Gorbachev" "Josef" "Konstantin"
  "Kruschev" "Lenin" "Leon" "Leonid" "Mikhail" "Nikita" "Putin" "Stalin"
  "Trotsky" "Vladimir" "Yeltsin" "Yuri"))
 
 (deftest :fdml/select/32
     (clsql:select [emplid] :from [employee]

-                :where [= [emplid] [any [select [companyid] :from [company]]]]
-                :flatp t :result-types nil :field-names nil)
+               :where [= [emplid] [any [select [companyid] :from [company]]]]
+               :flatp t :result-types nil :field-names nil)

   ("1"))
 
 (deftest :fdml/select/33
  (clsql:select [last-name] :from [employee]
   ("1"))
 
 (deftest :fdml/select/33
  (clsql:select [last-name] :from [employee]

-              :where [> [emplid] [all [select [groupid] :from [employee]]]]
-              :order-by [last-name]
-              :flatp t :result-types nil :field-names nil)
+             :where [> [emplid] [all [select [groupid] :from [employee]]]]
+             :order-by [last-name]
+             :flatp t :result-types nil :field-names nil)

 ("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Putin" "Stalin"
  "Trotsky" "Yeltsin"))
 
 ("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Putin" "Stalin"
  "Trotsky" "Yeltsin"))
 


@@ -372,8 +372,8 @@
    collect
    (car
     (clsql:select [last-name] :from [employee]
    collect
    (car
     (clsql:select [last-name] :from [employee]

-                  :where [= [emplid] x]
-                  :flatp t :result-types nil :field-names nil)))
+                 :where [= [emplid] x]
+                 :flatp t :result-types nil :field-names nil)))

   ("Lenin" "Stalin" "Trotsky" "Kruschev"))
 
 ;; test escaping of single quotes
   ("Lenin" "Stalin" "Trotsky" "Kruschev"))
 
 ;; test escaping of single quotes


@@ -392,54 +392,54 @@
 
 (deftest :fdml/select/37
     (clsql:select [emplid] :from [employee]
 
 (deftest :fdml/select/37
     (clsql:select [emplid] :from [employee]

-                  :order-by [emplid]
-                  :limit 5
-                  :field-names nil
-                  :flatp t)
+                 :order-by [emplid]
+                 :limit 5
+                 :field-names nil
+                 :flatp t)

   (1 2 3 4 5))
 
 (deftest :fdml/select/38
     (clsql:select [emplid] :from [employee]
   (1 2 3 4 5))
 
 (deftest :fdml/select/38
     (clsql:select [emplid] :from [employee]

-                  :order-by [emplid]
-                  :limit 5
-                  :offset 3
-                  :field-names nil
-                  :flatp t)
+                 :order-by [emplid]
+                 :limit 5
+                 :offset 3
+                 :field-names nil
+                 :flatp t)

   (4 5 6 7 8))
 
 (deftest :fdml/do-query/1
     (let ((result '()))
     (clsql:do-query ((name) [select [last-name] :from [employee]
   (4 5 6 7 8))
 
 (deftest :fdml/do-query/1
     (let ((result '()))
     (clsql:do-query ((name) [select [last-name] :from [employee]

-                                   :order-by [last-name]])
+                                  :order-by [last-name]])

       (push name result))
     result)
  ("Yeltsin" "Trotsky" "Stalin" "Putin" "Lenin" "Kruschev" "Gorbachev"
       (push name result))
     result)
  ("Yeltsin" "Trotsky" "Stalin" "Putin" "Lenin" "Kruschev" "Gorbachev"

-            "Chernenko" "Brezhnev" "Andropov"))
+           "Chernenko" "Brezhnev" "Andropov"))

 
 (deftest :fdml/map-query/1
     (clsql:map-query 'list #'identity
 
 (deftest :fdml/map-query/1
     (clsql:map-query 'list #'identity

-                    [select [last-name] :from [employee] :flatp t
-                            :order-by [last-name]])
+                   [select [last-name] :from [employee] :flatp t
+                           :order-by [last-name]])

   ("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Lenin" "Putin"
   ("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Lenin" "Putin"

-              "Stalin" "Trotsky" "Yeltsin"))
+             "Stalin" "Trotsky" "Yeltsin"))

 
 (deftest :fdml/map-query/2
     (clsql:map-query 'vector #'identity
 
 (deftest :fdml/map-query/2
     (clsql:map-query 'vector #'identity

-                    [select [last-name] :from [employee] :flatp t
-                            :order-by [last-name]])
+                   [select [last-name] :from [employee] :flatp t
+                           :order-by [last-name]])

   #("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Lenin" "Putin"
     "Stalin" "Trotsky" "Yeltsin"))
 
 (deftest :fdml/map-query/3
  (clsql:map-query 'list #'identity
   #("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Lenin" "Putin"
     "Stalin" "Trotsky" "Yeltsin"))
 
 (deftest :fdml/map-query/3
  (clsql:map-query 'list #'identity

-                  [select [last-name] :from [employee] :order-by [last-name]])
+                 [select [last-name] :from [employee] :order-by [last-name]])

  (("Andropov") ("Brezhnev") ("Chernenko") ("Gorbachev") ("Kruschev") ("Lenin")
   ("Putin") ("Stalin") ("Trotsky") ("Yeltsin")))
 
 (deftest :fdml/map-query/4
  (clsql:map-query 'list #'identity
  (("Andropov") ("Brezhnev") ("Chernenko") ("Gorbachev") ("Kruschev") ("Lenin")
   ("Putin") ("Stalin") ("Trotsky") ("Yeltsin")))
 
 (deftest :fdml/map-query/4
  (clsql:map-query 'list #'identity

-                  [select [first-name] [last-name] :from [employee]
-                          :order-by [last-name]])
+                 [select [first-name] [last-name] :from [employee]
+                         :order-by [last-name]])

  (("Yuri" "Andropov") ("Leonid" "Brezhnev") ("Konstantin" "Chernenko")
   ("Mikhail" "Gorbachev") ("Nikita" "Kruschev") ("Vladimir" "Lenin")
   ("Vladimir" "Putin") ("Josef" "Stalin") ("Leon" "Trotsky")
  (("Yuri" "Andropov") ("Leonid" "Brezhnev") ("Konstantin" "Chernenko")
   ("Mikhail" "Gorbachev") ("Nikita" "Kruschev") ("Vladimir" "Lenin")
   ("Vladimir" "Putin") ("Josef" "Stalin") ("Leon" "Trotsky")


@@ -451,7 +451,7 @@
       [select [first-name] [last-name] :from [employee] :order-by [last-name]]
       collect (concatenate 'string forename " " surname))
   ("Yuri Andropov" "Leonid Brezhnev" "Konstantin Chernenko" "Mikhail Gorbachev"
       [select [first-name] [last-name] :from [employee] :order-by [last-name]]
       collect (concatenate 'string forename " " surname))
   ("Yuri Andropov" "Leonid Brezhnev" "Konstantin Chernenko" "Mikhail Gorbachev"

-                   "Nikita Kruschev" "Vladimir Lenin" "Vladimir Putin"
+                  "Nikita Kruschev" "Vladimir Lenin" "Vladimir Putin"

    "Josef Stalin" "Leon Trotsky" "Boris Yeltsin"))
 
 (deftest :fdml/loop/2
    "Josef Stalin" "Leon Trotsky" "Boris Yeltsin"))
 
 (deftest :fdml/loop/2


@@ -473,81 +473,81 @@
     (let ((now (get-universal-time)))
       (clsql:insert-records :into [employee]
        :values `(11 1 "Yuri" "Gagarin" "gagarin@soviet.org"
     (let ((now (get-universal-time)))
       (clsql:insert-records :into [employee]
        :values `(11 1 "Yuri" "Gagarin" "gagarin@soviet.org"

-                    1 1 1.85 t ,(clsql:utime->time now) ,now))
+                   1 1 1.85 t ,(clsql:utime->time now) ,now))

       (values
        (clsql:select [first-name] [last-name] [email]
       (values
        (clsql:select [first-name] [last-name] [email]

-                    :from [employee] :where [= [emplid] 11])
+                   :from [employee] :where [= [emplid] 11])

        (progn (clsql:delete-records :from [employee] :where [= [emplid] 11])
        (progn (clsql:delete-records :from [employee] :where [= [emplid] 11])

-              (clsql:select [*] :from [employee] :where [= [emplid] 11]))))
+             (clsql:select [*] :from [employee] :where [= [emplid] 11]))))

   (("Yuri" "Gagarin" "gagarin@soviet.org")) nil)
 
 ;; inserts a record using attributes and values and then deletes it
 (deftest :fdml/insert/2
     (progn
       (clsql:insert-records :into [employee]
   (("Yuri" "Gagarin" "gagarin@soviet.org")) nil)
 
 ;; inserts a record using attributes and values and then deletes it
 (deftest :fdml/insert/2
     (progn
       (clsql:insert-records :into [employee]

-                           :attributes '(emplid groupid first_name last_name
-                                         email ecompanyid managerid)
-                           :values '(11 1 "Yuri" "Gagarin" "gagarin@soviet.org"
-                                     1 1))
+                          :attributes '(emplid groupid first_name last_name
+                                        email ecompanyid managerid)
+                          :values '(11 1 "Yuri" "Gagarin" "gagarin@soviet.org"
+                                    1 1))

       (values
        (clsql:select [first-name] [last-name] [email] :from [employee]
       (values
        (clsql:select [first-name] [last-name] [email] :from [employee]

-                    :where [= [emplid] 11])
+                   :where [= [emplid] 11])

        (progn (clsql:delete-records :from [employee] :where [= [emplid] 11])
        (progn (clsql:delete-records :from [employee] :where [= [emplid] 11])

-              (clsql:select [*] :from [employee] :where [= [emplid] 11]))))
+             (clsql:select [*] :from [employee] :where [= [emplid] 11]))))

   (("Yuri" "Gagarin" "gagarin@soviet.org")) nil)
 
 ;; inserts a record using av-pairs and then deletes it
 (deftest :fdml/insert/3
     (progn
       (clsql:insert-records :into [employee]
   (("Yuri" "Gagarin" "gagarin@soviet.org")) nil)
 
 ;; inserts a record using av-pairs and then deletes it
 (deftest :fdml/insert/3
     (progn
       (clsql:insert-records :into [employee]

-                           :av-pairs'((emplid 11) (groupid 1)
-                                      (first_name "Yuri")
-                                      (last_name "Gagarin")
-                                      (email "gagarin@soviet.org")
-                                      (ecompanyid 1) (managerid 1)))
+                          :av-pairs'((emplid 11) (groupid 1)
+                                     (first_name "Yuri")
+                                     (last_name "Gagarin")
+                                     (email "gagarin@soviet.org")
+                                     (ecompanyid 1) (managerid 1)))

       (values
        (clsql:select [first-name] [last-name] [email] :from [employee]
       (values
        (clsql:select [first-name] [last-name] [email] :from [employee]

-                    :where [= [emplid] 11])
+                   :where [= [emplid] 11])

        (progn (clsql:delete-records :from [employee] :where [= [emplid] 11])
        (progn (clsql:delete-records :from [employee] :where [= [emplid] 11])

-              (clsql:select [first-name] [last-name] [email] :from [employee]
-                           :where [= [emplid] 11]))))
+             (clsql:select [first-name] [last-name] [email] :from [employee]
+                          :where [= [emplid] 11]))))

   (("Yuri" "Gagarin" "gagarin@soviet.org")) nil)
 
 ;; inserts a records using a query from another table
 (deftest :fdml/insert/4
     (progn
       (clsql:create-table [employee2] '(([forename] string)
   (("Yuri" "Gagarin" "gagarin@soviet.org")) nil)
 
 ;; inserts a records using a query from another table
 (deftest :fdml/insert/4
     (progn
       (clsql:create-table [employee2] '(([forename] string)

-                                 ([surname] string)
-                                 ([email] string)))
+                                ([surname] string)
+                                ([email] string)))

       (clsql:insert-records :into [employee2]
       (clsql:insert-records :into [employee2]

-                     :query [select [first-name] [last-name] [email]
-                                    :from [employee]]
-                     :attributes '(forename surname email))
+                    :query [select [first-name] [last-name] [email]
+                                   :from [employee]]
+                    :attributes '(forename surname email))

       (prog1
       (prog1

-          (equal (clsql:select [*] :from [employee2])
-                 (clsql:select [first-name] [last-name] [email]
-                              :from [employee]))
-        (clsql:drop-table [employee2] :if-does-not-exist :ignore)))
+         (equal (clsql:select [*] :from [employee2])
+                (clsql:select [first-name] [last-name] [email]
+                             :from [employee]))
+       (clsql:drop-table [employee2] :if-does-not-exist :ignore)))

   t)
 
 ;; updates a record using attributes and values and then deletes it
 (deftest :fdml/update/1
     (progn
       (clsql:update-records [employee]
   t)
 
 ;; updates a record using attributes and values and then deletes it
 (deftest :fdml/update/1
     (progn
       (clsql:update-records [employee]

-                           :attributes '(first_name last_name email)
-                           :values '("Yuri" "Gagarin" "gagarin@soviet.org")
-                           :where [= [emplid] 1])
+                          :attributes '(first_name last_name email)
+                          :values '("Yuri" "Gagarin" "gagarin@soviet.org")
+                          :where [= [emplid] 1])

       (values
        (clsql:select [first-name] [last-name] [email] :from [employee]
       (values
        (clsql:select [first-name] [last-name] [email] :from [employee]

-                    :where [= [emplid] 1])
+                   :where [= [emplid] 1])

        (progn
        (progn

-         (clsql:update-records [employee]
-                              :av-pairs'((first_name "Vladimir")
-                                         (last_name "Lenin")
-                                         (email "lenin@soviet.org"))
-                              :where [= [emplid] 1])
-         (clsql:select [first-name] [last-name] [email] :from [employee]
-                      :where [= [emplid] 1]))))
+        (clsql:update-records [employee]
+                             :av-pairs'((first_name "Vladimir")
+                                        (last_name "Lenin")
+                                        (email "lenin@soviet.org"))
+                             :where [= [emplid] 1])
+        (clsql:select [first-name] [last-name] [email] :from [employee]
+                     :where [= [emplid] 1]))))

   (("Yuri" "Gagarin" "gagarin@soviet.org"))
   (("Vladimir" "Lenin" "lenin@soviet.org")))
 
   (("Yuri" "Gagarin" "gagarin@soviet.org"))
   (("Vladimir" "Lenin" "lenin@soviet.org")))
 


@@ -555,21 +555,21 @@
 (deftest :fdml/update/2
     (progn
       (clsql:update-records [employee]
 (deftest :fdml/update/2
     (progn
       (clsql:update-records [employee]

-                           :av-pairs'((first_name "Yuri")
-                                      (last_name "Gagarin")
-                                      (email "gagarin@soviet.org"))
-                           :where [= [emplid] 1])
+                          :av-pairs'((first_name "Yuri")
+                                     (last_name "Gagarin")
+                                     (email "gagarin@soviet.org"))
+                          :where [= [emplid] 1])

       (values
        (clsql:select [first-name] [last-name] [email] :from [employee]
       (values
        (clsql:select [first-name] [last-name] [email] :from [employee]

-                    :where [= [emplid] 1])
+                   :where [= [emplid] 1])

        (progn
        (progn

-         (clsql:update-records [employee]
-                              :av-pairs'((first_name "Vladimir")
-                                         (last_name "Lenin")
-                                         (email "lenin@soviet.org"))
-                              :where [= [emplid] 1])
-         (clsql:select [first-name] [last-name] [email]
-                      :from [employee] :where [= [emplid] 1]))))
+        (clsql:update-records [employee]
+                             :av-pairs'((first_name "Vladimir")
+                                        (last_name "Lenin")
+                                        (email "lenin@soviet.org"))
+                             :where [= [emplid] 1])
+        (clsql:select [first-name] [last-name] [email]
+                     :from [employee] :where [= [emplid] 1]))))

   (("Yuri" "Gagarin" "gagarin@soviet.org"))
   (("Vladimir" "Lenin" "lenin@soviet.org")))
 
   (("Yuri" "Gagarin" "gagarin@soviet.org"))
   (("Vladimir" "Lenin" "lenin@soviet.org")))
 


@@ -596,8 +596,8 @@
       (push (clsql:in-transaction-p) results)
       ;; Check that we got him back alright
       (push (clsql:select [email] :from [employee] :where [= [last-name] "Putin"]
       (push (clsql:in-transaction-p) results)
       ;; Check that we got him back alright
       (push (clsql:select [email] :from [employee] :where [= [last-name] "Putin"]

-                         :flatp t)
-            results)
+                        :flatp t)
+           results)

       (apply #'values (nreverse results)))
   nil t nil nil ("putin@soviet.org"))
 
       (apply #'values (nreverse results)))
   nil t nil nil ("putin@soviet.org"))
 


@@ -616,17 +616,17 @@
        :where [= [last-name] "Putin"])
       ;;Should be new value
       (push (clsql:select [email] :from [employee]
        :where [= [last-name] "Putin"])
       ;;Should be new value
       (push (clsql:select [email] :from [employee]

-                         :where [= [last-name] "Putin"]
-                         :flatp t)
-            results)
+                        :where [= [last-name] "Putin"]
+                        :flatp t)
+           results)

       ;;Oh no, he's still there
       (clsql:rollback)
       ;; test that we are out of the transaction
       (push (clsql:in-transaction-p) results)
       ;; Check that we got him back alright
       (push (clsql:select [email] :from [employee] :where [= [last-name] "Putin"]
       ;;Oh no, he's still there
       (clsql:rollback)
       ;; test that we are out of the transaction
       (push (clsql:in-transaction-p) results)
       ;; Check that we got him back alright
       (push (clsql:select [email] :from [employee] :where [= [last-name] "Putin"]

-                         :flatp t)
-            results)
+                        :flatp t)
+           results)

       (apply #'values (nreverse results)))
   nil t ("putin-nospam@soviet.org") nil ("putin@soviet.org"))
 
       (apply #'values (nreverse results)))
   nil t ("putin-nospam@soviet.org") nil ("putin@soviet.org"))
 


@@ -638,29 +638,29 @@
       ;; update records
       (push
        (clsql:with-transaction ()
       ;; update records
       (push
        (clsql:with-transaction ()

-         (clsql:update-records [employee]
-                              :av-pairs '((email "lenin-nospam@soviet.org"))
-                              :where [= [emplid] 1]))
+        (clsql:update-records [employee]
+                             :av-pairs '((email "lenin-nospam@soviet.org"))
+                             :where [= [emplid] 1]))

        results)
       ;; check status
       (push (clsql:in-transaction-p) results)
       ;; check that was committed
       (push (clsql:select [email] :from [employee] :where [= [emplid] 1]
        results)
       ;; check status
       (push (clsql:in-transaction-p) results)
       ;; check that was committed
       (push (clsql:select [email] :from [employee] :where [= [emplid] 1]

-                         :flatp t)
-            results)
+                        :flatp t)
+           results)

       ;; undo the changes
       (push
        (clsql:with-transaction ()
       ;; undo the changes
       (push
        (clsql:with-transaction ()

-         (clsql:update-records [employee]
-                              :av-pairs '((email "lenin@soviet.org"))
-                              :where [= [emplid] 1]))
+        (clsql:update-records [employee]
+                             :av-pairs '((email "lenin@soviet.org"))
+                             :where [= [emplid] 1]))

        results)
       ;; and check status
       (push (clsql:in-transaction-p) results)
       ;; check that was committed
       (push (clsql:select [email] :from [employee] :where [= [emplid] 1]
        results)
       ;; and check status
       (push (clsql:in-transaction-p) results)
       ;; check that was committed
       (push (clsql:select [email] :from [employee] :where [= [emplid] 1]

-                         :flatp t)
-            results)
+                        :flatp t)
+           results)

       (apply #'values (nreverse results)))
   nil nil nil ("lenin-nospam@soviet.org") nil nil ("lenin@soviet.org"))
 
       (apply #'values (nreverse results)))
   nil nil nil ("lenin-nospam@soviet.org") nil nil ("lenin@soviet.org"))
 


@@ -671,25 +671,25 @@
       ;; check status
       (push (clsql:in-transaction-p) results)
       (handler-case
       ;; check status
       (push (clsql:in-transaction-p) results)
       (handler-case

-          (clsql:with-transaction ()
-            ;; valid update
-            (clsql:update-records [employee]
-                                  :av-pairs '((email "lenin-nospam@soviet.org"))
-                                  :where [= [emplid] 1])
-            ;; invalid update which generates an error
-            (clsql:update-records [employee]
-                                  :av-pairs
-                                  '((emale "lenin-nospam@soviet.org"))
-                                  :where [= [emplid] 1]))
-        (clsql:sql-database-error ()
-          (progn
-            ;; check status
-            (push (clsql:in-transaction-p) results)
-            ;; and check nothing done
-            (push (clsql:select [email] :from [employee] :where [= [emplid] 1]
-                               :flatp t)
-                  results)
-            (apply #'values (nreverse results))))))
+         (clsql:with-transaction ()
+           ;; valid update
+           (clsql:update-records [employee]
+                                 :av-pairs '((email "lenin-nospam@soviet.org"))
+                                 :where [= [emplid] 1])
+           ;; invalid update which generates an error
+           (clsql:update-records [employee]
+                                 :av-pairs
+                                 '((emale "lenin-nospam@soviet.org"))
+                                 :where [= [emplid] 1]))
+       (clsql:sql-database-error ()
+         (progn
+           ;; check status
+           (push (clsql:in-transaction-p) results)
+           ;; and check nothing done
+           (push (clsql:select [email] :from [employee] :where [= [emplid] 1]
+                              :flatp t)
+                 results)
+           (apply #'values (nreverse results))))))

   nil nil ("lenin@soviet.org"))
 
 
   nil nil ("lenin@soviet.org"))