Major Freeze update

1 files changed, 790 insertions, 902 deletions

diff --git a/cpp/test/XMLTransform/transform/Populate.cpp b/cpp/test/XMLTransform/transform/Populate.cpp
index 306f13b46f4..cd85ff91ea2 100644
--- a/cpp/test/XMLTransform/transform/Populate.cpp
+++ b/cpp/test/XMLTransform/transform/Populate.cpp
@@ -29,9 +29,17 @@
 #include <IntD1MapOld.h>
 #include <IntS1MapOld.h>
 #include <IntC1MapOld.h>
+#include <db_cxx.h>
 
 #include <fstream>
 
+#include <sys/stat.h>
+#ifdef _WIN32
+#   define FREEZE_DB_MODE 0
+#else
+#   define FREEZE_DB_MODE (S_IRUSR | S_IWUSR)
+#endif
+
 using namespace std;
 using namespace Freeze;
 using namespace Ice;
@@ -78,404 +86,382 @@ emitSchemas(const string& fromValueType, const string& toValueType)
 }
 
 static void
-transformPrimitive(const DBEnvironmentPtr& dbEnv)
+transformPrimitive(const CommunicatorPtr& communicator, DbEnv& dbEnv)
 {
     Int i;
 
-    DBPtr db;
     StringSeq dummy;
 
     cout << "transforming primitives... " << flush;
 
-    try
+  
+    //
+    // Transform byte to short
+    //
     {
-        //
-        // Transform byte to short
-        //
-        db = dbEnv->openDB("byteToShort", true);
-        db->clear();
-
-        {
-            IntByteMap map(db);
-            for(i = 0; i < NUM_KEYS; i++)
-            {
-                map.put(IntByteMap::value_type(i, i));
-            }
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "byteToShort", false);
-        emitSchemas("xs:byte", "xs:short");
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-        }
-        db->close();
-        db = 0;
-
-        //
-        // Transform short to int
-        //
-        db = dbEnv->openDB("shortToInt", true);
-        db->clear();
-
-        {
-            IntShortMap map(db);
-            for(i = 0; i < NUM_KEYS; i++)
-            {
-                map.put(IntShortMap::value_type(i, i));
-            }
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "shortToInt", false);
-        emitSchemas("xs:short", "xs:int");
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-        }
-        db->close();
-        db = 0;
-
-        //
-        // Transform int to long
-        //
-        db = dbEnv->openDB("intToLong", true);
-        db->clear();
-
-        {
-            IntIntMap map(db);
-            for(i = 0; i < NUM_KEYS; i++)
-            {
-                map.put(IntIntMap::value_type(i, i));
-            }
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "intToLong", false);
-        emitSchemas("xs:int", "xs:long");
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-        }
-        db->close();
-        db = 0;
-
-        //
-        // Transform long to byte
-        //
-        db = dbEnv->openDB("longToByte", true);
-        db->clear();
-
-        {
-            IntLongMap map(db);
-            for(i = 0; i < NUM_KEYS; i++)
-            {
-                map.put(IntLongMap::value_type(i, i));
-            }
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "longToByte", false);
-        emitSchemas("xs:long", "xs:byte");
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-        }
-        db->close();
-        db = 0;	
-
-        //
-        // Transform float to double
-        //
-        db = dbEnv->openDB("floatToDouble", true);
-        db->clear();
-
-        {
-            IntFloatMap map(db);
-            for(i = 0; i < NUM_KEYS; i++)
-            {
-                map.put(IntFloatMap::value_type(i, static_cast<float>(i)));
-            }
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "floatToDouble", false);
-        emitSchemas("xs:float", "xs:double");
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-        }
-        db->close();
-        db = 0;
-
-        //
-        // Transform long to byte (should fail)
-        //
-        db = dbEnv->openDB("failure", true);
-        db->clear();
-
-        {
-            IntLongMap map(db);
-            Long l;
-            l = SCHAR_MIN;
-            map.put(IntLongMap::value_type(0, l));
-            map.put(IntLongMap::value_type(1, l - 1)); // Out of range for byte.
-            l = SCHAR_MAX;
-            map.put(IntLongMap::value_type(2, l));
-            map.put(IntLongMap::value_type(3, l + 1)); // Out of range for byte.
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "failure", false);
-        emitSchemas("xs:long", "xs:byte");
-        try
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-            test(false);
-        }
-        catch(const XMLTransform::IllegalTransform&)
-        {
-            // Expected.
-        }
-        db->close();
-        db = 0;
-
-        //
-        // Transform long to short (should fail)
-        //
-        db = dbEnv->openDB("failure", true);
-        db->clear();
-
-        {
-            IntLongMap map(db);
-            Long l;
-            l = SHRT_MIN;
-            map.put(IntLongMap::value_type(0, l));
-            map.put(IntLongMap::value_type(1, l - 1)); // Out of range for short.
-            l = SHRT_MAX;
-            map.put(IntLongMap::value_type(2, l));
-            map.put(IntLongMap::value_type(3, l + 1)); // Out of range for short.
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "failure", false);
-        emitSchemas("xs:long", "xs:short");
-        try
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-            test(false);
-        }
-        catch(const XMLTransform::IllegalTransform&)
-        {
-            // Expected.
-        }
-        db->close();
-        db = 0;
-
-        //
-        // Transform long to int (should fail)
-        //
-        db = dbEnv->openDB("failure", true);
-        db->clear();
-
-        {
-            IntLongMap map(db);
-            Long l;
-            l = INT_MIN;
-            map.put(IntLongMap::value_type(0, l));
-            map.put(IntLongMap::value_type(1, l - 1)); // Out of range for int.
-            l = INT_MAX;
-            map.put(IntLongMap::value_type(2, l));
-            map.put(IntLongMap::value_type(3, l + 1)); // Out of range for int.
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "failure", false);
-        emitSchemas("xs:long", "xs:int");
-        try
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-            test(false);
-        }
-        catch(const XMLTransform::IllegalTransform&)
-        {
-            // Expected.
-        }
-        db->close();
-        db = 0;
+	IntByteMap map(communicator, dbEnv, "byteToShort");
+	map.clear();
+	for(i = 0; i < NUM_KEYS; i++)
+	{
+	    map.put(IntByteMap::value_type(i, i));
+	}
+    }
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "byteToShort", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
+	emitSchemas("xs:byte", "xs:short");
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	}
+	db.close(0);
+    }
+    
+    
+    {
+	IntShortMap map(communicator, dbEnv, "shortToInt");
+	map.clear();
+	for(i = 0; i < NUM_KEYS; i++)
+	{
+	    map.put(IntShortMap::value_type(i, i));
+	}
+    }
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "shortToInt", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
+	emitSchemas("xs:short", "xs:int");
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	}
+	db.close(0);
+    }
+    
 
