@@ -71,10 +71,11 @@
 ;;
 (defstruct dbr:counts
   (state #f)
   (status #f)
   (count  0)) 
+
 
 ;;======================================================================
 ;; hash of hashs
 ;;======================================================================
 
@@ -125,23 +126,16 @@
 	   (debug:print-error 0 *default-log-port* " query " stmt " failed, params: " params ", error: " ((condition-property-accessor 'exn 'message) exn) ", exn=" exn)
 	   (print-call-chain (current-error-port))
 	   default)))
    (apply sqlite3:first-result db stmt params)))
 
-(define (db:generic-error-printout exn . message)
-  (print-call-chain (current-error-port))
-  (apply debug:print-error 0 *default-log-port* message)
-  (debug:print-error 0 *default-log-port* ;; "   params: " params
-		     ", error: "     ((condition-property-accessor 'exn 'message)   exn)
-		     ", arguments: " ((condition-property-accessor 'exn 'arguments) exn)
-		     ", location: "  ((condition-property-accessor 'exn 'location)  exn)
-		     ))
-
 (define (db:setup do-sync)
   (assert *toppath* "FATAL: db:setup called before launch:setup has been run.")
   (let* ((tmpdir (common:get-db-tmp-area)))
-    (dbfile:setup do-sync *toppath* tmpdir)))
+    (if (not *dbstruct-dbs*)
+	(dbfile:setup do-sync *toppath* tmpdir)
+	*dbstruct-dbs*)))
 
 ;; looks up subdb and returns it, if not found then set up
 ;; and then return it.
 ;;
 #;(define (db:get-db dbstruct run-id)
@@ -194,59 +188,10 @@
 		     ", error: "     ((condition-property-accessor 'exn 'message)   exn)
 		     ", arguments: " ((condition-property-accessor 'exn 'arguments) exn)
 		     ", location: "  ((condition-property-accessor 'exn 'location)  exn)
 		     ))
 
-(define (db:open-db dbstruct run-id)
-  (let* ((dbdat (dbfile:open-db dbstruct run-id db:initialize-main-db)))
-    (set! *db-write-access* (not (dbr:dbdat-read-only dbdat)))
-    dbdat))
-
-;; (db:with-db dbstruct run-id sqlite3:exec "select blah fgrom blaz;")
-;; r/w is a flag to indicate if the db is modified by this query #t = yes, #f = no
-;;
-(define (db:with-db dbstruct run-id r/w proc . params)
-  (let* ((have-struct (dbr:dbstruct? dbstruct))
-         (dbdat     (if have-struct                ;; this stuff just allows us to call with a db handle directly
-			(db:open-db dbstruct run-id) ;; (dbfile:get-subdb dbstruct run-id)
-			#f))
-	 (db        (if have-struct                ;; this stuff just allows us to call with a db handle directly
-			(dbr:dbdat-dbh dbdat)
-			dbstruct))
-	 (fname     (if dbdat
-			(dbr:dbdat-dbfile dbdat)
-			"nofilenameavailable"))
-	 #;(subdb     (if have-struct
-			(dbfile:get-subdb dbstruct run-id)
-			#f))
-	 (use-mutex (> *api-process-request-count* 25))) ;; was 25
-    (if (and use-mutex
-	     (common:low-noise-print 120 "over-50-parallel-api-requests"))
-	(debug:print-info 0 *default-log-port* *api-process-request-count* " parallel api requests being processed in process " (current-process-id) ", throttling access"))
-    (if (common:low-noise-print 600 (conc "parallel-api-requests" *max-api-process-requests*))
-	(debug:print-info 1 *default-log-port* "Parallel api request count: " *api-process-request-count* " max parallel requests: " *max-api-process-requests*))
-    (condition-case
-	(begin
-	  (if use-mutex (mutex-lock! *db-with-db-mutex*))
-	  (let ((res (apply proc dbdat db params)))
-	    (if use-mutex (mutex-unlock! *db-with-db-mutex*))
-	    ;; (if (vector? dbstruct)(db:done-with dbstruct run-id r/w))
-	    (if dbdat
-		(dbfile:add-dbdat dbstruct run-id dbdat))
-	    res))
-      (exn (io-error)
-	   (db:generic-error-printout exn "ERROR: i/o error with " fname ". Check permissions, disk space etc. and try again."))
-      (exn (corrupt)
-	   (db:generic-error-printout exn "ERROR: database " fname " is corrupt. Repair it to proceed."))
-      (exn (busy)
-	   (db:generic-error-printout exn "ERROR: database " fname
-				      " is locked. Try copying to another location, remove original and copy back."))
-      (exn (permission)(db:generic-error-printout exn "ERROR: database " fname " has some permissions problem."))
-      (exn ()
-	   (db:generic-error-printout exn "ERROR: Unknown error with database " fname " message: "
-				      ((condition-property-accessor 'exn 'message) exn))))))
-      
 
 ;; NB// #f => return dbdir only
 ;;      (was planned to be;  zeroth db with name=main.db)
 ;; 
 ;; If run-id is #f return to create and retrieve the path where the db will live.
@@ -430,31 +375,10 @@
     (if (and dbexists (not write-access))
 	(set! *db-write-access* #f))
     ;; (cons db dbpath)))
     (make-dbr:dbdat dbfile: dbpath dbh: db read-only: (not write-access))))
 
