;;;;
;;;; $Id$
;;;;
-;;;; CLSQL metaclass for standard-db-objects created in the OODDL.
+;;;; CLSQL metaclass for standard-db-objects created in the OODDL.
;;;;
;;;; This file is part of CLSQL.
;;;;
'compute-effective-slot-definition)))
3)
(pushnew :kmr-normal-cesd cl:*features*))
-
+
(when (>= (length (generic-function-lambda-list
(ensure-generic-function
'direct-slot-definition-class)))
3)
(pushnew :kmr-normal-dsdc cl:*features*))
-
+
(when (>= (length (generic-function-lambda-list
(ensure-generic-function
'effective-slot-definition-class)))
qualifier
&allow-other-keys)
(let ((root-class (find-class 'standard-db-object nil))
- (vmc (find-class 'standard-db-class)))
+ (vmc 'standard-db-class))
(setf (view-class-qualifier class)
(car qualifier))
(if root-class
- (if (member-if #'(lambda (super)
- (eq (class-of super) vmc)) direct-superclasses)
+ (if (some #'(lambda (super) (typep super vmc))
+ direct-superclasses)
(call-next-method)
(apply #'call-next-method
class
(defmethod reinitialize-instance :around ((class standard-db-class)
&rest all-keys
- &key base-table
+ &key base-table
direct-superclasses qualifier
&allow-other-keys)
(let ((root-class (find-class 'standard-db-object nil))
- (vmc (find-class 'standard-db-class)))
+ (vmc 'standard-db-class))
(setf (view-table class)
(table-name-from-arg (sql-escape (or (and base-table
(if (listp base-table)
(setf (view-class-qualifier class)
(car qualifier))
(if (and root-class (not (equal class root-class)))
- (if (member-if #'(lambda (super)
- (eq (class-of super) vmc)) direct-superclasses)
+ (if (some #'(lambda (super) (typep super vmc))
+ direct-superclasses)
(call-next-method)
(apply #'call-next-method
class
:documentation "Description of the join.")
(specified-type
:accessor specified-type
+ :initarg specified-type
:initform nil
- :documentation "KMR: Internal slot storing the :type specified by user.")))
+ :documentation "Internal slot storing the :type specified by user.")))
(defparameter *db-info-lambda-list*
'(&key join-class
(target-slot nil)
(retrieval :immmediate)
(set nil)))
-
+
(defun parse-db-info (db-info-list)
(destructuring-bind
(&key join-class home-key key-join foreign-key (delete-rule nil)
(push slot output-slots)))
output-slots))
-(defun compute-lisp-type-from-slot-specification (slotd specified-type)
- "Computes the Lisp type for a user-specified type. Needed for OpenMCL
-which does type checking before storing a value in a slot."
- ;; This function is called after the base compute-effective-slots is called.
- ;; OpenMCL sets the type-predicate based on the initial value of the slots type.
- ;; so we have to override the type-predicates here
- (cond
- ((consp specified-type)
- (cond
- ((and (symbolp (car specified-type))
- (string-equal (symbol-name (car specified-type)) "string"))
- 'string)
- ((and (symbolp (car specified-type))
- (string-equal (symbol-name (car specified-type)) "varchar"))
- 'string)
- ((and (symbolp (car specified-type))
- (string-equal (symbol-name (car specified-type)) "char"))
- 'string)
- (t
- specified-type)))
- ((eq (ensure-keyword specified-type) :bigint)
- 'integer)
- ((eq (ensure-keyword specified-type) :char)
- 'character)
- ((eq (ensure-keyword specified-type) :varchar)
- 'string)
- ((and specified-type
- (not (eql :not-null (slot-value slotd 'db-constraints))))
- `(or null ,specified-type))
- (t
- specified-type)))
+(defun compute-lisp-type-from-specified-type (specified-type db-constraints)
+ "Computes the Lisp type for a user-specified type."
+ (let ((type
+ (cond
+ ((consp specified-type)
+ (let* ((first (first specified-type))
+ (name (etypecase first
+ (symbol (symbol-name first))
+ (string first))))
+ (cond
+ ((or (string-equal name "string")
+ (string-equal name "varchar")
+ (string-equal name "char"))
+ 'string)
+ (t
+ specified-type))))
+ ((eq (ensure-keyword specified-type) :bigint)
+ 'integer)
+ ((eq (ensure-keyword specified-type) :char)
+ 'character)
+ ((eq (ensure-keyword specified-type) :varchar)
+ 'string)
+ (t
+ specified-type))))
+ (if (and type (not (member :not-null (listify db-constraints))))
+ `(or null ,type)
+ type)))
;; Compute the slot definition for slots in a view-class. Figures out
;; what kind of database value (if any) is stored there, generates and
(car list)
list))
-(defvar *impl-type-attrib-name* #-clisp 'type #+clisp 'clos::$type)
+(defmethod initialize-instance :around ((obj view-class-direct-slot-definition)
+ &rest initargs)
+ (do* ((saved-initargs initargs)
+ (parsed (list obj))
+ (name (first initargs) (first initargs))
+ (val (second initargs) (second initargs))
+ (type nil)
+ (db-constraints nil))
+ ((null initargs)
+ (setq parsed
+ (append parsed
+ (list 'specified-type type
+ :type (compute-lisp-type-from-specified-type
+ type db-constraints))))
+ (apply #'call-next-method parsed))
+ (case name
+ (:db-constraints
+ (setq db-constraints val)
+ (setq parsed (append parsed (list name val))))
+ (:type
+ (setq type val))
+ (t
+ (setq parsed (append parsed (list name val)))))
+ (setq initargs (cddr initargs))))
(defmethod compute-effective-slot-definition ((class standard-db-class)
#+kmr-normal-cesd slot-name
direct-slots)
#+kmr-normal-cesd (declare (ignore slot-name))
-
+
;; KMR: store the user-specified type and then compute
;; real Lisp type and store it
(let ((dsd (car direct-slots)))
- (when (and (typep dsd 'view-class-slot-definition-mixin)
- (null (specified-type dsd)))
- (setf (specified-type dsd)
- (slot-definition-type dsd))
- (setf #-clisp (slot-value dsd 'type)
- #+clisp (slot-definition-type dsd)
- (compute-lisp-type-from-slot-specification
- dsd (slot-definition-type dsd))))
-
(let ((esd (call-next-method)))
(typecase dsd
(view-class-slot-definition-mixin
(delistify-dsd (view-class-slot-column dsd))
(column-name-from-arg
(sql-escape (slot-definition-name dsd))))))
-
+
(setf (slot-value esd 'db-type)
(when (slot-boundp dsd 'db-type)
(delistify-dsd
(view-class-slot-db-type dsd))))
-
+
(setf (slot-value esd 'void-value)
(delistify-dsd
(view-class-slot-void-value dsd)))
-
+
;; :db-kind slot value defaults to :base (store slot value in
;; database)
-
+
(setf (slot-value esd 'db-kind)
(if (slot-boundp dsd 'db-kind)
(delistify-dsd (view-class-slot-db-kind dsd))
:base))
-
+
+ (setf (slot-value esd 'db-reader)
+ (when (slot-boundp dsd 'db-reader)
+ (delistify-dsd (view-class-slot-db-reader dsd))))
(setf (slot-value esd 'db-writer)
(when (slot-boundp dsd 'db-writer)
(delistify-dsd (view-class-slot-db-writer dsd))))
(setf (slot-value esd 'db-constraints)
(when (slot-boundp dsd 'db-constraints)
(delistify-dsd (view-class-slot-db-constraints dsd))))
-
+
;; I wonder if this slot option and the previous could be merged,
;; so that :base and :key remain keyword options, but :db-kind
;; :join becomes :db-kind (:join <db info .... >)?
((and (listp dsd-info) (= 1 (length dsd-info))
(listp (car dsd-info)))
(parse-db-info (car dsd-info)))))))
-
+
(setf (specified-type esd)
(delistify-dsd (specified-type dsd)))
-
+
)
;; all other slots
(t
- (let ((type-predicate #+openmcl (slot-value esd 'ccl::type-predicate)))
- #-openmcl (declare (ignore type-predicate))
- #-clisp (change-class esd 'view-class-effective-slot-definition
- #+allegro :name
- #+allegro (slot-definition-name dsd))
- #+openmcl (setf (slot-value esd 'ccl::type-predicate)
- type-predicate))
-
+ (unless (typep esd 'view-class-effective-slot-definition)
+ (warn "Non view-class-direct-slot object with non-view-class-effective-slot-definition in compute-effective-slot-definition")
+
+ (let ((type-predicate #+openmcl (slot-value esd 'ccl::type-predicate)))
+ #-openmcl (declare (ignore type-predicate))
+ #-(or clisp sbcl) (change-class esd 'view-class-effective-slot-definition
+ #+allegro :name
+ #+allegro (slot-definition-name dsd))
+ #+openmcl (setf (slot-value esd 'ccl::type-predicate)
+ type-predicate)))
+
(setf (slot-value esd 'column)
(column-name-from-arg
(sql-escape (slot-definition-name dsd))))
(setf (specified-type esd) (slot-definition-type dsd)))
)
esd)))
-
+
(defun slotdefs-for-slots-with-class (slots class)
(let ((result nil))
(dolist (s slots)
projects / clsql.git / blobdiff