-        cout << "ok" << endl;
+    //
+    // Transform int to long
+    //
+    
+    
+    {
+	IntIntMap map(communicator, dbEnv, "intToLong");
+	map.clear();
+	for(i = 0; i < NUM_KEYS; i++)
+	{
+	    map.put(IntIntMap::value_type(i, i));
+	}
     }
-    catch(...)
+    
     {
-        cout << "failed" << endl;
-        if(db)
-        {
-            db->close();
-        }
-        throw;
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "intToLong", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
+	
+	emitSchemas("xs:int", "xs:long");
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	}
+	db.close(0);
     }
 
-    if(db)
+    //
+    // Transform long to byte
+    //
+    {
+	IntLongMap map(communicator, dbEnv, "longToByte");
+	map.clear();
+	for(i = 0; i < NUM_KEYS; i++)
+	{
+	    map.put(IntLongMap::value_type(i, i));
+	}
+    }
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "longToByte", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
+	
+	emitSchemas("xs:long", "xs:byte");
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	}
+	db.close(0);
+    }
+    
+    
+    //
+    // Transform float to double
+    //
+    {
+	IntFloatMap map(communicator, dbEnv, "floatToDouble");
+	map.clear();
+	for(i = 0; i < NUM_KEYS; i++)
+	{
+	    map.put(IntFloatMap::value_type(i, static_cast<float>(i)));
+	}
+    }
+    
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "floatToDouble", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
+	emitSchemas("xs:float", "xs:double");
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	}
+	db.close(0);
+    }
+    
+    
+    //
+    // Transform long to byte (should fail)
+    //
+    
+    {
+	IntLongMap map(communicator, dbEnv, "failure");
+	map.clear();
+	Long l;
+	l = SCHAR_MIN;
+	map.put(IntLongMap::value_type(0, l));
+	map.put(IntLongMap::value_type(1, l - 1)); // Out of range for byte.
+	l = SCHAR_MAX;
+	map.put(IntLongMap::value_type(2, l));
+	map.put(IntLongMap::value_type(3, l + 1)); // Out of range for byte.
+    }
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "failure", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
+	emitSchemas("xs:long", "xs:byte");
+	try
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	    test(false);
+	}
+	catch(const XMLTransform::IllegalTransform&)
+	{
+	    // Expected.
+	}
+	db.close(0);
+    }
+    
+    //
+    // Transform long to short (should fail)
+    //
+    {
+	IntLongMap map(communicator, dbEnv, "failure");
+	map.clear();
+	Long l;
+	l = SHRT_MIN;
+	map.put(IntLongMap::value_type(0, l));
+	map.put(IntLongMap::value_type(1, l - 1)); // Out of range for short.
+	l = SHRT_MAX;
+	map.put(IntLongMap::value_type(2, l));
+	map.put(IntLongMap::value_type(3, l + 1)); // Out of range for short.
+    }
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "failure", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
+	emitSchemas("xs:long", "xs:short");
+	try
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	    test(false);
+	}
+	catch(const XMLTransform::IllegalTransform&)
+	{
+	    // Expected.
+	}
+	    db.close(0);
+    }
+    
+    //
+    // Transform long to int (should fail)
+    //
+    
+    {
+	IntLongMap map(communicator, dbEnv, "failure");
+	map.clear();
+	Long l;
+	l = INT_MIN;
+	map.put(IntLongMap::value_type(0, l));
+	map.put(IntLongMap::value_type(1, l - 1)); // Out of range for int.
+	l = INT_MAX;
+	map.put(IntLongMap::value_type(2, l));
+	map.put(IntLongMap::value_type(3, l + 1)); // Out of range for int.
+    }
+    
     {
-        db->close();
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "failure", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
+	emitSchemas("xs:long", "xs:int");
+	try
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	    test(false);
+	}
+	catch(const XMLTransform::IllegalTransform&)
+	{
+	    // Expected.
+	}
+	db.close(0);
     }
+    
+    cout << "ok" << endl;
+       
 }
 
 static void
