summaryrefslogtreecommitdiffstats
path: root/mddmgr/test/test_persmddcoll.cc
diff options
context:
space:
mode:
Diffstat (limited to 'mddmgr/test/test_persmddcoll.cc')
-rw-r--r--mddmgr/test/test_persmddcoll.cc768
1 files changed, 768 insertions, 0 deletions
diff --git a/mddmgr/test/test_persmddcoll.cc b/mddmgr/test/test_persmddcoll.cc
new file mode 100644
index 0000000..1a08546
--- /dev/null
+++ b/mddmgr/test/test_persmddcoll.cc
@@ -0,0 +1,768 @@
+/*
+* This file is part of rasdaman community.
+*
+* Rasdaman community is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* Rasdaman community is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with rasdaman community. If not, see <http://www.gnu.org/licenses/>.
+*
+* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann /
+rasdaman GmbH.
+*
+* For more information please see <http://www.rasdaman.org>
+* or contact Peter Baumann via <baumann@rasdaman.com>.
+/
+ /**
+ * SOURCE: test_persmddcoll.cc
+ *
+ * MODULE: test for mddobj of cachetamgr
+ *
+ * PURPOSE:
+ * creates a persistent collection of objects and iterators.
+ *
+ * COMMENTS:
+ * none
+ *
+*/
+
+#include "mymalloc/mymalloc.h"
+
+#include <stdlib.h>
+#include <iostream>
+
+#define TEST_PROTECTED
+#define TEST_PRIVATE
+
+
+#include "ulongtype.hh"
+
+#include "tilemgr/persmddcoll.hh"
+#include "tilemgr/persmddobj.hh"
+#include "tilemgr/perstile.hh"
+
+#include "tilemgr/persmddcolliter.hh"
+
+#include "adminif.hh"
+#include "databaseif.hh"
+#include "transactionif.hh"
+
+#include "raslib/rminit.hh"
+#include "typefactory.hh"
+
+#include "mddbasetype.hh"
+#include "mdddomaintype.hh"
+#include "settype.hh"
+
+extern char* myExecArgv0 = "";
+
+RMINITGLOBALS('C')
+
+static char* O2DBName;
+char *collName;
+char defaultCollName[]= "ObjsContainer";
+static int createMDDColl( const char* collName, DatabaseIf* db );
+static void ClearDB( d_Database &DB );
+static void testAccessing( );
+static void testConstructors( );
+static void testRemove( );
+static void testSearch( );
+static void testGetFunctions( );
+static void testLaterInsert( );
+PersTile* createPersTile( const r_Minterval& dom, const BaseType* type );
+static int openCreateDB( const char* O2DBName, DatabaseIf& database );
+
+TransactionIf ta;
+
+/*************************************************************
+ * Function name.: int main( int argc, char** argv)
+ *
+ * Arguments.....:
+ * argc: number of arguments given to program
+ * argv: array of char* with arguments
+ * Return value..: exit status
+ * Description...: none
+ ************************************************************/
+
+int
+main( int argc, char** argv)
+{
+ // variables representing O2 database, ta and session
+ DatabaseIf database;
+ DatabaseIf database1;
+
+ if( argc < 2 ) {
+ cout << "Usage: test_persmddcoll <database> [collName]" << endl;
+ return -1;
+ }
+ O2DBName = argv[1];
+ if ( argc == 3 ) collName = argv[2];
+ else
+ collName = defaultCollName;
+
+ // don't forget to initialize before using AdminIf!
+ myExecArgv0 = argv[0];
+ AdminIf* myAdmin = AdminIf::instance();
+
+ // connect to the database
+ cout << "Connecting to database " << O2DBName
+ << "..." << endl;
+
+ int errorDBOpen = openCreateDB( O2DBName, database );
+ if ( errorDBOpen < 0 )
+ {
+ cout << "Failed at opening newly created database " << errorDBOpen << endl;
+ cout << "Exiting " << endl;
+ return errorDBOpen;
+ }
+
+
+
+ cout << endl << "Deleting root object from the database ..." <<endl;
+ ta.begin( &database );
+ int i = PersMDDColl::destroyRoot( collName, &database );
+ cout << " i == " << i << endl;
+ cout << " &database = " << long( &database) << endl;
+ // database.destroyRootObj( collName );
+ ta.commit( );
+
+
+ ta.begin( &database);
+ createMDDColl( collName, &database );
+ ta.commit( );
+
+ // create collection and objects and put them in the collection
+ cout << endl << "Populate collection ..." << endl;
+ ta.begin( &database );
+ testConstructors( );
+ ta.commit( );
+
+ // read coll and print contents
+ cout << endl << "Read collection and print contents..." << endl;
+ ta.begin( &database );
+ testAccessing( );
+ ta.commit( );
+
+ // connect to the database
+ cout << "Closing database " << O2DBName
+ << "..." << endl;
+ database.close( );
+
+ // connect to the database
+ cout << endl << "Connecting to database SecondBase "
+ << "..." << endl;
+ // database1.open( "SecondBase" );
+
+ errorDBOpen = openCreateDB( "SecondBase", database1 );
+ if ( errorDBOpen < 0 )
+ {
+ cout << "Failed at opening database SecondBase " << errorDBOpen << endl;
+ cout << "Exiting " << endl;
+ return errorDBOpen;
+ }
+
+ // read coll and print contents
+ cout << endl << "Read collection and print contents..." << endl;
+ cout << "Read only? "<< endl;
+ int ro;
+ cin >> ro;
+ ta.begin( &database1, ro );
+ cout << endl << " testAccessing before "<<endl;
+ testAccessing( );
+ ta.commit( );
+
+/*
+ // add some new tiles
+ cout << endl << "Insert more tiles to the existing objects" << endl;
+ ta.begin( &database );
+ testLaterInsert( );
+ ta.commit( );
+
+ // read coll and print contents
+ cout << endl << "Read collection and print contents..." << endl;
+ ta.begin( &database );
+ testAccessing( );
+ ta.commit( );
+
+
+ // search for an interval
+ cout << endl << "Test region search ..." << endl;
+ ta.begin( &database );
+ testSearch( );
+ ta.commit( );
+
+ // search for an interval
+ cout << endl << "Test get functions of MDDObj ..." << endl;
+ ta.begin( &database );
+ testGetFunctions( );
+ ta.commit( );
+
+ // test remove operation and print contents
+ cout << endl << "Test remove ..." << endl;
+ ta.begin( &database );
+ testRemove( );
+ ta.commit( );
+
+ // read coll and print contents
+ cout << endl << "Read collection and print contents..." << endl;
+ ta.begin( &database );
+ testAccessing( );
+ ta.commit( );
+*/
+ cout << endl << "Ending O2 session..." << endl;
+ database.close( );
+ delete myAdmin;
+}
+/*************************************************************
+ * Function......: testConstructors()
+ *
+ ************************************************************/
+PersTile*
+createPersTile( const r_Minterval& dom, const BaseType* type )
+{
+ char* cells = (char*)mymalloc(dom.cell_count() * type->getSize());
+ PersTile* t = new PersTile( dom, type, cells );
+ return t;
+}
+
+/*************************************************************
+ * Function......: testConstructors()
+ *
+ * Arguments.....: none
+ * Return value..: none
+ * Description...: constructs Indices and inserts them
+ * in root collection.
+ ************************************************************/
+
+static void testConstructors()
+{
+ const BaseType* ulongTypeObj = TypeFactory::mapType("ULong");
+ const BaseType* boolTypeObj = TypeFactory::mapType("Bool");
+ char* uLongCells;
+ char* boolCells;
+
+ const MDDBaseType* mType1 =
+ (const MDDBaseType* ) TypeFactory::mapMDDType("TestSMDomainType2D");
+ const MDDBaseType* mType2 =
+ (const MDDBaseType* ) TypeFactory::mapMDDType("TestSMDomainType3D");
+
+ cout << "....testConstructors"<< endl;
+
+
+ // read root object
+
+ try {
+ PersMDDColl objsSet1("WrongName");
+ }
+ catch (...)
+ {
+ cout <<"Error caught ................."<< endl;
+ }
+
+ PersMDDColl objsSet(collName);
+
+/*
+ // test for crash of O2 iterator reset in case the collection is empty
+ cout << "createIterator " << endl;
+ MDDCollIter* it = objsSet.createIterator( );
+ // cout << " Iterator not Done returns " << it->notDone( );
+ // if ( it->notDone( ) ) it->reset( );
+ cout << " Iterator reset " << endl;
+ it->reset( );
+ // cout << " Testing advance on an empty collection" << endl;
+ // it->advance( ); // OK
+ // cout <<" Testing get_element on an empty collection" << endl;
+ // MDDObj* testIterMDDObj = it->getElement( ); // FATAL ERROR
+ // cout <<" get_element returned " << testIterMDDObj << endl;
+*/
+
+ // create MDD Object 1
+
+ cout << " mddObj1" << endl;
+ cout << " tile 1 = nil, 10-12, 20-24 "<< endl;
+ r_Sinterval limits1Obj1(10l,12l);
+ r_Sinterval limits2Obj1(20l,24l);
+ r_Minterval dom(2);
+ dom << limits1Obj1 << limits2Obj1;
+
+
+ r_Minterval tmpInt = *( ( MDDDomainType* ) mType1 )->getDomain( );
+ PersMDDObj* MDDObj1 = new PersMDDObj( mType1, tmpInt );
+
+ PersTile* tile1Obj1 = createPersTile( dom, ulongTypeObj);
+ MDDObj1->insertTile(tile1Obj1);
+
+ cout << " tile 2 = nil, 0-400, 22-24 "<< endl;
+ dom[0].set_interval(0l,400l);
+ dom[1].set_interval(22l,24l);
+ PersTile* tile2Obj1 = createPersTile( dom, ulongTypeObj);
+ MDDObj1->insertTile(tile2Obj1);
+
+ cout << " tile 3 = nil, 0-600, 10-1000 "<< endl;
+ dom[0].set_interval(0l,600l);
+ dom[1].set_interval(10l,1000l);
+ PersTile* tile3Obj1 = createPersTile( dom, ulongTypeObj);
+ MDDObj1->insertTile(tile3Obj1);
+
+ cout << " MDDObj1 == isPersistent:" << MDDObj1->isPersistent( )<< ";" ;
+ MDDObj1->printStatus( );
+ cout << endl;
+
+ objsSet.insert(MDDObj1);
+
+
+ // create MDD Object
+
+ cout << " mddObj2 "<< endl;
+ cout << " tile 1 = nil, 0-19, 20-59, 30-59 "<< endl;
+ r_Sinterval limits1Obj2(0l,19l);
+ r_Sinterval limits2Obj2(20l,59l);
+ r_Sinterval limits3Obj2(30l,59l);
+ r_Minterval dom2(3);
+ dom2 << limits1Obj2 << limits2Obj2 << limits3Obj2;
+ // PersMDDObj* MDDObj2 = new PersMDDObj( dom2, "Bool");
+
+ tmpInt = *( ( MDDDomainType* ) mType2 )->getDomain( );
+ PersMDDObj* MDDObj2 = new PersMDDObj( mType2, tmpInt );
+
+ PersTile* tile1Obj2 = createPersTile( dom2, boolTypeObj);
+ MDDObj2->insertTile( tile1Obj2 );
+
+ cout << " tile 2 = nil, 20-39, 60-79, 60-89 "<< endl;
+ dom2[0].set_interval(20l,39l);
+ dom2[1].set_interval(60l,79l);
+ dom2[2].set_interval(60l,89l);
+ PersTile* tile2Obj2 = createPersTile( dom2, boolTypeObj);
+
+ MDDObj2->insertTile(tile2Obj2);
+
+ cout << " MDDObj2 == isPersistent:" << MDDObj2->isPersistent( )<< ";" ;
+ MDDObj2->printStatus( );
+ cout << endl;
+
+ objsSet.insert(MDDObj2);
+
+ objsSet.releaseAll( );
+
+}
+
+/*************************************************************
+ * Function......: testAccessing()
+ *
+ * Arguments.....: none
+ * Return value..: none
+ * Description...: reads DirTilesIx's and shows contents
+ ************************************************************/
+
+static void testAccessing()
+{
+ PersMDDObj* accessedObj;
+
+ cout << "....testAccessing"<<endl;
+ try{
+ PersMDDColl objsSet(collName);
+
+ // To test PersMDDColl::printStatus( )
+ // objsSet.printStatus( );
+
+ // To test PersMDDObj::printStatus( ), MDDCollIter::createIterator( ) and
+ // MDDCollIter methods :
+
+
+ cout << "Iterating through the collection with PersMDDCollIter " << endl;
+ MDDCollIter* objsIt = objsSet.createIterator( );
+
+ for( int i = 1 ; objsIt->notDone( ); i++, objsIt->advance( ))
+ {
+ accessedObj = (PersMDDObj*) objsIt->getElement();
+ cout << i<<". MDD object in set:" << endl;
+ accessedObj->printStatus();
+ cout << endl << endl;
+ }
+ delete objsIt;
+ objsSet.releaseAll( );
+ }
+ catch(...)
+ {
+ cout << "Error opening collection !!!! "<<endl;
+ exit(-1);
+ }
+}
+
+/*************************************************************
+ * Function......: testLaterInsert()
+ *
+ * Description...:
+ ************************************************************/
+
+static void testLaterInsert()
+{
+ PersMDDObj* accessedObj;
+
+ cout << "....testAccessing"<<endl;
+
+ PersMDDColl objsSet(collName);
+
+ // To test PersMDDColl::printStatus( )
+ // objsSet.printStatus( );
+
+ // To test PersMDDObj::printStatus( ), MDDCollIter::createIterator( ) and
+ // MDDCollIter methods :
+
+
+ cout << "Iterating through the collection with PersMDDCollIter " << endl;
+ MDDCollIter* objsIt = objsSet.createIterator( );
+
+
+ PersTile *t, *t2, *t3;
+ for( int i = 1 ; objsIt->notDone( ); i++, objsIt->advance( ))
+ {
+ accessedObj = (PersMDDObj*) objsIt->getElement();
+ switch( accessedObj->getDimension( ) )
+ {
+ case 2 :
+ t2 = new PersTile( r_Minterval("[40:60,80:100]"),
+ accessedObj->getCellType( ) );
+ t = t2;
+ break;
+ case 3 :
+ t3 = new PersTile(r_Minterval("[40:60,80:100,0:20]"),
+ accessedObj->getCellType( ) );
+ t = t3;
+ break;
+ default:
+ cout << "Error Dimensionality not expected" << endl;
+ break;
+ }
+ accessedObj->insertTile(t);
+ cout << i<<". MDD object in set:" << endl;
+ accessedObj->printStatus();
+ cout << endl << endl;
+ }
+ delete objsIt;
+ objsSet.releaseAll( );
+}
+
+
+/*************************************************************
+ * Function......: testSearch()
+ *
+ * Arguments.....: none
+ * Return value..: none
+ * Description...: reads Index's and shows contents
+ ************************************************************/
+
+static void testSearch()
+{
+
+ MDDObj* accessedObj;
+
+ cout << "....testSearch"<<endl;
+
+ PersMDDColl objsSet(collName);
+
+ MDDCollIter* objsIt = objsSet.createIterator( );
+
+ for( int i = 1 ; objsIt->notDone( ); i++, objsIt->advance( ))
+ {
+ accessedObj = objsIt->getElement();
+
+ cout << "Accessed Object " << endl;
+ accessedObj->printStatus( );
+ cout << endl;
+
+ if (i == 1 || i == 2)
+ {
+ r_Minterval searchInt1(2);
+ r_Minterval searchInt2(3);
+ vector< Tile* >* entriesList;
+
+ cout << " -- " << i << ". MDD object in list. Search for:";
+ switch (i) {
+ case 1: searchInt1[0].set_interval(10l,20l);
+ searchInt1[1].set_interval(10l,30l);
+ cout << " 10-20, 10-30" << endl;
+ entriesList = accessedObj->intersect(searchInt1);
+ break;
+ case 2: searchInt2[0].set_interval(10l,20l);
+ searchInt2[1].set_interval(10l,30l);
+ searchInt2[2].set_interval(40l,50l);
+ cout << " 10-20, 10-30, 40-50" <<endl;
+ entriesList = accessedObj->intersect(searchInt2);
+ break;
+ default: break;
+ }
+ cout << " -- Search result: " << endl;
+ vector<Tile*>::iterator entryIt = entriesList->begin();
+
+ while (entryIt != entriesList->end())
+ {
+ // (*entryIt)->printStatus();
+ r_Minterval tileInterval = (*entryIt)->getDomain();
+ int dimensionality = tileInterval.dimension();
+
+ cout << " PersTile printStatus";
+ cout << " domain == " << dimensionality << ": ";
+ for (int i = 0; i <dimensionality; i++)
+ cout << tileInterval[i].low() << "-"
+ << tileInterval[i].high() <<", ";
+ cout << endl;
+
+ entryIt++;
+ }
+ delete entriesList;
+ }
+ }
+ delete objsIt;
+ objsSet.releaseAll( );
+}
+
+/*************************************************************
+ * Function......: testGetFunctions()
+ *
+ * Arguments.....: none
+ * Return value..: none
+ * Description...: reads Index's and shows contents
+ ************************************************************/
+
+static void testGetFunctions()
+{
+ PersMDDObj* accessedObj;
+
+ cout << "....testGetFunctions"<<endl;
+
+ PersMDDColl objsSet(collName);
+
+ MDDCollIter* objsIt = objsSet.createIterator( );
+
+ vector< Tile* >* entriesList;
+
+ for( int i = 1 ; objsIt->notDone( ); i++, objsIt->advance( ))
+ {
+ r_Minterval currDom;
+ r_Minterval defDom;
+
+ cout << " " << i << ". Object" << endl;
+ accessedObj = (PersMDDObj*) objsIt->getElement();
+
+
+ defDom = accessedObj->getDefinitionDomain( );
+ cout << " GetDefinitionDomain result: ";
+ defDom.print_status( );
+ cout << endl;
+
+ currDom = accessedObj->getCurrentDomain( );
+ cout << " GetCurrentDomain result: ";
+ currDom.print_status( );
+ cout << endl;
+
+ entriesList = accessedObj->getTiles( );
+ cout << " -- GetTiles result: " << endl;
+ vector<Tile*>::iterator entryIt = entriesList->begin();
+
+ while (entryIt != entriesList->end())
+ {
+ // (*entryIt)->printStatus();
+ r_Minterval tileInterval = (*entryIt)->getDomain();
+ int dimensionality = tileInterval.dimension();
+
+ cout << " PersTile ";
+ cout << " domain == " << dimensionality << ": ";
+ for (int i = 0; i <dimensionality; i++)
+ cout << tileInterval[i].low() << "-" << tileInterval[i].high() <<", ";
+ cout << endl;
+ entryIt++;
+ }
+ delete entriesList;
+ }
+ delete objsIt;
+ objsSet.releaseAll( );
+}
+
+/*************************************************************
+ * Function......: testRemove()
+ *
+ * Arguments.....: none
+ * Return value..: none
+ * Description...: reads DirTilesIx's and shows contents
+ ************************************************************/
+
+static void testRemove()
+{
+ PersMDDObj* accessedObj;
+
+ cout << "....testRemove"<<endl;
+
+ PersMDDColl objsSet(collName);
+ // PersMDDColl objsSet("Qualquercoisa");
+ // To test PersMDDColl::printStatus and PersMDDColl::remove
+
+
+ MDDCollIter* objsIt = objsSet.createIterator( );
+
+ cout << "-- Remove second element from collection " << endl;
+
+ for( int i = 1 ; objsIt->notDone( ) && i < 2; i++, objsIt->advance( ))
+ {
+ accessedObj = (PersMDDObj*) objsIt->getElement();
+ }
+ cout << "Delete of objsIt:" << endl;
+ delete objsIt;
+ cout << "Finished Delete of objsIt." << endl;
+ cout << "Remove accessedObj:" << endl;
+ objsSet.remove( accessedObj );
+ cout << "Finished Remove accessedObj." << endl;
+}
+
+/*************************************************************
+ * Function......: openCreateDB()
+ *
+ ************************************************************/
+
+static int openCreateDB( const char* O2DBName, DatabaseIf& database )
+{
+ cout << "openCreateDB " << O2DBName << endl;
+
+ int errorDBOpen;
+ try{
+ errorDBOpen = database.open( O2DBName );
+ }
+ catch( ...)
+ {
+ cout << "Caught Exception " << endl;
+ errorDBOpen = -6;
+ }
+ if ( errorDBOpen < 0 )
+ {
+ cout << "Database doesn't exist. Create it new ... " << endl;
+ cout << "Creating new database " << O2DBName
+ << "..." << endl;
+ database.create( O2DBName, "TestSMSchema" );
+ cout << endl << "Connecting to database " << O2DBName
+ << "..." << endl;
+
+ try{
+ errorDBOpen = database.open( O2DBName );
+ }
+ catch(...)
+ {
+ errorDBOpen = -6;
+ }
+ }
+ if ( errorDBOpen < 0 )
+ {
+ cout << "Failed at opening newly created database " << errorDBOpen << endl;
+ cout << "Exiting " << endl;
+ return errorDBOpen;
+ }
+ return errorDBOpen;
+}
+
+/*************************************************************
+ * Function......: createMDDColl( )
+ ************************************************************/
+static int
+createMDDColl( const char* collName, DatabaseIf* db )
+{
+ MDDDomainType* mType1 = 0;
+ MDDDomainType* mType2 = 0;
+ MDDType* mt = 0;
+ CollectionType* collType1 = 0;
+
+ const BaseType* ulongTypeObj = TypeFactory::mapType("ULong");
+
+ const MDDDomainType* cmType1 =
+ ( MDDDomainType* ) TypeFactory::mapMDDType( "TestSMDomainType2D" );
+ const MDDDomainType* cmType2 =
+ ( MDDDomainType* ) TypeFactory::mapMDDType( "TestSMDomainType3D" );
+
+ const CollectionType* collType =
+ (CollectionType*)TypeFactory::mapSetType( "ObjsContainerType" );
+
+
+ if( !cmType1 || !cmType2 || !collType )
+ {
+ char name1[] = "TestSMDomainType2D";
+ char name2[] = "TestSMDomainType3D";
+
+ r_Sinterval limits1Obj1(0l,1000l);
+ r_Sinterval limits2Obj1(0l,800l);
+ r_Minterval dom1(2);
+ dom1 << limits1Obj1 << limits2Obj1;
+ cout << "MDD Type 1 , domain "<< dom1 << endl;
+
+ cout << " tile 1 = nil, 0-19, 20-59, 30-59 "<< endl;
+ r_Sinterval limits1Obj2(0l,19l);
+ r_Sinterval limits2Obj2(20l,59l);
+ r_Sinterval limits3Obj2(30l,59l);
+ r_Minterval dom2(3);
+ dom2 << limits1Obj2 << limits2Obj2 << limits3Obj2;
+ cout << "MDD Type 2 , domain "<< dom2 << endl;
+
+ // MDDDomainType* mType1 =
+ mType1 =
+ new MDDDomainType((char*) name1, ( BaseType* ) ulongTypeObj, dom1 );
+ // MDDDomainType* mType2 =
+ mType2 =
+ new MDDDomainType((char*) name2, ( BaseType* ) ulongTypeObj, dom2 );
+
+ cout << "MDD Type1 == ";
+ mType1->print_status( cout );
+ cout << endl;
+ cout << "MDD Type2 == ";
+ mType2->print_status( cout );
+ cout << endl;
+
+ TypeFactory::addMDDType( mType1 );
+ TypeFactory::addMDDType( mType2 );
+
+ if ( !collType )
+ {
+ cout << "Collection type newly created " << endl;
+ // MDDType* mt = new MDDType( );
+ mt = new MDDType( );
+ cout << "MDDtype created "<< endl;
+ collType1 = new SetType( "ObjsContainerType", mType1 );
+ cout << "Set Type created ... ";
+ collType = collType1;
+ TypeFactory::addSetType( (SetType*) collType );
+ cout <<" and added "<< endl;
+
+ }
+
+ }
+ cout << "Creating root collection" << endl;
+
+ OId oColl;
+ if( OId::allocateMDDCollOId( &oColl ) == 0 )
+ cout <<"Successfully allocated OId for collection " << oColl << endl;
+ else
+ cout <<"Error allocating OId for collection " << endl;
+
+ PersMDDColl* col;
+ try {
+ // CollectionType* ct = TypeFactory::mapSetType( "ObjsContainerType" );
+ col = PersMDDColl::createRoot( collName, oColl, collType, db );
+ }
+ catch (...)
+ {
+ cout <<"Error caught ................."<< endl;
+ return -1;
+ }
+
+ cout << "Committing TA ..."<< endl;
+ ta.commit( );
+
+ if ( col ) delete col;
+ cout << "Col freed . "<< endl;
+
+ ta.begin( db );
+ return 0;
+}