Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -140,31 +140,22 @@
 ;;    if run-id is a string treat it as a filename
 ;;    if db already open - return inmem
 ;;    if db not open, open inmem, rundb and sync then return inmem
 ;;    inuse gets set automatically for rundb's
 ;;
-(define (db:get-db dbstruct run-id) 
-  (if (stack? (dbr:dbstruct-dbstack dbstruct))
-      (if (stack-empty? (dbr:dbstruct-dbstack dbstruct))
-          (let* ((dbname (db:run-id->dbname run-id))
-		 (newdb  (db:open-megatest-db path: (db:dbfile-path)
-					      name: dbname)))
-            ;; (stack-push! (dbr:dbstruct-dbstack dbstruct) newdb)
-            newdb)
-          (stack-pop! (dbr:dbstruct-dbstack dbstruct)))
-      (db:open-db dbstruct run-id)))
-
-;; ;; legacy handling of structure for managing db's. Refactor this into dbr:?
-(define (db:dbdat-get-db dbdat)
-  (if (pair? dbdat)
-      (car dbdat)
-      dbdat))
-
-(define (db:dbdat-get-path dbdat)
-  (if (pair? dbdat)
-      (cdr dbdat)
-      #f))
+(define (db:get-db dbstruct run-id) ;; RENAME TO db:get-dbh
+  (let* ((subdb (dbfile:get-subdb dbstruct run-id)))
+    (if (stack? (dbr:subdb-dbstack subdb))
+	(if (stack-empty? (dbr:subdb-dbstack subdb))
+	    (let* ((dbname (db:run-id->dbname run-id))
+		   (newdb  (db:open-megatest-db path: (db:dbfile-path)
+						name: dbname)))
+	      ;; NOTE: pushing on the stack only happens AFTER the handle has been used
+	      ;; (stack-push! (dbr:dbstruct-dbstack dbstruct) newdb)
+	      newdb)
+          (stack-pop! (dbr:subdb-dbstack subdb)))
+	(db:open-db subdb run-id))))
 
 (define-inline (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
@@ -176,17 +167,22 @@
 ;; (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 
+         (dbdat     (if have-struct                ;; this stuff just allows us to call with a db handle directly
 			(db:get-db dbstruct run-id)
 			#f))
-	 (db        (if have-struct
-			(db:dbdat-get-db dbdat)
+	 (db        (if have-struct                ;; this stuff just allows us to call with a db handle directly
+			(dbr:dbdat-dbh dbdat)
 			dbstruct))
-	 (fname     (db:dbdat-get-path dbdat))
+	 (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*))
@@ -195,11 +191,11 @@
      (begin
        (if use-mutex (mutex-lock! *db-with-db-mutex*))
        (let ((res (apply proc db params)))
 	 (if use-mutex (mutex-unlock! *db-with-db-mutex*))
 	 ;; (if (vector? dbstruct)(db:done-with dbstruct run-id r/w))
-	 (if dbdat (stack-push! (dbr:dbstruct-dbstack dbstruct) dbdat))
+	 (if dbdat (stack-push! (dbr:subdb-dbstack subdb) 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."))
@@ -296,29 +292,28 @@
          (exn (busy)      (debug:print 0 *default-log-port* "ERROR: database " fname " is locked. Try copying to another location, remove original and copy back."))
          (exn (permission)(debug:print 0 *default-log-port* "ERROR: database " fname " has some permissions problem."))
          (exn () (debug:print 0 *default-log-port* "ERROR: Unknown error with database " fname " message: " ((condition-property-accessor 'exn 'message) exn))))
 	)))
 
-
 ;; This routine creates the db if not already present. It is only called if the db is not already opened
 ;;
-(define (db:open-db dbstruct run-id #!key (areapath #f)(do-sync #t)) ;; TODO: actually use areapath
-  (let ((tmpdb-stack (dbr:dbstruct-dbstack dbstruct))) ;; RA => Returns the first reference in dbstruct
+(define (db:open-db subdb run-id #!key (areapath #f)(do-sync #t)) ;; TODO: actually use areapath
+  (let* ((tmpdb-stack (dbr:subdb-dbstack subdb))) ;; RA => Returns the first reference in dbstruct
     (if (stack? tmpdb-stack)
 	(db:get-db tmpdb-stack run-id) ;; get previously opened db (will create new db handle if all in the stack are already used
         (let* ((max-stale-tmp (configf:lookup-number *configdat* "server" "filling-db-max-stale-seconds" default: 10))
-               (dbpath       (db:dbfile-path ))      ;; path to tmp db area
+               (dbpath       (db:dbfile-path))      ;; path to tmp db area
 	       (dbname       (db:run-id->dbname run-id))
                (dbexists     (common:file-exists? dbpath))
 	       (mtdbfname    (conc *toppath* "/"dbname))
                (mtdbexists   (common:file-exists? mtdbfname))
                (mtdbmodtime  (if mtdbexists (common:lazy-sqlite-db-modification-time mtdbfname)  #f))
                (mtdb         (db:open-megatest-db mtdbfname))
 	       ;; the reference db for syncing
 	       (refdbfname   (conc dbpath "/"dbname"_ref"))
                (refndb       (db:open-megatest-db refdbfname))
-               ;; (mtdbpath     (db:dbdat-get-path mtdb))
+               ;; (mtdbpath     (dbr:dbdat-dbfile mtdb))
 	       ;; the tmpdb
 	       (tmpdbfname   (conc dbpath"/"dbname)) ;; /tmp/<stuff>/.db/[main|1,2...].db 
                (tmpdb        (db:open-megatest-db tmpdbfname)) ;; lock-create-open dbpath db:initialize-main-db))
 	       (dbfexists    (common:file-exists? tmpdbfname))  ;; (conc dbpath "/megatest.db")))
 	       (tmpdbmodtime (if dbfexists  (common:lazy-sqlite-db-modification-time tmpdbfname) #f))
@@ -330,63 +325,49 @@
           ;(tmpdbmodtime (if dbfexists (db:get-last-update-time (car tmpdb)) #f))    
           ;(fmt (file-modification-time tmpdbfname))
 	       (modtimedelta (and mtdbmodtime tmpdbmodtime (- mtdbmodtime tmpdbmodtime))))
 
           (when write-access
-            (sqlite3:execute (car mtdb) "drop trigger if exists update_tests_trigger")
-            (sqlite3:execute (car mtdb) "drop trigger if exists update_runs_trigger"))
+            (sqlite3:execute (dbr:dbdat-dbh mtdb) "drop trigger if exists update_tests_trigger")
+            (sqlite3:execute (dbr:dbdat-dbh mtdb) "drop trigger if exists update_runs_trigger"))
           
 	  ;; (print "mtdbmodtime " mtdbmodtime " tmpdbmodtime " tmpdbmodtime " mtdbpath " mtdbpath " " (conc *toppath* "/megatest.db"))
 	  ;; (debug:print-info 13 *default-log-port* "db:open-db>> mtdbpath="mtdbpath" mtdbexists="mtdbexists" and write-access="write-access)
           (if (and dbexists (not write-access))
               (begin
                 (set! *db-write-access* #f)
-                (dbr:dbstruct-read-only-set! dbstruct #t)))
-          (dbr:dbstruct-mtdb-set!   dbstruct mtdb)
-          (dbr:dbstruct-tmpdb-set!  dbstruct tmpdb)
-          (dbr:dbstruct-dbstack-set! dbstruct (make-stack)) ;; BB: why a stack?  Why would the number of db's be indeterminate?  Is this a legacy of 1.db 2.db .. ?
-          (stack-push! (dbr:dbstruct-dbstack dbstruct) tmpdb) ;; olddb is already a (cons db path)
-          (dbr:dbstruct-refndb-set! dbstruct refndb)
+                (dbr:subdb-read-only-set! subdb #t)))
+          (dbr:subdb-mtdb-set!   subdb mtdb)
+          (dbr:subdb-tmpdb-set!  subdb tmpdb)
+          (dbr:subdb-dbstack-set! subdb (make-stack)) ;; BB: why a stack?  Why would the number of db's be indeterminate?  Is this a legacy of 1.db 2.db .. ?
+          (stack-push! (dbr:subdb-dbstack subdb) tmpdb) ;; olddb is already a (cons db path)
+          (dbr:subdb-refndb-set! subdb refndb)
           (if (and  (or (not dbfexists)
 			(and modtimedelta
 			     (> modtimedelta max-stale-tmp))) ;; if db in tmp is over ten seconds older than the file in MTRA then do a sync back
 		    do-sync)
 	      (begin
-		(debug:print 1 *default-log-port* "filling db " (db:dbdat-get-path tmpdb) " with data \n    from " (db:dbdat-get-path mtdb) " mod time delta: " modtimedelta)
-		(db:sync-tables (db:sync-all-tables-list dbstruct) #f mtdb refndb tmpdb)
+		(debug:print 1 *default-log-port* "filling db " (dbr:dbdat-dbfile tmpdb) " with data \n    from " (dbr:dbdat-dbfile mtdb) " mod time delta: " modtimedelta)
+		(db:sync-tables (db:sync-all-tables-list subdb) #f mtdb refndb tmpdb)
 		;; touch tmp db to avoid wal mode wierdness  
 		(set! (file-modification-time tmpdbfname) (current-seconds))  
                 (debug:print-info 13 *default-log-port* "db:sync-all-tables-list done.")
                 )
-	      (debug:print 4 *default-log-port* " db, " (db:dbdat-get-path tmpdb) " already exists or fresh enough, not propogating data from\n     " (db:dbdat-get-path mtdb) " mod time delta: " modtimedelta) )
-	  ;; (db:multi-db-sync dbstruct 'old2new))  ;; migrate data from megatest.db automatically
+	      (debug:print 4 *default-log-port* " db, " (dbr:dbdat-dbfile tmpdb) " already exists or fresh enough, not propogating data from\n     " (dbr:dbdat-dbfile mtdb) " mod time delta: " modtimedelta) )
+	  ;; (db:multi-db-sync subdb 'old2new))  ;; migrate data from megatest.db automatically
           tmpdb))))
 
 
 (define (db:get-last-update-time db)
-;	(db:with-db
-;   dbstruct #f #f 
-;    (lambda (db)
-			(let ((last-update-time #f))
-      	(sqlite3:for-each-row 
-          (lambda (lup) 
-             (set! last-update-time lup))     
-          db    
-					"select max(lup) from ( select max(last_update) as lup  from tests union select max(last_update) as lup from runs);")
-        last-update-time))
-;))
-
-;; set up a single db (e.g. main.db, 1.db ... etc.)
-;;
-(define (db:setup-db dbstructs areapath run-id)
-  (let* ((dbname   (db:run-id->dbname run-id))
-	 (dbstruct (or (hash-table-ref/default dbstructs dbname #f)
-		       (make-dbr:dbstruct))))
-    (db:open-db dbstruct run-id areapath: areapath do-sync: #t)
-    (hash-table-set! dbstructs dbname dbstruct)
-    dbstruct))
-    
+  (let ((last-update-time #f))
+    (sqlite3:for-each-row 
+     (lambda (lup) 
+       (set! last-update-time lup))     
+     db    
+     "select max(lup) from ( select max(last_update) as lup  from tests union select max(last_update) as lup from runs);")
+    last-update-time))
+
 
 ;; Make the dbstruct, setup up auxillary db's and call for main db at least once
 ;;
 ;; called in http-transport and replicated in rmt.scm for *local* access. 
 ;;
@@ -393,20 +374,26 @@
 (define (db:setup do-sync #!key (areapath #f))
   ;;
   (cond
    (*dbstruct-dbs* *dbstruct-dbs*);; TODO: when multiple areas are supported, this optimization will be a hazard
    (else ;;(common:on-homehost?)
-    (let* ((dbstructs (make-hash-table)))
+    (let* ((dbstructs (make-dbr:dbstruct)))
       (when (not *toppath*)
-        (debug:print-info 13 *default-log-port* "in db:setup, *toppath* not set; calling launch:setup")
+        (debug:print-info 0 *default-log-port* "in db:setup, *toppath* not set; calling launch:setup")
         (launch:setup areapath: areapath))
       (set! *dbstruct-dbs* dbstructs)
-      ;;(debug:print-info 13 *default-log-port* "new dbstruct = "(dbr:dbstruct->alist dbstruct))
+      (dbr:dbstruct-areapath-set! dbstructs *toppath*)
       dbstructs))))
-   ;; (else
-   ;;  (debug:print 0 *default-log-port* "ERROR: attempt to open database when not on homehost. Exiting. Homehost: " (common:get-homehost))
-   ;;  (exit 1))))
+
+(define (dbfile:get-subdb dbstruct run-id)
+  (let* ((res (hash-table-ref/default (dbr:dbstruct-subdbs dbstruct) (dbfile:run-id->key run-id) #f)))
+    (if res
+	res
+	(let* ((newsubdb (make-dbr:subdb)))
+	  (db:open-db newsubdb run-id areapath: (dbr:dbstruct-areapath dbstruct) do-sync: #t)
+	  (hash-table-set! (dbr:dbstruct-subdbs dbstruct) (dbfile:run-id->key run-id) newsubdb)
+	  newsubdb))))
 
 ;; Open the classic megatest.db file (defaults to open in toppath)
 ;;
 ;;   NOTE: returns a dbdat not a dbstruct!
 ;;
@@ -420,29 +407,31 @@
                                               (db:initialize-main-db db))))
 	 (write-access (file-write-access? dbpath)))
     (debug:print-info 13 *default-log-port* "db:open-megatest-db "dbpath)
     (if (and dbexists (not write-access))
 	(set! *db-write-access* #f))
-    (cons db dbpath)))
+    ;; (cons db dbpath)))
+    (make-dbr:dbdat dbfile: dbpath dbh: db read-only: (not write-access))))
 
 ;; sync run to disk if touched
 ;;
 (define (db:sync-touched dbstruct run-id #!key (force-sync #f))
-  (let ((tmpdb   (db:get-db dbstruct run-id))
-	(mtdb    (dbr:dbstruct-mtdb   dbstruct))
-        (refndb  (dbr:dbstruct-refndb dbstruct))
-	(start-t (current-seconds)))
+  (let* ((subdb   (dbfile:get-subdb dbstruct run-id))
+	 (tmpdb   (db:get-db dbstruct run-id))
+	 (mtdb    (dbr:subdb-mtdb subdb))
+	 (refndb  (dbr:subdb-refndb subdb))
+	 (start-t (current-seconds)))
     (debug:print-info 4 *default-log-port* "Syncing for run-id: " run-id)
     (mutex-lock! *db-multi-sync-mutex*)
     (let ((update_info (cons (if force-sync 0 *db-last-sync*) "last_update")))
       (mutex-unlock! *db-multi-sync-mutex*)
       (db:sync-tables (db:sync-all-tables-list dbstruct) update_info tmpdb refndb 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*)
-    (stack-push! (dbr:dbstruct-dbstack dbstruct) tmpdb)))
+    (stack-push! (dbr:subdb-dbstack subdb) tmpdb)))
 
 (define (db:safely-close-sqlite3-db db stmt-cache #!key (try-num 3))
   (if (<= try-num 0)
       #f
       (handle-exceptions
@@ -466,18 +455,23 @@
 	  exn
 	  (begin
 	    (debug:print 0 *default-log-port* "WARNING: Finalizing failed, "  ((condition-property-accessor 'exn 'message) exn) ", note - exn=" exn)
 	    (print-call-chain *default-log-port*))
 	;; (db:sync-touched dbstruct 0 force-sync: #t) ;; NO. Do not do this here. Instead we rely on a server to be started when there are writes, even if the server itself is not going to be used as a server.
-        (let ((tdbs       (map db:dbdat-get-db 
-			       (stack->list (dbr:dbstruct-dbstack dbstruct))))
-              (mdb        (db:dbdat-get-db (dbr:dbstruct-mtdb   dbstruct)))
-              (rdb        (db:dbdat-get-db (dbr:dbstruct-refndb dbstruct)))
-	      (stmt-cache (dbr:dbstruct-stmt-cache dbstruct)))
-          (map (lambda (db)
-		 (db:safely-close-sqlite3-db db stmt-cache))
-	       tdbs)
+        (let* ((subdbs     (hash-table-values (dbr:dbstruct-subdbs dbstruct))))
+	  (for-each
+	   (lambda (subdb)
+	     (let* ((tdbs       (stack->list (dbr:subdb-dbstack subdb)))
+		    (mdb        (dbr:dbdat-dbh (dbr:subdb-mtdb subdb)))
+		    (rdb        (dbr:dbdat-dbh (dbr:subdb-refndb subdb))))
+		    
+	       (map (lambda (dbdat)
+		      (let* ((stmt-cache (dbr:dbdat-stmt-cache dbdat))
+			     (dbh        (dbr:dbdat-dbh        dbdat)))
+			(db:safely-close-sqlite3-db dbh stmt-cache)))
+		    tdbs)))
+	   subdbs)
           (db:safely-close-sqlite3-db mdb stmt-cache)     ;; (if (sqlite3:database? mdb) (sqlite3:finalize! mdb))
           (db:safely-close-sqlite3-db rdb stmt-cache))))) ;; (if (sqlite3:database? rdb) (sqlite3:finalize! rdb))))))
 
 ;;   (let ((locdbs (dbr:dbstruct-locdbs dbstruct)))
 ;;     (if (hash-table? locdbs)
@@ -593,11 +587,11 @@
 	  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   (db:dbdat-get-path        dbdat))
+  (let* ((dbpath   (dbr:dbdat-dbfile        dbdat))
 	 (dbdir    (pathname-directory       dbpath))
 	 (fname    (pathname-strip-directory dbpath))
 	 (fnamejnl (conc fname "-journal"))
 	 (tmpname  (conc fname "." (current-process-id)))
 	 (tmpjnl   (conc fnamejnl "." (current-process-id))))
@@ -614,11 +608,11 @@
     
 ;; return #f to indicate the dbdat should be closed/reopened
 ;; else return dbdat
 ;;
 (define (db:repair-db dbdat #!key (numtries 1))
-  (let* ((dbpath   (db:dbdat-get-path        dbdat))
+  (let* ((dbpath   (dbr:dbdat-dbfile        dbdat))
 	 (dbdir    (pathname-directory       dbpath))
 	 (fname    (pathname-strip-directory dbpath)))
     (debug:print-info 0 *default-log-port* "Checking db " dbpath " for errors.")
     (cond
      ((not (file-write-access? dbdir))
@@ -683,13 +677,13 @@
      (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 5 *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:  " (db:dbdat-get-path fromdb))
+     (debug:print 0 *default-log-port* " src db:  " (dbr:dbdat-dbfile fromdb))
      (for-each (lambda (dbdat)
-		 (let ((dbpath (db:dbdat-get-path 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)))))
@@ -700,24 +694,24 @@
    (cond
     ((not fromdb) (debug:print 3 *default-log-port* "WARNING: db:sync-tables called with fromdb missing")
      -1)
     ((not todb)   (debug:print 3 *default-log-port* "WARNING: db:sync-tables called with todb missing")
      -2)
-    ((not (sqlite3:database? (db:dbdat-get-db fromdb)))
+    ((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? (db:dbdat-get-db todb)))
+    ((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? (db:dbdat-get-path todb)))
+    ((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? (db:dbdat-get-path todb))))
+                           (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))
@@ -792,11 +786,11 @@
 	       (if (> (length fromdat) batch-len)
 		   (begin
 		     (set! fromdats (cons fromdat fromdats))
 		     (set! fromdat  '())
 		     (set! totrecords (+ totrecords 1)))))
-	     (db:dbdat-get-db fromdb)
+	     (dbr:dbdat-dbh fromdb)
 	     full-sel)
 	    
 	    ;; tack on remaining records in fromdat
 	    (if (not (null? fromdat))
 		(set! fromdats (cons fromdat fromdats)))
@@ -806,11 +800,11 @@
 
 	    ;; read the target table; BBHERE
 	    (sqlite3:for-each-row
 	     (lambda (a . b)
 	       (hash-table-set! todat a (apply vector a b)))
-	     (db:dbdat-get-db todb)
+	     (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)
@@ -818,11 +812,11 @@
               )
             
 	    ;; first pass implementation, just insert all changed rows
 	    (for-each 
 	     (lambda (targdb)
-	       (let* ((db                 (db:dbdat-get-db 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)
@@ -1059,93 +1053,96 @@
 ;;
 (define (db:multi-db-sync dbstruct . options)
   ;; (if (not (launch:setup))
   ;;    (debug:print 0 *default-log-port* "ERROR: not able to setup up for megatest.")
   (assert #f "FATAL: Call to db:multi-db-sync which is not completed yet.")
-  (let* ((mtdb     (dbr:dbstruct-mtdb dbstruct))
-	 (tmpdb    (db:get-db dbstruct))
-	 (refndb   (dbr:dbstruct-refndb dbstruct))
-	 (allow-cleanup #t) ;; (if run-ids #f #t))
-	 (servers (server:get-list *toppath*)) ;; (tasks:get-all-servers (db:delay-if-busy tdbdat)))
-	 (data-synced 0)) ;; count of changed records (I hope)
-    
-    (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? (db:dbdat-get-path mtdb)) (db:clean-up mtdb))
-	  (db:clean-up tmpdb)
-	  (db:clean-up refndb))
-
-	 ;; sync runs, test_meta etc.
-	 ;;
-	 ((old2new)
-	  (set! data-synced
-	    (+ (db:sync-tables (db:sync-all-tables-list dbstruct) #f mtdb tmpdb refndb)
-	       data-synced)))
-	 
-	 ;; now ensure all newdb data are synced to megatest.db
-	 ;; do not use the run-ids list passed in to the function
-	 ;;
-	 ((new2old)
-	  (set! data-synced
-	    (+ (db:sync-tables (db:sync-all-tables-list dbstruct) #f tmpdb refndb mtdb)
-	       data-synced)))
-
-	 ((adj-target)
-	  (db:adj-target (db:dbdat-get-db mtdb))
-	  (db:adj-target (db:dbdat-get-db tmpdb))
-	  (db:adj-target (db:dbdat-get-db refndb)))
-	 
-	 ((schema)
-	  (db:patch-schema-maindb (db:dbdat-get-db mtdb))
-	  (db:patch-schema-maindb (db:dbdat-get-db tmpdb))
-	  (db:patch-schema-maindb (db:dbdat-get-db refndb))
-	  (db:patch-schema-rundb  (db:dbdat-get-db mtdb))
-	  (db:patch-schema-rundb  (db:dbdat-get-db tmpdb))
-	  (db:patch-schema-rundb  (db:dbdat-get-db refndb))))
-       
-       (stack-push! (dbr:dbstruct-dbstack dbstruct) tmpdb))
-     options)
+  (let* ((data-synced 0)) ;; count of changed records (I hope)
+    (for-each
+     (lambda (subdb)
+       (let* ((mtdb     (dbr:subdb-mtdb subdb))
+	      (tmpdb    (dbr:subdb-tmpdb subdb))
+	      (refndb   (dbr:subdb-refndb subdb))
+	      (allow-cleanup #t) ;; (if run-ids #f #t))
+	      (servers  (server:get-list *toppath*)) ;; (tasks:get-all-servers (db:delay-if-busy tdbdat)))
+	      )    
+	 (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 tmpdb)
+	       (db:clean-up refndb))
+
+	      ;; sync runs, test_meta etc.
+	      ;;
+	      ((old2new)
+	       (set! data-synced
+		 (+ (db:sync-tables (db:sync-all-tables-list dbstruct) #f mtdb tmpdb refndb)
+		    data-synced)))
+	      
+	      ;; now ensure all newdb data are synced to megatest.db
+	      ;; do not use the run-ids list passed in to the function
+	      ;;
+	      ((new2old)
+	       (set! data-synced
+		 (+ (db:sync-tables (db:sync-all-tables-list dbstruct) #f tmpdb refndb mtdb)
+		    data-synced)))
+
+	      ((adj-target)
+	       (db:adj-target (dbr:dbdat-dbh mtdb))
+	       (db:adj-target (dbr:dbdat-dbh tmpdb))
+	       (db:adj-target (dbr:dbdat-dbh refndb)))
+	      
+	      ((schema)
+	       (db:patch-schema-maindb (dbr:dbdat-dbh mtdb))
+	       (db:patch-schema-maindb (dbr:dbdat-dbh tmpdb))
+	       (db:patch-schema-maindb (dbr:dbdat-dbh refndb))
+	       (db:patch-schema-rundb  (dbr:dbdat-dbh mtdb))
+	       (db:patch-schema-rundb  (dbr:dbdat-dbh tmpdb))
+	       (db:patch-schema-rundb  (dbr:dbdat-dbh refndb))))
+	    
+	    (stack-push! (dbr:subdb-dbstack subdb) tmpdb))
+	  options)))
+     (hash-table-values (dbr:dbstruct-subdbs dbstruct)))
     data-synced))
 
 ;; Sync all changed db's
 ;;
 (define (db:tmp->megatest.db-sync dbstruct run-id last-update)
-  (let* ((dbname (db:run-id->dbname run-id))
-	 (mtdb        (dbr:dbstruct-mtdb dbstruct))
-	 
-	 
-	 ;; more to do here?
-	 
-	 
-	 (tmpdb       (db:get-db dbstruct run-id))
-	 (refndb      (dbr:dbstruct-refndb dbstruct))
-	 (res         (db:sync-tables (db:sync-all-tables-list dbstruct) last-update tmpdb refndb mtdb)))
-    (stack-push! (dbr:dbstruct-dbstack dbstruct) tmpdb)
+  (let* ((subdbs (hash-table-values (dbr:dbstruct-subdbs dbstruct)))
+	 (res    '()))
+    (for-each
+     (lambda (subdb)
+       (let* ((dbname (db:run-id->dbname run-id))
+	      (mtdb   (dbr:subdb-mtdb subdb))
+	      (tmpdb  (db:get-db dbstruct run-id))
+	      (refndb (dbr:subdb-refndb subdb))
+	      (newres (db:sync-tables (db:sync-all-tables-list dbstruct) last-update tmpdb refndb mtdb)))
+	 (stack-push! (dbr:subdb-dbstack subdb) tmpdb)
+	 (set! res (cons newres res))))
+     subdbs)
     res))
 
 ;;;; run-ids
 ;;    if #f use *db-local-sync* : or 'local-sync-flags
 ;;    if #t use timestamps      : or 'timestamps
@@ -1187,11 +1184,11 @@
   (print "I don't work anymore. open-run-close-no-exception-handling needs fixing or removing...")
   (exit)
   (if (or *db-write-access*
 	  (not #t)) ;; was: (member proc * db:all-write-procs *)))
       (let* ((db (cond
-		  ((pair? idb)                 (db:dbdat-get-db idb))
+		  ((pair? idb)                 (dbr:dbdat-dbh idb))
 		  ((sqlite3:database? idb)     idb)
 		  ((not idb)                   (debug:print-error 0 *default-log-port* "cannot open-run-close with #f anymore"))
 		  ((procedure? idb)            (idb))
 		  (else   	               (debug:print-error 0 *default-log-port* "cannot open-run-close with #f anymore"))))
 	     (res #f))
@@ -1320,11 +1317,11 @@
   (let* ((configdat (car *configinfo*))  ;; tut tut, global warning...
 	 (keys     (keys:config-get-fields configdat))
 	 (havekeys (> (length keys) 0))
 	 (keystr   (keys->keystr keys))
 	 (fieldstr (keys:make-key/field-string configdat))
-	 (db       (db:dbdat-get-db dbdat)))
+	 (db       (dbr:dbdat-dbh dbdat)))
     (for-each (lambda (key)
 		(let ((keyn key))
 		  (if (member (string-downcase keyn)
 			      (list "runname" "state" "status" "owner" "event_time" "comment" "fail_count"
 				    "pass_count" "contour"))
@@ -1554,11 +1551,11 @@
 ;; are on disks with adequate space and already have this test/itempath
 ;; archived
 ;;
 (define (db:archive-get-allocations dbstruct testname itempath dneeded)
   (let* ((dbdat        (db:get-db dbstruct #f)) ;; archive tables are in main.db
-	 (db           (db:dbdat-get-db dbdat))
+	 (db           (dbr:dbdat-dbh dbdat))
 	 (res          '())
 	 (blocks       '())) ;; a block is an archive chunck that can be added too if there is space
     (sqlite3:for-each-row
      (lambda (id archive-disk-id disk-path last-du last-du-time)
        (set! res (cons (vector id archive-disk-id disk-path last-du last-du-time) res)))
@@ -1586,11 +1583,11 @@
 ;; returns id of the record, register a disk allocated to archiving and record it's last known
 ;; available space
 ;;
 (define (db:archive-register-disk dbstruct bdisk-name bdisk-path df)
   (let* ((dbdat        (db:get-db dbstruct #f)) ;; archive tables are in main.db
-	 (db           (db:dbdat-get-db dbdat))
+	 (db           (dbr:dbdat-dbh dbdat))
 	 (res          #f))
     (sqlite3:for-each-row
      (lambda (id)
        (set! res id))
      db
@@ -1616,11 +1613,11 @@
 ;; if path starts with / then it is full, otherwise it is relative to the archive disk
 ;; preference is to store the relative path.
 ;;
 (define (db:archive-register-block-name dbstruct bdisk-id archive-path #!key (du #f))
   (let* ((dbdat        (db:get-db dbstruct #f)) ;; archive tables are in main.db
-	 (db           (db:dbdat-get-db dbdat))
+	 (db           (dbr:dbdat-dbh dbdat))
 	 (res          #f))
     ;; first look to see if this path is already registered
     (sqlite3:for-each-row
      (lambda (id)
        (set! res id))
@@ -1669,11 +1666,11 @@
 	archive-block-id)
        res))))
 
 ;; (define (db:archive-allocate-testsuite/area-to-block block-id testsuite-name areakey)
 ;;   (let* ((dbdat        (db:get-db dbstruct #f)) ;; archive tables are in main.db
-;; 	 (db           (db:dbdat-get-db dbdat))
+;; 	 (db           (dbr:dbdat-dbh dbdat))
 ;; 	 (res          '())
 ;; 	 (blocks       '())) ;; a block is an archive chunck that can be added too if there is space
 ;;     (sqlite3:for-each-row  #f)
 
 ;;======================================================================
@@ -1945,11 +1942,11 @@
 ;;    b. ....
 ;;
 (define (db:clean-up dbdat)
   ;; (debug:print 0 *default-log-port* "WARNING: db clean up not fully ported to v1.60, cleanup action will be on megatest.db")
   (let* ((keep-record-age ( - (current-seconds) (common:hms-string->seconds (or (configf:lookup *configdat* "setup" "delete-record-age") "30d"))))
-	 (db         (db:dbdat-get-db dbdat))
+	 (db         (dbr:dbdat-dbh dbdat))
 	 (count-stmt (sqlite3:prepare db "SELECT (SELECT count(id) FROM tests)+(SELECT count(id) FROM runs);"))
 	(statements
 	 (map (lambda (stmt)
 		(sqlite3:prepare db stmt))
 	      (list
@@ -2000,11 +1997,11 @@
 ;;    a. If have tests that are not deleted, set state='unknown'
 ;;    b. ....
 ;;
 (define (db:clean-up-rundb dbdat)
   ;; (debug:print 0 *default-log-port* "WARNING: db clean up not fully ported to v1.60, cleanup action will be on megatest.db")
-  (let* ((db         (db:dbdat-get-db dbdat))
+  (let* ((db         (dbr:dbdat-dbh dbdat))
 	 (count-stmt (sqlite3:prepare db "SELECT (SELECT count(id) FROM tests);"))
 	(statements
 	 (map (lambda (stmt)
 		(sqlite3:prepare db stmt))
 	      (list
@@ -2041,11 +2038,11 @@
 ;;    a. If have tests that are not deleted, set state='unknown'
 ;;    b. ....
 ;;
 (define (db:clean-up-maindb dbdat)
   ;; (debug:print 0 *default-log-port* "WARNING: db clean up not fully ported to v1.60, cleanup action will be on megatest.db")
-  (let* ((db         (db:dbdat-get-db dbdat))
+  (let* ((db         (dbr:dbdat-dbh dbdat))
 	 (count-stmt (sqlite3:prepare db "SELECT (SELECT count(id) FROM runs);"))
 	 (statements
 	  (map (lambda (stmt)
 		 (sqlite3:prepare db stmt))
 	       (list
@@ -3441,11 +3438,11 @@
       (let loop ((new-id min-test-id))
 	(let ((test-id-found #f))
 	  (sqlite3:for-each-row 
 	   (lambda (id)
 	     (set! test-id-found id))
-	   (db:dbdat-get-db mtdb)
+	   (dbr:dbdat-dbh mtdb)
 	   "SELECT id FROM tests WHERE id=?;"
 	   new-id)
 	  ;; if test-id-found then need to try again
 	  (if test-id-found
 	      (loop (+ new-id 1))
@@ -3459,11 +3456,11 @@
   (debug:print-info 0 *default-log-port* "Adjusting test ids in megatest.db for run " run-id)
   (let ((min-test-id (* run-id 30000)))
     (for-each 
      (lambda (testrec)
        (let* ((test-id (vector-ref testrec (db:field->number "id" db:test-record-fields))))
-	 (db:adj-test-id (db:dbdat-get-db mtdb) min-test-id test-id)))
+	 (db:adj-test-id (dbr:dbdat-dbh mtdb) min-test-id test-id)))
      testrecs)))
 	
 ;; 1. move test ids into the 30k * run_id range
 ;; 2. move step ids into the 30k * run_id range
 ;;
@@ -3470,11 +3467,11 @@
 (define (db:prep-megatest.db-for-migration mtdb)
   (let* ((run-ids (db:get-all-run-ids mtdb)))
     (for-each 
      (lambda (run-id)
        (let ((testrecs (db:get-all-tests-info-by-run-id mtdb run-id)))
-	 (db:prep-megatest.db-adj-test-ids (db:dbdat-get-db mtdb) run-id testrecs)))
+	 (db:prep-megatest.db-adj-test-ids (dbr:dbdat-dbh mtdb) run-id testrecs)))
      run-ids)))
 
 ;; Get test data using test_id, run-id is not used
 ;; 
 (define (db:get-test-info-by-id dbstruct run-id test-id)
@@ -4468,14 +4465,14 @@
 ;; Function recursively checks if <db>.journal exists; if yes means db busy; call itself after delayed interval
 ;; return the sqlite3 db handle if possible
 ;; 
 (define (db:delay-if-busy dbdat #!key (count 6))
   (if (not (configf:lookup *configdat* "server" "delay-on-busy")) 
-      (and dbdat (db:dbdat-get-db dbdat))
+      (and dbdat (dbr:dbdat-dbh dbdat))
       (if dbdat
-	  (let* ((dbpath (db:dbdat-get-path dbdat))
-		 (db     (db:dbdat-get-db   dbdat)) ;; we'll return this so (db:delay--if-busy can be called inline
+	  (let* ((dbpath (dbr:dbdat-dbfile dbdat))
+		 (db     (dbr:dbdat-dbh   dbdat)) ;; we'll return this so (db:delay--if-busy can be called inline
 		 (dbfj   (conc dbpath "-journal")))
 	    (if (handle-exceptions
 		 exn
 		 (begin
 		   (debug:print-info 0 *default-log-port* "WARNING: failed to test for existance of " dbfj ", exn=" exn)
@@ -4887,11 +4884,11 @@
   (let* ((keysstr  (string-intersperse (map car keypatt-alist) ","))
 	 (keyqry   (string-intersperse (map (lambda (p)(conc (car p) " LIKE ? ")) keypatt-alist) " AND "))
 	 (numkeys  (length keypatt-alist))
 	 (test-ids '())
 	 (dbdat    (db:get-db dbstruct))
-	 (db       (db:dbdat-get-db dbdat))
+	 (db       (dbr:dbdat-dbh dbdat))
 	 (windows  (and pathmod (substring-index "\\" pathmod)))
 	 (tempdir  (conc "/tmp/" (current-user-name) "/" runspatt "_" (random 10000) "_" (current-process-id)))
 	 (runsheader (append (list "Run Id" "Runname") ; 0 1
 			     (map car keypatt-alist)   ; + N = length keypatt-alist
 			     (list "Testname"          ; 2

Index: dbfile.scm
==================================================================
--- dbfile.scm
+++ dbfile.scm
@@ -30,47 +30,70 @@
 
 ;;======================================================================
 ;;  R E C O R D S
 ;;======================================================================
 
-;; each db entry is a pair ( db . dbfilepath )
-;; NOTE: Need one dbr:dbstruct per main.db, 1.db ...
+;; a single Megatest area with it's multiple dbs is
+;; managed in a dbstruct
 ;;
 (defstruct dbr:dbstruct
-  (dbname      #f)
-  (dbdats      (make-hash-table))  ;; id => dbdat
-  (tmpdb       #f)
+  (areapath  #f)
+  (homehost  #f)
+  (read-only #f)
+  (subdbs (make-hash-table))
+  )
+
+;; NOTE: Need one dbr:subdb per main.db, 1.db ...
+;;
+(defstruct dbr:subdb
+  (dbname      #f) ;; .db/1.db
+  (mtdb        #f) ;; mtrah/.db/1.db
+  ;; (dbdats      (make-hash-table))  ;; id => dbdat 
+  (tmpdb       #f) ;; /tmp/.../.db/1.db
+  (refndb      #f) ;; /tmp/.../.db/1.db_ref
   (dbstack     #f) ;; stack for tmp db handles, do not initialize with a stack
-  (mtdb        #f)
-  (refndb      #f)
   (homehost    #f) ;; not used yet
   (on-homehost #f) ;; not used yet
   (read-only   #f)
-  (stmt-cache  (make-hash-table))
-  )                ;; goal is to converge on one struct for an area but for now it is too confusing
-  
-(defstruct dbr:dbdat
-  (db          #f)    ;; should rename this to oddb for on disk db
-  (tmpdb       #f)
-  (dbhstack    #f)    ;; do not init with a stack
   (last-sync   0)
   (last-write  (current-seconds))
-  (run-id      #f)
-  (fname       #f))
-
-; Returns the dbdat for a particular dbfile inside the area
-;;
-(define (dbr:dbstruct-get-dbdat dbstruct dbfile)
-  (hash-table-ref/default (dbr:dbstruct-dbdats dbstruct) dbfile #f))
-
-(define (dbr:dbstruct-dbdat-put! dbstruct dbfile db)
-  (hash-table-set! (dbr:dbstruct-dbdats dbstruct) dbfile db))
-
-(define (db:run-id->first-num run-id)
-  (let* ((s (number->string run-id))
-	 (l (string-length s)))
-    (substring s (- l 1) l)))
+  )                ;; goal is to converge on one struct for an area but for now it is too confusing
+
+;; need to keep dbhandles and cached statements together
+(defstruct dbr:dbdat
+  (dbfile      #f)
+  (dbh         #f)    
+  (stmt-cache  (make-hash-table))
+  (read-only   #f))
+
+(define (dbfile:run-id->key run-id)
+  (or run-id 'main))
+
+;; ;; set up a single db (e.g. main.db, 1.db ... etc.)
+;; ;;
+;; (define (db:setup-db dbstruct areapath run-id)
+;;   (let* ((dbname   (db:run-id->dbname run-id))
+;; 	 (dbstruct (hash-table-ref/default dbstructs dbname #f)))
+;;     (if dbstruct
+;; 	dbstruct
+;; 	(let* ((dbstruct-new (make-dbr:dbstruct)))
+;; 	  (db:open-db dbstruct-new run-id areapath: areapath do-sync: #t)
+;; 	  (hash-table-set! dbstructs dbname dbstruct-new)
+;; 	  dbstruct-new))))
+    
+;; ; Returns the dbdat for a particular dbfile inside the area
+;; ;;
+;; (define (dbr:dbstruct-get-dbdat dbstruct dbfile)
+;;   (hash-table-ref/default (dbr:dbstruct-dbdats dbstruct) dbfile #f))
+;; 
+;; (define (dbr:dbstruct-dbdat-put! dbstruct dbfile db)
+;;   (hash-table-set! (dbr:dbstruct-dbdats dbstruct) dbfile db))
+;; 
+;; (define (db:run-id->first-num run-id)
+;;   (let* ((s (number->string run-id))
+;; 	 (l (string-length s)))
+;;     (substring s (- l 1) l)))
 
 ;; 1234 => 4/1234.db
 ;;   #f => 0/main.db
 ;;   (abandoned the idea of num/db)
 ;;