-transformPrimitiveSequence(const DBEnvironmentPtr& dbEnv)
+transformPrimitiveSequence(const CommunicatorPtr& communicator, DbEnv& dbEnv)
 {
     Int i;
 
-    DBPtr db;
     StringSeq dummy;
 
     cout << "transforming primitive sequences... " << flush;
 
-    try
-    {
-        //
-        // Transform byte to short sequence
-        //
-        db = dbEnv->openDB("byteToShortSeq", true);
-        db->clear();
-
-        {
-            IntSeq1Map map(db);
-            Test::Seq1 seq;
-            for(i = 0; i < NUM_ELEMENTS; i++)
-            {
-                seq.push_back(i);
-            }
-            map.put(IntSeq1Map::value_type(0, seq));
-        }
-        db->close();
-        db = 0;
+   
+    //
+    // Transform byte to short sequence
+    //
 
-        db = dbEnv->openDBWithTxn(0, "byteToShortSeq", false);
+    {
+	IntSeq1Map map(communicator, dbEnv, "byteToShortSeq");
+	map.clear();
+	Test::Seq1 seq;
+	for(i = 0; i < NUM_ELEMENTS; i++)
+	{
+	    seq.push_back(i);
+	}
+	map.put(IntSeq1Map::value_type(0, seq));
+    }
+   
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "byteToShortSeq", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
         emitSchemas("tns:_internal.Test.Seq1Type", "tns:_internal.Test.Seq1Type");
         {
             XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
             transformer.transform(oldSchema, newSchema);
         }
-        db->close();
-        db = 0;
-
-        //
-        // Transform short to int sequence
-        //
-        db = dbEnv->openDB("shortToIntSeq", true);
-        db->clear();
-
-        {
-            IntSeq2Map map(db);
-            Test::Seq2 seq;
-            for(i = 0; i < NUM_ELEMENTS; i++)
-            {
-                seq.push_back(i);
-            }
-            map.put(IntSeq2Map::value_type(0, seq));
-        }
-        db->close();
-        db = 0;
+	db.close(0);
+    }
 
-        db = dbEnv->openDBWithTxn(0, "shortToIntSeq", false);
+       
+    {
+	IntSeq2Map map(communicator, dbEnv, "shortToIntSeq");
+	map.clear();
+	Test::Seq2 seq;
+	for(i = 0; i < NUM_ELEMENTS; i++)
+	{
+	    seq.push_back(i);
+	}
+	map.put(IntSeq2Map::value_type(0, seq));
+    }
+       
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "shortToIntSeq", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
         emitSchemas("tns:_internal.Test.Seq2Type", "tns:_internal.Test.Seq2Type");
         {
             XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
             transformer.transform(oldSchema, newSchema);
         }
-        db->close();
-        db = 0;
-
-        //
-        // Transform int to long sequence
-        //
-        db = dbEnv->openDB("intToLongSeq", true);
-        db->clear();
-
-        {
-            IntSeq3Map map(db);
-            Test::Seq3 seq;
-            for(i = 0; i < NUM_ELEMENTS; i++)
-            {
-                seq.push_back(i);
-            }
-            map.put(IntSeq3Map::value_type(0, seq));
-        }
-        db->close();
-        db = 0;
+	db.close(0);
+    }
 
-        db = dbEnv->openDBWithTxn(0, "intToLongSeq", false);
+    //
+    // Transform int to long sequence
+    //
+    {
+	IntSeq3Map map(communicator, dbEnv, "intToLongSeq");
+	map.clear();
+	Test::Seq3 seq;
+	for(i = 0; i < NUM_ELEMENTS; i++)
+	{
+	    seq.push_back(i);
+	}
+	map.put(IntSeq3Map::value_type(0, seq));
+    }
+   
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "intToLongSeq", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
         emitSchemas("tns:_internal.Test.Seq3Type", "tns:_internal.Test.Seq3Type");
         {
             XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
             transformer.transform(oldSchema, newSchema);
         }
-        db->close();
-        db = 0;
-
-        //
-        // Transform long to byte sequence
-        //
-        db = dbEnv->openDB("longToByteSeq", true);
-        db->clear();
-
-        {
-            IntSeq4Map map(db);
-            Test::Seq4 seq;
-            for(i = 0; i < NUM_ELEMENTS; i++)
-            {
-                seq.push_back(i);
-            }
-            map.put(IntSeq4Map::value_type(0, seq));
-        }
-        db->close();
-        db = 0;
+	db.close(0);
+    }
 
-        db = dbEnv->openDBWithTxn(0, "longToByteSeq", false);
+    //
+    // Transform long to byte sequence
+    //
+    {
+	
+	IntSeq4Map map(communicator, dbEnv, "longToByteSeq");
+	map.clear();
+	Test::Seq4 seq;
+	for(i = 0; i < NUM_ELEMENTS; i++)
+	{
+	    seq.push_back(i);
+	}
+	map.put(IntSeq4Map::value_type(0, seq));
+    }
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "longToByteSeq", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
         emitSchemas("tns:_internal.Test.Seq4Type", "tns:_internal.Test.Seq4Type");
         {
             XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
             transformer.transform(oldSchema, newSchema);
         }
-        db->close();
-        db = 0;
+        db.close(0);
+    }
 
         //
         // Transform long to byte sequence (should fail)
         //
-        db = dbEnv->openDB("failure", true);
-        db->clear();
-
-        {
-            IntSeq4Map map(db);
-            Test::Seq4 seq;
-            Long l;
-            l = SCHAR_MIN;
-            seq.push_back(l);
-            seq.push_back(l - 1); // Out of range for byte.
-            l = SCHAR_MAX;
-            seq.push_back(l);
-            seq.push_back(l + 1); // Out of range for byte.
-            map.put(IntSeq4Map::value_type(0, seq));
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "failure", false);
+      
+    {
+	IntSeq4Map map(communicator, dbEnv, "failure");
+	map.clear();
+	Test::Seq4 seq;
+	Long l;
+	l = SCHAR_MIN;
+	seq.push_back(l);
+	seq.push_back(l - 1); // Out of range for byte.
+	l = SCHAR_MAX;
+	seq.push_back(l);
+	seq.push_back(l + 1); // Out of range for byte.
+	map.put(IntSeq4Map::value_type(0, seq));
+    }
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "failure", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE); 
         emitSchemas("tns:_internal.Test.Seq4Type", "tns:_internal.Test.Seq4Type");
         try
         {
@@ -487,77 +473,63 @@ transformPrimitiveSequence(const DBEnvironmentPtr& dbEnv)
         {
             // Expected.
         }
-        db->close();
-        db = 0;
-
-        cout << "ok" << endl;
-    }
-    catch(...)
-    {
-        cout << "failed" << endl;
-        if(db)
-        {
-            db->close();
-        }
-        throw;
+	
+        db.close(0);
     }
 
-    if(db)
-    {
-        db->close();
-    }
+    cout << "ok" << endl;
 }
 
 static void
-transformEnum(const DBEnvironmentPtr& dbEnv)
+transformEnum(const CommunicatorPtr& communicator, DbEnv& dbEnv)
 {
-    DBPtr db;
+  
     StringSeq dummy;
 
     cout << "transforming enumerations... " << flush;
 
-    try
+    //
+    // Don't use E1::three, which is removed in new schema
+    //
+   
     {
-        //
-        // Don't use E1::three, which is removed in new schema
-        //
-        db = dbEnv->openDB("enum", true);
-        db->clear();
-
-        {
-            IntE1Map map(db);
-            map.put(IntE1Map::value_type(0, Test::one));
-            map.put(IntE1Map::value_type(1, Test::two));
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "enum", false);
+	IntE1Map map(communicator, dbEnv, "enum");
+	map.clear();
+	map.put(IntE1Map::value_type(0, Test::one));
+	map.put(IntE1Map::value_type(1, Test::two));
+    }
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "enum", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE);
         emitSchemas("tns:_internal.Test.E1Type", "tns:_internal.Test.E1Type");
         {
             XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
             transformer.transform(oldSchema, newSchema);
         }
