X-Git-Url: http://git.kpe.io/?p=clsql.git;a=blobdiff_plain;f=tests%2Ftest-syntax.lisp;h=01a76123d413021926d6e4cd199b56ef6fb0e765;hp=c0939aca3fefdfc64f344f73532a6d191e47ae8a;hb=b50166ae0ba2bc09a9094c0e675ec92010b7293e;hpb=5a6f424f3c8920f8f11bbf1e3aed6b4c2c7e6af8

diff --git a/tests/test-syntax.lisp b/tests/test-syntax.lisp
index c0939ac..01a7612 100644
--- a/tests/test-syntax.lisp
+++ b/tests/test-syntax.lisp
@@ -1,22 +1,24 @@
 ;;;; -*- Mode: LISP; Syntax: ANSI-Common-Lisp; Base: 10 -*-
-;;;; ======================================================================
-;;;; File:    test-syntax.lisp
-;;;; Author:  Marcus Pearce <m.t.pearce@city.ac.uk>
-;;;; Created: 30/03/2004
-;;;; Updated: $Id: $
-;;;; ======================================================================
+;;;; *************************************************************************
+;;;; FILE IDENTIFICATION
 ;;;;
-;;;; Description ==========================================================
-;;;; ======================================================================
+;;;; Name:     clsql.asd
+;;;; Purpose:  Tests for the CLSQL Symbolic SQL syntax.
+;;;; Authors:  Marcus Pearce and Kevin M. Rosenberg
+;;;; Created:  March 2004
 ;;;;
-;;;; Tests for the CLSQL Symbolic SQL syntax. 
-;;;;
-;;;; ======================================================================
+;;;; CLSQL users are granted the rights to distribute and use this software
+;;;; as governed by the terms of the Lisp Lesser GNU Public License
+;;;; (http://opensource.franz.com/preamble.html), also known as the LLGPL.
+;;;; *************************************************************************
 
 (in-package #:clsql-tests)
 
-#.(clsql:locally-enable-sql-reader-syntax)
+(clsql-sys:file-enable-sql-reader-syntax)
+
 
+(setq *rt-syntax*
+      '(
 
 (deftest :syntax/generic/1
     (clsql:sql "foo")
@@ -38,6 +40,9 @@
     (clsql:sql ["SELECT FOO,BAR FROM BAZ"])
   "SELECT FOO,BAR FROM BAZ")
 
+(deftest :syntax/generic/6
+    (clsql:sql "What's up Doc?")
+  "'What''s up Doc?'")
 
 (deftest :syntax/ident/1
     (clsql:sql [foo])
@@ -47,36 +52,156 @@
     (clsql:sql [foo bar])
   "FOO.BAR")
 
-;; not sure about this one 
 (deftest :syntax/ident/3
-    (clsql:sql ["foo" bar])
-  "foo.BAR")
+    (clsql:sql [foo :integer])
+  "FOO")
 
-;(deftest :syntax/ident/4
-;    (clsql:sql [foo "bar"])
-;  "FOO \"bar\"")
+(deftest :syntax/ident/4
+    (clsql:sql [foo bar :integer])
+  "FOO.BAR")
 
 (deftest :syntax/ident/5
-    (clsql:sql [foo :integer])
-  "FOO INTEGER")
+    (clsql:sql [foo "bar"])
+    "FOO \"bar\"")
 
 (deftest :syntax/ident/6
-    (clsql:sql [foo bar :integer])
-  "FOO.BAR INTEGER")
+    (clsql:sql ["foo" bar])
+ "\"foo\".BAR")
 
