334 lines
8.3 KiB
C++
334 lines
8.3 KiB
C++
|
|
/*
|
|
----
|
|
This file is part of SECONDO.
|
|
|
|
Copyright (C) 2015,
|
|
Faculty of Mathematics and Computer Science,
|
|
Database Systems for New Applications.
|
|
|
|
SECONDO 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 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
SECONDO 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 SECONDO; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
----
|
|
|
|
|
|
//[$][\$]
|
|
|
|
|
|
|
|
1 Implementation of the secondo operator count, lcount
|
|
|
|
*/
|
|
#include "DRel.h"
|
|
#include "NestedList.h"
|
|
#include "ListUtils.h"
|
|
#include "QueryProcessor.h"
|
|
#include "StandardTypes.h"
|
|
|
|
#include "DRelHelpers.h"
|
|
|
|
extern NestedList* nl;
|
|
extern QueryProcessor* qp;
|
|
|
|
using namespace distributed2;
|
|
|
|
namespace drel {
|
|
|
|
/*
|
|
1.1 Type Mapping
|
|
|
|
Get a d[f]rel as argument.
|
|
|
|
*/
|
|
ListExpr countTM( ListExpr args ) {
|
|
|
|
std::string err = "d[f]rel expected";
|
|
|
|
if( !nl->HasLength( args, 1 ) ) {
|
|
return listutils::typeError( err +
|
|
": one argument is expected" );
|
|
}
|
|
|
|
if( !DRelHelpers::drelCheck( nl->First( args ) ) ) {
|
|
return listutils::typeError( err +
|
|
": first argument is not a d[f]rel" );
|
|
}
|
|
|
|
return listutils::basicSymbol<CcInt>( );
|
|
}
|
|
|
|
/*
|
|
1.2 Type Mapping
|
|
|
|
Get a d[f]rel and a bool as argument.
|
|
|
|
*/
|
|
ListExpr lcountTM( ListExpr args ) {
|
|
|
|
std::string err = "d[f]rel x bool expected";
|
|
|
|
if( !nl->HasLength( args, 2 ) ) {
|
|
return listutils::typeError( err +
|
|
": two arguments are expected" );
|
|
}
|
|
|
|
if( !DRelHelpers::drelCheck( nl->First( args ) ) ) {
|
|
return listutils::typeError( err +
|
|
": first argument is not a d[f]rel" );
|
|
}
|
|
|
|
if( !CcBool::checkType( nl->Second( args ) ) ) {
|
|
return listutils::typeError( err +
|
|
": second argument is not a bool" );
|
|
}
|
|
|
|
return nl->TwoElemList(
|
|
listutils::basicSymbol<DArray>( ),
|
|
listutils::basicSymbol<CcInt>( ) );
|
|
}
|
|
|
|
/*
|
|
1.3 Value Mapping Operator lcount
|
|
|
|
*/
|
|
template<class T>
|
|
int lcountVMT( Word* args, Word& result, int message,
|
|
Word& local, Supplier s ) {
|
|
|
|
DRel* drel = ( DRel* )args[ 0 ].addr;
|
|
bool replTuple = ( ( CcBool* )args[ 1 ].addr )->GetValue( );
|
|
|
|
DArray* darray;
|
|
|
|
if( !drel->IsDefined( ) ) {
|
|
result = qp->ResultStorage( s );
|
|
darray = ( DArray* )result.addr;
|
|
darray->makeUndefined( );
|
|
return 0;
|
|
}
|
|
|
|
distributionType dType = drel->getDistType( )->getDistType( );
|
|
|
|
std::string drelptr = nl->ToString( DRelHelpers::createdrel2darray(
|
|
qp->GetType( qp->GetSon( s, 0 ) ), args[ 0 ].addr ) );
|
|
|
|
std::string queryS;
|
|
|
|
if( replTuple &&
|
|
( dType == replicated
|
|
|| dType == spatial2d
|
|
|| dType == spatial3d ) ) {
|
|
queryS = "(dmap " + drelptr + "\"\""
|
|
"(fun (dmapelem_1 ARRAYFUNARG1) (count (filter "
|
|
"(feed dmapelem_1) (fun (streamelem_2 STREAMELEM) "
|
|
"(= (attr streamelem_2 Original) TRUE))))))";
|
|
|
|
}
|
|
else {
|
|
queryS = "(dmap " + drelptr +
|
|
" \"\" (fun (dmapelem_1 ARRAYFUNARG1) (count (feed dmapelem_1)"
|
|
")))";
|
|
}
|
|
|
|
ListExpr query;
|
|
if( !nl->ReadFromString( queryS, query ) ) {
|
|
result = qp->ResultStorage( s );
|
|
darray = ( DArray* )result.addr;
|
|
darray->makeUndefined( );
|
|
return 0;
|
|
}
|
|
|
|
bool correct = false;
|
|
bool evaluable = false;
|
|
bool defined = false;
|
|
bool isFunction = false;
|
|
std::string typeString, errorString;
|
|
result = qp->ResultStorage( s );
|
|
darray = ( DArray* )result.addr;
|
|
Word tmpResult;
|
|
if( !QueryProcessor::ExecuteQuery( query, tmpResult,
|
|
typeString, errorString,
|
|
correct, evaluable, defined, isFunction ) ) {
|
|
darray->makeUndefined( );
|
|
return 0;
|
|
}
|
|
|
|
if( !correct || !evaluable || !defined ) {
|
|
darray = ( DArray* )result.addr;
|
|
darray->makeUndefined( );
|
|
return 0;
|
|
}
|
|
|
|
(*darray) = (*( (DArray*) tmpResult.addr));
|
|
delete (DArray*) tmpResult.addr;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
1.4 Value Mapping Operator count
|
|
|
|
*/
|
|
template<class T>
|
|
int countVMT( Word* args, Word& result, int message,
|
|
Word& local, Supplier s ) {
|
|
|
|
DRel* drel = ( DRel* )args[ 0 ].addr;
|
|
|
|
|
|
result = qp->ResultStorage( s );
|
|
CcInt* res = ( CcInt* )result.addr;
|
|
|
|
if( !drel->IsDefined( ) ) {
|
|
res->SetDefined( false );
|
|
return 0;
|
|
}
|
|
|
|
distributionType dType = drel->getDistType( )->getDistType( );
|
|
|
|
std::string drelptr = nl->ToString( DRelHelpers::createdrel2darray(
|
|
qp->GetType( qp->GetSon( s, 0 ) ), args[ 0 ].addr ) );
|
|
|
|
std::string queryS;
|
|
|
|
if( dType == replicated
|
|
|| dType == spatial2d
|
|
|| dType == spatial3d ) {
|
|
queryS = "(dmap " + drelptr + "\"\""
|
|
"(fun (dmapelem_1 ARRAYFUNARG1) (count (filter "
|
|
"(feed dmapelem_1) (fun (streamelem_2 STREAMELEM) "
|
|
"(= (attr streamelem_2 Original) TRUE))))))";
|
|
|
|
}
|
|
else {
|
|
queryS = "(dmap " + drelptr +
|
|
" \"\" (fun (dmapelem_1 ARRAYFUNARG1) (count (feed dmapelem_1)"
|
|
")))";
|
|
}
|
|
|
|
queryS = "(tie (getValue " + queryS +
|
|
") (fun (first_2 ELEMENT) (second_3 ELEMENT) "
|
|
"(+ first_2 second_3)))";
|
|
|
|
|
|
ListExpr query;
|
|
if( !nl->ReadFromString( queryS, query ) ) {
|
|
res->SetDefined( false );
|
|
return 0;
|
|
}
|
|
|
|
bool correct = false;
|
|
bool evaluable = false;
|
|
bool defined = false;
|
|
bool isFunction = false;
|
|
std::string typeString, errorString;
|
|
Word tmpResult;
|
|
|
|
if( !QueryProcessor::ExecuteQuery( query, tmpResult,
|
|
typeString, errorString,
|
|
correct, evaluable, defined, isFunction ) ) {
|
|
res->SetDefined( false );
|
|
return 0;
|
|
}
|
|
|
|
if( !correct || !evaluable || !defined ) {
|
|
res->SetDefined( false );
|
|
return 0;
|
|
}
|
|
// overtake result from query
|
|
CcInt* tmpRes = (CcInt*) tmpResult.addr;
|
|
res->CopyFrom(tmpRes);
|
|
delete tmpRes;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
1.5 ValueMapping Array for lcount
|
|
|
|
*/
|
|
ValueMapping lcountVM[ ] = {
|
|
lcountVMT<DRel>,
|
|
lcountVMT<DFRel>
|
|
};
|
|
|
|
/*
|
|
1.6 ValueMapping Array for count
|
|
|
|
*/
|
|
ValueMapping countVM[ ] = {
|
|
countVMT<DRel>,
|
|
countVMT<DFRel>
|
|
};
|
|
|
|
/*
|
|
1.7 Selection functions for count and lcount
|
|
|
|
*/
|
|
int countSelect( ListExpr args ) {
|
|
|
|
return DRel::checkType( nl->First( args ) ) ? 0 : 1;
|
|
}
|
|
|
|
/*
|
|
1.8 Specification of lcount
|
|
|
|
*/
|
|
OperatorSpec lcountSpec(
|
|
"d[f]rel(X) x bool -> darray ",
|
|
" _ lcount",
|
|
"Count the tuples in the partition of a d[f]rel. The second argument "
|
|
"is for filtering replicated tuples while using spatial partitioning."
|
|
" TRUE for eliminating the replicas while counting.",
|
|
" query drel1 lcount"
|
|
);
|
|
|
|
/*
|
|
1.9 Operator instance of lcount operator
|
|
|
|
*/
|
|
Operator lcountOp(
|
|
"lcount",
|
|
lcountSpec.getStr( ),
|
|
2,
|
|
lcountVM,
|
|
countSelect,
|
|
lcountTM
|
|
);
|
|
|
|
/*
|
|
1.10 Specification of count
|
|
|
|
*/
|
|
OperatorSpec countSpec(
|
|
"d[f]rel(X) -> int ",
|
|
" _ count",
|
|
"Count the tuples of a d[f]rel. Replicated tuples of a spatially "
|
|
"distributed drel are counted only once.",
|
|
" query drel1 count"
|
|
);
|
|
|
|
/*
|
|
1.11 Operator instance of count operator
|
|
|
|
*/
|
|
Operator countOp(
|
|
"count",
|
|
countSpec.getStr( ),
|
|
2,
|
|
countVM,
|
|
countSelect,
|
|
countTM
|
|
);
|
|
|
|
} // end of namespace drel
|