(in-package #:clsql-tests)
-(defvar *report-stream* nil "Stream to send text report.")
+(defvar *report-stream* *standard-output* "Stream to send text report.")
(defvar *sexp-report-stream* nil "Stream to send sexp report.")
(defvar *rt-connection*)
+(defvar *rt-basic*)
(defvar *rt-fddl*)
(defvar *rt-fdml*)
(defvar *rt-ooddl*)
:initarg :groupid)
(first-name
:accessor first-name
- :type (string 30)
+ :type (varchar 30)
:initarg :first-name)
(last-name
:accessor last-name
- :type (string 30)
+ :type (varchar 30)
:initarg :last-name)
(email
:accessor employee-email
- :type (string 100)
+ :type (varchar 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
: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))
:type integer
:initarg :groupid)
(name
- :type (string 100)
+ :type (varchar 100)
:initarg :name)
(presidentid
:type integer
:db-kind :join
:db-info (:join-class employee
:home-key (companyid groupid)
- :foreign-key (companyid groupid)
- :set t)))
- (:base-table company))
-
+ :foreign-key (ecompanyid groupid)
+ :set t))))
(def-view-class address ()
((addressid
:type integer
:initarg :street-number)
(street-name
- :type (string 30)
+ :type (varchar 30)
:void-value ""
:initarg :street-name)
(city
:column "city_field"
:void-value "no city"
- :type (string 30)
+ :type (varchar 30)
:initarg :city)
(postal-code
- :column "zip"
+ :column zip
:type integer
:void-value 0
- :initarg :postal-code)))
+ :initarg :postal-code))
+ (:base-table addr))
;; many employees can reside at many addressess
(def-view-class employee-address ()
- ((emplid :type integer
- :initarg :emplid)
- (addressid :type integer
- :initarg :addressid)
+ ((aemplid :type integer :initarg :emplid)
+ (aaddressid :type integer :initarg :addressid)
+ (verified :type boolean :initarg :verified)
+ (address :db-kind :join
+ :db-info (:join-class address
+ :home-key aaddressid
+ :foreign-key addressid
+ :retrieval :immediate)))
+ (:base-table "ea_join"))
+
+(def-view-class deferred-employee-address ()
+ ((aemplid :type integer :initarg :emplid)
+ (aaddressid :type integer :initarg :addressid)
+ (verified :type boolean :initarg :verified)
(address :db-kind :join
:db-info (:join-class address
- :home-key addressid
+ :home-key aaddressid
:foreign-key addressid
- :retrieval :immediate))))
+ :retrieval :deferred
+ :set nil)))
+ (:base-table "ea_join"))
(defun test-connect-to-database (db-type spec)
- (when (db-backend-has-create/destroy-db? db-type)
+ (when (clsql-sys:db-backend-has-create/destroy-db? db-type)
(ignore-errors (destroy-database spec :database-type db-type))
(ignore-errors (create-database spec :database-type db-type)))
(setf *test-database-type* db-type)
- (when (>= (length spec) 3)
- (setq *test-database-user* (third spec)))
+ (setf *test-database-user*
+ (cond
+ ((eq :oracle db-type) (second spec))
+ ((>= (length spec) 3) (third spec))))
;; Connect to the database
(clsql:connect spec
(truncate-database :database *default-database*)
(setf *test-database-underlying-type*
- (clsql:database-underlying-type *default-database*))
+ (clsql-sys:database-underlying-type *default-database*))
*default-database*)
(defun test-initialise-database ()
(test-basic-initialize)
-
(let ((*backend-warning-behavior*
(if (member *test-database-type* '(:postgresql :postgresql-socket))
:ignore
:addressid 2)
employee-address1 (make-instance 'employee-address
:emplid 1
- :addressid 1)
+ :addressid 1
+ :verified t)
employee-address2 (make-instance 'employee-address
:emplid 2
- :addressid 2)
+ :addressid 2
+ :verified t)
employee-address3 (make-instance 'employee-address
:emplid 3
- :addressid 1)
+ :addressid 1
+ :verified nil)
employee-address4 (make-instance 'employee-address
:emplid 1
- :addressid 2)
+ :addressid 2
+ :verified nil)
employee-address5 (make-instance 'employee-address
:emplid 3
:addressid 2)
(defun load-necessary-systems (specs)
(dolist (db-type +all-db-types+)
(when (db-type-spec db-type specs)
- (clsql:initialize-database-type :database-type db-type))))
+ (clsql-sys:initialize-database-type :database-type db-type))))
(defun write-report-banner (report-type db-type stream)
(format stream
*** CLSQL ~A begun at ~A
*** ~A
*** ~A on ~A
-*** Database ~A backend~A.
+*** Database ~:@(~A~) backend~A.
******************************************************************************
"
report-type
(machine-type)
db-type
(if (not (eq db-type *test-database-underlying-type*))
- (format nil " with underlying type ~A"
+ (format nil " with underlying type ~:@(~A~)"
*test-database-underlying-type*)
"")
))
(lisp-implementation-version)
(machine-type))))
(when *sexp-report-stream*
- (write sexp-error :stream *sexp-report-stream*))
+ (write sexp-error :stream *sexp-report-stream* :readably t))
(push sexp-error *error-list*))
(format *report-stream* "~&Tests skipped:")
(defun compute-tests-for-backend (db-type db-underlying-type)
- (declare (ignorable db-type))
(let ((test-forms '())
(skip-tests '()))
- (dolist (test-form (append (test-basic-forms)
- *rt-connection* *rt-fddl* *rt-fdml*
+ (dolist (test-form (append *rt-connection* *rt-basic* *rt-fddl* *rt-fdml*
*rt-ooddl* *rt-oodml* *rt-syntax*))
(let ((test (second test-form)))
(cond
- ((and (null (db-type-has-views? db-underlying-type))
- (clsql-base::in test :fddl/view/1 :fddl/view/2 :fddl/view/3 :fddl/view/4))
+ ((and (null (clsql-sys:db-type-has-views? db-underlying-type))
+ (clsql-sys:in test :fddl/view/1 :fddl/view/2 :fddl/view/3 :fddl/view/4))
(push (cons test "views not supported") skip-tests))
- ((and (null (db-type-has-boolean-where? db-underlying-type))
- (clsql-base::in test :fdml/select/11 :oodml/select/5))
+ ((and (null (clsql-sys:db-type-has-boolean-where? db-underlying-type))
+ (clsql-sys:in test :fdml/select/11 :oodml/select/5))
(push (cons test "boolean where not supported") skip-tests))
- ((and (null (db-type-has-subqueries? db-underlying-type))
- (clsql-base::in test :fdml/select/5 :fdml/select/10))
+ ((and (null (clsql-sys:db-type-has-subqueries? db-underlying-type))
+ (clsql-sys:in test :fdml/select/5 :fdml/select/10
+ :fdml/select/32 :fdml/select/33))
(push (cons test "subqueries not supported") skip-tests))
- ((and (null (db-type-transaction-capable? db-underlying-type
+ ((and (null (clsql-sys:db-type-transaction-capable? db-underlying-type
*default-database*))
- (clsql-base::in test :fdml/transaction/1 :fdml/transaction/2 :fdml/transaction/3 :fdml/transaction/4))
+ (clsql-sys:in test :fdml/transaction/1 :fdml/transaction/2 :fdml/transaction/3 :fdml/transaction/4))
(push (cons test "transactions not supported") skip-tests))
- ((and (null (db-type-has-fancy-math? db-underlying-type))
- (clsql-base::in test :fdml/select/1))
+ ((and (null (clsql-sys:db-type-has-fancy-math? db-underlying-type))
+ (clsql-sys:in test :fdml/select/1))
(push (cons test "fancy math not supported") skip-tests))
((and (eql *test-database-type* :sqlite)
- (clsql-base::in test :fddl/view/4 :fdml/select/10))
+ (clsql-sys:in test :fddl/view/4 :fdml/select/10
+ :fdml/select/21 :fdml/select/32
+ :fdml/select/33))
(push (cons test "not supported by sqlite") skip-tests))
+ ((and (not (clsql-sys:db-type-has-bigint? db-type))
+ (clsql-sys:in test :basic/bigint/1))
+ (push (cons test "bigint not supported") skip-tests))
+ ((and (eql *test-database-underlying-type* :mysql)
+ (clsql-sys:in test :fdml/select/26))
+ (push (cons test "string table aliases not supported on all mysql versions") skip-tests))
+ ((and (eql *test-database-underlying-type* :mysql)
+ (clsql-sys:in test :fdml/select/22 :fdml/query/5
+ :fdml/query/7 :fdml/query/8))
+ (push (cons test "not supported by mysql") skip-tests))
+ ((and (null (clsql-sys:db-type-has-union? db-underlying-type))
+ (clsql-sys:in test :fdml/query/6 :fdml/select/31))
+ (push (cons test "union not supported") skip-tests))
+ ((and (eq *test-database-type* :oracle)
+ (clsql-sys:in test :fdml/query/8 :fdml/select/21))
+ (push (cons test "syntax not supported") skip-tests))
(t
(push test-form test-forms)))))
- (values (nreverse test-forms) (nreverse skip-tests))))
+ (values (nreverse test-forms) (nreverse skip-tests))))
-(defun rl ()
+(defun rapid-load (type &optional (position 0))
"Rapid load for interactive testing."
(when *default-database*
(disconnect :database *default-database*))
- (test-connect-to-database :postgresql (car (postgresql-spec (read-specs))))
- (test-initialise-database))
+ (test-connect-to-database type (nth position (db-type-spec type (read-specs))))
+ (test-initialise-database)
+ *default-database*)
+
+(defun rl ()
+ (rapid-load :postgresql))
+
+(defun rlm ()
+ (rapid-load :mysql))
+
+(defun rlo ()
+ (rapid-load :oracle))
projects / clsql.git / blobdiff