Tiling & Indexing options added to rasql grammar

1 files changed, 477 insertions, 281 deletions

diff --git a/qlparser/qtinsert.cc b/qlparser/qtinsert.cc
index bfcfbc5..f024def 100644
--- a/qlparser/qtinsert.cc
+++ b/qlparser/qtinsert.cc
@@ -1,332 +1,339 @@
-/*
-* 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>.
-*/
 /*************************************************************
  *
+ * Copyright (C) 2003 Dr. Peter Baumann
  *
- * PURPOSE:
+ * SOURCE: qtinsert.cc
  *
+ * MODULE: qlparser
+ * CLASS:  QtInsert
  *
+ * PURPOSE:
+ *
+ * CHANGE HISTORY (append further entries):
+ * when         who         what
+ * ----------------------------------------------------------
+ * 17-01-98     Ritsch      created
+ * 2003-aug-25  PB          "insert into" type compatibility bug fixed (from K.Hahn)
+ * 2008-nov-10  Shams       added storagelayout to the expression
  * COMMENTS:
  *
  ************************************************************/
 
+
+
+#include <vector>
+#include "raslib/dlist.hh"
+//#include "rasodmg/stattiling.hh"
+#include "rasodmg/interesttiling.hh"
+#include "rasodmg/dirdecompose.hh"
+
+
 static const char rcsid[] = "@(#)qlparser, QtInsert: $Header: /home/rasdev/CVS-repository/rasdaman/qlparser/qtinsert.cc,v 1.27 2003/12/27 20:40:21 rasdev Exp $";
 
 #include "qlparser/qtinsert.hh"
 #include "qlparser/qtdata.hh"
 #include "qlparser/qtmdd.hh"
 
-#include "tilemgr/tile.hh"
 #include "mddmgr/mddcoll.hh"
 #include "mddmgr/mddobj.hh"
 
 #include <iostream>
+#include <exception>
 
 #include "servercomm/servercomm.hh"
+#include "qlparser/qtmintervaldata.hh"
+#include "raslib/basetype.hh"
+#include "raslib/collectiontype.hh"
 
 extern ServerComm::ClientTblElt* currentClientTblElt;
 
 const QtNode::QtNodeType QtInsert::nodeType = QtNode::QT_INSERT;
 
