3 ;;; Copyright (c) 2000, 2001 onShore Development, Inc.
5 ;;; Test time functions (time.lisp)
7 (in-package #:clsql-tests)
8 (clsql-sys:file-enable-sql-reader-syntax)
10 (def-view-class datetest ()
14 :db-constraints (:not-null :unique)
15 :accessor id :initarg :id
18 (testtimetz :column "testtimetz"
19 :type clsql-sys:wall-time
22 :accessor testtimetz :initarg :testtimetz
24 :db-type "timestamp with time zone")
25 (testtime :column "testtime"
26 :type clsql-sys:wall-time
29 :accessor testtime :initarg :testtime
31 :db-type "timestamp without time zone")))
33 (def-dataset *ds-datetest*
34 (:setup (lambda () (clsql-sys:create-view-from-class 'datetest)))
35 (:cleanup "DROP TABLE datetest"))
38 (def-dataset *cross-platform-datetest*
39 (:setup (lambda () (create-table [datetest]
40 '(([testtime] wall-time)))))
42 (drop-table [datetest]))))
48 ;; we use parse timestring a lot through here verifying other things
49 ;; start off just checking that.
50 (deftest :time/iso-parse/0
51 (let* ((time1 (parse-timestring "2010-01-23")))
53 0 0 0 0 23 1 2010 6 nil)
55 (deftest :time/iso-parse/1
56 (let* ((time1 (parse-timestring "2010-01-23T14:56:32Z")))
58 0 32 56 14 23 1 2010 6 T)
60 (deftest :time/iso-parse/2
61 (let* ((time1 (parse-timestring "2008-02-29 12:46:32")))
63 0 32 46 12 29 2 2008 5 nil)
65 (deftest :time/iso-parse/3
66 (let* ((time1 (parse-timestring "2010-01-23 14:56:32.44")))
68 440000 32 56 14 23 1 2010 6 nil)
70 (deftest :time/iso-parse/4
71 (let* ((time1 (parse-timestring "2010-01-23 14:56:32.0044")))
73 4400 32 56 14 23 1 2010 6 nil)
75 (deftest :time/iso-parse/5
76 (let* ((time1 (parse-timestring "2010-01-23 14:56:32.000003")))
78 3 32 56 14 23 1 2010 6 nil)
80 (deftest :time/iso-parse/6
81 (let* ((time1 (parse-timestring "2010-01-23T14:56:32-05")))
83 0 32 56 19 23 1 2010 6 t)
85 (deftest :time/iso-parse/7
86 (let* ((time1 (parse-timestring "2010-01-23T14:56:32-05")))
88 0 32 56 19 23 1 2010 6 t)
90 (deftest :time/iso-parse/8
91 (let* ((time1 (parse-timestring "2010-01-23T14:56:32-05:30")))
93 0 32 26 20 23 1 2010 6 t)
95 (deftest :time/utc-round-trip/1
96 (let* ((time1 (parse-timestring "2010-01-23T14:56:32")))
97 (decode-time (time-to-localtime (time-to-utc time1))))
98 0 32 56 14 23 1 2010 6 nil)
100 (deftest :time/utc-round-trip/2
101 (let* ((time1 (parse-timestring "2010-01-23T14:56:32Z")))
102 (decode-time (time-to-utc (time-to-localtime time1))))
103 0 32 56 14 23 1 2010 6 t)
105 (deftest :time/print-parse/1
106 ;;make sure when we print and parse we get the same time.
107 (let* ((time (clsql-sys:make-time :year 2010 :month 1 :day 4
108 :hour 14 :minute 15 :second 44))
109 (string-time (iso-timestring time))
110 (time2 (parse-timestring string-time)))
112 0 44 15 14 4 1 2010 1 nil)
114 (deftest :time/print-parse/2
115 ;;make sure when we print and parse we get the same time.
116 (let* ((time (clsql-sys:make-time :year 2010 :month 1 :day 4
117 :hour 14 :minute 15 :second 44 :usec 3))
118 (string-time (iso-timestring time))
119 (time2 (parse-timestring string-time)))
121 3 44 15 14 4 1 2010 1 nil)
124 ;; relations of intervals
126 (let* ((time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
127 (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
128 (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
129 (time-4 (clsql:parse-timestring "2002-01-01 13:00:00"))
130 (interval-1 (clsql:make-interval :start time-1 :end time-2))
131 (interval-2 (clsql:make-interval :start time-2 :end time-3))
132 (interval-3 (clsql:make-interval :start time-3 :end time-4))
133 (interval-4 (clsql:make-interval :start time-1 :end time-3))
134 (interval-5 (clsql:make-interval :start time-2 :end time-4))
135 (interval-6 (clsql:make-interval :start time-1 :end time-4)))
136 (flet ((my-assert (number relation i1 i2)
137 (declare (ignore number))
138 (let ((found-relation (clsql:interval-relation i1 i2)))
139 (equal relation found-relation))))
141 (my-assert 1 :contains interval-1 interval-1)
142 (my-assert 2 :precedes interval-1 interval-2)
143 (my-assert 3 :precedes interval-1 interval-3)
144 (my-assert 4 :contained interval-1 interval-4)
145 (my-assert 5 :precedes interval-1 interval-5)
146 (my-assert 6 :contained interval-1 interval-6)
147 (my-assert 7 :follows interval-2 interval-1)
148 (my-assert 8 :contains interval-2 interval-2)
149 (my-assert 9 :precedes interval-2 interval-3)
150 (my-assert 10 :contained interval-2 interval-4)
151 (my-assert 11 :contained interval-2 interval-5)
152 (my-assert 12 :contained interval-2 interval-6)
153 (my-assert 13 :follows interval-3 interval-1)
154 (my-assert 14 :follows interval-3 interval-2)
155 (my-assert 15 :contains interval-3 interval-3)
156 (my-assert 16 :follows interval-3 interval-4)
157 (my-assert 17 :contained interval-3 interval-5)
158 (my-assert 18 :contained interval-3 interval-6)
159 (my-assert 19 :contains interval-4 interval-1)
160 (my-assert 20 :contains interval-4 interval-2)
161 (my-assert 21 :precedes interval-4 interval-3)
162 (my-assert 22 :contains interval-4 interval-4)
163 (my-assert 23 :overlaps interval-4 interval-5)
164 (my-assert 24 :contained interval-4 interval-6)
165 (my-assert 25 :follows interval-5 interval-1)
166 (my-assert 26 :contains interval-5 interval-2)
167 (my-assert 27 :contains interval-5 interval-3)
168 (my-assert 28 :overlaps interval-5 interval-4)
169 (my-assert 29 :contains interval-5 interval-5)
170 (my-assert 30 :contained interval-5 interval-6)
171 (my-assert 31 :contains interval-6 interval-1)
172 (my-assert 32 :contains interval-6 interval-2)
173 (my-assert 33 :contains interval-6 interval-3)
174 (my-assert 34 :contains interval-6 interval-4)
175 (my-assert 35 :contains interval-6 interval-5)
176 (my-assert 36 :contains interval-6 interval-6))))
179 ;; adjacent intervals in list
181 (let* ((interval-list nil)
182 (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
183 (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
184 (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
186 (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-3
189 (clsql:interval-push interval-list (clsql:make-interval :start time-3 :end time-4
191 (clsql:interval-relation (car interval-list) (cadr interval-list)))
194 ;; nested intervals in list
196 (let* ((interval-list nil)
197 (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
198 (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
199 (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
200 (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
202 (clsql:interval-push interval-list (clsql:make-interval :start time-1
206 (clsql:interval-push interval-list (clsql:make-interval :start time-2
209 (let* ((interval (car interval-list))
211 (when interval (car (clsql:interval-contained interval)))))
212 (when (and interval interval-contained)
213 (and (clsql:time= (clsql:interval-start interval) time-1)
214 (clsql:time= (clsql:interval-end interval) time-4)
215 (eq (clsql:interval-type interval) :open)
216 (clsql:time= (clsql:interval-start interval-contained) time-2)
217 (clsql:time= (clsql:interval-end interval-contained) time-3)
218 (eq (clsql:interval-type interval-contained) :closed)))))
221 ;; interval-edit - nonoverlapping
223 (let* ((interval-list nil)
224 (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
225 (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
226 (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
227 (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
228 (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-2 :type :open)))
229 (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-3 :end time-4 :type :closed)))
230 (setf interval-list (clsql:interval-edit interval-list time-1 time-1 time-3))
231 ;; should be time-3 not time-2
232 (clsql:time= (clsql:interval-end (car interval-list)) time-3))
235 ;; interval-edit - overlapping
237 (let* ((interval-list nil)
238 (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
239 (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
240 (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
241 (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
242 (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-2 :type :open)))
243 (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-2 :end time-4 :type :closed)))
248 (clsql:interval-edit interval-list time-1 time-1 time-3))
254 ;; interval-edit - nested intervals in list
256 (let* ((interval-list nil)
257 (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
258 (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
259 (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
260 (time-4 (clsql:parse-timestring "2002-01-01 13:00:00"))
261 (time-5 (clsql:parse-timestring "2002-01-01 14:00:00"))
262 (time-6 (clsql:parse-timestring "2002-01-01 15:00:00")))
263 (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-6 :type :open)))
264 (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-2 :end time-3 :type :closed)))
265 (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-4 :end time-5 :type :closed)))
266 (setf interval-list (clsql:interval-edit interval-list time-1 time-1 time-4))
267 ;; should be time-4 not time-6
268 (clsql:time= (clsql:interval-end (car interval-list)) time-4))
271 ;; Test the boundaries of Local Time with granularity of 1 year
273 (let ((sec-in-year (* 60 60 24 365))
274 (year (clsql:time-element (clsql:make-time) :year)))
276 (let ((date (clsql:make-time :second (* n sec-in-year))))
277 (unless (= (+ year n)
278 (clsql:time-element date :year))
282 ;; Test db-timestring
284 (flet ((grab-year (dbstring)
285 (parse-integer (subseq dbstring 1 5))))
286 (let ((second-in-year (* 60 60 24 365)))
288 (let* ((second (* -1 n second-in-year))
289 (date (clsql:make-time :year 2525 :second second)))
291 (= (grab-year (clsql:db-timestring date))
292 (clsql:time-element date :year))
296 ;; Conversion between MJD and Gregorian
298 (dotimes (base 10000 base)
299 (unless (= (apply #'clsql:gregorian-to-mjd (clsql:mjd-to-gregorian base))
304 ;; Clsql:Roll by minutes: +90
306 (let ((now (clsql:get-time)))
307 (clsql:time= (clsql:time+ now (clsql:make-duration :minute 90))
308 (clsql:roll now :minute 90)))
311 ;;Clsql:Roll by minutes: +900
313 (let ((now (clsql:get-time)))
314 (clsql:time= (clsql:time+ now (clsql:make-duration :minute 900))
315 (clsql:roll now :minute 900)))
319 ;; Clsql:Roll by minutes: +900
321 (let* ((now (clsql:get-time))
322 (add-time (clsql:time+ now (clsql:make-duration :minute 9000)))
323 (roll-time (clsql:roll now :minute 9000)))
324 (clsql:time= add-time roll-time))
329 ;;; The cross platform dataset uses the 'timestamp' column type which is
330 ;;; in sql-92, for all that means.
331 (deftest :time/cross-platform/no-usec/no-tz
332 (with-dataset *cross-platform-datetest*
333 (let ((time (parse-timestring "2008-09-09T14:37:29")))
334 (clsql-sys:insert-records :into [datetest]
335 :attributes '([testtime])
338 (first (clsql:select [testtime]
339 :from [datetest] :flatp t
340 :where [= [testtime] time] ))))
341 (format-time nil (parse-timestring testtime) :format :iso)
343 #.(format-time nil (parse-timestring "2008-09-09T14:37:29") :format :iso))
345 ;; I think the reasonable thing is that timezones be stripped and dates be
346 ;; converted to UTC, as the DB should be returning a zoneless stamp
347 (deftest :time/cross-platform/no-usec/tz
348 (with-dataset *cross-platform-datetest*
349 (let ((time (parse-timestring "2008-09-09T14:37:29-04:00")))
350 (clsql-sys:insert-records :into [datetest]
351 :attributes '([testtime])
354 (first (clsql:select [testtime]
355 :from [datetest] :flatp t
356 :where [= [testtime] time] ))))
357 (format-time nil (parse-timestring testtime) :format :iso)
359 ;; I think the reasonable thing is that timezones be stripped, as the DB should
360 ;; be returning a zoneless stamp
361 #.(format-time nil (parse-timestring "2008-09-09T18:37:29") :format :iso))
363 ;;;This test gets at the databases that only support miliseconds,
364 ;;; not microseconds.
365 (deftest :time/cross-platform/msec
366 (with-dataset *cross-platform-datetest*
367 (let ((time (parse-timestring "2008-09-09T14:37:29.423")))
368 (clsql-sys:insert-records :into [datetest]
369 :attributes '([testtime])
372 (first (clsql:select [testtime]
373 :from [datetest] :flatp t
374 :where [= [testtime] time] ))))
375 (format-time nil (parse-timestring testtime) :format :iso)
377 #.(format-time nil (parse-timestring "2008-09-09T14:37:29.423") :format :iso))
379 (deftest :time/cross-platform/usec/no-tz
380 (with-dataset *cross-platform-datetest*
381 (let ((time (parse-timestring "2008-09-09T14:37:29.000213")))
382 (clsql-sys:insert-records :into [datetest]
383 :attributes '([testtime])
386 (first (clsql:select [testtime]
387 :from [datetest] :flatp t
388 :where [= [testtime] time] ))))
389 (format-time nil (parse-timestring testtime) :format :iso)
391 #.(format-time nil (parse-timestring "2008-09-09T14:37:29.000213") :format :iso))
393 (deftest :time/cross-platform/usec/tz
394 (with-dataset *cross-platform-datetest*
395 (let ((time (parse-timestring "2008-09-09T14:37:29.000213-04:00")))
396 (clsql-sys:insert-records :into [datetest]
397 :attributes '([testtime])
400 (first (clsql:select [testtime]
403 :where [= [testtime] time] ))))
404 (format-time nil (parse-timestring testtime) :format :iso)
406 #.(format-time nil (parse-timestring "2008-09-09T18:37:29.000213") :format :iso))
411 ;;; All odbc databases use local times exclusively (they do not send timezone info)
412 ;;; Postgresql can use timezones, except when being used over odbc. This test when
413 ;;; run through both postgres socket and postgres odbc should test a fairly
414 ;;; broad swath of available problem space, Timestamptz should return UTC times,
415 ;;; timestamps should return zoneless local times
417 ;;; Things the following tests try to prove correct
418 ;;; * Reading and writing usec and usec-less times
419 ;;; * reading and writing timezones (Z=utc) when appropriate (eg: postgresql-socket)
420 ;;; * reading and writing localtimes when appropriate (eg: ODBC)
421 ;;; * reading and writing through both the oodml and fdml layers
425 (deftest :time/pg/fdml/usec
426 (with-dataset *ds-datetest*
427 (let ((time (parse-timestring "2008-09-09T14:37:29.000213-04:00")))
428 (clsql-sys:insert-records :into [datetest]
429 :attributes '([testtimetz] [testtime] [id])
430 :values (list time time 1))
431 (destructuring-bind (testtimetz testtime)
432 (first (clsql:select [testtimetz] [testtime]
435 :where [= [testtime] time] ))
436 (values (iso-timestring (parse-timestring testtime))
437 (iso-timestring (parse-timestring testtimetz))))))
438 #.(iso-timestring (parse-timestring "2008-09-09T18:37:29.000213"))
439 #.(iso-timestring (parse-timestring "2008-09-09T14:37:29.000213-04:00")))
441 (deftest :time/pg/oodml/no-usec
442 (with-dataset *ds-datetest*
443 (let ((time (parse-timestring "2008-09-09T14:37:29-04:00")))
444 (clsql-sys:update-records-from-instance
445 (make-instance 'datetest :testtimetz time :testtime time :id 1))
446 (let ((o (first (clsql:select
449 :where [= [testtime] time] ))))
450 (assert o (o) "o shouldnt be null here (we should have just inserted)")
451 (update-records-from-instance o)
452 (update-instance-from-records o)
453 (values (iso-timestring (testtime o))
454 (iso-timestring (testtimetz o))))))
455 #.(iso-timestring (parse-timestring "2008-09-09T18:37:29"))
456 #.(iso-timestring (parse-timestring "2008-09-09T14:37:29-04:00")))
458 (deftest :time/pg/oodml/usec
459 (with-dataset *ds-datetest*
460 (let ((time (parse-timestring "2008-09-09T14:37:29.000278-04:00")))
461 (clsql-sys:update-records-from-instance
462 (make-instance 'datetest :testtimetz time :testtime time :id 1))
463 (let ((o (first (clsql:select
466 :where [= [testtime] time] ))))
467 (assert o (o) "o shouldnt be null here (we should have just inserted)")
468 (update-records-from-instance o)
469 (update-instance-from-records o)
470 (values (iso-timestring (testtime o))
471 (iso-timestring (testtimetz o)))
473 #.(iso-timestring (parse-timestring "2008-09-09T18:37:29.000278"))
474 #.(iso-timestring (parse-timestring "2008-09-09T14:37:29.000278-04:00")))
476 (deftest :time/historic-datetimes
477 (with-dataset *cross-platform-datetest*
478 (let ((time (parse-timestring "1800-09-09T14:37:29")))
479 (clsql-sys:insert-records :into [datetest]
480 :attributes '([testtime])
483 (first (clsql:select [testtime]
484 :from [datetest] :flatp t
485 :where [= [testtime] time] ))))
486 (format-time nil (parse-timestring testtime) :format :iso)
488 #.(format-time nil (parse-timestring "1800-09-09T14:37:29") :format :iso))