--- BDB/BDB.xs	2007/09/24 18:14:11	1.19
+++ BDB/BDB.xs	2007/12/22 07:33:48	1.28
@@ -104,16 +104,16 @@
   REQ_QUIT,
   REQ_ENV_OPEN, REQ_ENV_CLOSE, REQ_ENV_TXN_CHECKPOINT, REQ_ENV_LOCK_DETECT,
   REQ_ENV_MEMP_SYNC, REQ_ENV_MEMP_TRICKLE,
-  REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC,
+  REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC, REQ_DB_UPGRADE,
   REQ_DB_PUT, REQ_DB_GET, REQ_DB_PGET, REQ_DB_DEL, REQ_DB_KEY_RANGE,
   REQ_TXN_COMMIT, REQ_TXN_ABORT, REQ_TXN_FINISH,
   REQ_C_CLOSE, REQ_C_COUNT, REQ_C_PUT, REQ_C_GET, REQ_C_PGET, REQ_C_DEL,
   REQ_SEQ_OPEN, REQ_SEQ_CLOSE, REQ_SEQ_GET, REQ_SEQ_REMOVE,
 };
 
-typedef struct aio_cb
+typedef struct bdb_cb
 {
-  struct aio_cb *volatile next;
+  struct bdb_cb *volatile next;
   SV *callback;
   int type, pri, result;
 
@@ -132,9 +132,9 @@
   DB_KEY_RANGE key_range;
   DB_SEQUENCE *seq;
   db_seq_t seq_t;
-} aio_cb;
+} bdb_cb;
 
-typedef aio_cb *aio_req;
+typedef bdb_cb *bdb_req;
 
 enum {
   PRI_MIN     = -4,
@@ -171,7 +171,7 @@
   thread_t tid;
 
   /* locked by reslock, reqlock or wrklock */
-  aio_req req; /* currently processed request */
+  bdb_req req; /* currently processed request */
   void *dbuf;
   DIR *dirp;
 } worker;
@@ -248,14 +248,14 @@
  * per shift, the most expensive operation.
  */
 typedef struct {
-  aio_req qs[NUM_PRI], qe[NUM_PRI]; /* qstart, qend */
+  bdb_req qs[NUM_PRI], qe[NUM_PRI]; /* qstart, qend */
   int size;
 } reqq;
 
 static reqq req_queue;
 static reqq res_queue;
 
-int reqq_push (reqq *q, aio_req req)
+int reqq_push (reqq *q, bdb_req req)
 {
   int pri = req->pri;
   req->next = 0;
@@ -271,7 +271,7 @@
   return q->size++;
 }
 
