@@ -120,10 +120,43 @@
 		  (if (and (null? results)
 			   (not (null? tal)))
 		      (loop (car tal)(cdr tal))
 		      (car results)))))))))
     
+;; get the previous record for when this test was run where all keys match but runname
+;; NB// Merge this with test:get-previous-test-run-records
+(define (test:get-matching-previous-test-run-records db run-id test-name item-path)
+  (let* ((keys    (db:get-keys db))
+	 (selstr  (string-intersperse (map (lambda (x)(vector-ref x 0)) keys) ","))
+	 (qrystr  (string-intersperse (map (lambda (x)(conc (vector-ref x 0) "=?")) keys) " AND "))
+	 (keyvals #f))
+    ;; first look up the key values from the run selected by run-id
+    (sqlite3:for-each-row 
+     (lambda (a . b)
+       (set! keyvals (cons a b)))
+     db
+     (conc "SELECT " selstr " FROM runs WHERE id=? ORDER BY event_time DESC;") run-id)
+    (if (not keyvals)
+	#f
+	(let ((prev-run-ids '()))
+	  (apply sqlite3:for-each-row
+		 (lambda (id)
+		   (set! prev-run-ids (cons id prev-run-ids)))
+		 db
+		 (conc "SELECT id FROM runs WHERE " qrystr " AND id != ?;") (append keyvals (list run-id)))
+	  ;; for each run starting with the most recent look to see if there is a matching test
+	  ;; if found then return that matching test record
+	  (debug:print 4 "selstr: " selstr ", qrystr: " qrystr ", keyvals: " keyvals ", previous run ids found: " prev-run-ids)
+	  (if (null? prev-run-ids) #f
+	      (let loop ((hed (car prev-run-ids))
+			 (tal (cdr prev-run-ids)))
+		(let ((results (db-get-tests-for-run db hed test-name item-path)))
+		  (debug:print 4 "Got tests for run-id " run-id ", test-name " test-name ", item-path " item-path ": " results)
+		  (if (and (null? results)
+			   (not (null? tal)))
+		      (loop (car tal)(cdr tal))
+		      results))))))))
 
 (define (test-set-status! db run-id test-name state status itemdat-or-path comment dat)
   (let* ((real-status status)
 	 (item-path   (if (string? itemdat-or-path) itemdat-or-path (item-list->path itemdat-or-path)))
 	 (otherdat    (if dat dat (make-hash-table)))
@@ -794,13 +827,55 @@
 	      ;; read configs with tricks turned off (i.e. no system)
 	      (test-conf    (if testexists (read-config test-configf #f #f)(make-hash-table))))
 	 (runs:update-test_meta db test-name test-conf)))
      test-names)))
 	 
-(define (runs:rollup-run db keys keynames keyvallst n)
+;; This could probably be refactored into one complex query ...
+(define (runs:rollup-run db keys)
   (let* ((new-run-id   (register-run db keys))
-	 (similar-runs (db:get-runs db keys))
-	 (tests-n-days (db:get-tests-n-days db similar-runs)))
+	 (prev-tests   (test:get-matching-previous-test-run-records db new-run-id "%" "%"))
+	 (curr-tests   (db-get-tests-for-run db new-run-id "%" "%"))
+	 (curr-tests-hash (make-hash-table)))
+    ;; index the already saved tests by testname and itempath in curr-tests-hash
+    (for-each
+     (lambda (testdat)
+       (let* ((testname  (db:test-get-testname testdat))
+	      (item-path (db:test-get-item-path testdat))
+	      (full-name (conc testname "/" item-path)))
+	 (hash-table-set! curr-tests-hash full-name testdat)))
+     curr-tests)
+    ;; now for each test record found, if it is more recent than that which is stored in
+    ;; the db then:
+    ;;   1. update the db with all data from the newer record
+    ;;   2. update the lookup table
     (for-each 
-     (lambda (test-id)
-       (db:rollup-test db run-id test-id))
-     tests-n-days)))
+     (lambda (testdat)
+       (let* ((testname  (db:test-get-testname testdat))
+	      (item-path (db:test-get-item-path testdat))
+	      (full-name (conc testname "/" item-path))
+	      (prev-test-dat (hash-table-ref/default curr-tests-hash full-name #f)))
+	 ;; if testdat is more recent than prev-test-dat or if there is no prev-test-dat
+	 ;; then update the database and the hash table with this new record
+	 (if (or (not prev-test-dat)
+		 (> (db:test-get-event_time testdat)
+		    (db:test-get-event_time prev-test-dat)))
+	     (let ((test-steps      (db:get-steps-for-test db (db:test-get-id testdat)))
+		   (new-test-record #f))
+	       ;; replace these with insert ... select
+	       (apply sqlite3:execute 
+		db 
+		(conc "INSERT OR REPLACE INTO tests (run_id,testname,state,status,event_time,host,cpuload,diskfree,uname,rundir,item_path,run_duration,final_logf,comment,value,expected_value,tol,units,first_err,first_warn) "
+		      "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);")
+		new-run-id (cddr (vector->list testdat)))
+	       (set! new-testdat (car (db-get-tests-for-run db new-run-id testname item-path)))
+	       (hash-table-set! curr-tests-hash full-name new-testdat) ;; this could be confusing, which record should go into the lookup table?
+	       ;; Now duplicate the test steps
+	       (debug:print 4 "Copying records in test_steps from test_id=" (db:test-get-id testdat) " to " (db:test-get-id new-testdat))
+	       (sqlite3:execute 
+		db 
+		(conc "INSERT OR REPLACE INTO test_steps (test_id,stepname,state,status,event_time,comment) "
+		      "SELECT " (db:test-get-id new-testdat) ",stepname,state,status,event_time,comment FROM test_steps WHERE test_id=?;")
+		(db:test-get-id testdat))
+	       ))))
+     prev-tests)))
+	 
+