-;; sync run from tmp disk to nfs disk if touched
-;;
-(define (db:sync-touched dbstruct run-id #!key (force-sync #f))
-  (debug:print-info 0 *default-log-port* "db:sync-touched Syncing: " (conc (if run-id run-id "main") ".db"))
-  (let* (;; the subdb is needed to access the mtdbdat
-	 (subdb     (or (dbfile:get-subdb dbstruct run-id)
-			(dbfile:init-subdb dbstruct run-id db:initialize-main-db)))
-         (tmpdbfile (dbr:subdb-tmpdbfile subdb))
-	 (mtdb      (dbr:subdb-mtdbdat subdb))
-         (tmpdb     (dbfile:open-db dbstruct run-id db:initialize-main-db)) ;; sqlite3-db tmpdbfile #f))
-	 (start-t   (current-seconds)))
-    (mutex-lock! *db-multi-sync-mutex*)
-    (let ((update_info (cons "last_update" (if force-sync 0 *db-last-sync*) )))
-      (mutex-unlock! *db-multi-sync-mutex*)
-      (db:sync-tables (db:sync-all-tables-list dbstruct) update_info tmpdb mtdb))
-    (mutex-lock! *db-multi-sync-mutex*)
-    (set! *db-last-sync* start-t)
-    (set! *db-last-access* start-t)
-    (mutex-unlock! *db-multi-sync-mutex*)
-    (dbfile:add-dbdat dbstruct run-id tmpdb)
-  #t))
 
 
 ;; db:safely-close-sqlite3-db and db:close-all were here, moved to dbfile
 
 ;;   (let ((locdbs (dbr:dbstruct-locdbs dbstruct)))
@@ -468,110 +392,10 @@
 ;; 	 (handler (make-busy-timeout 3600)))
 ;;     (sqlite3:set-busy-handler! db handler)
 ;;     (db:initialize-run-id-db db)
 ;;     (cons db #f)))
 
-;; just tests, test_steps and test_data tables
-(define db:sync-tests-only
-  (list
-   ;; (list "strs"
-   ;;       '("id"             #f)
-   ;;       '("str"            #f))
-   (list "tests" 
-	 '("id"             #f)
-	 '("run_id"         #f)
-	 '("testname"       #f)
-	 '("host"           #f)
-	 '("cpuload"        #f)
-	 '("diskfree"       #f)
-	 '("uname"          #f)
-	 '("rundir"         #f)
-	 '("shortdir"       #f)
-	 '("item_path"      #f)
-	 '("state"          #f)
-	 '("status"         #f)
-	 '("attemptnum"     #f)
-	 '("final_logf"     #f)
-	 '("logdat"         #f)
-	 '("run_duration"   #f)
-	 '("comment"        #f)
-	 '("event_time"     #f)
-	 '("fail_count"     #f)
-	 '("pass_count"     #f)
-	 '("archived"       #f)
-         '("last_update"    #f))
-  (list "test_steps"
-	 '("id"             #f)
-	 '("test_id"        #f)
-	 '("stepname"       #f)
-	 '("state"          #f)
-	 '("status"         #f)
-	 '("event_time"     #f)
-	 '("comment"        #f)
-	 '("logfile"        #f)
-         '("last_update"    #f))
-   (list "test_data"
-	 '("id"             #f)
-	 '("test_id"        #f)
-	 '("category"       #f)
-	 '("variable"       #f)
-	 '("value"          #f)
-	 '("expected"       #f)
-	 '("tol"            #f)
-	 '("units"          #f)
-	 '("comment"        #f)
-	 '("status"         #f)
-	 '("type"           #f)
-         '("last_update"    #f))))
-
-;; needs db to get keys, this is for syncing all tables
-;;
-(define (db:sync-main-list dbstruct)
-  (let ((keys  (db:get-keys dbstruct)))
-    (list
-     (list "keys"
-	   '("id"        #f)
-	   '("fieldname" #f)
-	   '("fieldtype" #f))
-     (list "metadat" '("var" #f) '("val" #f))
-     (append (list "runs" 
-		   '("id"  #f))
-	     (map (lambda (k)(list k #f))
-		  (append keys
-			  (list "runname" "state" "status" "owner" "event_time" "comment" "fail_count" "pass_count" "contour" "last_update"))))
-     (list "archive_disks"
-           '("id" #f)
-           '("archive_area_name" #f) 
-           '("disk_path" #f)
-           '("last_df" #f)
-           '("last_df_time" #f)
-           '("creation_time" #f)) 
-
-     (list "archive_blocks"
-           '("id" #f)
-           '("archive_disk_id" #f) 
-           '("disk_path" #f)
-           '("last_du" #f)
-           '("last_du_time" #f)
-           '("creation_time" #f)) 
-
-     (list "test_meta"
-	   '("id"             #f)
-	   '("testname"       #f)
-	   '("owner"          #f)
-	   '("description"    #f)
-	   '("reviewed"       #f)
-	   '("iterated"       #f)
-	   '("avg_runtime"    #f)
-	   '("avg_disk"       #f)
-	   '("tags"           #f)
-	   '("jobgroup"       #f)))))
-
-(define (db:sync-all-tables-list dbstruct)
-  (append (db:sync-main-list dbstruct)
-	  db:sync-tests-only))
-
 ;; use bunch of Unix commands to try to break the lock and recreate the db
 ;;
 (define (db:move-and-recreate-db dbdat)
   (let* ((dbpath   (dbr:dbdat-dbfile        dbdat))
 	 (dbdir    (pathname-directory       dbpath))
@@ -645,240 +469,10 @@
 	   (sqlite3:execute db "vacuum;")))
 	 
 	 (sqlite3:finalize! db)
 	 #t))))))
     
-;; tbls is ( ("tablename" ( "field1" [#f|proc1] ) ( "field2" [#f|proc2] ) .... ) )
-;; db's are dbdat's
-;;
-;; if last-update specified ("field-name" . time-in-seconds)
-;;    then sync only records where field-name >= time-in-seconds
-;;    IFF field-name exists
-;;
-(define (db:sync-tables tbls last-update fromdb todb . slave-dbs)
-  (handle-exceptions
-   exn
-   (begin
-     (debug:print 0 *default-log-port* "EXCEPTION: database probably overloaded or unreadable in db:sync-tables.")
-     (print-call-chain (current-error-port))
-     (debug:print 0 *default-log-port* " message: " ((condition-property-accessor 'exn 'message) exn))
-     (debug:print 0 *default-log-port* "exn=" (condition->list exn))
-     (debug:print 0 *default-log-port* " status:  " ((condition-property-accessor 'sqlite3 'status) exn))
-     (debug:print 0 *default-log-port* " src db:  " (dbr:dbdat-dbfile fromdb))
-     (for-each (lambda (dbdat)
-		 (let ((dbpath (dbr:dbdat-dbfile dbdat)))
-		   (debug:print 0 *default-log-port* " dbpath:  " dbpath)
-		   (if (not (db:repair-db dbdat))
-		       (begin
-			 (debug:print-error 0 *default-log-port* "Failed to rebuild " dbpath ", exiting now.")
-			 (exit)))))
-	       (cons todb slave-dbs))
-     
-     0)
-
-   ;; this is the work to be done")
-   (cond
-    ((not fromdb) (debug:print 0 *default-log-port* "WARNING: db:sync-tables called with fromdb missing")
-     -1)
-    ((not todb)   (debug:print 0 *default-log-port* "WARNING: db:sync-tables called with todb missing")
-     -2)
-    ((not (sqlite3:database? (dbr:dbdat-dbh fromdb)))
-     (debug:print-error 0 *default-log-port* "db:sync-tables called with fromdb not a database " fromdb)
-   -3)
-    ((not (sqlite3:database? (dbr:dbdat-dbh todb)))
-     (debug:print-error 0 *default-log-port* "db:sync-tables called with todb not a database " todb)
-   -4)
-
-    ((not (file-write-access? (dbr:dbdat-dbfile todb)))
-     (debug:print-error 0 *default-log-port* "db:sync-tables called with todb not a read-only database " todb)
-     -5)
-    ((not (null? (let ((readonly-slave-dbs
-                        (filter
-                         (lambda (dbdat)
-                           (not (file-write-access? (dbr:dbdat-dbfile todb))))
-                         slave-dbs)))
-                   (for-each
-                    (lambda (bad-dbdat)
-                      (debug:print-error
-                       0 *default-log-port* "db:sync-tables called with todb not a read-only database " bad-dbdat))
-                    readonly-slave-dbs)
-                   readonly-slave-dbs))) -6)
-    (else
-     (debug:print 3 *default-log-port* "db:sync-tables: args are good")
-
-     (let ((stmts       (make-hash-table)) ;; table-field => stmt
-	   (all-stmts   '())              ;; ( ( stmt1 value1 ) ( stml2 value2 ))
-	   (numrecs     (make-hash-table))
-	   (start-time  (current-milliseconds))
-	   (tot-count   0))
-       (for-each ;; table
-	(lambda (tabledat)
-	  (let* ((tablename        (car tabledat))
-		 (fields           (cdr tabledat))
-		 (has-last-update  (member "last_update" fields))
-		 (use-last-update  (cond
-				    ((and has-last-update
-					  (member "last_update" fields))
-				     #t) ;; if given a number, just use it for all fields
-				    ((number? last-update) #f) ;; if not matched first entry then ignore last-update for this table
-				    ((and (pair? last-update)
-					  (member (car last-update)    ;; last-update field name
-						  (map car fields)))
-                                        #t)
-				    ((and last-update (not (pair? last-update)) (not (number? last-update)))
-				     (debug:print 0 *default-log-port* "ERROR: parameter last-update for db:sync-tables must be a pair or a number, received: " last-update);; found in fields
-				     #f)
-				    (else
-				     #f)))
-		 (last-update-value (if use-last-update ;; no need to check for has-last-update - it is already accounted for
-					(if (number? last-update)
-					    last-update
-					    (cdr last-update))
-					#f))
-		 (last-update-field (if use-last-update
-					(if (number? last-update)
-					    "last_update"
-					    (car last-update))
-					#f))
-		 (num-fields (length fields))
-		 (field->num (make-hash-table))
-		 (num->field (apply vector (map car fields))) ;; BBHERE
-		 (full-sel   (conc "SELECT " (string-intersperse (map car fields) ",") 
-				   " FROM " tablename (if use-last-update ;; apply last-update criteria
-							  (conc " WHERE " last-update-field " >= " last-update-value)
-							  "")
-				   ";"))
-		 (full-ins   (conc "INSERT OR REPLACE INTO " tablename " ( " (string-intersperse (map car fields) ",") " ) "
-				   " VALUES ( " (string-intersperse (make-list num-fields "?") ",") " );"))
-		 (fromdat    '())
-		 (fromdats   '())
-		 (totrecords 0)
-		 (batch-len  (string->number (or (configf:lookup *configdat* "sync" "batchsize") "100")))
-		 (todat      (make-hash-table))
-		 (count      0)
-                 (field-names (map car fields))
-                 (delay-handicap  (string->number (or (configf:lookup *configdat* "sync" "delay-handicap") "0")))
-                 )
-
-	    ;; set up the field->num table
-	    (for-each
-	     (lambda (field)
-	       (hash-table-set! field->num field count)
-	       (set! count (+ count 1)))
-	     fields)
-
-	    ;; read the source table
-            ;; store a list of all rows in the table in fromdat, up to batch-len.
-            ;; Then add fromdat to the fromdats list, clear fromdat and repeat.
-	    (sqlite3:for-each-row
-	     (lambda (a . b)
-	       (set! fromdat (cons (apply vector a b) fromdat))
-	       (if (> (length fromdat) batch-len)
-		   (begin
-		     (set! fromdats (cons fromdat fromdats))
-		     (set! fromdat  '())
-		     (set! totrecords (+ totrecords 1)))
-               )
-             )
-	     (dbr:dbdat-dbh fromdb)
-	     full-sel)
-
-             ;; Count less than batch-len as a record
-             (if (> (length fromdat) 0)
-                 (set! totrecords (+ totrecords 1)))
-
-	    ;; tack on remaining records in fromdat
-	    (if (not (null? fromdat))
-		(set! fromdats (cons fromdat fromdats)))
-
-	    (if (common:low-noise-print 120 "sync-records")
-		(debug:print 0 *default-log-port* "found " totrecords " records to sync"))
-
-	    (sqlite3:for-each-row
-	     (lambda (a . b)
-	       (hash-table-set! todat a (apply vector a b)))
-	     (dbr:dbdat-dbh todb)
-	     full-sel)
-
-            (when (and delay-handicap (> delay-handicap 0))
-              (debug:print-info 0 *default-log-port* "imposing synthetic sync delay of "delay-handicap" seconds since sync/delay-handicap is configured")
-              (thread-sleep! delay-handicap)
-              (debug:print-info 0 *default-log-port* "synthetic sync delay of "delay-handicap" seconds completed")
-              )
-            
-	    ;; first pass implementation, just insert all changed rows
-
-	    (for-each 
-	     (lambda (targdb)
-	       (let* ((db                 (dbr:dbdat-dbh targdb))
-                      (drp-trigger        (if (member "last_update" field-names)
-					      (db:drop-trigger db tablename) 
-					      #f))
-                      (is-trigger-dropped (if (member "last_update" field-names)
-                                              (db:is-trigger-dropped db tablename)
-					      #f)) 
-		      (stmth  (sqlite3:prepare db full-ins))
-                      (changed-rows 0))
-		 ;; (db:delay-if-busy targdb) ;; NO WAITING
-                 (if (member "last_update" field-names)
-                     (debug:print-info 3 *default-log-port* "is-trigger-dropped: " is-trigger-dropped)) 
-
-		 (for-each
-		  (lambda (fromdat-lst)
-		    (sqlite3:with-transaction
-		     db
-		     (lambda ()
-		       (for-each ;; 
-			(lambda (fromrow)
-			  (let* ((a    (vector-ref fromrow 0))
-				 (curr (hash-table-ref/default todat a #f))
-				 (same #t))
-			    (let loop ((i 0))
-			      (if (or (not curr)
-				      (not (equal? (vector-ref fromrow i)(vector-ref curr i))))
-				  (set! same #f))
-			      (if (and same
-				       (< i (- num-fields 1)))
-				  (loop (+ i 1))))
-			    (if (not same)
-				(begin
-				  (apply sqlite3:execute stmth (vector->list fromrow))
-				  (hash-table-set! numrecs tablename (+ 1 (hash-table-ref/default numrecs tablename 0)))
-                                  (set! changed-rows (+ changed-rows 1))
-                                )
-                            )
-                            ))
-			fromdat-lst))))
-		  fromdats)
-
-
-                 (if (> changed-rows 0)
-	           (debug:print 0 *default-log-port* "table " tablename " changed rows: " changed-rows)
-                 )
-
-
-		 (sqlite3:finalize! stmth)
-                 (if (member "last_update" field-names)
-                    (db:create-trigger db tablename))))
-	     (append (list todb) slave-dbs)
-           )
-          )
-        )
-	tbls)
-       (let* ((runtime      (- (current-milliseconds) start-time))
-	      (should-print (or (debug:debug-mode 12)
-				(common:low-noise-print 120 "db sync" (> runtime 500))))) ;; low and high sync times treated as separate.
-	 (if should-print (debug:print 0 *default-log-port* "INFO: db sync, total run time " runtime " ms"))
-	 (for-each 
-	  (lambda (dat)
-	    (let ((tblname (car dat))
-		  (count   (cdr dat)))
-	      (set! tot-count (+ tot-count count))
-	      (if (> count 0)
-		  (if should-print (debug:print 0 *default-log-port* (format #f "    ~10a ~5a" tblname count))))))
-	  (sort (hash-table->alist numrecs)(lambda (a b)(> (cdr a)(cdr b))))))
-       tot-count)))))
 
 (define (db:patch-schema-rundb frundb)
   ;;
   ;; remove this some time after September 2016 (added in version v1.6031
   ;;
@@ -1039,11 +633,11 @@
 ;; 			  (lambda ()
 ;; 			    (if (and (common:file-exists? megatest-db)
 ;; 				     (file-write-access? megatest-db))
 ;; 				(begin
 ;; 				  (db:sync-to-megatest.db dbstruct 'timestamps) ;; internally mutexes on *db-local-sync*
-;; 				  (debug:print-info 2 *default-log-port* "Done syncing to megatest.db"))))
+;; 				  (debug:print-info 2 *default-log-port* "Done syncing to megatest.db")))) 
 ;; 			  "call-with-cached-db sync-to-megatest.db"))
 ;; 	       (cache-db (db:cache-for-read-only
 ;; 			  megatest-db
 ;; 			  (conc cache-dir "/" fname)
 ;; 			  use-last-update: #t)))
@@ -1051,37 +645,13 @@
 ;; 	  (apply proc cache-db params)
 ;; 	  ))))
 
 
 
-
-;; Get a lock from the no-sync-db for the from-db, then delta sync the from-db to the to-db, otherwise return #f
-
-(define (db:lock-and-delta-sync no-sync-db dbstruct from-db-file runid)
-  (assert (not *db-sync-in-progress*) "FATAL: db:lock-and-sync called while a sync is in progress.")
-  (debug:print-info 3 *default-log-port* "db:lock-and-delta-sync")
-  (let* ((lockdat  (db:no-sync-get-lock no-sync-db from-db-file))
-	 (gotlock  (car lockdat))
-	 (locktime (cdr lockdat)))
-
-    (debug:print-info 3 *default-log-port* "db:lock-and-delta-sync: got lock?")
-    (if gotlock
-	(begin
-          (debug:print 0 *default-log-port* "db:lock-and-delta-sync copying db "runid" at "(current-seconds))
-          (db:sync-touched dbstruct runid)
-	  (db:no-sync-del! no-sync-db from-db-file)
-	  #t)
-        (begin
-          (debug:print 0 *default-log-port* "could not get lock for " from-db-file " from no-sync-db")
-	  #f
-        ))))
-
-
-
 
 (define (db:all-db-sync dbstruct)
-  (let* ((dbdat (db:open-db dbstruct #f))
+  (let* ((dbdat (db:open-db dbstruct #f db:initialize-main-db))
 	 (data-synced       0) ;; count of changed records
     (tmp-area       (common:get-db-tmp-area))
     (dbfiles        (glob (conc tmp-area"/.db/*.db")))
     (sync-durations (make-hash-table))
     (no-sync-db        (db:open-no-sync-db)))
@@ -1117,11 +687,11 @@
               (fname (pathname-file file))
               (runid (if (string= fname "main") #f (string->number fname)))
               )
 	       (debug:print-info 3 *default-log-port* "db:all-db-sync: fname: "
 				 fname", delta: " (- time1 time2) " seconds")
-	       (db:lock-and-delta-sync no-sync-db dbstruct fname runid)
+	       (db:lock-and-delta-sync no-sync-db dbstruct fname runid (db:get-keys dbstruct) db:initialize-main-db)
 	       (hash-table-set! sync-durations (conc fname".db")
 				(- (current-milliseconds) start-time)))
 	     (debug:print-info 3 *default-log-port* "skipping sync. " file " is up to date")
          )))
      dbfiles
@@ -1142,125 +712,67 @@
 ;;
 (define (db:multi-db-sync dbstruct . options)
   (let* ((dbdat       (db:open-db dbstruct #f))
 	 (data-synced 0) ;; count of changed records
     (tmp-area       (common:get-db-tmp-area))
-    (dbfiles        (glob (conc tmp-area"/.db/*.db")))
-    (sync-durations (make-hash-table)))
-    (for-each
-     (lambda (file)
-       (debug:print-info 0 *default-log-port* "file: " file)
-       (let* ((fname (conc (pathname-file file) ".db"))
-	      (fulln (conc *toppath*"/.db/"fname))
-	      (time1 (if (file-exists? file)
-			 (file-modification-time file)
-			 (begin
-			   (debug:print-info 0 *default-log-port* "Sync - I do not see file "file)
-			   1)))
-	      (time2 (if (file-exists? fulln)
-			 (file-modification-time fulln)
-			 (begin
-			   (debug:print-info 0 *default-log-port* "Sync - I do not see file "fulln)
+    (old2new (member 'old2new options)) 
+    (src-area (if old2new *toppath* tmp-area))
+    (dest-area (if old2new tmp-area *toppath*))
+    (dbfiles        (glob (conc tmp-area"/.db/*.db")))
+    (keys (db:get-keys dbstruct))
+    (sync-durations (make-hash-table)))
+
+    (for-each
+     (lambda (srcfile)
+       (debug:print-info 0 *default-log-port* "file: " srcfile)
+       (let* ((fname (conc (pathname-file srcfile) ".db"))
+              (basename (pathname-file srcfile))
+              (run-id (if (string= basename "main") #f (string->number basename)))
+	      (destfile (conc dest-area "/.db/" fname))
+	      (time1 (file-modification-time srcfile))
+
+              (time2 (if (file-exists? destfile)
+			 (file-modification-time destfile)
+			 (begin
+			   (debug:print-info 0 *default-log-port* "Sync - I do not see file " destfile)
 			   0)))
 	      (changed (> time1 time2))
-	      (do-cp (cond
-		      ((not (file-exists? fulln)) ;; shouldn't happen, but this might recover
-		       (debug:print-info 0 *default-log-port* "File "fulln" not found! Copying "fname" to "fulln)
+
+      (do-cp (cond
+		      ((not (file-exists? destfile)) ;; shouldn't happen, but this might recover
+		       (debug:print-info 0 *default-log-port* "File " destfile " not found! Copying "srcfile" to "destfile)
 		       #t)
 		      (changed ;; (and changed
 		       ;; (> (- (current-seconds) time1) 3)) ;; if file is changed and three seconds have passed.
 		       #t)
 		      ((and changed *time-to-exit*) ;; last sync
 		       #t)
 		      (else
 		       #f))))
-	 (if do-cp
-	     (let* ((start-time (current-milliseconds)))
-	       (debug:print-info 0 *default-log-port* "delta sync delta file: " fname", delta: " (- time1 time2) " seconds")
-	       (db:lock-and-delta-sync *no-sync-db* file fulln)
-	       (hash-table-set! sync-durations (conc fname".db") (- (current-milliseconds) start-time)))
-	     (debug:print-info 0 *default-log-port* "skipping delta sync. " file " is up to date")
-         )
+          (if do-cp
+	     (let* (
+                    (start-time (current-milliseconds))
+
+                    (subdb (or (dbfile:get-subdb dbstruct run-id) (dbfile:init-subdb dbstruct run-id dbfile:db-init-proc)))
+                    (mtdb      (dbr:subdb-mtdbdat subdb))
+                    (tmpdb     (dbfile:open-db dbstruct run-id dbfile:db-init-proc))
+
+                    )
+	       (debug:print-info 0 *default-log-port* "delta syncing file: " srcfile ", time diff: " (- time1 time2) " seconds")
+               (if old2new
+		 (db:sync-tables (db:sync-all-tables-list dbstruct (db:get-keys dbstruct)) #f mtdb tmpdb)
+		 (db:sync-tables (db:sync-all-tables-list dbstruct (db:get-keys dbstruct)) #f tmpdb mtdb)
+               )
+	       (hash-table-set! sync-durations (conc srcfile ".db") (- (current-milliseconds) start-time)))
+	     (debug:print-info 0 *default-log-port* "skipping delta sync. " srcfile " is up to date")
+          )
        )
      )
      dbfiles
     )
-
-
-    (hash-table->alist sync-durations)
-
-
-
-    (debug:print 0 *default-log-port* "db:multi-db-sync subdbs: " (hash-table-values (dbr:dbstruct-subdbs dbstruct)))
-    (for-each
-     (lambda (subdb)
-       (let* ((mtdb     (dbr:subdb-mtdbdat subdb))
-	      (tmpdbfile    (dbr:subdb-tmpdbfile subdb))
-              (main-tmpdb (dbfile:open-db dbstruct #f db:initialize-main-db))
-	      (allow-cleanup #t) ;; (if run-ids #f #t))
-	      (servers  (server:get-list *toppath*)) ;; (tasks:get-all-servers (db:delay-if-busy tdbdat)))
-	      )    
-         (debug:print 0 *default-log-port* "db:multi-db-sync mtdb: " mtdb " tmpdbfile:" tmpdbfile )
-	 (for-each
-	  (lambda (option)
-	    
-	    (case option
-	      ;; kill servers
-	      ((killservers)
-	       (for-each
-		(lambda (server)
-		  (handle-exceptions
-		      exn
-		      (begin 
-			(debug:print-info 0 *default-log-port*  "Unable to get host and/or port from " server ", exn=" exn)     
-			#f)
-		    (match-let (((mod-time host port start-time server-id pid) server))
-		      (if (and host pid)
-			  (tasks:kill-server host pid)))))
-		servers)
-	       
-	       ;; /tmp/bjbarcla/megatest_localdb/fullrun/.nfs.pdx.disks.icf_env_disk001.bjbarcla.gwa.issues.mtdev.matt-bisect.megatest.ext-tests.runs.all.v1.65.1.6524.dev.bb-24-justrollup-f8.rollup.fullrun/megatest.db.lock
-	       (delete-file* (common:get-sync-lock-filepath)))
-	      
-	      ;; clear out junk records
-	      ;;
-	      ((dejunk)
-	       ;; (db:delay-if-busy mtdb) ;; ok to delay on mtdb
-	       (when (file-write-access? (dbr:dbdat-dbfile mtdb)) (db:clean-up mtdb))
-	       (db:clean-up main-tmpdb)
-              )
-	      ;; sync from main dbs to /tmp ones.
-	      ;;
-	      ((old2new)
-	       (set! data-synced
-		 (+ (db:sync-tables (db:sync-all-tables-list dbstruct) #f mtdb main-tmpdb)
-		    data-synced)))
-	      
-	      ;; sync from /tmp dbs to main ones.
-	      ;;
-	      ((new2old)
-	       (set! data-synced
-		 (+ (db:sync-tables (db:sync-all-tables-list dbstruct) #f main-tmpdb mtdb)
-		    data-synced)))
-
-	      ((adj-target)
-	       (db:adj-target (dbr:dbdat-dbh mtdb))
-	       (db:adj-target (dbr:dbdat-dbh main-tmpdb))
-              )
-	      
-	      ((schema)
-	       (db:patch-schema-maindb (dbr:dbdat-dbh mtdb))
-	       (db:patch-schema-maindb (dbr:dbdat-dbh main-tmpdb))
-	       (db:patch-schema-rundb  (dbr:dbdat-dbh mtdb))
-	       (db:patch-schema-rundb  (dbr:dbdat-dbh main-tmpdb))
-               )
-              )
-	    (dbfile:add-dbdat dbstruct #f main-tmpdb))
-	  options)))
-     (hash-table-values (dbr:dbstruct-subdbs dbstruct)))
-    (if dbdat (dbfile:add-dbdat dbstruct #f dbdat))
-    data-synced)
+    data-synced
+  )
 )
 
 ;; Sync all changed db's
 ;;
 (define (db:tmp->megatest.db-sync dbstruct run-id last-update)
@@ -1270,11 +782,11 @@
      (lambda (subdb)
        (let* ((dbname (db:run-id->dbname run-id))
 	      (mtdb   (dbr:subdb-mtdb subdb))
 	      (tmpdb  (db:get-subdb dbstruct run-id))
 	      (refndb (dbr:subdb-refndb subdb))
-	      (newres (db:sync-tables (db:sync-all-tables-list dbstruct) last-update tmpdb refndb mtdb)))
+	      (newres (db:sync-tables (db:sync-all-tables-list dbstruct (db:get-keys dbstruct)) last-update tmpdb refndb mtdb)))
 	 ;; (stack-push! (dbr:subdb-dbstack subdb) tmpdb)
 	 (dbfile:add-dbdat dbstruct run-id tmpdb)
 	 (set! res (cons newres res))))
      subdbs)
     res))
@@ -1357,99 +869,10 @@
 #;(define open-run-close open-run-close-exception-handling)
 		;;	   open-run-close-no-exception-handling
 ;;			   open-run-close-exception-handling)
 ;;)
 
-(define db:trigger-list 
-     (list (list "update_runs_trigger"  "CREATE TRIGGER IF NOT EXISTS update_runs_trigger AFTER UPDATE ON runs
-                             FOR EACH ROW
-                               BEGIN 
-                                 UPDATE runs SET last_update=(strftime('%s','now'))
-                                   WHERE id=old.id;
-                               END;" ) 
-	   (list "update_run_stats_trigger"  "CREATE TRIGGER  IF NOT EXISTS update_run_stats_trigger AFTER UPDATE ON run_stats
-                             FOR EACH ROW
-                               BEGIN 
-                                 UPDATE run_stats SET last_update=(strftime('%s','now'))
-                                   WHERE id=old.id;
-                               END;" )
-	   (list "update_tests_trigger"  "CREATE TRIGGER  IF NOT EXISTS update_tests_trigger AFTER UPDATE ON tests
-                             FOR EACH ROW
-                               BEGIN 
-                                 UPDATE tests SET last_update=(strftime('%s','now'))
-                                   WHERE id=old.id;
-                               END;" )
-	   (list "update_teststeps_trigger"  "CREATE TRIGGER  IF NOT EXISTS update_teststeps_trigger AFTER UPDATE ON test_steps
-                             FOR EACH ROW
-                               BEGIN 
-                                 UPDATE test_steps SET last_update=(strftime('%s','now'))
-                                   WHERE id=old.id;
-                               END;" )
-	   (list "update_test_data_trigger"  "CREATE TRIGGER  IF NOT EXISTS update_test_data_trigger AFTER UPDATE ON test_data
-                             FOR EACH ROW
-                               BEGIN 
-                                 UPDATE test_data SET last_update=(strftime('%s','now'))
-                                   WHERE id=old.id;
-                               END;" )))
-;;
-;; ADD run-id SUPPORT
-;;
-(define (db:create-all-triggers dbstruct)
-(db:with-db
-   dbstruct #f #f
-   (lambda (dbdat db)
-(db:create-triggers db))))
-
-(define (db:create-triggers db)
-    (for-each (lambda (key)
-              (sqlite3:execute db (cadr key)))
-          db:trigger-list))
-
-(define (db:drop-all-triggers dbstruct)
-  (db:with-db
-   dbstruct #f #f
-   (lambda (dbdat db)
-     (db:drop-triggers db))))
-
-(define (db:is-trigger-dropped db tbl-name)
-  (let* ((trigger-name (if (equal? tbl-name "test_steps")
-			   "update_teststeps_trigger" 
-                           (conc "update_" tbl-name "_trigger")))
-	 (res          #f))
-    (sqlite3:for-each-row
-     (lambda (name)
-       (if (equal? name trigger-name)
-	   (set! res #t)))
-     db 
-     "SELECT name FROM sqlite_master WHERE type = 'trigger' ;" 
-     )))
-
-(define (db:drop-triggers db)
-  (for-each
-   (lambda (key) 
-     (sqlite3:execute db (conc "drop trigger if exists " (car key))))
-   db:trigger-list))
-
-(define  (db:drop-trigger db tbl-name)
-  (let* ((trigger-name (if (equal? tbl-name "test_steps")
-			   "update_teststeps_trigger" 
-                           (conc "update_" tbl-name "_trigger"))))
-    (for-each
-     (lambda (key) 
-       (if (equal? (car key) trigger-name)
-           (sqlite3:execute db (conc "drop trigger if exists " trigger-name))))
-     db:trigger-list)))
-
-(define  (db:create-trigger db tbl-name)
-      (let* ((trigger-name (if (equal? tbl-name "test_steps")
-                              "update_teststeps_trigger" 
-                              (conc "update_" tbl-name "_trigger"))))
-       (for-each (lambda (key) 
-             (if (equal? (car key) trigger-name)
-             (sqlite3:execute db (cadr key))))
-      db:trigger-list))) 
-
 
 (define (db:initialize-main-db db)
   (when (not *configinfo*)
            (launch:setup)) ;; added because Elena was getting stack dump because *configinfo* below was #f.
   (let* ((configdat (car *configinfo*))  ;; tut tut, global warning...
@@ -2308,10 +1731,11 @@
 ;; using keys:config-get-fields?
 
 (define (db:get-keys dbstruct)
   (keys:config-get-fields *configdat*)
 )
+
 ;;  (if *db-keys* *db-keys* 
 ;;      (let ((res '()))
 ;;	(db:with-db dbstruct #f #f
 ;;		    (lambda (dbdat db)
 ;;		      (sqlite3:for-each-row 
@@ -2438,16 +1862,18 @@
 	 (andstr    (if (> (length keys) 0) " AND " ""))
 	 (valslots  (keys->valslots keys)) ;; ?,?,? ...
 	 (allvals   (append (list runname state status user contour) (map cadr keyvals)))
 	 (qryvals   (append (list runname) (map cadr keyvals)))
 	 (key=?str  (string-intersperse (map (lambda (k)(conc k "=?")) keys) " AND ")))
+  (debug:print 0 *default-log-port* "Got here 0.")
     (debug:print 3 *default-log-port* "keys: " keys " allvals: " allvals " keyvals: " keyvals " key=?str is " key=?str)
     (debug:print 2 *default-log-port* "NOTE: using target " (string-intersperse (map cadr keyvals) "/") " for this run")
     (if (and runname (null? (filter (lambda (x)(not x)) keyvals))) ;; there must be a better way to "apply and"
 	(db:with-db
 	 dbstruct #f #f
 	 (lambda (dbdat db)
+  (debug:print 0 *default-log-port* "Got here 1.")
 	   (let ((res #f))
 	     (apply sqlite3:execute db (conc "INSERT OR IGNORE INTO runs (runname,state,status,owner,event_time,contour" comma keystr ") VALUES (?,?,?,?,strftime('%s','now'),?" comma valslots ");")
 		    allvals)
 	     (apply sqlite3:for-each-row 
 		    (lambda (id)