-aio_req reqq_shift (reqq *q)
+bdb_req reqq_shift (reqq *q)
 {
   int pri;
 
@@ -282,7 +282,7 @@
 
   for (pri = NUM_PRI; pri--; )
     {
-      aio_req req = q->qs[pri];
+      bdb_req req = q->qs[pri];
 
       if (req)
         {
@@ -297,10 +297,10 @@
 }
 
 static int poll_cb ();
-static void req_free (aio_req req);
-static void req_cancel (aio_req req);
+static void req_free (bdb_req req);
+static void req_cancel (bdb_req req);
 
-static int req_invoke (aio_req req)
+static int req_invoke (bdb_req req)
 {
   dSP;
 
@@ -328,6 +328,12 @@
             dbt_to_sv (req->sv3, &req->dbt3);
             break;
 
+          case REQ_DB_PUT:
+          case REQ_C_PUT:
+            dbt_to_sv (0, &req->dbt1);
+            dbt_to_sv (0, &req->dbt2);
+            break;
+
           case REQ_DB_KEY_RANGE:
             {
               AV *av = newAV ();
@@ -346,9 +352,9 @@
             SvREADONLY_off (req->sv1);
 
             if (sizeof (IV) > 4)
-              sv_setiv_mg (req->sv1, req->seq_t);
+              sv_setiv_mg (req->sv1, (IV)req->seq_t);
             else
-              sv_setnv_mg (req->sv1, req->seq_t);
+              sv_setnv_mg (req->sv1, (NV)req->seq_t);
 
             SvREFCNT_dec (req->sv1);
             break;
@@ -367,7 +373,7 @@
   return !SvTRUE (ERRSV);
 }
 
-static void req_free (aio_req req)
+static void req_free (bdb_req req)
 {
   free (req->buf1);
   free (req->buf2);
@@ -383,6 +389,9 @@
 static void
 create_respipe ()
 {
+#ifdef _WIN32
+  int arg; /* argg */
+#endif
   int old_readfd = respipe [0];
 
   if (respipe [1] >= 0)
@@ -405,7 +414,7 @@
     }
 
 #ifdef _WIN32
-  int arg = 1;
+  arg = 1;
   if (ioctlsocket (TO_SOCKET (respipe [0]), FIONBIO, &arg)
       || ioctlsocket (TO_SOCKET (respipe [1]), FIONBIO, &arg))
 #else
@@ -454,7 +463,7 @@
   start_thread ();
 }
 
-static void req_send (aio_req req)
+static void req_send (bdb_req req)
 {
   SV *wait_callback = 0;
 
@@ -472,7 +481,7 @@
       if (count != 2)
         croak ("prepare callback must return exactly two values\n");
 
-      wait_callback = SvREFCNT_inc (POPs);
+      wait_callback = POPs;
       SvREFCNT_dec (req->callback);
       req->callback = SvREFCNT_inc (POPs);
     }
@@ -493,15 +502,14 @@
       PUSHMARK (SP);
       PUTBACK;
       call_sv (wait_callback, G_DISCARD);
-      SvREFCNT_dec (wait_callback);
     }
 }
 
 static void end_thread (void)
 {
-  aio_req req;
+  bdb_req req;
 
-  Newz (0, req, 1, aio_cb);
+  Newz (0, req, 1, bdb_cb);
 
   req->type = REQ_QUIT;
   req->pri  = PRI_MAX + PRI_BIAS;
@@ -568,7 +576,7 @@
   int maxreqs = max_poll_reqs;
   int do_croak = 0;
   struct timeval tv_start, tv_now;
-  aio_req req;
+  bdb_req req;
 
   if (max_poll_time)
     gettimeofday (&tv_start, 0);
@@ -639,7 +647,7 @@
 
 X_THREAD_PROC (bdb_proc)
 {
-  aio_req req;
+  bdb_req req;
   struct timespec ts;
   worker *self = (worker *)thr_arg;
 
@@ -732,6 +740,10 @@
             req->result = req->db->sync (req->db, req->uint1);
             break;
 
+          case REQ_DB_UPGRADE:
+            req->result = req->db->upgrade (req->db, req->buf1, req->uint1);
+            break;
+
           case REQ_DB_PUT:
             req->result = req->db->put (req->db, req->txn, &req->dbt1, &req->dbt2, req->uint1);
             break;
@@ -863,7 +875,7 @@
 
 static void atfork_child (void)
 {
-  aio_req prv;
+  bdb_req prv;
 
   while (prv = reqq_shift (&req_queue))
     req_free (prv);
@@ -894,16 +906,16 @@
 }
 
 #define dREQ(reqtype)						\
-  aio_req req;							\
+  bdb_req req;							\
   int req_pri = next_pri;					\
   next_pri = DEFAULT_PRI + PRI_BIAS;				\
 								\
   if (SvOK (callback) && !SvROK (callback))			\
     croak ("callback must be undef or of reference type");	\
 								\
-  Newz (0, req, 1, aio_cb);	        			\
+  Newz (0, req, 1, bdb_cb);	        			\
   if (!req)							\
-    croak ("out of memory during aio_req allocation");		\
+    croak ("out of memory during bdb_req allocation");		\
 								\
   req->callback = newSVsv (callback);				\
   req->type = (reqtype); 					\
@@ -962,6 +974,7 @@
           const_iv (INIT_TXN)
           const_iv (RECOVER_FATAL)
           const_iv (CREATE)
+          const_iv (RDONLY)
           const_iv (USE_ENVIRON)
           const_iv (USE_ENVIRON_ROOT)
           const_iv (LOCKDOWN)
@@ -984,6 +997,7 @@
           const_iv (REGION_INIT)
           const_iv (TIME_NOTGRANTED)
           const_iv (TXN_NOSYNC)
+          const_iv (TXN_NOT_DURABLE)
           const_iv (TXN_WRITE_NOSYNC)
           const_iv (WRITECURSOR)
           const_iv (YIELDCPU)
@@ -1001,7 +1015,6 @@
           const_iv (NOSYNC)
           const_iv (CHKSUM)
           const_iv (ENCRYPT)
-          const_iv (TXN_NOT_DURABLE)
           const_iv (DUP)
           const_iv (DUPSORT)
           const_iv (RECNUM)
@@ -1016,6 +1029,7 @@
           //const_iv (MULTIPLE)
           const_iv (SNAPSHOT)
           const_iv (JOIN_ITEM)
+          const_iv (JOIN_NOSORT)
           const_iv (RMW)
 
           const_iv (NOTFOUND)
@@ -1041,7 +1055,6 @@
           const_iv (SET_LOCK_TIMEOUT)
           const_iv (SET_TXN_TIMEOUT)
 
-          const_iv (JOIN_ITEM)
           const_iv (FIRST)
           const_iv (NEXT)
           const_iv (NEXT_DUP)
@@ -1085,7 +1098,6 @@
           const_iv (NOSERVER_HOME)
           const_iv (NOSERVER_ID)
           const_iv (NOTFOUND)
-          const_iv (OLD_VERSION)
           const_iv (PAGE_NOTFOUND)
           const_iv (REP_DUPMASTER)
           const_iv (REP_HANDLE_DEAD)
@@ -1118,22 +1130,20 @@
 #endif
 #if DB_VERSION_MINOR >= 6
           const_iv (PREV_DUP)
-# if 0
           const_iv (PRIORITY_UNCHANGED)
           const_iv (PRIORITY_VERY_LOW)
           const_iv (PRIORITY_LOW)
           const_iv (PRIORITY_DEFAULT)
           const_iv (PRIORITY_HIGH)
           const_iv (PRIORITY_VERY_HIGH)
-# endif
 #endif
         };
 
         for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
           newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
 
-        newCONSTSUB (stash, "DB_VERSION", newSVnv (DB_VERSION_MAJOR + DB_VERSION_MINOR * .1));
-        newCONSTSUB (stash, "DB_VERSION_STRING", newSVpv (DB_VERSION_STRING, 0));
+        newCONSTSUB (stash, "VERSION", newSVnv (DB_VERSION_MAJOR + DB_VERSION_MINOR * .1));
+        newCONSTSUB (stash, "VERSION_STRING", newSVpv (DB_VERSION_STRING, 0));
 
         create_respipe ();
 
@@ -1445,6 +1455,17 @@
 }
 
 void
+db_upgrade (DB *db, octetstring file, U32 flags = 0, SV *callback = &PL_sv_undef)
+	CODE:
+{
+        dREQ (REQ_DB_SYNC);
+        req->db    = db;
+        req->buf1  = strdup (file);
+        req->uint1 = flags;
+        REQ_SEND;
+}
+
+void
 db_key_range (DB *db, DB_TXN_ornull *txn, SV *key, SV *key_range, U32 flags = 0, SV *callback = &PL_sv_undef)
 	CODE:
 {
@@ -1473,6 +1494,8 @@
 void
 db_get (DB *db, DB_TXN_ornull *txn, SV *key, SV *data, U32 flags = 0, SV *callback = &PL_sv_undef)
 	CODE:
+        if (SvREADONLY (data))
+          croak ("can't modify read-only data scalar in db_get");
 {
         dREQ (REQ_DB_GET);
         req->db    = db;
@@ -1487,6 +1510,8 @@
 void
 db_pget (DB *db, DB_TXN_ornull *txn, SV *key, SV *pkey, SV *data, U32 flags = 0, SV *callback = &PL_sv_undef)
 	CODE:
+        if (SvREADONLY (data))
+          croak ("can't modify read-only data scalar in db_pget");
 {
         dREQ (REQ_DB_PGET);
         req->db    = db;
@@ -1725,7 +1750,7 @@
 	OUTPUT:
         RETVAL
 
-int set_flags (DB_ENV *env, U32 flags, int onoff)
+int set_flags (DB_ENV *env, U32 flags, int onoff = 1)
 	CODE:
         RETVAL = env->set_flags (env, flags, onoff);
 	OUTPUT:
@@ -1739,7 +1764,7 @@
 	CODE:
         env->set_msgfile (env, msgfile);
 
-int set_verbose (DB_ENV *env, U32 which, int onoff = 1)
+int set_verbose (DB_ENV *env, U32 which = -1, int onoff = 1)
 	CODE:
         RETVAL = env->set_verbose (env, which, onoff);
 	OUTPUT:
@@ -1811,6 +1836,30 @@
 	OUTPUT:
         RETVAL
 
+int mutex_set_max (DB_ENV *env, U32 max)
+        CODE:
+        RETVAL = env->mutex_set_max (env, max);
+        OUTPUT:
+        RETVAL
+
+int mutex_set_increment (DB_ENV *env, U32 increment)
+        CODE:
+        RETVAL = env->mutex_set_increment (env, increment);
+        OUTPUT:
+        RETVAL
+
+int mutex_set_tas_spins (DB_ENV *env, U32 tas_spins)
+        CODE:
+        RETVAL = env->mutex_set_tas_spins (env, tas_spins);
+        OUTPUT:
+        RETVAL
+
+int mutex_set_align (DB_ENV *env, U32 align)
+        CODE:
+        RETVAL = env->mutex_set_align (env, align);
+        OUTPUT:
+        RETVAL
+
 DB_TXN *
 txn_begin (DB_ENV *env, DB_TXN_ornull *parent = 0, U32 flags = 0)
 	CODE:
@@ -1954,6 +2003,14 @@
         if (dbc)
           dbc->c_close (dbc);
 
+#if DB_VERSION_MINOR >= 6
+
+int set_priority (DBC *dbc, int priority)
+        CODE:
+        dbc->set_priority (dbc, priority);
+
+#endif
+
 MODULE = BDB		PACKAGE = BDB::Sequence
 
 void