-        db->close();
-        db = 0;
+        db.close(0);
+    }
+        
 
         //
         // Use E1::three, which is removed in new schema (should fail)
         //
-        db = dbEnv->openDB("failure", true);
-        db->clear();
-
-        {
-            IntE1Map map(db);
-            map.put(IntE1Map::value_type(0, Test::one));
-            map.put(IntE1Map::value_type(1, Test::two));
-            map.put(IntE1Map::value_type(2, Test::three));
-        }
-        db->close();
-        db = 0;
+      
+    {
+	IntE1Map map(communicator, dbEnv, "failure");
+	map.clear();
+	map.put(IntE1Map::value_type(0, Test::one));
+	map.put(IntE1Map::value_type(1, Test::two));
+	map.put(IntE1Map::value_type(2, Test::three));
+    }
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "failure", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE);
 
-        db = dbEnv->openDBWithTxn(0, "failure", false);
-        emitSchemas("tns:_internal.Test.E1Type", "tns:_internal.Test.E1Type");
+	emitSchemas("tns:_internal.Test.E1Type", "tns:_internal.Test.E1Type");
         try
         {
             XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
@@ -568,80 +540,64 @@ transformEnum(const DBEnvironmentPtr& dbEnv)
         {
             // Expected.
         }
-        db->close();
-        db = 0;
-
-        cout << "ok" << endl;
-    }
-    catch(...)
-    {
-        cout << "failed" << endl;
-        if(db)
-        {
-            db->close();
-        }
-        throw;
+        db.close(0);
     }
 
-    if(db)
-    {
-        db->close();
-    }
+    cout << "ok" << endl;
 }
 
 static void
-transformDictionary(const DBEnvironmentPtr& dbEnv)
+transformDictionary(const CommunicatorPtr& communicator, DbEnv& dbEnv)
 {
-    DBPtr db;
     StringSeq dummy;
 
     cout << "transforming dictionaries... " << flush;
 
-    try
+   
+    //
+    // Don't use E1::three, which is removed in new schema
+    //
+   
     {
-        //
-        // Don't use E1::three, which is removed in new schema
-        //
-        db = dbEnv->openDB("dict", true);
-        db->clear();
-
-        {
-            IntD1Map map(db);
-            Test::D1 dict;
-            dict.insert(make_pair(string("one"), Test::one));
-            dict.insert(make_pair(string("two"), Test::two));
-            map.put(IntD1Map::value_type(0, dict));
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "dict", false);
+	IntD1Map map(communicator, dbEnv, "dict");
+	map.clear();
+	Test::D1 dict;
+	dict.insert(make_pair(string("one"), Test::one));
+	dict.insert(make_pair(string("two"), Test::two));
+	map.put(IntD1Map::value_type(0, dict));
+    }
+   
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "dict", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE);
         emitSchemas("tns:_internal.Test.D1Type", "tns:_internal.Test.D1Type");
         {
             XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
             transformer.transform(oldSchema, newSchema);
         }
-        db->close();
-        db = 0;
-
-        //
-        // Use E1::three, which is removed in new schema (should fail)
-        //
-        db = dbEnv->openDB("failure", true);
-        db->clear();
+        db.close(0);
+    }
+        
 
-        {
-            IntD1Map map(db);
-            Test::D1 dict;
-            dict.insert(make_pair(string("one"), Test::one));
-            dict.insert(make_pair(string("two"), Test::two));
-            dict.insert(make_pair(string("three"), Test::three));
-            map.put(IntD1Map::value_type(0, dict));
-        }
-        db->close();
-        db = 0;
+    //
+    // Use E1::three, which is removed in new schema (should fail)
+    //
 
-        db = dbEnv->openDBWithTxn(0, "failure", false);
+    {
+	IntD1Map map(communicator, dbEnv, "failure");
+	map.clear();
+	Test::D1 dict;
+	dict.insert(make_pair(string("one"), Test::one));
+	dict.insert(make_pair(string("two"), Test::two));
+	dict.insert(make_pair(string("three"), Test::three));
+	map.put(IntD1Map::value_type(0, dict));
+    }
+  
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "failure", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE);
         emitSchemas("tns:_internal.Test.D1Type", "tns:_internal.Test.D1Type");
         try
         {
@@ -653,91 +609,70 @@ transformDictionary(const DBEnvironmentPtr& dbEnv)
         {
             // Expected.
         }
-        db->close();
-        db = 0;
-
-        cout << "ok" << endl;
-    }
-    catch(...)
-    {
-        cout << "failed" << endl;
-        if(db)
-        {
-            db->close();
-        }
-        throw;
-    }
-
-    if(db)
-    {
-        db->close();
+        db.close(0);
     }
+        
+    cout << "ok" << endl;
 }
 
 static void
