diff options
Diffstat (limited to 'qlparser/qtcondense.cc')
-rw-r--r-- | qlparser/qtcondense.cc | 801 |
1 files changed, 801 insertions, 0 deletions
diff --git a/qlparser/qtcondense.cc b/qlparser/qtcondense.cc new file mode 100644 index 0000000..7a17b93 --- /dev/null +++ b/qlparser/qtcondense.cc @@ -0,0 +1,801 @@ +/* +* 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: + * + * + * COMMENTS: + * + ************************************************************/ + +static const char rcsid[] = "@(#)qlparser, QtCondense: $Header: /home/rasdev/CVS-repository/rasdaman/qlparser/qtcondense.cc,v 1.47 2005/09/03 20:17:55 rasdev Exp $"; + +#include "raslib/rmdebug.hh" +#include "debug.hh" + +#include "qlparser/qtcondense.hh" +#include "qlparser/qtmdd.hh" +#include "qlparser/qtatomicdata.hh" +#include "qlparser/qtscalardata.hh" +#include "qlparser/qtcomplexdata.hh" +#include "qlparser/qtbinaryinduce.hh" +#include "qlparser/qtbinaryinduce2.hh" + +#include "mddmgr/mddobj.hh" + +#include "catalogmgr/typefactory.hh" +#include "catalogmgr/ops.hh" + +#include <iostream> +#ifndef CPPSTDLIB +#include <ospace/string.h> // STL<ToolKit> +#else +#include <string> +using namespace std; +#endif + +const QtNode::QtNodeType QtCondense::nodeType = QtNode::QT_CONDENSE; + +QtCondense::QtCondense( Ops::OpType newOpType ) + : QtUnaryOperation(), opType( newOpType ) +{ +} + + + +QtCondense::QtCondense( Ops::OpType newOpType, QtOperation* initInput ) + : QtUnaryOperation( initInput ), opType( newOpType ) +{ +} + + +QtNode::QtAreaType +QtCondense::getAreaType() +{ + return QT_AREA_SCALAR; +} + + + +void +QtCondense::optimizeLoad( QtTrimList* trimList ) +{ + // reset trimList because optimization enters a new MDD area + + // delete list + // release( trimList->begin(), trimList->end() ); + vector<QtNode::QtTrimElement*>::iterator iter; + for( iter=trimList->begin(); iter!=trimList->end(); iter++ ) + { + delete *iter; + *iter=NULL; + } + + delete trimList; + trimList=NULL; + + if( input ) + input->optimizeLoad( new QtNode::QtTrimList ); +} + + + +QtData* +QtCondense::computeFullCondense( QtDataList* inputList, r_Minterval& areaOp ) +{ + RMDBCLASS( "QtCondense", "computeFullCondense( QtDataList*, r_Minterval& )", "qlparser", __FILE__, __LINE__ ) + + QtScalarData* returnValue = NULL; + + // get the operand + QtData* operand = input->evaluate( inputList ); + + if( operand ) + { + +#ifdef QT_RUNTIME_TYPE_CHECK + if( operand->getDataType() != QT_MDD ) + { + RMInit::logOut << "Internal error in QtCountCells::computeFullCondense() - " + << "runtime type checking failed (MDD)." << endl; + + // delete old operand + if( operand ) operand->deleteRef(); + + return 0; + } +#endif + + QtMDD* mdd = (QtMDD*)operand; + +#ifdef QT_RUNTIME_TYPE_CHECK + if( opType == Ops::OP_SOME || opType == Ops::OP_ALL || opType == Ops::OP_COUNT ) + { + if( mdd->getCellType()->getType() != BOOLTYPE ) + { + RMInit::logOut << "Internal error in QtCondense::computeFullCondense() - " + << "runtime type checking failed (BOOL)." << endl; + + // delete old operand + if( operand ) operand->deleteRef(); + + return 0; + } + } +#endif + + // get result type + const BaseType* resultType = Ops::getResultType( opType, mdd->getCellType() ); + + // get the MDD object + MDDObj* op = ((QtMDD*)operand)->getMDDObject(); + + // get the area, where the operation has to be applied + areaOp = mdd->getLoadDomain(); + +TALK( "computeFullCondense-last-good\n" ); + // get all tiles in relevant area + vector<Tile*>* allTiles = op->intersect(areaOp); + +TALK( "computeFullCondense-8\n" ); + // get new operation object + CondenseOp* condOp = Ops::getCondenseOp( opType, resultType, mdd->getCellType() ); + +TALK( "computeFullCondense-9\n" ); + // and iterate over them + for( vector<Tile*>::iterator tileIt = allTiles->begin(); + tileIt!=allTiles->end(); tileIt++ ) + { + // domain of the actual tile + r_Minterval tileDom = (*tileIt)->getDomain(); + + // domain of the relevant area of the actual tile + r_Minterval intersectDom = tileDom.create_intersection( areaOp ); + + (*tileIt)->execCondenseOp( condOp, intersectDom ); + } + + // delete tile vector + delete allTiles; + allTiles=NULL; + +TALK( "computeFullCondense-a\n" ); + // create result object + if( resultType->getType() == STRUCT ) + returnValue = new QtComplexData(); + else + returnValue = new QtAtomicData(); + +TALK( "computeFullCondense-b\n" ); + // allocate buffer for the result + char* resultBuffer = new char[resultType->getSize()]; + memcpy( (void*)resultBuffer, (void*)condOp->getAccuVal(), (size_t)resultType->getSize() ); + +TALK( "computeFullCondense-c\n" ); + returnValue->setValueType ( resultType ); + returnValue->setValueBuffer( resultBuffer ); + +TALK( "computeFullCondense-d\n" ); + // delete operation object + delete condOp; + condOp=NULL; + +TALK( "computeFullCondense-e\n" ); + // delete old operand + if( operand ) operand->deleteRef(); + } + +RMDBGIF(3, RMDebug::module_qlparser, "QtCondense", \ + RMInit::dbgOut << endl << "opType of QtCondense::computeFullCondense(): " << opType << endl; \ + RMInit::dbgOut << "Result.....................................: " << flush; \ + returnValue->printStatus( RMInit::dbgOut ); \ + RMInit::dbgOut << endl; ) + return returnValue; +} + + + +const QtTypeElement& +QtCondense::checkType( QtTypeTuple* typeTuple ) +{ + RMDBCLASS( "QtCondense", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ ) + + dataStreamType.setDataType( QT_TYPE_UNKNOWN ); + + // check operand branches + if( input ) + { + + // get input types + const QtTypeElement& inputType = input->checkType( typeTuple ); + +RMDBGIF(3, RMDebug::module_qlparser, "QtCondense", \ + RMInit::dbgOut << "Class..: " << getClassName() << endl; \ + RMInit::dbgOut << "Operand: " << flush; \ + inputType.printStatus( RMInit::dbgOut ); \ + RMInit::dbgOut << endl; ) + + if( inputType.getDataType() != QT_MDD ) + { + RMInit::logOut << "Error: QtCondense::evaluate() - operand must be multidimensional." << endl; + parseInfo.setErrorNo(353); + throw parseInfo; + } + + const BaseType* baseType = ((const MDDBaseType*)(inputType.getType()))->getBaseType(); + + if( opType == Ops::OP_SOME || opType == Ops::OP_ALL ) + { + if( baseType->getType() != BOOLTYPE ) + { + RMInit::logOut << "Error: QtCondense::evaluate() - operand of quantifiers must be of type r_Marray<d_Boolean>." << endl; + parseInfo.setErrorNo(354); + throw parseInfo; + } + } + + if( opType == Ops::OP_COUNT ) + { + if( baseType->getType() != BOOLTYPE ) + { + RMInit::logOut << "Error: QtCondense::evaluate() - operand of count_cells must be of type r_Marray<d_Boolean>." << endl; + parseInfo.setErrorNo(415); + throw parseInfo; + } + } + + const BaseType* resultType = Ops::getResultType( opType, baseType ); + + if( getNodeType() == QT_AVGCELLS ) + { + // consider division by the number of cells + + const BaseType* DoubleType = TypeFactory::mapType("Double"); + const BaseType* finalResultType = Ops::getResultType( Ops::OP_DIV, resultType, DoubleType ); + + resultType = finalResultType; + } + + dataStreamType.setType( resultType ); + } + else + RMInit::logOut << "Error: QtCondense::checkType() - operand branch invalid." << endl; + + return dataStreamType; +} + + +void +QtCondense::printTree( int tab, ostream& s, QtChildType mode ) +{ + s << SPACE_STR(tab).c_str() << getClassName() << " object" << endl; + + QtUnaryOperation::printTree( tab, s, mode ); +} + + + +void +QtCondense::printAlgebraicExpression( ostream& s ) +{ + s << getAlgebraicName() << "("; + + if( input ) + input->printAlgebraicExpression( s ); + else + s << "<nn>"; + + s << ")"; +} + + + +const QtNode::QtNodeType QtSome::nodeType = QtNode::QT_SOME; + + +QtSome::QtSome() + : QtCondense( Ops::OP_SOME ) +{ +} + + +QtSome::QtSome( QtOperation* inputNew ) + : QtCondense( Ops::OP_SOME, inputNew ) +{ +} + +/* +void +QtSome::rewriteOps() +{ + if( input ) + { + if( input->getNodeType() == QtNode::QT_OR ) + { + // pushdown of condenser expression + + QtOr* orNode = (QtOr*) input; + QtOperation* node1 = orNode->getInput1(); + QtOperation* node2 = orNode->getInput2(); + + if( node1 && node2 && + node1->getAreaType() == QtNode::QT_AREA_MDD && + node2->getAreaType() == QtNode::QT_AREA_MDD ) + { + RMInit::logOut << "> rule (pushdown condenser): SOME_CELLS(A OR B) -> SOME_CELLS(A) OR SOME_CELLS(B)" << endl; + + QtSome* newNode = new QtSome( node1 ); + setInput( node2 ); + newNode->setDataStreamType( QtTypeElement(QT_BOOL) ); + + this->getParent()->setInput( this, orNode ); + orNode->setInput1( newNode ); + orNode->setInput2( this ); + orNode->setDataStreamType( QtTypeElement(QT_BOOL) ); + + newNode->rewriteOps(); + } + }; + + input->rewriteOps(); + } + else + RMInit::logOut << "Error: QtSome::rewriteOps() - the operand branch is invalid." << endl; +} +*/ + +QtData* +QtSome::evaluate( QtDataList* inputList ) +{ + RMDBCLASS( "QtSome", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ ) + + QtData* returnValue = NULL; + r_ULong dummy=0; // needed for conversion to and from CULong + + // get the operand + QtData* operand = input->evaluate( inputList ); + + if( operand ) + { +#ifdef QT_RUNTIME_TYPE_CHECK + if( operand->getDataType() != QT_MDD ) + { + RMInit::logOut << "Internal error in QtSome::evaluate() - " + << "runtime type checking failed (MDD)." << endl; + + // delete old operand + if( operand ) operand->deleteRef(); + + return 0; + } +#endif + + QtMDD* mdd = (QtMDD*)operand; + + // get result type + BaseType* resultType = (BaseType*)dataStreamType.getType(); + +#ifdef QT_RUNTIME_TYPE_CHECK + if( mdd->getCellType()->getType() != BOOLTYPE ) + RMInit::logOut << "Internal error in QtSome::evaluate() - " + << "runtime type checking failed (BOOL)." << endl; + + // delete old operand + if( operand ) operand->deleteRef(); + + return 0; + } +#endif + + // get the MDD object + MDDObj* op = mdd->getMDDObject(); + + // get the area, where the operation has to be applied + r_Minterval areaOp = mdd->getLoadDomain(); + + // get all tiles in relevant area + vector<Tile*>* allTiles = op->intersect(areaOp); + + // allocate buffer for the result + unsigned int typeSize = resultType->getSize(); + char* resultBuffer = new char[typeSize]; + + // initialize result buffer with false + dummy = 0; + resultType->makeFromCULong( resultBuffer, &dummy ); + CondenseOp* condOp = Ops::getCondenseOp(Ops::OP_SOME, resultType, resultBuffer, resultType, 0, 0); + + // and iterate over them + for( vector<Tile*>::iterator tileIt = allTiles->begin(); tileIt != allTiles->end() && !dummy ; tileIt++ ) + { + // domain of the actual tile + r_Minterval tileDom = (*tileIt)->getDomain(); + + // domain of the relevant area of the actual tile + r_Minterval intersectDom = tileDom.create_intersection( areaOp ); + (*tileIt)->execCondenseOp( condOp, intersectDom ); + resultType->convertToCULong( condOp->getAccuVal(), &dummy ); + } + + delete condOp; + condOp = NULL; + // delete tile vector + delete allTiles; + allTiles=NULL; + + // create QtAtomicData object for the result + returnValue = new QtAtomicData( (bool)(dummy) ); + + // delete result buffer + delete[] resultBuffer; + resultBuffer = NULL; + + // The following is now then when deleting the last reference to the operand. + // delete the obsolete MDD object + // delete op; + + // delete old operand + if( operand ) operand->deleteRef(); + } + + return returnValue; +} + + + +const QtAll::QtNodeType QtAll::nodeType = QtNode::QT_ALL; + + +QtAll::QtAll() + : QtCondense( Ops::OP_ALL ) +{ +} + + +QtAll::QtAll( QtOperation* inputNew ) + : QtCondense( Ops::OP_ALL, inputNew ) +{ +} + +/* +void +QtAll::rewriteOps() +{ + if( input ) + { + if( input->getNodeType() == QtNode::QT_AND ) + { + // pushdown of condenser expression + + QtAnd* andNode = (QtAnd*) input; + QtOperation* node1 = andNode->getInput1(); + QtOperation* node2 = andNode->getInput2(); + + if( node1 && node2 && + node1->getAreaType() == QtNode::QT_AREA_MDD && + node2->getAreaType() == QtNode::QT_AREA_MDD ) + { + RMInit::logOut << "> rule (pushdown condenser): ALL_CELLS(A AND B) -> ALL_CELLS(A) AND ALL_CELLS(B)" << endl; + + QtAll* newNode = new QtAll( node1 ); + setInput( node2 ); + newNode->setDataStreamType( QtTypeElement(QT_BOOL) ); + + this->getParent()->setInput( this, andNode ); + andNode->setInput1( newNode ); + andNode->setInput2( this ); + andNode->setDataStreamType( QtTypeElement(QT_BOOL) ); + + newNode->rewriteOps(); + } + }; + + input->rewriteOps(); + + } + else + RMInit::logOut << "Error: QtAll::rewriteOps() - the operand branch is invalid." << endl; +} +*/ + +QtData* +QtAll::evaluate( QtDataList* inputList ) +{ + RMDBCLASS( "QtAll", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ ) + + QtData* returnValue = NULL; + r_ULong dummy=0; // needed for conversion to and from CULong + + // get the operand + QtData* operand = input->evaluate( inputList ); + + if( operand ) + { + +#ifdef QT_RUNTIME_TYPE_CHECK + if( operand->getDataType() != QT_MDD ) + { + RMInit::logOut << "Internal error in QtAll::evaluate() - " + << "runtime type checking failed (MDD)." << endl; + + // delete old operand + if( operand ) operand->deleteRef(); + + return 0; + } +#endif + + QtMDD* mdd = (QtMDD*)operand; + + // get result type + const BaseType* resultType = (BaseType*)dataStreamType.getType(); + +#ifdef QT_RUNTIME_TYPE_CHECK + if( mdd->getCellType()->getType() != BOOLTYPE ) + RMInit::logOut << "Internal error in QtAll::evaluate() - " + << "runtime type checking failed (BOOL)." << endl; + + // delete old operand + if( operand ) operand->deleteRef(); + + return 0; + } +#endif + + // get the MDD object + MDDObj* op = ((QtMDD*)operand)->getMDDObject(); + + // get the area, where the operation has to be applied + r_Minterval areaOp = mdd->getLoadDomain(); + + // get all tiles in relevant area + vector<Tile*>* allTiles = op->intersect(areaOp); + + // allocate buffer for the result + unsigned int tempTypeSize = resultType->getSize(); + char* resultBuffer = new char[tempTypeSize]; + + // initialize result buffer with true + dummy = 1; + resultType->makeFromCULong( resultBuffer, &dummy ); + CondenseOp* condOp = Ops::getCondenseOp(Ops::OP_ALL, resultType, resultBuffer, resultType, 0, 0); + + for( std::vector<Tile*>::iterator tileIt = allTiles->begin(); tileIt!=allTiles->end() && dummy; tileIt++ ) + { + // domain of the actual tile + r_Minterval tileDom = (*tileIt)->getDomain(); + + // domain of the relevant area of the actual tile + r_Minterval intersectDom = tileDom.create_intersection( areaOp ); + + (*tileIt)->execCondenseOp( condOp, intersectDom ); + resultType->convertToCULong( condOp->getAccuVal(), &dummy ); + } + delete condOp; + condOp = NULL; + // delete tile vector + delete allTiles; + allTiles=NULL; + + // create QtBoolData object for the result + returnValue = new QtAtomicData( (bool)(dummy) ); + + // delete result buffer done in delete CondOp + delete[] resultBuffer; + resultBuffer=NULL; + + // delete old operand + if( operand ) operand->deleteRef(); + } + + return returnValue; +} + + + +const QtCountCells::QtNodeType QtCountCells::nodeType = QtNode::QT_COUNTCELLS; + + +QtCountCells::QtCountCells() + : QtCondense( Ops::OP_COUNT ) +{ +} + + +QtCountCells::QtCountCells( QtOperation* inputNew ) + : QtCondense( Ops::OP_COUNT, inputNew ) +{ +} + + +QtData* +QtCountCells::evaluate( QtDataList* inputList ) +{ + RMDBCLASS( "QtCountCells", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ ) +r_Minterval dummyint; + QtData* returnValue = QtCondense::computeFullCondense( inputList, dummyint ); + + return returnValue; +} + + + +const QtAddCells::QtNodeType QtAddCells::nodeType = QtNode::QT_ADDCELLS; + + +QtAddCells::QtAddCells() + : QtCondense( Ops::OP_SUM ) +{ +} + + +QtAddCells::QtAddCells( QtOperation* inputNew ) + : QtCondense( Ops::OP_SUM, inputNew ) +{ +} + + +QtData* +QtAddCells::evaluate( QtDataList* inputList ) +{ + RMDBCLASS( "QtAddCells", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ ) +r_Minterval dummyint; + + QtData* returnValue = QtCondense::computeFullCondense( inputList, dummyint ); + + return returnValue; +} + + + +const QtAvgCells::QtNodeType QtAvgCells::nodeType = QtNode::QT_AVGCELLS; + + +QtAvgCells::QtAvgCells() + : QtCondense( Ops::OP_SUM ) +{ +} + + +QtAvgCells::QtAvgCells( QtOperation* inputNew ) + : QtCondense( Ops::OP_SUM, inputNew ) +{ +} + + +QtData* +QtAvgCells::evaluate( QtDataList* inputList ) +{ + RMDBCLASS( "QtAvgCells", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ ) + + // domain for condensing operation + r_Minterval areaOp; + + QtData* dataCond = QtCondense::computeFullCondense( inputList, areaOp ); + + // + // divide by the number of cells + // + + QtScalarData* scalarDataResult = NULL; + QtScalarData* scalarDataCond = (QtScalarData*)dataCond; + BaseType* resultType = (BaseType*)dataStreamType.getType(); + + + // allocate memory for the result + char* resultBuffer = new char[ resultType->getSize() ]; + + // allocate ulong constant with number of cells + r_ULong constValue = areaOp.cell_count(); + const BaseType* constType = TypeFactory::mapType("ULong"); + char* constBuffer = new char[ constType->getSize() ]; + + constType->makeFromCULong( constBuffer, &constValue ); + +RMDBGIF(3, RMDebug::module_qlparser, "QtCondense", \ + RMInit::dbgOut << "Number of cells....: " << flush; \ + constType->printCell( RMInit::dbgOut, constBuffer ); \ + RMInit::dbgOut << endl; ) + + Ops::execBinaryConstOp( Ops::OP_DIV, resultType, + scalarDataCond->getValueType(), constType, + resultBuffer, + scalarDataCond->getValueBuffer(), constBuffer ); + + delete[] constBuffer; + constBuffer=NULL; + delete dataCond; + dataCond=NULL; + + if( resultType->getType() == STRUCT ) + scalarDataResult = new QtComplexData(); + else + scalarDataResult = new QtAtomicData(); + + scalarDataResult->setValueType ( resultType ); + scalarDataResult->setValueBuffer( resultBuffer ); + +RMDBGIF(3, RMDebug::module_qlparser, "QtCondense", \ + RMInit::dbgOut << endl << "Result.............: " << flush; \ + scalarDataResult->printStatus( RMInit::dbgOut ); \ + RMInit::dbgOut << endl; ) + + return scalarDataResult; +} + + +const QtMinCells::QtNodeType QtMinCells::nodeType = QtNode::QT_MINCELLS; + + +QtMinCells::QtMinCells() + : QtCondense( Ops::OP_MIN ) +{ +} + + +QtMinCells::QtMinCells( QtOperation* inputNew ) + : QtCondense( Ops::OP_MIN, inputNew ) +{ +} + + +QtData* +QtMinCells::evaluate( QtDataList* inputList ) +{ + RMDBCLASS( "QtMinCells", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ ) +r_Minterval dummyint; + + QtData* returnValue = QtCondense::computeFullCondense( inputList, dummyint ); + + return returnValue; +} + + + +const QtMaxCells::QtNodeType QtMaxCells::nodeType = QtNode::QT_MAXCELLS; + + +QtMaxCells::QtMaxCells() + : QtCondense( Ops::OP_MAX ) +{ +} + + +QtMaxCells::QtMaxCells( QtOperation* inputNew ) + : QtCondense( Ops::OP_MAX, inputNew ) +{ +} + + +QtData* +QtMaxCells::evaluate( QtDataList* inputList ) +{ + RMDBCLASS( "QtMaxCells", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ ) +r_Minterval dummyint; + + QtData* returnValue = QtCondense::computeFullCondense( inputList, dummyint ); + + return returnValue; +} |