-
-QtInsert::QtInsert( const std::string& initCollectionName, QtOperation* initSource )
-  : QtExecute(), collectionName( initCollectionName ), source( initSource )
-{
-  source->setParent( this );
+QtInsert::QtInsert(const std::string& initCollectionName, QtOperation* initSource)
+: QtExecute(), collectionName(initCollectionName), source(initSource) {
+    source->setParent(this);
+    stgLayout = NULL;
 }
 
-
-
-QtInsert::~QtInsert()
-{
-  if( source )
-  {
-    delete source;
-    source=NULL;
-  }
+QtInsert::QtInsert(const std::string& initCollectionName, QtOperation* initSource, QtOperation* storage)
+: QtExecute(), collectionName(initCollectionName), source(initSource), stgLayout(storage) {
+    source->setParent(this);
 }
 
-
-
-int
-QtInsert::evaluate()
-{
-  RMDBCLASS( "QtInsert", "evaluate()", "qlparser", __FILE__, __LINE__ )
-
-  // empty data list for evaluation of insert expression including constant
-  QtNode::QtDataList* nextTupel = new QtNode::QtDataList(0);
-
-  // get the operands
-  QtData* sourceData = source->evaluate( nextTupel );
-
-  if( sourceData )
-  {
-    QtMDD*  sourceMDD = (QtMDD*) sourceData;
-    MDDObj* sourceObj = sourceMDD->getMDDObject();
-
-    MDDColl* persColl = NULL;
-    MDDColl* almost = NULL;
-
-    try
-    {
-      almost = MDDColl::getMDDCollection( collectionName.c_str() );
+QtInsert::~QtInsert() {
+    if (source) {
+        delete source;
+        source = NULL;
     }
-    catch(...)
-    {
-      
-      RMInit::logOut << "Error: QtInsert::evaluate() - collection name not found" << std::endl;
-
-      // delete the operand
-      if( sourceData ) sourceData->deleteRef();
+    if (stgLayout) {
+        delete stgLayout;
+        stgLayout = NULL;
+    }
+}
 
-      parseInfo.setErrorNo(355);
-      throw parseInfo;
+int
+QtInsert::evaluate() {
+    RMDBCLASS("QtInsert", "evaluate()", "qlparser", __FILE__, __LINE__)
+    QtMddCfgOp* configOp = NULL;
+    QtMDDConfig* mddConfig = NULL;
+    // empty data list for evaluation of insert expression including constant
+    QtNode::QtDataList* nextTupel = new QtNode::QtDataList(0);
+    if (stgLayout) {
+        configOp = (QtMddCfgOp*) stgLayout;
+        mddConfig = configOp->getMddConfig();
     }
-if (!almost->isPersistent())
-	{
-	RMInit::logOut << "QtInsert: User tries to insert into system table" << std::endl;
-      if( sourceData ) sourceData->deleteRef();
-
-      parseInfo.setErrorNo(355);
-      throw parseInfo;
-	}
-else	{
-	persColl = (MDDColl*)almost;
-	}
-
-    //
-    // check MDD and collection type for compatibility
-    //
-
-RMDBGIF(3, RMDebug::module_qlparser, "QtInsert", \
-      char* collTypeStructure = persColl->getCollectionType()->getTypeStructure(); \
-      char* mddTypeStructure  = sourceObj->getMDDBaseType()->getTypeStructure(); \
+    // get the operands
+    QtData* sourceData = source->evaluate(nextTupel);
+
+    if (sourceData) {
+        QtMDD* sourceMDD = (QtMDD*) sourceData;
+        MDDObj* sourceObj = sourceMDD->getMDDObject();
+
+        MDDColl* persColl = NULL;
+        MDDColl* almost = NULL;
+
+        try {
+            almost = MDDColl::getMDDCollection(collectionName.c_str());
+        } catch (...) {
+
+            RMInit::logOut << "Error: QtInsert::evaluate() - collection name not found" << std::endl;
+
+            // delete the operand
+            if (sourceData) sourceData->deleteRef();
+
+            parseInfo.setErrorNo(355);
+            throw parseInfo;
+        }
+        if (!almost->isPersistent()) {
+            RMInit::logOut << "QtInsert: User tries to insert into system table" << std::endl;
+            if (sourceData) sourceData->deleteRef();
+
+            parseInfo.setErrorNo(355);
+            throw parseInfo;
+        } else {
+            persColl = (MDDColl*) almost;
+        }
+
+        //
+        // check MDD and collection type for compatibility
+        //
+        int cellSize;
+        RMDBGIF(3, RMDebug::module_qlparser, "QtInsert",  \
+      char* collTypeStructure = persColl->getCollectionType()->getTypeStructure();  \
+      char* mddTypeStructure = sourceObj->getMDDBaseType()->getTypeStructure();  \
       RMInit::dbgOut << std::endl << "Collection type structure.: " << collTypeStructure << std::endl \
                              << "MDD type structure........: " << mddTypeStructure << std::endl \
-                             << "MDD domain................: " << sourceObj->getDefinitionDomain() << std::endl; \
-      free( collTypeStructure ); collTypeStructure=NULL; \
-      free( mddTypeStructure ); mddTypeStructure=NULL; )
-
-    // bug fix: "insert into" found claimed non-existing type mismatch -- PB 2003-aug-25, based on fix by K.Hahn
-    // if( !persColl->getCollectionType()->compatibleWith( (Type*) sourceObj->getMDDBaseType() ) )
-    if( !((MDDType*) sourceObj->getMDDBaseType())->compatibleWith( persColl->getCollectionType()->getMDDType() ) )
-    {
-      // free resources
-      persColl->releaseAll();
-      delete persColl;
-      persColl=NULL;
-      if( sourceData ) sourceData->deleteRef();   // delete the operand
-
-      // return error
-      RMInit::logOut << "Error: QtInsert::evaluate() - MDD and collection types are incompatible" << std::endl;
-      parseInfo.setErrorNo(959);
-      throw parseInfo;
-    }
-
-    if( !persColl->getCollectionType()->getMDDType()->compatibleWithDomain( &(sourceObj->getDefinitionDomain()) ) )
-    {
-      // free resources
-      persColl->releaseAll();
-      delete persColl;
-      persColl=NULL;
-      if( sourceData ) sourceData->deleteRef();   // delete the operand
-
-      // return error
-      RMInit::logOut << "Error: QtInsert::evaluate() - MDD and collection domains are incompatible" << std::endl;
-      parseInfo.setErrorNo(959);
-      throw parseInfo;
-    }
-
-    //
-    // convert a transient MDD object to a persistent one
-    //
-
-    // allocate a new oid within the current db
-    OId oid;
+                             << "MDD domain................: " << sourceObj->getDefinitionDomain() << std::endl;  \
+      free(collTypeStructure); collTypeStructure = NULL;  \
+      free(mddTypeStructure); mddTypeStructure = NULL;)
+      cellSize = (int)sourceObj->getMDDBaseType()->getBaseType()->getSize();
+                // bug fix: "insert into" found claimed non-existing type mismatch -- PB 2003-aug-25, based on fix by K.Hahn
+                // if( !persColl->getCollectionType()->compatibleWith( (Type*) sourceObj->getMDDBaseType() ) )
+        if (!((MDDType*) sourceObj->getMDDBaseType())->compatibleWith(persColl->getCollectionType()->getMDDType())) {
+            // free resources
+            persColl->releaseAll();
+            delete persColl;
+            persColl = NULL;
+            if (sourceData) sourceData->deleteRef(); // delete the operand
+
+            // return error
+            RMInit::logOut << "Error: QtInsert::evaluate() - MDD and collection types are incompatible" << std::endl;
+            parseInfo.setErrorNo(959);
+            throw parseInfo;
+        }
+
+        if (!persColl->getCollectionType()->getMDDType()->compatibleWithDomain(&(sourceObj->getDefinitionDomain()))) {
+            // free resources
+            persColl->releaseAll();
+            delete persColl;
+            persColl = NULL;
+            if (sourceData) sourceData->deleteRef(); // delete the operand
+
+            // return error
+            RMInit::logOut << "Error: QtInsert::evaluate() - MDD and collection domains are incompatible" << std::endl;
+            parseInfo.setErrorNo(959);
+            throw parseInfo;
+        }
+
+        //
+        // convert a transient MDD object to a persistent one
+        //
+
+        // allocate a new oid within the current db
+        OId oid;
 #ifdef BASEDB_O2
-    if( !OId::allocateMDDOId( &oid ) )
-    {
+        if (!OId::allocateMDDOId(&oid)) {
 #else
-    OId::allocateOId( oid, OId::MDDOID );
+        OId::allocateOId(oid, OId::MDDOID);
 #endif
-      // get all tiles
-      vector<Tile*>* sourceTiles = sourceObj->getTiles();
-
-      // get a persistent type pointer
-      MDDBaseType* persMDDType = (MDDBaseType*)TypeFactory::ensurePersistence( (Type*)sourceObj->getMDDBaseType() );
-
-      if( !persMDDType )
-      {
-        RMInit::logOut << "Error: QtInsert::evaluate() - type not persistent" << std::endl;
-
-        // delete dynamic data
-        if( sourceData ) sourceData->deleteRef();
-        delete sourceTiles;
-        sourceTiles=NULL;
-        delete nextTupel;
-        nextTupel=NULL;
-        persColl->releaseAll();
-        delete persColl;
-        persColl=NULL;
-        parseInfo.setErrorNo(964);
-        throw parseInfo;        
-      }
-
-      // create a persistent MDD object
-      // need a StorageLayout here
-      StorageLayout tempStorageLayout;
-      tempStorageLayout.setTileSize(StorageLayout::DefaultTileSize);
-      tempStorageLayout.setIndexType(StorageLayout::DefaultIndexType);
-      tempStorageLayout.setTilingScheme(StorageLayout::DefaultTilingScheme);
-      if (sourceObj->getDefinitionDomain().dimension() == 
-	  StorageLayout::DefaultTileConfiguration.dimension())
-	tempStorageLayout.setTileConfiguration(StorageLayout::DefaultTileConfiguration);
-      MDDObj*  persMDDObj = new MDDObj( persMDDType, sourceObj->getDefinitionDomain(), oid, 
-						tempStorageLayout );
-
-      // iterate over source tiles
-      for( vector<Tile*>::iterator sourceIt = sourceTiles->begin(); sourceIt != sourceTiles->end(); sourceIt++ )
-      {
-        // create a new persistent tile, copy the transient data, and insert it into the target mdd object
-        Tile* newPersTile = new Tile( (*sourceIt)->getDomain(), persMDDType->getBaseType(), (*sourceIt)->getDataFormat() );
-        newPersTile->copyTile( (*sourceIt)->getDomain(), *sourceIt, (*sourceIt)->getDomain() );
-        persMDDObj->insertTile( newPersTile );
-      }
-
-      // delete tile vector
-      delete sourceTiles;
-      sourceTiles=NULL;
-      persColl->insert( persMDDObj );
+            // get all tiles
+            vector<Tile*>* sourceTiles = sourceObj->getTiles();
+
+            // get a persistent type pointer
+            MDDBaseType* persMDDType = (MDDBaseType*) TypeFactory::ensurePersistence((Type*) sourceObj->getMDDBaseType());
+
+            if (!persMDDType) {
+                RMInit::logOut << "Error: QtInsert::evaluate() - type not persistent" << std::endl;
+
+                // delete dynamic data
+                if (sourceData) sourceData->deleteRef();
+                delete sourceTiles;
+                sourceTiles = NULL;
+                delete nextTupel;
+                nextTupel = NULL;
+                persColl->releaseAll();
+                delete persColl;
+                persColl = NULL;
+                parseInfo.setErrorNo(964);
+                throw parseInfo;
+            }
+
+            // create a persistent MDD object
+            // need a StorageLayout here
+            if(mddConfig!= NULL){
+            if(mddConfig->getBorderThreshold() < 0)
+                mddConfig->setBorderThreshold(r_Stat_Tiling::DEF_BORDER_THR);
+            }
+            r_Index_Type ri = getIndexType(mddConfig);
+            StorageLayout tempStorageLayout;
+            tempStorageLayout.setDataFormat(getDataFormat(mddConfig));
+            r_Tiling_Scheme scheme = getTilingScheme(mddConfig);
+            tempStorageLayout.setIndexType(ri);
+            tempStorageLayout.setTilingScheme(scheme);
+            // Base Information has been set
+            tempStorageLayout.setTileSize
+                    ((mddConfig != NULL && mddConfig->getTileSize() > 0) ? mddConfig->getTileSize() :
+                    StorageLayout::DefaultTileSize);
+            if(mddConfig!= NULL){
+                tempStorageLayout.setInterestThreshold(mddConfig->getInterestThreshold());
+                tempStorageLayout.setBorderThreshold(mddConfig->getBorderThreshold());
+                if(mddConfig->getDirDecomp() != NULL)
+                    tempStorageLayout.setDirDecomp(mddConfig->getDirDecomp());
+                vector<r_Minterval>intervals = getIntervals(mddConfig);
+                tempStorageLayout.setCellSize(cellSize);
+                if(mddConfig->getTilingType() == QtMDDConfig::r_DRLDECOMP_TLG){
+                    tempStorageLayout.resetSubTiling();
+                }
+                else if(mddConfig->getTilingType() == QtMDDConfig::r_DRLDECOMPSUBTILE_TLG){
+                    tempStorageLayout.setSubTiling();
+                }
+                if(intervals.size() > 0){
+                    tempStorageLayout.setBBoxes(intervals);
+                }
+            }
+
+            r_Minterval tileCfg = getTileConfig(mddConfig);
+
+            if (sourceObj->getDefinitionDomain().dimension() ==
+                    tileCfg.dimension()) {
+                tempStorageLayout.setTileConfiguration(tileCfg);
+            }
+            MDDObj* persMDDObj = new MDDObj(persMDDType, sourceObj->getDefinitionDomain(), oid,
+                    tempStorageLayout);
+
+            // iterate over source tiles
+            for (vector<Tile*>::iterator sourceIt = sourceTiles->begin(); sourceIt != sourceTiles->end(); sourceIt++) {
+                // create a new persistent tile, copy the transient data, and insert it into the target mdd object
+                Tile* newPersTile = new Tile((*sourceIt)->getDomain(), persMDDType->getBaseType(), (*sourceIt)->getDataFormat());
+                newPersTile->copyTile((*sourceIt)->getDomain(), *sourceIt, (*sourceIt)->getDomain());
+                persMDDObj->insertTile(newPersTile);
+            }
+
+            // delete tile vector
+            delete sourceTiles;
+            sourceTiles = NULL;
+            persColl->insert(persMDDObj);
+
 #ifdef BASEDB_O2
-    }
-    else
-    {
-      RMInit::logOut << "Error: QtInsert::evaluate() - allocation of oid failed" << std::endl;
-
-      // delete dynamic data
-      if( sourceData ) sourceData->deleteRef();
-      delete nextTupel;
-      nextTupel=NULL;
-      persColl->releaseAll();
-      delete persColl;
-      persColl=NULL;
-      parseInfo.setErrorNo(958);
-      throw parseInfo;
-    }
+        } else {
+            RMInit::logOut << "Error: QtInsert::evaluate() - allocation of oid failed" << std::endl;
+
+            // delete dynamic data
+            if (sourceData) sourceData->deleteRef();
+            delete nextTupel;
+            nextTupel = NULL;
+            persColl->releaseAll();
+            delete persColl;
+            persColl = NULL;
+            parseInfo.setErrorNo(958);
+            throw parseInfo;
+        }
 #else
 #endif
-    // free transient memory
-    persColl->releaseAll();
-    delete persColl;
-    persColl=NULL;
-  }
-  else
-    RMInit::logOut << "Error: QtInsert::evaluate() - insert data is invalid." << std::endl;
-
-  // delete source operand
-  if( sourceData ) sourceData->deleteRef();
-
-  // delete dummy tupel vector 
-  delete nextTupel;
-  nextTupel=NULL;
-
-  return 0;
-}
+        // free transient memory
+        persColl->releaseAll();
+        delete persColl;
+        persColl = NULL;
+    } else
+        RMInit::logOut << "Error: QtInsert::evaluate() - insert data is invalid." << std::endl;
+
+    // delete source operand
+    if (sourceData) sourceData->deleteRef();
 
+    // delete dummy tupel vector
+    delete nextTupel;
+    nextTupel = NULL;
 
+    return 0;
+}
 
 QtNode::QtNodeList*
-QtInsert::getChilds( QtChildType flag )
-{
-  QtNodeList* resultList=NULL;
+QtInsert::getChilds(QtChildType flag) {
+    QtNodeList* resultList = NULL;
 
     RMDBGENTER(0, RMDebug::module_qlparser, "QtInsert", "QtInsert::getChilds()")
 
-  if( source )
-  {
-    // allocate resultList
-    if( flag == QT_DIRECT_CHILDS );
-      resultList = new QtNodeList();
+    if (source) {
+        // allocate resultList
+        if (flag == QT_DIRECT_CHILDS);
+        resultList = new QtNodeList();
 
-    if( flag == QT_LEAF_NODES || flag == QT_ALL_NODES )
-      resultList = source->getChilds( flag );
+        if (flag == QT_LEAF_NODES || flag == QT_ALL_NODES)
+            resultList = source->getChilds(flag);
 
-    // add the nodes of the current level
-    if( flag == QT_DIRECT_CHILDS || flag == QT_ALL_NODES )
-      resultList->push_back( source );
-  }
-  else
-    resultList = new QtNodeList();
+        // add the nodes of the current level
+        if (flag == QT_DIRECT_CHILDS || flag == QT_ALL_NODES)
+            resultList->push_back(source);
+    } else
+        resultList = new QtNodeList();
 
 
     RMDBGEXIT(0, RMDebug::module_qlparser, "QtInsert", "QtInsert::getChilds()")
-  return resultList;
+    return resultList;
 }
 
+void
+QtInsert::printTree(int tab, std::ostream& s, QtChildType mode) {
+    s << SPACE_STR(tab).c_str() << "QtInsert Object" << std::endl;
 
+    if (mode != QtNode::QT_DIRECT_CHILDS) {
+        if (source) {
+            s << SPACE_STR(tab).c_str() << "source : " << std::endl;
+            source->printTree(tab + 2, s);
+        } else
+            s << SPACE_STR(tab).c_str() << "no source" << std::endl;
 
-void
-QtInsert::printTree( int tab, std::ostream& s, QtChildType mode )
-{
-  s << SPACE_STR(tab).c_str() << "QtInsert Object" << std::endl;
-
-  if( mode != QtNode::QT_DIRECT_CHILDS )
-  {
-    if( source )
-    {
-      s << SPACE_STR(tab).c_str() << "source : " << std::endl;
-      source->printTree( tab + 2, s );
+        s << std::endl;
     }
-    else
-      s << SPACE_STR(tab).c_str() << "no source" << std::endl;
-
-    s << std::endl;
-  }
 }
 
-
-
 void
-QtInsert::printAlgebraicExpression( std::ostream& s )
-{
-  s << "insert<";
+QtInsert::printAlgebraicExpression(std::ostream& s) {
+    s << "insert<";
 
-  if( source )
-    source->printAlgebraicExpression( s );
-  else
-    s << "<no source>";
+    if (source)
+        source->printAlgebraicExpression(s);
+    else
+        s << "<no source>";
 
-  s << ">";
+    s << ">";
 }
 
-
 QtOperation*
-QtInsert::getSource()
-{
-	return source;
+QtInsert::getSource() {
+    return source;
 }
 
-
 /*
 void
 QtInsert::preOptimize()
@@ -334,28 +341,217 @@ QtInsert::preOptimize()
   if( source )
     source->optimizeLoad( new QtNode::QtTrimList );
 }
-*/
+ */
 
 
 void
-QtInsert::checkType()
-{
-  RMDBCLASS( "QtInsert", "checkType()", "qlparser", __FILE__, __LINE__ )
+QtInsert::checkType() {
+    RMDBCLASS("QtInsert", "checkType()", "qlparser", __FILE__, __LINE__)
+
+            // check operand branches
+    if (source) {
+
+        // get input type
+        const QtTypeElement& inputType = source->checkType();
+
+        if (inputType.getDataType() != QT_MDD) {
+            RMInit::logOut << "Error: QtInsert::checkType() - insert expression must be of type r_Marray<T>" << std::endl;
+            parseInfo.setErrorNo(960);
+            throw parseInfo;
+        }
+    } else
+        RMInit::logOut << "Error: QtInsert::checkType() - operand branch invalid." << std::endl;
+}
 
-  // check operand branches
-  if( source )
-  {
-
-  // get input type
-  const QtTypeElement& inputType = source->checkType(); 
-
-  if( inputType.getDataType() != QT_MDD )
-  {
-    RMInit::logOut << "Error: QtInsert::checkType() - insert expression must be of type r_Marray<T>" << std::endl;
-    parseInfo.setErrorNo(960);
-    throw parseInfo;
-  }
-  }
-  else
-    RMInit::logOut << "Error: QtInsert::checkType() - operand branch invalid." << std::endl;
+r_Data_Format
+QtInsert::getDataFormat(QtMDDConfig* config) {
+    if (!config)
+        return StorageLayout::DefaultDataFormat;
+    int dataType = config->getStorageType();
+    switch (dataType) {
+        case QtMDDConfig::r_DEFAULT_STG :
+            return StorageLayout::DefaultDataFormat;
+        case QtMDDConfig::r_ARRAY_STG :
+            return r_Array;
+        case QtMDDConfig::r_AUTO_STG :
+            return r_Auto_Compression;
+        case QtMDDConfig::r_BMP_STG :
+            return r_BMP;
+        case QtMDDConfig::r_DEM_STG :
+            return r_DEM;
+        case QtMDDConfig::r_HDF_STG :
+            return r_HDF;
+            //        case QtMDDConfig::r_HDF5_STG://need review
+            //            return r_HDF;
+        case QtMDDConfig::r_JPEG_STG :
+            return r_JPEG;
+        case QtMDDConfig::r_NTF_STG :
+            return r_NTF;
+        case QtMDDConfig::r_PACKBITS_STG :
+            return r_Pack_Bits;
+        case QtMDDConfig::r_PNG_STG :
+            return r_PNG;
+        case QtMDDConfig::r_PPM_STG :
+            return r_PPM;
+        case QtMDDConfig::r_RLE_STG :
+            return r_RLE;
+        case QtMDDConfig::r_RLESEP_STG :
+            return r_Sep_RLE;
+        case QtMDDConfig::r_TIFF_STG :
+            return r_TIFF;
+        case QtMDDConfig::r_TOR_STG :
+            return r_TOR;
+        case QtMDDConfig::r_VFF_STG :
+            return r_VFF;
+        case QtMDDConfig::r_WLTCOIFLETINT_STG :
+            if (config->getWltValue() == 6)
+                return r_Wavelet_Coiflet6;
+            if (config->getWltValue() == 12)
+                return r_Wavelet_Coiflet12;
+            if (config->getWltValue() == 18)
+                return r_Wavelet_Coiflet18;
+            if (config->getWltValue() == 24)
+                return r_Wavelet_Coiflet24;
+            if (config->getWltValue() == 30)
+                return r_Wavelet_Coiflet30;
+            return StorageLayout::DefaultDataFormat; //may be null
+        case QtMDDConfig::r_WLTDAUBECHIES_STG :
+            return r_Wavelet_Daubechies;
+        case QtMDDConfig::r_WLTDAUBECHIESINT_STG :
+            if (config->getWltValue() == 6)
+                return r_Wavelet_Daub6;
+            if (config->getWltValue() == 8)
+                return r_Wavelet_Daub8;
+            if (config->getWltValue() == 10)
+                return r_Wavelet_Daub10;
+            if (config->getWltValue() == 12)
+                return r_Wavelet_Daub12;
+            if (config->getWltValue() == 14)
+                return r_Wavelet_Daub14;
+            if (config->getWltValue() == 16)
+                return r_Wavelet_Daub16;
+            if (config->getWltValue() == 18)
+                return r_Wavelet_Daub18;
+            if (config->getWltValue() == 20)
+                return r_Wavelet_Daub20;
+            return StorageLayout::DefaultDataFormat; //may be default
+        case QtMDDConfig::r_WLTHAAR_STG :
+            return r_Wavelet_Haar;
+        case QtMDDConfig::r_WLTLEASTINT_STG :
+            if (config->getWltValue() == 8)
+                return r_Wavelet_Least8;
+            if (config->getWltValue() == 10)
+                return r_Wavelet_Least10;
+            if (config->getWltValue() == 12)
+                return r_Wavelet_Least12;
+            if (config->getWltValue() == 14)
+                return r_Wavelet_Least14;
+            if (config->getWltValue() == 16)
+                return r_Wavelet_Least16;
+            if (config->getWltValue() == 18)
+                return r_Wavelet_Least18;
+            if (config->getWltValue() == 20)
+                return r_Wavelet_Least20;
+        case QtMDDConfig::r_WLTQHAAR_STG :
+            return r_Wavelet_QHaar;
+        case QtMDDConfig::r_ZLIB_STG :
+            return r_ZLib;
+        case QtMDDConfig::r_ZLIBSEP_STG :
+            return r_Sep_ZLib;
+        default:
+            return StorageLayout::DefaultDataFormat;
+    }
+
+}
+
+r_Index_Type
+QtInsert::getIndexType(QtMDDConfig* config) {
+    if (!config)
+        return StorageLayout::DefaultIndexType;
+    int indexType = config->getIndexType();
+
+    switch (indexType) {
+        case QtMDDConfig::r_A_INDEX :
+            return r_Auto_Index;
+        case QtMDDConfig::r_DEFAULT_INDEX :
+            return StorageLayout::DefaultIndexType;
+        case QtMDDConfig::r_D_INDEX :
+            return r_Directory_Index;
+        case QtMDDConfig::r_IT_INDEX :
+            return r_Index_Type_NUMBER;
+        case QtMDDConfig::r_RC_INDEX :
+            return r_Reg_Computed_Index;
+        case QtMDDConfig::r_RD_INDEX :
+            return r_Reg_Directory_Index;
+        case QtMDDConfig::r_RPT_INDEX :
+            return r_RPlus_Tree_Index;
+        case QtMDDConfig::r_RRPT_INDEX :
+            return r_Reg_RPlus_Tree_Index;
+        case QtMDDConfig::r_TC_INDEX :
+            return r_Tile_Container_Index;
+        default:
+            return StorageLayout::DefaultIndexType;
+    }
+}
+
+r_Tiling_Scheme
+QtInsert::getTilingScheme(QtMDDConfig* cfg) {
+    if (!cfg)
+        return StorageLayout::DefaultTilingScheme;
+    int tileType = cfg->getTilingType();
+    switch (tileType) {
+        case QtMDDConfig::r_ALIGNED_TLG :
+            return r_AlignedTiling;
+        case QtMDDConfig::r_AREAOFINTEREST_TLG :
+            return r_InterestTiling;
+        case QtMDDConfig::r_REGULAR_TLG :
+            return r_RegularTiling;
+        case QtMDDConfig::r_DRLDECOMPSUBTILE_TLG :
+            return r_DirectionalTiling;
+        case QtMDDConfig::r_DRLDECOMP_TLG :
+            return r_DirectionalTiling;
+        case QtMDDConfig::r_STATISTICSPARAM_TLG :
+            return r_StatisticalTiling;
+        case QtMDDConfig::r_STATISTICS_TLG :
+            return r_StatisticalTiling;
+
+        default:
+            return StorageLayout::DefaultTilingScheme;
+    }
+}
+
+vector<r_Minterval>
+QtInsert::getIntervals(QtMDDConfig* cfg) {
+    vector<r_Minterval> intervals;
+    if (!cfg)
+        return intervals;
+    QtNode::QtOperationList* oplist = cfg->getBboxList();
+    if (!oplist)
+        return intervals;
+    QtNode::QtDataList* nextTupel = new QtNode::QtDataList(0);
+    QtOperationList::iterator iter;
+    for (iter = oplist->begin(); iter != oplist->end(); iter++) {
+        QtData* data = (*iter)->evaluate(nextTupel);
+        QtMintervalData* intervalData = (QtMintervalData*) data;
+        r_Minterval interval = intervalData->getMintervalData();
+        intervals.push_back(interval);
+    }
+    return intervals;
+}
+
+r_Minterval
+QtInsert::getTileConfig(QtMDDConfig* cfg) {
+    r_Minterval tileConfig;
+    if (!cfg || !(cfg->getTilingType() == QtMDDConfig::r_ALIGNED_TLG ||
+    cfg->getTilingType() == QtMDDConfig::r_REGULAR_TLG))
+        return StorageLayout::DefaultTileConfiguration;
+
+    QtOperation* op = cfg->getTileCfg();
+    if (!op)
+        return tileConfig;
+    QtNode::QtDataList* nextTupel = new QtNode::QtDataList(0);
+    QtData* data = op->evaluate(nextTupel);
+    QtMintervalData* intervalData = (QtMintervalData*) data;
+    tileConfig = intervalData->getMintervalData();
+    return tileConfig;
 }