Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -566,20 +566,21 @@
 				 patts))
 			comparator)))
 
 
 ;; register a test run with the db
-(define (db:register-run db keys keyvals runname state status user)
-  (debug:print 3 "runs:register-run, keys: " keys ", runname: " runname " state: " state " status: " status " user: " user)
-  (let* ((keystr    (keys->keystr keys))
+(define (db:register-run db keyvals runname state status user)
+  (debug:print 3 "runs:register-run runname: " runname " state: " state " status: " status " user: " user)
+  (let* ((keys      (map car keyvals))
+	 (keystr    (keys->keystr keys))	 
 	 (comma     (if (> (length keys) 0) "," ""))
 	 (andstr    (if (> (length keys) 0) " AND " ""))
 	 (valslots  (keys->valslots keys)) ;; ?,?,? ...
-	 (allvals   (append (list runname state status user) (map car keyvals)))
-	 (qryvals   (append (list runname) (map car keyvals)))
+	 (allvals   (append (list runname state status user) (map cadr keyvals)))
+	 (qryvals   (append (list runname) (map cadr keyvals)))
 	 (key=?str  (string-intersperse (map (lambda (k)(conc k "=?")) keys) " AND ")))
-    (debug:print 3 "keys: " keys " allvals: " allvals " keyvals: " keyvals)
+    (debug:print 3 "keys: " keys " allvals: " allvals " keyvals: " keyvals " key=?str is " key=?str)
     (debug:print 2 "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"
 	(let ((res #f))
 	  (apply sqlite3:execute db (conc "INSERT OR IGNORE INTO runs (runname,state,status,owner,event_time" comma keystr ") VALUES (?,?,?,?,strftime('%s','now')" comma valslots ");")
 		 allvals)

Index: launch.scm
==================================================================
--- launch.scm
+++ launch.scm
@@ -91,11 +91,11 @@
 	  ;; Setup the *runremote* global var
 	  (if *runremote* (debug:print 2 "ERROR: I'm not expecting *runremote* to be set at this time"))
 	  ;; (set! *runremote* runremote)
 	  (set! *transport-type* (string->symbol transport))
 	  (set! keys       (cdb:remote-run db:get-keys #f))
-	  (set! keyvals    (if run-id (cdb:remote-run db:get-key-vals #f run-id) #f))
+	  (set! keyvals    (keys:target->keyval keys target))
 	  ;; apply pre-overrides before other variables. The pre-override vars must not
 	  ;; clobbers things from the official sources such as megatest.config and runconfigs.config
 	  (if (string? set-vars)
 	      (let ((varpairs (string-split set-vars ",")))
 		(debug:print 4 "varpairs: " varpairs)
@@ -126,11 +126,11 @@
 
 	  (change-directory *toppath*) 
 	  (set-megatest-env-vars run-id) ;; these may be needed by the launching process
 	  (change-directory work-area) 
 
-	  (set-run-config-vars run-id keys keyvals target) ;; (db:get-target db run-id))
+	  (set-run-config-vars run-id keyvals target) ;; (db:get-target db run-id))
 	  ;; environment overrides are done *before* the remaining critical envars.
 	  (alist->env-vars env-ovrd)
 	  (set-megatest-env-vars run-id)
 	  (set-item-env-vars itemdat)
 	  (save-environment-as-files "megatest")
@@ -406,17 +406,17 @@
 ;; 
 ;; All log file links should be stored relative to the top of link path
 ;;  
 ;; <target> - <testname> [ - <itempath> ] 
 ;;
-(define (create-work-area run-id run-info key-vals test-id test-src-path disk-path testname itemdat)
+(define (create-work-area run-id run-info keyvals test-id test-src-path disk-path testname itemdat)
   (let* ((item-path (item-list->path itemdat))
 	 (runname  (db:get-value-by-header (db:get-row run-info)
 					   (db:get-header run-info)
 					   "runname"))
 	 ;; convert back to db: from rdb: - this is always run at server end
-	 (target   (string-intersperse (map cadr key-vals) "/"))
+	 (target   (string-intersperse (map cadr keyvals) "/"))
 
 	 (not-iterated  (equal? "" item-path))
 
 	 ;; all tests are found at <rundir>/test-base or <linkdir>/test-base
 	 (testtop-base (conc target "/" runname "/" testname))
@@ -554,11 +554,11 @@
 ;; 3. create link from run dir to megatest runs area 
 ;; 4. remotely run the test on allocated host
 ;;    - could be ssh to host from hosts table (update regularly with load)
 ;;    - could be netbatch
 ;;      (launch-test db (cadr status) test-conf))
-(define (launch-test test-id run-id run-info key-vals runname test-conf test-name test-path itemdat params)
+(define (launch-test test-id run-id run-info keyvals runname test-conf test-name test-path itemdat params)
   (change-directory *toppath*)
   (alist->env-vars ;; consolidate this code with the code in megatest.scm for "-execute"
    (list ;; (list "MT_TEST_RUN_DIR" work-area)
     (list "MT_RUN_AREA_HOME" *toppath*)
     (list "MT_TEST_NAME" test-name)
@@ -595,11 +595,11 @@
 	 (fullcmd    #f) ;; (define a (with-output-to-string (lambda ()(write x))))
 	 (mt-bindir-path #f)
 	 (item-path (item-list->path itemdat))
 	 ;; (test-id    (cdb:remote-run db:get-test-id #f run-id test-name item-path))
 	 (testinfo   (cdb:get-test-info-by-id *runremote* test-id))
-	 (mt_target  (string-intersperse (map cadr key-vals) "/"))
+	 (mt_target  (string-intersperse (map cadr keyvals) "/"))
 	 (debug-param (append (if (args:get-arg "-debug")  (list "-debug" (args:get-arg "-debug")) '())
 			      (if (args:get-arg "-logging")(list "-logging") '()))))
     (if hosts (set! hosts (string-split hosts)))
     ;; set the megatest to be called on the remote host
     (if (not remote-megatest)(set! remote-megatest local-megatest)) ;; "megatest"))
@@ -606,11 +606,11 @@
     (set! mt-bindir-path (pathname-directory remote-megatest))
     (if launcher (set! launcher (string-split launcher)))
     ;; set up the run work area for this test
     (set! diskpath (get-best-disk *configdat*))
     (if diskpath
-	(let ((dat  (create-work-area run-id run-info key-vals test-id test-path diskpath test-name itemdat)))
+	(let ((dat  (create-work-area run-id run-info keyvals test-id test-path diskpath test-name itemdat)))
 	  (set! work-area (car dat))
 	  (set! toptest-work-area (cadr dat))
 	  (debug:print-info 2 "Using work area " work-area))
 	(begin
 	  (set! work-area (conc test-path "/tmp_run"))

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -30,10 +30,11 @@
 (define *db* #f) ;; this is only for the repl, do not use in general!!!!
 
 (include "common_records.scm")
 (include "key_records.scm")
 (include "db_records.scm")
+(include "run_records.scm")
 (include "megatest-fossil-hash.scm")
 
 (let ((debugcontrolf (conc (get-environment-variable "HOME") "/.megatestrc")))
   (if (file-exists? debugcontrolf)
       (load debugcontrolf)))
@@ -442,11 +443,11 @@
 ;;======================================================================
 
 ;; since several actions can be specified on the command line the removal
 ;; is done first
 (define (operate-on action)
-  (let* ((runrec (runs:create-runrecord))
+  (let* ((runrec (runs:runrec-make-record))
 	 (target (or (args:get-arg "-reqtarg")
 		     (args:get-arg "-target"))))
     (cond
      ((not target)
       (debug:print 0 "ERROR: Missing required parameter for " action ", you must specify -target or -reqtarg")

Index: run-tests-queue-classic.scm
==================================================================
--- run-tests-queue-classic.scm
+++ run-tests-queue-classic.scm
@@ -1,13 +1,12 @@
 
 ;; test-records is a hash table testname:item_path => vector < testname testconfig waitons priority items-info ... >
-(define (runs:run-tests-queue-classic run-id runname test-records keyvallst flags test-patts required-tests)
+(define (runs:run-tests-queue-classic run-id runname test-records keyvals flags test-patts required-tests)
     ;; At this point the list of parent tests is expanded 
     ;; NB// Should expand items here and then insert into the run queue.
   (debug:print 5 "test-records: " test-records ", flags: " (hash-table->alist flags))
   (let ((run-info              (cdb:remote-run db:get-run-info #f run-id))
-	(key-vals              (cdb:remote-run db:get-key-vals #f run-id))
 	(sorted-test-names     (tests:sort-by-priority-and-waiton test-records))
 	(test-registry         (make-hash-table))
 	(registry-mutex        (make-mutex))
 	(num-retries           0)
 	(max-retries           (config-lookup *configdat* "setup" "maxretries"))
@@ -132,11 +131,11 @@
 		  (loop (car newtal)(cdr newtal) reruns))
 		 ((and have-resources
 		       (or (null? prereqs-not-met)
 			   (and (eq? testmode 'toplevel)
 				(null? non-completed))))
-		  (run:test run-id run-info key-vals runname test-record flags #f)
+		  (run:test run-id run-info keyvals runname test-record flags #f)
 		  (hash-table-set! test-registry (runs:make-full-test-name test-name item-path) 'running)
 		  (runs:shrink-can-run-more-tests-count)  ;; DELAY TWEAKER (still needed?)
 		  ;; (thread-sleep! *global-delta*)
 		  (if (not (null? tal))
 		      (loop (car tal)(cdr tal) reruns)))

Index: runconfig.scm
==================================================================
--- runconfig.scm
+++ runconfig.scm
@@ -8,24 +8,19 @@
 (declare (unit runconfig))
 (declare (uses common))
 
 (include "common_records.scm")
 
-
-
-;; (define (setup-env-defaults db fname run-id already-seen #!key (environ-patt #f)(change-env #t))
-(define (setup-env-defaults fname run-id already-seen keys keyvals #!key (environ-patt #f)(change-env #t))
-  (let* (;; (keys    (db:get-keys db))
-	 ;; (keyvals (if run-id (db:get-key-vals db run-id) #f))
-	 (thekey  (if keyvals (string-intersperse (map (lambda (x)(if x x "-na-")) (map car keyvals)) "/")
-		      (if (args:get-arg "-reqtarg") 
-			  (args:get-arg "-reqtarg")
-			  (if (args:get-arg "-target")
-			      (args:get-arg "-target")
-			      (begin
-				(debug:print 0 "ERROR: setup-env-defaults called with no run-id or -target or -reqtarg")
-				"nothing matches this I hope")))))
+(define (setup-env-defaults fname run-id already-seen keyvals #!key (environ-patt #f)(change-env #t))
+  (let* ((keys    (map car keyvals))
+	 (thekey  (if keyvals (string-intersperse (map (lambda (x)(if x x "-na-")) (map cadr keyvals)) "/")
+		      (or (args:get-arg "-reqtarg") 
+			  (args:get-arg "-target")
+			  (get-environment-variable "MT_TARGET")
+			  (begin
+			    (debug:print 0 "ERROR: setup-env-defaults called with no run-id or -target or -reqtarg")
+			    "nothing matches this I hope"))))
 	 ;; Why was system disallowed in the reading of the runconfigs file?
 	 ;; NOTE: Should be setting env vars based on (target|default)
 	 (confdat (read-config fname #f #t environ-patt: environ-patt sections: (list "default" thekey)))
 	 (whatfound (make-hash-table))
 	 (finaldat  (make-hash-table))
@@ -33,13 +28,13 @@
     (if (not *target*)(set! *target* thekey)) ;; may save a db access or two but repeats db:get-target code
     (debug:print 4 "Using key=\"" thekey "\"")
 
     (if change-env
 	(for-each ;; NB// This can be simplified with new content of keyvals having all that is needed.
-	 (lambda (key val)
-	   (setenv key (cadr val)))
-	 keys keyvals))
+	 (lambda (keyval)
+	   (setenv (car keyval)(cadr keyval)))
+	 keyvals))
 	
     (for-each 
      (lambda (section)
        (let ((section-dat (hash-table-ref/default confdat section #f)))
 	 (if section-dat
@@ -59,20 +54,21 @@
 		    sections)
 	  (debug:print 2 "---")
 	  (set! *already-seen-runconfig-info* #t)))
     finaldat))
 
-(define (set-run-config-vars run-id keys keyvals targ-from-db)
-  (push-directory *toppath*)
+(define (set-run-config-vars run-id keyvals targ-from-db)
+  (push-directory *toppath*) ;; the push/pop doesn't appear to do anything ...
   (let ((runconfigf (conc  *toppath* "/runconfigs.config"))
 	(targ       (or (args:get-arg "-target")
 			(args:get-arg "-reqtarg")
-			targ-from-db)))
+			targ-from-db
+			(get-environment-variable "MT_TARGET"))))
     (pop-directory)
     (if (file-exists? runconfigf)
-	(setup-env-defaults runconfigf run-id #t keys keyvals
+	(setup-env-defaults runconfigf run-id #t keyvals
 			    environ-patt: (conc "(default"
 						(if targ
 						    (conc "|" targ ")")
 						    ")")))
 	(debug:print 0 "WARNING: You do not have a run config file: " runconfigf))))
  

Index: runs.scm
==================================================================
--- runs.scm
+++ runs.scm
@@ -132,11 +132,12 @@
     (vector target runname testpatt keys keyvals envdat mconfig runconfig serverdat transport db toppath run-id)))
 
 	 
 (define (set-megatest-env-vars run-id #!key (inkeys #f)(inrunname #f)(inkeyvals #f))
   (let* ((target      (or (args:get-arg "-reqtarg")
-		           (args:get-arg "-target")))
+			  (args:get-arg "-target")
+			  (get-environment-variable "MT_TARGET")))
 	 (keys    (if inkeys    inkeys    (cdb:remote-run db:get-keys #f)))
 	 (keyvals (if inkeyvals inkeyvals (keys:target->keyval keys target)))
 	 (vals (hash-table-ref/default *env-vars-by-run-id* run-id #f)))
     ;; get the info from the db and put it in the cache
     (if (not vals)
@@ -223,24 +224,23 @@
 (define (runs:run-tests target runname test-patts user flags) ;; test-names
   (common:clear-caches) ;; clear all caches
   (let* ((db          #f)
 	 (keys        (keys:config-get-fields *configdat*))
 	 (keyvals     (keys:target->keyval keys target))
-	 (run-id      (cdb:remote-run db:register-run #f keys keyvals runname "new" "n/a" user))  ;;  test-name)))
+	 (run-id      (cdb:remote-run db:register-run #f keyvals runname "new" "n/a" user))  ;;  test-name)))
 	 (deferred    '()) ;; delay running these since they have a waiton clause
 	 ;; keepgoing is the defacto modality now, will add hit-n-run a bit later
 	 ;; (keepgoing   (hash-table-ref/default flags "-keepgoing" #f))
 	 (runconfigf   (conc  *toppath* "/runconfigs.config"))
 	 (required-tests '())
 	 (test-records (make-hash-table))
-     (all-test-names (tests:get-valid-tests *toppath* "%"))) ;; we need a list of all valid tests to check waiton names)
 	 (all-test-names (tests:get-valid-tests *toppath* "%"))) ;; we need a list of all valid tests to check waiton names
 
     (set-megatest-env-vars run-id inkeys: keys) ;; these may be needed by the launching process
 
     (if (file-exists? runconfigf)
-	(setup-env-defaults runconfigf run-id *already-seen-runconfig-info* keys keyvals "pre-launch-env-vars")
+	(setup-env-defaults runconfigf run-id *already-seen-runconfig-info* keyvals "pre-launch-env-vars")
 	(debug:print 0 "WARNING: You do not have a run config file: " runconfigf))
     
     ;; look up all tests matching the comma separated list of globs in
     ;; test-patts (using % as wildcard)
 
@@ -325,11 +325,11 @@
 							 (append (if (list? items) items '())
 								 (if (list? itemstable) itemstable '())))
 						 'have-procedure)
 						((or (list? items)(list? itemstable)) ;; calc now
 						 (debug:print-info 4 "items and itemstable are lists, calc now\n"
-							      "    items: " items " itemstable: " itemstable)
+								   "    items: " items " itemstable: " itemstable)
 						 (items:get-items-from-config config))
 						(else #f)))                           ;; not iterated
 					     #f      ;; itemsdat 5
 					     #f      ;; spare - used for item-path
 					     )))
@@ -348,12 +348,12 @@
 	(debug:print-info 1 "Adding " required-tests " to the run queue"))
     ;; NOTE: these are all parent tests, items are not expanded yet.
     (debug:print-info 4 "test-records=" (hash-table->alist test-records))
     (let ((reglen (any->number  (configf:lookup *configdat* "setup" "runqueue"))))
       (if reglen
-	  (runs:run-tests-queue-new     run-id runname test-records keyvallst flags test-patts required-tests reglen)
-	  (runs:run-tests-queue-classic run-id runname test-records keyvallst flags test-patts required-tests)))
+	  (runs:run-tests-queue-new     run-id runname test-records keyvals flags test-patts required-tests reglen)
+	  (runs:run-tests-queue-classic run-id runname test-records keyvals flags test-patts required-tests)))
     (debug:print-info 4 "All done by here")))
 
 (define (runs:calc-fails prereqs-not-met)
   (filter (lambda (test)
 	    (and (vector? test) ;; not (string? test))
@@ -404,11 +404,11 @@
 
 (include "run-tests-queue-classic.scm")
 (include "run-tests-queue-new.scm")
 
 ;; parent-test is there as a placeholder for when parent-tests can be run as a setup step
-(define (run:test run-id run-info key-vals runname test-record flags parent-test)
+(define (run:test run-id run-info keyvals runname test-record flags parent-test)
   ;; All these vars might be referenced by the testconfig file reader
   (let* ((test-name    (tests:testqueue-get-testname   test-record))
 	 (test-waitons (tests:testqueue-get-waitons    test-record))
 	 (test-conf    (tests:testqueue-get-testconfig test-record))
 	 (itemdat      (tests:testqueue-get-itemdat    test-record))
@@ -510,11 +510,11 @@
 				"\" and status \"" (test:get-status testdat) "\", use -rerun \"" (test:get-status testdat)
                                 "\" or -force to override"))
 	       ;; NOTE: No longer be checking prerequisites here! Will never get here unless prereqs are
 	       ;;       already met.
 	       ;; This would be a great place to do the process-fork
-	       (if (not (launch-test test-id run-id run-info key-vals runname test-conf test-name test-path itemdat flags))
+	       (if (not (launch-test test-id run-id run-info keyvals runname test-conf test-name test-path itemdat flags))
 		   (begin
 		     (print "ERROR: Failed to launch the test. Exiting as soon as possible")
 		     (set! *globalexitstatus* 1) ;; 
 		     (process-signal (current-process-id) signal/kill))))))
 	((KILLED) 
@@ -781,11 +781,11 @@
 
 ;; This could probably be refactored into one complex query ...
 (define (runs:rollup-run keys runname user keyvals)
   (debug:print 4 "runs:rollup-run, keys: " keys " :runname " runname " user: " user)
   (let* ((db              #f)
-	 (new-run-id      (cdb:remote-run db:register-run #f keys keyvals runname "new" "n/a" user))
+	 (new-run-id      (cdb:remote-run db:register-run #f keyvals runname "new" "n/a" user))
 	 (prev-tests      (open-run-close test:get-matching-previous-test-run-records db new-run-id "%" "%"))
 	 (curr-tests      (open-run-close db:get-tests-for-run db new-run-id "%/%" '() '()))
 	 (curr-tests-hash (make-hash-table)))
     (open-run-close db:update-run-event_time db new-run-id)
     ;; index the already saved tests by testname and itemdat in curr-tests-hash

Index: tests.scm
==================================================================
--- tests.scm
+++ tests.scm
@@ -107,12 +107,12 @@
 
 ;; get the previous record for when this test was run where all keys match but runname
 ;; returns #f if no such test found, returns a single test record if found
 (define (test:get-previous-test-run-record db run-id test-name item-path)
   (let* ((keys    (cdb:remote-run db:get-keys #f))
-	 (selstr  (string-intersperse (map (lambda (x)(vector-ref x 0)) keys) ","))
-	 (qrystr  (string-intersperse (map (lambda (x)(conc (vector-ref x 0) "=?")) keys) " AND "))
+	 (selstr  (string-intersperse  keys ","))
+	 (qrystr  (string-intersperse (map (lambda (x)(conc x "=?")) 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)))

Index: tests/tests.scm
==================================================================
--- tests/tests.scm
+++ tests/tests.scm
@@ -177,17 +177,17 @@
 		 (list ":runname" ":state" ":status")
 		 (list "-h")
 		 args:arg-hash
 		 0))
 
-(test "register-run" #t (number? (db:register-run *db*
-						  (db:get-keys *db*)
-						  '(("SYSTEM" "key1")("RELEASE" "key2"))
-						  "myrun" 
-						  "new"
-						  "n/a" 
-						  "bob")))
+(test "register-run" #t (number?
+			 (db:register-run *db*
+					  '(("SYSTEM" "key1")("RELEASE" "key2"))
+					  "myrun" 
+					  "new"
+					  "n/a" 
+					  "bob")))
 
 (test #f #t             (cdb:tests-register-test *runremote* 1 "nada" ""))
 (test #f 1              (cdb:remote-run db:get-test-id #f 1 "nada" ""))
 (test #f "NOT_STARTED"  (vector-ref (open-run-close db:get-test-info #f 1 "nada" "") 3))
 (test #f "NOT_STARTED"  (vector-ref (cdb:get-test-info *runremote* 1 "nada" "") 3))
@@ -197,12 +197,12 @@
 ;;======================================================================
 ;; D B
 ;;======================================================================
 
 (test #f "FOO LIKE 'abc%def'" (db:patt->like "FOO" "abc%def"))
-(test #f (vector '("SYSTEM" "RELEASE" "id" "runname" "state" "status" "owner" "event_time") '())
-      (runs:get-runs-by-patt db keys "%" "key1/key2"))
+(test #f "key2" (vector-ref (car (vector-ref (runs:get-runs-by-patt *db* '("SYSTEM" "RELEASE") "%" "key1/key2") 1)) 1))
+
 (test #f "SYSTEM,RELEASE,id,runname,state,status,owner,event_time" (car (runs:get-std-run-fields keys '("id" "runname" "state" "status" "owner" "event_time"))))
 (test #f #t (runs:operate-on 'print "%" "%" "%"))
 
 ;;(test "update-test-info" #t (test-update-meta-info *db* 1 "nada" 
 (setenv "BLAHFOO" "1234")
@@ -272,11 +272,11 @@
 
 (define rinfo #f)
 (test "get-run-info"  #f (vector? (vector-ref (let ((rinf (cdb:remote-run db:get-run-info #f 1)))
 						(set! rinfo rinf)
 						rinf) 0)))
-(test "get-key-vals"  "SYSTEM" (car (cdb:remote-run db:get-key-vals #f 1)))
+(test "get-key-vals"  "key1" (car (cdb:remote-run db:get-key-vals #f 1)))
 (test "tests:sort-by" '() (tests:sort-by-priority-and-waiton (make-hash-table)))
 
 (test "update-test_meta" "test1" (begin
 				   (runs:update-test_meta "test1" tconfig)
 				   (let ((dat (cdb:remote-run db:testmeta-get-record #f "test1")))