-transformStruct(const DBEnvironmentPtr& dbEnv)
+transformStruct(const CommunicatorPtr& communicator, DbEnv& dbEnv)
 {
-    DBPtr db;
     StringSeq dummy;
 
     cout << "transforming structs... " << flush;
-
-    try
+  
     {
-        //
-        // Transform S1
-        //
-        db = dbEnv->openDB("struct", true);
-        db->clear();
-
-        {
-            IntS1Map map(db);
-            Test::S1 s1;
-            s1.b = false;
-            s1.i = 0;
-            map.put(IntS1Map::value_type(0, s1));
-            s1.b = true;
-            s1.i = 1;
-            map.put(IntS1Map::value_type(1, s1));
-            s1.b = true;
-            s1.i = 2;
-            map.put(IntS1Map::value_type(2, s1));
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "struct", false);
-        emitSchemas("tns:_internal.Test.S1Type", "tns:_internal.Test.S1Type");
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-        }
-        db->close();
-        db = 0;
-
-        //
-        // Transform S1 (should fail)
-        //
-        db = dbEnv->openDB("failure", true);
-        db->clear();
-
-        {
-            IntS1Map map(db);
-            Test::S1 s1;
-            s1.b = false;
-            s1.i = SCHAR_MIN;
-            map.put(IntS1Map::value_type(0, s1));
-            s1.b = true;
-            s1.i = SCHAR_MAX;
-            map.put(IntS1Map::value_type(1, s1));
-            s1.b = true;
-            s1.i = ((Int)SCHAR_MAX) + 1; // Out of range for byte
-            map.put(IntS1Map::value_type(2, s1));
-        }
-        db->close();
-        db = 0;
+	IntS1Map map(communicator, dbEnv, "struct");
+	map.clear();
+	Test::S1 s1;
+	s1.b = false;
+	s1.i = 0;
+	map.put(IntS1Map::value_type(0, s1));
+	s1.b = true;
+	s1.i = 1;
+	map.put(IntS1Map::value_type(1, s1));
+	s1.b = true;
+	s1.i = 2;
+	map.put(IntS1Map::value_type(2, s1));
+    }
+   
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "struct", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE);
+	emitSchemas("tns:_internal.Test.S1Type", "tns:_internal.Test.S1Type");
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	}
+	db.close(0);
+    }
+        
 
-        db = dbEnv->openDBWithTxn(0, "failure", false);
+    //
+    // Transform S1 (should fail)
+    //
+   
+    {
+	IntS1Map map(communicator, dbEnv, "failure");
+	map.clear();
+	Test::S1 s1;
+	s1.b = false;
+	s1.i = SCHAR_MIN;
+	map.put(IntS1Map::value_type(0, s1));
+	s1.b = true;
+	s1.i = SCHAR_MAX;
+	map.put(IntS1Map::value_type(1, s1));
+	s1.b = true;
+	s1.i = ((Int)SCHAR_MAX) + 1; // Out of range for byte
+	map.put(IntS1Map::value_type(2, s1));
+    }
+   
+    {
+        Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "failure", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE);
         emitSchemas("tns:_internal.Test.S1Type", "tns:_internal.Test.S1Type");
         try
         {
@@ -749,225 +684,184 @@ transformStruct(const DBEnvironmentPtr& dbEnv)
         {
             // Expected.
         }
-        db->close();
-        db = 0;
-
-	//
-	// Make sure nothing changed.
-	//
-        db = dbEnv->openDB("failure", false);
-        {
-            IntS1Map map(db);
-	    for(IntS1Map::iterator p = map.begin(); p != map.end(); ++p)
-	    {
-		Test::S1 s1 = p->second;
-		s1.b = false;
-	    }
-        }
-        db->close();
-        db = 0;
-
-        cout << "ok" << endl;
-    }
-    catch(...)
-    {
-        cout << "failed" << endl;
-        if(db)
-        {
-            db->close();
-        }
-        throw;
+        db.close(0);
     }
+        
 
-    if(db)
+    //
+    // Make sure nothing changed.
+    //
     {
-        db->close();
+	IntS1Map map(communicator, dbEnv, "failure");
+	for(IntS1Map::iterator p = map.begin(); p != map.end(); ++p)
+	{
+	    Test::S1 s1 = p->second;
+	    s1.b = false;
+	}
     }
+  
+    cout << "ok" << endl;
 }
 
 static void
-transformClass(const DBEnvironmentPtr& dbEnv)
+transformClass(const CommunicatorPtr& communicator, DbEnv& dbEnv)
 {
-    DBPtr db;
     StringSeq dummy;
 
     cout << "transforming classes... " << flush;
 
-    try
+    //
+    // Transform C2
+    //
+  
     {
-        //
-        // Transform C2
-        //
-        db = dbEnv->openDB("class", true);
-        db->clear();
-
-        {
-            IntC1Map map(db);
-            Test::C2Ptr c2;
-            c2 = new Test::C2;
-            c2->s = "0";
-            c2->f = 0;
-            c2->b = 0;
-            c2->i = 0;
-            c2->l = 0;
-            c2->d = 0;
-            map.put(IntC1Map::value_type(0, c2));
-            c2 = new Test::C2;
-            c2->s = "1";
-            c2->f = 1;
-            c2->b = 1;
-            c2->i = 1;
-            c2->l = 1;
-            c2->d = 1;
-            map.put(IntC1Map::value_type(1, c2));
-            c2 = new Test::C2;
-            c2->s = "2";
-            c2->f = 2;
-            c2->b = 2;
-            c2->i = 2;
-            c2->l = 2;
-            c2->d = 2;
-            map.put(IntC1Map::value_type(2, c2));
-
-            //
-            // Add an object with facets.
-            //
-            Test::C1Ptr c1Facet;
-            Test::C2Ptr c2Facet;
-            c2 = new Test::C2;
-            c2->s = "3";
-            c2->f = 3;
-            c2->b = 3;
-            c2->i = 3;
-            c2->l = 3;
-            c2->d = 3;
-            c1Facet = new Test::C1;
-            c1Facet->s = "c1-0";
-            c1Facet->f = 0;
-            c1Facet->b = 0;
-            c2->ice_addFacet(c1Facet, "c1-0");
-            c1Facet = new Test::C1;
-            c1Facet->s = "c1-1";
-            c1Facet->f = 1;
-            c1Facet->b = 1;
-            c2->ice_addFacet(c1Facet, "c1-1");
-            c2Facet = new Test::C2;
-            c2Facet->s = "c1-2";
-            c2Facet->f = 2;
-            c2Facet->b = 2;
-            c2Facet->i = 2;
-            c2Facet->l = 2;
-            c2Facet->d = 2;
-            c1Facet = new Test::C1;
-            c1Facet->s = "c2-0";
-            c1Facet->f = 0;
-            c1Facet->b = 0;
-            c2Facet->ice_addFacet(c1Facet, "c2-0"); // Nested facet
-            c2->ice_addFacet(c2Facet, "c1-2");
-            map.put(IntC1Map::value_type(3, c2));
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "class", false);
-        emitSchemas("tns:_internal.Test.C1Type", "tns:_internal.Test.C1Type");
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-        }
-        db->close();
-        db = 0;
-
-        //
-        // Transform C2 (should fail)
-        //
-        db = dbEnv->openDB("failure", true);
-        db->clear();
-
-        {
-            IntC1Map map(db);
-            Test::C2Ptr c2;
-            c2 = new Test::C2;
-            c2->s = "0";
-            c2->f = 0;
-            c2->b = 0;
-            c2->i = 0;
-            c2->l = INT_MIN;
-            c2->d = 0;
-            map.put(IntC1Map::value_type(0, c2));
-            c2 = new Test::C2;
-            c2->s = "1";
-            c2->f = 1;
-            c2->b = 1;
-            c2->i = 1;
-            c2->l = INT_MAX;
-            c2->d = 1;
-            map.put(IntC1Map::value_type(1, c2));
-            c2 = new Test::C2;
-            c2->s = "2";
-            c2->f = 2;
-            c2->b = 2;
-            c2->i = 2;
-            c2->l = INT_MAX;
-            c2->l++; // Out of range for int
-            c2->d = 2;
-            map.put(IntC1Map::value_type(2, c2));
-        }
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "failure", false);
-        emitSchemas("tns:_internal.Test.C1Type", "tns:_internal.Test.C1Type");
-        try
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
-            transformer.transform(oldSchema, newSchema);
-            test(false);
-        }
-        catch(const XMLTransform::IllegalTransform&)
-        {
-            // Expected.
-        }
-        db->close();
-        db = 0;
-
+	IntC1Map map(communicator, dbEnv, "class");
+	map.clear();
+	Test::C2Ptr c2;
+	c2 = new Test::C2;
+	c2->s = "0";
+	c2->f = 0;
+	c2->b = 0;
+	c2->i = 0;
+	c2->l = 0;
+	c2->d = 0;
+	map.put(IntC1Map::value_type(0, c2));
+	c2 = new Test::C2;
+	c2->s = "1";
+	c2->f = 1;
+	c2->b = 1;
+	c2->i = 1;
+	c2->l = 1;
+	c2->d = 1;
+	map.put(IntC1Map::value_type(1, c2));
+	c2 = new Test::C2;
+	c2->s = "2";
+	c2->f = 2;
+	c2->b = 2;
+	c2->i = 2;
+	c2->l = 2;
+	c2->d = 2;
+	map.put(IntC1Map::value_type(2, c2));
+	
 	//
