diff options
Diffstat (limited to 'mddmgr/mddcoll.cc')
| -rw-r--r-- | mddmgr/mddcoll.cc | 411 |
1 files changed, 411 insertions, 0 deletions
diff --git a/mddmgr/mddcoll.cc b/mddmgr/mddcoll.cc new file mode 100644 index 0000000..56a1afe --- /dev/null +++ b/mddmgr/mddcoll.cc @@ -0,0 +1,411 @@ +/* +* 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: mddcoll.cc + * + * MODULE: cachetamgr + * CLASS: MDDColl + * + * COMMENTS: + * none + * +*/ + +#include "mymalloc/mymalloc.h" + +#include <iostream> +#include "mddcoll.hh" +#include "mddcolliter.hh" +#include "relmddif/dbmddset.hh" +#include "relcatalogif/mdddomaintype.hh" +#include "relcatalogif/settype.hh" +#include "mddobj.hh" +#include "relmddif/dbmddobj.hh" +#include "reladminif/objectbroker.hh" +#include "raslib/rmdebug.hh" +#include "reladminif/oidif.hh" +#include "relcatalogif/collectiontype.hh" // from base catalogif DBMS interface module +#include "reladminif/databaseif.hh" +#include "relmddif/dbmddset.hh" +#include "reladminif/eoid.hh" +#include "catalogmgr/typefactory.hh" +#include "tilemgr/tile.hh" + +#include <cstring> + +MDDColl::MDDColl(const CollectionType* newType, const char* name) + { + RMDBGONCE(2, RMDebug::module_mddmgr, "MDDColl", "MDDColl(" << newType->getName() << ", " << (name?name:"null") << ") " << (r_Ptr)this); + const char* theName = name; + if (theName == NULL) + { + theName = "rasdaman temporary collection"; + } + dbColl = new DBMDDSet(theName, newType); + } + +const char* +MDDColl::getName() const + { + return dbColl->getName(); + } + +const CollectionType* +MDDColl::getCollectionType() const + { + return dbColl->getCollType(); + } + +unsigned long +MDDColl::getCardinality() const + { + return dbColl->getCardinality(); + } + +bool +MDDColl::getOId(OId& pOId) const + { + if (isPersistent()) + { + pOId = dbColl->getOId(); + return true; + } + return false; + } + +bool +MDDColl::getEOId(EOId& pEOId) const + { + if (isPersistent()) + { + pEOId = dbColl->getEOId(); + return true; + } + return false; + } + +void +MDDColl::insert(const MDDObj* newObj) + { + RMDBGIF(0, RMDebug::module_mddmgr, "MDDColl", if (newObj == 0) \ + { \ + RMInit::dbgOut << "MDDColl::insert(const MDDObj*) assertion failed" << endl;\ + throw r_Error(MDD_NOT_VALID);\ + }) + RMDBGONCE(2, RMDebug::module_mddmgr, "MDDColl", "insert(" << (r_Ptr)newObj << ")") + dbColl->insert(newObj->getDBMDDObjId()); + insertIntoCache(newObj); + RMDBGIF(2, RMDebug::module_mddmgr, "MDDColl", dbColl->printStatus(0, RMInit::dbgOut);) + } + +void +MDDColl::releaseAll() { + MDDObj* tempMDD = 0; + while (!mddCache.empty()){ + tempMDD = (*mddCache.begin()).second; + (*mddCache.begin()).second = NULL; + delete tempMDD; + mddCache.erase(mddCache.begin()); + } +} + +MDDColl::~MDDColl() + { + RMDBGONCE(2, RMDebug::module_mddmgr, "MDDColl", "~MDDColl() " << (r_Ptr)this); + if (isPersistent()) + releaseAll(); + //else released by release transfer structures + } + +MDDColl::MDDColl(const DBMDDSetId& coll) + :dbColl(coll) + { + } + +DBMDDSetId +MDDColl::getDBMDDSet() const + { + return dbColl; + } + +void +MDDColl::insertIntoCache(const MDDObj* objToInsert) const + { + RMDBGONCE(2, RMDebug::module_mddmgr, "MDDColl", "insertIntoCache(" << (r_Ptr)objToInsert << ")") + mddCache[objToInsert->getDBMDDObjId().ptr()] = (MDDObj*)objToInsert; + } + +MDDObj* +MDDColl::getMDDObj(const DBMDDObj* objToGet) const + { + MDDObj* persMDDObjToGet = NULL; + MDDObjMap::const_iterator i = mddCache.find((DBMDDObj*)objToGet); + if (i != mddCache.end()) + persMDDObjToGet = (MDDObj*)(*i).second; + else { + persMDDObjToGet = new MDDObj((DBMDDObj*)objToGet); + insertIntoCache(persMDDObjToGet); + } + return persMDDObjToGet; + } + +bool +MDDColl::isPersistent() const + { + return dbColl->isPersistent(); + } + +void +MDDColl::printStatus(unsigned int level, std::ostream& stream) const + { + dbColl->printStatus(level, stream); + char* indent = new char[level*2 +1]; + for (int j = 0; j < level*2 ; j++) + indent[j] = ' '; + indent[level*2] = '\0'; + stream << indent; + for (MDDObjMap::iterator i = mddCache.begin(); i != mddCache.end(); i++) + { + stream << (r_Ptr)(*i).second; + } + delete[] indent; + indent=0; + } + +MDDCollIter* +MDDColl::createIterator() const + { + MDDCollIter* iter = new MDDCollIter((MDDColl*)this); + return iter; + } + +void +MDDColl::remove(const MDDObj* obj) + { + if (obj != NULL) + { + DBMDDObjId t2 = obj->getDBMDDObjId(); + dbColl->remove(t2); + + //remove from cache ;( + MDDObjMap::iterator i = mddCache.find(t2.ptr()); + if(i != mddCache.end()) + { + RMDBGONCE(2, RMDebug::module_mddmgr, "MDDColl", "remove(" << (r_Ptr)obj << ") found in cache") + mddCache.erase(i); + } + else + { + RMDBGONCE(0, RMDebug::module_mddmgr, "MDDColl", "remove(" << (r_Ptr)obj << ") not in collection cache") + } + } + else { + RMDBGONCE(0, RMDebug::module_mddmgr, "MDDColl", "remove(MDDObj*) NULL"); + throw r_Error(MDD_NOT_VALID); + } + } + +/* +void +MDDColl::removeFromCache(const PersMDDObj* objToRemove) + { + DBMDDObj* objIdVoidAddress = objToRemove->getDBMDDObjId().ptr(); + MDDObjMap::iterator i = mddCache.find(objIdVoidAddress); + + if (i != mddCache.end()) + { + persMDDObjToRemove = (*i).second; + (*i).second = NULL; + delete persMDDObjToRemove; + mddCache.erase(i); + RMDBGIF(0, RMDebug::module_mddmgr, "MDDColl", \ + if (mddCache.find(objIdVoidAddress) != mddCache.end()) \ + { \ + RMInit::dbgOut << "MDDColl::removeMDDObjfromCache() object multiple times in cache" << endl; \ + throw r_Error(MDD_EXISTS_MULTIPLE_TIMES); \ + }) + } + else { + RMDBGONCE(0, RMDebug::module_mddmgr, "MDDColl", "removeMDDObjfromCache(" << objToRemove << ") not in collection") + } + } +*/ + +void +MDDColl::removeAll() + { + dbColl->removeAll(); + } + + +const char* +MDDColl::AllCollectionnamesName = "RAS_COLLECTIONNAMES"; + +MDDColl* +MDDColl::createMDDCollection(const char* name, const CollectionType* ct) throw (r_Error) + { + if (name == NULL) + { + RMDBGONCE(0, RMDebug::module_mddmgr, "MDDColl", "createMDDColl(NULL, colltype)") + throw r_Error(r_Error::r_Error_NameNotUnique); + } + if (ct == NULL) + { + RMDBGONCE(0, RMDebug::module_mddmgr, "MDDColl", "createMDDColl(" << name << ", NULL)") + throw r_Error(COLLTYPE_NULL); + } + if (!ct->isPersistent()) + { + r_Error t(209); + t.setTextParameter("type", ct->getName()); + RMDBGONCE(0, RMDebug::module_mddmgr, "MDDColl", "createMDDColl(" << name << ", " << ct->getName() << " not persistent)") + throw t; + } + // may generate an exception: + DBMDDSetId newDBColl = new DBMDDSet(name, ct); + return new MDDColl(newDBColl); + } + +MDDColl* +MDDColl::createMDDCollection(const char* name, const OId& o, const CollectionType* ct) throw (r_Error) + { + // may generate an exception: + if (name == NULL) + { + RMDBGONCE(0, RMDebug::module_mddmgr, "MDDColl", "createMDDColl(NULL, " << o << ", colltype)") + throw r_Error(r_Error::r_Error_NameNotUnique); + } + if (ct == NULL) + { + RMDBGONCE(0, RMDebug::module_mddmgr, "MDDColl", "createMDDColl(" << name << ", " << o << ", NULL)") + throw r_Error(COLLTYPE_NULL); + } + if (!ct->isPersistent()) + { + r_Error t(209); + t.setTextParameter("type", ct->getName()); + RMDBGONCE(0, RMDebug::module_mddmgr, "MDDColl", "createMDDColl(" << name << ", " << o << ", " << ct->getName() << " not persistent)") + throw t; + } + DBMDDSetId newDBColl = new DBMDDSet(name, o, ct); + return new MDDColl(newDBColl); + } + +bool +MDDColl::dropMDDCollection(const char* name) + { + return DBMDDSet::deleteDBMDDSet(name); + } + +bool +MDDColl::dropMDDCollection(const OId& o) + { + return DBMDDSet::deleteDBMDDSet(o); + } + +MDDColl* +MDDColl::getMDDCollection(const OId& collOId) throw (r_Error) + { + RMDBGENTER(2, RMDebug::module_mddmgr, "MDDColl", "getMDDCollection(" << collOId << ")") + DBMDDSetId t(collOId); + //this will throw an exception + t->isModified(); + MDDColl* retval = new MDDColl(t); + RMDBGEXIT(2, RMDebug::module_mddmgr, "MDDColl", "getMDDCollection(" << collOId << ") " << retval) + return retval; + } + +MDDColl* +MDDColl::getMDDCollection(const char* collName) throw (r_Error) + { + RMDBGENTER(2, RMDebug::module_mddmgr, "MDDColl", "getMDDCollection(" << collName << ")") + MDDColl* retval = 0; + DBMDDSetId dbset; + if (strcmp(collName, AllCollectionnamesName) == 0) + { + r_Minterval transDomain("[0:*]"); + r_Minterval nameDomain("[0:0]"); + const BaseType* bt = TypeFactory::mapType("Char"); + MDDDomainType* mt = new MDDDomainType("RAS_NAMETYPE", bt, transDomain); + TypeFactory::addTempType(mt); + CollectionType* ct = new SetType("RAS_NAMESETTYPE", mt); + TypeFactory::addTempType(ct); + retval = new MDDColl(ct, AllCollectionnamesName); + OIdSet* list = ObjectBroker::getAllObjects(OId::MDDCOLLOID); + MDDObj* transObj = 0; + Tile* transTile = 0; + char* transName = 0; + const char* nameBuffer = 0; + r_Range namelen = 0; + while (!list->empty()) + { + dbset = *(list->begin()); + RMDBGMIDDLE(2, RMDebug::module_mddmgr, "MDDColl", "Coll OId : " << dbset.getOId()) + nameBuffer = dbset->getName(); + RMDBGMIDDLE(2, RMDebug::module_mddmgr, "MDDColl", "Coll Name : " << nameBuffer) + namelen = strlen(nameBuffer); + RMDBGMIDDLE(2, RMDebug::module_mddmgr, "MDDColl", "Coll Name Len: " << namelen) + transName = (char*)mymalloc(sizeof(char) * (namelen + 1)); + memset(transName, 0, namelen + 1); + strcpy(transName, nameBuffer); + RMDBGMIDDLE(2, RMDebug::module_mddmgr, "MDDColl", "Domain : " << namelen) + nameDomain[0].set_high((r_Range)namelen); + transObj = new MDDObj(mt, nameDomain); + transTile = new Tile(nameDomain, bt, transName, 0, r_Array); + transObj->insertTile(transTile); + retval->insert(transObj); + list->erase(list->begin()); + } + delete list; + } + else { + dbset = DBMDDSet::getDBMDDSet(collName); + retval = new MDDColl(dbset); + } + RMDBGEXIT(2, RMDebug::module_mddmgr, "MDDColl", "getMDDCollection(" << collName << ") " << retval) + return retval; + } + +bool +MDDColl::removeMDDObject(const OId& collOId, const OId& mddOId) + { + bool retval = true; + DBMDDSetId coll(collOId); + DBMDDObjId mdd(mddOId); + + if (coll.is_null()) + {//does not exist + retval = false; + } + else { + if (mdd.is_null()) + { + retval = false; + } + else { + coll->remove(mdd); + } + } + return retval; + } + |