use specialized engine subclass for postres for controlling timestamp conversion

storage/storage.lisp

@@ -5,7 +5,8 @@
 (defpackage :scopes/storage
   (:use :common-lisp)
   (:export #:*db-config*
-           #:make-engine #:make-storage 
+           #:make-engine #:make-storage #:engine
+           #:timestamp-to-sql
            #:db-options #:db-params #:qualified-table-name
            #:do-sql #:query #:drop-table
            #:schema))
@@ -17,6 +18,9 @@
 (defvar *backends*
   '(:dbi dbi-make-engine))
 
+(defvar *db-engines*
+  '(:postgres db-engine-pg))
+
 (defvar *db-params*
   '(:sqlite3 (:id-type integer :json-type json)
     :postgres (:id-type bigserial :json-type jsonb)))
@@ -30,6 +34,10 @@
   (let ((backend (getf *db-config* :backend)))
     (funcall (getf *backends* backend) *db-config*)))
 
+(defgeneric timestamp-to-sql (engine ts))
+
+(defmethod timestamp-to-sql ((engine db-engine) ts) ts)
+
 (defclass storage ()
   ((engine :reader engine :initarg :engine)
    (conn :reader conn)
@@ -74,15 +82,22 @@
       (dbi:row-count conn))))
 
 (defun drop-table (st tn)
-  (do-sql st (sxql:drop-table tn :if-exists t)))
+  (let ((table (qualified-table-name st tn)))
+    (do-sql st (sxql:drop-table table :if-exists t))))
 
 ;;; backend-/driver-specific stuff
 
 (defun dbi-make-engine (config)
   (let* ((db-type (getf config :db-type))
          (params (getf *db-params* db-type))
+         (engine (getf *db-engines* db-type 'db-engine))
          (conn-args (getf config :connect-args)))
-    (make-instance 'db-engine 
+    (make-instance engine 
                    :params params :config config
                    :connect #'(lambda () 
                                 (apply #'dbi:connect-cached db-type conn-args)))))
+
+(defclass db-engine-pg (db-engine) ())
+
+(defmethod timestamp-to-sql ((engine db-engine-pg) ts)
+  (format nil "~a" (local-time:universal-to-timestamp ts)))

storage/tracking.lisp

@@ -20,6 +20,9 @@
    (data :accessor data :initform nil)
    (container :reader container :initarg :container)))
 
+(defun engine (tr)
+  (storage:engine (storage (container tr))))
+
 (defclass container ()
   ((item-factory :initform #'(lambda (cont head) 
                                (make-instance 'track :container cont :head head)))
@@ -43,7 +46,7 @@
     (with-slots ((trid trackid) (ts time-stamp) data) track
       (if trid (setf (getf vl :trackid) trid))
       (if ts (setf (getf vl :timestamp) 
-                   (format nil "~a" (local-time:universal-to-timestamp ts))))
+                   (storage:timestamp-to-sql (engine track) ts)))
       (if data (setf (getf vl :data) data)))
     vl))
     

test/test-storage.lisp

@@ -40,7 +40,7 @@
 (defun test-track (st)
   (let (cont tr)
     (setf cont (make-instance 'tracking:container :storage st))
-    (storage:drop-table st :testing.tracks)
+    (storage:drop-table st :tracks)
     (tracking:create-table cont)
     (setf tr (tracking:make-item cont "t01" "john"))
     (setf (tracking:time-stamp tr) (get-universal-time))