along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dfd1e745480fabd88139d2804acb90d5b6dc055e
secondo/Algebras/DistributedUpdate/DistributedUpdateAlgebra.cpp

2281 lines
67 KiB
C++
Raw Normal View History

firs commit
2026-01-23 17:03:45 +08:00
/*
----
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
----
//[$][\$]
*/
#include "NestedList.h"
#include "ListUtils.h"
#include "QueryProcessor.h"
#include "StandardTypes.h"
#include "SecParser.h"
#include "Stream.h"
#include "Algebras/DRel/DRel.h"
#include "Algebras/DRel/DRelHelpers.h"
#include "Algebras/Distributed2/DArray.h"
#include "Algebras/FText/FTextAlgebra.h"
#include "Algebras/Relation-C++/OperatorFilter.h"
#include <string>
#include <iostream>
extern NestedList* nl;
extern QueryProcessor* qp;
template<int equalCheck>
ListExpr insertDeleteRelTypeMap(ListExpr args);
ListExpr insertTupleTypeMap(ListExpr args);
ListExpr updateSearchRelTypeMap(ListExpr args);
ListExpr updateDirectRelTypeMap(ListExpr args);
ListExpr appendIdentifierTypeMap (ListExpr args);
ListExpr allUpdatesRTreeTypeMap(ListExpr& args, std::string opName);
ListExpr allUpdatesBTreeTypeMap( const ListExpr& args, std::string opName);
template<int operatorId>
ListExpr IndexQuerySTypeMap(ListExpr args);
ListExpr WindowIntersectsSTypeMap(ListExpr args);
ListExpr deletebyid4TM(ListExpr args);
ListExpr updatebyid2TM(ListExpr args);
using namespace drel;
using namespace distributed2;
namespace drelupdate{
extern Operator drelspatialjoinOp;
/*
1. Operator ~drelinsert~
1.1 Type Mapping ~drelinsert~
*/
ListExpr drelinsertTM( ListExpr args ){
std::string err = "stream(tuple(X)) x drel(rel(tuple(X))) x int "
"expected";
if(!nl->HasLength(args,3)){
return listutils::typeError("wrong number of arguments");
}
// check for correct types
ListExpr streamType = nl->First( args );
if(!Stream<Tuple>::checkType(streamType)){
return listutils::typeError(err +
": first argument is not a stream");
}
ListExpr drelType = nl->Second( args );
distributionType type;
int attr, key;
if(!DRel::checkType( drelType, type, attr, key ) ){
return listutils::typeError(err +
": second argument is not a drel");
}
ListExpr port = nl->Third( args );
if(!CcInt::checkType( port ) ){
return listutils::typeError(err +
": last argument not of type int");
}
//streamType != relType (spatial2d, 3d, replicated)
ListExpr attrList = nl->Second(nl->Second( streamType ) );
if( type == replicated ){
attrList = ConcatLists(
attrList,
nl->OneElemList(nl->TwoElemList(
nl->SymbolAtom("Original"),
listutils::basicSymbol<CcBool>() ) ) );
} else if ( type == spatial2d || type == spatial3d ) {
attrList = DRelHelpers::addPartitionAttributes( attrList );
}
streamType = nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->TwoElemList(
listutils::basicSymbol<Tuple>(), attrList) );
ListExpr result = insertDeleteRelTypeMap<0>( nl->TwoElemList(
streamType, nl->Second(drelType) ) );
if(!listutils::isTupleStream( result ) ){
return result;
}
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second(result) ),
nl->Third(drelType) ); //distType
return resType;
}
/*
~distributeSimilarToDRel~
Distributes a relation in the same manner as a given drel.
*/
bool distributeSimilarToDRel( Relation* rel, ListExpr relType, DRel* drel,
ListExpr drelType, DFRel*& dfrel_tmp ){
std::string relPtr = nl->ToString( DRelHelpers::createPointerList(
relType, rel) );
std::string drelPtr = nl->ToString( DRelHelpers::createdrel2darray(
drelType, drel) );
distributionType type = drel->getDistType()->getDistType();
std::string dtype = getName(type);
std::string query;
if(type == replicated){
query = "(drelfdistribute " + relPtr + "\"TMP_DATA\" " +
dtype + " (consume (getWorkers " + drelPtr + ")))";
}
else if(type == drel::random){
query = "(drelfdistribute " + relPtr + "\"TMP_DATA\" " +
dtype + " (size " + drelPtr + ") " +
"(consume (getWorkers " + drelPtr + ")))";
}
else if( type == drel::hash || type == range
|| type == spatial2d || type == spatial3d){
//get attribute name for distribution
ListExpr attrList = nl->Second(
nl->Second(nl->Second(drelType) ) );
int attrPos = nl->IntValue(nl->Second(nl->Third(drelType) ) );
for(int i = 0; i < attrPos; i++){
attrList = nl->Rest(attrList);
}
std::string attr = nl->ToString( nl->First(nl->First(attrList) ) );
query = "(drelfdistribute " + relPtr + "\"TMP_DATA\" " +
dtype + " " + attr + " (size " + drelPtr + ") " +
"(consume (getWorkers " + drelPtr + ")))";
}
Word qRes;
if( !QueryProcessor::ExecuteQuery( query, qRes ) ) {
cout << "distribution of a stream to d[f]rel failed" << endl;
return false;
} else {
dfrel_tmp = (DFRel*) qRes.addr;
}
if( !dfrel_tmp || !dfrel_tmp->IsDefined() ){
return false;
}
return true;
}
/*
~removeTempObjects~
Removes temporary objects from a given dfrel.
*/
bool removeTempObjects(DFRel* dfrel_tmp, ListExpr drelType){
std::string dfrelPtr = nl->ToString(DRelHelpers::createPointerList(
nl->TwoElemList(
listutils::basicSymbol<distributed2::DFArray>(),
nl->Second(drelType) ),
dfrel_tmp ) ) ;
std::string query = "(deleteRemoteObjects " + dfrelPtr + ")";
Word qRes;
if( !QueryProcessor::ExecuteQuery( query, qRes ) ) {
return false;
} else {
int deletedObjects = ((CcInt*) qRes.addr)->GetValue();
return deletedObjects > 0 ? true : false;
}
}
/*
1.2 Value Mapping ~drelinsert~
*/
int drelinsertVM(Word* args, Word& result, int message,
Word& local, Supplier s ){
Stream<Tuple> stream(args[0].addr);
DRel* drel = (DRel*) args[1].addr;
CcInt* port = (CcInt*) args[2].addr;
result = qp->ResultStorage(s);
DFRel* resultDFRel = (DFRel*)result.addr;
//collect all tuples from stream into relation
stream.open();
Tuple* tup = stream.request();
Relation* rel = new Relation(tup->GetTupleType());
rel->AppendTuple(tup);
tup->DeleteIfAllowed();
while((tup = stream.request()) != 0){
rel->AppendTuple(tup);
tup->DeleteIfAllowed();
}
stream.close();
//distribute relation similar to drel
ListExpr relType = nl->TwoElemList(
listutils::basicSymbol<Relation> (),
nl->Second( qp->GetType( qp->GetSon(s,0) ) ) );
ListExpr drelType = qp->GetType( qp->GetSon(s,1) );
DFRel* dfrel_tmp = 0;
if( ! distributeSimilarToDRel(rel, relType, drel,
drelType, dfrel_tmp) ){
resultDFRel->makeUndefined();
delete dfrel_tmp;
delete rel;
return 0;
}
ListExpr arg1ptr = DRelHelpers::createPointerList(
nl->TwoElemList(
listutils::basicSymbol<distributed2::DFArray>(),
nl->Second(drelType) ),
dfrel_tmp );
ListExpr arg2ptr = DRelHelpers::createPointerList(
nl->TwoElemList(
listutils::basicSymbol<distributed2::DArray>(),
nl->Second(drelType) ),
drel );
std::string query = "(dmap2 " + nl->ToString(arg1ptr) +
nl->ToString(arg2ptr) + "\"\" "
"(fun (elem1 ARRAYFUNARG1) (elem2 ARRAYFUNARG2) "
"(insert (feed elem1) elem2)) " +
boost::to_string( port->GetValue() ) + ")";
Word qRes;
if( !QueryProcessor::ExecuteQuery( query, qRes ) ) {
resultDFRel->makeUndefined();
} else {
DFArray* dfarray = (DFArray*) qRes.addr;
if( !dfarray || !dfarray->IsDefined()){
resultDFRel->makeUndefined();
} else {
resultDFRel->copyFrom( *dfarray );
resultDFRel->setDistType( drel->getDistType()->copy() );
}
delete dfarray;
}
//delete temporary objects from remote server
if( !removeTempObjects(dfrel_tmp, drelType) ){
cout<<"temporary objects not deleted" << endl;
}
//check pointers
delete dfrel_tmp;
delete rel;
return 0;
}
/*
1.3 Specification of ~drelinsert~
*/
OperatorSpec drelinsertSpec(
" stream(tuple(X)) x drel(rel(tuple(X))) x int "
"-> dfrel(rel(tuple(X@[TID:tid])))",
" _ _ drelinsert [_]",
"Inserts tuples of the stream into the distributed relation. "
"The tuples to insert should not contain the partition "
"attributes (Cell, Original). The third argument specifies "
"a port number.",
"query rel1 feed drel1 drelinsert [1238]"
);
/*
1.4 Definition of ~drelinsert~
*/
Operator drelinsertOp (
"drelinsert",
drelinsertSpec.getStr( ),
drelinsertVM,
Operator::SimpleSelect,
drelinsertTM
);
/*
2. Operator ~drelinserttuple~
2.1 Type Mapping ~drelinserttuple~
*/
ListExpr drelinserttupleTM( ListExpr args ){
if(!nl->HasLength(args, 3) ){
return listutils::typeError("wrong number of arguments");
}
ListExpr drelType = nl->First( args );
ListExpr attrList = nl->Second( args );
// check for correct types
distributionType type;
int attr, key;
if(!DRel::checkType( drelType, type, attr, key ) ){
return listutils::typeError(
"first argument is not a drel");
}
if(nl->AtomType( attrList ) != NoAtom){
return listutils::typeError(
"second argument must be a list of attributes");
}
if(!CcInt::checkType( nl->Third( args ) ) ){
return listutils::typeError(
"last argument not of type int");
}
// attrList != relType (spatial2d, 3d, replicated)
if( type == replicated ) {
attrList = ConcatLists( attrList, nl->OneElemList(
listutils::basicSymbol<CcBool>() ) );
} else if ( type == spatial2d || type == spatial3d ) {
attrList = ConcatLists( attrList, nl->TwoElemList(
listutils::basicSymbol<CcInt>(),
listutils::basicSymbol<CcBool>() ) );
}
ListExpr result = insertTupleTypeMap( nl->TwoElemList(
nl->Second( drelType ),
attrList ) );
if(!listutils::isTupleStream( result ) ){
return result;
}
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( result ) ),
nl->Third( drelType ) ); //distType
return resType;
}
/*
2.2 Value Mapping ~drelinserttuple~
*/
int drelinserttupleVM(Word* args, Word& result, int message,
Word& local, Supplier s ){
DRel* drel = (DRel*) args[0].addr;
CcInt* port = (CcInt*) args[2].addr;
result = qp->ResultStorage(s);
DFRel* resultDFRel = (DFRel*)result.addr;
ListExpr resTupleType = nl->Second(
nl->Second( GetTupleResultType( s ) ) );
ListExpr rest, last, insertType;
rest = nl->Second( resTupleType );
insertType = nl->OneElemList(nl->First( rest ) );
last = insertType;
rest = nl->Rest( rest );
int i = 1;
distributionType type = drel->getDistType()->getDistType();
if(type == replicated)
i = 2;
else if( type == spatial2d || type == spatial3d )
i = 3;
while(nl->ListLength( rest ) > i){
last = nl->Append(last, nl->First( rest ) );
rest = nl->Rest( rest );
}
insertType = nl->TwoElemList(nl->First( resTupleType ),
insertType);
//create a new tuple from the attribute list
Tuple* insertTuple = new Tuple( new TupleType( insertType ) );
Supplier supplier = args[1].addr;
Supplier supplier_i;
Word attrValue;
Attribute* attr;
for(int i = 0; i < insertTuple->GetNoAttributes(); i++){
supplier_i = qp->GetSupplier(supplier, i);
qp->Request(supplier_i, attrValue);
attr = (Attribute*) attrValue.addr;
insertTuple->PutAttribute(i, attr->Clone() );
}
Relation* rel = new Relation( insertTuple->GetTupleType() );
rel->AppendTuple( insertTuple );
insertTuple->DeleteIfAllowed();
//distribute relation similar to drel
ListExpr drelType = qp->GetType( qp->GetSon(s,0) );
ListExpr attrs = DRelHelpers::removePartitionAttributes(
nl->Second( nl->Second( nl->Second( drelType ) ) ),
type );
ListExpr relType = nl->TwoElemList(
listutils::basicSymbol<Relation> (),
nl->TwoElemList(
listutils::basicSymbol<Tuple>(),
attrs ) );
DFRel* dfrel_tmp = 0;
if( ! distributeSimilarToDRel(rel, relType, drel, drelType,
dfrel_tmp) ){
resultDFRel->makeUndefined();
delete dfrel_tmp;
delete rel;
return 0;
}
ListExpr arg1ptr = DRelHelpers::createPointerList(
nl->TwoElemList(
listutils::basicSymbol<distributed2::DFArray>(),
nl->Second(drelType) ),
dfrel_tmp );
ListExpr arg2ptr = DRelHelpers::createPointerList(
nl->TwoElemList(
listutils::basicSymbol<distributed2::DArray>(),
nl->Second(drelType) ),
drel );
std::string query = "(dmap2 " + nl->ToString(arg1ptr) +
nl->ToString(arg2ptr) + "\"\" "
"(fun (elem1 ARRAYFUNARG1) (elem2 ARRAYFUNARG2) "
"(insert (feed elem1) elem2)) " +
boost::to_string( port->GetValue() ) + ")";
Word qRes;
if( !QueryProcessor::ExecuteQuery( query, qRes ) ) {
resultDFRel->makeUndefined();
} else {
DFArray* dfarray = (DFArray*) qRes.addr;
if( !dfarray || !dfarray->IsDefined()){
resultDFRel->makeUndefined();
} else {
resultDFRel->copyFrom( *dfarray );
resultDFRel->setDistType( drel->getDistType()->copy() );
}
delete dfarray;
}
//delete temporary objects from remote server
if( !removeTempObjects(dfrel_tmp, drelType) ){
cout<<"temporary objects not deleted" << endl;
}
//check pointers
delete dfrel_tmp;
delete rel;
return 0;
}
/*
2.3 Specification of ~drelinserttuple~
*/
OperatorSpec drelinserttupleSpec(
" drel(rel(tuple(X))) x [t1 ... tn] x int"
"-> dfrel(rel(tuple(X@[TID:tid])))",
" _ drelinserttuple [_; _]",
"Inserts a new tuple with the values from "
"the second argument list into the distributed relation. "
"The third argument specifies a port number. ",
"query drel1 drelinserttuple [\"Z\", 10 ; 1238]"
);
/*
2.4 Definition of ~drelinserttuple~
*/
Operator drelinserttupleOp (
"drelinserttuple",
drelinserttupleSpec.getStr( ),
drelinserttupleVM,
Operator::SimpleSelect,
drelinserttupleTM
);
/*
3. Operators ~dreldelete~, ~drelupdate~, ~dreldeletebyid~,
~drelupdatebyid~
3.1 Type Mapping functions
3.1.1 Type Mapping of ~dreldelete~
*/
ListExpr dreldeleteTM ( ListExpr args ){
if(!nl->HasLength(args, 3)){
return listutils::typeError("wrong number of arguments");
}
//check for correct types
ListExpr drelType1 = nl->First(args);
if( !DRel::checkType( drelType1 ) &&
!DFRel::checkType( drelType1 ) ){
return listutils::typeError(
"first argument is not a d[f]rel");
}
ListExpr drelType2 = nl->Second(args);
if( !DRel::checkType( drelType2 ) ){
return listutils::typeError(
"second argument is not a drel");
}
ListExpr port = nl->Third(args);
if( !CcInt::checkType( port ) ){
return listutils::typeError(
"last argument not of type int");
}
ListExpr result = insertDeleteRelTypeMap<0>(
nl->TwoElemList(
nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->Second(nl->Second( drelType1 ) ) ),
nl->Second( drelType2 ) ) );
if(!listutils::isTupleStream( result ) ){
return result;
}
// create function type for dmap2 operator
std::string fun = "(fun (elem1 ARRAYFUNARG1) (elem2 ARRAYFUNARG2) "
"(deletesearch (feed elem1) elem2)) ";
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( result ) ),
nl->Third( drelType2 ) );
ListExpr append = nl->OneElemList( nl->TextAtom( fun ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
3.1.2 Type Mapping of ~drelupdate~
*/
ListExpr drelupdateTM ( ListExpr args ){
if(!nl->HasLength(args, 4)){
return listutils::typeError("wrong number of arguments");
}
if(!DRelHelpers::isListOfTwoElemLists(args) ){
return listutils::typeError("internal Error");
}
// check for correct types
ListExpr drelType1 = nl->First( nl->First(args) );
if( !DRel::checkType( drelType1 ) &&
!DFRel::checkType( drelType1 ) ){
return listutils::typeError(
"first argument is not a d[f]rel");
}
ListExpr drelType2 = nl->First( nl->Second(args) );
if( !DRel::checkType( drelType2 ) ){
return listutils::typeError(
"second argument is not a drel");
}
ListExpr mapList = nl->First( nl->Third(args) );
ListExpr funList = nl->Second( nl->Third(args) );
ListExpr tempfun;
ListExpr funList_new = nl->TheEmptyList( );
while( !nl->IsEmpty( funList ) ){
if( !nl->HasLength( nl->First( funList ), 2 ) ){
return listutils::typeError( "internal error" );
}
if( !DRelHelpers::replaceDRELFUNARG(
nl->Second (nl->First( funList ) ), "TUPLE", tempfun ) ) {
return listutils::typeError( "error in the function format" );
}
if( nl->IsEmpty( funList_new ) ){
funList_new = nl->OneElemList( nl->TwoElemList(
nl->First(nl->First( funList ) ), tempfun ) );
} else {
funList_new = listutils::concat( funList_new,
nl->OneElemList( nl->TwoElemList(
nl->First(nl->First( funList ) ), tempfun ) ) );
}
funList = nl->Rest( funList );
}
ListExpr port = nl->Fourth(args);
if( !CcInt::checkType(nl->First( port ) ) ){
return listutils::typeError(
"last argument not of type int");
}
ListExpr result = updateSearchRelTypeMap(
nl->ThreeElemList(
nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->Second( nl->Second( drelType1 ) ) ),
nl->Second( drelType2 ),
mapList ) );
if( !nl->HasLength(result, 3) ){
return result;
}
// create function for dmap2 operator
std::string fun = "(fun (elem1 ARRAYFUNARG1) (elem2 ARRAYFUNARG2) "
"(updatesearch (feed elem1) elem2 " +
nl->ToString(funList_new) + ")) ";
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( nl->Third( result ) ) ),
nl->Third( drelType2 ) );
ListExpr append = nl->OneElemList( nl->TextAtom( fun ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
3.1.3 Type Mapping of ~dreldeletebyid~
*/
ListExpr dreldeletebyidTM ( ListExpr args ){
if(!nl->HasLength(args, 4)){
return listutils::typeError("wrong number of arguments");
}
// check for correct types
ListExpr arg1Type = nl->First(args);
if( !DRel::checkType( arg1Type ) &&
!DFRel::checkType( arg1Type ) &&
!DArray::checkType( arg1Type ) &&
!DFArray::checkType( arg1Type ) ){
return listutils::typeError(
"first argument is not a d[f]rel or a d[f]array");
}
if( !Relation::checkType( nl->Second( arg1Type ) ) ){
return listutils::typeError(
"wrong subtype of the first argument");
}
ListExpr drelType2 = nl->Second(args);
if( !DRel::checkType( drelType2 ) ){
return listutils::typeError(
"second argument is not a drel");
}
ListExpr attrName = nl->Third(args);
if(!listutils::isSymbol( attrName ) ){
return listutils::typeError(
"third argument must be an attribute name" );
}
ListExpr port = nl->Fourth( args );
if(!CcInt::checkType( port ) ){
return listutils::typeError(
"last argument not of type int");
}
ListExpr result = deletebyid4TM(
nl->ThreeElemList(
nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->Second( nl->Second( arg1Type ) ) ),
nl->Second( drelType2 ),
attrName ) );
if( !nl->HasLength(result, 3) ){
return result;
}
// create function for dmap2 operator
std::string attr = nl->ToString(attrName);
std::string fun = "(fun (elem1 ARRAYFUNARG1) (elem2 ARRAYFUNARG2) "
"(deletebyid4 (feed elem1) elem2 " + attr + ")) ";
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( nl->Third( result) ) ),
nl->Third( drelType2 ) );
ListExpr append = nl->OneElemList( nl->TextAtom( fun ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
3.1.4 Type Mapping of ~drelupdatebyid~
*/
ListExpr drelupdatebyidTM ( ListExpr args ){
if(!nl->HasLength(args, 5)){
return listutils::typeError("wrong number of arguments");
}
if(!DRelHelpers::isListOfTwoElemLists(args) ){
return listutils::typeError("internal Error");
}
// check for correct types
ListExpr arg1Type = nl->First( nl->First(args) );
if( !DRel::checkType( arg1Type ) &&
!DFRel::checkType( arg1Type ) &&
!DArray::checkType( arg1Type ) &&
!DFArray::checkType( arg1Type ) ){
return listutils::typeError(
"first argument is not a d[f]rel or a d[f]array");
}
if( !Relation::checkType( nl->Second( arg1Type ) ) ){
return listutils::typeError(
"wrong subtype of the first argument");
}
ListExpr drelType2 = nl->First( nl->Second(args) );
if( !DRel::checkType( drelType2 ) ){
return listutils::typeError(
"second argument is not a drel");
}
ListExpr attrName = nl->Second ( nl->Third( args ) );
if(!listutils::isSymbol( attrName ) ){
return listutils::typeError(
"third argument must be an attribute name" );
}
ListExpr mapList = nl->First( nl->Fourth(args) );
ListExpr funList = nl->Second( nl->Fourth(args) );
ListExpr tempfun;
ListExpr fundef;
ListExpr funList_new = nl->TheEmptyList( );
while( !nl->IsEmpty( funList ) ){
if( !nl->HasLength( nl->First( funList ), 2 ) ){
return listutils::typeError( "internal error" );
}
fundef = nl->Second( nl->First( funList ) );
if( !nl->HasLength( fundef, 4 )
|| !nl->HasLength( nl->Second( fundef ), 2 )
|| !nl->HasLength( nl->Third( fundef ), 2 )
|| !listutils::isSymbol( nl->Second ( nl->Second( fundef ) ) )
|| !listutils::isSymbol( nl->Second ( nl->Third( fundef ) ) ) )
{
return listutils::typeError( "error in the function format" );
}
tempfun = nl->FourElemList(
nl->First( fundef ),
nl->TwoElemList(
nl->First ( nl->Second( fundef ) ),
nl->SymbolAtom( "TUPLE" ) ),
nl->TwoElemList(
nl->First ( nl->Third( fundef ) ),
nl->SymbolAtom( "TUPLE2" ) ),
nl->Fourth( fundef ) );
if( nl->IsEmpty( funList_new ) ){
funList_new = nl->OneElemList( nl->TwoElemList(
nl->First(nl->First( funList ) ), tempfun ) );
} else {
funList_new = listutils::concat( funList_new,
nl->OneElemList( nl->TwoElemList(
nl->First(nl->First( funList ) ), tempfun ) ) );
}
funList = nl->Rest( funList );
}
ListExpr port = nl->Fifth( args );
if(!CcInt::checkType( nl->First(port) ) ){
return listutils::typeError(
"last argument not of type int");
}
ListExpr result = updatebyid2TM(
nl->FourElemList(
nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->Second( nl->Second( arg1Type ) ) ),
nl->Second( drelType2 ),
attrName,
mapList ) );
if( !nl->HasLength(result, 3) ){
return result;
}
// create function for dmap2 operator
std::string attr = nl->ToString(attrName);
std::string fun = "(fun (elem1 ARRAYFUNARG1) (elem2 ARRAYFUNARG2) "
"(updatebyid2 (feed elem1) elem2 " + attr + " " +
nl->ToString(funList_new) + "))";
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( nl->Third(result) ) ),
nl->Third( drelType2 ) );
ListExpr append = nl->OneElemList( nl->TextAtom( fun ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
3.2 Value Mapping function
used by ~dreldelete~, ~drelupdate~, ~dreldeletebyid~, ~drelupdatebyid~
operators
*/
template<class R>
int dreldmap2VMT(Word* args, Word& result, int message,
Word& local, Supplier s ){
int argsNum = qp->GetNoSons( s );
R* arg1 = (R*) args[0].addr;
DRel* drel2 = (DRel*) args[1].addr;
CcInt* port = (CcInt*) args[argsNum - 2].addr;
FText* funText = (FText*) args[argsNum - 1].addr;
result = qp->ResultStorage(s);
DFRel* resultDFRel = (DFRel*)result.addr;
ListExpr arg1ptr;
if( DRel::checkType( qp->GetType( qp->GetSon(s,0) ) ) ||
DFRel::checkType( qp->GetType( qp->GetSon(s,0) ) ) ) {
arg1ptr = DRelHelpers::createdrel2darray(
qp->GetType( qp->GetSon(s,0) ), arg1 );
} else {
arg1ptr = DRelHelpers::createPointerList(
qp->GetType( qp->GetSon(s,0) ), arg1 );
}
ListExpr arg2ptr = DRelHelpers::createdrel2darray(
qp->GetType( qp->GetSon(s,1) ), drel2 );
std::string query = "(dmap2 " + nl->ToString(arg1ptr) +
nl->ToString(arg2ptr) +
"\"\" " + funText->GetValue() +
boost::to_string( port->GetValue() ) + ")";
Word qRes;
if( !QueryProcessor::ExecuteQuery( query, qRes ) ) {
resultDFRel->makeUndefined();
return 0;
} else {
DFArray* dfarray = (DFArray*) qRes.addr;
if( !dfarray || !dfarray->IsDefined()){
resultDFRel->makeUndefined();
delete dfarray;
return 0;
}
resultDFRel->copyFrom( *dfarray );
resultDFRel->setDistType( drel2->getDistType()->copy() );
delete dfarray;
}
return 0;
}
ValueMapping dreldmap2VM[] = {
dreldmap2VMT<DArray>,
dreldmap2VMT<DFArray>
};
int dreldmap2UpdSelect( ListExpr args ){
return DRel::checkType( nl->First( args ) ) ||
DArray::checkType( nl->First( args ) ) ? 0 : 1;
}
/*
3.3 Specifications
3.3.1 Specification of ~dreldelete~
*/
OperatorSpec dreldeleteSpec(
" d[f]rel(rel(tuple(X))) x drel(rel(tuple(X))) x int"
"-> dfrel(rel(tuple(X@[TID:tid])))",
" _ _ dreldelete [_]",
"Deletes tuples from the distributed relation given "
"as a second argument. The first distributed relation "
"contains tuples to delete. The third argument "
"is a port number.",
"query drel1 drelfilter[.No > 5] drel1 dreldelete [1238]"
);
/*
3.3.2 Specification of ~drelupdate~
*/
OperatorSpec drelupdateSpec(
" d[f]rel(rel(tuple(X))) x drel(rel(tuple(X))) x funlist x int"
"-> dfrel(rel(tuple(X@[X1_old t1]@...[Xn_old tn]@[TID:tid])))",
" _ _ drelupdate [_ ; _]",
"Updates tuples in the distributed relation given "
"as a second argument by replacing attributes as "
"specified in the funlist. The first distributed "
"relation contains tuples to update. The fourth argument "
"is a port number.",
"query drel1 drelfilter[.No > 5] drel1 drelupdate [No: .No + 1; 1238]"
);
/*
3.3.3 Specification of ~dreldeletebyid~
*/
OperatorSpec dreldeletebyidSpec(
" d[f]rel(rel(tuple(X))) x drel(rel(tuple(Y))) x attr x int"
"-> dfrel(rel(tuple(Y@[TID:tid]))), "
" d[f]array(rel(tuple(X))) x drel(rel(tuple(Y))) x attr x int"
"-> dfrel(rel(tuple(Y@[TID:tid]))) ",
" _ _ dreldeletebyid [_, _]",
"Deletes tuples from the distributed relation given "
"as a second argument. The first argument contains "
"tuples to delete and specifies tupleids by the attr "
"argument. It can be of types d[f]array or d[f]rel. "
"The last argument is a port number.",
"query drel1 drelfilteraddid[.No > 5] drel1 dreldeletebyid[TID, 1238]"
);
/*
3.3.4 Specification of ~drelupdatebyid~
*/
OperatorSpec drelupdatebyidSpec(
" d[f]rel(rel(tuple(X))) x drel(rel(tuple(Y))) x attr x funlist x int"
"-> dfrel(rel(tuple(X))), "
" d[f]array(rel(tuple(X))) x drel(rel(tuple(Y))) x attr x funlist x int"
"-> dfrel(rel(tuple(X)))",
" _ _ drelupdatebyid [_ ; _; _]",
"Updates tuples in the distributed relation given "
"as a second argument. The first argument contains "
"tuples to update and specifies tupleid by the attr "
"argument. It can be of types d[f]array or d[f]rel. "
"The functions may use parts from the first argument "
"(dot notation) or from the second drel (double dot notation).",
"query drel1 dreladdid drel1 drelupdatebyid [TID; No: ..No + 1; 1238]"
);
/*
3.4 Definitions
3.4.1 Definition of ~dreldelete~
*/
Operator dreldeleteOp (
"dreldelete",
dreldeleteSpec.getStr( ),
2,
dreldmap2VM,
dreldmap2UpdSelect,
dreldeleteTM
);
/*
3.4.2 Definition of ~drelupdate~
*/
Operator drelupdateOp (
"drelupdate",
drelupdateSpec.getStr( ),
2,
dreldmap2VM,
dreldmap2UpdSelect,
drelupdateTM
);
/*
3.4.3 Definition of ~dreldeletebyid~
*/
Operator dreldeletebyidOp (
"dreldeletebyid",
dreldeletebyidSpec.getStr( ),
2,
dreldmap2VM,
dreldmap2UpdSelect,
dreldeletebyidTM
);
/*
3.4.4 Definition of ~drelupdatebyid~
*/
Operator drelupdatebyidOp (
"drelupdatebyid",
drelupdatebyidSpec.getStr( ),
2,
dreldmap2VM,
dreldmap2UpdSelect,
drelupdatebyidTM
);
/*
4. Operators ~drelinsertrtree~, ~dreldeletertree~, ~drelupdatertree~,
~drelinsertbtree~, ~dreldeletebtree~, ~drelupdatebtree~
4.1 Type Mapping function for update distributed rtree
*/
ListExpr drelAllUpdatesRTreeTM (ListExpr& args, std::string opName ){
if(!nl->HasLength(args, 4) ){
return listutils::typeError("wrong number of arguments");
}
ListExpr drelType = nl->First(args);
if( !DRel::checkType( drelType ) &&
!DFRel::checkType( drelType ) ){
return listutils::typeError(
"first argument is not a d[f]rel");
}
ListExpr darrayRTreeType = nl->Second(args);
if( !DArray::checkType( darrayRTreeType ) ){
return listutils::typeError(
"second argument is not a darray");
}
ListExpr attrName = nl->Third(args);
if(!listutils::isSymbol( attrName ) ){
return listutils::typeError(
"third argument must be an attribute name" );
}
ListExpr port = nl->Fourth(args);
if(!CcInt::checkType( port ) ){
return listutils::typeError(
"last argument not of type int");
}
ListExpr args2 = nl->ThreeElemList(
nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->Second(nl->Second( drelType ) ) ),
nl->Second( darrayRTreeType ),
attrName );
ListExpr result = allUpdatesRTreeTypeMap(args2, opName);
if( !nl->HasLength(result, 3) ){
return result;
}
//create function for dmap2 operator
std::string fun = "(fun (elem1 ARRAYFUNARG1) (elem2 ARRAYFUNARG2) "
"(" + opName + " (feed elem1) elem2 " +
nl->ToString(attrName) + "))";
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( nl->Third( result ) ) ),
nl->Third( drelType ) );
ListExpr append = nl->OneElemList( nl->TextAtom( fun ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
4.1.1 Type Mapping of ~drelinsertrtree~
*/
ListExpr drelinsertrtreeTM(ListExpr args){
return drelAllUpdatesRTreeTM(args, "insertrtree");
}
/*
4.1.2 Type Mapping of ~dreldeletertree~
*/
ListExpr dreldeletertreeTM(ListExpr args){
return drelAllUpdatesRTreeTM(args, "deletertree");
}
/*
4.1.3 Type Mapping of ~drelupdatertree~
*/
ListExpr drelupdatertreeTM(ListExpr args){
return drelAllUpdatesRTreeTM(args, "updatertree");
}
/*
4.2 Type Mapping function for update distributed btree
*/
ListExpr drelAllUpdatesBTreeTM (ListExpr& args, std::string opName ){
if(!nl->HasLength(args, 4) ){
return listutils::typeError("wrong number of arguments");
}
// check for correct types
ListExpr drelType = nl->First(args);
if( !DRel::checkType( drelType ) &&
!DFRel::checkType( drelType ) ){
return listutils::typeError(
"first argument is not a d[f]rel");
}
ListExpr darrayBTreeType = nl->Second( args );
if( !DArray::checkType( darrayBTreeType ) ){
return listutils::typeError(
"second argument is not a darray");
}
ListExpr attrName = nl->Third( args );
if( !listutils::isSymbol( attrName ) ){
return listutils::typeError(
"third argument must be an attribute name" );
}
ListExpr port = nl->Fourth(args);
if(!CcInt::checkType( port ) ){
return listutils::typeError(
"last argument not of type int");
}
ListExpr args2 = nl->ThreeElemList(
nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->Second(nl->Second( drelType ) ) ),
nl->Second( darrayBTreeType ),
attrName );
ListExpr result = allUpdatesBTreeTypeMap(args2, opName);
if( !nl->HasLength(result, 3) ){
return result;
}
//create function for dmap2 operator
std::string fun = "(fun (elem1 ARRAYFUNARG1) (elem2 ARRAYFUNARG2) "
"(" + opName + " (feed elem1) elem2 " +
nl->ToString(attrName) + "))";
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( nl->Third( result ) ) ),
nl->Third( drelType ) );
ListExpr append = nl->OneElemList( nl->TextAtom( fun ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
4.2.1 Type Mapping of ~drelinsertbtree~
*/
ListExpr drelinsertbtreeTM(ListExpr args){
return drelAllUpdatesBTreeTM(args, "insertbtree");
}
/*
4.2.2 Type Mapping of ~dreldeletebtree~
*/
ListExpr dreldeletebtreeTM(ListExpr args){
return drelAllUpdatesBTreeTM(args, "deletebtree");
}
/*
4.2.3 Type Mapping of ~drelupdatebtree~
*/
ListExpr drelupdatebtreeTM(ListExpr args){
return drelAllUpdatesBTreeTM(args, "updatebtree");
}
/*
4.3 Value Mapping function
used by ~drelinsertrtree~, ~dreldeletertree~, ~drelupdatertree~,
~drelinsertbtree~, ~dreldeletebtree~, ~drelupdatebtree~ operators
*/
template<class R>
int dreldmap2IVMT(Word* args, Word& result, int message,
Word& local, Supplier s ){
int argsNum = qp->GetNoSons( s );
R* drel = (R*) args[0].addr;
DArray* da = (DArray*) args[1].addr;
CcInt* port = (CcInt*) args[argsNum - 2].addr;
FText* funText = (FText*) args[argsNum - 1].addr;
result = qp->ResultStorage(s);
DFRel* resultDFRel = (DFRel*)result.addr;
ListExpr arg1ptr = DRelHelpers::createdrel2darray(
qp->GetType( qp->GetSon(s,0) ), drel );
ListExpr arg2ptr = DRelHelpers::createPointerList(
qp->GetType( qp->GetSon(s,1) ), da );
std::string query = "(dmap2 " + nl->ToString(arg1ptr) +
nl->ToString(arg2ptr) +
"\"\" " + funText->GetValue() +
boost::to_string( port->GetValue() ) + ")";
Word qRes;
if( !QueryProcessor::ExecuteQuery( query, qRes ) ) {
resultDFRel->makeUndefined();
return 0;
} else {
DFArray* dfarray = (DFArray*) qRes.addr;
if( !dfarray || !dfarray->IsDefined()){
resultDFRel->makeUndefined();
delete dfarray;
return 0;
}
resultDFRel->copyFrom( *dfarray );
resultDFRel->setDistType( drel->getDistType()->copy() );
delete dfarray;
}
return 0;
}
ValueMapping dreldmap2IVM[] = {
dreldmap2IVMT<DRel>,
dreldmap2IVMT<DFRel>
};
int dreldmap2IUpdSelect( ListExpr args ){
return DRel::checkType( nl->First( args ) ) ? 0 : 1;
}
/*
4.4 Specifications
4.4.1 Specification of ~drelinsertrtree~
*/
OperatorSpec drelinsertrtreeSpec(
" d[f]rel(rel(tuple(X@[TID:tid]))) x da(rtree(tuple(X))) x attr x int"
"-> dfrel(rel(tuple(X@[TID:tid])))",
" _ _ drelinsertrtree [_, _]",
"Inserts references of tuples with tupleids into the "
"distributed rtree. ",
"query drel da_rtree drelinsertrtree [GeoData, 1238]"
);
/*
4.4.2 Specification of ~dreldeletertree~
*/
OperatorSpec dreldeletertreeSpec(
" d[f]rel(rel(tuple(X@[TID:tid]))) x da(rtree(tuple(X))) x attr x int"
"-> dfrel(rel(tuple(X@[TID:tid])))",
" _ _ dreldeletertree [_, _]",
"Deletes references of tuples with tupleids from the "
"distributed rtree. ",
"query drel da_rtree dreldeletertree [GeoData, 1238]"
);
/*
4.4.3 Specification of ~drelupdatertree~
*/
OperatorSpec drelupdatertreeSpec(
" d[f]rel(rel(tuple(X@[X1_old t1]@...[Xn_old tn]@[TID:tid]))) x"
" da(rtree(tuple(X))) x attr x int "
"-> dfrel(rel(tuple(X@[X1_old t1]@...[Xn_old tn]@[TID:tid])))",
" _ _ drelupdatertree [_, _]",
"Updates references of tuples with tupleids in the "
"distributed rtree.",
"query drel da_rtree drelupdatertree [GeoData, 1238]"
);
/*
4.4.4 Specification of ~drelinsertbtree~
*/
OperatorSpec drelinsertbtreeSpec(
" d[f]rel(rel(tuple(X@[TID:tid]))) x da(btree(tuple(X))) x attr x int"
"-> dfrel(rel(tuple(X@[TID:tid])))",
" _ _ drelinsertbtree [_, _]",
"Inserts references of tuples with tupleids into the "
"distributed btree. ",
"query drel da_btree drelinsertbtree [BevT, 1238]"
);
/*
4.4.5 Specification of ~dreldeletebtree~
*/
OperatorSpec dreldeletebtreeSpec(
" d[f]rel(rel(tuple(X@[TID:tid]))) x da(btree(tuple(X))) x attr x int"
"-> dfrel(rel(tuple(X@[TID:tid])))",
" _ _ dreldeletebtree [_, _]",
"Deletes references of tuples with tupleids from the "
"distributed btree. ",
"query drel da_btree dreldeletebtree [BevT, 1238]"
);
/*
4.4.6 Specification of ~drelupdatebtree~
*/
OperatorSpec drelupdatebtreeSpec(
" d[f]rel(rel(tuple(X@[X1_old t1]@...[Xn_old tn]@[TID:tid]))) x"
" da(btree(tuple(X))) x attr x int "
"-> dfrel(rel(tuple(X@[X1_old t1]@...[Xn_old tn]@[TID:tid])))",
" _ _ drelupdatebtree [_, _]",
"Updates references of tuples with tupleids in the "
"distributed btree.",
"query drel da_btree drelupdatebtree [BevT, 1238]"
);
/*
4.5 Definitions
4.5.1 Definition of ~drelinsertrtree~
*/
Operator drelinsertrtreeOp (
"drelinsertrtree",
drelinsertrtreeSpec.getStr( ),
2,
dreldmap2IVM,
dreldmap2IUpdSelect,
drelinsertrtreeTM
);
/*
4.5.2 Definition of ~dreldeletertree~
*/
Operator dreldeletertreeOp (
"dreldeletertree",
dreldeletertreeSpec.getStr( ),
2,
dreldmap2IVM,
dreldmap2IUpdSelect,
dreldeletertreeTM
);
/*
4.5.3 Definition of ~drelupdatertree~
*/
Operator drelupdatertreeOp (
"drelupdatertree",
drelupdatertreeSpec.getStr( ),
2,
dreldmap2IVM,
dreldmap2IUpdSelect,
drelupdatertreeTM
);
/*
4.5.4 Definition of ~drelinsertbtree~
*/
Operator drelinsertbtreeOp (
"drelinsertbtree",
drelinsertbtreeSpec.getStr( ),
2,
dreldmap2IVM,
dreldmap2IUpdSelect,
drelinsertbtreeTM
);
/*
4.5.5 Definition of ~dreldeletebtree~
*/
Operator dreldeletebtreeOp (
"dreldeletebtree",
dreldeletebtreeSpec.getStr( ),
2,
dreldmap2IVM,
dreldmap2IUpdSelect,
dreldeletebtreeTM
);
/*
4.5.6 Definition of ~drelupdatebtree~
*/
Operator drelupdatebtreeOp (
"drelupdatebtree",
drelupdatebtreeSpec.getStr( ),
2,
dreldmap2IVM,
dreldmap2IUpdSelect,
drelupdatebtreeTM
);
/*
5. Operators ~dreladdid~, ~drelfilteraddid~, ~drelfilterdelete~,
~drelfilterupdate~
5.1 Type Mapping functions
5.1.1 Type Mapping of ~dreladdid~
*/
ListExpr dreladdidTM ( ListExpr args ){
if(!nl->HasLength(args, 1) ){
return listutils::typeError("wrong number of arguments");
}
ListExpr drelType = nl->First(args);
if( !DRel::checkType( drelType ) &&
!DFRel::checkType( drelType ) ){
return listutils::typeError(
"first argument is not a d[f]rel");
}
ListExpr result = appendIdentifierTypeMap(
nl->OneElemList(
nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->Second( nl->Second( drelType ) ) ) ) );
if(!listutils::isTupleStream( result ) ){
return result;
}
// create function for dmap operator
std::string fun ="(fun (elem1 ARRAYFUNARG1) (addid (feed elem1)))";
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( result ) ),
nl->Third( drelType ) ); //distType
ListExpr append = nl->OneElemList( nl->TextAtom( fun ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
5.1.2 Type Mapping of ~drelfilteraddid~
*/
ListExpr drelfilteraddidTM( ListExpr args ){
if(!nl->HasLength(args,2)){
return listutils::typeError("wrong number of arguments");
}
if(!DRelHelpers::isListOfTwoElemLists(args) ){
return listutils::typeError("internal error");
}
// check for correct types
ListExpr drelType, relType, distType, drelValue;
if(!DRelHelpers::isDRelDescr(nl->First(args), drelType, relType,
distType, drelValue) ){
return listutils::typeError(
"first argument is not a d[f]rel");
}
ListExpr fun, map;
if( !DRelHelpers::replaceDRELFUNARG( nl->Second( args ),
"STREAMELEM", fun, map) ){
return listutils::typeError(
"error in the function format");
}
ListExpr filterRes = OperatorFilter::FilterTypeMap(
nl->TwoElemList(
nl->TwoElemList(
nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->Second( relType ) ),
nl->TwoElemList(
nl->SymbolAtom("feed"), //dummy
drelValue ) ),
nl->TwoElemList( map, fun ) ) );
if(!listutils::isTupleStream( filterRes ) ){
return filterRes;
}
ListExpr result = appendIdentifierTypeMap( nl->OneElemList( filterRes ) );
if(!listutils::isTupleStream( result ) ){
return result;
}
// create function for dmap operator
std::string funText = "(fun (elem1 ARRAYFUNARG1) (addid (filter "
"(feed elem1) " + nl->ToString(fun) + ")))";
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( result ) ),
distType);
ListExpr append = nl->OneElemList( nl->TextAtom( funText ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
5.1.3 Type Mapping of ~drelfilterdelete~
*/
ListExpr drelfilterdeleteTM( ListExpr args ){
if(!nl->HasLength(args,2)){
return listutils::typeError("wrong number of arguments");
}
if(!DRelHelpers::isListOfTwoElemLists(args) ){
return listutils::typeError("internal error");
}
// check for correct types
ListExpr drelType = nl->First( nl->First( args ) );
ListExpr drelValue = nl->Second( nl->First( args ) );
if( !DRel::checkType( drelType ) ){
return listutils::typeError(
"first argument is not a drel"); // ONLY DREL
}
ListExpr fun, map;
if( !DRelHelpers::replaceDRELFUNARG( nl->Second( args ),
"STREAMELEM", fun, map) ){
return listutils::typeError(
"error in the function format");
}
ListExpr filterRes = OperatorFilter::FilterTypeMap(
nl->TwoElemList(
nl->TwoElemList(
nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->Second( nl->Second( drelType ) ) ),
nl->TwoElemList(
nl->SymbolAtom("feed"), //dummy
drelValue ) ),
nl->TwoElemList( map, fun ) ) );
if(!listutils::isTupleStream( filterRes ) ){
return filterRes;
}
ListExpr result = insertDeleteRelTypeMap<0>( nl->TwoElemList(
filterRes,
nl->Second( drelType ) ) );
if(!listutils::isTupleStream( result ) ){
return result;
}
// create function for dmap operator
std::string funText = "(fun (elem1 ARRAYFUNARG1) (deletedirect "
"(filter (feed elem1) " + nl->ToString(fun) + ") elem1))";
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( result ) ),
nl->Third( drelType ) ); // distType
ListExpr append = nl->OneElemList( nl->TextAtom( funText ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
5.1.4 Type Mapping of ~drelfilterupdate~
*/
ListExpr drelfilterupdateTM( ListExpr args ){
if(!nl->HasLength(args,3)){
return listutils::typeError("wrong number of arguments");
}
if(!DRelHelpers::isListOfTwoElemLists(args) ){
return listutils::typeError("internal error");
}
// check for correct types
ListExpr drelType = nl->First( nl->First( args ) );
ListExpr drelValue = nl->Second( nl->First( args ) );
if( !DRel::checkType( drelType ) ){
return listutils::typeError(
"first argument is not a drel"); // ONLY DREL
}
ListExpr filter_fun, filter_map;
if( !DRelHelpers::replaceDRELFUNARG( nl->Second( args ),
"STREAMELEM", filter_fun, filter_map) ){
return listutils::typeError(
"error in the function format");
}
ListExpr filterRes = OperatorFilter::FilterTypeMap(
nl->TwoElemList(
nl->TwoElemList(
nl->TwoElemList(
listutils::basicSymbol<Stream<Tuple> >(),
nl->Second( nl->Second( drelType ) ) ),
nl->TwoElemList(
nl->SymbolAtom("feed"), //dummy
drelValue ) ),
nl->TwoElemList( filter_map, filter_fun ) ) );
if(!listutils::isTupleStream( filterRes ) ){
return filterRes;
}
ListExpr update_mapList = nl->First( nl->Third(args) );
ListExpr update_funList = nl->Second( nl->Third(args) );
ListExpr tempfun;
ListExpr funList_new = nl->TheEmptyList( );
while( !nl->IsEmpty( update_funList ) ){
if( !nl->HasLength( nl->First( update_funList ), 2 ) ){
return listutils::typeError( "internal error" );
}
if( !DRelHelpers::replaceDRELFUNARG(
nl->Second (nl->First( update_funList ) ), "TUPLE", tempfun ) ) {
return listutils::typeError( "error in the function format" );
}
if( nl->IsEmpty( funList_new ) ){
funList_new = nl->OneElemList( nl->TwoElemList(
nl->First(nl->First( update_funList ) ), tempfun ) );
} else {
funList_new = listutils::concat( funList_new,
nl->OneElemList( nl->TwoElemList(
nl->First(nl->First( update_funList ) ), tempfun ) ) );
}
update_funList = nl->Rest( update_funList );
}
ListExpr result = updateDirectRelTypeMap(
nl->ThreeElemList(
filterRes,
nl->Second( drelType ), // relType
update_mapList ) );
if( !nl->HasLength(result, 3) ){
return result;
}
// create function for dmap operator
std::string funText = "(fun (elem1 ARRAYFUNARG1) (updatedirect "
"(filter (feed elem1) " + nl->ToString(filter_fun) + ") elem1 " +
nl->ToString(funList_new) + "))";
ListExpr resType = nl->ThreeElemList(
listutils::basicSymbol<DFRel>(),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( nl->Third( result ) ) ),
nl->Third( drelType ) ); //distType
ListExpr append = nl->OneElemList( nl->TextAtom( funText ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
5.2 Value Mapping function
used by ~dreladdid~, ~drelfilteraddid~, ~drelfilterdelete~,
~drelfilterupdate~ operators
*/
template<class R>
int dreldmapVMT(Word* args, Word& result, int message,
Word& local, Supplier s ){
int argsNum = qp->GetNoSons( s );
R* drel = (R*) args[0].addr;
FText* funText = (FText*) args[argsNum - 1].addr;
result = qp->ResultStorage(s);
DFRel* resultDFRel = (DFRel*)result.addr;
ListExpr drelptr = DRelHelpers::createdrel2darray
(qp->GetType( qp->GetSon(s, 0) ), drel);
std::string query = "(dmap " + nl->ToString(drelptr) + "\"\" " +
funText->GetValue() + ")";
Word qRes;
if( !QueryProcessor::ExecuteQuery( query, qRes ) ) {
resultDFRel->makeUndefined();
return 0;
} else {
DFArray* dfarray = (DFArray*) qRes.addr;
if( !dfarray || !dfarray->IsDefined()){
resultDFRel->makeUndefined();
delete dfarray;
return 0;
}
resultDFRel->copyFrom( *dfarray );
resultDFRel->setDistType( drel->getDistType()->copy() );
delete dfarray;
}
return 0;
}
ValueMapping dreldmapVM[] = {
dreldmapVMT<DRel>,
dreldmapVMT<DFRel>
};
int dreldmapUpdSelect( ListExpr args ){
return DRel::checkType( nl->First( args ) ) ? 0 : 1;
}
/*
5.3 Specifications
5.3.1 Specification of ~dreladdid~
*/
OperatorSpec dreladdidSpec(
" d[f]rel(rel(tuple(X))) -> dfrel(rel(tuple(X@[TID:tid])))",
" _ dreladdid",
"Appends tupleid attribute to each tuple of the "
"distributed relation. Must be applied directly "
"to the distributed relation, because other "
"operators may corrupt tupleids.",
"query drel1 dreladdid head[5] drel1 dreldeletebyid[TID, 1238]"
);
/*
5.3.2 Specification of ~drelfilteraddid~
*/
OperatorSpec drelfilteraddidSpec(
" d[f]rel(rel(tuple(X))) x fun -> dfrel(rel(tuple(X@[TID:tid])))",
" _ drelfilteraddid [_]",
"Only tuples, fulfilling a certain condition are selected, "
"extended with the TID attribute and passed to the output "
"distributed relation.",
"query drel1 drelfilteraddid [.No > 5] dreldeletebyid[TID, 1238]"
);
/*
5.3.3 Specification of ~drelfilterdelete~
*/
OperatorSpec drelfilterdeleteSpec(
"drel(rel(tuple(X))) x fun -> dfrel(rel(tuple(X@[TID:tid])))",
" _ drelfilterdelete [_]",
"Only tuples, fulfilling a certain condition are selected "
"and deleted from the distributed relation. The output "
"distributed relation contains deleted tuples extended "
"with the TID attribute. ",
"query drel1 drelfilterdelete[.No > 5]"
);
/*
5.3.4 Specification of ~drelfilterupdate~
*/
OperatorSpec drelfilterupdateSpec(
" drel(rel(tuple(X))) x fun x funlist -> "
" dfrel(rel(tuple(X@[X1_old t1]@...[Xn_old tn]@[TID:tid])))",
" _ drelfilterupdate [filter_fun; update_funlist]",
"Only tuples, fulfilling a certain condition (second argument) "
"are selected and updated by replacing attributes as specified "
"in the funlist (third argument). The output "
"distributed relation contains updated tuples extended "
"with old attribute values and TID attribute. ",
"query drel1 drelfilterupdate[.No > 5; No: .No + 1]"
);
/*
5.4 Definitions
5.4.1 Definition of ~dreladdid~
*/
Operator dreladdidOp (
"dreladdid",
dreladdidSpec.getStr( ),
2,
dreldmapVM,
dreldmapUpdSelect,
dreladdidTM
);
/*
5.4.2 Definition of ~drelfilteraddid~
*/
Operator drelfilteraddidOp (
"drelfilteraddid",
drelfilteraddidSpec.getStr( ),
2,
dreldmapVM,
dreldmapUpdSelect,
drelfilteraddidTM
);
/*
5.4.3 Definition of ~drelfilterdelete~
*/
Operator drelfilterdeleteOp (
"drelfilterdelete",
drelfilterdeleteSpec.getStr( ),
2,
dreldmapVM,
dreldmapUpdSelect,
drelfilterdeleteTM
);
/*
5.4.4 Definition of ~drelfilterupdate~
*/
Operator drelfilterupdateOp (
"drelfilterupdate",
drelfilterupdateSpec.getStr( ),
2,
dreldmapVM,
dreldmapUpdSelect,
drelfilterupdateTM
);
/*
6. Operators ~drelexactmatchS~, ~drelrangeS~, ~drelwindowintersectsS~
6.1 Type Mapping functions
6.1.1 Type Mapping of ~drelexactmatchS~, ~drelrangeS~
*/
//RANGE 2, EXACTMATCH 3
template<int operatorId>
ListExpr drelindexquerySTM (ListExpr args){
//check number of arguments 2/3
if( !nl->HasLength( args, 2 ) && !nl->HasLength( args, 3 ) ){
return listutils::typeError("wrong number of arguments");
}
if(!DRelHelpers::isListOfTwoElemLists( args ) ){
return listutils::typeError("internal error");
}
ListExpr darrayBTreeType = nl->First( nl->First( args ) );
if( !DArray::checkType( darrayBTreeType ) ){
return listutils::typeError(
"first argument is not a darray");
}
ListExpr args2;
if( operatorId == 2 ){
args2 = nl->ThreeElemList(
nl->Second( darrayBTreeType ),
nl->First( nl->Second( args ) ),
nl->First( nl->Third( args ) ) );
} else {
args2 = nl->TwoElemList(
nl->Second( darrayBTreeType ),
nl->First( nl->Second( args ) ) );
}
ListExpr result = IndexQuerySTypeMap<operatorId>( args2 );
if(!listutils::isTupleStream( result ) ){
return result;
}
ListExpr resType = nl->TwoElemList(
listutils::basicSymbol<DFArray>( ),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( result ) ) );
std::string funText;
if( operatorId == 2 ){
funText = "(fun (elem1 ARRAYFUNARG1) (rangeS elem1 " +
nl->ToString( nl->Second( nl->Second( args ) ) ) + " " +
nl->ToString( nl->Second( nl->Third( args ) ) ) + ")) ";
} else {
funText = "(fun (elem1 ARRAYFUNARG1) (exactmatchS elem1 " +
nl->ToString( nl->Second( nl->Second( args ) ) ) + ")) ";
}
ListExpr append = nl->OneElemList( nl->TextAtom( funText ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
6.1.2 Type Mapping of ~drelwindowintersectsS~
*/
ListExpr drelwindowintersectsSTM (ListExpr args){
if( !nl->HasLength( args, 2 ) ){
return listutils::typeError("wrong number of arguments");
}
if(!DRelHelpers::isListOfTwoElemLists( args ) ){
return listutils::typeError("internal error");
}
ListExpr darrayRTreeType = nl->First( nl->First( args ) );
if( !DArray::checkType( darrayRTreeType ) ){
return listutils::typeError(
"first argument is not a darray");
}
ListExpr result = WindowIntersectsSTypeMap(
nl->TwoElemList(
nl->Second( darrayRTreeType ),
nl->First( nl->Second( args ) ) ) );
if(!listutils::isTupleStream( result ) ){
return result;
}
ListExpr resType = nl->TwoElemList(
listutils::basicSymbol<DFArray>( ),
nl->TwoElemList(
listutils::basicSymbol<Relation>(),
nl->Second( result ) ) );
std::string fun = "(fun (elem1 ARRAYFUNARG1) (windowintersectsS elem1 " +
nl->ToString( nl->Second( nl->Second( args ) ) ) + ")) ";
ListExpr append = nl->OneElemList( nl->TextAtom( fun ) );
return nl->ThreeElemList(
nl->SymbolAtom(Symbols::APPEND()),
append,
resType);
}
/*
6.2 Value Mapping function
used by ~drelexactmatchS~, ~drelrangeS~, ~drelwindowintersectsS~ operators
*/
template<class A>
int dreldmapSVMT(Word* args, Word& result, int message,
Word& local, Supplier s ){
int argsNum = qp->GetNoSons( s );
A* darray = (A*) args[0].addr;
FText* funText = (FText*) args[argsNum - 1].addr;
result = qp->ResultStorage(s);
DFArray* resultDFArray = (DFArray*)result.addr;
ListExpr arg1ptr = DRelHelpers::createPointerList
(qp->GetType( qp->GetSon(s, 0) ), darray);
std::string query = "(dmap " + nl->ToString( arg1ptr ) +
"\"\" " + funText->GetValue() + ")";
Word qRes;
if( !QueryProcessor::ExecuteQuery( query, qRes ) ) {
resultDFArray->makeUndefined();
return 0;
} else {
resultDFArray = (DFArray*) qRes.addr;
result.setAddr(resultDFArray);
}
return 0;
}
ValueMapping dreldmapSVM[] = {
dreldmapSVMT<DArray>,
dreldmapSVMT<DFArray>
};
int dreldmapSUpdSelect( ListExpr args ){
return DArray::checkType( nl->First( args ) ) ? 0 : 1;
}
/*
6.3 Specifications
6.3.1 Specification of ~drelexactmatchS~
*/
OperatorSpec drelexactmatchSSpec(
" da(btree(tuple(X))) x ti -> dfarray(rel(tuple(Id tid)))",
" _ drelexactmatchS [_]",
"Uses the given distributed btree to find all tuple "
"identifiers where the key matches argument value ti. ",
"query da_btree drelexactmatchS [10]"
);
/*
6.3.2 Specification of ~drelrangeS~
*/
OperatorSpec drelrangeSSpec(
" da(btree(tuple(X))) x ti x ti-> dfarray(rel(tuple(Id tid)))",
" _ drelrangeS [_, _]",
"Uses the given distributed btree to find all tuple "
"identifiers where the key is between argument values ti. ",
"query da_btree drelrangeS [5, 10]"
);
/*
6.3.3 Specification of ~drelwindowintersectsS~
*/
OperatorSpec drelwindowintersectsSSpec(
" da(rtree(tuple(X))) x ti -> dfarray(rel(tuple(Id tid)))",
" _ drelwindowintersectsS [_]",
"Uses the given distributed rtree to find all tuple "
"identifiers whose bounding box intersects with "
"ti bounding box. The argument value ti can be in "
"{rect<d>} or SPATIAL<d>D, where d in {2, 3, 4, 8}.",
"query da_rtree drelwindowintersectsS [ bbox(thecenter) ]"
);
/*
6.4 Definitions
6.4.1 Definition of ~drelexactmatchS~
*/
Operator drelexactmatchSOp (
"drelexactmatchS",
drelexactmatchSSpec.getStr( ),
2,
dreldmapSVM,
dreldmapSUpdSelect,
drelindexquerySTM<3>
);
/*
6.4.2 Definition of ~drelrangeS~
*/
Operator drelrangeSOp (
"drelrangeS",
drelrangeSSpec.getStr( ),
2,
dreldmapSVM,
dreldmapSUpdSelect,
drelindexquerySTM<2>
);
/*
6.4.3 Definition of ~drelwindowintersectsS~
*/
Operator drelwindowintersectsSOp (
"drelwindowintersectsS",
drelwindowintersectsSSpec.getStr( ),
2,
dreldmapSVM,
dreldmapSUpdSelect,
drelwindowintersectsSTM
);
class DistributedUpdateAlgebra : public Algebra{
public:
DistributedUpdateAlgebra() : Algebra(){
AddOperator(&drelinsertOp);
AddOperator(&drelinserttupleOp);
AddOperator(&dreldeleteOp);
AddOperator(&drelupdateOp);
drelupdateOp.SetUsesArgsInTypeMapping( );
AddOperator(&dreldeletebyidOp);
AddOperator(&drelupdatebyidOp);
drelupdatebyidOp.SetUsesArgsInTypeMapping( );
AddOperator(&drelinsertrtreeOp);
AddOperator(&dreldeletertreeOp);
AddOperator(&drelupdatertreeOp);
AddOperator(&drelinsertbtreeOp);
AddOperator(&dreldeletebtreeOp);
AddOperator(&drelupdatebtreeOp);
AddOperator(&dreladdidOp);
AddOperator(&drelfilteraddidOp);
drelfilteraddidOp.SetUsesArgsInTypeMapping( );
AddOperator(&drelfilterdeleteOp);
drelfilterdeleteOp.SetUsesArgsInTypeMapping( );
AddOperator(&drelfilterupdateOp);
drelfilterupdateOp.SetUsesArgsInTypeMapping( );
AddOperator(&drelexactmatchSOp);
drelexactmatchSOp.SetUsesArgsInTypeMapping( );
AddOperator(&drelrangeSOp);
drelrangeSOp.SetUsesArgsInTypeMapping( );
AddOperator(&drelwindowintersectsSOp);
drelwindowintersectsSOp.SetUsesArgsInTypeMapping( );
AddOperator(&drelspatialjoinOp);
drelspatialjoinOp.SetUsesArgsInTypeMapping( );
}
};
} //end of namespace drelupdate
extern "C"
Algebra*
InitializeDistributedUpdateAlgebra( NestedList* nlRef,
QueryProcessor* qpRef ) {
return new drelupdate::DistributedUpdateAlgebra ();
}
Reference in New Issue Copy Permalink