-	// Make sure nothing changed.
+	// Add an object with facets.
 	//
-        db = dbEnv->openDB("failure", false);
-        {
-            IntC1Map map(db);
-	    for(IntC1Map::iterator p = map.begin(); p != map.end(); ++p)
-	    {
-		Test::C1Ptr c1 = p->second;
-	    }
-        }
-
-        db->close();
-        db = 0;
-
-        cout << "ok" << endl;
+	Test::C1Ptr c1Facet;
+	Test::C2Ptr c2Facet;
+	c2 = new Test::C2;
+	c2->s = "3";
+	c2->f = 3;
+	c2->b = 3;
+	c2->i = 3;
+	c2->l = 3;
+	c2->d = 3;
+	c1Facet = new Test::C1;
+	c1Facet->s = "c1-0";
+	c1Facet->f = 0;
+	c1Facet->b = 0;
+	c2->ice_addFacet(c1Facet, "c1-0");
+	c1Facet = new Test::C1;
+	c1Facet->s = "c1-1";
+	c1Facet->f = 1;
+	c1Facet->b = 1;
+	c2->ice_addFacet(c1Facet, "c1-1");
+	c2Facet = new Test::C2;
+	c2Facet->s = "c1-2";
+	c2Facet->f = 2;
+	c2Facet->b = 2;
+	c2Facet->i = 2;
+	c2Facet->l = 2;
+	c2Facet->d = 2;
+	c1Facet = new Test::C1;
+	c1Facet->s = "c2-0";
+	c1Facet->f = 0;
+	c1Facet->b = 0;
+	c2Facet->ice_addFacet(c1Facet, "c2-0"); // Nested facet
+	c2->ice_addFacet(c2Facet, "c1-2");
+	map.put(IntC1Map::value_type(3, c2));
     }
-    catch(...)
+   
     {
-        cout << "failed" << endl;
-        if(db)
-        {
-            db->close();
-        }
-        throw;
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "class", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE);
+	emitSchemas("tns:_internal.Test.C1Type", "tns:_internal.Test.C1Type");
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	}
+	db.close(0);
     }
-
-    if(db)
+    
+    
+    //
+    // Transform C2 (should fail)
+    //
+   
+    {
+	IntC1Map map(communicator, dbEnv, "failure");
+	map.clear();
+	Test::C2Ptr c2;
+	c2 = new Test::C2;
+	c2->s = "0";
+	c2->f = 0;
+	c2->b = 0;
+	c2->i = 0;
+	c2->l = INT_MIN;
+	c2->d = 0;
+	map.put(IntC1Map::value_type(0, c2));
+	c2 = new Test::C2;
+	c2->s = "1";
+	c2->f = 1;
+	c2->b = 1;
+	c2->i = 1;
+	c2->l = INT_MAX;
+	c2->d = 1;
+	map.put(IntC1Map::value_type(1, c2));
+	c2 = new Test::C2;
+	c2->s = "2";
+	c2->f = 2;
+	c2->b = 2;
+	c2->i = 2;
+	c2->l = INT_MAX;
+	c2->l++; // Out of range for int
+	c2->d = 2;
+	map.put(IntC1Map::value_type(2, c2));
+    }
+   
     {
-        db->close();
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "failure", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE);
+	emitSchemas("tns:_internal.Test.C1Type", "tns:_internal.Test.C1Type");
+	try
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+	    transformer.transform(oldSchema, newSchema);
+	    test(false);
+	}
+	catch(const XMLTransform::IllegalTransform&)
+	{
+	    // Expected.
+	}
+	db.close(0);
     }
+    
+    {
+	IntC1Map map(communicator, dbEnv, "failure");
+	for(IntC1Map::iterator p = map.begin(); p != map.end(); ++p)
+	{
+	    Test::C1Ptr c1 = p->second;
+	}
+    }
+    
+    cout << "ok" << endl;
 }
 
 static void
