diff options
Diffstat (limited to 'relstorageif/dbstoragelayout.pgc')
| -rw-r--r-- | relstorageif/dbstoragelayout.pgc | 646 |
1 files changed, 646 insertions, 0 deletions
diff --git a/relstorageif/dbstoragelayout.pgc b/relstorageif/dbstoragelayout.pgc new file mode 100644 index 0000000..f7b8910 --- /dev/null +++ b/relstorageif/dbstoragelayout.pgc @@ -0,0 +1,646 @@ +/* +* 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>. +*/ +/**************************************************************************** + * + * + * PURPOSE: + * Code with embedded SQL for PostgreSQL DBMS + * + * + * COMMENTS: + * none + * + ****************************************************************************/ + +#include "reladminif/sqlerror.hh" +#include "raslib/rmdebug.hh" +#include "reladminif/externs.h" +#include "dbstoragelayout.hh" +#include "storagemgr/sstoragelayout.hh" +#include "reladminif/objectbroker.hh" + +DBStorageLayout::DBStorageLayout() + : DBObject(), + indexType(StorageLayout::DefaultIndexType), + indexSize(StorageLayout::DefaultIndexSize), + tilingScheme(StorageLayout::DefaultTilingScheme), + tileSize(StorageLayout::DefaultTileSize), + tileConfiguration(new DBMinterval()), + dataFormat(StorageLayout::DefaultDataFormat), + pctMin(StorageLayout::DefaultMinimalTileSize), + pctMax(StorageLayout::DefaultPCTMax), + _supportsTileSize(false), + _supportsPCTMin(false), + _supportsPCTMax(false), + _supportsIndexSize(false), + _supportsIndexType(false), + _supportsTiling(false), + _supportsTileConfiguration(false), + _supportsDataFormat(false) +{ + objecttype = OId::STORAGEOID; +} + +DBStorageLayout::DBStorageLayout(const OId& id) throw(r_Error) + : DBObject(id), + indexType(StorageLayout::DefaultIndexType), + indexSize(StorageLayout::DefaultIndexSize), + tilingScheme(StorageLayout::DefaultTilingScheme), + tileSize(StorageLayout::DefaultTileSize), + tileConfiguration(new DBMinterval()), + dataFormat(StorageLayout::DefaultDataFormat), + pctMin(StorageLayout::DefaultMinimalTileSize), + pctMax(StorageLayout::DefaultPCTMax), + _supportsTileSize(false), + _supportsPCTMin(false), + _supportsPCTMax(false), + _supportsIndexSize(false), + _supportsIndexType(false), + _supportsTiling(false), + _supportsTileConfiguration(false), + _supportsDataFormat(false) +{ + objecttype = OId::STORAGEOID; + readFromDb(); +} + +void +DBStorageLayout::printStatus(unsigned int level, std::ostream& stream) const +{ + char* indent = new char[level*2 +1]; + for (int j = 0; j < level*2 ; j++) + indent[j] = ' '; + indent[level*2] = '\0'; + + stream << indent; + stream << "DBStorageLayout:" << endl; + if (supportsTileSize()) + stream << "\tTileSize\t\t\t:"; + else + stream << "\tTileSize (Def.)\t\t\t:"; + stream << getTileSize() << endl; + stream << indent; + if (supportsPCTMin()) + stream << "\tPCTMin\t\t:"; + else + stream << "\tPCTMin (Def.)\t\t\t:"; + stream << getPCTMin() << endl; + stream << indent; + if (supportsPCTMax()) + stream << "\tPCTMax\t\t:"; + else + stream << "\tPCTMax (Def.)\t\t\t:"; + stream << getPCTMax() << endl; + stream << indent; + if (supportsIndexSize()) + stream << "\tIndexSize\t\t:"; + else + stream << "\tIndexSize (Def.)\t\t:"; + stream << getIndexSize() << endl; + stream << indent; + if (supportsIndexType()) + stream << "\tIndexType\t\t\t:"; + else + stream << "\tIndexType (Def.)\t\t:"; + stream << getIndexType() << endl; + stream << indent; + if (supportsTilingScheme()) + stream << "\tTilingScheme\t\t\t:"; + else + stream << "\tTilingScheme (Def.)\t\t:"; + stream << getTilingScheme() << endl; + stream << indent; + if (supportsTileConfiguration()) + stream << "\tTileConfiguration\t\t:"; + else + stream << "\tTileConfiguration (Def.)\t:"; + stream << getTileConfiguration() << endl; + stream << indent; + if (supportsDataFormat()) + stream << "\tDataFormat\t\t\t:"; + else + stream << "\tDataFormat (Def.)\t\t:"; + stream << getDataFormat() << endl; + stream << indent; + + delete[] indent; +} + +bool +DBStorageLayout::supportsIndexType() const +{ + return _supportsIndexType; +} + +bool +DBStorageLayout::supportsDataFormat() const +{ + return _supportsDataFormat; +} + +bool +DBStorageLayout::supportsTilingScheme() const +{ + return _supportsTiling; +} + +bool +DBStorageLayout::supportsTileSize() const +{ + return _supportsTileSize; +} + +bool +DBStorageLayout::supportsIndexSize() const +{ + return _supportsIndexSize; +} + +bool +DBStorageLayout::supportsPCTMin() const +{ + return _supportsPCTMin; +} + +bool +DBStorageLayout::supportsPCTMax() const +{ + return _supportsPCTMax; +} + +bool +DBStorageLayout::supportsTileConfiguration() const +{ + return _supportsTileConfiguration; +} + +r_Index_Type +DBStorageLayout::getIndexType() const +{ + return indexType; +} + +r_Data_Format +DBStorageLayout::getDataFormat() const +{ + return dataFormat; +} + +r_Tiling_Scheme +DBStorageLayout::getTilingScheme() const +{ + return tilingScheme; +} + +r_Bytes +DBStorageLayout::getTileSize() const +{ + return tileSize; +} + +unsigned int +DBStorageLayout::getIndexSize() const +{ + return indexSize; +} + +r_Bytes +DBStorageLayout::getPCTMin() const +{ + return pctMin; +} + +r_Bytes +DBStorageLayout::getPCTMax() const +{ + return pctMax; +} + +r_Minterval +DBStorageLayout::getTileConfiguration() const +{ + return *tileConfiguration; +} + +void +DBStorageLayout::setIndexType(r_Index_Type it) +{ + _supportsIndexType = true; + indexType = it; + setModified(); +} + +void +DBStorageLayout::setDataFormat(r_Data_Format cs) +{ + _supportsDataFormat = true; + dataFormat = cs; + setModified(); +} + +void +DBStorageLayout::setTilingScheme(r_Tiling_Scheme ts) +{ + _supportsTiling = true; + tilingScheme = ts; + setModified(); +} + +void +DBStorageLayout::setTileSize(r_Bytes tsize) +{ + _supportsTileSize = true; + tileSize = tsize; + setModified(); +} + +void +DBStorageLayout::setTileConfiguration(const r_Minterval& tc) +{ + _supportsTileConfiguration = true; + *tileConfiguration = tc; + setModified(); +} + +void +DBStorageLayout::setIndexSize(unsigned int newindexSize) +{ + _supportsIndexSize = true; + indexSize = newindexSize; + setModified(); +} + +void +DBStorageLayout::setPCTMin(r_Bytes newpctMin) +{ + _supportsPCTMin = true; + pctMin = newpctMin; + setModified(); +} + +void +DBStorageLayout::setPCTMax(r_Bytes newpctMax) +{ + _supportsPCTMax = true; + pctMax = newpctMax; + setModified(); +} + +DBStorageLayout::~DBStorageLayout() +{ + validate(); +} + +/* +TABLE RAS_STORAGE ( + StorageId INTEGER NOT NULL UNIQUE, + DomainId INTEGER, + TileSize INTEGER, + PCTMin INTEGER, + PCTMax INTEGER, + IndexSize INTEGER, + IndexType SMALLINT, + TilingScheme SMALLINT, + DataFormat SMALLINT + ) +*/ + +void +DBStorageLayout::readFromDb() throw(r_Error) +{ + RMDBGENTER(5, RMDebug::module_storageif, "DBStorageLayout", "readFromDb() " << myOId); + EXEC SQL BEGIN DECLARE SECTION; + long storageid1; + long domainid1; + short domainid1ind; + long tilesize1; + short tilesize1ind; + long pctmin1; + short pctmin1ind; + long pctmax1; + short pctmax1ind; + long indexsize1; + short indexsize1ind; + short indextype1; + short indextype1ind; + short tilingscheme1; + short tilingscheme1ind; + short dataformat1; + short dataformat1ind; + EXEC SQL END DECLARE SECTION; + + storageid1 = myOId.getCounter(); + EXEC SQL SELECT + DomainId, + TileSize, + PCTMin, + PCTMax, + IndexType, + TilingScheme, + DataFormat, + IndexSize + INTO + :domainid1 INDICATOR :domainid1ind, + :tilesize1 INDICATOR :tilesize1ind, + :pctmin1 INDICATOR :pctmin1ind, + :pctmax1 INDICATOR :pctmax1ind, + :indextype1 INDICATOR :indextype1ind, + :tilingscheme1 INDICATOR :tilingscheme1ind, + :dataformat1 INDICATOR :dataformat1ind, + :indexsize1 INDICATOR :indexsize1ind + FROM + RAS_STORAGE + WHERE + StorageId = :storageid1; + if (SQLCODE != SQLOK) + { + check("DBStorageLayout::readFromDb() SELECT FROM RAS_STORAGE"); + generateException(); + } + + if (domainid1ind) + { + _supportsTileConfiguration = false; + //((DBMinterval)*tileConfiguration) = StorageLayout::DefaultTileConfiguration; + *tileConfiguration = StorageLayout::DefaultTileConfiguration; + } + else + { + _supportsTileConfiguration = true; + tileConfiguration = OId(domainid1, OId::DBMINTERVALOID); + } + + if (indexsize1ind) + { + _supportsIndexSize = false; + indexSize = StorageLayout::DefaultIndexSize; + } + else + { + _supportsIndexSize = true; + indexSize = indexsize1; + } + + if (tilesize1ind) + { + _supportsTileSize = false; + tileSize = StorageLayout::DefaultTileSize; + } + else + { + _supportsTileSize = true; + tileSize = tilesize1; + } + + if (pctmin1ind) + { + _supportsPCTMin = false; + pctMin = StorageLayout::DefaultMinimalTileSize; + } + else + { + _supportsPCTMin = true; + pctMin = pctmin1; + } + + if (pctmax1ind) + { + _supportsPCTMax = false; + pctMax = StorageLayout::DefaultPCTMax; + } + else + { + _supportsPCTMax = true; + pctMax = pctmax1; + } + + if (indextype1ind) + { + _supportsIndexType = false; + indexType = StorageLayout::DefaultIndexType; + } + else + { + _supportsIndexType = true; + indexType = (r_Index_Type)indextype1; + } + + if (tilingscheme1ind) + { + _supportsTiling = false; + tilingScheme = StorageLayout::DefaultTilingScheme; + } + else + { + _supportsTiling = true; + tilingScheme = (r_Tiling_Scheme)tilingscheme1; + } + + if (dataformat1ind) + { + _supportsDataFormat = false; + dataFormat = StorageLayout::DefaultDataFormat; + } + else + { + _supportsDataFormat = true; + dataFormat = (r_Data_Format)dataformat1; + } + + DBObject::readFromDb(); + RMDBGEXIT(5, RMDebug::module_storageif, "DBStorageLayout", "readFromDb() " << myOId); +} + +void +DBStorageLayout::updateInDb() throw(r_Error) +{ + deleteFromDb(); + insertInDb(); + DBObject::updateInDb(); +} + +void +DBStorageLayout::insertInDb() throw(r_Error) +{ + RMDBGENTER(5, RMDebug::module_storageif, "DBStorageLayout", "insertInDb() " << myOId); + EXEC SQL BEGIN DECLARE SECTION; + long storageid2; + long domainid2; + short domainid2ind; + long tilesize2; + short tilesize2ind; + long pctmin2; + short pctmin2ind; + long pctmax2; + short pctmax2ind; + long indexsize2; + short indexsize2ind; + short indextype2; + short indextype2ind; + short tilingscheme2; + short tilingscheme2ind; + short dataformat2; + short dataformat2ind; + EXEC SQL END DECLARE SECTION; + + storageid2 = myOId.getCounter(); + + if (supportsTileConfiguration()) + { + domainid2ind = 0; + tileConfiguration->setPersistent(true); + domainid2 = tileConfiguration->getOId().getCounter(); + } + else + { + domainid2ind = -1; + } + + if (supportsTileSize()) + { + tilesize2ind = 0; + tilesize2 = tileSize; + } + else + { + tilesize2ind = -1; + } + + if (supportsIndexSize()) + { + indexsize2ind = 0; + indexsize2 = indexSize; + } + else + { + indexsize2ind = -1; + } + + if (supportsPCTMin()) + { + pctmin2ind = 0; + pctmin2 = pctMin; + } + else + { + pctmin2ind = -1; + } + + if (supportsPCTMax()) + { + pctmax2ind = 0; + pctmax2 = pctMax; + } + else + { + pctmax2ind = -1; + } + + if (supportsIndexType()) + { + indextype2ind = 0; + indextype2 = indexType; + } + else + { + indextype2ind = -1; + } + + if (supportsTilingScheme()) + { + tilingscheme2ind = 0; + tilingscheme2 = tilingScheme; + } + else + { + tilingscheme2ind = -1; + } + + if (supportsDataFormat()) + { + dataformat2ind = 0; + dataformat2 = dataFormat; + } + else + { + dataformat2ind = -1; + } + + EXEC SQL INSERT + INTO + RAS_STORAGE + ( + StorageId, + DomainId, + TileSize, + PCTMin, + PCTMax, + IndexType, + TilingScheme, + DataFormat, + IndexSize + ) + VALUES ( + :storageid2, + :domainid2 INDICATOR :domainid2ind, + :tilesize2 INDICATOR :tilesize2ind, + :pctmin2 INDICATOR :pctmin2ind, + :pctmax2 INDICATOR :pctmax2ind, + :indextype2 INDICATOR :indextype2ind, + :tilingscheme2 INDICATOR :tilingscheme2ind, + :dataformat2 INDICATOR :dataformat2ind, + :indexsize2 INDICATOR :indexsize2ind + ); + if (SQLCODE != SQLOK) + { + check("DBStorageLayout::insertInDb() INSERT INTO RAS_STORAGE"); + generateException(); + } + + DBObject::insertInDb(); + + RMDBGEXIT(5, RMDebug::module_storageif, "DBStorageLayout", "insertInDb() " << myOId); +} + +void +DBStorageLayout::deleteFromDb() throw(r_Error) +{ + RMDBGENTER(5, RMDebug::module_storageif, "DBStorageLayout", "deleteFrom() " << myOId); + EXEC SQL BEGIN DECLARE SECTION; + long storageid3; + EXEC SQL END DECLARE SECTION; + + storageid3 = myOId.getCounter(); + + EXEC SQL DELETE FROM RAS_STORAGE WHERE StorageId = :storageid3; + if (SQLCODE != SQLOK) + { + check("DBStorageLayout::deleteFrom() DELETE FROM RAS_STORAGE"); + generateException(); + } + + tileConfiguration->setPersistent(false); + DBObject::deleteFromDb(); + + RMDBGEXIT(5, RMDebug::module_storageif, "DBStorageLayout", "deleteFrom() " << myOId); +} |