-;; not sure about this one 
 (deftest :syntax/ident/7
     (clsql:sql ["foo" bar :integer])
-  "foo.BAR INTEGER")
+ "\"foo\".BAR")
+
+
+(deftest :syntax/attribute/1
+    (clsql:sql (clsql:sql-expression :table 'foo :attribute 'bar))
+  "FOO.BAR")
+
+(deftest :syntax/attribute/2
+    (clsql:sql (clsql:sql-expression :table 'foo :attribute "bar"))
+  "FOO.\"bar\"")
+
+(deftest :syntax/attribute/3
+    (clsql:sql (clsql:sql-expression :table "foo" :attribute 'bar))
+  "\"foo\".BAR")
 
+(deftest :syntax/attribute/4
+    (clsql:sql (clsql:sql-expression :table "foo" :attribute "bar"))
+  "\"foo\".\"bar\"")
 
-(deftest :syntax/value/1
+
+(deftest :syntax/subquery/1
     (clsql:sql [any '(3 4)])
-  "(ANY ((3,4)))")
+ "ANY((3,4))")
+
+(deftest :syntax/subquery/2
+    (clsql:sql [in [foo] '(foo bar baz)])
+  "(FOO IN (FOO,BAR,BAZ))")
+
+(deftest :syntax/subquery/3
+    (clsql:sql [all '(foo bar baz)])
+  "ALL((FOO,BAR,BAZ))")
+
+(deftest :syntax/subquery/4
+    (clsql:sql [exists '(foo bar baz)])
+  "EXISTS((FOO,BAR,BAZ))")
+
+(deftest :syntax/subquery/5
+    (clsql:sql [some '(foo bar baz)])
+  "SOME((FOO,BAR,BAZ))")
+
+
+(deftest :syntax/aggregate/1
+    (clsql:sql [max [+ [foo] [* 1000 [bar]]]])
+ "MAX((FOO + (1000 * BAR)))")
+
+(deftest :syntax/aggregate/2
+    (clsql:sql [avg [+ [foo] [* 1000 [bar]]]])
+ "AVG((FOO + (1000 * BAR)))")
+
+(deftest :syntax/aggregate/3
+    (clsql:sql [min [+ [foo] [* 1000 [bar]]]])
+ "MIN((FOO + (1000 * BAR)))")
+
+(deftest :syntax/aggregate/4
+    (clsql:sql [sum [foo] [bar]])
+ "SUM(FOO,BAR)")
+
+(deftest :syntax/aggregate/5
+    (clsql:sql [count [foo]])
+ "COUNT(FOO)")
+
+
+(deftest :syntax/logical/1
+    (values (clsql:sql [and [foo] [bar]])
+	    (clsql:sql [or [foo] [bar]]))
+  "(FOO AND BAR)"
+  "(FOO OR BAR)")
+
+(deftest :syntax/logical/2
+    (clsql:sql [not [foo]])
+  "(NOT (FOO))")
+
+;;; Test how we apply logical operators when we have different numbers of children
+;;; This is useful if we wish to (apply #'sql-and some-list) without having to do
+;;; alot of length checking
+(deftest :syntax/logical/3
+    (values (clsql:sql [and ])
+	    (clsql:sql [and [foo]])
+	    (clsql:sql [and [not [foo]]])
+	    (clsql:sql [and [foo] [bar] [baz]]))
+  ""
+  "FOO"
+  "(NOT (FOO))"
+  "(FOO AND BAR AND BAZ)")
+
+(deftest :syntax/logical/4
+    (clsql:sql [and [= [foo] [bar]]])
+  "(FOO = BAR)")
+
+(deftest :syntax/logical/5
+  (clsql:sql [and [= [foo] [bar]]
+		  [= [bar] [bast]]
+		  [= [block] [blech]]])
+  "((FOO = BAR) AND (BAR = BAST) AND (BLOCK = BLECH))")
+
+(deftest :syntax/logical/6
+    (clsql:sql
+     (apply #'sql-and
+	    (list [= [foo] [bar]]
+		  [and ]
+		  [and [= [bar] [bast]]])))
+  "((FOO = BAR) AND (BAR = BAST))")
+
+
+(deftest :syntax/null/1
+    (clsql:sql [null [foo]])
+  "(FOO IS NULL)")
+
+(deftest :syntax/null/2
+    (clsql:sql [not [null [foo]]])
+  "(NOT ((FOO IS NULL)))")
+
+(deftest :syntax/null/3
+    (clsql:sql [null])
+  "NULL")
+
+(deftest :syntax/null/4
+    (clsql:sql [not [null]])
+  "(NOT (NULL))")
+
+(deftest :syntax/null/5
+    (clsql:sql [is [foo.bar] [null]])
+  "(FOO.BAR IS NULL)")
+
+(deftest :syntax/null/6
+    (clsql:sql [is [foo.bar] [not-null]])
+  "(FOO.BAR IS NOT NULL)")
+
+(deftest :syntax/null/7
+    (clsql:sql [not-null [foo.bar]])
+  "(FOO.BAR IS NOT NULL)")
 
-(deftest :syntax/value/2
-    (clsql:sql [* 2 3])
-  "(2 * 3)")
 
 
 (deftest :syntax/relational/1
@@ -88,6 +213,140 @@
       (clsql:sql [> [foo] x]))
   "(FOO > 10)")
 
+(deftest :syntax/relational/3
+    (clsql:sql [>= [baz] [beep]])
+  "(BAZ >= BEEP)")
+
+(deftest :syntax/relational/4
+    (clsql:sql [< [baz] [beep]])
+  "(BAZ < BEEP)")
+
+(deftest :syntax/relational/5
+    (clsql:sql [= [baz] [beep]])
+  "(BAZ = BEEP)")
+
+(deftest :syntax/relational/6
+    (clsql:sql [<> [baz] [beep]])
+  "(BAZ <> BEEP)")
+
+
+(deftest :syntax/between/1
+    (clsql:sql [between [- [foo] 1] [* [bar] 5] [/ [baz] 9]])
+  "(FOO - 1) BETWEEN (BAR * 5) AND (BAZ / 9)")
+
+(deftest :syntax/between/2
+    (clsql:sql [not [between [- [foo] 1] [* [bar] 5] [/ [baz] 9]]])
+  "(NOT ((FOO - 1) BETWEEN (BAR * 5) AND (BAZ / 9)))")
+
+
+(deftest :syntax/arithmetic/1
+    (clsql:sql [+ [foo bar] [baz]])
+ "(FOO.BAR + BAZ)")
+
+(deftest :syntax/arithmetic/2
+    (clsql:sql [- [foo bar] [baz]])
+ "(FOO.BAR - BAZ)")
+
+(deftest :syntax/arithmetic/3
+    (clsql:sql [/ [foo bar] [baz]])
+ "(FOO.BAR / BAZ)")
+
+(deftest :syntax/arithmetic/4
+    (clsql:sql [* [foo bar] [baz]])
+ "(FOO.BAR * BAZ)")
+
+(deftest :syntax/arithmetic/5
+    (clsql:sql [- [foo bar]])
+ "(- (FOO.BAR))")
+
+(deftest :syntax/arithmetic/6
+    (clsql:sql [* 2 3])
+  "(2 * 3)")
+
+
+(deftest :syntax/substr/1
+    (clsql:sql [substr [hello] 1 4])
+ "SUBSTR(HELLO,1,4)")
+
+(deftest :syntax/substring/1
+    (clsql:sql [substring [hello] 1 4])
+ "SUBSTRING(HELLO,1,4)")
+
+
+(deftest :syntax/concat/1
+    (clsql:sql [|| [foo] [bar] [baz]])
+ "(FOO || BAR || BAZ)")
+
+(deftest :syntax/concat/2
+    (clsql:sql [concat [foo] [bar]])
+ "CONCAT(FOO,BAR)")
+
+
+(deftest :syntax/pattern/1
+    (clsql:sql [like [foo] "%v"])
+  "(FOO LIKE '%v')")
+
+(deftest :syntax/pattern/2
+    (clsql:sql [not [like [foo] "%v"]])
+  "(NOT ((FOO LIKE '%v')))")
+
+
+(deftest :syntax/distinct/1
+    (clsql:sql [distinct [foo bar :string]])
+ "DISTINCT FOO.BAR")
+
+(deftest :syntax/distinct/2
+    (clsql:sql [distinct [foo :string] [bar :integer]])
+ "DISTINCT FOO, BAR")
+
+
+(deftest :syntax/order-by/1
+    (clsql:sql [order-by [foo]])
+ "ORDER BY FOO")
+
+(deftest :syntax/group-by/1
+    (clsql:sql [group-by [foo]])
+ "GROUP BY FOO")
+
+(deftest :syntax/group-by/2
+    (clsql:sql
+     (clsql-sys::make-query [foo] [bar] [count [foo]]
+      :from [table]
+      :group-by '([foo] [bar])
+      :order-by '([foo] [bar])))
+  "SELECT FOO,BAR,COUNT(FOO) FROM TABLE GROUP BY FOO,BAR ORDER BY FOO,BAR")
+
+
+(deftest :syntax/coalesce/1
+    (clsql:sql [coalesce [foo] [bar] "not specified"])
+ "COALESCE(FOO,BAR,'not specified')")
+
+(deftest :syntax/coalesce/2
+    (clsql:sql [nvl [foo] "not specified"])
+ "COALESCE(FOO,'not specified')")
+
+(deftest :syntax/nvl/1
+    (clsql:sql [nvl [foo] "not specified"])
+ "COALESCE(FOO,'not specified')")
+
+
+
+(deftest :syntax/sets/1
+    (clsql:sql [union [select [foo] :from [bar]] [select [baz] :from [bar]]])
+ "SELECT FOO FROM BAR UNION SELECT BAZ FROM BAR")
+
+(deftest :syntax/sets/2
+    (clsql:sql [intersect [select [foo] :from [bar]] [select [baz] :from [bar]]])
+ "SELECT FOO FROM BAR INTERSECT SELECT BAZ FROM BAR")
+
+(deftest :syntax/sets/3
+    (clsql:sql [except [select [foo] :from [bar]] [select [baz] :from [bar]]])
+ "SELECT FOO FROM BAR EXCEPT SELECT BAZ FROM BAR")
+
+(deftest :syntax/sets/4
+    (clsql:sql [minus [select [foo] :from [bar]] [select [baz] :from [bar]]])
+ "SELECT FOO FROM BAR MINUS SELECT BAZ FROM BAR")
+
 
 (deftest :syntax/function/1
     (clsql:sql [function "COS" [age]])
@@ -97,11 +356,12 @@
     (clsql:sql [function "TO_DATE" "02/06/99" "mm/DD/RR"])
   "TO_DATE('02/06/99','mm/DD/RR')")
 
+
 (deftest :syntax/query/1
     (clsql:sql [select [person_id] [surname] :from [person]])
   "SELECT PERSON_ID,SURNAME FROM PERSON")
 
-(deftest :syntax/query/2 
+(deftest :syntax/query/2
     (clsql:sql [select [foo] [bar *]
                       :from '([baz] [bar])
                       :where [or [= [foo] 3]
@@ -118,19 +378,19 @@
 (deftest :syntax/query/4
     (clsql:sql [select [count [*]] :from [emp]])
   "SELECT COUNT(*) FROM EMP")
-  
 
-(deftest :syntax/expression1
+
+(deftest :syntax/expression/1
     (clsql:sql
      (clsql:sql-operation
       'select
       (clsql:sql-expression :table 'foo :attribute 'bar)
       (clsql:sql-expression :attribute 'baz)
-      :from (list 
+      :from (list
              (clsql:sql-expression :table 'foo)
              (clsql:sql-expression :table 'quux))
       :where
-      (clsql:sql-operation 'or 
+      (clsql:sql-operation 'or
                           (clsql:sql-operation
                            '>
                            (clsql:sql-expression :attribute 'baz)
@@ -141,7 +401,7 @@
                                                 :attribute 'bar)
                            "SU%"))))
   "SELECT FOO.BAR,BAZ FROM FOO,QUUX WHERE ((BAZ > 3) OR (FOO.BAR LIKE 'SU%'))")
-  
+
 (deftest :syntax/expression/2
     (clsql:sql
      (apply (clsql:sql-operator 'and)
@@ -157,6 +417,49 @@
                   [like (clsql:sql-expression :table table
                                              :attribute 'baz)
                         (clsql:sql table)])))
-  "(BETWEEN(THISTIME.BAR,(HIP * HOP),42) AND (THISTIME.BAZ LIKE 'THISTIME') AND BETWEEN(NEXTTIME.BAR,(HIP * HOP),43) AND (NEXTTIME.BAZ LIKE 'NEXTTIME') AND BETWEEN(SOMETIME.BAR,(HIP * HOP),44) AND (SOMETIME.BAZ LIKE 'SOMETIME') AND BETWEEN(NEVER.BAR,(HIP * HOP),45) AND (NEVER.BAZ LIKE 'NEVER'))")
-  
-#.(clsql:restore-sql-reader-syntax-state)
+  "(BETWEEN(THISTIME.BAR,(HIP * HOP),42) AND (THISTIME.BAZ LIKE 'THISTIME') AND BETWEEN(NEXTTIME.BAR,(HIP * HOP),43) AND (NEXTTIME.BAZ LIKE 'NEXTTIME') AND BETWEEN(SOMETIME.BAR,(HIP * HOP),44) AND (SOMETIME.BAZ LIKE 'SOMETIME') AND BETWEEN(NEVER.BAR,(HIP * HOP),45) AND (NEVER.BAZ LIKE 'NEVER'))"
+ )
+
+(deftest :syntax/subqueries/query
+ (clsql:sql
+  (clsql:sql-operation 'select [*]
+   :from [foo]
+   :where [in [id] [select [id] :from [bar]]]))
+ "SELECT * FROM FOO WHERE (ID IN (SELECT ID FROM BAR))")
+
+(deftest :syntax/subqueries/delete
+ (clsql:sql
+  (make-instance 'clsql-sys::sql-delete
+   :from [foo]
+   :where [in [id] [select [id] :from [bar]]]))
+ "DELETE FROM FOO WHERE (ID IN (SELECT ID FROM BAR))")
+
+(deftest :syntax/subqueries/update
+ (clsql:sql
+  (make-instance 'clsql-sys::sql-update
+   :attributes (list [id])
+   :values '(0)
+   :table [foo]
+   :where [in [id] [select [id] :from [bar]]]))
+ "UPDATE FOO SET ID = 0 WHERE (ID IN (SELECT ID FROM BAR))")
+
+ ))
+
+(let ((tests '(((:foo) "FOO")
+	       ((:foo-bar) "FOO_BAR")
+	       (("foo") "\"foo\"")
+	       (('|foo bar|) "\"foo bar\"")
+	       ((:foo :table-alias :bar) "FOO BAR" )
+	       ((:foo_bar :table-alias :bar-bast) "FOO_BAR BAR_BAST")
+	       (("foo" :table-alias "Bar") "\"foo\" \"Bar\"")
+	       (('|foo bar| :table-alias :bast) "\"foo bar\" BAST"))))
+
+  (push
+   `(deftest :syntax/sql-ident-table
+	(values ,@(mapcar
+		   #'(lambda (args)
+		       `(clsql:sql (make-instance 'clsql-sys:sql-ident-table
+						  :name ,@args)))
+		   (mapcar #'first tests)))
+      ,@(mapcar #'second tests))
+   *rt-syntax*))