@@ -8,79 +8,81 @@
 ;;  PURPOSE.
 
 ;; (require-extension synch sqlite3 posix srfi-13 srfi-1 utils regex)
 (use sqlite3 srfi-1 posix regex srfi-69 srfi-13 posix-extras)
 (import (prefix sqlite3 sqlite3:))
+(include "/nfs/site/disks/icf_fdk_cw_gwa002/srehman/fossil/dbi/dbi.scm")
+(import (prefix dbi dbi:))
 
 (declare (unit filedb))
 
 (include "fdb_records.scm")
 ;; (include "settings.scm")
 
 (define (filedb:open-db dbpath)
   (let* ((fdb      (make-filedb:fdb))
 	 (dbexists (file-exists? dbpath))
-	 (db (sqlite3:open-database dbpath)))
+	 (db (dbi:open 'sqlite3 (cons (cons ('dbname dbpath) '())))))
     (filedb:fdb-set-db!        fdb db)
     (filedb:fdb-set-dbpath!    fdb dbpath)
     (filedb:fdb-set-pathcache! fdb (make-hash-table))
     (filedb:fdb-set-idcache!   fdb (make-hash-table))
     (filedb:fdb-set-partcache! fdb (make-hash-table))
-    (sqlite3:set-busy-handler!  db (make-busy-timeout 136000))
+    ;;(sqlite3:set-busy-handler!  db (make-busy-timeout 136000))
     (if (not dbexists)
 	(begin
-	  (sqlite3:execute db "PRAGMA synchronous = OFF;")
-	  (sqlite3:execute db "CREATE TABLE names (id INTEGER PRIMARY KEY,name TEST);") ;; for future use - change path in paths table to path_id
-	  (sqlite3:execute db "CREATE INDEX name_index ON names (name);")
+	  (dbi:execute db "PRAGMA synchronous = OFF;")
+	  (dbi:exec db "CREATE TABLE names (id INTEGER PRIMARY KEY,name TEST);") ;; for future use - change path in paths table to path_id
+	  (dbi:exec db "CREATE INDEX name_index ON names (name);")
 	  ;; NB// We store a useful subset of file attributes but do not attempt to store all
-	  (sqlite3:execute db "CREATE TABLE paths (id        INTEGER PRIMARY KEY,
+	  (dbi:exec db "CREATE TABLE paths (id        INTEGER PRIMARY KEY,
                                                    path      TEXT,
                                                    parent_id INTEGER,
                                                    mode      INTEGER DEFAULT -1,
                                                    uid       INTEGER DEFAULT -1,
                                                    gid       INTEGER DEFAULT -1,
                                                    size      INTEGER DEFAULT -1,
                                                    mtime     INTEGER DEFAULT -1);")
-	  (sqlite3:execute db "CREATE INDEX path_index ON paths (path,parent_id);")
-	  (sqlite3:execute db "CREATE TABLE bases (id INTEGER PRIMARY KEY,base TEXT,                  updated TIMESTAMP);")))
+	  (dbi:exec db "CREATE INDEX path_index ON paths (path,parent_id);")
+	  (dbi:exec db "CREATE TABLE bases (id INTEGER PRIMARY KEY,base TEXT,                  updated TIMESTAMP);")))
     ;; close the sqlite3 db and open it as needed
     (filedb:finalize-db! fdb)
     (filedb:fdb-set-db! fdb #f)
     fdb))
 
 (define (filedb:reopen-db fdb)
-  (let ((db (sqlite3:open-database (filedb:fdb-get-dbpath fdb))))
-    (filedb:fdb-set-db! fdb db)
-    (sqlite3:set-busy-handler!  db (make-busy-timeout 136000))))
+  (let ((db (dbi:open 'sqlite3 (cons (cons ('dbname (filedb:fdb-get-dbpath fdb)) '())))))
+    (filedb:fdb-set-db! fdb db)))
+    ;;(sqlite3:set-busy-handler!  db (make-busy-timeout 136000))))
   
 (define (filedb:finalize-db! fdb)
-  (sqlite3:finalize! (filedb:fdb-get-db fdb)))
+  (dbi:close (filedb:fdb-get-db fdb)))
 
 (define (filedb:get-current-time-string)
   (string-chomp (time->string (seconds->local-time (current-seconds)))))
 
 (define (filedb:get-base-id db path)
   (let ((stmt   (sqlite3:prepare db "SELECT id FROM bases WHERE base=?;"))
         (id-num #f))
-    (sqlite3:for-each-row 
+    (dbi:for-each-row 
      (lambda (num) (set! id-num num)) stmt path)
-    (sqlite3:finalize! stmt)
+    (dbi:close stmt)
     id-num))
 
 (define (filedb:get-path-id db path parent)
   (let ((stmt   (sqlite3:prepare db "SELECT id FROM paths WHERE path=? AND parent_id=?;"))
         (id-num #f))
-    (sqlite3:for-each-row 
+    (dbi:for-each-row 
      (lambda (num) (set! id-num num)) stmt path parent)
-    (sqlite3:finalize! stmt)
+    (dbi:close stmt)
     id-num))
 
 (define (filedb:add-base db path)
   (let ((existing (filedb:get-base-id db path)))
     (if existing #f
         (begin
-          (sqlite3:execute db "INSERT INTO bases (base,updated) VALUES (?,?);" path (filedb:get-current-time-string))))))
+          (dbi:exec db "INSERT INTO bases (base,updated) VALUES (?,?);" path (filedb:get-current-time-string))))))
 
 ;; index 	value 	field 	notes
 ;; 0 	inode number 	st_ino 	
 ;; 1 	mode 	st_mode 	bitfield combining file permissions and file type
 ;; 2 	number of hard links 	st_nlink 	
@@ -95,25 +97,25 @@
 ;; 11 	block size 	st_blksize 	
 ;; 12 	number of blocks allocated 	st_blocks 	
 
 (define (filedb:add-path-stat db path parent statinfo)
   (let ((stmt (sqlite3:prepare db "INSERT INTO paths (path,parent_id,mode,uid,gid,size,mtime) VALUES (?,?,?,?,?,?,?);")))
-	(sqlite3:execute stmt
+	(dbi:exec stmt
 			 path
 			 parent
 			 (vector-ref statinfo 1) ;; mode
 			 (vector-ref statinfo 3) ;; uid
 			 (vector-ref statinfo 4) ;; gid
 			 (vector-ref statinfo 5) ;; size
 			 (vector-ref statinfo 8) ;; mtime
 			 )
-	(sqlite3:finalize! stmt))) ;;  (filedb:get-current-time-string))))
+	(dbi:close stmt))) ;;  (filedb:get-current-time-string))))
   
 (define (filedb:add-path db path parent)
   (let ((stmt (sqlite3:prepare db "INSERT INTO paths (path,parent_id) VALUES (?,?);")))
-    (sqlite3:execute stmt path parent)
-    (sqlite3:finalize! stmt)))
+    (dbi:exec stmt path parent)
+    (dbi:close stmt)))
 
 (define (filedb:register-path fdb path #!key (save-stat #f))
   (let* ((db        (filedb:fdb-get-db        fdb))
 	 (pathcache (filedb:fdb-get-pathcache fdb))
 	 (stat      (if save-stat (file-stat path #t)))
@@ -175,34 +177,34 @@
 
 (define (filedb:find-all fdb pattern action)
   (let* ((db     (filedb:fdb-get-db fdb))
 	 (stmt   (sqlite3:prepare db "SELECT id FROM paths WHERE path like ?;"))
 	 (result '()))
-    (sqlite3:for-each-row 
+    (dbi:for-each-row 
      (lambda (num)
        (action num)
        (set! result (cons num result))) stmt pattern)
-    (sqlite3:finalize! stmt)
+    (dbi:close stmt)
     result))
 
 (define (filedb:get-path-record fdb id)
   (let* ((db        (filedb:fdb-get-db        fdb))
 	 (partcache (filedb:fdb-get-partcache fdb))
 	 (dat (hash-table-ref/default partcache id #f)))
     (if dat dat
 	(let ((stmt (sqlite3:prepare db "SELECT path,parent_id FROM paths WHERE id=?;"))
 	      (result #f))
-	  (sqlite3:for-each-row 
+	  (dbi:for-each-row 
 	   (lambda (path parent_id)(set! result (list path parent_id))) stmt id)
 	  (hash-table-set! partcache id result)
-	  (sqlite3:finalize! stmt)
+	  (dbi:close stmt)
 	  result))))
 
 (define (filedb:get-children fdb parent-id)
   (let* ((db        (filedb:fdb-get-db fdb))
 	 (res       '()))
-    (sqlite3:for-each-row
+    (dbi:for-each-row
      (lambda (id path parent-id)
        (set! res (cons (vector id path parent-id) res)))
      db "SELECT id,path,parent_id FROM paths WHERE parent_id=?;"
      parent-id)
     res))
@@ -211,11 +213,11 @@
 ;; children that match patt
 (define (filedb:get-children-patt fdb parent-id search-patt)
   (let* ((db        (filedb:fdb-get-db fdb))
 	 (res       '()))
     ;; first get the children that have no children
-    (sqlite3:for-each-row
+    (dbi:for-each-row
      (lambda (id path parent-id)
        (set! res (cons (vector id path parent-id) res)))
      db "SELECT id,path,parent_id FROM paths WHERE parent_id=? AND 
             (id IN (SELECT parent_id FROM paths) OR path LIKE ?);"
      parent-id search-patt)