X-Git-Url: http://git.kpe.io/?p=clsql.git;a=blobdiff_plain;f=sql%2Fmetaclasses.lisp;h=f4c87e09843314ec36897de2bb567b46eb8d2305;hp=60679fb409eb08d062beb0ccb8acc5ac1520af5d;hb=e622ee6f4bf2b9fe81af59d566e651c983a4833b;hpb=7f0e4a65d1b425f2fa58fc7cce8296c1a6c52c2f diff --git a/sql/metaclasses.lisp b/sql/metaclasses.lisp index 60679fb..f4c87e0 100644 --- a/sql/metaclasses.lisp +++ b/sql/metaclasses.lisp @@ -1,18 +1,18 @@ ;;;; -*- Mode: LISP; Syntax: ANSI-Common-Lisp; Base: 10 -*- -;;;; ====================================================================== -;;;; File: metaclasses.lisp -;;;; Updated: <04/04/2004 12:08:11 marcusp> -;;;; ====================================================================== +;;;; ************************************************************************* ;;;; -;;;; Description ========================================================== -;;;; ====================================================================== +;;;; $Id$ ;;;; -;;;; CLSQL-USQL 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. +;;;; +;;;; 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-usql-sys) +(in-package #:clsql-sys) (eval-when (:compile-toplevel :load-toplevel :execute) (when (>= (length (generic-function-lambda-list @@ -45,10 +45,6 @@ :accessor object-definition :initarg :definition :initform nil) - (version - :accessor object-version - :initarg :version - :initform 0) (key-slots :accessor key-slots :initform nil) @@ -58,92 +54,19 @@ :initform nil)) (:documentation "VIEW-CLASS metaclass.")) -#+lispworks -(defmacro push-on-end (value location) - `(setf ,location (nconc ,location (list ,value)))) +;;; Lispworks 4.2 and before requires special processing of extra slot and class options -;; As Heiko Kirscke (author of PLOB!) would say: !@##^@%! Lispworks! -#+lispworks -(defconstant +extra-slot-options+ '(:column :db-kind :db-reader :nulls-ok - :db-writer :db-type :db-info)) - -#+lispworks -(define-setf-expander assoc (key alist &environment env) - (multiple-value-bind (temps vals stores store-form access-form) - (get-setf-expansion alist env) - (let ((new-value (gensym "NEW-VALUE-")) - (keyed (gensym "KEYED-")) - (accessed (gensym "ACCESSED-")) - (store-new-value (car stores))) - (values (cons keyed temps) - (cons key vals) - `(,new-value) - `(let* ((,accessed ,access-form) - (,store-new-value (assoc ,keyed ,accessed))) - (if ,store-new-value - (rplacd ,store-new-value ,new-value) - (progn - (setq ,store-new-value - (acons ,keyed ,new-value ,accessed)) - ,store-form)) - ,new-value) - `(assoc ,new-value ,access-form))))) - -#+lispworks -(defmethod clos::canonicalize-defclass-slot :around - ((prototype standard-db-class) slot) - "\\lw\\ signals an error on unknown slot options; so this method -removes any extra allowed options before calling the default method -and returns the canonicalized extra options concatenated to the result -of the default method. The extra allowed options are the value of the -\\fcite{+extra-slot-options+}." - (let ((extra-slot-options ()) - (rest-options ()) - (result ())) - (do ((olist (cdr slot) (cddr olist))) - ((null olist)) - (let ((option (car olist))) - (cond - ((find option +extra-slot-options+) - ;;(push (cons option (cadr olist)) extra-slot-options)) - (setf (assoc option extra-slot-options) (cadr olist))) - (t - (push (cadr olist) rest-options) - (push (car olist) rest-options))))) - (setf result (call-next-method prototype (cons (car slot) rest-options))) - (dolist (option extra-slot-options) - (push-on-end (car option) result) - (push-on-end `(quote ,(cdr option)) result)) - result)) +(defvar +extra-slot-options+ '(:column :db-kind :db-type :db-reader :void-value :db-constraints + :db-writer :db-info)) +(defvar +extra-class-options+ '(:base-table)) #+lispworks -(defconstant +extra-class-options+ '(:base-table :version :schemas)) - -#+lispworks -(defmethod clos::canonicalize-class-options :around - ((prototype standard-db-class) class-options) - "\\lw\\ signals an error on unknown class options; so this method -removes any extra allowed options before calling the default method -and returns the canonicalized extra options concatenated to the result -of the default method. The extra allowed options are the value of the -\\fcite{+extra-class-options+}." - (let ((extra-class-options nil) - (rest-options ()) - (result ())) - (dolist (o class-options) - (let ((option (car o))) - (cond - ((find option +extra-class-options+) - ;;(push (cons option (cadr o)) extra-class-options)) - (setf (assoc option extra-class-options) (cadr o))) - (t - (push o rest-options))))) - (setf result (call-next-method prototype rest-options)) - (dolist (option extra-class-options) - (push-on-end (car option) result) - (push-on-end `(quote ,(cdr option)) result)) - result)) +(dolist (slot-option +extra-slot-options+) + (eval `(process-slot-option standard-db-class ,slot-option))) +#+lispworks +(dolist (class-option +extra-class-options+) + (eval `(process-class-option standard-db-class ,class-option))) (defmethod validate-superclass ((class standard-db-class) (superclass standard-class)) @@ -155,7 +78,7 @@ of the default method. The extra allowed options are the value of the ((typep arg 'sql-ident) (slot-value arg 'name)) ((stringp arg) - (intern (string-upcase arg))))) + (intern (symbol-name-default-case arg))))) (defun column-name-from-arg (arg) (cond ((symbolp arg) @@ -163,7 +86,7 @@ of the default method. The extra allowed options are the value of the ((typep arg 'sql-ident) (slot-value arg 'name)) ((stringp arg) - (intern (string-upcase arg))))) + (intern (symbol-name-default-case arg))))) (defun remove-keyword-arg (arglist akey) @@ -181,7 +104,7 @@ of the default method. The extra allowed options are the value of the (defmethod initialize-instance :around ((class standard-db-class) &rest all-keys &key direct-superclasses base-table - schemas version qualifier + qualifier &allow-other-keys) (let ((root-class (find-class 'standard-db-object nil)) (vmc (find-class 'standard-db-class))) @@ -203,16 +126,12 @@ of the default method. The extra allowed options are the value of the (car base-table) base-table)) (class-name class))))) - (setf (object-version class) version) - (mapc (lambda (schema) - (pushnew (class-name class) (gethash schema *object-schemas*))) - (if (listp schemas) schemas (list schemas))) (register-metaclass class (nth (1+ (position :direct-slots all-keys)) all-keys)))) (defmethod reinitialize-instance :around ((class standard-db-class) &rest all-keys - &key base-table schemas version + &key base-table direct-superclasses qualifier &allow-other-keys) (let ((root-class (find-class 'standard-db-object nil)) @@ -235,10 +154,6 @@ of the default method. The extra allowed options are the value of the direct-superclasses) (remove-keyword-arg all-keys :direct-superclasses))) (call-next-method))) - (setf (object-version class) version) - (mapc (lambda (schema) - (pushnew (class-name class) (gethash schema *object-schemas*))) - (if (listp schemas) schemas (list schemas))) (register-metaclass class (nth (1+ (position :direct-slots all-keys)) all-keys))) @@ -262,7 +177,7 @@ of the default method. The extra allowed options are the value of the (slot-value slot 'db-kind) (and (slot-boundp slot 'column) (slot-value slot 'column)))))) - (let ((all-slots (mapcar #'frob-slot (class-slots class)))) + (let ((all-slots (mapcar #'frob-slot (ordered-class-slots class)))) (setq all-slots (remove-if #'not-db-col all-slots)) (setq all-slots (stable-sort all-slots #'string< :key #'car)) ;;(mapcar #'dink-type all-slots) @@ -277,18 +192,18 @@ of the default method. The extra allowed options are the value of the (setq all-slots (remove-if #'not-db-col all-slots)) (setq all-slots (stable-sort all-slots #'string< :key #'car)) (setf (object-definition class) all-slots)) - #-(or allegro openmcl) + #-allegro (setf (key-slots class) (remove-if-not (lambda (slot) (eql (slot-value slot 'db-kind) :key)) - (class-slots class))))) + (ordered-class-slots class))))) -#+(or allegro openmcl) +#+allegro (defmethod finalize-inheritance :after ((class standard-db-class)) (setf (key-slots class) (remove-if-not (lambda (slot) (eql (slot-value slot 'db-kind) :key)) - (class-slots class)))) + (ordered-class-slots class)))) ;; return the deepest view-class ancestor for a given view class @@ -324,7 +239,9 @@ the slot name.") :accessor view-class-slot-db-kind :initarg :db-kind :initform :base - :type keyword + ;; openmcl 0.14.2 stores the value as list in the DSD + ;; :type (or list keyword) + #-openmcl :type #-openmcl keyword :documentation "The kind of DB mapping which is performed for this slot. :base indicates the slot maps to an ordinary column of the DB view. :key @@ -365,17 +282,20 @@ column definition in the database.") :initform nil :documentation "A single constraint or list of constraints for this column") - (nulls-ok - :accessor view-class-slot-nulls-ok - :initarg :nulls-ok + (void-value + :accessor view-class-slot-void-value + :initarg :void-value :initform nil :documentation - "If t, all sql NULL values retrieved from the database become nil; if nil, -all NULL values retrieved are converted by DATABASE-NULL-VALUE") + "Value to store is the SQL value is NULL. Default is NIL.") (db-info :accessor view-class-slot-db-info :initarg :db-info - :documentation "Description of the join."))) + :documentation "Description of the join.") + (specified-type + :accessor specified-type + :initform nil + :documentation "KMR: Internal slot storing the :type specified by user."))) (defparameter *db-info-lambda-list* '(&key join-class @@ -436,76 +356,164 @@ all NULL values retrieved are converted by DATABASE-NULL-VALUE") (declare (ignore initargs)) (find-class 'view-class-effective-slot-definition)) +#+openmcl +(when (not (symbol-function 'compute-class-precedence-list)) + (eval + (defun compute-class-precedence-list (class) + (class-precedence-list class)))) + +#-mop-slot-order-reversed +(defmethod compute-slots ((class standard-db-class)) + "Need to sort order of class slots so they are the same across +implementations." + (let ((slots (call-next-method)) + desired-sequence + output-slots) + (dolist (c (compute-class-precedence-list class)) + (dolist (s (class-direct-slots c)) + (let ((name (slot-definition-name s))) + (unless (find name desired-sequence) + (push name desired-sequence))))) + (dolist (desired desired-sequence) + (let ((slot (find desired slots :key #'slot-definition-name))) + (assert slot) + (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) + (t + specified-type))) + ((eq (ensure-keyword specified-type) :bigint) + 'integer) + ((and specified-type + (not (eql :not-null (slot-value slotd 'db-constraints)))) + `(or null ,specified-type)) + (t + specified-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 ;; verifies the column name. +(declaim (inline delistify)) +(defun delistify (list) + "Some MOPs, like openmcl 0.14.2, cons attribute values in a list." + (if (listp list) + (car list) + list)) + +(declaim (inline delistify)) +(defun delistify-dsd (list) + "Some MOPs, like openmcl 0.14.2, cons attribute values in a list." + (if (and (listp list) (null (cdr list))) + (car list) + list)) + (defmethod compute-effective-slot-definition ((class standard-db-class) #+kmr-normal-cesd slot-name direct-slots) #+kmr-normal-cesd (declare (ignore slot-name)) - (let ((slotd (call-next-method)) - (sd (car direct-slots))) - - (typecase sd - (view-class-slot-definition-mixin - ;; Use the specified :column argument if it is supplied, otherwise - ;; the column slot is filled in with the slot-name, but transformed - ;; to be sql safe, - to _ and such. - (setf (slot-value slotd 'column) - (column-name-from-arg - (if (slot-boundp sd 'column) - (view-class-slot-column sd) - (column-name-from-arg - (sql-escape (slot-definition-name sd)))))) - - (setf (slot-value slotd 'db-type) - (when (slot-boundp sd 'db-type) - (view-class-slot-db-type sd))) - - - (setf (slot-value slotd 'nulls-ok) - (view-class-slot-nulls-ok sd)) - - ;; :db-kind slot value defaults to :base (store slot value in - ;; database) - - (setf (slot-value slotd 'db-kind) - (if (slot-boundp sd 'db-kind) - (view-class-slot-db-kind sd) - :base)) - - (setf (slot-value slotd 'db-writer) - (when (slot-boundp sd 'db-writer) - (view-class-slot-db-writer sd))) - (setf (slot-value slotd 'db-constraints) - (when (slot-boundp sd 'db-constraints) - (view-class-slot-db-constraints sd))) - - - ;; 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 )? - - (setf (slot-value slotd 'db-info) - (when (slot-boundp sd 'db-info) - (if (listp (view-class-slot-db-info sd)) - (parse-db-info (view-class-slot-db-info sd)) - (view-class-slot-db-info sd))))) - ;; all other slots - (t - (change-class slotd 'view-class-effective-slot-definition - #+allegro :name - #+allegro (slot-definition-name sd)) - (setf (slot-value slotd 'column) - (column-name-from-arg - (sql-escape (slot-definition-name sd)))) - - (setf (slot-value slotd 'db-info) nil) - (setf (slot-value slotd 'db-kind) - :virtual))) - slotd)) - + + ;; 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 (slot-value dsd 'type) + (compute-lisp-type-from-slot-specification + dsd (slot-definition-type dsd)))) + + (let ((esd (call-next-method))) + (typecase dsd + (view-class-slot-definition-mixin + ;; Use the specified :column argument if it is supplied, otherwise + ;; the column slot is filled in with the slot-name, but transformed + ;; to be sql safe, - to _ and such. + (setf (slot-value esd 'column) + (column-name-from-arg + (if (slot-boundp dsd 'column) + (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-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 )? + + (setf (slot-value esd 'db-info) + (when (slot-boundp dsd 'db-info) + (let ((dsd-info (view-class-slot-db-info dsd))) + (cond + ((atom dsd-info) + dsd-info) + ((and (listp dsd-info) (> (length dsd-info) 1) + (atom (car dsd-info))) + (parse-db-info dsd-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)) + (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 (slot-value esd 'db-info) nil) + (setf (slot-value esd 'db-kind) :virtual) + (setf (specified-type esd) (slot-definition-type dsd))) + ) + esd))) + (defun slotdefs-for-slots-with-class (slots class) (let ((result nil)) (dolist (s slots)