-transformEvictor(const DBEnvironmentPtr& dbEnv)
+transformEvictor(const CommunicatorPtr& communicator, DbEnv& dbEnv)
 {
-    DBPtr db;
+
     StringSeq loadOld, loadNew;
     Identity ident;
     Freeze::EvictorPtr evictor;
@@ -992,173 +886,171 @@ transformEvictor(const DBEnvironmentPtr& dbEnv)
 
     cout << "transforming evictor map... " << flush;
 
-    try
+  
+    //
+    // Transform C2
+    //
     {
-        //
-        // Transform C2
-        //
-        db = dbEnv->openDB("evictor", true);
-        db->clear();
-        evictor = db->createEvictor(db->createEvictionStrategy());
-
-        {
-            Test::C2Ptr c2;
-            c2 = new Test::C2;
-            c2->s = "0";
-            c2->f = 0;
-            c2->b = 0;
-            c2->i = 0;
-            c2->l = 0;
-            c2->d = 0;
-            ident.name = "0";
-            evictor->createObject(ident, c2);
-            c2 = new Test::C2;
-            c2->s = "1";
-            c2->f = 1;
-            c2->b = 1;
-            c2->i = 1;
-            c2->l = 1;
-            c2->d = 1;
-            ident.name = "1";
-            evictor->createObject(ident, c2);
-            c2 = new Test::C2;
-            c2->s = "2";
-            c2->f = 2;
-            c2->b = 2;
-            c2->i = 2;
-            c2->l = 2;
-            c2->d = 2;
-            ident.name = "2";
-            evictor->createObject(ident, c2);
-
-            //
-            // Add an object with facets.
-            //
-            Test::C1Ptr c1Facet;
-            Test::C2Ptr c2Facet;
-            c2 = new Test::C2;
-            c2->s = "3";
-            c2->f = 3;
-            c2->b = 3;
-            c2->i = 3;
-            c2->l = 3;
-            c2->d = 3;
-            c1Facet = new Test::C1;
-            c1Facet->s = "c1-0";
-            c1Facet->f = 0;
-            c1Facet->b = 0;
-            c2->ice_addFacet(c1Facet, "c1-0");
-            c1Facet = new Test::C1;
-            c1Facet->s = "c1-1";
-            c1Facet->f = 1;
-            c1Facet->b = 1;
-            c2->ice_addFacet(c1Facet, "c1-1");
-            c2Facet = new Test::C2;
-            c2Facet->s = "c1-2";
-            c2Facet->f = 2;
-            c2Facet->b = 2;
-            c2Facet->i = 2;
-            c2Facet->l = 2;
-            c2Facet->d = 2;
-            c1Facet = new Test::C1;
-            c1Facet->s = "c2-0";
-            c1Facet->f = 0;
-            c1Facet->b = 0;
-            c2Facet->ice_addFacet(c1Facet, "c2-0"); // Nested facet
-            c2->ice_addFacet(c2Facet, "c1-2");
-            ident.name = "3";
-            evictor->createObject(ident, c2);
-        }
-        evictor->deactivate("");
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "evictor", false);
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, loadOld, loadNew, paths, paths, false);
-            transformer.transform(evictorSchema);
-        }
-        db->close();
-        db = 0;
-
-        //
-        // Transform C2 (should fail)
-        //
-        db = dbEnv->openDB("failure", true);
-        db->clear();
-        evictor = db->createEvictor(db->createEvictionStrategy());
-
-        {
-            Test::C2Ptr c2;
-            c2 = new Test::C2;
-            c2->s = "0";
-            c2->f = 0;
-            c2->b = 0;
-            c2->i = 0;
-            c2->l = INT_MIN;
-            c2->d = 0;
-            ident.name = "0";
-            evictor->createObject(ident, c2);
-            c2 = new Test::C2;
-            c2->s = "1";
-            c2->f = 1;
-            c2->b = 1;
-            c2->i = 1;
-            c2->l = INT_MAX;
-            c2->d = 1;
-            ident.name = "1";
-            evictor->createObject(ident, c2);
-            c2 = new Test::C2;
-            c2->s = "2";
-            c2->f = 2;
-            c2->b = 2;
-            c2->i = 2;
-            c2->l = INT_MAX;
-            c2->l++; // Out of range for int
-            c2->d = 2;
-            ident.name = "2";
-            evictor->createObject(ident, c2);
-        }
-        evictor->deactivate("");
-        db->close();
-        db = 0;
-
-        db = dbEnv->openDBWithTxn(0, "failure", false);
-        try
-        {
-            XMLTransform::DBTransformer transformer(dbEnv, db, loadOld, loadNew, paths, paths, false);
-            transformer.transform(evictorSchema);
-            test(false);
-        }
-        catch(const XMLTransform::IllegalTransform&)
-        {
-            // Expected.
-        }
-        db->close();
-        db = 0;
-
-        cout << "ok" << endl;
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD | DB_TRUNCATE | DB_CREATE;
+	db.open(0, "evictor", 0, DB_BTREE, flags, FREEZE_DB_MODE);
+	db.close(0);
     }
