anchor.diff:  				(clsql:list-attributes [v1]))
   			#'string<)
   	       (clsql:drop-view [v1] :if-does-not-exist :ignore))))
  -    ("a" "b" "c"))
  +    ("a" "c" "d"))
   
     ;; create a view, select stuff from it and drop it
   (deftest :fddl/view/3
       (with-dataset *ds-fddl*
         (progn
   	(clsql:create-view [v1]
  -			   :as [select [a] [b] [c]
  +			   :as [select [a] [c] [d]
   				       :from [alpha]
   				       :where [= [a] 1]])
   	(unwind-protect
   	     (let ((result
   		    (list
   		     ;; Shouldn't exist
  -		     (clsql:select [a] [b] [c]
  +		     (clsql:select [a] [c] 
   				   :from [v1]
   				   :where [= [a] -1])
   		     ;; Should exist
  -		     (car (clsql:select [a] [b] [c]
  +		     (car (clsql:select [a] [c]
   					:from [v1]
   					:where [= [a] 1])))))
   
   	       (apply #'values result))
   	  (clsql:drop-view [v1] :if-does-not-exist :ignore))))
  -  nil (1 1 "asdf"))
  +  nil (1 "asdf"))
   
   (deftest :fddl/view/4
       (with-dataset *ds-fddl*
         (progn
   	(clsql:create-view [v1]
   			   :column-list '([x] [y] [z])
  -			   :as [select [a] [b] [c]
  +			   :as [select [a] [c] [d]
   				       :from [alpha]
   				       :where [= [a] 1]])
   	(unwind-protect
   	     (let ((result
   		    (list
  +		     (sort (mapcar #'string-downcase
  +				   (clsql:list-attributes [v1]))
  +			   #'string<)
   		     ;; Shouldn't exist
  -		     (clsql:select [x] [y] [z]
  +		     (clsql:select [x] [y] 
   				   :from [v1]
   				   :where [= [x] -1])
   		     ;; Should exist
  -		     (car (clsql:select [x] [y] [z]
  +		     (car (clsql:select [x] [y] 
   					:from [v1]
   					:where [= [x] 1])))))
   
   	       (apply #'values result))
   	  (clsql:drop-view [v1] :if-does-not-exist :ignore))))
  -  nil (1 1 "asdf"))
  +  ("x" "y" "z") nil (1 "asdf"))
   
   ;; create an index, test for existence, drop it and test again
   (deftest :fddl/index/1
       (with-dataset *ds-fddl*
         (progn (clsql:create-index [bar] :on [alpha] :attributes
  -				 '([a] [b] [c]) :unique t)
  +				 '([a] [c]) :unique t)
   	     (values
   	       (clsql:index-exists-p [bar] :owner *test-database-user*)
   	       (progn
  
positive.code: ;; create a view, test for existence, drop it and test again
  (deftest :fddl/view/1
      (with-dataset *ds-fddl*
      (progn (clsql:create-view [v1]
  			      :as [select [a] [b] [c]
  					  :from [alpha]
  					  :where [= [a] 1]])
  	   (values
  	    (clsql:view-exists-p [v1] :owner *test-database-user*)
  	    (progn
  	      (clsql:drop-view [v1] :if-does-not-exist :ignore)
  	      (clsql:view-exists-p [v1] :owner *test-database-user*)))))
    t nil)
  
    ;; create a view, list its attributes and drop it
  (deftest :fddl/view/2
        (with-dataset *ds-fddl*
  	(progn (clsql:create-view [v1]
  			      :as [select [a] [b] [c]
  					  :from [alpha]
  					  :where [= [a] 1]])
  	     (unwind-protect
  
negative.code: 		      (clsql:list-attribute-types [alpha]
  						  :owner *test-database-user*))
  	      #'string<)))
    "a" "c" "d" "f")
  
  ;; Attribute types are vendor specific so need to test a range
  (deftest :fddl/attributes/3
  