Patchwork [1/1] python: Fix to support the python module _bsddb built with db 5.3

login
register
mail settings
Submitter jackie huang
Date Aug. 4, 2012, 1:14 p.m.
Message ID <898ab38feff6572ea4372256645bdae30a35e272.1344085668.git.jackie.huang@windriver.com>
Download mbox | patch
Permalink /patch/33779/
State Accepted
Commit 11267f8a1ccf65142988b095351a84b0fa0fcbcf
Headers show

Comments

jackie huang - Aug. 4, 2012, 1:14 p.m.
From: Jackie Huang <jackie.huang@windriver.com>

_bsddb module in python 2.7 could be built only with db version
between 4.1 and 4.7. A patch was added to avoid build warning
about this for [YOCTO #1937] but not actually fixed it.

This patch enable _bsddb module be built with db 5.3, and remove
--disable-statistics from the DB5_CONFIG to fix segmentation fault
when using _bsddb module in python.

[YOCTO #2749]

Signed-off-by: Jackie Huang <jackie.huang@windriver.com>
---
 .../python/python/avoid_warning_about_bsddb.patch  |   23 -
 .../python/python-2.7.3-berkeley-db-5.3.patch      | 1570 ++++++++++++++++++++
 .../python/python-2.7.3-remove-bsdb-rpath.patch    |   22 +
 meta/recipes-devtools/python/python_2.7.3.bb       |    5 +-
 meta/recipes-support/db/db_5.3.15.bb               |    4 +-
 5 files changed, 1597 insertions(+), 27 deletions(-)
 delete mode 100644 meta/recipes-devtools/python/python/avoid_warning_about_bsddb.patch
 create mode 100644 meta/recipes-devtools/python/python/python-2.7.3-berkeley-db-5.3.patch
 create mode 100644 meta/recipes-devtools/python/python/python-2.7.3-remove-bsdb-rpath.patch

Patch

diff --git a/meta/recipes-devtools/python/python/avoid_warning_about_bsddb.patch b/meta/recipes-devtools/python/python/avoid_warning_about_bsddb.patch
deleted file mode 100644
index 4968744..0000000
--- a/meta/recipes-devtools/python/python/avoid_warning_about_bsddb.patch
+++ /dev/null
@@ -1,23 +0,0 @@ 
-_bsddb module can be built only with db version between 4.1 and 4.7.
-Avoid a warning by not adding this module to missing variable.
-
-Upstream-Status: Inappropriate [distribution]
-
-Signed-off-by: Andrei Gherzan <andrei@gherzan.ro>
-
-
-Index: Python-2.7.2/setup.py
-===================================================================
---- Python-2.7.2.orig/setup.py	2012-04-05 23:16:49.268139840 +0300
-+++ Python-2.7.2/setup.py	2012-04-05 23:17:30.912138622 +0300
-@@ -1024,7 +1024,9 @@
-             db_incs = None
-             dblibs = []
-             dblib_dir = None
--            missing.append('_bsddb')
-+            # We need db version between 4.1 and 4.7
-+            # Avoid this warning
-+            #missing.append('_bsddb')
- 
-         # The sqlite interface
-         sqlite_setup_debug = False   # verbose debug prints from this script?
diff --git a/meta/recipes-devtools/python/python/python-2.7.3-berkeley-db-5.3.patch b/meta/recipes-devtools/python/python/python-2.7.3-berkeley-db-5.3.patch
new file mode 100644
index 0000000..469cbb3
--- /dev/null
+++ b/meta/recipes-devtools/python/python/python-2.7.3-berkeley-db-5.3.patch
@@ -0,0 +1,1570 @@ 
+Fix to support db 5.3 for bsddb module in python 2.7.2
+
+This patch is made from the db5.1.diff in
+http://archive.ubuntu.com/ubuntu/pool/main/p/python2.7/python2.7_2.7.3-0ubuntu3.diff.gz
+
+Signed-off-by: Jackie Huang <jackie.huang@windriver.com>
+---
+ Lib/bsddb/__init__.py        |    2 +-
+ Lib/bsddb/test/test_all.py   |    5 +-
+ Lib/bsddb/test/test_dbenv.py |   29 +++-
+ Modules/_bsddb.c             |  439 +++++++++++++++++++++++-------------------
+ Modules/bsddb.h              |   20 +-
+ setup.py                     |   25 +++-
+ 6 files changed, 307 insertions(+), 213 deletions(-)
+
+diff --git a/Lib/bsddb/__init__.py b/Lib/bsddb/__init__.py
+index ed4deea..1b1c388 100644
+--- a/Lib/bsddb/__init__.py
++++ b/Lib/bsddb/__init__.py
+@@ -33,7 +33,7 @@
+ #----------------------------------------------------------------------
+ 
+ 
+-"""Support for Berkeley DB 4.1 through 4.8 with a simple interface.
++"""Support for Berkeley DB 4.2 through 5.3 with a simple interface.
+ 
+ For the full featured object oriented interface use the bsddb.db module
+ instead.  It mirrors the Oracle Berkeley DB C API.
+diff --git a/Lib/bsddb/test/test_all.py b/Lib/bsddb/test/test_all.py
+index e9fe618..6a25f4a 100644
+--- a/Lib/bsddb/test/test_all.py
++++ b/Lib/bsddb/test/test_all.py
+@@ -484,6 +484,8 @@ def print_versions():
+     print '-=' * 38
+     print db.DB_VERSION_STRING
+     print 'bsddb.db.version():   %s' % (db.version(), )
++    if db.version() >= (5, 0) :
++        print 'bsddb.db.full_version(): %s' %repr(db.full_version())
+     print 'bsddb.db.__version__: %s' % db.__version__
+     print 'bsddb.db.cvsid:       %s' % db.cvsid
+ 
+@@ -528,7 +530,8 @@ def get_new_database_path() :
+ 
+ # This path can be overriden via "set_test_path_prefix()".
+ import os, os.path
+-get_new_path.prefix=os.path.join(os.sep,"tmp","z-Berkeley_DB")
++get_new_path.prefix=os.path.join(os.environ.get("TMPDIR",
++    os.path.join(os.sep,"tmp")), "z-Berkeley_DB")
+ get_new_path.num=0
+ 
+ def get_test_path_prefix() :
+diff --git a/Lib/bsddb/test/test_dbenv.py b/Lib/bsddb/test/test_dbenv.py
+index 37281df..6ac1e54 100644
+--- a/Lib/bsddb/test/test_dbenv.py
++++ b/Lib/bsddb/test/test_dbenv.py
+@@ -25,12 +25,31 @@ class DBEnv(unittest.TestCase):
+         test_support.rmtree(self.homeDir)
+ 
+ class DBEnv_general(DBEnv) :
++    def test_get_open_flags(self) :
++        flags = db.DB_CREATE | db.DB_INIT_MPOOL
++        self.env.open(self.homeDir, flags)
++        self.assertEqual(flags, self.env.get_open_flags())
++
++    def test_get_open_flags2(self) :
++        flags = db.DB_CREATE | db.DB_INIT_MPOOL | \
++                db.DB_INIT_LOCK | db.DB_THREAD
++        self.env.open(self.homeDir, flags)
++        self.assertEqual(flags, self.env.get_open_flags())
++
+     if db.version() >= (4, 7) :
+         def test_lk_partitions(self) :
+             for i in [10, 20, 40] :
+                 self.env.set_lk_partitions(i)
+                 self.assertEqual(i, self.env.get_lk_partitions())
+ 
++        def test_getset_intermediate_dir_mode(self) :
++            self.assertEqual(None, self.env.get_intermediate_dir_mode())
++            for mode in ["rwx------", "rw-rw-rw-", "rw-r--r--"] :
++                self.env.set_intermediate_dir_mode(mode)
++                self.assertEqual(mode, self.env.get_intermediate_dir_mode())
++            self.assertRaises(db.DBInvalidArgError,
++                    self.env.set_intermediate_dir_mode, "abcde")
++
+     if db.version() >= (4, 6) :
+         def test_thread(self) :
+             for i in [16, 100, 1000] :
+@@ -115,7 +134,7 @@ class DBEnv_general(DBEnv) :
+                 self.assertEqual(i, self.env.get_lk_max_lockers())
+ 
+         def test_lg_regionmax(self) :
+-            for i in [128, 256, 1024] :
++            for i in [128, 256, 1000] :
+                 i = i*1024*1024
+                 self.env.set_lg_regionmax(i)
+                 j = self.env.get_lg_regionmax()
+@@ -172,8 +191,12 @@ class DBEnv_general(DBEnv) :
+             self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)
+             cachesize = (0, 2*1024*1024, 1)
+             self.assertRaises(db.DBInvalidArgError,
+-                self.env.set_cachesize, *cachesize)
+-            self.assertEqual(cachesize2, self.env.get_cachesize())
++                              self.env.set_cachesize, *cachesize)
++            cachesize3 = self.env.get_cachesize()
++            self.assertEqual(cachesize2[0], cachesize3[0])
++            self.assertEqual(cachesize2[2], cachesize3[2])
++            # In Berkeley DB 5.3, the cachesize can change when opening the Env
++            self.assertTrue(cachesize2[1] <= cachesize3[1])
+ 
+         def test_set_cachesize_dbenv_db(self) :
+             # You can not configure the cachesize using
+diff --git a/Modules/_bsddb.c b/Modules/_bsddb.c
+index d2d12ff..e98e4bc 100644
+--- a/Modules/_bsddb.c
++++ b/Modules/_bsddb.c
+@@ -187,8 +187,10 @@ static PyObject* DBOldVersionError;     /* DB_OLD_VERSION */
+ static PyObject* DBRunRecoveryError;    /* DB_RUNRECOVERY */
+ static PyObject* DBVerifyBadError;      /* DB_VERIFY_BAD */
+ static PyObject* DBNoServerError;       /* DB_NOSERVER */
++#if (DBVER < 52)
+ static PyObject* DBNoServerHomeError;   /* DB_NOSERVER_HOME */
+ static PyObject* DBNoServerIDError;     /* DB_NOSERVER_ID */
++#endif
+ static PyObject* DBPageNotFoundError;   /* DB_PAGE_NOTFOUND */
+ static PyObject* DBSecondaryBadError;   /* DB_SECONDARY_BAD */
+ 
+@@ -202,9 +204,7 @@ static PyObject* DBFileExistsError;     /* EEXIST */
+ static PyObject* DBNoSuchFileError;     /* ENOENT */
+ static PyObject* DBPermissionsError;    /* EPERM  */
+ 
+-#if (DBVER >= 42)
+ static PyObject* DBRepHandleDeadError;  /* DB_REP_HANDLE_DEAD */
+-#endif
+ #if (DBVER >= 44)
+ static PyObject* DBRepLockoutError;     /* DB_REP_LOCKOUT */
+ #endif
+@@ -696,8 +696,10 @@ static int makeDBError(int err)
+         case DB_RUNRECOVERY:        errObj = DBRunRecoveryError;    break;
+         case DB_VERIFY_BAD:         errObj = DBVerifyBadError;      break;
+         case DB_NOSERVER:           errObj = DBNoServerError;       break;
++#if (DBVER < 52)
+         case DB_NOSERVER_HOME:      errObj = DBNoServerHomeError;   break;
+         case DB_NOSERVER_ID:        errObj = DBNoServerIDError;     break;
++#endif
+         case DB_PAGE_NOTFOUND:      errObj = DBPageNotFoundError;   break;
+         case DB_SECONDARY_BAD:      errObj = DBSecondaryBadError;   break;
+         case DB_BUFFER_SMALL:       errObj = DBNoMemoryError;       break;
+@@ -715,9 +717,7 @@ static int makeDBError(int err)
+         case ENOENT:  errObj = DBNoSuchFileError;   break;
+         case EPERM :  errObj = DBPermissionsError;  break;
+ 
+-#if (DBVER >= 42)
+         case DB_REP_HANDLE_DEAD : errObj = DBRepHandleDeadError; break;
+-#endif
+ #if (DBVER >= 44)
+         case DB_REP_LOCKOUT : errObj = DBRepLockoutError; break;
+ #endif
+@@ -2132,7 +2132,7 @@ DB_get_size(DBObject* self, PyObject* args, PyObject* kwargs)
+     MYDB_BEGIN_ALLOW_THREADS;
+     err = self->db->get(self->db, txn, &key, &data, flags);
+     MYDB_END_ALLOW_THREADS;
+-    if (err == DB_BUFFER_SMALL) {
++    if ((err == DB_BUFFER_SMALL) || (err == 0)) {
+         retval = NUMBER_FromLong((long)data.size);
+         err = 0;
+     }
+@@ -2385,9 +2385,7 @@ DB_open(DBObject* self, PyObject* args, PyObject* kwargs)
+         return NULL;
+     }
+ 
+-#if (DBVER >= 42)
+     self->db->get_flags(self->db, &self->setflags);
+-#endif
+ 
+     self->flags = flags;
+ 
+@@ -2539,6 +2537,37 @@ DB_get_priority(DBObject* self)
+ #endif
+ 
+ static PyObject*
++DB_get_dbname(DBObject* self)
++{
++    int err;
++    const char *filename, *dbname;
++
++    CHECK_DB_NOT_CLOSED(self);
++
++    MYDB_BEGIN_ALLOW_THREADS;
++    err = self->db->get_dbname(self->db, &filename, &dbname);
++    MYDB_END_ALLOW_THREADS;
++    RETURN_IF_ERR();
++    /* If "dbname==NULL", it is correctly converted to "None" */
++    return Py_BuildValue("(ss)", filename, dbname);
++}
++
++static PyObject*
++DB_get_open_flags(DBObject* self)
++{
++    int err;
++    unsigned int flags;
++
++    CHECK_DB_NOT_CLOSED(self);
++
++    MYDB_BEGIN_ALLOW_THREADS;
++    err = self->db->get_open_flags(self->db, &flags);
++    MYDB_END_ALLOW_THREADS;
++    RETURN_IF_ERR();
++    return NUMBER_FromLong(flags);
++}
++
++static PyObject*
+ DB_set_q_extentsize(DBObject* self, PyObject* args)
+ {
+     int err;
+@@ -2555,7 +2584,6 @@ DB_set_q_extentsize(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_q_extentsize(DBObject* self)
+ {
+@@ -2570,7 +2598,6 @@ DB_get_q_extentsize(DBObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(extentsize);
+ }
+-#endif
+ 
+ static PyObject*
+ DB_set_bt_minkey(DBObject* self, PyObject* args)
+@@ -2588,7 +2615,6 @@ DB_set_bt_minkey(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_bt_minkey(DBObject* self)
+ {
+@@ -2603,7 +2629,6 @@ DB_get_bt_minkey(DBObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(bt_minkey);
+ }
+-#endif
+ 
+ static int
+ _default_cmp(const DBT *leftKey,
+@@ -2759,7 +2784,6 @@ DB_set_cachesize(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_cachesize(DBObject* self)
+ {
+@@ -2777,7 +2801,6 @@ DB_get_cachesize(DBObject* self)
+ 
+     return Py_BuildValue("(iii)", gbytes, bytes, ncache);
+ }
+-#endif
+ 
+ static PyObject*
+ DB_set_flags(DBObject* self, PyObject* args)
+@@ -2797,7 +2820,6 @@ DB_set_flags(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_flags(DBObject* self)
+ {
+@@ -2812,6 +2834,35 @@ DB_get_flags(DBObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(flags);
+ }
++
++#if (DBVER >= 43)
++static PyObject*
++DB_get_transactional(DBObject* self)
++{
++    int err;
++
++    CHECK_DB_NOT_CLOSED(self);
++
++    MYDB_BEGIN_ALLOW_THREADS;
++    err = self->db->get_transactional(self->db);
++    MYDB_END_ALLOW_THREADS;
++
++    if(err == 0) {
++        Py_INCREF(Py_False);
++        return Py_False;
++    } else if(err == 1) {
++        Py_INCREF(Py_True);
++        return Py_True;
++    }
++
++    /*
++    ** If we reach there, there was an error. The
++    ** "return" should be unreachable.
++    */
++    RETURN_IF_ERR();
++    assert(0);  /* This coude SHOULD be unreachable */
++    return NULL;
++}
+ #endif
+ 
+ static PyObject*
+@@ -2830,7 +2881,6 @@ DB_set_h_ffactor(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_h_ffactor(DBObject* self)
+ {
+@@ -2845,7 +2895,6 @@ DB_get_h_ffactor(DBObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(ffactor);
+ }
+-#endif
+ 
+ static PyObject*
+ DB_set_h_nelem(DBObject* self, PyObject* args)
+@@ -2863,7 +2912,6 @@ DB_set_h_nelem(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_h_nelem(DBObject* self)
+ {
+@@ -2878,7 +2926,6 @@ DB_get_h_nelem(DBObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(nelem);
+ }
+-#endif
+ 
+ static PyObject*
+ DB_set_lorder(DBObject* self, PyObject* args)
+@@ -2896,7 +2943,6 @@ DB_set_lorder(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_lorder(DBObject* self)
+ {
+@@ -2911,7 +2957,6 @@ DB_get_lorder(DBObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(lorder);
+ }
+-#endif
+ 
+ static PyObject*
+ DB_set_pagesize(DBObject* self, PyObject* args)
+@@ -2929,7 +2974,6 @@ DB_set_pagesize(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_pagesize(DBObject* self)
+ {
+@@ -2944,7 +2988,6 @@ DB_get_pagesize(DBObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(pagesize);
+ }
+-#endif
+ 
+ static PyObject*
+ DB_set_re_delim(DBObject* self, PyObject* args)
+@@ -2967,7 +3010,6 @@ DB_set_re_delim(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_re_delim(DBObject* self)
+ {
+@@ -2981,7 +3023,6 @@ DB_get_re_delim(DBObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(re_delim);
+ }
+-#endif
+ 
+ static PyObject*
+ DB_set_re_len(DBObject* self, PyObject* args)
+@@ -2999,7 +3040,6 @@ DB_set_re_len(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_re_len(DBObject* self)
+ {
+@@ -3014,7 +3054,6 @@ DB_get_re_len(DBObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(re_len);
+ }
+-#endif
+ 
+ static PyObject*
+ DB_set_re_pad(DBObject* self, PyObject* args)
+@@ -3036,7 +3075,6 @@ DB_set_re_pad(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_re_pad(DBObject* self)
+ {
+@@ -3050,7 +3088,6 @@ DB_get_re_pad(DBObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(re_pad);
+ }
+-#endif
+ 
+ static PyObject*
+ DB_set_re_source(DBObject* self, PyObject* args)
+@@ -3069,7 +3106,6 @@ DB_set_re_source(DBObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_re_source(DBObject* self)
+ {
+@@ -3084,7 +3120,6 @@ DB_get_re_source(DBObject* self)
+     RETURN_IF_ERR();
+     return PyBytes_FromString(source);
+ }
+-#endif
+ 
+ static PyObject*
+ DB_stat(DBObject* self, PyObject* args, PyObject* kwargs)
+@@ -3381,7 +3416,6 @@ DB_set_encrypt(DBObject* self, PyObject* args, PyObject* kwargs)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DB_get_encrypt_flags(DBObject* self)
+ {
+@@ -3396,7 +3430,6 @@ DB_get_encrypt_flags(DBObject* self)
+ 
+     return NUMBER_FromLong(flags);
+ }
+-#endif
+ 
+ 
+ 
+@@ -4987,7 +5020,6 @@ DBEnv_set_encrypt(DBEnvObject* self, PyObject* args, PyObject* kwargs)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_encrypt_flags(DBEnvObject* self)
+ {
+@@ -5025,7 +5057,6 @@ DBEnv_get_timeout(DBEnvObject* self, PyObject* args, PyObject* kwargs)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(timeout);
+ }
+-#endif
+ 
+ 
+ static PyObject*
+@@ -5064,7 +5095,6 @@ DBEnv_set_shm_key(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_shm_key(DBEnvObject* self)
+ {
+@@ -5081,7 +5111,6 @@ DBEnv_get_shm_key(DBEnvObject* self)
+ 
+     return NUMBER_FromLong(shm_key);
+ }
+-#endif
+ 
+ #if (DBVER >= 46)
+ static PyObject*
+@@ -5170,7 +5199,6 @@ DBEnv_set_cachesize(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_cachesize(DBEnvObject* self)
+ {
+@@ -5188,7 +5216,6 @@ DBEnv_get_cachesize(DBEnvObject* self)
+ 
+     return Py_BuildValue("(iii)", gbytes, bytes, ncache);
+ }
+-#endif
+ 
+ 
+ static PyObject*
+@@ -5208,7 +5235,6 @@ DBEnv_set_flags(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_flags(DBEnvObject* self)
+ {
+@@ -5223,7 +5249,6 @@ DBEnv_get_flags(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(flags);
+ }
+-#endif
+ 
+ #if (DBVER >= 47)
+ static PyObject*
+@@ -5423,7 +5448,6 @@ DBEnv_set_data_dir(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_data_dirs(DBEnvObject* self)
+ {
+@@ -5463,7 +5487,6 @@ DBEnv_get_data_dirs(DBEnvObject* self)
+     }
+     return tuple;
+ }
+-#endif
+ 
+ #if (DBVER >= 44)
+ static PyObject*
+@@ -5513,7 +5536,6 @@ DBEnv_set_lg_bsize(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_lg_bsize(DBEnvObject* self)
+ {
+@@ -5528,7 +5550,6 @@ DBEnv_get_lg_bsize(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(lg_bsize);
+ }
+-#endif
+ 
+ static PyObject*
+ DBEnv_set_lg_dir(DBEnvObject* self, PyObject* args)
+@@ -5547,7 +5568,6 @@ DBEnv_set_lg_dir(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_lg_dir(DBEnvObject* self)
+ {
+@@ -5562,7 +5582,6 @@ DBEnv_get_lg_dir(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return PyBytes_FromString(dirp);
+ }
+-#endif
+ 
+ static PyObject*
+ DBEnv_set_lg_max(DBEnvObject* self, PyObject* args)
+@@ -5580,7 +5599,6 @@ DBEnv_set_lg_max(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_lg_max(DBEnvObject* self)
+ {
+@@ -5595,8 +5613,6 @@ DBEnv_get_lg_max(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(lg_max);
+ }
+-#endif
+-
+ 
+ static PyObject*
+ DBEnv_set_lg_regionmax(DBEnvObject* self, PyObject* args)
+@@ -5614,7 +5630,6 @@ DBEnv_set_lg_regionmax(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_lg_regionmax(DBEnvObject* self)
+ {
+@@ -5629,7 +5644,6 @@ DBEnv_get_lg_regionmax(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(lg_regionmax);
+ }
+-#endif
+ 
+ #if (DBVER >= 47)
+ static PyObject*
+@@ -5680,7 +5694,6 @@ DBEnv_set_lk_detect(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_lk_detect(DBEnvObject* self)
+ {
+@@ -5695,8 +5708,6 @@ DBEnv_get_lk_detect(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(lk_detect);
+ }
+-#endif
+-
+ 
+ #if (DBVER < 45)
+ static PyObject*
+@@ -5734,7 +5745,6 @@ DBEnv_set_lk_max_locks(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_lk_max_locks(DBEnvObject* self)
+ {
+@@ -5749,7 +5759,6 @@ DBEnv_get_lk_max_locks(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(lk_max);
+ }
+-#endif
+ 
+ static PyObject*
+ DBEnv_set_lk_max_lockers(DBEnvObject* self, PyObject* args)
+@@ -5767,7 +5776,6 @@ DBEnv_set_lk_max_lockers(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_lk_max_lockers(DBEnvObject* self)
+ {
+@@ -5782,7 +5790,6 @@ DBEnv_get_lk_max_lockers(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(lk_max);
+ }
+-#endif
+ 
+ static PyObject*
+ DBEnv_set_lk_max_objects(DBEnvObject* self, PyObject* args)
+@@ -5800,7 +5807,6 @@ DBEnv_set_lk_max_objects(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_lk_max_objects(DBEnvObject* self)
+ {
+@@ -5815,9 +5821,7 @@ DBEnv_get_lk_max_objects(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(lk_max);
+ }
+-#endif
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_mp_mmapsize(DBEnvObject* self)
+ {
+@@ -5832,8 +5836,6 @@ DBEnv_get_mp_mmapsize(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(mmapsize);
+ }
+-#endif
+-
+ 
+ static PyObject*
+ DBEnv_set_mp_mmapsize(DBEnvObject* self, PyObject* args)
+@@ -5869,8 +5871,6 @@ DBEnv_set_tmp_dir(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_tmp_dir(DBEnvObject* self)
+ {
+@@ -5887,8 +5887,6 @@ DBEnv_get_tmp_dir(DBEnvObject* self)
+ 
+     return PyBytes_FromString(dirpp);
+ }
+-#endif
+-
+ 
+ static PyObject*
+ DBEnv_txn_recover(DBEnvObject* self)
+@@ -5899,7 +5897,7 @@ DBEnv_txn_recover(DBEnvObject* self)
+     DBTxnObject *txn;
+ #define PREPLIST_LEN 16
+     DB_PREPLIST preplist[PREPLIST_LEN];
+-#if (DBVER < 48)
++#if (DBVER < 48 || DBVER > 51)
+     long retp;
+ #else
+     u_int32_t retp;
+@@ -6003,8 +6001,6 @@ DBEnv_txn_checkpoint(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_tx_max(DBEnvObject* self)
+ {
+@@ -6019,8 +6015,6 @@ DBEnv_get_tx_max(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return PyLong_FromUnsignedLong(max);
+ }
+-#endif
+-
+ 
+ static PyObject*
+ DBEnv_set_tx_max(DBEnvObject* self, PyObject* args)
+@@ -6038,8 +6032,6 @@ DBEnv_set_tx_max(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_tx_timestamp(DBEnvObject* self)
+ {
+@@ -6054,7 +6046,6 @@ DBEnv_get_tx_timestamp(DBEnvObject* self)
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(timestamp);
+ }
+-#endif
+ 
+ static PyObject*
+ DBEnv_set_tx_timestamp(DBEnvObject* self, PyObject* args)
+@@ -6756,6 +6747,55 @@ DBEnv_set_private(DBEnvObject* self, PyObject* private_obj)
+     RETURN_NONE();
+ }
+ 
++#if (DBVER >= 47)
++static PyObject*
++DBEnv_set_intermediate_dir_mode(DBEnvObject* self, PyObject* args)
++{
++    int err;
++    const char *mode;
++
++    if (!PyArg_ParseTuple(args,"s:set_intermediate_dir_mode", &mode))
++        return NULL;
++
++    CHECK_ENV_NOT_CLOSED(self);
++
++    MYDB_BEGIN_ALLOW_THREADS;
++    err = self->db_env->set_intermediate_dir_mode(self->db_env, mode);
++    MYDB_END_ALLOW_THREADS;
++    RETURN_IF_ERR();
++    RETURN_NONE();
++}
++
++static PyObject*
++DBEnv_get_intermediate_dir_mode(DBEnvObject* self)
++{
++    int err;
++    const char *mode;
++
++    CHECK_ENV_NOT_CLOSED(self);
++
++    MYDB_BEGIN_ALLOW_THREADS;
++    err = self->db_env->get_intermediate_dir_mode(self->db_env, &mode);
++    MYDB_END_ALLOW_THREADS;
++    RETURN_IF_ERR();
++    return Py_BuildValue("s", mode);
++}
++#endif
++
++static PyObject*
++DBEnv_get_open_flags(DBEnvObject* self)
++{
++    int err;
++    unsigned int flags;
++
++    CHECK_ENV_NOT_CLOSED(self);
++
++    MYDB_BEGIN_ALLOW_THREADS;
++    err = self->db_env->get_open_flags(self->db_env, &flags);
++    MYDB_END_ALLOW_THREADS;
++    RETURN_IF_ERR();
++    return NUMBER_FromLong(flags);
++}
+ 
+ #if (DBVER < 48)
+ static PyObject*
+@@ -6875,7 +6915,6 @@ DBEnv_set_verbose(DBEnvObject* self, PyObject* args)
+     RETURN_NONE();
+ }
+ 
+-#if (DBVER >= 42)
+ static PyObject*
+ DBEnv_get_verbose(DBEnvObject* self, PyObject* args)
+ {
+@@ -6893,7 +6932,6 @@ DBEnv_get_verbose(DBEnvObject* self, PyObject* args)
+     RETURN_IF_ERR();
+     return PyBool_FromLong(verbose);
+ }
+-#endif
+ 
+ #if (DBVER >= 45)
+ static void
+@@ -6975,9 +7013,7 @@ DBEnv_rep_process_message(DBEnvObject* self, PyObject* args)
+     PyObject *control_py, *rec_py;
+     DBT control, rec;
+     int envid;
+-#if (DBVER >= 42)
+     DB_LSN lsn;
+-#endif
+ 
+     if (!PyArg_ParseTuple(args, "OOi:rep_process_message", &control_py,
+                 &rec_py, &envid))
+@@ -6994,13 +7030,8 @@ DBEnv_rep_process_message(DBEnvObject* self, PyObject* args)
+     err = self->db_env->rep_process_message(self->db_env, &control, &rec,
+             envid, &lsn);
+ #else
+-#if (DBVER >= 42)
+     err = self->db_env->rep_process_message(self->db_env, &control, &rec,
+             &envid, &lsn);
+-#else
+-    err = self->db_env->rep_process_message(self->db_env, &control, &rec,
+-            &envid);
+-#endif
+ #endif
+     MYDB_END_ALLOW_THREADS;
+     switch (err) {
+@@ -7029,12 +7060,10 @@ DBEnv_rep_process_message(DBEnvObject* self, PyObject* args)
+                 return r;
+                 break;
+             }
+-#if (DBVER >= 42)
+         case DB_REP_NOTPERM :
+         case DB_REP_ISPERM :
+             return Py_BuildValue("(i(ll))", err, lsn.file, lsn.offset);
+             break;
+-#endif
+     }
+     RETURN_IF_ERR();
+     return Py_BuildValue("(OO)", Py_None, Py_None);
+@@ -7086,20 +7115,6 @@ _DBEnv_rep_transportCallback(DB_ENV* db_env, const DBT* control, const DBT* rec,
+     return ret;
+ }
+ 
+-#if (DBVER <= 41)
+-static int
+-_DBEnv_rep_transportCallbackOLD(DB_ENV* db_env, const DBT* control, const DBT* rec,
+-        int envid, u_int32_t flags)
+-{
+-    DB_LSN lsn;
+-
+-    lsn.file = -1;  /* Dummy values */
+-    lsn.offset = -1;
+-    return _DBEnv_rep_transportCallback(db_env, control, rec, &lsn, envid,
+-            flags);
+-}
+-#endif
+-
+ static PyObject*
+ DBEnv_rep_set_transport(DBEnvObject* self, PyObject* args)
+ {
+@@ -7120,13 +7135,8 @@ DBEnv_rep_set_transport(DBEnvObject* self, PyObject* args)
+     err = self->db_env->rep_set_transport(self->db_env, envid,
+             &_DBEnv_rep_transportCallback);
+ #else
+-#if (DBVER >= 42)
+     err = self->db_env->set_rep_transport(self->db_env, envid,
+             &_DBEnv_rep_transportCallback);
+-#else
+-    err = self->db_env->set_rep_transport(self->db_env, envid,
+-            &_DBEnv_rep_transportCallbackOLD);
+-#endif
+ #endif
+     MYDB_END_ALLOW_THREADS;
+     RETURN_IF_ERR();
+@@ -7608,6 +7618,7 @@ DBEnv_repmgr_start(DBEnvObject* self, PyObject* args, PyObject*
+     RETURN_NONE();
+ }
+ 
++#if (DBVER < 52)
+ static PyObject*
+ DBEnv_repmgr_set_local_site(DBEnvObject* self, PyObject* args, PyObject*
+         kwargs)
+@@ -7654,6 +7665,7 @@ DBEnv_repmgr_add_remote_site(DBEnvObject* self, PyObject* args, PyObject*
+     RETURN_IF_ERR();
+     return NUMBER_FromLong(eidp);
+ }
++#endif
+ 
+ static PyObject*
+ DBEnv_repmgr_set_ack_policy(DBEnvObject* self, PyObject* args)
+@@ -8482,65 +8494,43 @@ static PyMethodDef DB_methods[] = {
+     {"remove",          (PyCFunction)DB_remove,         METH_VARARGS|METH_KEYWORDS},
+     {"rename",          (PyCFunction)DB_rename,         METH_VARARGS},
+     {"set_bt_minkey",   (PyCFunction)DB_set_bt_minkey,  METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_bt_minkey",   (PyCFunction)DB_get_bt_minkey,  METH_NOARGS},
+-#endif
+     {"set_bt_compare",  (PyCFunction)DB_set_bt_compare, METH_O},
+     {"set_cachesize",   (PyCFunction)DB_set_cachesize,  METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_cachesize",   (PyCFunction)DB_get_cachesize,  METH_NOARGS},
+-#endif
+     {"set_encrypt",     (PyCFunction)DB_set_encrypt,    METH_VARARGS|METH_KEYWORDS},
+-#if (DBVER >= 42)
+     {"get_encrypt_flags", (PyCFunction)DB_get_encrypt_flags, METH_NOARGS},
+-#endif
+-
+     {"set_flags",       (PyCFunction)DB_set_flags,      METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_flags",       (PyCFunction)DB_get_flags,      METH_NOARGS},
++#if (DBVER >= 43)
++    {"get_transactional", (PyCFunction)DB_get_transactional, METH_NOARGS},
+ #endif
+     {"set_h_ffactor",   (PyCFunction)DB_set_h_ffactor,  METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_h_ffactor",   (PyCFunction)DB_get_h_ffactor,  METH_NOARGS},
+-#endif
+     {"set_h_nelem",     (PyCFunction)DB_set_h_nelem,    METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_h_nelem",     (PyCFunction)DB_get_h_nelem,    METH_NOARGS},
+-#endif
+     {"set_lorder",      (PyCFunction)DB_set_lorder,     METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_lorder",      (PyCFunction)DB_get_lorder,     METH_NOARGS},
+-#endif
+     {"set_pagesize",    (PyCFunction)DB_set_pagesize,   METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_pagesize",    (PyCFunction)DB_get_pagesize,   METH_NOARGS},
+-#endif
+     {"set_re_delim",    (PyCFunction)DB_set_re_delim,   METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_re_delim",    (PyCFunction)DB_get_re_delim,   METH_NOARGS},
+-#endif
+     {"set_re_len",      (PyCFunction)DB_set_re_len,     METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_re_len",      (PyCFunction)DB_get_re_len,     METH_NOARGS},
+-#endif
+     {"set_re_pad",      (PyCFunction)DB_set_re_pad,     METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_re_pad",      (PyCFunction)DB_get_re_pad,     METH_NOARGS},
+-#endif
+     {"set_re_source",   (PyCFunction)DB_set_re_source,  METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_re_source",   (PyCFunction)DB_get_re_source,  METH_NOARGS},
+-#endif
+     {"set_q_extentsize",(PyCFunction)DB_set_q_extentsize, METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_q_extentsize",(PyCFunction)DB_get_q_extentsize, METH_NOARGS},
+-#endif
+     {"set_private",     (PyCFunction)DB_set_private,    METH_O},
+     {"get_private",     (PyCFunction)DB_get_private,    METH_NOARGS},
+ #if (DBVER >= 46)
+     {"set_priority",    (PyCFunction)DB_set_priority,   METH_VARARGS},
+     {"get_priority",    (PyCFunction)DB_get_priority,   METH_NOARGS},
+ #endif
++    {"get_dbname",      (PyCFunction)DB_get_dbname,     METH_NOARGS},
++    {"get_open_flags",  (PyCFunction)DB_get_open_flags, METH_NOARGS},
+     {"stat",            (PyCFunction)DB_stat,           METH_VARARGS|METH_KEYWORDS},
+ #if (DBVER >= 43)
+     {"stat_print",      (PyCFunction)DB_stat_print,
+@@ -8639,24 +8629,18 @@ static PyMethodDef DBEnv_methods[] = {
+     {"get_thread_count", (PyCFunction)DBEnv_get_thread_count, METH_NOARGS},
+ #endif
+     {"set_encrypt",     (PyCFunction)DBEnv_set_encrypt,      METH_VARARGS|METH_KEYWORDS},
+-#if (DBVER >= 42)
+     {"get_encrypt_flags", (PyCFunction)DBEnv_get_encrypt_flags, METH_NOARGS},
+     {"get_timeout",     (PyCFunction)DBEnv_get_timeout,
+         METH_VARARGS|METH_KEYWORDS},
+-#endif
+     {"set_timeout",     (PyCFunction)DBEnv_set_timeout,     METH_VARARGS|METH_KEYWORDS},
+     {"set_shm_key",     (PyCFunction)DBEnv_set_shm_key,     METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_shm_key",     (PyCFunction)DBEnv_get_shm_key,     METH_NOARGS},
+-#endif
+ #if (DBVER >= 46)
+     {"set_cache_max",   (PyCFunction)DBEnv_set_cache_max,   METH_VARARGS},
+     {"get_cache_max",   (PyCFunction)DBEnv_get_cache_max,   METH_NOARGS},
+ #endif
+     {"set_cachesize",   (PyCFunction)DBEnv_set_cachesize,   METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_cachesize",   (PyCFunction)DBEnv_get_cachesize,   METH_NOARGS},
+-#endif
+     {"memp_trickle",    (PyCFunction)DBEnv_memp_trickle,    METH_VARARGS},
+     {"memp_sync",       (PyCFunction)DBEnv_memp_sync,       METH_VARARGS},
+     {"memp_stat",       (PyCFunction)DBEnv_memp_stat,
+@@ -8685,33 +8669,21 @@ static PyMethodDef DBEnv_methods[] = {
+ #endif
+ #endif
+     {"set_data_dir",    (PyCFunction)DBEnv_set_data_dir,    METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_data_dirs",   (PyCFunction)DBEnv_get_data_dirs,   METH_NOARGS},
+-#endif
+-#if (DBVER >= 42)
+     {"get_flags",       (PyCFunction)DBEnv_get_flags,       METH_NOARGS},
+-#endif
+     {"set_flags",       (PyCFunction)DBEnv_set_flags,       METH_VARARGS},
+ #if (DBVER >= 47)
+     {"log_set_config",  (PyCFunction)DBEnv_log_set_config,  METH_VARARGS},
+     {"log_get_config",  (PyCFunction)DBEnv_log_get_config,  METH_VARARGS},
+ #endif
+     {"set_lg_bsize",    (PyCFunction)DBEnv_set_lg_bsize,    METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_lg_bsize",    (PyCFunction)DBEnv_get_lg_bsize,    METH_NOARGS},
+-#endif
+     {"set_lg_dir",      (PyCFunction)DBEnv_set_lg_dir,      METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_lg_dir",      (PyCFunction)DBEnv_get_lg_dir,      METH_NOARGS},
+-#endif
+     {"set_lg_max",      (PyCFunction)DBEnv_set_lg_max,      METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_lg_max",      (PyCFunction)DBEnv_get_lg_max,      METH_NOARGS},
+-#endif
+     {"set_lg_regionmax",(PyCFunction)DBEnv_set_lg_regionmax, METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_lg_regionmax",(PyCFunction)DBEnv_get_lg_regionmax, METH_NOARGS},
+-#endif
+ #if (DBVER >= 44)
+     {"set_lg_filemode", (PyCFunction)DBEnv_set_lg_filemode, METH_VARARGS},
+     {"get_lg_filemode", (PyCFunction)DBEnv_get_lg_filemode, METH_NOARGS},
+@@ -8721,36 +8693,24 @@ static PyMethodDef DBEnv_methods[] = {
+     {"get_lk_partitions", (PyCFunction)DBEnv_get_lk_partitions, METH_NOARGS},
+ #endif
+     {"set_lk_detect",   (PyCFunction)DBEnv_set_lk_detect,   METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_lk_detect",   (PyCFunction)DBEnv_get_lk_detect,   METH_NOARGS},
+-#endif
+ #if (DBVER < 45)
+     {"set_lk_max",      (PyCFunction)DBEnv_set_lk_max,      METH_VARARGS},
+ #endif
+     {"set_lk_max_locks", (PyCFunction)DBEnv_set_lk_max_locks, METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_lk_max_locks", (PyCFunction)DBEnv_get_lk_max_locks, METH_NOARGS},
+-#endif
+     {"set_lk_max_lockers", (PyCFunction)DBEnv_set_lk_max_lockers, METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_lk_max_lockers", (PyCFunction)DBEnv_get_lk_max_lockers, METH_NOARGS},
+-#endif
+     {"set_lk_max_objects", (PyCFunction)DBEnv_set_lk_max_objects, METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_lk_max_objects", (PyCFunction)DBEnv_get_lk_max_objects, METH_NOARGS},
+-#endif
+ #if (DBVER >= 43)
+     {"stat_print",          (PyCFunction)DBEnv_stat_print,
+         METH_VARARGS|METH_KEYWORDS},
+ #endif
+     {"set_mp_mmapsize", (PyCFunction)DBEnv_set_mp_mmapsize, METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_mp_mmapsize", (PyCFunction)DBEnv_get_mp_mmapsize, METH_NOARGS},
+-#endif
+     {"set_tmp_dir",     (PyCFunction)DBEnv_set_tmp_dir,     METH_VARARGS},
+-#if (DBVER >= 42)
+     {"get_tmp_dir",     (PyCFunction)DBEnv_get_tmp_dir,     METH_NOARGS},
+-#endif
+     {"txn_begin",       (PyCFunction)DBEnv_txn_begin,       METH_VARARGS|METH_KEYWORDS},
+     {"txn_checkpoint",  (PyCFunction)DBEnv_txn_checkpoint,  METH_VARARGS},
+     {"txn_stat",        (PyCFunction)DBEnv_txn_stat,        METH_VARARGS},
+@@ -8758,10 +8718,8 @@ static PyMethodDef DBEnv_methods[] = {
+     {"txn_stat_print",  (PyCFunction)DBEnv_txn_stat_print,
+         METH_VARARGS|METH_KEYWORDS},
+ #endif
+-#if (DBVER >= 42)
+     {"get_tx_max",      (PyCFunction)DBEnv_get_tx_max,      METH_NOARGS},
+     {"get_tx_timestamp", (PyCFunction)DBEnv_get_tx_timestamp, METH_NOARGS},
+-#endif
+     {"set_tx_max",      (PyCFunction)DBEnv_set_tx_max,      METH_VARARGS},
+     {"set_tx_timestamp", (PyCFunction)DBEnv_set_tx_timestamp, METH_VARARGS},
+     {"lock_detect",     (PyCFunction)DBEnv_lock_detect,     METH_VARARGS},
+@@ -8804,11 +8762,16 @@ static PyMethodDef DBEnv_methods[] = {
+     {"get_mp_max_write", (PyCFunction)DBEnv_get_mp_max_write, METH_NOARGS},
+ #endif
+     {"set_verbose",     (PyCFunction)DBEnv_set_verbose,     METH_VARARGS},
+-#if (DBVER >= 42)
+-    {"get_verbose",     (PyCFunction)DBEnv_get_verbose,       METH_VARARGS},
++    {"get_verbose",     (PyCFunction)DBEnv_get_verbose,     METH_VARARGS},
++    {"set_private",     (PyCFunction)DBEnv_set_private,     METH_O},
++    {"get_private",     (PyCFunction)DBEnv_get_private,     METH_NOARGS},
++    {"get_open_flags",  (PyCFunction)DBEnv_get_open_flags,  METH_NOARGS},
++#if (DBVER >= 47)
++    {"set_intermediate_dir_mode", (PyCFunction)DBEnv_set_intermediate_dir_mode,
++        METH_VARARGS},
++    {"get_intermediate_dir_mode", (PyCFunction)DBEnv_get_intermediate_dir_mode,
++        METH_NOARGS},
+ #endif
+-    {"set_private",     (PyCFunction)DBEnv_set_private,       METH_O},
+-    {"get_private",     (PyCFunction)DBEnv_get_private,       METH_NOARGS},
+     {"rep_start",       (PyCFunction)DBEnv_rep_start,
+         METH_VARARGS|METH_KEYWORDS},
+     {"rep_set_transport", (PyCFunction)DBEnv_rep_set_transport, METH_VARARGS},
+@@ -8855,10 +8818,12 @@ static PyMethodDef DBEnv_methods[] = {
+ #if (DBVER >= 45)
+     {"repmgr_start", (PyCFunction)DBEnv_repmgr_start,
+         METH_VARARGS|METH_KEYWORDS},
++#if (DBVER < 52)
+     {"repmgr_set_local_site", (PyCFunction)DBEnv_repmgr_set_local_site,
+         METH_VARARGS|METH_KEYWORDS},
+     {"repmgr_add_remote_site", (PyCFunction)DBEnv_repmgr_add_remote_site,
+         METH_VARARGS|METH_KEYWORDS},
++#endif
+     {"repmgr_set_ack_policy", (PyCFunction)DBEnv_repmgr_set_ack_policy,
+         METH_VARARGS},
+     {"repmgr_get_ack_policy", (PyCFunction)DBEnv_repmgr_get_ack_policy,
+@@ -8922,13 +8887,9 @@ DBEnv_db_home_get(DBEnvObject* self)
+ 
+     CHECK_ENV_NOT_CLOSED(self);
+ 
+-#if (DBVER >= 42)
+     MYDB_BEGIN_ALLOW_THREADS;
+     self->db_env->get_home(self->db_env, &home);
+     MYDB_END_ALLOW_THREADS;
+-#else
+-    home=self->db_env->db_home;
+-#endif
+ 
+     if (home == NULL) {
+         RETURN_NONE();
+@@ -9298,10 +9259,25 @@ bsddb_version(PyObject* self)
+ {
+     int major, minor, patch;
+ 
++    /* This should be instantaneous, no need to release the GIL */
+     db_version(&major, &minor, &patch);
+     return Py_BuildValue("(iii)", major, minor, patch);
+ }
+ 
++#if (DBVER >= 50)
++static PyObject*
++bsddb_version_full(PyObject* self)
++{
++    char *version_string;
++    int family, release, major, minor, patch;
++
++    /* This should be instantaneous, no need to release the GIL */
++    version_string = db_full_version(&family, &release, &major, &minor, &patch);
++    return Py_BuildValue("(siiiii)",
++            version_string, family, release, major, minor, patch);
++}
++#endif
++
+ 
+ /* List of functions defined in the module */
+ static PyMethodDef bsddb_methods[] = {
+@@ -9311,6 +9287,9 @@ static PyMethodDef bsddb_methods[] = {
+     {"DBSequence",  (PyCFunction)DBSequence_construct,  METH_VARARGS | METH_KEYWORDS },
+ #endif
+     {"version",     (PyCFunction)bsddb_version,         METH_NOARGS, bsddb_version_doc},
++#if (DBVER >= 50)
++    {"full_version", (PyCFunction)bsddb_version_full, METH_NOARGS},
++#endif
+     {NULL,      NULL}       /* sentinel */
+ };
+ 
+@@ -9328,6 +9307,11 @@ static BSDDB_api bsddb_api;
+  */
+ #define ADD_INT(dict, NAME)         _addIntToDict(dict, #NAME, NAME)
+ 
++/*
++** We can rename the module at import time, so the string allocated
++** must be big enough, and any use of the name must use this particular
++** string.
++*/
+ #define MODULE_NAME_MAX_LEN     11
+ static char _bsddbModuleName[MODULE_NAME_MAX_LEN+1] = "_bsddb";
+ 
+@@ -9428,16 +9412,10 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_MAX_RECORDS);
+ 
+ #if (DBVER < 48)
+-#if (DBVER >= 42)
+     ADD_INT(d, DB_RPCCLIENT);
+-#else
+-    ADD_INT(d, DB_CLIENT);
+-    /* allow apps to be written using DB_RPCCLIENT on older Berkeley DB */
+-    _addIntToDict(d, "DB_RPCCLIENT", DB_CLIENT);
+-#endif
+ #endif
+ 
+-#if (DBVER < 48)
++#if (DBVER < 48 || DBVER > 51)
+     ADD_INT(d, DB_XA_CREATE);
+ #endif
+ 
+@@ -9477,6 +9455,14 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_TXN_SYNC);
+     ADD_INT(d, DB_TXN_NOWAIT);
+ 
++#if (DBVER >= 51)
++    ADD_INT(d, DB_TXN_BULK);
++#endif
++
++#if (DBVER >= 48)
++    ADD_INT(d, DB_CURSOR_BULK);
++#endif
++
+ #if (DBVER >= 46)
+     ADD_INT(d, DB_TXN_WAIT);
+ #endif
+@@ -9561,9 +9547,7 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_ARCH_ABS);
+     ADD_INT(d, DB_ARCH_DATA);
+     ADD_INT(d, DB_ARCH_LOG);
+-#if (DBVER >= 42)
+     ADD_INT(d, DB_ARCH_REMOVE);
+-#endif
+ 
+     ADD_INT(d, DB_BTREE);
+     ADD_INT(d, DB_HASH);
+@@ -9591,9 +9575,6 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_CACHED_COUNTS);
+ #endif
+ 
+-#if (DBVER <= 41)
+-    ADD_INT(d, DB_COMMIT);
+-#endif
+     ADD_INT(d, DB_CONSUME);
+     ADD_INT(d, DB_CONSUME_WAIT);
+     ADD_INT(d, DB_CURRENT);
+@@ -9651,8 +9632,10 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_LOCK_DEADLOCK);
+     ADD_INT(d, DB_LOCK_NOTGRANTED);
+     ADD_INT(d, DB_NOSERVER);
++#if (DBVER < 52)
+     ADD_INT(d, DB_NOSERVER_HOME);
+     ADD_INT(d, DB_NOSERVER_ID);
++#endif
+     ADD_INT(d, DB_NOTFOUND);
+     ADD_INT(d, DB_OLD_VERSION);
+     ADD_INT(d, DB_RUNRECOVERY);
+@@ -9671,6 +9654,10 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+ #if (DBVER >= 43)
+     ADD_INT(d, DB_STAT_SUBSYSTEM);
+     ADD_INT(d, DB_STAT_MEMP_HASH);
++    ADD_INT(d, DB_STAT_LOCK_CONF);
++    ADD_INT(d, DB_STAT_LOCK_LOCKERS);
++    ADD_INT(d, DB_STAT_LOCK_OBJECTS);
++    ADD_INT(d, DB_STAT_LOCK_PARAMS);
+ #endif
+ 
+ #if (DBVER >= 48)
+@@ -9690,7 +9677,6 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_EID_INVALID);
+     ADD_INT(d, DB_EID_BROADCAST);
+ 
+-#if (DBVER >= 42)
+     ADD_INT(d, DB_TIME_NOTGRANTED);
+     ADD_INT(d, DB_TXN_NOT_DURABLE);
+     ADD_INT(d, DB_TXN_WRITE_NOSYNC);
+@@ -9698,9 +9684,8 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_INIT_REP);
+     ADD_INT(d, DB_ENCRYPT);
+     ADD_INT(d, DB_CHKSUM);
+-#endif
+ 
+-#if (DBVER >= 42) && (DBVER < 47)
++#if (DBVER < 47)
+     ADD_INT(d, DB_LOG_AUTOREMOVE);
+     ADD_INT(d, DB_DIRECT_LOG);
+ #endif
+@@ -9733,6 +9718,20 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_VERB_REPLICATION);
+     ADD_INT(d, DB_VERB_WAITSFOR);
+ 
++#if (DBVER >= 50)
++    ADD_INT(d, DB_VERB_REP_SYSTEM);
++#endif
++
++#if (DBVER >= 47)
++    ADD_INT(d, DB_VERB_REP_ELECT);
++    ADD_INT(d, DB_VERB_REP_LEASE);
++    ADD_INT(d, DB_VERB_REP_MISC);
++    ADD_INT(d, DB_VERB_REP_MSGS);
++    ADD_INT(d, DB_VERB_REP_SYNC);
++    ADD_INT(d, DB_VERB_REPMGR_CONNFAIL);
++    ADD_INT(d, DB_VERB_REPMGR_MISC);
++#endif
++
+ #if (DBVER >= 45)
+     ADD_INT(d, DB_EVENT_PANIC);
+     ADD_INT(d, DB_EVENT_REP_CLIENT);
+@@ -9748,16 +9747,25 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_EVENT_WRITE_FAILED);
+ #endif
+ 
++#if (DBVER >= 50)
++    ADD_INT(d, DB_REPMGR_CONF_ELECTIONS);
++    ADD_INT(d, DB_EVENT_REP_MASTER_FAILURE);
++    ADD_INT(d, DB_EVENT_REP_DUPMASTER);
++    ADD_INT(d, DB_EVENT_REP_ELECTION_FAILED);
++#endif
++#if (DBVER >= 48)
++    ADD_INT(d, DB_EVENT_REG_ALIVE);
++    ADD_INT(d, DB_EVENT_REG_PANIC);
++#endif
++
+     ADD_INT(d, DB_REP_DUPMASTER);
+     ADD_INT(d, DB_REP_HOLDELECTION);
+ #if (DBVER >= 44)
+     ADD_INT(d, DB_REP_IGNORE);
+     ADD_INT(d, DB_REP_JOIN_FAILURE);
+ #endif
+-#if (DBVER >= 42)
+     ADD_INT(d, DB_REP_ISPERM);
+     ADD_INT(d, DB_REP_NOTPERM);
+-#endif
+     ADD_INT(d, DB_REP_NEWSITE);
+ 
+     ADD_INT(d, DB_REP_MASTER);
+@@ -9766,7 +9774,13 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_REP_PERMANENT);
+ 
+ #if (DBVER >= 44)
++#if (DBVER >= 50)
++    ADD_INT(d, DB_REP_CONF_AUTOINIT);
++#else
+     ADD_INT(d, DB_REP_CONF_NOAUTOINIT);
++#endif /* 5.0 */
++#endif /* 4.4 */
++#if (DBVER >= 44)
+     ADD_INT(d, DB_REP_CONF_DELAYCLIENT);
+     ADD_INT(d, DB_REP_CONF_BULK);
+     ADD_INT(d, DB_REP_CONF_NOWAIT);
+@@ -9774,9 +9788,7 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_REP_REREQUEST);
+ #endif
+ 
+-#if (DBVER >= 42)
+     ADD_INT(d, DB_REP_NOBUFFER);
+-#endif
+ 
+ #if (DBVER >= 46)
+     ADD_INT(d, DB_REP_LEASE_EXPIRED);
+@@ -9819,6 +9831,28 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_STAT_ALL);
+ #endif
+ 
++#if (DBVER >= 51)
++    ADD_INT(d, DB_REPMGR_ACKS_ALL_AVAILABLE);
++#endif
++
++#if (DBVER >= 48)
++    ADD_INT(d, DB_REP_CONF_INMEM);
++#endif
++
++    ADD_INT(d, DB_TIMEOUT);
++
++#if (DBVER >= 50)
++    ADD_INT(d, DB_FORCESYNC);
++#endif
++
++#if (DBVER >= 48)
++    ADD_INT(d, DB_FAILCHK);
++#endif
++
++#if (DBVER >= 51)
++    ADD_INT(d, DB_HOTBACKUP_IN_PROGRESS);
++#endif
++
+ #if (DBVER >= 43)
+     ADD_INT(d, DB_BUFFER_SMALL);
+     ADD_INT(d, DB_SEQ_DEC);
+@@ -9856,6 +9890,10 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     ADD_INT(d, DB_SET_LOCK_TIMEOUT);
+     ADD_INT(d, DB_SET_TXN_TIMEOUT);
+ 
++#if (DBVER >= 48)
++    ADD_INT(d, DB_SET_REG_TIMEOUT);
++#endif
++
+     /* The exception name must be correct for pickled exception *
+      * objects to unpickle properly.                            */
+ #ifdef PYBSDDB_STANDALONE  /* different value needed for standalone pybsddb */
+@@ -9912,8 +9950,10 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     MAKE_EX(DBRunRecoveryError);
+     MAKE_EX(DBVerifyBadError);
+     MAKE_EX(DBNoServerError);
++#if (DBVER >= 44 && DBVER < 52)
+     MAKE_EX(DBNoServerHomeError);
+     MAKE_EX(DBNoServerIDError);
++#endif
+     MAKE_EX(DBPageNotFoundError);
+     MAKE_EX(DBSecondaryBadError);
+ 
+@@ -9927,9 +9967,7 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     MAKE_EX(DBNoSuchFileError);
+     MAKE_EX(DBPermissionsError);
+ 
+-#if (DBVER >= 42)
+     MAKE_EX(DBRepHandleDeadError);
+-#endif
+ #if (DBVER >= 44)
+     MAKE_EX(DBRepLockoutError);
+ #endif
+@@ -9947,6 +9985,7 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+ #undef MAKE_EX
+ 
+     /* Initialise the C API structure and add it to the module */
++    bsddb_api.api_version      = PYBSDDB_API_VERSION;
+     bsddb_api.db_type          = &DB_Type;
+     bsddb_api.dbcursor_type    = &DBCursor_Type;
+     bsddb_api.dblogcursor_type = &DBLogCursor_Type;
+@@ -9955,19 +9994,25 @@ PyMODINIT_FUNC  PyInit__bsddb(void)    /* Note the two underscores */
+     bsddb_api.dblock_type      = &DBLock_Type;
+ #if (DBVER >= 43)
+     bsddb_api.dbsequence_type  = &DBSequence_Type;
++#else
++    bsddb_api.dbsequence_type  = NULL;
+ #endif
+     bsddb_api.makeDBError      = makeDBError;
+ 
+     /*
+-    ** Capsules exist from Python 3.1, but I
+-    ** don't want to break the API compatibility
+-    ** for already published Python versions.
++    ** Capsules exist from Python 2.7 and 3.1.
++    ** We don't support Python 3.0 anymore, so...
++    ** #if (PY_VERSION_HEX < ((PY_MAJOR_VERSION < 3) ? 0x02070000 : 0x03020000))
+     */
+-#if (PY_VERSION_HEX < 0x03020000)
++#if (PY_VERSION_HEX < 0x02070000)
+     py_api = PyCObject_FromVoidPtr((void*)&bsddb_api, NULL);
+ #else
+     {
+-        char py_api_name[250];
++        /*
++        ** The data must outlive the call!!. So, the static definition.
++        ** The buffer must be big enough...
++        */
++        static char py_api_name[MODULE_NAME_MAX_LEN+10];
+ 
+         strcpy(py_api_name, _bsddbModuleName);
+         strcat(py_api_name, ".api");
+diff --git a/Modules/bsddb.h b/Modules/bsddb.h
+index a3a687b..c1d862a 100644
+--- a/Modules/bsddb.h
++++ b/Modules/bsddb.h
+@@ -109,7 +109,7 @@
+ #error "eek! DBVER can't handle minor versions > 9"
+ #endif
+ 
+-#define PY_BSDDB_VERSION "4.8.4.2"
++#define PY_BSDDB_VERSION "5.3.15"
+ 
+ /* Python object definitions */
+ 
+@@ -236,7 +236,7 @@ typedef struct DBSequenceObject {
+ /* To access the structure from an external module, use code like the
+    following (error checking missed out for clarity):
+ 
+-     // If you are using Python before 3.2:
++     // If you are using Python before 2.7:
+      BSDDB_api* bsddb_api;
+      PyObject*  mod;
+      PyObject*  cobj;
+@@ -249,7 +249,7 @@ typedef struct DBSequenceObject {
+      Py_DECREF(mod);
+ 
+ 
+-     // If you are using Python 3.2 or up:
++     // If you are using Python 2.7 or up: (except Python 3.0, unsupported)
+      BSDDB_api* bsddb_api;
+ 
+      // Use "bsddb3._pybsddb.api" if you're using
+@@ -257,10 +257,14 @@ typedef struct DBSequenceObject {
+      bsddb_api = (void **)PyCapsule_Import("bsddb._bsddb.api", 1);
+ 
+ 
++   Check "api_version" number before trying to use the API.
++
+    The structure's members must not be changed.
+ */
+ 
++#define PYBSDDB_API_VERSION 1
+ typedef struct {
++    unsigned int api_version;
+     /* Type objects */
+     PyTypeObject* db_type;
+     PyTypeObject* dbcursor_type;
+@@ -268,9 +272,7 @@ typedef struct {
+     PyTypeObject* dbenv_type;
+     PyTypeObject* dbtxn_type;
+     PyTypeObject* dblock_type;
+-#if (DBVER >= 43)
+-    PyTypeObject* dbsequence_type;
+-#endif
++    PyTypeObject* dbsequence_type;  /* If DBVER < 43 -> NULL */
+ 
+     /* Functions */
+     int (*makeDBError)(int err);
+@@ -289,9 +291,9 @@ typedef struct {
+ #define DBEnvObject_Check(v)    ((v)->ob_type == bsddb_api->dbenv_type)
+ #define DBTxnObject_Check(v)    ((v)->ob_type == bsddb_api->dbtxn_type)
+ #define DBLockObject_Check(v)   ((v)->ob_type == bsddb_api->dblock_type)
+-#if (DBVER >= 43)
+-#define DBSequenceObject_Check(v)  ((v)->ob_type == bsddb_api->dbsequence_type)
+-#endif
++#define DBSequenceObject_Check(v)  \
++    ((bsddb_api->dbsequence_type) && \
++        ((v)->ob_type == bsddb_api->dbsequence_type))
+ 
+ #endif /* COMPILING_BSDDB_C */
+ 
+diff --git a/setup.py b/setup.py
+index 6b47451..e8ac96c 100644
+--- a/setup.py
++++ b/setup.py
+@@ -799,7 +799,7 @@ class PyBuildExt(build_ext):
+         # a release.  Most open source OSes come with one or more
+         # versions of BerkeleyDB already installed.
+ 
+-        max_db_ver = (4, 8)
++        max_db_ver = (5, 3)
+         min_db_ver = (4, 1)
+         db_setup_debug = False   # verbose debug prints from this script?
+ 
+@@ -821,7 +821,11 @@ class PyBuildExt(build_ext):
+             return True
+ 
+         def gen_db_minor_ver_nums(major):
+-            if major == 4:
++            if major == 5:
++                for x in range(max_db_ver[1]+1):
++                    if allow_db_ver((5, x)):
++                        yield x
++            elif major == 4:
+                 for x in range(max_db_ver[1]+1):
+                     if allow_db_ver((4, x)):
+                         yield x
+@@ -835,6 +839,9 @@ class PyBuildExt(build_ext):
+         # construct a list of paths to look for the header file in on
+         # top of the normal inc_dirs.
+         db_inc_paths = [
++            '/usr/include/db5',
++            '/usr/local/include/db5',
++            '/opt/sfw/include/db5',
+             '/usr/include/db4',
+             '/usr/local/include/db4',
+             '/opt/sfw/include/db4',
+@@ -845,6 +852,16 @@ class PyBuildExt(build_ext):
+             '/sw/include/db4',
+             '/sw/include/db3',
+         ]
++        # 5.x minor number specific paths
++        for x in gen_db_minor_ver_nums(5):
++            db_inc_paths.append('/usr/include/db5%d' % x)
++            db_inc_paths.append('/usr/include/db5.%d' % x)
++            db_inc_paths.append('/usr/local/BerkeleyDB.5.%d/include' % x)
++            db_inc_paths.append('/usr/local/include/db5%d' % x)
++            db_inc_paths.append('/pkg/db-5.%d/include' % x)
++            db_inc_paths.append('/opt/db-5.%d/include' % x)
++            # MacPorts default (http://www.macports.org/)
++            db_inc_paths.append('/opt/local/include/db5%d' % x)
+         # 4.x minor number specific paths
+         for x in gen_db_minor_ver_nums(4):
+             db_inc_paths.append('/usr/include/db4%d' % x)
+@@ -871,6 +888,10 @@ class PyBuildExt(build_ext):
+         for dn in inc_dirs:
+             std_variants.append(os.path.join(dn, 'db3'))
+             std_variants.append(os.path.join(dn, 'db4'))
++            std_variants.append(os.path.join(dn, 'db5'))
++            for x in gen_db_minor_ver_nums(5):
++                std_variants.append(os.path.join(dn, "db5%d"%x))
++                std_variants.append(os.path.join(dn, "db5.%d"%x))
+             for x in gen_db_minor_ver_nums(4):
+                 std_variants.append(os.path.join(dn, "db4%d"%x))
+                 std_variants.append(os.path.join(dn, "db4.%d"%x))
+-- 
+1.7.7
+
diff --git a/meta/recipes-devtools/python/python/python-2.7.3-remove-bsdb-rpath.patch b/meta/recipes-devtools/python/python/python-2.7.3-remove-bsdb-rpath.patch
new file mode 100644
index 0000000..4b8953a
--- /dev/null
+++ b/meta/recipes-devtools/python/python/python-2.7.3-remove-bsdb-rpath.patch
@@ -0,0 +1,22 @@ 
+Remove the RPTH to avoid QA issue warning.
+
+Signed-off-by: Jackie Huang <jackie.huang@windriver.com>
+---
+ setup.py |    1 -
+ 1 files changed, 0 insertions(+), 1 deletions(-)
+
+diff --git a/setup.py b/setup.py
+index 83b5e56..1fd5487 100644
+--- a/setup.py
++++ b/setup.py
+@@ -1025,7 +1025,6 @@ class PyBuildExt(build_ext):
+             exts.append(Extension('_bsddb', ['_bsddb.c'],
+                                   depends = ['bsddb.h'],
+                                   library_dirs=dblib_dir,
+-                                  runtime_library_dirs=dblib_dir,
+                                   include_dirs=db_incs,
+                                   libraries=dblibs))
+         else:
+-- 
+1.7.4
+
diff --git a/meta/recipes-devtools/python/python_2.7.3.bb b/meta/recipes-devtools/python/python_2.7.3.bb
index d27ff05..9c648fe 100644
--- a/meta/recipes-devtools/python/python_2.7.3.bb
+++ b/meta/recipes-devtools/python/python_2.7.3.bb
@@ -1,6 +1,6 @@ 
 require python.inc
 DEPENDS = "python-native bzip2 db gdbm openssl readline sqlite3 zlib"
-PR = "${INC_PR}.1"
+PR = "${INC_PR}.2"
 
 DISTRO_SRC_URI ?= "file://sitecustomize.py"
 DISTRO_SRC_URI_linuxstdbase = ""
@@ -23,9 +23,10 @@  SRC_URI += "\
   file://setuptweaks.patch \
   file://check-if-target-is-64b-not-host.patch \
   file://search_db_h_in_inc_dirs_and_avoid_warning.patch \
-  file://avoid_warning_about_bsddb.patch \
   file://avoid_warning_about_tkinter.patch \
   file://avoid_warning_for_sunos_specific_module.patch \
+  file://python-2.7.3-berkeley-db-5.3.patch \
+  file://python-2.7.3-remove-bsdb-rpath.patch \
 "
 
 S = "${WORKDIR}/Python-${PV}"
diff --git a/meta/recipes-support/db/db_5.3.15.bb b/meta/recipes-support/db/db_5.3.15.bb
index 0fc396e..063954a 100644
--- a/meta/recipes-support/db/db_5.3.15.bb
+++ b/meta/recipes-support/db/db_5.3.15.bb
@@ -14,7 +14,7 @@  HOMEPAGE = "http://www.oracle.com/technology/products/berkeley-db/db/index.html"
 LICENSE = "Sleepycat"
 VIRTUAL_NAME ?= "virtual/db"
 RCONFLICTS_${PN} = "db3"
-PR = "r7"
+PR = "r8"
 
 SRC_URI = "http://download.oracle.com/berkeley-db/db-${PV}.tar.gz"
 SRC_URI += "file://arm-thumb-mutex_db5.patch;patchdir=.."
@@ -56,7 +56,7 @@  FILES_SOLIBSDEV = "${libdir}/libdb.so"
 
 #configuration - set in local.conf to override
 # All the --disable-* options replace --enable-smallbuild, which breaks a bunch of stuff (eg. postfix)
-DB5_CONFIG ?= "--enable-o_direct --disable-cryptography --disable-queue --disable-replication --disable-statistics --disable-verify --disable-compat185 --disable-sql"
+DB5_CONFIG ?= "--enable-o_direct --disable-cryptography --disable-queue --disable-replication --disable-verify --disable-compat185 --disable-sql"
 
 EXTRA_OECONF = "${DB5_CONFIG}"