-    catch(...)
+    
+    evictor = Freeze::createEvictor(communicator, dbEnv, "evictor");
+    
     {
-        cout << "failed" << endl;
-        if(db)
-        {
-            db->close();
-        }
-        throw;
+	Test::C2Ptr c2;
+	c2 = new Test::C2;
+	c2->s = "0";
+	c2->f = 0;
+	c2->b = 0;
+	c2->i = 0;
+	c2->l = 0;
+	c2->d = 0;
+	ident.name = "0";
+	evictor->createObject(ident, c2);
+	c2 = new Test::C2;
+	c2->s = "1";
+	c2->f = 1;
+	c2->b = 1;
+	c2->i = 1;
+	c2->l = 1;
+	c2->d = 1;
+	ident.name = "1";
+	evictor->createObject(ident, c2);
+	c2 = new Test::C2;
+	c2->s = "2";
+	c2->f = 2;
+	c2->b = 2;
+	c2->i = 2;
+	c2->l = 2;
+	c2->d = 2;
+	ident.name = "2";
+	evictor->createObject(ident, c2);
+	
+	//
+	// Add an object with facets.
+	//
+	Test::C1Ptr c1Facet;
+	Test::C2Ptr c2Facet;
+	c2 = new Test::C2;
+	c2->s = "3";
+	c2->f = 3;
+	c2->b = 3;
+	c2->i = 3;
+	c2->l = 3;
+	c2->d = 3;
+	c1Facet = new Test::C1;
+	c1Facet->s = "c1-0";
+	c1Facet->f = 0;
+	c1Facet->b = 0;
+	c2->ice_addFacet(c1Facet, "c1-0");
+	c1Facet = new Test::C1;
+	c1Facet->s = "c1-1";
+	c1Facet->f = 1;
+	c1Facet->b = 1;
+	c2->ice_addFacet(c1Facet, "c1-1");
+	c2Facet = new Test::C2;
+	c2Facet->s = "c1-2";
+	c2Facet->f = 2;
+	c2Facet->b = 2;
+	c2Facet->i = 2;
+	c2Facet->l = 2;
+	c2Facet->d = 2;
+	c1Facet = new Test::C1;
+	c1Facet->s = "c2-0";
+	c1Facet->f = 0;
+	c1Facet->b = 0;
+	c2Facet->ice_addFacet(c1Facet, "c2-0"); // Nested facet
+	c2->ice_addFacet(c2Facet, "c1-2");
+	ident.name = "3";
+	evictor->createObject(ident, c2);
     }
-
-    if(db)
+    evictor->deactivate("");
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "evictor", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE);
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, loadOld, loadNew, paths, paths, false);
+	    transformer.transform(evictorSchema);
+	}
+	db.close(0);
+    }
+    
+    
+    //
+    // Transform C2 (should fail)
+    //
+    
+    {
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD | DB_TRUNCATE | DB_CREATE;
+	db.open(0, "failure", 0, DB_BTREE, flags, FREEZE_DB_MODE);
+	db.close(0);
+    }
+    
+    evictor = Freeze::createEvictor(communicator, dbEnv, "failure");
+    
+    {
+	Test::C2Ptr c2;
+	c2 = new Test::C2;
+	c2->s = "0";
+	c2->f = 0;
+	c2->b = 0;
+	c2->i = 0;
+	c2->l = INT_MIN;
+	c2->d = 0;
+	ident.name = "0";
+	evictor->createObject(ident, c2);
+	c2 = new Test::C2;
+	c2->s = "1";
+	c2->f = 1;
+	c2->b = 1;
+	c2->i = 1;
+	c2->l = INT_MAX;
+	c2->d = 1;
+	ident.name = "1";
+	evictor->createObject(ident, c2);
+	c2 = new Test::C2;
+	c2->s = "2";
+	c2->f = 2;
+	c2->b = 2;
+	c2->i = 2;
+	c2->l = INT_MAX;
+	c2->l++; // Out of range for int
+	c2->d = 2;
+	ident.name = "2";
+	evictor->createObject(ident, c2);
+    }
+    evictor->deactivate("");
+    
     {
-        db->close();
+	Db db(&dbEnv, 0);
+	u_int32_t flags = DB_AUTO_COMMIT | DB_THREAD;
+	db.open(0, "failure", 0, DB_UNKNOWN, flags, FREEZE_DB_MODE);
+	try
+	{
+	    XMLTransform::DBTransformer transformer(dbEnv, db, loadOld, loadNew, paths, paths, false);
+	    transformer.transform(evictorSchema);
+	    test(false);
+	}
+	catch(const XMLTransform::IllegalTransform&)
+	{
+	    // Expected.
+	}
+	db.close(0);
     }
+    
+    cout << "ok" << endl;    
 }
 
 static int
 run(int argc, char* argv[], const CommunicatorPtr& communicator)
 {
-    string dbEnvDir = "db";
+    string envName = "db";
 
     communicator->addObjectFactory(Test::C1::ice_factory(), Test::C1::ice_staticId());
     communicator->addObjectFactory(Test::C2::ice_factory(), Test::C2::ice_staticId());
@@ -1189,7 +1081,7 @@ run(int argc, char* argv[], const CommunicatorPtr& communicator)
                 return EXIT_FAILURE;
             }
 
-            dbEnvDir = argv[idx + 1];
+            envName = argv[idx + 1];
             for(int i = idx ; i + 2 < argc ; ++i)
             {
                 argv[i] = argv[i + 2];
@@ -1208,33 +1100,24 @@ run(int argc, char* argv[], const CommunicatorPtr& communicator)
         }
     }
 
-    DBEnvironmentPtr dbEnv;
+    DbEnv dbEnv(0);
+    dbEnv.set_flags(DB_TXN_NOSYNC, true);
 
-    try
-    {
-        dbEnv = Freeze::initializeWithTxn(communicator, dbEnvDir);
-        transformPrimitive(dbEnv);
-        transformPrimitiveSequence(dbEnv);
-        transformEnum(dbEnv);
-        transformDictionary(dbEnv);
-        transformStruct(dbEnv);
-        transformClass(dbEnv);
-        transformEvictor(dbEnv);
-    }
-    catch(...)
-    {
-        if(dbEnv)
-        {
-            dbEnv->close();
-        }
-        throw;
-    }
+    u_int32_t flags = DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN |
+	DB_PRIVATE | DB_THREAD | DB_RECOVER | DB_CREATE;
+    
+    dbEnv.open(envName.c_str(), flags, FREEZE_DB_MODE);
 
-    if(dbEnv)
-    {
-        dbEnv->close();
-    }
+    transformPrimitive(communicator, dbEnv);
+    transformPrimitiveSequence(communicator, dbEnv);
+    transformEnum(communicator, dbEnv);
+    transformDictionary(communicator, dbEnv);
+    transformStruct(communicator,dbEnv);
+    transformClass(communicator, dbEnv);
+    transformEvictor(communicator, dbEnv);
 
+    dbEnv.close(0);
+    
     return EXIT_SUCCESS;
 }
 
@@ -1249,6 +1132,11 @@ main(int argc, char* argv[])
         communicator = Ice::initialize(argc, argv);
         status = run(argc, argv, communicator);
     }
+    catch(const DbException& ex)
+    {
+	cerr << ex.what() << endl;
+	status = EXIT_FAILURE;
+    }
     catch(const Exception& ex)
     {
         cerr << ex << endl;