1761 lines
59 KiB
C++
1761 lines
59 KiB
C++
/*
|
|
----
|
|
This file is part of SECONDO.
|
|
|
|
Copyright (C) 2012, University in Hagen
|
|
Faculty of Mathematic 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 "Compute.h"
|
|
|
|
#include "NestedList.h"
|
|
#include "ListUtils.h"
|
|
#include "Utils.h"
|
|
|
|
#include "PropertyGraphMem.h"
|
|
#include "PropertyGraphQueryProcessor.h"
|
|
#include "QueryTree.h"
|
|
|
|
#include "SecondoInterfaceTTY.h"
|
|
#include "SecondoInterface.h"
|
|
#include "SecParser.h"
|
|
#include "QueryProcessor.h"
|
|
|
|
#include <fstream>
|
|
|
|
|
|
using namespace std;
|
|
|
|
namespace pgraph2 {
|
|
|
|
//----------------------------------------------------------------------------
|
|
Compute::Compute(PGraphQueryProcessor *pgp, QueryTree *tree, \
|
|
std::string pgstructure)
|
|
{
|
|
pgprocessor=pgp;
|
|
querytree=tree;
|
|
structure=pgstructure;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Compute::Compute(PGraphQueryProcessor *pgp,QueryTree *tree, \
|
|
std::string pgstructure, std::string tmptuplestream)
|
|
{
|
|
pgprocessor=pgp;
|
|
querytree=tree;
|
|
structure=pgstructure;
|
|
tuplestream = tmptuplestream;
|
|
withtuplestream=true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Compute::~Compute()
|
|
{
|
|
for (uint i=0; i<messageslist.size(); i++)
|
|
{
|
|
delete messageslist.at(i);
|
|
}
|
|
|
|
if (pgprocessor!=NULL) delete pgprocessor;
|
|
if (querytree!=NULL) querytree=NULL;
|
|
if (_InputRelationIteratorPregel!=NULL) _InputRelationIteratorPregel=NULL;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::CreateComputeFunction()
|
|
{
|
|
|
|
SetOutputFields();
|
|
SetFilterFields();
|
|
|
|
CreateHeaderString();
|
|
CreateProjectString();
|
|
CreateResults();
|
|
CreateInitialMessage();
|
|
|
|
CreateMessages();
|
|
std::string messagestring=ReadMessages();
|
|
gesamtstring=headerstring+messagestring;
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::CreateResults()
|
|
{
|
|
string outputf=GetOutputFieldsWithDatatype();
|
|
resultstring="let Results = [const rel(tuple(["+outputf+"])) value ()];";
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::CreateInitialMessage()
|
|
{
|
|
//Senderliste
|
|
int counter = pgprocessor->poslist.size();
|
|
string sender = "";
|
|
for (int i=0; i<counter; i++)
|
|
{
|
|
stringstream ss;
|
|
ss << i+1;
|
|
string strcounter = ss.str();
|
|
if (i == 0)
|
|
{
|
|
sender=sender+" Sender"+strcounter+": 0";
|
|
}
|
|
else
|
|
{
|
|
sender=sender+", Sender"+strcounter+": 0";
|
|
}
|
|
|
|
}
|
|
|
|
|
|
string filterf="";
|
|
std::vector<std::vector<std::string>> v;
|
|
std::map<std::string, std::vector<std::vector<std::string>>>::iterator\
|
|
itf = filterfields.find(querytree->Root->TypeName);
|
|
if (!withtuplestream)
|
|
{
|
|
if (itf != filterfields.end())
|
|
{
|
|
v=filterfields[querytree->Root->TypeName];
|
|
std::vector<std::vector<std::string>> tmpvector;
|
|
std::vector<std::string> tmpvector2;
|
|
uint vsize=v.size();
|
|
for (int i=vsize-1; i>=0; i--)
|
|
{
|
|
bool samefilter=false;
|
|
for (uint i2=0; i2<tmpvector.size();i2++)
|
|
{
|
|
if (v.at(i).at(1) == tmpvector.at(i2).at(0) && \
|
|
v.at(i).at(2) == tmpvector.at(i2).at(1)) samefilter=true;
|
|
}
|
|
|
|
if (!samefilter)
|
|
{
|
|
if (v.at(i).at(4) == "string" || v.at(i).at(4) == "text")
|
|
{
|
|
filterf=filterf+"filter[."+v.at(i).at(1)+v.at(i).at(2)+"\""
|
|
+v.at(i).at(3)+"\"] ";
|
|
}
|
|
else
|
|
{
|
|
filterf=filterf+"filter[."
|
|
+v.at(i).at(1)+v.at(i).at(2)+v.at(i).at(3)+"] ";
|
|
}
|
|
tmpvector2.erase(tmpvector2.begin(),tmpvector2.end());
|
|
tmpvector2.push_back(v.at(i).at(1));
|
|
tmpvector2.push_back(v.at(i).at(2));
|
|
tmpvector.push_back(tmpvector2);
|
|
if (v.size() > 1)
|
|
{
|
|
v.erase(v.begin()+i);
|
|
filterfields[querytree->Root->TypeName]=v;
|
|
}
|
|
else
|
|
{
|
|
filterfields.erase(querytree->Root->TypeName);
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
string outputfi = GetOutputFieldsWithoutDatatype(true);
|
|
|
|
RelationInfo *relinforoot = pgprocessor->pgraphMem->\
|
|
RelRegistry.GetRelationInfo(querytree->Root->TypeName);
|
|
if (!withtuplestream)
|
|
{
|
|
initialmessage="let InitialMessages = "+querytree->Root->TypeName
|
|
+"P feed "+filterf+"projectextend[; NodeId: ."+relinforoot->IdFieldName
|
|
+", Partition: part(."+relinforoot->IdFieldName
|
|
+"), Message: \""+querytree->Root->TypeName+"1\","
|
|
+sender+", "+outputfi+"] consume;\n\n\n";
|
|
}
|
|
else
|
|
{
|
|
|
|
static const size_t npos = -1;
|
|
size_t pos;
|
|
string initialtuple=tuplestream;
|
|
string rest="";
|
|
RelationInfo *relinfoinitial;
|
|
pos = initialtuple.find(" ");
|
|
|
|
while (pos != std::string::npos)
|
|
{
|
|
pos = initialtuple.find(" ");
|
|
rest = initialtuple.substr(pos+1);
|
|
initialtuple.erase(pos,npos);
|
|
cout << "erster Tupelstrom: " << initialtuple << endl;
|
|
|
|
relinfoinitial = pgprocessor->pgraphMem->\
|
|
RelRegistry.GetRelationInfo(initialtuple);
|
|
if (relinfoinitial != NULL) break;
|
|
|
|
initialtuple = initialtuple.substr(0, initialtuple.size()-1);
|
|
cout << "zweiter Tupelstrom: " << initialtuple << endl;
|
|
relinfoinitial = pgprocessor->pgraphMem->\
|
|
RelRegistry.GetRelationInfo(initialtuple);
|
|
if (relinfoinitial != NULL) break;
|
|
|
|
initialtuple=rest;
|
|
cout << "dritter Tupelstrom: " << initialtuple << endl;
|
|
pos = initialtuple.find(" ");
|
|
}
|
|
|
|
if (relinfoinitial == NULL)
|
|
{
|
|
throw PGraph2Exception("initial relation not found");
|
|
}
|
|
else
|
|
{
|
|
initialmessage="let InitialMessages = "+tuplestream
|
|
+" projectextend[; NodeId: ."+relinfoinitial->IdFieldName
|
|
+", Partition: part(."+relinfoinitial->IdFieldName
|
|
+"), Message: \""+querytree->Root->TypeName+"1\","
|
|
+sender+", "+outputfi+"] consume;\n\n\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::CreateHeaderString()
|
|
{
|
|
bool withdatatype=true;
|
|
tuplestring=GetTupleString(withdatatype);
|
|
headerstring="query fun (messages: stream(tuple(["+tuplestring+"]))) \n"
|
|
"messages \n"
|
|
"loopsel[fun(t: TUPLE)\n"
|
|
"attr(t, Message) \n"
|
|
"switch[ \n";
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::CreateProjectString()
|
|
{
|
|
bool withdatatype=false;
|
|
string tuplestringwithoutdatatype=GetTupleString(withdatatype);
|
|
projectstring="project["+tuplestringwithoutdatatype+"] \n";
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::string Compute::GetTupleString(bool withdatatype)
|
|
{
|
|
string messagebegin="";
|
|
if (withdatatype)
|
|
{
|
|
messagebegin="NodeId: int, Partition: int, Message: string,";
|
|
}
|
|
else
|
|
{
|
|
messagebegin="NodeId, Partition, Message,";
|
|
}
|
|
|
|
//Senderliste
|
|
int counter = pgprocessor->poslist.size();
|
|
string sender = "";
|
|
for (int i=0; i<counter; i++)
|
|
{
|
|
stringstream ss;
|
|
ss << i+1;
|
|
string strcounter = ss.str();
|
|
if (withdatatype)
|
|
{
|
|
if (i == 0)
|
|
{
|
|
sender=sender+" Sender"+strcounter+": int";
|
|
}
|
|
else
|
|
{
|
|
sender=sender+", Sender"+strcounter+": int";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (i == 0)
|
|
{
|
|
sender=sender+" Sender"+strcounter;
|
|
}
|
|
else
|
|
{
|
|
sender=sender+", Sender"+strcounter;
|
|
}
|
|
}
|
|
}
|
|
|
|
//value
|
|
string messagevalues=", ";
|
|
|
|
//OutputFields
|
|
string outputf="";
|
|
if (withdatatype)
|
|
{
|
|
outputf=GetOutputFieldsWithDatatype();
|
|
}
|
|
else
|
|
{
|
|
outputf=GetOutputFieldsWithoutDatatype(false);
|
|
}
|
|
|
|
string komplett = messagebegin+sender+messagevalues+outputf;
|
|
|
|
return komplett;
|
|
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
void Compute::SetOutputFields()
|
|
{
|
|
for(auto&& outputfield:querytree->outputFields.Fields)
|
|
{
|
|
string alias=outputfield->NodeAlias;
|
|
string relname="";
|
|
//hole für jeden Alias den Relationenname
|
|
for (auto&& aliasfield:querytree->AliasList.list)
|
|
{
|
|
if (aliasfield.AliasName==alias)
|
|
{
|
|
relname=aliasfield.TypeName;
|
|
break;
|
|
}
|
|
}
|
|
RelationInfo *relinfo=pgprocessor->pgraphMem->\
|
|
RelRegistry.GetRelationInfo(relname);
|
|
AttrInfo *ainfo=relinfo->RelSchema.\
|
|
GetAttrInfo(outputfield->PropertyName);
|
|
string attrtype=ainfo->TypeName;
|
|
|
|
std::vector<string> relvector;
|
|
relvector.push_back(outputfield->NodeAlias); //alias
|
|
relvector.push_back(outputfield->OutputName); //outputname
|
|
relvector.push_back(outputfield->PropertyName); //attributname
|
|
relvector.push_back(attrtype); //attributtype
|
|
|
|
std::map<std::string, std::vector<std::vector \
|
|
<std::string>>>::iterator it;
|
|
it = outputfields.find(relname);
|
|
if (it != outputfields.end())
|
|
{
|
|
std::vector v = outputfields[relname];
|
|
v.push_back(relvector);
|
|
outputfields[relname]=v;
|
|
}
|
|
else
|
|
{
|
|
std::vector<std::vector<std::string>> v;
|
|
v.push_back(relvector);
|
|
outputfields[relname]=v;
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::SetFilterFields()
|
|
{
|
|
string filteroperator="=";
|
|
bool filterexists=false;
|
|
std::vector<std::vector<std::string>> v;
|
|
RelationInfo *relinfo;
|
|
AttrInfo *ainfo;
|
|
string attrtype="";
|
|
std::map<std::string, std::vector<std::vector<std::string>>>::iterator it;
|
|
for (uint i=0; i<pgprocessor->poslist.size(); i++)
|
|
{
|
|
QueryTreeEdge *filteredge = pgprocessor->poslist.at(i);
|
|
std::vector<string> relvector;
|
|
for (auto&& filterfield:filteredge->FromNode->Filters)
|
|
{
|
|
relinfo=pgprocessor->pgraphMem->RelRegistry.\
|
|
GetRelationInfo(filteredge->FromNode->TypeName);
|
|
ainfo=relinfo->RelSchema.GetAttrInfo(filterfield->Name);
|
|
attrtype=ainfo->TypeName;
|
|
filterexists=false;
|
|
relvector.erase(relvector.begin(),relvector.end());
|
|
relvector.push_back(filteredge->FromNode->Alias); //alias
|
|
relvector.push_back(filterfield->Name); //attributname
|
|
relvector.push_back(filteroperator);
|
|
//Operator - Bei Nodefilter immer "="
|
|
relvector.push_back(filterfield->Value); // filtervalue
|
|
relvector.push_back(attrtype); //Attributtype
|
|
|
|
it = filterfields.find(filteredge->FromNode->TypeName);
|
|
if (it != filterfields.end())
|
|
{
|
|
v = filterfields[filteredge->FromNode->TypeName];
|
|
for (uint i=0; i<v.size(); i++)
|
|
{
|
|
if (relvector.at(1) == v.at(i).at(1) && \
|
|
relvector.at(2) == v.at(i).at(2) && \
|
|
relvector.at(3) == v.at(i).at(3))
|
|
{
|
|
filterexists=true;
|
|
break;
|
|
}
|
|
}
|
|
if (!filterexists) v.push_back(relvector);
|
|
}
|
|
else
|
|
{
|
|
v.push_back(relvector);
|
|
}
|
|
|
|
filterfields[filteredge->FromNode->TypeName]=v;
|
|
}
|
|
|
|
|
|
for (auto&& filterfield:filteredge->ToNode->Filters)
|
|
{
|
|
relinfo=pgprocessor->pgraphMem->RelRegistry.\
|
|
GetRelationInfo(filteredge->ToNode->TypeName);
|
|
ainfo=relinfo->RelSchema.GetAttrInfo(filterfield->Name);
|
|
attrtype=ainfo->TypeName;
|
|
filterexists=false;
|
|
v.erase(v.begin(),v.end());
|
|
//v durch ersten Durchlauf ggf. noch gesetzt.
|
|
relvector.erase(relvector.begin(),relvector.end());
|
|
relvector.push_back(filteredge->ToNode->Alias); //alias
|
|
relvector.push_back(filterfield->Name); //attributname
|
|
relvector.push_back(filteroperator);
|
|
//Operator - Bei Nodefilter immer "="
|
|
relvector.push_back(filterfield->Value); // filtervalue
|
|
relvector.push_back(attrtype); //Attributtype
|
|
|
|
it = filterfields.find(filteredge->ToNode->TypeName);
|
|
if (it != filterfields.end())
|
|
{
|
|
v = filterfields[filteredge->ToNode->TypeName];
|
|
for (uint i=0; i<v.size(); i++)
|
|
{
|
|
if (relvector.at(1) == v.at(i).at(1) && \
|
|
relvector.at(2) == v.at(i).at(2) && \
|
|
relvector.at(3) == v.at(i).at(3))
|
|
{
|
|
filterexists=true;
|
|
break;
|
|
}
|
|
}
|
|
if (!filterexists) v.push_back(relvector);
|
|
}
|
|
else
|
|
{
|
|
v.push_back(relvector);
|
|
}
|
|
|
|
filterfields[filteredge->ToNode->TypeName]=v;
|
|
}
|
|
}
|
|
|
|
for(auto&& filterfield:querytree->filterList.Fields)
|
|
{
|
|
string alias=filterfield->NodeAlias;
|
|
string relname="";
|
|
//hole für jeden Alias den Relationenname
|
|
for (auto&& aliasfield:querytree->AliasList.list)
|
|
{
|
|
if (aliasfield.AliasName==alias)
|
|
{
|
|
relname=aliasfield.TypeName;
|
|
break;
|
|
}
|
|
}
|
|
relinfo=pgprocessor->pgraphMem->\
|
|
RelRegistry.GetRelationInfo(relname);
|
|
ainfo=relinfo->RelSchema.GetAttrInfo(filterfield->PropertyName);
|
|
attrtype=ainfo->TypeName;
|
|
|
|
std::vector<string> relvector;
|
|
v.erase(v.begin(),v.end());
|
|
//v durch ersten Durchlauf ggf. noch gesetzt.
|
|
relvector.push_back(filterfield->NodeAlias); //alias
|
|
relvector.push_back(filterfield->PropertyName); //attributname
|
|
relvector.push_back(filterfield->Operator); //operator
|
|
relvector.push_back(filterfield->FilterValue); //filtervalue
|
|
relvector.push_back(attrtype); //attributtype
|
|
|
|
it = filterfields.find(relname);
|
|
if (it != filterfields.end())
|
|
{
|
|
v = filterfields[relname];
|
|
v.push_back(relvector);
|
|
filterfields[relname]=v;
|
|
}
|
|
else
|
|
{
|
|
v.push_back(relvector);
|
|
filterfields[relname]=v;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::string Compute::GetOutputFieldsWithDatatype()
|
|
{
|
|
string outputstring="";
|
|
for (std::map<std::string, std::vector<std::vector<string>>>::iterator \
|
|
it = outputfields.begin(); it != outputfields.end(); it++)
|
|
{
|
|
for (uint i=0; i<it->second.size(); i++)
|
|
{
|
|
if (i==0 && it==outputfields.begin())
|
|
{
|
|
outputstring=outputstring+it->second.at(i).at(1)
|
|
+": "+it->second.at(i).at(3);
|
|
}
|
|
else
|
|
{
|
|
outputstring=outputstring+", "+it->second.at(i).at(1)
|
|
+": "+it->second.at(i).at(3);
|
|
}
|
|
}
|
|
}
|
|
return outputstring;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::string Compute::GetOutputFieldsWithoutDatatype(bool initial)
|
|
{
|
|
string outputstring="";
|
|
if (!initial)
|
|
{
|
|
for (std::map<std::string, std::vector<std::vector<string>>>::iterator \
|
|
it = outputfields.begin(); it != outputfields.end(); it++)
|
|
{
|
|
for (uint i=0; i<it->second.size(); i++)
|
|
{
|
|
if (i==0 && it==outputfields.begin())
|
|
{
|
|
outputstring=outputstring+it->second.at(i).at(1);
|
|
}
|
|
else
|
|
{
|
|
outputstring=outputstring+", "+it->second.at(i).at(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (std::map<std::string, std::vector<std::vector<string>>>::iterator \
|
|
it = outputfields.begin(); it != outputfields.end(); it++)
|
|
{
|
|
for (uint i=0; i<it->second.size(); i++)
|
|
{
|
|
if (it->second.at(i).at(3) == "string")
|
|
{
|
|
if (i==0 && it==outputfields.begin())
|
|
{
|
|
outputstring=outputstring
|
|
+it->second.at(i).at(1)+": \"\"";
|
|
}
|
|
else
|
|
{
|
|
outputstring=outputstring+", "
|
|
+it->second.at(i).at(1)+": \"\"";
|
|
}
|
|
}
|
|
if (it->second.at(i).at(3) == "int")
|
|
{
|
|
if (i==0 && it==outputfields.begin())
|
|
{
|
|
outputstring=outputstring
|
|
+it->second.at(i).at(1)+": 0";
|
|
}
|
|
else
|
|
{
|
|
outputstring=outputstring
|
|
+", "+it->second.at(i).at(1)+": 0";
|
|
}
|
|
}
|
|
if (it->second.at(i).at(3) == "text")
|
|
{
|
|
if (i==0 && it==outputfields.begin())
|
|
{
|
|
outputstring=outputstring
|
|
+it->second.at(i).at(1)+": ''";
|
|
}
|
|
else
|
|
{
|
|
outputstring=outputstring+", "
|
|
+it->second.at(i).at(1)+": ''";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
return outputstring;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::CreateMessages()
|
|
{
|
|
std::vector<bool> sendervec;
|
|
std::map<std::string, std::vector<std::vector<std::string>>>* \
|
|
outputs=&outputfields;
|
|
std::map<std::string, std::vector<std::vector<std::string>>>* \
|
|
filters=&filterfields;
|
|
uint senderindex=0;
|
|
int messagecounter=1;
|
|
string actnodename=querytree->Root->TypeName;
|
|
bool goback=false;
|
|
bool last=false;
|
|
for (uint posindex=0; posindex<pgprocessor->poslist.size(); posindex++)
|
|
{
|
|
QueryTreeEdge *actedge=pgprocessor->poslist.at(posindex);
|
|
if (actedge->FromNode->TypeName == actnodename)
|
|
{
|
|
|
|
senderindex=sendervec.size()+1;
|
|
Message *message=new Message(pgprocessor, \
|
|
actedge,outputs,filters,messagecounter, \
|
|
senderindex, structure, withtuplestream);
|
|
message->CreateMessageString();
|
|
messageslist.push_back(message);
|
|
sendervec.push_back(true);
|
|
actnodename=actedge->ToNode->TypeName;
|
|
messagecounter++;
|
|
|
|
}
|
|
else
|
|
{
|
|
goback=true;
|
|
for (senderindex=sendervec.size()-1; senderindex>=0; senderindex--)
|
|
{
|
|
if (sendervec.at(senderindex)) break;
|
|
}
|
|
Message *message=new Message(pgprocessor, \
|
|
pgprocessor->poslist.at(senderindex),outputs,filters, \
|
|
messagecounter, goback, senderindex+1, structure, \
|
|
withtuplestream);
|
|
message->CreateMessageString();
|
|
messageslist.push_back(message);
|
|
actnodename=pgprocessor->poslist.at(senderindex)->\
|
|
FromNode->TypeName;
|
|
messagecounter++;
|
|
sendervec.at(senderindex)=false;
|
|
posindex--;
|
|
goback=false;
|
|
}
|
|
}
|
|
last=true;
|
|
Message *message=new Message(pgprocessor,actnodename, \
|
|
outputs,filters,messagecounter, last, structure, withtuplestream);
|
|
message->CreateMessageString();
|
|
messageslist.push_back(message);
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::string Compute::ReadMessages()
|
|
{
|
|
std::string messagestring="";
|
|
for (uint i=0; i<messageslist.size(); i++)
|
|
{
|
|
messagestring=messagestring+
|
|
messageslist.at(i)->GetGesamtMessageString();
|
|
if (messageslist.at(i)->lastmessage == true)
|
|
{
|
|
std::string tmpprojectstring="projectextend[; "+tuplestring+"] \n";
|
|
ReplaceStringInPlace(tmpprojectstring," int","0");
|
|
ReplaceStringInPlace(tmpprojectstring," string","\"\"");
|
|
ReplaceStringInPlace(tmpprojectstring," text","''");
|
|
messagestring=messagestring+tmpprojectstring;
|
|
}
|
|
else
|
|
{
|
|
messagestring=messagestring+projectstring;
|
|
}
|
|
}
|
|
messagestring=messagestring+"; NoMessages()] \n"
|
|
"] \n";
|
|
return messagestring;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
int Compute::GetMaxId(string relname, string attrname)
|
|
{
|
|
Word resultword;
|
|
string querystring="(max (feed " +relname+ ")"+attrname+")";
|
|
QueryProcessor::ExecuteQuery(querystring, resultword);
|
|
CcInt* intzeiger = (CcInt*) resultword.addr;
|
|
|
|
int relcount = intzeiger->GetIntval();
|
|
delete intzeiger;
|
|
return relcount;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::CreateObjects()
|
|
{
|
|
|
|
std::ofstream ofs;
|
|
|
|
if (structure == "pregelmemory")
|
|
{
|
|
std::map<std::string, int>::iterator mapiterator;
|
|
|
|
Relations[querytree->Root->TypeName] = 0;
|
|
for (uint i=0; i<pgprocessor->poslist.size(); i++)
|
|
{
|
|
mapiterator = Edges.find(pgprocessor->poslist.at(i)->TypeName);
|
|
if (mapiterator == Edges.end())
|
|
Edges[pgprocessor->poslist.at(i)->TypeName] = 0;
|
|
|
|
mapiterator = Relations.find(pgprocessor->\
|
|
poslist.at(i)->ToNode->TypeName);
|
|
if (mapiterator == Relations.end())
|
|
Relations[pgprocessor->poslist.at(i)->ToNode->TypeName] = 0;
|
|
}
|
|
|
|
|
|
RelationInfo* relinfo=NULL;
|
|
AttrInfo *ainfo;
|
|
AttrInfo *ainfo2;
|
|
ofs.open("creatememoryobjectspregellocal.sec", std::ofstream::out);
|
|
|
|
for (mapiterator = Relations.begin(); mapiterator != Relations.end(); \
|
|
mapiterator++)
|
|
{
|
|
relinfo=pgprocessor->pgraphMem->RelRegistry.\
|
|
GetRelationInfo(mapiterator->first);
|
|
ofs << "query isdefined(deleteObject(\""
|
|
+mapiterator->first+"M\"));" << endl;
|
|
ofs << "query isdefined(deleteObject(\""
|
|
+mapiterator->first+"MI\"));" << endl;
|
|
ofs << "let "+mapiterator->first+"M = "
|
|
+mapiterator->first+" feed head[1] mconsume;" << endl;
|
|
ofs << "let "+mapiterator->first+"MI = "+mapiterator->first
|
|
+"M mcreateAVLtree["+relinfo->IdFieldName+"]; \n" << endl;
|
|
}
|
|
|
|
for (mapiterator = Edges.begin(); mapiterator != Edges.end(); \
|
|
mapiterator++)
|
|
{
|
|
relinfo=pgprocessor->pgraphMem->RelRegistry.\
|
|
GetRelationInfo(mapiterator->first);
|
|
ainfo=relinfo->RelSchema.GetAttrInfo(0);
|
|
ainfo2=relinfo->RelSchema.GetAttrInfo(1);
|
|
int maxid = GetMaxId(relinfo->FromName,ainfo->Name);
|
|
int maxid2 = GetMaxId(relinfo->ToName,ainfo2->Name);
|
|
if (maxid >= maxid2)
|
|
{
|
|
Edges[mapiterator->first]=maxid+1;
|
|
}
|
|
else
|
|
{
|
|
Edges[mapiterator->first]=maxid2+1;
|
|
}
|
|
stringstream ss;
|
|
ss << Edges[mapiterator->first];
|
|
string globalmaxid = ss.str();
|
|
//ss << relinfo->statistics->cardinality;
|
|
//string strcardinality = ss.str();
|
|
ofs << "query isdefined(deleteObject(\""
|
|
+mapiterator->first+"M\"));" << endl;
|
|
ofs << "query isdefined(deleteObject(\""
|
|
+mapiterator->first+"_BM\"));" << endl;
|
|
ofs << "let "+mapiterator->first+"M = "+mapiterator->first
|
|
+" feed head[1] createmgraph3["+ainfo->Name+", "
|
|
+ainfo2->Name+", Cost, "+globalmaxid+"];" << endl;
|
|
ofs << "let "+mapiterator->first+"_BM = "+mapiterator->first
|
|
+"_B feed head[1] createmgraph3["+ainfo2->Name+", "
|
|
+ainfo->Name+", Cost, "+globalmaxid+"]; \n" << endl;
|
|
}
|
|
|
|
ofs.close();
|
|
|
|
string executescriptlocal="(executeScript "
|
|
"'creatememoryobjectspregellocal.sec' TRUE FALSE)";
|
|
Word reswordlocal;
|
|
QueryProcessor::ExecuteQuery(executescriptlocal,reswordlocal);
|
|
CcBool* zeigerlocal = (CcBool*) reswordlocal.addr;
|
|
delete zeigerlocal;
|
|
|
|
}
|
|
|
|
ofs.open("createobjectspregel.sec", std::ofstream::out);
|
|
// f.open("createobjectspregel.sec", ios::out);
|
|
ofs << "query isdefined(deleteObject(\"Results\"));" << endl;
|
|
ofs << "query isdefined(deleteObject(\"ResultsMemory\"));" << endl;
|
|
ofs << "query isdefined(deleteObject(\"InitialMessages\"));" << endl;
|
|
ofs << "query isdefined(deleteObject(\"NoMessages\"));" << endl;
|
|
ofs << "query isdefined(deleteObject(\"Compute\"));" << endl;
|
|
ofs << "query isdefined(deleteObject(\"EndResults\"));" << endl;
|
|
|
|
ofs << resultstring << "\n" << endl;
|
|
ofs << "let ResultsMemory = Results feed mconsume;" << "\n" << endl;
|
|
ofs << initialmessage << "\n" << endl;
|
|
ofs.close();
|
|
|
|
string executescript="(executeScript 'createobjectspregel.sec' TRUE FALSE)";
|
|
Word resw;
|
|
QueryProcessor::ExecuteQuery(executescript,resw);
|
|
CcBool* zeiger = (CcBool*) resw.addr;
|
|
delete zeiger;
|
|
|
|
string nomessagelist="(fun (head (feed InitialMessages)0))";
|
|
DoLet("NoMessages",nomessagelist);
|
|
|
|
SecParser sp;
|
|
string computelist="";
|
|
sp.Text2List( gesamtstring, computelist );
|
|
ReplaceStringInPlace(computelist, "(query ","");
|
|
computelist = computelist.substr(0, computelist.size()-2);
|
|
cout << "Compute: \n" << endl;
|
|
cout << gesamtstring << endl;
|
|
cout << computelist << endl;
|
|
if (structure =="pregelmemory")
|
|
{
|
|
DoLetCompute("Compute",computelist);
|
|
}
|
|
else if (structure == "pregelpersistent")
|
|
{
|
|
DoLetCompute("Compute",computelist);
|
|
}
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::ShareObjects()
|
|
{
|
|
|
|
std::ofstream ofs;
|
|
ofs.open("shareobjects.sec", std::ofstream::out);
|
|
// f.open("createobjectspregel.sec", ios::out);
|
|
ofs << "query share(\"Compute\", TRUE, Workers);" << endl;
|
|
ofs << "query share(\"part\", TRUE, Workers);" << endl;
|
|
ofs << "query share(\"NWorkers\", TRUE, Workers);" << endl;
|
|
ofs << "query share(\"InitialMessages\", TRUE, Workers);" << endl;
|
|
ofs << "query share(\"NoMessages\", TRUE, Workers);" << endl;
|
|
ofs << "query share(\"Results\", TRUE, Workers);" << endl;
|
|
ofs.close();
|
|
|
|
string sharescript="(executeScript 'shareobjects.sec' TRUE FALSE)";
|
|
Word resw;
|
|
QueryProcessor::ExecuteQuery(sharescript,resw);
|
|
CcBool* zeiger = (CcBool*) resw.addr;
|
|
delete zeiger;
|
|
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
void Compute::runPregelCommands()
|
|
{
|
|
Word resultword;
|
|
|
|
string setuppregel="(setupPregel Workers)";
|
|
string remoteResMem="(remotePregelCommand 'let ResultsMemory"
|
|
" = Results feed mconsume;')";
|
|
string setpregelfunc="(setPregelFunction Compute Partition)";
|
|
string initpregelmes="(initPregelMessages(feed InitialMessages))";
|
|
string startpregel="(startPregel -1)";
|
|
string remoteResUp="(remotePregelCommand 'update Results := "
|
|
"ResultsMemory mfeed consume')";
|
|
string dsummarize="(consume (dsummarize (createSDArray "
|
|
"\"Results\" Workers)))";
|
|
|
|
QueryProcessor::ExecuteQuery(setuppregel, resultword);
|
|
QueryProcessor::ExecuteQuery(remoteResMem, resultword);
|
|
|
|
if (structure == "pregelmemory")
|
|
{
|
|
string createremoteobj="(executeScript 'createremoteobjects.sec'"
|
|
" TRUE FALSE)";
|
|
Word reswremote;
|
|
QueryProcessor::ExecuteQuery(createremoteobj,reswremote);
|
|
CcBool* zeigerremote = (CcBool*) reswremote.addr;
|
|
delete zeigerremote;
|
|
}
|
|
|
|
QueryProcessor::ExecuteQuery(setpregelfunc, resultword);
|
|
QueryProcessor::ExecuteQuery(initpregelmes, resultword);
|
|
QueryProcessor::ExecuteQuery(startpregel, resultword);
|
|
QueryProcessor::ExecuteQuery(remoteResUp, resultword);
|
|
|
|
CcBool* zeiger = (CcBool*) resultword.addr;
|
|
delete zeiger;
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::runPregelCommandsSecond()
|
|
{
|
|
Word resultword;
|
|
|
|
string deleteResMem="(remotePregelCommand"
|
|
"'query isdefined(deleteObject(\"ResultsMemory\"));')";
|
|
string remoteResMem="(remotePregelCommand 'let ResultsMemory"
|
|
" = Results feed mconsume;')";
|
|
string setpregelfunc="(setPregelFunction Compute Partition)";
|
|
string initpregelmes="(initPregelMessages(feed InitialMessages))";
|
|
string startpregel="(startPregel -1)";
|
|
string remoteResUp="(remotePregelCommand 'update Results := "
|
|
"ResultsMemory mfeed consume')";
|
|
string dsummarize="(consume (dsummarize (createSDArray "
|
|
"\"Results\" Workers)))";
|
|
|
|
QueryProcessor::ExecuteQuery(deleteResMem, resultword);
|
|
QueryProcessor::ExecuteQuery(remoteResMem, resultword);
|
|
|
|
if (structure == "pregelmemory")
|
|
{
|
|
string createremoteobj="(executeScript 'createremoteobjects.sec'"
|
|
" TRUE FALSE)";
|
|
Word reswremote;
|
|
QueryProcessor::ExecuteQuery(createremoteobj,reswremote);
|
|
CcBool* zeigerremote = (CcBool*) reswremote.addr;
|
|
delete zeigerremote;
|
|
}
|
|
|
|
QueryProcessor::ExecuteQuery(setpregelfunc, resultword);
|
|
QueryProcessor::ExecuteQuery(initpregelmes, resultword);
|
|
QueryProcessor::ExecuteQuery(startpregel, resultword);
|
|
QueryProcessor::ExecuteQuery(remoteResUp, resultword);
|
|
|
|
CcBool* zeiger = (CcBool*) resultword.addr;
|
|
delete zeiger;
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::getEndResults()
|
|
{
|
|
std::ofstream ofs;
|
|
ofs.open("createendresults.sec", std::ofstream::out);
|
|
ofs << "let EndResults = createSDArray(\"Results\", Workers)"
|
|
" dsummarize consume;";
|
|
ofs.close();
|
|
|
|
string endresults="(executeScript 'createendresults.sec' TRUE FALSE)";
|
|
Word resw;
|
|
QueryProcessor::ExecuteQuery(endresults,resw);
|
|
CcBool* zeiger = (CcBool*) resw.addr;
|
|
delete zeiger;
|
|
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::createRemoteObjectsFile()
|
|
{
|
|
RelationInfo* relinfo=NULL;
|
|
AttrInfo *ainfo;
|
|
AttrInfo *ainfo2;
|
|
std::ofstream ofs;
|
|
ofs.open("createremoteobjects.sec", std::ofstream::out);
|
|
std::map<std::string, int>::iterator mapiterator;
|
|
|
|
ofs << "query remotePregelCommand('query meminit (1524)');" << endl;
|
|
|
|
for (mapiterator = Relations.begin(); mapiterator != Relations.end(); \
|
|
mapiterator++)
|
|
{
|
|
relinfo=pgprocessor->pgraphMem->RelRegistry.\
|
|
GetRelationInfo(mapiterator->first);
|
|
ofs << "query remotePregelCommand('let "+mapiterator->first
|
|
+"M = "+mapiterator->first+" feed mconsume;');" << endl;
|
|
ofs << "query remotePregelCommand('let "+mapiterator->first
|
|
+"MI = "+mapiterator->first+"M mcreateAVLtree["
|
|
+relinfo->IdFieldName+"];');" << endl;
|
|
}
|
|
|
|
for (mapiterator = Edges.begin(); mapiterator != Edges.end(); \
|
|
mapiterator++)
|
|
{
|
|
relinfo=pgprocessor->pgraphMem->RelRegistry.\
|
|
GetRelationInfo(mapiterator->first);
|
|
ainfo=relinfo->RelSchema.GetAttrInfo(0);
|
|
ainfo2=relinfo->RelSchema.GetAttrInfo(1);
|
|
stringstream ss;
|
|
ss << Edges[mapiterator->first];
|
|
string globalmaxid = ss.str();
|
|
//ss << relinfo->statistics->cardinality;
|
|
//string strcardinality = ss.str();
|
|
ofs << "query remotePregelCommand('let "+mapiterator->first
|
|
+"M = "+mapiterator->first+" feed createmgraph3["
|
|
+ainfo->Name+", "+ainfo2->Name+", Cost, "
|
|
+globalmaxid+"];');" << endl;
|
|
ofs << "query remotePregelCommand('let "+mapiterator->first
|
|
+"_BM = "+mapiterator->first+"_B feed createmgraph3["
|
|
+ainfo2->Name+", "+ainfo->Name+", Cost, "
|
|
+globalmaxid+"];');" << endl;
|
|
}
|
|
|
|
ofs.close();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::runPregel()
|
|
{
|
|
CreateObjects();
|
|
|
|
ShareObjects();
|
|
if (structure == "pregelmemory")
|
|
createRemoteObjectsFile();
|
|
runPregelCommands();
|
|
//getEndResults();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Compute::runPregelSecondTime()
|
|
{
|
|
CreateObjects();
|
|
|
|
ShareObjects();
|
|
if (structure == "pregelmemory")
|
|
createRemoteObjectsFile();
|
|
runPregelCommandsSecond();
|
|
//getEndResults();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Tuple *Compute::ReadNextResultTuplePregel()
|
|
{
|
|
Tuple* t = NULL;
|
|
Word resultword;
|
|
Relation* r = NULL;
|
|
Tuple* resulttuple = new Tuple(pgprocessor->_OutputTupleType);
|
|
string querystring="(consume (feed EndResults))";
|
|
|
|
if (_InputRelationIteratorPregel==NULL)
|
|
{
|
|
QueryProcessor::ExecuteQuery(querystring, resultword);
|
|
r = (Relation*) resultword.addr;
|
|
_InputRelationIteratorPregel = r->MakeScan();
|
|
t = _InputRelationIteratorPregel->GetNextTuple();
|
|
}
|
|
else
|
|
{
|
|
t = _InputRelationIteratorPregel->GetNextTuple();
|
|
}
|
|
|
|
if (t!=NULL)
|
|
{
|
|
int attrcounter=0;
|
|
std::map<std::string, std::vector<std::vector<std::string>>>::iterator \
|
|
it;
|
|
for (it = outputfields.begin(); it != outputfields.end(); it++)
|
|
{
|
|
for (uint i=0; i<it->second.size(); i++)
|
|
{
|
|
if (it->second.at(i).at(3) == "int")
|
|
{
|
|
resulttuple->PutAttribute(attrcounter, \
|
|
new CcInt( true, t->GetAttribute(attrcounter)));
|
|
attrcounter++;
|
|
}
|
|
if (it->second.at(i).at(3) == "string")
|
|
{
|
|
resulttuple->PutAttribute(attrcounter, \
|
|
new CcString( true, ((CcString*)t->\
|
|
GetAttribute(attrcounter))->GetValue()));
|
|
attrcounter++;
|
|
}
|
|
}
|
|
}
|
|
return resulttuple;
|
|
}
|
|
else
|
|
{
|
|
delete r;
|
|
_InputRelationIteratorPregel=NULL;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
Message::Message(PGraphQueryProcessor *pgp, QueryTreeEdge *qedge, \
|
|
std::map<std::string, std::vector<std::vector<std::string>>>* outputs, \
|
|
std::map<std::string, std::vector<std::vector<std::string>>>* filters, \
|
|
int indx, bool goback, uint senderid, std::string pgstructure, \
|
|
bool withtuplestream)
|
|
{
|
|
pgprocess=pgp;
|
|
edge=qedge;
|
|
outputfieldszg=outputs;
|
|
filterfieldszg=filters;
|
|
messageindex=indx;
|
|
gobackmessage=goback;
|
|
gotosender=senderid;
|
|
structure=pgstructure;
|
|
tuplestream=withtuplestream;
|
|
|
|
relinfofromnode=pgprocess->pgraphMem->RelRegistry.\
|
|
GetRelationInfo(edge->FromNode->TypeName);
|
|
relinfotonode=pgprocess->pgraphMem->RelRegistry.\
|
|
GetRelationInfo(edge->ToNode->TypeName);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Message::Message(PGraphQueryProcessor *pgp, std::string actnode, \
|
|
std::map<std::string, std::vector<std::vector<std::string>>>* outputs, \
|
|
std::map<std::string, std::vector<std::vector<std::string>>>* filters, \
|
|
int indx, bool last, std::string pgstructure, bool withtuplestream)
|
|
{
|
|
pgprocess=pgp;
|
|
actnodename=actnode;
|
|
outputfieldszg=outputs;
|
|
filterfieldszg=filters;
|
|
messageindex=indx;
|
|
lastmessage=last;
|
|
structure=pgstructure;
|
|
tuplestream=withtuplestream;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Message::Message(PGraphQueryProcessor *pgp, QueryTreeEdge *qedge, \
|
|
std::map<std::string, std::vector<std::vector<std::string>>>* outputs, \
|
|
std::map<std::string, std::vector<std::vector<std::string>>>* filters, \
|
|
int indx, uint senderid, std::string pgstructure, bool withtuplestream)
|
|
{
|
|
pgprocess=pgp;
|
|
edge=qedge;
|
|
outputfieldszg=outputs;
|
|
filterfieldszg=filters;
|
|
messageindex=indx;
|
|
gofromsender=senderid;
|
|
structure=pgstructure;
|
|
tuplestream=withtuplestream;
|
|
|
|
relinfofromnode=pgprocess->pgraphMem->RelRegistry.\
|
|
GetRelationInfo(edge->FromNode->TypeName);
|
|
relinfotonode=pgprocess->pgraphMem->RelRegistry.\
|
|
GetRelationInfo(edge->ToNode->TypeName);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Message::~Message()
|
|
{
|
|
pgprocess=NULL;
|
|
edge=NULL;
|
|
outputfieldszg=NULL;
|
|
filterfieldszg=NULL;
|
|
relinfofromnode=NULL;
|
|
relinfotonode=NULL;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Message::CreateMessageString()
|
|
{
|
|
CreateMessageName();
|
|
CreateMessageActualTupleString();
|
|
if (!gobackmessage && !lastmessage) CreateMessageActualSuccessorString();
|
|
CreateFilterString();
|
|
CreateReplaceString();
|
|
if (lastmessage) CreateLastMessageString();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Message::CreateMessageName()
|
|
{
|
|
stringstream ss;
|
|
ss << messageindex;
|
|
string strmessageindex = ss.str();
|
|
if (!lastmessage)
|
|
{
|
|
if (!gobackmessage)
|
|
{
|
|
if (messageindex == 1)
|
|
{
|
|
name=" \""+edge->FromNode->TypeName+strmessageindex+"\", \n";
|
|
}
|
|
else
|
|
{
|
|
name="; \""+edge->FromNode->TypeName+strmessageindex+"\", \n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
name="; \""+edge->ToNode->TypeName+strmessageindex+"\", \n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
name="; \""+actnodename+strmessageindex+"\", \n";
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::string Message::CreateNextMessageName()
|
|
{
|
|
string nextmessage="";
|
|
stringstream ss;
|
|
ss << messageindex+1;
|
|
string strmessageindex = ss.str();
|
|
if (!lastmessage)
|
|
{
|
|
if (!gobackmessage)
|
|
{
|
|
nextmessage="\""+edge->ToNode->TypeName+strmessageindex+"\"";
|
|
}
|
|
else
|
|
{
|
|
nextmessage="\""+edge->FromNode->TypeName+strmessageindex+"\"";
|
|
}
|
|
}
|
|
return nextmessage;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Message::CreateMessageActualTupleString()
|
|
{
|
|
if (!lastmessage)
|
|
{
|
|
if (!gobackmessage)
|
|
{
|
|
if (structure=="pregelpersistent")
|
|
{
|
|
actualtuple="loopjoin["+edge->FromNode->TypeName
|
|
+" orange[.NodeId; .NodeId] {a}] \n";
|
|
}
|
|
else if (structure=="pregelmemory")
|
|
{
|
|
actualtuple="loopjoin["+edge->FromNode->TypeName+"MI "
|
|
+edge->FromNode->TypeName+"M mexactmatch[.NodeId] {a}] \n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (structure=="pregelpersistent")
|
|
{
|
|
actualtuple="loopjoin["+edge->ToNode->TypeName
|
|
+" orange[.NodeId; .NodeId] {a}] \n";
|
|
}
|
|
else if (structure=="pregelmemory")
|
|
{
|
|
actualtuple="loopjoin["+edge->ToNode->TypeName+"MI "
|
|
+edge->ToNode->TypeName+"M mexactmatch[.NodeId] {a}] \n";
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (structure=="pregelpersistent")
|
|
{
|
|
actualtuple="loopjoin["+actnodename
|
|
+" orange[.NodeId; .NodeId] {a}] \n";
|
|
}
|
|
else if (structure=="pregelmemory")
|
|
{
|
|
actualtuple="loopjoin["+actnodename+"MI "+actnodename
|
|
+"M mexactmatch[.NodeId] {a}] \n";
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Message::CreateMessageActualSuccessorString()
|
|
{
|
|
if (edge->Reverse)
|
|
{
|
|
if (structure=="pregelpersistent")
|
|
{
|
|
actsuccessor="loopjoin["+edge->TypeName
|
|
+"_B orange[.NodeId; .NodeId] {ab}] \n";
|
|
}
|
|
else if (structure=="pregelmemory")
|
|
{
|
|
actsuccessor="loopjoin["+edge->TypeName
|
|
+"_BM mg3successors[.NodeId] {ab}] \n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (structure=="pregelpersistent")
|
|
{
|
|
actsuccessor="loopjoin["+edge->TypeName
|
|
+" orange[.NodeId; .NodeId] {ab}] \n";
|
|
}
|
|
else if (structure=="pregelmemory")
|
|
{
|
|
actsuccessor="loopjoin["+edge->TypeName
|
|
+"M mg3successors[.NodeId] {ab}] \n";
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool Message::CheckForOutputFields(std::string relname)
|
|
{
|
|
std::map<std::string, std::vector<std::vector<std::string>>>::iterator \
|
|
it = outputfieldszg->find(relname);
|
|
if (it != outputfieldszg->end())
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::vector<std::vector<std::string>> \
|
|
Message::GetOutputFields(std::string relname)
|
|
{
|
|
return outputfieldszg->at(relname);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool Message::CheckForGlobalFilters(std::string relname)
|
|
{
|
|
std::map<std::string, std::vector<std::vector<std::string>>>::iterator \
|
|
it = filterfieldszg->find(relname);
|
|
if (it != filterfieldszg->end())
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::vector<std::vector<std::string>> \
|
|
Message::GetGlobalFilters(std::string relname)
|
|
{
|
|
return filterfieldszg->at(relname);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Message::CreateFilterString()
|
|
{
|
|
std::vector<std::vector<std::string>> filterv;
|
|
|
|
if (!lastmessage)
|
|
{
|
|
if (!gobackmessage)
|
|
{
|
|
//Baue Filterstring zusammen
|
|
if (tuplestream || messageindex>1)
|
|
//Root rausgenommen, da Filter schon in InitialMessage
|
|
{
|
|
if (CheckForGlobalFilters(edge->FromNode->TypeName))
|
|
{
|
|
filterv=GetGlobalFilters(edge->FromNode->TypeName);
|
|
std::vector<std::vector<std::string>> tmpvector;
|
|
std::vector<std::string> tmpvector2;
|
|
uint vsize=filterv.size();
|
|
for (int i=vsize-1; i>=0; i--)
|
|
{
|
|
bool samefilter=false;
|
|
for (uint i2=0; i2<tmpvector.size();i2++)
|
|
{
|
|
if (filterv.at(i).at(1) == tmpvector.at(i2).at(0) && \
|
|
filterv.at(i).at(2) == "=" && \
|
|
tmpvector.at(i2).at(1) == "=") samefilter=true;
|
|
}
|
|
|
|
if (!samefilter)
|
|
{
|
|
if (filterv.at(i).at(4) == "string" ||
|
|
filterv.at(i).at(4) == "text")
|
|
{
|
|
if (filterv.at(i).at(2) == "<>")
|
|
{
|
|
filterstring=filterstring+"filter[not(."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)+"\""
|
|
+filterv.at(i).at(3)+"\")] \n";
|
|
}
|
|
else
|
|
{
|
|
filterstring=filterstring+"filter[."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)+"\""
|
|
+filterv.at(i).at(3)+"\"] \n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (filterv.at(i).at(2) == "<>")
|
|
{
|
|
filterstring=filterstring+"filter[not(."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)
|
|
+filterv.at(i).at(3)+")] \n";
|
|
}
|
|
else
|
|
{
|
|
filterstring=filterstring+"filter[."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)
|
|
+filterv.at(i).at(3)+"] \n";
|
|
}
|
|
}
|
|
//filterstring=filterstring+"filter[."+filterv.at(i).at(1)+"_a = .Value] \n";
|
|
tmpvector2.erase(tmpvector2.begin(), \
|
|
tmpvector2.end());
|
|
tmpvector2.push_back(filterv.at(i).at(1));
|
|
tmpvector2.push_back(filterv.at(i).at(2));
|
|
tmpvector.push_back(tmpvector2);
|
|
if (filterv.size() > 1)
|
|
{
|
|
filterv.erase(filterv.begin()+i);
|
|
filterfieldszg->at(edge->FromNode->TypeName)=\
|
|
filterv;
|
|
}
|
|
else
|
|
{
|
|
filterfieldszg->erase(edge->FromNode->TypeName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (CheckForGlobalFilters(edge->TypeName))
|
|
{
|
|
filterv=GetGlobalFilters(edge->TypeName);
|
|
std::vector<std::vector<std::string>> tmpvector;
|
|
std::vector<std::string> tmpvector2;
|
|
uint vsize=filterv.size();
|
|
for (int i=vsize-1; i>=0; i--)
|
|
{
|
|
bool samefilter=false;
|
|
for (uint i2=0; i2<tmpvector.size();i2++)
|
|
{
|
|
if (filterv.at(i).at(1) == tmpvector.at(i2).at(0)\
|
|
&& filterv.at(i).at(2) == "=" \
|
|
&& tmpvector.at(i2).at(1) == "=") samefilter=true;
|
|
}
|
|
|
|
if (!samefilter)
|
|
{
|
|
if (filterv.at(i).at(4) == "string"||
|
|
filterv.at(i).at(4) == "text")
|
|
{
|
|
if (filterv.at(i).at(2) == "<>")
|
|
{
|
|
filterstring=filterstring+"filter[not(."
|
|
+filterv.at(i).at(1)+"_ab"
|
|
+filterv.at(i).at(2)+"\""
|
|
+filterv.at(i).at(3)+"\")] \n";
|
|
}
|
|
else
|
|
{
|
|
filterstring=filterstring+"filter[."
|
|
+filterv.at(i).at(1)+"_ab"
|
|
+filterv.at(i).at(2)+"\""
|
|
+filterv.at(i).at(3)+"\"] \n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (filterv.at(i).at(2) == "<>")
|
|
{
|
|
filterstring=filterstring+"filter[not(."
|
|
+filterv.at(i).at(1)+"_ab"
|
|
+filterv.at(i).at(2)
|
|
+filterv.at(i).at(3)+")] \n";
|
|
}
|
|
else
|
|
{
|
|
filterstring=filterstring+"filter[."
|
|
+filterv.at(i).at(1)+"_ab"
|
|
+filterv.at(i).at(2)
|
|
+filterv.at(i).at(3)+"] \n";
|
|
}
|
|
|
|
}
|
|
//filterstring=filterstring+"filter[."+filterv.at(i).at(1)+"_ab "
|
|
//+filterv.at(i).at(2)+" "+filterv.at(i).at(3)+"] \n";
|
|
tmpvector2.erase(tmpvector2.begin(), \
|
|
tmpvector2.end());
|
|
tmpvector2.push_back(filterv.at(i).at(1));
|
|
tmpvector2.push_back(filterv.at(i).at(2));
|
|
tmpvector.push_back(tmpvector2);
|
|
if (filterv.size() > 1)
|
|
{
|
|
filterv.erase(filterv.begin()+i);
|
|
filterfieldszg->at(edge->TypeName)=filterv;
|
|
}
|
|
else
|
|
{
|
|
filterfieldszg->erase(edge->TypeName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Baue Filterstring zusammen
|
|
if (CheckForGlobalFilters(edge->ToNode->TypeName))
|
|
{
|
|
filterv=GetGlobalFilters(edge->ToNode->TypeName);
|
|
std::vector<std::vector<std::string>> tmpvector;
|
|
std::vector<std::string> tmpvector2;
|
|
uint vsize=filterv.size();
|
|
for (int i=vsize-1; i>=0; i--)
|
|
{
|
|
bool samefilter=false;
|
|
for (uint i2=0; i2<tmpvector.size();i2++)
|
|
{
|
|
if (filterv.at(i).at(1) == tmpvector.at(i2).at(0) && \
|
|
filterv.at(i).at(2) == "=" && \
|
|
tmpvector.at(i2).at(1) == "=") samefilter=true;
|
|
}
|
|
if (!samefilter)
|
|
{
|
|
if (filterv.at(i).at(4) == "string"||
|
|
filterv.at(i).at(4) == "text")
|
|
{
|
|
if (filterv.at(i).at(2) == "<>")
|
|
{
|
|
filterstring=filterstring+"filter[not(."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)+"\""
|
|
+filterv.at(i).at(3)+"\")] \n";
|
|
}
|
|
else
|
|
{
|
|
filterstring=filterstring+"filter[."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)+"\""
|
|
+filterv.at(i).at(3)+"\"] \n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (filterv.at(i).at(2) == "<>")
|
|
{
|
|
filterstring=filterstring+"filter[not(."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)
|
|
+filterv.at(i).at(3)+")] \n";
|
|
}
|
|
else
|
|
{
|
|
filterstring=filterstring+"filter[."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)
|
|
+filterv.at(i).at(3)+"] \n";
|
|
}
|
|
}
|
|
//filterstring=filterstring+"filter[."+filterv.at(i).at(1)+"_a = .Value] \n";
|
|
tmpvector2.erase(tmpvector2.begin(), \
|
|
tmpvector2.end());
|
|
tmpvector2.push_back(filterv.at(i).at(1));
|
|
tmpvector2.push_back(filterv.at(i).at(2));
|
|
tmpvector.push_back(tmpvector2);
|
|
if (filterv.size() > 1)
|
|
{
|
|
filterv.erase(filterv.begin()+i);
|
|
filterfieldszg->at(edge->ToNode->TypeName)=filterv;
|
|
}
|
|
else
|
|
{
|
|
filterfieldszg->erase(edge->ToNode->TypeName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Baue Filterstring zusammen
|
|
if (CheckForGlobalFilters(actnodename))
|
|
{
|
|
filterv=GetGlobalFilters(actnodename);
|
|
for (uint i=0; i<filterv.size(); i++)
|
|
{
|
|
if (filterv.at(i).at(4) == "string"||
|
|
filterv.at(i).at(4) == "text")
|
|
{
|
|
if (filterv.at(i).at(2) == "<>")
|
|
{
|
|
filterstring=filterstring+"filter[not(."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)+"\""
|
|
+filterv.at(i).at(3)+"\")] \n";
|
|
}
|
|
else
|
|
{
|
|
filterstring=filterstring+"filter[."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)+"\""
|
|
+filterv.at(i).at(3)+"\"] \n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (filterv.at(i).at(2) == "<>")
|
|
{
|
|
filterstring=filterstring+"filter[not(."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)
|
|
+filterv.at(i).at(3)+")] \n";
|
|
}
|
|
else
|
|
{
|
|
filterstring=filterstring+"filter[."
|
|
+filterv.at(i).at(1)+"_a"
|
|
+filterv.at(i).at(2)
|
|
+filterv.at(i).at(3)+"] \n";
|
|
}
|
|
}
|
|
//filterstring=filterstring+"filter[."+filterv.at(i).at(1)+"_a = .Value] \n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Message::CreateReplaceString()
|
|
{
|
|
string nextmessage=CreateNextMessageName();
|
|
|
|
if (!gobackmessage && !lastmessage)
|
|
{
|
|
stringstream ss;
|
|
ss << gofromsender;
|
|
string strgofromsender = ss.str();
|
|
|
|
std::vector<std::vector<std::string>> outputv;
|
|
string outputstring="";
|
|
|
|
//Baue Outputstring zusammen
|
|
if (CheckForOutputFields(edge->FromNode->TypeName))
|
|
{
|
|
outputv=GetOutputFields(edge->FromNode->TypeName);
|
|
for (uint i=0; i<outputv.size(); i++)
|
|
{
|
|
outputstring=outputstring+", "+outputv.at(i).at(1)+": ."
|
|
+outputv.at(i).at(2)+"_a";
|
|
}
|
|
}
|
|
if (CheckForOutputFields(edge->TypeName))
|
|
{
|
|
outputv=GetOutputFields(edge->TypeName);
|
|
for (uint i=0; i<outputv.size(); i++)
|
|
{
|
|
outputstring=outputstring+", "+outputv.at(i).at(1)
|
|
+": ."+outputv.at(i).at(2)+"_ab";
|
|
}
|
|
}
|
|
|
|
std::vector<std::vector<std::string>> filterv;
|
|
string filterstringtmp="";
|
|
|
|
replacestring="replaceAttr[NodeId: ."+relinfotonode->IdFieldName
|
|
+"_ab, Partition: part(."+relinfotonode->IdFieldName+"_ab),"
|
|
" Message: "+nextmessage+", Sender"+strgofromsender+": ."
|
|
+relinfofromnode->IdFieldName+"_a"+filterstringtmp+outputstring+
|
|
"] \n";
|
|
}
|
|
|
|
if (gobackmessage)
|
|
{
|
|
stringstream ss;
|
|
ss << gotosender;
|
|
string strgotosender = ss.str();
|
|
|
|
std::vector<std::vector<std::string>> outputv;
|
|
string outputstring="";
|
|
|
|
//Baue Outputstring zusammen
|
|
if (CheckForOutputFields(edge->ToNode->TypeName))
|
|
{
|
|
outputv=GetOutputFields(edge->ToNode->TypeName);
|
|
for (uint i=0; i<outputv.size(); i++)
|
|
{
|
|
outputstring=outputstring+", "+outputv.at(i).at(1)+": ."
|
|
+outputv.at(i).at(2)+"_a";
|
|
}
|
|
}
|
|
|
|
replacestring="replaceAttr[NodeId: .Sender"+strgotosender
|
|
+", Partition: part(.Sender"+strgotosender+"), "
|
|
"Message: "+nextmessage+""+outputstring+
|
|
"] \n";
|
|
}
|
|
|
|
if (lastmessage)
|
|
{
|
|
std::vector<std::vector<std::string>> outputv;
|
|
string outputstring="";
|
|
|
|
//Baue Outputstring zusammen
|
|
if (CheckForOutputFields(actnodename))
|
|
{
|
|
outputv=GetOutputFields(actnodename);
|
|
|
|
for (uint i=0; i<outputv.size(); i++)
|
|
{
|
|
if (i == 0)
|
|
{
|
|
outputstring=outputstring+outputv.at(i).at(1)
|
|
+": ."+outputv.at(i).at(2)+"_a";
|
|
}
|
|
else
|
|
{
|
|
outputstring=outputstring+", "+outputv.at(i).at(1)
|
|
+": ."+outputv.at(i).at(2)+"_a";
|
|
}
|
|
}
|
|
replacestring="replaceAttr["+outputstring+"] \n";
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void Message::CreateLastMessageString()
|
|
{
|
|
std::map<std::string, std::vector<std::vector<std::string>>>::iterator it;
|
|
string outputs="";
|
|
for (it = outputfieldszg->begin(); it != outputfieldszg->end(); it++)
|
|
{
|
|
for (uint i=0; i<it->second.size(); i++)
|
|
{
|
|
if (it == outputfieldszg->begin() && i==0)
|
|
{
|
|
outputs=outputs+it->second.at(i).at(1);
|
|
}
|
|
else
|
|
{
|
|
outputs=outputs+", "+it->second.at(i).at(1);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
lastmessagestring="project["+outputs+"] \n"
|
|
"minsert[ResultsMemory] \n"
|
|
"filter[FALSE] \n";
|
|
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::string Message::GetGesamtMessageString()
|
|
{
|
|
gesamtmessagestring=name+tuplestrom+actualtuple+actsuccessor
|
|
+filterstring+replacestring+lastmessagestring;
|
|
return gesamtmessagestring;
|
|
}
|
|
|
|
|
|
} // namespace
|